S5PC11X: CAMERA: add driver for Samsung s5k4ecgx 5MP camera

Signed-off-by: kyoungho.yun <kyoungho.yun@samsung.com>
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>
Change-Id: Ie8f43b6a5a6f3eda7ced8562e93831a8f1a90bf3

S5PC11X: CAMERA: Fixes for s5k4ecgx camera driver

Fix some locking issues in the driver.  The main interfaces
are s_ctrl and g_ctrl.  s_ctrl is already called with a lock
held by the fimc level above us, but no lock is held in g_ctrl.
Since the driver does i2c operations in batches (often multiple
writes of different lengths followed by a read), these really
need to be atomic.  Change driver to use a global lock for
both s_ctrl and g_ctrl, and release it when we sleep.

Change the wait for autofocus cancel to use a completion rather
than polling.

Fix issue where auto focus request after a previously succesful
auto focus would return complete too early.  Looks like the
sensor falsely reports success too quickly if we read the result
right away, so add a delay before we check for the result.  This
is a fix based on emprical testing since we have no documentation
on the registers we're reading and writing.

Fix handling of restoring focus state when cancelled during
2nd phase of auto focus.

Change-Id: I872a4aa37c53da660a0923b76da6caef4d424ad9
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Add infinite focus support

Add support in back camera for infinite focus mode.

Change-Id: Icb7738c4576cd3d3e7b7855ea4c1affb1128028e
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Timing cleanup and new reg values

Cleanup some timings based on new info/clarification from SLSI
camera engineer.  Also incorporate updated register values
in preparation for doing burst i2c writes in a next patch.  The
new values have also been cleaned up to remove unneeded values
(i.e. register bank address changes that aren't necessary).  We
leave the SOC in SW bank write mode by default and any switches
to read mode should restore write mode at the end.

Change-Id: Iadae0e328a61dc3326b11fb16d7e57aa63410f17
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Make get_iso get_shutterspeed function for EXIF

get_iso and get_shutterspeed is called in HAL.
And HAL add this information in EXIF information.

Change-Id: Ie8329b40b90280e9747e78c847f1c68757995ed0
Signed-off-by: kyoungho.yun <kyoungho.yun@samsung.com>

S5PC11X: CAMERA: Optimization for startup time

Change the driver so that it knows the defaults it wrote
at init time so that when the HAL sends it parameters
for preview and they are the same as the defaults, it can
do nothing.  This saves about 500ms for camera startup.

I also use s_parm API to set all the parameters at once,
instead of separate s_ctrls that were used before.

Change-Id: I692cb4864438f58742525ebc10a1cfda8fc55e99
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: fix scene mode operation, add torch mode

Fix scene mode operation in s_ctrl. Before this change, scene mode just call user setting value.
But for normal operation, there are need to add default value setting before user choiced value.
And add torch operation routine. This will turn on flash when user enable torch mode in video recording state.

Change-Id: I4ddf049c6b9dd5f87d720fae75dbe3bacb504962
Signed-off-by: kyoungho.yun <kyoungho.yun@samsung.com>

S5PC11X: CAMERA: Fix checkpatch warning

Change-Id: Idb099f09d7be84ecec566ee0c8db664ac993e52b
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Use i2c burst of init to speed startup

Shaves about 500ms off of the init time of the sensor.
However, there appears to be a problem with the sensor
when we burst so much data out and I had to add a delay
after some bursts.  This should be removed in Rev 1.1.

Change-Id: Ic3cdb5118c1e48c5cdc16a18b4e51ba5970f1c13
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Add support for rev EVT1.1 of s5k4ecgx

Change-Id: Idb50ed2094e53bc8c98adaacbf093d78d860cafa
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Update AF sequence using info from SLSI

1. Update register settings of camera sensor to version 14
2. Add settings of af flash assist
3. Add AF_Low_Light_Mode_On/OFF on auto focusing
4. Add AE_AWB_Lock_On/OFF on auto focusing
5. Add Checking AE stable on auto focusing
6. add for setting AWB locking on only auto AWB mode

Change-Id: I1737c22203e6f943f41643f8e360c4613339f15
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Fix resolutions

Change 1MP capture to 1280x960, because that's what the sensor
is actually generating.  The info table was wrong.  Fixes a
CTS test failure.

Reorder D1 preview after VGA, so it is sorted right.  Doesn't
have a functonal impact, just makes it cleaner.

Change-Id: I57e7b75e5e0d71f7223e65c1c4e7c4656eacc002
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Change temp buffer to vmalloc

The temporary buffer used to do burst i2c writes
can be pretty large and the allocation can fail since
the driver is loaded not at boot but whenever camera
starts and stops.  Change to use vmalloc so we are
less likely to fail.  I2C doesn't use DMA so vmalloc
is fine.

Change-Id: I0bd1d9d5f6cf2ee6154355ecc4cd1dd2272ff560
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: Camera: Turn on flash always on torch mode

Turning off flash is controlled by FLASH_MODE_TORCH_OFF. And Torch
mode was made for working on only video recording mode.
But it is misunderstanding of torch mode.
So it is changed to turn on flash always on torch mode.

Change-Id: Iffc853821e83b9a2e45fec6b7fcf3352c68d8fa6
Signed-off-by: Jeong-Seok Yang <jseok.yang@samsung.com>

S5PC11X: Camera: for do not check ESD status on auto focusing

It shouldn't check ESD status in middle of auto focusing procedure
because it disturbs commands of auto focusing procedure

Change-Id: I2711d63d2331d51bd87ee73143124f90ed2420ce
Signed-off-by: Jeong-Seok Yang <jseok.yang@samsung.com>

S5PC11X: Camera: Increase waiting time for searching auto focusing

For camera vendor's recommendation, Increase waiting time for
searching auto focusing. It raise possiblility of searching auto
focusing.

Change-Id: I74a3d2e8e1318d79519cc3efb7648515187ae952
Signed-off-by: Jeong-Seok Yang <jseok.yang@samsung.com>

S5PC11X: Camera: for keeping exposure value until capturing

Exposure value which setting automatically on auto focusing should
be kept until capturing picture or until stopping auto focusing
not until finishing auto focusing.

Change-Id: I54a46490d06aab370312acc7ac97a0e7199568c6
Signed-off-by: Jeong-Seok Yang <jseok.yang@samsung.com>
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: Camera: Adjust the intensity of flash

Using the main flash for AF assist and torch mode will damage
the LED in the long term. Reduce the brightness for these modes
by programming the LED controller.

Signed-off-by: Simon Wilson <simonwilson@google.com>

S5PC11X: Camera: Adjust ISO information

ISO information is a field of EXIF. It is matched to HAL

Change-Id: I3c019914a214ee42844435d502f5ecb430c261fd
Signed-off-by: Jeong-Seok Yang <jseok.yang@samsung.com>

S5PC11X: CAMERA: Update register settings for s5k4ecgx sensor

Revision 1.24 from vendor.  Change notes from Korea:

Changed item:
 1. AWB starting point change to between 4000K and 5000K
     - it is to reduce wrong color when enter camera

 2. Applied Flash register setting and TnP
    - TnP is kind of sensor firmware. this firmware
      control AE and AWB when emit flash.
    - Flash AWB setting is changed. this correct reddish image when flash.

3.  Changed Color matrix.
   - Out door color is changed from Samsung reliability test team request.

4. Changed Indoor register
   - To meet Samsung reliablity specification.

Change-Id: I12ded5dda98e2f74220ac7dc2cb1cf79482179ea
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: add flash-state flag and frame rate setting

Add flash-state flag and get function for make EXIF.
Add frame rate setting routine for video recording.

Change-Id: I956d1405f62b1bea6524b3658cb1851a12525a91
Signed-off-by: kyoungho.yun <kyoungho.yun@samsung.com>

S5PC11X: CAMERA: fix crash in s5k4ecgx driver when sensor not detected

We can't do detection in probe because the camera isn't powered, so
we can only notice that the sensor isn't communicating with us (for
whatever reason, like misconfig, or HW issues), later on.  So we
need to keep track of initialization state in the main s_ctrl and
g_ctrl APIs and return error if initialization failed.

Change-Id: If6dc16540462061788e2786ff6346d8e708c09a5
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: add assist flash when infinity mode

In infinity mode, add assist flash to fix brightness exposure.

Change-Id: Ie8166a9dc5958f9ae1ab99119d750aa84812f54c
Signed-off-by: kyoungho.yun <kyoungho.yun@samsung.com>

S5PC11X: CAMERA: new settings for preview

Settings to crop before scale to get less distortion on the
preview sizes that are not a multiple of the max resolution in
both axis.

Change-Id: I39cfc301825c24d3c717762d2a0bc56f29fdd3e7
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: Camera: for setting focus mode when stopping auto focusing

For camera vendor's recommendation, set current focus mode when
stopping auto focusing. and do not different working by checking
low light condition

Change-Id: I34e8becfec94ab43c236d8d81049789d629d022b
Signed-off-by: Jeong-Seok Yang <jseok.yang@samsung.com>

S5PC11X: CAMERA: fix capture resolution problem

Back camera was saying it supported capture resolutions it didn't
and would then fail at snapshot.  Now properly do what was originally
intended, which is to round unsupported resolutions to next highest
supported resolution.

Change-Id: Ia35636cf0dbc6c2cb15c633e344bd9811e74bfd1
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: rev 1.27 register settings

Notes from vendor:

Changed part:
 1. Indoor CCM
 2. Indoor Sharpness
 3. Low Light color improvement

Change-Id: Ied50f2eb598d5af842888f6188542f11de9a7156
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Fix ae_awb infinite locking problem

A recent change made ae_awb locked from start of
auto focus until it is cancelled or capture completes.
Some apps, like barcode scanner, just call auto focus
repeatedly and never cancel or do a capture.  That
would leave ae_awb locked forever, usually in a bad
color state.

This change only locks ae_awb when auto-focus is complete,
allowing enough time for ae_awb to settle.

Signed-off-by: Simon Wilson <simonwilson@google.com>

S5PC11X: CAMERA: Fix capture resolutions when cropping done on previews

When the preview resolution is not 640x480, we enable cropping
in order to not get distorted preview images.  However the change
that enabled cropping didn't disable it before the capture, resulting
in the captured images not being the right resolutions anymore.

This change undoes the cropping before capture if it active, then
restores it when preview starts again if needed.

Change-Id: Id5971667f339e7de7d187f6b426be31f0e043a57
Signed-off-by: Mike J. Chen <mjchen@sta.samsung.com>

S5PC11X: CAMERA: Fix capture error at Fireworks setting

[Fix Bug]
At Fireworks setting, sensor needs more exposure time than normal setting.
The maximum Exposure Time at Fireworks setting is 1000ms.
So change capture polling time from 500ms to 1000ms.

Change-Id: Iae4f7d714ad3a626c82b7780e7b5d3aa75a097ba
Signed-off-by: kyoungho.yun <kyoungho.yun@samsung.com>

7 files changed, 12386 insertions, 3 deletions

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 74c8c34..7937b34 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -1038,6 +1038,33 @@ config VIDEO_S5KA3DFX
         ---help---
           This driver supports S5KA3DFX SoC camera module
 
+config VIDEO_S5K4ECGX
+        tristate "S5K4ECGX Camera Sensor"
+        depends on I2C && VIDEO_V4L2
+        ---help---
+          This driver supports S5K4ECGX SoC camera module
+
+config VIDEO_S5K4ECGX_DEBUG
+	bool "S5K4ECGX Camera Sensor Debugging"
+	depends on VIDEO_S5K4ECGX
+	default n
+	---help---
+	  Enable extra debug messages for S5K4ECGX camera driver
+
+config VIDEO_S5K4ECGX_V_1_0
+	bool "S5K4ECGX Camera Sensor Version 1.0 Support"
+	depends on VIDEO_S5K4ECGX
+	default y
+	---help---
+	  Enabled support for Rev 1.0 sensor
+
+config VIDEO_S5K4ECGX_V_1_1
+	bool "S5K4ECGX Camera Sensor Version 1.1 Support"
+	depends on VIDEO_S5K4ECGX
+	default y
+	---help---
+	  Enabled support for Rev 1.1 sensor
+
 source "drivers/media/video/samsung/Kconfig"
 
 endif # VIDEO_CAPTURE_DRIVERS
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 7b8b8dc..c4ce996b 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -86,6 +86,7 @@ obj-$(CONFIG_SOC_CAMERA_RJ54N1)		+= rj54n1cb0c.o
 obj-$(CONFIG_SOC_CAMERA_TW9910)		+= tw9910.o
 
 obj-$(CONFIG_VIDEO_S5KA3DFX) 	+= s5ka3dfx.o
+obj-$(CONFIG_VIDEO_S5K4ECGX) 	+= s5k4ecgx.o
 # And now the v4l2 drivers:
 
 obj-$(CONFIG_VIDEO_BT848) += bt8xx/
diff --git a/drivers/media/video/s5k4ecgx.c b/drivers/media/video/s5k4ecgx.c
new file mode 100644
index 0000000..63fe6ab
--- /dev/null
+++ b/drivers/media/video/s5k4ecgx.c
@@ -0,0 +1,2850 @@
+/* drivers/media/video/s5k4ecgx.c
+ *
+ * Driver for s5k4ecgx (5MP Camera) from SEC
+ *
+ * Copyright (C) 2010, SAMSUNG ELECTRONICS
+ *
+ * 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.
+ */
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/version.h>
+#include <linux/vmalloc.h>
+#include <linux/completion.h>
+#include <media/v4l2-device.h>
+#include <media/v4l2-subdev.h>
+#include <media/v4l2-i2c-drv.h>
+#include <media/s5k4ecgx.h>
+#include <linux/videodev2_samsung.h>
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_V_1_0
+#include "s5k4ecgx_regs_1_0.h"
+#define S5K4ECGX_VERSION_1_0	0x00
+#endif
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_V_1_1
+#include "s5k4ecgx_regs_1_1.h"
+#define S5K4ECGX_VERSION_1_1	0x11
+#endif
+
+#define FORMAT_FLAGS_COMPRESSED		0x3
+#define SENSOR_JPEG_SNAPSHOT_MEMSIZE	0x410580
+
+#define DEFAULT_PIX_FMT		V4L2_PIX_FMT_UYVY	/* YUV422 */
+#define DEFAULT_MCLK		24000000
+#define POLL_TIME_MS		10
+#define CAPTURE_POLL_TIME_MS    1000
+
+/* maximum time for one frame at minimum fps (15fps) in normal mode */
+#define NORMAL_MODE_MAX_ONE_FRAME_DELAY_MS     67
+/* maximum time for one frame at minimum fps (4fps) in night mode */
+#define NIGHT_MODE_MAX_ONE_FRAME_DELAY_MS     250
+
+/* time to move lens to target position before last af mode register write */
+#define LENS_MOVE_TIME_MS       100
+
+/* level at or below which we need to enable flash when in auto mode */
+#define LOW_LIGHT_LEVEL		0x1D
+
+/* level at or below which we need to use low light capture mode */
+#define HIGH_LIGHT_LEVEL	0x80
+
+#define FIRST_AF_SEARCH_COUNT   80
+#define SECOND_AF_SEARCH_COUNT  80
+#define AE_STABLE_SEARCH_COUNT  4
+
+#define FIRST_SETTING_FOCUS_MODE_DELAY_MS	100
+#define SECOND_SETTING_FOCUS_MODE_DELAY_MS	200
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_DEBUG
+enum {
+	S5K4ECGX_DEBUG_I2C		= 1U << 0,
+	S5K4ECGX_DEBUG_I2C_BURSTS	= 1U << 1,
+};
+static uint32_t s5k4ecgx_debug_mask = S5K4ECGX_DEBUG_I2C_BURSTS;
+module_param_named(debug_mask, s5k4ecgx_debug_mask, uint, S_IWUSR | S_IRUGO);
+
+#define s5k4ecgx_debug(mask, x...) \
+	do { \
+		if (s5k4ecgx_debug_mask & mask) \
+			pr_info(x);	\
+	} while (0)
+#else
+
+#define s5k4ecgx_debug(mask, x...)
+
+#endif
+
+#define S5K4ECGX_VERSION_1_1	0x11
+
+/* result values returned to HAL */
+enum {
+	AUTO_FOCUS_FAILED,
+	AUTO_FOCUS_DONE,
+	AUTO_FOCUS_CANCELLED,
+};
+
+enum af_operation_status {
+	AF_NONE = 0,
+	AF_START,
+	AF_CANCEL,
+};
+
+enum s5k4ecgx_oprmode {
+	S5K4ECGX_OPRMODE_VIDEO = 0,
+	S5K4ECGX_OPRMODE_IMAGE = 1,
+};
+
+enum s5k4ecgx_preview_frame_size {
+	S5K4ECGX_PREVIEW_QCIF = 0,	/* 176x144 */
+	S5K4ECGX_PREVIEW_CIF,		/* 352x288 */
+	S5K4ECGX_PREVIEW_VGA,		/* 640x480 */
+	S5K4ECGX_PREVIEW_D1,		/* 720x480 */
+	S5K4ECGX_PREVIEW_WVGA,		/* 800x480 */
+	S5K4ECGX_PREVIEW_SVGA,		/* 800x600 */
+	S5K4ECGX_PREVIEW_WSVGA,		/* 1024x600*/
+	S5K4ECGX_PREVIEW_MAX,
+};
+
+enum s5k4ecgx_capture_frame_size {
+	S5K4ECGX_CAPTURE_VGA = 0,	/* 640x480 */
+	S5K4ECGX_CAPTURE_WVGA,		/* 800x480 */
+	S5K4ECGX_CAPTURE_SVGA,		/* 800x600 */
+	S5K4ECGX_CAPTURE_WSVGA,		/* 1024x600 */
+	S5K4ECGX_CAPTURE_1MP,		/* 1280x960 */
+	S5K4ECGX_CAPTURE_W1MP,		/* 1600x960 */
+	S5K4ECGX_CAPTURE_2MP,		/* UXGA  - 1600x1200 */
+	S5K4ECGX_CAPTURE_W2MP,		/* 35mm Academy Offset Standard 1.66 */
+					/* 2048x1232, 2.4MP */
+	S5K4ECGX_CAPTURE_3MP,		/* QXGA  - 2048x1536 */
+	S5K4ECGX_CAPTURE_W4MP,		/* WQXGA - 2560x1536 */
+	S5K4ECGX_CAPTURE_5MP,		/* 2560x1920 */
+	S5K4ECGX_CAPTURE_MAX,
+};
+
+struct s5k4ecgx_framesize {
+	u32 index;
+	u32 width;
+	u32 height;
+};
+
+static const struct s5k4ecgx_framesize s5k4ecgx_preview_framesize_list[] = {
+	{ S5K4ECGX_PREVIEW_QCIF,	176,  144 },
+	{ S5K4ECGX_PREVIEW_CIF,		352,  288 },
+	{ S5K4ECGX_PREVIEW_VGA,		640,  480 },
+	{ S5K4ECGX_PREVIEW_D1,		720,  480 },
+};
+
+static const struct s5k4ecgx_framesize s5k4ecgx_capture_framesize_list[] = {
+	{ S5K4ECGX_CAPTURE_VGA,		640,  480 },
+	{ S5K4ECGX_CAPTURE_1MP,		1280, 960 },
+	{ S5K4ECGX_CAPTURE_2MP,		1600, 1200 },
+	{ S5K4ECGX_CAPTURE_3MP,		2048, 1536 },
+	{ S5K4ECGX_CAPTURE_5MP,		2560, 1920 },
+};
+
+struct s5k4ecgx_version {
+	u32 major;
+	u32 minor;
+};
+
+struct s5k4ecgx_date_info {
+	u32 year;
+	u32 month;
+	u32 date;
+};
+
+enum s5k4ecgx_runmode {
+	S5K4ECGX_RUNMODE_NOTREADY,
+	S5K4ECGX_RUNMODE_IDLE,
+	S5K4ECGX_RUNMODE_RUNNING,
+	S5K4ECGX_RUNMODE_CAPTURE,
+};
+
+struct s5k4ecgx_firmware {
+	u32 addr;
+	u32 size;
+};
+
+struct s5k4ecgx_jpeg_param {
+	u32 enable;
+	u32 quality;
+	u32 main_size;		/* Main JPEG file size */
+	u32 thumb_size;		/* Thumbnail file size */
+	u32 main_offset;
+	u32 thumb_offset;
+	u32 postview_offset;
+};
+
+struct s5k4ecgx_position {
+	int x;
+	int y;
+};
+
+struct gps_info_common {
+	u32 direction;
+	u32 dgree;
+	u32 minute;
+	u32 second;
+};
+
+struct s5k4ecgx_gps_info {
+	unsigned char gps_buf[8];
+	unsigned char altitude_buf[4];
+	int gps_timeStamp;
+};
+
+struct s5k4ecgx_regset {
+	u32 size;
+	u8 *data;
+};
+
+struct s5k4ecgx_regset_table {
+	const u32	*reg;
+	int		array_size;
+};
+
+#define S5K4ECGX_REGSET(x, y)		\
+	[(x)] = {					\
+		.reg		= (y),			\
+		.array_size	= ARRAY_SIZE((y)),	\
+}
+
+#define S5K4ECGX_REGSET_TABLE(y)		\
+	{					\
+		.reg		= (y),			\
+		.array_size	= ARRAY_SIZE((y)),	\
+}
+
+struct s5k4ecgx_regs {
+	struct s5k4ecgx_regset_table ev[EV_MAX];
+	struct s5k4ecgx_regset_table metering[METERING_MAX];
+	struct s5k4ecgx_regset_table iso[ISO_MAX];
+	struct s5k4ecgx_regset_table effect[IMAGE_EFFECT_MAX];
+	struct s5k4ecgx_regset_table white_balance[WHITE_BALANCE_MAX];
+	struct s5k4ecgx_regset_table preview_size[S5K4ECGX_PREVIEW_MAX];
+	struct s5k4ecgx_regset_table capture_size[S5K4ECGX_CAPTURE_MAX];
+	struct s5k4ecgx_regset_table scene_mode[SCENE_MODE_MAX];
+	struct s5k4ecgx_regset_table saturation[SATURATION_MAX];
+	struct s5k4ecgx_regset_table contrast[CONTRAST_MAX];
+	struct s5k4ecgx_regset_table sharpness[SHARPNESS_MAX];
+	struct s5k4ecgx_regset_table fps[FRAME_RATE_MAX];
+	struct s5k4ecgx_regset_table preview_return;
+	struct s5k4ecgx_regset_table jpeg_quality_high;
+	struct s5k4ecgx_regset_table jpeg_quality_normal;
+	struct s5k4ecgx_regset_table jpeg_quality_low;
+	struct s5k4ecgx_regset_table flash_start;
+	struct s5k4ecgx_regset_table flash_end;
+	struct s5k4ecgx_regset_table af_assist_flash_start;
+	struct s5k4ecgx_regset_table af_assist_flash_end;
+	struct s5k4ecgx_regset_table af_low_light_mode_on;
+	struct s5k4ecgx_regset_table af_low_light_mode_off;
+	struct s5k4ecgx_regset_table ae_awb_lock_on;
+	struct s5k4ecgx_regset_table ae_awb_lock_off;
+	struct s5k4ecgx_regset_table low_cap_on;
+	struct s5k4ecgx_regset_table low_cap_off;
+	struct s5k4ecgx_regset_table wdr_on;
+	struct s5k4ecgx_regset_table wdr_off;
+	struct s5k4ecgx_regset_table face_detection_on;
+	struct s5k4ecgx_regset_table face_detection_off;
+	struct s5k4ecgx_regset_table capture_start;
+	struct s5k4ecgx_regset_table af_macro_mode_1;
+	struct s5k4ecgx_regset_table af_macro_mode_2;
+	struct s5k4ecgx_regset_table af_macro_mode_3;
+	struct s5k4ecgx_regset_table af_normal_mode_1;
+	struct s5k4ecgx_regset_table af_normal_mode_2;
+	struct s5k4ecgx_regset_table af_normal_mode_3;
+	struct s5k4ecgx_regset_table af_return_infinite_position;
+	struct s5k4ecgx_regset_table af_return_macro_position;
+	struct s5k4ecgx_regset_table single_af_start;
+	struct s5k4ecgx_regset_table single_af_off_1;
+	struct s5k4ecgx_regset_table single_af_off_2;
+	struct s5k4ecgx_regset_table dtp_start;
+	struct s5k4ecgx_regset_table dtp_stop;
+	struct s5k4ecgx_regset_table init_reg_1;
+	struct s5k4ecgx_regset_table init_reg_2;
+	struct s5k4ecgx_regset_table flash_init;
+	struct s5k4ecgx_regset_table reset_crop;
+	struct s5k4ecgx_regset_table get_ae_stable_status;
+	struct s5k4ecgx_regset_table get_light_level;
+	struct s5k4ecgx_regset_table get_1st_af_search_status;
+	struct s5k4ecgx_regset_table get_2nd_af_search_status;
+	struct s5k4ecgx_regset_table get_capture_status;
+	struct s5k4ecgx_regset_table get_esd_status;
+	struct s5k4ecgx_regset_table get_iso;
+	struct s5k4ecgx_regset_table get_shutterspeed;
+};
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_V_1_0
+static const struct s5k4ecgx_regs regs_for_fw_version_1_0 = {
+	.ev = {
+		S5K4ECGX_REGSET(EV_MINUS_4, s5k4ecgx_EV_Minus_4_v1),
+		S5K4ECGX_REGSET(EV_MINUS_3, s5k4ecgx_EV_Minus_3_v1),
+		S5K4ECGX_REGSET(EV_MINUS_2, s5k4ecgx_EV_Minus_2_v1),
+		S5K4ECGX_REGSET(EV_MINUS_1, s5k4ecgx_EV_Minus_1_v1),
+		S5K4ECGX_REGSET(EV_DEFAULT, s5k4ecgx_EV_Default_v1),
+		S5K4ECGX_REGSET(EV_PLUS_1, s5k4ecgx_EV_Plus_1_v1),
+		S5K4ECGX_REGSET(EV_PLUS_2, s5k4ecgx_EV_Plus_2_v1),
+		S5K4ECGX_REGSET(EV_PLUS_3, s5k4ecgx_EV_Plus_3_v1),
+		S5K4ECGX_REGSET(EV_PLUS_4, s5k4ecgx_EV_Plus_4_v1),
+	},
+	.metering = {
+		S5K4ECGX_REGSET(METERING_MATRIX, s5k4ecgx_Metering_Matrix_v1),
+		S5K4ECGX_REGSET(METERING_CENTER, s5k4ecgx_Metering_Center_v1),
+		S5K4ECGX_REGSET(METERING_SPOT, s5k4ecgx_Metering_Spot_v1),
+	},
+	.iso = {
+		S5K4ECGX_REGSET(ISO_AUTO, s5k4ecgx_ISO_Auto_v1),
+		S5K4ECGX_REGSET(ISO_50, s5k4ecgx_ISO_100_v1),     /* use 100 */
+		S5K4ECGX_REGSET(ISO_100, s5k4ecgx_ISO_100_v1),
+		S5K4ECGX_REGSET(ISO_200, s5k4ecgx_ISO_200_v1),
+		S5K4ECGX_REGSET(ISO_400, s5k4ecgx_ISO_400_v1),
+		S5K4ECGX_REGSET(ISO_800, s5k4ecgx_ISO_400_v1),    /* use 400 */
+		S5K4ECGX_REGSET(ISO_1600, s5k4ecgx_ISO_400_v1),   /* use 400 */
+		S5K4ECGX_REGSET(ISO_SPORTS, s5k4ecgx_ISO_Auto_v1),/* use auto */
+		S5K4ECGX_REGSET(ISO_NIGHT, s5k4ecgx_ISO_Auto_v1), /* use auto */
+		S5K4ECGX_REGSET(ISO_MOVIE, s5k4ecgx_ISO_Auto_v1), /* use auto */
+	},
+	.effect = {
+		S5K4ECGX_REGSET(IMAGE_EFFECT_NONE, s5k4ecgx_Effect_Normal_v1),
+		S5K4ECGX_REGSET(IMAGE_EFFECT_BNW,
+				s5k4ecgx_Effect_Black_White_v1),
+		S5K4ECGX_REGSET(IMAGE_EFFECT_SEPIA, s5k4ecgx_Effect_Sepia_v1),
+		S5K4ECGX_REGSET(IMAGE_EFFECT_NEGATIVE,
+				s5k4ecgx_Effect_Negative_v1),
+	},
+	.white_balance = {
+		S5K4ECGX_REGSET(WHITE_BALANCE_AUTO, s5k4ecgx_WB_Auto_v1),
+		S5K4ECGX_REGSET(WHITE_BALANCE_SUNNY, s5k4ecgx_WB_Sunny_v1),
+		S5K4ECGX_REGSET(WHITE_BALANCE_CLOUDY, s5k4ecgx_WB_Cloudy_v1),
+		S5K4ECGX_REGSET(WHITE_BALANCE_TUNGSTEN,
+				s5k4ecgx_WB_Tungsten_v1),
+		S5K4ECGX_REGSET(WHITE_BALANCE_FLUORESCENT,
+				s5k4ecgx_WB_Fluorescent_v1),
+	},
+	.preview_size = {
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_QCIF, s5k4ecgx_176_Preview_v1),
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_CIF, s5k4ecgx_352_Preview_v1),
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_VGA, s5k4ecgx_640_Preview_v1),
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_D1, s5k4ecgx_720_Preview_v1),
+	},
+	.capture_size = {
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_VGA, s5k4ecgx_VGA_Capture_v1),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_1MP, s5k4ecgx_1M_Capture_v1),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_2MP, s5k4ecgx_2M_Capture_v1),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_3MP, s5k4ecgx_3M_Capture_v1),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_5MP, s5k4ecgx_5M_Capture_v1),
+	},
+	.scene_mode = {
+		S5K4ECGX_REGSET(SCENE_MODE_NONE, s5k4ecgx_Scene_Default_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_PORTRAIT,
+				s5k4ecgx_Scene_Portrait_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_NIGHTSHOT,
+				s5k4ecgx_Scene_Nightshot_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_LANDSCAPE,
+				s5k4ecgx_Scene_Landscape_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_SPORTS, s5k4ecgx_Scene_Sports_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_PARTY_INDOOR,
+				s5k4ecgx_Scene_Party_Indoor_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_BEACH_SNOW,
+				s5k4ecgx_Scene_Beach_Snow_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_SUNSET, s5k4ecgx_Scene_Sunset_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_FIREWORKS,
+				s5k4ecgx_Scene_Fireworks_v1),
+		S5K4ECGX_REGSET(SCENE_MODE_CANDLE_LIGHT,
+				s5k4ecgx_Scene_Candle_Light_v1),
+	},
+	.saturation = {
+		S5K4ECGX_REGSET(SATURATION_MINUS_2,
+				s5k4ecgx_Saturation_Minus_2_v1),
+		S5K4ECGX_REGSET(SATURATION_MINUS_1,
+				s5k4ecgx_Saturation_Minus_1_v1),
+		S5K4ECGX_REGSET(SATURATION_DEFAULT,
+				s5k4ecgx_Saturation_Default_v1),
+		S5K4ECGX_REGSET(SATURATION_PLUS_1,
+				s5k4ecgx_Saturation_Plus_1_v1),
+		S5K4ECGX_REGSET(SATURATION_PLUS_2,
+				s5k4ecgx_Saturation_Plus_2_v1),
+	},
+	.contrast = {
+		S5K4ECGX_REGSET(CONTRAST_MINUS_2, s5k4ecgx_Contrast_Minus_2_v1),
+		S5K4ECGX_REGSET(CONTRAST_MINUS_1, s5k4ecgx_Contrast_Minus_1_v1),
+		S5K4ECGX_REGSET(CONTRAST_DEFAULT, s5k4ecgx_Contrast_Default_v1),
+		S5K4ECGX_REGSET(CONTRAST_PLUS_1, s5k4ecgx_Contrast_Plus_1_v1),
+		S5K4ECGX_REGSET(CONTRAST_PLUS_2, s5k4ecgx_Contrast_Plus_2_v1),
+	},
+	.sharpness = {
+		S5K4ECGX_REGSET(SHARPNESS_MINUS_2,
+				s5k4ecgx_Sharpness_Minus_2_v1),
+		S5K4ECGX_REGSET(SHARPNESS_MINUS_1,
+				s5k4ecgx_Sharpness_Minus_1_v1),
+		S5K4ECGX_REGSET(SHARPNESS_DEFAULT,
+				s5k4ecgx_Sharpness_Default_v1),
+		S5K4ECGX_REGSET(SHARPNESS_PLUS_1, s5k4ecgx_Sharpness_Plus_1_v1),
+		S5K4ECGX_REGSET(SHARPNESS_PLUS_2, s5k4ecgx_Sharpness_Plus_2_v1),
+	},
+	.preview_return = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Preview_Return_v1),
+	.jpeg_quality_high =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Jpeg_Quality_High_v1),
+	.jpeg_quality_normal =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Jpeg_Quality_Normal_v1),
+	.jpeg_quality_low = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Jpeg_Quality_Low_v1),
+	.flash_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Flash_Start_v1),
+	.flash_end = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Flash_End_v1),
+	.af_assist_flash_start =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Pre_Flash_Start_v1),
+	.af_assist_flash_end =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Pre_Flash_End_v1),
+	.af_low_light_mode_on =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Low_Light_Mode_On_v1),
+	.af_low_light_mode_off =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Low_Light_Mode_Off_v1),
+	.ae_awb_lock_on =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AE_AWB_Lock_On_v1),
+	.ae_awb_lock_off =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AE_AWB_Lock_Off_v1),
+	.low_cap_on = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Low_Cap_On_v1),
+	.low_cap_off = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Low_Cap_Off_v1),
+	.wdr_on = S5K4ECGX_REGSET_TABLE(s5k4ecgx_WDR_on_v1),
+	.wdr_off = S5K4ECGX_REGSET_TABLE(s5k4ecgx_WDR_off_v1),
+	.face_detection_on =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Face_Detection_On_v1),
+	.face_detection_off =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Face_Detection_Off_v1),
+	.capture_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Capture_Start_v1),
+	.af_macro_mode_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Macro_mode_1_v1),
+	.af_macro_mode_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Macro_mode_2_v1),
+	.af_macro_mode_3 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Macro_mode_3_v1),
+	.af_normal_mode_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Normal_mode_1_v1),
+	.af_normal_mode_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Normal_mode_2_v1),
+	.af_normal_mode_3 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Normal_mode_3_v1),
+	.af_return_infinite_position =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Return_Inf_pos_v1),
+	.af_return_macro_position =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Return_Macro_pos_v1),
+	.single_af_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Single_AF_Start_v1),
+	.single_af_off_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Single_AF_Off_1_v1),
+	.single_af_off_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Single_AF_Off_2_v1),
+	.dtp_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_DTP_init_v1),
+	.dtp_stop = S5K4ECGX_REGSET_TABLE(s5k4ecgx_DTP_stop_v1),
+	.init_reg_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_init_reg1_v1),
+	.init_reg_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_init_reg2_v1),
+	.flash_init = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Flash_init_v1),
+	.reset_crop = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Reset_Crop_v1),
+	.get_ae_stable_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Get_AE_Stable_Status_v1),
+	.get_light_level = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Get_Light_Level_v1),
+	.get_1st_af_search_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_1st_af_search_status_v1),
+	.get_2nd_af_search_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_2nd_af_search_status_v1),
+	.get_capture_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_capture_status_v1),
+	.get_esd_status = S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_esd_status_v1),
+	.get_iso = S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_iso_reg_v1),
+	.get_shutterspeed =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_shutterspeed_reg_v1),
+};
+#endif
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_V_1_1
+static const struct s5k4ecgx_regs regs_for_fw_version_1_1 = {
+	.ev = {
+		S5K4ECGX_REGSET(EV_MINUS_4, s5k4ecgx_EV_Minus_4),
+		S5K4ECGX_REGSET(EV_MINUS_3, s5k4ecgx_EV_Minus_3),
+		S5K4ECGX_REGSET(EV_MINUS_2, s5k4ecgx_EV_Minus_2),
+		S5K4ECGX_REGSET(EV_MINUS_1, s5k4ecgx_EV_Minus_1),
+		S5K4ECGX_REGSET(EV_DEFAULT, s5k4ecgx_EV_Default),
+		S5K4ECGX_REGSET(EV_PLUS_1, s5k4ecgx_EV_Plus_1),
+		S5K4ECGX_REGSET(EV_PLUS_2, s5k4ecgx_EV_Plus_2),
+		S5K4ECGX_REGSET(EV_PLUS_3, s5k4ecgx_EV_Plus_3),
+		S5K4ECGX_REGSET(EV_PLUS_4, s5k4ecgx_EV_Plus_4),
+	},
+	.metering = {
+		S5K4ECGX_REGSET(METERING_MATRIX, s5k4ecgx_Metering_Matrix),
+		S5K4ECGX_REGSET(METERING_CENTER, s5k4ecgx_Metering_Center),
+		S5K4ECGX_REGSET(METERING_SPOT, s5k4ecgx_Metering_Spot),
+	},
+	.iso = {
+		S5K4ECGX_REGSET(ISO_AUTO, s5k4ecgx_ISO_Auto),
+		S5K4ECGX_REGSET(ISO_50, s5k4ecgx_ISO_100),     /* map to 100 */
+		S5K4ECGX_REGSET(ISO_100, s5k4ecgx_ISO_100),
+		S5K4ECGX_REGSET(ISO_200, s5k4ecgx_ISO_200),
+		S5K4ECGX_REGSET(ISO_400, s5k4ecgx_ISO_400),
+		S5K4ECGX_REGSET(ISO_800, s5k4ecgx_ISO_400),    /* map to 400 */
+		S5K4ECGX_REGSET(ISO_1600, s5k4ecgx_ISO_400),   /* map to 400 */
+		S5K4ECGX_REGSET(ISO_SPORTS, s5k4ecgx_ISO_Auto),/* map to auto */
+		S5K4ECGX_REGSET(ISO_NIGHT, s5k4ecgx_ISO_Auto), /* map to auto */
+		S5K4ECGX_REGSET(ISO_MOVIE, s5k4ecgx_ISO_Auto), /* map to auto */
+	},
+	.effect = {
+		S5K4ECGX_REGSET(IMAGE_EFFECT_NONE, s5k4ecgx_Effect_Normal),
+		S5K4ECGX_REGSET(IMAGE_EFFECT_BNW, s5k4ecgx_Effect_Black_White),
+		S5K4ECGX_REGSET(IMAGE_EFFECT_SEPIA, s5k4ecgx_Effect_Sepia),
+		S5K4ECGX_REGSET(IMAGE_EFFECT_NEGATIVE,
+				s5k4ecgx_Effect_Negative),
+	},
+	.white_balance = {
+		S5K4ECGX_REGSET(WHITE_BALANCE_AUTO, s5k4ecgx_WB_Auto),
+		S5K4ECGX_REGSET(WHITE_BALANCE_SUNNY, s5k4ecgx_WB_Sunny),
+		S5K4ECGX_REGSET(WHITE_BALANCE_CLOUDY, s5k4ecgx_WB_Cloudy),
+		S5K4ECGX_REGSET(WHITE_BALANCE_TUNGSTEN, s5k4ecgx_WB_Tungsten),
+		S5K4ECGX_REGSET(WHITE_BALANCE_FLUORESCENT,
+				s5k4ecgx_WB_Fluorescent),
+	},
+	.preview_size = {
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_QCIF, s5k4ecgx_176_Preview),
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_CIF, s5k4ecgx_352_Preview),
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_VGA, s5k4ecgx_640_Preview),
+		S5K4ECGX_REGSET(S5K4ECGX_PREVIEW_D1, s5k4ecgx_720_Preview),
+	},
+	.capture_size = {
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_VGA, s5k4ecgx_VGA_Capture),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_1MP, s5k4ecgx_1M_Capture),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_2MP, s5k4ecgx_2M_Capture),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_3MP, s5k4ecgx_3M_Capture),
+		S5K4ECGX_REGSET(S5K4ECGX_CAPTURE_5MP, s5k4ecgx_5M_Capture),
+	},
+	.scene_mode = {
+		S5K4ECGX_REGSET(SCENE_MODE_NONE, s5k4ecgx_Scene_Default),
+		S5K4ECGX_REGSET(SCENE_MODE_PORTRAIT, s5k4ecgx_Scene_Portrait),
+		S5K4ECGX_REGSET(SCENE_MODE_NIGHTSHOT, s5k4ecgx_Scene_Nightshot),
+		S5K4ECGX_REGSET(SCENE_MODE_LANDSCAPE, s5k4ecgx_Scene_Landscape),
+		S5K4ECGX_REGSET(SCENE_MODE_SPORTS, s5k4ecgx_Scene_Sports),
+		S5K4ECGX_REGSET(SCENE_MODE_PARTY_INDOOR,
+				s5k4ecgx_Scene_Party_Indoor),
+		S5K4ECGX_REGSET(SCENE_MODE_BEACH_SNOW,
+				s5k4ecgx_Scene_Beach_Snow),
+		S5K4ECGX_REGSET(SCENE_MODE_SUNSET, s5k4ecgx_Scene_Sunset),
+		S5K4ECGX_REGSET(SCENE_MODE_FIREWORKS, s5k4ecgx_Scene_Fireworks),
+		S5K4ECGX_REGSET(SCENE_MODE_CANDLE_LIGHT,
+				s5k4ecgx_Scene_Candle_Light),
+	},
+	.saturation = {
+		S5K4ECGX_REGSET(SATURATION_MINUS_2,
+				s5k4ecgx_Saturation_Minus_2),
+		S5K4ECGX_REGSET(SATURATION_MINUS_1,
+				s5k4ecgx_Saturation_Minus_1),
+		S5K4ECGX_REGSET(SATURATION_DEFAULT,
+				s5k4ecgx_Saturation_Default),
+		S5K4ECGX_REGSET(SATURATION_PLUS_1, s5k4ecgx_Saturation_Plus_1),
+		S5K4ECGX_REGSET(SATURATION_PLUS_2, s5k4ecgx_Saturation_Plus_2),
+	},
+	.contrast = {
+		S5K4ECGX_REGSET(CONTRAST_MINUS_2, s5k4ecgx_Contrast_Minus_2),
+		S5K4ECGX_REGSET(CONTRAST_MINUS_1, s5k4ecgx_Contrast_Minus_1),
+		S5K4ECGX_REGSET(CONTRAST_DEFAULT, s5k4ecgx_Contrast_Default),
+		S5K4ECGX_REGSET(CONTRAST_PLUS_1, s5k4ecgx_Contrast_Plus_1),
+		S5K4ECGX_REGSET(CONTRAST_PLUS_2, s5k4ecgx_Contrast_Plus_2),
+	},
+	.sharpness = {
+		S5K4ECGX_REGSET(SHARPNESS_MINUS_2, s5k4ecgx_Sharpness_Minus_2),
+		S5K4ECGX_REGSET(SHARPNESS_MINUS_1, s5k4ecgx_Sharpness_Minus_1),
+		S5K4ECGX_REGSET(SHARPNESS_DEFAULT, s5k4ecgx_Sharpness_Default),
+		S5K4ECGX_REGSET(SHARPNESS_PLUS_1, s5k4ecgx_Sharpness_Plus_1),
+		S5K4ECGX_REGSET(SHARPNESS_PLUS_2, s5k4ecgx_Sharpness_Plus_2),
+	},
+	.fps = {
+		S5K4ECGX_REGSET(FRAME_RATE_AUTO, s5k4ecgx_FPS_Auto),
+		S5K4ECGX_REGSET(FRAME_RATE_7, s5k4ecgx_FPS_7),
+		S5K4ECGX_REGSET(FRAME_RATE_15, s5k4ecgx_FPS_15),
+		S5K4ECGX_REGSET(FRAME_RATE_30, s5k4ecgx_FPS_30),
+	},
+	.preview_return = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Preview_Return),
+	.jpeg_quality_high = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Jpeg_Quality_High),
+	.jpeg_quality_normal =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Jpeg_Quality_Normal),
+	.jpeg_quality_low = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Jpeg_Quality_Low),
+	.flash_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Flash_Start),
+	.flash_end = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Flash_End),
+	.af_assist_flash_start =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Pre_Flash_Start),
+	.af_assist_flash_end =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Pre_Flash_End),
+	.af_low_light_mode_on =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Low_Light_Mode_On),
+	.af_low_light_mode_off =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Low_Light_Mode_Off),
+	.ae_awb_lock_on =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AE_AWB_Lock_On),
+	.ae_awb_lock_off =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AE_AWB_Lock_Off),
+	.low_cap_on = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Low_Cap_On),
+	.low_cap_off = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Low_Cap_Off),
+	.wdr_on = S5K4ECGX_REGSET_TABLE(s5k4ecgx_WDR_on),
+	.wdr_off = S5K4ECGX_REGSET_TABLE(s5k4ecgx_WDR_off),
+	.face_detection_on = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Face_Detection_On),
+	.face_detection_off =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Face_Detection_Off),
+	.capture_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Capture_Start),
+	.af_macro_mode_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Macro_mode_1),
+	.af_macro_mode_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Macro_mode_2),
+	.af_macro_mode_3 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Macro_mode_3),
+	.af_normal_mode_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Normal_mode_1),
+	.af_normal_mode_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Normal_mode_2),
+	.af_normal_mode_3 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Normal_mode_3),
+	.af_return_infinite_position =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Return_Inf_pos),
+	.af_return_macro_position =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_AF_Return_Macro_pos),
+	.single_af_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Single_AF_Start),
+	.single_af_off_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Single_AF_Off_1),
+	.single_af_off_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Single_AF_Off_2),
+	.dtp_start = S5K4ECGX_REGSET_TABLE(s5k4ecgx_DTP_init),
+	.dtp_stop = S5K4ECGX_REGSET_TABLE(s5k4ecgx_DTP_stop),
+	.init_reg_1 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_init_reg1),
+	.init_reg_2 = S5K4ECGX_REGSET_TABLE(s5k4ecgx_init_reg2),
+	.flash_init = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Flash_init),
+	.reset_crop = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Reset_Crop),
+	.get_ae_stable_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_Get_AE_Stable_Status),
+	.get_light_level = S5K4ECGX_REGSET_TABLE(s5k4ecgx_Get_Light_Level),
+	.get_1st_af_search_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_1st_af_search_status),
+	.get_2nd_af_search_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_2nd_af_search_status),
+	.get_capture_status =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_capture_status),
+	.get_esd_status = S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_esd_status),
+	.get_iso = S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_iso_reg),
+	.get_shutterspeed =
+		S5K4ECGX_REGSET_TABLE(s5k4ecgx_get_shutterspeed_reg),
+};
+#endif
+
+struct s5k4ecgx_state {
+	struct s5k4ecgx_platform_data *pdata;
+	struct v4l2_subdev sd;
+	struct v4l2_pix_format pix;
+	struct v4l2_fract timeperframe;
+	struct s5k4ecgx_jpeg_param jpeg;
+	struct s5k4ecgx_version fw;
+	struct s5k4ecgx_version prm;
+	struct s5k4ecgx_date_info dateinfo;
+	struct s5k4ecgx_position position;
+	struct v4l2_streamparm strm;
+	struct s5k4ecgx_gps_info gps_info;
+	struct mutex ctrl_lock;
+	struct completion af_complete;
+	enum s5k4ecgx_runmode runmode;
+	enum s5k4ecgx_oprmode oprmode;
+	enum af_operation_status af_status;
+	int preview_framesize_index;
+	int capture_framesize_index;
+	int sensor_version;
+	int freq;		/* MCLK in Hz */
+	int check_dataline;
+	int check_previewdata;
+	bool flash_on;
+	bool sensor_af_in_low_light_mode;
+	bool flash_state_on_previous_capture;
+	bool initialized;
+	bool restore_preview_size_needed;
+	int one_frame_delay_ms;
+	const struct s5k4ecgx_regs *regs;
+};
+
+static const struct v4l2_fmtdesc capture_fmts[] = {
+	{
+		.index		= 0,
+		.type		= V4L2_BUF_TYPE_VIDEO_CAPTURE,
+		.flags		= FORMAT_FLAGS_COMPRESSED,
+		.description	= "JPEG + Postview",
+		.pixelformat	= V4L2_PIX_FMT_JPEG,
+	},
+};
+
+/**
+ * s5k4ecgx_i2c_read_twobyte: Read 2 bytes from sensor
+ */
+static int s5k4ecgx_i2c_read_twobyte(struct i2c_client *client,
+				  u16 subaddr, u16 *data)
+{
+	int err;
+	unsigned char buf[2];
+	struct i2c_msg msg[2];
+
+	cpu_to_be16s(&subaddr);
+
+	msg[0].addr = client->addr;
+	msg[0].flags = 0;
+	msg[0].len = 2;
+	msg[0].buf = (u8 *)&subaddr;
+
+	msg[1].addr = client->addr;
+	msg[1].flags = I2C_M_RD;
+	msg[1].len = 2;
+	msg[1].buf = buf;
+
+	err = i2c_transfer(client->adapter, msg, 2);
+	if (unlikely(err != 2)) {
+		dev_err(&client->dev,
+			"%s: register read fail\n", __func__);
+		return -EIO;
+	}
+
+	*data = ((buf[0] << 8) | buf[1]);
+
+	return 0;
+}
+
+/**
+ * s5k4ecgx_i2c_write_twobyte: Write (I2C) multiple bytes to the camera sensor
+ * @client: pointer to i2c_client
+ * @cmd: command register
+ * @w_data: data to be written
+ * @w_len: length of data to be written
+ *
+ * Returns 0 on success, <0 on error
+ */
+static int s5k4ecgx_i2c_write_twobyte(struct i2c_client *client,
+					 u16 addr, u16 w_data)
+{
+	int retry_count = 5;
+	unsigned char buf[4];
+	struct i2c_msg msg = {client->addr, 0, 4, buf};
+	int ret = 0;
+
+	buf[0] = addr >> 8;
+	buf[1] = addr;
+	buf[2] = w_data >> 8;
+	buf[3] = w_data & 0xff;
+
+	s5k4ecgx_debug(S5K4ECGX_DEBUG_I2C, "%s : W(0x%02X%02X%02X%02X)\n",
+		__func__, buf[0], buf[1], buf[2], buf[3]);
+
+	do {
+		ret = i2c_transfer(client->adapter, &msg, 1);
+		if (likely(ret == 1))
+			break;
+		msleep(POLL_TIME_MS);
+		dev_err(&client->dev, "%s: I2C err %d, retry %d.\n",
+			__func__, ret, retry_count);
+	} while (retry_count-- > 0);
+	if (ret != 1) {
+		dev_err(&client->dev, "%s: I2C is not working.\n", __func__);
+		return -EIO;
+	}
+
+	return 0;
+}
+
+static int s5k4ecgx_write_regs(struct v4l2_subdev *sd, const u32 regs[],
+			     int size)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	int i, err;
+
+	for (i = 0; i < size; i++) {
+		err = s5k4ecgx_i2c_write_twobyte(client,
+			(regs[i] >> 16), regs[i]);
+		if (unlikely(err != 0)) {
+			dev_err(&client->dev,
+				"%s: register write failed\n", __func__);
+			return err;
+		}
+	}
+
+	return 0;
+}
+
+static int s5k4ecgx_set_from_table(struct v4l2_subdev *sd,
+				const char *setting_name,
+				const struct s5k4ecgx_regset_table *table,
+				int table_size, int index)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	dev_dbg(&client->dev, "%s: set %s index %d\n",
+		__func__, setting_name, index);
+	if ((index < 0) || (index >= table_size)) {
+		dev_err(&client->dev,
+			"%s: index(%d) out of range[0:%d] for table for %s\n",
+			__func__, index, table_size, setting_name);
+		return -EINVAL;
+	}
+	table += index;
+	if (table->reg == NULL)
+		return -EINVAL;
+	return s5k4ecgx_write_regs(sd, table->reg, table->array_size);
+}
+
+static int s5k4ecgx_set_parameter(struct v4l2_subdev *sd,
+				int *current_value_ptr,
+				int new_value,
+				const char *setting_name,
+				const struct s5k4ecgx_regset_table *table,
+				int table_size)
+{
+	int err;
+
+	if (*current_value_ptr == new_value)
+		return 0;
+
+	err = s5k4ecgx_set_from_table(sd, setting_name, table,
+				table_size, new_value);
+
+	if (!err)
+		*current_value_ptr = new_value;
+	return err;
+}
+
+static int s5k4ecgx_set_preview_stop(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	if (state->runmode == S5K4ECGX_RUNMODE_RUNNING)
+		state->runmode = S5K4ECGX_RUNMODE_IDLE;
+
+	dev_dbg(&client->dev, "%s:\n", __func__);
+
+	return 0;
+}
+
+static int s5k4ecgx_set_preview_start(struct v4l2_subdev *sd)
+{
+	int err;
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	bool set_size = true;
+
+	dev_dbg(&client->dev, "%s: runmode = %d\n",
+		__func__, state->runmode);
+
+	if (!state->pix.width || !state->pix.height ||
+		!state->strm.parm.capture.timeperframe.denominator)
+		return -EINVAL;
+
+	if (state->runmode == S5K4ECGX_RUNMODE_CAPTURE) {
+		dev_dbg(&client->dev, "%s: sending Preview_Return cmd\n",
+			__func__);
+		err = s5k4ecgx_set_from_table(sd, "preview return",
+					&state->regs->preview_return, 1, 0);
+		if (err < 0) {
+			dev_err(&client->dev,
+				"%s: failed: s5k4ecgx_Preview_Return\n",
+				__func__);
+			return -EIO;
+		}
+		set_size = state->restore_preview_size_needed;
+	}
+
+	if (set_size) {
+		err = s5k4ecgx_set_from_table(sd, "preview_size",
+					state->regs->preview_size,
+					ARRAY_SIZE(state->regs->preview_size),
+					state->preview_framesize_index);
+		if (err < 0) {
+			dev_err(&client->dev,
+				"%s: failed: Could not set preview size\n",
+				__func__);
+			return -EIO;
+		}
+	}
+
+	dev_dbg(&client->dev, "%s: runmode now RUNNING\n", __func__);
+	state->runmode = S5K4ECGX_RUNMODE_RUNNING;
+
+	return 0;
+}
+
+static int s5k4ecgx_set_capture_size(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	int err;
+
+	dev_dbg(&client->dev, "%s: index:%d\n", __func__,
+		state->capture_framesize_index);
+
+	err = s5k4ecgx_set_from_table(sd, "capture_size",
+				state->regs->capture_size,
+				ARRAY_SIZE(state->regs->capture_size),
+				state->capture_framesize_index);
+	if (err < 0) {
+		dev_err(&client->dev,
+			"%s: failed: i2c_write for capture_size index %d\n",
+			__func__, state->capture_framesize_index);
+	}
+	state->runmode = S5K4ECGX_RUNMODE_CAPTURE;
+
+	return err;
+}
+
+static int s5k4ecgx_set_jpeg_quality(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	dev_dbg(&client->dev,
+		"%s: jpeg.quality %d\n", __func__, state->jpeg.quality);
+	if (state->jpeg.quality < 0)
+		state->jpeg.quality = 0;
+	if (state->jpeg.quality > 100)
+		state->jpeg.quality = 100;
+
+	switch (state->jpeg.quality) {
+	case 90 ... 100:
+		dev_dbg(&client->dev,
+			"%s: setting to high jpeg quality\n", __func__);
+		return s5k4ecgx_set_from_table(sd, "jpeg quality high",
+				&state->regs->jpeg_quality_high, 1, 0);
+	case 80 ... 89:
+		dev_dbg(&client->dev,
+			"%s: setting to normal jpeg quality\n", __func__);
+		return s5k4ecgx_set_from_table(sd, "jpeg quality normal",
+				&state->regs->jpeg_quality_normal, 1, 0);
+	default:
+		dev_dbg(&client->dev,
+			"%s: setting to low jpeg quality\n", __func__);
+		return s5k4ecgx_set_from_table(sd, "jpeg quality low",
+				&state->regs->jpeg_quality_low, 1, 0);
+	}
+}
+
+static u16 s5k4ecgx_get_light_level(struct v4l2_subdev *sd)
+{
+	int err;
+	u16 read_value = 0;
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	err = s5k4ecgx_set_from_table(sd, "get light level",
+				&state->regs->get_light_level, 1, 0);
+	if (err) {
+		dev_err(&client->dev,
+			"%s: write cmd failed, returning 0\n", __func__);
+		goto out;
+	}
+	err = s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+	if (err) {
+		dev_err(&client->dev,
+			"%s: read cmd failed, returning 0\n", __func__);
+		goto out;
+	}
+
+	dev_dbg(&client->dev, "%s: read_value = %d (0x%X)\n",
+		__func__, read_value, read_value);
+
+out:
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+	return read_value;
+}
+
+static int s5k4ecgx_start_capture(struct v4l2_subdev *sd)
+{
+	int err;
+	u16 read_value;
+	u16 light_level;
+	int poll_time_ms;
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+	struct s5k4ecgx_platform_data *pdata = client->dev.platform_data;
+
+	/* reset cropping if our current preview is not 640x480,
+	 * otherwise the capture will be wrong because of the cropping
+	 */
+	if (state->preview_framesize_index != S5K4ECGX_PREVIEW_VGA) {
+		int err = s5k4ecgx_set_from_table(sd, "reset crop",
+						&state->regs->reset_crop, 1, 0);
+		if (err < 0) {
+			dev_err(&client->dev,
+				"%s: failed: Could not set preview size\n",
+				__func__);
+			return -EIO;
+		}
+		state->restore_preview_size_needed = true;
+	} else
+		state->restore_preview_size_needed = false;
+
+	light_level = s5k4ecgx_get_light_level(sd);
+
+	dev_dbg(&client->dev, "%s: light_level = %d\n", __func__,
+		light_level);
+
+	state->flash_state_on_previous_capture = false;
+	if (parms->scene_mode != SCENE_MODE_NIGHTSHOT) {
+		switch (parms->flash_mode) {
+		case FLASH_MODE_AUTO:
+			if (light_level > LOW_LIGHT_LEVEL) {
+				/* light level bright enough
+				 * that we don't need flash
+				 */
+				break;
+			}
+			/* fall through to flash start */
+		case FLASH_MODE_ON:
+			if (parms->focus_mode == FOCUS_MODE_INFINITY) {
+				s5k4ecgx_set_from_table(sd,
+					"AF assist flash start",
+					&state->regs->af_assist_flash_start,
+					1, 0);
+				s5k4ecgx_set_from_table(sd,
+					"AF assist flash end",
+					&state->regs->af_assist_flash_end,
+					1, 0);
+				msleep(10);
+			}
+			s5k4ecgx_set_from_table(sd, "flash start",
+					&state->regs->flash_start, 1, 0);
+			state->flash_on = true;
+			state->flash_state_on_previous_capture = true;
+			pdata->flash_onoff(1);
+			break;
+		default:
+			break;
+		}
+	}
+
+	/* if light is low, use low light capture settings, EXCEPT
+	 * if scene mode set to NIGHTSHOT or SPORTS because they
+	 * have their own settings (though a low light sport setting
+	 * could be useful)
+	 */
+	if ((light_level <= HIGH_LIGHT_LEVEL) &&
+		(parms->scene_mode != SCENE_MODE_NIGHTSHOT) &&
+		(parms->scene_mode != SCENE_MODE_SPORTS)) {
+		s5k4ecgx_set_from_table(sd, "low cap on",
+					&state->regs->low_cap_on, 1, 0);
+	}
+
+	err = s5k4ecgx_set_capture_size(sd);
+	if (err < 0) {
+		dev_err(&client->dev,
+			"%s: failed: i2c_write for capture_resolution\n",
+			__func__);
+		return -EIO;
+	}
+
+	dev_dbg(&client->dev, "%s: send Capture_Start cmd\n", __func__);
+	s5k4ecgx_set_from_table(sd, "capture start",
+				&state->regs->capture_start, 1, 0);
+
+	/* a shot takes takes at least 50ms so sleep that amount first
+	 * and then start polling for completion.
+	 */
+	msleep(50);
+	/* Enter read mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x002C, 0x7000);
+	poll_time_ms = 50;
+	do {
+		s5k4ecgx_set_from_table(sd, "get capture status",
+					&state->regs->get_capture_status, 1, 0);
+		s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+		dev_dbg(&client->dev,
+			"%s: s5k4ecgx_Capture_Start check = %#x\n",
+			__func__, read_value);
+		if (read_value != 0x00)
+			break;
+		msleep(POLL_TIME_MS);
+		poll_time_ms += POLL_TIME_MS;
+	} while (poll_time_ms < CAPTURE_POLL_TIME_MS);
+
+	dev_dbg(&client->dev, "%s: capture done check finished after %d ms\n",
+		__func__, poll_time_ms);
+
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+	s5k4ecgx_set_from_table(sd, "ae awb lock off",
+				&state->regs->ae_awb_lock_off, 1, 0);
+
+	if ((light_level <= HIGH_LIGHT_LEVEL) &&
+		(parms->scene_mode != SCENE_MODE_NIGHTSHOT) &&
+		(parms->scene_mode != SCENE_MODE_SPORTS)) {
+		s5k4ecgx_set_from_table(sd, "low cap off",
+					&state->regs->low_cap_off, 1, 0);
+	}
+
+	if ((parms->scene_mode != SCENE_MODE_NIGHTSHOT) && (state->flash_on)) {
+		state->flash_on = false;
+		pdata->flash_onoff(0);
+		s5k4ecgx_set_from_table(sd, "flash end",
+					&state->regs->flash_end, 1, 0);
+	}
+
+	return 0;
+}
+
+/* wide dynamic range support */
+static int s5k4ecgx_set_wdr(struct v4l2_subdev *sd, int value)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	if (value == WDR_ON)
+		return s5k4ecgx_set_from_table(sd, "wdr on",
+					&state->regs->wdr_on, 1, 0);
+	return s5k4ecgx_set_from_table(sd, "wdr off",
+				&state->regs->wdr_off, 1, 0);
+}
+
+static int s5k4ecgx_set_face_detection(struct v4l2_subdev *sd, int value)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	if (value == FACE_DETECTION_ON)
+		return s5k4ecgx_set_from_table(sd, "face detection on",
+				&state->regs->face_detection_on, 1, 0);
+	return s5k4ecgx_set_from_table(sd, "face detection off",
+				&state->regs->face_detection_off, 1, 0);
+}
+
+static int s5k4ecgx_set_focus_mode(struct v4l2_subdev *sd, int value)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+	int err;
+
+	if (parms->focus_mode == value)
+		return 0;
+
+	dev_dbg(&client->dev, "%s value(%d)\n", __func__, value);
+
+	switch (value) {
+	case FOCUS_MODE_MACRO:
+		dev_dbg(&client->dev,
+				"%s: FOCUS_MODE_MACRO\n", __func__);
+		err = s5k4ecgx_set_from_table(sd, "af macro mode 1",
+				&state->regs->af_macro_mode_1, 1, 0);
+		if (err < 0)
+			goto fail;
+		msleep(FIRST_SETTING_FOCUS_MODE_DELAY_MS);
+		err = s5k4ecgx_set_from_table(sd, "af macro mode 2",
+				&state->regs->af_macro_mode_2, 1, 0);
+		if (err < 0)
+			goto fail;
+		msleep(SECOND_SETTING_FOCUS_MODE_DELAY_MS);
+		err = s5k4ecgx_set_from_table(sd, "af macro mode 3",
+				&state->regs->af_macro_mode_3, 1, 0);
+		if (err < 0)
+			goto fail;
+		parms->focus_mode = FOCUS_MODE_MACRO;
+		break;
+
+	case FOCUS_MODE_INFINITY:
+		err = s5k4ecgx_set_from_table(sd,
+			"af return infinite position",
+			&state->regs->af_return_infinite_position, 1, 0);
+		if (err < 0)
+			goto fail;
+		parms->focus_mode = FOCUS_MODE_INFINITY;
+		break;
+
+	case FOCUS_MODE_AUTO:
+	default:
+		dev_dbg(&client->dev,
+			"%s: FOCUS_MODE_AUTO\n", __func__);
+		err = s5k4ecgx_set_from_table(sd,
+			"af normal mode 1",
+			&state->regs->af_normal_mode_1, 1, 0);
+		if (err < 0)
+			goto fail;
+		msleep(FIRST_SETTING_FOCUS_MODE_DELAY_MS);
+		err = s5k4ecgx_set_from_table(sd,
+			"af normal mode 2",
+			&state->regs->af_normal_mode_2, 1, 0);
+		if (err < 0)
+			goto fail;
+		msleep(SECOND_SETTING_FOCUS_MODE_DELAY_MS);
+		err = s5k4ecgx_set_from_table(sd,
+			"af normal mode 3",
+			&state->regs->af_normal_mode_3, 1, 0);
+		if (err < 0)
+			goto fail;
+		parms->focus_mode = FOCUS_MODE_AUTO;
+		break;
+	}
+
+	return 0;
+fail:
+	dev_err(&client->dev,
+		"%s: i2c_write failed\n", __func__);
+	return -EIO;
+}
+
+static void s5k4ecgx_auto_focus_flash_start(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct s5k4ecgx_platform_data *pdata = client->dev.platform_data;
+	int count;
+	u16 read_value;
+
+	s5k4ecgx_set_from_table(sd, "AF assist flash start",
+				&state->regs->af_assist_flash_start, 1, 0);
+	state->flash_on = true;
+	pdata->af_assist_onoff(1);
+
+	/* delay 200ms (SLSI value) and then poll to see if AE is stable.
+	 * once it is stable, lock it and then return to do AF
+	 */
+	msleep(200);
+
+	/* enter read mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x002C, 0x7000);
+	for (count = 0; count < AE_STABLE_SEARCH_COUNT; count++) {
+		if (state->af_status == AF_CANCEL)
+			break;
+		s5k4ecgx_set_from_table(sd, "get ae stable status",
+				&state->regs->get_ae_stable_status, 1, 0);
+		s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+		dev_dbg(&client->dev, "%s: ae stable status = %#x\n",
+			__func__, read_value);
+		if (read_value == 0x1)
+			break;
+		msleep(state->one_frame_delay_ms);
+	}
+
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+	/* if we were cancelled, turn off flash */
+	if (state->af_status == AF_CANCEL) {
+		dev_dbg(&client->dev,
+			"%s: AF cancelled\n", __func__);
+		s5k4ecgx_set_from_table(sd, "AF assist flash end",
+				&state->regs->af_assist_flash_end, 1, 0);
+		state->flash_on = false;
+		pdata->af_assist_onoff(0);
+	}
+}
+
+static int s5k4ecgx_start_auto_focus(struct v4l2_subdev *sd)
+{
+	int light_level;
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+
+	dev_dbg(&client->dev, "%s: start SINGLE AF operation, flash mode %d\n",
+		__func__, parms->flash_mode);
+
+	/* in case user calls auto_focus repeatedly without a cancel
+	 * or a capture, we need to cancel here to allow ae_awb
+	 * to work again, or else we could be locked forever while
+	 * that app is running, which is not the expected behavior.
+	 */
+	s5k4ecgx_set_from_table(sd, "ae awb lock off",
+				&state->regs->ae_awb_lock_off, 1, 0);
+
+	if (parms->scene_mode == SCENE_MODE_NIGHTSHOT) {
+		/* user selected night shot mode, assume we need low light
+		 * af mode.  flash is always off in night shot mode
+		 */
+		goto enable_af_low_light_mode;
+	}
+
+	light_level = s5k4ecgx_get_light_level(sd);
+
+	switch (parms->flash_mode) {
+	case FLASH_MODE_AUTO:
+		if (light_level > LOW_LIGHT_LEVEL) {
+			/* flash not needed */
+			break;
+		}
+		/* fall through to turn on flash for AF assist */
+	case FLASH_MODE_ON:
+		s5k4ecgx_auto_focus_flash_start(sd);
+		if (state->af_status == AF_CANCEL)
+			return 0;
+		break;
+	case FLASH_MODE_OFF:
+		break;
+	default:
+		dev_err(&client->dev,
+			"%s: Unknown Flash mode 0x%x\n",
+			__func__, parms->flash_mode);
+		break;
+	}
+
+	if (light_level > LOW_LIGHT_LEVEL) {
+		if (state->sensor_af_in_low_light_mode) {
+			state->sensor_af_in_low_light_mode = false;
+			s5k4ecgx_set_from_table(sd, "af low light mode off",
+				&state->regs->af_low_light_mode_off, 1, 0);
+		}
+	} else {
+enable_af_low_light_mode:
+		if (!state->sensor_af_in_low_light_mode) {
+			state->sensor_af_in_low_light_mode = true;
+			s5k4ecgx_set_from_table(sd, "af low light mode on",
+				&state->regs->af_low_light_mode_on, 1, 0);
+		}
+	}
+
+	s5k4ecgx_set_from_table(sd, "single af start",
+				&state->regs->single_af_start, 1, 0);
+	state->af_status = AF_START;
+	INIT_COMPLETION(state->af_complete);
+	dev_dbg(&client->dev, "%s: af_status set to start\n", __func__);
+
+	return 0;
+}
+
+static int s5k4ecgx_stop_auto_focus(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+	int focus_mode = parms->focus_mode;
+
+	dev_dbg(&client->dev, "%s: single AF Off command Setting\n", __func__);
+
+	/* always cancel ae_awb, in case AF already finished before
+	 * we got called.
+	 */
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+	s5k4ecgx_set_from_table(sd, "ae awb lock off",
+				&state->regs->ae_awb_lock_off, 1, 0);
+
+	if (state->af_status != AF_START) {
+		/* we weren't in the middle auto focus operation, we're done */
+		dev_dbg(&client->dev,
+			"%s: auto focus not in progress, done\n", __func__);
+
+		if (focus_mode == FOCUS_MODE_MACRO) {
+			/* for change focus mode forcely */
+			parms->focus_mode = -1;
+			s5k4ecgx_set_focus_mode(sd, FOCUS_MODE_MACRO);
+		} else if (focus_mode == FOCUS_MODE_AUTO) {
+			/* for change focus mode forcely */
+			parms->focus_mode = -1;
+			s5k4ecgx_set_focus_mode(sd, FOCUS_MODE_AUTO);
+		}
+
+		return 0;
+	}
+
+	/* auto focus was in progress.  the other thread
+	 * is either in the middle of get_auto_focus_result()
+	 * or will call it shortly.  set a flag to have
+	 * it abort it's polling.  that thread will
+	 * also do cleanup like restore focus position.
+	 *
+	 * it might be enough to just send sensor commands
+	 * to abort auto focus and the other thread would get
+	 * that state from it's polling calls, but I'm not sure.
+	 */
+	state->af_status = AF_CANCEL;
+	dev_dbg(&client->dev,
+		"%s: sending Single_AF_Off commands to sensor\n", __func__);
+
+	s5k4ecgx_set_from_table(sd, "single af off 1",
+				&state->regs->single_af_off_1, 1, 0);
+
+	msleep(state->one_frame_delay_ms);
+
+	s5k4ecgx_set_from_table(sd, "single af off 2",
+				&state->regs->single_af_off_2, 1, 0);
+
+	/* wait until the other thread has completed
+	 * aborting the auto focus and restored state
+	 */
+	dev_dbg(&client->dev, "%s: wait AF cancel done start\n", __func__);
+	mutex_unlock(&state->ctrl_lock);
+	wait_for_completion(&state->af_complete);
+	mutex_lock(&state->ctrl_lock);
+	dev_dbg(&client->dev, "%s: wait AF cancel done finished\n", __func__);
+
+	return 0;
+}
+
+/* called by HAL after auto focus was started to get the result.
+ * it might be aborted asynchronously by a call to set_auto_focus
+ */
+static int s5k4ecgx_get_auto_focus_result(struct v4l2_subdev *sd,
+					struct v4l2_control *ctrl)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	int err, count;
+	u16 read_value;
+
+	dev_dbg(&client->dev, "%s: Check AF Result\n", __func__);
+
+	if (state->af_status == AF_NONE) {
+		dev_dbg(&client->dev,
+			"%s: auto focus never started, returning 0x2\n",
+			__func__);
+		ctrl->value = AUTO_FOCUS_CANCELLED;
+		return 0;
+	}
+
+	/* must delay 2 frame times before checking result of 1st phase */
+	mutex_unlock(&state->ctrl_lock);
+	msleep(state->one_frame_delay_ms*2);
+	mutex_lock(&state->ctrl_lock);
+
+	/* lock AE and AWB after first AF search */
+	s5k4ecgx_set_from_table(sd, "ae awb lock on",
+				&state->regs->ae_awb_lock_on, 1, 0);
+
+	dev_dbg(&client->dev, "%s: 1st AF search\n", __func__);
+	/* enter read mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x002C, 0x7000);
+	for (count = 0; count < FIRST_AF_SEARCH_COUNT; count++) {
+		if (state->af_status == AF_CANCEL) {
+			dev_dbg(&client->dev,
+				"%s: AF is cancelled while doing\n", __func__);
+			ctrl->value = AUTO_FOCUS_CANCELLED;
+			goto check_flash;
+		}
+		s5k4ecgx_set_from_table(sd, "get 1st af search status",
+					&state->regs->get_1st_af_search_status,
+					1, 0);
+		s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+		dev_dbg(&client->dev,
+			"%s: 1st i2c_read --- read_value == 0x%x\n",
+			__func__, read_value);
+
+		/* check for success and failure cases.  0x1 is
+		 * auto focus still in progress.  0x2 is success.
+		 * 0x0,0x3,0x4,0x6,0x8 are all failures cases
+		 */
+		if (read_value != 0x01)
+			break;
+		mutex_unlock(&state->ctrl_lock);
+		msleep(50);
+		mutex_lock(&state->ctrl_lock);
+	}
+
+	if ((count >= FIRST_AF_SEARCH_COUNT) || (read_value != 0x02)) {
+		dev_dbg(&client->dev,
+			"%s: 1st scan timed out or failed\n", __func__);
+		ctrl->value = AUTO_FOCUS_FAILED;
+		goto check_flash;
+	}
+
+	dev_dbg(&client->dev, "%s: 2nd AF search\n", __func__);
+
+	/* delay 1 frame time before checking for 2nd AF completion */
+	mutex_unlock(&state->ctrl_lock);
+	msleep(state->one_frame_delay_ms);
+	mutex_lock(&state->ctrl_lock);
+
+	/* this is the long portion of AF, can take a second or more.
+	 * we poll and wakeup more frequently than 1 second mainly
+	 * to see if a cancel was requested
+	 */
+	for (count = 0; count < SECOND_AF_SEARCH_COUNT; count++) {
+		if (state->af_status == AF_CANCEL) {
+			dev_dbg(&client->dev,
+				"%s: AF is cancelled while doing\n", __func__);
+			ctrl->value = AUTO_FOCUS_CANCELLED;
+			goto check_flash;
+		}
+		s5k4ecgx_set_from_table(sd, "get 2nd af search status",
+					&state->regs->get_2nd_af_search_status,
+					1, 0);
+		s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+		dev_dbg(&client->dev,
+			"%s: 2nd i2c_read --- read_value == 0x%x\n",
+			__func__, read_value);
+
+		/* low byte is garbage.  done when high byte is 0x0 */
+		if (!(read_value & 0xff00))
+			break;
+
+		mutex_unlock(&state->ctrl_lock);
+		msleep(50);
+		mutex_lock(&state->ctrl_lock);
+	}
+
+	if (count >= SECOND_AF_SEARCH_COUNT) {
+		dev_dbg(&client->dev, "%s: 2nd scan timed out\n", __func__);
+		ctrl->value = AUTO_FOCUS_FAILED;
+		goto check_flash;
+	}
+
+	dev_dbg(&client->dev, "%s: AF is success\n", __func__);
+	ctrl->value = AUTO_FOCUS_DONE;
+
+check_flash:
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+	if (state->flash_on) {
+		struct s5k4ecgx_platform_data *pd = client->dev.platform_data;
+		s5k4ecgx_set_from_table(sd, "AF assist flash end",
+				&state->regs->af_assist_flash_end, 1, 0);
+		state->flash_on = false;
+		pd->af_assist_onoff(0);
+	}
+
+	dev_dbg(&client->dev, "%s: single AF finished\n", __func__);
+	state->af_status = AF_NONE;
+	complete(&state->af_complete);
+	return err;
+}
+
+static void s5k4ecgx_init_parameters(struct v4l2_subdev *sd)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+
+	state->strm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	parms->capture.capturemode = 0;
+	parms->capture.timeperframe.numerator = 1;
+	parms->capture.timeperframe.denominator = 30;
+	parms->contrast = CONTRAST_DEFAULT;
+	parms->effects = IMAGE_EFFECT_NONE;
+	parms->brightness = EV_DEFAULT;
+	parms->flash_mode = FLASH_MODE_AUTO;
+	parms->focus_mode = FOCUS_MODE_AUTO;
+	parms->iso = ISO_AUTO;
+	parms->metering = METERING_CENTER;
+	parms->saturation = SATURATION_DEFAULT;
+	parms->scene_mode = SCENE_MODE_NONE;
+	parms->sharpness = SHARPNESS_DEFAULT;
+	parms->white_balance = WHITE_BALANCE_AUTO;
+
+	state->jpeg.enable = 0;
+	state->jpeg.quality = 100;
+	state->jpeg.main_offset = 0;
+	state->jpeg.main_size = 0;
+	state->jpeg.thumb_offset = 0;
+	state->jpeg.thumb_size = 0;
+	state->jpeg.postview_offset = 0;
+
+	state->fw.major = 1;
+
+	state->one_frame_delay_ms = NORMAL_MODE_MAX_ONE_FRAME_DELAY_MS;
+}
+
+static void s5k4ecgx_set_framesize(struct v4l2_subdev *sd,
+				const struct s5k4ecgx_framesize *frmsize,
+				int frmsize_count, bool exact_match);
+static int s5k4ecgx_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+
+	dev_dbg(&client->dev, "%s: pixelformat = 0x%x (%c%c%c%c),"
+		" colorspace = 0x%x, width = %d, height = %d\n",
+		__func__, fmt->fmt.pix.pixelformat,
+		fmt->fmt.pix.pixelformat,
+		fmt->fmt.pix.pixelformat >> 8,
+		fmt->fmt.pix.pixelformat >> 16,
+		fmt->fmt.pix.pixelformat >> 24,
+		fmt->fmt.pix.colorspace,
+		fmt->fmt.pix.width, fmt->fmt.pix.height);
+
+	if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_JPEG &&
+		fmt->fmt.pix.colorspace != V4L2_COLORSPACE_JPEG) {
+		dev_err(&client->dev,
+			"%s: mismatch in pixelformat and colorspace\n",
+			__func__);
+		return -EINVAL;
+	}
+
+	state->pix.width = fmt->fmt.pix.width;
+	state->pix.height = fmt->fmt.pix.height;
+	state->pix.pixelformat = fmt->fmt.pix.pixelformat;
+
+	if (fmt->fmt.pix.colorspace == V4L2_COLORSPACE_JPEG) {
+		state->oprmode = S5K4ECGX_OPRMODE_IMAGE;
+		/*
+		 * In case of image capture mode,
+		 * if the given image resolution is not supported,
+		 * use the next higher image resolution. */
+		s5k4ecgx_set_framesize(sd, s5k4ecgx_capture_framesize_list,
+				ARRAY_SIZE(s5k4ecgx_capture_framesize_list),
+				false);
+
+	} else {
+		state->oprmode = S5K4ECGX_OPRMODE_VIDEO;
+		/*
+		 * In case of video mode,
+		 * if the given video resolution is not matching, use
+		 * the default rate (currently S5K4ECGX_PREVIEW_WVGA).
+		 */
+		s5k4ecgx_set_framesize(sd, s5k4ecgx_preview_framesize_list,
+				ARRAY_SIZE(s5k4ecgx_preview_framesize_list),
+				true);
+	}
+
+	state->jpeg.enable = state->pix.pixelformat == V4L2_PIX_FMT_JPEG;
+
+	return 0;
+}
+
+static int s5k4ecgx_enum_framesizes(struct v4l2_subdev *sd,
+				  struct v4l2_frmsizeenum *fsize)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	/* The camera interface should read this value, this is the resolution
+	 * at which the sensor would provide framedata to the camera i/f
+	 *
+	 * In case of image capture,
+	 * this returns the default camera resolution (SVGA)
+	 */
+	fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+	fsize->discrete.width = state->pix.width;
+	fsize->discrete.height = state->pix.height;
+	return 0;
+}
+
+static int s5k4ecgx_enum_fmt(struct v4l2_subdev *sd,
+			struct v4l2_fmtdesc *fmtdesc)
+{
+	pr_debug("%s: index = %d\n", __func__, fmtdesc->index);
+
+	if (fmtdesc->index >= ARRAY_SIZE(capture_fmts))
+		return -EINVAL;
+
+	memcpy(fmtdesc, &capture_fmts[fmtdesc->index], sizeof(*fmtdesc));
+
+	return 0;
+}
+
+static int s5k4ecgx_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
+{
+	int num_entries;
+	int i;
+
+	num_entries = ARRAY_SIZE(capture_fmts);
+
+	pr_debug("%s: pixelformat = 0x%x (%c%c%c%c), num_entries = %d\n",
+		__func__, fmt->fmt.pix.pixelformat,
+		fmt->fmt.pix.pixelformat,
+		fmt->fmt.pix.pixelformat >> 8,
+		fmt->fmt.pix.pixelformat >> 16,
+		fmt->fmt.pix.pixelformat >> 24,
+		num_entries);
+
+	for (i = 0; i < num_entries; i++) {
+		if (capture_fmts[i].pixelformat == fmt->fmt.pix.pixelformat) {
+			pr_debug("%s: match found, returning 0\n", __func__);
+			return 0;
+		}
+	}
+
+	pr_debug("%s: no match found, returning -EINVAL\n", __func__);
+	return -EINVAL;
+}
+
+static void s5k4ecgx_enable_torch(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct s5k4ecgx_platform_data *pdata = client->dev.platform_data;
+
+	s5k4ecgx_set_from_table(sd, "flash start",
+				&state->regs->flash_start, 1, 0);
+	state->flash_on = true;
+	pdata->torch_onoff(1);
+}
+
+static void s5k4ecgx_disable_torch(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct s5k4ecgx_platform_data *pdata = client->dev.platform_data;
+
+	if (state->flash_on) {
+		state->flash_on = false;
+		pdata->torch_onoff(0);
+		s5k4ecgx_set_from_table(sd, "flash end",
+					&state->regs->flash_end, 1, 0);
+	}
+}
+static int s5k4ecgx_set_flash_mode(struct v4l2_subdev *sd, int value)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+
+	if (parms->flash_mode == value)
+		return 0;
+
+	if ((value >= FLASH_MODE_OFF) && (value <= FLASH_MODE_TORCH)) {
+		pr_debug("%s: setting flash mode to %d\n",
+			__func__, value);
+		parms->flash_mode = value;
+		if (parms->flash_mode == FLASH_MODE_TORCH)
+			s5k4ecgx_enable_torch(sd);
+		else
+			s5k4ecgx_disable_torch(sd);
+		return 0;
+	}
+	pr_debug("%s: trying to set invalid flash mode %d\n",
+		__func__, value);
+	return -EINVAL;
+}
+
+static int s5k4ecgx_g_parm(struct v4l2_subdev *sd,
+			struct v4l2_streamparm *param)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	memcpy(param, &state->strm, sizeof(param));
+	return 0;
+}
+
+static int s5k4ecgx_s_parm(struct v4l2_subdev *sd,
+			struct v4l2_streamparm *param)
+{
+	int err = 0;
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *new_parms =
+		(struct sec_cam_parm *)&param->parm.raw_data;
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+
+	dev_dbg(&client->dev, "%s: start\n", __func__);
+
+	if (param->parm.capture.timeperframe.numerator !=
+		parms->capture.timeperframe.numerator ||
+		param->parm.capture.timeperframe.denominator !=
+		parms->capture.timeperframe.denominator) {
+
+		int fps = 0;
+		int fps_max = 30;
+
+		if (param->parm.capture.timeperframe.numerator &&
+			param->parm.capture.timeperframe.denominator)
+			fps =
+			    (int)(param->parm.capture.timeperframe.denominator /
+				  param->parm.capture.timeperframe.numerator);
+		else
+			fps = 0;
+
+		if (fps <= 0 || fps > fps_max) {
+			dev_err(&client->dev,
+				"%s: Framerate %d not supported,"
+				" setting it to %d fps.\n",
+				__func__, fps, fps_max);
+			fps = fps_max;
+		}
+
+		/*
+		 * Don't set the fps value, just update it in the state
+		 * We will set the resolution and
+		 * fps in the start operation (preview/capture) call
+		 */
+		parms->capture.timeperframe.numerator = 1;
+		parms->capture.timeperframe.denominator = fps;
+	}
+
+	/* we return an error if one happened but don't stop trying to
+	 * set all parameters passed
+	 */
+	err = s5k4ecgx_set_parameter(sd, &parms->contrast, new_parms->contrast,
+				"contrast", state->regs->contrast,
+				ARRAY_SIZE(state->regs->contrast));
+	err |= s5k4ecgx_set_parameter(sd, &parms->effects, new_parms->effects,
+				"effect", state->regs->effect,
+				ARRAY_SIZE(state->regs->effect));
+	err |= s5k4ecgx_set_parameter(sd, &parms->brightness,
+				new_parms->brightness, "brightness",
+				state->regs->ev, ARRAY_SIZE(state->regs->ev));
+	err |= s5k4ecgx_set_flash_mode(sd, new_parms->flash_mode);
+	err |= s5k4ecgx_set_focus_mode(sd, new_parms->focus_mode);
+	err |= s5k4ecgx_set_parameter(sd, &parms->iso, new_parms->iso,
+				"iso", state->regs->iso,
+				ARRAY_SIZE(state->regs->iso));
+	err |= s5k4ecgx_set_parameter(sd, &parms->metering, new_parms->metering,
+				"metering", state->regs->metering,
+				ARRAY_SIZE(state->regs->metering));
+	err |= s5k4ecgx_set_parameter(sd, &parms->saturation,
+				new_parms->saturation, "saturation",
+				state->regs->saturation,
+				ARRAY_SIZE(state->regs->saturation));
+	err |= s5k4ecgx_set_parameter(sd, &parms->scene_mode,
+				new_parms->scene_mode, "scene_mode",
+				state->regs->scene_mode,
+				ARRAY_SIZE(state->regs->scene_mode));
+	err |= s5k4ecgx_set_parameter(sd, &parms->sharpness,
+				new_parms->sharpness, "sharpness",
+				state->regs->sharpness,
+				ARRAY_SIZE(state->regs->sharpness));
+	err |= s5k4ecgx_set_parameter(sd, &parms->white_balance,
+				new_parms->white_balance, "white balance",
+				state->regs->white_balance,
+				ARRAY_SIZE(state->regs->white_balance));
+	err |= s5k4ecgx_set_parameter(sd, &parms->fps,
+				new_parms->fps, "fps",
+				state->regs->fps,
+				ARRAY_SIZE(state->regs->fps));
+
+	if (parms->scene_mode == SCENE_MODE_NIGHTSHOT)
+		state->one_frame_delay_ms = NIGHT_MODE_MAX_ONE_FRAME_DELAY_MS;
+	else
+		state->one_frame_delay_ms = NORMAL_MODE_MAX_ONE_FRAME_DELAY_MS;
+
+	dev_dbg(&client->dev, "%s: returning %d\n", __func__, err);
+	return err;
+}
+
+/* This function is called from the g_ctrl api
+ *
+ * This function should be called only after the s_fmt call,
+ * which sets the required width/height value.
+ *
+ * It checks a list of available frame sizes and sets the
+ * most appropriate frame size.
+ *
+ * The list is stored in an increasing order (as far as possible).
+ * Hence the first entry (searching from the beginning) where both the
+ * width and height is more than the required value is returned.
+ * In case of no perfect match, we set the last entry (which is supposed
+ * to be the largest resolution supported.)
+ */
+static void s5k4ecgx_set_framesize(struct v4l2_subdev *sd,
+				const struct s5k4ecgx_framesize *frmsize,
+				int frmsize_count, bool preview)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	const struct s5k4ecgx_framesize *last_frmsize =
+		&frmsize[frmsize_count - 1];
+
+	dev_dbg(&client->dev, "%s: Requested Res: %dx%d\n", __func__,
+		state->pix.width, state->pix.height);
+
+	do {
+		/*
+		 * In case of image capture mode,
+		 * if the given image resolution is not supported,
+		 * return the next higher image resolution. */
+		if (preview) {
+			if (frmsize->width == state->pix.width &&
+				frmsize->height == state->pix.height) {
+				break;
+			}
+		} else {
+			dev_dbg(&client->dev,
+				"%s: compare frmsize %dx%d to %dx%d\n",
+				__func__,
+				frmsize->width, frmsize->height,
+				state->pix.width, state->pix.height);
+			if (frmsize->width >= state->pix.width &&
+				frmsize->height >= state->pix.height) {
+				dev_dbg(&client->dev,
+					"%s: select frmsize %dx%d, index=%d\n",
+					__func__,
+					frmsize->width, frmsize->height,
+					frmsize->index);
+				break;
+			}
+		}
+
+		frmsize++;
+	} while (frmsize <= last_frmsize);
+
+	if (frmsize > last_frmsize)
+		frmsize = last_frmsize;
+
+	state->pix.width = frmsize->width;
+	state->pix.height = frmsize->height;
+	if (preview) {
+		state->preview_framesize_index = frmsize->index;
+		dev_dbg(&client->dev, "%s: Preview Res Set: %dx%d, index %d\n",
+			__func__, state->pix.width, state->pix.height,
+			state->preview_framesize_index);
+	} else {
+		state->capture_framesize_index = frmsize->index;
+		dev_dbg(&client->dev, "%s: Capture Res Set: %dx%d, index %d\n",
+			__func__, state->pix.width, state->pix.height,
+			state->capture_framesize_index);
+	}
+}
+
+static int s5k4ecgx_check_dataline_stop(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	int err;
+
+	dev_dbg(&client->dev, "%s\n", __func__);
+
+	err = s5k4ecgx_set_from_table(sd, "DTP stop",
+				&state->regs->dtp_stop, 1, 0);
+	if (err < 0) {
+		v4l_info(client, "%s: register set failed\n", __func__);
+		return -EIO;
+	}
+
+	state->check_dataline = 0;
+
+	return err;
+}
+
+static void s5k4ecgx_get_esd_int(struct v4l2_subdev *sd,
+				struct v4l2_control *ctrl)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	u16 read_value;
+	int err;
+
+	if ((S5K4ECGX_RUNMODE_RUNNING == state->runmode) &&
+		(state->af_status != AF_START)) {
+		err = s5k4ecgx_set_from_table(sd, "get esd status",
+					&state->regs->get_esd_status,
+					1, 0);
+		err |= s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+		dev_dbg(&client->dev,
+			"%s: read_value == 0x%x\n", __func__, read_value);
+		/* return to write mode */
+		err |= s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+		if (err < 0) {
+			v4l_info(client,
+				"Failed I2C for getting ESD information\n");
+			ctrl->value = 0x01;
+		} else {
+			if (read_value != 0x0000) {
+				v4l_info(client, "ESD interrupt happened!!\n");
+				ctrl->value = 0x01;
+			} else {
+				dev_dbg(&client->dev,
+					"%s: No ESD interrupt!!\n", __func__);
+				ctrl->value = 0x00;
+			}
+		}
+	} else
+		ctrl->value = 0x00;
+}
+
+/* returns the real iso currently used by sensor due to lighting
+ * conditions, not the requested iso we sent using s_ctrl.
+ */
+static int s5k4ecgx_get_iso(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+	int err;
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	u16 read_value1 = 0;
+	u16 read_value2 = 0;
+	int read_value;
+
+	err = s5k4ecgx_set_from_table(sd, "get iso",
+				&state->regs->get_iso, 1, 0);
+	err |= s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value1);
+	err |= s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value2);
+
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+	read_value = read_value1 * read_value2 / 0x100 / 2;
+
+	if (read_value > 0x400)
+		ctrl->value = ISO_400;
+	else if (read_value > 0x200)
+		ctrl->value = ISO_200;
+	else if (read_value > 0x100)
+		ctrl->value = ISO_100;
+	else
+		ctrl->value = ISO_50;
+
+	dev_dbg(&client->dev, "%s: get iso == %d (0x%x, 0x%x)\n",
+		__func__, ctrl->value, read_value1, read_value2);
+
+	return err;
+}
+
+static int s5k4ecgx_get_shutterspeed(struct v4l2_subdev *sd,
+	struct v4l2_control *ctrl)
+{
+	int err;
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	u16 read_value = 0;
+
+	err = s5k4ecgx_set_from_table(sd, "get shutterspeed",
+				&state->regs->get_shutterspeed, 1, 0);
+	err |= s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+	ctrl->value = read_value / 400;
+	dev_dbg(&client->dev,
+			"%s: get shutterspeed == %d\n", __func__, ctrl->value);
+
+	return err;
+}
+
+static int s5k4ecgx_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+	int err = 0;
+
+	if (!state->initialized) {
+		dev_err(&client->dev,
+			"%s: return error because uninitialized\n", __func__);
+		return -ENODEV;
+	}
+
+	mutex_lock(&state->ctrl_lock);
+
+	switch (ctrl->id) {
+	case V4L2_CID_CAMERA_WHITE_BALANCE:
+		ctrl->value = parms->white_balance;
+		break;
+	case V4L2_CID_CAMERA_EFFECT:
+		ctrl->value = parms->effects;
+		break;
+	case V4L2_CID_CAMERA_CONTRAST:
+		ctrl->value = parms->contrast;
+		break;
+	case V4L2_CID_CAMERA_SATURATION:
+		ctrl->value = parms->saturation;
+		break;
+	case V4L2_CID_CAMERA_SHARPNESS:
+		ctrl->value = parms->sharpness;
+		break;
+	case V4L2_CID_CAM_JPEG_MAIN_SIZE:
+		ctrl->value = state->jpeg.main_size;
+		break;
+	case V4L2_CID_CAM_JPEG_MAIN_OFFSET:
+		ctrl->value = state->jpeg.main_offset;
+		break;
+	case V4L2_CID_CAM_JPEG_THUMB_SIZE:
+		ctrl->value = state->jpeg.thumb_size;
+		break;
+	case V4L2_CID_CAM_JPEG_THUMB_OFFSET:
+		ctrl->value = state->jpeg.thumb_offset;
+		break;
+	case V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET:
+		ctrl->value = state->jpeg.postview_offset;
+		break;
+	case V4L2_CID_CAM_JPEG_MEMSIZE:
+		ctrl->value = SENSOR_JPEG_SNAPSHOT_MEMSIZE;
+		break;
+	case V4L2_CID_CAM_JPEG_QUALITY:
+		ctrl->value = state->jpeg.quality;
+		break;
+	case V4L2_CID_CAMERA_AUTO_FOCUS_RESULT:
+		err = s5k4ecgx_get_auto_focus_result(sd, ctrl);
+		break;
+	case V4L2_CID_CAM_DATE_INFO_YEAR:
+		ctrl->value = 2010;
+		break;
+	case V4L2_CID_CAM_DATE_INFO_MONTH:
+		ctrl->value = 2;
+		break;
+	case V4L2_CID_CAM_DATE_INFO_DATE:
+		ctrl->value = 25;
+		break;
+	case V4L2_CID_CAM_SENSOR_VER:
+		ctrl->value = 1;
+		break;
+	case V4L2_CID_CAM_FW_MINOR_VER:
+		ctrl->value = state->fw.minor;
+		break;
+	case V4L2_CID_CAM_FW_MAJOR_VER:
+		ctrl->value = state->fw.major;
+		break;
+	case V4L2_CID_CAM_PRM_MINOR_VER:
+		ctrl->value = state->prm.minor;
+		break;
+	case V4L2_CID_CAM_PRM_MAJOR_VER:
+		ctrl->value = state->prm.major;
+		break;
+	case V4L2_CID_ESD_INT:
+		s5k4ecgx_get_esd_int(sd, ctrl);
+		break;
+	case V4L2_CID_CAMERA_GET_ISO:
+		err = s5k4ecgx_get_iso(sd, ctrl);
+		break;
+	case V4L2_CID_CAMERA_GET_SHT_TIME:
+		err = s5k4ecgx_get_shutterspeed(sd, ctrl);
+		break;
+	case V4L2_CID_CAMERA_GET_FLASH_ONOFF:
+		ctrl->value = state->flash_state_on_previous_capture;
+		break;
+	case V4L2_CID_CAMERA_OBJ_TRACKING_STATUS:
+	case V4L2_CID_CAMERA_SMART_AUTO_STATUS:
+		break;
+	default:
+		err = -ENOIOCTLCMD;
+		dev_err(&client->dev, "%s: unknown ctrl id 0x%x\n",
+			__func__, ctrl->id);
+		break;
+	}
+
+	mutex_unlock(&state->ctrl_lock);
+
+	return err;
+}
+
+static int s5k4ecgx_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct sec_cam_parm *parms =
+		(struct sec_cam_parm *)&state->strm.parm.raw_data;
+	int err = 0;
+	int value = ctrl->value;
+
+	if (!state->initialized &&
+		(ctrl->id != V4L2_CID_CAMERA_CHECK_DATALINE)) {
+		dev_err(&client->dev,
+			"%s: return error because uninitialized\n", __func__);
+		return -ENODEV;
+	}
+
+	dev_dbg(&client->dev, "%s: V4l2 control ID =%d, val = %d\n",
+		__func__, ctrl->id - V4L2_CID_PRIVATE_BASE, value);
+
+	mutex_lock(&state->ctrl_lock);
+
+	switch (ctrl->id) {
+	case V4L2_CID_CAMERA_FLASH_MODE:
+		err = s5k4ecgx_set_flash_mode(sd, value);
+		break;
+	case V4L2_CID_CAMERA_BRIGHTNESS:
+		if (state->runmode == S5K4ECGX_RUNMODE_RUNNING) {
+			err = s5k4ecgx_set_parameter(sd, &parms->brightness,
+						value, "brightness",
+						state->regs->ev,
+						ARRAY_SIZE(state->regs->ev));
+		} else {
+			dev_err(&client->dev,
+				"%s: trying to set brightness when not "
+				"in preview mode\n",
+				__func__);
+			err = -EINVAL;
+		}
+		break;
+	case V4L2_CID_CAMERA_WHITE_BALANCE:
+		if (state->runmode == S5K4ECGX_RUNMODE_RUNNING) {
+			err = s5k4ecgx_set_parameter(sd, &parms->white_balance,
+					value, "white balance",
+					state->regs->white_balance,
+					ARRAY_SIZE(state->regs->white_balance));
+		} else {
+			dev_err(&client->dev,
+				"%s: trying to set white balance when not "
+				"in preview mode\n",
+				__func__);
+			err = -EINVAL;
+		}
+		break;
+	case V4L2_CID_CAMERA_EFFECT:
+		if (state->runmode == S5K4ECGX_RUNMODE_RUNNING) {
+			err = s5k4ecgx_set_parameter(sd, &parms->effects,
+					value, "effects", state->regs->effect,
+					ARRAY_SIZE(state->regs->effect));
+		} else {
+			dev_err(&client->dev,
+				"%s: trying to set effect when not "
+				"in preview mode\n",
+				__func__);
+			err = -EINVAL;
+		}
+		break;
+	case V4L2_CID_CAMERA_ISO:
+		if (state->runmode == S5K4ECGX_RUNMODE_RUNNING) {
+			err = s5k4ecgx_set_parameter(sd, &parms->iso,
+						value, "iso",
+						state->regs->iso,
+						ARRAY_SIZE(state->regs->iso));
+		} else {
+			dev_err(&client->dev,
+				"%s: trying to set iso when not "
+				"in preview mode\n",
+				__func__);
+			err = -EINVAL;
+		}
+		break;
+	case V4L2_CID_CAMERA_METERING:
+		if (state->runmode == S5K4ECGX_RUNMODE_RUNNING) {
+			err = s5k4ecgx_set_parameter(sd, &parms->metering,
+					value, "metering",
+					state->regs->metering,
+					ARRAY_SIZE(state->regs->metering));
+		} else {
+			dev_err(&client->dev,
+				"%s: trying to set metering when not "
+				"in preview mode\n",
+				__func__);
+			err = -EINVAL;
+		}
+		break;
+	case V4L2_CID_CAMERA_CONTRAST:
+		err = s5k4ecgx_set_parameter(sd, &parms->contrast,
+					value, "contrast",
+					state->regs->contrast,
+					ARRAY_SIZE(state->regs->contrast));
+		break;
+	case V4L2_CID_CAMERA_SATURATION:
+		err = s5k4ecgx_set_parameter(sd, &parms->saturation,
+					value, "saturation",
+					state->regs->saturation,
+					ARRAY_SIZE(state->regs->saturation));
+		break;
+	case V4L2_CID_CAMERA_SHARPNESS:
+		err = s5k4ecgx_set_parameter(sd, &parms->sharpness,
+					value, "sharpness",
+					state->regs->sharpness,
+					ARRAY_SIZE(state->regs->sharpness));
+		break;
+	case V4L2_CID_CAMERA_WDR:
+		err = s5k4ecgx_set_wdr(sd, value);
+		break;
+	case V4L2_CID_CAMERA_FACE_DETECTION:
+		err = s5k4ecgx_set_face_detection(sd, value);
+		break;
+	case V4L2_CID_CAMERA_FOCUS_MODE:
+		err = s5k4ecgx_set_focus_mode(sd, value);
+		break;
+	case V4L2_CID_CAM_JPEG_QUALITY:
+		if (state->runmode == S5K4ECGX_RUNMODE_RUNNING) {
+			state->jpeg.quality = value;
+			err = s5k4ecgx_set_jpeg_quality(sd);
+		} else {
+			dev_err(&client->dev,
+				"%s: trying to set jpeg quality when not "
+				"in preview mode\n",
+				__func__);
+			err = -EINVAL;
+		}
+		break;
+	case V4L2_CID_CAMERA_SCENE_MODE:
+		err = s5k4ecgx_set_parameter(sd, &parms->scene_mode,
+					SCENE_MODE_NONE, "scene_mode",
+					state->regs->scene_mode,
+					ARRAY_SIZE(state->regs->scene_mode));
+		if (err < 0) {
+			dev_err(&client->dev,
+				"%s: failed to set scene-mode default value\n",
+				__func__);
+			break;
+		}
+		if (value != SCENE_MODE_NONE) {
+			err = s5k4ecgx_set_parameter(sd, &parms->scene_mode,
+					value, "scene_mode",
+					state->regs->scene_mode,
+					ARRAY_SIZE(state->regs->scene_mode));
+		}
+		if (parms->scene_mode == SCENE_MODE_NIGHTSHOT) {
+			state->one_frame_delay_ms =
+				NIGHT_MODE_MAX_ONE_FRAME_DELAY_MS;
+		} else {
+			state->one_frame_delay_ms =
+				NORMAL_MODE_MAX_ONE_FRAME_DELAY_MS;
+		}
+
+		break;
+	case V4L2_CID_CAMERA_GPS_LATITUDE:
+		dev_err(&client->dev,
+			"%s: V4L2_CID_CAMERA_GPS_LATITUDE: not implemented\n",
+			__func__);
+		break;
+	case V4L2_CID_CAMERA_GPS_LONGITUDE:
+		dev_err(&client->dev,
+			"%s: V4L2_CID_CAMERA_GPS_LONGITUDE: not implemented\n",
+			__func__);
+		break;
+	case V4L2_CID_CAMERA_GPS_TIMESTAMP:
+		dev_err(&client->dev,
+			"%s: V4L2_CID_CAMERA_GPS_TIMESTAMP: not implemented\n",
+			__func__);
+		break;
+	case V4L2_CID_CAMERA_GPS_ALTITUDE:
+		dev_err(&client->dev,
+			"%s: V4L2_CID_CAMERA_GPS_ALTITUDE: not implemented\n",
+			__func__);
+		break;
+	case V4L2_CID_CAMERA_OBJECT_POSITION_X:
+		state->position.x = value;
+		break;
+	case V4L2_CID_CAMERA_OBJECT_POSITION_Y:
+		state->position.y = value;
+		break;
+	case V4L2_CID_CAMERA_SET_AUTO_FOCUS:
+		if (value == AUTO_FOCUS_ON)
+			err = s5k4ecgx_start_auto_focus(sd);
+		else if (value == AUTO_FOCUS_OFF)
+			err = s5k4ecgx_stop_auto_focus(sd);
+		else {
+			err = -EINVAL;
+			dev_err(&client->dev,
+				"%s: bad focus value requestion %d\n",
+				__func__, value);
+		}
+		break;
+	case V4L2_CID_CAMERA_FRAME_RATE:
+		dev_dbg(&client->dev,
+			"%s: camera frame rate request for %d fps\n",
+			__func__, value);
+		err = s5k4ecgx_set_parameter(sd, &parms->fps,
+					value, "fps",
+					state->regs->fps,
+					ARRAY_SIZE(state->regs->fps));
+		break;
+	case V4L2_CID_CAM_CAPTURE:
+		err = s5k4ecgx_start_capture(sd);
+		break;
+
+	/* Used to start / stop preview operation.
+	 * This call can be modified to START/STOP operation,
+	 * which can be used in image capture also
+	 */
+	case V4L2_CID_CAM_PREVIEW_ONOFF:
+		if (value)
+			err = s5k4ecgx_set_preview_start(sd);
+		else
+			err = s5k4ecgx_set_preview_stop(sd);
+		break;
+	case V4L2_CID_CAMERA_CHECK_DATALINE:
+		dev_dbg(&client->dev, "%s: check_dataline set to %d\n",
+			__func__, value);
+		state->check_dataline = value;
+		break;
+	case V4L2_CID_CAMERA_CHECK_DATALINE_STOP:
+		err = s5k4ecgx_check_dataline_stop(sd);
+		break;
+	default:
+		dev_err(&client->dev, "%s: unknown set ctrl id 0x%x\n",
+			__func__, ctrl->id);
+		err = -ENOIOCTLCMD;
+		break;
+	}
+
+	if (err < 0)
+		dev_err(&client->dev, "%s: videoc_s_ctrl failed %d\n", __func__,
+			err);
+
+	mutex_unlock(&state->ctrl_lock);
+
+	dev_dbg(&client->dev, "%s: videoc_s_ctrl returning %d\n",
+		__func__, err);
+
+	return err;
+}
+
+static int s5k4ecgx_s_ext_ctrl(struct v4l2_subdev *sd,
+			      struct v4l2_ext_control *ctrl)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	int err = 0;
+	struct gps_info_common *tempGPSType = NULL;
+
+	switch (ctrl->id) {
+
+	case V4L2_CID_CAMERA_GPS_LATITUDE:
+		tempGPSType = (struct gps_info_common *)ctrl->reserved2[1];
+		state->gps_info.gps_buf[0] = tempGPSType->direction;
+		state->gps_info.gps_buf[1] = tempGPSType->dgree;
+		state->gps_info.gps_buf[2] = tempGPSType->minute;
+		state->gps_info.gps_buf[3] = tempGPSType->second;
+		break;
+	case V4L2_CID_CAMERA_GPS_LONGITUDE:
+		tempGPSType = (struct gps_info_common *)ctrl->reserved2[1];
+		state->gps_info.gps_buf[4] = tempGPSType->direction;
+		state->gps_info.gps_buf[5] = tempGPSType->dgree;
+		state->gps_info.gps_buf[6] = tempGPSType->minute;
+		state->gps_info.gps_buf[7] = tempGPSType->second;
+		break;
+	case V4L2_CID_CAMERA_GPS_ALTITUDE:
+		tempGPSType = (struct gps_info_common *)ctrl->reserved2[1];
+		state->gps_info.altitude_buf[0] = tempGPSType->direction;
+		state->gps_info.altitude_buf[1] =
+					(tempGPSType->dgree) & 0x00ff;
+		state->gps_info.altitude_buf[2] =
+					((tempGPSType->dgree) & 0xff00) >> 8;
+		state->gps_info.altitude_buf[3] = tempGPSType->minute;
+		break;
+	case V4L2_CID_CAMERA_GPS_TIMESTAMP:
+		state->gps_info.gps_timeStamp = *((int *)ctrl->reserved2[1]);
+		err = 0;
+		break;
+	default:
+		dev_err(&client->dev, "%s: unknown ctrl->id %d\n",
+			__func__, ctrl->id);
+		err = -ENOIOCTLCMD;
+		break;
+	}
+
+	if (err < 0)
+		dev_err(&client->dev, "%s: vidioc_s_ext_ctrl failed %d\n",
+			__func__, err);
+
+	return err;
+}
+
+static int s5k4ecgx_s_ext_ctrls(struct v4l2_subdev *sd,
+				struct v4l2_ext_controls *ctrls)
+{
+	struct v4l2_ext_control *ctrl = ctrls->controls;
+	int ret;
+	int i;
+
+	for (i = 0; i < ctrls->count; i++, ctrl++) {
+		ret = s5k4ecgx_s_ext_ctrl(sd, ctrl);
+
+		if (ret) {
+			ctrls->error_idx = i;
+			break;
+		}
+	}
+
+	return ret;
+}
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_DEBUG
+static void s5k4ecgx_dump_regset(struct s5k4ecgx_regset *regset)
+{
+	if ((regset->data[0] == 0x00) && (regset->data[1] == 0x2A)) {
+		if (regset->size <= 6)
+			pr_err("odd regset size %d\n", regset->size);
+		pr_info("regset: addr = 0x%02X%02X, data[0,1] = 0x%02X%02X,"
+			" total data size = %d\n",
+			regset->data[2], regset->data[3],
+			regset->data[6], regset->data[7],
+			regset->size-6);
+	} else {
+		pr_info("regset: 0x%02X%02X%02X%02X\n",
+			regset->data[0], regset->data[1],
+			regset->data[2], regset->data[3]);
+		if (regset->size != 4)
+			pr_err("odd regset size %d\n", regset->size);
+	}
+}
+#endif
+
+static int s5k4ecgx_i2c_write_block(struct v4l2_subdev *sd, u8 *buf, int size)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	int retry_count = 5;
+	int ret;
+	struct i2c_msg msg = {client->addr, 0, size, buf};
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_DEBUG
+	if (s5k4ecgx_debug_mask & S5K4ECGX_DEBUG_I2C_BURSTS) {
+		if ((buf[0] == 0x0F) && (buf[1] == 0x12))
+			pr_info("%s : data[0,1] = 0x%02X%02X,"
+				" total data size = %d\n",
+				__func__, buf[2], buf[3], size-2);
+		else
+			pr_info("%s : 0x%02X%02X%02X%02X\n",
+				__func__, buf[0], buf[1], buf[2], buf[3]);
+	}
+#endif
+
+	do {
+		ret = i2c_transfer(client->adapter, &msg, 1);
+		if (likely(ret == 1))
+			break;
+		msleep(POLL_TIME_MS);
+	} while (retry_count-- > 0);
+	if (ret != 1) {
+		dev_err(&client->dev, "%s: I2C is not working.\n", __func__);
+		return -EIO;
+	}
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_V_1_0
+	{
+		struct s5k4ecgx_state *state =
+			container_of(sd, struct s5k4ecgx_state, sd);
+		if (state->fw.minor == 0) {
+			/* v1.0 sensor have problems sometimes if we write
+			 * too much data too fast, so add a sleep.  I've
+			 * tried various combinations of size/delay.  Checking
+			 * for a larger size doesn't seem to work reliably, and
+			 * a delay of 1ms sometimes isn't enough either.
+			 */
+			if (size > 16)
+				msleep(2);
+		}
+	}
+#endif
+	return 0;
+}
+
+/*
+ * Parse the init_reg2 array into a number of register sets that
+ * we can send over as i2c burst writes instead of writing each
+ * entry of init_reg2 as a single 4 byte write.  Write the
+ * new data structures and then free them.
+ */
+static int s5k4ecgx_write_init_reg2_burst(struct v4l2_subdev *sd)
+{
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct s5k4ecgx_regset *regset_table;
+	struct s5k4ecgx_regset *regset;
+	struct s5k4ecgx_regset *end_regset;
+	u8 *regset_data;
+	u8 *dst_ptr;
+	const u32 *end_src_ptr;
+	bool flag_copied;
+	int init_reg_2_array_size = state->regs->init_reg_2.array_size;
+	int init_reg_2_size = init_reg_2_array_size * sizeof(u32);
+	const u32 *src_ptr = state->regs->init_reg_2.reg;
+	u32 src_value;
+	int err;
+
+	pr_debug("%s : start\n", __func__);
+
+	regset_data = vmalloc(init_reg_2_size);
+	if (regset_data == NULL)
+		return -ENOMEM;
+	regset_table = vmalloc(sizeof(struct s5k4ecgx_regset) *
+			init_reg_2_size);
+	if (regset_table == NULL) {
+		kfree(regset_data);
+		return -ENOMEM;
+	}
+
+	dst_ptr = regset_data;
+	regset = regset_table;
+	end_src_ptr = &state->regs->init_reg_2.reg[init_reg_2_array_size];
+
+	src_value = *src_ptr++;
+	while (src_ptr <= end_src_ptr) {
+		/* initial value for a regset */
+		regset->data = dst_ptr;
+		flag_copied = false;
+		*dst_ptr++ = src_value >> 24;
+		*dst_ptr++ = src_value >> 16;
+		*dst_ptr++ = src_value >> 8;
+		*dst_ptr++ = src_value;
+
+		/* check subsequent values for a data flag (starts with
+		   0x0F12) or something else */
+		do {
+			src_value = *src_ptr++;
+			if ((src_value & 0xFFFF0000) != 0x0F120000) {
+				/* src_value is start of next regset */
+				regset->size = dst_ptr - regset->data;
+				regset++;
+				break;
+			}
+			/* copy the 0x0F12 flag if not done already */
+			if (!flag_copied) {
+				*dst_ptr++ = src_value >> 24;
+				*dst_ptr++ = src_value >> 16;
+				flag_copied = true;
+			}
+			/* copy the data part */
+			*dst_ptr++ = src_value >> 8;
+			*dst_ptr++ = src_value;
+		} while (src_ptr < end_src_ptr);
+	}
+	pr_debug("%s : finished creating table\n", __func__);
+
+	end_regset = regset;
+	pr_debug("%s : first regset = %p, last regset = %p, count = %d\n",
+		__func__, regset_table, regset, end_regset - regset_table);
+	pr_debug("%s : regset_data = %p, end = %p, dst_ptr = %p\n", __func__,
+		regset_data, regset_data + (init_reg_2_size * sizeof(u32)),
+		dst_ptr);
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_DEBUG
+	if (s5k4ecgx_debug_mask & S5K4ECGX_DEBUG_I2C_BURSTS) {
+		int last_regset_end_addr = 0;
+		regset = regset_table;
+		do {
+			s5k4ecgx_dump_regset(regset);
+			if (regset->size > 4) {
+				int regset_addr = (regset->data[2] << 8 |
+						regset->data[3]);
+				if (last_regset_end_addr == regset_addr)
+					pr_info("%s : this regset can be"
+						" combined with previous\n",
+						__func__);
+				last_regset_end_addr = (regset_addr +
+							regset->size - 6);
+			}
+			regset++;
+		} while (regset < end_regset);
+	}
+#endif
+	regset = regset_table;
+	pr_debug("%s : start writing init reg 2 bursts\n", __func__);
+	do {
+		if (regset->size > 4) {
+			/* write the address packet */
+			err = s5k4ecgx_i2c_write_block(sd, regset->data, 4);
+			if (err)
+				break;
+			/* write the data in a burst */
+			err = s5k4ecgx_i2c_write_block(sd, regset->data+4,
+						regset->size-4);
+
+		} else
+			err = s5k4ecgx_i2c_write_block(sd, regset->data,
+						regset->size);
+		if (err)
+			break;
+		regset++;
+	} while (regset < end_regset);
+
+	pr_debug("%s : finished writing init reg 2 bursts\n", __func__);
+
+	vfree(regset_data);
+	vfree(regset_table);
+
+	return err;
+}
+
+static int s5k4ecgx_init_regs(struct v4l2_subdev *sd)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	u16 read_value;
+
+	/* we'd prefer to do this in probe, but the framework hasn't
+	 * turned on the camera yet so our i2c operations would fail
+	 * if we tried to do it in probe, so we have to do it here
+	 * and keep track if we succeeded or not.
+	 */
+
+	/* enter read mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x002C, 0x7000);
+
+	s5k4ecgx_i2c_write_twobyte(client, 0x002E, 0x01A6);
+	s5k4ecgx_i2c_read_twobyte(client, 0x0F12, &read_value);
+
+	pr_info("%s : revision %08X\n", __func__, read_value);
+
+	/* restore write mode */
+	s5k4ecgx_i2c_write_twobyte(client, 0x0028, 0x7000);
+
+#ifdef CONFIG_VIDEO_S5K4ECGX_V_1_0
+	if (read_value == S5K4ECGX_VERSION_1_0) {
+		state->regs = &regs_for_fw_version_1_0;
+		state->initialized = true;
+		return 0;
+	}
+#endif
+#ifdef CONFIG_VIDEO_S5K4ECGX_V_1_1
+	if (read_value == S5K4ECGX_VERSION_1_1) {
+		state->fw.minor = 1;
+		state->regs = &regs_for_fw_version_1_1;
+		state->initialized = true;
+		return 0;
+	}
+#endif
+
+	dev_err(&client->dev, "%s: unknown fw version 0x%x\n",
+		__func__, read_value);
+	return -ENODEV;
+}
+
+static int s5k4ecgx_init(struct v4l2_subdev *sd, u32 val)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	dev_dbg(&client->dev, "%s: start\n", __func__);
+
+	s5k4ecgx_init_parameters(sd);
+
+	if (s5k4ecgx_init_regs(&state->sd) < 0)
+		return -ENODEV;
+
+	dev_dbg(&client->dev, "%s: state->check_dataline : %d\n",
+		__func__, state->check_dataline);
+
+	if (s5k4ecgx_set_from_table(sd, "init reg 1",
+					&state->regs->init_reg_1, 1, 0) < 0)
+		return -EIO;
+
+	/* delay 10ms after wakeup of SOC processor */
+	msleep(10);
+
+	if (s5k4ecgx_write_init_reg2_burst(sd) < 0)
+		return -EIO;
+
+	if (s5k4ecgx_set_from_table(sd, "flash init",
+				&state->regs->flash_init, 1, 0) < 0)
+		return -EIO;
+
+	if (state->check_dataline) {
+		if (s5k4ecgx_set_from_table(sd, "dtp start",
+					&state->regs->dtp_start, 1, 0) < 0)
+			return -EIO;
+	}
+
+	dev_dbg(&client->dev, "%s: end\n", __func__);
+
+	return 0;
+}
+
+/*
+ * s_config subdev ops
+ * With camera device, we need to re-initialize
+ * every single opening time therefor,
+ * it is not necessary to be initialized on probe time.
+ * except for version checking
+ * NOTE: version checking is optional
+ */
+static int s5k4ecgx_s_config(struct v4l2_subdev *sd,
+			int irq, void *platform_data)
+{
+	struct i2c_client *client = v4l2_get_subdevdata(sd);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+	struct s5k4ecgx_platform_data *pdata = client->dev.platform_data;
+
+	/*
+	 * Assign default format and resolution
+	 * Use configured default information in platform data
+	 * or without them, use default information in driver
+	 */
+	state->pix.width = pdata->default_width;
+	state->pix.height = pdata->default_height;
+
+	if (!pdata->pixelformat)
+		state->pix.pixelformat = DEFAULT_PIX_FMT;
+	else
+		state->pix.pixelformat = pdata->pixelformat;
+
+	if (!pdata->freq)
+		state->freq = DEFAULT_MCLK;	/* 24MHz default */
+	else
+		state->freq = pdata->freq;
+
+	return 0;
+}
+
+static const struct v4l2_subdev_core_ops s5k4ecgx_core_ops = {
+	.init = s5k4ecgx_init,	/* initializing API */
+	.s_config = s5k4ecgx_s_config,	/* Fetch platform data */
+	.g_ctrl = s5k4ecgx_g_ctrl,
+	.s_ctrl = s5k4ecgx_s_ctrl,
+	.s_ext_ctrls = s5k4ecgx_s_ext_ctrls,
+};
+
+static const struct v4l2_subdev_video_ops s5k4ecgx_video_ops = {
+	.s_fmt = s5k4ecgx_s_fmt,
+	.enum_framesizes = s5k4ecgx_enum_framesizes,
+	.enum_fmt = s5k4ecgx_enum_fmt,
+	.try_fmt = s5k4ecgx_try_fmt,
+	.g_parm = s5k4ecgx_g_parm,
+	.s_parm = s5k4ecgx_s_parm,
+};
+
+static const struct v4l2_subdev_ops s5k4ecgx_ops = {
+	.core = &s5k4ecgx_core_ops,
+	.video = &s5k4ecgx_video_ops,
+};
+
+
+/*
+ * s5k4ecgx_probe
+ * Fetching platform data is being done with s_config subdev call.
+ * In probe routine, we just register subdev device
+ */
+static int s5k4ecgx_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	struct v4l2_subdev *sd;
+	struct s5k4ecgx_state *state;
+	struct s5k4ecgx_platform_data *pdata = client->dev.platform_data;
+
+	if ((pdata == NULL) || (pdata->flash_onoff == NULL)) {
+		dev_err(&client->dev, "%s: bad platform data\n", __func__);
+		return -ENODEV;
+	}
+
+	state = kzalloc(sizeof(struct s5k4ecgx_state), GFP_KERNEL);
+	if (state == NULL)
+		return -ENOMEM;
+
+	mutex_init(&state->ctrl_lock);
+	init_completion(&state->af_complete);
+
+	state->runmode = S5K4ECGX_RUNMODE_NOTREADY;
+	sd = &state->sd;
+	strcpy(sd->name, S5K4ECGX_DRIVER_NAME);
+
+	/* Registering subdev */
+	v4l2_i2c_subdev_init(sd, client, &s5k4ecgx_ops);
+
+	dev_dbg(&client->dev, "5MP camera S5K4ECGX loaded.\n");
+
+	return 0;
+}
+
+static int s5k4ecgx_remove(struct i2c_client *client)
+{
+	struct v4l2_subdev *sd = i2c_get_clientdata(client);
+	struct s5k4ecgx_state *state =
+		container_of(sd, struct s5k4ecgx_state, sd);
+
+	v4l2_device_unregister_subdev(sd);
+	mutex_destroy(&state->ctrl_lock);
+	kfree(state);
+
+	dev_dbg(&client->dev, "Unloaded camera sensor S5K4ECGX.\n");
+
+	return 0;
+}
+
+static const struct i2c_device_id s5k4ecgx_id[] = {
+	{ S5K4ECGX_DRIVER_NAME, 0 },
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, s5k4ecgx_id);
+
+static struct v4l2_i2c_driver_data v4l2_i2c_data = {
+	.name = S5K4ECGX_DRIVER_NAME,
+	.probe = s5k4ecgx_probe,
+	.remove = s5k4ecgx_remove,
+	.id_table = s5k4ecgx_id,
+};
+
+MODULE_DESCRIPTION("LSI S5K4ECGX 5MP SOC camera driver");
+MODULE_AUTHOR("Seok-Young Jang <quartz.jang@samsung.com>");
+MODULE_LICENSE("GPL");
+
+
+
diff --git a/drivers/media/video/s5k4ecgx_regs_1_0.h b/drivers/media/video/s5k4ecgx_regs_1_0.h
new file mode 100644
index 0000000..9e81727
--- /dev/null
+++ b/drivers/media/video/s5k4ecgx_regs_1_0.h
@@ -0,0 +1,4803 @@
+/* drivers/media/video/s5k4ecgx_regs_1_0.h
+ *
+ * Driver for s5k4ecgx (5MP Camera) from SEC(LSI), firmware EVT1.0
+ *
+ * Copyright (C) 2010, SAMSUNG ELECTRONICS
+ *
+ * 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.
+ */
+
+
+#ifndef __S5K4ECGX_REGS_1_0_H__
+#define __S5K4ECGX_REGS_1_0_H__
+
+/* ARM initialization */
+static const u32 s5k4ecgx_init_reg1_v1[] = {
+	/* direct addressing, hw addresses */
+	0xFCFCD000,
+	0x00040000,
+	0xFCFCD000,
+	0x00100001,
+	0xFCFCD000,
+	0x10300000,
+	0x00140001,
+};
+
+static const u32 s5k4ecgx_init_reg2_v1[] = {
+	/* start analog settings, indirect addressing mode */
+	0x0028D000,
+
+	0x002A007A,
+	0x0F120000,
+
+	0x002AE406,
+	0x0F120092,
+
+	0x002AE410,
+	0x0F123804,
+
+	0x002AE420,
+	0x0F120003,
+	0x0F120060,
+
+	0x002AE42E,
+	0x0F120004,
+
+	0x002AF400,
+	0x0F125A3C,
+	0x0F120023,
+	0x0F128080,
+	0x0F1203AF,
+	0x0F12000A,
+	0x0F12AA54,
+	0x0F120040,
+	0x0F12464E,
+	0x0F120240,
+	0x0F120240,
+	0x0F120040,
+	0x0F121000,
+	0x0F125558,
+	0x0F12D000,
+	0x0F120010,
+	0x0F120202,
+	0x0F120401,
+	0x0F120022,
+	0x0F120088,
+	0x0F12009F,
+	0x0F120000,
+	0x0F121800,
+	0x0F120088,
+	0x0F120000,
+	0x0F122428,
+	0x0F120000,
+	0x0F1203EE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	0x002AF480,
+	0x0F120004,
+	0x0F1205B6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F120007,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F12024E,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F1205B6,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F12024F,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120075,
+	0x0F1200CF,
+	0x0F120000,
+	0x0F120000,
+	0x0F120075,
+	0x0F1200D6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120004,
+	0x0F1201F4,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200F0,
+	0x0F1201F4,
+	0x0F12029E,
+	0x0F1205B2,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F8,
+	0x0F120228,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120208,
+	0x0F120238,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	0x002AF590,
+	0x0F120000,
+
+	0x002AF500,
+	0x0F120218,
+	0x0F120238,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F120009,
+	0x0F1200DE,
+	0x0F1205C0,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200DF,
+	0x0F1200E4,
+	0x0F1201F8,
+	0x0F1201FD,
+	0x0F1205B6,
+	0x0F1205BB,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F8,
+	0x0F120000,
+	0x0F120000,
+	0x0F120077,
+	0x0F12007E,
+	0x0F12024F,
+	0x0F12025E,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120708,
+	0x0F12080C,
+
+	0x002A1082,
+	0x0F125555,
+	0x0F125555,
+
+	0x002A1088,
+	0x0F12055D,
+
+	0x002A100E,
+	0x0F120000,
+
+	/* switch to sw address bank */
+	0x00287000,
+
+	0x002A0716,
+	0x0F120100,
+
+	/* Start of Patch Data for firmware */
+	0x002A3A10,
+	0x0F12B5F8,
+	0x0F124A3E,
+	0x0F12493E,
+	0x0F12483F,
+	0x0F12C004,
+	0x0F126001,
+	0x0F124C3E,
+	0x0F122500,
+	0x0F128265,
+	0x0F128025,
+	0x0F12493D,
+	0x0F12483E,
+	0x0F122701,
+	0x0F12002A,
+	0x0F12F000,
+	0x0F12FC38,
+	0x0F12493C,
+	0x0F12483D,
+	0x0F122602,
+	0x0F12003A,
+	0x0F12F000,
+	0x0F12FC32,
+	0x0F12493B,
+	0x0F12483C,
+	0x0F120032,
+	0x0F122703,
+	0x0F12F000,
+	0x0F12FC2C,
+	0x0F128225,
+	0x0F12493A,
+	0x0F12483A,
+	0x0F122604,
+	0x0F12003A,
+	0x0F12F000,
+	0x0F12FC25,
+	0x0F12200E,
+	0x0F128420,
+	0x0F122701,
+	0x0F1283E7,
+	0x0F124937,
+	0x0F124837,
+	0x0F120032,
+	0x0F122405,
+	0x0F12F000,
+	0x0F12FC1B,
+	0x0F124936,
+	0x0F124836,
+	0x0F122606,
+	0x0F120022,
+	0x0F12F000,
+	0x0F12FC15,
+	0x0F124C28,
+	0x0F123460,
+	0x0F1281E7,
+	0x0F124825,
+	0x0F123824,
+	0x0F1286C5,
+	0x0F124932,
+	0x0F124832,
+	0x0F120032,
+	0x0F122707,
+	0x0F12F000,
+	0x0F12FC09,
+	0x0F124931,
+	0x0F124831,
+	0x0F122608,
+	0x0F12003A,
+	0x0F12F000,
+	0x0F12FC03,
+	0x0F124930,
+	0x0F124830,
+	0x0F120032,
+	0x0F122709,
+	0x0F12F000,
+	0x0F12FBFD,
+	0x0F122005,
+	0x0F128160,
+	0x0F12492E,
+	0x0F12482E,
+	0x0F126281,
+	0x0F128225,
+	0x0F128265,
+	0x0F12482D,
+	0x0F128320,
+	0x0F12482D,
+	0x0F128360,
+	0x0F120270,
+	0x0F1283A0,
+	0x0F122005,
+	0x0F120300,
+	0x0F1283E0,
+	0x0F124828,
+	0x0F12492A,
+	0x0F123840,
+	0x0F126001,
+	0x0F12492A,
+	0x0F12482A,
+	0x0F12240A,
+	0x0F12003A,
+	0x0F12F000,
+	0x0F12FBE3,
+	0x0F124929,
+	0x0F124829,
+	0x0F120022,
+	0x0F12250B,
+	0x0F12F000,
+	0x0F12FBDD,
+	0x0F124820,
+	0x0F124927,
+	0x0F123080,
+	0x0F126381,
+	0x0F124927,
+	0x0F124827,
+	0x0F12240C,
+	0x0F12002A,
+	0x0F12F000,
+	0x0F12FBD3,
+	0x0F124926,
+	0x0F124826,
+	0x0F120022,
+	0x0F12F000,
+	0x0F12FBCE,
+	0x0F12BCF8,
+	0x0F12BC08,
+	0x0F124718,
+	0x0F120000,
+	0x0F120174,
+	0x0F124EC1,
+	0x0F12FFFE,
+	0x0F120000,
+	0x0F121EF0,
+	0x0F127000,
+	0x0F124780,
+	0x0F127000,
+	0x0F123BF3,
+	0x0F127000,
+	0x0F12A1D9,
+	0x0F120000,
+	0x0F123B9D,
+	0x0F127000,
+	0x0F12A0BD,
+	0x0F120000,
+	0x0F123C8D,
+	0x0F127000,
+	0x0F12217B,
+	0x0F120000,
+	0x0F123CE9,
+	0x0F127000,
+	0x0F12E0DF,
+	0x0F120000,
+	0x0F123E73,
+	0x0F127000,
+	0x0F12053B,
+	0x0F120000,
+	0x0F123D71,
+	0x0F127000,
+	0x0F12509B,
+	0x0F120000,
+	0x0F123FF9,
+	0x0F127000,
+	0x0F12D42F,
+	0x0F120000,
+	0x0F123EB5,
+	0x0F127000,
+	0x0F1249D1,
+	0x0F120000,
+	0x0F123F4F,
+	0x0F127000,
+	0x0F121E57,
+	0x0F120000,
+	0x0F124033,
+	0x0F127000,
+	0x0F1200C0,
+	0x0F127000,
+	0x0F124E34,
+	0x0F120000,
+	0x0F127C53,
+	0x0F120000,
+	0x0F1240BF,
+	0x0F127000,
+	0x0F1240FB,
+	0x0F127000,
+	0x0F12F5D7,
+	0x0F120000,
+	0x0F12406F,
+	0x0F127000,
+	0x0F12BAB1,
+	0x0F120000,
+	0x0F124187,
+	0x0F127000,
+	0x0F124129,
+	0x0F127000,
+	0x0F12C10D,
+	0x0F120000,
+	0x0F124203,
+	0x0F127000,
+	0x0F12B231,
+	0x0F120000,
+	0x0F12B570,
+	0x0F12000C,
+	0x0F126820,
+	0x0F126865,
+	0x0F12F000,
+	0x0F12FB84,
+	0x0F124BFC,
+	0x0F120402,
+	0x0F120C12,
+	0x0F12819A,
+	0x0F1248FB,
+	0x0F1289C1,
+	0x0F12428A,
+	0x0F12D305,
+	0x0F124AFA,
+	0x0F128986,
+	0x0F128852,
+	0x0F1242B2,
+	0x0F12D300,
+	0x0F128199,
+	0x0F128801,
+	0x0F122900,
+	0x0F12D008,
+	0x0F1249F7,
+	0x0F12002B,
+	0x0F126E0A,
+	0x0F122105,
+	0x0F121C80,
+	0x0F12F000,
+	0x0F12FB74,
+	0x0F126020,
+	0x0F12E006,
+	0x0F12899A,
+	0x0F1248F3,
+	0x0F12002B,
+	0x0F122105,
+	0x0F12F000,
+	0x0F12FB6C,
+	0x0F126020,
+	0x0F126820,
+	0x0F12BC70,
+	0x0F12BC08,
+	0x0F124718,
+	0x0F12B5F8,
+	0x0F120004,
+	0x0F122000,
+	0x0F129000,
+	0x0F120020,
+	0x0F122501,
+	0x0F123810,
+	0x0F122601,
+	0x0F1240A5,
+	0x0F124086,
+	0x0F124FEA,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F1243A8,
+	0x0F128038,
+	0x0F12E002,
+	0x0F128878,
+	0x0F1243B0,
+	0x0F128078,
+	0x0F12F000,
+	0x0F12FB59,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F124328,
+	0x0F128038,
+	0x0F12E002,
+	0x0F128878,
+	0x0F124330,
+	0x0F128078,
+	0x0F1248DA,
+	0x0F122105,
+	0x0F128982,
+	0x0F1248DD,
+	0x0F12466B,
+	0x0F12F000,
+	0x0F12FB41,
+	0x0F121C41,
+	0x0F124CD7,
+	0x0F120049,
+	0x0F120040,
+	0x0F121909,
+	0x0F121900,
+	0x0F12466B,
+	0x0F128A89,
+	0x0F128A80,
+	0x0F12881A,
+	0x0F12F000,
+	0x0F12FB45,
+	0x0F128A61,
+	0x0F120540,
+	0x0F1202C9,
+	0x0F120D40,
+	0x0F124301,
+	0x0F1248D4,
+	0x0F128081,
+	0x0F1249D4,
+	0x0F1248D4,
+	0x0F123120,
+	0x0F128BC0,
+	0x0F128809,
+	0x0F121841,
+	0x0F120020,
+	0x0F123060,
+	0x0F128A82,
+	0x0F124291,
+	0x0F12D205,
+	0x0F128AC0,
+	0x0F1249CF,
+	0x0F127388,
+	0x0F122001,
+	0x0F1231A0,
+	0x0F1270C8,
+	0x0F12BCF8,
+	0x0F12BC08,
+	0x0F124718,
+	0x0F12B5F8,
+	0x0F1248C6,
+	0x0F122200,
+	0x0F1230A0,
+	0x0F1281C2,
+	0x0F126808,
+	0x0F124669,
+	0x0F12F000,
+	0x0F12FB29,
+	0x0F12466B,
+	0x0F128818,
+	0x0F12F000,
+	0x0F12FB2D,
+	0x0F120005,
+	0x0F12466B,
+	0x0F128858,
+	0x0F12F000,
+	0x0F12FB30,
+	0x0F120004,
+	0x0F122101,
+	0x0F121928,
+	0x0F1202C9,
+	0x0F121A08,
+	0x0F120286,
+	0x0F120029,
+	0x0F120030,
+	0x0F12F000,
+	0x0F12FB2E,
+	0x0F120005,
+	0x0F122701,
+	0x0F1202BF,
+	0x0F120021,
+	0x0F120030,
+	0x0F12F000,
+	0x0F12FB27,
+	0x0F1249B5,
+	0x0F124AB8,
+	0x0F123140,
+	0x0F123220,
+	0x0F12808D,
+	0x0F128295,
+	0x0F1280CF,
+	0x0F1282D7,
+	0x0F128108,
+	0x0F128310,
+	0x0F12E7CE,
+	0x0F126808,
+	0x0F120400,
+	0x0F120C00,
+	0x0F126849,
+	0x0F120409,
+	0x0F120C09,
+	0x0F124AAA,
+	0x0F128A12,
+	0x0F122A00,
+	0x0F12D00D,
+	0x0F122300,
+	0x0F121A89,
+	0x0F12D400,
+	0x0F12000B,
+	0x0F120419,
+	0x0F120C09,
+	0x0F1223FF,
+	0x0F1233C1,
+	0x0F121810,
+	0x0F124298,
+	0x0F12D800,
+	0x0F120003,
+	0x0F120418,
+	0x0F120C00,
+	0x0F124AA9,
+	0x0F128150,
+	0x0F128191,
+	0x0F124770,
+	0x0F12B5F8,
+	0x0F122400,
+	0x0F124DA7,
+	0x0F124F9E,
+	0x0F1248A7,
+	0x0F128C39,
+	0x0F128041,
+	0x0F122101,
+	0x0F128001,
+	0x0F12F000,
+	0x0F12FAFB,
+	0x0F1248A5,
+	0x0F128BC0,
+	0x0F12F000,
+	0x0F12FAFF,
+	0x0F12260D,
+	0x0F120736,
+	0x0F122000,
+	0x0F1200E1,
+	0x0F1219CA,
+	0x0F120041,
+	0x0F12194B,
+	0x0F12199B,
+	0x0F12881B,
+	0x0F121851,
+	0x0F12844B,
+	0x0F121C40,
+	0x0F120400,
+	0x0F120C00,
+	0x0F122804,
+	0x0F12D3F4,
+	0x0F123508,
+	0x0F12042D,
+	0x0F120C2D,
+	0x0F121C64,
+	0x0F120424,
+	0x0F120C24,
+	0x0F122C07,
+	0x0F12D3E9,
+	0x0F12E78A,
+	0x0F12B5F0,
+	0x0F12B087,
+	0x0F126808,
+	0x0F129006,
+	0x0F126848,
+	0x0F120405,
+	0x0F120C2D,
+	0x0F126888,
+	0x0F120403,
+	0x0F120C1B,
+	0x0F124892,
+	0x0F128B80,
+	0x0F122800,
+	0x0F12D100,
+	0x0F122300,
+	0x0F12001C,
+	0x0F124A90,
+	0x0F12466E,
+	0x0F121E91,
+	0x0F121E88,
+	0x0F12C607,
+	0x0F12498F,
+	0x0F120023,
+	0x0F122207,
+	0x0F120028,
+	0x0F12F000,
+	0x0F12FAD3,
+	0x0F12487E,
+	0x0F128BC1,
+	0x0F122900,
+	0x0F12D030,
+	0x0F122100,
+	0x0F124888,
+	0x0F124A7B,
+	0x0F12380A,
+	0x0F1288C0,
+	0x0F1200C3,
+	0x0F12189A,
+	0x0F124696,
+	0x0F124A86,
+	0x0F121C40,
+	0x0F12189B,
+	0x0F12469C,
+	0x0F124B76,
+	0x0F1200C0,
+	0x0F1218C6,
+	0x0F121887,
+	0x0F120048,
+	0x0F124672,
+	0x0F124663,
+	0x0F121812,
+	0x0F12181B,
+	0x0F128C52,
+	0x0F128EDB,
+	0x0F12435A,
+	0x0F120092,
+	0x0F120C15,
+	0x0F124A6F,
+	0x0F121882,
+	0x0F12235A,
+	0x0F12529D,
+	0x0F121833,
+	0x0F121838,
+	0x0F128C5B,
+	0x0F128EC0,
+	0x0F124343,
+	0x0F120098,
+	0x0F120C00,
+	0x0F123260,
+	0x0F128050,
+	0x0F121C49,
+	0x0F120409,
+	0x0F120C09,
+	0x0F122904,
+	0x0F12D3E3,
+	0x0F124A66,
+	0x0F12325A,
+	0x0F120013,
+	0x0F123308,
+	0x0F12E00A,
+	0x0F124870,
+	0x0F124971,
+	0x0F12380A,
+	0x0F1288C0,
+	0x0F1200C2,
+	0x0F121852,
+	0x0F123236,
+	0x0F121C40,
+	0x0F1200C0,
+	0x0F121843,
+	0x0F123336,
+	0x0F122100,
+	0x0F124864,
+	0x0F123020,
+	0x0F124684,
+	0x0F124E69,
+	0x0F120048,
+	0x0F123E0A,
+	0x0F128937,
+	0x0F125A15,
+	0x0F128976,
+	0x0F12437D,
+	0x0F125A1F,
+	0x0F124377,
+	0x0F124E65,
+	0x0F1219ED,
+	0x0F121986,
+	0x0F123660,
+	0x0F1289F6,
+	0x0F124366,
+	0x0F1219AD,
+	0x0F12022D,
+	0x0F120C2D,
+	0x0F12AE04,
+	0x0F125235,
+	0x0F124666,
+	0x0F127C76,
+	0x0F124375,
+	0x0F129E06,
+	0x0F12026D,
+	0x0F120C2D,
+	0x0F125235,
+	0x0F121C49,
+	0x0F122904,
+	0x0F12D3E1,
+	0x0F12B007,
+	0x0F12BCF0,
+	0x0F12BC08,
+	0x0F124718,
+	0x0F12B5F8,
+	0x0F120004,
+	0x0F12F7FF,
+	0x0F12FF53,
+	0x0F122101,
+	0x0F12000D,
+	0x0F120020,
+	0x0F123810,
+	0x0F124081,
+	0x0F1240A5,
+	0x0F124F4A,
+	0x0F12000E,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F1243A8,
+	0x0F128038,
+	0x0F12E002,
+	0x0F128878,
+	0x0F1243B0,
+	0x0F128078,
+	0x0F12F000,
+	0x0F12FA5E,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F124328,
+	0x0F128038,
+	0x0F12E6EC,
+	0x0F128878,
+	0x0F124330,
+	0x0F128078,
+	0x0F12E6E8,
+	0x0F12B5F8,
+	0x0F120004,
+	0x0F124F48,
+	0x0F124949,
+	0x0F1278FA,
+	0x0F122001,
+	0x0F122A00,
+	0x0F12D102,
+	0x0F122000,
+	0x0F1286C8,
+	0x0F12E003,
+	0x0F127AFA,
+	0x0F122A00,
+	0x0F12D000,
+	0x0F1286C8,
+	0x0F122101,
+	0x0F12000D,
+	0x0F120020,
+	0x0F123810,
+	0x0F124081,
+	0x0F1240A5,
+	0x0F12000E,
+	0x0F122C10,
+	0x0F12DA04,
+	0x0F124932,
+	0x0F128808,
+	0x0F1243A8,
+	0x0F128008,
+	0x0F12E003,
+	0x0F124930,
+	0x0F128848,
+	0x0F1243B0,
+	0x0F128048,
+	0x0F12F000,
+	0x0F12FA39,
+	0x0F122C10,
+	0x0F12DA04,
+	0x0F12482C,
+	0x0F128801,
+	0x0F124329,
+	0x0F128001,
+	0x0F12E003,
+	0x0F124829,
+	0x0F128841,
+	0x0F124331,
+	0x0F128041,
+	0x0F124934,
+	0x0F128B08,
+	0x0F1206C2,
+	0x0F12D50A,
+	0x0F127ABA,
+	0x0F120652,
+	0x0F12D507,
+	0x0F122210,
+	0x0F124390,
+	0x0F128308,
+	0x0F124830,
+	0x0F127AF9,
+	0x0F126B00,
+	0x0F12F000,
+	0x0F12FA27,
+	0x0F12481C,
+	0x0F123060,
+	0x0F1289C0,
+	0x0F122800,
+	0x0F12D009,
+	0x0F1278F8,
+	0x0F122800,
+	0x0F12D006,
+	0x0F127AF8,
+	0x0F122800,
+	0x0F12D003,
+	0x0F127AB8,
+	0x0F122140,
+	0x0F124308,
+	0x0F1272B8,
+	0x0F12E69B,
+	0x0F12B5F8,
+	0x0F120004,
+	0x0F124826,
+	0x0F128981,
+	0x0F122900,
+	0x0F12D007,
+	0x0F128940,
+	0x0F122800,
+	0x0F12D104,
+	0x0F12481E,
+	0x0F1222BF,
+	0x0F127A81,
+	0x0F124011,
+	0x0F127281,
+	0x0F122101,
+	0x0F12000D,
+	0x0F120020,
+	0x0F123810,
+	0x0F124081,
+	0x0F1240A5,
+	0x0F124F0E,
+	0x0F12000E,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F1243A8,
+	0x0F128038,
+	0x0F12E002,
+	0x0F128878,
+	0x0F1243B0,
+	0x0F128078,
+	0x0F12F000,
+	0x0F12F9FE,
+	0x0F122C10,
+	0x0F12DA2D,
+	0x0F128838,
+	0x0F124328,
+	0x0F128038,
+	0x0F12E674,
+	0x0F1221C0,
+	0x0F127000,
+	0x0F124780,
+	0x0F127000,
+	0x0F122D00,
+	0x0F127000,
+	0x0F122AD0,
+	0x0F127000,
+	0x0F120924,
+	0x0F127000,
+	0x0F121100,
+	0x0F12D000,
+	0x0F12E300,
+	0x0F12D000,
+	0x0F1229D0,
+	0x0F127000,
+	0x0F122C30,
+	0x0F127000,
+	0x0F125000,
+	0x0F12D000,
+	0x0F12A006,
+	0x0F120000,
+	0x0F12A000,
+	0x0F12D000,
+	0x0F1206F8,
+	0x0F127000,
+	0x0F120888,
+	0x0F127000,
+	0x0F1221DA,
+	0x0F127000,
+	0x0F1208AC,
+	0x0F127000,
+	0x0F1220BC,
+	0x0F127000,
+	0x0F121ECC,
+	0x0F127000,
+	0x0F122FA4,
+	0x0F127000,
+	0x0F12235C,
+	0x0F127000,
+	0x0F120234,
+	0x0F127000,
+	0x0F128878,
+	0x0F124330,
+	0x0F128078,
+	0x0F12E646,
+	0x0F12B570,
+	0x0F124D99,
+	0x0F124C99,
+	0x0F128B28,
+	0x0F120701,
+	0x0F12D507,
+	0x0F122108,
+	0x0F124388,
+	0x0F128328,
+	0x0F124997,
+	0x0F126B20,
+	0x0F1268C9,
+	0x0F12F000,
+	0x0F12F9C4,
+	0x0F128B28,
+	0x0F1206C1,
+	0x0F12D50A,
+	0x0F124994,
+	0x0F127A8A,
+	0x0F120652,
+	0x0F12D406,
+	0x0F122210,
+	0x0F124390,
+	0x0F128328,
+	0x0F127AC9,
+	0x0F126B20,
+	0x0F12F000,
+	0x0F12F9A6,
+	0x0F12E5DC,
+	0x0F12B570,
+	0x0F124D8E,
+	0x0F124C8F,
+	0x0F1288EA,
+	0x0F122A14,
+	0x0F12D101,
+	0x0F122200,
+	0x0F1281A2,
+	0x0F12F000,
+	0x0F12F9B3,
+	0x0F1288E8,
+	0x0F122821,
+	0x0F12D10F,
+	0x0F128B28,
+	0x0F122800,
+	0x0F12D10C,
+	0x0F12200C,
+	0x0F125E20,
+	0x0F128961,
+	0x0F124288,
+	0x0F12DC07,
+	0x0F124882,
+	0x0F123880,
+	0x0F126B80,
+	0x0F12F000,
+	0x0F12F9AB,
+	0x0F1289A0,
+	0x0F121C40,
+	0x0F1281A0,
+	0x0F12E5BE,
+	0x0F12B5F8,
+	0x0F120004,
+	0x0F122101,
+	0x0F12000D,
+	0x0F120020,
+	0x0F123810,
+	0x0F124081,
+	0x0F1240A5,
+	0x0F124F7E,
+	0x0F12000E,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F1243A8,
+	0x0F128038,
+	0x0F12E002,
+	0x0F128878,
+	0x0F1243B0,
+	0x0F128078,
+	0x0F12F000,
+	0x0F12F99A,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F124328,
+	0x0F128038,
+	0x0F12E002,
+	0x0F128878,
+	0x0F124330,
+	0x0F128078,
+	0x0F124874,
+	0x0F128800,
+	0x0F120400,
+	0x0F12D504,
+	0x0F12F000,
+	0x0F12F993,
+	0x0F12496E,
+	0x0F122012,
+	0x0F1280C8,
+	0x0F12E5E3,
+	0x0F12B570,
+	0x0F124E6A,
+	0x0F128881,
+	0x0F1278F2,
+	0x0F124D6E,
+	0x0F124C6A,
+	0x0F122A00,
+	0x0F12D005,
+	0x0F128A62,
+	0x0F121889,
+	0x0F128081,
+	0x0F128B61,
+	0x0F128029,
+	0x0F12E004,
+	0x0F128A22,
+	0x0F121889,
+	0x0F128081,
+	0x0F128B21,
+	0x0F128029,
+	0x0F12F000,
+	0x0F12F982,
+	0x0F1278F0,
+	0x0F122800,
+	0x0F12D002,
+	0x0F128BE0,
+	0x0F1282E8,
+	0x0F12E57B,
+	0x0F128BA0,
+	0x0F1282E8,
+	0x0F12E578,
+	0x0F12B430,
+	0x0F12680B,
+	0x0F12684D,
+	0x0F12688C,
+	0x0F1268C8,
+	0x0F124A5F,
+	0x0F128054,
+	0x0F124958,
+	0x0F1278CC,
+	0x0F124959,
+	0x0F122C00,
+	0x0F12D003,
+	0x0F128A49,
+	0x0F121808,
+	0x0F128090,
+	0x0F12E002,
+	0x0F128A09,
+	0x0F121808,
+	0x0F128090,
+	0x0F1280D3,
+	0x0F128115,
+	0x0F12BC30,
+	0x0F124770,
+	0x0F12B5F3,
+	0x0F120004,
+	0x0F12B081,
+	0x0F129802,
+	0x0F126800,
+	0x0F120600,
+	0x0F120E00,
+	0x0F122201,
+	0x0F120015,
+	0x0F120021,
+	0x0F123910,
+	0x0F12408A,
+	0x0F1240A5,
+	0x0F124F4D,
+	0x0F120016,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128839,
+	0x0F1243A9,
+	0x0F128039,
+	0x0F12E002,
+	0x0F128879,
+	0x0F1243B1,
+	0x0F128079,
+	0x0F12F000,
+	0x0F12F950,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128839,
+	0x0F124329,
+	0x0F128039,
+	0x0F12E002,
+	0x0F128879,
+	0x0F124331,
+	0x0F128079,
+	0x0F124946,
+	0x0F128809,
+	0x0F122900,
+	0x0F12D102,
+	0x0F12F000,
+	0x0F12F949,
+	0x0F122000,
+	0x0F129902,
+	0x0F126008,
+	0x0F12BCFE,
+	0x0F12BC08,
+	0x0F124718,
+	0x0F12B538,
+	0x0F124C40,
+	0x0F1289E5,
+	0x0F12F000,
+	0x0F12F946,
+	0x0F121FE8,
+	0x0F1238FD,
+	0x0F12D132,
+	0x0F1289E0,
+	0x0F121FC1,
+	0x0F1239FF,
+	0x0F12D12E,
+	0x0F12483C,
+	0x0F1269E1,
+	0x0F126840,
+	0x0F121809,
+	0x0F120200,
+	0x0F12F000,
+	0x0F12F8BA,
+	0x0F120400,
+	0x0F120C00,
+	0x0F124A38,
+	0x0F122305,
+	0x0F120011,
+	0x0F123114,
+	0x0F12F000,
+	0x0F12F938,
+	0x0F120002,
+	0x0F1266E0,
+	0x0F124D34,
+	0x0F128CE0,
+	0x0F123D14,
+	0x0F1289E9,
+	0x0F12F000,
+	0x0F12F88A,
+	0x0F12466B,
+	0x0F128018,
+	0x0F128A29,
+	0x0F128D20,
+	0x0F126EE2,
+	0x0F12F000,
+	0x0F12F883,
+	0x0F12466B,
+	0x0F128058,
+	0x0F120021,
+	0x0F129800,
+	0x0F123170,
+	0x0F12F000,
+	0x0F12F92A,
+	0x0F120020,
+	0x0F123060,
+	0x0F128A02,
+	0x0F124928,
+	0x0F123980,
+	0x0F12808A,
+	0x0F128A42,
+	0x0F1280CA,
+	0x0F128A80,
+	0x0F128108,
+	0x0F12BC38,
+	0x0F12BC08,
+	0x0F124718,
+	0x0F12B5F8,
+	0x0F120004,
+	0x0F126808,
+	0x0F120400,
+	0x0F120C00,
+	0x0F122201,
+	0x0F120015,
+	0x0F120021,
+	0x0F123910,
+	0x0F12408A,
+	0x0F1240A5,
+	0x0F124F17,
+	0x0F120016,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128839,
+	0x0F1243A9,
+	0x0F128039,
+	0x0F12E002,
+	0x0F128879,
+	0x0F1243B1,
+	0x0F128079,
+	0x0F12F000,
+	0x0F12F90D,
+	0x0F122C10,
+	0x0F12DA03,
+	0x0F128838,
+	0x0F124328,
+	0x0F128038,
+	0x0F12E002,
+	0x0F128878,
+	0x0F124330,
+	0x0F128078,
+	0x0F12480D,
+	0x0F128800,
+	0x0F120400,
+	0x0F12D507,
+	0x0F124B12,
+	0x0F127819,
+	0x0F124A12,
+	0x0F127810,
+	0x0F127018,
+	0x0F127011,
+	0x0F124905,
+	0x0F128188,
+	0x0F12E513,
+	0x0F120000,
+	0x0F122FA4,
+	0x0F127000,
+	0x0F12235C,
+	0x0F127000,
+	0x0F120140,
+	0x0F127000,
+	0x0F1220BC,
+	0x0F127000,
+	0x0F122DF0,
+	0x0F127000,
+	0x0F1247E0,
+	0x0F127000,
+	0x0F121100,
+	0x0F12D000,
+	0x0F122EE2,
+	0x0F127000,
+	0x0F12F400,
+	0x0F12D000,
+	0x0F123200,
+	0x0F12D000,
+	0x0F1216DE,
+	0x0F127000,
+	0x0F1236F8,
+	0x0F127000,
+	0x0F122B90,
+	0x0F127000,
+	0x0F1217B4,
+	0x0F127000,
+	0x0F122EDD,
+	0x0F127000,
+	0x0F122EDE,
+	0x0F127000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F1213D5,
+	0x0F120001,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12A083,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12A035,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12A1D9,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F122D27,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F127D47,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F127AB1,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F127ACB,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12F004,
+	0x0F12E51F,
+	0x0F122630,
+	0x0F120001,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12ED4D,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12EDDB,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F124EB5,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12053B,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F1249D1,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12D411,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F121E57,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F122603,
+	0x0F120001,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12BC3D,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F122601,
+	0x0F120001,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12BAB1,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12B89F,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12F077,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12C10D,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12C0C9,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12EAF9,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F122E61,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12E86B,
+	0x0F120000,
+	0x0F124778,
+	0x0F1246C0,
+	0x0F12C000,
+	0x0F12E59F,
+	0x0F12FF1C,
+	0x0F12E12F,
+	0x0F12B231,
+	0x0F120000,
+	/* End of Patch Data*/
+
+	/* switch to firmware address bank */
+	0x0028D000,
+	0x002A1000,
+	0x0F120001,
+	/* End of factory settings*/
+
+	/* Switch to sw address bank */
+	0x00287000,
+
+	0x002A479E,
+	0x0F120001,
+
+	0x002A1432,
+	0x0F120000,
+
+	0x002A47EE,
+	0x0F120001,
+	0x0F12000A,
+	0x0F120014,
+	0x0F120070,
+	0x0F120005,
+	0x0F125A3C,
+
+	0x002A4780,
+	0x0F120000,
+	0x0F120014,
+	0x0F1200D2,
+	0x0F120384,
+	0x0F1207D0,
+	0x0F121388,
+	0x0F120180,
+	0x0F120196,
+	0x0F120054,
+	0x0F120001,
+	0x0F1201CC,
+	0x0F1201CC,
+	0x0F1201CC,
+	0x0F1201CC,
+	0x0F1201CC,
+
+	0x002A0EF0,
+	0x0F120001,
+
+	0x002A0EF6,
+	0x0F120002,
+
+	0x002A1A84,
+	0x0F12001C,
+
+	0x002A01F8,
+	0x0F120000,
+
+	0x002A16E4,
+	0x0F120100,
+
+	0x002A01FA,
+	0x0F120003,
+	0x0F120000,
+
+	0x002A0200,
+	0x0F120061,
+
+	0x002A0208,
+	0x0F122F0C,
+	0x0F120190,
+
+	0x002A028E,
+	0x0F120100,
+	0x0F1200E3,
+	0x0F120200,
+	0x0F120238,
+	0x0F1201C6,
+	0x0F120166,
+	0x0F120074,
+	0x0F120132,
+	0x0F120001,
+
+	0x002A0702,
+	0x0F1200FF,
+
+	0x002A1600,
+	0x0F120000,
+
+	0x002A0712,
+	0x0F120001,
+
+	0x002A160C,
+	0x0F129002,
+
+	0x002A1616,
+	0x0F120003,
+
+	0x002A15A4,
+	0x0F120902,
+
+	0x002A1618,
+	0x0F120000,
+
+	0x002A1610,
+	0x0F120003,
+
+	0x002A1602,
+	0x0F1200E5,
+	0x0F120098,
+
+	0x002A1598,
+	0x0F120000,
+	0x0F12D000,
+
+	0x002A165E,
+	0x0F12FF95,
+
+	0x002A162E,
+	0x0F120280,
+
+	0x002A163A,
+	0x0F1203A0,
+	0x0F120320,
+
+	0x002A1680,
+	0x0F120030,
+
+	0x002A16A4,
+	0x0F120060,
+
+	0x002A1698,
+	0x0F120010,
+
+	0x002A161A,
+	0x0F120000,
+
+	0x002A15AA,
+	0x0F12003C,
+	0x0F120018,
+	0x0F12002A,
+	0x0F120030,
+	0x0F120036,
+	0x0F12003C,
+	0x0F120042,
+	0x0F120048,
+	0x0F12004E,
+	0x0F120054,
+	0x0F12005A,
+	0x0F120060,
+	0x0F120066,
+	0x0F12006C,
+	0x0F120072,
+	0x0F120078,
+	0x0F12007E,
+	0x0F120084,
+	0x0F12008A,
+	0x0F120090,
+	0x0F120096,
+	0x0F12009C,
+	0x0F1200A2,
+	0x0F1200A8,
+	0x0F1200AE,
+	0x0F1200B4,
+	0x0F1200BA,
+
+	0x002A16E6,
+	0x0F128000,
+	0x0F120006,
+	0x0F123FF0,
+	0x0F1203E8,
+	0x0F120000,
+	0x0F120080,
+	0x0F120009,
+	0x0F120020,
+	0x0F120040,
+	0x0F120080,
+	0x0F1200C0,
+	0x0F1200E0,
+
+	0x002A0286,
+	0x0F120003,
+
+	0x002A11B4,
+	0x0F12012C,
+	0x0F120121,
+
+	0x002A1A00,
+	0x0F12192E,
+	0x0F127000,
+
+	0x002A185C,
+	0x0F120004,
+	0x0F1209D1,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F1209D5,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F1209D5,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F120326,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F1209D1,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F1209D5,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F120327,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F120084,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F12008D,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F1202AA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200AA,
+	0x0F1202AA,
+	0x0F1203AD,
+	0x0F1209CD,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AE,
+	0x0F1202DE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202BE,
+	0x0F1202EE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202CE,
+	0x0F1202EE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F120009,
+	0x0F120095,
+	0x0F1209DB,
+	0x0F120000,
+	0x0F120000,
+	0x0F120096,
+	0x0F12009B,
+	0x0F1202AE,
+	0x0F1202B3,
+	0x0F1209D1,
+	0x0F1209D6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120009,
+	0x0F120010,
+	0x0F120327,
+	0x0F120336,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120004,
+	0x0F1205B6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F120007,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F12024E,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F1205B6,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F12024F,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120075,
+	0x0F1200CF,
+	0x0F120000,
+	0x0F120000,
+	0x0F120075,
+	0x0F1200D6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120004,
+	0x0F1201F4,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200F0,
+	0x0F1201F4,
+	0x0F12029E,
+	0x0F1205B2,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F8,
+	0x0F120228,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120208,
+	0x0F120238,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120218,
+	0x0F120238,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F120009,
+	0x0F1200DE,
+	0x0F1205C0,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200DF,
+	0x0F1200E4,
+	0x0F1201F8,
+	0x0F1201FD,
+	0x0F1205B6,
+	0x0F1205BB,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F8,
+	0x0F120000,
+	0x0F120000,
+	0x0F120077,
+	0x0F12007E,
+	0x0F12024F,
+	0x0F12025E,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A1836,
+	0x0F120002,
+	0x0F120000,
+	0x0F120003,
+
+	0x002A183E,
+	0x0F120FB0,
+
+	0x002A184C,
+	0x0F120060,
+	0x0F120060,
+	0x0F1205C0,
+	0x0F1205C0,
+
+	0x002A1A8A,
+	0x0F128080,
+	0x0F120080,
+
+	0x002A1A80,
+	0x0F120000,
+
+	0x002A1A12,
+	0x0F120000,
+
+	0x002A1842,
+	0x0F120004,
+
+	0x002A1A0A,
+	0x0F12009A,
+
+	0x002A3776,
+	0x0F12024C,
+
+	0x002A0EB2,
+	0x0F120000,
+
+	0x002A08C6,
+	0x0F120001,
+
+	0x002A08A4,
+	0x0F120001,
+
+	0x002A08E2,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124500,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x002A08E0,
+	0x0F120001,
+
+	0x002A1456,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120202,
+	0x0F120202,
+	0x0F120102,
+
+	0x002A1448,
+	0x0F12003C,
+
+	0x002A144E,
+	0x0F12000F,
+
+	0x002A0580,
+	0x0F123520,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F120470,
+	0x0F120C00,
+	0x0F120100,
+	0x0F121000,
+
+	0x002A0538,
+	0x0F120111,
+	0x0F1200EF,
+
+	0x002A05FC,
+	0x0F120000,
+	0x0F120001,
+	0x0F120600,
+	0x0F120100,
+	0x0F120001,
+	0x0F120000,
+	0x0F120A3C,
+	0x0F120000,
+	0x0F120D04,
+	0x0F120000,
+	0x0F124008,
+	0x0F120000,
+	0x0F127000,
+	0x0F120000,
+	0x0F129C00,
+	0x0F120000,
+	0x0F12AD00,
+	0x0F120001,
+	0x0F12F1D4,
+	0x0F120002,
+	0x0F12DC00,
+	0x0F120005,
+	0x0F12DC00,
+	0x0F120005,
+	0x0F120001,
+	0x0F120000,
+	0x0F120A3C,
+	0x0F120000,
+	0x0F120D05,
+	0x0F120000,
+	0x0F123408,
+	0x0F120000,
+	0x0F123408,
+	0x0F120000,
+	0x0F126810,
+	0x0F120000,
+	0x0F128214,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F120650,
+	0x0F120100,
+
+	0x002A06AC,
+	0x0F12452C,
+	0x0F120004,
+
+	0x002A0280,
+	0x0F120001,
+
+	0x002A05C4,
+	0x0F120000,
+
+	0x002A0476,
+	0x0F120001,
+	0x0F120280,
+	0x0F1201E0,
+	0x0F120005,
+
+	0x002A01F4,
+	0x0F125DC0,
+
+	0x002A020E,
+	0x0F120002,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0216,
+	0x0F123A98,
+	0x0F124F1A,
+	0x0F124F1A,
+	0x0F124F1A,
+	0x0F124F1A,
+	0x0F124F1A,
+
+	0x002A0228,
+	0x0F120001,
+
+	0x002A02A0,
+	0x0F120280,
+	0x0F1201E0,
+	0x0F120005,
+	0x0F124F1A,
+	0x0F124F1A,
+
+	0x002A02AE,
+	0x0F120052,
+
+	0x002A02B6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+
+	0x002A02AA,
+	0x0F120080,
+
+	0x002A024C,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+
+	0x002A048E,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A025E,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0392,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120009,
+	0x0F124F1A,
+	0x0F124F1A,
+
+	0x002A03A0,
+	0x0F120002,
+
+	0x002A03A8,
+	0x0F120001,
+	0x0F120000,
+	0x0F120002,
+	0x0F120535,
+	0x0F12029A,
+
+	0x002A039C,
+	0x0F120080,
+
+	0x002A0476,
+	0x0F120001,
+	0x0F120280,
+	0x0F1201E0,
+	0x0F120005,
+
+	0x002A0262,
+	0x0F120000,
+
+	0x002A0266,
+	0x0F120001,
+
+	0x002A024A,
+	0x0F120001,
+
+	0x002A0264,
+	0x0F120001,
+
+	0x002A026C,
+	0x0F120001,
+
+	0x002A023A,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0472,
+	0x0F12005F,
+	0x0F12005F,
+
+	0x002A0FE0,
+	0x0F1203B8,
+	0x0F1203CE,
+	0x0F120350,
+	0x0F1203C4,
+	0x0F1202F2,
+	0x0F120394,
+	0x0F1202C0,
+	0x0F120364,
+	0x0F12029E,
+	0x0F120334,
+	0x0F12027C,
+	0x0F120312,
+	0x0F12025E,
+	0x0F1202F2,
+	0x0F120246,
+	0x0F1202D0,
+	0x0F120230,
+	0x0F1202B0,
+	0x0F120218,
+	0x0F12029E,
+	0x0F120208,
+	0x0F120290,
+	0x0F1201F8,
+	0x0F120284,
+	0x0F1201E8,
+	0x0F120276,
+	0x0F1201DA,
+	0x0F12026A,
+	0x0F1201CE,
+	0x0F12025E,
+	0x0F1201EC,
+	0x0F12022E,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120005,
+
+	0x002A1034,
+	0x0F120010,
+
+	0x002A1038,
+	0x0F120126,
+
+	0x002A103C,
+	0x0F12026C,
+	0x0F12029A,
+	0x0F12025C,
+	0x0F1202B6,
+	0x0F12024E,
+	0x0F1202C0,
+	0x0F120240,
+	0x0F1202BE,
+	0x0F12023A,
+	0x0F1202B4,
+	0x0F12023A,
+	0x0F1202AA,
+	0x0F120240,
+	0x0F12029E,
+	0x0F12025C,
+	0x0F120294,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120004,
+
+	0x002A1070,
+	0x0F120008,
+
+	0x002A1074,
+	0x0F1201E2,
+
+	0x002A1078,
+	0x0F120350,
+	0x0F120422,
+	0x0F1202C4,
+	0x0F120452,
+	0x0F120278,
+	0x0F12041C,
+	0x0F120230,
+	0x0F1203EE,
+	0x0F1201F0,
+	0x0F120392,
+	0x0F1201C0,
+	0x0F120340,
+	0x0F120194,
+	0x0F120302,
+	0x0F12016E,
+	0x0F1202C2,
+	0x0F120148,
+	0x0F120286,
+	0x0F12018A,
+	0x0F120242,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120006,
+
+	0x002A10AC,
+	0x0F12000A,
+
+	0x002A10B0,
+	0x0F120106,
+
+	0x002A10B4,
+	0x0F120380,
+	0x0F120000,
+	0x0F120168,
+	0x0F120000,
+	0x0F122D90,
+	0x0F120000,
+
+	0x002A1428,
+	0x0F120008,
+	0x0F120190,
+	0x0F1200A0,
+
+	0x002A11EC,
+	0x0F1200C0,
+
+	0x002A11F0,
+	0x0F120010,
+
+	0x002A11EE,
+	0x0F120010,
+
+	0x002A11CE,
+	0x0F1205D5,
+
+	0x002A11D2,
+	0x0F120000,
+	0x0F120771,
+	0x0F1203A4,
+	0x0F120036,
+	0x0F12002A,
+
+	0x002A08AC,
+	0x0F1200C0,
+	0x0F1200DF,
+	0x0F120100,
+	0x0F120125,
+	0x0F12015F,
+	0x0F12017C,
+	0x0F120194,
+
+	0x002A123C,
+	0x0F12FEF7,
+	0x0F120021,
+	0x0F120E74,
+	0x0F120E74,
+	0x0F12018F,
+	0x0F120096,
+	0x0F12000E,
+
+	0x002A11E8,
+	0x0F120032,
+	0x0F12001E,
+
+	0x002A2ABC,
+	0x0F120006,
+
+	0x002A1430,
+	0x0F120002,
+
+	0x002A140A,
+	0x0F1200AB,
+	0x0F1200BF,
+	0x0F1200D2,
+	0x0F120093,
+
+	0x002A13F8,
+	0x0F120300,
+	0x0F12036E,
+	0x0F1203C2,
+	0x0F121015,
+	0x0F1210E1,
+	0x0F121154,
+	0x0F1211A8,
+	0x0F1211BB,
+	0x0F12123B,
+
+	0x002A1368,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F120030,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F120030,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F120030,
+	0x0F12FFE0,
+	0x0F12FFE0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFA0,
+	0x0F12FE36,
+	0x0F12FFE0,
+	0x0F12FFE0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFA0,
+	0x0F12FE36,
+	0x0F12FFE0,
+	0x0F12FFE0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFA0,
+	0x0F12FE36,
+	0x0F12FFEA,
+	0x0F12FFEA,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFEA,
+	0x0F12FFEA,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFEA,
+	0x0F12FFEA,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F12FFC8,
+	0x0F120014,
+	0x0F120014,
+	0x0F120014,
+	0x0F12FDA0,
+	0x0F12FCF0,
+	0x0F12FCD0,
+	0x0F120014,
+	0x0F120014,
+	0x0F120014,
+	0x0F12FDA0,
+	0x0F12FCF0,
+	0x0F12FCD0,
+	0x0F120014,
+	0x0F120014,
+	0x0F120014,
+	0x0F12FDA0,
+	0x0F12FCF0,
+	0x0F12FCD0,
+
+	0x002A13FE,
+	0x0F121015,
+	0x0F12106C,
+	0x0F1210CA,
+	0x0F121142,
+	0x0F1211BB,
+	0x0F12123B,
+	0x0F1200AB,
+	0x0F1200BF,
+	0x0F1200D2,
+	0x0F120093,
+
+	0x002A11CC,
+	0x0F120020,
+
+	0x002A1412,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0724,
+	0x0F120001,
+	0x0F120007,
+	0x0F120010,
+	0x0F120028,
+	0x0F120062,
+	0x0F1200D3,
+	0x0F120130,
+	0x0F120158,
+	0x0F12017D,
+	0x0F1201BE,
+	0x0F1201F8,
+	0x0F12022C,
+	0x0F12025B,
+	0x0F1202AA,
+	0x0F1202EC,
+	0x0F12034E,
+	0x0F120396,
+	0x0F1203C6,
+	0x0F1203E9,
+	0x0F1203F9,
+	0x0F120001,
+	0x0F120007,
+	0x0F120010,
+	0x0F120028,
+	0x0F120062,
+	0x0F1200D3,
+	0x0F120130,
+	0x0F120158,
+	0x0F12017D,
+	0x0F1201BE,
+	0x0F1201F8,
+	0x0F12022C,
+	0x0F12025B,
+	0x0F1202AA,
+	0x0F1202EC,
+	0x0F12034E,
+	0x0F120396,
+	0x0F1203C6,
+	0x0F1203E9,
+	0x0F1203F9,
+	0x0F120001,
+	0x0F120007,
+	0x0F120010,
+	0x0F120028,
+	0x0F120062,
+	0x0F1200D3,
+	0x0F120130,
+	0x0F120158,
+	0x0F12017D,
+	0x0F1201BE,
+	0x0F1201F8,
+	0x0F12022C,
+	0x0F12025B,
+	0x0F1202AA,
+	0x0F1202EC,
+	0x0F12034E,
+	0x0F120396,
+	0x0F1203C6,
+	0x0F1203E9,
+	0x0F1203F9,
+	0x0F120000,
+	0x0F12000F,
+	0x0F120020,
+	0x0F120043,
+	0x0F120086,
+	0x0F1200ED,
+	0x0F12013E,
+	0x0F120163,
+	0x0F120185,
+	0x0F1201BF,
+	0x0F1201F2,
+	0x0F120221,
+	0x0F12024A,
+	0x0F120294,
+	0x0F1202D0,
+	0x0F12032A,
+	0x0F12036A,
+	0x0F12039F,
+	0x0F1203CC,
+	0x0F1203F9,
+	0x0F120000,
+	0x0F12000F,
+	0x0F120020,
+	0x0F120043,
+	0x0F120086,
+	0x0F1200ED,
+	0x0F12013E,
+	0x0F120163,
+	0x0F120185,
+	0x0F1201BF,
+	0x0F1201F2,
+	0x0F120221,
+	0x0F12024A,
+	0x0F120294,
+	0x0F1202D0,
+	0x0F12032A,
+	0x0F12036A,
+	0x0F12039F,
+	0x0F1203CC,
+	0x0F1203F9,
+	0x0F120000,
+	0x0F12000F,
+	0x0F120020,
+	0x0F120043,
+	0x0F120086,
+	0x0F1200ED,
+	0x0F12013E,
+	0x0F120163,
+	0x0F120185,
+	0x0F1201BF,
+	0x0F1201F2,
+	0x0F120221,
+	0x0F12024A,
+	0x0F120294,
+	0x0F1202D0,
+	0x0F12032A,
+	0x0F12036A,
+	0x0F12039F,
+	0x0F1203CC,
+	0x0F1203F9,
+
+	0x002A0896,
+	0x0F1200C0,
+	0x0F120100,
+	0x0F120125,
+	0x0F12015F,
+	0x0F12017C,
+	0x0F120194,
+	0x0F120001,
+
+	0x002A0888,
+	0x0F124800,
+	0x0F127000,
+
+	0x002A4800,
+	0x0F12016C,
+	0x0F12FF94,
+	0x0F12FFCE,
+	0x0F12FF20,
+	0x0F1201BF,
+	0x0F12FF53,
+	0x0F12003F,
+	0x0F120007,
+	0x0F1201DF,
+	0x0F120110,
+	0x0F1200DF,
+	0x0F12FF47,
+	0x0F120206,
+	0x0F12FF7F,
+	0x0F120191,
+	0x0F12FF06,
+	0x0F1201BA,
+	0x0F120108,
+	0x0F12016C,
+	0x0F12FF94,
+	0x0F12FFCE,
+	0x0F12FF20,
+	0x0F1201BF,
+	0x0F12FF53,
+	0x0F12003F,
+	0x0F120007,
+	0x0F1201DF,
+	0x0F120110,
+	0x0F1200DF,
+	0x0F12FF47,
+	0x0F120206,
+	0x0F12FF7F,
+	0x0F120191,
+	0x0F12FF06,
+	0x0F1201BA,
+	0x0F120108,
+	0x0F12016C,
+	0x0F12FF94,
+	0x0F12FFCE,
+	0x0F12FF20,
+	0x0F1201BF,
+	0x0F12FF53,
+	0x0F12003F,
+	0x0F120007,
+	0x0F1201DF,
+	0x0F120110,
+	0x0F1200DF,
+	0x0F12FF47,
+	0x0F120206,
+	0x0F12FF7F,
+	0x0F120191,
+	0x0F12FF06,
+	0x0F1201BA,
+	0x0F120108,
+	0x0F120208,
+	0x0F12FFD3,
+	0x0F12FFE9,
+	0x0F12FF5B,
+	0x0F12025A,
+	0x0F12FF80,
+	0x0F12FFC8,
+	0x0F12FFC1,
+	0x0F12013A,
+	0x0F120112,
+	0x0F1200EE,
+	0x0F12FF99,
+	0x0F12009E,
+	0x0F12FF5F,
+	0x0F1201A8,
+	0x0F12FF75,
+	0x0F120187,
+	0x0F1201BF,
+	0x0F120208,
+	0x0F12FFD3,
+	0x0F12FFE9,
+	0x0F12FF5B,
+	0x0F12025A,
+	0x0F12FF80,
+	0x0F12FFC8,
+	0x0F12FFC1,
+	0x0F12013A,
+	0x0F120112,
+	0x0F1200EE,
+	0x0F12FF99,
+	0x0F12009E,
+	0x0F12FF5F,
+	0x0F1201A8,
+	0x0F12FF75,
+	0x0F120187,
+	0x0F1201BF,
+	0x0F120208,
+	0x0F12FFD3,
+	0x0F12FFE9,
+	0x0F12FF5B,
+	0x0F12025A,
+	0x0F12FF80,
+	0x0F12FFC8,
+	0x0F12FFC1,
+	0x0F12013A,
+	0x0F120112,
+	0x0F1200EE,
+	0x0F12FF99,
+	0x0F12009E,
+	0x0F12FF5F,
+	0x0F1201A8,
+	0x0F12FF75,
+	0x0F120187,
+	0x0F1201BF,
+
+	0x002A0890,
+	0x0F1248D8,
+	0x0F127000,
+
+	0x002A48D8,
+	0x0F1201AA,
+	0x0F12FFB6,
+	0x0F12FFD4,
+	0x0F12FF6C,
+	0x0F1201E8,
+	0x0F12FF79,
+	0x0F120000,
+	0x0F12FFF5,
+	0x0F12023C,
+	0x0F1200BF,
+	0x0F1200E0,
+	0x0F12FF5B,
+	0x0F12022D,
+	0x0F12FF9B,
+	0x0F1201E1,
+	0x0F12FF34,
+	0x0F12014B,
+	0x0F1201B6,
+
+	0x002A0924,
+	0x0F120050,
+	0x0F1200B0,
+	0x0F120196,
+	0x0F120245,
+	0x0F120300,
+
+	0x002A0958,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120032,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F123604,
+	0x0F12032A,
+	0x0F120403,
+	0x0F121B06,
+	0x0F126015,
+	0x0F1200C0,
+	0x0F126080,
+	0x0F124080,
+	0x0F120640,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120000,
+	0x0F120400,
+	0x0F12365A,
+	0x0F12102A,
+	0x0F12000B,
+	0x0F120600,
+	0x0F125A0F,
+	0x0F120505,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123028,
+	0x0F120418,
+	0x0F120101,
+	0x0F120800,
+	0x0F121804,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120205,
+	0x0F120304,
+	0x0F120409,
+	0x0F120306,
+	0x0F120407,
+	0x0F121C04,
+	0x0F120214,
+	0x0F121002,
+	0x0F120610,
+	0x0F120F02,
+	0x0F124A18,
+	0x0F120080,
+	0x0F120040,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F122A36,
+	0x0F126024,
+	0x0F122A36,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F123601,
+	0x0F12242A,
+	0x0F123660,
+	0x0F12FF2A,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120032,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F122404,
+	0x0F12031B,
+	0x0F120103,
+	0x0F121205,
+	0x0F12400D,
+	0x0F120080,
+	0x0F122080,
+	0x0F123040,
+	0x0F120630,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120300,
+	0x0F12245A,
+	0x0F121018,
+	0x0F12000B,
+	0x0F120B00,
+	0x0F125A0F,
+	0x0F120505,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123428,
+	0x0F12041C,
+	0x0F120101,
+	0x0F120800,
+	0x0F121004,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120205,
+	0x0F120304,
+	0x0F120409,
+	0x0F120306,
+	0x0F120407,
+	0x0F121F04,
+	0x0F120218,
+	0x0F121102,
+	0x0F120611,
+	0x0F121002,
+	0x0F128018,
+	0x0F120080,
+	0x0F120080,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F121B24,
+	0x0F126024,
+	0x0F121010,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F122401,
+	0x0F12241B,
+	0x0F121E60,
+	0x0F12FF18,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120032,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F121B04,
+	0x0F120312,
+	0x0F120003,
+	0x0F120C03,
+	0x0F122806,
+	0x0F120060,
+	0x0F121580,
+	0x0F122020,
+	0x0F120620,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120300,
+	0x0F12145A,
+	0x0F121010,
+	0x0F12000B,
+	0x0F120E00,
+	0x0F125A0F,
+	0x0F120504,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123828,
+	0x0F120428,
+	0x0F120101,
+	0x0F128000,
+	0x0F120A04,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120207,
+	0x0F120304,
+	0x0F120409,
+	0x0F120306,
+	0x0F120407,
+	0x0F122404,
+	0x0F120221,
+	0x0F121202,
+	0x0F120613,
+	0x0F121202,
+	0x0F128018,
+	0x0F120080,
+	0x0F120080,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F12121B,
+	0x0F126024,
+	0x0F120C0C,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F121B01,
+	0x0F122412,
+	0x0F120C60,
+	0x0F12FF0C,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120032,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F121504,
+	0x0F12030F,
+	0x0F120003,
+	0x0F120902,
+	0x0F122004,
+	0x0F120050,
+	0x0F121140,
+	0x0F12201C,
+	0x0F120620,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120300,
+	0x0F12145A,
+	0x0F121010,
+	0x0F12000B,
+	0x0F121000,
+	0x0F125A0F,
+	0x0F120503,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123C28,
+	0x0F12042C,
+	0x0F120101,
+	0x0F12FF00,
+	0x0F120904,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120206,
+	0x0F120304,
+	0x0F120409,
+	0x0F120305,
+	0x0F120406,
+	0x0F122804,
+	0x0F120228,
+	0x0F121402,
+	0x0F120618,
+	0x0F121402,
+	0x0F128018,
+	0x0F120080,
+	0x0F120080,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F120F15,
+	0x0F126024,
+	0x0F120A0A,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F121501,
+	0x0F12240F,
+	0x0F120A60,
+	0x0F12FF0A,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120032,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F120F04,
+	0x0F12030C,
+	0x0F120003,
+	0x0F120602,
+	0x0F121803,
+	0x0F120040,
+	0x0F120E20,
+	0x0F122018,
+	0x0F120620,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120200,
+	0x0F12145A,
+	0x0F121010,
+	0x0F12000B,
+	0x0F121200,
+	0x0F125A0F,
+	0x0F120502,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F124028,
+	0x0F120430,
+	0x0F120101,
+	0x0F12FF00,
+	0x0F120804,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120205,
+	0x0F120304,
+	0x0F120409,
+	0x0F120306,
+	0x0F120407,
+	0x0F122C04,
+	0x0F12022C,
+	0x0F121402,
+	0x0F120618,
+	0x0F121402,
+	0x0F128018,
+	0x0F120080,
+	0x0F120080,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F120C0F,
+	0x0F126024,
+	0x0F120808,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F120F01,
+	0x0F12240C,
+	0x0F120860,
+	0x0F12FF08,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F1223CE,
+	0x0F12FDC8,
+	0x0F12112E,
+	0x0F1293A5,
+	0x0F12FE67,
+	0x0F120000,
+
+	0xFCFCD000,
+	0x00287000,
+	0x002A01A2,
+	0x0F120A0A,
+
+	0xFCFCD000,
+	0x00040001,
+};
+
+static const u32 s5k4ecgx_DTP_init_v1[] = {
+	0x0028D000,
+	0x002AB054,
+	0x0F120001,
+	0x00287000,
+};
+
+static const u32 s5k4ecgx_DTP_stop_v1[] = {
+	0x0028D000,
+	0x002AB054,
+	0x0F120000,
+	0x00287000,
+};
+
+static const u32 s5k4ecgx_Effect_Normal_v1[] = {
+	0x002A0238,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Effect_Negative_v1[] = {
+	0x002A0238,
+	0x0F120003,
+};
+
+static const u32 s5k4ecgx_Effect_Sepia_v1[] = {
+	0x002A0238,
+	0x0F120004,
+};
+
+static const u32 s5k4ecgx_Effect_Black_White_v1[] = {
+	0x002A0238,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_WB_Auto_v1[] = {
+	0x002a04E0,
+	0x0f12077F,
+};
+
+static const u32 s5k4ecgx_WB_Sunny_v1[] = {
+	0x002a04E0,
+	0x0f120777,
+	0x002a04B4,
+	0x0f1205E0,
+	0x0f120001,
+	0x0f120400,
+	0x0f120001,
+	0x0f120530,
+	0x0f120001,
+	0x0f120001,
+};
+
+static const u32 s5k4ecgx_WB_Cloudy_v1[] = {
+	0x002a04E0,
+	0x0f120777,
+	0x002a04B4,/* USER RGB Gain */
+	0x0f120710,/* R */
+	0x0f120001,/* Changed */
+	0x0f120400,/* G */
+	0x0f120001,
+	0x0f120420,/* B  480-reference */
+	0x0f120001,
+	0x0f120001,
+};
+
+static const u32 s5k4ecgx_WB_Tungsten_v1[] = {
+	0x002a04E0,
+	0x0f120777,
+	0x002a04B4,
+	0x0f120390,
+	0x0f120001,
+	0x0f120400,
+	0x0f120001,
+	0x0f120920,
+	0x0f120001,
+	0x0f120001,
+};
+
+static const u32 s5k4ecgx_WB_Fluorescent_v1[] = {
+	0x002a04E0,
+	0x0f120777,
+	0x002a04B4,
+	0x0f120505,
+	0x0f120001,
+	0x0f120400,
+	0x0f120001,
+	0x0f120875,
+	0x0f120001,
+	0x0f120001,
+};
+
+static const u32 s5k4ecgx_WDR_on_v1[] = {
+	0x002A1B4A,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_WDR_off_v1[] = {
+	0x002A1B4A,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_ISO_Auto_v1[] = {
+	0x002A4780,
+	0x0F120000,
+
+	0x002A0EF0,
+	0x0F120001,
+	0x002A04E0,
+	0x0F12077F,
+	0x002A04CA,
+	0x0F120000,
+
+	0x002A04CA,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x002A06B6,
+	0x0F120200,
+};
+
+static const u32 s5k4ecgx_ISO_100_v1[] = {
+	0x002A04E0,
+	0x0F12065F,
+	0x002A04D0,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04CA,
+	0x0F120001,
+	0x0F1201A0,
+	0x0F120001,
+	0x002A06B6,
+	0x0F120100,
+
+	0x002A4780,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_ISO_200_v1[] = {
+	0x002A04E0,
+	0x0F12065F,
+	0x002A04D0,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04CA,
+	0x0F120001,
+	0x0F120340,
+	0x0F120001,
+	0x002A06B6,
+	0x0F120100,
+
+	0x002A4780,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_ISO_400_v1[] = {
+	0x002A04E0,
+	0x0F12065F,
+	0x002A04D0,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04CA,
+	0x0F120001,
+	0x0F120680,
+	0x0F120001,
+	0x002A06B6,
+	0x0F120100,
+
+	0x002A4780,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Metering_Matrix_v1[] = {
+	0x002A1456,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+};
+
+static const u32 s5k4ecgx_Metering_Center_v1[] = {
+	0x002A1456,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120202,
+	0x0F120202,
+	0x0F120102,
+};
+
+static const u32 s5k4ecgx_Metering_Spot_v1[] = {
+	0x002A1456,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120101,
+	0x0f120101,
+	0x0f120000,
+	0x0f120000,
+	0x0f12010f,
+	0x0f120f01,
+	0x0f120000,
+	0x0f120000,
+	0x0f12010f,
+	0x0f120f01,
+	0x0f120000,
+	0x0f120000,
+	0x0f120101,
+	0x0f120101,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+	0x0f120000,
+};
+
+static const u32 s5k4ecgx_EV_Minus_4_v1[] = {
+	0x002A022C,
+	0x0F12FF30,
+};
+
+static const u32 s5k4ecgx_EV_Minus_3_v1[] = {
+	0x002A022C,
+	0x0F12FFA0,
+};
+
+static const u32 s5k4ecgx_EV_Minus_2_v1[] = {
+	0x002A022C,
+	0x0F12FFC8,
+};
+
+static const u32 s5k4ecgx_EV_Minus_1_v1[] = {
+	0x002A022C,
+	0x0F12FFE0,
+};
+
+static const u32 s5k4ecgx_EV_Default_v1[] = {
+	0x002A022C,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_EV_Plus_1_v1[] = {
+	0x002A022C,
+	0x0F120020,
+};
+
+static const u32 s5k4ecgx_EV_Plus_2_v1[] = {
+	0x002A022C,
+	0x0F120038,
+};
+
+static const u32 s5k4ecgx_EV_Plus_3_v1[] = {
+	0x002A022C,
+	0x0F120060,
+};
+
+static const u32 s5k4ecgx_EV_Plus_4_v1[] = {
+	0x002A022C,
+	0x0F12007F,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_4_v1[] = {
+	0x002A022E,
+	0x0F12FF81,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_3_v1[] = {
+	0x002A022E,
+	0x0F12FFA0,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_2_v1[] = {
+	0x002A022E,
+	0x0F12FFC0,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_1_v1[] = {
+	0x002A022E,
+	0x0F12FFE0,
+};
+
+static const u32 s5k4ecgx_Contrast_Default_v1[] = {
+	0x002A022E,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_1_v1[] = {
+	0x002A022E,
+	0x0F120020,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_2_v1[] = {
+	0x002A022E,
+	0x0F120040,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_3_v1[] = {
+	0x002A022E,
+	0x0F120060,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_4_v1[] = {
+	0x002A022E,
+	0x0F12007F,
+};
+
+static const u32 s5k4ecgx_Sharpness_Minus_3_v1[] = {
+	0x002A09F4,
+	0x0F120000,
+	0x002A0AAA,
+	0x0F120000,
+	0x002A0B60,
+	0x0F120000,
+	0x002A0C16,
+	0x0F120000,
+	0x002A0CCC,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Sharpness_Minus_2_v1[] = {
+	0x002A09F4,
+	0x0F122010,
+	0x002A0AAA,
+	0x0F122010,
+	0x002A0B60,
+	0x0F122010,
+	0x002A0C16,
+	0x0F122010,
+	0x002A0CCC,
+	0x0F122010,
+};
+
+static const u32 s5k4ecgx_Sharpness_Minus_1_v1[] = {
+	0x002A09F4,
+	0x0F124020,
+	0x002A0AAA,
+	0x0F124020,
+	0x002A0B60,
+	0x0F124020,
+	0x002A0C16,
+	0x0F124020,
+	0x002A0CCC,
+	0x0F124020,
+};
+
+static const u32 s5k4ecgx_Sharpness_Default_v1[] = {
+	0x002A09F4,
+	0x0F126024,
+	0x002A0AAA,
+	0x0F126024,
+	0x002A0B60,
+	0x0F126024,
+	0x002A0C16,
+	0x0F126024,
+	0x002A0CCC,
+	0x0F126024,
+};
+
+static const u32 s5k4ecgx_Sharpness_Plus_1_v1[] = {
+	0x002A09F4,
+	0x0F128040,
+	0x002A0AAA,
+	0x0F128040,
+	0x002A0B60,
+	0x0F128040,
+	0x002A0C16,
+	0x0F128040,
+	0x002A0CCC,
+	0x0F128040,
+};
+
+static const u32 s5k4ecgx_Sharpness_Plus_2_v1[] = {
+	0x002A09F4,
+	0x0F12A060,
+	0x002A0AAA,
+	0x0F12A060,
+	0x002A0B60,
+	0x0F12A060,
+	0x002A0C16,
+	0x0F12A060,
+	0x002A0CCC,
+	0x0F12A060,
+};
+
+static const u32 s5k4ecgx_Sharpness_Plus_3_v1[] = {
+	0x002A09F4,
+	0x0F12C080,
+	0x002A0AAA,
+	0x0F12C080,
+	0x002A0B60,
+	0x0F12C080,
+	0x002A0C16,
+	0x0F12C080,
+	0x002A0CCC,
+	0x0F12C080,
+};
+
+static const u32 s5k4ecgx_Saturation_Minus_2_v1[] = {
+	0x002A0230,
+	0x0F12FF81,
+};
+
+static const u32 s5k4ecgx_Saturation_Minus_1_v1[] = {
+	0x002A0230,
+	0x0F12FFC0,
+};
+
+static const u32 s5k4ecgx_Saturation_Default_v1[] = {
+	0x002A0230,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Saturation_Plus_1_v1[] = {
+	0x002A0230,
+	0x0F120040,
+};
+
+static const u32 s5k4ecgx_Saturation_Plus_2_v1[] = {
+	0x002A0230,
+	0x0F12007F,
+};
+
+static const u32 s5k4ecgx_Jpeg_Quality_High_v1[] = {
+	0x002A0472,
+	0x0F12005F,
+	0x0F12005F,
+};
+
+static const u32 s5k4ecgx_Jpeg_Quality_Normal_v1[] = {
+	0x002A0472,
+	0x0F120050,
+	0x0F120050,
+};
+
+static const u32 s5k4ecgx_Jpeg_Quality_Low_v1[] = {
+	0x002A0472,
+	0x0F12004B,
+	0x0F12004B,
+};
+
+static const u32 s5k4ecgx_Scene_Default_v1[] = {
+	0x002A1456,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120202,
+	0x0F120202,
+	0x0F120102,
+
+	0x002A4780,
+	0x0F120000,
+
+	0x002A06AC,
+	0x0F12452C,
+	0x0F120004,
+
+	0x002A0EF0,
+	0x0F120001,
+	0x002A0EF6,
+	0x0F120001,
+	0x002A04E0,
+	0x0F12077F,
+	0x002A04CA,
+	0x0F120000,
+
+	0x002A04CA,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x002A06B6,
+	0x0F120200,
+
+	0x002a2B7E,
+	0x0f120001,
+
+
+	0x002A1448,
+	0x0F12003C,
+	0x002A144E,
+	0x0F12000F,
+	0x002A0580,
+	0x0F123520,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F120470,
+	0x0F120C00,
+	0x0F120100,
+	0x0F121000,
+
+	0x002A0538,
+	0x0F120111,
+	0x0F1200EF,
+
+
+	0x002A05FC,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A09F4,
+	0x0F126024,
+	0x002A0AAA,
+	0x0F126024,
+	0x002A0B60,
+	0x0F126024,
+	0x002A0C16,
+	0x0F126024,
+	0x002A0CCC,
+	0x0F126024,
+
+	0x002A0230,
+	0x0F120000,
+
+	0x002A062C,
+	0x0F120001,
+	0x0F120000,
+	0x002A0630,
+	0x0F120A3C,
+	0x0F120000,
+	0x002A0634,
+	0x0F120D05,
+	0x0F120000,
+	0x002A0638,
+	0x0F123408,
+	0x0F120000,
+	0x002A063C,
+	0x0F123408,
+	0x0F120000,
+	0x002A0640,
+	0x0F126810,
+	0x0F120000,
+	0x002A0644,
+	0x0F128214,
+	0x0F120000,
+	0x002A0648,
+	0x0F12C350,
+	0x0F120000,
+	0x002A064C,
+	0x0F12C350,
+	0x0F120000,
+	0x002A0650,
+	0x0F12C350,
+	0x0F120000,
+
+	0x002A03AE,
+	0x0F120535,
+	0x0F12029A,
+
+
+	0x002A0262,
+	0x0F120000,
+	0x002A0266,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0264,
+	0x0F120001,
+	0x002A026C,
+	0x0F120001,
+	0x002A023A,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Portrait_v1[] = {
+	0x002A09F4,
+	0x0F124020,
+	0x002A0AAA,
+	0x0F124020,
+	0x002A0B60,
+	0x0F124020,
+	0x002A0C16,
+	0x0F124020,
+	0x002A0CCC,
+	0x0F124020,
+};
+
+static const u32 s5k4ecgx_Scene_Nightshot_v1[] = {
+	0x002A06AC,
+	0x0F12FFFF,
+	0x0F1200FF,
+
+	0x002A05FC,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0580,
+	0x0F12F424,
+	0x0F120001,
+	0x0F12F424,
+	0x0F120001,
+	0x0F12F424,
+	0x0F120001,
+	0x0F12F424,
+	0x0F120001,
+	0x0F120100,
+	0x0F120700,
+	0x0F120100,
+	0x0F122000,
+
+	0x002A03AE,
+	0x0F121388,
+	0x0F121388,
+
+	0x002A02BC,
+	0x0F1209C4,
+	0x0F12014D,
+
+	0x002A0262,
+	0x0F120000,
+
+	0x002A0266,
+	0x0F120001,
+
+	0x002A024A,
+	0x0F120001,
+
+	0x002A0264,
+	0x0F120001,
+
+	0x002A026C,
+	0x0F120001,
+
+	0x002A023A,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A09EA,
+	0x0F121580,
+};
+
+static const u32 s5k4ecgx_Scene_Landscape_v1[] = {
+	0x002A1456,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x0f120101,
+	0x002A09F4,
+	0x0F128040,
+	0x002A0AAA,
+	0x0F128040,
+	0x002A0B60,
+	0x0F128040,
+	0x002A0C16,
+	0x0F128040,
+	0x002A0CCC,
+	0x0F128040,
+	0x002A0230,
+	0x0F120040,
+};
+
+static const u32 s5k4ecgx_Scene_Sports_v1[] = {
+	0x002A05FC,
+
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0580,
+	0x0F123520,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F120200,
+	0x0F120200,
+	0x0F120200,
+	0x0F120200,
+
+	0x002A0262,
+	0x0F120000,
+	0x002A0266,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0264,
+	0x0F120001,
+	0x002A026C,
+	0x0F120001,
+	0x002A023A,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Party_Indoor_v1[] = {
+	0x002A04E0,
+	0x0F12065F,
+	0x002A04D0,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04CA,
+	0x0F120001,
+	0x0F120340,
+	0x0F120001,
+	0x002A06B6,
+	0x0F120100,
+
+
+	0x002A4780,
+	0x0F120001,
+
+	0x002A0230,
+	0x0F120031,
+};
+
+static const u32 s5k4ecgx_Scene_Beach_Snow_v1[] = {
+	0x002A04E0,
+	0x0F12065F,
+	0x002A04D0,
+	0x0F120000,
+	0x0F120001,
+	0x002A04CA,
+	0x0F120001,
+	0x0F1200D0,
+	0x0F120001,
+	0x002A06B6,
+	0x0F120100,
+
+
+	0x002A4780,
+	0x0F120001,
+
+	0x002A0230,
+	0x0F120031,
+};
+
+static const u32 s5k4ecgx_Scene_Sunset_v1[] = {
+	0x002a2B7E,
+	0x0f120000,
+
+	0x002a04B4,
+	0x0f1205E0,
+	0x0f120001,
+	0x0f120400,
+	0x0f120001,
+	0x0f120520,
+	0x0f120001,
+};
+
+static const u32 s5k4ecgx_Scene_Duskdawn_v1[] = {
+	0x002a2B7E,
+	0x0f120000,
+
+	0x002a04B4,
+	0x0f120575,
+	0x0f120001,
+	0x0f120400,
+	0x0f120001,
+	0x0f120835,
+	0x0f120001,
+};
+
+static const u32 s5k4ecgx_Scene_Fireworks_v1[] = {
+	0x002A062C,
+	0x0F120001,
+	0x0F120000,
+	0x002A0630,
+	0x0F121478,
+	0x0F120000,
+	0x002A0634,
+	0x0F121A0A,
+	0x0F120000,
+	0x002A0638,
+	0x0F126810,
+	0x0F120000,
+	0x002A063C,
+	0x0F126810,
+	0x0F120000,
+	0x002A0640,
+	0x0F12D020,
+	0x0F120000,
+	0x002A0644,
+	0x0F120428,
+	0x0F120001,
+	0x002A0648,
+	0x0F121A80,
+	0x0F120006,
+	0x002A064C,
+	0x0F121A80,
+	0x0F120006,
+	0x002A0650,
+	0x0F121A80,
+	0x0F120006,
+
+	0x002A03AE,
+	0x0F122710,
+	0x0F122710,
+
+	0x002A0262,
+	0x0F120000,
+	0x002A0266,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0264,
+	0x0F120001,
+	0x002A026C,
+	0x0F120001,
+	0x002A023A,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Candle_Light_v1[] = {
+	0x002a04E0,
+	0x0f120777,
+	0x002a04B4,
+	0x0f1205E0,
+	0x0f120001,
+	0x0f120400,
+	0x0f120001,
+	0x0f120530,
+	0x0f120001,
+};
+
+static const u32 s5k4ecgx_Night_Capture_v1[] = {
+	0x002A09EA,
+	0x0F120AAA,
+	0x002A0AA0,
+	0x0F120AAA,
+};
+
+
+static const u32 s5k4ecgx_AF_Return_Inf_pos_v1[] = {
+	0x002A159A,
+	0x0F12D02A,
+};
+
+static const u32 s5k4ecgx_AF_Return_Macro_pos_v1[] = {
+	0x002A15AC,
+	0x0F120018,
+	0x0F12002A,
+	0x0F120030,
+	0x0F120036,
+	0x0F12003C,
+	0x0F120042,
+	0x0F120048,
+	0x0F12004E,
+	0x0F120054,
+	0x0F12005A,
+	0x0F120060,
+	0x0F120066,
+	0x0F12006C,
+	0x0F120072,
+	0x0F120078,
+	0x0F12007E,
+	0x0F120084,
+	0x0F12008A,
+	0x0F120090,
+	0x0F120096,
+	0x0F12009C,
+	0x0F1200A2,
+	0x0F1200A8,
+	0x0F1200AE,
+	0x0F1200B4,
+	0x0F1200BA,
+};
+
+static const u32 s5k4ecgx_AF_Normal_mode_1_v1[] = {
+	0x002A0288,
+	0x0F12002A,
+};
+
+static const u32 s5k4ecgx_AF_Normal_mode_2_v1[] = {
+	0x002A0286,
+	0x0F120004,
+};
+
+
+static const u32 s5k4ecgx_AF_Normal_mode_3_v1[] = {
+	0x002A160C,
+	0x0F129002,
+};
+
+static const u32 s5k4ecgx_AF_Macro_mode_1_v1[] = {
+	0x002A0288,
+	0x0F1200D0,
+};
+
+static const u32 s5k4ecgx_AF_Macro_mode_2_v1[] = {
+	0x002A0286,
+	0x0F120004,
+};
+
+static const u32 s5k4ecgx_AF_Macro_mode_3_v1[] = {
+	0x002A160C,
+	0x0F129042,
+	0x002A159E,
+	0x0F121800,
+};
+
+static const u32 s5k4ecgx_AF_Low_Light_Mode_On_v1[] = {
+	0x002A1616,
+	0x0F120003,
+
+	0x002A15A4,
+	0x0F120902,
+
+	0x002A159E,
+	0x0F120C00,
+
+	0x002A15AC,
+	0x0F12002A,
+	0x0F120033,
+	0x0F12003C,
+	0x0F120045,
+	0x0F12004E,
+	0x0F120057,
+	0x0F120063,
+	0x0F12006F,
+	0x0F12007B,
+	0x0F120087,
+	0x0F120093,
+	0x0F1200A2,
+	0x0F1200B1,
+};
+
+static const u32 s5k4ecgx_AF_Low_Light_Mode_Off_v1[] = {
+	0x002A1616,
+	0x0F120003,
+
+	0x002A15A4,
+	0x0F120902,
+
+	0x002A159E,
+	0x0F121800,
+
+	0x002A15AC,
+	0x0F120018,
+	0x0F12002A,
+	0x0F120030,
+	0x0F120036,
+	0x0F12003C,
+	0x0F120042,
+	0x0F120048,
+	0x0F12004E,
+	0x0F120054,
+	0x0F12005A,
+	0x0F120060,
+	0x0F120066,
+	0x0F12006C,
+	0x0F120072,
+	0x0F120078,
+	0x0F12007E,
+	0x0F120084,
+	0x0F12008A,
+	0x0F120090,
+	0x0F120096,
+	0x0F12009C,
+	0x0F1200A2,
+	0x0F1200A8,
+	0x0F1200AE,
+	0x0F1200B4,
+	0x0F1200BA,
+};
+
+static const u32 s5k4ecgx_Single_AF_Start_v1[] = {
+	0x002A0286,
+	0x0F120005,
+};
+
+static const u32 s5k4ecgx_Single_AF_Off_1_v1[] = {
+	0x002A0288,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Single_AF_Off_2_v1[] = {
+	0x002A0286,
+	0x0F120004,
+};
+
+static const u32 s5k4ecgx_Face_Detection_On_v1[] = {
+	0x002A028E,
+	0x0F120100,
+	0x0F1200E3,
+	0x0F120200,
+	0x0F120238,
+	0x0F1201C6,
+	0x0F120166,
+	0x0F120074,
+	0x0F120132,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Face_Detection_Off_v1[] = {
+	0x002A028E,
+	0x0F120100,
+	0x0F1200E3,
+	0x0F120200,
+	0x0F120238,
+	0x0F1201C6,
+	0x0F120166,
+	0x0F120074,
+	0x0F120132,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Low_Cap_On_v1[] = {
+	0x002A09EA,
+	0x0F120D58,
+	0x002A0AA0,
+	0x0F120A53,
+};
+
+static const u32 s5k4ecgx_Low_Cap_Off_v1[] = {
+	0x002A09EA,
+	0x0F120040,
+	0x002A0AA0,
+	0x0F120080,
+};
+
+/* restores crop settings to full resolution */
+static const u32 s5k4ecgx_Reset_Crop_v1[] = {
+	0x002A024C,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x002A048E,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A025E,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Capture_Start_v1[] = {
+	0x002A1A00,
+	0x0F12185C,
+	0x0F127000,
+	0x002A023E,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0240,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Preview_Return_v1[] = {
+	0x002A05C4,
+	0x0F120000,
+	0x002A1A00,
+	0x0F12192E,
+	0x0F127000,
+	0x002A0952,
+	0x0F120000,
+	0x002A023E,
+	0x0F120000,
+	0x002A024A,
+	0x0F120001,
+	0x002A0240,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Flash_init_v1[] = {
+	0x002A17DC,
+	0x0F120001, /* one frame AE */
+
+	0x002A17AE,
+	0x0F120270, /* AWB R point */
+
+	0x002A17B0,
+	0x0F120210, /* AWB B point */
+
+	0x002A17E2,
+	0x0F120001, /* Flash AE tune start*/
+	0x0F120030, /* 0x100 for Rin output */
+	0x0F120040,
+	0x0F120050,
+	0x0F120060,
+	0x0F120070,
+	0x0F120080,
+	0x0F120090,
+	0x0F1200A0,
+	0x0F120050, /* 0x100 for Rout output-20 */
+	0x0F120014,
+	0x0F12000A,
+	0x0F120008,
+	0x0F120005,
+	0x0F120004,
+	0x0F120002,
+	0x0F120001,
+
+	0x002A1824,
+	0x0F120100, /* 0x100 for NB output */
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+
+	0x002A17B4,
+	0x0F120100,
+	0x0F1200A0,
+	0x0F120080,
+	0x0F120020,
+	0x0F120001,
+
+	0x002A17C8,
+	0x0F120025,
+	0x0F120030,
+	0x0F120050,
+	0x0F120070,
+	0x0F120080,
+};
+
+static const u32 s5k4ecgx_Pre_Flash_Start_v1[] = {
+	0x002A057C, /* set AE speed to fast */
+	0x0F120000,
+
+	0x002A1F06, /* fls_afl_FlashWP_Weight_0_  Pre_Flash_Start */
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Pre_Flash_End_v1[] = {
+	0x002A057C, /* set AE speed to normal */
+	0x0F120002,
+
+	0x002A1F08, /* fls_afl_FlashWP_Weight_0_  Pre_Flash_end */
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Flash_Start_v1[] = {
+	0x002A17A8,
+	0x0F120001,
+
+	0x002A047E,
+	0x0F120002,
+
+	0x002A1448,
+	0x0F120027,
+};
+
+static const u32 s5k4ecgx_Flash_End_v1[] = {
+	0x002A17A8,
+	0x0F120000,
+
+	0x002A047E,
+	0x0F120000,
+
+	0x002A1448,
+	0x0F12003C,
+};
+
+static const u32 s5k4ecgx_5M_Capture_v1[] = {  /* 2560 x 1920 */
+	0x002A0392,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120009,
+
+	0x002A03AC,
+	0x0F120002,
+
+	0x002A03AA,
+	0x0F120000,
+
+	0x002A026C,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_3M_Capture_v1[] = {  /* 2048 x 1536 */
+	0x002A0392,
+	0x0F120800,
+	0x0F120600,
+	0x0F120009,
+
+	0x002A03AC,
+	0x0F120002,
+
+	0x002A03AA,
+	0x0F120000,
+
+	0x002A024A,
+	0x0F120001,
+
+	0x002A026C,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_2M_Capture_v1[] = {  /* 1600 x 1200 */
+	0x002A0392,
+	0x0F120640,
+	0x0F1204B0,
+	0x0F120009,
+
+	0x002A03AC,
+	0x0F120002,
+
+	0x002A03AA,
+	0x0F120000,
+
+	0x002A024A,
+	0x0F120001,
+
+	0x002A026C,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_1M_Capture_v1[] = {  /* 1280 x 960 */
+	0x002A0392,
+	0x0F120500,
+	0x0F1203C0,
+	0x0F120009,
+
+	0x002A03AC,
+	0x0F120002,
+
+	0x002A03AA,
+	0x0F120000,
+
+	0x002A024A,
+	0x0F120001,
+
+	0x002A026C,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_VGA_Capture_v1[] = {  /* 640 x 480 */
+	0x002A0392,
+	0x0F120280,
+	0x0F1201E0,
+	0x0F120009,
+
+	0x002A03AC,
+	0x0F120002,
+
+	0x002A03AA,
+	0x0F120000,
+
+	0x002A024A,
+	0x0F120001,
+
+	0x002A026C,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_720_Preview_v1[] = {  /* 720 x 480 */
+	0x002A02A0,
+	0x0F1202D0,
+	0x0F1201E0,
+	0x0F120005,
+	0x002A02AE,
+	0x0F120052,
+	0x002A02B8,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+	0x002A02CA,
+	0x0F120000,
+	0x0F120000,
+	0x002A0262,
+	0x0F120000,
+	0x002A0266,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0264,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_640_Preview_v1[] = {  /* 640 x 480 */
+	0x002A02A0,
+	0x0F120280,
+	0x0F1201E0,
+	0x0F120005,
+	0x002A02AE,
+	0x0F120052,
+	0x002A02B8,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+	0x002A02CA,
+	0x0F120000,
+	0x0F120000,
+	0x002A0262,
+	0x0F120000,
+	0x002A0266,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0264,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_352_Preview_v1[] = {  /* 352 x 288 */
+	0x002A02A0,
+	0x0F120160,
+	0x0F120120,
+	0x0F120005,
+	0x002A02AE,
+	0x0F120052,
+	0x002A02B8,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+	0x002A02CA,
+	0x0F120000,
+	0x0F120000,
+	0x002A0262,
+	0x0F120000,
+	0x002A0266,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0264,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_176_Preview_v1[] = {  /* 176 x 144 */
+	0x002A02A0,
+	0x0F1200B0,
+	0x0F120090,
+	0x0F120005,
+	0x002A02AE,
+	0x0F120052,
+	0x002A02B8,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+	0x002A02CA,
+	0x0F120000,
+	0x0F120000,
+	0x002A0262,
+	0x0F120000,
+	0x002A0266,
+	0x0F120001,
+	0x002A024A,
+	0x0F120001,
+	0x002A0264,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_AE_AWB_Lock_On_v1[] = {
+	0x002A2B76,  /* AE Lock On */
+	0x0F120000,
+	0x002A2B7E,  /* AWB Lock On */
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_AE_AWB_Lock_Off_v1[] = {
+	0x002A2B76,  /* AE Lock Off */
+	0x0F120001,
+	0x002A2B7E,  /* AWB Lock Off */
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Get_AE_Stable_Status_v1[] = {
+	0x002E2B8C,
+};
+
+static const u32 s5k4ecgx_Get_Light_Level_v1[] = {
+	0x002C7000,
+	0x002E2B30,
+};
+
+static const u32 s5k4ecgx_get_1st_af_search_status_v1[] = {
+	0x002E2E06,
+};
+
+static const u32 s5k4ecgx_get_2nd_af_search_status_v1[] = {
+	0x002E2167,
+};
+
+static const u32 s5k4ecgx_get_capture_status_v1[] = {
+	0x002E1F02,
+};
+
+static const u32 s5k4ecgx_get_esd_status_v1[] = {
+	0xFCFCD000,
+	0x002CD000,
+	0x002E0060,
+};
+
+static const u32 s5k4ecgx_get_iso_reg_v1[] = {
+	0x002C7000,
+	0x002E2ADC,
+};
+
+static const u32 s5k4ecgx_get_shutterspeed_reg_v1[] = {
+	0x002C7000,
+	0x002E2AD8,
+};
+
+#endif /* __S5K4ECGX_REGS_1_0_H__ */
diff --git a/drivers/media/video/s5k4ecgx_regs_1_1.h b/drivers/media/video/s5k4ecgx_regs_1_1.h
new file mode 100755
index 0000000..bf26f2f
--- /dev/null
+++ b/drivers/media/video/s5k4ecgx_regs_1_1.h
@@ -0,0 +1,4656 @@
+/* drivers/media/video/s5k4ecgx_regs_1_1.h
+ *
+ * Driver for s5k4ecgx (5MP Camera) from SEC(LSI), firmware EVT1.1
+ *
+ * Copyright (C) 2010, SAMSUNG ELECTRONICS
+ *
+ * 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.
+ */
+
+
+#ifndef __S5K4ECGX_REGS_1_1_H__
+#define __S5K4ECGX_REGS_1_1_H__
+
+/* ARM Initiation */
+static const u32 s5k4ecgx_init_reg1[] = {
+	0xFCFCD000,
+	0x00100001,
+	0x10300000,
+	0x00140001,
+};
+
+static const u32 s5k4ecgx_init_reg2[] = {
+	/* Drive current setting */
+	0x0028D000,
+	0x002A1082,
+	0x0F120155,	/*d0_d4_cd10, d0_d4_cd10 9:0*/
+	0x0F120155,	/*d5_d9_cd10, d5_d9_cd10 9:0*/
+	0x0F120055,	/*gpio_cd10, gpio_cd10*/
+	0x0F120555,	/*clks_output_cd10, clks_output_cd10 11:0*/
+	0x002A100E,
+	0x0F120000,	/*pclk_delay_r*/
+
+	0x002A007A,
+	0x0F120000,
+
+	/* ISP FE(ADLC) */
+	0x002AE406,
+	0x0F120092,
+	0x002AE410,
+	0x0F123804,
+	0x002AE41A,
+	0x0F120010,	/*101022 ADD adlcptune_total */
+	0x002AE420,
+	0x0F120003,
+	0x0F120060,
+	0x002AE42E,
+	0x0F120004,
+	0x002AF400,
+	0x0F125A3C,
+	0x0F120023,
+	0x0F128080,
+	0x0F1203AF,
+	0x0F12000A,
+	0x0F12AA54,
+	0x0F120040,
+	0x0F12464E,
+	0x0F120240,
+	0x0F120240,
+	0x0F120040,
+	0x0F121000,
+	0x0F12555C,
+	0x0F12D000,
+	0x0F120010,
+	0x0F120202,
+	0x0F120401,
+	0x0F120022,
+	0x0F120088,
+	0x0F12009F,
+	0x0F120000,
+	0x0F121800,
+	0x0F120088,
+	0x0F120000,
+	0x0F122428,
+	0x0F120000,
+	0x0F1203EE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x002AF552,
+	0x0F120708,
+	0x0F12080C,
+
+	/* For subsampling Size */
+	0x00287000,
+	0x002A18BC,
+	0x0F120004,
+	0x0F1205B6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F120007,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F12024E,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F1205B6,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F1205BA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F4,
+	0x0F12024F,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120075,
+	0x0F1200CF,
+	0x0F120000,
+	0x0F120000,
+	0x0F120075,
+	0x0F1200D6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120004,
+	0x0F1201F4,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200F0,
+	0x0F1201F4,
+	0x0F12029E,
+	0x0F1205B2,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F8,
+	0x0F120228,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120208,
+	0x0F120238,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120218,
+	0x0F120238,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F120009,
+	0x0F1200DE,
+	0x0F1205C0,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200DF,
+	0x0F1200E4,
+	0x0F1201F8,
+	0x0F1201FD,
+	0x0F1205B6,
+	0x0F1205BB,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1201F8,
+	0x0F120000,
+	0x0F120000,
+	0x0F120077,
+	0x0F12007E,
+	0x0F12024F,
+	0x0F12025E,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	/* For Capture */
+	0x0F120004,
+	0x0F1209D1,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F1209D5,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F1209D5,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F120326,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F1209D1,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F1209D5,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AA,
+	0x0F120327,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F120084,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F12008D,
+	0x0F120000,
+	0x0F120000,
+	0x0F120008,
+	0x0F1202AA,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200AA,
+	0x0F1202AA,
+	0x0F1203AD,
+	0x0F1209CD,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AE,
+	0x0F1202DE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202BE,
+	0x0F1202EE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202CE,
+	0x0F1202EE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x0F120009,
+	0x0F120095,
+	0x0F1209DB,
+	0x0F120000,
+	0x0F120000,
+	0x0F120096,
+	0x0F12009B,
+	0x0F1202AE,
+	0x0F1202B3,
+	0x0F1209D1,
+	0x0F1209D6,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1202AE,
+	0x0F120000,
+	0x0F120000,
+	0x0F120009,
+	0x0F120010,
+	0x0F120327,
+	0x0F120336,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A1AF8,
+	0x0F125A3C,	/*#senHal_TuneStr_AngTuneData1_2_D000F400
+			  register at subsampling*/
+
+	0x002A1896,
+	0x0F120002,	/*#senHal_SamplingType	0002 03EE: PLA setting*/
+	0x0F120000,	/*#senHal_SamplingMode 0 : 2 PLA / 1 : 4PLA*/
+	0x0F120003,	/*#senHal_PLAOption
+			  [0] VPLA enable , [1] HPLA enable*/
+
+	0x002A189E,
+	0x0F120FB0,	/*#senHal_ExpMinPixels*/
+
+	0x002A18AC,
+	0x0F120060,	/*#senHal_uAddColsBin*/
+	0x0F120060,	/*#senHal_uAddColsNoBin*/
+	0x0F1205C0,	/*#senHal_uMinColsBin*/
+	0x0F1205C0,	/*#senHal_uMinColsNoBin*/
+
+	0x002A1AEA,
+	0x0F128080,	/*#senHal_SubF404Tune*/
+	0x0F120080,	/*#senHal_FullF404Tune*/
+	0x002A1AE0,
+	0x0F120000,	/*#senHal_bSenAAC*/
+
+	0x002A1A72,
+	0x0F120000,	/*#senHal_bSRX	SRX off*/
+	0x002A18A2,
+	0x0F120004,	/*#senHal_NExpLinesCheckFine,
+			  extend Forbidden area line*/
+	0x002A1A6A,
+	0x0F12009A,	/*#senHal_usForbiddenRightOfs,
+			  extend right Forbidden area line*/
+	0x002A385E,
+	0x0F12024C,	/*#Mon_Sen_uExpPixelsOfs*/
+
+	0x002A0EE6,
+	0x0F120000,	/*#setot_bUseDigitalHbin*/
+	0x002A1B2A,
+	0x0F120300,	/*#senHal_TuneStr2_usAngTuneGainTh  2   70001B2A*/
+	0x0F1200D6,	/*#senHal_TuneStr2_AngTuneF4CA_0_   2   70001B2C*/
+	0x0F12008D,	/*#senHal_TuneStr2_AngTuneF4CA_1_   2   70001B2E*/
+	0x0F1200CF,	/*#senHal_TuneStr2_AngTuneF4C2_0_   2   70001B30*/
+	0x0F120084,	/*#senHal_TuneStr2_AngTuneF4C2_1_   2   70001B32*/
+
+	/* OTP setting */
+
+	0x002A0722,
+	0x0F120100,	/*#skl_OTP_usWaitTime,
+			  This register should be positioned in
+			  front of D0001000*/
+	0x002A0726,
+	0x0F120001,	/*#skl_bUseOTPfunc, This is OTP on/off function*/
+	0x002A08D6,
+	0x0F120001,	/*#ash_bUseOTPData*/
+	0x002A146E,
+	0x0F120000,	/*#awbb_otp_disable*/
+	0x002A08DC,
+	0x0F120001,	/*#ash_bUseGasAlphaOTP*/
+
+	/* TnP setting */
+	/* Start of Patch data */
+	0x002A3AF8,    /* TnP */
+	0x0F12B570,    /* 70003AF8 */
+	0x0F124B33,    /* 70003AFA */
+	0x0F12216F,    /* 70003AFC */
+	0x0F124833,    /* 70003AFE */
+	0x0F128C80,    /* 70003B00 */
+	0x0F122200,    /* 70003B02 */
+	0x0F12C008,    /* 70003B04 */
+	0x0F126001,    /* 70003B06 */
+	0x0F124931,    /* 70003B08 */
+	0x0F124832,    /* 70003B0A */
+	0x0F122401,    /* 70003B0C */
+	0x0F12F000,    /* 70003B0E */
+	0x0F12FB1F,    /* 70003B10 */
+	0x0F124931,    /* 70003B12 */
+	0x0F124831,    /* 70003B14 */
+	0x0F122502,    /* 70003B16 */
+	0x0F120022,    /* 70003B18 */
+	0x0F12F000,    /* 70003B1A */
+	0x0F12FB19,    /* 70003B1C */
+	0x0F124830,    /* 70003B1E */
+	0x0F120261,    /* 70003B20 */
+	0x0F128001,    /* 70003B22 */
+	0x0F122100,    /* 70003B24 */
+	0x0F128041,    /* 70003B26 */
+	0x0F12492E,    /* 70003B28 */
+	0x0F12482F,    /* 70003B2A */
+	0x0F126041,    /* 70003B2C */
+	0x0F12492F,    /* 70003B2E */
+	0x0F12482F,    /* 70003B30 */
+	0x0F12002A,    /* 70003B32 */
+	0x0F122403,    /* 70003B34 */
+	0x0F12F000,    /* 70003B36 */
+	0x0F12FB0B,    /* 70003B38 */
+	0x0F12482B,    /* 70003B3A */
+	0x0F12492D,    /* 70003B3C */
+	0x0F1230C0,    /* 70003B3E */
+	0x0F1263C1,    /* 70003B40 */
+	0x0F124929,    /* 70003B42 */
+	0x0F12482C,    /* 70003B44 */
+	0x0F123980,    /* 70003B46 */
+	0x0F126408,    /* 70003B48 */
+	0x0F12482C,    /* 70003B4A */
+	0x0F12492C,    /* 70003B4C */
+	0x0F126388,    /* 70003B4E */
+	0x0F12492C,    /* 70003B50 */
+	0x0F12482D,    /* 70003B52 */
+	0x0F122504,    /* 70003B54 */
+	0x0F120022,    /* 70003B56 */
+	0x0F12F000,    /* 70003B58 */
+	0x0F12FAFA,    /* 70003B5A */
+	0x0F12492B,    /* 70003B5C */
+	0x0F12482C,    /* 70003B5E */
+	0x0F122405,    /* 70003B60 */
+	0x0F12002A,    /* 70003B62 */
+	0x0F12F000,    /* 70003B64 */
+	0x0F12F86C,    /* 70003B66 */
+	0x0F124829,    /* 70003B68 */
+	0x0F12492A,    /* 70003B6A */
+	0x0F120022,    /* 70003B6C */
+	0x0F122506,    /* 70003B6E */
+	0x0F121D80,    /* 70003B70 */
+	0x0F12F000,    /* 70003B72 */
+	0x0F12F865,    /* 70003B74 */
+	0x0F124826,    /* 70003B76 */
+	0x0F124927,    /* 70003B78 */
+	0x0F122407,    /* 70003B7A */
+	0x0F12002A,    /* 70003B7C */
+	0x0F12300C,    /* 70003B7E */
+	0x0F12F000,    /* 70003B80 */
+	0x0F12F85E,    /* 70003B82 */
+	0x0F124822,    /* 70003B84 */
+	0x0F124925,    /* 70003B86 */
+	0x0F120022,    /* 70003B88 */
+	0x0F122508,    /* 70003B8A */
+	0x0F123010,    /* 70003B8C */
+	0x0F12F000,    /* 70003B8E */
+	0x0F12F857,    /* 70003B90 */
+	0x0F124923,    /* 70003B92 */
+	0x0F124823,    /* 70003B94 */
+	0x0F122409,    /* 70003B96 */
+	0x0F12002A,    /* 70003B98 */
+	0x0F12F000,    /* 70003B9A */
+	0x0F12FAD9,    /* 70003B9C */
+	0x0F124922,    /* 70003B9E */
+	0x0F124822,    /* 70003BA0 */
+	0x0F120022,    /* 70003BA2 */
+	0x0F12250A,    /* 70003BA4 */
+	0x0F12F000,    /* 70003BA6 */
+	0x0F12FAD3,    /* 70003BA8 */
+	0x0F124921,    /* 70003BAA */
+	0x0F124821,    /* 70003BAC */
+	0x0F12240B,    /* 70003BAE */
+	0x0F12002A,    /* 70003BB0 */
+	0x0F12F000,    /* 70003BB2 */
+	0x0F12FACD,    /* 70003BB4 */
+	0x0F124920,    /* 70003BB6 */
+	0x0F124820,    /* 70003BB8 */
+	0x0F120022,    /* 70003BBA */
+	0x0F12F000,    /* 70003BBC */
+	0x0F12FAC8,    /* 70003BBE */
+	0x0F12BC70,    /* 70003BC0 */
+	0x0F12BC08,    /* 70003BC2 */
+	0x0F124718,    /* 70003BC4 */
+	0x0F120000,    /* 70003BC6 */
+	0x0F12017B,    /* 70003BC8 */
+	0x0F124EC2,    /* 70003BCA */
+	0x0F121F6C,    /* 70003BCC */
+	0x0F127000,    /* 70003BCE */
+	0x0F123C59,    /* 70003BD0 */
+	0x0F127000,    /* 70003BD2 */
+	0x0F12E38B,    /* 70003BD4 */
+	0x0F120000,    /* 70003BD6 */
+	0x0F123C91,    /* 70003BD8 */
+	0x0F127000,    /* 70003BDA */
+	0x0F12C3B1,    /* 70003BDC */
+	0x0F120000,    /* 70003BDE */
+	0x0F124780,    /* 70003BE0 */
+	0x0F127000,    /* 70003BE2 */
+	0x0F123CEF,    /* 70003BE4 */
+	0x0F127000,    /* 70003BE6 */
+	0x0F120080,    /* 70003BE8 */
+	0x0F127000,    /* 70003BEA */
+	0x0F123D2B,    /* 70003BEC */
+	0x0F127000,    /* 70003BEE */
+	0x0F12B49D,    /* 70003BF0 */
+	0x0F120000,    /* 70003BF2 */
+	0x0F123DD7,    /* 70003BF4 */
+	0x0F127000,    /* 70003BF6 */
+	0x0F123D8B,    /* 70003BF8 */
+	0x0F127000,    /* 70003BFA */
+	0x0F12FFFF,    /* 70003BFC */
+	0x0F1200FF,    /* 70003BFE */
+	0x0F1217E0,    /* 70003C00 */
+	0x0F127000,    /* 70003C02 */
+	0x0F123F53,    /* 70003C04 */
+	0x0F127000,    /* 70003C06 */
+	0x0F12053D,    /* 70003C08 */
+	0x0F120000,    /* 70003C0A */
+	0x0F120000,    /* 70003C0C */
+	0x0F120A89,    /* 70003C0E */
+	0x0F126CD2,    /* 70003C10 */
+	0x0F120000,    /* 70003C12 */
+	0x0F1202C9,    /* 70003C14 */
+	0x0F120000,    /* 70003C16 */
+	0x0F120000,    /* 70003C18 */
+	0x0F120A9A,    /* 70003C1A */
+	0x0F120000,    /* 70003C1C */
+	0x0F1202D2,    /* 70003C1E */
+	0x0F123FA1,    /* 70003C20 */
+	0x0F127000,    /* 70003C22 */
+	0x0F129E65,    /* 70003C24 */
+	0x0F120000,    /* 70003C26 */
+	0x0F124015,    /* 70003C28 */
+	0x0F127000,    /* 70003C2A */
+	0x0F127C49,    /* 70003C2C */
+	0x0F120000,    /* 70003C2E */
+	0x0F124089,    /* 70003C30 */
+	0x0F127000,    /* 70003C32 */
+	0x0F127C63,    /* 70003C34 */
+	0x0F120000,    /* 70003C36 */
+	0x0F1240A5,    /* 70003C38 */
+	0x0F127000,    /* 70003C3A */
+	0x0F128F01,    /* 70003C3C */
+	0x0F120000,    /* 70003C3E */
+	0x0F12B570,    /* 70003C40 */
+	0x0F12000C,    /* 70003C42 */
+	0x0F120015,    /* 70003C44 */
+	0x0F120029,    /* 70003C46 */
+	0x0F12F000,    /* 70003C48 */
+	0x0F12FA8A,    /* 70003C4A */
+	0x0F1249F8,    /* 70003C4C */
+	0x0F1200A8,    /* 70003C4E */
+	0x0F12500C,    /* 70003C50 */
+	0x0F12BC70,    /* 70003C52 */
+	0x0F12BC08,    /* 70003C54 */
+	0x0F124718,    /* 70003C56 */
+	0x0F126808,    /* 70003C58 */
+	0x0F120400,    /* 70003C5A */
+	0x0F120C00,    /* 70003C5C */
+	0x0F126849,    /* 70003C5E */
+	0x0F120409,    /* 70003C60 */
+	0x0F120C09,    /* 70003C62 */
+	0x0F124AF3,    /* 70003C64 */
+	0x0F128992,    /* 70003C66 */
+	0x0F122A00,    /* 70003C68 */
+	0x0F12D00D,    /* 70003C6A */
+	0x0F122300,    /* 70003C6C */
+	0x0F121A89,    /* 70003C6E */
+	0x0F12D400,    /* 70003C70 */
+	0x0F12000B,    /* 70003C72 */
+	0x0F120419,    /* 70003C74 */
+	0x0F120C09,    /* 70003C76 */
+	0x0F1223FF,    /* 70003C78 */
+	0x0F1233C1,    /* 70003C7A */
+	0x0F121810,    /* 70003C7C */
+	0x0F124298,    /* 70003C7E */
+	0x0F12D800,    /* 70003C80 */
+	0x0F120003,    /* 70003C82 */
+	0x0F120418,    /* 70003C84 */
+	0x0F120C00,    /* 70003C86 */
+	0x0F124AEB,    /* 70003C88 */
+	0x0F128150,    /* 70003C8A */
+	0x0F128191,    /* 70003C8C */
+	0x0F124770,    /* 70003C8E */
+	0x0F12B5F3,    /* 70003C90 */
+	0x0F120004,    /* 70003C92 */
+	0x0F12B081,    /* 70003C94 */
+	0x0F129802,    /* 70003C96 */
+	0x0F126800,    /* 70003C98 */
+	0x0F120600,    /* 70003C9A */
+	0x0F120E00,    /* 70003C9C */
+	0x0F122201,    /* 70003C9E */
+	0x0F120015,    /* 70003CA0 */
+	0x0F120021,    /* 70003CA2 */
+	0x0F123910,    /* 70003CA4 */
+	0x0F12408A,    /* 70003CA6 */
+	0x0F1240A5,    /* 70003CA8 */
+	0x0F124FE4,    /* 70003CAA */
+	0x0F120016,    /* 70003CAC */
+	0x0F122C10,    /* 70003CAE */
+	0x0F12DA03,    /* 70003CB0 */
+	0x0F128839,    /* 70003CB2 */
+	0x0F1243A9,    /* 70003CB4 */
+	0x0F128039,    /* 70003CB6 */
+	0x0F12E002,    /* 70003CB8 */
+	0x0F128879,    /* 70003CBA */
+	0x0F1243B1,    /* 70003CBC */
+	0x0F128079,    /* 70003CBE */
+	0x0F12F000,    /* 70003CC0 */
+	0x0F12FA56,    /* 70003CC2 */
+	0x0F122C10,    /* 70003CC4 */
+	0x0F12DA03,    /* 70003CC6 */
+	0x0F128839,    /* 70003CC8 */
+	0x0F124329,    /* 70003CCA */
+	0x0F128039,    /* 70003CCC */
+	0x0F12E002,    /* 70003CCE */
+	0x0F128879,    /* 70003CD0 */
+	0x0F124331,    /* 70003CD2 */
+	0x0F128079,    /* 70003CD4 */
+	0x0F1249DA,    /* 70003CD6 */
+	0x0F128809,    /* 70003CD8 */
+	0x0F122900,    /* 70003CDA */
+	0x0F12D102,    /* 70003CDC */
+	0x0F12F000,    /* 70003CDE */
+	0x0F12FA4F,    /* 70003CE0 */
+	0x0F122000,    /* 70003CE2 */
+	0x0F129902,    /* 70003CE4 */
+	0x0F126008,    /* 70003CE6 */
+	0x0F12BCFE,    /* 70003CE8 */
+	0x0F12BC08,    /* 70003CEA */
+	0x0F124718,    /* 70003CEC */
+	0x0F12B538,    /* 70003CEE */
+	0x0F129C04,    /* 70003CF0 */
+	0x0F120015,    /* 70003CF2 */
+	0x0F12002A,    /* 70003CF4 */
+	0x0F129400,    /* 70003CF6 */
+	0x0F12F000,    /* 70003CF8 */
+	0x0F12FA4A,    /* 70003CFA */
+	0x0F124AD1,    /* 70003CFC */
+	0x0F128811,    /* 70003CFE */
+	0x0F122900,    /* 70003D00 */
+	0x0F12D00F,    /* 70003D02 */
+	0x0F128820,    /* 70003D04 */
+	0x0F124281,    /* 70003D06 */
+	0x0F12D20C,    /* 70003D08 */
+	0x0F128861,    /* 70003D0A */
+	0x0F128853,    /* 70003D0C */
+	0x0F124299,    /* 70003D0E */
+	0x0F12D200,    /* 70003D10 */
+	0x0F121E40,    /* 70003D12 */
+	0x0F120400,    /* 70003D14 */
+	0x0F120C00,    /* 70003D16 */
+	0x0F128020,    /* 70003D18 */
+	0x0F128851,    /* 70003D1A */
+	0x0F128061,    /* 70003D1C */
+	0x0F124368,    /* 70003D1E */
+	0x0F121840,    /* 70003D20 */
+	0x0F126060,    /* 70003D22 */
+	0x0F12BC38,    /* 70003D24 */
+	0x0F12BC08,    /* 70003D26 */
+	0x0F124718,    /* 70003D28 */
+	0x0F12B5F8,    /* 70003D2A */
+	0x0F120004,    /* 70003D2C */
+	0x0F126808,    /* 70003D2E */
+	0x0F120400,    /* 70003D30 */
+	0x0F120C00,    /* 70003D32 */
+	0x0F122201,    /* 70003D34 */
+	0x0F120015,    /* 70003D36 */
+	0x0F120021,    /* 70003D38 */
+	0x0F123910,    /* 70003D3A */
+	0x0F12408A,    /* 70003D3C */
+	0x0F1240A5,    /* 70003D3E */
+	0x0F124FBE,    /* 70003D40 */
+	0x0F120016,    /* 70003D42 */
+	0x0F122C10,    /* 70003D44 */
+	0x0F12DA03,    /* 70003D46 */
+	0x0F128839,    /* 70003D48 */
+	0x0F1243A9,    /* 70003D4A */
+	0x0F128039,    /* 70003D4C */
+	0x0F12E002,    /* 70003D4E */
+	0x0F128879,    /* 70003D50 */
+	0x0F1243B1,    /* 70003D52 */
+	0x0F128079,    /* 70003D54 */
+	0x0F12F000,    /* 70003D56 */
+	0x0F12FA23,    /* 70003D58 */
+	0x0F122C10,    /* 70003D5A */
+	0x0F12DA03,    /* 70003D5C */
+	0x0F128838,    /* 70003D5E */
+	0x0F124328,    /* 70003D60 */
+	0x0F128038,    /* 70003D62 */
+	0x0F12E002,    /* 70003D64 */
+	0x0F128878,    /* 70003D66 */
+	0x0F124330,    /* 70003D68 */
+	0x0F128078,    /* 70003D6A */
+	0x0F1248B6,    /* 70003D6C */
+	0x0F128800,    /* 70003D6E */
+	0x0F120400,    /* 70003D70 */
+	0x0F12D507,    /* 70003D72 */
+	0x0F124BB5,    /* 70003D74 */
+	0x0F127819,    /* 70003D76 */
+	0x0F124AB5,    /* 70003D78 */
+	0x0F127810,    /* 70003D7A */
+	0x0F127018,    /* 70003D7C */
+	0x0F127011,    /* 70003D7E */
+	0x0F1249B4,    /* 70003D80 */
+	0x0F128188,    /* 70003D82 */
+	0x0F12BCF8,    /* 70003D84 */
+	0x0F12BC08,    /* 70003D86 */
+	0x0F124718,    /* 70003D88 */
+	0x0F12B538,    /* 70003D8A */
+	0x0F1248B2,    /* 70003D8C */
+	0x0F124669,    /* 70003D8E */
+	0x0F12F000,    /* 70003D90 */
+	0x0F12FA0E,    /* 70003D92 */
+	0x0F1248B1,    /* 70003D94 */
+	0x0F1249B0,    /* 70003D96 */
+	0x0F1269C2,    /* 70003D98 */
+	0x0F122400,    /* 70003D9A */
+	0x0F1231A8,    /* 70003D9C */
+	0x0F122A00,    /* 70003D9E */
+	0x0F12D008,    /* 70003DA0 */
+	0x0F1261C4,    /* 70003DA2 */
+	0x0F12684A,    /* 70003DA4 */
+	0x0F126242,    /* 70003DA6 */
+	0x0F126282,    /* 70003DA8 */
+	0x0F12466B,    /* 70003DAA */
+	0x0F12881A,    /* 70003DAC */
+	0x0F126302,    /* 70003DAE */
+	0x0F12885A,    /* 70003DB0 */
+	0x0F126342,    /* 70003DB2 */
+	0x0F126A02,    /* 70003DB4 */
+	0x0F122A00,    /* 70003DB6 */
+	0x0F12D00A,    /* 70003DB8 */
+	0x0F126204,    /* 70003DBA */
+	0x0F126849,    /* 70003DBC */
+	0x0F126281,    /* 70003DBE */
+	0x0F12466B,    /* 70003DC0 */
+	0x0F128819,    /* 70003DC2 */
+	0x0F126301,    /* 70003DC4 */
+	0x0F128859,    /* 70003DC6 */
+	0x0F126341,    /* 70003DC8 */
+	0x0F1249A5,    /* 70003DCA */
+	0x0F1288C9,    /* 70003DCC */
+	0x0F1263C1,    /* 70003DCE */
+	0x0F12F000,    /* 70003DD0 */
+	0x0F12F9F6,    /* 70003DD2 */
+	0x0F12E7A6,    /* 70003DD4 */
+	0x0F12B5F0,    /* 70003DD6 */
+	0x0F12B08B,    /* 70003DD8 */
+	0x0F1220FF,    /* 70003DDA */
+	0x0F121C40,    /* 70003DDC */
+	0x0F1249A1,    /* 70003DDE */
+	0x0F1289CC,    /* 70003DE0 */
+	0x0F124E9E,    /* 70003DE2 */
+	0x0F126AB1,    /* 70003DE4 */
+	0x0F124284,    /* 70003DE6 */
+	0x0F12D101,    /* 70003DE8 */
+	0x0F12489F,    /* 70003DEA */
+	0x0F126081,    /* 70003DEC */
+	0x0F126A70,    /* 70003DEE */
+	0x0F120200,    /* 70003DF0 */
+	0x0F12F000,    /* 70003DF2 */
+	0x0F12F9ED,    /* 70003DF4 */
+	0x0F120400,    /* 70003DF6 */
+	0x0F120C00,    /* 70003DF8 */
+	0x0F124A96,    /* 70003DFA */
+	0x0F128A11,    /* 70003DFC */
+	0x0F129109,    /* 70003DFE */
+	0x0F122101,    /* 70003E00 */
+	0x0F120349,    /* 70003E02 */
+	0x0F124288,    /* 70003E04 */
+	0x0F12D200,    /* 70003E06 */
+	0x0F120001,    /* 70003E08 */
+	0x0F124A92,    /* 70003E0A */
+	0x0F128211,    /* 70003E0C */
+	0x0F124D97,    /* 70003E0E */
+	0x0F128829,    /* 70003E10 */
+	0x0F129108,    /* 70003E12 */
+	0x0F124A8B,    /* 70003E14 */
+	0x0F122303,    /* 70003E16 */
+	0x0F123222,    /* 70003E18 */
+	0x0F121F91,    /* 70003E1A */
+	0x0F12F000,    /* 70003E1C */
+	0x0F12F9DE,    /* 70003E1E */
+	0x0F128028,    /* 70003E20 */
+	0x0F12488E,    /* 70003E22 */
+	0x0F124987,    /* 70003E24 */
+	0x0F126BC2,    /* 70003E26 */
+	0x0F126AC0,    /* 70003E28 */
+	0x0F124282,    /* 70003E2A */
+	0x0F12D201,    /* 70003E2C */
+	0x0F128CC8,    /* 70003E2E */
+	0x0F128028,    /* 70003E30 */
+	0x0F1288E8,    /* 70003E32 */
+	0x0F129007,    /* 70003E34 */
+	0x0F122240,    /* 70003E36 */
+	0x0F124310,    /* 70003E38 */
+	0x0F1280E8,    /* 70003E3A */
+	0x0F122000,    /* 70003E3C */
+	0x0F120041,    /* 70003E3E */
+	0x0F12194B,    /* 70003E40 */
+	0x0F12001E,    /* 70003E42 */
+	0x0F123680,    /* 70003E44 */
+	0x0F128BB2,    /* 70003E46 */
+	0x0F12AF04,    /* 70003E48 */
+	0x0F12527A,    /* 70003E4A */
+	0x0F124A7D,    /* 70003E4C */
+	0x0F12188A,    /* 70003E4E */
+	0x0F128897,    /* 70003E50 */
+	0x0F1283B7,    /* 70003E52 */
+	0x0F1233A0,    /* 70003E54 */
+	0x0F12891F,    /* 70003E56 */
+	0x0F12AE01,    /* 70003E58 */
+	0x0F125277,    /* 70003E5A */
+	0x0F128A11,    /* 70003E5C */
+	0x0F128119,    /* 70003E5E */
+	0x0F121C40,    /* 70003E60 */
+	0x0F120400,    /* 70003E62 */
+	0x0F120C00,    /* 70003E64 */
+	0x0F122806,    /* 70003E66 */
+	0x0F12D3E9,    /* 70003E68 */
+	0x0F12F000,    /* 70003E6A */
+	0x0F12F9BF,    /* 70003E6C */
+	0x0F12F000,    /* 70003E6E */
+	0x0F12F9C5,    /* 70003E70 */
+	0x0F124F79,    /* 70003E72 */
+	0x0F1237A8,    /* 70003E74 */
+	0x0F122800,    /* 70003E76 */
+	0x0F12D10A,    /* 70003E78 */
+	0x0F121FE0,    /* 70003E7A */
+	0x0F1238FD,    /* 70003E7C */
+	0x0F12D001,    /* 70003E7E */
+	0x0F121CC0,    /* 70003E80 */
+	0x0F12D105,    /* 70003E82 */
+	0x0F124874,    /* 70003E84 */
+	0x0F128829,    /* 70003E86 */
+	0x0F123818,    /* 70003E88 */
+	0x0F126840,    /* 70003E8A */
+	0x0F124348,    /* 70003E8C */
+	0x0F126078,    /* 70003E8E */
+	0x0F124972,    /* 70003E90 */
+	0x0F126878,    /* 70003E92 */
+	0x0F126B89,    /* 70003E94 */
+	0x0F124288,    /* 70003E96 */
+	0x0F12D300,    /* 70003E98 */
+	0x0F120008,    /* 70003E9A */
+	0x0F126078,    /* 70003E9C */
+	0x0F122000,    /* 70003E9E */
+	0x0F120041,    /* 70003EA0 */
+	0x0F12AA04,    /* 70003EA2 */
+	0x0F125A53,    /* 70003EA4 */
+	0x0F12194A,    /* 70003EA6 */
+	0x0F12269C,    /* 70003EA8 */
+	0x0F1252B3,    /* 70003EAA */
+	0x0F12AB01,    /* 70003EAC */
+	0x0F125A59,    /* 70003EAE */
+	0x0F1232A0,    /* 70003EB0 */
+	0x0F128111,    /* 70003EB2 */
+	0x0F121C40,    /* 70003EB4 */
+	0x0F120400,    /* 70003EB6 */
+	0x0F120C00,    /* 70003EB8 */
+	0x0F122806,    /* 70003EBA */
+	0x0F12D3F0,    /* 70003EBC */
+	0x0F124965,    /* 70003EBE */
+	0x0F129809,    /* 70003EC0 */
+	0x0F128208,    /* 70003EC2 */
+	0x0F129808,    /* 70003EC4 */
+	0x0F128028,    /* 70003EC6 */
+	0x0F129807,    /* 70003EC8 */
+	0x0F1280E8,    /* 70003ECA */
+	0x0F121FE0,    /* 70003ECC */
+	0x0F1238FD,    /* 70003ECE */
+	0x0F12D13B,    /* 70003ED0 */
+	0x0F124D64,    /* 70003ED2 */
+	0x0F1289E8,    /* 70003ED4 */
+	0x0F121FC1,    /* 70003ED6 */
+	0x0F1239FF,    /* 70003ED8 */
+	0x0F12D136,    /* 70003EDA */
+	0x0F124C5F,    /* 70003EDC */
+	0x0F128AE0,    /* 70003EDE */
+	0x0F12F000,    /* 70003EE0 */
+	0x0F12F994,    /* 70003EE2 */
+	0x0F120006,    /* 70003EE4 */
+	0x0F128B20,    /* 70003EE6 */
+	0x0F12F000,    /* 70003EE8 */
+	0x0F12F998,    /* 70003EEA */
+	0x0F129000,    /* 70003EEC */
+	0x0F126AA1,    /* 70003EEE */
+	0x0F126878,    /* 70003EF0 */
+	0x0F121809,    /* 70003EF2 */
+	0x0F120200,    /* 70003EF4 */
+	0x0F12F000,    /* 70003EF6 */
+	0x0F12F96B,    /* 70003EF8 */
+	0x0F120400,    /* 70003EFA */
+	0x0F120C00,    /* 70003EFC */
+	0x0F120022,    /* 70003EFE */
+	0x0F123246,    /* 70003F00 */
+	0x0F120011,    /* 70003F02 */
+	0x0F12310A,    /* 70003F04 */
+	0x0F122305,    /* 70003F06 */
+	0x0F12F000,    /* 70003F08 */
+	0x0F12F968,    /* 70003F0A */
+	0x0F1266E8,    /* 70003F0C */
+	0x0F126B23,    /* 70003F0E */
+	0x0F120002,    /* 70003F10 */
+	0x0F120031,    /* 70003F12 */
+	0x0F120018,    /* 70003F14 */
+	0x0F12F000,    /* 70003F16 */
+	0x0F12F989,    /* 70003F18 */
+	0x0F12466B,    /* 70003F1A */
+	0x0F128518,    /* 70003F1C */
+	0x0F126EEA,    /* 70003F1E */
+	0x0F126B60,    /* 70003F20 */
+	0x0F129900,    /* 70003F22 */
+	0x0F12F000,    /* 70003F24 */
+	0x0F12F982,    /* 70003F26 */
+	0x0F12466B,    /* 70003F28 */
+	0x0F128558,    /* 70003F2A */
+	0x0F120029,    /* 70003F2C */
+	0x0F12980A,    /* 70003F2E */
+	0x0F123170,    /* 70003F30 */
+	0x0F12F000,    /* 70003F32 */
+	0x0F12F983,    /* 70003F34 */
+	0x0F120028,    /* 70003F36 */
+	0x0F123060,    /* 70003F38 */
+	0x0F128A02,    /* 70003F3A */
+	0x0F124946,    /* 70003F3C */
+	0x0F123128,    /* 70003F3E */
+	0x0F12808A,    /* 70003F40 */
+	0x0F128A42,    /* 70003F42 */
+	0x0F1280CA,    /* 70003F44 */
+	0x0F128A80,    /* 70003F46 */
+	0x0F128108,    /* 70003F48 */
+	0x0F12B00B,    /* 70003F4A */
+	0x0F12BCF0,    /* 70003F4C */
+	0x0F12BC08,    /* 70003F4E */
+	0x0F124718,    /* 70003F50 */
+	0x0F12B570,    /* 70003F52 */
+	0x0F122400,    /* 70003F54 */
+	0x0F124D46,    /* 70003F56 */
+	0x0F124846,    /* 70003F58 */
+	0x0F128881,    /* 70003F5A */
+	0x0F124846,    /* 70003F5C */
+	0x0F128041,    /* 70003F5E */
+	0x0F122101,    /* 70003F60 */
+	0x0F128001,    /* 70003F62 */
+	0x0F12F000,    /* 70003F64 */
+	0x0F12F972,    /* 70003F66 */
+	0x0F124842,    /* 70003F68 */
+	0x0F123820,    /* 70003F6A */
+	0x0F128BC0,    /* 70003F6C */
+	0x0F12F000,    /* 70003F6E */
+	0x0F12F975,    /* 70003F70 */
+	0x0F124B42,    /* 70003F72 */
+	0x0F12220D,    /* 70003F74 */
+	0x0F120712,    /* 70003F76 */
+	0x0F1218A8,    /* 70003F78 */
+	0x0F128806,    /* 70003F7A */
+	0x0F1200E1,    /* 70003F7C */
+	0x0F1218C9,    /* 70003F7E */
+	0x0F1281CE,    /* 70003F80 */
+	0x0F128846,    /* 70003F82 */
+	0x0F12818E,    /* 70003F84 */
+	0x0F128886,    /* 70003F86 */
+	0x0F12824E,    /* 70003F88 */
+	0x0F1288C0,    /* 70003F8A */
+	0x0F128208,    /* 70003F8C */
+	0x0F123508,    /* 70003F8E */
+	0x0F12042D,    /* 70003F90 */
+	0x0F120C2D,    /* 70003F92 */
+	0x0F121C64,    /* 70003F94 */
+	0x0F120424,    /* 70003F96 */
+	0x0F120C24,    /* 70003F98 */
+	0x0F122C07,    /* 70003F9A */
+	0x0F12D3EC,    /* 70003F9C */
+	0x0F12E658,    /* 70003F9E */
+	0x0F12B510,    /* 70003FA0 */
+	0x0F124834,    /* 70003FA2 */
+	0x0F124C34,    /* 70003FA4 */
+	0x0F1288C0,    /* 70003FA6 */
+	0x0F128060,    /* 70003FA8 */
+	0x0F122001,    /* 70003FAA */
+	0x0F128020,    /* 70003FAC */
+	0x0F124831,    /* 70003FAE */
+	0x0F123820,    /* 70003FB0 */
+	0x0F128BC0,    /* 70003FB2 */
+	0x0F12F000,    /* 70003FB4 */
+	0x0F12F952,    /* 70003FB6 */
+	0x0F1288E0,    /* 70003FB8 */
+	0x0F124A31,    /* 70003FBA */
+	0x0F122800,    /* 70003FBC */
+	0x0F12D003,    /* 70003FBE */
+	0x0F124930,    /* 70003FC0 */
+	0x0F128849,    /* 70003FC2 */
+	0x0F122900,    /* 70003FC4 */
+	0x0F12D009,    /* 70003FC6 */
+	0x0F122001,    /* 70003FC8 */
+	0x0F1203C0,    /* 70003FCA */
+	0x0F128050,    /* 70003FCC */
+	0x0F1280D0,    /* 70003FCE */
+	0x0F122000,    /* 70003FD0 */
+	0x0F128090,    /* 70003FD2 */
+	0x0F128110,    /* 70003FD4 */
+	0x0F12BC10,    /* 70003FD6 */
+	0x0F12BC08,    /* 70003FD8 */
+	0x0F124718,    /* 70003FDA */
+	0x0F128050,    /* 70003FDC */
+	0x0F128920,    /* 70003FDE */
+	0x0F1280D0,    /* 70003FE0 */
+	0x0F128960,    /* 70003FE2 */
+	0x0F120400,    /* 70003FE4 */
+	0x0F121400,    /* 70003FE6 */
+	0x0F128090,    /* 70003FE8 */
+	0x0F1289A1,    /* 70003FEA */
+	0x0F120409,    /* 70003FEC */
+	0x0F121409,    /* 70003FEE */
+	0x0F128111,    /* 70003FF0 */
+	0x0F1289E3,    /* 70003FF2 */
+	0x0F128A24,    /* 70003FF4 */
+	0x0F122B00,    /* 70003FF6 */
+	0x0F12D104,    /* 70003FF8 */
+	0x0F1217C3,    /* 70003FFA */
+	0x0F120F5B,    /* 70003FFC */
+	0x0F121818,    /* 70003FFE */
+	0x0F1210C0,    /* 70004000 */
+	0x0F128090,    /* 70004002 */
+	0x0F122C00,    /* 70004004 */
+	0x0F12D1E6,    /* 70004006 */
+	0x0F1217C8,    /* 70004008 */
+	0x0F120F40,    /* 7000400A */
+	0x0F121840,    /* 7000400C */
+	0x0F1210C0,    /* 7000400E */
+	0x0F128110,    /* 70004010 */
+	0x0F12E7E0,    /* 70004012 */
+	0x0F12B510,    /* 70004014 */
+	0x0F12000C,    /* 70004016 */
+	0x0F124919,    /* 70004018 */
+	0x0F122204,    /* 7000401A */
+	0x0F126820,    /* 7000401C */
+	0x0F125E8A,    /* 7000401E */
+	0x0F120140,    /* 70004020 */
+	0x0F121A80,    /* 70004022 */
+	0x0F120280,    /* 70004024 */
+	0x0F128849,    /* 70004026 */
+	0x0F12F000,    /* 70004028 */
+	0x0F12F920,    /* 7000402A */
+	0x0F126020,    /* 7000402C */
+	0x0F12E7D2,    /* 7000402E */
+	0x0F1238D4,    /* 70004030 */
+	0x0F127000,    /* 70004032 */
+	0x0F1217D0,    /* 70004034 */
+	0x0F127000,    /* 70004036 */
+	0x0F125000,    /* 70004038 */
+	0x0F12D000,    /* 7000403A */
+	0x0F121100,    /* 7000403C */
+	0x0F12D000,    /* 7000403E */
+	0x0F12171A,    /* 70004040 */
+	0x0F127000,    /* 70004042 */
+	0x0F124780,    /* 70004044 */
+	0x0F127000,    /* 70004046 */
+	0x0F122FCA,    /* 70004048 */
+	0x0F127000,    /* 7000404A */
+	0x0F122FC5,    /* 7000404C */
+	0x0F127000,    /* 7000404E */
+	0x0F122FC6,    /* 70004050 */
+	0x0F127000,    /* 70004052 */
+	0x0F122ED8,    /* 70004054 */
+	0x0F127000,    /* 70004056 */
+	0x0F122BD0,    /* 70004058 */
+	0x0F127000,    /* 7000405A */
+	0x0F1217E0,    /* 7000405C */
+	0x0F127000,    /* 7000405E */
+	0x0F122DE8,    /* 70004060 */
+	0x0F127000,    /* 70004062 */
+	0x0F1237E0,    /* 70004064 */
+	0x0F127000,    /* 70004066 */
+	0x0F12210C,    /* 70004068 */
+	0x0F127000,    /* 7000406A */
+	0x0F121484,    /* 7000406C */
+	0x0F127000,    /* 7000406E */
+	0x0F12A006,    /* 70004070 */
+	0x0F120000,    /* 70004072 */
+	0x0F120724,    /* 70004074 */
+	0x0F127000,    /* 70004076 */
+	0x0F12A000,    /* 70004078 */
+	0x0F12D000,    /* 7000407A */
+	0x0F122270,    /* 7000407C */
+	0x0F127000,    /* 7000407E */
+	0x0F122558,    /* 70004080 */
+	0x0F127000,    /* 70004082 */
+	0x0F12146C,    /* 70004084 */
+	0x0F127000,    /* 70004086 */
+	0x0F12B510,    /* 70004088 */
+	0x0F12000C,    /* 7000408A */
+	0x0F12492E,    /* 7000408C */
+	0x0F122208,    /* 7000408E */
+	0x0F126820,    /* 70004090 */
+	0x0F125E8A,    /* 70004092 */
+	0x0F120140,    /* 70004094 */
+	0x0F121A80,    /* 70004096 */
+	0x0F120280,    /* 70004098 */
+	0x0F1288C9,    /* 7000409A */
+	0x0F12F000,    /* 7000409C */
+	0x0F12F8E6,    /* 7000409E */
+	0x0F126020,    /* 700040A0 */
+	0x0F12E798,    /* 700040A2 */
+	0x0F12B5FE,    /* 700040A4 */
+	0x0F12000C,    /* 700040A6 */
+	0x0F126825,    /* 700040A8 */
+	0x0F126866,    /* 700040AA */
+	0x0F1268A0,    /* 700040AC */
+	0x0F129001,    /* 700040AE */
+	0x0F1268E7,    /* 700040B0 */
+	0x0F121BA8,    /* 700040B2 */
+	0x0F1242B5,    /* 700040B4 */
+	0x0F12DA00,    /* 700040B6 */
+	0x0F121B70,    /* 700040B8 */
+	0x0F129000,    /* 700040BA */
+	0x0F124922,    /* 700040BC */
+	0x0F124823,    /* 700040BE */
+	0x0F12884A,    /* 700040C0 */
+	0x0F128843,    /* 700040C2 */
+	0x0F12435A,    /* 700040C4 */
+	0x0F122304,    /* 700040C6 */
+	0x0F125ECB,    /* 700040C8 */
+	0x0F120A92,    /* 700040CA */
+	0x0F1218D2,    /* 700040CC */
+	0x0F1202D2,    /* 700040CE */
+	0x0F120C12,    /* 700040D0 */
+	0x0F1288CB,    /* 700040D2 */
+	0x0F128880,    /* 700040D4 */
+	0x0F124343,    /* 700040D6 */
+	0x0F120A98,    /* 700040D8 */
+	0x0F122308,    /* 700040DA */
+	0x0F125ECB,    /* 700040DC */
+	0x0F1218C0,    /* 700040DE */
+	0x0F1202C0,    /* 700040E0 */
+	0x0F120C00,    /* 700040E2 */
+	0x0F120411,    /* 700040E4 */
+	0x0F120400,    /* 700040E6 */
+	0x0F121409,    /* 700040E8 */
+	0x0F121400,    /* 700040EA */
+	0x0F121A08,    /* 700040EC */
+	0x0F124917,    /* 700040EE */
+	0x0F1239E0,    /* 700040F0 */
+	0x0F126148,    /* 700040F2 */
+	0x0F129801,    /* 700040F4 */
+	0x0F123040,    /* 700040F6 */
+	0x0F127880,    /* 700040F8 */
+	0x0F122800,    /* 700040FA */
+	0x0F12D103,    /* 700040FC */
+	0x0F129801,    /* 700040FE */
+	0x0F120029,    /* 70004100 */
+	0x0F12F000,    /* 70004102 */
+	0x0F12F8B9,    /* 70004104 */
+	0x0F128839,    /* 70004106 */
+	0x0F129800,    /* 70004108 */
+	0x0F124281,    /* 7000410A */
+	0x0F12D814,    /* 7000410C */
+	0x0F128879,    /* 7000410E */
+	0x0F129800,    /* 70004110 */
+	0x0F124281,    /* 70004112 */
+	0x0F12D20C,    /* 70004114 */
+	0x0F129801,    /* 70004116 */
+	0x0F120029,    /* 70004118 */
+	0x0F12F000,    /* 7000411A */
+	0x0F12F8B5,    /* 7000411C */
+	0x0F129801,    /* 7000411E */
+	0x0F120029,    /* 70004120 */
+	0x0F12F000,    /* 70004122 */
+	0x0F12F8B1,    /* 70004124 */
+	0x0F129801,    /* 70004126 */
+	0x0F120029,    /* 70004128 */
+	0x0F12F000,    /* 7000412A */
+	0x0F12F8AD,    /* 7000412C */
+	0x0F12E003,    /* 7000412E */
+	0x0F129801,    /* 70004130 */
+	0x0F120029,    /* 70004132 */
+	0x0F12F000,    /* 70004134 */
+	0x0F12F8A8,    /* 70004136 */
+	0x0F129801,    /* 70004138 */
+	0x0F120032,    /* 7000413A */
+	0x0F120039,    /* 7000413C */
+	0x0F12F000,    /* 7000413E */
+	0x0F12F8AB,    /* 70004140 */
+	0x0F126020,    /* 70004142 */
+	0x0F12E5D0,    /* 70004144 */
+	0x0F120000,    /* 70004146 */
+	0x0F122558,    /* 70004148 */
+	0x0F127000,    /* 7000414A */
+	0x0F122AB8,    /* 7000414C */
+	0x0F127000,    /* 7000414E */
+	0x0F124778,    /* 70004150 */
+	0x0F1246C0,    /* 70004152 */
+	0x0F12C000,    /* 70004154 */
+	0x0F12E59F,    /* 70004156 */
+	0x0F12FF1C,    /* 70004158 */
+	0x0F12E12F,    /* 7000415A */
+	0x0F121789,    /* 7000415C */
+	0x0F120001,    /* 7000415E */
+	0x0F124778,    /* 70004160 */
+	0x0F1246C0,    /* 70004162 */
+	0x0F12C000,    /* 70004164 */
+	0x0F12E59F,    /* 70004166 */
+	0x0F12FF1C,    /* 70004168 */
+	0x0F12E12F,    /* 7000416A */
+	0x0F1216F1,    /* 7000416C */
+	0x0F120001,    /* 7000416E */
+	0x0F124778,    /* 70004170 */
+	0x0F1246C0,    /* 70004172 */
+	0x0F12C000,    /* 70004174 */
+	0x0F12E59F,    /* 70004176 */
+	0x0F12FF1C,    /* 70004178 */
+	0x0F12E12F,    /* 7000417A */
+	0x0F12C3B1,    /* 7000417C */
+	0x0F120000,    /* 7000417E */
+	0x0F124778,    /* 70004180 */
+	0x0F1246C0,    /* 70004182 */
+	0x0F12C000,    /* 70004184 */
+	0x0F12E59F,    /* 70004186 */
+	0x0F12FF1C,    /* 70004188 */
+	0x0F12E12F,    /* 7000418A */
+	0x0F12C36D,    /* 7000418C */
+	0x0F120000,    /* 7000418E */
+	0x0F124778,    /* 70004190 */
+	0x0F1246C0,    /* 70004192 */
+	0x0F12C000,    /* 70004194 */
+	0x0F12E59F,    /* 70004196 */
+	0x0F12FF1C,    /* 70004198 */
+	0x0F12E12F,    /* 7000419A */
+	0x0F12F6D7,    /* 7000419C */
+	0x0F120000,    /* 7000419E */
+	0x0F124778,    /* 700041A0 */
+	0x0F1246C0,    /* 700041A2 */
+	0x0F12C000,    /* 700041A4 */
+	0x0F12E59F,    /* 700041A6 */
+	0x0F12FF1C,    /* 700041A8 */
+	0x0F12E12F,    /* 700041AA */
+	0x0F12B49D,    /* 700041AC */
+	0x0F120000,    /* 700041AE */
+	0x0F124778,    /* 700041B0 */
+	0x0F1246C0,    /* 700041B2 */
+	0x0F12C000,    /* 700041B4 */
+	0x0F12E59F,    /* 700041B6 */
+	0x0F12FF1C,    /* 700041B8 */
+	0x0F12E12F,    /* 700041BA */
+	0x0F127EDF,    /* 700041BC */
+	0x0F120000,    /* 700041BE */
+	0x0F124778,    /* 700041C0 */
+	0x0F1246C0,    /* 700041C2 */
+	0x0F12C000,    /* 700041C4 */
+	0x0F12E59F,    /* 700041C6 */
+	0x0F12FF1C,    /* 700041C8 */
+	0x0F12E12F,    /* 700041CA */
+	0x0F12448D,    /* 700041CC */
+	0x0F120000,    /* 700041CE */
+	0x0F124778,    /* 700041D0 */
+	0x0F1246C0,    /* 700041D2 */
+	0x0F12F004,    /* 700041D4 */
+	0x0F12E51F,    /* 700041D6 */
+	0x0F1229EC,    /* 700041D8 */
+	0x0F120001,    /* 700041DA */
+	0x0F124778,    /* 700041DC */
+	0x0F1246C0,    /* 700041DE */
+	0x0F12C000,    /* 700041E0 */
+	0x0F12E59F,    /* 700041E2 */
+	0x0F12FF1C,    /* 700041E4 */
+	0x0F12E12F,    /* 700041E6 */
+	0x0F122EF1,    /* 700041E8 */
+	0x0F120000,    /* 700041EA */
+	0x0F124778,    /* 700041EC */
+	0x0F1246C0,    /* 700041EE */
+	0x0F12C000,    /* 700041F0 */
+	0x0F12E59F,    /* 700041F2 */
+	0x0F12FF1C,    /* 700041F4 */
+	0x0F12E12F,    /* 700041F6 */
+	0x0F12EE03,    /* 700041F8 */
+	0x0F120000,    /* 700041FA */
+	0x0F124778,    /* 700041FC */
+	0x0F1246C0,    /* 700041FE */
+	0x0F12C000,    /* 70004200 */
+	0x0F12E59F,    /* 70004202 */
+	0x0F12FF1C,    /* 70004204 */
+	0x0F12E12F,    /* 70004206 */
+	0x0F12A58B,    /* 70004208 */
+	0x0F120000,    /* 7000420A */
+	0x0F124778,    /* 7000420C */
+	0x0F1246C0,    /* 7000420E */
+	0x0F12C000,    /* 70004210 */
+	0x0F12E59F,    /* 70004212 */
+	0x0F12FF1C,    /* 70004214 */
+	0x0F12E12F,    /* 70004216 */
+	0x0F127C49,    /* 70004218 */
+	0x0F120000,    /* 7000421A */
+	0x0F124778,    /* 7000421C */
+	0x0F1246C0,    /* 7000421E */
+	0x0F12C000,    /* 70004220 */
+	0x0F12E59F,    /* 70004222 */
+	0x0F12FF1C,    /* 70004224 */
+	0x0F12E12F,    /* 70004226 */
+	0x0F127C63,    /* 70004228 */
+	0x0F120000,    /* 7000422A */
+	0x0F124778,    /* 7000422C */
+	0x0F1246C0,    /* 7000422E */
+	0x0F12C000,    /* 70004230 */
+	0x0F12E59F,    /* 70004232 */
+	0x0F12FF1C,    /* 70004234 */
+	0x0F12E12F,    /* 70004236 */
+	0x0F122DB7,    /* 70004238 */
+	0x0F120000,    /* 7000423A */
+	0x0F124778,    /* 7000423C */
+	0x0F1246C0,    /* 7000423E */
+	0x0F12C000,    /* 70004240 */
+	0x0F12E59F,    /* 70004242 */
+	0x0F12FF1C,    /* 70004244 */
+	0x0F12E12F,    /* 70004246 */
+	0x0F12EB3D,    /* 70004248 */
+	0x0F120000,    /* 7000424A */
+	0x0F124778,    /* 7000424C */
+	0x0F1246C0,    /* 7000424E */
+	0x0F12C000,    /* 70004250 */
+	0x0F12E59F,    /* 70004252 */
+	0x0F12FF1C,    /* 70004254 */
+	0x0F12E12F,    /* 70004256 */
+	0x0F12F061,    /* 70004258 */
+	0x0F120000,    /* 7000425A */
+	0x0F124778,    /* 7000425C */
+	0x0F1246C0,    /* 7000425E */
+	0x0F12C000,    /* 70004260 */
+	0x0F12E59F,    /* 70004262 */
+	0x0F12FF1C,    /* 70004264 */
+	0x0F12E12F,    /* 70004266 */
+	0x0F12F0EF,    /* 70004268 */
+	0x0F120000,    /* 7000426A */
+	0x0F124778,    /* 7000426C */
+	0x0F1246C0,    /* 7000426E */
+	0x0F12F004,    /* 70004270 */
+	0x0F12E51F,    /* 70004272 */
+	0x0F122824,    /* 70004274 */
+	0x0F120001,    /* 70004276 */
+	0x0F124778,    /* 70004278 */
+	0x0F1246C0,    /* 7000427A */
+	0x0F12C000,    /* 7000427C */
+	0x0F12E59F,    /* 7000427E */
+	0x0F12FF1C,    /* 70004280 */
+	0x0F12E12F,    /* 70004282 */
+	0x0F128EDD,    /* 70004284 */
+	0x0F120000,    /* 70004286 */
+	0x0F124778,    /* 70004288 */
+	0x0F1246C0,    /* 7000428A */
+	0x0F12C000,    /* 7000428C */
+	0x0F12E59F,    /* 7000428E */
+	0x0F12FF1C,    /* 70004290 */
+	0x0F12E12F,    /* 70004292 */
+	0x0F128DCB,    /* 70004294 */
+	0x0F120000,    /* 70004296 */
+	0x0F124778,    /* 70004298 */
+	0x0F1246C0,    /* 7000429A */
+	0x0F12C000,    /* 7000429C */
+	0x0F12E59F,    /* 7000429E */
+	0x0F12FF1C,    /* 700042A0 */
+	0x0F12E12F,    /* 700042A2 */
+	0x0F128E17,    /* 700042A4 */
+	0x0F120000,    /* 700042A6 */
+	/* End of Patch Data(Last : 700042A6h)*/
+	/* Total Size 1968 */
+	/* Addr : 3AF8 , Size : 1966(7AEh) */
+
+
+	/*#define	TNP_USER_MBCV_CONTROL			*/
+	/*#define TNP_4EC_MBR_TUNE					*/
+	/*#define TNP_4EC_FORBIDDEN_TUNE			*/
+	/*#define TNP_AF_FINESEARCH_DRIVEBACK		*/
+	/*#define TNP_FLASH_ALG						*/
+	/*#define TNP_GAS_ALPHA_OTP					*/
+	/*#define	TNP_AWB_MODUL_COMP				*/
+
+
+	/*TNP_Regs_usCintrTh         2   70004780	*/
+	/*TNP_Regs_usFixedCintc      2   70004782	*/
+	/*TNP_Regs_FlsWeightRIn_0_   2   70004784	*/
+	/*TNP_Regs_FlsWeightRIn_1_   2   70004786	*/
+	/*TNP_Regs_FlsWeightRIn_2_   2   70004788	*/
+	/*TNP_Regs_FlsWeightRIn_3_   2   7000478A	*/
+	/*TNP_Regs_FlsWeightRIn_4_   2   7000478C	*/
+	/*TNP_Regs_FlsWeightRIn_5_   2   7000478E	*/
+	/*TNP_Regs_FlsWeightROut_0_  2   70004790	*/
+	/*TNP_Regs_FlsWeightROut_1_  2   70004792	*/
+	/*TNP_Regs_FlsWeightROut_2_  2   70004794	*/
+	/*TNP_Regs_FlsWeightROut_3_  2   70004796	*/
+	/*TNP_Regs_FlsWeightROut_4_  2   70004798	*/
+	/*TNP_Regs_FlsWeightROut_5_  2   7000479A	*/
+
+	/*TNP_Regs_FlBRIn_0_         2   7000479C	*/
+	/*TNP_Regs_FlBRIn_1_         2   7000479E	*/
+	/*TNP_Regs_FlBRIn_2_         2   700047A0	*/
+	/*TNP_Regs_FlBRInOut_0_      2   700047A2	*/
+	/*TNP_Regs_FlBRInOut_1_      2   700047A4	*/
+	/*TNP_Regs_FlBRInOut_2_      2   700047A6	*/
+
+	0x0028D000,
+	0x002A1000,
+	0x0F120001,
+
+	/* AF setting */
+	0x00287000,
+	0x002A01FC,
+	0x0F120001,	/* #REG_TC_IPRM_LedGpio	*/
+	0x002A1720,
+	0x0F120100,
+	0x002A01FE,
+	0x0F120003,
+	0x0F120000,
+	0x002A0204,
+	0x0F120061,
+	0x002A020C,
+	0x0F122F0C,
+	0x0F120190,
+	0x002A0294,
+	0x0F120100,
+	0x0F1200E3,
+	0x0F120200,
+	0x0F120238,
+	0x0F1201C6,
+	0x0F120166,
+	0x0F120074,
+	0x0F120132,
+	0x0F120001,
+
+	0x002A070E,
+	0x0F1200C0,
+	0x002A071E,
+	0x0F120001,
+	0x002A163C,
+	0x0F120000,
+	0x002A1648,
+	0x0F129002,
+	0x002A1652,
+	0x0F120002,
+	0x0F120000,
+	0x002A15E0,
+	0x0F120902,
+
+	0x002A164C,
+	0x0F120003,
+	0x002A163E,
+	0x0F1200D5,
+	0x0F120098,
+	0x002A15D4,
+	0x0F120000,
+	0x0F12D000,
+	0x002A169A,
+	0x0F12FF95,
+	0x002A166A,
+	0x0F120280,
+	0x002A1676,
+	0x0F1203A0,
+	0x0F120320,
+	0x002A16BC,
+	0x0F120030,
+	0x002A16E0,
+	0x0F120060,
+	0x002A16D4,
+	0x0F120010,
+	0x002A1656,
+	0x0F120000,
+	0x002A15E6,
+	0x0F12003C,
+
+	0x0F120018,	/*#af_pos_usTableLastInd*/
+	0x0F12002A,
+	0x0F120030,
+	0x0F120036,
+	0x0F12003C,
+	0x0F120042,
+	0x0F120048,
+	0x0F12004E,
+	0x0F120054,
+	0x0F12005A,
+	0x0F120060,
+	0x0F120066,
+	0x0F12006C,
+	0x0F120072,
+	0x0F120078,
+	0x0F12007E,
+	0x0F120084,
+	0x0F12008A,
+	0x0F120090,
+	0x0F120096,
+	0x0F12009C,
+	0x0F1200A2,
+	0x0F1200A8,
+	0x0F1200AE,
+	0x0F1200B4,
+	0x0F1200BA,	/*#af_pos_usTable_24_*/
+
+	0x002A1722,
+	0x0F128000,
+	0x0F120006,
+	0x0F123FF0,
+	0x0F1203E8,
+	0x0F120000,
+	0x0F120020,
+	0x0F120010,
+	0x0F120008,
+	0x0F120040,
+	0x0F120080,
+	0x0F1200C0,
+	0x0F1200E0,
+
+	0x002A028C,
+	0x0F120003,	/*#REG_TC_AF_AfCmd*/
+
+	/* GAS TBL setting */
+	0x002A08B4,
+	0x0F120001,	/*#wbt_bUseOutdoorASH*/
+
+	/*TVAR_ash_AwbAshCord, Refer Mon_AWB_RotGain*/
+	0x002A08BC,
+	0x0F1200C0,	/*#TVAR_ash_AwbAshCord_0_ 2300K*/
+	0x0F1200DF,	/*#TVAR_ash_AwbAshCord_1_ 2750K*/
+	0x0F120100,	/*#TVAR_ash_AwbAshCord_2_ 3300K*/
+	0x0F120125,	/*#TVAR_ash_AwbAshCord_3_ 4150K*/
+	0x0F12015F,	/*#TVAR_ash_AwbAshCord_4_ 5250K*/
+	0x0F12017C,	/*#TVAR_ash_AwbAshCord_5_ 6400K*/
+	0x0F120194,	/*#TVAR_ash_AwbAshCord_6_ 7500K*/
+
+
+	0x002A08F6,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x0F124500,
+	0x0F124000,
+	0x0F124000,
+	0x0F124000,
+
+	0x002A08F4,
+	0x0F120001,	/*#ash_bUseGasAlpha*/
+
+	/* AE START */
+
+	/*AE WEIGHT */
+	0x002A1492,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120202,
+	0x0F120202,
+	0x0F120102,
+
+	0x002A1484,
+	0x0F12003C,	/*#TVAR_ae_BrAve*/
+	0x002A148A,
+	0x0F12000F,	/*#ae_StatMode*/
+	0x002A058C,
+	0x0F123520,
+	0x0F120000,	/*#lt_uMaxExp1*/
+	0x0F12C350,
+	0x0F120000,	/*#lt_uMaxExp2*/
+	0x0F123520,
+	0x0F120000,	/*#lt_uCapMaxExp1*/
+	0x0F12C350,
+	0x0F120000,	/*#lt_uCapMaxExp2*/
+	0x0F120470,	/*#lt_uMaxAnGain1*/
+	0x0F120C00,	/*#lt_uMaxAnGain2*/
+	0x0F120100,	/*#lt_uMaxDigGain*/
+	0x0F121000,	/*#lt_uMaxTotGain*/
+
+	0x002A0544,
+	0x0F120111,	/*#lt_uLimitHigh*/
+	0x0F1200EF,	/*#lt_uLimitLow*/
+
+	0x002A0F2A,
+	0x0F120001,	/*#AFC_Default60Hz*/
+	0x002A0F30,
+	0x0F120002,	/*#AFC_D_ConvAccelerPower*/
+
+	0x002A0608,
+	0x0F120001,	/*#lt_ExpGain_uSubsamplingmode*/
+	0x0F120001,	/*#lt_ExpGain_uNonSubsampling*/
+	0x0F120800,	/*#lt_ExpGain_ExpCurveGainMaxStr*/
+	0x0F120100,	/*#lt_ExpGain_ExpCurveGainMaxStr_0__uMaxDigGain*/
+	0x0F120001,
+	0x0F120000,	/*#lt_ExpGain_ExpCurveGainMaxStr_0__ulExpIn_0_*/
+	0x0F120A3C,
+	0x0F120000,
+	0x0F120D04,
+	0x0F120000,
+	0x0F124008,
+	0x0F120000,
+	0x0F127000,
+	0x0F120000,
+	0x0F129C00,
+	0x0F120000,
+	0x0F12AD00,
+	0x0F120001,
+	0x0F12F1D4,
+	0x0F120002,
+	0x0F12DC00,
+	0x0F120005,
+	0x0F12DC00,
+	0x0F120005,
+	0x0F120001,
+	0x0F120000,	/*#lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_0_*/
+	0x0F120A3C,
+	0x0F120000,
+	0x0F120D05,
+	0x0F120000,
+	0x0F123408,
+	0x0F120000,
+	0x0F123408,
+	0x0F120000,
+	0x0F126810,
+	0x0F120000,
+	0x0F128214,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F120650,	/*#lt_ExpGain_ExpCurveGainMaxStr_1_*/
+	0x0F120100,	/*#lt_ExpGain_ExpCurveGainMaxStr_1__uMaxDigGain*/
+
+	0x002A06B8,
+	0x0F12452C,
+	0x0F120004,	/*#lt_uMaxLei*/
+
+	0x002A05D0,
+	0x0F120000,	/*#lt_mbr_Peak_behind*/
+
+	/* AWB init Start point */
+	0x002A145E,
+	0x0F120688, /* 0400 */
+	0x0F1203C8, /* 0428 */
+	0x0F120658, /* 9B3  */
+
+	/* AWB Init */
+	/*White Locus */
+	0x002A11F0,
+	0x0F12012C,	/*#awbb_IntcR*/
+	0x0F120121,	/*#awbb_IntcB*/
+
+	/* IndoorZone*/
+	0x002A101C,
+	0x0F12039A,
+	0x0F1203E8,
+	0x0F12033C,
+	0x0F1203AE,
+	0x0F1202DE,
+	0x0F120376,
+	0x0F12029C,
+	0x0F12033C,
+	0x0F12027E,
+	0x0F120312,
+	0x0F12025E,
+	0x0F1202F6,
+	0x0F12023E,
+	0x0F1202DA,
+	0x0F12022A,
+	0x0F1202BC,
+	0x0F120214,
+	0x0F1202A2,
+	0x0F1201FE,
+	0x0F120292,
+	0x0F1201F0,
+	0x0F120284,
+	0x0F1201E0,
+	0x0F120276,
+	0x0F1201D2,
+	0x0F120266,
+	0x0F1201C4,
+	0x0F120258,
+	0x0F1201D8,
+	0x0F120216,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	0x0F120005,	/*#awbb_IndoorGrZones_m_GridStep*/
+	0x002A1070,
+	0x0F12000F,	/*#awbb_IndoorGrZones_ZInfo_m_GridSz*/
+	0x002A1074,
+	0x0F12013C,	/*#awbb_IndoorGrZones_m_Boffs*/
+
+	/*Outdoor Zone*/
+	0x002A1078,
+	0x0F120260,
+	0x0F1202A2,
+	0x0F120256,
+	0x0F1202BA,
+	0x0F12024C,
+	0x0F1202C0,
+	0x0F120240,
+	0x0F1202C4,
+	0x0F120236,
+	0x0F1202B6,
+	0x0F12022A,
+	0x0F1202A8,
+	0x0F120228,
+	0x0F1202A0,
+	0x0F120224,
+	0x0F120298,
+	0x0F12022C,
+	0x0F120292,
+	0x0F120232,
+	0x0F12028A,
+	0x0F120250,
+	0x0F120282,
+	0x0F120000,
+	0x0F120000,
+
+	0x0F120004,	/*#awbb_OutdoorGrZones_m_GridStep*/
+	0x002A10AC,
+	0x0F12000B,	/*#awbb_OutdoorGrZones_ZInfo_m_GridSz*/
+	0x002A10B0,
+	0x0F1201DE,	/*#awbb_OutdoorGrZones_m_Boffs*/
+
+	/*LowBR Zone*/
+	0x002A10B4,
+	0x0F120350,
+	0x0F120422,
+	0x0F1202C4,
+	0x0F120452,
+	0x0F120278,
+	0x0F12041C,
+	0x0F120230,
+	0x0F1203EE,
+	0x0F1201F0,
+	0x0F120392,
+	0x0F1201C0,
+	0x0F120340,
+	0x0F120194,
+	0x0F120302,
+	0x0F12016E,
+	0x0F1202C2,
+	0x0F120148,
+	0x0F120286,
+	0x0F12018A,
+	0x0F120242,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+
+	0x0F120006,	/*#awbb_LowBrGrZones_m_GridStep*/
+	0x002A10E8,
+	0x0F12000A,	/*#awbb_LowBrGrZones_ZInfo_m_GridSz*/
+	0x002A10EC,
+	0x0F120106,	/*#awbb_LowBrGrZones_m_Boffs*/
+
+	/*LowTemp Zone*/
+	0x002A10F0,
+	0x0F120380,
+	0x0F120000,	/*#awbb_CrclLowT_R_c*/
+	0x0F120168,
+	0x0F120000,	/*#awbb_CrclLowT_B_c*/
+	0x0F122D90,
+	0x0F120000,	/*#awbb_CrclLowT_Rad_c*/
+
+	/*AWB Convergence Speed*/
+	0x002A1464,
+	0x0F120008,
+	0x0F120190,
+	0x0F1200A0,
+
+	0x002A1228,
+	0x0F1200C0,
+	0x002A122C,
+	0x0F120010,
+	0x002A122A,
+	0x0F120010,
+
+	0x002A120A,
+	0x0F1205D5,	/*#awbb_MvEq_RBthresh*/
+	0x002A120E,
+	0x0F120000,
+
+	0x0F120771,
+	0x0F1203A4,
+	0x0F120036,
+	0x0F12002A,
+
+	0x002A1278,
+	0x0F12FEF7,
+	0x0F120021,
+	0x0F120E74,
+	0x0F120E74,
+	0x0F12018F,
+	0x0F120096,
+	0x0F12000E,
+	0x002A1224,
+	0x0F120032,
+	0x0F12001E,
+	0x0F1200C0,
+	0x0F120010,
+	0x0F120002, /*awbb_YThreshLow_Low */
+	0x002A2BA4,
+	0x0F120006,	/*#Mon_AWB_ByPassMode*/
+
+	0x002A146C,
+	0x0F120002,	/*#awbb_GridEnable*/
+
+	/*Grid*/
+	0x002A1434,
+	0x0F120300,	/* awbb_GridConst_1			*/
+	0x0F12036E,	/* awbb_GridConst_1_1_  */
+	0x0F1203C2,	/* awbb_GridConst_1_2_  */
+	0x0F121074,	/* awbb_GridConst_2     */
+	0x0F1210C2,	/* awbb_GridConst_2_1_  */
+	0x0F121104,	/* awbb_GridConst_2_2_  */
+	0x0F121142,	/* awbb_GridConst_2_3_  */
+	0x0F1211BB,	/* awbb_GridConst_2_4_  */
+	0x0F12123B,	/* awbb_GridConst_2_5_  */
+	0x0F1200AB,	/* awbb_GridCoeff_R_1   */
+	0x0F1200BF,	/* awbb_GridCoeff_B_1   */
+	0x0F1200D2,	/* awbb_GridCoeff_R_2   */
+	0x0F120093,	/* awbb_GridCoeff_B_2   */
+
+	/*Indoor Grid Offset*/
+	0x002A13A4,
+	0x0F120000,
+	0x0F12FFD0,
+	0x0F12FFD0,
+	0x0F120000,
+	0x0F120008,
+	0x0F120008,
+	0x0F120000,
+	0x0F12FFD0,
+	0x0F12FFD0,
+	0x0F120000,
+	0x0F120008,
+	0x0F120008,
+	0x0F120000,
+	0x0F12FFD0,
+	0x0F12FFD0,
+	0x0F120000,
+	0x0F120008,
+	0x0F120008,
+	0x0F12FFE0,
+	0x0F12FFE0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFB0,
+	0x0F12FFB0,
+	0x0F12FFE0,
+	0x0F12FFE0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFB0,
+	0x0F12FFB0,
+	0x0F12FFE0,
+	0x0F12FFE0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFB0,
+	0x0F12FFB0,
+
+	/*Outdoor Grid Offset*/
+	0x0F12FFB8,
+	0x0F12FFD8,
+	0x0F12FFD8,
+	0x0F12FFD8,
+	0x0F120000,
+	0x0F120000,
+	0x0F12FFB8,
+	0x0F12FFD8,
+	0x0F12FFD8,
+	0x0F12FFD8,
+	0x0F120000,
+	0x0F120000,
+	0x0F12FFB8,
+	0x0F12FFD8,
+	0x0F12FFD8,
+	0x0F12FFD8,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F12FFD0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F120000,
+	0x0F12FFD0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F120000,
+	0x0F12FFD0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+	0x0F12FFC0,
+
+	0x002A1208,
+	0x0F120020,
+
+	0x002A144E,
+	0x0F120000,	/*#awbb_RGainOff*/
+	0x0F120000,	/*#awbb_BGainOff*/
+	0x0F120000,	/*#awbb_GGainOff*/
+
+	/*RGB Indoor Gamma*/
+	0x002A0734,
+	0x0F120001,
+	0x0F120007,
+	0x0F120010,
+	0x0F120028,
+	0x0F120062,
+	0x0F1200D3,
+	0x0F120130,
+	0x0F120158,
+	0x0F12017D,
+	0x0F1201BE,
+	0x0F1201F8,
+	0x0F12022C,
+	0x0F12025B,
+	0x0F1202AA,
+	0x0F1202EC,
+	0x0F12034E,
+	0x0F120396,
+	0x0F1203C6,
+	0x0F1203E9,
+	0x0F1203F9,
+	0x0F120001,
+	0x0F120007,
+	0x0F120010,
+	0x0F120028,
+	0x0F120062,
+	0x0F1200D3,
+	0x0F120130,
+	0x0F120158,
+	0x0F12017D,
+	0x0F1201BE,
+	0x0F1201F8,
+	0x0F12022C,
+	0x0F12025B,
+	0x0F1202AA,
+	0x0F1202EC,
+	0x0F12034E,
+	0x0F120396,
+	0x0F1203C6,
+	0x0F1203E9,
+	0x0F1203F9,
+	0x0F120001,
+	0x0F120007,
+	0x0F120010,
+	0x0F120028,
+	0x0F120062,
+	0x0F1200D3,
+	0x0F120130,
+	0x0F120158,
+	0x0F12017D,
+	0x0F1201BE,
+	0x0F1201F8,
+	0x0F12022C,
+	0x0F12025B,
+	0x0F1202AA,
+	0x0F1202EC,
+	0x0F12034E,
+	0x0F120396,
+	0x0F1203C6,
+	0x0F1203E9,
+	0x0F1203F9,
+
+	/*RGB Outdoor Gamma*/
+	0x0F120000,
+	0x0F12000F,
+	0x0F120020,
+	0x0F120043,
+	0x0F120086,
+	0x0F1200ED,
+	0x0F12013E,
+	0x0F120163,
+	0x0F120185,
+	0x0F1201BF,
+	0x0F1201F2,
+	0x0F120221,
+	0x0F12024A,
+	0x0F120294,
+	0x0F1202D0,
+	0x0F12032A,
+	0x0F12036A,
+	0x0F12039F,
+	0x0F1203CC,
+	0x0F1203F9,
+	0x0F120000,
+	0x0F12000F,
+	0x0F120020,
+	0x0F120043,
+	0x0F120086,
+	0x0F1200ED,
+	0x0F12013E,
+	0x0F120163,
+	0x0F120185,
+	0x0F1201BF,
+	0x0F1201F2,
+	0x0F120221,
+	0x0F12024A,
+	0x0F120294,
+	0x0F1202D0,
+	0x0F12032A,
+	0x0F12036A,
+	0x0F12039F,
+	0x0F1203CC,
+	0x0F1203F9,
+	0x0F120000,
+	0x0F12000F,
+	0x0F120020,
+	0x0F120043,
+	0x0F120086,
+	0x0F1200ED,
+	0x0F12013E,
+	0x0F120163,
+	0x0F120185,
+	0x0F1201BF,
+	0x0F1201F2,
+	0x0F120221,
+	0x0F12024A,
+	0x0F120294,
+	0x0F1202D0,
+	0x0F12032A,
+	0x0F12036A,
+	0x0F12039F,
+	0x0F1203CC,
+	0x0F1203F9,
+
+	/*CCM*/
+	0x002A08A6,
+	0x0F1200C0,
+	0x0F1200D0,
+	0x0F1200E0,
+	0x0F120110,
+	0x0F12017C,
+	0x0F120194,
+
+	0x0F120001,
+
+	0x002A0898,
+	0x0F124800,
+	0x0F127000,
+	0x002A08A0,
+	0x0F1248D8,
+	0x0F127000,
+
+	0x002A4800,
+	0x0F12010F,	/*hor*/
+	0x0F12FF90,
+	0x0F12FF7D,
+	0x0F12FEF1,
+	0x0F120137,
+	0x0F12FF68,
+	0x0F12FFEE,
+	0x0F12FF8A,
+	0x0F12013A,
+	0x0F12006E,
+	0x0F120089,
+	0x0F12FEFE,
+	0x0F120175,
+	0x0F12FF4A,
+	0x0F1200D6,
+	0x0F12FEFE,
+	0x0F120113,
+	0x0F1200E6,
+	0x0F12010F,	/*incaA*/
+	0x0F12FF90,
+	0x0F12FF7D,
+	0x0F12FEF1,
+	0x0F120137,
+	0x0F12FF68,
+	0x0F12FFEE,
+	0x0F12FF8A,
+	0x0F12013A,
+	0x0F12006E,
+	0x0F120089,
+	0x0F12FEFE,
+	0x0F120175,
+	0x0F12FF4A,
+	0x0F1200D6,
+	0x0F12FEFE,
+	0x0F120113,
+	0x0F1200E6,
+	0x0F12010F,	/*WW*/
+	0x0F12FF90,
+	0x0F12FF7D,
+	0x0F12FEF1,
+	0x0F120137,
+	0x0F12FF68,
+	0x0F12FFEE,
+	0x0F12FF8A,
+	0x0F12013A,
+	0x0F12006E,
+	0x0F120089,
+	0x0F12FEFE,
+	0x0F120175,
+	0x0F12FF4A,
+	0x0F1200D6,
+	0x0F12FEFE,
+	0x0F120113,
+	0x0F1200E6,
+	0x0F12017B,	/*CW*/
+	0x0F12FFB5,
+	0x0F12FFF9,
+	0x0F12FF5E,
+	0x0F12019D,
+	0x0F12FFA2,
+	0x0F12FFD9,
+	0x0F12FFCB,
+	0x0F12012C,
+	0x0F1200C9,
+	0x0F1200B0,
+	0x0F12FF2F,
+	0x0F1200CA,
+	0x0F12FF91,
+	0x0F12015E,
+	0x0F12FF47,
+	0x0F120129,
+	0x0F120125,
+	0x0F1201BC,	/*D50*/
+	0x0F12FFB5,
+	0x0F12FFF0,
+	0x0F12FF32,
+	0x0F1201E8,
+	0x0F12FF87,
+	0x0F12FFC8,
+	0x0F12FFC1,
+	0x0F12013A,
+	0x0F120112,
+	0x0F1200EE,
+	0x0F12FF99,
+	0x0F12009D,
+	0x0F12FF71,
+	0x0F120197,
+	0x0F12FF0C,
+	0x0F12013D,
+	0x0F12013D,
+	0x0F1201BC,	/*D65*/
+	0x0F12FFB5,
+	0x0F12FFF0,
+	0x0F12FF32,
+	0x0F1201E8,
+	0x0F12FF87,
+	0x0F12FFC8,
+	0x0F12FFC1,
+	0x0F12013A,
+	0x0F120112,
+	0x0F1200EE,
+	0x0F12FF99,
+	0x0F12009D,
+	0x0F12FF71,
+	0x0F120197,
+	0x0F12FF0C,
+	0x0F12013D,
+	0x0F12013D,
+
+	0x0F12019F,	/*#TVAR_wbt_pOutdoorCcm[0]*/
+	0x0F12FFBF,
+	0x0F12FFFD,
+	0x0F12FF10,
+	0x0F1201D4,
+	0x0F12FFA4,
+	0x0F12FFE8,
+	0x0F12FFE0,
+	0x0F1201C2,
+	0x0F120087,
+	0x0F1200A5,
+	0x0F12FF17,
+	0x0F1201DD,
+	0x0F12FF0E,
+	0x0F12010B,
+	0x0F12FF24,
+	0x0F1200F0,
+	0x0F1201DB,
+
+	/*AFIT*/
+	0x002A0944,
+	0x0F120050,	/*#afit_uNoiseIndInDoor_0_*/
+	0x0F120103,	/*#afit_uNoiseIndInDoor_1_*/
+	0x0F120196,	/*#afit_uNoiseIndInDoor_2_*/
+	0x0F120245,	/*#afit_uNoiseIndInDoor_3_*/
+	0x0F120300,	/*#afit_uNoiseIndInDoor_4_*/
+
+	0x002A097A,
+	0x0F120001,	/*#afit_bUseSenBpr*/
+	0x0F1201CC,	/*#afit_usBprThr_0_*/
+	0x0F1201CC,	/*#afit_usBprThr_1_*/
+	0x0F1201CC,	/*#afit_usBprThr_2_*/
+	0x0F1201CC,	/*#afit_usBprThr_3_*/
+	0x0F1201CC,	/*#afit_usBprThr_4_*/
+	0x0F120180,	/*#afit_NIContrastAFITValue*/
+	0x0F120196,	/*#afit_NIContrastTh*/
+
+	0x002A0976,
+	0x0F120070,
+	0x0F120005,
+
+	0x002A0938,
+	0x0F120000,
+	0x0F120014,	/*#SARR_uNormBrInDoor_0_*/
+	0x0F1200D2,	/*#SARR_uNormBrInDoor_1_*/
+	0x0F120384,	/*#SARR_uNormBrInDoor_2_*/
+	0x0F1207D0,	/*#SARR_uNormBrInDoor_3_*/
+	0x0F121388,	/*#SARR_uNormBrInDoor_4_*/
+
+	0x002A098C,
+	0x0F120000,	/*AFIT 0*/
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F12005F,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F123604,
+	0x0F12032A,
+	0x0F120403,
+	0x0F121B06,
+	0x0F126015,
+	0x0F1200C0,
+	0x0F126080,
+	0x0F124080,
+	0x0F120640,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120000,
+	0x0F120400,
+	0x0F12365A,
+	0x0F12102A,
+	0x0F12000B,
+	0x0F120600,
+	0x0F125A0F,
+	0x0F120505,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123028,
+	0x0F120418,
+	0x0F120101,
+	0x0F120800,
+	0x0F121804,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120705,
+	0x0F120206,
+	0x0F120304,
+	0x0F120309,
+	0x0F120305,
+	0x0F122006,
+	0x0F121320,
+	0x0F121014,
+	0x0F121010,
+	0x0F120C10,
+	0x0F121A0C,
+	0x0F124A18,
+	0x0F120080,
+	0x0F120050,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F122A36,
+	0x0F126024,
+	0x0F122A36,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F123601,
+	0x0F12242A,
+	0x0F123660,
+	0x0F12FF2A,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,	/*AFIT 1*/
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120051,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F122404,
+	0x0F12031B,
+	0x0F120103,
+	0x0F121205,
+	0x0F12400D,
+	0x0F120080,
+	0x0F121980,
+	0x0F12272E,
+	0x0F120629,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120300,
+	0x0F12245A,
+	0x0F121018,
+	0x0F12000B,
+	0x0F120B00,
+	0x0F125A0F,
+	0x0F120505,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123828,
+	0x0F120425,
+	0x0F120101,
+	0x0F120800,
+	0x0F121004,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120205,
+	0x0F120304,
+	0x0F120409,
+	0x0F120306,
+	0x0F120407,
+	0x0F122204,
+	0x0F12021C,
+	0x0F121102,
+	0x0F120611,
+	0x0F121A02,
+	0x0F128018,
+	0x0F120080,
+	0x0F120074,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F12141D,
+	0x0F126024,
+	0x0F121217,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F122401,
+	0x0F12241B,
+	0x0F121E60,
+	0x0F12FF18,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,	/*AFIT 2*/
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120043,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F121B04,
+	0x0F120312,
+	0x0F120003,
+	0x0F120C03,
+	0x0F122806,
+	0x0F120060,
+	0x0F121580,
+	0x0F122020,
+	0x0F120620,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120300,
+	0x0F12145A,
+	0x0F121010,
+	0x0F12000B,
+	0x0F120E00,
+	0x0F125A0F,
+	0x0F120504,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123828,
+	0x0F120428,
+	0x0F120101,
+	0x0F128000,
+	0x0F120A04,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120207,
+	0x0F120304,
+	0x0F120409,
+	0x0F120306,
+	0x0F120407,
+	0x0F122404,
+	0x0F120221,
+	0x0F121202,
+	0x0F120613,
+	0x0F121A02,
+	0x0F128018,
+	0x0F120080,
+	0x0F120080,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F12121B,
+	0x0F126024,
+	0x0F120C0C,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F121B01,
+	0x0F122412,
+	0x0F120C60,
+	0x0F12FF0C,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,	/*AFIT 3*/
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120032,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F121504,
+	0x0F12030F,
+	0x0F120003,
+	0x0F120902,
+	0x0F122004,
+	0x0F120050,
+	0x0F121140,
+	0x0F12201C,
+	0x0F120620,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120300,
+	0x0F12145A,
+	0x0F121010,
+	0x0F12000B,
+	0x0F121000,
+	0x0F125A0F,
+	0x0F120503,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F123C28,
+	0x0F12042C,
+	0x0F120101,
+	0x0F12FF00,
+	0x0F120904,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120206,
+	0x0F120304,
+	0x0F120409,
+	0x0F120305,
+	0x0F120406,
+	0x0F122804,
+	0x0F120228,
+	0x0F121402,
+	0x0F120618,
+	0x0F121A02,
+	0x0F128018,
+	0x0F120080,
+	0x0F120080,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F120F15,
+	0x0F126024,
+	0x0F120A0A,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F121501,
+	0x0F12240F,
+	0x0F120A60,
+	0x0F12FF0A,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F120000,	/*AFIT 4*/
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F1200C0,
+	0x0F120064,
+	0x0F120384,
+	0x0F120032,
+	0x0F1201F4,
+	0x0F120070,
+	0x0F120040,
+	0x0F1200A0,
+	0x0F120100,
+	0x0F120010,
+	0x0F120060,
+	0x0F120100,
+	0x0F121430,
+	0x0F120201,
+	0x0F120204,
+	0x0F120F04,
+	0x0F12030C,
+	0x0F120003,
+	0x0F120602,
+	0x0F121803,
+	0x0F120040,
+	0x0F120E20,
+	0x0F122018,
+	0x0F120620,
+	0x0F120306,
+	0x0F122003,
+	0x0F12FF01,
+	0x0F120404,
+	0x0F120200,
+	0x0F12145A,
+	0x0F121010,
+	0x0F12000B,
+	0x0F121200,
+	0x0F125A0F,
+	0x0F120502,
+	0x0F121802,
+	0x0F120000,
+	0x0F122006,
+	0x0F124028,
+	0x0F120430,
+	0x0F120101,
+	0x0F12FF00,
+	0x0F120804,
+	0x0F124008,
+	0x0F120540,
+	0x0F128006,
+	0x0F120020,
+	0x0F120000,
+	0x0F121800,
+	0x0F120000,
+	0x0F121E10,
+	0x0F12000B,
+	0x0F120607,
+	0x0F120005,
+	0x0F120607,
+	0x0F120405,
+	0x0F120205,
+	0x0F120304,
+	0x0F120409,
+	0x0F120306,
+	0x0F120407,
+	0x0F122C04,
+	0x0F12022C,
+	0x0F121402,
+	0x0F120618,
+	0x0F121A02,
+	0x0F128018,
+	0x0F120080,
+	0x0F120080,
+	0x0F120180,
+	0x0F120A0A,
+	0x0F120101,
+	0x0F120C0F,
+	0x0F126024,
+	0x0F120808,
+	0x0F12FFFF,
+	0x0F120808,
+	0x0F120A01,
+	0x0F12010A,
+	0x0F120F01,
+	0x0F12240C,
+	0x0F120860,
+	0x0F12FF08,
+	0x0F1208FF,
+	0x0F120008,
+	0x0F120001,
+	0x0F1223CE,
+	0x0F12FDC8,
+	0x0F12112E,
+	0x0F1283A5,
+	0x0F12FE67,
+	0x0F120000,
+
+	/*System Setting*/
+	0x002A01F8,
+	0x0F125DC0,	/*#REG_TC_IPRM_InClockLSBs, MCLK: 24Mhz*/
+	0x002A0212,
+	0x0F120002,	/*#REG_TC_IPRM_UseNPviClocks*/
+	0x0F120000,	/*#REG_TC_IPRM_UseNMipiClocks*/
+	0x0F120000,	/*#REG_TC_IPRM_NumberOfMipiLanes*/
+	0x002A021A,
+	0x0F123A98,	/*#REG_TC_IPRM_OpClk4KHz_0, SCLK: 60Mhz*/
+	0x0F124F1A,	/*#REG_TC_IPRM_MinOutRate4KHz_0	PCLK Min : 81Mhz*/
+	0x0F124F1A,	/*#REG_TC_IPRM_MaxOutRate4KHz_0	PCLK Max : 81Mhz*/
+	0x0F124F1A,	/*#REG_TC_IPRM_OpClk4KHz_1	SCLK	 : 81Mhz*/
+	0x0F124F1A,	/*#REG_TC_IPRM_MinOutRate4KHz_1	PCLK Min : 81Mhz*/
+	0x0F124F1A,	/*#REG_TC_IPRM_MaxOutRate4KHz_1 PCLK Max : 81Mhz*/
+	0x002A022C,
+	0x0F120001,	/*#REG_TC_IPRM_InitParamsUpdated*/
+
+	/*ETC.. Setting*/
+	0x002A0478,
+	0x0F12005F,	/*#REG_TC_BRC_usPrevQuality*/
+	0x0F12005F,	/*#REG_TC_BRC_usCaptureQuality*/
+
+	0x0F120001,	/*#REG_TC_THUMB_Thumb_bActive*/
+	0x0F120280,	/*#REG_TC_THUMB_Thumb_uWidth*/
+	0x0F1201E0,	/*#REG_TC_THUMB_Thumb_uHeight*/
+	0x0F120005,	/*#REG_TC_THUMB_Thumb_Format*/
+
+	0x002A17DC,
+	0x0F120054,	/*#jpeg_ManualMBCV*/
+	0x002A1AE4,
+	0x0F12001C,	/*#senHal_bExtraAddLine*/
+	0x002A0284,
+	0x0F120001,	/*#REG_TC_GP_bBypassScalerJpg*/
+	0x002A028A,
+	0x0F120001,	/*#REG_TC_GP_bUse1FrameCaptureMode
+			  0 : Continuous mode,1 : Single frame mode*/
+
+	/*Configuration Setting*/
+	0x002A02A6,
+	0x0F120280,	/*#REG_0TC_PCFG_usWidth	   : 640*/
+	0x0F1201E0,	/*#REG_0TC_PCFG_usHeight   : 480*/
+	0x0F120005,	/*#REG_0TC_PCFG_Format	5 : YUV	7 : Raw	9 : JPG*/
+	0x0F124F1A,	/*#REG_0TC_PCFG_usMaxOut4KHzRate*/
+	0x0F124F1A,	/*#REG_0TC_PCFG_usMinOut4KHzRate*/
+	0x0F120100,	/*#REG_0TC_PCFG_OutClkPerPix88*/
+	0x0F120300,	/*#REG_0TC_PCFG_uBpp88*/
+	0x0F120052,	/*#REG_0TC_PCFG_PVIMask*/
+	0x0F120000,	/*#REG_0TC_PCFG_OIFMask*/
+	0x0F1201E0,	/*#REG_0TC_PCFG_usJpegPacketSize*/
+	0x0F120000,	/*#REG_0TC_PCFG_usJpegTotalPackets*/
+	0x0F120000,	/*#REG_0TC_PCFG_uClockInd*/
+	0x0F120000,	/*#REG_0TC_PCFG_usFrTimeType*/
+	0x0F120001,	/*#REG_0TC_PCFG_FrRateQualityType*/
+	0x0F12029A,	/*#REG_0TC_PCFG_usMaxFrTimeMsecMult10*/
+	0x0F12014A,	/*#REG_0TC_PCFG_usMinFrTimeMsecMult10*/
+	0x002A02D0,
+	0x0F120000,	/*#REG_0TC_PCFG_uPrevMirror*/
+	0x0F120000,	/*#REG_0TC_PCFG_uCaptureMirror*/
+	0x0F120000,	/*#REG_0TC_PCFG_uRotation*/
+
+	0x002A0396,
+	0x0F120000,	/*#REG_0TC_CCFG_uCaptureMode*/
+	0x0F120A00,	/*#REG_0TC_CCFG_usWidth*/
+	0x0F120780,	/*#REG_0TC_CCFG_usHeight*/
+	0x0F120009,	/*#REG_0TC_CCFG_Format*/
+	0x0F124F1A,	/*#REG_0TC_CCFG_usMaxOut4KHzRate*/
+	0x0F124F1A,	/*#REG_0TC_CCFG_usMinOut4KHzRate*/
+	0x0F120100,	/*#REG_0TC_CCFG_OutClkPerPix88*/
+	0x0F120300,	/*#REG_0TC_CCFG_uBpp88*/
+	0x0F120042,	/*#REG_0TC_CCFG_PVIMask*/
+	0x0F120000,	/*#REG_0TC_CCFG_OIFMask*/
+	0x0F1201E0,	/*#REG_0TC_CCFG_usJpegPacketSize*/
+	0x0F120000,	/*#REG_0TC_CCFG_usJpegTotalPackets*/
+	0x0F120001,	/*#REG_0TC_CCFG_uClockInd*/
+	0x0F120000,	/*#REG_0TC_CCFG_usFrTimeType*/
+	0x0F120002,	/*#REG_0TC_CCFG_FrRateQualityType*/
+	0x0F120535,	/*#REG_0TC_CCFG_usMaxFrTimeMsecMult10*/
+	0x0F12029A,	/*#REG_0TC_CCFG_usMinFrTimeMsecMult10*/
+
+	0x002A0250,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x002A0494,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0262,
+	0x0F120001,
+	0x0F120001,
+	0x0F120000,	/*#REG_TC_GP_ActivePrevConfig*/
+	0x002A026A,
+	0x0F120001,	/*#REG_TC_GP_PrevOpenAfterChange*/
+	0x002A024E,
+	0x0F120001,	/*#REG_TC_GP_NewConfigSync*/
+	0x002A0268,
+	0x0F120001,	/*#REG_TC_GP_PrevConfigChanged*/
+	0x002A0270,
+	0x0F120001,	/*#REG_TC_GP_CapConfigChanged*/
+	0x002A023E,
+	0x0F120001,	/*#REG_TC_GP_EnablePreview*/
+	0x0F120001,	/*#REG_TC_GP_EnablePreviewChanged*/
+};
+
+static const u32 s5k4ecgx_DTP_init[] = {
+	0x0028D000,
+	0x002AB054,
+	0x0F120001,
+	0x00287000,
+};
+
+static const u32 s5k4ecgx_DTP_stop[] = {
+	0x0028D000,
+	0x002AB054,
+	0x0F120000,
+	0x00287000,
+};
+
+static const u32 s5k4ecgx_FPS_Auto[] = {
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014A,
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_FPS_5[] = {
+
+};
+
+static const u32 s5k4ecgx_FPS_7[] = {
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F120535,
+	0x0F120535,
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_FPS_10[] = {
+
+};
+
+static const u32 s5k4ecgx_FPS_15[] = {
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12029A,
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_FPS_30[] = {
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F12014D,
+	0x0F12014D,
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_FPS_60[] = {
+
+};
+
+static const u32 s5k4ecgx_FPS_120[] = {
+
+};
+
+static const u32 s5k4ecgx_Effect_Normal[] = {
+	0x002A023C,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Effect_Solarization[] = {
+	0x002A023C,
+	0x0F120002,
+};
+
+static const u32 s5k4ecgx_Effect_Negative[] = {
+	0x002A023C,
+	0x0F120003,
+};
+
+static const u32 s5k4ecgx_Effect_Sepia[] = {
+	0x002A023C,
+	0x0F120004,
+};
+
+static const u32 s5k4ecgx_Effect_Black_White[] = {
+	0x002A023C,
+	0x0F120001,
+};
+
+
+static const u32 s5k4ecgx_WB_Auto[] = {
+	0x002A04E6,
+	0x0F12077F,
+};
+
+static const u32 s5k4ecgx_WB_Sunny[] = {
+	0x002A04E6,
+	0x0F120777,
+	0x002A04BA,
+	0x0F1205E0,
+	0x0F120001,
+	0x0F120400,
+	0x0F120001,
+	0x0F120530,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_WB_Cloudy[] = {
+	0x002A04E6,
+	0x0F120777,
+	0x002A04BA,
+	0x0F120710,
+	0x0F120001,
+	0x0F120400,
+	0x0F120001,
+	0x0F120420,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_WB_Tungsten[] = {
+	0x002A04E6,
+	0x0F120777,
+	0x002A04BA,
+	0x0F120390,
+	0x0F120001,
+	0x0F120400,
+	0x0F120001,
+	0x0F120920,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_WB_Fluorescent[] = {
+	0x002A04E6,
+	0x0F120777,
+	0x002A04BA,
+	0x0F120505,
+	0x0F120001,
+	0x0F120400,
+	0x0F120001,
+	0x0F120875,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_WDR_on[] = {
+	0x002A1BEA,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_WDR_off[] = {
+	0x002A1BEA,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_ISO_Auto[] = {
+	0x002A0938,
+	0x0F120000,
+
+	0x002A0F2A,
+	0x0F120001,
+	0x002A04E6,
+	0x0F12077F,
+
+	0x002A04D0,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x002A06C2,
+	0x0F120200,
+};
+
+static const u32 s5k4ecgx_ISO_100[] = {
+	0x002A04E6,
+	0x0F12065F,
+	0x002A04D6,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04D0,
+	0x0F120001,
+	0x0F1201A0,
+	0x0F120001,
+	0x002A06C2,
+	0x0F120100,
+
+	0x002A0938,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_ISO_200[] = {
+	0x002A04E6,
+	0x0F12065F,
+	0x002A04D6,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04D0,
+	0x0F120001,
+	0x0F120340,
+	0x0F120001,
+	0x002A06C2,
+	0x0F120100,
+
+	0x002A0938,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_ISO_400[] = {
+	0x002A04E6,
+	0x0F12065F,
+	0x002A04D6,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04D0,
+	0x0F120001,
+	0x0F120680,
+	0x0F120001,
+	0x002A06C2,
+	0x0F120100,
+
+	0x002A0938,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Metering_Matrix[] = {
+	0x002A1492,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+};
+
+static const u32 s5k4ecgx_Metering_Center[] = {
+	0x002A1492,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120202,
+	0x0F120202,
+	0x0F120102,
+};
+
+static const u32 s5k4ecgx_Metering_Spot[] = {
+	0x002A1492,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120000,
+	0x0F12010F,
+	0x0F120F01,
+	0x0F120000,
+	0x0F120000,
+	0x0F12010F,
+	0x0F120F01,
+	0x0F120000,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_EV_Minus_4[] = {
+	0x002A0230,
+	0x0F12FF30,
+};
+
+static const u32 s5k4ecgx_EV_Minus_3[] = {
+	0x002A0230,
+	0x0F12FFA0,
+};
+
+static const u32 s5k4ecgx_EV_Minus_2[] = {
+	0x002A0230,
+	0x0F12FFC8,
+};
+
+static const u32 s5k4ecgx_EV_Minus_1[] = {
+	0x002A0230,
+	0x0F12FFE0,
+};
+
+static const u32 s5k4ecgx_EV_Default[] = {
+	0x002A0230,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_EV_Plus_1[] = {
+	0x002A0230,
+	0x0F120020,
+};
+
+static const u32 s5k4ecgx_EV_Plus_2[] = {
+	0x002A0230,
+	0x0F120038,
+};
+
+static const u32 s5k4ecgx_EV_Plus_3[] = {
+	0x002A0230,
+	0x0F120060,
+};
+
+static const u32 s5k4ecgx_EV_Plus_4[] = {
+	0x002A0230,
+	0x0F12007F,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_4[] = {
+	0x002A0232,
+	0x0F12FF81,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_3[] = {
+	0x002A0232,
+	0x0F12FFA0,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_2[] = {
+	0x002A0232,
+	0x0F12FFC0,
+};
+
+static const u32 s5k4ecgx_Contrast_Minus_1[] = {
+	0x002A0232,
+	0x0F12FFE0,
+};
+
+static const u32 s5k4ecgx_Contrast_Default[] = {
+	0x002A0232,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_1[] = {
+	0x002A0232,
+	0x0F120020,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_2[] = {
+	0x002A0232,
+	0x0F120040,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_3[] = {
+	0x002A0232,
+	0x0F120060,
+};
+
+static const u32 s5k4ecgx_Contrast_Plus_4[] = {
+	0x002A0232,
+	0x0F12007F,
+};
+
+static const u32 s5k4ecgx_Sharpness_Minus_3[] = {
+	0x002A0A28,
+	0x0F120000,
+	0x002A0ADE,
+	0x0F120000,
+	0x002A0B94,
+	0x0F120000,
+	0x002A0C4A,
+	0x0F120000,
+	0x002A0D00,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Sharpness_Minus_2[] = {
+	0x002A0A28,
+	0x0F122010,
+	0x002A0ADE,
+	0x0F122010,
+	0x002A0B94,
+	0x0F122010,
+	0x002A0C4A,
+	0x0F122010,
+	0x002A0D00,
+	0x0F122010,
+};
+
+static const u32 s5k4ecgx_Sharpness_Minus_1[] = {
+	0x002A0A28,
+	0x0F124020,
+	0x002A0ADE,
+	0x0F124020,
+	0x002A0B94,
+	0x0F124020,
+	0x002A0C4A,
+	0x0F124020,
+	0x002A0D00,
+	0x0F124020,
+};
+
+static const u32 s5k4ecgx_Sharpness_Default[] = {
+	0x002A0A28,
+	0x0F126024,
+	0x002A0ADE,
+	0x0F126024,
+	0x002A0B94,
+	0x0F126024,
+	0x002A0C4A,
+	0x0F126024,
+	0x002A0D00,
+	0x0F126024,
+};
+
+static const u32 s5k4ecgx_Sharpness_Plus_1[] = {
+	0x002A0A28,
+	0x0F128040,
+	0x002A0ADE,
+	0x0F128040,
+	0x002A0B94,
+	0x0F128040,
+	0x002A0C4A,
+	0x0F128040,
+	0x002A0D00,
+	0x0F128040,
+};
+
+static const u32 s5k4ecgx_Sharpness_Plus_2[] = {
+	0x002A0A28,
+	0x0F12A060,
+	0x002A0ADE,
+	0x0F12A060,
+	0x002A0B94,
+	0x0F12A060,
+	0x002A0C4A,
+	0x0F12A060,
+	0x002A0D00,
+	0x0F12A060,
+};
+
+static const u32 s5k4ecgx_Sharpness_Plus_3[] = {
+	0x002A0A28,
+	0x0F12C080,
+	0x002A0ADE,
+	0x0F12C080,
+	0x002A0B94,
+	0x0F12C080,
+	0x002A0C4A,
+	0x0F12C080,
+	0x002A0D00,
+	0x0F12C080,
+};
+
+static const u32 s5k4ecgx_Saturation_Minus_2[] = {
+	0x002A0234,
+	0x0F12FF81,
+};
+
+static const u32 s5k4ecgx_Saturation_Minus_1[] = {
+	0x002A0234,
+	0x0F12FFC0,
+};
+
+static const u32 s5k4ecgx_Saturation_Default[] = {
+	0x002A0234,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Saturation_Plus_1[] = {
+	0x002A0234,
+	0x0F120040,
+};
+
+static const u32 s5k4ecgx_Saturation_Plus_2[] = {
+	0x002A0234,
+	0x0F12007F,
+};
+
+static const u32 s5k4ecgx_Jpeg_Quality_High[] = {
+	0x002A0478,
+	0x0F12005F,
+	0x0F12005F,
+};
+
+static const u32 s5k4ecgx_Jpeg_Quality_Normal[] = {
+	0x002A0478,
+	0x0F120056,
+	0x0F120056,
+};
+
+static const u32 s5k4ecgx_Jpeg_Quality_Low[] = {
+	0x002A0478,
+	0x0F12004F,
+	0x0F12004F,
+};
+
+static const u32 s5k4ecgx_Scene_Default[] = {
+	0x002A1492,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120403,
+	0x0F120304,
+	0x0F120102,
+	0x0F120201,
+	0x0F120303,
+	0x0F120303,
+	0x0F120102,
+	0x0F120201,
+	0x0F120202,
+	0x0F120202,
+	0x0F120102,
+
+	0x002A0938,
+	0x0F120000,
+
+	0x002A06B8,
+	0x0F12452C,
+	0x0F120004,
+
+	0x002A0F2A,
+	0x0F120001,
+	0x002A0F30,
+	0x0F120001,
+	0x002A04E6,
+	0x0F12077F,
+
+	0x002A04D0,
+	0x0F120000,
+	0x0F120000,
+	0x0F120001,
+	0x002A06C2,
+	0x0F120200,
+
+	0x002A2C66,
+	0x0F120001,
+
+	0x002A1484,
+	0x0F12003C,
+	0x002A148A,
+	0x0F12000F,
+	0x002A058C,
+	0x0F123520,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F12C350,
+	0x0F120000,
+	0x0F120470,
+	0x0F120C00,
+	0x0F120100,
+	0x0F121000,
+
+	0x002A0544,
+	0x0F120111,
+	0x0F1200EF,
+
+	0x002A0608,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0A28,
+	0x0F126024,
+	0x002A0ADE,
+	0x0F126024,
+	0x002A0B94,
+	0x0F126024,
+	0x002A0C4A,
+	0x0F126024,
+	0x002A0D00,
+	0x0F126024,
+
+	0x002A0234,
+	0x0F120000,
+
+	0x002A0638,
+	0x0F120001,
+	0x0F120000,
+	0x002A063C,
+	0x0F120A3C,
+	0x0F120000,
+	0x002A0640,
+	0x0F120D05,
+	0x0F120000,
+	0x002A0644,
+	0x0F123408,
+	0x0F120000,
+	0x002A0648,
+	0x0F123408,
+	0x0F120000,
+	0x002A064C,
+	0x0F126810,
+	0x0F120000,
+	0x002A0650,
+	0x0F128214,
+	0x0F120000,
+	0x002A0654,
+	0x0F12C350,
+	0x0F120000,
+	0x002A0658,
+	0x0F12C350,
+	0x0F120000,
+	0x002A065C,
+	0x0F12C350,
+	0x0F120000,
+
+	0x002A03B4,
+	0x0F120535,
+	0x0F12029A,
+
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+	0x002A0270,
+	0x0F120001,
+	0x002A023E,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Portrait[] = {
+	0x002A0A28,
+	0x0F124020,
+	0x002A0ADE,
+	0x0F124020,
+	0x002A0B94,
+	0x0F124020,
+	0x002A0C4A,
+	0x0F124020,
+	0x002A0D00,
+	0x0F124020,
+};
+
+static const u32 s5k4ecgx_Scene_Nightshot[] = {
+	0x002A06B8,
+	0x0F12FFFF,
+	0x0F1200FF,
+
+	0x002A0608,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A058C,
+	0x0F12F424,
+	0x0F120001,
+	0x0F12D090,
+	0x0F120007,
+	0x0F12F424,
+	0x0F120001,
+	0x0F12D090,
+	0x0F120007,
+	0x0F120100,
+	0x0F120800,
+	0x0F120100,
+	0x0F122000,
+
+	0x002A03B4,
+	0x0F121388,
+	0x0F121388,
+	0x002A02C2,
+	0x0F1209C4,
+	0x0F12014A,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+	0x002A0270,
+	0x0F120001,
+	0x002A023E,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0A1E,
+	0x0F121580,
+};
+
+static const u32 s5k4ecgx_Scene_Backlight[] = {
+	0x002A1492,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120000,
+	0x0F12010F,
+	0x0F120F01,
+	0x0F120000,
+	0x0F120000,
+	0x0F12010F,
+	0x0F120F01,
+	0x0F120000,
+	0x0F120000,
+	0x0F120101,
+	0x0F120101,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Scene_Landscape[] = {
+	0x002A1492,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x0F120101,
+	0x002A0A28,
+	0x0F12E082,
+	0x002A0ADE,
+	0x0F12E082,
+	0x002A0B94,
+	0x0F12E082,
+	0x002A0C4A,
+	0x0F12E082,
+	0x002A0D00,
+	0x0F12E082,
+	0x002A0234,
+	0x0F120030,
+};
+
+static const u32 s5k4ecgx_Scene_Sports[] = {
+	0x002A0608,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A058C,
+	0x0F123520,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F123520,
+	0x0F120000,
+	0x0F120200,
+	0x0F120200,
+	0x0F120200,
+	0x0F120200,
+
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+	0x002A0270,
+	0x0F120001,
+	0x002A023E,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Party_Indoor[] = {
+	0x002A04E6,
+	0x0F12065F,
+	0x002A04D6,
+	0x0F120000,
+	0x0F120001,
+
+	0x002A04D0,
+	0x0F120001,
+	0x0F120340,
+	0x0F120001,
+	0x002A06C2,
+	0x0F120100,
+
+	0x002A0938,
+	0x0F120001,
+
+	0x002A0234,
+	0x0F120030,
+};
+
+static const u32 s5k4ecgx_Scene_Beach_Snow[] = {
+	0x002A1484,
+	0x0F120045,	/*#TVAR_ae_BrAve*/
+	0x002A04E6,
+	0x0F12065F,
+	0x002A04D6,
+	0x0F120000,
+	0x0F120001,
+	0x002A04D0,
+	0x0F120001,
+	0x0F1200D0,
+	0x0F120001,
+	0x002A06C2,
+	0x0F120100,
+
+	0x002A0938,
+	0x0F120001,
+
+	0x002A0234,
+	0x0F120030,
+};
+
+static const u32 s5k4ecgx_Scene_Sunset[] = {
+	0x002A04E6,
+	0x0F120777,
+
+	0x002A04BA,
+	0x0F1205E0,
+	0x0F120001,
+	0x0F120400,
+	0x0F120001,
+	0x0F120530,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Duskdawn[] = {
+	0x002A04E6,
+	0x0F120777,
+	0x002A04BA,
+	0x0F120505,
+	0x0F120001,
+	0x0F120400,
+	0x0F120001,
+	0x0F120875,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Fall_Color[] = {
+	0x002A0234,
+	0x0F120060,
+};
+
+static const u32 s5k4ecgx_Scene_Fireworks[] = {
+	0x002A0638,
+	0x0F120001,
+	0x0F120000,
+	0x002A063C,
+	0x0F121478,
+	0x0F120000,
+	0x002A0640,
+	0x0F121A0A,
+	0x0F120000,
+	0x002A0644,
+	0x0F126810,
+	0x0F120000,
+	0x002A0648,
+	0x0F126810,
+	0x0F120000,
+	0x002A064C,
+	0x0F12D020,
+	0x0F120000,
+	0x002A0650,
+	0x0F120428,
+	0x0F120001,
+	0x002A0654,
+	0x0F121A80,
+	0x0F120006,
+	0x002A0658,
+	0x0F121A80,
+	0x0F120006,
+	0x002A065C,
+	0x0F121A80,
+	0x0F120006,
+
+	0x002A03B4,
+	0x0F122710,
+	0x0F122710,
+
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+	0x002A0270,
+	0x0F120001,
+	0x002A023E,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Scene_Text[] = {
+	0x002A0A28,
+	0x0F12A060,
+	0x002A0ADE,
+	0x0F12A060,
+	0x002A0B94,
+	0x0F12A060,
+	0x002A0C4A,
+	0x0F12A060,
+	0x002A0D00,
+	0x0F12A060,
+};
+
+static const u32 s5k4ecgx_Scene_Candle_Light[] = {
+	0x002A04E6,
+	0x0F120777,
+	0x002A04BA,
+	0x0F1205E0,
+	0x0F120001,
+	0x0F120400,
+	0x0F120001,
+	0x0F120530,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Night_Capture[] = {
+	0x002A0608,
+	0x0F120000,	/*#lt_ExpGain_uSubsamplingmode*/
+	0x0F120000,	/*#lt_ExpGain_uNonSubsampling*/
+};
+
+static const u32 s5k4ecgx_AF_Return_Inf_pos[] = {
+	0x002A15D6,
+	0x0F12D000,
+};
+
+static const u32 s5k4ecgx_AF_Return_Macro_pos[] = {
+	0x002A15E8,
+	0x0F120018,
+	0x0F12002A,
+	0x0F120030,
+	0x0F120036,
+	0x0F12003C,
+	0x0F120042,
+	0x0F120048,
+	0x0F12004E,
+	0x0F120054,
+	0x0F12005A,
+	0x0F120060,
+	0x0F120066,
+	0x0F12006C,
+	0x0F120072,
+	0x0F120078,
+	0x0F12007E,
+	0x0F120084,
+	0x0F12008A,
+	0x0F120090,
+	0x0F120096,
+	0x0F12009C,
+	0x0F1200A2,
+	0x0F1200A8,
+	0x0F1200AE,
+	0x0F1200B4,
+	0x0F1200BA,
+};
+
+static const u32 s5k4ecgx_AF_Normal_mode_1[] = {
+	0x002A028E,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_AF_Normal_mode_2[] = {
+	0x002A028C,
+	0x0F120004,
+};
+
+static const u32 s5k4ecgx_AF_Normal_mode_3[] = {
+	0x002A1648,
+	0x0F129002,
+};
+
+static const u32 s5k4ecgx_AF_Macro_mode_1[] = {
+	0x002A028E,
+	0x0F1200D0,
+};
+
+static const u32 s5k4ecgx_AF_Macro_mode_2[] = {
+	0x002A028C,
+	0x0F120004,
+};
+
+static const u32 s5k4ecgx_AF_Macro_mode_3[] = {
+	0x002A1648,
+	0x0F129042,
+	0x002A15DA,
+	0x0F121800,
+};
+
+static const u32 s5k4ecgx_AF_Low_Light_Mode_On[] = {
+	0x002A15DA,
+	0x0F120C00,
+
+	0x002A15E8,
+	0x0F12000C,
+	0x0F12002A,
+	0x0F120033,
+	0x0F12003C,
+	0x0F120045,
+	0x0F12004E,
+	0x0F120057,
+	0x0F120063,
+	0x0F12006F,
+	0x0F12007B,
+	0x0F120087,
+	0x0F120093,
+	0x0F1200A2,
+	0x0F1200B1,
+};
+
+static const u32 s5k4ecgx_AF_Low_Light_Mode_Off[] = {
+	0x002A15DA,
+	0x0F121800,
+
+	0x002A15E8,
+	0x0F120018,
+	0x0F12002A,
+	0x0F120030,
+	0x0F120036,
+	0x0F12003C,
+	0x0F120042,
+	0x0F120048,
+	0x0F12004E,
+	0x0F120054,
+	0x0F12005A,
+	0x0F120060,
+	0x0F120066,
+	0x0F12006C,
+	0x0F120072,
+	0x0F120078,
+	0x0F12007E,
+	0x0F120084,
+	0x0F12008A,
+	0x0F120090,
+	0x0F120096,
+	0x0F12009C,
+	0x0F1200A2,
+	0x0F1200A8,
+	0x0F1200AE,
+	0x0F1200B4,
+	0x0F1200BA,
+};
+
+static const u32 s5k4ecgx_Single_AF_Start[] = {
+	0x002A028C,
+	0x0F120005,
+};
+
+static const u32 s5k4ecgx_Single_AF_Off_1[] = {
+	0x002A028E,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_Single_AF_Off_2[] = {
+	0x002A028C,
+	0x0F120004,
+};
+
+static const u32 s5k4ecgx_Single_AF_Off_3[] = {
+
+};
+
+
+static const u32 s5k4ecgx_Face_Detection_On[] = {
+	0x002A0294,
+	0x0F120100,
+	0x0F1200E3,
+	0x0F120200,
+	0x0F120238,
+	0x0F1201C6,
+	0x0F120166,
+	0x0F120074,
+	0x0F120132,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Face_Detection_Off[] = {
+	0x002A0294,
+	0x0F120100,
+	0x0F1200E3,
+	0x0F120200,
+	0x0F120238,
+	0x0F1201C6,
+	0x0F120166,
+	0x0F120074,
+	0x0F120132,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Low_Cap_On[] = {
+	0x002A06B8,
+	0x0F12FFFF,
+	0x0F1200FF, /*#lt_uMaxLei*/
+
+	0x002A0A1C,
+	0x0F12008A, /*#Gamma linearity*/
+
+	0x002A0608,
+	0x0F120001,	/*#lt_ExpGain_uSubsamplingmode*/
+	0x0F120001,	/*#lt_ExpGain_uNonSubsampling*/
+	0x0F120900,	/*#lt_ExpGain_ExpCurveGainMaxStr*/
+
+	0x002A0938,
+	0x0F120001,
+	0x0F120012,	/*#SARR_uNormBrInDoor_0_*/
+	0x0F120022,	/*#SARR_uNormBrInDoor_1_*/
+	0x0F120384,	/*#SARR_uNormBrInDoor_2_*/
+	0x0F1207D0,	/*#SARR_uNormBrInDoor_3_*/
+	0x0F121388,	/*#SARR_uNormBrInDoor_4_*/
+};
+
+static const u32 s5k4ecgx_Low_Cap_Off[] = {
+	0x002A06B8,
+	0x0F12452C,
+	0x0F120004,	/*#lt_uMaxLei*/
+
+	0x002A0A1C,
+	0x0F120080, /*#Gamma linearity*/
+
+
+	0x002A0608,
+	0x0F120001,	/*#lt_ExpGain_uSubsamplingmode*/
+	0x0F120001,	/*#lt_ExpGain_uNonSubsampling*/
+	0x0F120800,	/*#lt_ExpGain_ExpCurveGainMaxStr*/
+
+	0x002A0938,
+	0x0F120000,
+	0x0F120014,	/*#SARR_uNormBrInDoor_0_*/
+	0x0F1200D2,	/*#SARR_uNormBrInDoor_1_*/
+	0x0F120384,	/*#SARR_uNormBrInDoor_2_*/
+	0x0F1207D0,	/*#SARR_uNormBrInDoor_3_*/
+	0x0F121388,	/*#SARR_uNormBrInDoor_4_*/
+};
+
+/* restores crop settings to full resolution */
+static const u32 s5k4ecgx_Reset_Crop[] = {
+	0x002A0250,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x002A0494,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0262,
+	0x0F120001,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Capture_Start[] = {
+	0x002A0A1E,
+	0x0F120050,
+
+	0x002A0AD4,
+	0x0F120074,
+
+	0x002A0242,
+	0x0F120001,
+
+	0x002A024E,
+	0x0F120001,
+
+	0x002A0244,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Preview_Return[] = {
+	0x002A0A1E,
+	0x0F120028,
+
+	0x002A0AD4,
+	0x0F12003C,
+
+	0x002A05D0,
+	0x0F120000,
+
+	0x002A0972,
+	0x0F120000,
+
+	0x002A0242,
+	0x0F120000,
+
+	0x002A024E,
+	0x0F120001,
+
+	0x002A0244,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Flash_init[] = {
+	0x002A0484,
+	0x0F120002,	/* capture flash on */
+
+	0x002A183A,
+	0x0F120001,	/* one frame AE*/
+
+	0x002A17F6,
+	0x0F120258,	/* AWB R point */
+	0x0F120228,	/* AWB B point */
+
+	0x002A1840,
+	0x0F120001,	/* Fls AE tune start */
+
+	0x0F120100,	/* fls_afl_FlsAFIn  Rin */
+	0x0F120120,
+	0x0F120180,
+	0x0F120200,
+	0x0F120400,
+	0x0F120800,
+	0x0F120A00,
+	0x0F121000,
+
+	0x0F120100,	/* fls_afl_FlsAFOut  Rout */
+	0x0F1200A0,
+	0x0F120090,
+	0x0F120080,
+	0x0F120070,
+	0x0F120045,
+	0x0F120030,
+	0x0F120010,
+
+	0x002A1884,
+	0x0F120100,	/* fls_afl_FlsNBOut  flash NB default */
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+	0x0F120100,
+
+	0x002A1826,
+
+	0x0F120100,	/* fls_afl_FlashWP_Weight  flash NB default */
+	0x0F1200C0,
+	0x0F120080,
+	0x0F12000A,
+	0x0F120000,
+
+	0x0F120030,	/* fls_afl_FlashWP_Weight  flash NB default */
+	0x0F120040,
+	0x0F120048,
+	0x0F120050,
+	0x0F120060,
+
+	0x002A4784,
+	0x0F1200A0,	/* TNP_Regs_FlsWeightRIn  weight tune start in*/
+	0x0F1200C0,
+	0x0F1200D0,
+	0x0F120100,
+	0x0F120200,
+	0x0F120300,
+
+	0x0F120088,	/* TNP_Regs_FlsWeightROut  weight tune start out*/
+	0x0F1200B0,
+	0x0F1200C0,
+	0x0F120100,
+	0x0F120200,
+	0x0F120300,
+
+	0x002A479C,
+
+	0x0F120120,	/*Fls  BRIn  */
+	0x0F120150,
+	0x0F120200,
+
+	0x0F12003C,	/* Fls  BROut*/
+	0x0F12003B,
+	0x0F120030,
+
+};
+
+static const u32 s5k4ecgx_Pre_Flash_Start[] = {
+	0x002A0588, /* set AE speed to fast */
+	0x0F120000,
+
+	0x002A17FC, /* fls_afl_FlashWP_Weight_0_  Pre_Flash_Start */
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Pre_Flash_End[] = {
+	0x002A0588, /* set AE speed to normal */
+	0x0F120002,
+
+	0x002A1800, /* fls_afl_FlashWP_Weight_0_  Pre_Flash_end */
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Flash_Start[] = {
+	0x002A17E8,	/* fls_afl_FlashMode : Flash alg start */
+	0x0F120001,
+
+	0x002A180C,	/* fls_afl_FlashWP_Weight_4_  flash br avg */
+	0x0F120027,
+};
+
+static const u32 s5k4ecgx_Flash_End[] = {
+	0x002A17E8,	/* fls_afl_FlashMode  Flash alg end */
+	0x0F120000,
+};
+
+/* 2560 x 1920 */
+static const u32 s5k4ecgx_5M_Capture[] = {
+	0x002A0398,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120009,
+
+	0x002A03B2,
+	0x0F120002,
+	0x002A03B0,
+	0x0F120002,
+	0x002A0270,
+	0x0F120001,
+};
+/* 2048 x 1536 */
+static const u32 s5k4ecgx_3M_Capture[] = {
+	0x002A0398,
+	0x0F120800,  /* REG_0TC_CCFG_usWidth */
+	0x0F120600,  /* REG_0TC_CCFG_usWidth */
+	0x0F120009,  /* REG_0TC_CCFG_Format */
+
+	0x002A03B2,
+	0x0F120002,  /* REG_0TC_CCFG_FrRateQualityType */
+	0x002A03B0,
+	0x0F120002,  /* REG_0TC_CCFG_usFrTimeType */
+	0x002A024E,
+	0x0F120001,  /* REG_TC_GP_NewConfigSync */
+	0x002A0270,
+	0x0F120001,  /* REG_TC_GP_CapConfigChanged */
+};
+/* 1600 x 1200 */
+static const u32 s5k4ecgx_2M_Capture[] = {
+	0x002A0398,
+	0x0F120640,
+	0x0F1204B0,
+	0x0F120009,
+	0x002A03B2,
+	0x0F120002,
+	0x002A03B0,
+	0x0F120002,
+	0x002A024E,
+	0x0F120001,
+	0x002A0270,
+	0x0F120001,
+};
+/* 1280 x 960 */
+static const u32 s5k4ecgx_1M_Capture[] = {
+	0x002A0398,
+	0x0F120500,
+	0x0F1203C0,
+	0x0F120009,
+	0x002A03B2,
+	0x0F120002,
+	0x002A03B0,
+	0x0F120002,
+	0x002A024E,
+	0x0F120001,
+	0x002A0270,
+	0x0F120001,
+};
+/* 640 x 480 */
+static const u32 s5k4ecgx_VGA_Capture[] = {
+	0x002A0398,
+	0x0F120280,
+	0x0F1201E0,
+	0x0F120009,
+	0x002A03B2,
+	0x0F120002,
+	0x002A03B0,
+	0x0F120002,
+	0x002A024E,
+	0x0F120001,
+	0x002A0270,
+	0x0F120001,
+};
+/* 720 x 480 */
+static const u32 s5k4ecgx_720_Preview[] = {
+	0x002A0250,
+	0x0F120A00,
+	0x0F1206A8,
+	0x0F120010,
+	0x0F120078,
+	0x0F120A00,
+	0x0F1206A8,
+	0x0F120010,
+	0x0F120078,
+	0x002A0494,
+	0x0F120A00,
+	0x0F1206A8,
+	0x0F120000,
+	0x0F120000,
+	0x0F120A00,
+	0x0F1206A8,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0262,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0A1E,
+	0x0F120028,
+	0x002A0AD4,
+	0x0F12003C,
+
+	0x002A02A6,
+	0x0F1202D0,
+	0x0F1201E0,
+	0x0F120005,
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+/* 640 x 480 */
+static const u32 s5k4ecgx_640_Preview[] = {
+	0x002A0250,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120010,
+	0x0F12000C,
+	0x002A0494,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+	0x0F120A00,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0262,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0A1E,
+	0x0F120028,
+	0x002A0AD4,
+	0x0F12003C,
+
+	0x002A02A6,
+	0x0F120280,
+	0x0F1201E0,
+	0x0F120005,
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014A, /* Flicker */
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+/* 352 x 288 */
+static const u32 s5k4ecgx_352_Preview[] = {
+	0x002A0250,
+	0x0F120928,
+	0x0F120780,
+	0x0F12007C,
+	0x0F12000C,
+	0x0F120928,
+	0x0F120780,
+	0x0F12007C,
+	0x0F12000C,
+	0x002A0494,
+	0x0F120928,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+	0x0F120928,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0262,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0A1E,
+	0x0F120028,
+	0x002A0AD4,
+	0x0F12003C,
+
+	0x002A02A6,
+	0x0F120160,
+	0x0F120120,
+	0x0F120005,
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+/* 176 x 144 */
+static const u32 s5k4ecgx_176_Preview[] = {
+	0x002A0250,
+	0x0F120928,
+	0x0F120780,
+	0x0F12007C,
+	0x0F12000C,
+	0x0F120928,
+	0x0F120780,
+	0x0F12007C,
+	0x0F12000C,
+	0x002A0494,
+	0x0F120928,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+	0x0F120928,
+	0x0F120780,
+	0x0F120000,
+	0x0F120000,
+
+	0x002A0262,
+	0x0F120001,
+	0x0F120001,
+
+	0x002A0A1E,
+	0x0F120028,
+	0x002A0AD4,
+	0x0F12003C,
+
+	0x002A02A6,
+	0x0F1200B0,
+	0x0F120090,
+	0x0F120005,
+	0x002A02B4,
+	0x0F120052,
+	0x002A02BE,
+	0x0F120000,
+	0x0F120001,
+	0x0F12029A,
+	0x0F12014D,
+	0x002A02D0,
+	0x0F120000,
+	0x0F120000,
+	0x002A0266,
+	0x0F120000,
+	0x002A026A,
+	0x0F120001,
+	0x002A024E,
+	0x0F120001,
+	0x002A0268,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_AE_AWB_Lock_On[] = {
+	0x002A2C5E,
+	0x0F120000,
+};
+
+static const u32 s5k4ecgx_AE_AWB_Lock_Off[] = {
+	0x002A2C5E,
+	0x0F120001,
+};
+
+static const u32 s5k4ecgx_Get_AE_Stable_Status[] = {
+	0x002E2C74,
+};
+
+static const u32 s5k4ecgx_Get_Light_Level[] = {
+	0x002C7000,
+	0x002E2C18,
+};
+
+static const u32 s5k4ecgx_get_1st_af_search_status[] = {
+	0x002E2EEE,
+};
+
+static const u32 s5k4ecgx_get_2nd_af_search_status[] = {
+	0x002E2207,
+};
+
+static const u32 s5k4ecgx_get_capture_status[] = {
+	0x002E0530,
+};
+
+static const u32 s5k4ecgx_get_esd_status[] = {
+	0xFCFCD000,
+	0x002CD000,
+	0x002E0060,
+};
+
+static const u32 s5k4ecgx_get_iso_reg[] = {
+	0x002C7000,
+	0x002E2BC4,
+};
+
+static const u32 s5k4ecgx_get_shutterspeed_reg[] = {
+	0x002C7000,
+	0x002E2BC0,
+};
+
+#endif /* __S5K4ECGX_REGS_1_0_H__ */
diff --git a/include/linux/videodev2_samsung.h b/include/linux/videodev2_samsung.h
index 639b124..3630ae3 100644
--- a/include/linux/videodev2_samsung.h
+++ b/include/linux/videodev2_samsung.h
@@ -1,7 +1,7 @@
 /*
  * Video for Linux Two header file for samsung
  *
- * Copyright (C) 2009, Dongsoo Nathaniel Kim<dongsoo45.kim@samsung.com>
+ * Copyright (C) 2009, Samsung Electronics
  *
  * This header file contains several v4l2 APIs to be proposed to v4l2
  * community and until bein accepted, will be used restrictly in Samsung's
@@ -387,10 +387,11 @@ enum v4l2_face_lock {
 enum v4l2_focusmode {
 	FOCUS_MODE_AUTO = 0,
 	FOCUS_MODE_MACRO,
-	FOCUS_MODE_FD,
+	FOCUS_MODE_FACEDETECT,
 	FOCUS_MODE_AUTO_DEFAULT,
 	FOCUS_MODE_MACRO_DEFAULT,
-	FOCUS_MODE_FD_DEFAULT,
+	FOCUS_MODE_FACEDETECT_DEFAULT,
+	FOCUS_MODE_INFINITY,
 	FOCUS_MODE_MAX,
 };
 
@@ -461,6 +462,8 @@ enum v4l2_slow_ae_mode {
 #define V4L2_CID_CAMERA_GET_ISO			(V4L2_CID_PRIVATE_BASE + 114)
 #define V4L2_CID_CAMERA_GET_SHT_TIME		(V4L2_CID_PRIVATE_BASE + 115)
 #define V4L2_CID_CAMERA_SENSOR_MODE		(V4L2_CID_PRIVATE_BASE + 116)
+#define V4L2_CID_ESD_INT			(V4L2_CID_PRIVATE_BASE + 117)
+#define V4L2_CID_CAMERA_GET_FLASH_ONOFF		(V4L2_CID_PRIVATE_BASE + 118)
 
 /* Pixel format FOURCC depth Description */
 /* 12  Y/CbCr 4:2:0 64x32 macroblocks */
@@ -596,4 +599,23 @@ struct v4l2_recognition {
 #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 flash_mode;
+	int focus_mode;
+	int iso;
+	int metering;
+	int saturation;
+	int scene_mode;
+	int sharpness;
+	int white_balance;
+	int fps;
+};
+
 #endif /* __LINUX_VIDEODEV2_SAMSUNG_H */
diff --git a/include/media/s5k4ecgx.h b/include/media/s5k4ecgx.h
new file mode 100644
index 0000000..3902ef5
--- /dev/null
+++ b/include/media/s5k4ecgx.h
@@ -0,0 +1,24 @@
+/* include/media/s5k4ecgx.h
+ *
+ * Copyright (C) 2010, SAMSUNG ELECTRONICS
+ *
+ * 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.
+ */
+
+#define S5K4ECGX_DRIVER_NAME	"S5K4ECGX"
+
+struct s5k4ecgx_platform_data {
+	unsigned int default_width;
+	unsigned int default_height;
+	unsigned int pixelformat;
+	int freq;	/* MCLK in Hz */
+
+	int (*flash_onoff)(int);
+	int (*af_assist_onoff)(int);
+	int (*torch_onoff)(int);
+};
+
+