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

#include <sys/param.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/sched.h>
#include <sys/time.h>
#include <sys/stdarg.h>
#include <vm/vm.h>
#include <vm/pmap.h>

/**
 *
 * @brief Private data structure
 *
 *  Data struct to store the information on the
 *  memory allocated. This structure is stored at the beginning of
 *  the allocated chunk of memory
 *  size is the no of byte passed to the memory allocation functions
 *  mSize is the real size of the memory required to the OS
 *
 *  +----------------------------+--------------------------------+
 *  | QatUtilsMemAllocInfoStruct | memory returned to user (size) |
 *  +----------------------------+--------------------------------+
 *  ^                            ^
 *  mAllocMemPtr                 Ptr returned to the caller of MemAlloc*
 *
 */

typedef struct _QatUtilsMemAllocInfoStruct {
        void *mAllocMemPtr; /* memory addr returned by the kernel */
        uint32_t mSize;     /* allocated size */
} QatUtilsMemAllocInfoStruct;

/**************************************
 * Memory functions
 *************************************/
void *
qatUtilsMemAllocContiguousNUMA(uint32_t size, uint32_t node, uint32_t alignment)
{
        void *ptr = NULL;
        void *pRet = NULL;
        uint32_t alignment_offset = 0;

        QatUtilsMemAllocInfoStruct memInfo = { 0 };
        if (size == 0 || alignment < 1) {
                QAT_UTILS_LOG(
                    "QatUtilsMemAllocNUMA: size or alignment are zero.\n");
                return NULL;
        }
        if (alignment & (alignment - 1)) {
                QAT_UTILS_LOG(
                    "QatUtilsMemAllocNUMA: Expecting alignment of a power.\n");
                return NULL;
        }

        memInfo.mSize = size + alignment + sizeof(QatUtilsMemAllocInfoStruct);
        ptr = contigmalloc(memInfo.mSize, M_QAT, M_WAITOK, 0, ~1UL, 64, 0);

        memInfo.mAllocMemPtr = ptr;
        pRet =
            (char *)memInfo.mAllocMemPtr + sizeof(QatUtilsMemAllocInfoStruct);
#ifdef __x86_64__
        alignment_offset = (uint64_t)pRet % alignment;
#else
        alignment_offset = (uint32_t)pRet % alignment;
#endif
        pRet = (char *)pRet + (alignment - alignment_offset);
        memcpy(((char *)pRet) - sizeof(QatUtilsMemAllocInfoStruct),
               &memInfo,
               sizeof(QatUtilsMemAllocInfoStruct));

        return pRet;
}

void
qatUtilsMemFreeNUMA(void *ptr)
{
        QatUtilsMemAllocInfoStruct *memInfo = NULL;

        memInfo =
            (QatUtilsMemAllocInfoStruct *)((int8_t *)ptr -
                                           sizeof(QatUtilsMemAllocInfoStruct));
        if (memInfo->mSize == 0 || memInfo->mAllocMemPtr == NULL) {
                QAT_UTILS_LOG(
                    "QatUtilsMemAlignedFree: Detected corrupted data: memory leak!\n");
                return;
        }
        free(memInfo->mAllocMemPtr, M_QAT);
}

CpaStatus
qatUtilsSleep(uint32_t milliseconds)
{
        if (milliseconds != 0) {
                pause("qatUtils sleep", milliseconds * hz / (1000));
        } else {
                sched_relinquish(curthread);
        }
        return CPA_STATUS_SUCCESS;
}

void
qatUtilsYield(void)
{
        sched_relinquish(curthread);
}