/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2025 Intel Corporation */

/**
 *****************************************************************************
 * @file sal_get_instances.c
 *
 * @defgroup SalCtrl Service Access Layer Controller
 *
 * @ingroup SalCtrl
 *
 * @description
 *      This file contains generic functions to get instances of a specified
 *      service type. Note these are complementary to the already existing
 *      service-specific functions.
 *
 *****************************************************************************/

/*
*******************************************************************************
* Include public/global header files
*******************************************************************************
*/

/* QAT-API includes */
#include "cpa.h"
#include "cpa_cy_common.h"
#include "cpa_cy_im.h"
#include "cpa_dc.h"

/* ADF includes */
#include "icp_accel_devices.h"
#include "icp_adf_accel_mgr.h"

/* SAL includes */
#include "lac_mem.h"
#include "lac_list.h"
#include "lac_sal_types.h"
#include "lac_sal_types_crypto.h"

/**
 ******************************************************************************
 * @ingroup SalCtrl
 * @description
 *   Get the total number of either sym, asym or cy instances
 *****************************************************************************/
CpaStatus
Lac_GetCyNumInstancesByType(
    const CpaAccelerationServiceType accelerationServiceType,
    Cpa16U *pNumInstances)
{
	CpaStatus status = CPA_STATUS_SUCCESS;
	CpaInstanceHandle instanceHandle;
	CpaInstanceInfo2 info;
	icp_accel_dev_t **pAdfInsts = NULL;
	icp_accel_dev_t *dev_addr = NULL;
	sal_t *base_addr = NULL;
	sal_list_t *list_temp = NULL;
	Cpa16U num_accel_dev = 0;
	Cpa16U num_inst = 0;
	Cpa16U i = 0;
	Cpa32U accel_capability = 0;
	char *service = NULL;

	LAC_CHECK_NULL_PARAM(pNumInstances);
	*pNumInstances = 0;

	switch (accelerationServiceType) {
	case CPA_ACC_SVC_TYPE_CRYPTO_ASYM:
		accel_capability = ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC;
		service = "asym";
		break;

	case CPA_ACC_SVC_TYPE_CRYPTO_SYM:
		accel_capability = ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC;
		service = "sym";
		break;

	case CPA_ACC_SVC_TYPE_CRYPTO:
		accel_capability = ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC |
		    ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC;
		service = "cy";
		break;

	default:
		QAT_UTILS_LOG("Invalid service type\n");
		return CPA_STATUS_INVALID_PARAM;
	}

	/* Get the number of accel_dev in the system */
	status = icp_amgr_getNumInstances(&num_accel_dev);
	LAC_CHECK_STATUS(status);

	/* Allocate memory to store addr of accel_devs */
	pAdfInsts = malloc(num_accel_dev * sizeof(icp_accel_dev_t *),
			   M_QAT,
			   M_WAITOK | M_ZERO);
	if (NULL == pAdfInsts) {
		QAT_UTILS_LOG("Failed to allocate dev instance memory\n");
		return CPA_STATUS_RESOURCE;
	}

	num_accel_dev = 0;
	status = icp_amgr_getAllAccelDevByCapabilities(accel_capability,
						       pAdfInsts,
						       &num_accel_dev);
	if (CPA_STATUS_SUCCESS != status) {
		QAT_UTILS_LOG("No support for service %s\n", service);
		free(pAdfInsts, M_QAT);
		return status;
	}

	for (i = 0; i < num_accel_dev; i++) {
		dev_addr = pAdfInsts[i];
		if (NULL == dev_addr || NULL == dev_addr->pSalHandle) {
			continue;
		}
		base_addr = dev_addr->pSalHandle;

		if (CPA_ACC_SVC_TYPE_CRYPTO == accelerationServiceType) {
			list_temp = base_addr->crypto_services;
			while (NULL != list_temp) {
				instanceHandle = SalList_getObject(list_temp);
				status = cpaCyInstanceGetInfo2(instanceHandle,
							       &info);
				if (CPA_STATUS_SUCCESS == status &&
				    CPA_TRUE == info.isPolled) {
					num_inst++;
				}
				list_temp = SalList_next(list_temp);
			}
		}

		if (CPA_ACC_SVC_TYPE_CRYPTO_ASYM == accelerationServiceType ||
		    CPA_ACC_SVC_TYPE_CRYPTO == accelerationServiceType) {
			list_temp = base_addr->asym_services;
			while (NULL != list_temp) {
				instanceHandle = SalList_getObject(list_temp);
				status = cpaCyInstanceGetInfo2(instanceHandle,
							       &info);
				if (CPA_STATUS_SUCCESS == status &&
				    CPA_TRUE == info.isPolled) {
					num_inst++;
				}
				list_temp = SalList_next(list_temp);
			}
		}

		if (CPA_ACC_SVC_TYPE_CRYPTO_SYM == accelerationServiceType ||
		    CPA_ACC_SVC_TYPE_CRYPTO == accelerationServiceType) {
			list_temp = base_addr->sym_services;
			while (NULL != list_temp) {
				instanceHandle = SalList_getObject(list_temp);
				status = cpaCyInstanceGetInfo2(instanceHandle,
							       &info);
				if (CPA_STATUS_SUCCESS == status &&
				    CPA_TRUE == info.isPolled) {
					num_inst++;
				}
				list_temp = SalList_next(list_temp);
			}
		}
	}

	*pNumInstances = num_inst;
	free(pAdfInsts, M_QAT);

	return status;
}

