/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2022 Intel Corporation */
/* $FreeBSD$ */
/**
 *****************************************************************************
 * @file sal_versions.c
 *
 * @ingroup SalVersions
 *
 * @description
 *    This file contains implementation of functions used to obtain version
 *    information
 *
 *****************************************************************************/

#include "cpa.h"
#include "qat_utils.h"

#include "icp_accel_devices.h"
#include "icp_adf_accel_mgr.h"
#include "icp_adf_cfg.h"

#include "lac_common.h"

#include "icp_sal_versions.h"

#define ICP_SAL_VERSIONS_ALL_CAP_MASK 0xFFFFFFFF
/**< Mask used to get all devices from ADF */

/**
*******************************************************************************
 * @ingroup SalVersions
 *      Fills in the version info structure
 * @description
 *      This function obtains hardware and software information associated with
 *      a given device and fills in the version info structure
 *
 * @param[in]   device      Pointer to the device for which version information
 *                          is to be obtained.
 * @param[out]  pVerInfo    Pointer to a structure that will hold version
 *                          information
 *
 * @context
 *      This function might sleep. It cannot be executed in a context that
 *      does not permit sleeping.
 * @assumptions
 *      The system has been started
 * @sideEffects
 *      None
 * @blocking
 *      No
 * @reentrant
 *      No
 * @threadSafe
 *      Yes
 *
 * @return CPA_STATUS_SUCCESS       Operation finished successfully
 * @return CPA_STATUS_FAIL          Operation failed
 *
 *****************************************************************************/
static CpaStatus
SalVersions_FillVersionInfo(icp_accel_dev_t *device,
			    icp_sal_dev_version_info_t *pVerInfo)
{
	CpaStatus status = CPA_STATUS_SUCCESS;
	char param_value[ADF_CFG_MAX_VAL_LEN_IN_BYTES] = { 0 };
	Cpa32S strSize = 0;

	memset(pVerInfo, 0, sizeof(icp_sal_dev_version_info_t));
	pVerInfo->devId = device->accelId;

	status = icp_adf_cfgGetParamValue(device,
					  LAC_CFG_SECTION_GENERAL,
					  ICP_CFG_HW_REV_ID_KEY,
					  param_value);
	LAC_CHECK_STATUS(status);

	strSize = snprintf((char *)pVerInfo->hardwareVersion,
			   ICP_SAL_VERSIONS_HW_VERSION_SIZE,
			   "%s",
			   param_value);
	LAC_CHECK_PARAM_RANGE(strSize, 1, ICP_SAL_VERSIONS_HW_VERSION_SIZE);

	memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES);
	status = icp_adf_cfgGetParamValue(device,
					  LAC_CFG_SECTION_GENERAL,
					  ICP_CFG_UOF_VER_KEY,
					  param_value);
	LAC_CHECK_STATUS(status);

	strSize = snprintf((char *)pVerInfo->firmwareVersion,
			   ICP_SAL_VERSIONS_FW_VERSION_SIZE,
			   "%s",
			   param_value);
	LAC_CHECK_PARAM_RANGE(strSize, 1, ICP_SAL_VERSIONS_FW_VERSION_SIZE);

	memset(param_value, 0, ADF_CFG_MAX_VAL_LEN_IN_BYTES);
	status = icp_adf_cfgGetParamValue(device,
					  LAC_CFG_SECTION_GENERAL,
					  ICP_CFG_MMP_VER_KEY,
					  param_value);
	LAC_CHECK_STATUS(status);

	strSize = snprintf((char *)pVerInfo->mmpVersion,
			   ICP_SAL_VERSIONS_MMP_VERSION_SIZE,
			   "%s",
			   param_value);
	LAC_CHECK_PARAM_RANGE(strSize, 1, ICP_SAL_VERSIONS_MMP_VERSION_SIZE);

	snprintf((char *)pVerInfo->softwareVersion,
		 ICP_SAL_VERSIONS_SW_VERSION_SIZE,
		 "%d.%d.%d",
		 SAL_INFO2_DRIVER_SW_VERSION_MAJ_NUMBER,
		 SAL_INFO2_DRIVER_SW_VERSION_MIN_NUMBER,
		 SAL_INFO2_DRIVER_SW_VERSION_PATCH_NUMBER);

	return status;
}

CpaStatus
icp_sal_getDevVersionInfo(Cpa32U devId, icp_sal_dev_version_info_t *pVerInfo)
{
	CpaStatus status = CPA_STATUS_SUCCESS;
	Cpa16U numInstances = 0;
	icp_accel_dev_t **pAccel_dev = NULL;
	Cpa16U num_accel_dev = 0, index = 0;
	icp_accel_dev_t *pDevice = NULL;

	LAC_CHECK_NULL_PARAM(pVerInfo);

	status = icp_amgr_getNumInstances(&numInstances);
	if (CPA_STATUS_SUCCESS != status) {
		QAT_UTILS_LOG("Error while getting number of devices.\n");
		return CPA_STATUS_FAIL;
	}

	if (devId >= ADF_MAX_DEVICES) {
		QAT_UTILS_LOG("Invalid devId\n");
		return CPA_STATUS_INVALID_PARAM;
	}

	pAccel_dev =
	    malloc(numInstances * sizeof(icp_accel_dev_t *), M_QAT, M_WAITOK);

	/* Get ADF to return all accel_devs */
	status =
	    icp_amgr_getAllAccelDevByCapabilities(ICP_SAL_VERSIONS_ALL_CAP_MASK,
						  pAccel_dev,
						  &num_accel_dev);

	if (CPA_STATUS_SUCCESS == status) {
		for (index = 0; index < num_accel_dev; index++) {
			pDevice = (icp_accel_dev_t *)pAccel_dev[index];

			if (pDevice->accelId == devId) {
				status = SalVersions_FillVersionInfo(pDevice,
								     pVerInfo);
				if (CPA_STATUS_SUCCESS != status) {
					QAT_UTILS_LOG(
					    "Error while filling in version info.\n");
				}
				break;
			}
		}

		if (index == num_accel_dev) {
			QAT_UTILS_LOG("Device %d not found or not started.\n",
				      devId);
			status = CPA_STATUS_FAIL;
		}
	} else {
		QAT_UTILS_LOG("Error while getting devices.\n");
	}

	free(pAccel_dev, M_QAT);
	return status;
}