/* SPDX-License-Identifier: BSD-3-Clause */
/* Copyright(c) 2007-2022 Intel Corporation */
#include "adf_transport_access_macros.h"
#include "adf_transport_internal.h"

#include "cpa.h"
#include "icp_adf_init.h"
#include "icp_adf_transport.h"
#include "icp_adf_poll.h"
#include "icp_adf_transport_dp.h"
#include "icp_sal_poll.h"

/*
 * adf_modulo
 * result = data % ( 2 ^ shift )
 */
static inline Cpa32U
adf_modulo(Cpa32U data, Cpa32U shift)
{
	Cpa32U div = data >> shift;
	Cpa32U mult = div << shift;

	return data - mult;
}

/*
 * icp_adf_transCreateHandle
 * crete transport handle for a service
 * call adf_create_ring from adf driver directly with same parameters
 */
CpaStatus
icp_adf_transCreateHandle(icp_accel_dev_t *adf,
			  icp_transport_type trans_type,
			  const char *section,
			  const uint32_t accel_nr,
			  const uint32_t bank_nr,
			  const char *service_name,
			  const icp_adf_ringInfoService_t info,
			  icp_trans_callback callback,
			  icp_resp_deliv_method resp,
			  const uint32_t num_msgs,
			  const uint32_t msg_size,
			  icp_comms_trans_handle *trans_handle)
{
	CpaStatus status;
	int error;

	ICP_CHECK_FOR_NULL_PARAM(trans_handle);
	ICP_CHECK_FOR_NULL_PARAM(adf);

	error = adf_create_ring(adf->accel_dev,
				section,
				bank_nr,
				num_msgs,
				msg_size,
				service_name,
				callback,
				((resp == ICP_RESP_TYPE_IRQ) ? 0 : 1),
				(struct adf_etr_ring_data **)trans_handle);
	if (!error)
		status = CPA_STATUS_SUCCESS;
	else
		status = CPA_STATUS_FAIL;

	return status;
}

/*
 * icp_adf_transReinitHandle
 * Reinitialize transport handle for a service
 */
CpaStatus
icp_adf_transReinitHandle(icp_accel_dev_t *adf,
			  icp_transport_type trans_type,
			  const char *section,
			  const uint32_t accel_nr,
			  const uint32_t bank_nr,
			  const char *service_name,
			  const icp_adf_ringInfoService_t info,
			  icp_trans_callback callback,
			  icp_resp_deliv_method resp,
			  const uint32_t num_msgs,
			  const uint32_t msg_size,
			  icp_comms_trans_handle *trans_handle)
{
	return CPA_STATUS_SUCCESS;
}
/*
 * icp_adf_transReleaseHandle
 * destroy a transport handle, call adf_remove_ring from adf driver directly
 */
CpaStatus
icp_adf_transReleaseHandle(icp_comms_trans_handle trans_handle)
{
	struct adf_etr_ring_data *ring = trans_handle;

	ICP_CHECK_FOR_NULL_PARAM(ring);
	adf_remove_ring(ring);

	return CPA_STATUS_SUCCESS;
}

/*
 * icp_adf_transResetHandle
 * clean a transport handle, call adf_remove_ring from adf driver directly
 */
CpaStatus
icp_adf_transResetHandle(icp_comms_trans_handle trans_handle)
{
	return CPA_STATUS_SUCCESS;
}

/*
 * icp_adf_transGetRingNum
 * get ring number from a transport handle
 */
CpaStatus
icp_adf_transGetRingNum(icp_comms_trans_handle trans_handle, uint32_t *ringNum)
{
	struct adf_etr_ring_data *ring = trans_handle;

	ICP_CHECK_FOR_NULL_PARAM(ring);
	ICP_CHECK_FOR_NULL_PARAM(ringNum);
	*ringNum = (uint32_t)(ring->ring_number);

	return CPA_STATUS_SUCCESS;
}

/*
 * icp_adf_transPutMsg
 * send a request to transport handle
 * call adf_send_message from adf driver directly
 */
CpaStatus
icp_adf_transPutMsg(icp_comms_trans_handle trans_handle,
		    uint32_t *inBuf,
		    uint32_t bufLen)
{
	struct adf_etr_ring_data *ring = trans_handle;
	CpaStatus status = CPA_STATUS_FAIL;
	int error = EFAULT;

	ICP_CHECK_FOR_NULL_PARAM(ring);

	error = adf_send_message(ring, inBuf);
	if (EAGAIN == error)
		status = CPA_STATUS_RETRY;
	else if (0 == error)
		status = CPA_STATUS_SUCCESS;
	else
		status = CPA_STATUS_FAIL;

	return status;
}

