[ALPS02370195] DISP: MT8173: Support 32 bits user space

[Detail]
Support 32 bits user space program

[Solution]
add compat ioctl in display driver

[Feature] Display Driver

Change-Id: I796ad6ad1e6442ef8d19b67349f1b1497725b181
Signed-off-by: ginny.chen <ginny.chen@mediatek.com>
CR-Id: ALPS02370195

8 files changed, 816 insertions, 121 deletions

diff --git a/drivers/misc/mediatek/video/mt8173/videox/Makefile b/drivers/misc/mediatek/video/mt8173/videox/Makefile
index b66ec09fc4e1..f238929f49b5 100644
--- a/drivers/misc/mediatek/video/mt8173/videox/Makefile
+++ b/drivers/misc/mediatek/video/mt8173/videox/Makefile
@@ -4,18 +4,19 @@
 
 
 obj-$(CONFIG_MTK_FB) += mtkfb_console.o             \
-         disp_assert_layer.o                        \
-         mtkfb.o                                    \
-         mtkfb_vsync.o			    \
-         debug.o                                    \
-         primary_display.o                        \
-         disp_lcm.o                                 \
-         disp_utils.o                               \
-	     mtkfb_fence.o\
-	     mtk_disp_mgr.o\
-	     fbconfig_kdebug_rome.o\
-	     mtk_mira.o \
-	     mtk_ovl.o
+			disp_assert_layer.o         \
+			mtkfb.o                     \
+			mtkfb_vsync.o               \
+			debug.o                     \
+			primary_display.o           \
+			disp_lcm.o                  \
+			disp_utils.o                \
+			mtkfb_fence.o               \
+			mtk_disp_mgr.o              \
+			fbconfig_kdebug_rome.o      \
+			mtk_mira.o                  \
+			mtk_ovl.o                   \
+			compat_mtk_disp_mgr.o
 
 subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/mmp/
 ccflags-y += -I$(srctree)/drivers/misc/mediatek/video/$(MTK_PLATFORM)/dispsys   \
