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

#include <sys/types.h>
#include <sys/lock.h>
#include <sys/sema.h>
#include <sys/mutex.h>

/* Define a 64 bit number */
#define QAT_UTILS_MAX_LONG (0x7FFFFFFF)

/* Max timeout in MS, used to guard against possible overflow */
#define QAT_UTILS_MAX_TIMEOUT_MS (QAT_UTILS_MAX_LONG / hz)

CpaStatus
qatUtilsSemaphoreInit(struct sema **pSid, uint32_t start_value)
{
	if (!pSid)
		return CPA_STATUS_FAIL;

	*pSid = malloc(sizeof(struct sema), M_QAT, M_WAITOK);

	sema_init(*pSid, start_value, "qat sema");

	return CPA_STATUS_SUCCESS;
}

/**
 * DESCRIPTION: If the semaphore is unset, the calling thread is blocked.
 *         If the semaphore is set, it is taken and control is returned
 *         to the caller. If the time indicated in 'timeout' is reached,
 *         the thread will unblock and return an error indication. If the
 *         timeout is set to 'QAT_UTILS_WAIT_NONE', the thread will never block;
 *         if it is set to 'QAT_UTILS_WAIT_FOREVER', the thread will block until
 *         the semaphore is available.
 *
 *
 */

CpaStatus
qatUtilsSemaphoreWait(struct sema **pSid, int32_t timeout)
{

	CpaStatus Status = CPA_STATUS_SUCCESS;
	unsigned long timeoutTime;

	if (!pSid)
		return CPA_STATUS_FAIL;
	/*
	 * Guard against illegal timeout values
	 */
	if ((timeout < 0) && (timeout != QAT_UTILS_WAIT_FOREVER)) {
		QAT_UTILS_LOG(
		    "QatUtilsSemaphoreWait(): illegal timeout value\n");
		return CPA_STATUS_FAIL;
	} else if (timeout > QAT_UTILS_MAX_TIMEOUT_MS) {
		QAT_UTILS_LOG(
		    "QatUtilsSemaphoreWait(): use a smaller timeout value to avoid overflow.\n");
		return CPA_STATUS_FAIL;
	}

	if (timeout == QAT_UTILS_WAIT_FOREVER) {
		sema_wait(*pSid);
	} else if (timeout == QAT_UTILS_WAIT_NONE) {
		if (sema_trywait(*pSid)) {
			Status = CPA_STATUS_FAIL;
		}
	} else {
		/* Convert timeout in milliseconds to HZ */
		timeoutTime = timeout * hz / 1000;
		if (sema_timedwait(*pSid, timeoutTime)) {
			Status = CPA_STATUS_FAIL;
		}
	} /* End of if */

	return Status;
}

CpaStatus
qatUtilsSemaphoreTryWait(struct sema **pSid)
{
	if (!pSid)
		return CPA_STATUS_FAIL;
	if (sema_trywait(*pSid)) {
		return CPA_STATUS_FAIL;
	}
	return CPA_STATUS_SUCCESS;
}

/**
 *
 * DESCRIPTION: This function causes the next available thread in the pend queue
 *              to be unblocked. If no thread is pending on this semaphore, the
 *              semaphore becomes 'full'.
 */
CpaStatus
qatUtilsSemaphorePost(struct sema **pSid)
{
	if (!pSid)
		return CPA_STATUS_FAIL;
	sema_post(*pSid);
	return CPA_STATUS_SUCCESS;
}

CpaStatus
qatUtilsSemaphoreDestroy(struct sema **pSid)
{
	if (!pSid)
		return CPA_STATUS_FAIL;

	sema_destroy(*pSid);
	free(*pSid, M_QAT);

	return CPA_STATUS_SUCCESS;
}

/****************************
 *    Mutex
 ****************************/

CpaStatus
qatUtilsMutexInit(struct mtx **pMutex)
{
	if (!pMutex)
		return CPA_STATUS_FAIL;
	*pMutex = malloc(sizeof(struct mtx), M_QAT, M_WAITOK);

	memset(*pMutex, 0, sizeof(struct mtx));

	mtx_init(*pMutex, "qat mtx", NULL, MTX_DEF);
	return CPA_STATUS_SUCCESS;
}

CpaStatus
qatUtilsMutexLock(struct mtx **pMutex, int32_t timeout)
{
	if (!pMutex)
		return CPA_STATUS_FAIL;
	if (timeout != QAT_UTILS_WAIT_FOREVER) {
		QAT_UTILS_LOG("QatUtilsMutexLock(): Illegal timeout value\n");
		return CPA_STATUS_FAIL;
	}

	mtx_lock(*pMutex);
	return CPA_STATUS_SUCCESS;
}

CpaStatus
qatUtilsMutexUnlock(struct mtx **pMutex)
{
	if (!pMutex || !(*pMutex))
		return CPA_STATUS_FAIL;
	mtx_unlock(*pMutex);
	return CPA_STATUS_SUCCESS;
}

CpaStatus
qatUtilsMutexDestroy(struct mtx **pMutex)
{
	if (!pMutex || !(*pMutex))
		return CPA_STATUS_FAIL;
	mtx_destroy(*pMutex);
	free(*pMutex, M_QAT);
	*pMutex = NULL;

	return CPA_STATUS_SUCCESS;
}