CpaStatus
icp_adf_getInflightRequests(icp_comms_trans_handle trans_handle,
			    Cpa32U *maxInflightRequests,
			    Cpa32U *numInflightRequests)
{
	struct adf_etr_ring_data *ring = trans_handle;
	ICP_CHECK_FOR_NULL_PARAM(ring);
	ICP_CHECK_FOR_NULL_PARAM(maxInflightRequests);
	ICP_CHECK_FOR_NULL_PARAM(numInflightRequests);
	/*
	 * XXX: The qat_direct version of this routine returns max - 1, not
	 * the absolute max.
	 */
	*numInflightRequests = (*(uint32_t *)ring->inflights);
	*maxInflightRequests =
	    ADF_MAX_INFLIGHTS(ring->ring_size, ring->msg_size);
	return CPA_STATUS_SUCCESS;
}

CpaStatus
icp_adf_dp_getInflightRequests(icp_comms_trans_handle trans_handle,
			       Cpa32U *maxInflightRequests,
			       Cpa32U *numInflightRequests)
{
	ICP_CHECK_FOR_NULL_PARAM(trans_handle);
	ICP_CHECK_FOR_NULL_PARAM(maxInflightRequests);
	ICP_CHECK_FOR_NULL_PARAM(numInflightRequests);

	return icp_adf_getInflightRequests(trans_handle,
					   maxInflightRequests,
					   numInflightRequests);
}

/*
 * This function allows the user to poll the response ring. The
 * ring number to be polled is supplied by the user via the
 * trans handle for that ring. The trans_hnd is a pointer
 * to an array of trans handles. This ring is
 * only polled if it contains data.
 * This method is used as an alternative to the reading messages
 * via the ISR method.
 * This function will return RETRY if the ring is empty.
 */
CpaStatus
icp_adf_pollInstance(icp_comms_trans_handle *trans_hnd,
		     Cpa32U num_transHandles,
		     Cpa32U response_quota)
{
	Cpa32U resp_total = 0;
	Cpa32U num_resp;
	struct adf_etr_ring_data *ring = NULL;
	struct adf_etr_bank_data *bank = NULL;
	Cpa32U i;

	ICP_CHECK_FOR_NULL_PARAM(trans_hnd);

	for (i = 0; i < num_transHandles; i++) {
		ring = trans_hnd[i];
		if (!ring)
			continue;
		bank = ring->bank;

		/* If the ring in question is empty try the next ring.*/
		if (!bank || !bank->ring_mask) {
			continue;
		}

		num_resp = adf_handle_response(ring, response_quota);
		resp_total += num_resp;
	}

	/* If any of the rings in the instance had data and was polled
	 * return SUCCESS. */
	if (resp_total)
		return CPA_STATUS_SUCCESS;
	else
		return CPA_STATUS_RETRY;
}

/*
 * This function allows the user to check the response ring. The
 * ring number to be polled is supplied by the user via the
 * trans handle for that ring. The trans_hnd is a pointer
 * to an array of trans handles.
 * This function now is a empty function.
 */
CpaStatus
icp_adf_check_RespInstance(icp_comms_trans_handle *trans_hnd,
			   Cpa32U num_transHandles)
{
	return CPA_STATUS_SUCCESS;
}

/*
 * icp_sal_pollBank
 * poll bank with id bank_number inside acceleration device with id @accelId
 */
CpaStatus
icp_sal_pollBank(Cpa32U accelId, Cpa32U bank_number, Cpa32U response_quota)
{
	int ret;

	ret = adf_poll_bank(accelId, bank_number, response_quota);
	if (!ret)
		return CPA_STATUS_SUCCESS;
	else if (EAGAIN == ret)
		return CPA_STATUS_RETRY;

	return CPA_STATUS_FAIL;
}

/*
 * icp_sal_pollAllBanks
 * poll all banks inside acceleration device with id @accelId
 */
CpaStatus
icp_sal_pollAllBanks(Cpa32U accelId, Cpa32U response_quota)
{
	int ret = 0;

	ret = adf_poll_all_banks(accelId, response_quota);
	if (!ret)
		return CPA_STATUS_SUCCESS;
	else if (ret == EAGAIN)
		return CPA_STATUS_RETRY;

	return CPA_STATUS_FAIL;
}

/*
 * icp_adf_getQueueMemory
 * Data plane support function - returns the pointer to next message on the ring
 * or NULL if there is not enough space.
 */
void
icp_adf_getQueueMemory(icp_comms_trans_handle trans_handle,
		       Cpa32U numberRequests,
		       void **pCurrentQatMsg)
{
	struct adf_etr_ring_data *ring = trans_handle;
	Cpa64U flight;

	ICP_CHECK_FOR_NULL_PARAM_VOID(ring);

	/* Check if there is enough space in the ring */
	flight = atomic_add_return(numberRequests, ring->inflights);
	if (flight > ADF_MAX_INFLIGHTS(ring->ring_size, ring->msg_size)) {
		atomic_sub(numberRequests, ring->inflights);
		*pCurrentQatMsg = NULL;
		return;
	}

	/* We have enough space - get the address of next message */
	*pCurrentQatMsg = (void *)((uintptr_t)ring->base_addr + ring->tail);
}