diff --git a/drivers/misc/mediatek/video/mt8173/videox/compat_mtk_disp_mgr.c b/drivers/misc/mediatek/video/mt8173/videox/compat_mtk_disp_mgr.c
new file mode 100644
index 000000000000..c209e4805c3a
--- /dev/null
+++ b/drivers/misc/mediatek/video/mt8173/videox/compat_mtk_disp_mgr.c
@@ -0,0 +1,266 @@
+
+#include "compat_mtk_disp_mgr.h"
+
+#include "disp_drv_log.h"
+#include "debug.h"
+#include "primary_display.h"
+#include "display_recorder.h"
+#include "mtkfb_fence.h"
+#include "disp_drv_platform.h"
+
+
+#ifdef CONFIG_COMPAT
+static int compat_get_disp_output_config(compat_disp_output_config __user *data32,
+					disp_output_config __user *data)
+{
+	compat_uint_t u;
+	compat_uptr_t p;
+	int err = 0;
+
+	err |= get_user(p, (unsigned long *)&(data32->va));
+	err |= put_user(p, (unsigned long *)&(data->va));
+
+	err |= get_user(p, (unsigned long *)&(data32->pa));
+	err |= put_user(p, (unsigned long *)&(data->pa));
+
+	err |= get_user(u, &(data32->fmt));
+	err |= put_user(u, &(data->fmt));
+
+	err |= get_user(u, &(data32->x));
+	err |= put_user(u, &(data->x));
+
+	err |= get_user(u, &(data32->y));
+	err |= put_user(u, &(data->y));
+
+	err |= get_user(u, &(data32->width));
+	err |= put_user(u, &(data->width));
+
+	err |= get_user(u, &(data32->height));
+	err |= put_user(u, &(data->height));
+
+	err |= get_user(u, &(data32->pitch));
+	err |= put_user(u, &(data->pitch));
+
+	err |= get_user(u, &(data32->pitchUV));
+	err |= put_user(u, &(data->pitchUV));
+
+	err |= get_user(u, &(data32->security));
+	err |= put_user(u, &(data->security));
+
+	err |= get_user(u, &(data32->buff_idx));
+	err |= put_user(u, &(data->buff_idx));
+
+	err |= get_user(u, &(data32->interface_idx));
+	err |= put_user(u, &(data->interface_idx));
+
+	err |= get_user(u, &(data32->frm_sequence));
+	err |= put_user(u, &(data->frm_sequence));
+
+	return err;
+}
+
+static int compat_get_disp_session_output_config(compat_disp_session_output_config __user *data32,
+						 disp_session_output_config __user *data)
+{
+	compat_uint_t u;
+	int err = 0;
+
+	err = get_user(u, &(data32->session_id));
+	err |= put_user(u, &(data->session_id));
+
+	err |= compat_get_disp_output_config(&data32->config, &data->config);
+
+	return err;
+}
+
+static int compat_get_disp_input_config(compat_disp_input_config __user *data32,
+					disp_input_config __user *data)
+{
+	compat_uint_t u;
+	compat_int_t i;
+	compat_uptr_t p;
+	int err = 0;
+
+	err |= get_user(u, &(data32->layer_id));
+	err |= put_user(u, &(data->layer_id));
+
+	err |= get_user(u, &(data32->layer_enable));
+	err |= put_user(u, &(data->layer_enable));
+
+	err |= get_user(u, &(data32->buffer_source));
+	err |= put_user(u, &(data->buffer_source));
+
+	err |= get_user(p, (unsigned long *)&(data32->src_base_addr));
+	err |= put_user(p, (unsigned long *)&(data->src_base_addr));
+
+	err |= get_user(p, (unsigned long *)&(data32->src_phy_addr));
+	err |= put_user(p, (unsigned long *)&(data->src_phy_addr));
+
+	err |= get_user(u, &(data32->src_direct_link));
+	err |= put_user(u, &(data->src_direct_link));
+
+	err |= get_user(u, &(data32->src_fmt));
+	err |= put_user(u, &(data->src_fmt));
+
+	err |= get_user(u, &(data32->src_use_color_key));
+	err |= put_user(u, &(data->src_use_color_key));
+
+	err |= get_user(u, &(data32->src_pitch));
+	err |= put_user(u, &(data->src_pitch));
+
+	err |= get_user(u, &(data32->src_offset_x));
+	err |= put_user(u, &(data->src_offset_x));
+
+	err |= get_user(u, &(data32->src_offset_y));
+	err |= put_user(u, &(data->src_offset_y));
+
+	err |= get_user(u, &(data32->src_width));
+	err |= put_user(u, &(data->src_width));
+
+	err |= get_user(u, &(data32->src_height));
+	err |= put_user(u, &(data->src_height));
+
+	err |= get_user(u, &(data32->tgt_offset_x));
+	err |= put_user(u, &(data->tgt_offset_x));
+
+	err |= get_user(u, &(data32->tgt_offset_y));
+	err |= put_user(u, &(data->tgt_offset_y));
+
+	err |= get_user(u, &(data32->tgt_width));
+	err |= put_user(u, &(data->tgt_width));
+
+	err |= get_user(u, &(data32->tgt_height));
+	err |= put_user(u, &(data->tgt_height));
+
+	err |= get_user(u, &(data32->layer_rotation));
+	err |= put_user(u, &(data->layer_rotation));
+
+	err |= get_user(u, &(data32->layer_type));
+	err |= put_user(u, &(data->layer_type));
+
+	err |= get_user(u, &(data32->video_rotation));
+	err |= put_user(u, &(data->video_rotation));
+
+	err |= get_user(u, &(data32->isTdshp));
+	err |= put_user(u, &(data->isTdshp));
+
+	err |= get_user(u, &(data32->next_buff_idx));
+	err |= put_user(u, &(data->next_buff_idx));
+
+	err |= get_user(i, &(data32->identity));
+	err |= put_user(i, &(data->identity));
+
+	err |= get_user(i, &(data32->connected_type));
+	err |= put_user(i, &(data->connected_type));
+
+	err |= get_user(u, &(data32->security));
+	err |= put_user(u, &(data->security));
+
+	err |= get_user(u, &(data32->alpha_enable));
+	err |= put_user(u, &(data->alpha_enable));
+
+	err |= get_user(u, &(data32->alpha));
+	err |= put_user(u, &(data->alpha));
+
+	err |= get_user(u, &(data32->sur_aen));
+	err |= put_user(u, &(data->sur_aen));
+
+	err |= get_user(u, &(data32->src_alpha));
+	err |= put_user(u, &(data->src_alpha));
+
+	err |= get_user(u, &(data32->dst_alpha));
+	err |= put_user(u, &(data->dst_alpha));
+
+	err |= get_user(i, &(data32->frm_sequence));
+	err |= put_user(i, &(data->frm_sequence));
+
+	err |= get_user(u, &(data32->yuv_range));
+	err |= put_user(u, &(data->yuv_range));
+
+	err |= get_user(u, &(data32->fps));
+	err |= put_user(u, &(data->fps));
+
+	err |= get_user(u, &(data32->timestamp));
+	err |= put_user(u, &(data->timestamp));
+
+	return err;
+}
+
+static int compat_get_disp_session_input_config(compat_disp_session_input_config __user *data32,
+						disp_session_input_config __user *data)
+{
+	compat_uint_t u;
+	compat_long_t l;
+	int err = 0;
+	int j;
+
+	err |= get_user(u, &(data32->session_id));
+	err |= put_user(u, &(data->session_id));
+
+	err |= get_user(l, &(data32->config_layer_num));
+	err |= put_user(l, &(data->config_layer_num));
+
+	for (j = 0; j < ARRAY_SIZE(data32->config); j++)
+		err |= compat_get_disp_input_config(&data32->config[j], &data->config[j]);
+
+	return err;
+}
+
+int _compat_ioctl_set_input_buffer(struct file *file, unsigned long arg)
+{
+	int ret = 0;
+	int err = 0;
+
+	compat_disp_session_input_config __user *data32;
+
+	disp_session_input_config __user *data;
+
+	DISPDBG("COMPAT_DISP_IOCTL_SET_INPUT_BUFFER\n");
+	data32 = compat_ptr(arg);
+	data = compat_alloc_user_space(sizeof(disp_session_input_config));
+
+	if (data == NULL) {
+		DISPERR("compat_alloc_user_space fail!\n");
+		return -EFAULT;
+	}
+
+	err = compat_get_disp_session_input_config(data32, data);
+	if (err) {
+		DISPERR("compat_get_disp_session_input_config fail!\n");
+		return err;
+	}
+
+	ret = file->f_op->unlocked_ioctl(file, DISP_IOCTL_SET_INPUT_BUFFER, (unsigned long)data);
+	return ret;
+}
+
+int _compat_ioctl_set_output_buffer(struct file *file, unsigned long arg)
+{
+	int ret = 0;
+	int err = 0;
+
+	compat_disp_session_output_config __user *data32;
+
+	disp_session_output_config __user *data;
+
+	DISPDBG("COMPAT_DISP_IOCTL_SET_OUTPUT_BUFFER\n");
+	data32 = compat_ptr(arg);
+	data = compat_alloc_user_space(sizeof(disp_session_output_config));
+
+	if (data == NULL) {
+		DISPERR("compat_alloc_user_space fail!\n");
+		return -EFAULT;
+	}
+
+	err = compat_get_disp_session_output_config(data32, data);
+	if (err) {
+		DISPERR("compat_get_disp__session_output_config fail!\n");
+		return err;
+	}
+
+	ret = file->f_op->unlocked_ioctl(file, DISP_IOCTL_SET_OUTPUT_BUFFER, (unsigned long)data);
+
+	return ret;
+}
+
+#endif
diff --git a/drivers/misc/mediatek/video/mt8173/videox/compat_mtk_disp_mgr.h b/drivers/misc/mediatek/video/mt8173/videox/compat_mtk_disp_mgr.h
new file mode 100644
index 000000000000..8973d837ef77
--- /dev/null
+++ b/drivers/misc/mediatek/video/mt8173/videox/compat_mtk_disp_mgr.h
@@ -0,0 +1,80 @@
+#ifndef _COMPAT_MTK_DISP_MGR_H_
+#define _COMPAT_MTK_DISP_MGR_H_
+#include <linux/uaccess.h>
+#include <linux/compat.h>
+#include "mtk_disp_mgr.h"
+
+#include "disp_session.h"
+
+#ifdef CONFIG_COMPAT
+typedef struct compat_disp_input_config_t {
+	compat_uint_t layer_id;
+	compat_uint_t layer_enable;
+	compat_uint_t buffer_source;
+	compat_uptr_t src_base_addr;
+	compat_uptr_t src_phy_addr;
+	compat_uint_t src_direct_link;
+	compat_uint_t src_fmt;
+	compat_uint_t src_use_color_key;
+	compat_uint_t src_color_key;
+	compat_uint_t src_pitch;
+	compat_uint_t src_offset_x, src_offset_y;
+	compat_uint_t src_width, src_height;
+
+	compat_uint_t tgt_offset_x, tgt_offset_y;
+	compat_uint_t tgt_width, tgt_height;
+	compat_uint_t layer_rotation;
+	compat_uint_t layer_type;
+	compat_uint_t video_rotation;
+
+	compat_uint_t isTdshp;
+
+	compat_uint_t next_buff_idx;
+	compat_int_t identity;
+	compat_int_t connected_type;
+	compat_uint_t security;
+	compat_uint_t alpha_enable;
+	compat_uint_t alpha;
+	compat_uint_t sur_aen;
+	compat_uint_t src_alpha;
+	compat_uint_t dst_alpha;
+	compat_uint_t frm_sequence;
+	compat_uint_t yuv_range;
+	compat_uint_t fps;
+	compat_u64 timestamp;
+} compat_disp_input_config;
+
+typedef struct compat_disp_output_config_t {
+	compat_uptr_t va;
+	compat_uptr_t pa;
+	compat_uint_t fmt;
+	compat_uint_t x;
+	compat_uint_t y;
+	compat_uint_t width;
+	compat_uint_t height;
+	compat_uint_t pitch;
+	compat_uint_t pitchUV;
+	compat_uint_t security;
+	compat_uint_t buff_idx;
+	compat_uint_t interface_idx;
+	compat_uint_t frm_sequence;
+} compat_disp_output_config;
+
+typedef struct compat_disp_session_input_config_t {
+	compat_uint_t session_id;
+	compat_uint_t config_layer_num;
+	compat_disp_input_config config[MAX_INPUT_CONFIG];
+} compat_disp_session_input_config;
+
+typedef struct compat_disp_session_output_config_t {
+	compat_uint_t session_id;
+	compat_disp_output_config config;
+} compat_disp_session_output_config;
+
+int _compat_ioctl_set_input_buffer(struct file *file, unsigned long arg);
+int _compat_ioctl_set_output_buffer(struct file *file, unsigned long arg);
+
+#define	COMPAT_DISP_IOCTL_SET_INPUT_BUFFER			DISP_IOW(206, compat_disp_session_input_config)
+#define	COMPAT_DISP_IOCTL_SET_OUTPUT_BUFFER			DISP_IOW(207, compat_disp_session_output_config)
+#endif
+#endif /*_COMPAT_MTK_DISP_MGR_H_*/
diff --git a/drivers/misc/mediatek/video/mt8173/videox/compat_mtkfb.h b/drivers/misc/mediatek/video/mt8173/videox/compat_mtkfb.h
new file mode 100644
index 000000000000..59899396781c
--- /dev/null
+++ b/drivers/misc/mediatek/video/mt8173/videox/compat_mtkfb.h
@@ -0,0 +1,49 @@
+#ifndef _COMPAT_MTKFB_H_
+#define _COMPAT_MTKFB_H_
+#include <linux/compat.h>
+
+#ifdef CONFIG_COMPAT
+
+struct compat_fb_overlay_layer {
+	compat_uint_t layer_id;
+	compat_uint_t layer_enable;
+
+	compat_uptr_t src_base_addr;
+	compat_uptr_t src_phy_addr;
+	compat_uint_t src_direct_link;
+	compat_int_t src_fmt;
+	compat_uint_t src_use_color_key;
+	compat_uint_t src_color_key;
+	compat_uint_t src_pitch;
+	compat_uint_t src_offset_x, src_offset_y;
+	compat_uint_t src_width, src_height;
+
+	compat_uint_t tgt_offset_x, tgt_offset_y;
+	compat_uint_t tgt_width, tgt_height;
+	compat_int_t layer_rotation;
+	compat_int_t layer_type;
+	compat_int_t video_rotation;
+
+	compat_uint_t isTdshp;	/* set to 1, will go through tdshp first, then layer blending, then to color */
+
+	compat_int_t next_buff_idx;
+	compat_int_t identity;
+	compat_int_t connected_type;
+	compat_uint_t security;
+	compat_uint_t alpha_enable;
+	compat_uint_t alpha;
+	compat_int_t fence_fd;	/* 8135 */
+	compat_int_t ion_fd;	/* 8135 CL 2340210 */
+};
+
+#define COMPAT_MTKFB_SET_OVERLAY_LAYER			MTK_IOW(0, struct compat_fb_overlay_layer)
+#define COMPAT_MTKFB_SET_VIDEO_LAYERS			MTK_IOW(2, struct compat_fb_overlay_layer)
+#define COMPAT_MTKFB_CAPTURE_FRAMEBUFFER		MTK_IOW(3, compat_ulong_t)
+#define COMPAT_MTKFB_GET_POWERSTATE				MTK_IOR(21, compat_ulong_t)
+#define COMPAT_MTKFB_AEE_LAYER_EXIST            MTK_IOR(23, compat_ulong_t)
+#define COMPAT_MTKFB_FACTORY_AUTO_TEST          MTK_IOR(25, compat_ulong_t)
+#define COMPAT_MTKFB_META_RESTORE_SCREEN		MTK_IOW(101, compat_ulong_t)
+
+#endif
+
+#endif /*_COMPAT_MTKFB_H_*/
diff --git a/drivers/misc/mediatek/video/mt8173/videox/disp_session.h b/drivers/misc/mediatek/video/mt8173/videox/disp_session.h
index 65884d98427b..30de1874ae34 100644
--- a/drivers/misc/mediatek/video/mt8173/videox/disp_session.h
+++ b/drivers/misc/mediatek/video/mt8173/videox/disp_session.h
@@ -143,28 +143,28 @@ typedef enum {
 
 
 typedef struct disp_session_config_t {
-	DISP_SESSION_TYPE type;
+	unsigned int type;
 	unsigned int device_id;
-	DISP_MODE mode;
+	unsigned int mode;
 	unsigned int session_id;
-	unsigned int          present_fence_idx;
-	DISP_OUTPUT_TYPE output_type;
+	unsigned int present_fence_idx;
+	unsigned int output_type;
 } disp_session_config;
 
 typedef struct {
 	unsigned int session_id;
 	unsigned int vsync_cnt;
-	long int vsync_ts;
+	uint64_t vsync_ts;
 } disp_session_vsync_config;
 
 typedef struct disp_input_config_t {
 	unsigned int layer_id;
 	unsigned int layer_enable;
-	DISP_BUFFER_SOURCE buffer_source;
+	unsigned int buffer_source;
 	void *src_base_addr;
 	void *src_phy_addr;
 	unsigned int src_direct_link;
-	DISP_FORMAT src_fmt;
+	unsigned int src_fmt;
 	unsigned int src_use_color_key;
 	unsigned int src_color_key;
 	unsigned int src_pitch;
@@ -173,23 +173,23 @@ typedef struct disp_input_config_t {
 
 	unsigned int tgt_offset_x, tgt_offset_y;
 	unsigned int tgt_width, tgt_height;
-	DISP_ORIENTATION layer_rotation;
-	DISP_LAYER_TYPE layer_type;
-	DISP_ORIENTATION video_rotation;
+	unsigned int layer_rotation;
+	unsigned int layer_type;
+	unsigned int video_rotation;
 
 	unsigned int isTdshp;	/* set to 1, will go through tdshp first, then layer blending, then to color */
 
 	unsigned int next_buff_idx;
 	int identity;
 	int connected_type;
-	DISP_BUFFER_TYPE security;
+	unsigned int security;
 	unsigned int alpha_enable;
 	unsigned int alpha;
 	unsigned int sur_aen;
-	DISP_ALPHA_TYPE src_alpha;
-	DISP_ALPHA_TYPE dst_alpha;
+	unsigned int src_alpha;
+	unsigned int dst_alpha;
 	unsigned int frm_sequence;
-	DISP_YUV_RANGE_ENUM yuv_range;
+	unsigned int yuv_range;
 
 	unsigned int fps;
 	int64_t timestamp;
@@ -198,14 +198,14 @@ typedef struct disp_input_config_t {
 typedef struct disp_output_config_t {
 	void *va;
 	void *pa;
-	DISP_FORMAT fmt;
+	unsigned int fmt;
 	unsigned int x;
 	unsigned int y;
 	unsigned int width;
 	unsigned int height;
 	unsigned int pitch;
 	unsigned int pitchUV;
-	DISP_BUFFER_TYPE security;
+	unsigned int security;
 	unsigned int buff_idx;
 	unsigned int interface_idx;
 	unsigned int frm_sequence;
@@ -319,94 +319,4 @@ typedef struct disp_caps_t {
 #define	DISP_IOCTL_SET_VSYNC_FPS				DISP_IOW(215, unsigned int)
 #define	DISP_IOCTL_GET_PRESENT_FENCE			DISP_IOW(216, disp_present_fence)
 
-
-#ifdef CONFIG_COMPAT
-#include <linux/compat.h>
-#include <linux/uaccess.h>
-
-typedef struct compat_disp_session_config_t {
-	DISP_SESSION_TYPE type;
-	compat_uint_t device_id;
-	DISP_MODE mode;
-	compat_uint_t session_id;
-} compat_disp_session_config;
-
-typedef struct compat_disp_buffer_info_t {
-	/* Session */
-	compat_uint_t session_id;
-	/* Input */
-	compat_uint_t layer_id;
-	compat_uint_t layer_en;
-	compat_int_t ion_fd;
-	compat_uint_t cache_sync;
-	/* Output */
-	compat_uint_t index;
-	compat_int_t fence_fd;
-} compat_disp_buffer_info;
-
-typedef struct compat_disp_input_config_t {
-	compat_int_t layer_id;
-	compat_int_t layer_enable;
-
-	compat_uptr_t src_base_addr;
-	compat_uptr_t src_phy_addr;
-	compat_uint_t src_direct_link;
-	DISP_FORMAT src_fmt;
-	compat_uint_t src_use_color_key;
-	compat_uint_t src_color_key;
-	compat_uint_t src_pitch;
-	compat_uint_t src_offset_x, src_offset_y;
-	compat_uint_t src_width, src_height;
-
-	compat_uint_t tgt_offset_x, tgt_offset_y;
-	compat_uint_t tgt_width, tgt_height;
-	DISP_ORIENTATION layer_rotation;
-	DISP_LAYER_TYPE layer_type;
-	DISP_ORIENTATION video_rotation;
-
-	compat_uint_t isTdshp;	/* set to 1, will go through tdshp first, then layer blending, then to color */
-
-	compat_uint_t next_buff_idx;
-	compat_int_t identity;
-	compat_int_t connected_type;
-	DISP_BUFFER_TYPE security;
-	compat_uint_t alpha_enable;
-	compat_uint_t alpha;
-} compat_disp_input_config;
-
-typedef struct compat_disp_session_input_config_t {
-	compat_uint_t session_id;
-	compat_uint_t config_layer_num;
-	compat_disp_input_config config[MAX_INPUT_CONFIG];
-} compat_disp_session_input_config;
-
-typedef struct {
-	compat_uint_t session_id;
-	compat_uint_t vsync_cnt;
-	compat_long_t vsync_ts;
-} compat_disp_session_vsync_config;
-
-typedef struct compat_disp_session_info_t {
-	compat_uint_t session_id;
-	compat_uint_t maxLayerNum;
-	compat_uint_t isHwVsyncAvailable;
-	DISP_IF_TYPE displayType;
-	compat_uint_t displayWidth;
-	compat_uint_t displayHeight;
-	compat_uint_t displayFormat;
-	DISP_IF_MODE displayMode;
-	compat_uint_t vsyncFPS;
-	compat_uint_t physicalWidth;
-	compat_uint_t physicalHeight;
-	compat_uint_t isConnected;
-} compat_disp_session_info;
-
-#define	COMPAT_DISP_IOCTL_CREATE_SESSION		DISP_IOW(201, compat_disp_session_config)
-#define	COMPAT_DISP_IOCTL_DESTROY_SESSION		DISP_IOW(202, compat_disp_session_config)
-#define	COMPAT_DISP_IOCTL_TRIGGER_SESSION		DISP_IOW(203, compat_disp_session_config)
-#define COMPAT_DISP_IOCTL_PREPARE_INPUT_BUFFER	DISP_IOW(204, compat_disp_buffer_info)
-#define COMPAT_DISP_IOCTL_SET_INPUT_BUFFER		DISP_IOW(206, compat_disp_session_input_config)
-#define	COMPAT_DISP_IOCTL_WAIT_FOR_VSYNC		DISP_IOW(213, compat_disp_session_vsync_config)
-#define	COMPAT_DISP_IOCTL_GET_SESSION_INFO		DISP_IOW(208, compat_disp_session_info)
-#endif /* CONFIG_COMPAT */
 #endif				/* __DISP_SESSION_H */
diff --git a/drivers/misc/mediatek/video/mt8173/videox/fbconfig_kdebug_rome.c b/drivers/misc/mediatek/video/mt8173/videox/fbconfig_kdebug_rome.c
index f193003ed9a1..8b15444eb03b 100644
--- a/drivers/misc/mediatek/video/mt8173/videox/fbconfig_kdebug_rome.c
+++ b/drivers/misc/mediatek/video/mt8173/videox/fbconfig_kdebug_rome.c
@@ -568,12 +568,30 @@ static int fbconfig_release(struct inode *inode, struct file *file)
 	return 0;
 }
 
+/* compat-ioctl */
+static long compat_fbconfig_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	long ret;
+	void __user *data32;
+
+	if (!file->f_op || !file->f_op->unlocked_ioctl)
+		return -ENOTTY;
+
+	data32 = compat_ptr(arg);
+	ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)data32);
+	return ret;
+}
+
+/* end CONFIG_COMPAT */
 
 static const struct file_operations fbconfig_fops = {
 	.read = fbconfig_read,
 	.write = fbconfig_write,
 	.open = fbconfig_open,
 	.unlocked_ioctl = fbconfig_ioctl,
+#ifdef CONFIG_COMPAT
+	.compat_ioctl = compat_fbconfig_ioctl,
+#endif
 	.release = fbconfig_release,
 };
 
diff --git a/drivers/misc/mediatek/video/mt8173/videox/mtk_disp_mgr.c b/drivers/misc/mediatek/video/mt8173/videox/mtk_disp_mgr.c
index 1fc6a31ff0ad..5b9d8bfbe538 100644
--- a/drivers/misc/mediatek/video/mt8173/videox/mtk_disp_mgr.c
+++ b/drivers/misc/mediatek/video/mt8173/videox/mtk_disp_mgr.c
@@ -32,6 +32,7 @@
 #include <linux/wait.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
+#include <linux/compat.h>
 
 #include "mtk_sync.h"
 
@@ -63,6 +64,7 @@
 #include "disp_session.h"
 #include "mtk_ovl.h"
 #include "ddp_mmp.h"
+#include "compat_mtk_disp_mgr.h"
 
 #ifdef CONFIG_MTK_HDMI_SUPPORT
 #include "extd_ddp.h"
@@ -75,7 +77,6 @@
 #include "mtkfb_fence.h"
 
 /*for fence log?*/
-
 typedef enum {
 	PREPARE_INPUT_FENCE,
 	PREPARE_OUTPUT_FENCE,
@@ -2120,10 +2121,105 @@ long mtk_disp_mgr_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 	return ret;
 }
 
+#ifdef CONFIG_COMPAT
+const char *_session_compat_ioctl_spy(unsigned int cmd)
+{
+	switch (cmd) {
+	case COMPAT_DISP_IOCTL_SET_INPUT_BUFFER:
+		{
+			return "DISP_IOCTL_SET_INPUT_BUFFER";
+		}
+	case COMPAT_DISP_IOCTL_SET_OUTPUT_BUFFER:
+		{
+			return "DISP_IOCTL_SET_OUTPUT_BUFFER";
+		}
+	default:
+		{
+			return "unknown";
+		}
+	}
+}
+
+static long mtk_disp_mgr_compat_ioctl(struct file *file, unsigned int cmd,  unsigned long arg)
+{
+	long ret = -ENOIOCTLCMD;
+	/*DISPMSG("mtk_disp_mgr_compat_ioctl, cmd=%s, arg=0x%08lx\n", _session_compat_ioctl_spy(cmd), arg);*/
+	switch (cmd) {
+	case COMPAT_DISP_IOCTL_SET_INPUT_BUFFER:
+		{
+			return _compat_ioctl_set_input_buffer(file, arg);
+		}
+	case COMPAT_DISP_IOCTL_SET_OUTPUT_BUFFER:
+		{
+		    return _compat_ioctl_set_output_buffer(file, arg);
+		}
+	case DISP_IOCTL_AAL_GET_HIST:
+	case DISP_IOCTL_AAL_EVENTCTL:
+	case DISP_IOCTL_AAL_INIT_REG:
+	case DISP_IOCTL_AAL_SET_PARAM:
+	case DISP_IOCTL_CREATE_SESSION:
+	case DISP_IOCTL_DESTROY_SESSION:
+	case DISP_IOCTL_TRIGGER_SESSION:
+	case DISP_IOCTL_PREPARE_INPUT_BUFFER:
+	case DISP_IOCTL_PREPARE_OUTPUT_BUFFER:
+	case DISP_IOCTL_GET_SESSION_INFO:
+	case DISP_IOCTL_SET_SESSION_MODE:
+	case DISP_IOCTL_WAIT_FOR_VSYNC:
+	case DISP_IOCTL_SET_VSYNC_FPS:
+	case DISP_IOCTL_GET_PRESENT_FENCE:
+		{
+			void __user *data32;
+
+			data32 = compat_ptr(arg);
+			ret = file->f_op->unlocked_ioctl(file, cmd, (unsigned long)data32);
+			return ret;
+		}
+	case DISP_IOCTL_SET_GAMMALUT:
+	case DISP_IOCTL_SET_CCORR:
+	case DISP_IOCTL_SET_PQPARAM:
+	case DISP_IOCTL_GET_PQPARAM:
+	case DISP_IOCTL_SET_PQINDEX:
+	case DISP_IOCTL_SET_TDSHPINDEX:
+	case DISP_IOCTL_GET_TDSHPINDEX:
+	case DISP_IOCTL_SET_PQ_CAM_PARAM:
+	case DISP_IOCTL_GET_PQ_CAM_PARAM:
+	case DISP_IOCTL_SET_PQ_GAL_PARAM:
+	case DISP_IOCTL_GET_PQ_GAL_PARAM:
+	case DISP_IOCTL_PQ_SET_BYPASS_COLOR:
+	case DISP_IOCTL_PQ_SET_WINDOW:
+	case DISP_IOCTL_OD_CTL:
+	case DISP_IOCTL_WRITE_REG:
+	case DISP_IOCTL_READ_REG:
+	case DISP_IOCTL_MUTEX_CONTROL:
+	case DISP_IOCTL_PQ_GET_TDSHP_FLAG:
+	case DISP_IOCTL_PQ_SET_TDSHP_FLAG:
+	case DISP_IOCTL_PQ_GET_DC_PARAM:
+	case DISP_IOCTL_PQ_SET_DC_PARAM:
+	case DISP_IOCTL_WRITE_SW_REG:
+	case DISP_IOCTL_READ_SW_REG:
+		{
+			ret = primary_display_user_cmd(cmd, arg);
+			break;
+		}
+	default:
+		{
+				DISPERR("[%s]ioctl not supported, 0x%08x\n", __func__, cmd);
+				return -ENOIOCTLCMD;
+		}
+	}
+
+	return ret;
+}
+#endif
+
+
 static const struct file_operations mtk_disp_mgr_fops = {
 	.owner = THIS_MODULE,
 	.mmap = mtk_disp_mgr_mmap,
 	.unlocked_ioctl = mtk_disp_mgr_ioctl,
+#ifdef CONFIG_COMPAT
+	.compat_ioctl = mtk_disp_mgr_compat_ioctl,
+#endif
 	.open = mtk_disp_mgr_open,
 	.release = mtk_disp_mgr_release,
 	.flush = mtk_disp_mgr_flush,
diff --git a/drivers/misc/mediatek/video/mt8173/videox/mtkfb.c b/drivers/misc/mediatek/video/mt8173/videox/mtkfb.c
index 5299be3c4a7d..9b19e2a7fc9d 100644
--- a/drivers/misc/mediatek/video/mt8173/videox/mtkfb.c
+++ b/drivers/misc/mediatek/video/mt8173/videox/mtkfb.c
@@ -34,7 +34,7 @@
 /*#include <mach/dma.h>*/
 /*#include <mach/irqs.h>*/
 #include <linux/dma-mapping.h>
-
+#include <linux/compat.h>
 #include <mt-plat/mt_boot.h>
 
 #include "debug.h"
@@ -53,7 +53,7 @@
 #include "ddp_dump.h"
 #include "display_recorder.h"
 #include "fbconfig_kdebug_rome.h"
-
+#include "compat_mtkfb.h"
 #include "mtk_ovl.h"
 
 #if defined(MTK_ALPS_BOX_SUPPORT)
@@ -1600,6 +1600,278 @@ static int mtkfb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg
 	}
 }
 
+#ifdef CONFIG_COMPAT
+
+static void compat_convert(struct compat_fb_overlay_layer *compat_info,
+			   struct fb_overlay_layer *info)
+{
+	info->layer_id = compat_info->layer_id;
+	info->layer_enable = compat_info->layer_enable;
+	info->src_base_addr = (void *)((unsigned long)(compat_info->src_base_addr));
+	info->src_phy_addr = (void *)((unsigned long)(compat_info->src_phy_addr));
+	info->src_direct_link = compat_info->src_direct_link;
+	info->src_fmt = compat_info->src_fmt;
+	info->src_use_color_key = compat_info->src_use_color_key;
+	info->src_color_key = compat_info->src_color_key;
+	info->src_pitch = compat_info->src_pitch;
+	info->src_offset_x = compat_info->src_offset_x;
+	info->src_offset_y = compat_info->src_offset_y;
+	info->src_width = compat_info->src_width;
+	info->src_height = compat_info->src_height;
+	info->tgt_offset_x = compat_info->tgt_offset_x;
+	info->tgt_width = compat_info->tgt_width;
+	info->tgt_height = compat_info->tgt_height;
+	info->layer_rotation = compat_info->layer_rotation;
+	info->layer_type = compat_info->layer_type;
+	info->video_rotation = compat_info->video_rotation;
+
+	info->isTdshp = compat_info->isTdshp;
+	info->next_buff_idx = compat_info->next_buff_idx;
+	info->identity = compat_info->identity;
+	info->connected_type = compat_info->connected_type;
+
+	info->security = compat_info->security;
+	info->alpha_enable = compat_info->alpha_enable;
+	info->alpha = compat_info->alpha;
+	info->fence_fd = compat_info->fence_fd;
+	info->ion_fd = compat_info->ion_fd;
+}
+
+
+static int mtkfb_compat_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
+{
+	struct fb_overlay_layer layerInfo;
+	long ret = 0;
+
+	pr_debug("[FB Driver] mtkfb_compat_ioctl, cmd=0x%08x, cmd nr=0x%08x, cmd size=0x%08x\n", cmd,
+	       (unsigned int)_IOC_NR(cmd), (unsigned int)_IOC_SIZE(cmd));
+
+	switch (cmd) {
+	case MTKFB_GET_FRAMEBUFFER_MVA:
+		{
+			compat_uint_t __user *data32;
+			__u32 data;
+
+			data32 = compat_ptr(arg);
+			data = (__u32) fb_pa;
+			if (put_user(data, data32)) {
+				pr_err("MTKFB_FRAMEBUFFER_MVA failed\n");
+				ret = -EFAULT;
+			}
+			pr_debug("MTKFB_FRAMEBUFFER_MVA success 0x%lx\n", fb_pa);
+			return ret;
+		}
+	case MTKFB_GET_DISPLAY_IF_INFORMATION:
+		{
+			compat_uint_t __user *data32;
+			compat_uint_t displayid = 0;
+
+			data32 = compat_ptr(arg);
+			if (get_user(displayid, data32)) {
+				pr_err("MTKFB_GET_DISPLAY_IF_INFORMATION failed\n");
+				return -EFAULT;
+			}
+			if (displayid > MTKFB_MAX_DISPLAY_COUNT) {
+				pr_err("[FB]: invalid display id:%d\n", displayid);
+				return -EFAULT;
+			}
+			if (displayid == 0) {
+				dispif_info[displayid].displayWidth = primary_display_get_width();
+				dispif_info[displayid].displayHeight = primary_display_get_height();
+
+				dispif_info[displayid].lcmOriginalWidth =
+					primary_display_get_original_width();
+				dispif_info[displayid].lcmOriginalHeight =
+					primary_display_get_original_height();
+				dispif_info[displayid].displayMode =
+					primary_display_is_video_mode() ? 0 : 1;
+			} else {
+				DISPERR("information for displayid: %d is not available now\n",
+				displayid);
+			}
+
+			if (copy_to_user((void __user *)arg,
+				&(dispif_info[displayid]), sizeof(mtk_dispif_info_t))) {
+				pr_err("[FB]: copy_to_user failed! line:%d\n", __LINE__);
+				return -EFAULT;
+			}
+			break;
+		}
+	case MTKFB_POWEROFF:
+		{
+			ret = mtkfb_ioctl(info, MTKFB_POWEROFF, arg);
+			break;
+		}
+
+	case MTKFB_POWERON:
+		{
+			ret = mtkfb_ioctl(info, MTKFB_POWERON, arg);
+			break;
+		}
+	case COMPAT_MTKFB_GET_POWERSTATE:
+		{
+			compat_uint_t __user *data32;
+			int power_state = 0;
+
+			data32 = compat_ptr(arg);
+			if (primary_display_is_sleepd())
+				power_state = 0;
+			else
+				power_state = 1;
+			if (put_user(power_state, data32)) {
+				pr_err("MTKFB_GET_POWERSTATE failed\n");
+				ret = -EFAULT;
+			}
+			pr_debug("MTKFB_GET_POWERSTATE success %d\n", power_state);
+			break;
+		}
+	case COMPAT_MTKFB_CAPTURE_FRAMEBUFFER:
+		{
+			compat_ulong_t __user *data32;
+			unsigned long *pbuf;
+			compat_ulong_t l;
+
+			data32 = compat_ptr(arg);
+			pbuf = compat_alloc_user_space(sizeof(unsigned long));
+			ret = get_user(l, data32);
+			ret |= put_user(l, pbuf);
+			primary_display_capture_framebuffer_ovl(*pbuf, eBGRA8888);
+			break;
+		}
+	case MTKFB_TRIG_OVERLAY_OUT:
+		{
+			arg = (unsigned long)compat_ptr(arg);
+			ret = mtkfb_ioctl(info, MTKFB_TRIG_OVERLAY_OUT, arg);
+			break;
+		}
+	case COMPAT_MTKFB_META_RESTORE_SCREEN:
+		{
+			arg = (unsigned long)compat_ptr(arg);
+			ret = mtkfb_ioctl(info, MTKFB_META_RESTORE_SCREEN, arg);
+			break;
+		}
+
+	case COMPAT_MTKFB_SET_OVERLAY_LAYER:
+		{
+			struct compat_fb_overlay_layer compat_layerInfo;
+
+			MTKFB_LOG(" mtkfb_compat_ioctl():MTKFB_SET_OVERLAY_LAYER\n");
+
+			arg = (unsigned long)compat_ptr(arg);
+			if (copy_from_user(&compat_layerInfo, (void __user *)arg, sizeof(compat_layerInfo))) {
+				MTKFB_LOG("[FB Driver]: copy_from_user failed! line:%d\n",
+					  __LINE__);
+				ret = -EFAULT;
+			} else {
+				primary_disp_input_config input;
+
+				compat_convert(&compat_layerInfo, &layerInfo);
+
+				/* in early suspend mode ,will not update buffer index, info SF by return value */
+				if (primary_display_is_sleepd()) {
+					pr_err("[FB Driver] error, set overlay in early suspend ,skip!\n");
+					return MTKFB_ERROR_IS_EARLY_SUSPEND;
+				}
+
+				memset((void *)&input, 0, sizeof(primary_disp_input_config));
+				_convert_fb_layer_to_disp_input(&layerInfo, &input);
+				primary_display_config_input(&input);
+				primary_display_trigger(1, NULL, 0);
+
+			#if defined(MTK_ALPS_BOX_SUPPORT)
+				MTKFB_LOG("%s COMPAT_MTKFB_SET_OVERLAY_LAYER ext_disp_config_input\n",
+					  __func__);
+				if (factory_mode) {
+					ext_disp_config_input((ext_disp_input_config *) &input);
+					ext_disp_trigger(true, NULL, 0);
+				}
+			#endif
+			}
+		}
+		break;
+
+	case COMPAT_MTKFB_SET_VIDEO_LAYERS:
+		{
+			struct compat_fb_overlay_layer compat_layerInfo[VIDEO_LAYER_COUNT];
+
+			MTKFB_LOG(" mtkfb_compat_ioctl():MTKFB_SET_VIDEO_LAYERS\n");
+
+			if (copy_from_user(&compat_layerInfo, (void __user *)arg, sizeof(compat_layerInfo))) {
+				MTKFB_LOG("[FB Driver]: copy_from_user failed! line:%d\n",
+					  __LINE__);
+				ret = -EFAULT;
+			} else {
+				int32_t i;
+				primary_disp_input_config input;
+
+				for (i = 0; i < VIDEO_LAYER_COUNT; ++i) {
+					compat_convert(&compat_layerInfo[i], &layerInfo);
+					memset((void *)&input, 0, sizeof(primary_disp_input_config));
+					_convert_fb_layer_to_disp_input(&layerInfo, &input);
+					primary_display_config_input(&input);
+
+				#if defined(MTK_ALPS_BOX_SUPPORT)
+					if (factory_mode) {
+						MTKFB_LOG("%s  ext_disp_config_input\n", __func__);
+						ext_disp_config_input((ext_disp_input_config *) &
+								      input);
+					}
+				#endif
+				}
+				primary_display_trigger(1, NULL, 0);
+
+			#if defined(MTK_ALPS_BOX_SUPPORT)
+				if (factory_mode) {
+					MTKFB_LOG("%s ext_disp_trigger\n", __func__);
+					ext_disp_trigger(true, NULL, 0);
+				}
+			#endif
+			}
+		}
+		break;
+	case COMPAT_MTKFB_AEE_LAYER_EXIST:
+		{
+			int dal_en = is_DAL_Enabled();
+			compat_ulong_t __user *data32;
+
+			data32 = compat_ptr(arg);
+			if (put_user(dal_en, data32)) {
+				pr_err("MTKFB_GET_POWERSTATE failed\n");
+				ret = -EFAULT;
+			}
+			break;
+		}
+	case COMPAT_MTKFB_FACTORY_AUTO_TEST:
+		{
+			unsigned long result = 0;
+			compat_ulong_t __user *data32;
+
+			DISPMSG("factory mode: lcm auto test\n");
+			result = mtkfb_fm_auto_test();
+			data32 = compat_ptr(arg);
+			if (put_user(result, data32)) {
+				pr_err("MTKFB_GET_POWERSTATE failed\n");
+				ret = -EFAULT;
+			}
+			break;
+			/*return copy_to_user(argp, &result, sizeof(result)) ? -EFAULT : 0;*/
+		}
+	case MTKFB_META_SHOW_BOOTLOGO:
+		{
+			arg = (unsigned long)compat_ptr(arg);
+			ret = mtkfb_ioctl(info, MTKFB_META_SHOW_BOOTLOGO, arg);
+			break;
+		}
+	default:
+		/* NOTHING DIFFERENCE with standard ioctl calling */
+		arg = (unsigned long)compat_ptr(arg);
+		ret = mtkfb_ioctl(info, cmd, arg);
+		break;
+	}
+
+	return ret;
+}
+#endif
 
 static int mtkfb_pan_display_proxy(struct fb_var_screeninfo *var, struct fb_info *info)
 {
@@ -1667,6 +1939,9 @@ static struct fb_ops mtkfb_ops = {
 	.fb_check_var = mtkfb_check_var,
 	.fb_set_par = mtkfb_set_par,
 	.fb_ioctl = mtkfb_ioctl,
+#ifdef CONFIG_COMPAT
+	.fb_compat_ioctl = mtkfb_compat_ioctl,
+#endif
 #if defined(CONFIG_PM_AUTOSLEEP)
 	.fb_blank = mtkfb_blank,
 #endif