libhdmi: add placeholders and update for hwcomposer compatibility

Change-Id: I592230db0d39527591981200fb7174d3926e9bbe

14 files changed, 1882 insertions, 274 deletions

diff --git a/exynos4/hal/include/SecHdmi.h b/exynos4/hal/include/SecHdmi.h
index 08bee20..1dea5b7 100644
--- a/exynos4/hal/include/SecHdmi.h
+++ b/exynos4/hal/include/SecHdmi.h
@@ -61,6 +61,10 @@
 
 #include <utils/threads.h>
 
+#define NUM_SUPPORTED_RESOLUTION_2D      (14)
+#define NUM_SUPPORTED_RESOLUTION_S3D_TB  (4)
+#define NUM_SUPPORTED_RESOLUTION_S3D_SBS (3)
+
 
 namespace android {
 
@@ -75,6 +79,12 @@ public :
         HDMI_LAYER_MAX,
     };
 
+    enum HDMI_S3D_MODE {
+        HDMI_2D = 0,
+        HDMI_S3D_TB,
+        HDMI_S3D_SBS,
+    };
+
 private :
     class CECThread: public Thread
     {
@@ -129,6 +139,7 @@ private :
 
     int          mHdmiOutputMode;
     unsigned int mHdmiResolutionValue;
+    unsigned int mHdmiS3DMode;
 
     unsigned int mHdmiPresetId;
     v4l2_std_id  mHdmiStdId;
@@ -141,17 +152,19 @@ private :
 
     int          mCurrentHdmiOutputMode;
     unsigned int mCurrentHdmiResolutionValue;
+    unsigned int mCurrentHdmiS3DMode;
     bool         mCurrentHdcpMode;
     int          mCurrentAudioMode;
     bool         mHdmiInfoChange;
 
     int          mFimcDstColorFormat;
 
-    SecBuffer    mFimcReservedMem[HDMI_FIMC_OUTPUT_BUF_NUM];
-    unsigned int mFimcCurrentOutBufIndex;
+    SecBuffer    mFimcReservedMem;
     SecFimc      mSecFimc;
 
-    unsigned int mHdmiResolutionValueList[14];
+    unsigned int mHdmiResolutionValueList[NUM_SUPPORTED_RESOLUTION_2D];
+    unsigned int mHdmiS3dTbResolutionValueList[NUM_SUPPORTED_RESOLUTION_S3D_TB];
+    unsigned int mHdmiS3dSbsResolutionValueList[NUM_SUPPORTED_RESOLUTION_S3D_SBS];
     int          mHdmiSizeOfResolutionValueList;
 
     SecBuffer    mMixerBuffer[HDMI_LAYER_MAX][MAX_BUFFERS_MIXER];
@@ -195,7 +208,8 @@ public :
 	bool        clear(int hdmiLayer);
 
     bool        setHdmiOutputMode(int hdmiOutputMode, bool forceRun = false);
-    bool        setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun = false);
+    bool        setHdmiResolution(unsigned int hdmiResolutionValue, unsigned int s3dMode, bool forceRun = false);
+    unsigned int getHdmiResolution(void);
     bool        setHdcpMode(bool hdcpMode, bool forceRun = false);
     bool        setUIRotation(unsigned int rotVal, unsigned int hwcLayer);
     bool        setDisplaySize(int width, int height);
@@ -207,12 +221,12 @@ private:
     bool        m_startHdmi(int hdmiLayer);
     bool        m_stopHdmi(int hdmiLayer);
     bool        m_setHdmiOutputMode(int hdmiOutputMode);
-    bool        m_setHdmiResolution(unsigned int hdmiResolutionValue);
+    bool        m_setHdmiResolution(unsigned int hdmiResolutionValue, unsigned int s3dMode);
     bool        m_setCompositeResolution(unsigned int compositeStdId);
     bool        m_setHdcpMode(bool hdcpMode);
     bool        m_setAudioMode(int audioMode);
 
-    int         m_resolutionValueIndex(unsigned int ResolutionValue);
+    int         m_resolutionValueIndex(unsigned int ResolutionValue, unsigned int s3dMode);
     bool        m_flagHWConnected(void);
 };
 
diff --git a/exynos4/hal/include/sec_utils.h b/exynos4/hal/include/sec_utils.h
index c99dec6..bd1822d 100644
--- a/exynos4/hal/include/sec_utils.h
+++ b/exynos4/hal/include/sec_utils.h
@@ -28,9 +28,8 @@
 extern "C" {
 #endif
 
-#include <linux/videodev2.h>
-#include "videodev2_exynos_camera.h"
-#include "videodev2_exynos_media.h"
+#include <videodev2.h>
+#include "videodev2_samsung.h"
 
 #ifdef __cplusplus
 }
