starred/mpp-nyanmisaka
1
0
Fork 0
mirror of https://github.com/nyanmisaka/mpp.git synced 2026-01-24 03:10:39 +01:00
Code Issues Projects Packages Wiki Activity Actions

feat[mpp_obj]: Add mpp_obj for kernel object

Browse source 
Signed-off-by: Herman Chen <herman.chen@rock-chips.com>
Change-Id: I7e5ec2b970cff69c37218cc03f6b759816becb93
This commit is contained in:
Herman Chen 2024-12-02 23:18:40 +08:00
parent dfc7564693
commit ae3ef50921
6 changed files with 926 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

1
mpp/base/CMakeLists.txt
View file

@ -24,6 +24,7 @@ add_library(mpp_base STATIC
mpp_cfg.cpp
mpp_2str.c
mpp_dec_hdr_meta.c
kmpp_obj.c
)
set_target_properties(mpp_base PROPERTIES FOLDER "mpp/base")

113
mpp/base/inc/kmpp_obj.h Normal file
View file

@ -0,0 +1,113 @@
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/*
* Copyright (c) 2024 Rockchip Electronics Co., Ltd.
*/
#ifndef __KMPP_OBJ_H__
#define __KMPP_OBJ_H__
#include <linux/types.h>
#include "mpp_trie.h"
typedef enum EntryType_e {
ENTRY_TYPE_s32,
ENTRY_TYPE_u32,
ENTRY_TYPE_s64,
ENTRY_TYPE_u64,
ENTRY_TYPE_ptr,
ENTRY_TYPE_fp, /* function poineter */
ENTRY_TYPE_st,
ENTRY_TYPE_BUTT,
} EntryType;
/* location table */
typedef union MppLocTbl_u {
rk_u64 val;
struct {
rk_u16 data_offset;
rk_u16 data_size : 12;
EntryType data_type : 3;
rk_u16 flag_type : 1;
rk_u16 flag_offset;
rk_u16 flag_value;
};
} KmppLocTbl;
/* kernel object trie share info */
typedef struct KmppObjTrie_t {
/* share object trie root userspace address (read only) */
__u64 trie_root;
} KmppObjTrie;
/* kernel object share memory */
typedef struct KmppObjShm_t {
__u64 kobj_uaddr;
__u64 kobj_kaddr;
/* DO NOT access reserved data only used by kernel */
} KmppObjShm;
/* KmppObjDef - mpp object name size and access table trie definition */
typedef void* KmppObjDef;
/* KmppObj - mpp object for string name access and function access */
typedef void* KmppObj;
typedef void (*KmppObjPreset)(void *obj);
typedef rk_s32 (*KmppObjDump)(void *obj);
rk_s32 kmpp_objdef_init(KmppObjDef *def, const char *name);
rk_s32 kmpp_objdef_get_entry(KmppObjDef def, const char *name, KmppLocTbl **tbl);
rk_s32 kmpp_objdef_add_trie_root(KmppObjDef def, void *root);
rk_s32 kmpp_objdef_add_dump(KmppObjDef def, KmppObjDump dump);
rk_s32 kmpp_objdef_deinit(KmppObjDef def);
rk_u32 kmpp_objdef_lookup(KmppObjDef *def, const char *name);
/* mpp objcet internal element set / get function */
const char *kmpp_objdef_get_name(KmppObjDef def);
rk_s32 kmpp_objdef_get_entry_size(KmppObjDef def);
MppTrie kmpp_objdef_get_trie(KmppObjDef def);
/* import kernel object ref */
rk_s32 kmpp_obj_get(KmppObj *obj, KmppObjDef def);
rk_s32 kmpp_obj_put(KmppObj obj);
rk_s32 kmpp_obj_check(KmppObj obj, const char *caller);
void *kmpp_obj_get_entry(KmppObj obj);
rk_s32 kmpp_obj_set_s32(KmppObj obj, const char *name, rk_s32 val);
rk_s32 kmpp_obj_get_s32(KmppObj obj, const char *name, rk_s32 *val);
rk_s32 kmpp_obj_set_u32(KmppObj obj, const char *name, rk_u32 val);
rk_s32 kmpp_obj_get_u32(KmppObj obj, const char *name, rk_u32 *val);
rk_s32 kmpp_obj_set_s64(KmppObj obj, const char *name, rk_s64 val);
rk_s32 kmpp_obj_get_s64(KmppObj obj, const char *name, rk_s64 *val);
rk_s32 kmpp_obj_set_u64(KmppObj obj, const char *name, rk_u64 val);
rk_s32 kmpp_obj_get_u64(KmppObj obj, const char *name, rk_u64 *val);
rk_s32 kmpp_obj_set_ptr(KmppObj obj, const char *name, void *val);
rk_s32 kmpp_obj_get_ptr(KmppObj obj, const char *name, void **val);
rk_s32 kmpp_obj_set_fp(KmppObj obj, const char *name, void *val);
rk_s32 kmpp_obj_get_fp(KmppObj obj, const char *name, void **val);
rk_s32 kmpp_obj_set_st(KmppObj obj, const char *name, void *val);
rk_s32 kmpp_obj_get_st(KmppObj obj, const char *name, void *val);
rk_s32 kmpp_obj_tbl_set_s32(KmppObj obj, KmppLocTbl *tbl, rk_s32 val);
rk_s32 kmpp_obj_tbl_get_s32(KmppObj obj, KmppLocTbl *tbl, rk_s32 *val);
rk_s32 kmpp_obj_tbl_set_u32(KmppObj obj, KmppLocTbl *tbl, rk_u32 val);
rk_s32 kmpp_obj_tbl_get_u32(KmppObj obj, KmppLocTbl *tbl, rk_u32 *val);
rk_s32 kmpp_obj_tbl_set_s64(KmppObj obj, KmppLocTbl *tbl, rk_s64 val);
rk_s32 kmpp_obj_tbl_get_s64(KmppObj obj, KmppLocTbl *tbl, rk_s64 *val);
rk_s32 kmpp_obj_tbl_set_u64(KmppObj obj, KmppLocTbl *tbl, rk_u64 val);
rk_s32 kmpp_obj_tbl_get_u64(KmppObj obj, KmppLocTbl *tbl, rk_u64 *val);
rk_s32 kmpp_obj_tbl_set_ptr(KmppObj obj, KmppLocTbl *tbl, void *val);
rk_s32 kmpp_obj_tbl_get_ptr(KmppObj obj, KmppLocTbl *tbl, void **val);
rk_s32 kmpp_obj_tbl_set_fp(KmppObj obj, KmppLocTbl *tbl, void *val);
rk_s32 kmpp_obj_tbl_get_fp(KmppObj obj, KmppLocTbl *tbl, void **val);
rk_s32 kmpp_obj_tbl_set_st(KmppObj obj, KmppLocTbl *tbl, void *val);
rk_s32 kmpp_obj_tbl_get_st(KmppObj obj, KmppLocTbl *tbl, void *val);
/* run a callback function */
rk_s32 kmpp_obj_run(KmppObj obj, const char *name);
rk_s32 kmpp_obj_dump(KmppObj obj, const char *caller);
#define kmpp_obj_dump_f(obj) kmpp_obj_dump(obj, __FUNCTION__)
#endif /* __KMPP_OBJ_H__ */

