GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)

source/gmp/usr/ext/Makefile

@@ -0,0 +1,15 @@
+SDK_DIR ?= $(shell cd $(CURDIR)/../../../.. && /bin/pwd)
+
+include $(SDK_DIR)/build/base.mk
+
+.PHONY: all clean
+all: msensor
+clean: msensor_clean
+
+
+.PHONY: msensor msensor_clean
+msensor:
+	$(AT)$(MAKE) -C msensor
+msensor_clean:
+	$(AT)$(MAKE) -C msensor clean
+

source/gmp/usr/ext/msensor/Makefile

@@ -0,0 +1,19 @@
+SDK_DIR ?= $(shell cd $(CURDIR)/../../../../.. && /bin/pwd)
+$(warning SDK_DIR=$(SDK_DIR))
+include $(SDK_DIR)/build/base.mk
+
+LIB_NAME := libxmedia_msensor
+
+SRCS := xmedia_msensor.c
+
+SDK_USR_CFLAGS += -I$(GMP_DIR)/include
+SDK_USR_CFLAGS += -I$(GMP_DIR)/usr/include
+SDK_USR_CFLAGS += -I$(GMP_DIR)/drv/include
+SDK_USR_CFLAGS += -I$(GMP_DIR)/drv/ext/msensor/include
+SDK_USR_CFLAGS += -I$(GMP_DIR)/drv/ext/msensor/msensor_mng/include
+
+$(info SDK_USR_CFLAGS=$(SDK_USR_CFLAGS))
+$(info SRCS=$(SRCS))
+$(info SDK_DIR=$(SDK_DIR))
+
+include $(SDK_DIR)/build/sdk_lib_rules.mk

source/gmp/usr/ext/msensor/xmedia_msensor.c