diff --git a/exynos4/hal/include/videodev2_samsung.h b/exynos4/hal/include/videodev2_samsung.h
new file mode 100644
index 0000000..f681d2b
--- /dev/null
+++ b/exynos4/hal/include/videodev2_samsung.h
@@ -0,0 +1,1225 @@
+/*
+ * Video for Linux Two header file for samsung
+ *
+ * Copyright (C) 2009, Dongsoo Nathaniel Kim<dongsoo45.kim@samsung.com>
+ *
+ * This header file contains several v4l2 APIs to be proposed to v4l2
+ * community and until bein accepted, will be used restrictly in Samsung's
+ * camera interface driver FIMC.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __LINUX_VIDEODEV2_SAMSUNG_H
+#define __LINUX_VIDEODEV2_SAMSUNG_H
+
+/* Values for 'capabilities' field */
+/* Object detection device */
+#define V4L2_CAP_OBJ_RECOGNITION    0x10000000
+/* strobe control */
+#define V4L2_CAP_STROBE         0x20000000
+
+#define V4L2_CID_FOCUS_MODE     (V4L2_CID_CAMERA_CLASS_BASE+17)
+/* Focus Methods */
+enum v4l2_focus_mode {
+    V4L2_FOCUS_MODE_AUTO        = 0,
+    V4L2_FOCUS_MODE_MACRO       = 1,
+    V4L2_FOCUS_MODE_MANUAL      = 2,
+    V4L2_FOCUS_MODE_LASTP       = 2,
+};
+
+#define V4L2_CID_ZOOM_MODE      (V4L2_CID_CAMERA_CLASS_BASE+18)
+/* Zoom Methods */
+enum v4l2_zoom_mode {
+    V4L2_ZOOM_MODE_CONTINUOUS   = 0,
+    V4L2_ZOOM_MODE_OPTICAL      = 1,
+    V4L2_ZOOM_MODE_DIGITAL      = 2,
+    V4L2_ZOOM_MODE_LASTP        = 2,
+};
+
+/* Exposure Methods */
+#define V4L2_CID_PHOTOMETRY     (V4L2_CID_CAMERA_CLASS_BASE+19)
+enum v4l2_photometry_mode {
+    V4L2_PHOTOMETRY_MULTISEG    = 0, /*Multi Segment*/
+    V4L2_PHOTOMETRY_CWA     = 1, /*Centre Weighted Average*/
+    V4L2_PHOTOMETRY_SPOT        = 2,
+    V4L2_PHOTOMETRY_AFSPOT      = 3, /*Spot metering on focused point*/
+    V4L2_PHOTOMETRY_LASTP       = V4L2_PHOTOMETRY_AFSPOT,
+};
+
+/* Manual exposure control items menu type: iris, shutter, iso */
+#define V4L2_CID_CAM_APERTURE   (V4L2_CID_CAMERA_CLASS_BASE+20)
+#define V4L2_CID_CAM_SHUTTER    (V4L2_CID_CAMERA_CLASS_BASE+21)
+#define V4L2_CID_CAM_ISO    (V4L2_CID_CAMERA_CLASS_BASE+22)
+
+/* Following CIDs are menu type */
+#define V4L2_CID_SCENEMODE  (V4L2_CID_CAMERA_CLASS_BASE+23)
+#define V4L2_CID_CAM_STABILIZE  (V4L2_CID_CAMERA_CLASS_BASE+24)
+#define V4L2_CID_CAM_MULTISHOT  (V4L2_CID_CAMERA_CLASS_BASE+25)
+
+/* Control dynamic range */
+#define V4L2_CID_CAM_DR     (V4L2_CID_CAMERA_CLASS_BASE+26)
+
+/* White balance preset control */
+#define V4L2_CID_WHITE_BALANCE_PRESET   (V4L2_CID_CAMERA_CLASS_BASE+27)
+#define V4L2_CID_CAM_SENSOR_FW_VER		(V4L2_CID_CAMERA_CLASS_BASE + 28)
+#define V4L2_CID_CAM_PHONE_FW_VER		(V4L2_CID_CAMERA_CLASS_BASE + 29)
+
+/* CID extensions */
+#define V4L2_CID_ROTATION       (V4L2_CID_PRIVATE_BASE + 0)
+#define V4L2_CID_PADDR_Y        (V4L2_CID_PRIVATE_BASE + 1)
+#define V4L2_CID_PADDR_CB       (V4L2_CID_PRIVATE_BASE + 2)
+#define V4L2_CID_PADDR_CR       (V4L2_CID_PRIVATE_BASE + 3)
+#define V4L2_CID_PADDR_CBCR     (V4L2_CID_PRIVATE_BASE + 4)
+#define V4L2_CID_OVERLAY_AUTO       (V4L2_CID_PRIVATE_BASE + 5)
+#define V4L2_CID_OVERLAY_VADDR0     (V4L2_CID_PRIVATE_BASE + 6)
+#define V4L2_CID_OVERLAY_VADDR1     (V4L2_CID_PRIVATE_BASE + 7)
+#define V4L2_CID_OVERLAY_VADDR2     (V4L2_CID_PRIVATE_BASE + 8)
+#define V4L2_CID_OVLY_MODE      (V4L2_CID_PRIVATE_BASE + 9)
+#define V4L2_CID_DST_INFO       (V4L2_CID_PRIVATE_BASE + 10)
+/* UMP secure id control */
+#define V4L2_CID_GET_UMP_SECURE_ID  (V4L2_CID_PRIVATE_BASE + 11)
+//#define V4L2_CID_GET_PHY_SRC_YADDR 	(V4L2_CID_PRIVATE_BASE + 12) //lt, mr1
+//#define V4L2_CID_GET_PHY_SRC_CADDR 	(V4L2_CID_PRIVATE_BASE + 13)
+#define V4L2_CID_IMAGE_EFFECT_FN    (V4L2_CID_PRIVATE_BASE + 16)
+#define V4L2_CID_IMAGE_EFFECT_APPLY (V4L2_CID_PRIVATE_BASE + 17)
+#define V4L2_CID_IMAGE_EFFECT_CB    (V4L2_CID_PRIVATE_BASE + 18)
+#define V4L2_CID_IMAGE_EFFECT_CR    (V4L2_CID_PRIVATE_BASE + 19)
+#define V4L2_CID_RESERVED_MEM_BASE_ADDR (V4L2_CID_PRIVATE_BASE + 20)
+#define V4L2_CID_FIMC_VERSION       (V4L2_CID_PRIVATE_BASE + 21)
+
+#define V4L2_CID_STREAM_PAUSE           (V4L2_CID_PRIVATE_BASE + 53)
+
+/* CID Extensions for camera sensor operations */
+#define V4L2_CID_CAM_PREVIEW_ONOFF      (V4L2_CID_PRIVATE_BASE + 64)
+#define V4L2_CID_CAM_CAPTURE            (V4L2_CID_PRIVATE_BASE + 65)
+#define V4L2_CID_CAM_JPEG_MEMSIZE       (V4L2_CID_PRIVATE_BASE + 66)
+
+#define V4L2_CID_CAM_DATE_INFO_YEAR             (V4L2_CID_PRIVATE_BASE + 14)
+#define V4L2_CID_CAM_DATE_INFO_MONTH            (V4L2_CID_PRIVATE_BASE + 15)
+#define V4L2_CID_CAM_DATE_INFO_DATE             (V4L2_CID_PRIVATE_BASE + 22)
+#define V4L2_CID_CAM_SENSOR_VER                 (V4L2_CID_PRIVATE_BASE + 23)
+#define V4L2_CID_CAM_FW_MINOR_VER               (V4L2_CID_PRIVATE_BASE + 24)
+#define V4L2_CID_CAM_FW_MAJOR_VER               (V4L2_CID_PRIVATE_BASE + 25)
+#define V4L2_CID_CAM_PRM_MINOR_VER              (V4L2_CID_PRIVATE_BASE + 26)
+#define V4L2_CID_CAM_PRM_MAJOR_VER              (V4L2_CID_PRIVATE_BASE + 27)
+#define V4L2_CID_CAM_FW_VER                     (V4L2_CID_PRIVATE_BASE + 28)
+#define V4L2_CID_CAM_SET_FW_ADDR                (V4L2_CID_PRIVATE_BASE + 29)
+#define V4L2_CID_CAM_SET_FW_SIZE                (V4L2_CID_PRIVATE_BASE + 30)
+#define V4L2_CID_CAM_UPDATE_FW  (V4L2_CID_PRIVATE_BASE + 31)
+enum v4l2_firmware_mode {
+	FW_MODE_UPDATE,
+	FW_MODE_VERSION,
+	FW_MODE_DUMP,
+};
+
+#define V4L2_CID_CAM_JPEG_MAIN_SIZE     (V4L2_CID_PRIVATE_BASE + 32)
+#define V4L2_CID_CAM_JPEG_MAIN_OFFSET       (V4L2_CID_PRIVATE_BASE + 33)
+#define V4L2_CID_CAM_JPEG_THUMB_SIZE        (V4L2_CID_PRIVATE_BASE + 34)
+#define V4L2_CID_CAM_JPEG_THUMB_OFFSET      (V4L2_CID_PRIVATE_BASE + 35)
+#define V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET   (V4L2_CID_PRIVATE_BASE + 36)
+#define V4L2_CID_CAM_JPEG_QUALITY   (V4L2_CID_PRIVATE_BASE + 37)
+#define V4L2_CID_CAM_SENSOR_MAKER   (V4L2_CID_PRIVATE_BASE + 38)
+#define V4L2_CID_CAM_SENSOR_OPTICAL (V4L2_CID_PRIVATE_BASE + 39)
+#define V4L2_CID_CAM_AF_VER_LOW     (V4L2_CID_PRIVATE_BASE + 40)
+#define V4L2_CID_CAM_AF_VER_HIGH    (V4L2_CID_PRIVATE_BASE + 41)
+#define V4L2_CID_CAM_GAMMA_RG_LOW   (V4L2_CID_PRIVATE_BASE + 42)
+#define V4L2_CID_CAM_GAMMA_RG_HIGH  (V4L2_CID_PRIVATE_BASE + 43)
+#define V4L2_CID_CAM_GAMMA_BG_LOW   (V4L2_CID_PRIVATE_BASE + 44)
+#define V4L2_CID_CAM_GAMMA_BG_HIGH  (V4L2_CID_PRIVATE_BASE + 45)
+#define V4L2_CID_CAM_DUMP_FW        (V4L2_CID_PRIVATE_BASE + 46)
+#define V4L2_CID_CAM_GET_DUMP_SIZE  (V4L2_CID_PRIVATE_BASE + 47)
+#define V4L2_CID_CAMERA_VT_MODE         (V4L2_CID_PRIVATE_BASE + 48)
+#define V4L2_CID_CAMERA_VGA_BLUR    (V4L2_CID_PRIVATE_BASE + 49)
+#define V4L2_CID_CAMERA_CAPTURE     (V4L2_CID_PRIVATE_BASE + 50)
+#define V4L2_CID_CAMERA_HDR	 	(V4L2_CID_PRIVATE_BASE + 51)
+
+#define V4L2_CID_MAIN_SW_DATE_INFO_YEAR     (V4L2_CID_PRIVATE_BASE + 54)
+#define V4L2_CID_MAIN_SW_DATE_INFO_MONTH    (V4L2_CID_PRIVATE_BASE + 55)
+#define V4L2_CID_MAIN_SW_DATE_INFO_DATE     (V4L2_CID_PRIVATE_BASE + 56)
+#define V4L2_CID_MAIN_SW_FW_MINOR_VER       (V4L2_CID_PRIVATE_BASE + 57)
+#define V4L2_CID_MAIN_SW_FW_MAJOR_VER       (V4L2_CID_PRIVATE_BASE + 58)
+#define V4L2_CID_MAIN_SW_PRM_MINOR_VER      (V4L2_CID_PRIVATE_BASE + 59)
+#define V4L2_CID_MAIN_SW_PRM_MAJOR_VER      (V4L2_CID_PRIVATE_BASE + 60)
+
+
+/* SLIM IS control */
+#define V4L2_CID_FIMC_IS_BASE               (V4L2_CTRL_CLASS_CAMERA | 0x1000)
+//#define V4L2_CID_FIMC_IS_TUNE_BASE		(V4L2_CTRL_CLASS_CAMERA | 0x2000) //lt, mr1
+
+#define V4L2_CID_IS_LOAD_FW                 (V4L2_CID_FIMC_IS_BASE + 10)
+#define V4L2_CID_IS_INIT_PARAM              (V4L2_CID_FIMC_IS_BASE + 11)
+//#define V4L2_CID_IS_RESET			(V4L2_CID_FIMC_IS_BASE + 12) //lt, mr1
+#define V4L2_CID_IS_RESETi                  (V4L2_CID_FIMC_IS_BASE + 12)
+#define V4L2_CID_IS_S_POWER                 (V4L2_CID_FIMC_IS_BASE + 13)
+enum is_set_power {
+    IS_POWER_OFF,
+    IS_POWER_ON
+};
+
+#define V4L2_CID_IS_S_STREAM                (V4L2_CID_FIMC_IS_BASE + 14)
+enum is_set_stream {
+    IS_DISABLE_STREAM,
+    IS_ENABLE_STREAM
+};
+
+#define V4L2_CID_IS_S_SCENARIO_MODE         (V4L2_CID_FIMC_IS_BASE + 15)
+#define V4L2_CID_IS_S_FORMAT_SCENARIO       (V4L2_CID_FIMC_IS_BASE + 16)
+enum scenario_mode {
+    IS_MODE_PREVIEW_STILL,
+    IS_MODE_PREVIEW_VIDEO,
+    IS_MODE_CAPTURE_STILL,
+    IS_MODE_CAPTURE_VIDEO,
+    IS_MODE_MAX
+};
+
+/* global */
+#define V4L2_CID_IS_CAMERA_SHOT_MODE_NORMAL      (V4L2_CID_FIMC_IS_BASE + 101)
+/* value : 1 : single shot , >=2 : continuous shot */
+
+#define V4L2_CID_IS_CAMERA_SENSOR_NUM       (V4L2_CID_FIMC_IS_BASE + 201)
+
+#define V4L2_CID_IS_CAMERA_FOCUS_MODE       (V4L2_CID_FIMC_IS_BASE + 401)
+enum is_focus_mode {
+    IS_FOCUS_MODE_AUTO,
+    IS_FOCUS_MODE_MACRO,
+    IS_FOCUS_MODE_INFINITY,
+    IS_FOCUS_MODE_CONTINUOUS,
+    IS_FOCUS_MODE_TOUCH,
+    IS_FOCUS_MODE_FACEDETECT,
+	IS_FOCUS_MODE_IDLE,
+    IS_FOCUS_MODE_MAX,
+};
+
+#define V4L2_CID_IS_CAMERA_FLASH_MODE        (V4L2_CID_FIMC_IS_BASE + 402)
+enum is_flash_mode {
+    IS_FLASH_MODE_OFF,
+    IS_FLASH_MODE_AUTO,
+    IS_FLASH_MODE_AUTO_REDEYE,
+    IS_FLASH_MODE_ON,
+    IS_FLASH_MODE_TORCH,
+    IS_FLASH_MODE_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_AWB_MODE        (V4L2_CID_FIMC_IS_BASE + 403)
+enum is_awb_mode {
+    IS_AWB_AUTO,
+    IS_AWB_DAYLIGHT,
+    IS_AWB_CLOUDY,
+    IS_AWB_TUNGSTEN,
+    IS_AWB_FLUORESCENT,
+    IS_AWB_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_IMAGE_EFFECT        (V4L2_CID_FIMC_IS_BASE + 404)
+enum is_image_effect {
+    IS_IMAGE_EFFECT_DISABLE,
+    IS_IMAGE_EFFECT_MONOCHROME,
+    IS_IMAGE_EFFECT_NEGATIVE_MONO,
+    IS_IMAGE_EFFECT_NEGATIVE_COLOR,
+    IS_IMAGE_EFFECT_SEPIA,
+    IS_IMAGE_EFFECT_SEPIA_CB,
+    IS_IMAGE_EFFECT_SEPIA_CR,
+    IS_IMAGE_EFFECT_NEGATIVE,
+    IS_IMAGE_EFFECT_ARTFREEZE,
+    IS_IMAGE_EFFECT_EMBOSSING,
+    IS_IMAGE_EFFECT_SILHOUETTE,
+    IS_IMAGE_EFFECT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_ISO            (V4L2_CID_FIMC_IS_BASE + 405)
+enum is_iso {
+    IS_ISO_AUTO,
+    IS_ISO_50,
+    IS_ISO_100,
+    IS_ISO_200,
+    IS_ISO_400,
+    IS_ISO_800,
+    IS_ISO_1600,
+    IS_ISO_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_CONTRAST        (V4L2_CID_FIMC_IS_BASE + 406)
+enum is_contrast {
+    IS_CONTRAST_AUTO,
+    IS_CONTRAST_MINUS_2,
+    IS_CONTRAST_MINUS_1,
+    IS_CONTRAST_DEFAULT,
+    IS_CONTRAST_PLUS_1,
+    IS_CONTRAST_PLUS_2,
+    IS_CONTRAST_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_SATURATION        (V4L2_CID_FIMC_IS_BASE + 407)
+enum is_saturation {
+    IS_SATURATION_MINUS_2,
+    IS_SATURATION_MINUS_1,
+    IS_SATURATION_DEFAULT,
+    IS_SATURATION_PLUS_1,
+    IS_SATURATION_PLUS_2,
+    IS_SATURATION_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_SHARPNESS        (V4L2_CID_FIMC_IS_BASE + 408)
+enum is_sharpness {
+    IS_SHARPNESS_MINUS_2,
+    IS_SHARPNESS_MINUS_1,
+    IS_SHARPNESS_DEFAULT,
+    IS_SHARPNESS_PLUS_1,
+    IS_SHARPNESS_PLUS_2,
+    IS_SHARPNESS_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_EXPOSURE        (V4L2_CID_FIMC_IS_BASE + 409)
+enum is_exposure {
+    IS_EXPOSURE_MINUS_4,
+    IS_EXPOSURE_MINUS_3,
+    IS_EXPOSURE_MINUS_2,
+    IS_EXPOSURE_MINUS_1,
+    IS_EXPOSURE_DEFAULT,
+    IS_EXPOSURE_PLUS_1,
+    IS_EXPOSURE_PLUS_2,
+    IS_EXPOSURE_PLUS_3,
+    IS_EXPOSURE_PLUS_4,
+    IS_EXPOSURE_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_BRIGHTNESS        (V4L2_CID_FIMC_IS_BASE + 410)
+enum is_brightness {
+    IS_BRIGHTNESS_MINUS_2,
+    IS_BRIGHTNESS_MINUS_1,
+    IS_BRIGHTNESS_DEFAULT,
+    IS_BRIGHTNESS_PLUS_1,
+    IS_BRIGHTNESS_PLUS_2,
+    IS_BRIGHTNESS_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_HUE            (V4L2_CID_FIMC_IS_BASE + 411)
+enum is_hue {
+    IS_HUE_MINUS_2,
+    IS_HUE_MINUS_1,
+    IS_HUE_DEFAULT,
+    IS_HUE_PLUS_1,
+    IS_HUE_PLUS_2,
+    IS_HUE_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_METERING        (V4L2_CID_FIMC_IS_BASE + 412)
+enum is_metering {
+    IS_METERING_AVERAGE,
+    IS_METERING_SPOT,
+    IS_METERING_MATRIX,
+    IS_METERING_CENTER,
+    IS_METERING_MAX
+};
+#define V4L2_CID_IS_CAMERA_METERING_POSITION_X  (V4L2_CID_FIMC_IS_BASE + 500)
+#define V4L2_CID_IS_CAMERA_METERING_POSITION_Y  (V4L2_CID_FIMC_IS_BASE + 501)
+#define V4L2_CID_IS_CAMERA_METERING_WINDOW_X    (V4L2_CID_FIMC_IS_BASE + 502)
+#define V4L2_CID_IS_CAMERA_METERING_WINDOW_Y    (V4L2_CID_FIMC_IS_BASE + 503)
+
+#define V4L2_CID_IS_CAMERA_AFC_MODE        (V4L2_CID_FIMC_IS_BASE + 413)
+enum is_afc_mode {
+    IS_AFC_DISABLE,
+    IS_AFC_AUTO,
+    IS_AFC_MANUAL_50HZ,
+    IS_AFC_MANUAL_60HZ,
+    IS_AFC_MAX
+};
+/*
+#define V4L2_CID_IS_AWB_LOCK_UNLOCK		(V4L2_CID_FIMC_IS_BASE + 496)
+enum is_awb_lock_unlock {
+	IS_AWB_LOCK,
+	IS_AWB_UNLOCK,
+	IS_AWB_LOCK_UNLOCK_MAX
+};
+
+#define V4L2_CID_IS_AE_LOCK_UNLOCK		(V4L2_CID_FIMC_IS_BASE + 497)
+enum is_ae_lock_unlock {
+	IS_AE_LOCK,
+	IS_AE_UNLOCK,
+	IS_AE_LOCK_UNLOCK_MAX
+};
+*/ //lt, mr1
+#define V4L2_CID_IS_FD_GET_FACE_COUNT               (V4L2_CID_FIMC_IS_BASE + 600)
+#define V4L2_CID_IS_FD_GET_FACE_FRAME_NUMBER        (V4L2_CID_FIMC_IS_BASE + 601)
+#define V4L2_CID_IS_FD_GET_FACE_CONFIDENCE          (V4L2_CID_FIMC_IS_BASE + 602)
+#define V4L2_CID_IS_FD_GET_FACE_SMILE_LEVEL         (V4L2_CID_FIMC_IS_BASE + 603)
+#define V4L2_CID_IS_FD_GET_FACE_BLINK_LEVEL         (V4L2_CID_FIMC_IS_BASE + 604)
+#define V4L2_CID_IS_FD_GET_FACE_TOPLEFT_X           (V4L2_CID_FIMC_IS_BASE + 605)
+#define V4L2_CID_IS_FD_GET_FACE_TOPLEFT_Y           (V4L2_CID_FIMC_IS_BASE + 606)
+#define V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_X       (V4L2_CID_FIMC_IS_BASE + 607)
+#define V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_Y       (V4L2_CID_FIMC_IS_BASE + 608)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_X       (V4L2_CID_FIMC_IS_BASE + 609)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_Y       (V4L2_CID_FIMC_IS_BASE + 610)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_X   (V4L2_CID_FIMC_IS_BASE + 611)
+#define V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_Y   (V4L2_CID_FIMC_IS_BASE + 612)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_X      (V4L2_CID_FIMC_IS_BASE + 613)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_Y      (V4L2_CID_FIMC_IS_BASE + 614)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_X  (V4L2_CID_FIMC_IS_BASE + 615)
+#define V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_Y  (V4L2_CID_FIMC_IS_BASE + 616)
+#define V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_X          (V4L2_CID_FIMC_IS_BASE + 617)
+#define V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_Y          (V4L2_CID_FIMC_IS_BASE + 618)
+#define V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_X      (V4L2_CID_FIMC_IS_BASE + 619)
+#define V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_Y      (V4L2_CID_FIMC_IS_BASE + 620)
+#define V4L2_CID_IS_FD_GET_ANGLE                    (V4L2_CID_FIMC_IS_BASE + 621)
+#define V4L2_CID_IS_FD_GET_YAW_ANGLE			(V4L2_CID_FIMC_IS_BASE + 622)
+#define V4L2_CID_IS_FD_GET_NEXT				(V4L2_CID_FIMC_IS_BASE + 623)
+#define V4L2_CID_IS_FD_GET_DATA				(V4L2_CID_FIMC_IS_BASE + 624)
+
+
+#define V4L2_CID_IS_FD_SET_MAX_FACE_NUMBER          (V4L2_CID_FIMC_IS_BASE + 650)
+#define V4L2_CID_IS_FD_SET_ROLL_ANGLE               (V4L2_CID_FIMC_IS_BASE + 651)
+enum is_fd_roll_angle {
+    /* 0, 45, 0, -45 */
+    IS_FD_ROLL_ANGLE_BASIC = 0,
+    /* 0, 30, 0, -30, 0, 45, 0, -45 */
+    IS_FD_ROLL_ANGLE_PRECISE_BASIC = 1,
+    /* 0, 90, 0, -90 */
+    IS_FD_ROLL_ANGLE_SIDES = 2,
+    /* 0, 90, 0, -90 0, 45, 0, -45 */
+    IS_FD_ROLL_ANGLE_PRECISE_SIDES = 3,
+    /* 0, 90, 0, -90, 0, 180 */
+    IS_FD_ROLL_ANGLE_FULL = 4,
+    /* 0, 90, 0, -90, 0, 180, 0, 135, 0, -135 */
+    IS_FD_ROLL_ANGLE_PRECISE_FULL = 5,
+};
+
+#define V4L2_CID_IS_FD_SET_YAW_ANGLE            (V4L2_CID_FIMC_IS_BASE + 652)
+enum is_fd_yaw_angle {
+    IS_FD_YAW_ANGLE_0    = 0,
+    IS_FD_YAW_ANGLE_45    = 1,
+    IS_FD_YAW_ANGLE_90    = 2,
+    IS_FD_YAW_ANGLE_45_90    = 3,
+};
+
+#define V4L2_CID_IS_FD_SET_SMILE_MODE           (V4L2_CID_FIMC_IS_BASE + 653)
+enum is_fd_smile_mode {
+    IS_FD_SMILE_MODE_DISABLE    = 0,
+    IS_FD_SMILE_MODE_ENABLE        = 1,
+};
+
+#define V4L2_CID_IS_FD_SET_BLINK_MODE           (V4L2_CID_FIMC_IS_BASE + 654)
+enum is_fd_blink_mode {
+    IS_FD_BLINK_MODE_DISABLE    = 0,
+    IS_FD_BLINK_MODE_ENABLE        = 1,
+};
+
+#define V4L2_CID_IS_FD_SET_EYE_DETECT_MODE      (V4L2_CID_FIMC_IS_BASE + 655)
+enum is_fd_eye_detect_mode {
+    IS_FD_EYE_DETECT_DISABLE    = 0,
+    IS_FD_EYE_DETECT_ENABLE        = 1,
+};
+
+#define V4L2_CID_IS_FD_SET_MOUTH_DETECT_MODE    (V4L2_CID_FIMC_IS_BASE + 656)
+enum is_fd_mouth_detect_mode {
+    IS_FD_MOUTH_DETECT_DISABLE    = 0,
+    IS_FD_MOUTH_DETECT_ENABLE    = 1,
+};
+
+#define V4L2_CID_IS_FD_SET_ORIENTATION_MODE     (V4L2_CID_FIMC_IS_BASE + 657)
+enum is_fd_orientation_mode {
+    IS_FD_ORIENTATION_DISABLE    = 0,
+    IS_FD_ORIENTATION_ENABLE    = 1,
+};
+
+#define V4L2_CID_IS_FD_SET_ORIENTATION          (V4L2_CID_FIMC_IS_BASE + 658)
+#define V4L2_CID_IS_FD_SET_DATA_ADDRESS         (V4L2_CID_FIMC_IS_BASE + 659)
+
+#define V4L2_CID_IS_SET_ISP            (V4L2_CID_FIMC_IS_BASE + 440)
+enum is_isp_bypass_mode {
+    IS_ISP_BYPASS_DISABLE,
+    IS_ISP_BYPASS_ENABLE,
+    IS_ISP_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_DRC            (V4L2_CID_FIMC_IS_BASE + 441)
+enum is_drc_bypass_mode {
+    IS_DRC_BYPASS_DISABLE,
+    IS_DRC_BYPASS_ENABLE,
+    IS_DRC_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_FD            (V4L2_CID_FIMC_IS_BASE + 442)
+enum is_fd_bypass_mode {
+    IS_FD_BYPASS_DISABLE,
+    IS_FD_BYPASS_ENABLE,
+    IS_FD_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_ODC            (V4L2_CID_FIMC_IS_BASE + 443)
+enum is_odc_bypass_mode {
+    IS_ODC_BYPASS_DISABLE,
+    IS_ODC_BYPASS_ENABLE,
+    IS_ODC_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_DIS            (V4L2_CID_FIMC_IS_BASE + 444)
+enum is_dis_bypass_mode {
+    IS_DIS_BYPASS_DISABLE,
+    IS_DIS_BYPASS_ENABLE,
+    IS_DIS_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_3DNR            (V4L2_CID_FIMC_IS_BASE + 445)
+enum is_tdnr_bypass_mode {
+    IS_TDNR_BYPASS_DISABLE,
+    IS_TDNR_BYPASS_ENABLE,
+    IS_TDNR_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_SCALERC            (V4L2_CID_FIMC_IS_BASE + 446)
+enum is_scalerc_bypass_mode {
+    IS_SCALERC_BYPASS_DISABLE,
+    IS_SCALERC_BYPASS_ENABLE,
+    IS_SCALERC_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_SET_SCALERP            (V4L2_CID_FIMC_IS_BASE + 446)
+enum is_scalerp_bypass_mode {
+    IS_SCALERP_BYPASS_DISABLE,
+    IS_SCALERP_BYPASS_ENABLE,
+    IS_SCALERP_BYPASS_MAX
+};
+
+#define V4L2_CID_IS_ROTATION_MODE        (V4L2_CID_FIMC_IS_BASE + 450)
+enum is_rotation_mode {
+    IS_ROTATION_0,
+    IS_ROTATION_90,
+    IS_ROTATION_180,
+    IS_ROTATION_270,
+    IS_ROTATION_MAX
+};
+
+#define V4L2_CID_IS_3DNR_1ST_FRAME_MODE        (V4L2_CID_FIMC_IS_BASE + 451)
+enum is_tdnr_1st_frame_mode {
+    IS_TDNR_1ST_FRAME_NOPROCESSING,
+    IS_TDNR_1ST_FRAME_2DNR,
+    IS_TDNR_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_OBJECT_WINDOW_X	    (V4L2_CID_FIMC_IS_BASE + 665)
+#define V4L2_CID_IS_CAMERA_OBJECT_WINDOW_Y	    (V4L2_CID_FIMC_IS_BASE + 666)
+#define V4L2_CID_IS_CAMERA_OBJECT_POSITION_X    (V4L2_CID_FIMC_IS_BASE + 452)
+#define V4L2_CID_IS_CAMERA_OBJECT_POSITION_Y    (V4L2_CID_FIMC_IS_BASE + 453)
+#define V4L2_CID_IS_CAMERA_WINDOW_SIZE_X        (V4L2_CID_FIMC_IS_BASE + 454)
+#define V4L2_CID_IS_CAMERA_WINDOW_SIZE_Y        (V4L2_CID_FIMC_IS_BASE + 455)
+
+#define V4L2_CID_IS_CAMERA_EXIF_EXPTIME         (V4L2_CID_FIMC_IS_BASE + 456)
+#define V4L2_CID_IS_CAMERA_EXIF_FLASH           (V4L2_CID_FIMC_IS_BASE + 457)
+#define V4L2_CID_IS_CAMERA_EXIF_ISO             (V4L2_CID_FIMC_IS_BASE + 458)
+#define V4L2_CID_IS_CAMERA_EXIF_SHUTTERSPEED    (V4L2_CID_FIMC_IS_BASE + 459)
+#define V4L2_CID_IS_CAMERA_EXIF_BRIGHTNESS      (V4L2_CID_FIMC_IS_BASE + 460)
+
+#define V4L2_CID_IS_CAMERA_ISP_SEL_INPUT        (V4L2_CID_FIMC_IS_BASE + 461)
+enum is_isp_sel_input {
+    IS_ISP_INPUT_OTF,
+    IS_ISP_INPUT_DMA1,
+    IS_ISP_INPUT_DMA2,
+    IS_ISP_INPUT_DMA12,
+    IS_ISP_INPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_ISP_SEL_OUTPUT    (V4L2_CID_FIMC_IS_BASE + 462)
+enum is_isp_sel_output {
+    IS_ISP_OUTPUT_OTF,
+    IS_ISP_OUTPUT_DMA1,
+    IS_ISP_OUTPUT_DMA2,
+    IS_ISP_OUTPUT_DMA12,
+    IS_ISP_OUTPUT_OTF_DMA1,
+    IS_ISP_OUTPUT_OTF_DMA2,
+    IS_ISP_OUTPUT_OTF_DMA12,
+    IS_ISP_OUTPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_DRC_SEL_INPUT    (V4L2_CID_FIMC_IS_BASE + 463)
+enum is_drc_sel_input {
+    IS_DRC_INPUT_OTF,
+    IS_DRC_INPUT_DMA,
+    IS_DRC_INPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_FD_SEL_INPUT        (V4L2_CID_FIMC_IS_BASE + 464)
+enum is_fd_sel_input {
+    IS_FD_INPUT_OTF,
+    IS_FD_INPUT_DMA,
+    IS_FD_INPUT_MAX
+};
+
+#define V4L2_CID_IS_CAMERA_INIT_WIDTH        (V4L2_CID_FIMC_IS_BASE + 465)
+#define V4L2_CID_IS_CAMERA_INIT_HEIGHT       (V4L2_CID_FIMC_IS_BASE + 466)
+
+#define V4L2_CID_IS_CMD_ISP            (V4L2_CID_FIMC_IS_BASE + 467)
+enum is_isp_cmd_mode {
+    IS_ISP_COMMAND_STOP,
+    IS_ISP_COMMAND_START,
+    IS_ISP_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_DRC            (V4L2_CID_FIMC_IS_BASE + 468)
+enum is_drc_cmd_mode {
+    IS_DRC_COMMAND_STOP,
+    IS_DRC_COMMAND_START,
+    IS_DRC_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_FD            (V4L2_CID_FIMC_IS_BASE + 469)
+enum is_fd_cmd_mode {
+    IS_FD_COMMAND_STOP,
+    IS_FD_COMMAND_START,
+    IS_FD_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_ODC            (V4L2_CID_FIMC_IS_BASE + 470)
+enum is_odc_cmd_mode {
+    IS_ODC_COMMAND_STOP,
+    IS_ODC_COMMAND_START,
+    IS_ODC_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_DIS            (V4L2_CID_FIMC_IS_BASE + 471)
+enum is_dis_cmd_mode {
+    IS_DIS_COMMAND_STOP,
+    IS_DIS_COMMAND_START,
+    IS_DIS_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_TDNR           (V4L2_CID_FIMC_IS_BASE + 472)
+enum is_tdnr_cmd_mode {
+    IS_TDNR_COMMAND_STOP,
+    IS_TDNR_COMMAND_START,
+    IS_TDNR_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_SCALERC        (V4L2_CID_FIMC_IS_BASE + 473)
+enum is_scalerc_cmd_mode {
+    IS_SCALERC_COMMAND_STOP,
+    IS_SCALERC_COMMAND_START,
+    IS_SCALERC_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_CMD_SCALERP        (V4L2_CID_FIMC_IS_BASE + 474)
+enum is_scalerp_cmd_mode {
+    IS_SCALERP_COMMAND_STOP,
+    IS_SCALERP_COMMAND_START,
+    IS_SCALERP_COMMAND_MAX
+};
+
+#define V4L2_CID_IS_GET_SENSOR_OFFSET_X        (V4L2_CID_FIMC_IS_BASE + 480)
+#define V4L2_CID_IS_GET_SENSOR_OFFSET_Y        (V4L2_CID_FIMC_IS_BASE + 481)
+#define V4L2_CID_IS_GET_SENSOR_WIDTH           (V4L2_CID_FIMC_IS_BASE + 482)
+#define V4L2_CID_IS_GET_SENSOR_HEIGHT          (V4L2_CID_FIMC_IS_BASE + 483)
+
+#define V4L2_CID_IS_GET_FRAME_VALID            (V4L2_CID_FIMC_IS_BASE + 484)
+#define V4L2_CID_IS_SET_FRAME_VALID            (V4L2_CID_FIMC_IS_BASE + 485)
+#define V4L2_CID_IS_GET_FRAME_BADMARK          (V4L2_CID_FIMC_IS_BASE + 486)
+#define V4L2_CID_IS_SET_FRAME_BADMARK          (V4L2_CID_FIMC_IS_BASE + 487)
+#define V4L2_CID_IS_GET_FRAME_CAPTURED         (V4L2_CID_FIMC_IS_BASE + 488)
+#define V4L2_CID_IS_SET_FRAME_CAPTURED         (V4L2_CID_FIMC_IS_BASE + 489)
+#define V4L2_CID_IS_SET_FRAME_NUMBER           (V4L2_CID_FIMC_IS_BASE + 490)
+#define V4L2_CID_IS_GET_FRAME_NUMBER           (V4L2_CID_FIMC_IS_BASE + 491)
+#define V4L2_CID_IS_CLEAR_FRAME_NUMBER         (V4L2_CID_FIMC_IS_BASE + 492)
+#define V4L2_CID_IS_GET_LOSTED_FRAME_NUMBER    (V4L2_CID_FIMC_IS_BASE + 493)
+#define V4L2_CID_IS_ISP_DMA_BUFFER_NUM         (V4L2_CID_FIMC_IS_BASE + 494)
+#define V4L2_CID_IS_ISP_DMA_BUFFER_ADDRESS     (V4L2_CID_FIMC_IS_BASE + 495)
+
+#define V4L2_CID_IS_ZOOM_STATE                 (V4L2_CID_FIMC_IS_BASE + 660)
+#define V4L2_CID_IS_ZOOM_MAX_LEVEL             (V4L2_CID_FIMC_IS_BASE + 661)
+#define V4L2_CID_IS_ZOOM                       (V4L2_CID_FIMC_IS_BASE + 662)
+#define V4L2_CID_IS_FW_DEBUG_REGION_ADDR       (V4L2_CID_FIMC_IS_BASE + 663)
+#define V4L2_CID_IS_AF_LOST_STATE			   (V4L2_CID_FIMC_IS_BASE + 664)
+#define V4L2_CID_IS_FLASH_ON_OFF  		(V4L2_CID_FIMC_IS_BASE + 667)
+
+#define V4L2_CID_IS_TUNE_SEL_ENTRY		(V4L2_CID_FIMC_IS_TUNE_BASE)
+#define V4L2_CID_IS_TUNE_SENSOR_EXPOSURE	(V4L2_CID_FIMC_IS_TUNE_BASE + 1)
+#define V4L2_CID_IS_TUNE_SENSOR_ANALOG_GAIN	(V4L2_CID_FIMC_IS_TUNE_BASE + 2)
+#define V4L2_CID_IS_TUNE_SENSOR_FRAME_RATE	(V4L2_CID_FIMC_IS_TUNE_BASE + 3)
+#define V4L2_CID_IS_TUNE_SENSOR_ACTUATOR_POS	(V4L2_CID_FIMC_IS_TUNE_BASE + 4)
+
+enum v4l2_blur
+{
+    BLUR_LEVEL_0 = 0,
+    BLUR_LEVEL_1,
+    BLUR_LEVEL_2,
+    BLUR_LEVEL_3,
+    BLUR_LEVEL_MAX,
+};
+
+#if 1
+#define V4L2_CID_CAMERA_SCENE_MODE      (V4L2_CID_PRIVATE_BASE+70)
+enum v4l2_scene_mode
+{
+    SCENE_MODE_BASE,
+    SCENE_MODE_NONE,
+    SCENE_MODE_PORTRAIT,
+    SCENE_MODE_NIGHTSHOT,
+    SCENE_MODE_BACK_LIGHT,
+    SCENE_MODE_LANDSCAPE,
+    SCENE_MODE_SPORTS,
+    SCENE_MODE_PARTY_INDOOR,
+    SCENE_MODE_BEACH_SNOW,
+    SCENE_MODE_SUNSET,
+	SCENE_MODE_DUSK_DAWN, 
+    SCENE_MODE_DUST_DAWN,
+    SCENE_MODE_FALL_COLOR,
+    SCENE_MODE_FIREWORKS,
+    SCENE_MODE_TEXT,
+    SCENE_MODE_CANDLE_LIGHT,
+    SCENE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_FLASH_MODE      (V4L2_CID_PRIVATE_BASE+71)
+enum v4l2_flash_mode
+{
+    FLASH_MODE_BASE,
+    FLASH_MODE_OFF,
+    FLASH_MODE_AUTO,
+    FLASH_MODE_ON,
+    FLASH_MODE_TORCH,
+    FLASH_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BRIGHTNESS      (V4L2_CID_PRIVATE_BASE+72)
+enum v4l2_ev_mode {
+    EV_MINUS_4  = -4,
+    EV_MINUS_3  = -3,
+    EV_MINUS_2  = -2,
+    EV_MINUS_1  = -1,
+    EV_DEFAULT  = 0,
+    EV_PLUS_1   = 1,
+    EV_PLUS_2   = 2,
+    EV_PLUS_3   = 3,
+    EV_PLUS_4   = 4,
+    EV_MAX,
+};
+
+#define V4L2_CID_CAMERA_WHITE_BALANCE   (V4L2_CID_PRIVATE_BASE+73)
+enum v4l2_wb_mode {
+    WHITE_BALANCE_BASE = 0,
+    WHITE_BALANCE_AUTO,
+    WHITE_BALANCE_SUNNY,
+    WHITE_BALANCE_CLOUDY,
+    WHITE_BALANCE_TUNGSTEN,
+    WHITE_BALANCE_FLUORESCENT,
+    WHITE_BALANCE_MAX,
+};
+
+#define V4L2_CID_CAMERA_EFFECT          (V4L2_CID_PRIVATE_BASE+74)
+enum v4l2_effect_mode {
+    IMAGE_EFFECT_BASE = 0,
+    IMAGE_EFFECT_NONE,
+    IMAGE_EFFECT_BNW,
+    IMAGE_EFFECT_SEPIA,
+    IMAGE_EFFECT_AQUA,
+    IMAGE_EFFECT_ANTIQUE,
+    IMAGE_EFFECT_NEGATIVE,
+    IMAGE_EFFECT_SHARPEN,
+    IMAGE_EFFECT_RED,
+    IMAGE_EFFECT_PINK,
+    IMAGE_EFFECT_YELLOW,
+    IMAGE_EFFECT_GREEN,
+    IMAGE_EFFECT_BLUE,
+    IMAGE_EFFECT_PURPLE,
+    IMAGE_EFFECT_WATERCOLOR,
+    IMAGE_EFFECT_MAX,
+};
+
+#define V4L2_CID_CAMERA_ISO             (V4L2_CID_PRIVATE_BASE+75)
+enum v4l2_iso_mode {
+    ISO_AUTO = 0,
+    ISO_50,
+    ISO_100,
+    ISO_200,
+    ISO_400,
+    ISO_800,
+    ISO_1200,
+    ISO_1600,
+    ISO_SPORTS,
+    ISO_NIGHT,
+    ISO_MOVIE,
+    ISO_MAX,
+};
+
+#define V4L2_CID_CAMERA_METERING            (V4L2_CID_PRIVATE_BASE+76)
+enum v4l2_metering_mode {
+    METERING_BASE = 0,
+    METERING_MATRIX,
+    METERING_CENTER,
+    METERING_SPOT,
+    METERING_MAX,
+};
+
+#define V4L2_CID_CAMERA_CONTRAST            (V4L2_CID_PRIVATE_BASE+77)
+enum v4l2_contrast_mode {
+    CONTRAST_MINUS_2 = 0,
+    CONTRAST_MINUS_1,
+    CONTRAST_DEFAULT,
+    CONTRAST_PLUS_1,
+    CONTRAST_PLUS_2,
+    CONTRAST_MAX,
+};
+
+#define V4L2_CID_CAMERA_SATURATION      (V4L2_CID_PRIVATE_BASE+78)
+enum v4l2_saturation_mode {
+    SATURATION_MINUS_2 = 0,
+    SATURATION_MINUS_1,
+    SATURATION_DEFAULT,
+    SATURATION_PLUS_1,
+    SATURATION_PLUS_2,
+    SATURATION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SHARPNESS       (V4L2_CID_PRIVATE_BASE+79)
+enum v4l2_sharpness_mode {
+    SHARPNESS_MINUS_2 = 0,
+    SHARPNESS_MINUS_1,
+    SHARPNESS_DEFAULT,
+    SHARPNESS_PLUS_1,
+    SHARPNESS_PLUS_2,
+    SHARPNESS_MAX,
+};
+
+#define V4L2_CID_CAMERA_WDR             (V4L2_CID_PRIVATE_BASE+80)
+enum v4l2_wdr_mode {
+    WDR_OFF,
+    WDR_ON,
+    WDR_MAX,
+};
+
+#define V4L2_CID_CAMERA_ANTI_SHAKE      (V4L2_CID_PRIVATE_BASE+81)
+enum v4l2_anti_shake_mode {
+    ANTI_SHAKE_OFF,
+    ANTI_SHAKE_STILL_ON,
+    ANTI_SHAKE_MOVIE_ON,
+    ANTI_SHAKE_MAX,
+};
+
+#define V4L2_CID_CAMERA_TOUCH_AF_START_STOP     (V4L2_CID_PRIVATE_BASE+82)
+enum v4l2_touch_af {
+    TOUCH_AF_STOP = 0,
+    TOUCH_AF_START,
+    TOUCH_AF_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO      (V4L2_CID_PRIVATE_BASE+83)
+enum v4l2_smart_auto {
+    SMART_AUTO_OFF = 0,
+    SMART_AUTO_ON,
+    SMART_AUTO_MAX,
+};
+
+#define V4L2_CID_CAMERA_VINTAGE_MODE        (V4L2_CID_PRIVATE_BASE+84)
+enum v4l2_vintage_mode {
+    VINTAGE_MODE_BASE,
+    VINTAGE_MODE_OFF,
+    VINTAGE_MODE_NORMAL,
+    VINTAGE_MODE_WARM,
+    VINTAGE_MODE_COOL,
+    VINTAGE_MODE_BNW,
+    VINTAGE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_JPEG_QUALITY        (V4L2_CID_PRIVATE_BASE+85)
+#define V4L2_CID_CAMERA_GPS_LATITUDE        (V4L2_CID_CAMERA_CLASS_BASE + 30)//(V4L2_CID_PRIVATE_BASE+86)
+#define V4L2_CID_CAMERA_GPS_LONGITUDE   (V4L2_CID_CAMERA_CLASS_BASE + 31)//(V4L2_CID_PRIVATE_BASE+87)
+#define V4L2_CID_CAMERA_GPS_TIMESTAMP   (V4L2_CID_CAMERA_CLASS_BASE + 32)//(V4L2_CID_PRIVATE_BASE+88)
+#define V4L2_CID_CAMERA_GPS_ALTITUDE        (V4L2_CID_CAMERA_CLASS_BASE + 33)//(V4L2_CID_PRIVATE_BASE+89)
+#define V4L2_CID_CAMERA_EXIF_TIME_INFO  (V4L2_CID_CAMERA_CLASS_BASE + 34)
+#define V4L2_CID_CAMERA_GPS_PROCESSINGMETHOD                     (V4L2_CID_CAMERA_CLASS_BASE+35)
+#define V4L2_CID_CAMERA_ZOOM                (V4L2_CID_PRIVATE_BASE+90)
+enum v4l2_zoom_level {
+    ZOOM_LEVEL_0 = 0,
+    ZOOM_LEVEL_1,
+    ZOOM_LEVEL_2,
+    ZOOM_LEVEL_3,
+    ZOOM_LEVEL_4,
+    ZOOM_LEVEL_5,
+    ZOOM_LEVEL_6,
+    ZOOM_LEVEL_7,
+    ZOOM_LEVEL_8,
+    ZOOM_LEVEL_9,
+    ZOOM_LEVEL_10,
+    ZOOM_LEVEL_11,
+    ZOOM_LEVEL_12,
+    ZOOM_LEVEL_13,
+    ZOOM_LEVEL_14,
+    ZOOM_LEVEL_15,
+    ZOOM_LEVEL_16,
+    ZOOM_LEVEL_17,
+    ZOOM_LEVEL_18,
+    ZOOM_LEVEL_19,
+    ZOOM_LEVEL_20,
+	ZOOM_LEVEL_MAX = 21,
+};
+
+#define V4L2_CID_CAMERA_FACE_DETECTION      (V4L2_CID_PRIVATE_BASE+91)
+enum v4l2_face_detection {
+    FACE_DETECTION_OFF = 0,
+    FACE_DETECTION_ON,
+    FACE_DETECTION_NOLINE,
+    FACE_DETECTION_ON_BEAUTY,
+    FACE_DETECTION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO_STATUS       (V4L2_CID_PRIVATE_BASE+92)
+enum v4l2_smart_auto_status {
+    SMART_AUTO_STATUS_AUTO = 0,
+    SMART_AUTO_STATUS_LANDSCAPE,
+    SMART_AUTO_STATUS_PORTRAIT,
+    SMART_AUTO_STATUS_MACRO,
+    SMART_AUTO_STATUS_NIGHT,
+    SMART_AUTO_STATUS_PORTRAIT_NIGHT,
+    SMART_AUTO_STATUS_BACKLIT,
+    SMART_AUTO_STATUS_PORTRAIT_BACKLIT,
+    SMART_AUTO_STATUS_ANTISHAKE,
+    SMART_AUTO_STATUS_PORTRAIT_ANTISHAKE,
+    SMART_AUTO_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_AUTO_FOCUS      (V4L2_CID_PRIVATE_BASE+93)
+enum v4l2_auto_focus {
+    AUTO_FOCUS_OFF = 0,
+    AUTO_FOCUS_ON,
+    AUTO_FOCUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_BEAUTY_SHOT     (V4L2_CID_PRIVATE_BASE+94)
+enum v4l2_beauty_shot {
+    BEAUTY_SHOT_OFF = 0,
+    BEAUTY_SHOT_ON,
+    BEAUTY_SHOT_MAX,
+};
+
+#define V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK       (V4L2_CID_PRIVATE_BASE+95)
+enum v4l2_ae_awb_lockunlock {
+    AE_UNLOCK_AWB_UNLOCK = 0,
+    AE_LOCK_AWB_UNLOCK,
+    AE_UNLOCK_AWB_LOCK,
+    AE_LOCK_AWB_LOCK,
+    AE_AWB_MAX
+};
+
+#define V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK   (V4L2_CID_PRIVATE_BASE+96)
+enum v4l2_face_lock {
+    FACE_LOCK_OFF = 0,
+    FACE_LOCK_ON,
+    FIRST_FACE_TRACKING,
+    FACE_LOCK_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJECT_POSITION_X   (V4L2_CID_PRIVATE_BASE+97)
+#define V4L2_CID_CAMERA_OBJECT_POSITION_Y   (V4L2_CID_PRIVATE_BASE+98)
+#define V4L2_CID_CAMERA_FOCUS_MODE      (V4L2_CID_PRIVATE_BASE+99)
+enum v4l2_focusmode {
+    FOCUS_MODE_AUTO = 0,
+    FOCUS_MODE_MACRO,
+    FOCUS_MODE_FACEDETECT,
+    FOCUS_MODE_INFINITY,
+    FOCUS_MODE_CONTINOUS,
+    FOCUS_MODE_CONTINOUS_XY,
+    FOCUS_MODE_TOUCH,
+    FOCUS_MODE_TOUCH_CONTINUOUS,
+    FOCUS_MODE_TOUCH_FLASH_AUTO,
+    FOCUS_MODE_TOUCH_FLASH_ON,
+    FOCUS_MODE_TOUCH_FLASH_OFF,
+    FOCUS_MODE_MAX,
+    FOCUS_MODE_DEFAULT = (1 << 8),
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_STATUS (V4L2_CID_PRIVATE_BASE+100)
+enum v4l2_obj_tracking_status {
+    OBJECT_TRACKING_STATUS_BASE,
+    OBJECT_TRACKING_STATUS_PROGRESSING,
+    OBJECT_TRACKING_STATUS_SUCCESS,
+    OBJECT_TRACKING_STATUS_FAIL,
+    OBJECT_TRACKING_STATUS_MISSING,
+    OBJECT_TRACKING_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP (V4L2_CID_PRIVATE_BASE+101)
+enum v4l2_ot_start_stop {
+    OT_STOP = 0,
+    OT_START,
+    OT_MAX,
+};
+
+#define V4L2_CID_CAMERA_CAF_START_STOP  (V4L2_CID_PRIVATE_BASE+102)
+enum v4l2_caf_start_stop {
+    CAF_STOP = 0,
+    CAF_START,
+    CAF_MAX,
+};
+
+#define V4L2_CID_CAMERA_AUTO_FOCUS_RESULT           (V4L2_CID_PRIVATE_BASE+103)
+#define V4L2_CID_CAMERA_FRAME_RATE          (V4L2_CID_PRIVATE_BASE+104)
+enum v4l2_frame_rate {
+    FRAME_RATE_AUTO = 0,
+    FRAME_RATE_7 = 7,
+    FRAME_RATE_15 = 15,
+    FRAME_RATE_20 = 20,
+    FRAME_RATE_30 = 30,
+    FRAME_RATE_60 = 60,
+    FRAME_RATE_120 = 120,
+    FRAME_RATE_MAX
+};
+
+#define V4L2_CID_CAMERA_ANTI_BANDING                    (V4L2_CID_PRIVATE_BASE+105)
+enum v4l2_anti_banding {
+    ANTI_BANDING_AUTO = 0,
+    ANTI_BANDING_50HZ = 1,
+    ANTI_BANDING_60HZ = 2,
+    ANTI_BANDING_OFF = 3,
+};
+
+#define V4L2_CID_CAMERA_SET_GAMMA   (V4L2_CID_PRIVATE_BASE+106)
+enum v4l2_gamma_mode {
+    GAMMA_OFF = 0,
+    GAMMA_ON = 1,
+    GAMMA_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_SLOW_AE (V4L2_CID_PRIVATE_BASE+107)
+enum v4l2_slow_ae_mode {
+    SLOW_AE_OFF,
+    SLOW_AE_ON,
+    SLOW_AE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BATCH_REFLECTION                    (V4L2_CID_PRIVATE_BASE+108)
+#define V4L2_CID_CAMERA_EXIF_ORIENTATION                    (V4L2_CID_PRIVATE_BASE+109)
+
+#define V4L2_CID_CAMERA_RESET                               (V4L2_CID_PRIVATE_BASE+111) //s1_camera [ Defense process by ESD input ]
+#define V4L2_CID_CAMERA_CHECK_DATALINE                      (V4L2_CID_PRIVATE_BASE+112)
+#define V4L2_CID_CAMERA_CHECK_DATALINE_STOP                 (V4L2_CID_PRIVATE_BASE+113)
+
+#endif
+
+#if defined(CONFIG_ARIES_NTT) // Modify NTTS1
+#define V4L2_CID_CAMERA_AE_AWB_DISABLE_LOCK                 (V4L2_CID_PRIVATE_BASE+114)
+#endif
+#define V4L2_CID_CAMERA_THUMBNAIL_NULL                                  (V4L2_CID_PRIVATE_BASE+115)
+#define V4L2_CID_CAMERA_SENSOR_MODE                 (V4L2_CID_PRIVATE_BASE+116)
+enum v4l2_sensor_mode {
+	SENSOR_CAMERA,
+	SENSOR_MOVIE,
+};
+
+typedef enum {
+	STREAM_MODE_CAM_OFF,
+	STREAM_MODE_CAM_ON,
+	STREAM_MODE_MOVIE_OFF,
+	STREAM_MODE_MOVIE_ON,
+} stream_mode_t;
+
+#define V4L2_CID_CAMERA_EXIF_EXPTIME                (V4L2_CID_PRIVATE_BASE+117)
+#define V4L2_CID_CAMERA_EXIF_FLASH                  (V4L2_CID_PRIVATE_BASE+118)
+#define V4L2_CID_CAMERA_EXIF_ISO                    (V4L2_CID_PRIVATE_BASE+119)
+#define V4L2_CID_CAMERA_EXIF_TV                     (V4L2_CID_PRIVATE_BASE+120)
+#define V4L2_CID_CAMERA_EXIF_BV                     (V4L2_CID_PRIVATE_BASE+121)
+#define V4L2_CID_CAMERA_EXIF_EBV                    (V4L2_CID_PRIVATE_BASE+122)
+#define V4L2_CID_CAMERA_CHECK_ESD		(V4L2_CID_PRIVATE_BASE+123)
+#define V4L2_CID_CAMERA_APP_CHECK		(V4L2_CID_PRIVATE_BASE+124)
+#define V4L2_CID_CAMERA_BUSFREQ_LOCK                (V4L2_CID_PRIVATE_BASE+125)
+#define V4L2_CID_CAMERA_BUSFREQ_UNLOCK              (V4L2_CID_PRIVATE_BASE+126)
+#define V4L2_CID_CAMERA_EXPOSURE (V4L2_CID_PRIVATE_BASE+127)
+enum v4l2_exposure_mode {
+	exposure_MINUS_4 = -4,
+	exposure_MINUS_3,
+	exposure_MINUS_2,
+	exposure_MINUS_1,
+	exposure_DEFAULT,
+	exposure_PLUS_1,
+	exposure_PLUS_2,
+	exposure_PLUS_3,
+	exposure_PLUS_4,
+	exposure_MAX,
+};
+
+#define V4L2_CID_CAMERA_TORCH_MODE      (V4L2_CID_PRIVATE_BASE+128)
+enum v4l2_torch_mode
+{
+    TORCH_MODE_PICTURE,
+    TORCH_MODE_RECORD,
+    TORCH_MODE_FLASHLIGHT,
+};
+/*      Pixel format FOURCC depth  Description  */
+enum v4l2_pix_format_mode {
+	V4L2_PIX_FMT_MODE_PREVIEW,
+	V4L2_PIX_FMT_MODE_CAPTURE,
+	V4L2_PIX_FMT_MODE_HDR,
+	V4L2_PIX_FMT_MODE_VT_MIRROR,
+	V4L2_PIX_FMT_MODE_VT_NONMIRROR,
+};
+/* 12  Y/CbCr 4:2:0 64x32 macroblocks */
+#define V4L2_PIX_FMT_NV12T    v4l2_fourcc('T', 'V', '1', '2')
+#define V4L2_PIX_FMT_NV21T    v4l2_fourcc('T', 'V', '2', '1')
+
+
+/*
+ *  * V4L2 extention for digital camera
+ *   */
+/* Strobe flash light */
+enum v4l2_strobe_control {
+    /* turn off the flash light */
+    V4L2_STROBE_CONTROL_OFF     = 0,
+    /* turn on the flash light */
+    V4L2_STROBE_CONTROL_ON      = 1,
+    /* act guide light before splash */
+    V4L2_STROBE_CONTROL_AFGUIDE = 2,
+    /* charge the flash light */
+    V4L2_STROBE_CONTROL_CHARGE  = 3,
+};
+
+enum v4l2_strobe_conf {
+    V4L2_STROBE_OFF         = 0,    /* Always off */
+    V4L2_STROBE_ON          = 1,    /* Always splashes */
+    /* Auto control presets */
+    V4L2_STROBE_AUTO        = 2,
+    V4L2_STROBE_REDEYE_REDUCTION    = 3,
+    V4L2_STROBE_SLOW_SYNC       = 4,
+    V4L2_STROBE_FRONT_CURTAIN   = 5,
+    V4L2_STROBE_REAR_CURTAIN    = 6,
+    /* Extra manual control presets */
+    /* keep turned on until turning off */
+    V4L2_STROBE_PERMANENT       = 7,
+    V4L2_STROBE_EXTERNAL        = 8,
+};
+
+enum v4l2_strobe_status {
+    V4L2_STROBE_STATUS_OFF      = 0,
+    /* while processing configurations */
+    V4L2_STROBE_STATUS_BUSY     = 1,
+    V4L2_STROBE_STATUS_ERR      = 2,
+    V4L2_STROBE_STATUS_CHARGING = 3,
+    V4L2_STROBE_STATUS_CHARGED  = 4,
+};
+
+/* capabilities field */
+/* No strobe supported */
+#define V4L2_STROBE_CAP_NONE        0x0000
+/* Always flash off mode */
+#define V4L2_STROBE_CAP_OFF     0x0001
+/* Always use flash light mode */
+#define V4L2_STROBE_CAP_ON      0x0002
+/* Flashlight works automatic */
+#define V4L2_STROBE_CAP_AUTO        0x0004
+/* Red-eye reduction */
+#define V4L2_STROBE_CAP_REDEYE      0x0008
+/* Slow sync */
+#define V4L2_STROBE_CAP_SLOWSYNC    0x0010
+/* Front curtain */
+#define V4L2_STROBE_CAP_FRONT_CURTAIN   0x0020
+/* Rear curtain */
+#define V4L2_STROBE_CAP_REAR_CURTAIN    0x0040
+/* keep turned on until turning off */
+#define V4L2_STROBE_CAP_PERMANENT   0x0080
+/* use external strobe */
+#define V4L2_STROBE_CAP_EXTERNAL    0x0100
+
+/* Set mode and Get status */
+struct v4l2_strobe {
+    /* off/on/charge:0/1/2 */
+    enum    v4l2_strobe_control control;
+    /* supported strobe capabilities */
+    __u32   capabilities;
+    enum    v4l2_strobe_conf mode;
+    enum    v4l2_strobe_status status;  /* read only */
+    /* default is 0 and range of value varies from each models */
+    __u32   flash_ev;
+    __u32   reserved[4];
+};
+
+#define VIDIOC_S_STROBE     _IOWR('V', 83, struct v4l2_strobe)
+#define VIDIOC_G_STROBE     _IOR('V', 84, struct v4l2_strobe)
+
+/* Object recognition and collateral actions */
+enum v4l2_recog_mode {
+    V4L2_RECOGNITION_MODE_OFF   = 0,
+    V4L2_RECOGNITION_MODE_ON    = 1,
+    V4L2_RECOGNITION_MODE_LOCK  = 2,
+};
+
+enum v4l2_recog_action {
+    V4L2_RECOGNITION_ACTION_NONE    = 0,    /* only recognition */
+    V4L2_RECOGNITION_ACTION_BLINK   = 1,    /* Capture on blinking */
+    V4L2_RECOGNITION_ACTION_SMILE   = 2,    /* Capture on smiling */
+};
+
+enum v4l2_recog_pattern {
+    V4L2_RECOG_PATTERN_FACE     = 0, /* Face */
+    V4L2_RECOG_PATTERN_HUMAN    = 1, /* Human */
+    V4L2_RECOG_PATTERN_CHAR     = 2, /* Character */
+};
+
+struct v4l2_recog_rect {
+    enum    v4l2_recog_pattern  p;  /* detected pattern */
+    struct  v4l2_rect  o;   /* detected area */
+    __u32   reserved[4];
+};
+
+struct v4l2_recog_data {
+    __u8    detect_cnt;     /* detected object counter */
+    struct  v4l2_rect   o;  /* detected area */
+    __u32   reserved[4];
+};
+
+struct v4l2_recognition {
+    enum v4l2_recog_mode    mode;
+
+    /* Which pattern to detect */
+    enum v4l2_recog_pattern  pattern;
+
+    /* How many object to detect */
+    __u8    obj_num;
+
+    /* select detected object */
+    __u32   detect_idx;
+
+    /* read only :Get object coordination */
+    struct v4l2_recog_data  data;
+
+    enum v4l2_recog_action  action;
+    __u32   reserved[4];
+};
+
+#define VIDIOC_S_RECOGNITION    _IOWR('V', 85, struct v4l2_recognition)
+#define VIDIOC_G_RECOGNITION    _IOR('V', 86, struct v4l2_recognition)
+
+/* We use this struct as the v4l2_streamparm raw_data for
+ * VIDIOC_G_PARM and VIDIOC_S_PARM
+ */
+struct sec_cam_parm {
+    struct v4l2_captureparm capture;
+    int contrast;
+    int effects;
+    int brightness;
+    int exposure;
+    int flash_mode;
+    int torch_mode;	
+    int focus_mode;
+    int aeawb_mode;
+    int iso;
+    int metering;
+    int saturation;
+    int scene_mode;
+    int sharpness;
+    int hue;
+    int white_balance;
+    int anti_banding;
+};
+
+#endif /* __LINUX_VIDEODEV2_SAMSUNG_H */
\ No newline at end of file
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmi.cpp b/exynos4/hal/libhdmi/SecHdmi/SecHdmi.cpp
index 021898c..7574c49 100644
--- a/exynos4/hal/libhdmi/SecHdmi/SecHdmi.cpp
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmi.cpp
@@ -245,6 +245,7 @@ SecHdmi::SecHdmi():
     mHdmiSrcCbCrAddr(0),
     mHdmiOutputMode(DEFAULT_OUPUT_MODE),
     mHdmiResolutionValue(DEFAULT_HDMI_RESOLUTION_VALUE), // V4L2_STD_480P_60_4_3
+    mHdmiS3DMode(HDMI_2D),
     mCompositeStd(DEFAULT_COMPOSITE_STD),
     mHdcpMode(false),
     mAudioMode(2),
@@ -252,11 +253,11 @@ SecHdmi::SecHdmi():
     mG2DUIRotVal(0),
     mCurrentHdmiOutputMode(-1),
     mCurrentHdmiResolutionValue(0), // 1080960
+    mCurrentHdmiS3DMode(0), // 0 = 2D mode
     mCurrentHdcpMode(false),
     mCurrentAudioMode(-1),
     mHdmiInfoChange(true),
     mFimcDstColorFormat(0),
-    mFimcCurrentOutBufIndex(0),
     mFBaddr(NULL),
     mFBsize(0),
     mFBionfd(-1),
@@ -309,13 +310,21 @@ SecHdmi::SecHdmi():
     mHdmiResolutionValueList[12] = 4809601;
     mHdmiResolutionValueList[13] = 4809602;
 
+    mHdmiS3dTbResolutionValueList[0] = 1080960;
+    mHdmiS3dTbResolutionValueList[1] = 1080924;
+    mHdmiS3dTbResolutionValueList[2] = 720960;
+    mHdmiS3dTbResolutionValueList[3] = 720950;
+
+    mHdmiS3dSbsResolutionValueList[0] = 1080960;
+    mHdmiS3dSbsResolutionValueList[1] = 1080924;
+    mHdmiS3dSbsResolutionValueList[2] = 720960;
+
 #if defined(BOARD_USES_CEC)
     mCECThread = new CECThread(this);
 #endif
 
     SecBuffer zeroBuf;
-    for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
-        mFimcReservedMem[i] = zeroBuf;
+    mFimcReservedMem = zeroBuf;
 #if defined(BOARD_USE_V4L2)
     for (int i = 0; i < HDMI_LAYER_MAX; i++)
         for (int j = 0; j < MAX_BUFFERS_MIXER; j++)
@@ -341,10 +350,9 @@ bool SecHdmi::create(int width, int height)
     Mutex::Autolock lock(mLock);
     unsigned int fimc_buf_size = 0;
     unsigned int gralloc_buf_size = 0;
-    mFimcCurrentOutBufIndex = 0;
     int stride;
     int vstride;
-    int BufNum = 0;
+    unsigned int BufNum = 0;
 #if defined(BOARD_USE_V4L2_ION)
     int IonClient = -1;
     int IonFd = -1;
@@ -392,7 +400,7 @@ bool SecHdmi::create(int width, int height)
     BufNum = 1;
 #endif
 
-    if (mSecFimc.create(SecFimc::DEV_3, SecFimc::MODE_SINGLE_BUF, BufNum) == false) {
+    if (mSecFimc.create(SecFimc::FIMC_DEV3, FIMC_OVLY_NONE_SINGLE_BUF, BufNum) == false) {
         ALOGE("%s::SecFimc create() fail", __func__);
         goto CREATE_FAIL;
     }
@@ -420,16 +428,16 @@ bool SecHdmi::create(int width, int height)
 #else
 #ifndef BOARD_USE_V4L2
     for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
-        mFimcReservedMem[i].phys.p = mSecFimc.getMemAddr()->phys.p + gralloc_buf_size + (fimc_buf_size * i);
+        mFimcReservedMem.phys.p = mSecFimc.getFimcRsrvedPhysMemAddr() + gralloc_buf_size + fimc_buf_size;
 #endif
 
 #if defined(BOARD_USES_FIMGAPI)
 #if defined(BOARD_USES_HDMI_SUBTITLES)
     for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
-        g2d_reserved_memory[i] = mFimcReservedMem[HDMI_FIMC_OUTPUT_BUF_NUM - 1].phys.p + fimc_buf_size + (g2d_reserved_memory_size * i);
+        g2d_reserved_memory[i] = mFimcReservedMem.phys.p + fimc_buf_size + (g2d_reserved_memory_size * i);
 #else
     for (int i = 0; i < HDMI_G2D_OUTPUT_BUF_NUM; i++)
-        g2d_reserved_memory[i] = mSecFimc.getMemAddr()->phys.p + gralloc_buf_size + (g2d_reserved_memory_size * i);
+        g2d_reserved_memory[i] = mSecFimc.getFimcRsrvedPhysMemAddr() + gralloc_buf_size + (g2d_reserved_memory_size * i);
 #endif
 #endif
 #endif
@@ -454,12 +462,12 @@ bool SecHdmi::create(int width, int height)
 #if defined(BOARD_USE_V4L2)
         unsigned int preset_id;
 
-        if (hdmi_resolution_2_preset_id(mHdmiResolutionValue, &mHdmiDstWidth, &mHdmiDstHeight, &preset_id) < 0) {
+        if (hdmi_resolution_2_preset_id(mHdmiResolutionValue, mHdmiS3DMode, &mHdmiDstWidth, &mHdmiDstHeight, &preset_id) < 0) {
             ALOGE("%s::hdmi_resolution_2_preset_id(%d) fail\n", __func__, mHdmiResolutionValue);
             goto CREATE_FAIL;
         }
 #else
-        if (hdmi_resolution_2_std_id(mHdmiResolutionValue, &mHdmiDstWidth, &mHdmiDstHeight, &std_id) < 0) {
+        if (hdmi_resolution_2_std_id(mHdmiResolutionValue, mHdmiS3DMode, &mHdmiDstWidth, &mHdmiDstHeight, &std_id) < 0) {
             ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, mHdmiResolutionValue);
             goto CREATE_FAIL;
         }
@@ -596,7 +604,7 @@ bool SecHdmi::connect(void)
 
     if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
             mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
-        if (this->setHdmiResolution(mHdmiResolutionValue, true) == false)
+        if (this->setHdmiResolution(mHdmiResolutionValue, mHdmiS3DMode, true) == false)
             ALOGE("%s::setHdmiResolution(%d) fail \n", __func__, mHdmiResolutionValue);
 
         if (this->setHdcpMode(mHdcpMode, false) == false)
@@ -676,8 +684,8 @@ bool SecHdmi::disconnect(void)
     mAudioMode = 2;
     mCurrentHdmiOutputMode = -1;
     mCurrentHdmiResolutionValue = 0;
+    mCurrentHdmiS3DMode = HDMI_2D;
     mCurrentAudioMode = -1;
-    mFimcCurrentOutBufIndex = 0;
 
     return true;
 }
@@ -867,32 +875,32 @@ bool SecHdmi::flush(int srcW, int srcH, int srcColorFormat,
                     mHdmiDstWidth, mHdmiDstHeight);
 #endif
         } else {
-            if (mSecFimc.setSrcAddr(srcYAddr, srcCbAddr, srcCrAddr, srcColorFormat) == false) {
-                ALOGE("%s::setSrcAddr(%d, %d, %d) fail",
+            if (mSecFimc.setSrcPhyAddr(srcYAddr, srcCbAddr, srcCrAddr) == false) {
+                ALOGE("%s::setSrcPhyAddr(%d, %d, %d) fail",
                         __func__, srcYAddr, srcCbAddr, srcCrAddr);
                 return false;
             }
 
             int  y_size = 0;
             if (mUIRotVal == 0 || mUIRotVal == 180)
-                y_size =  ALIGN(ALIGN(srcW,128) * ALIGN(srcH, 32), SZ_8K);
+                y_size =  ALIGN(ALIGN(srcW,128) * ALIGN(srcH, 32), 0x00002000);
             else
-                y_size =  ALIGN(ALIGN(srcH,128) * ALIGN(srcW, 32), SZ_8K);
+                y_size =  ALIGN(ALIGN(srcH,128) * ALIGN(srcW, 32), 0x00002000);
 
-            mHdmiSrcYAddr    = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[0];
+            mHdmiSrcYAddr    = mFimcReservedMem.phys.extP[0];
 #ifdef BOARD_USE_V4L2
-            mHdmiSrcCbCrAddr = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[1];
+            mHdmiSrcCbCrAddr = mFimcReservedMem.phys.extP[1];
 #else
-            mHdmiSrcCbCrAddr = mFimcReservedMem[mFimcCurrentOutBufIndex].phys.extP[0] + y_size;
+            mHdmiSrcCbCrAddr = mFimcReservedMem.phys.extP[0] + y_size;
 #endif
-            if (mSecFimc.setDstAddr(mHdmiSrcYAddr, mHdmiSrcCbCrAddr, 0, mFimcCurrentOutBufIndex) == false) {
-                ALOGE("%s::mSecFimc.setDstAddr(%d, %d) fail \n",
+            if (mSecFimc.setDstPhyAddr(mHdmiSrcYAddr, mHdmiSrcCbCrAddr, 0) == false) {
+                ALOGE("%s::mSecFimc.setDstPhyAddr(%d, %d) fail \n",
                         __func__, mHdmiSrcYAddr, mHdmiSrcCbCrAddr);
                 return false;
             }
 
-            if (mSecFimc.draw(0, mFimcCurrentOutBufIndex) == false) {
-                ALOGE("%s::mSecFimc.draw() fail \n", __func__);
+            if (mSecFimc.handleOneShot() == false) {
+                ALOGE("%s::mSecFimc.handleOneShot() fail \n", __func__);
                 return false;
             }
 #if defined(BOARD_USE_V4L2)
@@ -910,23 +918,20 @@ bool SecHdmi::flush(int srcW, int srcH, int srcColorFormat,
                         mHdmiSrcYAddr, mHdmiSrcCbCrAddr,
                         mHdmiDstWidth, mHdmiDstHeight);
 #endif
-            mFimcCurrentOutBufIndex++;
-            if (mFimcCurrentOutBufIndex >= HDMI_FIMC_OUTPUT_BUF_NUM)
-                mFimcCurrentOutBufIndex = 0;
         }
 
     } else {
         if (srcColorFormat != HAL_PIXEL_FORMAT_BGRA_8888 &&
             srcColorFormat != HAL_PIXEL_FORMAT_RGBA_8888 &&
             srcColorFormat != HAL_PIXEL_FORMAT_RGB_565) {
-            if (mSecFimc.setSrcAddr(srcYAddr, srcCbAddr, srcCrAddr, srcColorFormat) == false) {
-                ALOGE("%s::setSrcAddr(%d, %d, %d) fail",
+            if (mSecFimc.setSrcPhyAddr(srcYAddr, srcCbAddr, srcCrAddr) == false) {
+                ALOGE("%s::setSrcPhyAddr(%d, %d, %d) fail",
                      __func__, srcYAddr, srcCbAddr, srcCrAddr);
                 return false;
             }
 
-            if (mSecFimc.draw(0, mFimcCurrentOutBufIndex) == false) {
-                ALOGE("%s::mSecFimc.draw() failed", __func__);
+            if (mSecFimc.handleOneShot() == false) {
+                ALOGE("%s::mSecFimc.handleOneShot() failed", __func__);
                 return false;
             }
 #if defined(BOARD_USE_V4L2)
@@ -1106,10 +1111,10 @@ bool SecHdmi::setHdmiOutputMode(int hdmiOutputMode, bool forceRun)
     return true;
 }
 
-bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
+bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, unsigned int s3dMode, bool forceRun)
 {
 #ifdef DEBUG_MSG_ENABLE
-    ALOGD("%s:: hdmiResolutionValue = %d, forceRun = %d", __func__, hdmiResolutionValue, forceRun);
+    ALOGD("%s:: hdmiResolutionValue = %d, s3dMode=%d, forceRun = %d", __func__, hdmiResolutionValue, s3dMode, forceRun);
 #endif
 
     Mutex::Autolock lock(mLock);
@@ -1119,14 +1124,15 @@ bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
         return false;
     }
 
-    if (forceRun == false && mHdmiResolutionValue == hdmiResolutionValue) {
+    if (forceRun == false && mHdmiS3DMode == s3dMode &&  mHdmiResolutionValue == hdmiResolutionValue) {
 #ifdef DEBUG_HDMI_HW_LEVEL
-        ALOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
+        ALOGD("%s::same hdmiResolutionValue(%d) s3dMode(%d)\n", __func__, hdmiResolutionValue, s3dMode);
 #endif
         return true;
     }
 
     unsigned int newHdmiResolutionValue = hdmiResolutionValue;
+    unsigned int newHdmiS3DMode = s3dMode;
     int w = 0;
     int h = 0;
 
@@ -1134,13 +1140,13 @@ bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
     // find perfect resolutions..
 #if defined(BOARD_USE_V4L2)
     unsigned int preset_id;
-    if (hdmi_resolution_2_preset_id(newHdmiResolutionValue, &w, &h, &preset_id) < 0 ||
+    if (hdmi_resolution_2_preset_id(newHdmiResolutionValue, s3dMode, &w, &h, &preset_id) < 0 ||
         hdmi_check_resolution(preset_id) < 0) {
         bool flagFoundIndex = false;
-        int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue);
+        int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue, newHdmiS3DMode);
 
         for (int i = resolutionValueIndex + 1; i < mHdmiSizeOfResolutionValueList; i++) {
-            if (hdmi_resolution_2_preset_id(mHdmiResolutionValueList[i], &w, &h, &preset_id) == 0 &&
+            if (hdmi_resolution_2_preset_id(mHdmiResolutionValueList[i], s3dMode, &w, &h, &preset_id) == 0 &&
                 hdmi_check_resolution(preset_id) == 0) {
                 newHdmiResolutionValue = mHdmiResolutionValueList[i];
                 flagFoundIndex = true;
@@ -1158,13 +1164,13 @@ bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
     }
 #else
     v4l2_std_id std_id;
-    if (hdmi_resolution_2_std_id(newHdmiResolutionValue, &w, &h, &std_id) < 0 ||
+    if (hdmi_resolution_2_std_id(newHdmiResolutionValue, s3dMode, &w, &h, &std_id) < 0 ||
         hdmi_check_resolution(std_id) < 0) {
         bool flagFoundIndex = false;
-        int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue);
+        int resolutionValueIndex = m_resolutionValueIndex(newHdmiResolutionValue, newHdmiS3DMode);
 
         for (int i = resolutionValueIndex + 1; i < mHdmiSizeOfResolutionValueList; i++) {
-            if (hdmi_resolution_2_std_id(mHdmiResolutionValueList[i], &w, &h, &std_id) == 0 &&
+            if (hdmi_resolution_2_std_id(mHdmiResolutionValueList[i], s3dMode, &w, &h, &std_id) == 0 &&
                 hdmi_check_resolution(std_id) == 0) {
                 newHdmiResolutionValue = mHdmiResolutionValueList[i];
                 flagFoundIndex = true;
@@ -1193,9 +1199,20 @@ bool SecHdmi::setHdmiResolution(unsigned int hdmiResolutionValue, bool forceRun)
         mHdmiInfoChange = true;
     }
 
+    if (mHdmiS3DMode != newHdmiS3DMode) {
+        mHdmiS3DMode = newHdmiS3DMode;
+        mHdmiInfoChange = true;
+    }
+
     return true;
 }
 
+unsigned int SecHdmi::getHdmiResolution(void)
+{
+    return mHdmiResolutionValue;
+}
+
+
 bool SecHdmi::setHdcpMode(bool hdcpMode, bool forceRun)
 {
 #ifdef DEBUG_MSG_ENABLE
@@ -1283,7 +1300,6 @@ bool SecHdmi::m_reset(int w, int h, int colorFormat, int hdmiLayer, int hwcLayer
     ALOGD("### %s called", __func__);
 #endif
     v4l2_std_id std_id = 0;
-    mFimcCurrentOutBufIndex = 0;
 
     int srcW = w;
     int srcH = h;
@@ -1482,7 +1498,7 @@ bool SecHdmi::m_reset(int w, int h, int colorFormat, int hdmiLayer, int hwcLayer
             }
         } else if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
                    mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
-            if (m_setHdmiResolution(mHdmiResolutionValue) == false) {
+            if (m_setHdmiResolution(mHdmiResolutionValue, mHdmiS3DMode) == false) {
                 ALOGE("%s::m_setHdmiResolution() fail \n", __func__);
                 return false;
             }
@@ -1523,8 +1539,7 @@ bool SecHdmi::m_reset(int w, int h, int colorFormat, int hdmiLayer, int hwcLayer
 
         mHdmiInfoChange = false;
 #ifdef BOARD_USE_V4L2
-        for (int i = 0; i < HDMI_FIMC_OUTPUT_BUF_NUM; i++)
-            mFimcReservedMem[i] = *(mSecFimc.getMemAddr(i));
+        mFimcReservedMem = *(mSecFimc.getFimcRsrvedPhysMemAddr());
 #endif
     }
 
@@ -1779,15 +1794,15 @@ bool SecHdmi::m_setCompositeResolution(unsigned int compositeStdId)
     return true;
 }
 
-bool SecHdmi::m_setHdmiResolution(unsigned int hdmiResolutionValue)
+bool SecHdmi::m_setHdmiResolution(unsigned int hdmiResolutionValue, unsigned int s3dMode)
 {
 #ifdef DEBUG_MSG_ENABLE
     ALOGD("%s", __func__);
 #endif
 
-    if (hdmiResolutionValue == mCurrentHdmiResolutionValue) {
+    if ((hdmiResolutionValue == mCurrentHdmiResolutionValue) && (s3dMode == mCurrentHdmiS3DMode)) {
 #ifdef DEBUG_HDMI_HW_LEVEL
-        ALOGD("%s::same hdmiResolutionValue(%d) \n", __func__, hdmiResolutionValue);
+        ALOGD("%s::same hdmiResolutionValue(%d), mCurrentHdmiS3DMode(%d) \n", __func__, hdmiResolutionValue, mCurrentHdmiS3DMode);
 #endif
         return true;
     }
@@ -1808,13 +1823,13 @@ bool SecHdmi::m_setHdmiResolution(unsigned int hdmiResolutionValue)
     if (mHdmiOutputMode >= HDMI_OUTPUT_MODE_YCBCR &&
         mHdmiOutputMode <= HDMI_OUTPUT_MODE_DVI) {
 #if defined(BOARD_USE_V4L2)
-        if (hdmi_resolution_2_preset_id(hdmiResolutionValue, &w, &h, &preset_id) < 0) {
+        if (hdmi_resolution_2_preset_id(hdmiResolutionValue, s3dMode, &w, &h, &preset_id) < 0) {
             ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
             return false;
         }
         mHdmiPresetId    = preset_id;
 #else
-        if (hdmi_resolution_2_std_id(hdmiResolutionValue, &w, &h, &std_id) < 0) {
+        if (hdmi_resolution_2_std_id(hdmiResolutionValue, s3dMode, &w, &h, &std_id) < 0) {
             ALOGE("%s::hdmi_resolution_2_std_id(%d) fail\n", __func__, hdmiResolutionValue);
             return false;
         }
@@ -1835,6 +1850,7 @@ bool SecHdmi::m_setHdmiResolution(unsigned int hdmiResolutionValue)
     mHdmiDstHeight = h;
 
     mCurrentHdmiResolutionValue = hdmiResolutionValue;
+    mCurrentHdmiS3DMode = s3dMode;
 
 #ifdef DEBUG_HDMI_HW_LEVEL
 #if defined(BOARD_USE_V4L2)
@@ -1912,7 +1928,7 @@ bool SecHdmi::m_setAudioMode(int audioMode)
     return true;
 }
 
-int SecHdmi::m_resolutionValueIndex(unsigned int ResolutionValue)
+int SecHdmi::m_resolutionValueIndex(unsigned int ResolutionValue, unsigned int s3dMode)
 {
 #ifdef DEBUG_MSG_ENABLE
     ALOGD("%s", __func__);
@@ -1920,11 +1936,29 @@ int SecHdmi::m_resolutionValueIndex(unsigned int ResolutionValue)
 
     int index = -1;
 
-    for (int i = 0; i < mHdmiSizeOfResolutionValueList; i++) {
-        if (mHdmiResolutionValueList[i] == ResolutionValue) {
-            index = i;
-            break;
+    if (s3dMode == HDMI_2D) {
+        for (int i = 0; i < NUM_SUPPORTED_RESOLUTION_2D; i++) {
+            if (mHdmiResolutionValueList[i] == ResolutionValue) {
+                index = i;
+                break;
+            }
+        }
+    } else if (s3dMode == HDMI_S3D_TB) {
+        for (int i = 0; i < NUM_SUPPORTED_RESOLUTION_S3D_TB; i++) {
+            if (mHdmiS3dTbResolutionValueList[i] == ResolutionValue) {
+                index = i;
+                break;
+            }
         }
+    } else if (s3dMode == HDMI_S3D_SBS) {
+        for (int i = 0; i < NUM_SUPPORTED_RESOLUTION_S3D_SBS; i++) {
+            if (mHdmiS3dSbsResolutionValueList[i] == ResolutionValue) {
+                index = i;
+                break;
+            }
+        }
+    } else {
+        ALOGE("%s::Unsupported S3D mode(%d)\n", __func__, s3dMode);
     }
     return index;
 }
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmiCommon.h b/exynos4/hal/libhdmi/SecHdmi/SecHdmiCommon.h
index 203dfe4..473a5da 100644
--- a/exynos4/hal/libhdmi/SecHdmi/SecHdmiCommon.h
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmiCommon.h
@@ -136,3 +136,9 @@ enum hdmi_layer {
     HDMI_LAYER_GRAPHIC_1,
     HDMI_LAYER_MAX,
 };
+
+enum hdmi_s3d_mode {
+    HDMI_2D = 0,
+    HDMI_S3D_TB,
+    HDMI_S3D_SBS,
+};
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
index f3ae1ac..0522e40 100644
--- a/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.cpp
@@ -1494,12 +1494,12 @@ int hdmi_set_g_scaling(int layer,
         cur_g2d_address = (unsigned int)dst_addr;
         prev_src_addr = src_address;
 
-        srcAddr = {(addr_space)ADDR_USER, (unsigned long)src_address, src_w * src_h * 4, 1, 0};
-        srcImage = {srcAddr, srcAddr, src_w, src_h, src_w*4, AX_RGB, CF_ARGB_8888};
+        srcAddr = {(addr_space)ADDR_USER, (unsigned long)src_address};
+        srcImage = { src_w, src_h, src_w*4, AX_RGB, CF_ARGB_8888, srcAddr, srcAddr, srcRect, false };
         srcRect = {0, 0, src_w, src_h};
 
-        dstAddr = {(addr_space)ADDR_USER, (unsigned long)dst_addr, dst_w * dst_h * dst_bpp, 1, 0};
-        dstImage = {dstAddr, dstAddr, dst_w, dst_h, dst_w*dst_bpp, AX_RGB, (color_format)dst_color_format};
+        dstAddr = {(addr_space)ADDR_USER, (unsigned long)dst_addr};
+        dstImage = { dst_w, dst_h, dst_w*dst_bpp, AX_RGB, (color_format)dst_color_format, dstAddr, dstAddr, dstRect, false};
         dstRect = {0, 0, dst_w, dst_h};
         dstClip = {0, 0, 0, dst_w, dst_h};
 
@@ -1686,19 +1686,19 @@ int hdmi_gl_set_param(int layer,
         cur_g2d_address = (unsigned int)dst_addr;
         prev_src_addr = src_y_address;
 
-        srcAddr = {(addr_space)ADDR_PHYS, (unsigned long)src_y_address, src_w*src_h*4, 1, 0};
-        srcImage = {srcAddr, srcAddr, src_w, src_h, src_w*4, AX_RGB, CF_ARGB_8888};
+        srcAddr = {(addr_space)ADDR_USER, (unsigned long)src_y_address};
+        srcImage = { src_w, src_h, src_w*4, AX_RGB, CF_ARGB_8888, srcAddr, srcAddr, srcRect, false };
         srcRect = {0, 0, src_w, src_h};
 
-        dstAddr = {(addr_space)ADDR_PHYS, (unsigned long)dst_addr, dst_w*dst_h*dst_bpp, 1, 0};
-        dstImage = {dstAddr, dstAddr, dst_w, dst_h, dst_w*dst_bpp, AX_RGB, (color_format)dst_color_format};
+        dstAddr = {(addr_space)ADDR_USER, (unsigned long)dst_addr};
+        dstImage = { dst_w, dst_h, dst_w*dst_bpp, AX_RGB, (color_format)dst_color_format, dstAddr, dstAddr, dstRect, false};
         dstRect = {0, 0, dst_w, dst_h};
         dstClip = {0, 0, 0, dst_w, dst_h};
 
         if (rotVal == 0 || rotVal == 180)
-            Scaling = {SCALING_BILINEAR, SCALING_PIXELS, 0, 0, src_w, src_h, dst_w, dst_h};
+            Scaling = {SCALING_BILINEAR, src_w, src_h, dst_w, dst_h};
         else
-            Scaling = {SCALING_BILINEAR, SCALING_PIXELS, 0, 0, src_w, src_h, dst_h, dst_w};
+            Scaling = {SCALING_BILINEAR, src_w, src_h, dst_h, dst_w};
 
         switch (rotVal) {
         case 0:
@@ -1719,8 +1719,13 @@ int hdmi_gl_set_param(int layer,
             break;
         }
 
-        BlitParam = {BLIT_OP_SRC, NON_PREMULTIPLIED, 0xff, 0, g2d_rotation, &Scaling, 0, 0, &dstClip, 0, &srcImage, &dstImage, NULL, &srcRect, &dstRect, NULL, 0};
-
+        struct fimg2d_param Param;
+        struct fimg2d_repeat Repeat;
+        struct fimg2d_bluscr BluScr;
+        memset(&Repeat, 0, sizeof(struct fimg2d_repeat));
+        memset(&BluScr, 0, sizeof(struct fimg2d_bluscr));
+        Param = {0, 0xff, 0, g2d_rotation, NON_PREMULTIPLIED, Scaling, Repeat, BluScr, dstClip};
+        BlitParam = {BLIT_OP_SRC, Param, &srcImage, NULL, NULL, &dstImage, BLIT_SYNC, 0};
         if (stretchFimgApi(&BlitParam) < 0) {
             ALOGE("%s::stretchFimgApi() fail", __func__);
             return -1;
@@ -2118,81 +2123,125 @@ int hdmi_resolution_2_preset_id(unsigned int resolution, int * w, int * h, unsig
 {
     int ret = 0;
 
-    switch (resolution) {
-    case 1080960:
-        *w      = 1920;
-        *h      = 1080;
-        *preset_id = V4L2_DV_1080P60;
-        break;
-    case 1080950:
-        *w      = 1920;
-        *h      = 1080;
-        *preset_id = V4L2_DV_1080P50;
-        break;
-    case 1080930:
-        *w      = 1920;
-        *h      = 1080;
-        *preset_id = V4L2_DV_1080P30;
-        break;
-    case 1080924:
-        *w      = 1920;
-        *h      = 1080;
-        *preset_id = V4L2_DV_1080P24_TB;
-        break;
-    case 1080160:
-        *w      = 1920;
-        *h      = 1080;
-        *preset_id = V4L2_DV_1080I60;
-        break;
-    case 1080150:
-        *w      = 1920;
-        *h      = 1080;
-        *preset_id = V4L2_DV_1080I50;
-        break;
-    case 720960:
-        *w      = 1280;
-        *h      = 720;
-        *preset_id = V4L2_DV_720P60;
-        break;
-    case 7209601:
-        *w      = 1280;
-        *h      = 720;
-        *preset_id = V4L2_DV_720P60_SB_HALF;
-        break;
-    case 720950:
-        *w      = 1280;
-        *h      = 720;
-        *preset_id = V4L2_DV_720P50;
-        break;
-    case 7209501:
-        *w      = 1280;
-        *h      = 720;
-        *preset_id = V4L2_DV_720P50_TB;
-        break;
-    case 5769501:
-        *w      = 720;
-        *h      = 576;
-        *preset_id = V4L2_DV_576P50;
-        break;
-    case 5769502:
-        *w      = 720;
-        *h      = 576;
-        *preset_id = V4L2_DV_576P50;
-       break;
-    case 4809601:
-        *w      = 720;
-        *h      = 480;
-        *preset_id = V4L2_DV_480P60;
-       break;
-    case 4809602:
-        *w     = 720;
-        *h     = 480;
-        *preset_id = V4L2_DV_480P60;
-      break;
-    default:
-        ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+    if (s3dMode == HDMI_2D) {
+        switch (resolution) {
+        case 1080960:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P60;
+            break;
+        case 1080950:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P50;
+            break;
+        case 1080930:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P30;
+            break;
+        case 1080924:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P24;
+            break;
+        case 1080160:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080I60;
+            break;
+        case 1080150:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080I50;
+            break;
+        case 720960:
+            *w      = 1280;
+            *h      = 720;
+            *preset_id = V4L2_DV_720P60;
+            break;
+        case 720950:
+            *w      = 1280;
+            *h      = 720;
+            *preset_id = V4L2_DV_720P50;
+            break;
+        case 5769501: // 16:9
+            *w      = 720;
+            *h      = 576;
+            *preset_id = V4L2_DV_576P50;
+            break;
+        case 5769502: // 4:3
+            *w      = 720;
+            *h      = 576;
+            *preset_id = V4L2_DV_576P50;
+            break;
+        case 4809601: // 16:9
+            *w      = 720;
+            *h      = 480;
+            *preset_id = V4L2_DV_480P60;
+            break;
+        case 4809602: // 4:3
+            *w      = 720;
+            *h      = 480;
+            *preset_id = V4L2_DV_480P60;
+            break;
+        default:
+            ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+            ret = -1;
+            break;
+        }
+    } else if (s3dMode == HDMI_S3D_TB) {
+        switch (resolution) {
+        case 1080960:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P60_TB;
+            break;
+        case 1080924:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P24_TB;
+            break;
+        case 720960:
+            *w      = 1280;
+            *h      = 720;
+            *preset_id = V4L2_DV_720P60_TB;
+            break;
+        case 720950:
+            *w      = 1280;
+            *h      = 720;
+            *preset_id = V4L2_DV_720P50_TB;
+            break;
+        default:
+            ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+            ret = -1;
+            break;
+        }
+    } else if (s3dMode == HDMI_S3D_SBS) {
+        switch (resolution) {
+        case 1080960:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P60_SB_HALF;
+            break;
+        case 1080924:
+            *w      = 1920;
+            *h      = 1080;
+            *preset_id = V4L2_DV_1080P24_SB_HALF;
+            break;
+        case 720960:
+            *w      = 1280;
+            *h      = 720;
+            *preset_id = V4L2_DV_720P60_SB_HALF;
+            break;
+        default:
+            ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+            ret = -1;
+            break;
+        }
+    } else {
+        ALOGE("%s::Unsupported S3D mode(%d)\n", __func__, s3dMode);
         ret = -1;
-        break;
     }
 
     return ret;
@@ -2304,85 +2353,129 @@ int hdmi_check_resolution(v4l2_std_id std_id)
     return 0;
 }
 
-int hdmi_resolution_2_std_id(unsigned int resolution, int * w, int * h, v4l2_std_id * std_id)
+int hdmi_resolution_2_std_id(unsigned int resolution, unsigned int s3dMode, int * w, int * h, v4l2_std_id * std_id)
 {
     int ret = 0;
 
-    switch (resolution) {
-    case 1080960:
-        *std_id = V4L2_STD_1080P_60;
-        *w      = 1920;
-        *h      = 1080;
-        break;
-    case 1080950:
-        *std_id = V4L2_STD_1080P_50;
-        *w      = 1920;
-        *h      = 1080;
-        break;
-    case 1080930:
-        *std_id = V4L2_STD_1080P_30;
-        *w      = 1920;
-        *h      = 1080;
-        break;
-    case 1080924:
-        *std_id = V4L2_STD_TVOUT_1080P_24_TB;
-        *w      = 1920;
-        *h      = 1080;
-        break;
-    case 1080160:
-        *std_id = V4L2_STD_1080I_60;
-        *w      = 1920;
-        *h      = 1080;
-        break;
-    case 1080150:
-        *std_id = V4L2_STD_1080I_50;
-        *w      = 1920;
-        *h      = 1080;
-        break;
-    case 720960:
-        *std_id = V4L2_STD_720P_60;
-        *w      = 1280;
-        *h      = 720;
-        break;
-    case 7209601:
-        *std_id = V4L2_STD_TVOUT_720P_60_SBS_HALF;
-        *w      = 1280;
-        *h      = 720;
-        break;
-    case 720950:
-        *std_id = V4L2_STD_720P_50;
-        *w      = 1280;
-        *h      = 720;
-        break;
-    case 7209501:
-        *std_id = V4L2_STD_TVOUT_720P_50_TB;
-        *w      = 1280;
-        *h      = 720;
-        break;
-    case 5769501:
-        *std_id = V4L2_STD_576P_50_16_9;
-        *w      = 720;
-        *h      = 576;
-        break;
-    case 5769502:
-        *std_id = V4L2_STD_576P_50_4_3;
-        *w      = 720;
-        *h      = 576;
-        break;
-    case 4809601:
-        *std_id = V4L2_STD_480P_60_16_9;
-        *w      = 720;
-        *h      = 480;
-        break;
-    case 4809602:
-        *std_id = V4L2_STD_480P_60_4_3;
-        *w     = 720;
-        *h     = 480;
-        break;
-    default:
-        ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+    if (s3dMode == HDMI_2D) {
+        switch (resolution) {
+        case 1080960:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P60;
+            break;
+        case 1080950:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P50;
+            break;
+        case 1080930:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P30;
+            break;
+        case 1080924:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P24;
+            break;
+        case 1080160:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080I60;
+            break;
+        case 1080150:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080I50;
+            break;
+        case 720960:
+            *w      = 1280;
+            *h      = 720;
+            *std_id = V4L2_DV_720P60;
+            break;
+        case 720950:
+            *w      = 1280;
+            *h      = 720;
+            *std_id = V4L2_DV_720P50;
+            break;
+        case 5769501: // 16:9
+            *w      = 720;
+            *h      = 576;
+            *std_id = V4L2_DV_576P50;
+            break;
+        case 5769502: // 4:3
+            *w      = 720;
+            *h      = 576;
+            *std_id = V4L2_DV_576P50;
+            break;
+        case 4809601: // 16:9
+            *w      = 720;
+            *h      = 480;
+            *std_id = V4L2_DV_480P60;
+            break;
+        case 4809602: // 4:3
+            *w      = 720;
+            *h      = 480;
+            *std_id = V4L2_DV_480P60;
+            break;
+        default:
+            ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+            ret = -1;
+            break;
+        }
+    } else if (s3dMode == HDMI_S3D_TB) {
+        switch (resolution) {
+        case 1080960:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P60_TB;
+            break;
+        case 1080924:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P24_TB;
+            break;
+        case 720960:
+            *w      = 1280;
+            *h      = 720;
+            *std_id = V4L2_DV_720P60_TB;
+            break;
+        case 720950:
+            *w      = 1280;
+            *h      = 720;
+            *std_id = V4L2_DV_720P50_TB;
+            break;
+        default:
+            ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+            ret = -1;
+            break;
+        }
+    } else if (s3dMode == HDMI_S3D_SBS) {
+        switch (resolution) {
+        case 1080960:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P60_SB_HALF;
+            break;
+        case 1080924:
+            *w      = 1920;
+            *h      = 1080;
+            *std_id = V4L2_DV_1080P24_SB_HALF;
+            break;
+        case 720960:
+            *w      = 1280;
+            *h      = 720;
+            *std_id = V4L2_DV_720P60_SB_HALF;
+            break;
+        default:
+            ALOGE("%s::unmathced resolution(%d)", __func__, resolution);
+            ret = -1;
+            break;
+        }
+    } else {
+        ALOGE("%s::Unsupported S3D mode(%d)\n", __func__, s3dMode);
         ret = -1;
-        break;
     }
 
     return ret;
diff --git a/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
index a4aa69c..176e617 100644
--- a/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
+++ b/exynos4/hal/libhdmi/SecHdmi/SecHdmiV4L2Utils.h
@@ -115,10 +115,10 @@ int composite_std_2_v4l2_std_id(int std);
 int hdmi_check_output_mode(int v4l2_output_type);
 #if defined(BOARD_USE_V4L2)
 int hdmi_check_resolution(unsigned int preset_id);
-int hdmi_resolution_2_preset_id(unsigned int resolution, int * w, int * h, unsigned int *preset_id);
+int hdmi_resolution_2_preset_id(unsigned int resolution, unsigned int s3dMode, int * w, int * h, unsigned int *preset_id);
 #else
 int hdmi_check_resolution(v4l2_std_id std_id);
-int hdmi_resolution_2_std_id(unsigned int resolution, int *w, int *h, v4l2_std_id *std_id);
+int hdmi_resolution_2_std_id(unsigned int resolution, unsigned int s3dMode, int *w, int *h, v4l2_std_id *std_id);
 #endif
 int hdmi_enable_hdcp(unsigned int hdcp_en);
 int hdmi_check_audio(void);
diff --git a/exynos4/hal/libhdmi/libhdmiservice/Android.mk b/exynos4/hal/libhdmi/libhdmiservice/Android.mk
index ebfa9d5..e4ef3de 100644
--- a/exynos4/hal/libhdmi/libhdmiservice/Android.mk
+++ b/exynos4/hal/libhdmi/libhdmiservice/Android.mk
@@ -86,6 +86,7 @@ LOCAL_C_INCLUDES += \
 LOCAL_SHARED_LIBRARIES := \
 	libbinder \
 	libutils \
+	liblog \
 	libTVOut
 
 ifeq ($(TARGET_SIMULATOR),true)
diff --git a/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.cpp b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.cpp
index a013bf1..995120c 100644
--- a/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.cpp
+++ b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.cpp
@@ -32,8 +32,10 @@ namespace android {
 
     enum {
         SET_HDMI_STATUS = IBinder::FIRST_CALL_TRANSACTION,
+        GET_HDMI_STATUS,
         SET_HDMI_MODE,
         SET_HDMI_RESOLUTION,
+        GET_HDMI_RESOLUTION,
         SET_HDMI_HDCP,
         SET_HDMI_ROTATE,
         SET_HDMI_HWCLAYER,
@@ -47,6 +49,13 @@ namespace android {
         remote()->transact(SET_HDMI_STATUS, data, &reply);
     }
 
+    uint32_t BpSecTVOut::getHdmiCableStatus()
+    {
+        Parcel data, reply;
+        remote()->transact(GET_HDMI_STATUS, data, &reply);
+        return reply.readInt32();
+    }
+
     void BpSecTVOut::setHdmiMode(uint32_t mode)
     {
         Parcel data, reply;
@@ -54,13 +63,21 @@ namespace android {
         remote()->transact(SET_HDMI_MODE, data, &reply);
     }
 
-    void BpSecTVOut::setHdmiResolution(uint32_t resolution)
+    void BpSecTVOut::setHdmiResolution(uint32_t resolution, uint32_t s3dMode)
     {
         Parcel data, reply;
         data.writeInt32(resolution);
+        data.writeInt32(s3dMode);
         remote()->transact(SET_HDMI_RESOLUTION, data, &reply);
     }
 
+    uint32_t BpSecTVOut::getHdmiResolution(void)
+    {
+        Parcel data, reply;
+        remote()->transact(GET_HDMI_RESOLUTION, data, &reply);
+        return reply.readInt32();
+    }
+
     void BpSecTVOut::setHdmiHdcp(uint32_t resolution)
     {
         Parcel data, reply;
@@ -83,15 +100,23 @@ namespace android {
         remote()->transact(SET_HDMI_HWCLAYER, data, &reply);
     }
 
-    void BpSecTVOut::blit2Hdmi(uint32_t w, uint32_t h,
-                                        uint32_t colorFormat,
-                                        uint32_t physYAddr,
+    void BpSecTVOut::blit2Hdmi(int32_t w, int32_t h,
+                                        int32_t colorFormat,
+                                        int32_t physYAddr,
                                         uint32_t physCbAddr,
                                         uint32_t physCrAddr,
                                         uint32_t dstX,
                                         uint32_t dstY,
                                         uint32_t hdmiLayer,
-                                        uint32_t num_of_hwc_layer)
+                                        uint32_t num_of_hwc_layer,
+                                        uint32_t a,
+                                        uint32_t b,
+                                        uint32_t c,
+                                        uint32_t d,
+                                        uint32_t e,
+                                        uint32_t f,
+                                        uint32_t g,
+                                        uint32_t hh)
     {
         Parcel data, reply;
         data.writeInt32(w);
@@ -104,6 +129,14 @@ namespace android {
         data.writeInt32(dstY);
         data.writeInt32(hdmiLayer);
         data.writeInt32(num_of_hwc_layer);
+        data.writeInt32(a);
+        data.writeInt32(b);
+        data.writeInt32(c);
+        data.writeInt32(d);
+        data.writeInt32(e);
+        data.writeInt32(f);
+        data.writeInt32(g);
+        data.writeInt32(hh);
         remote()->transact(BLIT_2_HDMI, data, &reply);
     }
 
diff --git a/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.h b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.h
index 5506b57..045bb78 100644
--- a/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.h
+++ b/exynos4/hal/libhdmi/libhdmiservice/ISecTVOut.h
@@ -34,20 +34,30 @@ namespace android {
         public:
             DECLARE_META_INTERFACE(SecTVOut);
             virtual void setHdmiCableStatus(uint32_t status) = 0;
+	    virtual uint32_t getHdmiCableStatus(void) = 0;
             virtual void setHdmiMode(uint32_t mode) = 0;
-            virtual void setHdmiResolution(uint32_t resolution) = 0;
+            virtual void setHdmiResolution(uint32_t resolution, uint32_t s3dMode) = 0;
+	    virtual uint32_t getHdmiResolution(void) = 0;
             virtual void setHdmiHdcp(uint32_t enHdcp) = 0;
             virtual void setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer) = 0;
             virtual void setHdmiHwcLayer(uint32_t hwcLayer) = 0;
-            virtual void blit2Hdmi(uint32_t w, uint32_t h,
-                                        uint32_t colorFormat,
-                                        uint32_t physYAddr,
+            virtual void blit2Hdmi(int32_t w, int32_t h,
+                                        int32_t colorFormat,
+                                        int32_t physYAddr,
                                         uint32_t physCbAddr,
                                         uint32_t physCrAddr,
                                         uint32_t dstX,
                                         uint32_t dstY,
                                         uint32_t hdmiLayer,
-                                        uint32_t num_of_hwc_layer) = 0;
+                                        uint32_t a,
+                                        uint32_t b,
+                                        uint32_t c,
+                                        uint32_t d,
+                                        uint32_t e,
+                                        uint32_t f,
+                                        uint32_t g,
+                                        uint32_t hh,
+                                        uint32_t i) = 0;
     };
     //--------------------------------------------------------------
     class BpSecTVOut: public BpInterface<ISecTVOut>
@@ -55,20 +65,30 @@ namespace android {
         public:
             BpSecTVOut(const sp<IBinder>& impl): BpInterface<ISecTVOut>(impl){}
             virtual void setHdmiCableStatus(uint32_t status);
+	    virtual uint32_t getHdmiCableStatus(void);
             virtual void setHdmiMode(uint32_t mode);
-            virtual void setHdmiResolution(uint32_t resolution);
+            virtual void setHdmiResolution(uint32_t resolution, uint32_t s3dMode);
+	    virtual uint32_t getHdmiResolution(void);
             virtual void setHdmiHdcp(uint32_t enHdcp);
             virtual void setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer);
             virtual void setHdmiHwcLayer(uint32_t hwcLayer);
-            virtual void blit2Hdmi(uint32_t w, uint32_t h,
-                                        uint32_t colorFormat,
-                                        uint32_t physYAddr,
+            virtual void blit2Hdmi(int32_t w, int32_t h,
+                                        int32_t colorFormat,
+                                        int32_t physYAddr,
                                         uint32_t physCbAddr,
                                         uint32_t physCrAddr,
                                         uint32_t dstX,
                                         uint32_t dstY,
                                         uint32_t hdmiLayer,
-                                        uint32_t num_of_hwc_layer);
+                                        uint32_t num_of_hwc_layer,
+                                        uint32_t a,
+                                        uint32_t b,
+                                        uint32_t c,
+                                        uint32_t d,
+                                        uint32_t e,
+                                        uint32_t f,
+                                        uint32_t g,
+                                        uint32_t hh);
     };
 };
 #endif
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
index 2e327e6..c919605 100644
--- a/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.cpp
@@ -54,6 +54,89 @@ void SecHdmiClient::setHdmiCableStatus(int status)
         g_SecTVOutService->setHdmiCableStatus(status);
 }
 
+int SecHdmiClient::getHdmiCableStatus(void)
+{
+    //ALOGD("%s HDMI status: %d\n", __func__, status);
+    int cableStatus = 0;
+
+    if (g_SecTVOutService != 0)
+        cableStatus = g_SecTVOutService->getHdmiCableStatus();
+
+    return cableStatus;
+}
+
+int SecHdmiClient::getS3DSupport(void)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+
+    return 0;
+}
+
+int SecHdmiClient::getForceMirrorMode(void)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+
+    return 0;
+}
+
+void SecHdmiClient::setUITransform(int transform)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+}
+
+void SecHdmiClient::setMirrorWithVideoMode(int mirror)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+}
+
+int SecHdmiClient::getMirrorWithVideoMode(void)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+
+    return 0;
+}
+
+int SecHdmiClient::getVideoTransform(void)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+
+    return 0;
+}
+
+int SecHdmiClient::getVideoMode(void)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+
+    return 0;
+}
+
+void SecHdmiClient::setExtDispLayerNum(int num)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+}
+
+void SecHdmiClient::disableLayer(unsigned int layer)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+}
+
+void SecHdmiClient::enableLayer(unsigned int layer)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+}
+
+int SecHdmiClient::waitForVsync(void)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+
+    return 0;
+}
+
+void SecHdmiClient::setVideoTransform(int transform)
+{
+    //TODO: dhiru1602: This is just a placeholder for HWC
+}
+
 void SecHdmiClient::setHdmiMode(int mode)
 {
     //ALOGD("%s HDMI Mode: %d\n", __func__, mode);
@@ -62,12 +145,22 @@ void SecHdmiClient::setHdmiMode(int mode)
         g_SecTVOutService->setHdmiMode(mode);
 }
 
-void SecHdmiClient::setHdmiResolution(int resolution)
+void SecHdmiClient::setHdmiResolution(int resolution, HDMI_S3D_MODE s3dMode)
 {
     //ALOGD("%s HDMI Resolution: %d\n", __func__, resolution);
 
     if (g_SecTVOutService != 0)
-        g_SecTVOutService->setHdmiResolution(resolution);
+        g_SecTVOutService->setHdmiResolution(resolution, s3dMode);
+}
+
+int SecHdmiClient::getHdmiResolution(void)
+{
+    int resolution = 0;
+
+    if (g_SecTVOutService != 0)
+        resolution = g_SecTVOutService->getHdmiResolution();
+
+    return resolution;
 }
 
 void SecHdmiClient::setHdmiHdcp(int enHdcp)
@@ -102,18 +195,26 @@ void SecHdmiClient::setHdmiEnable(uint32_t enable)
         mEnable = enable;
 }
 
-void SecHdmiClient::blit2Hdmi(uint32_t w, uint32_t h,
-                                uint32_t colorFormat,
-                                uint32_t physYAddr,
+void SecHdmiClient::blit2Hdmi(int32_t w, int32_t h,
+                                int32_t colorFormat,
+                                int32_t physYAddr,
                                 uint32_t physCbAddr,
                                 uint32_t physCrAddr,
                                 uint32_t dstX,
                                 uint32_t dstY,
                                 uint32_t hdmiLayer,
-                                uint32_t num_of_hwc_layer)
+                                uint32_t num_of_hwc_layer,
+                                uint32_t a,
+                                uint32_t b,
+                                uint32_t c,
+                                uint32_t d,
+                                uint32_t e,
+                                uint32_t f,
+                                uint32_t g,
+                                uint32_t hh)
 {
     if (g_SecTVOutService != 0 && mEnable == 1)
-        g_SecTVOutService->blit2Hdmi(w, h, colorFormat, physYAddr, physCbAddr, physCrAddr, dstX, dstY, hdmiLayer, num_of_hwc_layer);
+        g_SecTVOutService->blit2Hdmi(w, h, colorFormat, physYAddr, physCbAddr, physCrAddr, dstX, dstY, hdmiLayer, num_of_hwc_layer, a, b, c, d, e, f, g, hh);
 }
 
 sp<ISecTVOut> SecHdmiClient::m_getSecTVOutService(void)
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.h b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.h
index ebee763..113d103 100644
--- a/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.h
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecHdmiClient.h
@@ -34,8 +34,8 @@
 #include <cutils/log.h>
 #include <binder/IBinder.h>
 #include <binder/IServiceManager.h>
-#include <surfaceflinger/ISurfaceComposer.h>
-#include <surfaceflinger/SurfaceComposerClient.h>
+#include <gui/ISurfaceComposer.h>
+#include <gui/SurfaceComposerClient.h>
 #include "ISecTVOut.h"
 
 #define GETSERVICETIMEOUT (5)
@@ -52,6 +52,12 @@ public:
         HDMI_MODE_VIDEO,
     };
 
+    enum HDMI_S3D_MODE {
+        HDMI_2D = 0,
+        HDMI_S3D_TB,
+        HDMI_S3D_SBS,
+    };
+
 private:
     SecHdmiClient();
     virtual ~SecHdmiClient();
@@ -60,21 +66,43 @@ private:
 public:
         static SecHdmiClient * getInstance(void);
         void setHdmiCableStatus(int status);
+        int getHdmiCableStatus(void);
+        int getS3DSupport(void);
+        int getForceMirrorMode(void);
+        void setUITransform(int transform);
+        void setMirrorWithVideoMode(int mirror);
+        int getMirrorWithVideoMode(void);
+        int getVideoTransform(void);
+        int getVideoMode(void);
+        void setExtDispLayerNum(int num);
+        void disableLayer(unsigned int layer);
+        void enableLayer(unsigned int layer);
+        int waitForVsync(void);
+        void setVideoTransform(int transform);
         void setHdmiMode(int mode);
-        void setHdmiResolution(int resolution);
+        void setHdmiResolution(int resolution, HDMI_S3D_MODE s3dMode);
+        int getHdmiResolution(void);
         void setHdmiHdcp(int enHdcp);
         void setHdmiRotate(int rotVal, uint32_t hwcLayer);
         void setHdmiHwcLayer(uint32_t hwcLayer);
         void setHdmiEnable(uint32_t enable);
-        virtual void blit2Hdmi(uint32_t w, uint32_t h,
-                                        uint32_t colorFormat,
-                                        uint32_t physYAddr,
+        virtual void blit2Hdmi(int32_t w, int32_t h,
+                                        int32_t colorFormat,
+                                        int32_t physYAddr,
                                         uint32_t physCbAddr,
                                         uint32_t physCrAddr,
                                         uint32_t dstX,
                                         uint32_t dstY,
                                         uint32_t hdmiLayer,
-                                        uint32_t num_of_hwc_layer);
+                                        uint32_t num_of_hwc_layer,
+                                        uint32_t a,
+                                        uint32_t b,
+                                        uint32_t c,
+                                        uint32_t d,
+                                        uint32_t e,
+                                        uint32_t f,
+                                        uint32_t g,
+                                        uint32_t hh);
 
 private:
         sp<ISecTVOut> m_getSecTVOutService(void);
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.cpp b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
index c0150a3..568c455 100644
--- a/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.cpp
@@ -41,6 +41,7 @@ namespace android {
 
     enum {
         SET_HDMI_STATUS = IBinder::FIRST_CALL_TRANSACTION,
+        GET_HDMI_STATUS,
         SET_HDMI_MODE,
         SET_HDMI_RESOLUTION,
         SET_HDMI_HDCP,
@@ -136,6 +137,11 @@ namespace android {
             setHdmiStatus(status);
         } break;
 
+        case GET_HDMI_STATUS: {
+             uint32_t status = getHdmiCableStatus();
+             reply->writeInt32(status);
+        } break;
+
         case SET_HDMI_MODE: {
             int mode = data.readInt32();
             setHdmiMode(mode);
@@ -143,7 +149,8 @@ namespace android {
 
         case SET_HDMI_RESOLUTION: {
             int resolution = data.readInt32();
-            setHdmiResolution(resolution);
+            int s3dMode = data.readInt32();
+            setHdmiResolution(resolution, (HDMI_S3D_MODE)s3dMode);
         } break;
 
         case SET_HDMI_HDCP: {
@@ -163,18 +170,26 @@ namespace android {
         } break;
 
         case BLIT_2_HDMI: {
-            uint32_t w = data.readInt32();
-            uint32_t h = data.readInt32();
-            uint32_t colorFormat = data.readInt32();
-            uint32_t physYAddr  = data.readInt32();
+            int32_t w = data.readInt32();
+            int32_t h = data.readInt32();
+            int32_t colorFormat = data.readInt32();
+            int32_t physYAddr  = data.readInt32();
             uint32_t physCbAddr = data.readInt32();
             uint32_t physCrAddr = data.readInt32();
             uint32_t dstX   = data.readInt32();
             uint32_t dstY   = data.readInt32();
             uint32_t hdmiLayer   = data.readInt32();
             uint32_t num_of_hwc_layer = data.readInt32();
-
-            blit2Hdmi(w, h, colorFormat, physYAddr, physCbAddr, physCrAddr, dstX, dstY, hdmiLayer, num_of_hwc_layer);
+            uint32_t a = data.readInt32();
+            uint32_t b = data.readInt32();
+            uint32_t c = data.readInt32();
+            uint32_t d = data.readInt32();
+            uint32_t e = data.readInt32();
+            uint32_t f = data.readInt32();
+            uint32_t g = data.readInt32();
+            uint32_t hh = data.readInt32();
+
+            blit2Hdmi(w, h, colorFormat, physYAddr, physCbAddr, physCrAddr, dstX, dstY, hdmiLayer, num_of_hwc_layer, a, b, c, d, e, f, g, hh);
         } break;
 
         default :
@@ -211,7 +226,15 @@ namespace android {
         }
 
         if (hdmiCableInserted() == true)
-            this->blit2Hdmi(mLCD_width, mLCD_height, HAL_PIXEL_FORMAT_BGRA_8888, 0, 0, 0, 0, 0, HDMI_MODE_UI, 0);
+            this->blit2Hdmi(mLCD_width, mLCD_height, HAL_PIXEL_FORMAT_BGRA_8888, 0, 0, 0, 0, 0, HDMI_MODE_UI, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+
+    uint32_t SecTVOutService::getHdmiCableStatus()
+    {
+        Mutex::Autolock _l(mLock);
+
+        //ALOGD("%s TV Cable status = %d", __func__, hdmiCableInserted());
+        return hdmiCableInserted();
     }
 
     void SecTVOutService::setHdmiMode(uint32_t mode)
@@ -225,17 +248,24 @@ namespace android {
         }
     }
 
-    void SecTVOutService::setHdmiResolution(uint32_t resolution)
+    void SecTVOutService::setHdmiResolution(uint32_t resolution, HDMI_S3D_MODE s3dMode)
     {
         //ALOGD("%s TV resolution = %d", __func__, resolution);
         Mutex::Autolock _l(mLock);
 
-        if ((hdmiCableInserted() == true) && (mSecHdmi.setHdmiResolution(resolution)) == false) {
+        if ((hdmiCableInserted() == true) && (mSecHdmi.setHdmiResolution(resolution, s3dMode)) == false) {
             ALOGE("%s::mSecHdmi.setHdmiResolution() fail", __func__);
             return;
         }
     }
 
+    uint32_t SecTVOutService::getHdmiResolution(void)
+    {
+        Mutex::Autolock _l(mLock);
+
+        return mSecHdmi.getHdmiResolution();
+    }
+
     void SecTVOutService::setHdmiHdcp(uint32_t hdcp_en)
     {
         ALOGD("%s TV HDCP = %d", __func__, hdcp_en);
@@ -267,11 +297,19 @@ namespace android {
         return;
     }
 
-    void SecTVOutService::blit2Hdmi(uint32_t w, uint32_t h, uint32_t colorFormat, 
-                                 uint32_t pPhyYAddr, uint32_t pPhyCbAddr, uint32_t pPhyCrAddr,
+    void SecTVOutService::blit2Hdmi(int32_t w, int32_t h, int32_t colorFormat, 
+                                 int32_t pPhyYAddr, uint32_t pPhyCbAddr, uint32_t pPhyCrAddr,
                                  uint32_t dstX, uint32_t dstY,
                                  uint32_t hdmiMode,
-                                 uint32_t num_of_hwc_layer)
+                                 uint32_t num_of_hwc_layer,
+                                 uint32_t a,
+                                 uint32_t b,
+                                 uint32_t c,
+                                 uint32_t d,
+                                 uint32_t e,
+                                 uint32_t f,
+                                 uint32_t g,
+                                 uint32_t hh)
     {
         Mutex::Autolock _l(mLock);
 
diff --git a/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.h b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.h
index b1048b5..505aed7 100644
--- a/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.h
+++ b/exynos4/hal/libhdmi/libhdmiservice/SecTVOutService.h
@@ -49,6 +49,12 @@ namespace android {
                 HDMI_MODE_VIDEO,
             };
 
+            enum HDMI_S3D_MODE {
+                HDMI_2D = 0,
+                HDMI_S3D_TB,
+                HDMI_S3D_SBS,
+            };
+
             mutable Mutex mLock;
 
             class HDMIFlushThread : public Thread {
@@ -78,16 +84,20 @@ namespace android {
             virtual ~SecTVOutService ();
 
             virtual void                        setHdmiStatus(uint32_t status);
+            virtual uint32_t                    getHdmiCableStatus(void);
             virtual void                        setHdmiMode(uint32_t mode);
-            virtual void                        setHdmiResolution(uint32_t resolution);
+            virtual void                        setHdmiResolution(uint32_t resolution, HDMI_S3D_MODE s3dMode);
+	    virtual uint32_t                    getHdmiResolution(void);
             virtual void                        setHdmiHdcp(uint32_t enHdcp);
             virtual void                        setHdmiRotate(uint32_t rotVal, uint32_t hwcLayer);
             virtual void                        setHdmiHwcLayer(uint32_t hwcLayer);
-            virtual void                        blit2Hdmi(uint32_t w, uint32_t h,
-                                                uint32_t colorFormat,
-                                                uint32_t pPhyYAddr, uint32_t pPhyCbAddr, uint32_t pPhyCrAddr,
+            virtual void                        blit2Hdmi(int32_t w, int32_t h,
+                                                int32_t colorFormat,
+                                                int32_t pPhyYAddr, uint32_t pPhyCbAddr, uint32_t pPhyCrAddr,
                                                 uint32_t dstX, uint32_t dstY,
-                                                uint32_t hdmiMode, uint32_t num_of_hwc_layer);
+                                                uint32_t hdmiMode, uint32_t num_of_hwc_layer, uint32_t a,
+                                                uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f,
+                                                uint32_t g, uint32_t hh);
             bool                                hdmiCableInserted(void);
             void                                setLCDsize(void);
 
@@ -107,6 +117,12 @@ namespace android {
                 HDMI_MODE_VIDEO,
             };
 
+            enum HDMI_S3D_MODE {
+                HDMI_2D = 0,
+                HDMI_S3D_TB,
+                HDMI_S3D_SBS,
+            };
+
             mutable     Mutex mBlitLock;
 
             SecHdmi     *pSecHdmi;