31
mpp/base/inc/kmpp_obj_func.h Normal file
View file

@ -0,0 +1,31 @@
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/*
* Copyright (c) 2024 Rockchip Electronics Co., Ltd.
*/
#ifndef KMPP_OBJ_FUNC_PREFIX
#error "KMPP_OBJ_FUNC_PREFIX must be defined on using kmpp_idef_begin.h"
#endif
#ifndef KMPP_OBJ_INTF_TYPE
#error "KMPP_OBJ_INTF_TYPE must be defined on using kmpp_idef_begin.h"
#endif
#ifndef KMPP_OBJ_ENTRY_TABLE
#error "KMPP_OBJ_ENTRY_TABLE must be defined on using kmpp_idef_begin.h"
#endif
#define KMPP_OBJ_FUNC(x, y, z) x##y##z
#define ENTRY_TO_DECLARE(ftype, type, f1) \
rk_s32 KMPP_OBJ_FUNC(KMPP_OBJ_FUNC_PREFIX, _set_, f1)(KMPP_OBJ_INTF_TYPE p, type val); \
rk_s32 KMPP_OBJ_FUNC(KMPP_OBJ_FUNC_PREFIX, _get_, f1)(KMPP_OBJ_INTF_TYPE p, type* val);
KMPP_OBJ_ENTRY_TABLE(ENTRY_TO_DECLARE)
#undef KMPP_OBJ_FUNC_PREFIX
#undef KMPP_OBJ_INTF_TYPE
#undef KMPP_OBJ_ENTRY_TABLE
#undef ENTRY_TO_DECLARE
#undef KMPP_OBJ_FUNC

86
mpp/base/inc/kmpp_obj_helper.h Normal file
View file

