Major cleanup: rework for miscdevice kernel interface

This removes all support for the uio-based interface from libvmeta,
replacing it with the new miscdevice interface code.  This represents
a substantial cleanup of this code.

2 files changed, 232 insertions, 800 deletions

diff --git a/vmeta_lib.c b/vmeta_lib.c
index 38b0139..8d5bb96 100644
--- a/vmeta_lib.c
+++ b/vmeta_lib.c
@@ -21,70 +21,66 @@
  */
 
 #include <sys/mman.h>
-#include <sys/stat.h>
 #include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdarg.h>
 #include <string.h>
 #include <time.h>
-#include <errno.h>
+#include <unistd.h>
 #include <pthread.h>
 
 #include "vmeta_lib.h"
 #include "bmm_lib.h"
-#include "sys/poll.h"
+#include "uio_vmeta.h"
 
 #define ALIGN(x,a)		__ALIGN_MASK(x,(typeof(x))(a)-1)
 #define __ALIGN_MASK(x,mask)	(((x)+(mask))&~(mask))
 
-// these APIs are used for vmeta driver only, not for export purpose.
-#define VMETA_PRIVATE_LOCK_HANDLE "vmeta_private_lock"
+#define VDEC_DEBUG_ALL		0x1
+#define VDEC_DEBUG_MEM		0x2
+#define VDEC_DEBUG_LOCK		0x4
+#define VDEC_DEBUG_VER		0x8
+#define VDEC_DEBUG_NONE		0x0
 
-static SIGN32 vmeta_private_lock();
-static SIGN32 vmeta_private_unlock();
-static SIGN32 vdec_os_api_get_ks(kernel_share **pp_ks);//get kernel shared resources
+#define MAP_IO_MEM		0
+#define MAP_IO_HW_CONTEXT	1
+#define MAP_IO_VMETA_OBJ	2
 
-// global variable
-static vdec_os_driver_cb_t *vdec_iface = NULL;
-static UNSG32 globalDbgLevel = VDEC_DEBUG_NONE;
-static UNSG32 syncTimeout = 500;
-static pthread_mutex_t pmt = PTHREAD_MUTEX_INITIALIZER;
-
-static inline int get_bit(int nr, unsigned int *addr)
-{
-	unsigned int mask = 1 << nr;
-
-	return ((*addr) & mask) != 0;
-}
+#define VMETA_KERN_MIN_VER	104
+#define VMETA_USER_VER		"build-004"
 
-static inline int set_bit(int nr, unsigned int *addr)
-{
-	unsigned int mask = 1 << nr;
-	unsigned int old;
+// debug message
+#define VMETA_LOG_ON		0
+#define VMETA_LOG_FILE		"/data/vmeta_dbg.log"
 
-	old = *addr;
-	*addr = old | mask;
+static void dbg_printf(UNSG32 dbglevel, const char *format, ...);
 
-	return (old & mask) != 0;
-}
-  
-static inline int clear_bit(int nr, unsigned int *addr)
-{
-	unsigned int mask = 1 << nr;
-	unsigned int old;
+// our private data structure
+typedef struct vdec_os_driver_cb_s {
+	int fd;			// kernel file descriptor
+	int refcount;		// reference count in current process
+	int kern_ver;		// vmeta kernel version
+	struct {
+		UNSG32 phys;
+		UNSG32 size;
+	} map[3];
 
-	old = *addr;
-	*addr = old & ~mask;
-
-	return (old & mask) != 0;
-}
+	void *regs;		// the vmeta registers
+	void *vdec_obj_va;
+	UNSG32 vdec_obj_size;
+} vdec_os_driver_cb_t;
 
+// global variable
+static vdec_os_driver_cb_t *vdec_iface = NULL;
+static UNSG32 globalDbgLevel = VDEC_DEBUG_NONE;
+static UNSG32 syncTimeout = 500;
+static pthread_mutex_t pmt = PTHREAD_MUTEX_INITIALIZER;
 