/*
 * icp_adf_getSingleQueueAddr
 * Data plane support function - returns the pointer to next message on the ring
 * or NULL if there is not enough space - it also updates the shadow tail copy.
 */
void
icp_adf_getSingleQueueAddr(icp_comms_trans_handle trans_handle,
			   void **pCurrentQatMsg)
{
	struct adf_etr_ring_data *ring = trans_handle;
	Cpa64U flight;

	ICP_CHECK_FOR_NULL_PARAM_VOID(ring);
	ICP_CHECK_FOR_NULL_PARAM_VOID(pCurrentQatMsg);

	/* Check if there is enough space in the ring */
	flight = atomic_add_return(1, ring->inflights);
	if (flight > ADF_MAX_INFLIGHTS(ring->ring_size, ring->msg_size)) {
		atomic_dec(ring->inflights);
		*pCurrentQatMsg = NULL;
		return;
	}

	/* We have enough space - get the address of next message */
	*pCurrentQatMsg = (void *)((uintptr_t)ring->base_addr + ring->tail);

	/* Update the shadow tail */
	ring->tail =
	    adf_modulo(ring->tail + ADF_MSG_SIZE_TO_BYTES(ring->msg_size),
		       ADF_RING_SIZE_MODULO(ring->ring_size));
}

/*
 * icp_adf_getQueueNext
 * Data plane support function - increments the tail pointer and returns
 * the pointer to next message on the ring.
 */
void
icp_adf_getQueueNext(icp_comms_trans_handle trans_handle, void **pCurrentQatMsg)
{
	struct adf_etr_ring_data *ring = trans_handle;

	ICP_CHECK_FOR_NULL_PARAM_VOID(ring);
	ICP_CHECK_FOR_NULL_PARAM_VOID(pCurrentQatMsg);

	/* Increment tail to next message */
	ring->tail =
	    adf_modulo(ring->tail + ADF_MSG_SIZE_TO_BYTES(ring->msg_size),
		       ADF_RING_SIZE_MODULO(ring->ring_size));

	/* Get the address of next message */
	*pCurrentQatMsg = (void *)((uintptr_t)ring->base_addr + ring->tail);
}

/*
 * icp_adf_updateQueueTail
 * Data plane support function - Writes the tail shadow copy to the device.
 */
void
icp_adf_updateQueueTail(icp_comms_trans_handle trans_handle)
{
	struct adf_etr_ring_data *ring = trans_handle;
	struct adf_hw_csr_ops *csr_ops;

	ICP_CHECK_FOR_NULL_PARAM_VOID(ring);
	ICP_CHECK_FOR_NULL_PARAM_VOID(ring->bank);
	ICP_CHECK_FOR_NULL_PARAM_VOID(ring->bank->accel_dev);

	csr_ops = GET_CSR_OPS(ring->bank->accel_dev);

	ICP_CHECK_FOR_NULL_PARAM_VOID(csr_ops);

	csr_ops->write_csr_ring_tail(ring->bank->csr_addr,
				     ring->bank->bank_number,
				     ring->ring_number,
				     ring->tail);
	ring->csr_tail_offset = ring->tail;
}

/*
 * icp_adf_pollQueue
 * Data plane support function - Poll messages from the queue.
 */
CpaStatus
icp_adf_pollQueue(icp_comms_trans_handle trans_handle, Cpa32U response_quota)
{
	Cpa32U num_resp;
	struct adf_etr_ring_data *ring = trans_handle;

	ICP_CHECK_FOR_NULL_PARAM(ring);

	num_resp = adf_handle_response(ring, response_quota);

	if (num_resp)
		return CPA_STATUS_SUCCESS;
	else
		return CPA_STATUS_RETRY;
}

/*
 * icp_adf_queueDataToSend
 * Data-plane support function - Indicates if there is data on the ring to be
 * sent. This should only be called on request rings. If the function returns
 * true then it is ok to call icp_adf_updateQueueTail() function on this ring.
 */
CpaBoolean
icp_adf_queueDataToSend(icp_comms_trans_handle trans_handle)
{
	struct adf_etr_ring_data *ring = trans_handle;

	if (ring->tail != ring->csr_tail_offset)
		return CPA_TRUE;
	else
		return CPA_FALSE;
}

/*
 * This icp API won't be supported in kernel space currently
 */
CpaStatus
icp_adf_transGetFdForHandle(icp_comms_trans_handle trans_hnd, int *fd)
{
	return CPA_STATUS_UNSUPPORTED;
}