@@ -0,0 +1,298 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/prctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "xmedia_debug.h"
+#include "xmedia_msensor.h"
+#include "msensor_chip_ioctl.h"
+#include "msensor_mng_ioctl.h"
+
+#define MSENSOR_CHIP_NAME   "/dev/msensor_chip"
+#define MSENSOR_MNG_NAME    "/dev/msensor_mng"
+
+static xmedia_bool g_msensor_tgid_init = XMEDIA_FALSE;
+static xmedia_s32 g_msensor_chip_fd[XMEDIA_MSENSOR_MAX_DEV_NUM] = { [0 ...(XMEDIA_MSENSOR_MAX_DEV_NUM - 1)] = -1 };
+static xmedia_s32 g_msensor_mng_fd[XMEDIA_MSENSOR_MAX_DEV_NUM] = { [0 ...(XMEDIA_MSENSOR_MAX_DEV_NUM - 1)] = -1 };
+
+static pthread_mutex_t g_msensor_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+#define MSENSOR_MUTEX_LOCK()                      \
+    do {                                     \
+        (void)pthread_mutex_lock(&g_msensor_mutex); \
+    } while (0)
+
+#define MSENSOR_MUTEX_UNLOCK()                      \
+    do {                                       \
+        (void)pthread_mutex_unlock(&g_msensor_mutex); \
+    } while (0)
+
+#define MSENSOR_TRACE(level, fmt, ...)                                                                                 \
+    do {                                                                                                          \
+        printf("[Func]:%s [Line]:%d [Info]:" fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
+    } while (0)
+
+#define MSENSOR_CHECK_INIT_RETURN()               \
+    do {                                     \
+        MSENSOR_MUTEX_LOCK();                     \
+        if (g_msensor_tgid_init != XMEDIA_TRUE) { \
+            printf("msensor not init!\n");        \
+            MSENSOR_MUTEX_UNLOCK();               \
+            return XMEDIA_ERRCODE_NOT_INIT;  \
+        }                                    \
+        MSENSOR_MUTEX_UNLOCK();                   \
+    } while (0)
+
+static xmedia_s32 msensor_check_dev(xmedia_s32 dev)
+{
+    if ((dev >= XMEDIA_MSENSOR_MAX_DEV_NUM) || (dev < 0)) {
+        MSENSOR_TRACE(MODULE_DBG_ERR, "dev id(%d) is invalid\r\n", dev);
+        return XMEDIA_ERRCODE_INVALID_PIPE_ID;
+    }
+
+    return XMEDIA_SUCCESS;
+}
+
+static xmedia_s32 msensor_check_null_ptr(xmedia_void *ptr)
+{
+    if (ptr == XMEDIA_NULL) {
+        MSENSOR_TRACE(MODULE_DBG_ERR, "null pointer\n");
+        return XMEDIA_ERRCODE_NULL_PTR;
+    }
+
+    return XMEDIA_SUCCESS;
+}
+
+static xmedia_s32 msensor_check_chip_open(xmedia_s32 dev)
+{
+    MSENSOR_MUTEX_LOCK();
+
+    if (g_msensor_chip_fd[dev] < 0) {
+        xmedia_s32 arg = dev;
+        g_msensor_chip_fd[dev] = open(MSENSOR_CHIP_NAME, O_RDONLY);
+        if (g_msensor_chip_fd[dev] < 0) {
+            MSENSOR_MUTEX_UNLOCK();
+            MSENSOR_TRACE(MODULE_DBG_ERR, "open msensor dev %d err, ret %d\n", dev, g_msensor_chip_fd[dev]);
+            return XMEDIA_ERRCODE_NOT_READY;
+        }
+        if (ioctl(g_msensor_chip_fd[dev], MSENSOR_CMD_CHIP_BIND_FLAG2FD, &arg)) {
+            close(g_msensor_chip_fd[dev]);
+            g_msensor_chip_fd[dev] = -1;
+            MSENSOR_MUTEX_UNLOCK();
+            MSENSOR_TRACE(MODULE_DBG_ERR, "msensor dev %d, ret %d\n", dev, g_msensor_chip_fd[dev]);
+            return XMEDIA_ERRCODE_NOT_READY;
+        }
+    }
+    MSENSOR_MUTEX_UNLOCK();
+
+    return XMEDIA_SUCCESS;
+}
+
+static xmedia_s32 msensor_check_mng_open(xmedia_s32 dev)
+{
+    MSENSOR_MUTEX_LOCK();
+
+    if (g_msensor_mng_fd[dev] < 0) {
+        xmedia_s32 arg = dev;
+        g_msensor_mng_fd[dev] = open(MSENSOR_MNG_NAME, O_RDONLY);
+        if (g_msensor_mng_fd[dev] < 0) {
+            MSENSOR_MUTEX_UNLOCK();
+            MSENSOR_TRACE(MODULE_DBG_ERR, "open msensor dev %d err, ret %d\n", dev, g_msensor_mng_fd[dev]);
+            return XMEDIA_ERRCODE_NOT_READY;
+        }
+        if (ioctl(g_msensor_mng_fd[dev], MSENSOR_CMD_MNG_BIND_FLAG2FD, &arg)) {
+            close(g_msensor_mng_fd[dev]);
+            g_msensor_mng_fd[dev] = -1;
+            MSENSOR_MUTEX_UNLOCK();
+            MSENSOR_TRACE(MODULE_DBG_ERR, "msensor dev %d, ret %d\n", dev, g_msensor_mng_fd[dev]);
+            return XMEDIA_ERRCODE_NOT_READY;
+        }
+    }
+    MSENSOR_MUTEX_UNLOCK();
+
+    return XMEDIA_SUCCESS;
+}
+
+#define MSENSOR_CHECK_NULL_PTR_RETURN(ptr)                             \
+    do {                                                          \
+        xmedia_s32 ret = msensor_check_null_ptr((xmedia_void *)(ptr)); \
+        if (ret != XMEDIA_SUCCESS) {                              \
+            return ret;                                           \
+        }                                                         \
+    } while (0)
+
+
+#define MSENSOR_CHECK_DEV_ID_RETURN(dev)            \
+    do {                                         \
+        xmedia_s32 ret = msensor_check_dev(dev); \
+        if (ret != XMEDIA_SUCCESS) {             \
+            return ret;                          \
+        }                                        \
+    } while (0)
+
+#define MSENSOR_CHECK_CHIP_OPEN_RETURN(dev)            \
+    do {                                         \
+        xmedia_s32 ret = msensor_check_chip_open(dev); \
+        if (ret != XMEDIA_SUCCESS) {             \
+            return ret;                          \
+        }                                        \
+    } while (0)
+
+#define MSENSOR_CHECK_MNG_OPEN_RETURN(dev)            \
+            do {                                         \
+                xmedia_s32 ret = msensor_check_mng_open(dev); \
+                if (ret != XMEDIA_SUCCESS) {             \
+                    return ret;                          \
+                }                                        \
+            } while (0)
+
+xmedia_s32 xmedia_msensor_init(xmedia_void)
+{
+    MSENSOR_MUTEX_LOCK();
+
+    if (g_msensor_tgid_init == XMEDIA_TRUE) {
+        MSENSOR_MUTEX_UNLOCK();
+        return XMEDIA_SUCCESS;
+    }
+
+    g_msensor_tgid_init = XMEDIA_TRUE;
+
+    MSENSOR_MUTEX_UNLOCK();
+    return XMEDIA_SUCCESS;
+}
+
+xmedia_void xmedia_msensor_exit(xmedia_void)
+{
+    xmedia_s32 i;
+
+    MSENSOR_MUTEX_LOCK();
+
+    if (g_msensor_tgid_init == XMEDIA_FALSE) {
+        MSENSOR_MUTEX_UNLOCK();
+        return ;
+    }
+
+    for (i = 0; i < XMEDIA_MSENSOR_MAX_DEV_NUM; i++) {
+        if (g_msensor_mng_fd[i] >= 0) {
+            close(g_msensor_mng_fd[i]);
+            g_msensor_mng_fd[i] = -1;
+        }
+    }
+
+    for (i = 0; i < XMEDIA_MSENSOR_MAX_DEV_NUM; i++) {
+        if (g_msensor_chip_fd[i] >= 0) {
+            close(g_msensor_chip_fd[i]);
+            g_msensor_chip_fd[i] = -1;
+        }
+    }
+
+    g_msensor_tgid_init = XMEDIA_FALSE;
+
+    MSENSOR_MUTEX_UNLOCK();
+    return;
+}
+
+xmedia_s32 xmedia_msensor_create_dev(xmedia_s32 dev, const xmedia_msensor_param *param)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+    MSENSOR_CHECK_NULL_PTR_RETURN(param);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_chip_fd[dev], MSENSOR_CMD_CREATE, param);
+}
+
+xmedia_s32 xmedia_msensor_destroy_dev(xmedia_s32 dev)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_chip_fd[dev], MSENSOR_CMD_DESTROY);
+}
+
+xmedia_s32 xmedia_msensor_get_param(xmedia_s32 dev, xmedia_msensor_param *param)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+    MSENSOR_CHECK_NULL_PTR_RETURN(param);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_chip_fd[dev], MSENSOR_CMD_GET_PARAM, param);
+}
+
+xmedia_s32 xmedia_msensor_start_dev(xmedia_s32 dev)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_chip_fd[dev], MSENSOR_CMD_START);
+}
+
+xmedia_s32 xmedia_msensor_stop_dev(xmedia_s32 dev)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_chip_fd[dev], MSENSOR_CMD_STOP);
+}
+
+xmedia_s32 xmedia_msensor_add_user(xmedia_s32 dev, xmedia_s32 *user_id)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+    MSENSOR_CHECK_MNG_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_mng_fd[dev], MSENSOR_CMD_ADD_USER, user_id);
+}
+
+xmedia_s32 xmedia_msensor_delete_user(xmedia_s32 dev, xmedia_s32 user_id)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+    MSENSOR_CHECK_MNG_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_mng_fd[dev], MSENSOR_CMD_DELETE_USER, &user_id);
+}
+
+xmedia_s32 xmedia_msensor_get_data(xmedia_s32 dev, xmedia_msensor_data_info *data)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+    MSENSOR_CHECK_NULL_PTR_RETURN(data);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+    MSENSOR_CHECK_MNG_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_mng_fd[dev], MSENSOR_CMD_GET_DATA, data);
+}
+
+xmedia_s32 xmedia_msensor_send_data(xmedia_s32 dev, const xmedia_msensor_data_info *data)
+{
+    MSENSOR_CHECK_DEV_ID_RETURN(dev);
+    MSENSOR_CHECK_NULL_PTR_RETURN(data);
+
+    MSENSOR_CHECK_INIT_RETURN();
+    MSENSOR_CHECK_CHIP_OPEN_RETURN(dev);
+    MSENSOR_CHECK_MNG_OPEN_RETURN(dev);
+
+    return ioctl(g_msensor_mng_fd[dev], MSENSOR_CMD_SEND_DATA, data);
+}
+