178ee8d1cSJulian Grajkowski /* SPDX-License-Identifier: BSD-3-Clause */
2*25f09d4aSHareshx Sankar Raj /* Copyright(c) 2007-2025 Intel Corporation */
378ee8d1cSJulian Grajkowski /**
478ee8d1cSJulian Grajkowski ***************************************************************************
578ee8d1cSJulian Grajkowski * @file lac_mem.h
678ee8d1cSJulian Grajkowski *
778ee8d1cSJulian Grajkowski * @defgroup LacMem Memory
878ee8d1cSJulian Grajkowski *
978ee8d1cSJulian Grajkowski * @ingroup LacCommon
1078ee8d1cSJulian Grajkowski *
1178ee8d1cSJulian Grajkowski * Memory re-sizing functions and memory accessor macros.
1278ee8d1cSJulian Grajkowski *
1378ee8d1cSJulian Grajkowski ***************************************************************************/
1478ee8d1cSJulian Grajkowski
1578ee8d1cSJulian Grajkowski #ifndef LAC_MEM_H
1678ee8d1cSJulian Grajkowski #define LAC_MEM_H
1778ee8d1cSJulian Grajkowski
1878ee8d1cSJulian Grajkowski /***************************************************************************
1978ee8d1cSJulian Grajkowski * Include header files
2078ee8d1cSJulian Grajkowski ***************************************************************************/
2178ee8d1cSJulian Grajkowski #include "cpa.h"
2278ee8d1cSJulian Grajkowski #include "qat_utils.h"
2378ee8d1cSJulian Grajkowski #include "lac_common.h"
2478ee8d1cSJulian Grajkowski
2578ee8d1cSJulian Grajkowski /**
2678ee8d1cSJulian Grajkowski *******************************************************************************
2778ee8d1cSJulian Grajkowski * @ingroup LacMem
2878ee8d1cSJulian Grajkowski * These macros are used to Endian swap variables from IA to QAT.
2978ee8d1cSJulian Grajkowski *
3078ee8d1cSJulian Grajkowski * @param[out] x The variable to be swapped.
3178ee8d1cSJulian Grajkowski *
3278ee8d1cSJulian Grajkowski * @retval none
3378ee8d1cSJulian Grajkowski ******************************************************************************/
3478ee8d1cSJulian Grajkowski #if (BYTE_ORDER == LITTLE_ENDIAN)
3578ee8d1cSJulian Grajkowski #define LAC_MEM_WR_64(x) QAT_UTILS_HOST_TO_NW_64(x)
3678ee8d1cSJulian Grajkowski #define LAC_MEM_WR_32(x) QAT_UTILS_HOST_TO_NW_32(x)
3778ee8d1cSJulian Grajkowski #define LAC_MEM_WR_16(x) QAT_UTILS_HOST_TO_NW_16(x)
3878ee8d1cSJulian Grajkowski #define LAC_MEM_RD_64(x) QAT_UTILS_NW_TO_HOST_64(x)
3978ee8d1cSJulian Grajkowski #define LAC_MEM_RD_32(x) QAT_UTILS_NW_TO_HOST_32(x)
4078ee8d1cSJulian Grajkowski #define LAC_MEM_RD_16(x) QAT_UTILS_NW_TO_HOST_16(x)
4178ee8d1cSJulian Grajkowski #else
4278ee8d1cSJulian Grajkowski #define LAC_MEM_WR_64(x) (x)
4378ee8d1cSJulian Grajkowski #define LAC_MEM_WR_32(x) (x)
4478ee8d1cSJulian Grajkowski #define LAC_MEM_WR_16(x) (x)
4578ee8d1cSJulian Grajkowski #define LAC_MEM_RD_64(x) (x)
4678ee8d1cSJulian Grajkowski #define LAC_MEM_RD_32(x) (x)
4778ee8d1cSJulian Grajkowski #define LAC_MEM_RD_16(x) (x)
4878ee8d1cSJulian Grajkowski #endif
4978ee8d1cSJulian Grajkowski
5078ee8d1cSJulian Grajkowski /*
5178ee8d1cSJulian Grajkowski *******************************************************************************
5278ee8d1cSJulian Grajkowski * Shared Memory Macros (memory accessible by Acceleration Engines, e.g. QAT)
5378ee8d1cSJulian Grajkowski *******************************************************************************
5478ee8d1cSJulian Grajkowski */
5578ee8d1cSJulian Grajkowski
5678ee8d1cSJulian Grajkowski /**
5778ee8d1cSJulian Grajkowski *******************************************************************************
5878ee8d1cSJulian Grajkowski * @ingroup LacMem
5978ee8d1cSJulian Grajkowski * This macro can be used to write to a variable that will be read by the
6078ee8d1cSJulian Grajkowski * QAT. The macro will automatically detect the size of the target variable and
6178ee8d1cSJulian Grajkowski * will select the correct method for performing the write. The data is cast to
6278ee8d1cSJulian Grajkowski * the type of the field that it will be written to.
6378ee8d1cSJulian Grajkowski * This macro swaps data if required.
6478ee8d1cSJulian Grajkowski *
6578ee8d1cSJulian Grajkowski * @param[out] var The variable to be written. Can be a field of a struct.
6678ee8d1cSJulian Grajkowski *
6778ee8d1cSJulian Grajkowski * @param[in] data The value to be written. Will be cast to the size of the
6878ee8d1cSJulian Grajkowski * target.
6978ee8d1cSJulian Grajkowski *
7078ee8d1cSJulian Grajkowski * @retval none
7178ee8d1cSJulian Grajkowski ******************************************************************************/
7278ee8d1cSJulian Grajkowski #define LAC_MEM_SHARED_WRITE_SWAP(var, data) \
7378ee8d1cSJulian Grajkowski do { \
7478ee8d1cSJulian Grajkowski switch (sizeof(var)) { \
7578ee8d1cSJulian Grajkowski case 1: \
7678ee8d1cSJulian Grajkowski (var) = (Cpa8U)(data); \
7778ee8d1cSJulian Grajkowski break; \
7878ee8d1cSJulian Grajkowski case 2: \
7978ee8d1cSJulian Grajkowski (var) = (Cpa16U)(data); \
8078ee8d1cSJulian Grajkowski (var) = LAC_MEM_WR_16(((Cpa16U)var)); \
8178ee8d1cSJulian Grajkowski break; \
8278ee8d1cSJulian Grajkowski case 4: \
8378ee8d1cSJulian Grajkowski (var) = (Cpa32U)(data); \
8478ee8d1cSJulian Grajkowski (var) = LAC_MEM_WR_32(((Cpa32U)var)); \
8578ee8d1cSJulian Grajkowski break; \
8678ee8d1cSJulian Grajkowski case 8: \
8778ee8d1cSJulian Grajkowski (var) = (Cpa64U)(data); \
8878ee8d1cSJulian Grajkowski (var) = LAC_MEM_WR_64(((Cpa64U)var)); \
8978ee8d1cSJulian Grajkowski break; \
9078ee8d1cSJulian Grajkowski default: \
9178ee8d1cSJulian Grajkowski break; \
9278ee8d1cSJulian Grajkowski } \
9378ee8d1cSJulian Grajkowski } while (0)
9478ee8d1cSJulian Grajkowski
9578ee8d1cSJulian Grajkowski /**
9678ee8d1cSJulian Grajkowski *******************************************************************************
9778ee8d1cSJulian Grajkowski * @ingroup LacMem
9878ee8d1cSJulian Grajkowski * This macro can be used to read a variable that was written by the QAT.
9978ee8d1cSJulian Grajkowski * The macro will automatically detect the size of the data to be read and will
10078ee8d1cSJulian Grajkowski * select the correct method for performing the read. The value read from the
10178ee8d1cSJulian Grajkowski * variable is cast to the size of the data type it will be stored in.
10278ee8d1cSJulian Grajkowski * This macro swaps data if required.
10378ee8d1cSJulian Grajkowski *
10478ee8d1cSJulian Grajkowski * @param[in] var The variable to be read. Can be a field of a struct.
10578ee8d1cSJulian Grajkowski *
10678ee8d1cSJulian Grajkowski * @param[out] data The variable to hold the result of the read. Data read
10778ee8d1cSJulian Grajkowski * will be cast to the size of this variable
10878ee8d1cSJulian Grajkowski *
10978ee8d1cSJulian Grajkowski * @retval none
11078ee8d1cSJulian Grajkowski ******************************************************************************/
11178ee8d1cSJulian Grajkowski #define LAC_MEM_SHARED_READ_SWAP(var, data) \
11278ee8d1cSJulian Grajkowski do { \
11378ee8d1cSJulian Grajkowski switch (sizeof(var)) { \
11478ee8d1cSJulian Grajkowski case 1: \
11578ee8d1cSJulian Grajkowski (data) = (var); \
11678ee8d1cSJulian Grajkowski break; \
11778ee8d1cSJulian Grajkowski case 2: \
11878ee8d1cSJulian Grajkowski (data) = LAC_MEM_RD_16(((Cpa16U)var)); \
11978ee8d1cSJulian Grajkowski break; \
12078ee8d1cSJulian Grajkowski case 4: \
12178ee8d1cSJulian Grajkowski (data) = LAC_MEM_RD_32(((Cpa32U)var)); \
12278ee8d1cSJulian Grajkowski break; \
12378ee8d1cSJulian Grajkowski case 8: \
12478ee8d1cSJulian Grajkowski (data) = LAC_MEM_RD_64(((Cpa64U)var)); \
12578ee8d1cSJulian Grajkowski break; \
12678ee8d1cSJulian Grajkowski default: \
12778ee8d1cSJulian Grajkowski break; \
12878ee8d1cSJulian Grajkowski } \
12978ee8d1cSJulian Grajkowski } while (0)
13078ee8d1cSJulian Grajkowski
13178ee8d1cSJulian Grajkowski /**
13278ee8d1cSJulian Grajkowski *******************************************************************************
13378ee8d1cSJulian Grajkowski * @ingroup LacMem
13478ee8d1cSJulian Grajkowski * This macro can be used to write a pointer to a QAT request. The fields
13578ee8d1cSJulian Grajkowski * for pointers in the QAT request and response messages are always 64 bits
13678ee8d1cSJulian Grajkowski *
13778ee8d1cSJulian Grajkowski * @param[out] var The variable to be written to. Can be a field of a struct.
13878ee8d1cSJulian Grajkowski *
13978ee8d1cSJulian Grajkowski * @param[in] data The value to be written. Will be cast to size of target
14078ee8d1cSJulian Grajkowski * variable
14178ee8d1cSJulian Grajkowski *
14278ee8d1cSJulian Grajkowski * @retval none
14378ee8d1cSJulian Grajkowski ******************************************************************************/
14478ee8d1cSJulian Grajkowski /* cast pointer to scalar of same size of the native pointer */
14578ee8d1cSJulian Grajkowski #define LAC_MEM_SHARED_WRITE_FROM_PTR(var, data) \
14678ee8d1cSJulian Grajkowski ((var) = (Cpa64U)(LAC_ARCH_UINT)(data))
14778ee8d1cSJulian Grajkowski
14878ee8d1cSJulian Grajkowski /* Note: any changes to this macro implementation should also be made to the
14978ee8d1cSJulian Grajkowski * similar LAC_MEM_CAST_PTR_TO_UINT64 macro
15078ee8d1cSJulian Grajkowski */
15178ee8d1cSJulian Grajkowski
15278ee8d1cSJulian Grajkowski /**
15378ee8d1cSJulian Grajkowski *******************************************************************************
15478ee8d1cSJulian Grajkowski * @ingroup LacMem
15578ee8d1cSJulian Grajkowski * This macro can be used to read a pointer from a QAT response. The fields
15678ee8d1cSJulian Grajkowski * for pointers in the QAT request and response messages are always 64 bits
15778ee8d1cSJulian Grajkowski *
15878ee8d1cSJulian Grajkowski * @param[in] var The variable to be read. Can be a field of a struct.
15978ee8d1cSJulian Grajkowski *
16078ee8d1cSJulian Grajkowski * @param[out] data The variable to hold the result of the read. Data read
16178ee8d1cSJulian Grajkowski * will be cast to the size of this variable
16278ee8d1cSJulian Grajkowski *
16378ee8d1cSJulian Grajkowski * @retval none
16478ee8d1cSJulian Grajkowski ******************************************************************************/
16578ee8d1cSJulian Grajkowski /* Cast back to native pointer */
16678ee8d1cSJulian Grajkowski #define LAC_MEM_SHARED_READ_TO_PTR(var, data) \
16778ee8d1cSJulian Grajkowski ((data) = (void *)(LAC_ARCH_UINT)(var))
16878ee8d1cSJulian Grajkowski
16978ee8d1cSJulian Grajkowski /**
17078ee8d1cSJulian Grajkowski *******************************************************************************
17178ee8d1cSJulian Grajkowski * @ingroup LacMem
17278ee8d1cSJulian Grajkowski * This macro safely casts a pointer to a Cpa64U type.
17378ee8d1cSJulian Grajkowski *
17478ee8d1cSJulian Grajkowski * @param[in] pPtr The pointer to be cast.
17578ee8d1cSJulian Grajkowski *
17678ee8d1cSJulian Grajkowski * @retval pointer cast to Cpa64U
17778ee8d1cSJulian Grajkowski ******************************************************************************/
17878ee8d1cSJulian Grajkowski #define LAC_MEM_CAST_PTR_TO_UINT64(pPtr) ((Cpa64U)(pPtr))
17978ee8d1cSJulian Grajkowski
18078ee8d1cSJulian Grajkowski /**
18178ee8d1cSJulian Grajkowski *******************************************************************************
18278ee8d1cSJulian Grajkowski * @ingroup LacMem
18378ee8d1cSJulian Grajkowski * This macro uses an QAT Utils macro to convert from a virtual address to
18478ee8d1cSJulian Grajkowski *a
18578ee8d1cSJulian Grajkowski * physical address for internally allocated memory.
18678ee8d1cSJulian Grajkowski *
18778ee8d1cSJulian Grajkowski * @param[in] pVirtAddr The address to be converted.
18878ee8d1cSJulian Grajkowski *
18978ee8d1cSJulian Grajkowski * @retval The converted physical address
19078ee8d1cSJulian Grajkowski ******************************************************************************/
19178ee8d1cSJulian Grajkowski #define LAC_OS_VIRT_TO_PHYS_INTERNAL(pVirtAddr) \
19278ee8d1cSJulian Grajkowski (QAT_UTILS_MMU_VIRT_TO_PHYS(pVirtAddr))
19378ee8d1cSJulian Grajkowski
19478ee8d1cSJulian Grajkowski /**
19578ee8d1cSJulian Grajkowski *******************************************************************************
19678ee8d1cSJulian Grajkowski * @ingroup LacMem
19778ee8d1cSJulian Grajkowski * This macro should be called on all externally allocated memory it calls
19878ee8d1cSJulian Grajkowski * SalMem_virt2PhysExternal function which allows a user
19978ee8d1cSJulian Grajkowski * to set the virt2phys function used by an instance.
20078ee8d1cSJulian Grajkowski * Defaults to virt to phys for kernel.
20178ee8d1cSJulian Grajkowski *
20278ee8d1cSJulian Grajkowski * @param[in] genService Generic sal_service_t structure.
20378ee8d1cSJulian Grajkowski * @param[in] pVirtAddr The address to be converted.
20478ee8d1cSJulian Grajkowski *
20578ee8d1cSJulian Grajkowski * @retval The converted physical address
20678ee8d1cSJulian Grajkowski ******************************************************************************/
20778ee8d1cSJulian Grajkowski #define LAC_OS_VIRT_TO_PHYS_EXTERNAL(genService, pVirtAddr) \
20878ee8d1cSJulian Grajkowski ((SalMem_virt2PhysExternal(pVirtAddr, &(genService))))
20978ee8d1cSJulian Grajkowski
21078ee8d1cSJulian Grajkowski /**
21178ee8d1cSJulian Grajkowski *******************************************************************************
21278ee8d1cSJulian Grajkowski * @ingroup LacMem
21378ee8d1cSJulian Grajkowski * This macro can be used to write an address variable that will be read by
21478ee8d1cSJulian Grajkowski * the QAT. The macro will perform the necessary virt2phys address translation
21578ee8d1cSJulian Grajkowski * This macro is only to be called on memory allocated internally by the driver.
21678ee8d1cSJulian Grajkowski *
21778ee8d1cSJulian Grajkowski * @param[out] var The address variable to write. Can be a field of a struct.
21878ee8d1cSJulian Grajkowski *
21978ee8d1cSJulian Grajkowski * @param[in] pPtr The pointer variable to containing the address to be
22078ee8d1cSJulian Grajkowski * written
22178ee8d1cSJulian Grajkowski *
22278ee8d1cSJulian Grajkowski * @retval none
22378ee8d1cSJulian Grajkowski ******************************************************************************/
22478ee8d1cSJulian Grajkowski #define LAC_MEM_SHARED_WRITE_VIRT_TO_PHYS_PTR_INTERNAL(var, pPtr) \
22578ee8d1cSJulian Grajkowski do { \
22678ee8d1cSJulian Grajkowski Cpa64U physAddr = 0; \
22778ee8d1cSJulian Grajkowski physAddr = LAC_MEM_CAST_PTR_TO_UINT64( \
22878ee8d1cSJulian Grajkowski LAC_OS_VIRT_TO_PHYS_INTERNAL(pPtr)); \
22978ee8d1cSJulian Grajkowski var = physAddr; \
23078ee8d1cSJulian Grajkowski } while (0)
23178ee8d1cSJulian Grajkowski
23278ee8d1cSJulian Grajkowski /**
23378ee8d1cSJulian Grajkowski *******************************************************************************
23478ee8d1cSJulian Grajkowski * @ingroup LacMem
23578ee8d1cSJulian Grajkowski * This macro can be used to write an address variable that will be read by
23678ee8d1cSJulian Grajkowski * the QAT. The macro will perform the necessary virt2phys address translation
23778ee8d1cSJulian Grajkowski * This macro is to be used on memory allocated externally by the user. It calls
23878ee8d1cSJulian Grajkowski * the user supplied virt2phys address translation.
23978ee8d1cSJulian Grajkowski *
24078ee8d1cSJulian Grajkowski * @param[in] pService The pointer to the service
24178ee8d1cSJulian Grajkowski * @param[out] var The address variable to write. Can be a field of a struct
24278ee8d1cSJulian Grajkowski * @param[in] pPtr The pointer variable to containing the address to be
24378ee8d1cSJulian Grajkowski * written
24478ee8d1cSJulian Grajkowski *
24578ee8d1cSJulian Grajkowski * @retval none
24678ee8d1cSJulian Grajkowski ******************************************************************************/
24778ee8d1cSJulian Grajkowski #define LAC_MEM_SHARED_WRITE_VIRT_TO_PHYS_PTR_EXTERNAL(pService, var, pPtr) \
24878ee8d1cSJulian Grajkowski do { \
24978ee8d1cSJulian Grajkowski Cpa64U physAddr = 0; \
25078ee8d1cSJulian Grajkowski physAddr = LAC_MEM_CAST_PTR_TO_UINT64( \
25178ee8d1cSJulian Grajkowski LAC_OS_VIRT_TO_PHYS_EXTERNAL(pService, pPtr)); \
25278ee8d1cSJulian Grajkowski var = physAddr; \
25378ee8d1cSJulian Grajkowski } while (0)
25478ee8d1cSJulian Grajkowski
25578ee8d1cSJulian Grajkowski /*
25678ee8d1cSJulian Grajkowski *******************************************************************************
25778ee8d1cSJulian Grajkowski * OS Memory Macros
25878ee8d1cSJulian Grajkowski *******************************************************************************
25978ee8d1cSJulian Grajkowski */
26078ee8d1cSJulian Grajkowski
26178ee8d1cSJulian Grajkowski /**
26278ee8d1cSJulian Grajkowski *******************************************************************************
26378ee8d1cSJulian Grajkowski * @ingroup LacMem
26478ee8d1cSJulian Grajkowski * This function and associated macro allocates the memory for the given
26578ee8d1cSJulian Grajkowski * size and stores the address of the memory allocated in the pointer.
26678ee8d1cSJulian Grajkowski *
26778ee8d1cSJulian Grajkowski * @param[out] ppMemAddr address of pointer where address will be stored
26878ee8d1cSJulian Grajkowski * @param[in] sizeBytes the size of the memory to be allocated.
26978ee8d1cSJulian Grajkowski *
27078ee8d1cSJulian Grajkowski * @retval CPA_STATUS_RESOURCE Macro failed to allocate Memory
27178ee8d1cSJulian Grajkowski * @retval CPA_STATUS_SUCCESS Macro executed successfully
27278ee8d1cSJulian Grajkowski *
27378ee8d1cSJulian Grajkowski ******************************************************************************/
27478ee8d1cSJulian Grajkowski static __inline CpaStatus
LacMem_OsMemAlloc(void ** ppMemAddr,Cpa32U sizeBytes)27578ee8d1cSJulian Grajkowski LacMem_OsMemAlloc(void **ppMemAddr, Cpa32U sizeBytes)
27678ee8d1cSJulian Grajkowski {
27778ee8d1cSJulian Grajkowski *ppMemAddr = malloc(sizeBytes, M_QAT, M_WAITOK);
27878ee8d1cSJulian Grajkowski
27978ee8d1cSJulian Grajkowski return CPA_STATUS_SUCCESS;
28078ee8d1cSJulian Grajkowski }
28178ee8d1cSJulian Grajkowski
28278ee8d1cSJulian Grajkowski /**
28378ee8d1cSJulian Grajkowski *******************************************************************************
28478ee8d1cSJulian Grajkowski * @ingroup LacMem
28578ee8d1cSJulian Grajkowski * This function and associated macro allocates the contiguous
28678ee8d1cSJulian Grajkowski * memory for the given
28778ee8d1cSJulian Grajkowski * size and stores the address of the memory allocated in the pointer.
28878ee8d1cSJulian Grajkowski *
28978ee8d1cSJulian Grajkowski * @param[out] ppMemAddr address of pointer where address will be stored
29078ee8d1cSJulian Grajkowski * @param[in] sizeBytes the size of the memory to be allocated.
29178ee8d1cSJulian Grajkowski * @param[in] alignmentBytes the alignment
29278ee8d1cSJulian Grajkowski * @param[in] node node to allocate from
29378ee8d1cSJulian Grajkowski *
29478ee8d1cSJulian Grajkowski * @retval CPA_STATUS_RESOURCE Macro failed to allocate Memory
29578ee8d1cSJulian Grajkowski * @retval CPA_STATUS_SUCCESS Macro executed successfully
29678ee8d1cSJulian Grajkowski *
29778ee8d1cSJulian Grajkowski ******************************************************************************/
29878ee8d1cSJulian Grajkowski static __inline CpaStatus
LacMem_OsContigAlignMemAlloc(void ** ppMemAddr,Cpa32U sizeBytes,Cpa32U alignmentBytes,Cpa32U node)29978ee8d1cSJulian Grajkowski LacMem_OsContigAlignMemAlloc(void **ppMemAddr,
30078ee8d1cSJulian Grajkowski Cpa32U sizeBytes,
30178ee8d1cSJulian Grajkowski Cpa32U alignmentBytes,
30278ee8d1cSJulian Grajkowski Cpa32U node)
30378ee8d1cSJulian Grajkowski {
30478ee8d1cSJulian Grajkowski if ((alignmentBytes & (alignmentBytes - 1)) !=
30578ee8d1cSJulian Grajkowski 0) /* if is not power of 2 */
30678ee8d1cSJulian Grajkowski {
30778ee8d1cSJulian Grajkowski *ppMemAddr = NULL;
30878ee8d1cSJulian Grajkowski QAT_UTILS_LOG("alignmentBytes MUST be the power of 2\n");
30978ee8d1cSJulian Grajkowski return CPA_STATUS_INVALID_PARAM;
31078ee8d1cSJulian Grajkowski }
31178ee8d1cSJulian Grajkowski
31278ee8d1cSJulian Grajkowski *ppMemAddr =
31378ee8d1cSJulian Grajkowski qatUtilsMemAllocContiguousNUMA(sizeBytes, node, alignmentBytes);
31478ee8d1cSJulian Grajkowski
31578ee8d1cSJulian Grajkowski if (NULL == *ppMemAddr) {
31678ee8d1cSJulian Grajkowski return CPA_STATUS_RESOURCE;
31778ee8d1cSJulian Grajkowski }
31878ee8d1cSJulian Grajkowski
31978ee8d1cSJulian Grajkowski return CPA_STATUS_SUCCESS;
32078ee8d1cSJulian Grajkowski }
32178ee8d1cSJulian Grajkowski
32278ee8d1cSJulian Grajkowski /**
32378ee8d1cSJulian Grajkowski *******************************************************************************
32478ee8d1cSJulian Grajkowski * @ingroup LacMem
32578ee8d1cSJulian Grajkowski * Macro from the malloc() function
32678ee8d1cSJulian Grajkowski *
32778ee8d1cSJulian Grajkowski ******************************************************************************/
32878ee8d1cSJulian Grajkowski #define LAC_OS_MALLOC(sizeBytes) malloc(sizeBytes, M_QAT, M_WAITOK)
32978ee8d1cSJulian Grajkowski
33078ee8d1cSJulian Grajkowski /**
33178ee8d1cSJulian Grajkowski *******************************************************************************
33278ee8d1cSJulian Grajkowski * @ingroup LacMem
33378ee8d1cSJulian Grajkowski * Macro from the LacMem_OsContigAlignMemAlloc function
33478ee8d1cSJulian Grajkowski *
33578ee8d1cSJulian Grajkowski ******************************************************************************/
33678ee8d1cSJulian Grajkowski #define LAC_OS_CAMALLOC(ppMemAddr, sizeBytes, alignmentBytes, node) \
33778ee8d1cSJulian Grajkowski LacMem_OsContigAlignMemAlloc((void *)ppMemAddr, \
33878ee8d1cSJulian Grajkowski sizeBytes, \
33978ee8d1cSJulian Grajkowski alignmentBytes, \
34078ee8d1cSJulian Grajkowski node)
34178ee8d1cSJulian Grajkowski
34278ee8d1cSJulian Grajkowski /**
34378ee8d1cSJulian Grajkowski *******************************************************************************
34478ee8d1cSJulian Grajkowski * @ingroup LacMem
34578ee8d1cSJulian Grajkowski * Macro for declaration static const unsigned int constant. One provides
34678ee8d1cSJulian Grajkowski * the compilation time computation with the highest bit set in the
34778ee8d1cSJulian Grajkowski * sizeof(TYPE) value. The constant is being put by the linker by default in
34878ee8d1cSJulian Grajkowski * .rodata section
34978ee8d1cSJulian Grajkowski *
35078ee8d1cSJulian Grajkowski * E.g. Statement LAC_DECLARE_HIGHEST_BIT_OF(lac_mem_blk_t)
35178ee8d1cSJulian Grajkowski * results in following entry:
35278ee8d1cSJulian Grajkowski * static const unsigned int highest_bit_of_lac_mem_blk_t = 3
35378ee8d1cSJulian Grajkowski *
354*25f09d4aSHareshx Sankar Raj * CAUTION!
35578ee8d1cSJulian Grajkowski * Macro is prepared only for type names NOT-containing ANY
35678ee8d1cSJulian Grajkowski * special characters. Types as amongst others:
35778ee8d1cSJulian Grajkowski * - void *
35878ee8d1cSJulian Grajkowski * - unsigned long
35978ee8d1cSJulian Grajkowski * - unsigned int
36078ee8d1cSJulian Grajkowski * are strictly forbidden and will result in compilation error.
36178ee8d1cSJulian Grajkowski * Use typedef to provide one-word type name for MACRO's usage.
36278ee8d1cSJulian Grajkowski ******************************************************************************/
36378ee8d1cSJulian Grajkowski #define LAC_DECLARE_HIGHEST_BIT_OF(TYPE) \
36478ee8d1cSJulian Grajkowski static const unsigned int highest_bit_of_##TYPE = \
36578ee8d1cSJulian Grajkowski (sizeof(TYPE) & 0x80000000 ? 31 : (sizeof(TYPE) & 0x40000000 ? 30 : (sizeof(TYPE) & 0x20000000 ? 29 : ( \
36678ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x10000000 ? 28 : ( \
36778ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x08000000 ? 27 : ( \
36878ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x04000000 ? 26 : ( \
36978ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x02000000 ? 25 : ( \
37078ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x01000000 ? 24 : ( \
37178ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00800000 ? \
37278ee8d1cSJulian Grajkowski 23 : \
37378ee8d1cSJulian Grajkowski (sizeof(TYPE) & 0x00400000 ? 22 : ( \
37478ee8d1cSJulian Grajkowski sizeof( \
37578ee8d1cSJulian Grajkowski TYPE) & \
37678ee8d1cSJulian Grajkowski 0x00200000 ? \
37778ee8d1cSJulian Grajkowski 21 : \
37878ee8d1cSJulian Grajkowski ( \
37978ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00100000 ? 20 : (sizeof(TYPE) & 0x00080000 ? 19 : ( \
38078ee8d1cSJulian Grajkowski sizeof( \
38178ee8d1cSJulian Grajkowski TYPE) & \
38278ee8d1cSJulian Grajkowski 0x00040000 ? \
38378ee8d1cSJulian Grajkowski 18 : \
38478ee8d1cSJulian Grajkowski ( \
38578ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00020000 ? 17 : ( \
38678ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00010000 ? 16 : (sizeof(TYPE) & \
38778ee8d1cSJulian Grajkowski 0x00008000 ? \
38878ee8d1cSJulian Grajkowski 15 : \
38978ee8d1cSJulian Grajkowski (sizeof(TYPE) & 0x00004000 ? 14 : ( \
39078ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00002000 ? 13 : \
39178ee8d1cSJulian Grajkowski ( \
39278ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00001000 ? 12 : ( \
39378ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000800 ? 11 : ( \
39478ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000400 ? 10 : \
39578ee8d1cSJulian Grajkowski ( \
39678ee8d1cSJulian Grajkowski sizeof(TYPE) & \
39778ee8d1cSJulian Grajkowski 0x00000200 ? \
39878ee8d1cSJulian Grajkowski 9 : \
39978ee8d1cSJulian Grajkowski (sizeof( \
40078ee8d1cSJulian Grajkowski TYPE) & \
40178ee8d1cSJulian Grajkowski 0x00000100 ? \
40278ee8d1cSJulian Grajkowski 8 : \
40378ee8d1cSJulian Grajkowski (sizeof(TYPE) & 0x00000080 ? 7 : \
40478ee8d1cSJulian Grajkowski ( \
40578ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000040 ? \
40678ee8d1cSJulian Grajkowski 6 : \
40778ee8d1cSJulian Grajkowski ( \
40878ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000020 ? 5 : \
40978ee8d1cSJulian Grajkowski ( \
41078ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000010 ? 4 : \
41178ee8d1cSJulian Grajkowski ( \
41278ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000008 ? 3 : \
41378ee8d1cSJulian Grajkowski ( \
41478ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000004 ? 2 : \
41578ee8d1cSJulian Grajkowski ( \
41678ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000002 ? 1 : ( \
41778ee8d1cSJulian Grajkowski sizeof(TYPE) & 0x00000001 ? 0 : 32))))))))))))))))) /*16*/))))))))))))))) /* 31 */
41878ee8d1cSJulian Grajkowski
41978ee8d1cSJulian Grajkowski /**
42078ee8d1cSJulian Grajkowski *******************************************************************************
42178ee8d1cSJulian Grajkowski * @ingroup LacMem
42278ee8d1cSJulian Grajkowski * This function and associated macro frees the memory at the given address
42378ee8d1cSJulian Grajkowski * and resets the pointer to NULL
42478ee8d1cSJulian Grajkowski *
42578ee8d1cSJulian Grajkowski * @param[out] ppMemAddr address of pointer where mem address is stored.
42678ee8d1cSJulian Grajkowski * If pointer is NULL, the function will exit silently
42778ee8d1cSJulian Grajkowski *
42878ee8d1cSJulian Grajkowski * @retval void
42978ee8d1cSJulian Grajkowski *
43078ee8d1cSJulian Grajkowski ******************************************************************************/
43178ee8d1cSJulian Grajkowski static __inline void
LacMem_OsMemFree(void ** ppMemAddr)43278ee8d1cSJulian Grajkowski LacMem_OsMemFree(void **ppMemAddr)
43378ee8d1cSJulian Grajkowski {
43478ee8d1cSJulian Grajkowski free(*ppMemAddr, M_QAT);
43578ee8d1cSJulian Grajkowski *ppMemAddr = NULL;
43678ee8d1cSJulian Grajkowski }
43778ee8d1cSJulian Grajkowski
43878ee8d1cSJulian Grajkowski /**
43978ee8d1cSJulian Grajkowski *******************************************************************************
44078ee8d1cSJulian Grajkowski * @ingroup LacMem
44178ee8d1cSJulian Grajkowski * This function and associated macro frees the contiguous memory at the
44278ee8d1cSJulian Grajkowski * given address and resets the pointer to NULL
44378ee8d1cSJulian Grajkowski *
44478ee8d1cSJulian Grajkowski * @param[out] ppMemAddr address of pointer where mem address is stored.
44578ee8d1cSJulian Grajkowski * If pointer is NULL, the function will exit silently
44678ee8d1cSJulian Grajkowski *
44778ee8d1cSJulian Grajkowski * @retval void
44878ee8d1cSJulian Grajkowski *
44978ee8d1cSJulian Grajkowski ******************************************************************************/
45078ee8d1cSJulian Grajkowski static __inline void
LacMem_OsContigAlignMemFree(void ** ppMemAddr)45178ee8d1cSJulian Grajkowski LacMem_OsContigAlignMemFree(void **ppMemAddr)
45278ee8d1cSJulian Grajkowski {
45378ee8d1cSJulian Grajkowski if (NULL != *ppMemAddr) {
45478ee8d1cSJulian Grajkowski qatUtilsMemFreeNUMA(*ppMemAddr);
45578ee8d1cSJulian Grajkowski *ppMemAddr = NULL;
45678ee8d1cSJulian Grajkowski }
45778ee8d1cSJulian Grajkowski }
45878ee8d1cSJulian Grajkowski
45978ee8d1cSJulian Grajkowski #define LAC_OS_FREE(pMemAddr) LacMem_OsMemFree((void *)&pMemAddr)
46078ee8d1cSJulian Grajkowski
46178ee8d1cSJulian Grajkowski #define LAC_OS_CAFREE(pMemAddr) LacMem_OsContigAlignMemFree((void *)&pMemAddr)
46278ee8d1cSJulian Grajkowski
46378ee8d1cSJulian Grajkowski /**
46478ee8d1cSJulian Grajkowski *******************************************************************************
46578ee8d1cSJulian Grajkowski * @ingroup LacMem
46678ee8d1cSJulian Grajkowski * Copies user data to a working buffer of the correct size (required by
46778ee8d1cSJulian Grajkowski * PKE services)
46878ee8d1cSJulian Grajkowski *
46978ee8d1cSJulian Grajkowski * @description
47078ee8d1cSJulian Grajkowski * This function produces a correctly sized working buffer from the input
47178ee8d1cSJulian Grajkowski * user buffer. If the original buffer is too small a new buffer shall
47278ee8d1cSJulian Grajkowski * be allocated and memory is copied (left padded with zeros to the
47378ee8d1cSJulian Grajkowski *required
47478ee8d1cSJulian Grajkowski * length).
47578ee8d1cSJulian Grajkowski *
47678ee8d1cSJulian Grajkowski * The returned working buffer is guaranteed to be of the desired size for
47778ee8d1cSJulian Grajkowski * QAT.
47878ee8d1cSJulian Grajkowski *
47978ee8d1cSJulian Grajkowski * When this function is called pInternalMem describes the user_buffer and
48078ee8d1cSJulian Grajkowski * when the function returns pInternalMem describes the working buffer.
48178ee8d1cSJulian Grajkowski * This is because pInternalMem describes the memory that will be sent to
48278ee8d1cSJulian Grajkowski * QAT.
48378ee8d1cSJulian Grajkowski *
484*25f09d4aSHareshx Sankar Raj * The caller must keep the original buffer pointer. The allocated buffer
48578ee8d1cSJulian Grajkowski *is
48678ee8d1cSJulian Grajkowski * freed (as necessary) using icp_LacBufferRestore().
48778ee8d1cSJulian Grajkowski *
48878ee8d1cSJulian Grajkowski * @param[in] instanceHandle Handle to crypto instance so pke_resize mem pool
48978ee8d1cSJulian Grajkowski *can
49078ee8d1cSJulian Grajkowski * be located
49178ee8d1cSJulian Grajkowski * @param[in] pUserBuffer Pointer on the user buffer
49278ee8d1cSJulian Grajkowski * @param[in] userLen length of the user buffer
49378ee8d1cSJulian Grajkowski * @param[in] workingLen length of the working (correctly sized) buffer
49478ee8d1cSJulian Grajkowski * @param[in/out] pInternalMem pointer to boolean if TRUE on input then
49578ee8d1cSJulian Grajkowski * user_buffer is internally allocated memory
49678ee8d1cSJulian Grajkowski * if false then it is externally allocated.
49778ee8d1cSJulian Grajkowski * This value gets updated by the function
49878ee8d1cSJulian Grajkowski * if the returned pointer references internally
49978ee8d1cSJulian Grajkowski * allocated memory.
50078ee8d1cSJulian Grajkowski *
50178ee8d1cSJulian Grajkowski * @return a pointer to the working (correctly sized) buffer or NULL if the
50278ee8d1cSJulian Grajkowski * allocation failed
50378ee8d1cSJulian Grajkowski *
50478ee8d1cSJulian Grajkowski * @note the working length cannot be smaller than the user buffer length
50578ee8d1cSJulian Grajkowski *
50678ee8d1cSJulian Grajkowski * @warning the working buffer may be the same or different from the original
50778ee8d1cSJulian Grajkowski * user buffer; the caller should make no assumptions in this regard
50878ee8d1cSJulian Grajkowski *
50978ee8d1cSJulian Grajkowski * @see icp_LacBufferRestore()
51078ee8d1cSJulian Grajkowski *
51178ee8d1cSJulian Grajkowski ******************************************************************************/
51278ee8d1cSJulian Grajkowski Cpa8U *icp_LacBufferResize(CpaInstanceHandle instanceHandle,
51378ee8d1cSJulian Grajkowski Cpa8U *pUserBuffer,
51478ee8d1cSJulian Grajkowski Cpa32U userLen,
51578ee8d1cSJulian Grajkowski Cpa32U workingLen,
51678ee8d1cSJulian Grajkowski CpaBoolean *pInternalMemory);
51778ee8d1cSJulian Grajkowski
51878ee8d1cSJulian Grajkowski /**
51978ee8d1cSJulian Grajkowski *******************************************************************************
52078ee8d1cSJulian Grajkowski * @ingroup LacMem
52178ee8d1cSJulian Grajkowski * Restores a user buffer
52278ee8d1cSJulian Grajkowski *
52378ee8d1cSJulian Grajkowski * @description
52478ee8d1cSJulian Grajkowski * This function restores a user buffer and releases its
52578ee8d1cSJulian Grajkowski * corresponding working buffer. The working buffer, assumed to be
52678ee8d1cSJulian Grajkowski * previously obtained using icp_LacBufferResize(), is freed as necessary.
52778ee8d1cSJulian Grajkowski *
52878ee8d1cSJulian Grajkowski * The contents are copied in the process.
52978ee8d1cSJulian Grajkowski *
53078ee8d1cSJulian Grajkowski * @note the working length cannot be smaller than the user buffer length
53178ee8d1cSJulian Grajkowski *
53278ee8d1cSJulian Grajkowski * @param[out] pUserBuffer Pointer on the user buffer
53378ee8d1cSJulian Grajkowski * @param[in] userLen length of the user buffer
53478ee8d1cSJulian Grajkowski * @param[in] pWorkingBuffer Pointer on the working buffer
53578ee8d1cSJulian Grajkowski * @param[in] workingLen working buffer length
53678ee8d1cSJulian Grajkowski * @param[in] copyBuf if set _TRUE the data in the workingBuffer
53778ee8d1cSJulian Grajkowski * will be copied to the userBuffer before the
53878ee8d1cSJulian Grajkowski * workingBuffer is freed.
53978ee8d1cSJulian Grajkowski *
54078ee8d1cSJulian Grajkowski * @return the status of the operation
54178ee8d1cSJulian Grajkowski *
54278ee8d1cSJulian Grajkowski * @see icp_LacBufferResize()
54378ee8d1cSJulian Grajkowski *
54478ee8d1cSJulian Grajkowski ******************************************************************************/
54578ee8d1cSJulian Grajkowski CpaStatus icp_LacBufferRestore(Cpa8U *pUserBuffer,
54678ee8d1cSJulian Grajkowski Cpa32U userLen,
54778ee8d1cSJulian Grajkowski Cpa8U *pWorkingBuffer,
54878ee8d1cSJulian Grajkowski Cpa32U workingLen,
54978ee8d1cSJulian Grajkowski CpaBoolean copyBuf);
55078ee8d1cSJulian Grajkowski
55178ee8d1cSJulian Grajkowski /**
55278ee8d1cSJulian Grajkowski *******************************************************************************
55378ee8d1cSJulian Grajkowski * @ingroup LacMem
55478ee8d1cSJulian Grajkowski * Uses an instance specific user supplied virt2phys function to convert a
55578ee8d1cSJulian Grajkowski * virtual address to a physical address.
55678ee8d1cSJulian Grajkowski *
55778ee8d1cSJulian Grajkowski * @description
55878ee8d1cSJulian Grajkowski * Uses an instance specific user supplied virt2phys function to convert a
55978ee8d1cSJulian Grajkowski * virtual address to a physical address. A client of QA API can set the
56078ee8d1cSJulian Grajkowski * virt2phys function for an instance by using the
56178ee8d1cSJulian Grajkowski * cpaXxSetAddressTranslation() function. If the client does not set the
56278ee8d1cSJulian Grajkowski * virt2phys function and the instance is in kernel space then OS specific
56378ee8d1cSJulian Grajkowski * virt2phys function will be used. In user space the virt2phys function
56478ee8d1cSJulian Grajkowski * MUST be set by the user.
56578ee8d1cSJulian Grajkowski *
56678ee8d1cSJulian Grajkowski * @param[in] pVirtAddr the virtual addr to be converted
56778ee8d1cSJulian Grajkowski * @param[in] pServiceGen Pointer on the sal_service_t structure
56878ee8d1cSJulian Grajkowski * so client supplied virt2phys function can be
56978ee8d1cSJulian Grajkowski * called.
57078ee8d1cSJulian Grajkowski *
57178ee8d1cSJulian Grajkowski * @return the physical address
57278ee8d1cSJulian Grajkowski *
57378ee8d1cSJulian Grajkowski ******************************************************************************/
57478ee8d1cSJulian Grajkowski CpaPhysicalAddr SalMem_virt2PhysExternal(void *pVirtAddr, void *pServiceGen);
57578ee8d1cSJulian Grajkowski
57678ee8d1cSJulian Grajkowski #endif /* LAC_MEM_H */
577