/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2022 Intel Corporation */
/* $FreeBSD$ */
/**
 *****************************************************************************
 * @file dc_buffers.c
 *
 * @defgroup Dc_DataCompression DC Data Compression
 *
 * @ingroup Dc_DataCompression
 *
 * @description
 *      Implementation of the buffer management operations for
 *      Data Compression service.
 *
 *****************************************************************************/

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

#include "sal_types_compression.h"
#include "icp_qat_fw_comp.h"
#include "sal_hw_gen.h"

#define CPA_DC_CEIL_DIV(x, y) (((x) + (y)-1) / (y))
#define DC_DEST_BUFF_EXTRA_DEFLATE_GEN2 (55)
#define DC_DEST_BUFF_EXTRA_DEFLATE_GEN4_STATIC (1029)
#define DC_DEST_BUFF_EXTRA_DEFLATE_GEN4_DYN (512)
#define DC_DEST_BUFF_MIN_EXTRA_BYTES(x) ((x < 8) ? (8 - x) : 0)
#define DC_BUF_MAX_SIZE (0xFFFFFFFF)

CpaStatus
cpaDcBufferListGetMetaSize(const CpaInstanceHandle instanceHandle,
			   Cpa32U numBuffers,
			   Cpa32U *pSizeInBytes)
{
	CpaInstanceHandle insHandle = NULL;

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

	LAC_CHECK_INSTANCE_HANDLE(insHandle);
	LAC_CHECK_NULL_PARAM(pSizeInBytes);

	/* Ensure this is a compression instance */
	SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);

	if (0 == numBuffers) {
		QAT_UTILS_LOG("Number of buffers is 0.\n");
		return CPA_STATUS_INVALID_PARAM;
	}

	*pSizeInBytes = (sizeof(icp_buffer_list_desc_t) +
			 (sizeof(icp_flat_buffer_desc_t) * (numBuffers + 1)) +
			 ICP_DESCRIPTOR_ALIGNMENT_BYTES);

	return CPA_STATUS_SUCCESS;
}

CpaStatus
cpaDcBnpBufferListGetMetaSize(const CpaInstanceHandle instanceHandle,
			      Cpa32U numJobs,
			      Cpa32U *pSizeInBytes)
{
	return CPA_STATUS_UNSUPPORTED;
}

static inline CpaStatus
dcDeflateBoundGen2(CpaDcHuffType huffType, Cpa32U inputSize, Cpa32U *outputSize)
{
	Cpa64U inBufferSize = inputSize;
	Cpa64U outBufferSize = 0;

	/* Formula for GEN2 deflate:
	 * ceil(9 * Total input bytes / 8) + 55 bytes.
	 * 55 bytes is the skid pad value for GEN2 devices.
	 * Adding extra bytes = `DC_DEST_BUFF_MIN_EXTRA_BYTES(inputSize)`
	 * when calculated value from `CPA_DC_CEIL_DIV(9 * inputSize, 8) +
	 * DC_DEST_BUFF_EXTRA_DEFLATE_GEN2` is less than 64 bytes to
	 * achieve a safer output buffer size of 64 bytes.
	 */
	outBufferSize = CPA_DC_CEIL_DIV(9 * inBufferSize, 8) +
	    DC_DEST_BUFF_EXTRA_DEFLATE_GEN2 +
	    DC_DEST_BUFF_MIN_EXTRA_BYTES(inputSize);

	if (outBufferSize > DC_BUF_MAX_SIZE)
		*outputSize = DC_BUF_MAX_SIZE;
	else
		*outputSize = (Cpa32U)outBufferSize;

	return CPA_STATUS_SUCCESS;
}

static inline CpaStatus
dcDeflateBoundGen4(CpaDcHuffType huffType, Cpa32U inputSize, Cpa32U *outputSize)
{
	Cpa64U outputSizeLong;
	Cpa64U inputSizeLong = (Cpa64U)inputSize;

	switch (huffType) {
	case CPA_DC_HT_STATIC:
		/* Formula for GEN4 static deflate:
		 * ceil((9*sourceLen)/8) + 5 + 1024. */
		outputSizeLong = CPA_DC_CEIL_DIV(9 * inputSizeLong, 8) +
		    DC_DEST_BUFF_EXTRA_DEFLATE_GEN4_STATIC;
		break;
	case CPA_DC_HT_FULL_DYNAMIC:
		/* Formula for GEN4 dynamic deflate:
		 * Ceil ((9*sourceLen)/8)▒| +
		 * ((((8/7) * sourceLen)/ 16KB) * (150+5)) + 512
		 */
		outputSizeLong = DC_DEST_BUFF_EXTRA_DEFLATE_GEN4_DYN;
		outputSizeLong += CPA_DC_CEIL_DIV(9 * inputSizeLong, 8);
		outputSizeLong += ((8 * inputSizeLong * 155) / 7) / (16 * 1024);
		break;
	default:
		return CPA_STATUS_INVALID_PARAM;
	}

	/* Avoid output size overflow */
	if (outputSizeLong & 0xffffffff00000000UL)
		return CPA_STATUS_INVALID_PARAM;

	*outputSize = (Cpa32U)outputSizeLong;
	return CPA_STATUS_SUCCESS;
}

CpaStatus
cpaDcDeflateCompressBound(const CpaInstanceHandle dcInstance,
			  CpaDcHuffType huffType,
			  Cpa32U inputSize,
			  Cpa32U *outputSize)
{
	sal_compression_service_t *pService = NULL;
	CpaInstanceHandle insHandle = NULL;

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

	LAC_CHECK_INSTANCE_HANDLE(insHandle);
	LAC_CHECK_NULL_PARAM(outputSize);
	/* Ensure this is a compression instance */
	SAL_CHECK_INSTANCE_TYPE(insHandle, SAL_SERVICE_TYPE_COMPRESSION);
	if (!inputSize) {
		QAT_UTILS_LOG(
		    "The input size needs to be greater than zero.\n");
		return CPA_STATUS_INVALID_PARAM;
	}

	if ((CPA_DC_HT_STATIC != huffType) &&
	    (CPA_DC_HT_FULL_DYNAMIC != huffType)) {
		QAT_UTILS_LOG("Invalid huffType value.\n");
		return CPA_STATUS_INVALID_PARAM;
	}

	pService = (sal_compression_service_t *)insHandle;
	if (isDcGen4x(pService)) {
		return dcDeflateBoundGen4(huffType, inputSize, outputSize);
	} else {
		return dcDeflateBoundGen2(huffType, inputSize, outputSize);
	}
}

CpaStatus
cpaDcLZ4CompressBound(const CpaInstanceHandle dcInstance,
		      Cpa32U inputSize,
		      Cpa32U *outputSize)
{
	return CPA_STATUS_UNSUPPORTED;
}

CpaStatus
cpaDcLZ4SCompressBound(const CpaInstanceHandle dcInstance,
		       Cpa32U inputSize,
		       Cpa32U *outputSize)
{
	return CPA_STATUS_UNSUPPORTED;
}