/**
 ******************************************************************************
 * @ingroup SalCtrl
 * @description
 *   Get either sym, asym or cy instance
 *****************************************************************************/
CpaStatus
Lac_GetCyInstancesByType(
    const CpaAccelerationServiceType accelerationServiceType,
    Cpa16U numInstances,
    CpaInstanceHandle *pInstances)
{
	CpaStatus status = CPA_STATUS_SUCCESS;
	CpaInstanceHandle instanceHandle = NULL;
	CpaInstanceInfo2 info;
	icp_accel_dev_t **pAdfInsts = NULL;
	icp_accel_dev_t *dev_addr = NULL;
	sal_t *base_addr = NULL;
	sal_list_t *list_temp = NULL;
	Cpa16U num_accel_dev = 0;
	Cpa16U num_allocated_instances = 0;
	Cpa16U index = 0;
	Cpa16U i = 0;
	Cpa32U accel_capability = 0;
	char *service = NULL;

	LAC_CHECK_NULL_PARAM(pInstances);
	if (0 == numInstances) {
		QAT_UTILS_LOG("NumInstances is 0\n");
		return CPA_STATUS_INVALID_PARAM;
	}

	switch (accelerationServiceType) {
	case CPA_ACC_SVC_TYPE_CRYPTO_ASYM:
		accel_capability = ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC;
		service = "asym";
		break;

	case CPA_ACC_SVC_TYPE_CRYPTO_SYM:
		accel_capability = ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC;
		service = "sym";
		break;

	case CPA_ACC_SVC_TYPE_CRYPTO:
		accel_capability = ICP_ACCEL_CAPABILITIES_CRYPTO_SYMMETRIC |
		    ICP_ACCEL_CAPABILITIES_CRYPTO_ASYMMETRIC;
		service = "cy";
		break;

	default:
		QAT_UTILS_LOG("Invalid service type\n");
		return CPA_STATUS_INVALID_PARAM;
	}

	/* Get the number of instances */
	status = Lac_GetCyNumInstancesByType(accelerationServiceType,
					     &num_allocated_instances);
	if (CPA_STATUS_SUCCESS != status) {
		return status;
	}

	if (numInstances > num_allocated_instances) {
		QAT_UTILS_LOG("Only %d instances available\n",
			      num_allocated_instances);
		return CPA_STATUS_RESOURCE;
	}

	/* Get the number of accel devices in the system */
	status = icp_amgr_getNumInstances(&num_accel_dev);
	LAC_CHECK_STATUS(status);

	/* Allocate memory to store addr of accel_devs */
	pAdfInsts = malloc(num_accel_dev * sizeof(icp_accel_dev_t *),
			   M_QAT,
			   M_WAITOK | M_ZERO);
	if (NULL == pAdfInsts) {
		QAT_UTILS_LOG("Failed to allocate dev instance memory\n");
		return CPA_STATUS_RESOURCE;
	}

	num_accel_dev = 0;
	status = icp_amgr_getAllAccelDevByCapabilities(accel_capability,
						       pAdfInsts,
						       &num_accel_dev);
	if (CPA_STATUS_SUCCESS != status) {
		QAT_UTILS_LOG("No support for service %s\n", service);
		free(pAdfInsts, M_QAT);
		return status;
	}

	for (i = 0; i < num_accel_dev; i++) {
		dev_addr = pAdfInsts[i];
		/* Note dev_addr cannot be NULL here as numInstances = 0
		 * is not valid and if dev_addr = NULL then index = 0 (which
		 * is less than numInstances and status is set to _RESOURCE
		 * above)
		 */
		base_addr = dev_addr->pSalHandle;
		if (NULL == base_addr) {
			continue;
		}

		if (CPA_ACC_SVC_TYPE_CRYPTO == accelerationServiceType) {
			list_temp = base_addr->crypto_services;
			while (NULL != list_temp) {
				if (index > (numInstances - 1))
					break;

				instanceHandle = SalList_getObject(list_temp);
				status = cpaCyInstanceGetInfo2(instanceHandle,
							       &info);
				list_temp = SalList_next(list_temp);
				if (CPA_STATUS_SUCCESS != status ||
				    CPA_TRUE != info.isPolled) {
					continue;
				}
				pInstances[index] = instanceHandle;
				index++;
			}
		}

		if (CPA_ACC_SVC_TYPE_CRYPTO_ASYM == accelerationServiceType ||
		    CPA_ACC_SVC_TYPE_CRYPTO == accelerationServiceType) {
			list_temp = base_addr->asym_services;
			while (NULL != list_temp) {
				if (index > (numInstances - 1))
					break;

				instanceHandle = SalList_getObject(list_temp);
				status = cpaCyInstanceGetInfo2(instanceHandle,
							       &info);
				list_temp = SalList_next(list_temp);
				if (CPA_STATUS_SUCCESS != status ||
				    CPA_TRUE != info.isPolled) {
					continue;
				}
				pInstances[index] = instanceHandle;
				index++;
			}
		}

		if (CPA_ACC_SVC_TYPE_CRYPTO_SYM == accelerationServiceType ||
		    CPA_ACC_SVC_TYPE_CRYPTO == accelerationServiceType) {
			list_temp = base_addr->sym_services;
			while (NULL != list_temp) {
				if (index > (numInstances - 1))
					break;

				instanceHandle = SalList_getObject(list_temp);
				status = cpaCyInstanceGetInfo2(instanceHandle,
							       &info);
				list_temp = SalList_next(list_temp);
				if (CPA_STATUS_SUCCESS != status ||
				    CPA_TRUE != info.isPolled) {
					continue;
				}
				pInstances[index] = instanceHandle;
				index++;
			}
		}
	}
	free(pAdfInsts, M_QAT);

	return status;
}