@ -0,0 +1,86 @@
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/*
* Copyright (c) 2024 Rockchip Electronics Co., Ltd.
*/
#if defined(KMPP_OBJ_HERLPER_EXIST)
#error "can not include kmpp_obj_helper.h twice"
#endif
#define KMPP_OBJ_HERLPER_EXIST
#if defined(KMPP_OBJ_IMPL_TYPE) && defined(KMPP_OBJ_IMPL_DEF)
/*
* macro for register structure fiedl to trie
* type -> struct base type
* f1 -> struct:field1 name segment 1 the field1 part
* f2 -> struct:field1:field2 name segment 2 the field2 part
* ftype -> field type as EntryType
*/
#define FIELD_TO_LOCTBL_FLAG1(f1, ftype, field_flag, flag_value) \
{ \
.data_offset = offsetof(KMPP_OBJ_IMPL_TYPE, f1), \
.data_size = sizeof(((KMPP_OBJ_IMPL_TYPE *)0)->f1), \
.data_type = ENTRY_TYPE_##ftype, \
.flag_type = flag_value ? 1 : 0, \
.flag_offset = offsetof(KMPP_OBJ_IMPL_TYPE, field_flag), \
.flag_value = flag_value, \
}
#define FIELD_TO_LOCTBL_ACCESS1(f1, ftype) \
{ \
.data_offset = offsetof(KMPP_OBJ_IMPL_TYPE, f1), \
.data_size = sizeof(((KMPP_OBJ_IMPL_TYPE *)0)->f1), \
.data_type = ENTRY_TYPE_##ftype, \
.flag_type = 0, \
.flag_offset = 0, \
.flag_value = 0, \
}
#define ENTRY_TO_TRIE1(ftype, type, f1) \
do { \
KmppLocTbl tbl = FIELD_TO_LOCTBL_ACCESS1(f1, ftype); \
kmpp_objdef_add_entry(KMPP_OBJ_IMPL_DEF, #f1, &tbl); \
} while (0);
#define FIELD_TO_LOCTBL_FLAG2(f1, f2, ftype, field_flag, flag_value) \
{ \
.data_offset = offsetof(KMPP_OBJ_IMPL_TYPE, f1.f2), \
.data_size = sizeof(((KMPP_OBJ_IMPL_TYPE *)0)->f1.f2), \
.data_type = ENTRY_TYPE_##ftype, \
.flag_type = flag_value ? 1 : 0, \
.flag_offset = offsetof(KMPP_OBJ_IMPL_TYPE, field_flag), \
.flag_value = flag_value, \
}
#define FIELD_TO_LOCTBL_ACCESS2(f1, f2, ftype) \
{ \
.data_offset = offsetof(KMPP_OBJ_IMPL_TYPE, f1.f2), \
.data_size = sizeof(((KMPP_OBJ_IMPL_TYPE *)0)->f1.f2), \
.data_type = ENTRY_TYPE_##ftype, \
.flag_type = 0, \
.flag_offset = 0, \
.flag_value = 0, \
}
#define ENTRY_TO_TRIE2(ftype, type, f1, f2) \
do { \
KmppLocTbl tbl = FIELD_TO_LOCTBL_ACCESS2(KMPP_OBJ_IMPL_TYPE, f1, f2, ftype); \
kmpp_objdef_add_entry(KMPP_OBJ_IMPL_DEF, #f1":"#f2, &tbl); \
} while (0);
#else
#define FIELD_TO_LOCTBL_FLAG1(f1, ftype, field_flag, flag_value)
#define FIELD_TO_LOCTBL_ACCESS1(f1, ftype)
#define ENTRY_TO_TRIE1(ftype, type, f1)
#define FIELD_TO_LOCTBL_FLAG2(f1, f2, ftype, field_flag, flag_value)
#define FIELD_TO_LOCTBL_ACCESS2(f1, f2, ftype)
#define ENTRY_TO_TRIE2(ftype, type, f1, f2)
#error "use kmpp_obj_helper.h need macro KMPP_OBJ_IMPL_TYPE and KMPP_OBJ_IMPL_DEF as input"
#endif
#undef KMPP_OBJ_HERLPER_EXIST

26
mpp/base/inc/kmpp_obj_impl.h Normal file
View file

@ -0,0 +1,26 @@
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/*
* Copyright (c) 2024 Rockchip Electronics Co., Ltd.
*/
#ifndef __KMPP_OBJ_IMPL_H__
#define __KMPP_OBJ_IMPL_H__
#include "kmpp_obj.h"
rk_s32 kmpp_obj_impl_set_s32(KmppLocTbl *tbl, void *entry, rk_s32 val);
rk_s32 kmpp_obj_impl_get_s32(KmppLocTbl *tbl, void *entry, rk_s32 *val);
rk_s32 kmpp_obj_impl_set_u32(KmppLocTbl *tbl, void *entry, rk_u32 val);
rk_s32 kmpp_obj_impl_get_u32(KmppLocTbl *tbl, void *entry, rk_u32 *val);
rk_s32 kmpp_obj_impl_set_s64(KmppLocTbl *tbl, void *entry, rk_s64 val);
rk_s32 kmpp_obj_impl_get_s64(KmppLocTbl *tbl, void *entry, rk_s64 *val);
rk_s32 kmpp_obj_impl_set_u64(KmppLocTbl *tbl, void *entry, rk_u64 val);
rk_s32 kmpp_obj_impl_get_u64(KmppLocTbl *tbl, void *entry, rk_u64 *val);
rk_s32 kmpp_obj_impl_set_ptr(KmppLocTbl *tbl, void *entry, void *val);
rk_s32 kmpp_obj_impl_get_ptr(KmppLocTbl *tbl, void *entry, void **val);
rk_s32 kmpp_obj_impl_set_fp(KmppLocTbl *tbl, void *entry, void *val);
rk_s32 kmpp_obj_impl_get_fp(KmppLocTbl *tbl, void *entry, void **val);
rk_s32 kmpp_obj_impl_set_st(KmppLocTbl *tbl, void *entry, void *val);
rk_s32 kmpp_obj_impl_get_st(KmppLocTbl *tbl, void *entry, void *val);
#endif /* __KMPP_OBJ_IMPL_H__ */

669
mpp/base/kmpp_obj.c Normal file
View file

@ -0,0 +1,669 @@
/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/*
* Copyright (c) 2024 Rockchip Electronics Co., Ltd.
*/
#define MODULE_TAG "kmpp_obj"
#include <string.h>
#include <sys/ioctl.h>
#include "mpp_list.h"
#include "mpp_mem.h"
#include "mpp_debug.h"
#include "mpp_common.h"
#include "mpp_trie.h"
#include "kmpp_obj_impl.h"
#define KMPP_SHM_IOC_MAGIC 'm'
#define KMPP_SHM_IOC_QUERY_INFO _IOW(KMPP_SHM_IOC_MAGIC, 1, unsigned int)
#define KMPP_SHM_IOC_GET_SHM _IOW(KMPP_SHM_IOC_MAGIC, 2, unsigned int)
#define KMPP_SHM_IOC_PUT_SHM _IOW(KMPP_SHM_IOC_MAGIC, 3, unsigned int)
#define KMPP_SHM_IOC_DUMP _IOW(KMPP_SHM_IOC_MAGIC, 4, unsigned int)
#define MPP_OBJ_DBG_SET (0x00000001)
#define MPP_OBJ_DBG_GET (0x00000002)
#define kmpp_obj_dbg(flag, fmt, ...) _mpp_dbg(kmpp_obj_debug, flag, fmt, ## __VA_ARGS__)
#define kmpp_obj_dbg_set(fmt, ...) kmpp_obj_dbg(MPP_OBJ_DBG_SET, fmt, ## __VA_ARGS__)
#define kmpp_obj_dbg_get(fmt, ...) kmpp_obj_dbg(MPP_OBJ_DBG_GET, fmt, ## __VA_ARGS__)
#define ENTRY_TO_PTR(tbl, entry) ((char *)entry + tbl->data_offset)
#define ENTRY_TO_s32_PTR(tbl, entry) ((rk_s32 *)ENTRY_TO_PTR(tbl, entry))
#define ENTRY_TO_u32_PTR(tbl, entry) ((rk_u32 *)ENTRY_TO_PTR(tbl, entry))
#define ENTRY_TO_s64_PTR(tbl, entry) ((rk_s64 *)ENTRY_TO_PTR(tbl, entry))
#define ENTRY_TO_u64_PTR(tbl, entry) ((rk_u64 *)ENTRY_TO_PTR(tbl, entry))
#define ENTRY_TO_ptr_PTR(tbl, entry) ((void **)ENTRY_TO_PTR(tbl, entry))
#define ENTRY_TO_fp_PTR(tbl, entry) ((void **)ENTRY_TO_PTR(tbl, entry))
#define ENTRY_TO_FLAG_PTR(tbl, entry) ((rk_u16 *)((char *)entry + tbl->flag_offset))
typedef struct KmppObjDefImpl_t {
struct list_head list;
rk_s32 ref_cnt;
rk_s32 entry_size;
MppTrie trie;
rk_s32 obj_fd;
KmppObjDump dump;
const char *name_check; /* for object name address check */
char *name;
} KmppObjDefImpl;
typedef struct KmppObjImpl_t {
const char *name_check;
/* class infomation link */
KmppObjDefImpl *def;
/* trie for fast access */
MppTrie trie;
/* malloc flag */
rk_u32 need_free;
KmppObjShm *shm;
void *entry;
} KmppObjImpl;
//static rk_u32 kmpp_obj_debug = MPP_OBJ_DBG_SET | MPP_OBJ_DBG_GET;
static rk_u32 kmpp_obj_debug = 0;
static LIST_HEAD(kmpp_obj_list);
const char *strof_entry_type(EntryType type)
{
static const char *entry_type_names[] = {
"rk_s32",
"rk_u32",
"rk_s64",
"rk_u64",
"void *",
"struct",
};
return entry_type_names[type];
}
#define MPP_OBJ_ACCESS_IMPL(type, base_type, log_str) \
rk_s32 kmpp_obj_impl_set_##type(KmppLocTbl *tbl, void *entry, base_type val) \
{ \
base_type *dst = ENTRY_TO_##type##_PTR(tbl, entry); \
base_type old = dst[0]; \
dst[0] = val; \
if (!tbl->flag_type) { \
kmpp_obj_dbg_set("%p + %x set " #type " change " #log_str " -> " #log_str "\n", entry, tbl->data_offset, old, val); \
} else { \
if (old != val) { \
kmpp_obj_dbg_set("%p + %x set " #type " update " #log_str " -> " #log_str " flag %d|%x\n", \
entry, tbl->data_offset, old, val, tbl->flag_offset, tbl->flag_value); \
ENTRY_TO_FLAG_PTR(tbl, entry)[0] |= tbl->flag_value; \
} else { \
kmpp_obj_dbg_set("%p + %x set " #type " keep " #log_str "\n", entry, tbl->data_offset, old); \
} \
} \
return MPP_OK; \
} \
rk_s32 kmpp_obj_impl_get_##type(KmppLocTbl *tbl, void *entry, base_type *val) \
{ \
if (tbl && tbl->data_size) { \
base_type *src = ENTRY_TO_##type##_PTR(tbl, entry); \
kmpp_obj_dbg_get("%p + %x get " #type " value " #log_str "\n", entry, tbl->data_offset, src[0]); \
val[0] = src[0]; \
return MPP_OK; \
} \
return MPP_NOK; \
}
MPP_OBJ_ACCESS_IMPL(s32, rk_s32, % d)
MPP_OBJ_ACCESS_IMPL(u32, rk_u32, % u)
MPP_OBJ_ACCESS_IMPL(s64, rk_s64, % llx)
MPP_OBJ_ACCESS_IMPL(u64, rk_u64, % llx)
MPP_OBJ_ACCESS_IMPL(ptr, void *, % p)
MPP_OBJ_ACCESS_IMPL(fp, void *, % p)
rk_s32 kmpp_obj_impl_set_st(KmppLocTbl *tbl, void *entry, void *val)
{
char *dst = ENTRY_TO_PTR(tbl, entry);
if (!tbl->flag_type) {
/* simple copy */
kmpp_obj_dbg_set("%p + %x set struct change %p -> %p\n", entry, tbl->data_offset, dst, val);
memcpy(dst, val, tbl->data_size);
return MPP_OK;
}
/* copy with flag check and updata */
if (memcmp(dst, val, tbl->data_size)) {
kmpp_obj_dbg_set("%p + %x set struct update %p -> %p flag %d|%x\n",
entry, tbl->data_offset, dst, val, tbl->flag_offset, tbl->flag_value);
memcpy(dst, val, tbl->data_size);
ENTRY_TO_FLAG_PTR(tbl, entry)[0] |= tbl->flag_value;
} else {
kmpp_obj_dbg_set("%p + %x set struct keep %p\n", entry, tbl->data_offset, dst);
}
return MPP_OK;
}
rk_s32 kmpp_obj_impl_get_st(KmppLocTbl *tbl, void *entry, void *val)
{
if (tbl && tbl->data_size) {
void *src = (void *)ENTRY_TO_PTR(tbl, entry);
kmpp_obj_dbg_get("%p + %d get st from %p\n", entry, tbl->data_offset, src);
memcpy(val, src, tbl->data_size);
return MPP_OK;
}
return MPP_NOK;
}
static void show_entry_tbl_err(KmppLocTbl *tbl, EntryType type, const char *func, const char *name)
{
mpp_loge("%s entry %s expect %s input NOT %s\n", func, name,
strof_entry_type(tbl->data_type), strof_entry_type(type));
}
rk_s32 check_entry_tbl(KmppLocTbl *tbl, const char *name, EntryType type,
const char *func)
{
EntryType entry_type;
rk_s32 entry_size;
rk_s32 ret;
if (!tbl) {
mpp_loge("%s: entry %s is invalid\n", func, name);
return MPP_NOK;
}
entry_type = tbl->data_type;
entry_size = tbl->data_size;
ret = MPP_OK;
switch (type) {
case ENTRY_TYPE_st : {
if (entry_type != type) {
show_entry_tbl_err(tbl, type, func, name);
ret = MPP_NOK;
}
if (entry_size <= 0) {
mpp_loge("%s: entry %s found invalid size %d\n", func, name, entry_size);
ret = MPP_NOK;
}
} break;
case ENTRY_TYPE_ptr :
case ENTRY_TYPE_fp : {
if (entry_type != type) {
show_entry_tbl_err(tbl, type, func, name);
ret = MPP_NOK;
}
} break;
case ENTRY_TYPE_s32 :
case ENTRY_TYPE_u32 : {
if (entry_size != sizeof(rk_s32)) {
show_entry_tbl_err(tbl, type, func, name);
ret = MPP_NOK;
}
} break;
case ENTRY_TYPE_s64 :
case ENTRY_TYPE_u64 : {
if (entry_size != sizeof(rk_s64)) {
show_entry_tbl_err(tbl, type, func, name);
ret = MPP_NOK;
}
} break;
default : {
mpp_loge("%s: entry %s found invalid type %d\n", func, name, type);
ret = MPP_NOK;
} break;
}
return ret;
}
rk_s32 kmpp_objdef_init(KmppObjDef *def, const char *name)
{
KmppObjDefImpl *impl = NULL;
char dev_name[64];
rk_s32 len;
rk_s32 ret = MPP_NOK;
if (!def || !name) {
mpp_loge_f("invalid param def %p name %p\n", def, name);
goto DONE;
}
*def = NULL;
len = MPP_ALIGN(strlen(name) + 1, sizeof(rk_s32));
impl = mpp_calloc_size(KmppObjDefImpl, sizeof(KmppObjDefImpl) + len);
if (!impl) {
mpp_loge_f("malloc contex %d failed\n", sizeof(KmppObjDefImpl) + len);
goto DONE;
}
impl->name_check = name;
impl->name = (char *)(impl + 1);
strncpy(impl->name, name, len);
snprintf(dev_name, sizeof(dev_name) - 1, "/dev/%s", name);
impl->obj_fd = open(dev_name, O_RDWR);
if (impl->obj_fd < 0) {
mpp_loge_f("open %s failed\n", dev_name);
goto DONE;
} else {
KmppObjTrie s;
MppTrieInfo *info = NULL;
void *root = NULL;
RK_S32 obj_size = 0;
ret = ioctl(impl->obj_fd, KMPP_SHM_IOC_QUERY_INFO, &s);
if (ret) {
mpp_err_f("%d ioctl KMPP_SHM_IOC_QUERY_INFO failed\n", impl->obj_fd);
goto DONE;
}
root = (void *)s.trie_root;
info = mpp_trie_get_info_from_root(root, "__size");
obj_size = info ? *(RK_S32 *)mpp_trie_info_ctx(info) : 0;
ret = mpp_trie_init(&impl->trie, name);
if (ret) {
mpp_err_f("class %s init trie failed\n", name);
goto DONE;
}
ret = mpp_trie_import(impl->trie, root);
if (ret) {
mpp_err_f("class %s import trie failed\n", name);
goto DONE;
}
impl->entry_size = obj_size;
}
*def = impl;
INIT_LIST_HEAD(&impl->list);
list_add_tail(&impl->list, &kmpp_obj_list);
impl->ref_cnt++;
ret = MPP_OK;
DONE:
if (ret && impl) {
kmpp_objdef_deinit(impl);
impl = NULL;
}
return ret;
}
rk_s32 kmpp_objdef_get_entry(KmppObjDef def, const char *name, KmppLocTbl **tbl)
{
KmppObjDefImpl *impl = (KmppObjDefImpl *)def;
rk_s32 ret = MPP_NOK;
if (impl->trie) {
MppTrieInfo *info = mpp_trie_get_info(impl->trie, name);
if (info) {
*tbl = (KmppLocTbl *)mpp_trie_info_ctx(info);
ret = MPP_OK;
}
}
if (ret)
mpp_loge_f("class %s get entry %s failed ret %d\n",
impl ? impl->name : NULL, name, ret);
return ret;
}
rk_s32 kmpp_objdef_add_dump(KmppObjDef def, KmppObjDump dump)
{
if (def) {
KmppObjDefImpl *impl = (KmppObjDefImpl *)def;
impl->dump = dump;
return MPP_OK;
}
return MPP_NOK;
}
rk_s32 kmpp_objdef_deinit(KmppObjDef def)
{
KmppObjDefImpl *impl = (KmppObjDefImpl *)def;
rk_s32 ret = MPP_NOK;
if (impl) {
impl->ref_cnt--;
if (!impl->ref_cnt) {
if (impl->trie) {
ret = mpp_trie_deinit(impl->trie);
impl->trie = NULL;
}
list_del_init(&impl->list);
if (impl->obj_fd > 0) {
close(impl->obj_fd);
impl->obj_fd = -1;
}
mpp_free(impl);
}
ret = MPP_OK;
}
return ret;
}
const char *kmpp_objdef_get_name(KmppObjDef def)
{
KmppObjDefImpl *impl = (KmppObjDefImpl *)def;
return impl ? impl->name : NULL;
}
rk_s32 kmpp_objdef_get_entry_size(KmppObjDef def)
{
KmppObjDefImpl *impl = (KmppObjDefImpl *)def;
return impl ? impl->entry_size : 0;
}
MppTrie kmpp_objdef_get_trie(KmppObjDef def)
{
KmppObjDefImpl *impl = (KmppObjDefImpl *)def;
return impl ? impl->trie : NULL;
}
rk_u32 kmpp_objdef_lookup(KmppObjDef *def, const char *name)
{
KmppObjDefImpl *impl = NULL;
KmppObjDefImpl *n = NULL;
list_for_each_entry_safe(impl, n, &kmpp_obj_list, KmppObjDefImpl, list) {
if (strcmp(impl->name, name) == 0) {
impl->ref_cnt++;
*def = impl;
return MPP_OK;
}
}
*def = NULL;
return MPP_NOK;
}
rk_s32 kmpp_obj_get(KmppObj *obj, KmppObjDef def)
{
KmppObjImpl *impl;
KmppObjDefImpl *def_impl;
KmppObjShm *shm = NULL;
rk_s32 ret = MPP_NOK;
if (!obj || !def) {
mpp_loge_f("invalid param obj %p def %p\n", obj, def);
return ret;
}
*obj = NULL;
def_impl = (KmppObjDefImpl *)def;
impl = mpp_calloc(KmppObjImpl, 1);
if (!impl) {
mpp_loge_f("malloc obj impl %d failed\n", sizeof(KmppObjImpl));
return ret;
}
ret = ioctl(def_impl->obj_fd, KMPP_SHM_IOC_GET_SHM, &shm);
if (ret) {
mpp_err("%s fd %d ioctl KMPP_SHM_IOC_GET_SHM failed\n",
def_impl->name, def_impl->obj_fd);
mpp_free(impl);
return ret;
}
impl->name_check = def_impl->name_check;
impl->def = def;
impl->trie = def_impl->trie;
impl->need_free = 1;
impl->shm = shm;
impl->entry = (void *)shm->kobj_uaddr;
*obj = impl;
return MPP_OK;
}
rk_s32 kmpp_obj_put(KmppObj obj)
{
if (obj) {
KmppObjImpl *impl = (KmppObjImpl *)obj;
KmppObjDefImpl *def = impl->def;
if (impl->shm) {
rk_s32 ret = ioctl(def->obj_fd, KMPP_SHM_IOC_PUT_SHM, impl->shm);
if (ret)
mpp_err("ioctl KMPP_SHM_IOC_PUT_SHM failed ret %d\n", ret);
impl->shm = NULL;
}
if (impl->need_free)
mpp_free(impl);
return MPP_OK;
}
return MPP_NOK;
}
rk_s32 kmpp_obj_check(KmppObj obj, const char *caller)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
if (!impl) {
mpp_loge_f("from %s failed for NULL arg\n", caller);
return MPP_NOK;
}
if (!impl->name_check || !impl->def ||
impl->name_check != impl->def->name_check) {
mpp_loge_f("from %s failed for name check %s but %s\n", caller,
impl->def ? impl->def->name_check : NULL, impl->name_check);
return MPP_NOK;
}
return MPP_OK;
}
void *kmpp_obj_get_entry(KmppObj obj)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
return impl ? impl->entry : NULL;
}
#define MPP_OBJ_ACCESS(type, base_type) \
rk_s32 kmpp_obj_set_##type(KmppObj obj, const char *name, base_type val) \
{ \
KmppObjImpl *impl = (KmppObjImpl *)obj; \
rk_s32 ret = MPP_NOK; \
if (impl->trie) { \
MppTrieInfo *info = mpp_trie_get_info(impl->trie, name); \
if (info) { \
KmppLocTbl *tbl = (KmppLocTbl *)mpp_trie_info_ctx(info); \
ret = kmpp_obj_impl_set_##type(tbl, impl->entry, val); \
} \
} \
if (ret) \
mpp_loge("obj %s set %s " #type " failed ret %d\n", \
impl ? impl->def ? impl->def->name : NULL : NULL, name, ret); \
return MPP_NOK; \
} \
rk_s32 kmpp_obj_get_##type(KmppObj obj, const char *name, base_type *val) \
{ \
KmppObjImpl *impl = (KmppObjImpl *)obj; \
rk_s32 ret = MPP_NOK; \
if (impl->trie) { \
MppTrieInfo *info = mpp_trie_get_info(impl->trie, name); \
if (info) { \
KmppLocTbl *tbl = (KmppLocTbl *)mpp_trie_info_ctx(info); \
ret = kmpp_obj_impl_get_##type(tbl, impl->entry, val); \
} \
} \
if (ret) \
mpp_loge("obj %s get %s " #type " failed ret %d\n", \
impl ? impl->def ? impl->def->name : NULL : NULL, name, ret); \
return MPP_NOK; \
}
MPP_OBJ_ACCESS(s32, rk_s32)
MPP_OBJ_ACCESS(u32, rk_u32)
MPP_OBJ_ACCESS(s64, rk_s64)
MPP_OBJ_ACCESS(u64, rk_u64)
MPP_OBJ_ACCESS(ptr, void *)
MPP_OBJ_ACCESS(fp, void *)
rk_s32 kmpp_obj_set_st(KmppObj obj, const char *name, void *val)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
rk_s32 ret = MPP_NOK;
if (impl->trie) {
MppTrieInfo *info = mpp_trie_get_info(impl->trie, name);
if (info) {
KmppLocTbl *tbl = (KmppLocTbl *)mpp_trie_info_ctx(info);
ret = kmpp_obj_impl_set_st(tbl, impl->entry, val);
}
}
if (ret)
mpp_loge("obj %s set %s st failed ret %d\n",
impl ? impl->def ? impl->def->name : NULL : NULL, name, ret);
return MPP_NOK;
}
rk_s32 kmpp_obj_get_st(KmppObj obj, const char *name, void *val)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
rk_s32 ret = MPP_NOK;
if (impl->trie) {
MppTrieInfo *info = mpp_trie_get_info(impl->trie, name);
if (info) {
KmppLocTbl *tbl = (KmppLocTbl *)mpp_trie_info_ctx(info);
ret = kmpp_obj_impl_get_st(tbl, impl->entry, val);
}
}
if (ret)
mpp_loge("obj %s get %s st failed ret %d\n",
impl ? impl->def ? impl->def->name : NULL : NULL, name, ret);
return MPP_NOK;
}
#define MPP_OBJ_TBL_ACCESS(type, base_type) \
rk_s32 kmpp_obj_tbl_set_##type(KmppObj obj, KmppLocTbl *tbl, base_type val) \
{ \
KmppObjImpl *impl = (KmppObjImpl *)obj; \
rk_s32 ret = MPP_NOK; \
if (impl) \
ret = kmpp_obj_impl_set_##type(tbl, impl->entry, val); \
if (ret) \
mpp_loge("obj %s tbl %08x set " #type " failed ret %d\n", \
impl ? impl->def ? impl->def->name : NULL : NULL, tbl ? tbl->val : 0, ret); \
return MPP_NOK; \
} \
rk_s32 kmpp_obj_tbl_get_##type(KmppObj obj, KmppLocTbl *tbl, base_type *val) \
{ \
KmppObjImpl *impl = (KmppObjImpl *)obj; \
rk_s32 ret = MPP_NOK; \
if (impl) \
ret = kmpp_obj_impl_get_##type(tbl, impl->entry, val); \
if (ret) \
mpp_loge("obj %s tbl %08x get " #type " failed ret %d\n", \
impl ? impl->def ? impl->def->name : NULL : NULL, tbl ? tbl->val : 0, ret); \
return MPP_NOK; \
}
MPP_OBJ_TBL_ACCESS(s32, rk_s32)
MPP_OBJ_TBL_ACCESS(u32, rk_u32)
MPP_OBJ_TBL_ACCESS(s64, rk_s64)
MPP_OBJ_TBL_ACCESS(u64, rk_u64)
MPP_OBJ_TBL_ACCESS(ptr, void *)
MPP_OBJ_TBL_ACCESS(fp, void *)
rk_s32 kmpp_obj_tbl_set_st(KmppObj obj, KmppLocTbl *tbl, void *val)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
rk_s32 ret = MPP_NOK;
if (impl)
ret = kmpp_obj_impl_set_st(tbl, impl->entry, val);
if (ret)
mpp_loge("obj %s tbl %08x set %s st failed ret %d\n",
impl ? impl->def ? impl->def->name : NULL : NULL, tbl ? tbl->val : 0, ret);
return MPP_NOK;
}
rk_s32 kmpp_obj_tbl_get_st(KmppObj obj, KmppLocTbl *tbl, void *val)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
rk_s32 ret = MPP_NOK;
if (impl)
ret = kmpp_obj_impl_get_st(tbl, impl->entry, val);
if (ret)
mpp_loge("obj %s tbl %08x get %s st failed ret %d\n",
impl ? impl->def ? impl->def->name : NULL : NULL, tbl ? tbl->val : 0, ret);
return MPP_NOK;
}
static rk_s32 kmpp_obj_impl_run(rk_s32 (*run)(void *ctx), void *ctx)
{
return run(ctx);
}
rk_s32 kmpp_obj_run(KmppObj obj, const char *name)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
rk_s32 ret = MPP_NOK;
if (impl->trie) {
MppTrieInfo *info = mpp_trie_get_info(impl->trie, name);
void *val = NULL;
if (info) {
KmppLocTbl *tbl = (KmppLocTbl *)mpp_trie_info_ctx(info);
ret = kmpp_obj_impl_get_fp(tbl, impl->entry, &val);
}
if (val)
ret = kmpp_obj_impl_run(val, impl->entry);
}
return ret;
}
rk_s32 kmpp_obj_dump(KmppObj obj, const char *caller)
{
KmppObjImpl *impl = (KmppObjImpl *)obj;
if (impl && impl->def && impl->def->dump) {
mpp_logi_f("%s obj %p entry %p from %s\n",
impl->def->name, impl, impl->entry, caller);
return impl->def->dump(impl);
}
return MPP_NOK;
}