-//Add for hal mmap
 UNSG8 vdec_os_api_rd8(UNSG32 addr)
 {
 	return *((volatile UNSG8*)addr);
@@ -117,10 +113,9 @@ void vdec_os_api_wr32(UNSG32 addr, UNSG32 data)
 
 UNSG32 vdec_os_api_get_regbase_addr(void)
 {
-	vdec_os_driver_cb_t *vdec_iface = vdec_driver_get_cb();
-	return (UNSG32) vdec_iface->io_mem_virt_addr;
+	vdec_os_driver_cb_t *vdec = vdec_iface;
+	return (UNSG32) vdec->regs;
 }
-//End of hal mmap
 
 //Mem map to bmm_lib
 UNSG32 vdec_os_api_get_pa(UNSG32 vaddr)
@@ -208,19 +203,19 @@ static void *vmeta_bmm_malloc_aligned(UNSG32 size, UNSG32 align, UNSG32 *phys, i
 	return ptr;
 }
 
-void * vdec_os_api_dma_alloc(UNSG32 size, UNSG32 align, UNSG32 * pPhysical)
+void *vdec_os_api_dma_alloc(UNSG32 size, UNSG32 align, UNSG32 *phys)
 {
-	return vmeta_bmm_malloc_aligned(size, align, pPhysical, BMM_ATTR_NONCACHED);
+	return vmeta_bmm_malloc_aligned(size, align, phys, BMM_ATTR_NONCACHED);
 }
 
-void * vdec_os_api_dma_alloc_cached(UNSG32 size, UNSG32 align, UNSG32 * pPhysical)
+void *vdec_os_api_dma_alloc_cached(UNSG32 size, UNSG32 align, UNSG32 *phys)
 {
-	return vmeta_bmm_malloc_aligned(size, align, pPhysical, BMM_ATTR_DEFAULT);
+	return vmeta_bmm_malloc_aligned(size, align, phys, BMM_ATTR_DEFAULT);
 }
 
-void * vdec_os_api_dma_alloc_writecombine(UNSG32 size, UNSG32 align, UNSG32 * pPhysical)
+void *vdec_os_api_dma_alloc_writecombine(UNSG32 size, UNSG32 align, UNSG32 *phys)
 {
-	return vmeta_bmm_malloc_aligned(size, align, pPhysical, BMM_ATTR_WRITECOMBINE);
+	return vmeta_bmm_malloc_aligned(size, align, phys, BMM_ATTR_WRITECOMBINE);
 }
 
 UNSG32 vdec_os_api_flush_cache(UNSG32 vaddr, UNSG32 size, enum dma_data_direction direction)
@@ -254,18 +249,44 @@ UNSG32 vdec_os_api_flush_cache(UNSG32 vaddr, UNSG32 size, enum dma_data_directio
 	return 0;
 }
 
+static int vmeta_ioctl(unsigned cmd)
+{
+	vdec_os_driver_cb_t *vdec = vdec_iface;
+
+	if (vdec == NULL) {
+		errno = EBADF;
+		return -1;
+	}
+
+	return ioctl(vdec->fd, cmd);
+}
+
+static int vmeta_ioctl_ulong(unsigned cmd, unsigned long arg)
+{
+	vdec_os_driver_cb_t *vdec = vdec_iface;
+
+	if (vdec == NULL) {
+		errno = EBADF;
+		return -1;
+	}
+
+	return ioctl(vdec->fd, cmd, arg);
+}
+
 // enable vmeta interrupt
 void vdec_os_api_irq_enable(void)
 {
+	vdec_os_driver_cb_t *vdec = vdec_iface;
 	int irq_on = 1;
-	write(vdec_iface->fd, &irq_on, sizeof(int));
+	write(vdec->fd, &irq_on, sizeof(int));
 }
 
 // disable vmeta interrupt
 void vdec_os_api_irq_disable(void)
 {
+	vdec_os_driver_cb_t *vdec = vdec_iface;
 	int irq_on = 0;
-	write(vdec_iface->fd, &irq_on, sizeof(int));
+	write(vdec->fd, &irq_on, sizeof(int));
 }
 
 SIGN32 vdec_os_api_set_sync_timeout_isr(UNSG32 timeout)
@@ -276,10 +297,11 @@ SIGN32 vdec_os_api_set_sync_timeout_isr(UNSG32 timeout)
 
 SIGN32 vdec_os_api_sync_event()
 {
+	vdec_os_driver_cb_t *vdec = vdec_iface;
 	struct pollfd ufds;
 	int result = 0;
 
-	ufds.fd = vdec_iface->fd;
+	ufds.fd = vdec->fd;
 	ufds.events = POLLIN;
 
 	vdec_os_api_irq_enable();
@@ -289,80 +311,13 @@ SIGN32 vdec_os_api_sync_event()
 	else
 		return -VDEC_OS_DRIVER_SYNC_TIMEOUT_FAIL;
 }
-//End of mem mmap
-#define VMETA_VERSION_PREFIX "build-"
-
-static int get_version(const char *filename)
-{
-	int ret;
-	int version;
-
-	FILE *file = fopen(filename, "r");
-
-	if(!file) {
-		dbg_printf(VDEC_DEBUG_ALL, "Error: %s -> fopen failed\n", __FUNCTION__);
-		return -1;
-	}
-
-	ret = fscanf(file, VMETA_VERSION_PREFIX"%d", &version);
-	if(ret<0) {
-		dbg_printf(VDEC_DEBUG_ALL, "Error: get_version -> fscanf failed\n");
-		version = -1;
-	}
-
-	fclose(file);
-	return version;
-}
-
-static UNSG32 get_file_unsg32(const char *fmt, ...)
-{
-	char buf[80];
-	va_list ap;
-	FILE *file;
-	UNSG32 result;
-	int ret;
-
-	va_start(ap, fmt);
-	ret = vsnprintf(buf, sizeof(buf), fmt, ap);
-	va_end(ap);
-	if (ret >= sizeof(buf))
-		return -VDEC_OS_DRIVER_OPEN_FAIL;
-
-	file = fopen(buf, "r");
-	if(!file) {
-		dbg_printf(VDEC_DEBUG_ALL, "Error: %s: fopen %s failed\n",
-			   __FUNCTION__, buf);
-		return -VDEC_OS_DRIVER_OPEN_FAIL;
-	}
-
-	ret = fscanf(file, "0x%x", &result);
-	if (ret != 1) {
-		dbg_printf(VDEC_DEBUG_ALL, "Error: %s: fscanf %s failed\n",
-			   __FUNCTION__, buf);
-		result = 0;
-	}
-
-	fclose(file);
-	return result;
-}
 
-static int uio_get_map(unsigned uio_num, unsigned map, unsigned size, void **rptr, unsigned *rsize, UNSG32 *rphys)
+static int vmeta_get_map(vdec_os_driver_cb_t *vdec, unsigned map, unsigned size, void **rptr, unsigned *rsize)
 {
-	vdec_os_driver_cb_t *vdec = vdec_iface;
-	UNSG32 phys;
 	UNSG32 map_size;
 	void *addr;
 
-	if (vdec->uio) {
-		map_size = get_file_unsg32("/sys/class/uio/uio%u/maps/map%u/size",
-					   uio_num, map);
-	} else {
-		map_size = vdec->map[map].size;
-	}
-
-	if (map_size == (UNSG32)-VDEC_OS_DRIVER_OPEN_FAIL)
-		return -VDEC_OS_DRIVER_OPEN_FAIL;
-
+	map_size = vdec->map[map].size;
 	if (map_size == 0)
 		return -VDEC_OS_DRIVER_MMAP_FAIL;
 
@@ -375,35 +330,18 @@ static int uio_get_map(unsigned uio_num, unsigned map, unsigned size, void **rpt
 	if (rsize)
 		*rsize = map_size;
 
-	if (rphys) {
-		if (vdec->uio) {
-			phys = get_file_unsg32("/sys/class/uio/uio%u/maps/map%u/addr",
-						uio_num, map);
-		} else {
-			phys = vdec->map[map].phys;
-		}
-		if (phys == (UNSG32)-VDEC_OS_DRIVER_OPEN_FAIL)
-			return -VDEC_OS_DRIVER_OPEN_FAIL;
-		if (phys == 0)
-			return -VDEC_OS_DRIVER_MMAP_FAIL;
+	if (size == 0)
+		size = map_size;
 
-		*rphys = phys;
+	addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
+		    vdec->fd, map * getpagesize());
+	if (addr == MAP_FAILED) {
+		dbg_printf(VDEC_DEBUG_MEM, "Error: %s: mmap of map %u failed: %s\n",
+			   __FUNCTION__, map, strerror(errno));
+		return -VDEC_OS_DRIVER_MMAP_FAIL;
 	}
 
-	if (rptr) {
-		if (size == 0)
-			size = map_size;
-
-		addr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED,
-			    vdec->fd, map * getpagesize());
-		if (addr == MAP_FAILED) {
-			dbg_printf(VDEC_DEBUG_MEM, "Error: %s: mmap of map %u failed: %d\n",
-				   __FUNCTION__, map, errno);
-			return -VDEC_OS_DRIVER_MMAP_FAIL;
-		}
-
-		*rptr = addr;
-	}
+	*rptr = addr;
 
 	return VDEC_OS_DRIVER_OK;
 }
@@ -411,112 +349,93 @@ static int uio_get_map(unsigned uio_num, unsigned map, unsigned size, void **rpt
 // init vdec os driver
 SIGN32 vdec_os_driver_init(void)
 {
+	vdec_os_driver_cb_t *vdec;
+	struct vmeta_info info;
 	unsigned size;
 	void *addr;
-	UNSG32 phys;
-	int ret = 0;
+	int i, ret;
 
 #if VMETA_LOG_ON
 	FILE *fp_log;
 #endif
 
 	pthread_mutex_lock(&pmt);
-	if(vdec_iface != NULL) {	// already been initiated in this process
+	if (vdec_iface != NULL) {
+		// already been initiated in this process
 		vdec_iface->refcount++;
 		pthread_mutex_unlock(&pmt);
-		return ret;
+		return VDEC_OS_DRIVER_OK;
 	}
 
 #if (VMETA_LOG_ON && 0)
-
 	fp_log = fopen(VMETA_LOG_FILE,"w");
 	if(fp_log == NULL) {
 		pthread_mutex_unlock(&pmt);
 		return -1;
 	}
 	fclose(fp_log);
-
 #endif
 
 	// Prepare the vdec os driver control interface
-	vdec_iface = malloc(sizeof(vdec_os_driver_cb_t));
-	if(vdec_iface == NULL) {
+	vdec = malloc(sizeof(vdec_os_driver_cb_t));
+	if (vdec == NULL) {
 		pthread_mutex_unlock(&pmt);
 		return -VDEC_OS_DRIVER_INIT_FAIL;
 	}
-	memset(vdec_iface, 0, sizeof(vdec_os_driver_cb_t));
+	memset(vdec, 0, sizeof(*vdec));
 
 	// initialize reference count
-	vdec_iface->refcount++;
+	vdec->refcount++;
 
 	// Try to open the (new) vmeta device
-	vdec_iface->fd = open("/dev/vmeta", O_RDWR);
-	if (vdec_iface->fd == -1) {
-		if (errno == ENOENT || errno == ENODEV) {
-			// Try the older uio vmeta driver
-			vdec_iface->fd = open(UIO_DEV, O_RDWR);
-			if(vdec_iface->fd < 0) {
-				ret = -VDEC_OS_DRIVER_OPEN_FAIL;
-				goto err_open_fail;
-			}
-			vdec_iface->uio = 1;
-
-			dbg_printf(VDEC_DEBUG_ALL, "%s: using UIO fd=%d\n",
-				__FUNCTION__, vdec_iface->fd);
-
-			vdec_iface->kern_ver = get_version(UIO_IO_VERSION);
-		}
-	} else {
-		struct vmeta_info info;
-		int i;
-info.revision = 1;
-		ret = ioctl(vdec_iface->fd, VMETA_CMD_GET_INFO, &info);
-		if (ret == -1) {
-			dbg_printf(VDEC_DEBUG_ALL, "%s: unable to get info: %s\n",
-				   __FUNCTION__, strerror(errno));
-			close(vdec_iface->fd);
-			ret = -VDEC_OS_DRIVER_VER_FAIL;
-			goto err_open_fail;
-		}
-
-		vdec_iface->kern_ver = info.revision;
-
-		for (i = 0; i < 3; i++) {
-			vdec_iface->map[i].phys = info.map[i].phys;
-			vdec_iface->map[i].size = info.map[i].size;
-		}
+	vdec->fd = open("/dev/vmeta", O_RDWR);
+	if (vdec->fd == -1) {
+		ret = -VDEC_OS_DRIVER_OPEN_FAIL;
+		goto err_open_fail;
 	}
 
-	dbg_printf(VDEC_DEBUG_VER, "vdec os driver kern=%d user=%s\n", vdec_iface->kern_ver,VMETA_USER_VER);
+	ret = ioctl(vdec->fd, VMETA_CMD_GET_INFO, &info);
+	if (ret == -1) {
+		dbg_printf(VDEC_DEBUG_ALL, "%s: unable to get info: %s\n",
+			   __FUNCTION__, strerror(errno));
+		close(vdec->fd);
+		ret = -VDEC_OS_DRIVER_VER_FAIL;
+		goto err_open_fail;
+	}
 
-	if(vdec_iface->kern_ver < VMETA_KERN_MIN_VER) {
-		close(vdec_iface->fd);
+	dbg_printf(VDEC_DEBUG_VER, "%s: version: kernel=%u user=%s\n",
+		   __FUNCTION__, info.revision, VMETA_USER_VER);
+	vdec->kern_ver = info.revision;
+	if (vdec->kern_ver < VMETA_KERN_MIN_VER) {
+		close(vdec->fd);
 		ret = -VDEC_OS_DRIVER_VER_FAIL;
 		goto err_open_fail;
 	}
 
+	for (i = 0; i < 3; i++) {
+		vdec->map[i].phys = info.map[i].phys;
+		vdec->map[i].size = info.map[i].size;
+	}
+
 	// Get the IO mem phy addr and size of vPro's register
-	ret = uio_get_map(0, UIO_IO_MEM_INDEX, 0, &addr, &size, &phys);
+	ret = vmeta_get_map(vdec, MAP_IO_MEM, 0, &addr, &size);
 	if (ret < 0)
 		goto err_mmap_fail;
 
 	dbg_printf(VDEC_DEBUG_MEM, "vdec os driver io mem size: 0x%x, phy addr 0x%x, virt 0x%p\n",
-		   size, phys, addr);
+		   size, vdec->map[0].phys, addr);
 
-	vdec_iface->io_mem_phy_addr = phys;
-	vdec_iface->io_mem_size = size;
-	vdec_iface->io_mem_virt_addr = addr;
+	vdec->regs = addr;
+
+	vdec_iface = vdec;
 
 	pthread_mutex_unlock(&pmt);
-	return ret;
+	return VDEC_OS_DRIVER_OK;
 
 err_mmap_fail:
-	if(vdec_iface->io_mem_virt_addr > 0)
-		munmap(vdec_iface->io_mem_virt_addr, vdec_iface->io_mem_size);
-	close(vdec_iface->fd);
+	close(vdec->fd);
 err_open_fail:
-	free(vdec_iface);
-	vdec_iface = NULL;
+	free(vdec);
 
 	pthread_mutex_unlock(&pmt);
 	return ret;
@@ -525,64 +444,52 @@ err_open_fail:
 // clean vdec os driver
 SIGN32 vdec_os_driver_clean(void)
 {
-	pthread_mutex_lock(&pmt);
+	vdec_os_driver_cb_t *vdec;
 
-	if(vdec_iface == NULL){
+	pthread_mutex_lock(&pmt);
+	vdec = vdec_iface;
+	if (vdec == NULL){
 		pthread_mutex_unlock(&pmt);
 		return -VDEC_OS_DRIVER_CLEAN_FAIL;
 	}
 
 	// decrease the refcount
-	vdec_iface->refcount--;
+	vdec->refcount--;
 
-	if(vdec_iface->refcount != 0) {
-		dbg_printf(VDEC_DEBUG_ALL, "refcount = %d\n", vdec_iface->refcount);
+	if (vdec->refcount != 0) {
+		dbg_printf(VDEC_DEBUG_ALL, "refcount = %d\n", vdec->refcount);
 		pthread_mutex_unlock(&pmt);
 		return 0;
 	}
 
 	// close clock and power
-	if(vdec_os_api_get_user_count() <=0)
-	{
+	if (vdec_os_api_get_user_count() <= 0) {
 		vdec_os_api_clock_off();
 		vdec_os_api_power_off();
 		dbg_printf(VDEC_DEBUG_ALL, "close vmeta power and clock in case app doesn't close\n");
 	}
 
 	// unmap memory area
-	if(vdec_iface->io_mem_virt_addr != NULL) {
-		dbg_printf(VDEC_DEBUG_MEM, "munmap with io_mem_virt_addr = 0x%x\n", vdec_iface->io_mem_virt_addr);
-		munmap(vdec_iface->io_mem_virt_addr, vdec_iface->io_mem_size);
-		vdec_iface->io_mem_virt_addr = NULL;
-		vdec_iface->io_mem_size = 0;
+	if (vdec->regs) {
+		dbg_printf(VDEC_DEBUG_MEM, "munmap registers at 0x%x\n",
+			   vdec->regs);
+		munmap(vdec->regs, vdec->map[MAP_IO_MEM].size);
 	}
 
-	if(vdec_iface->kernel_share_va != NULL) {
-		dbg_printf(VDEC_DEBUG_MEM, "munmap with kernel_share_va = 0x%p size=%d\n", vdec_iface->kernel_share_va,vdec_iface->kernel_share_size);
-		munmap(vdec_iface->kernel_share_va, vdec_iface->kernel_share_size);
-		vdec_iface->kernel_share_va = NULL;
-		vdec_iface->kernel_share_size = 0;
-	}
-
-	if(vdec_iface->vdec_obj_va != NULL) {
-		dbg_printf(VDEC_DEBUG_MEM, "munmap with vdec_obj_va = 0x%x size=%d\n", vdec_iface->vdec_obj_va, vdec_iface->vdec_obj_size);
-		munmap(vdec_iface->vdec_obj_va,vdec_iface->vdec_obj_size );
-		vdec_iface->vdec_obj_va = NULL;
-		vdec_iface->vdec_obj_size = 0;
+	if (vdec->vdec_obj_va != NULL) {
+		dbg_printf(VDEC_DEBUG_MEM, "munmap with vdec_obj_va = 0x%x size=%d\n",
+			   vdec->vdec_obj_va, vdec->vdec_obj_size);
+		munmap(vdec->vdec_obj_va, vdec->vdec_obj_size);
 	}
 
 	// close fd
-	if(vdec_iface->fd > 0) {
-		close(vdec_iface->fd);
-		dbg_printf(VDEC_DEBUG_ALL, "uio close\n");
-	}
+	close(vdec->fd);
+	dbg_printf(VDEC_DEBUG_ALL, "kernel close\n");
 
 	// free vdec_iface
-	if(vdec_iface != NULL) {
-		free(vdec_iface);
-		dbg_printf(VDEC_DEBUG_ALL, "free vdec_iface\n");
-		vdec_iface = NULL;
-	}
+	free(vdec);
+	dbg_printf(VDEC_DEBUG_ALL, "free vdec_iface\n");
+	vdec_iface = NULL;
 
 	dbg_printf(VDEC_DEBUG_ALL, "vmeta clean done\n");
 	pthread_mutex_unlock(&pmt);
@@ -590,11 +497,11 @@ SIGN32 vdec_os_driver_clean(void)
 }
 
 /* display debug message */
-static int dbg_printf(UNSG32 dbglevel, const char* format, ...)
+static void dbg_printf(UNSG32 dbglevel, const char* format, ...)
 {
 	/* Fast exit path */
 	if (globalDbgLevel == VDEC_DEBUG_NONE)
-		return 0;
+		return;
 
 	if (globalDbgLevel & (dbglevel | VDEC_DEBUG_ALL)) {
 		FILE *f;
@@ -609,7 +516,7 @@ static int dbg_printf(UNSG32 dbglevel, const char* format, ...)
 #if VMETA_LOG_ON
 		f = fopen(VMETA_LOG_FILE, "a+");
 		if (f == NULL)
-			return -1;
+			return;
 #else
 		f = stderr;
 #endif
@@ -621,533 +528,156 @@ static int dbg_printf(UNSG32 dbglevel, const char* format, ...)
 		fclose(f);
 #endif
 	}
-
-	return 0;
-}
-
-/* vdec driver get cb */
-vdec_os_driver_cb_t *vdec_driver_get_cb(void)
-{
-	return vdec_iface;
 }
 
 SIGN32 vdec_os_api_get_hw_obj_addr(UNSG32* vaddr,UNSG32 size)
 {
+	vdec_os_driver_cb_t *vdec = vdec_iface;
 	void *addr;
 	int ret;
 
-	if(vdec_iface->vdec_obj_va != NULL)
-	{
+	if (vdec->vdec_obj_va != NULL) {
 		dbg_printf(VDEC_DEBUG_MEM, "Already get vdec obj\n");
-		*vaddr = (UNSG32)vdec_iface->vdec_obj_va;
+		*vaddr = (UNSG32)vdec->vdec_obj_va;
 		return VDEC_OS_DRIVER_OK;
 	}
 
-	ret = uio_get_map(0, UIO_IO_VMETA_OBJ_INDEX, size, &addr, NULL, NULL);
+	ret = vmeta_get_map(vdec, MAP_IO_VMETA_OBJ, size, &addr, NULL);
 	if (ret < 0)
-		goto get_vdec_obj_fail;
+		return ret;
 
-	dbg_printf(VDEC_DEBUG_MEM, "UIO_IO_VMETA_OBJ virtual 0x%p size=%d\n", addr, size);
+	dbg_printf(VDEC_DEBUG_MEM, "MAP_IO_VMETA_OBJ virtual 0x%p size=%d\n",
+		   addr, size);
 
 	*vaddr = (UNSG32)addr;
-	vdec_iface->vdec_obj_va = addr;
-	vdec_iface->vdec_obj_size = size;
+	vdec->vdec_obj_va = addr;
+	vdec->vdec_obj_size = size;
 
-get_vdec_obj_fail:
-	return ret;
+	return VDEC_OS_DRIVER_OK;
 }
 
 SIGN32 vdec_os_api_get_hw_context_addr(UNSG32* paddr, UNSG32* vaddr, UNSG32 size, SIGN32 flag)
 {
-	UNSG32 phys;
-	int ret;
-
-	if(vdec_iface->hw_context_pa != 0)
-	{
-		dbg_printf(VDEC_DEBUG_MEM, "Already get hw context\n");
-		*paddr =  vdec_iface->hw_context_pa;
-		return VDEC_OS_DRIVER_OK;
-	}
-
-	ret = uio_get_map(0, UIO_IO_HW_CONTEXT_INDEX, size, NULL, NULL, &phys);
-	if (ret < 0)
-		goto get_hw_context_fail;
-
-	*paddr =  phys;
-	vdec_iface->hw_context_pa = phys;
-
-	dbg_printf(VDEC_DEBUG_MEM, "UIO_IO_HW_CONTEXT: 0x%08x\n", *paddr);
-
-get_hw_context_fail:
-	return ret;
-}
-
-SIGN32 vdec_os_api_get_ks(kernel_share** pp_ks)
-{
-	unsigned size;
-	void *addr;
-	int ret;
+	vdec_os_driver_cb_t *vdec = vdec_iface;
 
-	if(vdec_iface->kernel_share_va != NULL)
-	{
-		dbg_printf(VDEC_DEBUG_MEM, "Already get kernel share\n");
-		return 0;
+	if (vdec->map[MAP_IO_HW_CONTEXT].size < size) {
+		dbg_printf(VDEC_DEBUG_MEM, "Error: %s: requested %u bytes but only %u bytes available\n",
+			   __FUNCTION__, size,
+			   vdec->map[MAP_IO_HW_CONTEXT].size);
+		return -VDEC_OS_DRIVER_MMAP_FAIL;
 	}
+	*paddr = vdec->map[MAP_IO_HW_CONTEXT].phys;
 
-	ret = uio_get_map(0, UIO_IO_KERNEL_SHARE_INDEX, 0, &addr, &size, NULL);
-	if (ret < 0)
-		goto get_vos_fail;
-
-	dbg_printf(VDEC_DEBUG_MEM, "kernel share virtual address: 0x%p size=%d\n", addr, size);
+	dbg_printf(VDEC_DEBUG_MEM, "MAP_IO_HW_CONTEXT: 0x%08x\n", *paddr);
 
-	*pp_ks = addr;
-	vdec_iface->kernel_share_va = addr;
-	vdec_iface->kernel_share_size = size;
-
-get_vos_fail:
-	return ret;
-}
-
-static int find_user_id(id_instance *list)//return unoccupied id
-{
-	int i;
-	for(i=0; i<MAX_VMETA_INSTANCE; i++) {
-		if(get_bit(VMETA_STATUS_BIT_USED, &(list[i].status)) == 0) {
-			set_bit(VMETA_STATUS_BIT_USED, &(list[i].status));
-			return i;
-		}
-	}
-	return -VDEC_OS_DRIVER_USER_ID_FAIL;
+	return VDEC_OS_DRIVER_OK;
 }
 
 SIGN32 vdec_os_api_force_ini(void)
 {
-	kernel_share *p_ks;
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-
-	if (p_cb && p_cb->kern_ver >= 100) {
-		int ret;
-
-		ret = ioctl(p_cb->fd, VMETA_CMD_FORCE_INI);
-
-		return ret < 0 ? -1 : 0;
-	}
-
-	if(p_cb->kernel_share_va == NULL) {
-		vdec_os_api_get_ks(&p_ks);
-	} else {
-		p_ks = p_cb->kernel_share_va;
-	}
-
-	vmeta_private_lock(); 
-	memset(p_ks, 0, sizeof(kernel_share));
-	p_ks->active_user_id = MAX_VMETA_INSTANCE;
-	vmeta_private_unlock();
-
-	ioctl(vdec_iface->fd,VMETA_CMD_UNLOCK);
-
-	return 0;
+	return vmeta_ioctl(VMETA_CMD_FORCE_INI);
 }
 
 SIGN32 vdec_os_api_get_user_id(void)
 {
-	kernel_share *p_ks;
-	SIGN32 ret;
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-
-	if (p_cb->kern_ver >= 100) {
-		unsigned id;
-
-		ret = ioctl(p_cb->fd, VMETA_CMD_GET_USER_ID, &id);
-
-		return ret == 0 && id < MAX_VMETA_INSTANCE ? id :
-				-VDEC_OS_DRIVER_USER_ID_FAIL;
-	}
-
-	if(p_cb->kernel_share_va == NULL) {
-		vdec_os_api_get_ks(&p_ks);
-	} else {
-		p_ks = p_cb->kernel_share_va;
-	}
+	vdec_os_driver_cb_t *vdec = vdec_iface;
+	unsigned id;
+	int ret;
 
-	vmeta_private_lock();
-	ret = find_user_id(p_ks->user_id_list);
-	if(ret < 0) {
-		dbg_printf(VDEC_DEBUG_ALL, "vdec_os_api_get_user_id: find_user_id error\n");
-	}
-	vmeta_private_unlock();
+	ret = ioctl(vdec->fd, VMETA_CMD_GET_USER_ID, &id);
 
-	return ret;
+	return ret == 0 && id < MAX_VMETA_INSTANCE ? id :
+			-VDEC_OS_DRIVER_USER_ID_FAIL;
 }
 
 SIGN32 vdec_os_api_free_user_id(SIGN32 user_id)
 {
-	kernel_share *p_ks;
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-
-	if (p_cb->kern_ver >= 100) {
-		int ret;
-
-		ret = ioctl(p_cb->fd, VMETA_CMD_FREE_USER_ID, user_id);
-
-		return ret == 0 ? VDEC_OS_DRIVER_OK : VDEC_OS_DRIVER_USER_ID_FAIL;
-	}
+	int ret = vmeta_ioctl_ulong(VMETA_CMD_FREE_USER_ID, user_id);
 
-	if(p_cb->kernel_share_va == NULL) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_free_user_id error: not init yet\n");
-		return VDEC_OS_DRIVER_USER_ID_FAIL;
-	}
-
-	if(user_id >= MAX_VMETA_INSTANCE || user_id < 0) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_free_user_id error: exceeds max user_id\n");
-		return VDEC_OS_DRIVER_USER_ID_FAIL;
-	}
-	p_ks = p_cb->kernel_share_va;
-
-	vmeta_private_lock();
-
-	clear_bit(VMETA_STATUS_BIT_REGISTED,&(p_ks->user_id_list[user_id].status));
-	clear_bit(VMETA_STATUS_BIT_USED,&(p_ks->user_id_list[user_id].status));
-
-	vmeta_private_unlock();
-
-	return VDEC_OS_DRIVER_OK;
-}
-
-static void *vmeta_thread_monitor(void *_data)
-{
-	struct monitor_data *pmd = _data;
-	kernel_share *p_ks;
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-	pthread_attr_t pat;
-	int detach_attr;
-	struct monitor_data *p_md = NULL;
-
-	pthread_mutex_lock(&pmt);
-
-	if(p_cb->kernel_share_va == NULL || pmd == NULL) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_free_user_id error: not init yet\n");
-		free(pmd);
-		pthread_detach(pthread_self());
-		pthread_mutex_unlock(&pmt);
-		return (void *)-1;
-	}
-
-	p_md = malloc(sizeof(struct monitor_data));
-	if(p_md == NULL) {
-		free(pmd);
-		pthread_detach(pthread_self());
-		pthread_mutex_unlock(&pmt);
-		return (void *)-1;
-	}
-
-	memcpy(p_md,pmd,sizeof(struct monitor_data));
-	dbg_printf(VDEC_DEBUG_LOCK,"ori 0x%x 0x%x pt=0x%x user_id=0x%x\n",pmd->pt, pmd->user_id, p_md->pt,p_md->user_id);
-
-	p_ks = p_cb->kernel_share_va;
-
-	if(pthread_getattr_np(p_md->pt,&pat) != 0) {
-		dbg_printf(VDEC_DEBUG_LOCK,"get thread attr failed\n");
-		goto tag_monitor_fail;
-	}
-
-	if( pthread_attr_getdetachstate(&pat,&detach_attr) != 0) {
-		dbg_printf(VDEC_DEBUG_LOCK,"get detach attr failed\n");
-		goto tag_monitor_fail;
-	}
-
-	if( detach_attr == PTHREAD_CREATE_DETACHED) {
-		dbg_printf(VDEC_DEBUG_LOCK,"The thread is a detached thread, cannot join\nexit monitor!\n");
-		goto tag_monitor_fail;
-	}
-
-	dbg_printf(VDEC_DEBUG_LOCK,"wait for pt=0x%x\n",p_md->pt);
-	pthread_mutex_unlock(&pmt);
-
-	pthread_join(p_md->pt,NULL);
-	dbg_printf(VDEC_DEBUG_LOCK,"pt=0x%x is killed user_id(%d)\n",p_md->pt,p_md->user_id);
-
-	pthread_mutex_lock(&pmt);
-	p_cb = vdec_driver_get_cb();
-
-	if(p_cb) {
-		if(p_cb->kernel_share_va) {
-			p_ks = p_cb->kernel_share_va;
-			if(p_md->user_id==p_ks->active_user_id) {
-				dbg_printf(VDEC_DEBUG_LOCK,"vmeta thread exit abnormally, instance id=%d lock flag=%d\n",p_md->user_id,p_ks->lock_flag);
-				if( p_ks->lock_flag==VMETA_LOCK_ON ) {
-					vdec_os_api_unlock(p_md->user_id);
-					p_ks->lock_flag = VMETA_LOCK_FORCE_INIT;
-				}
-				p_ks->active_user_id = MAX_VMETA_INSTANCE;
-			}
-
-			if(p_ks->user_id_list[p_md->user_id].status != 0) {
-				dbg_printf(VDEC_DEBUG_LOCK,"vmeta thread exit abnormally, clear instance(%d)\n",p_md->user_id);
-				memset(&(p_ks->user_id_list[p_md->user_id]),0x0,sizeof(id_instance));
-				p_ks->ref_count--;
-			}
-		}
-	}
-
-	free(p_md);
-	free(pmd);
-	pthread_attr_destroy(&pat);
-
-	dbg_printf(VDEC_DEBUG_MEM,"thread monitor exit\n");
-	pthread_detach(pthread_self());
-	pthread_mutex_unlock(&pmt);
-	return NULL;
-
-tag_monitor_fail:
-	pthread_mutex_unlock(&pmt);
-	free(p_md);
-	free(pmd);
-	pthread_detach(pthread_self());
-
-	pthread_attr_destroy(&pat);
-	return (void *)-1;
+	return ret == 0 ? VDEC_OS_DRIVER_OK : VDEC_OS_DRIVER_USER_ID_FAIL;
 }
 
 SIGN32 vdec_os_api_register_user_id(SIGN32 user_id)
 {
-	kernel_share *p_ks;
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-	pthread_t tmp;
-	struct monitor_data *p_md;
-
-	if (p_cb->kern_ver >= 100) {
-		int ret;
-
-		ret = ioctl(p_cb->fd, VMETA_CMD_REGISTER_USER_ID, user_id);
-
-		if (ret < 0) {
-			dbg_printf(VDEC_DEBUG_ALL, "%s: error %d\n",
-				   __FUNCTION__, errno);
-			return VDEC_OS_DRIVER_USER_ID_FAIL;
-		}
-
-		return VDEC_OS_DRIVER_OK;
-	}
+	int ret = vmeta_ioctl_ulong(VMETA_CMD_REGISTER_USER_ID, user_id);
 
-	if(user_id>=MAX_VMETA_INSTANCE || user_id<0) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_register_user_id error: exceeds max user_id\n");
+	if (ret < 0) {
+		dbg_printf(VDEC_DEBUG_ALL, "%s: error: %s\n",
+			   __FUNCTION__, strerror(errno));
 		return VDEC_OS_DRIVER_USER_ID_FAIL;
 	}
 
-	if(p_cb->kernel_share_va == NULL) {
-		vdec_os_api_get_ks(&p_ks);
-	} else {
-		p_ks = p_cb->kernel_share_va;
-	}
-
-	if(set_bit(VMETA_STATUS_BIT_REGISTED, &(p_ks->user_id_list[user_id].status)) == 1) {
-		dbg_printf(VDEC_DEBUG_ALL, "vdec_os_api_register_user_id error: user id has already been registered\n");
-		return VDEC_OS_DRIVER_USER_ID_FAIL;
-	}
-
-	p_md = malloc(sizeof(struct monitor_data));//This is freed monitor function
-	if(p_md == NULL) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_register_user_id error: OOM\n");
-		return VDEC_OS_DRIVER_USER_ID_FAIL;
-	}
-	p_ks->ref_count++;
-	p_ks->user_id_list[user_id].pid = getpid();
-	p_md->pt = pthread_self();
-	p_ks->user_id_list[user_id].pt = (unsigned int) p_md->pt;
-	p_md->user_id = user_id;
-
-	pthread_create(&tmp,NULL,vmeta_thread_monitor,p_md);
-	dbg_printf(VDEC_DEBUG_LOCK,"pid=%x,pt=0x%x are monitored user_id(%d)\n",p_ks->user_id_list[user_id].pid,p_ks->user_id_list[user_id].pt,user_id);
-
 	return VDEC_OS_DRIVER_OK;
 }
 
 SIGN32 vdec_os_api_unregister_user_id(SIGN32 user_id)
 {
-	kernel_share *p_ks;
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-
-	if (p_cb->kern_ver >= 100) {
-		int ret;
-
-		ret = ioctl(p_cb->fd, VMETA_CMD_UNREGISTER_USER_ID, user_id);
-		if (ret < 0) {
-			dbg_printf(VDEC_DEBUG_ALL, "%s: error: %d\n",
-				   __FUNCTION__, errno);
-			return VDEC_OS_DRIVER_USER_ID_FAIL;
-		}
-
-		return VDEC_OS_DRIVER_OK;
-	}
-
-	if(user_id>=MAX_VMETA_INSTANCE || user_id<0) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_unregister_user_id error: exceeds max user_id\n");
-		return VDEC_OS_DRIVER_USER_ID_FAIL;
-	}
+	int ret = vmeta_ioctl_ulong(VMETA_CMD_UNREGISTER_USER_ID, user_id);
 
-	if(p_cb->kernel_share_va == NULL) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_unregister_user_id error: not init yet\n");
-		return VDEC_OS_DRIVER_USER_ID_FAIL;
-	} else {
-		p_ks = p_cb->kernel_share_va;
-	}
-
-	if(clear_bit(VMETA_STATUS_BIT_REGISTED,&(p_ks->user_id_list[user_id].status)) == 0) {
-		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_unregister_user_id error: user id[%d] has not been registered\n",user_id);
+	if (ret < 0) {
+		dbg_printf(VDEC_DEBUG_ALL, "%s: error: %s\n",
+			   __FUNCTION__, strerror(errno));
 		return VDEC_OS_DRIVER_USER_ID_FAIL;
 	}
 
-	p_ks->ref_count--;
-
 	return VDEC_OS_DRIVER_OK;
 }
 
 
-static SIGN32 vmeta_private_lock()
-{
-	ioctl(vdec_iface->fd,VMETA_CMD_PRIV_LOCK,(unsigned long)0xffffffff);
-	return 0;
-}
-
-static SIGN32 vmeta_private_unlock()
-{
-	ioctl(vdec_iface->fd,VMETA_CMD_PRIV_UNLOCK);
-	return 0;
-}
-
 SIGN32 vdec_os_api_get_user_count(void)
 {
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-	kernel_share *p_ks;
+	vdec_os_driver_cb_t *vdec = vdec_iface;
+	unsigned num;
+	int ret;
 
-	if(p_cb == NULL) {
+	if (vdec == NULL) {
 		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_get_user_count error: point is NULL\n");
 		return -1;
 	}
 
-	if (p_cb->kern_ver >= 100) {
-		unsigned num;
-		int ret;
-
-		ret = ioctl(p_cb->fd, VMETA_CMD_GET_USER_NUM, &num);
-
-		return ret < 0 ? -1 : num;
-	}
+	ret = ioctl(vdec->fd, VMETA_CMD_GET_USER_NUM, &num);
 
-	if(p_cb->kernel_share_va == NULL) {
-		vdec_os_api_get_ks(&p_ks);
-	} else {
-		p_ks = p_cb->kernel_share_va;
-	}
-
-	dbg_printf(VDEC_DEBUG_ALL, "get_user_count=%d\n",p_ks->ref_count);
-
-	return p_ks->ref_count;
+	return ret < 0 ? -1 : num;
 }
 
 SIGN32 vdec_os_api_lock(SIGN32 user_id, long to_ms)
 {
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-	kernel_share* p_ks;
-	SIGN32 ret;
+	vdec_os_driver_cb_t *vdec = vdec_iface;
+	struct vmeta_lock lock;
+	int ret;
 
-	if(p_cb == NULL) {
+	if (vdec == NULL) {
 		dbg_printf(VDEC_DEBUG_ALL,"vdec_os_api_lock error: point is NULL\n");
 		return LOCK_RET_ERROR_UNKNOWN;
 	}
 
-	if (p_cb->kern_ver >= 100) {
-		struct vmeta_lock lock;
-		int ret;
+	lock.user_id = user_id;
+	lock.timeout = to_ms;
 
-		lock.user_id = user_id;
-		lock.timeout = to_ms;
-
-		ret = ioctl(p_cb->fd, VMETA_CMD_LOCK_USER_ID, &lock);
-
-		if (ret < 0) {
-			switch (errno) {
-			case ETIME:
-				return LOCK_RET_ERROR_TIMEOUT;
-			case EDEADLOCK:
-				return LOCK_RET_ME;
-			case EUCLEAN:
-				return LOCK_RET_FORCE_INIT;
-			default:
-				return LOCK_RET_ERROR_UNKNOWN;
-			}
+	ret = ioctl(vdec->fd, VMETA_CMD_LOCK_USER_ID, &lock);
+	if (ret < 0) {
+		switch (errno) {
+		case ETIME:
+			return LOCK_RET_ERROR_TIMEOUT;
+		case EDEADLOCK:
+			return LOCK_RET_ME;
+		case EUCLEAN:
+			return LOCK_RET_FORCE_INIT;
+		default:
+			return LOCK_RET_ERROR_UNKNOWN;
 		}
-		return LOCK_RET_OHTERS_NORM;
-	}
-
-	p_ks = p_cb->kernel_share_va;
-
-	if(p_ks->active_user_id == user_id) {
-		dbg_printf(VDEC_DEBUG_LOCK,"lock same user=%d, lock_flag=%d,ref_count=%d\n",\
-				user_id,p_ks->lock_flag,p_ks->ref_count);
-		return LOCK_RET_ME;//just return since they are the same caller
-	}
-
-	ret = ioctl(vdec_iface->fd,VMETA_CMD_LOCK,(unsigned long)to_ms);
-	if(ret!=0) {
-		dbg_printf(VDEC_DEBUG_LOCK, "lock timeout\n");
-		return LOCK_RET_ERROR_TIMEOUT;
-	}
-
-	vmeta_private_lock();
-	p_ks->active_user_id = user_id;
-	if(p_ks->lock_flag == VMETA_LOCK_FORCE_INIT){
-		p_ks->lock_flag = VMETA_LOCK_ON;
-		vmeta_private_unlock();
-		return LOCK_RET_FORCE_INIT;
 	}
-	p_ks->lock_flag = VMETA_LOCK_ON;
-	vmeta_private_unlock();
 
 	return LOCK_RET_OHTERS_NORM;
 }
 
 SIGN32 vdec_os_api_unlock(SIGN32 user_id)
 {
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
-	kernel_share* p_ks;
-	int ret;
+	int ret = vmeta_ioctl_ulong(VMETA_CMD_UNLOCK_USER_ID, user_id);
 
-	if(p_cb == NULL) {
-		dbg_printf(VDEC_DEBUG_LOCK,"vdec_os_api_unlock error: point is NULL\n");
-		return LOCK_RET_ERROR_UNKNOWN;
-	}
-
-	if (p_cb->kern_ver >= 100) {
-		ret = ioctl(p_cb->fd, VMETA_CMD_UNLOCK_USER_ID, user_id);
-
-		if (ret < 0) {
-			dbg_printf(VDEC_DEBUG_LOCK, "%s: error %d\n",
-				   __FUNCTION__, errno);
-			return LOCK_RET_ERROR_UNKNOWN;
-		}
-		return LOCK_RET_OHTERS_NORM;
-	}
-
-	p_ks = p_cb->kernel_share_va;
-	vmeta_private_lock();
-	if(p_ks->active_user_id == user_id) {
-		p_ks->active_user_id = MAX_VMETA_INSTANCE;
-		p_ks->lock_flag = VMETA_LOCK_OFF;
-	}
-	else
-	{
-		dbg_printf(VDEC_DEBUG_LOCK,"vdec_os_api_unlock error: unlock other user id %d; active_user_id is %d\n", user_id, p_ks->active_user_id);
-		vmeta_private_unlock();
-		return LOCK_RET_ERROR_UNKNOWN;
-	}
-	vmeta_private_unlock();
-
-	ret = ioctl(vdec_iface->fd,VMETA_CMD_UNLOCK);
-	dbg_printf(VDEC_DEBUG_LOCK, "ID: %d after unlock\n", user_id);
-	if(ret != 0) {
-		dbg_printf(VDEC_DEBUG_LOCK,"vdec_os_api_unlock ioctl error\n");
+	if (ret < 0) {
+		dbg_printf(VDEC_DEBUG_LOCK, "%s: error: %s\n",
+			   __FUNCTION__, strerror(errno));
 		return LOCK_RET_ERROR_UNKNOWN;
 	}
 
@@ -1156,69 +686,34 @@ SIGN32 vdec_os_api_unlock(SIGN32 user_id)
 
 SIGN32 vdec_os_api_power_on(void)
 {
-	SIGN32 ret = 0;
-
-	if(vdec_iface == NULL) {
-		return -1;
-	}
-	ret = ioctl(vdec_iface->fd,VMETA_CMD_POWER_ON);
-
-	return ret;
+	return vmeta_ioctl(VMETA_CMD_POWER_ON);
 }
 
 SIGN32 vdec_os_api_power_off(void)
 {
-	SIGN32 ret = 0;
-
-	if(vdec_iface == NULL) {
-		return -1;
-	}
-	ret = ioctl(vdec_iface->fd,VMETA_CMD_POWER_OFF);
-
-	return ret;
+	return vmeta_ioctl(VMETA_CMD_POWER_OFF);
 }
 
 SIGN32 vdec_os_api_clock_on(void)
 {
-	SIGN32 ret = 0;
-
-	if(vdec_iface == NULL) {
-		return -1;
-	}
-	ret = ioctl(vdec_iface->fd,VMETA_CMD_CLK_ON);
-
-	return ret;
+	return vmeta_ioctl(VMETA_CMD_CLK_ON);
 }
 
 SIGN32 vdec_os_api_clock_off(void)
 {
-	SIGN32 ret = 0;
-
-	if(vdec_iface == NULL) {
-		return -1;
-	}
-	ret = ioctl(vdec_iface->fd,VMETA_CMD_CLK_OFF);
-
-	return ret;
+	return vmeta_ioctl(VMETA_CMD_CLK_OFF);
 }
 
 SIGN32 vdec_os_api_clock_switch(VMETA_CLOCK_OP vco)
 {
-	SIGN32 ret = 0;
-
-	if(vdec_iface == NULL) {
-		return -1;
-	}
-	ret = ioctl(vdec_iface->fd,VMETA_CMD_CLK_SWITCH,(unsigned long)vco);
-
-	return ret;
+	return vmeta_ioctl_ulong(VMETA_CMD_CLK_SWITCH, (unsigned long)vco);
 }
 
 SIGN32 vdec_os_driver_version(SIGN8 *ver_str)
 {
-	vdec_os_driver_cb_t *p_cb = vdec_driver_get_cb();
+	vdec_os_driver_cb_t *vdec = vdec_iface;
 
-	if(p_cb==NULL || ver_str==NULL) {
+	if (vdec == NULL || ver_str == NULL) {
 		dbg_printf(VDEC_DEBUG_VER,"vdec_os_driver_version error: point is NULL\n");
 		return -VDEC_OS_DRIVER_VER_FAIL;
 	}
@@ -1231,25 +726,23 @@ SIGN32 vdec_os_driver_version(SIGN8 *ver_str)
 }
 
 // check VMeta is ready to suspend
-SIGN32 vdec_os_api_suspend_check(void) {
+SIGN32 vdec_os_api_suspend_check(void)
+{
+	vdec_os_driver_cb_t *vdec = vdec_iface;
 	SIGN32 suspend_check;
 
-	if(vdec_iface == NULL)
+	if (vdec == NULL)
 		return 0;
 
-	ioctl(vdec_iface->fd, VMETA_CMD_SUSPEND_CHECK, &suspend_check);
+	ioctl(vdec->fd, VMETA_CMD_SUSPEND_CHECK, &suspend_check);
 
 	return suspend_check;
 }
 
 // VMeta is ready to suspend
-SIGN32 vdec_os_api_suspend_ready(void) {
-	if(vdec_iface == NULL)
-		return 0;
-
-	ioctl(vdec_iface->fd, VMETA_CMD_SUSPEND_READY);
-
+SIGN32 vdec_os_api_suspend_ready(void)
+{
+	vmeta_ioctl(VMETA_CMD_SUSPEND_READY);
 	return 0;
 }
 
-
diff --git a/vmeta_lib.h b/vmeta_lib.h
index 6226542..9060c32 100644
--- a/vmeta_lib.h
+++ b/vmeta_lib.h
@@ -1,32 +1,14 @@
+/*
+ * This header file describes the public interface of the libvmeta library.
+ */
 #ifndef VDEC_OS_DRIVER_H
 #define VDEC_OS_DRIVER_H
-#include <sys/poll.h>
-#include <semaphore.h>
-#include "uio_vmeta.h"
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-#define VDEC_DEBUG_ALL 0x1
-#define VDEC_DEBUG_MEM 0x2
-#define VDEC_DEBUG_LOCK 0x4
-#define VDEC_DEBUG_VER 0x8
-#define VDEC_DEBUG_NONE 0x0
-
-#define UIO_DEV "/dev/uio0"
-#define UIO_IO_VERSION "/sys/class/uio/uio0/version"
-
-#define UIO_IO_MEM_INDEX 0
-#define UIO_IO_HW_CONTEXT_INDEX 1
-#define UIO_IO_VMETA_OBJ_INDEX 2
-#define UIO_IO_KERNEL_SHARE_INDEX 3
-
-#define VMETA_SHARED_LOCK_HANDLE "vmeta_shared_lock"
-
-#define VMETA_KERN_MIN_VER	4
-#define VMETA_USER_VER		"build-004"
 //---------------------------------------------------------------------------
 // Macros
 //---------------------------------------------------------------------------
@@ -61,9 +43,6 @@ enum dma_data_direction {
 	DMA_NONE = 3,
 };
 
-#define VMETA_STATUS_BIT_USED		0
-#define VMETA_STATUS_BIT_REGISTED	1
-
 //---------------------------------------------------------------------------
 // Driver initialization API
 //---------------------------------------------------------------------------
@@ -114,7 +93,6 @@ SIGN32 vdec_os_api_free_user_id(SIGN32 user_id);
 SIGN32 vdec_os_api_register_user_id(SIGN32 user_id);
 SIGN32 vdec_os_api_unregister_user_id(SIGN32 user_id);
 
-SIGN32 vdec_os_api_update_user_info(SIGN32 user_id, void* info);
 SIGN32 vdec_os_api_get_user_count(void);
 
 //return: Former user unlock vmeta normally/abnormally/forced
@@ -162,45 +140,6 @@ typedef enum _LOCK_RET_CODE {
 	LOCK_RET_FORCE_INIT,
 }LOCK_RET_CODE;
 
-/* display debug message */
-#define VMETA_LOG_ON 0
-#define VMETA_LOG_FILE "/data/vmeta_dbg.log"
-static int dbg_printf(UNSG32 dbglevel, const char* format, ...);
-
-typedef sem_t lock_t;
-//---------------------------------------------------------------------------
-// the control block of vdec os driver
-//---------------------------------------------------------------------------
-typedef struct vdec_os_driver_cb_s
-{
-	int fd;				// kernel file descriptor
-	int uio;			// using uio driver
-	struct {
-		UNSG32 phys;
-		UNSG32 size;
-	} map[3];
-
-	UNSG32 io_mem_phy_addr;		// the physical addr of io register base
-	void *io_mem_virt_addr;		// the reg base addr that maped from kernel
-	UNSG32 io_mem_size;		// the size of io mem area
-	int refcount;			// reference count in current process
-	void *vdec_obj_va;
-	UNSG32 vdec_obj_size;
-	UNSG32 hw_context_pa;
-	struct _kernel_share *kernel_share_va;
-	UNSG32 kernel_share_size;
-	int kern_ver;	//vmeta kernel version
-} vdec_os_driver_cb_t;
-
-struct monitor_data{
-	pthread_t pt;
-	SIGN32 user_id;
-};
-
-/* vdec driver get cb */
-vdec_os_driver_cb_t *vdec_driver_get_cb(void);
-
-
 #ifdef __cplusplus
 }
 #endif