/**
 ******************************************************************************
 * @ingroup SalCtrl
 *****************************************************************************/
CpaStatus
cpaGetNumInstances(const CpaAccelerationServiceType accelerationServiceType,
		   Cpa16U *pNumInstances)
{
	LAC_CHECK_NULL_PARAM(pNumInstances);

	switch (accelerationServiceType) {
	case CPA_ACC_SVC_TYPE_CRYPTO_ASYM:
	case CPA_ACC_SVC_TYPE_CRYPTO_SYM:
	case CPA_ACC_SVC_TYPE_CRYPTO:
		return Lac_GetCyNumInstancesByType(accelerationServiceType,
						   pNumInstances);

	case CPA_ACC_SVC_TYPE_DATA_COMPRESSION:
		return cpaDcGetNumInstances(pNumInstances);

	case CPA_ACC_SVC_TYPE_PATTERN_MATCH:
	case CPA_ACC_SVC_TYPE_RAID:
	case CPA_ACC_SVC_TYPE_XML:
		QAT_UTILS_LOG("Unsupported service type\n");
		return CPA_STATUS_UNSUPPORTED;

	default:
		QAT_UTILS_LOG("Invalid service type\n");
		*pNumInstances = 0;
		return CPA_STATUS_INVALID_PARAM;
	}
}

/**
 ******************************************************************************
 * @ingroup SalCtrl
 *****************************************************************************/
CpaStatus
cpaGetInstances(const CpaAccelerationServiceType accelerationServiceType,
		Cpa16U numInstances,
		CpaInstanceHandle *pInstances)
{
	LAC_CHECK_NULL_PARAM(pInstances);

	switch (accelerationServiceType) {
	case CPA_ACC_SVC_TYPE_CRYPTO_ASYM:
	case CPA_ACC_SVC_TYPE_CRYPTO_SYM:
	case CPA_ACC_SVC_TYPE_CRYPTO:
		return Lac_GetCyInstancesByType(accelerationServiceType,
						numInstances,
						pInstances);

	case CPA_ACC_SVC_TYPE_DATA_COMPRESSION:
		return cpaDcGetInstances(numInstances, pInstances);

	case CPA_ACC_SVC_TYPE_PATTERN_MATCH:
	case CPA_ACC_SVC_TYPE_RAID:
	case CPA_ACC_SVC_TYPE_XML:
		QAT_UTILS_LOG("Unsupported service type\n");
		return CPA_STATUS_UNSUPPORTED;

	default:
		QAT_UTILS_LOG("Invalid service type\n");
		return CPA_STATUS_INVALID_PARAM;
	}
}