/* Copyright 2020 Rockchip Electronics Co. LTD
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*/
|
|
#include <stdint.h>
|
#include <inttypes.h>
|
#include <stdio.h>
|
#include <unistd.h>
|
#include <cstring>
|
#include <vector>
|
|
#include "rk_debug.h"
|
#include "rk_comm_mb.h"
|
#include "rk_mpi_mmz.h"
|
#include "argparse.h"
|
|
#define MB_POOL_COUNT 10
|
#define MB_POOL_MB_COUNT 10
|
#define MB_POOL_MB_SIZE 1280 * 720 * 2
|
|
typedef struct _rkTestMMZCtx {
|
RK_S32 s32MmzCount;
|
RK_S32 s32MmzSize;
|
RK_S32 s32PoolCount;
|
RK_S32 s32LoopCount;
|
RK_BOOL bExternal;
|
RK_BOOL bPreAlloc;
|
RK_S32 s32RemapMode;
|
RK_S32 s32AllocType;
|
} TEST_MMZ_CTX_S;
|
|
#define vaddr_to_fd_offset(vaddr, fd, offset) do {\
|
MB_BLK __blk = RK_MPI_MMZ_VirAddr2Handle(vaddr); \
|
if (__blk != (MB_BLK)RK_NULL) { \
|
RK_VOID* __vaddr = RK_MPI_MMZ_Handle2VirAddr(__blk); \
|
offset = vaddr - reinterpret_cast<RK_U8 *>(__vaddr); \
|
fd = RK_MPI_MMZ_Handle2Fd(__blk); \
|
} else { \
|
offset = -1; \
|
fd = -1; \
|
} \
|
} while (0);
|
|
#define paddr_to_fd_offset(paddr, fd, offset) do {\
|
MB_BLK __blk = RK_MPI_MMZ_PhyAddr2Handle(paddr); \
|
if (__blk != (MB_BLK)RK_NULL) { \
|
RK_U64 __paddr = RK_MPI_MMZ_Handle2PhysAddr(__blk); \
|
offset = (RK_U8)paddr - (RK_U8)__paddr; \
|
fd = RK_MPI_MMZ_Handle2Fd(__blk); \
|
} else { \
|
offset = -1; \
|
fd = -1; \
|
} \
|
} while (0);
|
|
RK_S32 unit_test_mpi_mmz(const TEST_MMZ_CTX_S *pCtx) {
|
MB_BLK mb;
|
RK_S32 len = 1048576;
|
RK_S32 ret = RK_SUCCESS;
|
RK_S32 flags = RK_MMZ_ALLOC_CACHEABLE | RK_MMZ_ALLOC_TYPE_CMA;
|
|
ret = RK_MPI_MMZ_Alloc(&mb, len, flags);
|
if (ret < 0) {
|
RK_LOGI("alloc mmz fail");
|
return ret;
|
}
|
|
RK_U8 *vaddr = reinterpret_cast<RK_U8 *>(RK_MPI_MMZ_Handle2VirAddr(mb));
|
RK_U64 paddr = RK_MPI_MMZ_Handle2PhysAddr(mb);
|
RK_S32 fd = RK_MPI_MMZ_Handle2Fd(mb);
|
len = RK_MPI_MMZ_GetSize(mb);
|
RK_S32 is_cacheable = RK_MPI_MMZ_IsCacheable(mb);
|
|
RK_LOGI("alloc buffer: fd=%d, len=%d, paddr=0x%x, vaddr=%p, cacheable=%d", fd, len, paddr, vaddr, is_cacheable);
|
MB_BLK mb_by_fd = RK_MPI_MMZ_Fd2Handle(fd);
|
MB_BLK mb_by_vaddr = RK_MPI_MMZ_VirAddr2Handle(reinterpret_cast<RK_VOID *>(vaddr));
|
RK_LOGI("MB: %p %p %p", mb, mb_by_fd, mb_by_vaddr);
|
|
RK_U8 *vaddr_temp = vaddr + 1;
|
RK_LOGI("vaddr+1: %p, mb: %p", vaddr_temp, RK_MPI_MMZ_VirAddr2Handle(reinterpret_cast<RK_VOID *>(vaddr_temp)));
|
|
vaddr_temp = vaddr-1;
|
RK_LOGI("vaddr-1: %p, mb: %p", vaddr_temp, RK_MPI_MMZ_VirAddr2Handle(reinterpret_cast<RK_VOID *>(vaddr_temp)));
|
|
vaddr_temp = vaddr+len;
|
RK_LOGI("vaddr+len: %p, mb: %p", vaddr_temp, RK_MPI_MMZ_VirAddr2Handle(reinterpret_cast<RK_VOID *>(vaddr_temp)));
|
|
vaddr_temp = vaddr+len-1;
|
RK_LOGI("vaddr+len-1: %p, mb: %p", vaddr_temp, RK_MPI_MMZ_VirAddr2Handle(reinterpret_cast<RK_VOID *>(vaddr_temp)));
|
|
RK_U64 paddr_temp = paddr+1;
|
RK_LOGI("paddr+1: 0x%x, mb: %p", paddr_temp, RK_MPI_MMZ_PhyAddr2Handle(paddr_temp));
|
|
paddr_temp = paddr-1;
|
RK_LOGI("paddr-1: 0x%x, mb: %p", paddr_temp, RK_MPI_MMZ_PhyAddr2Handle(paddr_temp));
|
|
paddr_temp = paddr+len;
|
RK_LOGI("paddr+len: 0x%x, mb: %p", paddr_temp, RK_MPI_MMZ_PhyAddr2Handle(paddr_temp));
|
|
paddr_temp = paddr+len-1;
|
RK_LOGI("paddr+len-1: 0x%x, mb: %p", paddr_temp, RK_MPI_MMZ_PhyAddr2Handle(paddr_temp));
|
|
RK_U32 offset;
|
vaddr_temp = vaddr+len-10;
|
vaddr_to_fd_offset(vaddr_temp, fd, offset);
|
RK_LOGI("vaddr+len-10: %p, fd: %d, offset: %d", vaddr_temp, fd, offset);
|
|
paddr_temp = paddr+len-10;
|
paddr_to_fd_offset(paddr_temp, fd, offset);
|
RK_LOGI("paddr+len-10: 0x%x, fd: %d, offset: %d", paddr_temp, fd, offset);
|
|
ret = RK_MPI_MMZ_FlushCacheStart(mb, 0, 0, RK_MMZ_SYNC_WRITEONLY);
|
memset(vaddr, 0x5A, len);
|
ret = RK_MPI_MMZ_FlushCacheEnd(mb, 0, 0, RK_MMZ_SYNC_WRITEONLY);
|
|
ret = RK_MPI_MMZ_FlushCacheStart(mb, 4096, 4096, RK_MMZ_SYNC_RW);
|
memset(vaddr, 0x5A, len);
|
ret = RK_MPI_MMZ_FlushCacheEnd(mb, 4096, 4096, RK_MMZ_SYNC_RW);
|
|
vaddr_temp = vaddr+len-10;
|
ret = RK_MPI_MMZ_FlushCacheVaddrStart(reinterpret_cast<RK_VOID *>(vaddr_temp), 4096, RK_MMZ_SYNC_WRITEONLY);
|
memset(vaddr_temp, 0x5A, 10);
|
ret = RK_MPI_MMZ_FlushCacheVaddrEnd(reinterpret_cast<RK_VOID *>(vaddr_temp), 4096, RK_MMZ_SYNC_WRITEONLY);
|
|
paddr_temp = paddr_temp+len-10;
|
ret = RK_MPI_MMZ_FlushCachePaddrStart(paddr_temp, 4096, RK_MMZ_SYNC_WRITEONLY);
|
vaddr_temp = vaddr+len-10;
|
memset(vaddr_temp, 0x5A, 10);
|
ret = RK_MPI_MMZ_FlushCachePaddrEnd(paddr_temp, 4096, RK_MMZ_SYNC_WRITEONLY);
|
|
usleep(100000);
|
RK_MPI_MMZ_Free(mb);
|
return RK_SUCCESS;
|
}
|
|
|
static const char *const usages[] = {
|
"./rk_mpi_mmz_test [-c MB_COUNT] [-s MB_SIZE]...",
|
NULL,
|
};
|
|
RK_S32 main(RK_S32 argc, const char **argv) {
|
RK_S32 s32Ret = RK_SUCCESS;
|
TEST_MMZ_CTX_S stMmzCtx;
|
|
memset(&stMmzCtx, 0, sizeof(TEST_MMZ_CTX_S));
|
|
struct argparse_option options[] = {
|
OPT_HELP(),
|
OPT_GROUP("basic options:"),
|
OPT_END(),
|
};
|
|
struct argparse argparse;
|
argparse_init(&argparse, options, usages, 0);
|
argparse_describe(&argparse, "\nselect a test case to run.",
|
"\nuse --help for details.");
|
|
argc = argparse_parse(&argparse, argc, argv);
|
|
s32Ret = unit_test_mpi_mmz(&stMmzCtx);
|
if (s32Ret != RK_SUCCESS) {
|
goto __FAILED;
|
}
|
|
RK_LOGI("test running ok.");
|
return RK_SUCCESS;
|
__FAILED:
|
RK_LOGE("test running failed!");
|
return RK_ERR_MB_BUSY;
|
}
|
