/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2022 Intel Corporation */
/**
 *****************************************************************************
 * @file dc_dp.c
 *
 * @defgroup cpaDcDp Data Compression Data Plane API
 *
 * @ingroup cpaDcDp
 *
 * @description
 *      Implementation of the Data Compression DP operations.
 *
 *****************************************************************************/

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

#include "icp_qat_fw_comp.h"

/*
*******************************************************************************
* Include private header files
*******************************************************************************
*/
#include "dc_session.h"
#include "dc_datapath.h"
#include "lac_common.h"
#include "lac_mem.h"
#include "lac_mem_pools.h"
#include "sal_types_compression.h"
#include "lac_sal.h"
#include "lac_sync.h"
#include "sal_service_state.h"
#include "sal_qat_cmn_msg.h"
#include "icp_sal_poll.h"
#include "sal_hw_gen.h"

/**
 *****************************************************************************
 * @ingroup cpaDcDp
 *      Check that pOpData is valid
 *
 * @description
 *      Check that all the parameters defined in the pOpData are valid
 *
 * @param[in]       pOpData          Pointer to a structure containing the
 *                                   request parameters
 *
 * @retval CPA_STATUS_SUCCESS        Function executed successfully
 * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in
 *
 *****************************************************************************/
static CpaStatus
dcDataPlaneParamCheck(const CpaDcDpOpData *pOpData)
{
        sal_compression_service_t *pService = NULL;
        dc_session_desc_t *pSessionDesc = NULL;

        LAC_CHECK_NULL_PARAM(pOpData);
        LAC_CHECK_NULL_PARAM(pOpData->dcInstance);
        LAC_CHECK_NULL_PARAM(pOpData->pSessionHandle);

        /* Ensure this is a compression instance */
        SAL_CHECK_INSTANCE_TYPE(pOpData->dcInstance,
                                SAL_SERVICE_TYPE_COMPRESSION);

        pService = (sal_compression_service_t *)(pOpData->dcInstance);

        pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData->pSessionHandle);
        if (NULL == pSessionDesc) {
                QAT_UTILS_LOG("Session handle not as expected.\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if (CPA_FALSE == pSessionDesc->isDcDp) {
                QAT_UTILS_LOG("The session type should be data plane.\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        /* Compressing zero byte is not supported */
        if ((CPA_DC_DIR_COMPRESS == pSessionDesc->sessDirection) &&
            (0 == pOpData->bufferLenToCompress)) {
                QAT_UTILS_LOG("The source buffer length to compress needs to "
                              "be greater than zero byte.\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if (pOpData->sessDirection > CPA_DC_DIR_DECOMPRESS) {
                QAT_UTILS_LOG("Invalid direction of operation.\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if (0 == pOpData->srcBuffer) {
                QAT_UTILS_LOG("Invalid srcBuffer\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if (0 == pOpData->destBuffer) {
                QAT_UTILS_LOG("Invalid destBuffer\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if (pOpData->srcBuffer == pOpData->destBuffer) {
                QAT_UTILS_LOG("In place operation is not supported.\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if (0 == pOpData->thisPhys) {
                QAT_UTILS_LOG("Invalid thisPhys\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if ((CPA_TRUE != pOpData->compressAndVerify) &&
            (CPA_FALSE != pOpData->compressAndVerify)) {
                QAT_UTILS_LOG("Invalid compressAndVerify\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if ((CPA_TRUE == pOpData->compressAndVerify) &&
            !(pService->generic_service_info.dcExtendedFeatures &
              DC_CNV_EXTENDED_CAPABILITY)) {
                QAT_UTILS_LOG("Invalid compressAndVerify, no CNV capability\n");
                return CPA_STATUS_UNSUPPORTED;
        }
        if ((CPA_TRUE != pOpData->compressAndVerifyAndRecover) &&
            (CPA_FALSE != pOpData->compressAndVerifyAndRecover)) {
                QAT_UTILS_LOG("Invalid compressAndVerifyAndRecover\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if ((CPA_TRUE == pOpData->compressAndVerifyAndRecover) &&
            (CPA_FALSE == pOpData->compressAndVerify)) {
                QAT_UTILS_LOG("CnVnR option set without setting CnV\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if ((CPA_TRUE == pOpData->compressAndVerifyAndRecover) &&
            !(pService->generic_service_info.dcExtendedFeatures &
              DC_CNVNR_EXTENDED_CAPABILITY)) {
                QAT_UTILS_LOG(
                    "Invalid CnVnR option set and no CnVnR capability.\n");
                return CPA_STATUS_UNSUPPORTED;
        }

        if ((CPA_DP_BUFLIST == pOpData->srcBufferLen) &&
            (CPA_DP_BUFLIST != pOpData->destBufferLen)) {
                QAT_UTILS_LOG(
                    "The source and destination buffers need to be of the same type (both flat buffers or buffer lists).\n");
                return CPA_STATUS_INVALID_PARAM;
        }
        if ((CPA_DP_BUFLIST != pOpData->srcBufferLen) &&
            (CPA_DP_BUFLIST == pOpData->destBufferLen)) {
                QAT_UTILS_LOG(
                    "The source and destination buffers need to be of the same type (both flat buffers or buffer lists).\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        if (CPA_DP_BUFLIST != pOpData->srcBufferLen) {
                if (pOpData->srcBufferLen < pOpData->bufferLenToCompress) {
                        QAT_UTILS_LOG(
                            "srcBufferLen is smaller than bufferLenToCompress.\n");
                        return CPA_STATUS_INVALID_PARAM;
                }

                if (pOpData->destBufferLen < pOpData->bufferLenForData) {
                        QAT_UTILS_LOG(
                            "destBufferLen is smaller than bufferLenForData.\n");
                        return CPA_STATUS_INVALID_PARAM;
                }
        } else {
                /* We are assuming that there is enough memory in the source and
                 * destination buffer lists. We only receive physical addresses
                 * of the buffers so we are unable to test it here */
                LAC_CHECK_8_BYTE_ALIGNMENT(pOpData->srcBuffer);
                LAC_CHECK_8_BYTE_ALIGNMENT(pOpData->destBuffer);
        }

        LAC_CHECK_8_BYTE_ALIGNMENT(pOpData->thisPhys);

        if ((CPA_DC_DIR_COMPRESS == pSessionDesc->sessDirection) ||
            (CPA_DC_DIR_COMBINED == pSessionDesc->sessDirection)) {
                if (CPA_DC_HT_FULL_DYNAMIC == pSessionDesc->huffType) {
                        /* Check if Intermediate Buffer Array pointer is NULL */
                        if (isDcGen2x(pService) &&
                            ((0 == pService->pInterBuffPtrsArrayPhyAddr) ||
                             (NULL == pService->pInterBuffPtrsArray))) {
                                QAT_UTILS_LOG(
                                    "No intermediate buffer defined for this instance - see cpaDcStartInstance.\n");
                                return CPA_STATUS_INVALID_PARAM;
                        }

                        /* Ensure that the destination buffer length for data is
                         * greater
                         * or equal to 128B */
                        if (pOpData->bufferLenForData <
                            DC_DEST_BUFFER_DYN_MIN_SIZE) {
                                QAT_UTILS_LOG(
                                    "Destination buffer length for data should be greater or equal to 128B.\n");
                                return CPA_STATUS_INVALID_PARAM;
                        }
                } else {
                        /* Ensure that the destination buffer length for data is
                         * greater
                         * or equal to min output buffsize */
                        if (pOpData->bufferLenForData <
                            pService->comp_device_data.minOutputBuffSize) {
                                QAT_UTILS_LOG(
                                    "Destination buffer size should be greater or equal to %d bytes.\n",
                                    pService->comp_device_data
                                        .minOutputBuffSize);
                                return CPA_STATUS_INVALID_PARAM;
                        }
                }
        }

        return CPA_STATUS_SUCCESS;
}

/**
 *****************************************************************************
 * @ingroup cpaDcDp
 *      Partial-read parameters validation utility.
 *
 * @description
 *      Basic check that all partial-read related parameters provided by
 *      caller are valid.
 *
 * @param[in]       pOpData          Pointer to a structure containing the
 *                                   request parameters
 * @param[in]       pPartReadData    Pointer to a structure containing the
 *                                   partial-read request parameters.
 *
 * @retval CPA_STATUS_SUCCESS        Function executed successfully
 * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in
 *
 *****************************************************************************/
static CpaStatus
dcDataPlanePartReadCheck(CpaDcDpOpData *pOpData,
                         CpaDcDpPartialReadData *pPartReadData)
{
        sal_compression_service_t *pService = NULL;

        LAC_CHECK_NULL_PARAM(pPartReadData);

        pService = (sal_compression_service_t *)(pOpData->dcInstance);

        if (!isDcGen4x(pService)) {
                /* Extended features are not supported prior Gen4 */
                return CPA_STATUS_UNSUPPORTED;
        }

        if (pOpData->sessDirection == CPA_DC_DIR_COMPRESS) {
                /* Decompression specific feature */
                return CPA_STATUS_INVALID_PARAM;
        }

        if (pPartReadData->length > pOpData->bufferLenForData) {
                QAT_UTILS_LOG(
                    "Partial read data length can not be greater than the destination buffer size\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        return CPA_STATUS_SUCCESS;
}

/**
 *****************************************************************************
 * @ingroup cpaDcDp
 *      Zero-padding parameters validation utility.
 *
 * @description
 *      Basic check that all zero-padding related parameters provided by
 *      caller are valid.
 *
 * @param[in]       pOpData          Pointer to a structure containing the
 *                                   request parameters.
 *
 * @retval CPA_STATUS_SUCCESS        Function executed successfully
 * @retval CPA_STATUS_INVALID_PARAM  Invalid parameter passed in
 * @retval CPA_STATUS_NOT_SUPPORTED  Feature not supported
 *
 *****************************************************************************/
static CpaStatus
dcDataPlaneZeroPadCheck(CpaDcDpOpData *pOpData)
{
        sal_compression_service_t *pService = NULL;

        pService = (sal_compression_service_t *)(pOpData->dcInstance);

        if (!isDcGen4x(pService)) {
                /* Extended features are not supported prior Gen4 */
                return CPA_STATUS_UNSUPPORTED;
        }

        if (pOpData->sessDirection == CPA_DC_DIR_DECOMPRESS) {
                /* Compression specific feature */
                return CPA_STATUS_INVALID_PARAM;
        }

        return CPA_STATUS_SUCCESS;
}
CpaStatus
cpaDcDpGetSessionSize(CpaInstanceHandle dcInstance,
                      CpaDcSessionSetupData *pSessionData,
                      Cpa32U *pSessionSize)
{
        return dcGetSessionSize(dcInstance, pSessionData, pSessionSize, NULL);
}

CpaStatus
cpaDcDpInitSession(CpaInstanceHandle dcInstance,
                   CpaDcSessionHandle pSessionHandle,
                   CpaDcSessionSetupData *pSessionData)
{
        CpaStatus status = CPA_STATUS_SUCCESS;
        dc_session_desc_t *pSessionDesc = NULL;
        sal_compression_service_t *pService = NULL;

        LAC_CHECK_INSTANCE_HANDLE(dcInstance);
        SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);

        pService = (sal_compression_service_t *)dcInstance;

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

        /* Stateful is not supported */
        if (CPA_DC_STATELESS != pSessionData->sessState) {
                QAT_UTILS_LOG("Invalid sessState value\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        status =
            dcInitSession(dcInstance, pSessionHandle, pSessionData, NULL, NULL);
        if (CPA_STATUS_SUCCESS == status) {
                pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pSessionHandle);
                pSessionDesc->isDcDp = CPA_TRUE;

                ICP_QAT_FW_COMN_PTR_TYPE_SET(
                    pSessionDesc->reqCacheDecomp.comn_hdr.comn_req_flags,
                    DC_DP_QAT_PTR_TYPE);
                ICP_QAT_FW_COMN_PTR_TYPE_SET(
                    pSessionDesc->reqCacheComp.comn_hdr.comn_req_flags,
                    DC_DP_QAT_PTR_TYPE);
        }

        return status;
}

CpaStatus
cpaDcDpRemoveSession(const CpaInstanceHandle dcInstance,
                     CpaDcSessionHandle pSessionHandle)
{
        return cpaDcRemoveSession(dcInstance, pSessionHandle);
}

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

CpaStatus
cpaDcDpRegCbFunc(const CpaInstanceHandle dcInstance,
                 const CpaDcDpCallbackFn pNewCb)
{
        sal_compression_service_t *pService = NULL;

        LAC_CHECK_NULL_PARAM(dcInstance);
        SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);
        LAC_CHECK_NULL_PARAM(pNewCb);

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

        pService = (sal_compression_service_t *)dcInstance;
        pService->pDcDpCb = pNewCb;

        return CPA_STATUS_SUCCESS;
}

/**
 *****************************************************************************
 * @ingroup cpaDcDp
 *
 * @description
 *      Writes the message to the ring
 *
 * @param[in]       pOpData          Pointer to a structure containing the
 *                                   request parameters
 * @param[in]       pCurrentQatMsg   Pointer to current QAT message on the ring
 *
 *****************************************************************************/
static void
dcDpWriteRingMsg(CpaDcDpOpData *pOpData, icp_qat_fw_comp_req_t *pCurrentQatMsg)
{
        icp_qat_fw_comp_req_t *pReqCache = NULL;
        dc_session_desc_t *pSessionDesc = NULL;
        Cpa8U bufferFormat;

        Cpa8U cnvDecompReq = ICP_QAT_FW_COMP_NO_CNV;
        Cpa8U cnvnrCompReq = ICP_QAT_FW_COMP_NO_CNV_RECOVERY;
        CpaBoolean cnvErrorInjection = ICP_QAT_FW_COMP_NO_CNV_DFX;
        sal_compression_service_t *pService = NULL;

        pService = (sal_compression_service_t *)(pOpData->dcInstance);
        pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData->pSessionHandle);

        if (CPA_DC_DIR_COMPRESS == pOpData->sessDirection) {
                pReqCache = &(pSessionDesc->reqCacheComp);
                /* CNV check */
                if (CPA_TRUE == pOpData->compressAndVerify) {
                        cnvDecompReq = ICP_QAT_FW_COMP_CNV;
                        if (isDcGen4x(pService)) {
                                cnvErrorInjection =
                                    pSessionDesc->cnvErrorInjection;
                        }

                        /* CNVNR check */
                        if (CPA_TRUE == pOpData->compressAndVerifyAndRecover) {
                                cnvnrCompReq = ICP_QAT_FW_COMP_CNV_RECOVERY;
                        }
                }
        } else {
                pReqCache = &(pSessionDesc->reqCacheDecomp);
        }

        /* Fills in the template DC ET ring message - cached from the
         * session descriptor */
        memcpy((void *)pCurrentQatMsg,
               (void *)(pReqCache),
               (LAC_QAT_DC_REQ_SZ_LW * LAC_LONG_WORD_IN_BYTES));

        if (CPA_DP_BUFLIST == pOpData->srcBufferLen) {
                bufferFormat = QAT_COMN_PTR_TYPE_SGL;
        } else {
                bufferFormat = QAT_COMN_PTR_TYPE_FLAT;
        }

        pCurrentQatMsg->comp_pars.req_par_flags |=
            ICP_QAT_FW_COMP_REQ_PARAM_FLAGS_BUILD(
                ICP_QAT_FW_COMP_NOT_SOP,
                ICP_QAT_FW_COMP_NOT_EOP,
                ICP_QAT_FW_COMP_NOT_BFINAL,
                cnvDecompReq,
                cnvnrCompReq,
                cnvErrorInjection,
                ICP_QAT_FW_COMP_CRC_MODE_LEGACY);

        SalQatMsg_CmnMidWrite((icp_qat_fw_la_bulk_req_t *)pCurrentQatMsg,
                              pOpData,
                              bufferFormat,
                              pOpData->srcBuffer,
                              pOpData->destBuffer,
                              pOpData->srcBufferLen,
                              pOpData->destBufferLen);

        pCurrentQatMsg->comp_pars.comp_len = pOpData->bufferLenToCompress;
        pCurrentQatMsg->comp_pars.out_buffer_sz = pOpData->bufferLenForData;
}

/**
 *****************************************************************************
 * @ingroup cpaDcDp
 *
 * @description
 *      Updates the request decryptor with optional parameters:
 *      - partial read specific fields
 *      - zero-padding specific field
 *
 * @param[in]       pOpData          Pointer to a structure containing the
 *                                   request parameters.
 * @param[in]       pPartReadData    Pointer to a structure containing the
 *                                   partial-read request parameters.
 * @param[in]       zeroPadFlag      Boolean indicator containing the
 *                                   zero-padding enablement flag.
 * @param[in]       pCurrentQatMsg   Pointer to current QAT message on the ring.
 *
 *****************************************************************************/
static void
dcDpUpdateRingMsg(CpaDcDpOpData *pOpData,
                  CpaDcDpPartialReadData *pPartReadData,
                  CpaBoolean zeroPadFlag,
                  icp_qat_fw_comp_req_t *pCurrentQatMsg)
{
        sal_compression_service_t *pService = NULL;

        pService = (sal_compression_service_t *)(pOpData->dcInstance);
        if (!isDcGen4x(pService)) {
                return;
        }

        /* Partial read settings */
        if (NULL != pPartReadData) {
                pCurrentQatMsg->u1.partial_decompress
                    .partial_decompress_offset = pPartReadData->dataOffset;
                pCurrentQatMsg->u1.partial_decompress
                    .partial_decompress_length = pPartReadData->length;
                ICP_QAT_FW_COMP_PART_DECOMP_SET(
                    pCurrentQatMsg->comp_pars.req_par_flags,
                    ICP_QAT_FW_COMP_PART_DECOMP);
        }
        /* Zero padding settings */
        if (CPA_TRUE == zeroPadFlag) {
                ICP_QAT_FW_COMP_ZEROPAD_SET(
                    pCurrentQatMsg->comp_pars.req_par_flags,
                    ICP_QAT_FW_COMP_ZEROPAD);
        }
}

static CpaStatus
dcDpEnqueueOpBase(CpaDcDpOpData *pOpData,
                  CpaDcDpPartialReadData *pPartReadData,
                  CpaBoolean zeroPadFlag,
                  const CpaBoolean performOpNow)
{
        icp_qat_fw_comp_req_t *pCurrentQatMsg = NULL;
        icp_comms_trans_handle trans_handle = NULL;
        dc_session_desc_t *pSessionDesc = NULL;
        CpaStatus status = CPA_STATUS_SUCCESS;

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

        if (NULL != pPartReadData) {
                status = dcDataPlanePartReadCheck(pOpData, pPartReadData);
                if (CPA_STATUS_SUCCESS != status) {
                        return status;
                }
        }

        if (CPA_TRUE == zeroPadFlag) {
                status = dcDataPlaneZeroPadCheck(pOpData);
                if (CPA_STATUS_SUCCESS != status) {
                        return status;
                }
        }

        if ((CPA_FALSE == pOpData->compressAndVerify) &&
            (CPA_DC_DIR_COMPRESS == pOpData->sessDirection)) {
                return CPA_STATUS_UNSUPPORTED;
        }

        /* Check if SAL is initialised otherwise return an error */
        SAL_RUNNING_CHECK(pOpData->dcInstance);

        trans_handle = ((sal_compression_service_t *)pOpData->dcInstance)
                           ->trans_handle_compression_tx;
        pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData->pSessionHandle);

        if ((CPA_DC_DIR_COMPRESS == pOpData->sessDirection) &&
            (CPA_DC_DIR_DECOMPRESS == pSessionDesc->sessDirection)) {
                QAT_UTILS_LOG(
                    "The session does not support this direction of operation.\n");
                return CPA_STATUS_INVALID_PARAM;
        } else if ((CPA_DC_DIR_DECOMPRESS == pOpData->sessDirection) &&
                   (CPA_DC_DIR_COMPRESS == pSessionDesc->sessDirection)) {
                QAT_UTILS_LOG(
                    "The session does not support this direction of operation.\n");
                return CPA_STATUS_INVALID_PARAM;
        }

        icp_adf_getSingleQueueAddr(trans_handle, (void **)&pCurrentQatMsg);
        if (NULL == pCurrentQatMsg) {
                return CPA_STATUS_RETRY;
        }

        dcDpWriteRingMsg(pOpData, pCurrentQatMsg);
        if (NULL != pPartReadData || CPA_TRUE == zeroPadFlag) {
                dcDpUpdateRingMsg(pOpData,
                                  pPartReadData,
                                  zeroPadFlag,
                                  pCurrentQatMsg);
        }

        pSessionDesc->pendingDpStatelessCbCount++;

        if (CPA_TRUE == performOpNow) {
                SalQatMsg_updateQueueTail(trans_handle);
        }

        return CPA_STATUS_SUCCESS;
}

CpaStatus
cpaDcDpEnqueueOp(CpaDcDpOpData *pOpData, const CpaBoolean performOpNow)
{

        return dcDpEnqueueOpBase(pOpData, NULL, CPA_FALSE, performOpNow);
}

CpaStatus
cpaDcDpEnqueueOpWithPartRead(CpaDcDpOpData *pOpData,
                             CpaDcDpPartialReadData *pPartReadData,
                             const CpaBoolean performOpNow)
{
        return dcDpEnqueueOpBase(pOpData,
                                 pPartReadData,
                                 CPA_FALSE,
                                 performOpNow);
}

CpaStatus
cpaDcDpEnqueueOpWithZeroPad(CpaDcDpOpData *pOpData,
                            const CpaBoolean performOpNow)
{
        return dcDpEnqueueOpBase(pOpData, NULL, CPA_TRUE, performOpNow);
}

static CpaStatus
dcDpEnqueueOpBatchBase(const Cpa32U numberRequests,
                       CpaDcDpOpData *pOpData[],
                       CpaDcDpPartialReadData *pPartData[],
                       CpaBoolean zeroPadFlag,
                       const CpaBoolean performOpNow)
{
        icp_qat_fw_comp_req_t *pCurrentQatMsg = NULL;
        icp_comms_trans_handle trans_handle = NULL;
        dc_session_desc_t *pSessionDesc = NULL;
        Cpa32U i = 0;
        CpaStatus status = CPA_STATUS_SUCCESS;
        sal_compression_service_t *pService = NULL;

        LAC_CHECK_NULL_PARAM(pOpData);
        LAC_CHECK_NULL_PARAM(pOpData[0]);
        LAC_CHECK_NULL_PARAM(pOpData[0]->dcInstance);

        pService = (sal_compression_service_t *)(pOpData[0]->dcInstance);
        if ((numberRequests == 0) ||
            (numberRequests > pService->maxNumCompConcurrentReq)) {
                QAT_UTILS_LOG(
                    "The number of requests needs to be between 1 and %d.\n",
                    pService->maxNumCompConcurrentReq);
                return CPA_STATUS_INVALID_PARAM;
        }

        for (i = 0; i < numberRequests; i++) {
                status = dcDataPlaneParamCheck(pOpData[i]);
                if (CPA_STATUS_SUCCESS != status) {
                        return status;
                }

                if (NULL != pPartData) {
                        status =
                            dcDataPlanePartReadCheck(pOpData[i], pPartData[i]);
                        if (CPA_STATUS_SUCCESS != status) {
                                return status;
                        }
                }

                if (CPA_TRUE == zeroPadFlag) {
                        status = dcDataPlaneZeroPadCheck(pOpData[i]);
                        if (CPA_STATUS_SUCCESS != status) {
                                return status;
                        }
                }

                /* Check that all instance handles and session handles are the
                 * same */
                if (pOpData[i]->dcInstance != pOpData[0]->dcInstance) {
                        QAT_UTILS_LOG(
                            "All instance handles should be the same in the pOpData.\n");
                        return CPA_STATUS_INVALID_PARAM;
                }

                if (pOpData[i]->pSessionHandle != pOpData[0]->pSessionHandle) {
                        QAT_UTILS_LOG(
                            "All session handles should be the same in the pOpData.\n");
                        return CPA_STATUS_INVALID_PARAM;
                }
        }

        for (i = 0; i < numberRequests; i++) {
                if ((CPA_FALSE == pOpData[i]->compressAndVerify) &&
                    (CPA_DC_DIR_COMPRESS == pOpData[i]->sessDirection)) {
                        return CPA_STATUS_UNSUPPORTED;
                }
        }

        /* Check if SAL is initialised otherwise return an error */
        SAL_RUNNING_CHECK(pOpData[0]->dcInstance);

        trans_handle = ((sal_compression_service_t *)pOpData[0]->dcInstance)
                           ->trans_handle_compression_tx;
        pSessionDesc = DC_SESSION_DESC_FROM_CTX_GET(pOpData[0]->pSessionHandle);

        for (i = 0; i < numberRequests; i++) {
                if ((CPA_DC_DIR_COMPRESS == pOpData[i]->sessDirection) &&
                    (CPA_DC_DIR_DECOMPRESS == pSessionDesc->sessDirection)) {
                        QAT_UTILS_LOG(
                            "The session does not support this direction of operation.\n");
                        return CPA_STATUS_INVALID_PARAM;
                } else if ((CPA_DC_DIR_DECOMPRESS ==
                            pOpData[i]->sessDirection) &&
                           (CPA_DC_DIR_COMPRESS ==
                            pSessionDesc->sessDirection)) {
                        QAT_UTILS_LOG(
                            "The session does not support this direction of operation.\n");
                        return CPA_STATUS_INVALID_PARAM;
                }
        }

        icp_adf_getQueueMemory(trans_handle,
                               numberRequests,
                               (void **)&pCurrentQatMsg);
        if (NULL == pCurrentQatMsg) {
                return CPA_STATUS_RETRY;
        }

        for (i = 0; i < numberRequests; i++) {
                dcDpWriteRingMsg(pOpData[i], pCurrentQatMsg);
                if (pPartData) {
                        dcDpUpdateRingMsg(pOpData[i],
                                          pPartData[i],
                                          CPA_FALSE,
                                          pCurrentQatMsg);
                }
                if (CPA_TRUE == zeroPadFlag) {
                        dcDpUpdateRingMsg(pOpData[i],
                                          NULL,
                                          CPA_TRUE,
                                          pCurrentQatMsg);
                }
                icp_adf_getQueueNext(trans_handle, (void **)&pCurrentQatMsg);
        }

        pSessionDesc->pendingDpStatelessCbCount += numberRequests;

        if (CPA_TRUE == performOpNow) {
                SalQatMsg_updateQueueTail(trans_handle);
        }

        return CPA_STATUS_SUCCESS;
}

CpaStatus
cpaDcDpEnqueueOpBatch(const Cpa32U numberRequests,
                      CpaDcDpOpData *pOpData[],
                      const CpaBoolean performOpNow)
{
        return dcDpEnqueueOpBatchBase(
            numberRequests, pOpData, NULL, CPA_FALSE, performOpNow);
}

CpaStatus
cpaDcDpEnqueueOpWithPartReadBatch(const Cpa32U numberRequests,
                                  CpaDcDpOpData *pOpData[],
                                  CpaDcDpPartialReadData *pPartReadData[],
                                  const CpaBoolean performOpNow)
{
        return dcDpEnqueueOpBatchBase(
            numberRequests, pOpData, pPartReadData, CPA_FALSE, performOpNow);
}

CpaStatus
cpaDcDpEnqueueOpWithZeroPadBatch(const Cpa32U numberRequests,
                                 CpaDcDpOpData *pOpData[],
                                 const CpaBoolean performOpNow)
{
        return dcDpEnqueueOpBatchBase(
            numberRequests, pOpData, NULL, CPA_TRUE, performOpNow);
}

CpaStatus
icp_sal_DcPollDpInstance(CpaInstanceHandle dcInstance, Cpa32U responseQuota)
{
        icp_comms_trans_handle trans_handle = NULL;

        LAC_CHECK_INSTANCE_HANDLE(dcInstance);
        SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);

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

        trans_handle = ((sal_compression_service_t *)dcInstance)
                           ->trans_handle_compression_rx;

        return icp_adf_pollQueue(trans_handle, responseQuota);
}

CpaStatus
cpaDcDpPerformOpNow(CpaInstanceHandle dcInstance)
{
        icp_comms_trans_handle trans_handle = NULL;

        LAC_CHECK_NULL_PARAM(dcInstance);
        SAL_CHECK_INSTANCE_TYPE(dcInstance, SAL_SERVICE_TYPE_COMPRESSION);

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

        trans_handle = ((sal_compression_service_t *)dcInstance)
                           ->trans_handle_compression_tx;

        if (CPA_TRUE == icp_adf_queueDataToSend(trans_handle)) {
                SalQatMsg_updateQueueTail(trans_handle);
        }

        return CPA_STATUS_SUCCESS;
}

CpaStatus
cpaDcDpIsPartReadSupported(const CpaInstanceHandle instanceHandle,
                           CpaBoolean *flag)
{
        sal_compression_service_t *pService = NULL;
        dc_extd_ftrs_t *pExtendedFtrs = NULL;

        LAC_CHECK_NULL_PARAM(instanceHandle);
        SAL_CHECK_INSTANCE_TYPE(instanceHandle, SAL_SERVICE_TYPE_COMPRESSION);

        pService = (sal_compression_service_t *)instanceHandle;
        if (!isDcGen4x(pService)) {
                *flag = CPA_FALSE;
                return CPA_STATUS_SUCCESS;
        }

        pExtendedFtrs = (dc_extd_ftrs_t *)&(
            ((sal_service_t *)instanceHandle)->dcExtendedFeatures);

        *flag = (CpaBoolean)pExtendedFtrs->is_part_read;

        return CPA_STATUS_SUCCESS;
}

CpaStatus
cpaDcDpIsZeroPadSupported(const CpaInstanceHandle instanceHandle,
                          CpaBoolean *flag)
{
        sal_compression_service_t *pService = NULL;
        dc_extd_ftrs_t *pExtendedFtrs = NULL;

        LAC_CHECK_NULL_PARAM(instanceHandle);
        SAL_CHECK_INSTANCE_TYPE(instanceHandle, SAL_SERVICE_TYPE_COMPRESSION);

        pService = (sal_compression_service_t *)instanceHandle;
        if (!isDcGen4x(pService)) {
                *flag = CPA_FALSE;
                return CPA_STATUS_SUCCESS;
        }

        pExtendedFtrs = (dc_extd_ftrs_t *)&(
            ((sal_service_t *)instanceHandle)->dcExtendedFeatures);

        *flag = (CpaBoolean)pExtendedFtrs->is_zero_pad;

        return CPA_STATUS_SUCCESS;
}