upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-02-27 03:40:37 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
opnsense-src/sys/dev/qat/qat_api/common/compression/dc_session.c
Krzysztof Zdziarski 266b0663c5 qat: Add Intel® 4xxx Series VF driver support 
Overview:
Intel(R) QuickAssist Technology (Intel(R) QAT) provides hardware
acceleration for offloading security, authentication and compression
services from the CPU, thus significantly increasing the performance and
efficiency of standard platform solutions.

This commit introduces:
- Intel® 4xxx Series VF driver support.
- Device configurability via sysctls.
- UIO support for Intel® 4xxx Series devices.

Patch co-authored by: Krzysztof Zdziarski <krzysztofx.zdziarski@intel.com>
Patch co-authored by: Michal Gulbicki <michalx.gulbicki@intel.com>
Patch co-authored by: Julian Grajkowski <julianx.grajkowski@intel.com>
Patch co-authored by: Piotr Kasierski <piotrx.kasierski@intel.com>
Patch co-authored by: Lukasz Kolodzinski <lukaszx.kolodzinski@intel.com>
Patch co-authored by: Karol Grzadziel <karolx.grzadziel@intel.com>

Sponsored by:	Intel Corporation
Differential Revision: https://reviews.freebsd.org/D39850
2023-06-12 13:44:01 -04:00

1279 lines
39 KiB
C
Raw Blame History

/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2022 Intel Corporation */
/* $FreeBSD$ */
/**
*****************************************************************************
* @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 (CPA_TRUE == 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 =
(CPA_TRUE == 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;
}
Reference in a new issue View git blame Copy permalink