From 067c248f8d4b7ff7dde27b91bd8e0d97b15b1b60 Mon Sep 17 00:00:00 2001
From: ddl <ddl@rockchip.com>
Date: Mon, 27 Dec 2010 14:53:26 +0800
Subject: [PATCH] camera:add ov7675 driver, add ov5642 A3907 AF firmware, fix
 ov5642 AF may be fail

---
 drivers/media/video/Kconfig              |    6 +-
 drivers/media/video/Makefile             |    1 +
 drivers/media/video/ov5642.c             |  485 +-
 drivers/media/video/ov5642_af_firmware.c | 5893 ++++++++++++----------
 drivers/media/video/ov7675.c             | 2439 +++++++++
 include/linux/videodev2.h                |    7 +-
 include/media/v4l2-chip-ident.h          |    1 +
 7 files changed, 6055 insertions(+), 2777 deletions(-)
 mode change 100644 => 100755 drivers/media/video/Kconfig
 mode change 100644 => 100755 drivers/media/video/Makefile
 create mode 100755 drivers/media/video/ov7675.c

diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
old mode 100644
new mode 100755
index 394cb0b745fc..1d1932181db6
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -864,7 +864,11 @@ config SOC_CAMERA_OV772X
 	depends on SOC_CAMERA && I2C
 	help
 	  This is a ov772x camera driver
-
+config SOC_CAMERA_OV7675
+	tristate "ov7675 camera support"
+	depends on SOC_CAMERA && I2C
+	help
+	  This is a ov7675 camera driver
 config SOC_CAMERA_OV2655
 	tristate "ov2655 camera support"
 	depends on SOC_CAMERA && I2C
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
old mode 100644
new mode 100755
index 71a0079fc218..01e90112e541
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -78,6 +78,7 @@ obj-$(CONFIG_SOC_CAMERA_MT9T031)	+= mt9t031.o
 obj-$(CONFIG_SOC_CAMERA_MT9V022)	+= mt9v022.o
 obj-$(CONFIG_SOC_CAMERA_OV772X)		+= ov772x.o
 obj-$(CONFIG_SOC_CAMERA_TW9910)		+= tw9910.o
+obj-$(CONFIG_SOC_CAMERA_OV7675)		+= ov7675.o
 obj-$(CONFIG_SOC_CAMERA_OV2655)		+= ov2655.o
 obj-$(CONFIG_SOC_CAMERA_OV2659)		+= ov2659.o
 obj-$(CONFIG_SOC_CAMERA_OV9650)		+= ov9650.o
diff --git a/drivers/media/video/ov5642.c b/drivers/media/video/ov5642.c
index d38d3af218e9..d80ddcd6e3b8 100644
--- a/drivers/media/video/ov5642.c
+++ b/drivers/media/video/ov5642.c
@@ -98,6 +98,15 @@
 #define SENSOR_AF_IS_ERR    (0x00<<0)
 #define SENSOR_AF_IS_OK		(0x01<<0)
 
+#if CONFIG_SENSOR_Focus
+#define SENSOR_AF_MODE_INFINITY    0
+#define SENSOR_AF_MODE_MACRO       1
+#define SENSOR_AF_MODE_FIXED       2
+#define SENSOR_AF_MODE_AUTO        3
+#define SENSOR_AF_MODE_CONTINUOUS  4
+#define SENSOR_AF_MODE_CLOSE       5
+#endif
+
 #if CONFIG_SENSOR_Focus
 /* ov5642 VCM Command and Status Registers */
 #define CMD_MAIN_Reg      0x3024
@@ -477,7 +486,324 @@ static struct reginfo sensor_init_data[] =
     {0x370d , 0x02},
     {0x3620 , 0x52},
     {0x3c00 , 0x04},
-    {0X0000 , 0x00}
+
+	{0x5001,0xFF},
+	{0x5583,0x50},
+	{0x5584,0x50},
+	{0x5580,0x02},
+	{0x3c01,0x80},
+	{0x3c00,0x04},
+	{0x5800,0x27},
+	{0x5801,0x22},
+	{0x5802,0x1b},
+	{0x5803,0x17},
+	{0x5804,0x16},
+	{0x5805,0x18},
+	{0x5806,0x20},
+	{0x5807,0x20},
+	{0x5808,0x1b},
+	{0x5809,0x15},
+	{0x580a,0x0f},
+	{0x580b,0x0d},
+	{0x580c,0x0d},
+	{0x580d,0x0e},
+	{0x580e,0x11},
+	{0x580f,0x18},
+	{0x5810,0x10},
+	{0x5811,0x0d},
+	{0x5812,0x08},
+	{0x5813,0x05},
+	{0x5814,0x04},
+	{0x5815,0x06},
+	{0x5816,0x09},
+	{0x5817,0x0e},
+	{0x5818,0x0d},
+	{0x5819,0x09},
+	{0x581a,0x03},
+	{0x581b,0x00},
+	{0x581c,0x00},
+	{0x581d,0x01},
+	{0x581e,0x05},
+	{0x581f,0x0b},
+	{0x5820,0x0d},
+	{0x5821,0x09},
+	{0x5822,0x03},
+	{0x5823,0x00},
+	{0x5824,0x00},
+	{0x5825,0x01},
+	{0x5826,0x05},
+	{0x5827,0x0b},
+	{0x5828,0x10},
+	{0x5829,0x0c},
+	{0x582a,0x08},
+	{0x582b,0x04},
+	{0x582c,0x03},
+	{0x582d,0x05},
+	{0x582e,0x09},
+	{0x582f,0x0e},
+	{0x5830,0x1b},
+	{0x5831,0x14},
+	{0x5832,0x0f},
+	{0x5833,0x0c},
+	{0x5834,0x0c},
+	{0x5835,0x0d},
+	{0x5836,0x10},
+	{0x5837,0x19},
+	{0x5838,0x25},
+	{0x5839,0x23},
+	{0x583a,0x1a},
+	{0x583b,0x16},
+	{0x583c,0x15},
+	{0x583d,0x18},
+	{0x583e,0x1f},
+	{0x583f,0x25},
+	{0x5840,0x10},
+	{0x5841,0x0e},
+	{0x5842,0x0e},
+	{0x5843,0x0e},
+	{0x5844,0x0f},
+	{0x5845,0x0a},
+	{0x5846,0x08},
+	{0x5847,0x0f},
+	{0x5848,0x0f},
+	{0x5849,0x0f},
+	{0x584a,0x0c},
+	{0x584b,0x0f},
+	{0x584c,0x09},
+	{0x584d,0x10},
+	{0x584e,0x11},
+	{0x584f,0x10},
+	{0x5850,0x0f},
+	{0x5851,0x0e},
+	{0x5852,0x08},
+	{0x5853,0x10},
+	{0x5854,0x10},
+	{0x5855,0x10},
+	{0x5856,0x0e},
+	{0x5857,0x0e},
+	{0x5858,0x0a},
+	{0x5859,0x0e},
+	{0x585a,0x0e},
+	{0x585b,0x0e},
+	{0x585c,0x0e},
+	{0x585d,0x0d},
+	{0x585e,0x08},
+	{0x585f,0x0b},
+	{0x5860,0x0a},
+	{0x5861,0x0a},
+	{0x5862,0x09},
+	{0x5863,0x0d},
+	{0x5864,0x13},
+	{0x5865,0x0e},
+	{0x5866,0x10},
+	{0x5867,0x10},
+	{0x5868,0x0e},
+	{0x5869,0x11},
+	{0x586a,0x12},
+	{0x586b,0x10},
+	{0x586c,0x10},
+	{0x586d,0x10},
+	{0x586e,0x10},
+	{0x586f,0x11},
+	{0x5870,0x15},
+	{0x5871,0x10},
+	{0x5872,0x10},
+	{0x5873,0x10},
+	{0x5874,0x11},
+	{0x5875,0x11},
+	{0x5876,0x14},
+	{0x5877,0x0f},
+	{0x5878,0x10},
+	{0x5879,0x10},
+	{0x587a,0x10},
+	{0x587b,0x11},
+	{0x587c,0x12},
+	{0x587d,0x0f},
+	{0x587e,0x0f},
+	{0x587f,0x10},
+	{0x5880,0x10},
+	{0x5881,0x0f},
+	{0x5882,0x12},
+	{0x5883,0x0e},
+	{0x5884,0x10},
+	{0x5885,0x10},
+	{0x5886,0x0e},
+	{0x5887,0x0e},
+	{0x5180,0xff},
+	{0x5181,0x52},
+	{0x5182,0x11},
+	{0x5183,0x14},
+	{0x5184,0x25},
+	{0x5185,0x24},
+	{0x5186,0x14},
+	{0x5187,0x14},
+	{0x5188,0x14},
+	{0x5189,0x6c},
+	{0x518a,0x60},
+	{0x518b,0xbd},
+	{0x518c,0x9c},
+	{0x518d,0x3d},
+	{0x518e,0x34},
+	{0x518f,0x57},
+	{0x5190,0x4a},
+	{0x5191,0xf8},
+	{0x5192,0x04},
+	{0x5193,0x70},
+	{0x5194,0xf0},
+	{0x5195,0xf0},
+	{0x5196,0x03},
+	{0x5197,0x01},
+	{0x5198,0x04},
+	{0x5199,0x00},
+	{0x519a,0x04},
+	{0x519b,0x35},
+	{0x519c,0x08},
+	{0x519d,0xb8},
+	{0x519e,0xa0},
+	{0x528a,0x00},
+	{0x528b,0x01},
+	{0x528c,0x04},
+	{0x528d,0x08},
+	{0x528e,0x10},
+	{0x528f,0x20},
+	{0x5290,0x30},
+	{0x5292,0x00},
+	{0x5293,0x00},
+	{0x5294,0x00},
+	{0x5295,0x01},
+	{0x5296,0x00},
+	{0x5297,0x04},
+	{0x5298,0x00},
+	{0x5299,0x08},
+	{0x529a,0x00},
+	{0x529b,0x10},
+	{0x529c,0x00},
+	{0x529d,0x20},
+	{0x529e,0x00},
+	{0x529f,0x30},
+	{0x5282,0x00},
+	{0x5300,0x00},
+	{0x5301,0x20},
+	{0x5302,0x00},
+	{0x5303,0x7c},
+	{0x530c,0x00},
+	{0x530d,0x10},
+	{0x530e,0x20},
+	{0x530f,0x80},
+	{0x5310,0x20},
+	{0x5311,0x80},
+	{0x5308,0x20},
+	{0x5309,0x40},
+	{0x5304,0x00},
+	{0x5305,0x30},
+	{0x5306,0x00},
+	{0x5307,0x80},
+	{0x5314,0x08},
+	{0x5315,0x20},
+	{0x5319,0x30},
+	{0x5316,0x10},
+	{0x5317,0x00},
+	{0x5318,0x02},
+	{0x5380,0x01},
+	{0x5381,0x00},
+	{0x5382,0x00},
+	{0x5383,0x1f},
+	{0x5384,0x00},
+	{0x5385,0x06},
+	{0x5386,0x00},
+	{0x5387,0x00},
+	{0x5388,0x00},
+	{0x5389,0xE1},
+	{0x538A,0x00},
+	{0x538B,0x2B},
+	{0x538C,0x00},
+	{0x538D,0x00},
+	{0x538E,0x00},
+	{0x538F,0x10},
+	{0x5390,0x00},
+	{0x5391,0xB3},
+	{0x5392,0x00},
+	{0x5393,0xA6},
+	{0x5394,0x08},
+	{0x5480,0x14},
+	{0x5481,0x21},
+	{0x5482,0x36},
+	{0x5483,0x57},
+	{0x5484,0x65},
+	{0x5485,0x71},
+	{0x5486,0x7D},
+	{0x5487,0x87},
+	{0x5488,0x91},
+	{0x5489,0x9A},
+	{0x548A,0xAA},
+	{0x548B,0xB8},
+	{0x548C,0xCD},
+	{0x548D,0xDD},
+	{0x548E,0xEA},
+	{0x548F,0x1d},
+	{0x5490,0x05},
+	{0x5491,0x00},
+	{0x5492,0x04},
+	{0x5493,0x20},
+	{0x5494,0x03},
+	{0x5495,0x60},
+	{0x5496,0x02},
+	{0x5497,0xB8},
+	{0x5498,0x02},
+	{0x5499,0x86},
+	{0x549A,0x02},
+	{0x549B,0x5B},
+	{0x549C,0x02},
+	{0x549D,0x3B},
+	{0x549E,0x02},
+	{0x549F,0x1C},
+	{0x54A0,0x02},
+	{0x54A1,0x04},
+	{0x54A2,0x01},
+	{0x54A3,0xED},
+	{0x54A4,0x01},
+	{0x54A5,0xC5},
+	{0x54A6,0x01},
+	{0x54A7,0xA5},
+	{0x54A8,0x01},
+	{0x54A9,0x6C},
+	{0x54AA,0x01},
+	{0x54AB,0x41},
+	{0x54AC,0x01},
+	{0x54AD,0x20},
+	{0x54AE,0x00},
+	{0x54AF,0x16},
+	{0x54B0,0x01},
+	{0x54B1,0x20},
+	{0x54B2,0x00},
+	{0x54B3,0x10},
+	{0x54B4,0x00},
+	{0x54B5,0xf0},
+	{0x54B6,0x00},
+	{0x54B7,0xDF},
+	{0x5402,0x3f},
+	{0x5403,0x00},
+	{0x5500,0x10},
+	{0x5502,0x00},
+	{0x5503,0x06},
+	{0x5504,0x00},
+	{0x5505,0x7f},
+	{0x5025,0x80},
+	{0x3a0f,0x30},
+	{0x3a10,0x28},
+	{0x3a1b,0x30},
+	{0x3a1e,0x28},
+	{0x3a11,0x61},
+	{0x3a1f,0x10},
+	{0x5688,0xfd},
+	{0x5689,0xdf},
+	{0x568a,0xfe},
+	{0x568b,0xef},
+	{0x568c,0xfe},
+	{0x568d,0xef},
+	{0x568e,0xaa},
+	{0x568f,0xaa},
+    {0x0000,0x00}
 
 };
 /* 2592X1944 QSXGA */
@@ -1224,6 +1550,14 @@ static const struct v4l2_queryctrl sensor_controls[] =
         .maximum	= 1,
         .step		= 1,
         .default_value = 0,
+    },{
+        .id		= V4L2_CID_FOCUS_CONTINUOUS,
+        .type		= V4L2_CTRL_TYPE_BOOLEAN,
+        .name		= "Focus Control",
+        .minimum	= 0,
+        .maximum	= 1,
+        .step		= 1,
+        .default_value = 0,
     },
     #endif
 
@@ -1419,6 +1753,7 @@ struct af_cmdinfo
 static int sensor_af_cmdset(struct i2c_client *client, int cmd_main, struct af_cmdinfo *cmdinfo)
 {
 	int i;
+	char read_tag=0xff,cnt;
 
 	if (cmdinfo) {
 		if (cmdinfo->validate_bit & 0x80) {
@@ -1449,16 +1784,59 @@ static int sensor_af_cmdset(struct i2c_client *client, int cmd_main, struct af_c
 		SENSOR_TR("%s write CMD_MAIN_Reg(main:0x%x) error!\n",SENSOR_NAME_STRING(),cmd_main);
 		goto sensor_af_cmdset_err;
 	}
-	SENSOR_DG("%s write CMD_MAIN_Reg(main:0x%x) success!\n",SENSOR_NAME_STRING(),cmd_main);
+
+	cnt = 0;
+	do
+	{
+		msleep(5);
+		if (sensor_read(client,CMD_TAG_Reg,&read_tag)){
+		   SENSOR_TR("%s[%d] read TAG failed\n",SENSOR_NAME_STRING(),__LINE__);
+		   break;
+		}
+    } while((read_tag != 0x00)&& (cnt++<100));
+
+	SENSOR_DG("%s write CMD_MAIN_Reg(main:0x%x read tag:0x%x) success!\n",SENSOR_NAME_STRING(),cmd_main,read_tag);
 	return 0;
 sensor_af_cmdset_err:
 	return -1;
 }
+
+static int sensor_af_idlechk(struct i2c_client *client)
+{
+	int ret = 0;
+	char state,cnt;
+
+	cnt = 0;
+	do
+	{
+		ret = sensor_read(client, STA_FOCUS_Reg, &state);
+		if (ret != 0){
+		   SENSOR_TR("%s[%d] read focus_status failed\n",SENSOR_NAME_STRING(),__LINE__);
+		   ret = -1;
+		   goto sensor_af_idlechk_end;
+		}
+
+		if (state != S_IDLE) {
+			sensor_af_cmdset(client, ReturnIdle_Cmd, NULL);
+			msleep(1);
+			cnt++;
+		}
+    } while((state != S_IDLE)&& (cnt<100));
+
+	ret = (state == S_IDLE) ? 0 : -1;
+
+sensor_af_idlechk_end:
+	return ret;
+}
+
 static int sensor_af_single(struct i2c_client *client)
 {
 	int ret = 0;
 	char state,cnt;
 
+	if (sensor_af_idlechk(client))
+		goto sensor_af_single_end;
+
 	if (sensor_af_cmdset(client, SingleFocus_Cmd, NULL)) {
 		SENSOR_TR("%s single focus mode set error!\n",SENSOR_NAME_STRING());
 		ret = -1;
@@ -1495,6 +1873,9 @@ static int sensor_af_const(struct i2c_client *client)
 {
 	int ret = 0;
 
+	if (sensor_af_idlechk(client))
+		goto sensor_af_const_end;
+
 	if (sensor_af_cmdset(client, ConstFocus_Cmd, NULL)) {
 		SENSOR_TR("%s const focus mode set error!\n",SENSOR_NAME_STRING());
 		ret = -1;
@@ -1541,6 +1922,9 @@ static int sensor_af_zoneupdate(struct i2c_client *client)
 {
 	int ret = 0;
 
+	if (sensor_af_idlechk(client))
+		goto sensor_af_zoneupdate_end;
+
 	if (sensor_af_cmdset(client, UpdateZone_Cmd, NULL)) {
 		SENSOR_TR("%s update zone fail!\n",SENSOR_NAME_STRING());
 		ret = -1;
@@ -1575,7 +1959,7 @@ static int sensor_af_init(struct i2c_client *client)
 		   ret = -1;
 		   goto sensor_af_init_end;
 		}
-    }while((state == S_STARTUP) && (cnt<50));
+    }while((state == S_STARTUP) && (cnt<100));
 
     if (state != S_IDLE) {
         SENSOR_TR("%s focus state(0x%x) is error!\n",SENSOR_NAME_STRING(),state);
@@ -1922,9 +2306,9 @@ static int sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
         }
 
         sensor->info_priv.winseqe_cur_addr  = (int)winseqe_set_addr;
-        #if CONFIG_SENSOR_Focus
-		sensor_af_zoneupdate(client);
-		#endif
+        //#if CONFIG_SENSOR_Focus
+		//sensor_af_zoneupdate(client);
+		//#endif
 
 
         SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,set_w,set_h);
@@ -2248,11 +2632,16 @@ static int sensor_set_focus_absolute(struct soc_camera_device *icd, const struct
 		return -EINVAL;
 
 	if (sensor->info_priv.funmodule_state & SENSOR_AF_IS_OK) {
-		if ((value >= qctrl->minimum) && (value <= qctrl->maximum)) {
+		if ((value >= qctrl_info->minimum) && (value <= qctrl_info->maximum)) {
+
+			if (sensor_af_idlechk(client))
+				goto sensor_set_focus_absolute_end;
+
 			cmdinfo.cmd_tag = StepFocus_Spec_Tag;
 			cmdinfo.cmd_para[0] = value;
 			cmdinfo.validate_bit = 0x81;
 			ret = sensor_af_cmdset(client, StepMode_Cmd, &cmdinfo);
+			//ret |= sensor_af_cmdset(client, ReturnIdle_Cmd, NULL);
 			SENSOR_DG("%s..%s : %d  ret:0x%x\n",SENSOR_NAME_STRING(),__FUNCTION__, value,ret);
 		} else {
 			ret = -EINVAL;
@@ -2263,6 +2652,7 @@ static int sensor_set_focus_absolute(struct soc_camera_device *icd, const struct
 		SENSOR_TR("\n %s..%s AF module state is error!\n",SENSOR_NAME_STRING(),__FUNCTION__);
 	}
 
+sensor_set_focus_absolute_end:
 	return ret;
 }
 static int sensor_set_focus_relative(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
@@ -2278,7 +2668,11 @@ static int sensor_set_focus_relative(struct soc_camera_device *icd, const struct
 		return -EINVAL;
 
 	if (sensor->info_priv.funmodule_state & SENSOR_AF_IS_OK) {
-		if ((value >= qctrl->minimum) && (value <= qctrl->maximum)) {
+		if ((value >= qctrl_info->minimum) && (value <= qctrl_info->maximum)) {
+
+			if (sensor_af_idlechk(client))
+				goto sensor_set_focus_relative_end;
+
 			if (value > 0) {
 				cmdinfo.cmd_tag = StepFocus_Near_Tag;
 			} else if (value < 0) {
@@ -2286,6 +2680,7 @@ static int sensor_set_focus_relative(struct soc_camera_device *icd, const struct
 			}
 			cmdinfo.validate_bit = 0x80;
 			ret = sensor_af_cmdset(client, StepMode_Cmd, &cmdinfo);
+
 			SENSOR_DG("%s..%s : %d  ret:0x%x\n",SENSOR_NAME_STRING(),__FUNCTION__, value,ret);
 		} else {
 			ret = -EINVAL;
@@ -2295,23 +2690,48 @@ static int sensor_set_focus_relative(struct soc_camera_device *icd, const struct
 		ret = -EACCES;
 		SENSOR_TR("\n %s..%s AF module state is error!\n",SENSOR_NAME_STRING(),__FUNCTION__);
 	}
-
+sensor_set_focus_relative_end:
 	return ret;
 }
 
-static int sensor_set_focus_auto(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+static int sensor_set_focus_mode(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
 {
 	struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
 	struct sensor *sensor = to_sensor(client);
-	const struct v4l2_queryctrl *qctrl_info;
 	int ret = 0;
 
-	qctrl_info = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FOCUS_AUTO);
-	if (!qctrl_info)
-		return -EINVAL;
-
 	if (sensor->info_priv.funmodule_state & SENSOR_AF_IS_OK) {
-		ret = sensor_af_const(client);
+		switch (value)
+		{
+			case SENSOR_AF_MODE_AUTO:
+			{
+				ret = sensor_af_single(client);
+				break;
+			}
+
+			case SENSOR_AF_MODE_MACRO:
+			{
+				ret = sensor_set_focus_absolute(icd, qctrl, 0xff);
+				break;
+			}
+
+			case SENSOR_AF_MODE_INFINITY:
+			{
+				ret = sensor_set_focus_absolute(icd, qctrl, 0x00);
+				break;
+			}
+
+			case SENSOR_AF_MODE_CONTINUOUS:
+			{
+				ret = sensor_af_const(client);
+				break;
+			}
+			default:
+				SENSOR_TR("\n %s..%s AF value(0x%x) is error!\n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+				break;
+
+		}
+
 		SENSOR_DG("%s..%s : %d  ret:0x%x\n",SENSOR_NAME_STRING(),__FUNCTION__, value,ret);
 	} else {
 		ret = -EACCES;
@@ -2631,7 +3051,15 @@ static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_c
                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
                     return -EINVAL;
 
-				sensor_set_focus_absolute(icd, qctrl,ext_ctrl->value);
+				if (sensor_set_focus_absolute(icd, qctrl,ext_ctrl->value) == 0) {
+					if (ext_ctrl->value == qctrl->minimum) {
+						sensor->info_priv.auto_focus = SENSOR_AF_MODE_INFINITY;
+					} else if (ext_ctrl->value == qctrl->maximum) {
+						sensor->info_priv.auto_focus = SENSOR_AF_MODE_MACRO;
+					} else {
+						sensor->info_priv.auto_focus = SENSOR_AF_MODE_FIXED;
+					}
+				}
 
                 break;
             }
@@ -2645,10 +3073,27 @@ static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_c
             }
 		case V4L2_CID_FOCUS_AUTO:
 			{
-				if (ext_ctrl->value != sensor->info_priv.auto_focus) {
-					if (sensor_set_focus_auto(icd, qctrl,ext_ctrl->value) != 0)
+				if (ext_ctrl->value == 1) {
+					if (sensor_set_focus_mode(icd, qctrl,SENSOR_AF_MODE_AUTO) != 0)
 						return -EINVAL;
-					sensor->info_priv.auto_focus = ext_ctrl->value;
+					sensor->info_priv.auto_focus = SENSOR_AF_MODE_AUTO;
+				} else if (SENSOR_AF_MODE_AUTO == sensor->info_priv.auto_focus){
+					if (ext_ctrl->value == 0)
+						sensor->info_priv.auto_focus = SENSOR_AF_MODE_CLOSE;
+				}
+				break;
+			}
+		case V4L2_CID_FOCUS_CONTINUOUS:
+			{
+				if (SENSOR_AF_MODE_CONTINUOUS != sensor->info_priv.auto_focus) {
+					if (ext_ctrl->value == 1) {
+						if (sensor_set_focus_mode(icd, qctrl,SENSOR_AF_MODE_CONTINUOUS) != 0)
+							return -EINVAL;
+						sensor->info_priv.auto_focus = SENSOR_AF_MODE_CONTINUOUS;
+					}
+				} else {
+					if (ext_ctrl->value == 0)
+						sensor->info_priv.auto_focus = SENSOR_AF_MODE_CLOSE;
 				}
 				break;
 			}
diff --git a/drivers/media/video/ov5642_af_firmware.c b/drivers/media/video/ov5642_af_firmware.c
index 7c7649cf9d6a..4ee405a75b6e 100644
--- a/drivers/media/video/ov5642_af_firmware.c
+++ b/drivers/media/video/ov5642_af_firmware.c
@@ -9,16 +9,12 @@
  */
 #include "ov5642.h"
 
-/*
- * A3907 is compatible with AD5820
- */
 #define VCM_DRIVER_A3907   0
 #define VCM_DRIVER_AD5820  1
 #define VCM_DRIVER_DW9710  2
-#define VCM_DRIVER         VCM_DRIVER_AD5820
+#define VCM_DRIVER         VCM_DRIVER_A3907
 
 #if (VCM_DRIVER == VCM_DRIVER_A3907)
-/* Not support const-focus */
 struct reginfo sensor_af_firmware[] =
 {
 	{0x3000,0x20},
@@ -26,8 +22,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x8001,0x00},
 	{0x8002,0x06},
 	{0x8003,0x02},
-	{0x8004,0x0b},
-	{0x8005,0x6c},
+	{0x8004,0x0d},
+	{0x8005,0xd1},
 	{0x8006,0x78},
 	{0x8007,0x7f},
 	{0x8008,0xe4},
@@ -38,12 +34,12 @@ struct reginfo sensor_af_firmware[] =
 	{0x800d,0x81},
 	{0x800e,0x7e},
 	{0x800f,0x02},
-	{0x8010,0x14},
-	{0x8011,0x3f},
+	{0x8010,0x15},
+	{0x8011,0x5f},
 	{0x8012,0x00},
 	{0x8013,0x02},
-	{0x8014,0x13},
-	{0x8015,0x6a},
+	{0x8014,0x15},
+	{0x8015,0xab},
 	{0x8016,0xe0},
 	{0x8017,0xf5},
 	{0x8018,0x72},
@@ -466,45 +462,45 @@ struct reginfo sensor_af_firmware[] =
 	{0x81b9,0x8c},
 	{0x81ba,0x3c},
 	{0x81bb,0x22},
-	{0x81bc,0xe5},
-	{0x81bd,0x0b},
-	{0x81be,0x24},
-	{0x81bf,0x01},
-	{0x81c0,0xff},
-	{0x81c1,0xe4},
-	{0x81c2,0x33},
-	{0x81c3,0xfe},
-	{0x81c4,0x22},
-	{0x81c5,0xaf},
-	{0x81c6,0x2b},
-	{0x81c7,0xae},
-	{0x81c8,0x2a},
-	{0x81c9,0xad},
-	{0x81ca,0x29},
-	{0x81cb,0xac},
-	{0x81cc,0x28},
-	{0x81cd,0x78},
-	{0x81ce,0x06},
-	{0x81cf,0x12},
-	{0x81d0,0x09},
-	{0x81d1,0xb8},
-	{0x81d2,0x8f},
-	{0x81d3,0x2b},
-	{0x81d4,0x8e},
-	{0x81d5,0x2a},
-	{0x81d6,0x8d},
-	{0x81d7,0x29},
-	{0x81d8,0x8c},
-	{0x81d9,0x28},
-	{0x81da,0xd3},
+	{0x81bc,0xaf},
+	{0x81bd,0x2b},
+	{0x81be,0xae},
+	{0x81bf,0x2a},
+	{0x81c0,0xad},
+	{0x81c1,0x29},
+	{0x81c2,0xac},
+	{0x81c3,0x28},
+	{0x81c4,0x78},
+	{0x81c5,0x06},
+	{0x81c6,0x12},
+	{0x81c7,0x09},
+	{0x81c8,0xb8},
+	{0x81c9,0x8f},
+	{0x81ca,0x2b},
+	{0x81cb,0x8e},
+	{0x81cc,0x2a},
+	{0x81cd,0x8d},
+	{0x81ce,0x29},
+	{0x81cf,0x8c},
+	{0x81d0,0x28},
+	{0x81d1,0xd3},
+	{0x81d2,0xe5},
+	{0x81d3,0x29},
+	{0x81d4,0x94},
+	{0x81d5,0x00},
+	{0x81d6,0xe5},
+	{0x81d7,0x28},
+	{0x81d8,0x94},
+	{0x81d9,0x00},
+	{0x81da,0x22},
 	{0x81db,0xe5},
-	{0x81dc,0x29},
-	{0x81dd,0x94},
-	{0x81de,0x00},
-	{0x81df,0xe5},
-	{0x81e0,0x28},
-	{0x81e1,0x94},
-	{0x81e2,0x00},
+	{0x81dc,0x0b},
+	{0x81dd,0x24},
+	{0x81de,0x01},
+	{0x81df,0xff},
+	{0x81e0,0xe4},
+	{0x81e1,0x33},
+	{0x81e2,0xfe},
 	{0x81e3,0x22},
 	{0x81e4,0x85},
 	{0x81e5,0x0d},
@@ -681,8 +677,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x8290,0x0a},
 	{0x8291,0x22},
 	{0x8292,0x90},
-	{0x8293,0x11},
-	{0x8294,0x91},
+	{0x8293,0x12},
+	{0x8294,0x67},
 	{0x8295,0xe4},
 	{0x8296,0x93},
 	{0x8297,0xff},
@@ -718,13 +714,13 @@ struct reginfo sensor_af_firmware[] =
 	{0x82b5,0x22},
 	{0x82b6,0xd3},
 	{0x82b7,0xe5},
-	{0x82b8,0x69},
+	{0x82b8,0x0b},
 	{0x82b9,0x94},
 	{0x82ba,0xff},
 	{0x82bb,0xe5},
-	{0x82bc,0x68},
+	{0x82bc,0x0a},
 	{0x82bd,0x94},
-	{0x82be,0x03},
+	{0x82be,0x00},
 	{0x82bf,0x22},
 	{0x82c0,0x30},
 	{0x82c1,0x18},
@@ -1058,7 +1054,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x8409,0x0b},
 	{0x840a,0x12},
 	{0x840b,0x01},
-	{0x840c,0xbc},
+	{0x840c,0xdb},
 	{0x840d,0xe5},
 	{0x840e,0x4e},
 	{0x840f,0xb5},
@@ -1093,7 +1089,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x842c,0x1e},
 	{0x842d,0x12},
 	{0x842e,0x01},
-	{0x842f,0xbc},
+	{0x842f,0xdb},
 	{0x8430,0xe5},
 	{0x8431,0x4c},
 	{0x8432,0xb5},
@@ -1128,7 +1124,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x844f,0x1c},
 	{0x8450,0x12},
 	{0x8451,0x01},
-	{0x8452,0xbc},
+	{0x8452,0xdb},
 	{0x8453,0xe5},
 	{0x8454,0x4a},
 	{0x8455,0xb5},
@@ -1149,7 +1145,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x8464,0x4e},
 	{0x8465,0x12},
 	{0x8466,0x01},
-	{0x8467,0xbe},
+	{0x8467,0xdd},
 	{0x8468,0xad},
 	{0x8469,0x0b},
 	{0x846a,0x7c},
@@ -1173,7 +1169,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x847c,0x4d},
 	{0x847d,0x12},
 	{0x847e,0x01},
-	{0x847f,0xbe},
+	{0x847f,0xdd},
 	{0x8480,0xef},
 	{0x8481,0xb5},
 	{0x8482,0x05},
@@ -1193,7 +1189,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x8490,0x4c},
 	{0x8491,0x12},
 	{0x8492,0x01},
-	{0x8493,0xbe},
+	{0x8493,0xdd},
 	{0x8494,0xad},
 	{0x8495,0x0b},
 	{0x8496,0x7c},
@@ -1217,7 +1213,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x84a8,0x4b},
 	{0x84a9,0x12},
 	{0x84aa,0x01},
-	{0x84ab,0xbe},
+	{0x84ab,0xdd},
 	{0x84ac,0xef},
 	{0x84ad,0xb5},
 	{0x84ae,0x05},
@@ -1237,7 +1233,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x84bc,0x4a},
 	{0x84bd,0x12},
 	{0x84be,0x01},
-	{0x84bf,0xbe},
+	{0x84bf,0xdd},
 	{0x84c0,0x7c},
 	{0x84c1,0x00},
 	{0x84c2,0xef},
@@ -1334,14 +1330,14 @@ struct reginfo sensor_af_firmware[] =
 	{0x851d,0x0b},
 	{0x851e,0x03},
 	{0x851f,0x02},
-	{0x8520,0x15},
-	{0x8521,0xa1},
+	{0x8520,0x16},
+	{0x8521,0xf7},
 	{0x8522,0x85},
 	{0x8523,0x0b},
 	{0x8524,0x0c},
 	{0x8525,0x12},
 	{0x8526,0x0e},
-	{0x8527,0xa9},
+	{0x8527,0xf9},
 	{0x8528,0xd2},
 	{0x8529,0x02},
 	{0x852a,0xc2},
@@ -1392,8 +1388,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x8557,0xf5},
 	{0x8558,0x0a},
 	{0x8559,0x12},
-	{0x855a,0x11},
-	{0x855b,0xfa},
+	{0x855a,0x13},
+	{0x855b,0x9c},
 	{0x855c,0x02},
 	{0x855d,0x06},
 	{0x855e,0xcb},
@@ -1404,9 +1400,9 @@ struct reginfo sensor_af_firmware[] =
 	{0x8563,0x06},
 	{0x8564,0xe3},
 	{0x8565,0xc2},
-	{0x8566,0x3a},
+	{0x8566,0x3c},
 	{0x8567,0xd2},
-	{0x8568,0x39},
+	{0x8568,0x3b},
 	{0x8569,0x02},
 	{0x856a,0x06},
 	{0x856b,0xdc},
@@ -1417,40 +1413,40 @@ struct reginfo sensor_af_firmware[] =
 	{0x8570,0x06},
 	{0x8571,0xe3},
 	{0x8572,0xd2},
-	{0x8573,0x3a},
+	{0x8573,0x3c},
 	{0x8574,0xc2},
-	{0x8575,0x39},
+	{0x8575,0x3b},
 	{0x8576,0x02},
 	{0x8577,0x06},
 	{0x8578,0xdc},
 	{0x8579,0x30},
-	{0x857a,0x36},
+	{0x857a,0x38},
 	{0x857b,0x0c},
 	{0x857c,0x20},
-	{0x857d,0x3a},
+	{0x857d,0x3c},
 	{0x857e,0x03},
 	{0x857f,0x30},
-	{0x8580,0x39},
+	{0x8580,0x3b},
 	{0x8581,0x06},
 	{0x8582,0xe4},
 	{0x8583,0xf5},
 	{0x8584,0x0a},
 	{0x8585,0x12},
-	{0x8586,0x13},
-	{0x8587,0x1b},
+	{0x8586,0x15},
+	{0x8587,0x10},
 	{0x8588,0xd2},
 	{0x8589,0x18},
 	{0x858a,0xc2},
 	{0x858b,0x19},
 	{0x858c,0x22},
 	{0x858d,0x30},
-	{0x858e,0x36},
+	{0x858e,0x38},
 	{0x858f,0x09},
 	{0x8590,0x20},
-	{0x8591,0x3a},
+	{0x8591,0x3c},
 	{0x8592,0x03},
 	{0x8593,0x30},
-	{0x8594,0x39},
+	{0x8594,0x3b},
 	{0x8595,0x03},
 	{0x8596,0x12},
 	{0x8597,0x06},
@@ -1461,30 +1457,30 @@ struct reginfo sensor_af_firmware[] =
 	{0x859c,0x19},
 	{0x859d,0x22},
 	{0x859e,0x30},
-	{0x859f,0x36},
+	{0x859f,0x38},
 	{0x85a0,0x0c},
 	{0x85a1,0x20},
-	{0x85a2,0x3a},
+	{0x85a2,0x3c},
 	{0x85a3,0x03},
 	{0x85a4,0x30},
-	{0x85a5,0x39},
+	{0x85a5,0x3b},
 	{0x85a6,0x06},
 	{0x85a7,0x75},
 	{0x85a8,0x0a},
 	{0x85a9,0x02},
 	{0x85aa,0x12},
-	{0x85ab,0x13},
-	{0x85ac,0x1b},
+	{0x85ab,0x15},
+	{0x85ac,0x10},
 	{0x85ad,0xc2},
 	{0x85ae,0x18},
 	{0x85af,0xd2},
 	{0x85b0,0x19},
 	{0x85b1,0x22},
 	{0x85b2,0x20},
-	{0x85b3,0x3a},
+	{0x85b3,0x3c},
 	{0x85b4,0x06},
 	{0x85b5,0x20},
-	{0x85b6,0x39},
+	{0x85b6,0x3b},
 	{0x85b7,0x03},
 	{0x85b8,0x02},
 	{0x85b9,0x06},
@@ -1531,8 +1527,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x85e2,0x0a},
 	{0x85e3,0x02},
 	{0x85e4,0x02},
-	{0x85e5,0x13},
-	{0x85e6,0x1b},
+	{0x85e5,0x15},
+	{0x85e6,0x10},
 	{0x85e7,0xe5},
 	{0x85e8,0x68},
 	{0x85e9,0xd3},
@@ -1768,26 +1764,26 @@ struct reginfo sensor_af_firmware[] =
 	{0x86cf,0x0a},
 	{0x86d0,0x01},
 	{0x86d1,0x12},
-	{0x86d2,0x13},
-	{0x86d3,0x1b},
+	{0x86d2,0x15},
+	{0x86d3,0x10},
 	{0x86d4,0xd2},
 	{0x86d5,0x18},
 	{0x86d6,0xd2},
 	{0x86d7,0x19},
 	{0x86d8,0xc2},
-	{0x86d9,0x3a},
+	{0x86d9,0x3c},
 	{0x86da,0xc2},
-	{0x86db,0x39},
+	{0x86db,0x3b},
 	{0x86dc,0xd2},
 	{0x86dd,0x1a},
 	{0x86de,0xd2},
-	{0x86df,0x36},
+	{0x86df,0x38},
 	{0x86e0,0xd2},
 	{0x86e1,0x30},
 	{0x86e2,0x22},
 	{0x86e3,0x12},
-	{0x86e4,0x11},
-	{0x86e5,0xfa},
+	{0x86e4,0x13},
+	{0x86e5,0x9c},
 	{0x86e6,0x75},
 	{0x86e7,0x79},
 	{0x86e8,0x02},
@@ -1795,8 +1791,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x86ea,0xf5},
 	{0x86eb,0x0a},
 	{0x86ec,0x12},
-	{0x86ed,0x13},
-	{0x86ee,0x1b},
+	{0x86ed,0x15},
+	{0x86ee,0x10},
 	{0x86ef,0xd2},
 	{0x86f0,0x18},
 	{0x86f1,0xc2},
@@ -1806,8 +1802,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x86f5,0x0a},
 	{0x86f6,0x01},
 	{0x86f7,0x12},
-	{0x86f8,0x13},
-	{0x86f9,0x1b},
+	{0x86f8,0x15},
+	{0x86f9,0x10},
 	{0x86fa,0x22},
 	{0x86fb,0x90},
 	{0x86fc,0x38},
@@ -2811,8 +2807,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x8ae2,0x12},
 	{0x8ae3,0x14},
 	{0x8ae4,0x12},
-	{0x8ae5,0x13},
-	{0x8ae6,0xfb},
+	{0x8ae5,0x16},
+	{0x8ae6,0x3c},
 	{0x8ae7,0xc2},
 	{0x8ae8,0x09},
 	{0x8ae9,0x12},
@@ -2935,8 +2931,8 @@ struct reginfo sensor_af_firmware[] =
 	{0x8b5e,0x27},
 	{0x8b5f,0x22},
 	{0x8b60,0x12},
-	{0x8b61,0x13},
-	{0x8b62,0xfb},
+	{0x8b61,0x16},
+	{0x8b62,0x3c},
 	{0x8b63,0xc2},
 	{0x8b64,0x09},
 	{0x8b65,0x90},
@@ -2946,2725 +2942,3116 @@ struct reginfo sensor_af_firmware[] =
 	{0x8b69,0x21},
 	{0x8b6a,0xf0},
 	{0x8b6b,0x22},
-	{0x8b6c,0xc0},
-	{0x8b6d,0xe0},
-	{0x8b6e,0xc0},
-	{0x8b6f,0xf0},
-	{0x8b70,0xc0},
-	{0x8b71,0x83},
-	{0x8b72,0xc0},
-	{0x8b73,0x82},
-	{0x8b74,0xc0},
-	{0x8b75,0xd0},
-	{0x8b76,0x75},
-	{0x8b77,0xd0},
-	{0x8b78,0x00},
-	{0x8b79,0xc0},
-	{0x8b7a,0x00},
-	{0x8b7b,0xc0},
-	{0x8b7c,0x01},
-	{0x8b7d,0xc0},
-	{0x8b7e,0x02},
-	{0x8b7f,0xc0},
-	{0x8b80,0x03},
-	{0x8b81,0xc0},
-	{0x8b82,0x04},
-	{0x8b83,0xc0},
-	{0x8b84,0x05},
-	{0x8b85,0xc0},
-	{0x8b86,0x06},
-	{0x8b87,0xc0},
-	{0x8b88,0x07},
-	{0x8b89,0x90},
-	{0x8b8a,0x3f},
-	{0x8b8b,0x0c},
-	{0x8b8c,0xe0},
-	{0x8b8d,0xf5},
-	{0x8b8e,0x08},
-	{0x8b8f,0xe5},
-	{0x8b90,0x08},
-	{0x8b91,0x20},
-	{0x8b92,0xe3},
-	{0x8b93,0x03},
-	{0x8b94,0x02},
-	{0x8b95,0x0c},
-	{0x8b96,0x1d},
-	{0x8b97,0x30},
-	{0x8b98,0x35},
-	{0x8b99,0x03},
-	{0x8b9a,0x02},
+	{0x8b6c,0x30},
+	{0x8b6d,0x04},
+	{0x8b6e,0x03},
+	{0x8b6f,0x02},
+	{0x8b70,0x0c},
+	{0x8b71,0xa7},
+	{0x8b72,0xd2},
+	{0x8b73,0x04},
+	{0x8b74,0xe5},
+	{0x8b75,0x7e},
+	{0x8b76,0xb4},
+	{0x8b77,0x01},
+	{0x8b78,0x06},
+	{0x8b79,0x12},
+	{0x8b7a,0x17},
+	{0x8b7b,0x3c},
+	{0x8b7c,0x02},
+	{0x8b7d,0x0c},
+	{0x8b7e,0xa0},
+	{0x8b7f,0xe5},
+	{0x8b80,0x7e},
+	{0x8b81,0xb4},
+	{0x8b82,0x02},
+	{0x8b83,0x06},
+	{0x8b84,0x12},
+	{0x8b85,0x17},
+	{0x8b86,0x4d},
+	{0x8b87,0x02},
+	{0x8b88,0x0c},
+	{0x8b89,0xa0},
+	{0x8b8a,0xe5},
+	{0x8b8b,0x7e},
+	{0x8b8c,0xb4},
+	{0x8b8d,0x03},
+	{0x8b8e,0x05},
+	{0x8b8f,0xe4},
+	{0x8b90,0xf5},
+	{0x8b91,0x0c},
+	{0x8b92,0x80},
+	{0x8b93,0x08},
+	{0x8b94,0xe5},
+	{0x8b95,0x7e},
+	{0x8b96,0xb4},
+	{0x8b97,0x04},
+	{0x8b98,0x09},
+	{0x8b99,0x85},
+	{0x8b9a,0x7c},
 	{0x8b9b,0x0c},
-	{0x8b9c,0x1d},
-	{0x8b9d,0x90},
-	{0x8b9e,0x60},
-	{0x8b9f,0x16},
-	{0x8ba0,0xe0},
-	{0x8ba1,0xf5},
-	{0x8ba2,0x6a},
-	{0x8ba3,0xa3},
-	{0x8ba4,0xe0},
-	{0x8ba5,0xf5},
-	{0x8ba6,0x6b},
-	{0x8ba7,0x90},
-	{0x8ba8,0x60},
-	{0x8ba9,0x1e},
-	{0x8baa,0xe0},
-	{0x8bab,0xf5},
-	{0x8bac,0x6c},
-	{0x8bad,0xa3},
-	{0x8bae,0xe0},
-	{0x8baf,0xf5},
-	{0x8bb0,0x6d},
-	{0x8bb1,0x90},
-	{0x8bb2,0x60},
-	{0x8bb3,0x26},
-	{0x8bb4,0xe0},
-	{0x8bb5,0xf5},
-	{0x8bb6,0x6e},
-	{0x8bb7,0xa3},
-	{0x8bb8,0xe0},
-	{0x8bb9,0xf5},
-	{0x8bba,0x6f},
-	{0x8bbb,0x90},
-	{0x8bbc,0x60},
-	{0x8bbd,0x2e},
-	{0x8bbe,0xe0},
-	{0x8bbf,0xf5},
-	{0x8bc0,0x70},
-	{0x8bc1,0xa3},
-	{0x8bc2,0xe0},
-	{0x8bc3,0xf5},
-	{0x8bc4,0x71},
-	{0x8bc5,0x90},
-	{0x8bc6,0x60},
-	{0x8bc7,0x36},
-	{0x8bc8,0x12},
-	{0x8bc9,0x00},
-	{0x8bca,0x16},
-	{0x8bcb,0x12},
-	{0x8bcc,0x01},
-	{0x8bcd,0xc5},
-	{0x8bce,0x40},
-	{0x8bcf,0x06},
-	{0x8bd0,0x75},
-	{0x8bd1,0x2a},
-	{0x8bd2,0xff},
-	{0x8bd3,0x75},
-	{0x8bd4,0x2b},
-	{0x8bd5,0xff},
-	{0x8bd6,0x85},
-	{0x8bd7,0x2a},
-	{0x8bd8,0x74},
+	{0x8b9c,0x12},
+	{0x8b9d,0x0e},
+	{0x8b9e,0xf9},
+	{0x8b9f,0x02},
+	{0x8ba0,0x0c},
+	{0x8ba1,0xa0},
+	{0x8ba2,0xe5},
+	{0x8ba3,0x7e},
+	{0x8ba4,0x64},
+	{0x8ba5,0x0f},
+	{0x8ba6,0x70},
+	{0x8ba7,0x3d},
+	{0x8ba8,0xd3},
+	{0x8ba9,0xe5},
+	{0x8baa,0x69},
+	{0x8bab,0x94},
+	{0x8bac,0xff},
+	{0x8bad,0xe5},
+	{0x8bae,0x68},
+	{0x8baf,0x94},
+	{0x8bb0,0x03},
+	{0x8bb1,0x40},
+	{0x8bb2,0x06},
+	{0x8bb3,0x7e},
+	{0x8bb4,0x03},
+	{0x8bb5,0x7f},
+	{0x8bb6,0xff},
+	{0x8bb7,0x80},
+	{0x8bb8,0x04},
+	{0x8bb9,0xae},
+	{0x8bba,0x68},
+	{0x8bbb,0xaf},
+	{0x8bbc,0x69},
+	{0x8bbd,0x8e},
+	{0x8bbe,0x68},
+	{0x8bbf,0x8f},
+	{0x8bc0,0x69},
+	{0x8bc1,0x85},
+	{0x8bc2,0x68},
+	{0x8bc3,0x64},
+	{0x8bc4,0x85},
+	{0x8bc5,0x69},
+	{0x8bc6,0x65},
+	{0x8bc7,0xe5},
+	{0x8bc8,0x69},
+	{0x8bc9,0xc4},
+	{0x8bca,0xf8},
+	{0x8bcb,0x54},
+	{0x8bcc,0x0f},
+	{0x8bcd,0xc8},
+	{0x8bce,0x68},
+	{0x8bcf,0xf5},
+	{0x8bd0,0x69},
+	{0x8bd1,0xe5},
+	{0x8bd2,0x68},
+	{0x8bd3,0xc4},
+	{0x8bd4,0x54},
+	{0x8bd5,0xf0},
+	{0x8bd6,0x48},
+	{0x8bd7,0xf5},
+	{0x8bd8,0x68},
 	{0x8bd9,0x85},
-	{0x8bda,0x2b},
-	{0x8bdb,0x75},
-	{0x8bdc,0x90},
-	{0x8bdd,0x60},
-	{0x8bde,0x1a},
-	{0x8bdf,0xe0},
-	{0x8be0,0xf5},
-	{0x8be1,0x6a},
-	{0x8be2,0xa3},
-	{0x8be3,0xe0},
-	{0x8be4,0xf5},
-	{0x8be5,0x6b},
-	{0x8be6,0x90},
-	{0x8be7,0x60},
-	{0x8be8,0x22},
-	{0x8be9,0xe0},
-	{0x8bea,0xf5},
-	{0x8beb,0x6c},
-	{0x8bec,0xa3},
-	{0x8bed,0xe0},
+	{0x8bda,0x68},
+	{0x8bdb,0x11},
+	{0x8bdc,0x85},
+	{0x8bdd,0x69},
+	{0x8bde,0x12},
+	{0x8bdf,0x12},
+	{0x8be0,0x0a},
+	{0x8be1,0x20},
+	{0x8be2,0x02},
+	{0x8be3,0x0c},
+	{0x8be4,0xa0},
+	{0x8be5,0xe5},
+	{0x8be6,0x7e},
+	{0x8be7,0x64},
+	{0x8be8,0x10},
+	{0x8be9,0x60},
+	{0x8bea,0x03},
+	{0x8beb,0x02},
+	{0x8bec,0x0c},
+	{0x8bed,0xa0},
 	{0x8bee,0xf5},
-	{0x8bef,0x6d},
-	{0x8bf0,0x90},
-	{0x8bf1,0x60},
-	{0x8bf2,0x2a},
-	{0x8bf3,0xe0},
-	{0x8bf4,0xf5},
-	{0x8bf5,0x6e},
-	{0x8bf6,0xa3},
-	{0x8bf7,0xe0},
-	{0x8bf8,0xf5},
-	{0x8bf9,0x6f},
-	{0x8bfa,0x90},
-	{0x8bfb,0x60},
-	{0x8bfc,0x32},
-	{0x8bfd,0xe0},
-	{0x8bfe,0xf5},
-	{0x8bff,0x70},
-	{0x8c00,0xa3},
-	{0x8c01,0xe0},
-	{0x8c02,0xf5},
-	{0x8c03,0x71},
-	{0x8c04,0x90},
-	{0x8c05,0x60},
-	{0x8c06,0x3a},
-	{0x8c07,0x12},
-	{0x8c08,0x00},
-	{0x8c09,0x16},
-	{0x8c0a,0x12},
-	{0x8c0b,0x01},
-	{0x8c0c,0xc5},
-	{0x8c0d,0x40},
-	{0x8c0e,0x06},
-	{0x8c0f,0x75},
-	{0x8c10,0x2a},
-	{0x8c11,0xff},
-	{0x8c12,0x75},
-	{0x8c13,0x2b},
-	{0x8c14,0xff},
-	{0x8c15,0x85},
-	{0x8c16,0x2a},
-	{0x8c17,0x76},
-	{0x8c18,0x85},
-	{0x8c19,0x2b},
-	{0x8c1a,0x77},
-	{0x8c1b,0xd2},
-	{0x8c1c,0x3b},
-	{0x8c1d,0xe5},
-	{0x8c1e,0x08},
-	{0x8c1f,0x30},
-	{0x8c20,0xe5},
-	{0x8c21,0x41},
-	{0x8c22,0x90},
-	{0x8c23,0x56},
-	{0x8c24,0x90},
-	{0x8c25,0xe0},
-	{0x8c26,0xf5},
-	{0x8c27,0x55},
-	{0x8c28,0xe5},
-	{0x8c29,0x7b},
-	{0x8c2a,0x12},
-	{0x8c2b,0x01},
-	{0x8c2c,0xbe},
-	{0x8c2d,0xad},
-	{0x8c2e,0x55},
-	{0x8c2f,0xc3},
-	{0x8c30,0xef},
-	{0x8c31,0x9d},
-	{0x8c32,0x74},
-	{0x8c33,0x80},
-	{0x8c34,0xf8},
-	{0x8c35,0x6e},
-	{0x8c36,0x98},
-	{0x8c37,0x50},
-	{0x8c38,0x02},
-	{0x8c39,0x80},
-	{0x8c3a,0x01},
-	{0x8c3b,0xc3},
-	{0x8c3c,0x92},
-	{0x8c3d,0x27},
-	{0x8c3e,0xaf},
-	{0x8c3f,0x55},
-	{0x8c40,0xef},
-	{0x8c41,0x24},
-	{0x8c42,0x01},
-	{0x8c43,0xff},
-	{0x8c44,0xe4},
-	{0x8c45,0x33},
-	{0x8c46,0xfe},
-	{0x8c47,0xc3},
-	{0x8c48,0xef},
-	{0x8c49,0x95},
-	{0x8c4a,0x7b},
-	{0x8c4b,0x74},
-	{0x8c4c,0x80},
-	{0x8c4d,0xf8},
-	{0x8c4e,0x6e},
-	{0x8c4f,0x98},
-	{0x8c50,0x50},
-	{0x8c51,0x02},
-	{0x8c52,0x80},
-	{0x8c53,0x02},
-	{0x8c54,0xa2},
-	{0x8c55,0x27},
-	{0x8c56,0x92},
-	{0x8c57,0x27},
-	{0x8c58,0x30},
-	{0x8c59,0x27},
-	{0x8c5a,0x04},
-	{0x8c5b,0xaf},
-	{0x8c5c,0x55},
-	{0x8c5d,0x80},
-	{0x8c5e,0x02},
-	{0x8c5f,0xaf},
-	{0x8c60,0x7b},
-	{0x8c61,0x8f},
-	{0x8c62,0x7b},
-	{0x8c63,0xe5},
-	{0x8c64,0x08},
-	{0x8c65,0x30},
-	{0x8c66,0xe1},
-	{0x8c67,0x08},
-	{0x8c68,0x90},
-	{0x8c69,0x30},
-	{0x8c6a,0x24},
-	{0x8c6b,0xe0},
-	{0x8c6c,0xf5},
-	{0x8c6d,0x33},
-	{0x8c6e,0xe4},
-	{0x8c6f,0xf0},
-	{0x8c70,0x90},
-	{0x8c71,0x3f},
-	{0x8c72,0x0c},
-	{0x8c73,0xe5},
-	{0x8c74,0x08},
-	{0x8c75,0xf0},
-	{0x8c76,0xd0},
-	{0x8c77,0x07},
-	{0x8c78,0xd0},
-	{0x8c79,0x06},
-	{0x8c7a,0xd0},
-	{0x8c7b,0x05},
-	{0x8c7c,0xd0},
-	{0x8c7d,0x04},
-	{0x8c7e,0xd0},
-	{0x8c7f,0x03},
-	{0x8c80,0xd0},
-	{0x8c81,0x02},
-	{0x8c82,0xd0},
-	{0x8c83,0x01},
-	{0x8c84,0xd0},
-	{0x8c85,0x00},
-	{0x8c86,0xd0},
-	{0x8c87,0xd0},
-	{0x8c88,0xd0},
-	{0x8c89,0x82},
-	{0x8c8a,0xd0},
-	{0x8c8b,0x83},
-	{0x8c8c,0xd0},
-	{0x8c8d,0xf0},
-	{0x8c8e,0xd0},
-	{0x8c8f,0xe0},
-	{0x8c90,0x32},
-	{0x8c91,0xe5},
-	{0x8c92,0x33},
-	{0x8c93,0x70},
-	{0x8c94,0x03},
-	{0x8c95,0x02},
-	{0x8c96,0x0d},
-	{0x8c97,0x9e},
-	{0x8c98,0xc2},
-	{0x8c99,0xaf},
-	{0x8c9a,0xaf},
-	{0x8c9b,0x33},
-	{0x8c9c,0xe4},
-	{0x8c9d,0xf5},
-	{0x8c9e,0x33},
-	{0x8c9f,0xd2},
-	{0x8ca0,0xaf},
-	{0x8ca1,0x90},
-	{0x8ca2,0x30},
-	{0x8ca3,0x25},
-	{0x8ca4,0xe0},
-	{0x8ca5,0xf5},
-	{0x8ca6,0x7e},
-	{0x8ca7,0x90},
-	{0x8ca8,0x50},
-	{0x8ca9,0x82},
-	{0x8caa,0xe0},
-	{0x8cab,0xf5},
-	{0x8cac,0x66},
-	{0x8cad,0xa3},
-	{0x8cae,0xe0},
-	{0x8caf,0xf5},
-	{0x8cb0,0x67},
-	{0x8cb1,0xa3},
-	{0x8cb2,0xe0},
-	{0x8cb3,0xf5},
-	{0x8cb4,0x68},
-	{0x8cb5,0xa3},
-	{0x8cb6,0xe0},
-	{0x8cb7,0xf5},
-	{0x8cb8,0x69},
-	{0x8cb9,0xef},
-	{0x8cba,0x12},
-	{0x8cbb,0x09},
-	{0x8cbc,0xfa},
-	{0x8cbd,0x0c},
-	{0x8cbe,0xe2},
-	{0x8cbf,0x03},
-	{0x8cc0,0x0c},
-	{0x8cc1,0xf7},
-	{0x8cc2,0x05},
-	{0x8cc3,0x0d},
-	{0x8cc4,0x21},
-	{0x8cc5,0x06},
-	{0x8cc6,0x0d},
-	{0x8cc7,0x0f},
-	{0x8cc8,0x08},
-	{0x8cc9,0x0d},
-	{0x8cca,0x2e},
-	{0x8ccb,0x10},
-	{0x8ccc,0x0d},
-	{0x8ccd,0x42},
-	{0x8cce,0x12},
-	{0x8ccf,0x0d},
-	{0x8cd0,0x47},
-	{0x8cd1,0x20},
-	{0x8cd2,0x0d},
-	{0x8cd3,0x55},
-	{0x8cd4,0x21},
-	{0x8cd5,0x0d},
-	{0x8cd6,0x5a},
-	{0x8cd7,0x30},
-	{0x8cd8,0x0d},
-	{0x8cd9,0x83},
-	{0x8cda,0x50},
-	{0x8cdb,0x0d},
-	{0x8cdc,0x65},
-	{0x8cdd,0xd8},
-	{0x8cde,0x00},
-	{0x8cdf,0x00},
+	{0x8bef,0x66},
+	{0x8bf0,0xf5},
+	{0x8bf1,0x67},
+	{0x8bf2,0xf5},
+	{0x8bf3,0x68},
+	{0x8bf4,0xab},
+	{0x8bf5,0x69},
+	{0x8bf6,0xaa},
+	{0x8bf7,0x68},
+	{0x8bf8,0xa9},
+	{0x8bf9,0x67},
+	{0x8bfa,0xa8},
+	{0x8bfb,0x66},
+	{0x8bfc,0x12},
+	{0x8bfd,0x01},
+	{0x8bfe,0x73},
+	{0x8bff,0x12},
+	{0x8c00,0x02},
+	{0x8c01,0x11},
+	{0x8c02,0xfe},
+	{0x8c03,0xe4},
+	{0x8c04,0xfc},
+	{0x8c05,0xfd},
+	{0x8c06,0x12},
+	{0x8c07,0x01},
+	{0x8c08,0xfd},
+	{0x8c09,0xe4},
+	{0x8c0a,0x7b},
+	{0x8c0b,0xff},
+	{0x8c0c,0xfa},
+	{0x8c0d,0xf9},
+	{0x8c0e,0xf8},
+	{0x8c0f,0x12},
+	{0x8c10,0x02},
+	{0x8c11,0x7a},
+	{0x8c12,0x12},
+	{0x8c13,0x01},
+	{0x8c14,0x88},
+	{0x8c15,0xe4},
+	{0x8c16,0x93},
+	{0x8c17,0xfe},
+	{0x8c18,0x74},
+	{0x8c19,0x01},
+	{0x8c1a,0x93},
+	{0x8c1b,0xff},
+	{0x8c1c,0xe4},
+	{0x8c1d,0xfc},
+	{0x8c1e,0xfd},
+	{0x8c1f,0xe5},
+	{0x8c20,0x69},
+	{0x8c21,0x2f},
+	{0x8c22,0xf5},
+	{0x8c23,0x69},
+	{0x8c24,0xe5},
+	{0x8c25,0x68},
+	{0x8c26,0x3e},
+	{0x8c27,0xf5},
+	{0x8c28,0x68},
+	{0x8c29,0xed},
+	{0x8c2a,0x35},
+	{0x8c2b,0x67},
+	{0x8c2c,0xf5},
+	{0x8c2d,0x67},
+	{0x8c2e,0xec},
+	{0x8c2f,0x35},
+	{0x8c30,0x66},
+	{0x8c31,0xf5},
+	{0x8c32,0x66},
+	{0x8c33,0x85},
+	{0x8c34,0x68},
+	{0x8c35,0x66},
+	{0x8c36,0x85},
+	{0x8c37,0x69},
+	{0x8c38,0x67},
+	{0x8c39,0xd3},
+	{0x8c3a,0xe5},
+	{0x8c3b,0x67},
+	{0x8c3c,0x94},
+	{0x8c3d,0xff},
+	{0x8c3e,0xe5},
+	{0x8c3f,0x66},
+	{0x8c40,0x94},
+	{0x8c41,0x03},
+	{0x8c42,0x40},
+	{0x8c43,0x06},
+	{0x8c44,0x7e},
+	{0x8c45,0x03},
+	{0x8c46,0x7f},
+	{0x8c47,0xff},
+	{0x8c48,0x80},
+	{0x8c49,0x04},
+	{0x8c4a,0xae},
+	{0x8c4b,0x66},
+	{0x8c4c,0xaf},
+	{0x8c4d,0x67},
+	{0x8c4e,0x8e},
+	{0x8c4f,0x66},
+	{0x8c50,0x8f},
+	{0x8c51,0x67},
+	{0x8c52,0x85},
+	{0x8c53,0x66},
+	{0x8c54,0x64},
+	{0x8c55,0x85},
+	{0x8c56,0x67},
+	{0x8c57,0x65},
+	{0x8c58,0xe5},
+	{0x8c59,0x67},
+	{0x8c5a,0xc4},
+	{0x8c5b,0xf8},
+	{0x8c5c,0x54},
+	{0x8c5d,0x0f},
+	{0x8c5e,0xc8},
+	{0x8c5f,0x68},
+	{0x8c60,0xf5},
+	{0x8c61,0x67},
+	{0x8c62,0xe5},
+	{0x8c63,0x66},
+	{0x8c64,0xc4},
+	{0x8c65,0x54},
+	{0x8c66,0xf0},
+	{0x8c67,0x48},
+	{0x8c68,0xf5},
+	{0x8c69,0x66},
+	{0x8c6a,0x85},
+	{0x8c6b,0x66},
+	{0x8c6c,0x11},
+	{0x8c6d,0x85},
+	{0x8c6e,0x67},
+	{0x8c6f,0x12},
+	{0x8c70,0x12},
+	{0x8c71,0x0a},
+	{0x8c72,0x20},
+	{0x8c73,0xe4},
+	{0x8c74,0xf5},
+	{0x8c75,0x67},
+	{0x8c76,0xf5},
+	{0x8c77,0x67},
+	{0x8c78,0xe5},
+	{0x8c79,0x67},
+	{0x8c7a,0xd3},
+	{0x8c7b,0x95},
+	{0x8c7c,0x7c},
+	{0x8c7d,0x50},
+	{0x8c7e,0x21},
+	{0x8c7f,0x12},
+	{0x8c80,0x01},
+	{0x8c81,0x88},
+	{0x8c82,0xaf},
+	{0x8c83,0x67},
+	{0x8c84,0x75},
+	{0x8c85,0xf0},
+	{0x8c86,0x02},
+	{0x8c87,0xef},
+	{0x8c88,0x12},
+	{0x8c89,0x09},
+	{0x8c8a,0xee},
+	{0x8c8b,0xc3},
+	{0x8c8c,0x74},
+	{0x8c8d,0x01},
+	{0x8c8e,0x93},
+	{0x8c8f,0x95},
+	{0x8c90,0x69},
+	{0x8c91,0xe4},
+	{0x8c92,0x93},
+	{0x8c93,0x95},
+	{0x8c94,0x68},
+	{0x8c95,0x40},
+	{0x8c96,0x05},
+	{0x8c97,0x85},
+	{0x8c98,0x67},
+	{0x8c99,0x7d},
+	{0x8c9a,0x80},
+	{0x8c9b,0x04},
+	{0x8c9c,0x05},
+	{0x8c9d,0x67},
+	{0x8c9e,0x80},
+	{0x8c9f,0xd8},
+	{0x8ca0,0x90},
+	{0x8ca1,0x30},
+	{0x8ca2,0x25},
+	{0x8ca3,0xe4},
+	{0x8ca4,0xf0},
+	{0x8ca5,0xd2},
+	{0x8ca6,0x34},
+	{0x8ca7,0x22},
+	{0x8ca8,0xe5},
+	{0x8ca9,0x33},
+	{0x8caa,0x70},
+	{0x8cab,0x03},
+	{0x8cac,0x02},
+	{0x8cad,0x0d},
+	{0x8cae,0xd0},
+	{0x8caf,0xc2},
+	{0x8cb0,0xaf},
+	{0x8cb1,0xaf},
+	{0x8cb2,0x33},
+	{0x8cb3,0xe4},
+	{0x8cb4,0xf5},
+	{0x8cb5,0x33},
+	{0x8cb6,0xd2},
+	{0x8cb7,0xaf},
+	{0x8cb8,0x90},
+	{0x8cb9,0x30},
+	{0x8cba,0x25},
+	{0x8cbb,0xe0},
+	{0x8cbc,0xf5},
+	{0x8cbd,0x7e},
+	{0x8cbe,0x90},
+	{0x8cbf,0x50},
+	{0x8cc0,0x82},
+	{0x8cc1,0xe0},
+	{0x8cc2,0xf5},
+	{0x8cc3,0x66},
+	{0x8cc4,0xa3},
+	{0x8cc5,0xe0},
+	{0x8cc6,0xf5},
+	{0x8cc7,0x67},
+	{0x8cc8,0xa3},
+	{0x8cc9,0xe0},
+	{0x8cca,0xf5},
+	{0x8ccb,0x68},
+	{0x8ccc,0xa3},
+	{0x8ccd,0xe0},
+	{0x8cce,0xf5},
+	{0x8ccf,0x69},
+	{0x8cd0,0xef},
+	{0x8cd1,0x12},
+	{0x8cd2,0x09},
+	{0x8cd3,0xfa},
+	{0x8cd4,0x0c},
+	{0x8cd5,0xfc},
+	{0x8cd6,0x03},
+	{0x8cd7,0x0d},
+	{0x8cd8,0x14},
+	{0x8cd9,0x04},
+	{0x8cda,0x0d},
+	{0x8cdb,0x2f},
+	{0x8cdc,0x05},
+	{0x8cdd,0x0d},
+	{0x8cde,0x53},
+	{0x8cdf,0x06},
 	{0x8ce0,0x0d},
-	{0x8ce1,0x90},
-	{0x8ce2,0x20},
-	{0x8ce3,0x05},
-	{0x8ce4,0x03},
-	{0x8ce5,0x02},
+	{0x8ce1,0x41},
+	{0x8ce2,0x08},
+	{0x8ce3,0x0d},
+	{0x8ce4,0x60},
+	{0x8ce5,0x10},
 	{0x8ce6,0x0d},
-	{0x8ce7,0x90},
-	{0x8ce8,0x30},
-	{0x8ce9,0x00},
-	{0x8cea,0x03},
-	{0x8ceb,0x02},
+	{0x8ce7,0x74},
+	{0x8ce8,0x12},
+	{0x8ce9,0x0d},
+	{0x8cea,0x79},
+	{0x8ceb,0x20},
 	{0x8cec,0x0d},
-	{0x8ced,0x90},
-	{0x8cee,0xd2},
-	{0x8cef,0x07},
-	{0x8cf0,0xc2},
-	{0x8cf1,0x06},
-	{0x8cf2,0x12},
-	{0x8cf3,0x02},
-	{0x8cf4,0x9d},
-	{0x8cf5,0x80},
-	{0x8cf6,0x24},
-	{0x8cf7,0x20},
-	{0x8cf8,0x05},
-	{0x8cf9,0x03},
-	{0x8cfa,0x02},
-	{0x8cfb,0x0d},
-	{0x8cfc,0x90},
-	{0x8cfd,0x30},
-	{0x8cfe,0x00},
-	{0x8cff,0x03},
-	{0x8d00,0x02},
-	{0x8d01,0x0d},
-	{0x8d02,0x90},
-	{0x8d03,0xc2},
-	{0x8d04,0x07},
-	{0x8d05,0xd2},
+	{0x8ced,0x87},
+	{0x8cee,0x21},
+	{0x8cef,0x0d},
+	{0x8cf0,0x8c},
+	{0x8cf1,0x30},
+	{0x8cf2,0x0d},
+	{0x8cf3,0xb5},
+	{0x8cf4,0x50},
+	{0x8cf5,0x0d},
+	{0x8cf6,0x97},
+	{0x8cf7,0xd8},
+	{0x8cf8,0x00},
+	{0x8cf9,0x00},
+	{0x8cfa,0x0d},
+	{0x8cfb,0xc2},
+	{0x8cfc,0x30},
+	{0x8cfd,0x00},
+	{0x8cfe,0x03},
+	{0x8cff,0x02},
+	{0x8d00,0x0d},
+	{0x8d01,0xc2},
+	{0x8d02,0x20},
+	{0x8d03,0x07},
+	{0x8d04,0x06},
+	{0x8d05,0x20},
 	{0x8d06,0x06},
-	{0x8d07,0x12},
-	{0x8d08,0x02},
-	{0x8d09,0xa8},
-	{0x8d0a,0xc2},
-	{0x8d0b,0x04},
-	{0x8d0c,0x02},
-	{0x8d0d,0x0d},
-	{0x8d0e,0x90},
-	{0x8d0f,0x12},
-	{0x8d10,0x02},
-	{0x8d11,0x64},
-	{0x8d12,0x30},
-	{0x8d13,0x05},
-	{0x8d14,0x06},
-	{0x8d15,0xe4},
-	{0x8d16,0xf5},
-	{0x8d17,0x0c},
-	{0x8d18,0x12},
-	{0x8d19,0x0e},
-	{0x8d1a,0xa9},
-	{0x8d1b,0xc2},
-	{0x8d1c,0x31},
-	{0x8d1d,0xd2},
-	{0x8d1e,0x34},
-	{0x8d1f,0x80},
-	{0x8d20,0x6f},
-	{0x8d21,0x30},
-	{0x8d22,0x07},
-	{0x8d23,0x6c},
-	{0x8d24,0x30},
-	{0x8d25,0x06},
-	{0x8d26,0x69},
-	{0x8d27,0x12},
-	{0x8d28,0x02},
-	{0x8d29,0x9d},
-	{0x8d2a,0xd2},
-	{0x8d2b,0x31},
-	{0x8d2c,0x80},
-	{0x8d2d,0x62},
-	{0x8d2e,0x20},
-	{0x8d2f,0x07},
-	{0x8d30,0x03},
-	{0x8d31,0x30},
-	{0x8d32,0x06},
-	{0x8d33,0x09},
-	{0x8d34,0xe5},
-	{0x8d35,0x7e},
-	{0x8d36,0x64},
-	{0x8d37,0x0e},
-	{0x8d38,0x70},
-	{0x8d39,0x56},
-	{0x8d3a,0x20},
-	{0x8d3b,0x00},
-	{0x8d3c,0x53},
-	{0x8d3d,0x12},
-	{0x8d3e,0x05},
-	{0x8d3f,0x32},
-	{0x8d40,0x80},
-	{0x8d41,0x4e},
-	{0x8d42,0x12},
-	{0x8d43,0x06},
-	{0x8d44,0xfb},
-	{0x8d45,0x80},
-	{0x8d46,0x49},
-	{0x8d47,0x30},
-	{0x8d48,0x05},
-	{0x8d49,0x46},
-	{0x8d4a,0x20},
-	{0x8d4b,0x07},
-	{0x8d4c,0x43},
-	{0x8d4d,0x20},
-	{0x8d4e,0x06},
-	{0x8d4f,0x40},
-	{0x8d50,0x12},
-	{0x8d51,0x15},
-	{0x8d52,0xd5},
-	{0x8d53,0x80},
-	{0x8d54,0x3b},
-	{0x8d55,0x12},
-	{0x8d56,0x0f},
-	{0x8d57,0xfb},
-	{0x8d58,0x80},
-	{0x8d59,0x36},
-	{0x8d5a,0x20},
-	{0x8d5b,0x07},
-	{0x8d5c,0x33},
-	{0x8d5d,0x20},
-	{0x8d5e,0x06},
-	{0x8d5f,0x30},
-	{0x8d60,0x12},
-	{0x8d61,0x15},
-	{0x8d62,0xe4},
-	{0x8d63,0x80},
-	{0x8d64,0x2b},
-	{0x8d65,0xe5},
-	{0x8d66,0x7e},
-	{0x8d67,0x64},
-	{0x8d68,0x01},
-	{0x8d69,0x70},
-	{0x8d6a,0x25},
-	{0x8d6b,0xd2},
-	{0x8d6c,0x35},
-	{0x8d6d,0x90},
-	{0x8d6e,0x50},
-	{0x8d6f,0x82},
-	{0x8d70,0xe5},
-	{0x8d71,0x74},
-	{0x8d72,0xf0},
-	{0x8d73,0xa3},
-	{0x8d74,0xe5},
-	{0x8d75,0x75},
-	{0x8d76,0xf0},
-	{0x8d77,0xa3},
-	{0x8d78,0xe5},
-	{0x8d79,0x76},
-	{0x8d7a,0xf0},
-	{0x8d7b,0xa3},
-	{0x8d7c,0xe5},
-	{0x8d7d,0x77},
-	{0x8d7e,0xf0},
-	{0x8d7f,0xc2},
-	{0x8d80,0x35},
-	{0x8d81,0x80},
-	{0x8d82,0x0d},
-	{0x8d83,0x90},
-	{0x8d84,0x50},
-	{0x8d85,0x82},
-	{0x8d86,0x30},
-	{0x8d87,0x33},
-	{0x8d88,0x05},
-	{0x8d89,0x74},
-	{0x8d8a,0x55},
-	{0x8d8b,0xf0},
-	{0x8d8c,0x80},
-	{0x8d8d,0x02},
-	{0x8d8e,0xe4},
-	{0x8d8f,0xf0},
-	{0x8d90,0x20},
-	{0x8d91,0x07},
-	{0x8d92,0x06},
-	{0x8d93,0x30},
-	{0x8d94,0x06},
-	{0x8d95,0x03},
-	{0x8d96,0x30},
-	{0x8d97,0x04},
-	{0x8d98,0x05},
-	{0x8d99,0x90},
-	{0x8d9a,0x30},
-	{0x8d9b,0x25},
-	{0x8d9c,0xe4},
-	{0x8d9d,0xf0},
-	{0x8d9e,0x22},
-	{0x8d9f,0x30},
-	{0x8da0,0x04},
-	{0x8da1,0x03},
-	{0x8da2,0x02},
-	{0x8da3,0x0e},
-	{0x8da4,0x82},
-	{0x8da5,0xd2},
-	{0x8da6,0x04},
-	{0x8da7,0xe5},
-	{0x8da8,0x7e},
-	{0x8da9,0xb4},
-	{0x8daa,0x01},
-	{0x8dab,0x06},
-	{0x8dac,0x12},
-	{0x8dad,0x15},
-	{0x8dae,0xb5},
-	{0x8daf,0x02},
-	{0x8db0,0x0e},
-	{0x8db1,0x7b},
-	{0x8db2,0xe5},
-	{0x8db3,0x7e},
-	{0x8db4,0xb4},
-	{0x8db5,0x02},
-	{0x8db6,0x06},
-	{0x8db7,0x12},
-	{0x8db8,0x15},
-	{0x8db9,0xc6},
-	{0x8dba,0x02},
-	{0x8dbb,0x0e},
-	{0x8dbc,0x7b},
-	{0x8dbd,0xe5},
-	{0x8dbe,0x7e},
-	{0x8dbf,0xb4},
-	{0x8dc0,0x03},
-	{0x8dc1,0x05},
-	{0x8dc2,0xe4},
-	{0x8dc3,0xf5},
-	{0x8dc4,0x0c},
-	{0x8dc5,0x80},
-	{0x8dc6,0x08},
-	{0x8dc7,0xe5},
-	{0x8dc8,0x7e},
-	{0x8dc9,0xb4},
-	{0x8dca,0x04},
-	{0x8dcb,0x09},
-	{0x8dcc,0x85},
-	{0x8dcd,0x7c},
-	{0x8dce,0x0c},
-	{0x8dcf,0x12},
-	{0x8dd0,0x0e},
-	{0x8dd1,0xa9},
-	{0x8dd2,0x02},
-	{0x8dd3,0x0e},
-	{0x8dd4,0x7b},
-	{0x8dd5,0xe5},
-	{0x8dd6,0x7e},
-	{0x8dd7,0x64},
-	{0x8dd8,0x0f},
-	{0x8dd9,0x70},
-	{0x8dda,0x15},
-	{0x8ddb,0x12},
-	{0x8ddc,0x02},
-	{0x8ddd,0xb6},
-	{0x8dde,0x40},
-	{0x8ddf,0x06},
-	{0x8de0,0x7e},
-	{0x8de1,0x03},
-	{0x8de2,0x7f},
-	{0x8de3,0xff},
-	{0x8de4,0x80},
-	{0x8de5,0x04},
-	{0x8de6,0xae},
-	{0x8de7,0x68},
-	{0x8de8,0xaf},
-	{0x8de9,0x69},
-	{0x8dea,0x12},
-	{0x8deb,0x0e},
-	{0x8dec,0x83},
-	{0x8ded,0x02},
-	{0x8dee,0x0e},
-	{0x8def,0x7b},
-	{0x8df0,0xe5},
-	{0x8df1,0x7e},
-	{0x8df2,0x64},
-	{0x8df3,0x10},
-	{0x8df4,0x60},
-	{0x8df5,0x03},
-	{0x8df6,0x02},
-	{0x8df7,0x0e},
-	{0x8df8,0x7b},
-	{0x8df9,0xf5},
-	{0x8dfa,0x66},
-	{0x8dfb,0xf5},
-	{0x8dfc,0x67},
-	{0x8dfd,0xf5},
-	{0x8dfe,0x68},
-	{0x8dff,0xab},
-	{0x8e00,0x69},
-	{0x8e01,0xaa},
-	{0x8e02,0x68},
-	{0x8e03,0xa9},
-	{0x8e04,0x67},
-	{0x8e05,0xa8},
-	{0x8e06,0x66},
-	{0x8e07,0x12},
-	{0x8e08,0x01},
-	{0x8e09,0x73},
-	{0x8e0a,0x12},
-	{0x8e0b,0x02},
-	{0x8e0c,0x11},
-	{0x8e0d,0xfe},
-	{0x8e0e,0xe4},
-	{0x8e0f,0xfc},
-	{0x8e10,0xfd},
-	{0x8e11,0x12},
-	{0x8e12,0x01},
-	{0x8e13,0xfd},
-	{0x8e14,0xe4},
-	{0x8e15,0x7b},
-	{0x8e16,0xff},
-	{0x8e17,0xfa},
-	{0x8e18,0xf9},
-	{0x8e19,0xf8},
-	{0x8e1a,0x12},
-	{0x8e1b,0x02},
-	{0x8e1c,0x7a},
-	{0x8e1d,0x12},
-	{0x8e1e,0x01},
-	{0x8e1f,0x88},
-	{0x8e20,0xe4},
-	{0x8e21,0x93},
-	{0x8e22,0xfe},
-	{0x8e23,0x74},
-	{0x8e24,0x01},
-	{0x8e25,0x93},
-	{0x8e26,0xff},
-	{0x8e27,0xe4},
-	{0x8e28,0xfc},
-	{0x8e29,0xfd},
-	{0x8e2a,0xe5},
-	{0x8e2b,0x69},
-	{0x8e2c,0x2f},
-	{0x8e2d,0xf5},
-	{0x8e2e,0x69},
-	{0x8e2f,0xe5},
-	{0x8e30,0x68},
-	{0x8e31,0x3e},
-	{0x8e32,0xf5},
-	{0x8e33,0x68},
-	{0x8e34,0xed},
-	{0x8e35,0x35},
-	{0x8e36,0x67},
-	{0x8e37,0xf5},
-	{0x8e38,0x67},
-	{0x8e39,0xec},
-	{0x8e3a,0x35},
-	{0x8e3b,0x66},
-	{0x8e3c,0xf5},
-	{0x8e3d,0x66},
-	{0x8e3e,0x12},
-	{0x8e3f,0x02},
-	{0x8e40,0xb6},
-	{0x8e41,0x40},
-	{0x8e42,0x06},
-	{0x8e43,0x7e},
-	{0x8e44,0x03},
-	{0x8e45,0x7f},
-	{0x8e46,0xff},
-	{0x8e47,0x80},
-	{0x8e48,0x04},
-	{0x8e49,0xae},
-	{0x8e4a,0x68},
-	{0x8e4b,0xaf},
-	{0x8e4c,0x69},
-	{0x8e4d,0x12},
-	{0x8e4e,0x0e},
-	{0x8e4f,0x83},
-	{0x8e50,0xe4},
-	{0x8e51,0xf5},
-	{0x8e52,0x67},
+	{0x8d07,0x03},
+	{0x8d08,0xc3},
+	{0x8d09,0x80},
+	{0x8d0a,0x01},
+	{0x8d0b,0xd3},
+	{0x8d0c,0x92},
+	{0x8d0d,0x36},
+	{0x8d0e,0xd2},
+	{0x8d0f,0x07},
+	{0x8d10,0xc2},
+	{0x8d11,0x06},
+	{0x8d12,0x80},
+	{0x8d13,0x16},
+	{0x8d14,0x30},
+	{0x8d15,0x00},
+	{0x8d16,0x03},
+	{0x8d17,0x02},
+	{0x8d18,0x0d},
+	{0x8d19,0xc2},
+	{0x8d1a,0x20},
+	{0x8d1b,0x07},
+	{0x8d1c,0x06},
+	{0x8d1d,0x20},
+	{0x8d1e,0x06},
+	{0x8d1f,0x03},
+	{0x8d20,0xc3},
+	{0x8d21,0x80},
+	{0x8d22,0x01},
+	{0x8d23,0xd3},
+	{0x8d24,0x92},
+	{0x8d25,0x36},
+	{0x8d26,0xd2},
+	{0x8d27,0x07},
+	{0x8d28,0xd2},
+	{0x8d29,0x06},
+	{0x8d2a,0x12},
+	{0x8d2b,0x02},
+	{0x8d2c,0x9d},
+	{0x8d2d,0x80},
+	{0x8d2e,0x1e},
+	{0x8d2f,0x30},
+	{0x8d30,0x00},
+	{0x8d31,0x03},
+	{0x8d32,0x02},
+	{0x8d33,0x0d},
+	{0x8d34,0xc2},
+	{0x8d35,0xc2},
+	{0x8d36,0x07},
+	{0x8d37,0xd2},
+	{0x8d38,0x06},
+	{0x8d39,0x12},
+	{0x8d3a,0x02},
+	{0x8d3b,0xa8},
+	{0x8d3c,0xc2},
+	{0x8d3d,0x04},
+	{0x8d3e,0x02},
+	{0x8d3f,0x0d},
+	{0x8d40,0xc2},
+	{0x8d41,0x12},
+	{0x8d42,0x02},
+	{0x8d43,0x64},
+	{0x8d44,0x30},
+	{0x8d45,0x05},
+	{0x8d46,0x06},
+	{0x8d47,0xe4},
+	{0x8d48,0xf5},
+	{0x8d49,0x0c},
+	{0x8d4a,0x12},
+	{0x8d4b,0x0e},
+	{0x8d4c,0xf9},
+	{0x8d4d,0xc2},
+	{0x8d4e,0x31},
+	{0x8d4f,0xd2},
+	{0x8d50,0x34},
+	{0x8d51,0x80},
+	{0x8d52,0x6f},
+	{0x8d53,0x30},
+	{0x8d54,0x07},
+	{0x8d55,0x6c},
+	{0x8d56,0x30},
+	{0x8d57,0x06},
+	{0x8d58,0x69},
+	{0x8d59,0x12},
+	{0x8d5a,0x02},
+	{0x8d5b,0x9d},
+	{0x8d5c,0xd2},
+	{0x8d5d,0x31},
+	{0x8d5e,0x80},
+	{0x8d5f,0x62},
+	{0x8d60,0x20},
+	{0x8d61,0x07},
+	{0x8d62,0x03},
+	{0x8d63,0x30},
+	{0x8d64,0x06},
+	{0x8d65,0x09},
+	{0x8d66,0xe5},
+	{0x8d67,0x7e},
+	{0x8d68,0x64},
+	{0x8d69,0x0e},
+	{0x8d6a,0x70},
+	{0x8d6b,0x56},
+	{0x8d6c,0x20},
+	{0x8d6d,0x00},
+	{0x8d6e,0x53},
+	{0x8d6f,0x12},
+	{0x8d70,0x05},
+	{0x8d71,0x32},
+	{0x8d72,0x80},
+	{0x8d73,0x4e},
+	{0x8d74,0x12},
+	{0x8d75,0x06},
+	{0x8d76,0xfb},
+	{0x8d77,0x80},
+	{0x8d78,0x49},
+	{0x8d79,0x30},
+	{0x8d7a,0x05},
+	{0x8d7b,0x46},
+	{0x8d7c,0x20},
+	{0x8d7d,0x07},
+	{0x8d7e,0x43},
+	{0x8d7f,0x20},
+	{0x8d80,0x06},
+	{0x8d81,0x40},
+	{0x8d82,0x12},
+	{0x8d83,0x17},
+	{0x8d84,0x5c},
+	{0x8d85,0x80},
+	{0x8d86,0x3b},
+	{0x8d87,0x12},
+	{0x8d88,0x10},
+	{0x8d89,0x4b},
+	{0x8d8a,0x80},
+	{0x8d8b,0x36},
+	{0x8d8c,0x20},
+	{0x8d8d,0x07},
+	{0x8d8e,0x33},
+	{0x8d8f,0x20},
+	{0x8d90,0x06},
+	{0x8d91,0x30},
+	{0x8d92,0x12},
+	{0x8d93,0x17},
+	{0x8d94,0x6b},
+	{0x8d95,0x80},
+	{0x8d96,0x2b},
+	{0x8d97,0xe5},
+	{0x8d98,0x7e},
+	{0x8d99,0x64},
+	{0x8d9a,0x01},
+	{0x8d9b,0x70},
+	{0x8d9c,0x25},
+	{0x8d9d,0xd2},
+	{0x8d9e,0x35},
+	{0x8d9f,0x90},
+	{0x8da0,0x50},
+	{0x8da1,0x82},
+	{0x8da2,0xe5},
+	{0x8da3,0x74},
+	{0x8da4,0xf0},
+	{0x8da5,0xa3},
+	{0x8da6,0xe5},
+	{0x8da7,0x75},
+	{0x8da8,0xf0},
+	{0x8da9,0xa3},
+	{0x8daa,0xe5},
+	{0x8dab,0x76},
+	{0x8dac,0xf0},
+	{0x8dad,0xa3},
+	{0x8dae,0xe5},
+	{0x8daf,0x77},
+	{0x8db0,0xf0},
+	{0x8db1,0xc2},
+	{0x8db2,0x35},
+	{0x8db3,0x80},
+	{0x8db4,0x0d},
+	{0x8db5,0x90},
+	{0x8db6,0x50},
+	{0x8db7,0x82},
+	{0x8db8,0x30},
+	{0x8db9,0x33},
+	{0x8dba,0x05},
+	{0x8dbb,0x74},
+	{0x8dbc,0x55},
+	{0x8dbd,0xf0},
+	{0x8dbe,0x80},
+	{0x8dbf,0x02},
+	{0x8dc0,0xe4},
+	{0x8dc1,0xf0},
+	{0x8dc2,0x20},
+	{0x8dc3,0x07},
+	{0x8dc4,0x06},
+	{0x8dc5,0x30},
+	{0x8dc6,0x06},
+	{0x8dc7,0x03},
+	{0x8dc8,0x30},
+	{0x8dc9,0x04},
+	{0x8dca,0x05},
+	{0x8dcb,0x90},
+	{0x8dcc,0x30},
+	{0x8dcd,0x25},
+	{0x8dce,0xe4},
+	{0x8dcf,0xf0},
+	{0x8dd0,0x22},
+	{0x8dd1,0xc0},
+	{0x8dd2,0xe0},
+	{0x8dd3,0xc0},
+	{0x8dd4,0xf0},
+	{0x8dd5,0xc0},
+	{0x8dd6,0x83},
+	{0x8dd7,0xc0},
+	{0x8dd8,0x82},
+	{0x8dd9,0xc0},
+	{0x8dda,0xd0},
+	{0x8ddb,0x75},
+	{0x8ddc,0xd0},
+	{0x8ddd,0x00},
+	{0x8dde,0xc0},
+	{0x8ddf,0x00},
+	{0x8de0,0xc0},
+	{0x8de1,0x01},
+	{0x8de2,0xc0},
+	{0x8de3,0x02},
+	{0x8de4,0xc0},
+	{0x8de5,0x03},
+	{0x8de6,0xc0},
+	{0x8de7,0x04},
+	{0x8de8,0xc0},
+	{0x8de9,0x05},
+	{0x8dea,0xc0},
+	{0x8deb,0x06},
+	{0x8dec,0xc0},
+	{0x8ded,0x07},
+	{0x8dee,0x90},
+	{0x8def,0x3f},
+	{0x8df0,0x0c},
+	{0x8df1,0xe0},
+	{0x8df2,0xf5},
+	{0x8df3,0x08},
+	{0x8df4,0xe5},
+	{0x8df5,0x08},
+	{0x8df6,0x20},
+	{0x8df7,0xe3},
+	{0x8df8,0x03},
+	{0x8df9,0x02},
+	{0x8dfa,0x0e},
+	{0x8dfb,0x82},
+	{0x8dfc,0x30},
+	{0x8dfd,0x35},
+	{0x8dfe,0x03},
+	{0x8dff,0x02},
+	{0x8e00,0x0e},
+	{0x8e01,0x82},
+	{0x8e02,0x90},
+	{0x8e03,0x60},
+	{0x8e04,0x16},
+	{0x8e05,0xe0},
+	{0x8e06,0xf5},
+	{0x8e07,0x6a},
+	{0x8e08,0xa3},
+	{0x8e09,0xe0},
+	{0x8e0a,0xf5},
+	{0x8e0b,0x6b},
+	{0x8e0c,0x90},
+	{0x8e0d,0x60},
+	{0x8e0e,0x1e},
+	{0x8e0f,0xe0},
+	{0x8e10,0xf5},
+	{0x8e11,0x6c},
+	{0x8e12,0xa3},
+	{0x8e13,0xe0},
+	{0x8e14,0xf5},
+	{0x8e15,0x6d},
+	{0x8e16,0x90},
+	{0x8e17,0x60},
+	{0x8e18,0x26},
+	{0x8e19,0xe0},
+	{0x8e1a,0xf5},
+	{0x8e1b,0x6e},
+	{0x8e1c,0xa3},
+	{0x8e1d,0xe0},
+	{0x8e1e,0xf5},
+	{0x8e1f,0x6f},
+	{0x8e20,0x90},
+	{0x8e21,0x60},
+	{0x8e22,0x2e},
+	{0x8e23,0xe0},
+	{0x8e24,0xf5},
+	{0x8e25,0x70},
+	{0x8e26,0xa3},
+	{0x8e27,0xe0},
+	{0x8e28,0xf5},
+	{0x8e29,0x71},
+	{0x8e2a,0x90},
+	{0x8e2b,0x60},
+	{0x8e2c,0x36},
+	{0x8e2d,0x12},
+	{0x8e2e,0x00},
+	{0x8e2f,0x16},
+	{0x8e30,0x12},
+	{0x8e31,0x01},
+	{0x8e32,0xbc},
+	{0x8e33,0x40},
+	{0x8e34,0x06},
+	{0x8e35,0x75},
+	{0x8e36,0x2a},
+	{0x8e37,0xff},
+	{0x8e38,0x75},
+	{0x8e39,0x2b},
+	{0x8e3a,0xff},
+	{0x8e3b,0x85},
+	{0x8e3c,0x2a},
+	{0x8e3d,0x74},
+	{0x8e3e,0x85},
+	{0x8e3f,0x2b},
+	{0x8e40,0x75},
+	{0x8e41,0x90},
+	{0x8e42,0x60},
+	{0x8e43,0x1a},
+	{0x8e44,0xe0},
+	{0x8e45,0xf5},
+	{0x8e46,0x6a},
+	{0x8e47,0xa3},
+	{0x8e48,0xe0},
+	{0x8e49,0xf5},
+	{0x8e4a,0x6b},
+	{0x8e4b,0x90},
+	{0x8e4c,0x60},
+	{0x8e4d,0x22},
+	{0x8e4e,0xe0},
+	{0x8e4f,0xf5},
+	{0x8e50,0x6c},
+	{0x8e51,0xa3},
+	{0x8e52,0xe0},
 	{0x8e53,0xf5},
-	{0x8e54,0x67},
-	{0x8e55,0xe5},
-	{0x8e56,0x67},
-	{0x8e57,0xd3},
-	{0x8e58,0x95},
-	{0x8e59,0x7c},
-	{0x8e5a,0x50},
-	{0x8e5b,0x1c},
-	{0x8e5c,0x12},
-	{0x8e5d,0x01},
-	{0x8e5e,0x88},
-	{0x8e5f,0xaf},
-	{0x8e60,0x67},
-	{0x8e61,0x75},
-	{0x8e62,0xf0},
-	{0x8e63,0x02},
-	{0x8e64,0xef},
-	{0x8e65,0x12},
-	{0x8e66,0x09},
-	{0x8e67,0xee},
-	{0x8e68,0xc3},
-	{0x8e69,0x74},
-	{0x8e6a,0x01},
-	{0x8e6b,0x93},
-	{0x8e6c,0x95},
-	{0x8e6d,0x69},
-	{0x8e6e,0xe4},
-	{0x8e6f,0x93},
-	{0x8e70,0x95},
-	{0x8e71,0x68},
-	{0x8e72,0x50},
-	{0x8e73,0x04},
-	{0x8e74,0x05},
-	{0x8e75,0x67},
-	{0x8e76,0x80},
-	{0x8e77,0xdd},
-	{0x8e78,0x85},
-	{0x8e79,0x67},
-	{0x8e7a,0x7d},
-	{0x8e7b,0x90},
-	{0x8e7c,0x30},
-	{0x8e7d,0x25},
-	{0x8e7e,0xe4},
-	{0x8e7f,0xf0},
+	{0x8e54,0x6d},
+	{0x8e55,0x90},
+	{0x8e56,0x60},
+	{0x8e57,0x2a},
+	{0x8e58,0xe0},
+	{0x8e59,0xf5},
+	{0x8e5a,0x6e},
+	{0x8e5b,0xa3},
+	{0x8e5c,0xe0},
+	{0x8e5d,0xf5},
+	{0x8e5e,0x6f},
+	{0x8e5f,0x90},
+	{0x8e60,0x60},
+	{0x8e61,0x32},
+	{0x8e62,0xe0},
+	{0x8e63,0xf5},
+	{0x8e64,0x70},
+	{0x8e65,0xa3},
+	{0x8e66,0xe0},
+	{0x8e67,0xf5},
+	{0x8e68,0x71},
+	{0x8e69,0x90},
+	{0x8e6a,0x60},
+	{0x8e6b,0x3a},
+	{0x8e6c,0x12},
+	{0x8e6d,0x00},
+	{0x8e6e,0x16},
+	{0x8e6f,0x12},
+	{0x8e70,0x01},
+	{0x8e71,0xbc},
+	{0x8e72,0x40},
+	{0x8e73,0x06},
+	{0x8e74,0x75},
+	{0x8e75,0x2a},
+	{0x8e76,0xff},
+	{0x8e77,0x75},
+	{0x8e78,0x2b},
+	{0x8e79,0xff},
+	{0x8e7a,0x85},
+	{0x8e7b,0x2a},
+	{0x8e7c,0x76},
+	{0x8e7d,0x85},
+	{0x8e7e,0x2b},
+	{0x8e7f,0x77},
 	{0x8e80,0xd2},
-	{0x8e81,0x34},
-	{0x8e82,0x22},
-	{0x8e83,0x8e},
-	{0x8e84,0x68},
-	{0x8e85,0x8f},
-	{0x8e86,0x69},
-	{0x8e87,0x85},
-	{0x8e88,0x68},
-	{0x8e89,0x64},
-	{0x8e8a,0x85},
-	{0x8e8b,0x69},
-	{0x8e8c,0x65},
+	{0x8e81,0x3d},
+	{0x8e82,0xe5},
+	{0x8e83,0x08},
+	{0x8e84,0x30},
+	{0x8e85,0xe5},
+	{0x8e86,0x44},
+	{0x8e87,0x90},
+	{0x8e88,0x56},
+	{0x8e89,0x90},
+	{0x8e8a,0xe0},
+	{0x8e8b,0xf5},
+	{0x8e8c,0x55},
 	{0x8e8d,0xe5},
-	{0x8e8e,0x69},
-	{0x8e8f,0xc4},
-	{0x8e90,0xf8},
-	{0x8e91,0x54},
-	{0x8e92,0x0f},
-	{0x8e93,0xc8},
-	{0x8e94,0x68},
-	{0x8e95,0xf5},
-	{0x8e96,0x69},
-	{0x8e97,0xe5},
-	{0x8e98,0x68},
-	{0x8e99,0xc4},
-	{0x8e9a,0x54},
-	{0x8e9b,0xf0},
-	{0x8e9c,0x48},
-	{0x8e9d,0xf5},
-	{0x8e9e,0x68},
-	{0x8e9f,0x85},
-	{0x8ea0,0x68},
-	{0x8ea1,0x11},
-	{0x8ea2,0x85},
-	{0x8ea3,0x69},
-	{0x8ea4,0x12},
-	{0x8ea5,0x12},
-	{0x8ea6,0x0a},
-	{0x8ea7,0x20},
-	{0x8ea8,0x22},
-	{0x8ea9,0xe5},
-	{0x8eaa,0x0c},
-	{0x8eab,0xd3},
-	{0x8eac,0x95},
-	{0x8ead,0x7c},
-	{0x8eae,0x40},
-	{0x8eaf,0x01},
-	{0x8eb0,0x22},
-	{0x8eb1,0x12},
-	{0x8eb2,0x01},
-	{0x8eb3,0x88},
-	{0x8eb4,0x75},
-	{0x8eb5,0xf0},
-	{0x8eb6,0x02},
-	{0x8eb7,0xe5},
-	{0x8eb8,0x0c},
-	{0x8eb9,0x12},
-	{0x8eba,0x09},
-	{0x8ebb,0xee},
-	{0x8ebc,0xe4},
-	{0x8ebd,0x93},
-	{0x8ebe,0xf5},
-	{0x8ebf,0x0d},
-	{0x8ec0,0x74},
-	{0x8ec1,0x01},
-	{0x8ec2,0x93},
-	{0x8ec3,0xf5},
-	{0x8ec4,0x0e},
-	{0x8ec5,0x45},
-	{0x8ec6,0x0d},
-	{0x8ec7,0x70},
-	{0x8ec8,0x08},
-	{0x8ec9,0x85},
-	{0x8eca,0x64},
-	{0x8ecb,0x0f},
-	{0x8ecc,0x85},
-	{0x8ecd,0x65},
-	{0x8ece,0x10},
-	{0x8ecf,0x80},
-	{0x8ed0,0x13},
-	{0x8ed1,0x12},
-	{0x8ed2,0x01},
-	{0x8ed3,0xe4},
+	{0x8e8e,0x7b},
+	{0x8e8f,0x24},
+	{0x8e90,0x02},
+	{0x8e91,0xff},
+	{0x8e92,0xe4},
+	{0x8e93,0x33},
+	{0x8e94,0xfe},
+	{0x8e95,0xad},
+	{0x8e96,0x55},
+	{0x8e97,0xc3},
+	{0x8e98,0xef},
+	{0x8e99,0x9d},
+	{0x8e9a,0x74},
+	{0x8e9b,0x80},
+	{0x8e9c,0xf8},
+	{0x8e9d,0x6e},
+	{0x8e9e,0x98},
+	{0x8e9f,0x50},
+	{0x8ea0,0x02},
+	{0x8ea1,0x80},
+	{0x8ea2,0x01},
+	{0x8ea3,0xc3},
+	{0x8ea4,0x92},
+	{0x8ea5,0x27},
+	{0x8ea6,0xaf},
+	{0x8ea7,0x55},
+	{0x8ea8,0xef},
+	{0x8ea9,0x24},
+	{0x8eaa,0x02},
+	{0x8eab,0xff},
+	{0x8eac,0xe4},
+	{0x8ead,0x33},
+	{0x8eae,0xfe},
+	{0x8eaf,0xc3},
+	{0x8eb0,0xef},
+	{0x8eb1,0x95},
+	{0x8eb2,0x7b},
+	{0x8eb3,0x74},
+	{0x8eb4,0x80},
+	{0x8eb5,0xf8},
+	{0x8eb6,0x6e},
+	{0x8eb7,0x98},
+	{0x8eb8,0x50},
+	{0x8eb9,0x02},
+	{0x8eba,0x80},
+	{0x8ebb,0x02},
+	{0x8ebc,0xa2},
+	{0x8ebd,0x27},
+	{0x8ebe,0x92},
+	{0x8ebf,0x27},
+	{0x8ec0,0x30},
+	{0x8ec1,0x27},
+	{0x8ec2,0x04},
+	{0x8ec3,0xaf},
+	{0x8ec4,0x55},
+	{0x8ec5,0x80},
+	{0x8ec6,0x02},
+	{0x8ec7,0xaf},
+	{0x8ec8,0x7b},
+	{0x8ec9,0x8f},
+	{0x8eca,0x7b},
+	{0x8ecb,0xe5},
+	{0x8ecc,0x08},
+	{0x8ecd,0x30},
+	{0x8ece,0xe1},
+	{0x8ecf,0x08},
+	{0x8ed0,0x90},
+	{0x8ed1,0x30},
+	{0x8ed2,0x24},
+	{0x8ed3,0xe0},
 	{0x8ed4,0xf5},
-	{0x8ed5,0x11},
-	{0x8ed6,0x85},
-	{0x8ed7,0x0e},
-	{0x8ed8,0x12},
-	{0x8ed9,0x12},
-	{0x8eda,0x0a},
-	{0x8edb,0x20},
-	{0x8edc,0x30},
-	{0x8edd,0x33},
-	{0x8ede,0x02},
-	{0x8edf,0xc3},
-	{0x8ee0,0x22},
-	{0x8ee1,0x02},
-	{0x8ee2,0x0f},
-	{0x8ee3,0x56},
-	{0x8ee4,0xd3},
-	{0x8ee5,0xe5},
-	{0x8ee6,0x10},
-	{0x8ee7,0x94},
-	{0x8ee8,0x64},
-	{0x8ee9,0xe5},
-	{0x8eea,0x0f},
-	{0x8eeb,0x94},
-	{0x8eec,0x00},
-	{0x8eed,0x40},
-	{0x8eee,0x39},
-	{0x8eef,0xd3},
-	{0x8ef0,0xe5},
-	{0x8ef1,0x10},
-	{0x8ef2,0x94},
-	{0x8ef3,0xf4},
-	{0x8ef4,0xe5},
-	{0x8ef5,0x0f},
-	{0x8ef6,0x94},
-	{0x8ef7,0x01},
-	{0x8ef8,0x40},
-	{0x8ef9,0x08},
-	{0x8efa,0x75},
-	{0x8efb,0x0f},
-	{0x8efc,0x01},
-	{0x8efd,0x75},
-	{0x8efe,0x10},
-	{0x8eff,0xc2},
-	{0x8f00,0x80},
-	{0x8f01,0x1b},
-	{0x8f02,0xd3},
-	{0x8f03,0xe5},
-	{0x8f04,0x10},
-	{0x8f05,0x94},
-	{0x8f06,0x5e},
+	{0x8ed5,0x33},
+	{0x8ed6,0xe4},
+	{0x8ed7,0xf0},
+	{0x8ed8,0x90},
+	{0x8ed9,0x3f},
+	{0x8eda,0x0c},
+	{0x8edb,0xe5},
+	{0x8edc,0x08},
+	{0x8edd,0xf0},
+	{0x8ede,0xd0},
+	{0x8edf,0x07},
+	{0x8ee0,0xd0},
+	{0x8ee1,0x06},
+	{0x8ee2,0xd0},
+	{0x8ee3,0x05},
+	{0x8ee4,0xd0},
+	{0x8ee5,0x04},
+	{0x8ee6,0xd0},
+	{0x8ee7,0x03},
+	{0x8ee8,0xd0},
+	{0x8ee9,0x02},
+	{0x8eea,0xd0},
+	{0x8eeb,0x01},
+	{0x8eec,0xd0},
+	{0x8eed,0x00},
+	{0x8eee,0xd0},
+	{0x8eef,0xd0},
+	{0x8ef0,0xd0},
+	{0x8ef1,0x82},
+	{0x8ef2,0xd0},
+	{0x8ef3,0x83},
+	{0x8ef4,0xd0},
+	{0x8ef5,0xf0},
+	{0x8ef6,0xd0},
+	{0x8ef7,0xe0},
+	{0x8ef8,0x32},
+	{0x8ef9,0xe5},
+	{0x8efa,0x0c},
+	{0x8efb,0xd3},
+	{0x8efc,0x95},
+	{0x8efd,0x7c},
+	{0x8efe,0x40},
+	{0x8eff,0x01},
+	{0x8f00,0x22},
+	{0x8f01,0x12},
+	{0x8f02,0x01},
+	{0x8f03,0x88},
+	{0x8f04,0x75},
+	{0x8f05,0xf0},
+	{0x8f06,0x02},
 	{0x8f07,0xe5},
-	{0x8f08,0x0f},
-	{0x8f09,0x94},
-	{0x8f0a,0x01},
-	{0x8f0b,0x40},
-	{0x8f0c,0x04},
-	{0x8f0d,0x74},
-	{0x8f0e,0xce},
-	{0x8f0f,0x80},
-	{0x8f10,0x02},
-	{0x8f11,0x74},
-	{0x8f12,0xe2},
-	{0x8f13,0x25},
-	{0x8f14,0x10},
-	{0x8f15,0xf5},
-	{0x8f16,0x10},
-	{0x8f17,0x74},
-	{0x8f18,0xff},
-	{0x8f19,0x35},
-	{0x8f1a,0x0f},
-	{0x8f1b,0xf5},
-	{0x8f1c,0x0f},
-	{0x8f1d,0x85},
-	{0x8f1e,0x0f},
-	{0x8f1f,0x0d},
-	{0x8f20,0x85},
-	{0x8f21,0x10},
-	{0x8f22,0x0e},
-	{0x8f23,0x12},
-	{0x8f24,0x01},
-	{0x8f25,0xe4},
-	{0x8f26,0x80},
+	{0x8f08,0x0c},
+	{0x8f09,0x12},
+	{0x8f0a,0x09},
+	{0x8f0b,0xee},
+	{0x8f0c,0xe4},
+	{0x8f0d,0x93},
+	{0x8f0e,0xf5},
+	{0x8f0f,0x0d},
+	{0x8f10,0x74},
+	{0x8f11,0x01},
+	{0x8f12,0x93},
+	{0x8f13,0xf5},
+	{0x8f14,0x0e},
+	{0x8f15,0x45},
+	{0x8f16,0x0d},
+	{0x8f17,0x70},
+	{0x8f18,0x08},
+	{0x8f19,0x85},
+	{0x8f1a,0x64},
+	{0x8f1b,0x0f},
+	{0x8f1c,0x85},
+	{0x8f1d,0x65},
+	{0x8f1e,0x10},
+	{0x8f1f,0x80},
+	{0x8f20,0x13},
+	{0x8f21,0x12},
+	{0x8f22,0x01},
+	{0x8f23,0xe4},
+	{0x8f24,0xf5},
+	{0x8f25,0x11},
+	{0x8f26,0x85},
 	{0x8f27,0x0e},
-	{0x8f28,0xe4},
-	{0x8f29,0xf5},
-	{0x8f2a,0x0f},
-	{0x8f2b,0xf5},
-	{0x8f2c,0x10},
-	{0x8f2d,0x75},
-	{0x8f2e,0x0d},
-	{0x8f2f,0x80},
-	{0x8f30,0xf5},
-	{0x8f31,0x0e},
-	{0x8f32,0xf5},
-	{0x8f33,0x64},
-	{0x8f34,0xf5},
-	{0x8f35,0x65},
-	{0x8f36,0x85},
-	{0x8f37,0x0d},
-	{0x8f38,0x11},
-	{0x8f39,0x85},
-	{0x8f3a,0x0e},
-	{0x8f3b,0x12},
-	{0x8f3c,0x12},
-	{0x8f3d,0x0a},
-	{0x8f3e,0x20},
-	{0x8f3f,0x30},
-	{0x8f40,0x33},
-	{0x8f41,0x02},
-	{0x8f42,0xc3},
-	{0x8f43,0x22},
+	{0x8f28,0x12},
+	{0x8f29,0x12},
+	{0x8f2a,0x0a},
+	{0x8f2b,0x20},
+	{0x8f2c,0x30},
+	{0x8f2d,0x33},
+	{0x8f2e,0x02},
+	{0x8f2f,0xc3},
+	{0x8f30,0x22},
+	{0x8f31,0x02},
+	{0x8f32,0x0f},
+	{0x8f33,0xa6},
+	{0x8f34,0xd3},
+	{0x8f35,0xe5},
+	{0x8f36,0x10},
+	{0x8f37,0x94},
+	{0x8f38,0x64},
+	{0x8f39,0xe5},
+	{0x8f3a,0x0f},
+	{0x8f3b,0x94},
+	{0x8f3c,0x00},
+	{0x8f3d,0x40},
+	{0x8f3e,0x39},
+	{0x8f3f,0xd3},
+	{0x8f40,0xe5},
+	{0x8f41,0x10},
+	{0x8f42,0x94},
+	{0x8f43,0xf4},
 	{0x8f44,0xe5},
-	{0x8f45,0x10},
-	{0x8f46,0x45},
-	{0x8f47,0x0f},
-	{0x8f48,0x60},
-	{0x8f49,0x0c},
+	{0x8f45,0x0f},
+	{0x8f46,0x94},
+	{0x8f47,0x01},
+	{0x8f48,0x40},
+	{0x8f49,0x08},
 	{0x8f4a,0x75},
-	{0x8f4b,0x11},
-	{0x8f4c,0x00},
+	{0x8f4b,0x0f},
+	{0x8f4c,0x01},
 	{0x8f4d,0x75},
-	{0x8f4e,0x12},
-	{0x8f4f,0x32},
-	{0x8f50,0x12},
-	{0x8f51,0x15},
-	{0x8f52,0x56},
-	{0x8f53,0x02},
-	{0x8f54,0x0e},
-	{0x8f55,0xe4},
-	{0x8f56,0x85},
-	{0x8f57,0x0c},
-	{0x8f58,0x7d},
-	{0x8f59,0xd3},
-	{0x8f5a,0x22},
-	{0x8f5b,0x12},
-	{0x8f5c,0x02},
-	{0x8f5d,0x92},
-	{0x8f5e,0xb5},
-	{0x8f5f,0x07},
-	{0x8f60,0x03},
-	{0x8f61,0xd3},
-	{0x8f62,0x80},
-	{0x8f63,0x01},
-	{0x8f64,0xc3},
-	{0x8f65,0x40},
-	{0x8f66,0x03},
-	{0x8f67,0x02},
-	{0x8f68,0x0f},
-	{0x8f69,0xfa},
-	{0x8f6a,0x90},
-	{0x8f6b,0x30},
-	{0x8f6c,0x04},
-	{0x8f6d,0xe0},
-	{0x8f6e,0x44},
-	{0x8f6f,0x20},
-	{0x8f70,0xf0},
-	{0x8f71,0xa3},
-	{0x8f72,0xe0},
-	{0x8f73,0x44},
-	{0x8f74,0x40},
-	{0x8f75,0xf0},
-	{0x8f76,0x90},
-	{0x8f77,0x50},
-	{0x8f78,0x25},
-	{0x8f79,0xe0},
-	{0x8f7a,0x44},
-	{0x8f7b,0x04},
-	{0x8f7c,0xf0},
-	{0x8f7d,0x90},
-	{0x8f7e,0x50},
-	{0x8f7f,0x03},
-	{0x8f80,0xe0},
-	{0x8f81,0x54},
-	{0x8f82,0xfd},
-	{0x8f83,0xf0},
-	{0x8f84,0x90},
-	{0x8f85,0x50},
-	{0x8f86,0x27},
-	{0x8f87,0xe0},
-	{0x8f88,0x44},
-	{0x8f89,0x01},
-	{0x8f8a,0xf0},
-	{0x8f8b,0x90},
-	{0x8f8c,0x50},
-	{0x8f8d,0x31},
-	{0x8f8e,0xe4},
-	{0x8f8f,0xf0},
-	{0x8f90,0x90},
-	{0x8f91,0x50},
-	{0x8f92,0x33},
-	{0x8f93,0xf0},
-	{0x8f94,0x90},
-	{0x8f95,0x30},
-	{0x8f96,0x1e},
-	{0x8f97,0x12},
-	{0x8f98,0x02},
-	{0x8f99,0x1f},
-	{0x8f9a,0x90},
-	{0x8f9b,0x30},
-	{0x8f9c,0x18},
-	{0x8f9d,0x12},
-	{0x8f9e,0x02},
-	{0x8f9f,0x1f},
-	{0x8fa0,0x90},
-	{0x8fa1,0x30},
-	{0x8fa2,0x1b},
-	{0x8fa3,0x12},
-	{0x8fa4,0x02},
-	{0x8fa5,0x1f},
-	{0x8fa6,0xe0},
-	{0x8fa7,0xf5},
-	{0x8fa8,0x25},
-	{0x8fa9,0x90},
-	{0x8faa,0x30},
-	{0x8fab,0x18},
-	{0x8fac,0xe0},
-	{0x8fad,0xf5},
-	{0x8fae,0x21},
-	{0x8faf,0x90},
-	{0x8fb0,0x60},
-	{0x8fb1,0x00},
-	{0x8fb2,0x74},
-	{0x8fb3,0xf5},
-	{0x8fb4,0xf0},
-	{0x8fb5,0x90},
-	{0x8fb6,0x3f},
-	{0x8fb7,0x01},
-	{0x8fb8,0xe4},
-	{0x8fb9,0xf0},
-	{0x8fba,0xa3},
-	{0x8fbb,0xf0},
-	{0x8fbc,0x90},
-	{0x8fbd,0x3f},
-	{0x8fbe,0x01},
-	{0x8fbf,0xe0},
-	{0x8fc0,0x44},
-	{0x8fc1,0x08},
-	{0x8fc2,0xf0},
-	{0x8fc3,0xe0},
-	{0x8fc4,0x44},
-	{0x8fc5,0x20},
-	{0x8fc6,0xf0},
-	{0x8fc7,0x90},
-	{0x8fc8,0x3f},
-	{0x8fc9,0x05},
-	{0x8fca,0x74},
-	{0x8fcb,0x30},
+	{0x8f4e,0x10},
+	{0x8f4f,0xc2},
+	{0x8f50,0x80},
+	{0x8f51,0x1b},
+	{0x8f52,0xd3},
+	{0x8f53,0xe5},
+	{0x8f54,0x10},
+	{0x8f55,0x94},
+	{0x8f56,0x5e},
+	{0x8f57,0xe5},
+	{0x8f58,0x0f},
+	{0x8f59,0x94},
+	{0x8f5a,0x01},
+	{0x8f5b,0x40},
+	{0x8f5c,0x04},
+	{0x8f5d,0x74},
+	{0x8f5e,0xce},
+	{0x8f5f,0x80},
+	{0x8f60,0x02},
+	{0x8f61,0x74},
+	{0x8f62,0xe2},
+	{0x8f63,0x25},
+	{0x8f64,0x10},
+	{0x8f65,0xf5},
+	{0x8f66,0x10},
+	{0x8f67,0x74},
+	{0x8f68,0xff},
+	{0x8f69,0x35},
+	{0x8f6a,0x0f},
+	{0x8f6b,0xf5},
+	{0x8f6c,0x0f},
+	{0x8f6d,0x85},
+	{0x8f6e,0x0f},
+	{0x8f6f,0x0d},
+	{0x8f70,0x85},
+	{0x8f71,0x10},
+	{0x8f72,0x0e},
+	{0x8f73,0x12},
+	{0x8f74,0x01},
+	{0x8f75,0xe4},
+	{0x8f76,0x80},
+	{0x8f77,0x0e},
+	{0x8f78,0xe4},
+	{0x8f79,0xf5},
+	{0x8f7a,0x0f},
+	{0x8f7b,0xf5},
+	{0x8f7c,0x10},
+	{0x8f7d,0x75},
+	{0x8f7e,0x0d},
+	{0x8f7f,0x80},
+	{0x8f80,0xf5},
+	{0x8f81,0x0e},
+	{0x8f82,0xf5},
+	{0x8f83,0x64},
+	{0x8f84,0xf5},
+	{0x8f85,0x65},
+	{0x8f86,0x85},
+	{0x8f87,0x0d},
+	{0x8f88,0x11},
+	{0x8f89,0x85},
+	{0x8f8a,0x0e},
+	{0x8f8b,0x12},
+	{0x8f8c,0x12},
+	{0x8f8d,0x0a},
+	{0x8f8e,0x20},
+	{0x8f8f,0x30},
+	{0x8f90,0x33},
+	{0x8f91,0x02},
+	{0x8f92,0xc3},
+	{0x8f93,0x22},
+	{0x8f94,0xe5},
+	{0x8f95,0x10},
+	{0x8f96,0x45},
+	{0x8f97,0x0f},
+	{0x8f98,0x60},
+	{0x8f99,0x0c},
+	{0x8f9a,0x75},
+	{0x8f9b,0x11},
+	{0x8f9c,0x00},
+	{0x8f9d,0x75},
+	{0x8f9e,0x12},
+	{0x8f9f,0x32},
+	{0x8fa0,0x12},
+	{0x8fa1,0x16},
+	{0x8fa2,0xd5},
+	{0x8fa3,0x02},
+	{0x8fa4,0x0f},
+	{0x8fa5,0x34},
+	{0x8fa6,0x85},
+	{0x8fa7,0x0c},
+	{0x8fa8,0x7d},
+	{0x8fa9,0xd3},
+	{0x8faa,0x22},
+	{0x8fab,0x12},
+	{0x8fac,0x02},
+	{0x8fad,0x92},
+	{0x8fae,0xb5},
+	{0x8faf,0x07},
+	{0x8fb0,0x03},
+	{0x8fb1,0xd3},
+	{0x8fb2,0x80},
+	{0x8fb3,0x01},
+	{0x8fb4,0xc3},
+	{0x8fb5,0x40},
+	{0x8fb6,0x03},
+	{0x8fb7,0x02},
+	{0x8fb8,0x10},
+	{0x8fb9,0x4a},
+	{0x8fba,0x90},
+	{0x8fbb,0x30},
+	{0x8fbc,0x04},
+	{0x8fbd,0xe0},
+	{0x8fbe,0x44},
+	{0x8fbf,0x20},
+	{0x8fc0,0xf0},
+	{0x8fc1,0xa3},
+	{0x8fc2,0xe0},
+	{0x8fc3,0x44},
+	{0x8fc4,0x40},
+	{0x8fc5,0xf0},
+	{0x8fc6,0x90},
+	{0x8fc7,0x50},
+	{0x8fc8,0x25},
+	{0x8fc9,0xe0},
+	{0x8fca,0x44},
+	{0x8fcb,0x04},
 	{0x8fcc,0xf0},
-	{0x8fcd,0xa3},
-	{0x8fce,0x74},
-	{0x8fcf,0x24},
-	{0x8fd0,0xf0},
-	{0x8fd1,0x90},
-	{0x8fd2,0x3f},
-	{0x8fd3,0x0b},
-	{0x8fd4,0xe0},
-	{0x8fd5,0x44},
-	{0x8fd6,0x0f},
-	{0x8fd7,0xf0},
-	{0x8fd8,0x90},
-	{0x8fd9,0x3f},
-	{0x8fda,0x01},
-	{0x8fdb,0xe0},
-	{0x8fdc,0x44},
-	{0x8fdd,0x02},
-	{0x8fde,0xf0},
-	{0x8fdf,0xc2},
-	{0x8fe0,0x8c},
-	{0x8fe1,0x75},
-	{0x8fe2,0x89},
-	{0x8fe3,0x03},
-	{0x8fe4,0x75},
-	{0x8fe5,0xa8},
-	{0x8fe6,0x07},
-	{0x8fe7,0x75},
-	{0x8fe8,0xb8},
-	{0x8fe9,0x04},
-	{0x8fea,0xe4},
-	{0x8feb,0xf5},
-	{0x8fec,0xd8},
-	{0x8fed,0xf5},
-	{0x8fee,0xe8},
-	{0x8fef,0x90},
-	{0x8ff0,0x30},
-	{0x8ff1,0x01},
-	{0x8ff2,0xe0},
-	{0x8ff3,0x44},
-	{0x8ff4,0x40},
-	{0x8ff5,0xf0},
+	{0x8fcd,0x90},
+	{0x8fce,0x50},
+	{0x8fcf,0x03},
+	{0x8fd0,0xe0},
+	{0x8fd1,0x54},
+	{0x8fd2,0xfd},
+	{0x8fd3,0xf0},
+	{0x8fd4,0x90},
+	{0x8fd5,0x50},
+	{0x8fd6,0x27},
+	{0x8fd7,0xe0},
+	{0x8fd8,0x44},
+	{0x8fd9,0x01},
+	{0x8fda,0xf0},
+	{0x8fdb,0x90},
+	{0x8fdc,0x50},
+	{0x8fdd,0x31},
+	{0x8fde,0xe4},
+	{0x8fdf,0xf0},
+	{0x8fe0,0x90},
+	{0x8fe1,0x50},
+	{0x8fe2,0x33},
+	{0x8fe3,0xf0},
+	{0x8fe4,0x90},
+	{0x8fe5,0x30},
+	{0x8fe6,0x1e},
+	{0x8fe7,0x12},
+	{0x8fe8,0x02},
+	{0x8fe9,0x1f},
+	{0x8fea,0x90},
+	{0x8feb,0x30},
+	{0x8fec,0x18},
+	{0x8fed,0x12},
+	{0x8fee,0x02},
+	{0x8fef,0x1f},
+	{0x8ff0,0x90},
+	{0x8ff1,0x30},
+	{0x8ff2,0x1b},
+	{0x8ff3,0x12},
+	{0x8ff4,0x02},
+	{0x8ff5,0x1f},
 	{0x8ff6,0xe0},
-	{0x8ff7,0x54},
-	{0x8ff8,0xbf},
-	{0x8ff9,0xf0},
-	{0x8ffa,0x22},
-	{0x8ffb,0xe5},
-	{0x8ffc,0x7e},
-	{0x8ffd,0x64},
-	{0x8ffe,0x01},
-	{0x8fff,0x70},
-	{0x9000,0x4f},
-	{0x9001,0x12},
-	{0x9002,0x01},
-	{0x9003,0x88},
-	{0x9004,0xe5},
-	{0x9005,0x7d},
-	{0x9006,0x12},
+	{0x8ff7,0xf5},
+	{0x8ff8,0x25},
+	{0x8ff9,0x90},
+	{0x8ffa,0x30},
+	{0x8ffb,0x18},
+	{0x8ffc,0xe0},
+	{0x8ffd,0xf5},
+	{0x8ffe,0x21},
+	{0x8fff,0x90},
+	{0x9000,0x60},
+	{0x9001,0x00},
+	{0x9002,0x74},
+	{0x9003,0xf5},
+	{0x9004,0xf0},
+	{0x9005,0x90},
+	{0x9006,0x3f},
 	{0x9007,0x01},
-	{0x9008,0x7b},
-	{0x9009,0x12},
-	{0x900a,0x02},
-	{0x900b,0x11},
-	{0x900c,0xfe},
-	{0x900d,0xe4},
-	{0x900e,0x8f},
-	{0x900f,0x69},
-	{0x9010,0x8e},
-	{0x9011,0x68},
-	{0x9012,0xf5},
-	{0x9013,0x67},
-	{0x9014,0xf5},
-	{0x9015,0x66},
-	{0x9016,0x12},
-	{0x9017,0x02},
-	{0x9018,0x08},
-	{0x9019,0x7b},
-	{0x901a,0xff},
-	{0x901b,0xfa},
-	{0x901c,0xf9},
-	{0x901d,0xf8},
-	{0x901e,0x12},
-	{0x901f,0x01},
-	{0x9020,0xfd},
-	{0x9021,0xc0},
-	{0x9022,0x04},
-	{0x9023,0xc0},
-	{0x9024,0x05},
-	{0x9025,0xc0},
-	{0x9026,0x06},
-	{0x9027,0xc0},
-	{0x9028,0x07},
-	{0x9029,0x12},
+	{0x9008,0xe4},
+	{0x9009,0xf0},
+	{0x900a,0xa3},
+	{0x900b,0xf0},
+	{0x900c,0x90},
+	{0x900d,0x3f},
+	{0x900e,0x01},
+	{0x900f,0xe0},
+	{0x9010,0x44},
+	{0x9011,0x08},
+	{0x9012,0xf0},
+	{0x9013,0xe0},
+	{0x9014,0x44},
+	{0x9015,0x20},
+	{0x9016,0xf0},
+	{0x9017,0x90},
+	{0x9018,0x3f},
+	{0x9019,0x05},
+	{0x901a,0x74},
+	{0x901b,0x30},
+	{0x901c,0xf0},
+	{0x901d,0xa3},
+	{0x901e,0x74},
+	{0x901f,0x24},
+	{0x9020,0xf0},
+	{0x9021,0x90},
+	{0x9022,0x3f},
+	{0x9023,0x0b},
+	{0x9024,0xe0},
+	{0x9025,0x44},
+	{0x9026,0x0f},
+	{0x9027,0xf0},
+	{0x9028,0x90},
+	{0x9029,0x3f},
 	{0x902a,0x01},
-	{0x902b,0x73},
-	{0x902c,0x12},
+	{0x902b,0xe0},
+	{0x902c,0x44},
 	{0x902d,0x02},
-	{0x902e,0x11},
-	{0x902f,0xab},
-	{0x9030,0x07},
-	{0x9031,0xfa},
-	{0x9032,0xe4},
-	{0x9033,0xf9},
-	{0x9034,0xf8},
-	{0x9035,0xd0},
+	{0x902e,0xf0},
+	{0x902f,0xc2},
+	{0x9030,0x8c},
+	{0x9031,0x75},
+	{0x9032,0x89},
+	{0x9033,0x03},
+	{0x9034,0x75},
+	{0x9035,0xa8},
 	{0x9036,0x07},
-	{0x9037,0xd0},
-	{0x9038,0x06},
-	{0x9039,0xd0},
-	{0x903a,0x05},
-	{0x903b,0xd0},
-	{0x903c,0x04},
-	{0x903d,0x12},
-	{0x903e,0x02},
-	{0x903f,0x7a},
-	{0x9040,0x85},
-	{0x9041,0x69},
-	{0x9042,0x66},
-	{0x9043,0x85},
-	{0x9044,0x7d},
-	{0x9045,0x67},
-	{0x9046,0x12},
-	{0x9047,0x01},
-	{0x9048,0x88},
-	{0x9049,0x75},
-	{0x904a,0xf0},
-	{0x904b,0x02},
-	{0x904c,0xe5},
-	{0x904d,0x7d},
-	{0x904e,0x80},
-	{0x904f,0x1d},
-	{0x9050,0xe5},
-	{0x9051,0x7e},
-	{0x9052,0xb4},
-	{0x9053,0x02},
-	{0x9054,0x08},
-	{0x9055,0xe4},
-	{0x9056,0xf5},
-	{0x9057,0x67},
-	{0x9058,0x12},
-	{0x9059,0x01},
-	{0x905a,0x88},
-	{0x905b,0x80},
-	{0x905c,0x14},
-	{0x905d,0xe5},
-	{0x905e,0x7e},
-	{0x905f,0xb4},
-	{0x9060,0x03},
-	{0x9061,0x17},
-	{0x9062,0x85},
-	{0x9063,0x7c},
-	{0x9064,0x67},
-	{0x9065,0x12},
-	{0x9066,0x01},
-	{0x9067,0x88},
-	{0x9068,0x75},
-	{0x9069,0xf0},
-	{0x906a,0x02},
-	{0x906b,0xe5},
-	{0x906c,0x7c},
-	{0x906d,0x12},
-	{0x906e,0x09},
-	{0x906f,0xee},
-	{0x9070,0xe4},
-	{0x9071,0x93},
-	{0x9072,0xf5},
-	{0x9073,0x68},
-	{0x9074,0x74},
-	{0x9075,0x01},
-	{0x9076,0x93},
-	{0x9077,0xf5},
-	{0x9078,0x69},
-	{0x9079,0x90},
-	{0x907a,0x50},
-	{0x907b,0x82},
-	{0x907c,0xe5},
-	{0x907d,0x66},
-	{0x907e,0xf0},
-	{0x907f,0xa3},
-	{0x9080,0xe5},
-	{0x9081,0x67},
-	{0x9082,0xf0},
-	{0x9083,0xa3},
-	{0x9084,0xe5},
-	{0x9085,0x68},
-	{0x9086,0xf0},
-	{0x9087,0xa3},
-	{0x9088,0xe5},
-	{0x9089,0x69},
-	{0x908a,0xf0},
-	{0x908b,0x22},
-	{0x908c,0x30},
-	{0x908d,0x3c},
-	{0x908e,0x09},
-	{0x908f,0x30},
-	{0x9090,0x20},
-	{0x9091,0x06},
-	{0x9092,0xae},
-	{0x9093,0x56},
-	{0x9094,0xaf},
-	{0x9095,0x57},
-	{0x9096,0x80},
-	{0x9097,0x04},
-	{0x9098,0xae},
-	{0x9099,0x6a},
-	{0x909a,0xaf},
-	{0x909b,0x6b},
-	{0x909c,0x8e},
-	{0x909d,0x56},
-	{0x909e,0x8f},
-	{0x909f,0x57},
-	{0x90a0,0x30},
-	{0x90a1,0x3c},
-	{0x90a2,0x09},
-	{0x90a3,0x30},
-	{0x90a4,0x21},
-	{0x90a5,0x06},
-	{0x90a6,0xae},
-	{0x90a7,0x58},
-	{0x90a8,0xaf},
-	{0x90a9,0x59},
-	{0x90aa,0x80},
-	{0x90ab,0x04},
-	{0x90ac,0xae},
-	{0x90ad,0x6c},
-	{0x90ae,0xaf},
-	{0x90af,0x6d},
-	{0x90b0,0x8e},
-	{0x90b1,0x58},
-	{0x90b2,0x8f},
-	{0x90b3,0x59},
-	{0x90b4,0x30},
-	{0x90b5,0x3c},
-	{0x90b6,0x09},
-	{0x90b7,0x30},
-	{0x90b8,0x22},
-	{0x90b9,0x06},
-	{0x90ba,0xae},
-	{0x90bb,0x5a},
-	{0x90bc,0xaf},
-	{0x90bd,0x5b},
-	{0x90be,0x80},
-	{0x90bf,0x04},
-	{0x90c0,0xae},
-	{0x90c1,0x6e},
-	{0x90c2,0xaf},
-	{0x90c3,0x6f},
-	{0x90c4,0x8e},
-	{0x90c5,0x5a},
-	{0x90c6,0x8f},
-	{0x90c7,0x5b},
-	{0x90c8,0x30},
-	{0x90c9,0x3c},
-	{0x90ca,0x09},
-	{0x90cb,0x30},
-	{0x90cc,0x23},
-	{0x90cd,0x06},
-	{0x90ce,0xae},
-	{0x90cf,0x5c},
-	{0x90d0,0xaf},
-	{0x90d1,0x5d},
-	{0x90d2,0x80},
-	{0x90d3,0x04},
-	{0x90d4,0xae},
-	{0x90d5,0x70},
-	{0x90d6,0xaf},
-	{0x90d7,0x71},
-	{0x90d8,0x8e},
-	{0x90d9,0x5c},
-	{0x90da,0x8f},
-	{0x90db,0x5d},
+	{0x9037,0x75},
+	{0x9038,0xb8},
+	{0x9039,0x04},
+	{0x903a,0xe4},
+	{0x903b,0xf5},
+	{0x903c,0xd8},
+	{0x903d,0xf5},
+	{0x903e,0xe8},
+	{0x903f,0x90},
+	{0x9040,0x30},
+	{0x9041,0x01},
+	{0x9042,0xe0},
+	{0x9043,0x44},
+	{0x9044,0x40},
+	{0x9045,0xf0},
+	{0x9046,0xe0},
+	{0x9047,0x54},
+	{0x9048,0xbf},
+	{0x9049,0xf0},
+	{0x904a,0x22},
+	{0x904b,0xe5},
+	{0x904c,0x7e},
+	{0x904d,0x64},
+	{0x904e,0x01},
+	{0x904f,0x70},
+	{0x9050,0x4f},
+	{0x9051,0x12},
+	{0x9052,0x01},
+	{0x9053,0x88},
+	{0x9054,0xe5},
+	{0x9055,0x7d},
+	{0x9056,0x12},
+	{0x9057,0x01},
+	{0x9058,0x7b},
+	{0x9059,0x12},
+	{0x905a,0x02},
+	{0x905b,0x11},
+	{0x905c,0xfe},
+	{0x905d,0xe4},
+	{0x905e,0x8f},
+	{0x905f,0x69},
+	{0x9060,0x8e},
+	{0x9061,0x68},
+	{0x9062,0xf5},
+	{0x9063,0x67},
+	{0x9064,0xf5},
+	{0x9065,0x66},
+	{0x9066,0x12},
+	{0x9067,0x02},
+	{0x9068,0x08},
+	{0x9069,0x7b},
+	{0x906a,0xff},
+	{0x906b,0xfa},
+	{0x906c,0xf9},
+	{0x906d,0xf8},
+	{0x906e,0x12},
+	{0x906f,0x01},
+	{0x9070,0xfd},
+	{0x9071,0xc0},
+	{0x9072,0x04},
+	{0x9073,0xc0},
+	{0x9074,0x05},
+	{0x9075,0xc0},
+	{0x9076,0x06},
+	{0x9077,0xc0},
+	{0x9078,0x07},
+	{0x9079,0x12},
+	{0x907a,0x01},
+	{0x907b,0x73},
+	{0x907c,0x12},
+	{0x907d,0x02},
+	{0x907e,0x11},
+	{0x907f,0xab},
+	{0x9080,0x07},
+	{0x9081,0xfa},
+	{0x9082,0xe4},
+	{0x9083,0xf9},
+	{0x9084,0xf8},
+	{0x9085,0xd0},
+	{0x9086,0x07},
+	{0x9087,0xd0},
+	{0x9088,0x06},
+	{0x9089,0xd0},
+	{0x908a,0x05},
+	{0x908b,0xd0},
+	{0x908c,0x04},
+	{0x908d,0x12},
+	{0x908e,0x02},
+	{0x908f,0x7a},
+	{0x9090,0x85},
+	{0x9091,0x69},
+	{0x9092,0x66},
+	{0x9093,0x85},
+	{0x9094,0x7d},
+	{0x9095,0x67},
+	{0x9096,0x12},
+	{0x9097,0x01},
+	{0x9098,0x88},
+	{0x9099,0x75},
+	{0x909a,0xf0},
+	{0x909b,0x02},
+	{0x909c,0xe5},
+	{0x909d,0x7d},
+	{0x909e,0x80},
+	{0x909f,0x1d},
+	{0x90a0,0xe5},
+	{0x90a1,0x7e},
+	{0x90a2,0xb4},
+	{0x90a3,0x02},
+	{0x90a4,0x08},
+	{0x90a5,0xe4},
+	{0x90a6,0xf5},
+	{0x90a7,0x67},
+	{0x90a8,0x12},
+	{0x90a9,0x01},
+	{0x90aa,0x88},
+	{0x90ab,0x80},
+	{0x90ac,0x14},
+	{0x90ad,0xe5},
+	{0x90ae,0x7e},
+	{0x90af,0xb4},
+	{0x90b0,0x03},
+	{0x90b1,0x17},
+	{0x90b2,0x85},
+	{0x90b3,0x7c},
+	{0x90b4,0x67},
+	{0x90b5,0x12},
+	{0x90b6,0x01},
+	{0x90b7,0x88},
+	{0x90b8,0x75},
+	{0x90b9,0xf0},
+	{0x90ba,0x02},
+	{0x90bb,0xe5},
+	{0x90bc,0x7c},
+	{0x90bd,0x12},
+	{0x90be,0x09},
+	{0x90bf,0xee},
+	{0x90c0,0xe4},
+	{0x90c1,0x93},
+	{0x90c2,0xf5},
+	{0x90c3,0x68},
+	{0x90c4,0x74},
+	{0x90c5,0x01},
+	{0x90c6,0x93},
+	{0x90c7,0xf5},
+	{0x90c8,0x69},
+	{0x90c9,0x90},
+	{0x90ca,0x50},
+	{0x90cb,0x82},
+	{0x90cc,0xe5},
+	{0x90cd,0x66},
+	{0x90ce,0xf0},
+	{0x90cf,0xa3},
+	{0x90d0,0xe5},
+	{0x90d1,0x67},
+	{0x90d2,0xf0},
+	{0x90d3,0xa3},
+	{0x90d4,0xe5},
+	{0x90d5,0x68},
+	{0x90d6,0xf0},
+	{0x90d7,0xa3},
+	{0x90d8,0xe5},
+	{0x90d9,0x69},
+	{0x90da,0xf0},
+	{0x90db,0x22},
 	{0x90dc,0x30},
-	{0x90dd,0x3c},
+	{0x90dd,0x3e},
 	{0x90de,0x09},
 	{0x90df,0x30},
-	{0x90e0,0x24},
+	{0x90e0,0x20},
 	{0x90e1,0x06},
 	{0x90e2,0xae},
-	{0x90e3,0x5e},
+	{0x90e3,0x56},
 	{0x90e4,0xaf},
-	{0x90e5,0x5f},
+	{0x90e5,0x57},
 	{0x90e6,0x80},
 	{0x90e7,0x04},
 	{0x90e8,0xae},
-	{0x90e9,0x72},
+	{0x90e9,0x6a},
 	{0x90ea,0xaf},
-	{0x90eb,0x73},
+	{0x90eb,0x6b},
 	{0x90ec,0x8e},
-	{0x90ed,0x5e},
+	{0x90ed,0x56},
 	{0x90ee,0x8f},
-	{0x90ef,0x5f},
+	{0x90ef,0x57},
 	{0x90f0,0x30},
-	{0x90f1,0x3c},
+	{0x90f1,0x3e},
 	{0x90f2,0x09},
 	{0x90f3,0x30},
-	{0x90f4,0x25},
+	{0x90f4,0x21},
 	{0x90f5,0x06},
 	{0x90f6,0xae},
-	{0x90f7,0x60},
+	{0x90f7,0x58},
 	{0x90f8,0xaf},
-	{0x90f9,0x61},
+	{0x90f9,0x59},
 	{0x90fa,0x80},
 	{0x90fb,0x04},
 	{0x90fc,0xae},
-	{0x90fd,0x74},
+	{0x90fd,0x6c},
 	{0x90fe,0xaf},
-	{0x90ff,0x75},
+	{0x90ff,0x6d},
 	{0x9100,0x8e},
-	{0x9101,0x60},
+	{0x9101,0x58},
 	{0x9102,0x8f},
-	{0x9103,0x61},
+	{0x9103,0x59},
 	{0x9104,0x30},
-	{0x9105,0x3c},
+	{0x9105,0x3e},
 	{0x9106,0x09},
 	{0x9107,0x30},
-	{0x9108,0x26},
+	{0x9108,0x22},
 	{0x9109,0x06},
 	{0x910a,0xae},
-	{0x910b,0x62},
+	{0x910b,0x5a},
 	{0x910c,0xaf},
-	{0x910d,0x63},
+	{0x910d,0x5b},
 	{0x910e,0x80},
 	{0x910f,0x04},
 	{0x9110,0xae},
-	{0x9111,0x76},
+	{0x9111,0x6e},
 	{0x9112,0xaf},
-	{0x9113,0x77},
+	{0x9113,0x6f},
 	{0x9114,0x8e},
-	{0x9115,0x62},
+	{0x9115,0x5a},
 	{0x9116,0x8f},
-	{0x9117,0x63},
-	{0x9118,0x22},
-	{0x9119,0xd3},
-	{0x911a,0xe5},
-	{0x911b,0x57},
-	{0x911c,0x95},
-	{0x911d,0x6b},
-	{0x911e,0xe5},
-	{0x911f,0x56},
-	{0x9120,0x95},
-	{0x9121,0x6a},
-	{0x9122,0x40},
-	{0x9123,0x03},
-	{0x9124,0xd3},
-	{0x9125,0x80},
-	{0x9126,0x01},
-	{0x9127,0xc3},
-	{0x9128,0x92},
-	{0x9129,0x20},
-	{0x912a,0xd3},
-	{0x912b,0xe5},
-	{0x912c,0x59},
-	{0x912d,0x95},
-	{0x912e,0x6d},
-	{0x912f,0xe5},
-	{0x9130,0x58},
-	{0x9131,0x95},
-	{0x9132,0x6c},
-	{0x9133,0x40},
-	{0x9134,0x03},
-	{0x9135,0xd3},
+	{0x9117,0x5b},
+	{0x9118,0x30},
+	{0x9119,0x3e},
+	{0x911a,0x09},
+	{0x911b,0x30},
+	{0x911c,0x23},
+	{0x911d,0x06},
+	{0x911e,0xae},
+	{0x911f,0x5c},
+	{0x9120,0xaf},
+	{0x9121,0x5d},
+	{0x9122,0x80},
+	{0x9123,0x04},
+	{0x9124,0xae},
+	{0x9125,0x70},
+	{0x9126,0xaf},
+	{0x9127,0x71},
+	{0x9128,0x8e},
+	{0x9129,0x5c},
+	{0x912a,0x8f},
+	{0x912b,0x5d},
+	{0x912c,0x30},
+	{0x912d,0x3e},
+	{0x912e,0x09},
+	{0x912f,0x30},
+	{0x9130,0x24},
+	{0x9131,0x06},
+	{0x9132,0xae},
+	{0x9133,0x5e},
+	{0x9134,0xaf},
+	{0x9135,0x5f},
 	{0x9136,0x80},
-	{0x9137,0x01},
-	{0x9138,0xc3},
-	{0x9139,0x92},
-	{0x913a,0x21},
-	{0x913b,0xd3},
-	{0x913c,0xe5},
-	{0x913d,0x5b},
-	{0x913e,0x95},
-	{0x913f,0x6f},
-	{0x9140,0xe5},
-	{0x9141,0x5a},
-	{0x9142,0x95},
-	{0x9143,0x6e},
-	{0x9144,0x40},
-	{0x9145,0x03},
-	{0x9146,0xd3},
-	{0x9147,0x80},
-	{0x9148,0x01},
-	{0x9149,0xc3},
-	{0x914a,0x92},
-	{0x914b,0x22},
-	{0x914c,0xd3},
-	{0x914d,0xe5},
-	{0x914e,0x5d},
-	{0x914f,0x95},
-	{0x9150,0x71},
-	{0x9151,0xe5},
-	{0x9152,0x5c},
-	{0x9153,0x95},
-	{0x9154,0x70},
-	{0x9155,0x40},
-	{0x9156,0x03},
-	{0x9157,0xd3},
-	{0x9158,0x80},
-	{0x9159,0x01},
-	{0x915a,0xc3},
-	{0x915b,0x92},
-	{0x915c,0x23},
-	{0x915d,0xd3},
-	{0x915e,0xe5},
-	{0x915f,0x5f},
-	{0x9160,0x95},
-	{0x9161,0x73},
-	{0x9162,0xe5},
-	{0x9163,0x5e},
-	{0x9164,0x95},
-	{0x9165,0x72},
-	{0x9166,0x40},
-	{0x9167,0x03},
-	{0x9168,0xd3},
-	{0x9169,0x80},
-	{0x916a,0x01},
-	{0x916b,0xc3},
-	{0x916c,0x92},
-	{0x916d,0x24},
-	{0x916e,0xd3},
+	{0x9137,0x04},
+	{0x9138,0xae},
+	{0x9139,0x72},
+	{0x913a,0xaf},
+	{0x913b,0x73},
+	{0x913c,0x8e},
+	{0x913d,0x5e},
+	{0x913e,0x8f},
+	{0x913f,0x5f},
+	{0x9140,0x30},
+	{0x9141,0x3e},
+	{0x9142,0x09},
+	{0x9143,0x30},
+	{0x9144,0x25},
+	{0x9145,0x06},
+	{0x9146,0xae},
+	{0x9147,0x60},
+	{0x9148,0xaf},
+	{0x9149,0x61},
+	{0x914a,0x80},
+	{0x914b,0x04},
+	{0x914c,0xae},
+	{0x914d,0x74},
+	{0x914e,0xaf},
+	{0x914f,0x75},
+	{0x9150,0x8e},
+	{0x9151,0x60},
+	{0x9152,0x8f},
+	{0x9153,0x61},
+	{0x9154,0x30},
+	{0x9155,0x3e},
+	{0x9156,0x09},
+	{0x9157,0x30},
+	{0x9158,0x26},
+	{0x9159,0x06},
+	{0x915a,0xae},
+	{0x915b,0x62},
+	{0x915c,0xaf},
+	{0x915d,0x63},
+	{0x915e,0x80},
+	{0x915f,0x04},
+	{0x9160,0xae},
+	{0x9161,0x76},
+	{0x9162,0xaf},
+	{0x9163,0x77},
+	{0x9164,0x8e},
+	{0x9165,0x62},
+	{0x9166,0x8f},
+	{0x9167,0x63},
+	{0x9168,0x22},
+	{0x9169,0x30},
+	{0x916a,0x36},
+	{0x916b,0x4e},
+	{0x916c,0x12},
+	{0x916d,0x11},
+	{0x916e,0xe1},
 	{0x916f,0xe5},
-	{0x9170,0x61},
-	{0x9171,0x95},
-	{0x9172,0x75},
-	{0x9173,0xe5},
-	{0x9174,0x60},
-	{0x9175,0x95},
-	{0x9176,0x74},
-	{0x9177,0x40},
-	{0x9178,0x03},
-	{0x9179,0xd3},
-	{0x917a,0x80},
-	{0x917b,0x01},
-	{0x917c,0xc3},
-	{0x917d,0x92},
-	{0x917e,0x25},
-	{0x917f,0xd3},
-	{0x9180,0xe5},
-	{0x9181,0x63},
-	{0x9182,0x95},
-	{0x9183,0x77},
-	{0x9184,0xe5},
-	{0x9185,0x62},
-	{0x9186,0x95},
-	{0x9187,0x76},
-	{0x9188,0x40},
-	{0x9189,0x03},
-	{0x918a,0xd3},
-	{0x918b,0x80},
-	{0x918c,0x01},
-	{0x918d,0xc3},
-	{0x918e,0x92},
-	{0x918f,0x26},
-	{0x9190,0x22},
-	{0x9191,0x56},
-	{0x9192,0x0c},
-	{0x9193,0x04},
-	{0x9194,0x00},
-	{0x9195,0x00},
-	{0x9196,0x00},
-	{0x9197,0xc8},
-	{0x9198,0x01},
-	{0x9199,0x2c},
-	{0x919a,0x01},
-	{0x919b,0x5e},
-	{0x919c,0x01},
-	{0x919d,0x8b},
-	{0x919e,0x01},
-	{0x919f,0xb8},
-	{0x91a0,0x01},
-	{0x91a1,0xe5},
-	{0x91a2,0x02},
-	{0x91a3,0x12},
-	{0x91a4,0x02},
-	{0x91a5,0x3f},
-	{0x91a6,0x02},
-	{0x91a7,0x6c},
-	{0x91a8,0x02},
-	{0x91a9,0x99},
-	{0x91aa,0x02},
-	{0x91ab,0xc6},
-	{0x91ac,0x02},
-	{0x91ad,0xf3},
-	{0x91ae,0x07},
-	{0x91af,0x20},
-	{0x91b0,0x12},
-	{0x91b1,0x28},
-	{0x91b2,0x1e},
-	{0x91b3,0x18},
-	{0x91b4,0x18},
-	{0x91b5,0x28},
-	{0x91b6,0x1e},
-	{0x91b7,0x18},
-	{0x91b8,0x12},
-	{0x91b9,0x28},
-	{0x91ba,0x1e},
-	{0x91bb,0x18},
-	{0x91bc,0x12},
-	{0x91bd,0x28},
-	{0x91be,0x18},
-	{0x91bf,0x18},
-	{0x91c0,0x12},
-	{0x91c1,0x20},
-	{0x91c2,0x18},
-	{0x91c3,0x28},
-	{0x91c4,0x1c},
-	{0x91c5,0x30},
-	{0x91c6,0x24},
-	{0x91c7,0x10},
-	{0x91c8,0x1c},
-	{0x91c9,0x18},
-	{0x91ca,0x24},
-	{0x91cb,0x1c},
-	{0x91cc,0x14},
-	{0x91cd,0x24},
-	{0x91ce,0x1c},
-	{0x91cf,0x28},
-	{0x91d0,0x0c},
-	{0x91d1,0x30},
-	{0x91d2,0x14},
-	{0x91d3,0x10},
-	{0x91d4,0x0c},
-	{0x91d5,0x18},
-	{0x91d6,0x14},
-	{0x91d7,0x1c},
-	{0x91d8,0x20},
-	{0x91d9,0x24},
-	{0x91da,0x28},
-	{0x91db,0x0c},
-	{0x91dc,0x14},
-	{0x91dd,0x14},
-	{0x91de,0x1c},
-	{0x91df,0x1c},
-	{0x91e0,0x14},
-	{0x91e1,0x24},
-	{0x91e2,0x1c},
-	{0x91e3,0x2c},
-	{0x91e4,0x14},
-	{0x91e5,0x34},
-	{0x91e6,0x1c},
-	{0x91e7,0x1c},
-	{0x91e8,0x08},
-	{0x91e9,0x24},
-	{0x91ea,0x10},
-	{0x91eb,0x19},
-	{0x91ec,0x19},
-	{0x91ed,0x1c},
-	{0x91ee,0x19},
-	{0x91ef,0x19},
-	{0x91f0,0x10},
-	{0x91f1,0x10},
-	{0x91f2,0x10},
-	{0x91f3,0x10},
-	{0x91f4,0x10},
-	{0x91f5,0x00},
-	{0x91f6,0x00},
-	{0x91f7,0x00},
-	{0x91f8,0x00},
-	{0x91f9,0x00},
-	{0x91fa,0xe5},
-	{0x91fb,0x0a},
-	{0x91fc,0x70},
-	{0x91fd,0x04},
-	{0x91fe,0x7a},
-	{0x91ff,0x11},
-	{0x9200,0x7b},
-	{0x9201,0xaf},
-	{0x9202,0xe5},
-	{0x9203,0x0a},
-	{0x9204,0xb4},
-	{0x9205,0x01},
-	{0x9206,0x04},
-	{0x9207,0x7a},
-	{0x9208,0x11},
-	{0x9209,0x7b},
-	{0x920a,0xc3},
-	{0x920b,0xe5},
-	{0x920c,0x0a},
-	{0x920d,0xb4},
-	{0x920e,0x02},
-	{0x920f,0x04},
-	{0x9210,0x7a},
-	{0x9211,0x11},
-	{0x9212,0x7b},
-	{0x9213,0xd7},
-	{0x9214,0x8b},
-	{0x9215,0x82},
-	{0x9216,0x8a},
-	{0x9217,0x83},
-	{0x9218,0x12},
-	{0x9219,0x09},
-	{0x921a,0xde},
-	{0x921b,0x8f},
-	{0x921c,0x37},
-	{0x921d,0x8e},
-	{0x921e,0x36},
-	{0x921f,0x8d},
-	{0x9220,0x35},
-	{0x9221,0x8c},
-	{0x9222,0x34},
+	{0x9170,0x32},
+	{0x9171,0xd3},
+	{0x9172,0x95},
+	{0x9173,0x7d},
+	{0x9174,0x40},
+	{0x9175,0x0c},
+	{0x9176,0xe5},
+	{0x9177,0x32},
+	{0x9178,0x04},
+	{0x9179,0xf5},
+	{0x917a,0x0c},
+	{0x917b,0x12},
+	{0x917c,0x0e},
+	{0x917d,0xf9},
+	{0x917e,0xd2},
+	{0x917f,0x37},
+	{0x9180,0x80},
+	{0x9181,0x44},
+	{0x9182,0xe5},
+	{0x9183,0x7c},
+	{0x9184,0xb5},
+	{0x9185,0x7d},
+	{0x9186,0x04},
+	{0x9187,0x7f},
+	{0x9188,0x01},
+	{0x9189,0x80},
+	{0x918a,0x02},
+	{0x918b,0x7f},
+	{0x918c,0x00},
+	{0x918d,0xef},
+	{0x918e,0x24},
+	{0x918f,0xfb},
+	{0x9190,0xd3},
+	{0x9191,0x64},
+	{0x9192,0x80},
+	{0x9193,0xf8},
+	{0x9194,0xe5},
+	{0x9195,0x7d},
+	{0x9196,0x64},
+	{0x9197,0x80},
+	{0x9198,0x98},
+	{0x9199,0x40},
+	{0x919a,0x12},
+	{0x919b,0xc2},
+	{0x919c,0x37},
+	{0x919d,0xe5},
+	{0x919e,0x7c},
+	{0x919f,0xb5},
+	{0x91a0,0x7d},
+	{0x91a1,0x04},
+	{0x91a2,0x7f},
+	{0x91a3,0x01},
+	{0x91a4,0x80},
+	{0x91a5,0x02},
+	{0x91a6,0x7f},
+	{0x91a7,0x00},
+	{0x91a8,0xef},
+	{0x91a9,0x24},
+	{0x91aa,0xfa},
+	{0x91ab,0x80},
+	{0x91ac,0x06},
+	{0x91ad,0xd2},
+	{0x91ae,0x37},
+	{0x91af,0xe5},
+	{0x91b0,0x7d},
+	{0x91b1,0x24},
+	{0x91b2,0x02},
+	{0x91b3,0xf5},
+	{0x91b4,0x0c},
+	{0x91b5,0x12},
+	{0x91b6,0x0e},
+	{0x91b7,0xf9},
+	{0x91b8,0x80},
+	{0x91b9,0x0c},
+	{0x91ba,0xe5},
+	{0x91bb,0x7d},
+	{0x91bc,0x70},
+	{0x91bd,0x0f},
+	{0x91be,0x12},
+	{0x91bf,0x11},
+	{0x91c0,0xe1},
+	{0x91c1,0xc2},
+	{0x91c2,0x03},
+	{0x91c3,0x12},
+	{0x91c4,0x17},
+	{0x91c5,0x3c},
+	{0x91c6,0xd2},
+	{0x91c7,0x02},
+	{0x91c8,0xd2},
+	{0x91c9,0x01},
+	{0x91ca,0xd2},
+	{0x91cb,0x00},
+	{0x91cc,0x22},
+	{0x91cd,0x30},
+	{0x91ce,0x03},
+	{0x91cf,0x08},
+	{0x91d0,0xc2},
+	{0x91d1,0x03},
+	{0x91d2,0xc2},
+	{0x91d3,0x04},
+	{0x91d4,0x12},
+	{0x91d5,0x02},
+	{0x91d6,0xa8},
+	{0x91d7,0x22},
+	{0x91d8,0xe4},
+	{0x91d9,0xf5},
+	{0x91da,0x0c},
+	{0x91db,0x12},
+	{0x91dc,0x0e},
+	{0x91dd,0xf9},
+	{0x91de,0xd2},
+	{0x91df,0x03},
+	{0x91e0,0x22},
+	{0x91e1,0x12},
+	{0x91e2,0x17},
+	{0x91e3,0x28},
+	{0x91e4,0xc2},
+	{0x91e5,0x3e},
+	{0x91e6,0x12},
+	{0x91e7,0x10},
+	{0x91e8,0xdc},
+	{0x91e9,0xc2},
+	{0x91ea,0x3e},
+	{0x91eb,0x12},
+	{0x91ec,0x14},
+	{0x91ed,0x01},
+	{0x91ee,0x22},
+	{0x91ef,0xd3},
+	{0x91f0,0xe5},
+	{0x91f1,0x57},
+	{0x91f2,0x95},
+	{0x91f3,0x6b},
+	{0x91f4,0xe5},
+	{0x91f5,0x56},
+	{0x91f6,0x95},
+	{0x91f7,0x6a},
+	{0x91f8,0x40},
+	{0x91f9,0x03},
+	{0x91fa,0xd3},
+	{0x91fb,0x80},
+	{0x91fc,0x01},
+	{0x91fd,0xc3},
+	{0x91fe,0x92},
+	{0x91ff,0x20},
+	{0x9200,0xd3},
+	{0x9201,0xe5},
+	{0x9202,0x59},
+	{0x9203,0x95},
+	{0x9204,0x6d},
+	{0x9205,0xe5},
+	{0x9206,0x58},
+	{0x9207,0x95},
+	{0x9208,0x6c},
+	{0x9209,0x40},
+	{0x920a,0x03},
+	{0x920b,0xd3},
+	{0x920c,0x80},
+	{0x920d,0x01},
+	{0x920e,0xc3},
+	{0x920f,0x92},
+	{0x9210,0x21},
+	{0x9211,0xd3},
+	{0x9212,0xe5},
+	{0x9213,0x5b},
+	{0x9214,0x95},
+	{0x9215,0x6f},
+	{0x9216,0xe5},
+	{0x9217,0x5a},
+	{0x9218,0x95},
+	{0x9219,0x6e},
+	{0x921a,0x40},
+	{0x921b,0x03},
+	{0x921c,0xd3},
+	{0x921d,0x80},
+	{0x921e,0x01},
+	{0x921f,0xc3},
+	{0x9220,0x92},
+	{0x9221,0x22},
+	{0x9222,0xd3},
 	{0x9223,0xe5},
-	{0x9224,0x82},
-	{0x9225,0x24},
-	{0x9226,0x04},
-	{0x9227,0xf5},
-	{0x9228,0x82},
-	{0x9229,0xe4},
-	{0x922a,0x35},
-	{0x922b,0x83},
-	{0x922c,0xf5},
-	{0x922d,0x83},
-	{0x922e,0x12},
-	{0x922f,0x09},
-	{0x9230,0xde},
-	{0x9231,0x8f},
-	{0x9232,0x3b},
-	{0x9233,0x8e},
-	{0x9234,0x3a},
-	{0x9235,0x8d},
-	{0x9236,0x39},
-	{0x9237,0x8c},
-	{0x9238,0x38},
-	{0x9239,0xeb},
-	{0x923a,0x24},
-	{0x923b,0x08},
-	{0x923c,0x12},
-	{0x923d,0x02},
-	{0x923e,0x53},
-	{0x923f,0x12},
+	{0x9224,0x5d},
+	{0x9225,0x95},
+	{0x9226,0x71},
+	{0x9227,0xe5},
+	{0x9228,0x5c},
+	{0x9229,0x95},
+	{0x922a,0x70},
+	{0x922b,0x40},
+	{0x922c,0x03},
+	{0x922d,0xd3},
+	{0x922e,0x80},
+	{0x922f,0x01},
+	{0x9230,0xc3},
+	{0x9231,0x92},
+	{0x9232,0x23},
+	{0x9233,0xd3},
+	{0x9234,0xe5},
+	{0x9235,0x5f},
+	{0x9236,0x95},
+	{0x9237,0x73},
+	{0x9238,0xe5},
+	{0x9239,0x5e},
+	{0x923a,0x95},
+	{0x923b,0x72},
+	{0x923c,0x40},
+	{0x923d,0x03},
+	{0x923e,0xd3},
+	{0x923f,0x80},
 	{0x9240,0x01},
-	{0x9241,0xb3},
-	{0x9242,0xeb},
+	{0x9241,0xc3},
+	{0x9242,0x92},
 	{0x9243,0x24},
-	{0x9244,0x0c},
-	{0x9245,0x12},
-	{0x9246,0x02},
-	{0x9247,0x53},
-	{0x9248,0x8f},
-	{0x9249,0x43},
-	{0x924a,0x8e},
-	{0x924b,0x42},
-	{0x924c,0x8d},
-	{0x924d,0x41},
-	{0x924e,0x8c},
-	{0x924f,0x40},
-	{0x9250,0xeb},
-	{0x9251,0x24},
-	{0x9252,0x10},
-	{0x9253,0x12},
-	{0x9254,0x02},
-	{0x9255,0x53},
-	{0x9256,0x8f},
-	{0x9257,0x47},
-	{0x9258,0x8e},
-	{0x9259,0x46},
-	{0x925a,0x8d},
-	{0x925b,0x45},
-	{0x925c,0x8c},
-	{0x925d,0x44},
-	{0x925e,0x22},
-	{0x925f,0x30},
-	{0x9260,0x3c},
-	{0x9261,0x07},
-	{0x9262,0x30},
-	{0x9263,0x20},
-	{0x9264,0x04},
-	{0x9265,0xaf},
-	{0x9266,0x4a},
-	{0x9267,0x80},
-	{0x9268,0x02},
-	{0x9269,0xaf},
-	{0x926a,0x7d},
-	{0x926b,0x8f},
-	{0x926c,0x4a},
-	{0x926d,0x30},
-	{0x926e,0x3c},
-	{0x926f,0x07},
-	{0x9270,0x30},
-	{0x9271,0x21},
-	{0x9272,0x04},
-	{0x9273,0xaf},
-	{0x9274,0x4b},
-	{0x9275,0x80},
-	{0x9276,0x02},
-	{0x9277,0xaf},
-	{0x9278,0x7d},
-	{0x9279,0x8f},
-	{0x927a,0x4b},
-	{0x927b,0x30},
-	{0x927c,0x3c},
-	{0x927d,0x07},
-	{0x927e,0x30},
-	{0x927f,0x22},
-	{0x9280,0x04},
-	{0x9281,0xaf},
-	{0x9282,0x4c},
-	{0x9283,0x80},
-	{0x9284,0x02},
-	{0x9285,0xaf},
-	{0x9286,0x7d},
-	{0x9287,0x8f},
-	{0x9288,0x4c},
-	{0x9289,0x30},
-	{0x928a,0x3c},
-	{0x928b,0x07},
-	{0x928c,0x30},
-	{0x928d,0x23},
-	{0x928e,0x04},
-	{0x928f,0xaf},
-	{0x9290,0x4d},
-	{0x9291,0x80},
-	{0x9292,0x02},
-	{0x9293,0xaf},
-	{0x9294,0x7d},
-	{0x9295,0x8f},
-	{0x9296,0x4d},
-	{0x9297,0x30},
-	{0x9298,0x3c},
-	{0x9299,0x07},
-	{0x929a,0x30},
-	{0x929b,0x24},
-	{0x929c,0x04},
-	{0x929d,0xaf},
-	{0x929e,0x4e},
-	{0x929f,0x80},
-	{0x92a0,0x02},
-	{0x92a1,0xaf},
-	{0x92a2,0x7d},
-	{0x92a3,0x8f},
-	{0x92a4,0x4e},
-	{0x92a5,0x30},
-	{0x92a6,0x3c},
-	{0x92a7,0x07},
-	{0x92a8,0x30},
-	{0x92a9,0x25},
-	{0x92aa,0x04},
-	{0x92ab,0xaf},
-	{0x92ac,0x4f},
-	{0x92ad,0x80},
-	{0x92ae,0x02},
-	{0x92af,0xaf},
-	{0x92b0,0x7d},
-	{0x92b1,0x8f},
-	{0x92b2,0x4f},
-	{0x92b3,0x30},
-	{0x92b4,0x3c},
-	{0x92b5,0x07},
-	{0x92b6,0x30},
-	{0x92b7,0x26},
-	{0x92b8,0x04},
-	{0x92b9,0xaf},
-	{0x92ba,0x50},
-	{0x92bb,0x80},
-	{0x92bc,0x02},
-	{0x92bd,0xaf},
-	{0x92be,0x7d},
-	{0x92bf,0x8f},
-	{0x92c0,0x50},
-	{0x92c1,0x22},
-	{0x92c2,0xc2},
-	{0x92c3,0x34},
-	{0x92c4,0x20},
-	{0x92c5,0x05},
-	{0x92c6,0x05},
-	{0x92c7,0x75},
-	{0x92c8,0x0a},
-	{0x92c9,0xee},
-	{0x92ca,0x80},
-	{0x92cb,0x36},
-	{0x92cc,0x20},
-	{0x92cd,0x07},
-	{0x92ce,0x08},
-	{0x92cf,0x20},
-	{0x92d0,0x06},
-	{0x92d1,0x05},
-	{0x92d2,0xe4},
-	{0x92d3,0xf5},
-	{0x92d4,0x0a},
-	{0x92d5,0x80},
-	{0x92d6,0x2b},
-	{0x92d7,0x20},
-	{0x92d8,0x07},
-	{0x92d9,0x08},
-	{0x92da,0x30},
-	{0x92db,0x06},
-	{0x92dc,0x05},
-	{0x92dd,0x75},
-	{0x92de,0x0a},
-	{0x92df,0x20},
-	{0x92e0,0x80},
-	{0x92e1,0x20},
-	{0x92e2,0x30},
-	{0x92e3,0x00},
-	{0x92e4,0x05},
-	{0x92e5,0x75},
-	{0x92e6,0x0a},
-	{0x92e7,0x01},
-	{0x92e8,0x80},
-	{0x92e9,0x18},
-	{0x92ea,0xe5},
-	{0x92eb,0x20},
-	{0x92ec,0x54},
-	{0x92ed,0x07},
-	{0x92ee,0xff},
-	{0x92ef,0xbf},
-	{0x92f0,0x06},
-	{0x92f1,0x0d},
-	{0x92f2,0x30},
-	{0x92f3,0x31},
-	{0x92f4,0x04},
-	{0x92f5,0x7f},
-	{0x92f6,0x12},
-	{0x92f7,0x80},
-	{0x92f8,0x02},
-	{0x92f9,0x7f},
+	{0x9244,0xd3},
+	{0x9245,0xe5},
+	{0x9246,0x61},
+	{0x9247,0x95},
+	{0x9248,0x75},
+	{0x9249,0xe5},
+	{0x924a,0x60},
+	{0x924b,0x95},
+	{0x924c,0x74},
+	{0x924d,0x40},
+	{0x924e,0x03},
+	{0x924f,0xd3},
+	{0x9250,0x80},
+	{0x9251,0x01},
+	{0x9252,0xc3},
+	{0x9253,0x92},
+	{0x9254,0x25},
+	{0x9255,0xd3},
+	{0x9256,0xe5},
+	{0x9257,0x63},
+	{0x9258,0x95},
+	{0x9259,0x77},
+	{0x925a,0xe5},
+	{0x925b,0x62},
+	{0x925c,0x95},
+	{0x925d,0x76},
+	{0x925e,0x40},
+	{0x925f,0x03},
+	{0x9260,0xd3},
+	{0x9261,0x80},
+	{0x9262,0x01},
+	{0x9263,0xc3},
+	{0x9264,0x92},
+	{0x9265,0x26},
+	{0x9266,0x22},
+	{0x9267,0x56},
+	{0x9268,0x0c},
+	{0x9269,0x04},
+	{0x926a,0x00},
+	{0x926b,0x00},
+	{0x926c,0x00},
+	{0x926d,0xc8},
+	{0x926e,0x01},
+	{0x926f,0x2c},
+	{0x9270,0x01},
+	{0x9271,0x5e},
+	{0x9272,0x01},
+	{0x9273,0x8b},
+	{0x9274,0x01},
+	{0x9275,0xb8},
+	{0x9276,0x01},
+	{0x9277,0xe5},
+	{0x9278,0x02},
+	{0x9279,0x12},
+	{0x927a,0x02},
+	{0x927b,0x3f},
+	{0x927c,0x02},
+	{0x927d,0x6c},
+	{0x927e,0x02},
+	{0x927f,0x99},
+	{0x9280,0x02},
+	{0x9281,0xc6},
+	{0x9282,0x02},
+	{0x9283,0xf3},
+	{0x9284,0x07},
+	{0x9285,0x20},
+	{0x9286,0x12},
+	{0x9287,0x28},
+	{0x9288,0x1e},
+	{0x9289,0x18},
+	{0x928a,0x18},
+	{0x928b,0x28},
+	{0x928c,0x1e},
+	{0x928d,0x18},
+	{0x928e,0x12},
+	{0x928f,0x28},
+	{0x9290,0x1e},
+	{0x9291,0x18},
+	{0x9292,0x12},
+	{0x9293,0x28},
+	{0x9294,0x18},
+	{0x9295,0x18},
+	{0x9296,0x12},
+	{0x9297,0x20},
+	{0x9298,0x18},
+	{0x9299,0x28},
+	{0x929a,0x1c},
+	{0x929b,0x30},
+	{0x929c,0x24},
+	{0x929d,0x10},
+	{0x929e,0x1c},
+	{0x929f,0x18},
+	{0x92a0,0x24},
+	{0x92a1,0x1c},
+	{0x92a2,0x14},
+	{0x92a3,0x24},
+	{0x92a4,0x1c},
+	{0x92a5,0x28},
+	{0x92a6,0x0c},
+	{0x92a7,0x30},
+	{0x92a8,0x14},
+	{0x92a9,0x10},
+	{0x92aa,0x0c},
+	{0x92ab,0x18},
+	{0x92ac,0x14},
+	{0x92ad,0x1c},
+	{0x92ae,0x20},
+	{0x92af,0x24},
+	{0x92b0,0x28},
+	{0x92b1,0x0c},
+	{0x92b2,0x14},
+	{0x92b3,0x14},
+	{0x92b4,0x1c},
+	{0x92b5,0x1c},
+	{0x92b6,0x14},
+	{0x92b7,0x24},
+	{0x92b8,0x1c},
+	{0x92b9,0x2c},
+	{0x92ba,0x14},
+	{0x92bb,0x34},
+	{0x92bc,0x1c},
+	{0x92bd,0x1c},
+	{0x92be,0x08},
+	{0x92bf,0x24},
+	{0x92c0,0x10},
+	{0x92c1,0x19},
+	{0x92c2,0x19},
+	{0x92c3,0x1c},
+	{0x92c4,0x19},
+	{0x92c5,0x19},
+	{0x92c6,0x10},
+	{0x92c7,0x10},
+	{0x92c8,0x10},
+	{0x92c9,0x10},
+	{0x92ca,0x10},
+	{0x92cb,0x00},
+	{0x92cc,0x00},
+	{0x92cd,0x00},
+	{0x92ce,0x00},
+	{0x92cf,0x00},
+	{0x92d0,0x12},
+	{0x92d1,0x11},
+	{0x92d2,0xef},
+	{0x92d3,0x30},
+	{0x92d4,0x36},
+	{0x92d5,0x40},
+	{0x92d6,0xe5},
+	{0x92d7,0x24},
+	{0x92d8,0x54},
+	{0x92d9,0x1f},
+	{0x92da,0xff},
+	{0x92db,0x60},
+	{0x92dc,0x0e},
+	{0x92dd,0x64},
+	{0x92de,0x1f},
+	{0x92df,0x60},
+	{0x92e0,0x0a},
+	{0x92e1,0xe5},
+	{0x92e2,0x7c},
+	{0x92e3,0x65},
+	{0x92e4,0x7d},
+	{0x92e5,0x60},
+	{0x92e6,0x04},
+	{0x92e7,0xe5},
+	{0x92e8,0x7d},
+	{0x92e9,0x70},
+	{0x92ea,0x18},
+	{0x92eb,0xbf},
+	{0x92ec,0x1f},
+	{0x92ed,0x02},
+	{0x92ee,0xb2},
+	{0x92ef,0x37},
+	{0x92f0,0xe5},
+	{0x92f1,0x7c},
+	{0x92f2,0xb5},
+	{0x92f3,0x7d},
+	{0x92f4,0x02},
+	{0x92f5,0xc2},
+	{0x92f6,0x37},
+	{0x92f7,0xe5},
+	{0x92f8,0x7d},
+	{0x92f9,0x70},
 	{0x92fa,0x02},
-	{0x92fb,0x8f},
-	{0x92fc,0x0a},
-	{0x92fd,0x80},
-	{0x92fe,0x03},
-	{0x92ff,0x75},
-	{0x9300,0x0a},
-	{0x9301,0xfe},
-	{0x9302,0x90},
-	{0x9303,0x30},
-	{0x9304,0x27},
-	{0x9305,0xe5},
-	{0x9306,0x0a},
-	{0x9307,0xf0},
-	{0x9308,0xe5},
-	{0x9309,0x23},
-	{0x930a,0x54},
-	{0x930b,0xf8},
-	{0x930c,0xf5},
-	{0x930d,0x0a},
-	{0x930e,0xe5},
-	{0x930f,0x79},
-	{0x9310,0x25},
-	{0x9311,0x0a},
-	{0x9312,0xf5},
-	{0x9313,0x0a},
-	{0x9314,0x90},
-	{0x9315,0x30},
-	{0x9316,0x26},
-	{0x9317,0xe5},
-	{0x9318,0x0a},
-	{0x9319,0xf0},
-	{0x931a,0x22},
-	{0x931b,0xe5},
-	{0x931c,0x0a},
-	{0x931d,0x70},
-	{0x931e,0x04},
-	{0x931f,0x7e},
-	{0x9320,0x11},
-	{0x9321,0x7f},
-	{0x9322,0xeb},
+	{0x92fb,0xd2},
+	{0x92fc,0x37},
+	{0x92fd,0xc2},
+	{0x92fe,0x02},
+	{0x92ff,0xd2},
+	{0x9300,0x01},
+	{0x9301,0xd2},
+	{0x9302,0x00},
+	{0x9303,0xc2},
+	{0x9304,0x3e},
+	{0x9305,0x12},
+	{0x9306,0x10},
+	{0x9307,0xdc},
+	{0x9308,0xc2},
+	{0x9309,0x3e},
+	{0x930a,0x12},
+	{0x930b,0x14},
+	{0x930c,0x01},
+	{0x930d,0x30},
+	{0x930e,0x37},
+	{0x930f,0x03},
+	{0x9310,0x02},
+	{0x9311,0x17},
+	{0x9312,0x3c},
+	{0x9313,0x02},
+	{0x9314,0x17},
+	{0x9315,0x4d},
+	{0x9316,0xd2},
+	{0x9317,0x3e},
+	{0x9318,0x12},
+	{0x9319,0x10},
+	{0x931a,0xdc},
+	{0x931b,0xd2},
+	{0x931c,0x3e},
+	{0x931d,0x12},
+	{0x931e,0x14},
+	{0x931f,0x01},
+	{0x9320,0x12},
+	{0x9321,0x17},
+	{0x9322,0x3c},
 	{0x9323,0xe5},
-	{0x9324,0x0a},
-	{0x9325,0xb4},
-	{0x9326,0x01},
-	{0x9327,0x04},
-	{0x9328,0x7e},
-	{0x9329,0x11},
-	{0x932a,0x7f},
-	{0x932b,0xf0},
-	{0x932c,0xe5},
-	{0x932d,0x0a},
-	{0x932e,0xb4},
-	{0x932f,0x02},
-	{0x9330,0x04},
-	{0x9331,0x7e},
-	{0x9332,0x11},
-	{0x9333,0x7f},
-	{0x9334,0xf5},
-	{0x9335,0x8f},
-	{0x9336,0x82},
-	{0x9337,0x8e},
-	{0x9338,0x83},
-	{0x9339,0xe4},
-	{0x933a,0x93},
-	{0x933b,0xf5},
-	{0x933c,0x2c},
-	{0x933d,0x74},
-	{0x933e,0x01},
-	{0x933f,0x93},
-	{0x9340,0xf5},
-	{0x9341,0x2d},
-	{0x9342,0x74},
-	{0x9343,0x02},
-	{0x9344,0x93},
-	{0x9345,0xf5},
-	{0x9346,0x2e},
-	{0x9347,0x74},
-	{0x9348,0x03},
-	{0x9349,0x93},
-	{0x934a,0xf5},
-	{0x934b,0x2f},
-	{0x934c,0x74},
-	{0x934d,0x04},
-	{0x934e,0x93},
-	{0x934f,0xf5},
-	{0x9350,0x30},
-	{0x9351,0xe5},
-	{0x9352,0x0a},
-	{0x9353,0xb4},
-	{0x9354,0x01},
-	{0x9355,0x07},
-	{0x9356,0x74},
-	{0x9357,0x2c},
-	{0x9358,0x25},
-	{0x9359,0x79},
-	{0x935a,0xf8},
-	{0x935b,0x76},
-	{0x935c,0x40},
-	{0x935d,0xe5},
-	{0x935e,0x0a},
-	{0x935f,0xb4},
-	{0x9360,0x02},
+	{0x9324,0x32},
+	{0x9325,0xd3},
+	{0x9326,0x95},
+	{0x9327,0x7d},
+	{0x9328,0x40},
+	{0x9329,0x05},
+	{0x932a,0xe4},
+	{0x932b,0x95},
+	{0x932c,0x7d},
+	{0x932d,0x40},
+	{0x932e,0x06},
+	{0x932f,0xc2},
+	{0x9330,0x02},
+	{0x9331,0xd2},
+	{0x9332,0x01},
+	{0x9333,0xd2},
+	{0x9334,0x00},
+	{0x9335,0x22},
+	{0x9336,0x12},
+	{0x9337,0x11},
+	{0x9338,0xef},
+	{0x9339,0xc3},
+	{0x933a,0x30},
+	{0x933b,0x25},
+	{0x933c,0x0c},
+	{0x933d,0xe5},
+	{0x933e,0x61},
+	{0x933f,0x95},
+	{0x9340,0x75},
+	{0x9341,0xff},
+	{0x9342,0xe5},
+	{0x9343,0x60},
+	{0x9344,0x95},
+	{0x9345,0x74},
+	{0x9346,0xfe},
+	{0x9347,0x80},
+	{0x9348,0x0a},
+	{0x9349,0xe5},
+	{0x934a,0x75},
+	{0x934b,0x95},
+	{0x934c,0x61},
+	{0x934d,0xff},
+	{0x934e,0xe5},
+	{0x934f,0x74},
+	{0x9350,0x95},
+	{0x9351,0x60},
+	{0x9352,0xfe},
+	{0x9353,0x8e},
+	{0x9354,0x0a},
+	{0x9355,0x8f},
+	{0x9356,0x0b},
+	{0x9357,0x30},
+	{0x9358,0x03},
+	{0x9359,0x26},
+	{0x935a,0x12},
+	{0x935b,0x02},
+	{0x935c,0xb6},
+	{0x935d,0x50},
+	{0x935e,0x03},
+	{0x935f,0x30},
+	{0x9360,0x27},
 	{0x9361,0x07},
-	{0x9362,0x74},
-	{0x9363,0x2c},
-	{0x9364,0x25},
-	{0x9365,0x79},
-	{0x9366,0xf8},
-	{0x9367,0x76},
-	{0x9368,0x80},
-	{0x9369,0x22},
-	{0x936a,0xc0},
-	{0x936b,0xe0},
-	{0x936c,0xc0},
-	{0x936d,0x83},
-	{0x936e,0xc0},
-	{0x936f,0x82},
-	{0x9370,0xc0},
-	{0x9371,0xd0},
-	{0x9372,0x90},
-	{0x9373,0x3f},
-	{0x9374,0x0d},
-	{0x9375,0xe0},
-	{0x9376,0xf5},
-	{0x9377,0x09},
-	{0x9378,0xe5},
-	{0x9379,0x09},
-	{0x937a,0x30},
-	{0x937b,0xe0},
-	{0x937c,0x2e},
-	{0x937d,0xe5},
-	{0x937e,0x7a},
-	{0x937f,0xb4},
-	{0x9380,0x01},
-	{0x9381,0x09},
-	{0x9382,0x90},
-	{0x9383,0x3a},
-	{0x9384,0x00},
-	{0x9385,0xe0},
-	{0x9386,0xf5},
-	{0x9387,0x78},
-	{0x9388,0x44},
-	{0x9389,0x01},
-	{0x938a,0xf0},
-	{0x938b,0xe5},
-	{0x938c,0x7a},
-	{0x938d,0xb4},
-	{0x938e,0x03},
-	{0x938f,0x09},
-	{0x9390,0x90},
-	{0x9391,0x3a},
-	{0x9392,0x00},
-	{0x9393,0xe0},
-	{0x9394,0xf5},
-	{0x9395,0x78},
-	{0x9396,0x54},
-	{0x9397,0xfe},
-	{0x9398,0xf0},
-	{0x9399,0xe5},
-	{0x939a,0x7a},
-	{0x939b,0xb4},
-	{0x939c,0x03},
-	{0x939d,0x05},
-	{0x939e,0x75},
-	{0x939f,0x7a},
-	{0x93a0,0x00},
-	{0x93a1,0x80},
-	{0x93a2,0x02},
-	{0x93a3,0x05},
-	{0x93a4,0x7a},
-	{0x93a5,0x90},
-	{0x93a6,0x3f},
-	{0x93a7,0x0d},
-	{0x93a8,0x74},
-	{0x93a9,0x01},
-	{0x93aa,0xf0},
-	{0x93ab,0xd0},
-	{0x93ac,0xd0},
-	{0x93ad,0xd0},
-	{0x93ae,0x82},
-	{0x93af,0xd0},
-	{0x93b0,0x83},
-	{0x93b1,0xd0},
-	{0x93b2,0xe0},
-	{0x93b3,0x32},
-	{0x93b4,0x90},
-	{0x93b5,0x50},
-	{0x93b6,0x27},
-	{0x93b7,0xe0},
-	{0x93b8,0x44},
-	{0x93b9,0x01},
-	{0x93ba,0xf0},
-	{0x93bb,0x90},
-	{0x93bc,0x50},
-	{0x93bd,0x34},
-	{0x93be,0x74},
-	{0x93bf,0x80},
-	{0x93c0,0xf0},
-	{0x93c1,0xa3},
-	{0x93c2,0x74},
-	{0x93c3,0x2a},
-	{0x93c4,0xf0},
-	{0x93c5,0xa3},
-	{0x93c6,0x74},
-	{0x93c7,0x14},
-	{0x93c8,0xf0},
-	{0x93c9,0x90},
-	{0x93ca,0x50},
-	{0x93cb,0x30},
-	{0x93cc,0xe4},
-	{0x93cd,0xf0},
-	{0x93ce,0xa3},
-	{0x93cf,0x74},
-	{0x93d0,0x02},
-	{0x93d1,0xf0},
-	{0x93d2,0xa3},
-	{0x93d3,0xe4},
-	{0x93d4,0xf0},
-	{0x93d5,0xa3},
-	{0x93d6,0x74},
-	{0x93d7,0x80},
-	{0x93d8,0xf0},
-	{0x93d9,0xe4},
-	{0x93da,0xf5},
-	{0x93db,0x0a},
-	{0x93dc,0x12},
-	{0x93dd,0x11},
-	{0x93de,0xfa},
-	{0x93df,0x75},
-	{0x93e0,0x79},
-	{0x93e1,0x02},
-	{0x93e2,0x75},
-	{0x93e3,0x0a},
-	{0x93e4,0x01},
-	{0x93e5,0x12},
-	{0x93e6,0x13},
-	{0x93e7,0x1b},
-	{0x93e8,0xd2},
-	{0x93e9,0x18},
-	{0x93ea,0xd2},
-	{0x93eb,0x19},
-	{0x93ec,0xc2},
-	{0x93ed,0x3a},
-	{0x93ee,0xc2},
-	{0x93ef,0x39},
-	{0x93f0,0xd2},
-	{0x93f1,0x1a},
-	{0x93f2,0xd2},
-	{0x93f3,0x36},
-	{0x93f4,0xd2},
-	{0x93f5,0x30},
-	{0x93f6,0xc2},
-	{0x93f7,0x35},
-	{0x93f8,0xc2},
-	{0x93f9,0x3b},
-	{0x93fa,0x22},
-	{0x93fb,0x85},
-	{0x93fc,0x14},
-	{0x93fd,0x15},
-	{0x93fe,0x7f},
-	{0x93ff,0x08},
-	{0x9400,0xe5},
-	{0x9401,0x15},
-	{0x9402,0x30},
-	{0x9403,0xe7},
-	{0x9404,0x04},
-	{0x9405,0xd2},
-	{0x9406,0x29},
-	{0x9407,0x80},
-	{0x9408,0x02},
-	{0x9409,0xc2},
-	{0x940a,0x29},
-	{0x940b,0x12},
-	{0x940c,0x01},
-	{0x940d,0x6c},
-	{0x940e,0x75},
-	{0x940f,0x51},
-	{0x9410,0x0a},
-	{0x9411,0xae},
-	{0x9412,0x51},
-	{0x9413,0x15},
-	{0x9414,0x51},
-	{0x9415,0xee},
-	{0x9416,0x70},
-	{0x9417,0xf9},
-	{0x9418,0xe5},
-	{0x9419,0x15},
-	{0x941a,0x25},
-	{0x941b,0xe0},
-	{0x941c,0xf5},
-	{0x941d,0x15},
-	{0x941e,0xd2},
-	{0x941f,0x28},
-	{0x9420,0x12},
-	{0x9421,0x01},
-	{0x9422,0x6c},
-	{0x9423,0x75},
-	{0x9424,0x51},
-	{0x9425,0x0a},
-	{0x9426,0xae},
-	{0x9427,0x51},
-	{0x9428,0x15},
-	{0x9429,0x51},
-	{0x942a,0xee},
-	{0x942b,0x70},
-	{0x942c,0xf9},
-	{0x942d,0xc2},
-	{0x942e,0x28},
-	{0x942f,0x12},
-	{0x9430,0x01},
-	{0x9431,0x6c},
-	{0x9432,0x75},
-	{0x9433,0x51},
-	{0x9434,0x05},
-	{0x9435,0xae},
-	{0x9436,0x51},
-	{0x9437,0x15},
-	{0x9438,0x51},
-	{0x9439,0xee},
-	{0x943a,0x70},
-	{0x943b,0xf9},
-	{0x943c,0xdf},
-	{0x943d,0xc2},
-	{0x943e,0x22},
-	{0x943f,0xc2},
-	{0x9440,0xaf},
-	{0x9441,0x90},
-	{0x9442,0x30},
-	{0x9443,0x27},
-	{0x9444,0x74},
-	{0x9445,0xfa},
-	{0x9446,0xf0},
-	{0x9447,0x12},
-	{0x9448,0x0f},
-	{0x9449,0x5b},
-	{0x944a,0x12},
-	{0x944b,0x15},
-	{0x944c,0x0d},
-	{0x944d,0xe4},
-	{0x944e,0xf5},
-	{0x944f,0x33},
-	{0x9450,0xd2},
+	{0x9362,0xc2},
+	{0x9363,0x3e},
+	{0x9364,0x12},
+	{0x9365,0x10},
+	{0x9366,0xdc},
+	{0x9367,0x80},
+	{0x9368,0x2f},
+	{0x9369,0x05},
+	{0x936a,0x31},
+	{0x936b,0xe5},
+	{0x936c,0x31},
+	{0x936d,0xd3},
+	{0x936e,0x94},
+	{0x936f,0x02},
+	{0x9370,0x40},
+	{0x9371,0x29},
+	{0x9372,0xe4},
+	{0x9373,0xf5},
+	{0x9374,0x31},
+	{0x9375,0xc2},
+	{0x9376,0x03},
+	{0x9377,0xc2},
+	{0x9378,0x02},
+	{0x9379,0xc2},
+	{0x937a,0x01},
+	{0x937b,0xd2},
+	{0x937c,0x00},
+	{0x937d,0xd2},
+	{0x937e,0x34},
+	{0x937f,0x22},
+	{0x9380,0x12},
+	{0x9381,0x02},
+	{0x9382,0xb6},
+	{0x9383,0x50},
+	{0x9384,0x03},
+	{0x9385,0x30},
+	{0x9386,0x27},
+	{0x9387,0x04},
+	{0x9388,0x05},
+	{0x9389,0x31},
+	{0x938a,0x80},
+	{0x938b,0x03},
+	{0x938c,0xe4},
+	{0x938d,0xf5},
+	{0x938e,0x31},
+	{0x938f,0xe5},
+	{0x9390,0x31},
+	{0x9391,0xd3},
+	{0x9392,0x94},
+	{0x9393,0x02},
+	{0x9394,0x40},
+	{0x9395,0x05},
+	{0x9396,0xd2},
+	{0x9397,0x03},
+	{0x9398,0xe4},
+	{0x9399,0xf5},
+	{0x939a,0x31},
+	{0x939b,0x22},
+	{0x939c,0xe5},
+	{0x939d,0x0a},
+	{0x939e,0x70},
+	{0x939f,0x04},
+	{0x93a0,0x7a},
+	{0x93a1,0x12},
+	{0x93a2,0x7b},
+	{0x93a3,0x85},
+	{0x93a4,0xe5},
+	{0x93a5,0x0a},
+	{0x93a6,0xb4},
+	{0x93a7,0x01},
+	{0x93a8,0x04},
+	{0x93a9,0x7a},
+	{0x93aa,0x12},
+	{0x93ab,0x7b},
+	{0x93ac,0x99},
+	{0x93ad,0xe5},
+	{0x93ae,0x0a},
+	{0x93af,0xb4},
+	{0x93b0,0x02},
+	{0x93b1,0x04},
+	{0x93b2,0x7a},
+	{0x93b3,0x12},
+	{0x93b4,0x7b},
+	{0x93b5,0xad},
+	{0x93b6,0x8b},
+	{0x93b7,0x82},
+	{0x93b8,0x8a},
+	{0x93b9,0x83},
+	{0x93ba,0x12},
+	{0x93bb,0x09},
+	{0x93bc,0xde},
+	{0x93bd,0x8f},
+	{0x93be,0x37},
+	{0x93bf,0x8e},
+	{0x93c0,0x36},
+	{0x93c1,0x8d},
+	{0x93c2,0x35},
+	{0x93c3,0x8c},
+	{0x93c4,0x34},
+	{0x93c5,0xe5},
+	{0x93c6,0x82},
+	{0x93c7,0x24},
+	{0x93c8,0x04},
+	{0x93c9,0xf5},
+	{0x93ca,0x82},
+	{0x93cb,0xe4},
+	{0x93cc,0x35},
+	{0x93cd,0x83},
+	{0x93ce,0xf5},
+	{0x93cf,0x83},
+	{0x93d0,0x12},
+	{0x93d1,0x09},
+	{0x93d2,0xde},
+	{0x93d3,0x8f},
+	{0x93d4,0x3b},
+	{0x93d5,0x8e},
+	{0x93d6,0x3a},
+	{0x93d7,0x8d},
+	{0x93d8,0x39},
+	{0x93d9,0x8c},
+	{0x93da,0x38},
+	{0x93db,0xeb},
+	{0x93dc,0x24},
+	{0x93dd,0x08},
+	{0x93de,0x12},
+	{0x93df,0x02},
+	{0x93e0,0x53},
+	{0x93e1,0x12},
+	{0x93e2,0x01},
+	{0x93e3,0xb3},
+	{0x93e4,0xeb},
+	{0x93e5,0x24},
+	{0x93e6,0x0c},
+	{0x93e7,0x12},
+	{0x93e8,0x02},
+	{0x93e9,0x53},
+	{0x93ea,0x8f},
+	{0x93eb,0x43},
+	{0x93ec,0x8e},
+	{0x93ed,0x42},
+	{0x93ee,0x8d},
+	{0x93ef,0x41},
+	{0x93f0,0x8c},
+	{0x93f1,0x40},
+	{0x93f2,0xeb},
+	{0x93f3,0x24},
+	{0x93f4,0x10},
+	{0x93f5,0x12},
+	{0x93f6,0x02},
+	{0x93f7,0x53},
+	{0x93f8,0x8f},
+	{0x93f9,0x47},
+	{0x93fa,0x8e},
+	{0x93fb,0x46},
+	{0x93fc,0x8d},
+	{0x93fd,0x45},
+	{0x93fe,0x8c},
+	{0x93ff,0x44},
+	{0x9400,0x22},
+	{0x9401,0x30},
+	{0x9402,0x3e},
+	{0x9403,0x07},
+	{0x9404,0x30},
+	{0x9405,0x20},
+	{0x9406,0x04},
+	{0x9407,0xaf},
+	{0x9408,0x4a},
+	{0x9409,0x80},
+	{0x940a,0x02},
+	{0x940b,0xaf},
+	{0x940c,0x7d},
+	{0x940d,0x8f},
+	{0x940e,0x4a},
+	{0x940f,0x30},
+	{0x9410,0x3e},
+	{0x9411,0x07},
+	{0x9412,0x30},
+	{0x9413,0x21},
+	{0x9414,0x04},
+	{0x9415,0xaf},
+	{0x9416,0x4b},
+	{0x9417,0x80},
+	{0x9418,0x02},
+	{0x9419,0xaf},
+	{0x941a,0x7d},
+	{0x941b,0x8f},
+	{0x941c,0x4b},
+	{0x941d,0x30},
+	{0x941e,0x3e},
+	{0x941f,0x07},
+	{0x9420,0x30},
+	{0x9421,0x22},
+	{0x9422,0x04},
+	{0x9423,0xaf},
+	{0x9424,0x4c},
+	{0x9425,0x80},
+	{0x9426,0x02},
+	{0x9427,0xaf},
+	{0x9428,0x7d},
+	{0x9429,0x8f},
+	{0x942a,0x4c},
+	{0x942b,0x30},
+	{0x942c,0x3e},
+	{0x942d,0x07},
+	{0x942e,0x30},
+	{0x942f,0x23},
+	{0x9430,0x04},
+	{0x9431,0xaf},
+	{0x9432,0x4d},
+	{0x9433,0x80},
+	{0x9434,0x02},
+	{0x9435,0xaf},
+	{0x9436,0x7d},
+	{0x9437,0x8f},
+	{0x9438,0x4d},
+	{0x9439,0x30},
+	{0x943a,0x3e},
+	{0x943b,0x07},
+	{0x943c,0x30},
+	{0x943d,0x24},
+	{0x943e,0x04},
+	{0x943f,0xaf},
+	{0x9440,0x4e},
+	{0x9441,0x80},
+	{0x9442,0x02},
+	{0x9443,0xaf},
+	{0x9444,0x7d},
+	{0x9445,0x8f},
+	{0x9446,0x4e},
+	{0x9447,0x30},
+	{0x9448,0x3e},
+	{0x9449,0x07},
+	{0x944a,0x30},
+	{0x944b,0x25},
+	{0x944c,0x04},
+	{0x944d,0xaf},
+	{0x944e,0x4f},
+	{0x944f,0x80},
+	{0x9450,0x02},
 	{0x9451,0xaf},
-	{0x9452,0x12},
-	{0x9453,0x0c},
-	{0x9454,0x91},
+	{0x9452,0x7d},
+	{0x9453,0x8f},
+	{0x9454,0x4f},
 	{0x9455,0x30},
-	{0x9456,0x30},
-	{0x9457,0x03},
-	{0x9458,0x12},
-	{0x9459,0x06},
-	{0x945a,0xfb},
-	{0x945b,0x30},
-	{0x945c,0x34},
-	{0x945d,0x03},
-	{0x945e,0x12},
-	{0x945f,0x12},
-	{0x9460,0xc2},
-	{0x9461,0x30},
-	{0x9462,0x3b},
-	{0x9463,0xee},
-	{0x9464,0xc2},
-	{0x9465,0x3b},
-	{0x9466,0xd2},
-	{0x9467,0x35},
-	{0x9468,0x30},
-	{0x9469,0x00},
-	{0x946a,0x05},
-	{0x946b,0x12},
-	{0x946c,0x14},
-	{0x946d,0xe0},
-	{0x946e,0x80},
-	{0x946f,0x09},
-	{0x9470,0x20},
-	{0x9471,0x07},
-	{0x9472,0x06},
-	{0x9473,0x30},
-	{0x9474,0x06},
-	{0x9475,0x03},
-	{0x9476,0x12},
-	{0x9477,0x0d},
-	{0x9478,0x9f},
-	{0x9479,0xc2},
-	{0x947a,0x35},
-	{0x947b,0x80},
-	{0x947c,0xd5},
-	{0x947d,0x12},
-	{0x947e,0x11},
-	{0x947f,0x19},
-	{0x9480,0xd2},
-	{0x9481,0x3c},
-	{0x9482,0x12},
-	{0x9483,0x10},
-	{0x9484,0x8c},
-	{0x9485,0xd2},
-	{0x9486,0x3c},
-	{0x9487,0x12},
-	{0x9488,0x12},
-	{0x9489,0x5f},
-	{0x948a,0xe5},
-	{0x948b,0x7c},
-	{0x948c,0xd3},
-	{0x948d,0x95},
-	{0x948e,0x7d},
-	{0x948f,0x40},
-	{0x9490,0x03},
-	{0x9491,0xd3},
-	{0x9492,0x80},
-	{0x9493,0x01},
-	{0x9494,0xc3},
-	{0x9495,0x50},
-	{0x9496,0x14},
-	{0x9497,0x20},
-	{0x9498,0x37},
-	{0x9499,0x0e},
+	{0x9456,0x3e},
+	{0x9457,0x07},
+	{0x9458,0x30},
+	{0x9459,0x26},
+	{0x945a,0x04},
+	{0x945b,0xaf},
+	{0x945c,0x50},
+	{0x945d,0x80},
+	{0x945e,0x02},
+	{0x945f,0xaf},
+	{0x9460,0x7d},
+	{0x9461,0x8f},
+	{0x9462,0x50},
+	{0x9463,0x22},
+	{0x9464,0x12},
+	{0x9465,0x11},
+	{0x9466,0xef},
+	{0x9467,0xd2},
+	{0x9468,0x3e},
+	{0x9469,0x12},
+	{0x946a,0x10},
+	{0x946b,0xdc},
+	{0x946c,0xd2},
+	{0x946d,0x3e},
+	{0x946e,0x12},
+	{0x946f,0x14},
+	{0x9470,0x01},
+	{0x9471,0x30},
+	{0x9472,0x36},
+	{0x9473,0x26},
+	{0x9474,0x30},
+	{0x9475,0x37},
+	{0x9476,0x06},
+	{0x9477,0xe5},
+	{0x9478,0x7c},
+	{0x9479,0x65},
+	{0x947a,0x7d},
+	{0x947b,0x60},
+	{0x947c,0x3e},
+	{0x947d,0x20},
+	{0x947e,0x37},
+	{0x947f,0x04},
+	{0x9480,0xe5},
+	{0x9481,0x7d},
+	{0x9482,0x60},
+	{0x9483,0x37},
+	{0x9484,0xe5},
+	{0x9485,0x24},
+	{0x9486,0x54},
+	{0x9487,0x1f},
+	{0x9488,0xff},
+	{0x9489,0xbf},
+	{0x948a,0x1f},
+	{0x948b,0x06},
+	{0x948c,0x30},
+	{0x948d,0x25},
+	{0x948e,0x03},
+	{0x948f,0x20},
+	{0x9490,0x26},
+	{0x9491,0x29},
+	{0x9492,0x30},
+	{0x9493,0x37},
+	{0x9494,0x02},
+	{0x9495,0x80},
+	{0x9496,0x21},
+	{0x9497,0x02},
+	{0x9498,0x17},
+	{0x9499,0x4d},
 	{0x949a,0xe5},
-	{0x949b,0x24},
-	{0x949c,0x54},
-	{0x949d,0x1f},
-	{0x949e,0xff},
-	{0x949f,0xbf},
-	{0x94a0,0x1f},
-	{0x94a1,0x06},
-	{0x94a2,0x30},
-	{0x94a3,0x25},
-	{0x94a4,0x03},
-	{0x94a5,0x20},
-	{0x94a6,0x26},
-	{0x94a7,0x03},
-	{0x94a8,0x02},
-	{0x94a9,0x15},
-	{0x94aa,0xb5},
-	{0x94ab,0x12},
-	{0x94ac,0x02},
-	{0x94ad,0xc0},
-	{0x94ae,0x22},
-	{0x94af,0xe5},
-	{0x94b0,0x7d},
-	{0x94b1,0x70},
-	{0x94b2,0x19},
-	{0x94b3,0x12},
-	{0x94b4,0x15},
-	{0x94b5,0x8d},
-	{0x94b6,0xc2},
-	{0x94b7,0x3c},
-	{0x94b8,0x12},
-	{0x94b9,0x10},
-	{0x94ba,0x8c},
-	{0x94bb,0xc2},
-	{0x94bc,0x3c},
-	{0x94bd,0x12},
-	{0x94be,0x12},
-	{0x94bf,0x5f},
-	{0x94c0,0xc2},
-	{0x94c1,0x03},
-	{0x94c2,0x12},
-	{0x94c3,0x15},
-	{0x94c4,0xb5},
-	{0x94c5,0xd2},
-	{0x94c6,0x02},
-	{0x94c7,0xd2},
-	{0x94c8,0x01},
-	{0x94c9,0xd2},
-	{0x94ca,0x00},
-	{0x94cb,0x22},
-	{0x94cc,0x30},
-	{0x94cd,0x03},
+	{0x949b,0x7c},
+	{0x949c,0xd3},
+	{0x949d,0x95},
+	{0x949e,0x7d},
+	{0x949f,0x40},
+	{0x94a0,0x03},
+	{0x94a1,0xd3},
+	{0x94a2,0x80},
+	{0x94a3,0x01},
+	{0x94a4,0xc3},
+	{0x94a5,0x50},
+	{0x94a6,0x14},
+	{0x94a7,0x20},
+	{0x94a8,0x39},
+	{0x94a9,0x0e},
+	{0x94aa,0xe5},
+	{0x94ab,0x24},
+	{0x94ac,0x54},
+	{0x94ad,0x1f},
+	{0x94ae,0xff},
+	{0x94af,0xbf},
+	{0x94b0,0x1f},
+	{0x94b1,0x06},
+	{0x94b2,0x30},
+	{0x94b3,0x25},
+	{0x94b4,0x03},
+	{0x94b5,0x20},
+	{0x94b6,0x26},
+	{0x94b7,0x03},
+	{0x94b8,0x02},
+	{0x94b9,0x17},
+	{0x94ba,0x3c},
+	{0x94bb,0x12},
+	{0x94bc,0x02},
+	{0x94bd,0xc0},
+	{0x94be,0x22},
+	{0x94bf,0xc2},
+	{0x94c0,0x34},
+	{0x94c1,0x20},
+	{0x94c2,0x07},
+	{0x94c3,0x08},
+	{0x94c4,0x20},
+	{0x94c5,0x06},
+	{0x94c6,0x05},
+	{0x94c7,0xe4},
+	{0x94c8,0xf5},
+	{0x94c9,0x0a},
+	{0x94ca,0x80},
+	{0x94cb,0x2b},
+	{0x94cc,0x20},
+	{0x94cd,0x07},
 	{0x94ce,0x08},
-	{0x94cf,0xc2},
-	{0x94d0,0x03},
-	{0x94d1,0xc2},
-	{0x94d2,0x04},
-	{0x94d3,0x12},
-	{0x94d4,0x02},
-	{0x94d5,0xa8},
-	{0x94d6,0x22},
-	{0x94d7,0xe4},
-	{0x94d8,0xf5},
-	{0x94d9,0x0c},
-	{0x94da,0x12},
-	{0x94db,0x0e},
-	{0x94dc,0xa9},
-	{0x94dd,0xd2},
-	{0x94de,0x03},
-	{0x94df,0x22},
-	{0x94e0,0xe5},
-	{0x94e1,0x20},
-	{0x94e2,0x54},
-	{0x94e3,0x07},
-	{0x94e4,0xff},
-	{0x94e5,0xbf},
-	{0x94e6,0x01},
-	{0x94e7,0x03},
-	{0x94e8,0x02},
-	{0x94e9,0x14},
-	{0x94ea,0xaf},
-	{0x94eb,0xe5},
-	{0x94ec,0x20},
-	{0x94ed,0x54},
-	{0x94ee,0x07},
-	{0x94ef,0xff},
-	{0x94f0,0xbf},
-	{0x94f1,0x07},
-	{0x94f2,0x03},
-	{0x94f3,0x02},
-	{0x94f4,0x15},
-	{0x94f5,0x33},
-	{0x94f6,0xe5},
-	{0x94f7,0x20},
-	{0x94f8,0x54},
-	{0x94f9,0x07},
-	{0x94fa,0xff},
-	{0x94fb,0xbf},
-	{0x94fc,0x03},
-	{0x94fd,0x03},
-	{0x94fe,0x02},
-	{0x94ff,0x14},
-	{0x9500,0x7d},
-	{0x9501,0xe5},
-	{0x9502,0x20},
-	{0x9503,0x54},
-	{0x9504,0x07},
-	{0x9505,0xff},
-	{0x9506,0xbf},
-	{0x9507,0x05},
-	{0x9508,0x03},
-	{0x9509,0x12},
-	{0x950a,0x15},
-	{0x950b,0xf3},
-	{0x950c,0x22},
-	{0x950d,0x12},
-	{0x950e,0x13},
-	{0x950f,0xb4},
-	{0x9510,0x12},
-	{0x9511,0x16},
-	{0x9512,0x01},
-	{0x9513,0x50},
-	{0x9514,0x04},
-	{0x9515,0xd2},
-	{0x9516,0x05},
-	{0x9517,0x80},
-	{0x9518,0x02},
-	{0x9519,0xc2},
-	{0x951a,0x05},
-	{0x951b,0x12},
-	{0x951c,0x02},
-	{0x951d,0x64},
-	{0x951e,0xc2},
-	{0x951f,0x37},
-	{0x9520,0xc2},
-	{0x9521,0x31},
-	{0x9522,0xd2},
-	{0x9523,0x34},
-	{0x9524,0x12},
-	{0x9525,0x02},
-	{0x9526,0x92},
-	{0x9527,0xb5},
-	{0x9528,0x07},
-	{0x9529,0x03},
-	{0x952a,0xd3},
-	{0x952b,0x80},
-	{0x952c,0x01},
-	{0x952d,0xc3},
-	{0x952e,0x40},
-	{0x952f,0x02},
-	{0x9530,0xc2},
-	{0x9531,0x05},
-	{0x9532,0x22},
-	{0x9533,0x12},
-	{0x9534,0x11},
-	{0x9535,0x19},
-	{0x9536,0xd2},
-	{0x9537,0x3c},
-	{0x9538,0x12},
-	{0x9539,0x10},
-	{0x953a,0x8c},
-	{0x953b,0xd2},
-	{0x953c,0x3c},
-	{0x953d,0x12},
-	{0x953e,0x12},
-	{0x953f,0x5f},
-	{0x9540,0x12},
-	{0x9541,0x15},
-	{0x9542,0xb5},
-	{0x9543,0xe5},
-	{0x9544,0x32},
-	{0x9545,0xd3},
-	{0x9546,0x95},
-	{0x9547,0x7d},
-	{0x9548,0x40},
-	{0x9549,0x05},
-	{0x954a,0xe4},
-	{0x954b,0x95},
-	{0x954c,0x7d},
-	{0x954d,0x40},
-	{0x954e,0x06},
-	{0x954f,0xc2},
-	{0x9550,0x02},
-	{0x9551,0xd2},
-	{0x9552,0x01},
-	{0x9553,0xd2},
-	{0x9554,0x00},
-	{0x9555,0x22},
-	{0x9556,0xe4},
-	{0x9557,0xff},
-	{0x9558,0xfe},
-	{0x9559,0xc3},
-	{0x955a,0xef},
-	{0x955b,0x95},
-	{0x955c,0x12},
-	{0x955d,0xee},
-	{0x955e,0x95},
-	{0x955f,0x11},
-	{0x9560,0x50},
-	{0x9561,0x15},
-	{0x9562,0x7d},
-	{0x9563,0x8a},
-	{0x9564,0x7c},
-	{0x9565,0x02},
-	{0x9566,0xed},
-	{0x9567,0x1d},
-	{0x9568,0xaa},
-	{0x9569,0x04},
-	{0x956a,0x70},
-	{0x956b,0x01},
-	{0x956c,0x1c},
-	{0x956d,0x4a},
-	{0x956e,0x70},
-	{0x956f,0xf6},
-	{0x9570,0x0f},
-	{0x9571,0xbf},
-	{0x9572,0x00},
-	{0x9573,0x01},
-	{0x9574,0x0e},
-	{0x9575,0x80},
-	{0x9576,0xe2},
-	{0x9577,0x22},
-	{0x9578,0x75},
-	{0x9579,0x48},
-	{0x957a,0x11},
-	{0x957b,0x75},
-	{0x957c,0x49},
-	{0x957d,0x94},
-	{0x957e,0x90},
-	{0x957f,0x11},
-	{0x9580,0x92},
-	{0x9581,0xe4},
-	{0x9582,0x93},
-	{0x9583,0xf5},
-	{0x9584,0x7c},
-	{0x9585,0xa3},
-	{0x9586,0xe4},
-	{0x9587,0x93},
-	{0x9588,0xf5},
-	{0x9589,0x32},
-	{0x958a,0xc2},
-	{0x958b,0x38},
-	{0x958c,0x22},
-	{0x958d,0xe4},
-	{0x958e,0xff},
-	{0x958f,0xef},
-	{0x9590,0x25},
-	{0x9591,0xe0},
-	{0x9592,0x24},
-	{0x9593,0x56},
-	{0x9594,0xf8},
-	{0x9595,0xe4},
-	{0x9596,0xf6},
-	{0x9597,0x08},
-	{0x9598,0xf6},
-	{0x9599,0x0f},
-	{0x959a,0xbf},
-	{0x959b,0x07},
-	{0x959c,0xf2},
-	{0x959d,0x53},
-	{0x959e,0x24},
-	{0x959f,0x80},
-	{0x95a0,0x22},
-	{0x95a1,0xc2},
-	{0x95a2,0x03},
-	{0x95a3,0xd2},
-	{0x95a4,0x04},
-	{0x95a5,0x12},
-	{0x95a6,0x02},
-	{0x95a7,0xa8},
-	{0x95a8,0xc2},
-	{0x95a9,0x3c},
-	{0x95aa,0x12},
-	{0x95ab,0x10},
-	{0x95ac,0x8c},
-	{0x95ad,0xc2},
-	{0x95ae,0x3c},
-	{0x95af,0x12},
-	{0x95b0,0x12},
-	{0x95b1,0x5f},
-	{0x95b2,0xd2},
-	{0x95b3,0x34},
-	{0x95b4,0x22},
-	{0x95b5,0xe5},
-	{0x95b6,0x7d},
-	{0x95b7,0xc3},
-	{0x95b8,0x95},
-	{0x95b9,0x7c},
-	{0x95ba,0x40},
-	{0x95bb,0x01},
-	{0x95bc,0x22},
-	{0x95bd,0xe5},
-	{0x95be,0x7d},
-	{0x95bf,0x04},
-	{0x95c0,0xf5},
-	{0x95c1,0x0c},
-	{0x95c2,0x12},
-	{0x95c3,0x0e},
-	{0x95c4,0xa9},
-	{0x95c5,0x22},
-	{0x95c6,0xe5},
-	{0x95c7,0x7d},
-	{0x95c8,0x70},
-	{0x95c9,0x02},
-	{0x95ca,0xc3},
-	{0x95cb,0x22},
+	{0x94cf,0x30},
+	{0x94d0,0x06},
+	{0x94d1,0x05},
+	{0x94d2,0x75},
+	{0x94d3,0x0a},
+	{0x94d4,0x20},
+	{0x94d5,0x80},
+	{0x94d6,0x20},
+	{0x94d7,0x30},
+	{0x94d8,0x00},
+	{0x94d9,0x05},
+	{0x94da,0x75},
+	{0x94db,0x0a},
+	{0x94dc,0x01},
+	{0x94dd,0x80},
+	{0x94de,0x18},
+	{0x94df,0xe5},
+	{0x94e0,0x20},
+	{0x94e1,0x54},
+	{0x94e2,0x07},
+	{0x94e3,0xff},
+	{0x94e4,0xbf},
+	{0x94e5,0x06},
+	{0x94e6,0x0d},
+	{0x94e7,0x30},
+	{0x94e8,0x31},
+	{0x94e9,0x04},
+	{0x94ea,0x7f},
+	{0x94eb,0x12},
+	{0x94ec,0x80},
+	{0x94ed,0x02},
+	{0x94ee,0x7f},
+	{0x94ef,0x02},
+	{0x94f0,0x8f},
+	{0x94f1,0x0a},
+	{0x94f2,0x80},
+	{0x94f3,0x03},
+	{0x94f4,0x75},
+	{0x94f5,0x0a},
+	{0x94f6,0xfe},
+	{0x94f7,0x90},
+	{0x94f8,0x30},
+	{0x94f9,0x27},
+	{0x94fa,0xe5},
+	{0x94fb,0x0a},
+	{0x94fc,0xf0},
+	{0x94fd,0xe5},
+	{0x94fe,0x23},
+	{0x94ff,0x54},
+	{0x9500,0xf8},
+	{0x9501,0xf5},
+	{0x9502,0x0a},
+	{0x9503,0xe5},
+	{0x9504,0x79},
+	{0x9505,0x25},
+	{0x9506,0x0a},
+	{0x9507,0xf5},
+	{0x9508,0x0a},
+	{0x9509,0x90},
+	{0x950a,0x30},
+	{0x950b,0x26},
+	{0x950c,0xe5},
+	{0x950d,0x0a},
+	{0x950e,0xf0},
+	{0x950f,0x22},
+	{0x9510,0xe5},
+	{0x9511,0x0a},
+	{0x9512,0x70},
+	{0x9513,0x04},
+	{0x9514,0x7e},
+	{0x9515,0x12},
+	{0x9516,0x7f},
+	{0x9517,0xc1},
+	{0x9518,0xe5},
+	{0x9519,0x0a},
+	{0x951a,0xb4},
+	{0x951b,0x01},
+	{0x951c,0x04},
+	{0x951d,0x7e},
+	{0x951e,0x12},
+	{0x951f,0x7f},
+	{0x9520,0xc6},
+	{0x9521,0xe5},
+	{0x9522,0x0a},
+	{0x9523,0xb4},
+	{0x9524,0x02},
+	{0x9525,0x04},
+	{0x9526,0x7e},
+	{0x9527,0x12},
+	{0x9528,0x7f},
+	{0x9529,0xcb},
+	{0x952a,0x8f},
+	{0x952b,0x82},
+	{0x952c,0x8e},
+	{0x952d,0x83},
+	{0x952e,0xe4},
+	{0x952f,0x93},
+	{0x9530,0xf5},
+	{0x9531,0x2c},
+	{0x9532,0x74},
+	{0x9533,0x01},
+	{0x9534,0x93},
+	{0x9535,0xf5},
+	{0x9536,0x2d},
+	{0x9537,0x74},
+	{0x9538,0x02},
+	{0x9539,0x93},
+	{0x953a,0xf5},
+	{0x953b,0x2e},
+	{0x953c,0x74},
+	{0x953d,0x03},
+	{0x953e,0x93},
+	{0x953f,0xf5},
+	{0x9540,0x2f},
+	{0x9541,0x74},
+	{0x9542,0x04},
+	{0x9543,0x93},
+	{0x9544,0xf5},
+	{0x9545,0x30},
+	{0x9546,0xe5},
+	{0x9547,0x0a},
+	{0x9548,0xb4},
+	{0x9549,0x01},
+	{0x954a,0x07},
+	{0x954b,0x74},
+	{0x954c,0x2c},
+	{0x954d,0x25},
+	{0x954e,0x79},
+	{0x954f,0xf8},
+	{0x9550,0x76},
+	{0x9551,0x40},
+	{0x9552,0xe5},
+	{0x9553,0x0a},
+	{0x9554,0xb4},
+	{0x9555,0x02},
+	{0x9556,0x07},
+	{0x9557,0x74},
+	{0x9558,0x2c},
+	{0x9559,0x25},
+	{0x955a,0x79},
+	{0x955b,0xf8},
+	{0x955c,0x76},
+	{0x955d,0x80},
+	{0x955e,0x22},
+	{0x955f,0xc2},
+	{0x9560,0xaf},
+	{0x9561,0x90},
+	{0x9562,0x30},
+	{0x9563,0x27},
+	{0x9564,0x74},
+	{0x9565,0xfa},
+	{0x9566,0xf0},
+	{0x9567,0x12},
+	{0x9568,0x0f},
+	{0x9569,0xab},
+	{0x956a,0x12},
+	{0x956b,0x16},
+	{0x956c,0xad},
+	{0x956d,0xe4},
+	{0x956e,0xf5},
+	{0x956f,0x33},
+	{0x9570,0xd2},
+	{0x9571,0xaf},
+	{0x9572,0x12},
+	{0x9573,0x0c},
+	{0x9574,0xa8},
+	{0x9575,0x30},
+	{0x9576,0x30},
+	{0x9577,0x03},
+	{0x9578,0x12},
+	{0x9579,0x06},
+	{0x957a,0xfb},
+	{0x957b,0x30},
+	{0x957c,0x34},
+	{0x957d,0x03},
+	{0x957e,0x12},
+	{0x957f,0x14},
+	{0x9580,0xbf},
+	{0x9581,0x30},
+	{0x9582,0x3d},
+	{0x9583,0xee},
+	{0x9584,0xc2},
+	{0x9585,0x3d},
+	{0x9586,0xd2},
+	{0x9587,0x35},
+	{0x9588,0x30},
+	{0x9589,0x00},
+	{0x958a,0x05},
+	{0x958b,0x12},
+	{0x958c,0x16},
+	{0x958d,0x80},
+	{0x958e,0x80},
+	{0x958f,0x17},
+	{0x9590,0x30},
+	{0x9591,0x07},
+	{0x9592,0x0b},
+	{0x9593,0x30},
+	{0x9594,0x06},
+	{0x9595,0x08},
+	{0x9596,0x20},
+	{0x9597,0x31},
+	{0x9598,0x0e},
+	{0x9599,0x12},
+	{0x959a,0x13},
+	{0x959b,0x36},
+	{0x959c,0x80},
+	{0x959d,0x09},
+	{0x959e,0x20},
+	{0x959f,0x07},
+	{0x95a0,0x06},
+	{0x95a1,0x30},
+	{0x95a2,0x06},
+	{0x95a3,0x03},
+	{0x95a4,0x12},
+	{0x95a5,0x0b},
+	{0x95a6,0x6c},
+	{0x95a7,0xc2},
+	{0x95a8,0x35},
+	{0x95a9,0x80},
+	{0x95aa,0xc7},
+	{0x95ab,0xc0},
+	{0x95ac,0xe0},
+	{0x95ad,0xc0},
+	{0x95ae,0x83},
+	{0x95af,0xc0},
+	{0x95b0,0x82},
+	{0x95b1,0xc0},
+	{0x95b2,0xd0},
+	{0x95b3,0x90},
+	{0x95b4,0x3f},
+	{0x95b5,0x0d},
+	{0x95b6,0xe0},
+	{0x95b7,0xf5},
+	{0x95b8,0x09},
+	{0x95b9,0xe5},
+	{0x95ba,0x09},
+	{0x95bb,0x30},
+	{0x95bc,0xe0},
+	{0x95bd,0x2e},
+	{0x95be,0xe5},
+	{0x95bf,0x7a},
+	{0x95c0,0xb4},
+	{0x95c1,0x01},
+	{0x95c2,0x09},
+	{0x95c3,0x90},
+	{0x95c4,0x3a},
+	{0x95c5,0x00},
+	{0x95c6,0xe0},
+	{0x95c7,0xf5},
+	{0x95c8,0x78},
+	{0x95c9,0x44},
+	{0x95ca,0x01},
+	{0x95cb,0xf0},
 	{0x95cc,0xe5},
-	{0x95cd,0x7d},
-	{0x95ce,0x14},
-	{0x95cf,0xf5},
-	{0x95d0,0x0c},
-	{0x95d1,0x12},
-	{0x95d2,0x0e},
-	{0x95d3,0xa9},
-	{0x95d4,0x22},
-	{0x95d5,0xe5},
-	{0x95d6,0x7e},
-	{0x95d7,0xb4},
-	{0x95d8,0x01},
-	{0x95d9,0x09},
-	{0x95da,0x12},
-	{0x95db,0x15},
-	{0x95dc,0x78},
-	{0x95dd,0xe4},
-	{0x95de,0xf5},
-	{0x95df,0x0c},
-	{0x95e0,0x12},
-	{0x95e1,0x0e},
-	{0x95e2,0xa9},
-	{0x95e3,0x22},
-	{0x95e4,0xe5},
-	{0x95e5,0x7e},
-	{0x95e6,0x24},
-	{0x95e7,0xfe},
-	{0x95e8,0x60},
-	{0x95e9,0x06},
-	{0x95ea,0x04},
-	{0x95eb,0x70},
-	{0x95ec,0x05},
-	{0x95ed,0xd2},
-	{0x95ee,0x37},
-	{0x95ef,0x22},
-	{0x95f0,0xc2},
-	{0x95f1,0x37},
-	{0x95f2,0x22},
-	{0x95f3,0xe5},
-	{0x95f4,0x31},
-	{0x95f5,0xd3},
-	{0x95f6,0x94},
-	{0x95f7,0x00},
-	{0x95f8,0x40},
-	{0x95f9,0x03},
-	{0x95fa,0x15},
-	{0x95fb,0x31},
-	{0x95fc,0x22},
-	{0x95fd,0x12},
-	{0x95fe,0x15},
-	{0x95ff,0xa1},
-	{0x9600,0x22},
-	{0x9601,0x12},
-	{0x9602,0x15},
-	{0x9603,0x78},
-	{0x9604,0xe4},
-	{0x9605,0xf5},
-	{0x9606,0x0c},
-	{0x9607,0x12},
-	{0x9608,0x0e},
-	{0x9609,0xa9},
-	{0x960a,0x22},
+	{0x95cd,0x7a},
+	{0x95ce,0xb4},
+	{0x95cf,0x03},
+	{0x95d0,0x09},
+	{0x95d1,0x90},
+	{0x95d2,0x3a},
+	{0x95d3,0x00},
+	{0x95d4,0xe0},
+	{0x95d5,0xf5},
+	{0x95d6,0x78},
+	{0x95d7,0x54},
+	{0x95d8,0xfe},
+	{0x95d9,0xf0},
+	{0x95da,0xe5},
+	{0x95db,0x7a},
+	{0x95dc,0xb4},
+	{0x95dd,0x03},
+	{0x95de,0x05},
+	{0x95df,0x75},
+	{0x95e0,0x7a},
+	{0x95e1,0x00},
+	{0x95e2,0x80},
+	{0x95e3,0x02},
+	{0x95e4,0x05},
+	{0x95e5,0x7a},
+	{0x95e6,0x90},
+	{0x95e7,0x3f},
+	{0x95e8,0x0d},
+	{0x95e9,0x74},
+	{0x95ea,0x01},
+	{0x95eb,0xf0},
+	{0x95ec,0xd0},
+	{0x95ed,0xd0},
+	{0x95ee,0xd0},
+	{0x95ef,0x82},
+	{0x95f0,0xd0},
+	{0x95f1,0x83},
+	{0x95f2,0xd0},
+	{0x95f3,0xe0},
+	{0x95f4,0x32},
+	{0x95f5,0x90},
+	{0x95f6,0x50},
+	{0x95f7,0x27},
+	{0x95f8,0xe0},
+	{0x95f9,0x44},
+	{0x95fa,0x01},
+	{0x95fb,0xf0},
+	{0x95fc,0x90},
+	{0x95fd,0x50},
+	{0x95fe,0x34},
+	{0x95ff,0x74},
+	{0x9600,0x80},
+	{0x9601,0xf0},
+	{0x9602,0xa3},
+	{0x9603,0x74},
+	{0x9604,0x2a},
+	{0x9605,0xf0},
+	{0x9606,0xa3},
+	{0x9607,0x74},
+	{0x9608,0x14},
+	{0x9609,0xf0},
+	{0x960a,0x90},
+	{0x960b,0x50},
+	{0x960c,0x30},
+	{0x960d,0xe4},
+	{0x960e,0xf0},
+	{0x960f,0xa3},
+	{0x9610,0x74},
+	{0x9611,0x02},
+	{0x9612,0xf0},
+	{0x9613,0xa3},
+	{0x9614,0xe4},
+	{0x9615,0xf0},
+	{0x9616,0xa3},
+	{0x9617,0x74},
+	{0x9618,0x80},
+	{0x9619,0xf0},
+	{0x961a,0xe4},
+	{0x961b,0xf5},
+	{0x961c,0x0a},
+	{0x961d,0x12},
+	{0x961e,0x13},
+	{0x961f,0x9c},
+	{0x9620,0x75},
+	{0x9621,0x79},
+	{0x9622,0x02},
+	{0x9623,0x75},
+	{0x9624,0x0a},
+	{0x9625,0x01},
+	{0x9626,0x12},
+	{0x9627,0x15},
+	{0x9628,0x10},
+	{0x9629,0xd2},
+	{0x962a,0x18},
+	{0x962b,0xd2},
+	{0x962c,0x19},
+	{0x962d,0xc2},
+	{0x962e,0x3c},
+	{0x962f,0xc2},
+	{0x9630,0x3b},
+	{0x9631,0xd2},
+	{0x9632,0x1a},
+	{0x9633,0xd2},
+	{0x9634,0x38},
+	{0x9635,0xd2},
+	{0x9636,0x30},
+	{0x9637,0xc2},
+	{0x9638,0x35},
+	{0x9639,0xc2},
+	{0x963a,0x3d},
+	{0x963b,0x22},
+	{0x963c,0x85},
+	{0x963d,0x14},
+	{0x963e,0x15},
+	{0x963f,0x7f},
+	{0x9640,0x08},
+	{0x9641,0xe5},
+	{0x9642,0x15},
+	{0x9643,0x30},
+	{0x9644,0xe7},
+	{0x9645,0x04},
+	{0x9646,0xd2},
+	{0x9647,0x29},
+	{0x9648,0x80},
+	{0x9649,0x02},
+	{0x964a,0xc2},
+	{0x964b,0x29},
+	{0x964c,0x12},
+	{0x964d,0x01},
+	{0x964e,0x6c},
+	{0x964f,0x75},
+	{0x9650,0x51},
+	{0x9651,0x0a},
+	{0x9652,0xae},
+	{0x9653,0x51},
+	{0x9654,0x15},
+	{0x9655,0x51},
+	{0x9656,0xee},
+	{0x9657,0x70},
+	{0x9658,0xf9},
+	{0x9659,0xe5},
+	{0x965a,0x15},
+	{0x965b,0x25},
+	{0x965c,0xe0},
+	{0x965d,0xf5},
+	{0x965e,0x15},
+	{0x965f,0xd2},
+	{0x9660,0x28},
+	{0x9661,0x12},
+	{0x9662,0x01},
+	{0x9663,0x6c},
+	{0x9664,0x75},
+	{0x9665,0x51},
+	{0x9666,0x0a},
+	{0x9667,0xae},
+	{0x9668,0x51},
+	{0x9669,0x15},
+	{0x966a,0x51},
+	{0x966b,0xee},
+	{0x966c,0x70},
+	{0x966d,0xf9},
+	{0x966e,0xc2},
+	{0x966f,0x28},
+	{0x9670,0x12},
+	{0x9671,0x01},
+	{0x9672,0x6c},
+	{0x9673,0x75},
+	{0x9674,0x51},
+	{0x9675,0x05},
+	{0x9676,0xae},
+	{0x9677,0x51},
+	{0x9678,0x15},
+	{0x9679,0x51},
+	{0x967a,0xee},
+	{0x967b,0x70},
+	{0x967c,0xf9},
+	{0x967d,0xdf},
+	{0x967e,0xc2},
+	{0x967f,0x22},
+	{0x9680,0xe5},
+	{0x9681,0x20},
+	{0x9682,0x54},
+	{0x9683,0x07},
+	{0x9684,0xff},
+	{0x9685,0xbf},
+	{0x9686,0x01},
+	{0x9687,0x03},
+	{0x9688,0x02},
+	{0x9689,0x11},
+	{0x968a,0x69},
+	{0x968b,0xe5},
+	{0x968c,0x20},
+	{0x968d,0x54},
+	{0x968e,0x07},
+	{0x968f,0xff},
+	{0x9690,0xbf},
+	{0x9691,0x07},
+	{0x9692,0x03},
+	{0x9693,0x02},
+	{0x9694,0x12},
+	{0x9695,0xd0},
+	{0x9696,0xe5},
+	{0x9697,0x20},
+	{0x9698,0x54},
+	{0x9699,0x07},
+	{0x969a,0xff},
+	{0x969b,0xbf},
+	{0x969c,0x03},
+	{0x969d,0x03},
+	{0x969e,0x02},
+	{0x969f,0x14},
+	{0x96a0,0x64},
+	{0x96a1,0xe5},
+	{0x96a2,0x20},
+	{0x96a3,0x54},
+	{0x96a4,0x07},
+	{0x96a5,0xff},
+	{0x96a6,0xbf},
+	{0x96a7,0x05},
+	{0x96a8,0x03},
+	{0x96a9,0x12},
+	{0x96aa,0x17},
+	{0x96ab,0x7a},
+	{0x96ac,0x22},
+	{0x96ad,0x12},
+	{0x96ae,0x15},
+	{0x96af,0xf5},
+	{0x96b0,0x12},
+	{0x96b1,0x17},
+	{0x96b2,0x88},
+	{0x96b3,0x50},
+	{0x96b4,0x04},
+	{0x96b5,0xd2},
+	{0x96b6,0x05},
+	{0x96b7,0x80},
+	{0x96b8,0x02},
+	{0x96b9,0xc2},
+	{0x96ba,0x05},
+	{0x96bb,0x12},
+	{0x96bc,0x02},
+	{0x96bd,0x64},
+	{0x96be,0xc2},
+	{0x96bf,0x39},
+	{0x96c0,0xc2},
+	{0x96c1,0x36},
+	{0x96c2,0xc2},
+	{0x96c3,0x31},
+	{0x96c4,0xd2},
+	{0x96c5,0x34},
+	{0x96c6,0x12},
+	{0x96c7,0x02},
+	{0x96c8,0x92},
+	{0x96c9,0xb5},
+	{0x96ca,0x07},
+	{0x96cb,0x03},
+	{0x96cc,0xd3},
+	{0x96cd,0x80},
+	{0x96ce,0x01},
+	{0x96cf,0xc3},
+	{0x96d0,0x40},
+	{0x96d1,0x02},
+	{0x96d2,0xc2},
+	{0x96d3,0x05},
+	{0x96d4,0x22},
+	{0x96d5,0xe4},
+	{0x96d6,0xff},
+	{0x96d7,0xfe},
+	{0x96d8,0xc3},
+	{0x96d9,0xef},
+	{0x96da,0x95},
+	{0x96db,0x12},
+	{0x96dc,0xee},
+	{0x96dd,0x95},
+	{0x96de,0x11},
+	{0x96df,0x50},
+	{0x96e0,0x15},
+	{0x96e1,0x7d},
+	{0x96e2,0x8a},
+	{0x96e3,0x7c},
+	{0x96e4,0x02},
+	{0x96e5,0xed},
+	{0x96e6,0x1d},
+	{0x96e7,0xaa},
+	{0x96e8,0x04},
+	{0x96e9,0x70},
+	{0x96ea,0x01},
+	{0x96eb,0x1c},
+	{0x96ec,0x4a},
+	{0x96ed,0x70},
+	{0x96ee,0xf6},
+	{0x96ef,0x0f},
+	{0x96f0,0xbf},
+	{0x96f1,0x00},
+	{0x96f2,0x01},
+	{0x96f3,0x0e},
+	{0x96f4,0x80},
+	{0x96f5,0xe2},
+	{0x96f6,0x22},
+	{0x96f7,0xc2},
+	{0x96f8,0x03},
+	{0x96f9,0xd2},
+	{0x96fa,0x04},
+	{0x96fb,0x12},
+	{0x96fc,0x02},
+	{0x96fd,0xa8},
+	{0x96fe,0x30},
+	{0x96ff,0x07},
+	{0x9700,0x05},
+	{0x9701,0x30},
+	{0x9702,0x06},
+	{0x9703,0x02},
+	{0x9704,0xd2},
+	{0x9705,0x36},
+	{0x9706,0xc2},
+	{0x9707,0x3e},
+	{0x9708,0x12},
+	{0x9709,0x10},
+	{0x970a,0xdc},
+	{0x970b,0xc2},
+	{0x970c,0x3e},
+	{0x970d,0x12},
+	{0x970e,0x14},
+	{0x970f,0x01},
+	{0x9710,0xd2},
+	{0x9711,0x34},
+	{0x9712,0x22},
+	{0x9713,0x75},
+	{0x9714,0x48},
+	{0x9715,0x12},
+	{0x9716,0x75},
+	{0x9717,0x49},
+	{0x9718,0x6a},
+	{0x9719,0x90},
+	{0x971a,0x12},
+	{0x971b,0x68},
+	{0x971c,0xe4},
+	{0x971d,0x93},
+	{0x971e,0xf5},
+	{0x971f,0x7c},
+	{0x9720,0xa3},
+	{0x9721,0xe4},
+	{0x9722,0x93},
+	{0x9723,0xf5},
+	{0x9724,0x32},
+	{0x9725,0xc2},
+	{0x9726,0x3a},
+	{0x9727,0x22},
+	{0x9728,0xe4},
+	{0x9729,0xff},
+	{0x972a,0xef},
+	{0x972b,0x25},
+	{0x972c,0xe0},
+	{0x972d,0x24},
+	{0x972e,0x56},
+	{0x972f,0xf8},
+	{0x9730,0xe4},
+	{0x9731,0xf6},
+	{0x9732,0x08},
+	{0x9733,0xf6},
+	{0x9734,0x0f},
+	{0x9735,0xbf},
+	{0x9736,0x07},
+	{0x9737,0xf2},
+	{0x9738,0x53},
+	{0x9739,0x24},
+	{0x973a,0x80},
+	{0x973b,0x22},
+	{0x973c,0xe5},
+	{0x973d,0x7d},
+	{0x973e,0xc3},
+	{0x973f,0x95},
+	{0x9740,0x7c},
+	{0x9741,0x40},
+	{0x9742,0x01},
+	{0x9743,0x22},
+	{0x9744,0xe5},
+	{0x9745,0x7d},
+	{0x9746,0x04},
+	{0x9747,0xf5},
+	{0x9748,0x0c},
+	{0x9749,0x12},
+	{0x974a,0x0e},
+	{0x974b,0xf9},
+	{0x974c,0x22},
+	{0x974d,0xe5},
+	{0x974e,0x7d},
+	{0x974f,0x70},
+	{0x9750,0x02},
+	{0x9751,0xc3},
+	{0x9752,0x22},
+	{0x9753,0xe5},
+	{0x9754,0x7d},
+	{0x9755,0x14},
+	{0x9756,0xf5},
+	{0x9757,0x0c},
+	{0x9758,0x12},
+	{0x9759,0x0e},
+	{0x975a,0xf9},
+	{0x975b,0x22},
+	{0x975c,0xe5},
+	{0x975d,0x7e},
+	{0x975e,0xb4},
+	{0x975f,0x01},
+	{0x9760,0x09},
+	{0x9761,0x12},
+	{0x9762,0x17},
+	{0x9763,0x13},
+	{0x9764,0xe4},
+	{0x9765,0xf5},
+	{0x9766,0x0c},
+	{0x9767,0x12},
+	{0x9768,0x0e},
+	{0x9769,0xf9},
+	{0x976a,0x22},
+	{0x976b,0xe5},
+	{0x976c,0x7e},
+	{0x976d,0x24},
+	{0x976e,0xfe},
+	{0x976f,0x60},
+	{0x9770,0x06},
+	{0x9771,0x04},
+	{0x9772,0x70},
+	{0x9773,0x05},
+	{0x9774,0xd2},
+	{0x9775,0x39},
+	{0x9776,0x22},
+	{0x9777,0xc2},
+	{0x9778,0x39},
+	{0x9779,0x22},
+	{0x977a,0xe5},
+	{0x977b,0x31},
+	{0x977c,0xd3},
+	{0x977d,0x94},
+	{0x977e,0x00},
+	{0x977f,0x40},
+	{0x9780,0x03},
+	{0x9781,0x15},
+	{0x9782,0x31},
+	{0x9783,0x22},
+	{0x9784,0x12},
+	{0x9785,0x16},
+	{0x9786,0xf7},
+	{0x9787,0x22},
+	{0x9788,0x12},
+	{0x9789,0x17},
+	{0x978a,0x13},
+	{0x978b,0xe4},
+	{0x978c,0xf5},
+	{0x978d,0x0c},
+	{0x978e,0x12},
+	{0x978f,0x0e},
+	{0x9790,0xf9},
+	{0x9791,0x22},
 	{0x3024,0x00},
 	{0x3025,0x00},
 	{0x5082,0x00},
@@ -5674,7 +6061,7 @@ struct reginfo sensor_af_firmware[] =
 	{0x3026,0x00},
 	{0x3027,0xFF},
 	{0x3000,0x00},
-	{0x0000,0x00}
+	{0x0000,0x00}
 };
 #elif (VCM_DRIVER == VCM_DRIVER_AD5820)
 /* support const-focus */
@@ -17470,6 +17857,6 @@ struct reginfo sensor_af_firmware[] =
 	{0x3027,0xFF},
 	{0x3000,0x00},
 	{0x0000,0x00}
-}
+};
 #endif
 
diff --git a/drivers/media/video/ov7675.c b/drivers/media/video/ov7675.c
new file mode 100755
index 000000000000..809b41ea4ff5
--- /dev/null
+++ b/drivers/media/video/ov7675.c
@@ -0,0 +1,2439 @@
+
+/*
+o* Driver for MT9M001 CMOS Image Sensor from Micron
+ *
+ * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/videodev2.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/log2.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/circ_buf.h>
+#include <linux/miscdevice.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-chip-ident.h>
+#include <media/soc_camera.h>
+#include <mach/rk29_camera.h>
+
+#define _CONS(a,b) a##b
+#define CONS(a,b) _CONS(a,b)
+
+#define __STR(x) #x
+#define _STR(x) __STR(x)
+#define STR(x) _STR(x)
+
+/* Sensor Driver Configuration */
+#define SENSOR_NAME ov7675
+#define SENSOR_V4L2_IDENT V4L2_IDENT_OV7675
+#define SENSOR_ID 0x76
+#define SENSOR_MIN_WIDTH    640//176
+#define SENSOR_MIN_HEIGHT   480//144
+#define SENSOR_MAX_WIDTH    640
+#define SENSOR_MAX_HEIGHT   480
+#define SENSOR_INIT_WIDTH	640			/* Sensor pixel size for sensor_init_data array */
+#define SENSOR_INIT_HEIGHT  480
+#define SENSOR_INIT_WINSEQADR sensor_vga
+#define SENSOR_INIT_PIXFMT V4L2_PIX_FMT_YUYV
+
+#define CONFIG_SENSOR_WhiteBalance	0
+#define CONFIG_SENSOR_Brightness	0
+#define CONFIG_SENSOR_Contrast      0
+#define CONFIG_SENSOR_Saturation    0
+#define CONFIG_SENSOR_Effect        1
+#define CONFIG_SENSOR_Scene         0
+#define CONFIG_SENSOR_DigitalZoom   0
+#define CONFIG_SENSOR_Focus         0
+#define CONFIG_SENSOR_Exposure      0
+#define CONFIG_SENSOR_Flash         0
+#define CONFIG_SENSOR_Mirror        0
+#define CONFIG_SENSOR_Flip          0
+
+#define CONFIG_SENSOR_I2C_SPEED     100000       /* Hz */
+
+#define CONFIG_SENSOR_TR      1
+#define CONFIG_SENSOR_DEBUG	  1
+
+#define SENSOR_NAME_STRING(a) STR(CONS(SENSOR_NAME, a))
+#define SENSOR_NAME_VARFUN(a) CONS(SENSOR_NAME, a)
+
+#define MIN(x,y)   ((x<y) ? x: y)
+#define MAX(x,y)    ((x>y) ? x: y)
+
+#if (CONFIG_SENSOR_TR)
+	#define SENSOR_TR(format, ...)      printk(format, ## __VA_ARGS__)
+	#if (CONFIG_SENSOR_DEBUG)
+	#define SENSOR_DG(format, ...)      printk(format, ## __VA_ARGS__)
+	#else
+	#define SENSOR_DG(format, ...)
+	#endif
+#else
+	#define SENSOR_TR(format, ...)
+#endif
+
+#define SENSOR_BUS_PARAM  (SOCAM_MASTER | SOCAM_PCLK_SAMPLE_RISING |\
+                          SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW |\
+                          SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8  |SOCAM_MCLK_24MHZ)
+
+#define COLOR_TEMPERATURE_CLOUDY_DN  6500
+#define COLOR_TEMPERATURE_CLOUDY_UP    8000
+#define COLOR_TEMPERATURE_CLEARDAY_DN  5000
+#define COLOR_TEMPERATURE_CLEARDAY_UP    6500
+#define COLOR_TEMPERATURE_OFFICE_DN     3500
+#define COLOR_TEMPERATURE_OFFICE_UP     5000
+#define COLOR_TEMPERATURE_HOME_DN       2500
+#define COLOR_TEMPERATURE_HOME_UP       3500
+
+struct reginfo
+{
+    u8 reg;
+    u8 val;
+};
+
+/* init 640X480 VGA */
+static struct reginfo sensor_init_data[] =
+{
+	{0x12, 0x80},
+	{0x11, 0x80},
+	{0x2a, 0x00},
+	{0x2b, 0x00},
+	{0x92, 0x66},
+	{0x93, 0x00},
+	{0x3a, 0x0c},
+	{0x3D, 0xC0},
+	{0x12, 0x00},
+	{0x15, 0x00},
+	{0xc1, 0x7f},
+	{0x17, 0x13},
+	{0x18, 0x01},
+	{0x32, 0xbF},
+	{0x19, 0x03},
+	{0x1a, 0x7b},
+	{0x03, 0x0a},
+	{0x0c, 0x00},
+	{0x3e, 0x00},
+	{0x70, 0x3a},
+	{0x71, 0x35},
+	{0x72, 0x11},
+	{0x73, 0xf0},
+	{0xa2, 0x02},
+	{0x13, 0xe0},
+	//{0x00, 0x00},
+	{0x10, 0x00},
+	{0x14, 0x28},
+	{0xa5, 0x06},
+	{0xab, 0x07},
+	{0x24, 0x58},
+	{0x25, 0x48},
+	{0x26, 0x93},
+	{0x9f, 0x78},
+	{0xa0, 0x68},
+	{0xa1, 0x03},
+	{0xa6, 0xD8},
+	{0xa7, 0xD8},
+	{0xa8, 0xf0},
+	{0xa9, 0x90},
+	{0xaa, 0x14},
+	{0x13, 0xe5},
+	{0x0e, 0x61},
+	{0x0f, 0x4b},
+	{0x16, 0x02},
+	{0x1e, 0x07},
+	{0x21, 0x02},
+	{0x22, 0x91},
+	{0x29, 0x07},
+	{0x33, 0x0b},
+	{0x35, 0x0b},
+	{0x37, 0x1d},
+	{0x38, 0x71},
+	{0x39, 0x2a},
+	{0x3c, 0x78},
+	{0x4d, 0x40},
+	{0x4e, 0x20},
+	{0x69, 0x00},
+	{0x6b, 0x0a},
+	{0x74, 0x10},
+	{0x8d, 0x4f},
+	{0x8e, 0x00},
+	{0x8f, 0x00},
+	{0x90, 0x00},
+	{0x91, 0x00},
+	{0x96, 0x00},
+	{0x9a, 0x80},
+	{0xb0, 0x84},
+	{0xb1, 0x0c},
+	{0xb2, 0x0e},
+	{0xb3, 0x82},
+	{0xb8, 0x0a},
+	{0xbb, 0xa1},
+	{0x0d, 0x60},
+	{0x42, 0x80},
+	{0x62, 0x00},
+	{0x63, 0x00},
+	{0x64, 0x10},
+	{0x65, 0x07},
+	{0x66, 0x05},
+	{0x94, 0x10},
+	{0x95, 0x12},
+	{0x7a, 0x24},
+	{0x7b, 0x04},
+	{0x7c, 0x07},
+	{0x7d, 0x12},
+	{0x7e, 0x2f},
+	{0x7f, 0x3f},
+	{0x80, 0x4d},
+	{0x81, 0x5a},
+	{0x82, 0x69},
+	{0x83, 0x74},
+	{0x84, 0x7f},
+	{0x85, 0x91},
+	{0x86, 0x9e},
+	{0x87, 0xbb},
+	{0x88, 0xd2},
+	{0x89, 0xe5},
+	{0x43, 0x0a},
+	{0x44, 0xf0},
+	{0x45, 0x34},
+	{0x46, 0x58},
+	{0x47, 0x28},
+	{0x48, 0x3a},
+	{0x59, 0x88},
+	{0x5a, 0x88},
+	{0x5b, 0xc2},
+	{0x5c, 0x60},
+	{0x5d, 0x58},
+	{0x5e, 0x10},
+	{0x6c, 0x0a},
+	{0x6d, 0x55},
+	{0x6e, 0x11},
+	{0x6f, 0x9e},
+	{0x6a, 0x40},
+	{0x01, 0x56},
+	{0x02, 0x44},
+	{0x13, 0xe7},
+	{0x4f, 0x95},
+	{0x50, 0x99},
+	{0x51, 0x04},
+	{0x52, 0x1a},
+	{0x53, 0x7f},
+	{0x54, 0x99},
+	{0x58, 0x1a},
+	{0x3f, 0x02},
+	{0x75, 0x63},
+	{0x76, 0xe1},
+	{0x4c, 0x00},
+	{0x77, 0x01},
+	{0x4b, 0x09},
+	{0xc9, 0x60},
+	{0x41, 0x38},
+	{0x56, 0x40},
+	{0x34, 0x11},
+	{0x3b, 0xaa},
+	{0xa4, 0x88},
+	{0x96, 0x00},
+	{0x97, 0x30},
+	{0x98, 0x20},
+	{0x99, 0x30},
+	{0x9a, 0x84},
+	{0x9b, 0x29},
+	{0x9c, 0x03},
+	{0x9d, 0x99},
+	{0x9e, 0x99},
+	{0x78, 0x04},
+	{0x79, 0x01},
+	{0xc8, 0xf0},
+	{0x79, 0x0f},
+	{0xc8, 0x00},
+	{0x79, 0x10},
+	{0xc8, 0x7e},
+	{0x79, 0x0a},
+	{0xc8, 0x80},
+	{0x79, 0x0b},
+	{0xc8, 0x01},
+	{0x79, 0x0c},
+	{0xc8, 0x0f},
+	{0x79, 0x0d},
+	{0xc8, 0x20},
+	{0x79, 0x09},
+	{0xc8, 0x80},
+	{0x79, 0x02},
+	{0xc8, 0xc0},
+	{0x79, 0x03},
+	{0xc8, 0x40},
+	{0x79, 0x05},
+	{0xc8, 0x30},
+	{0x79, 0x26},
+	{0x00, 0x00}
+};
+
+/* 1280X1024 SXGA */
+static struct reginfo sensor_sxga[] =
+{
+	{0x00,0x00}
+};
+
+/* 800X600 SVGA*/
+static struct reginfo sensor_svga[] =
+{
+    {0x0, 0x0},
+};
+
+/* 640X480 VGA */
+static struct reginfo sensor_vga[] =
+{
+    {0x17, 0x13},
+    {0x18, 0x01},
+    {0x32, 0xbf},
+    {0x19, 0x03},
+    {0x1a, 0x7b},
+    {0x03, 0x0a},
+	{0x00,0x00}
+};
+
+/* 352X288 CIF */
+static struct reginfo sensor_cif[] =
+{
+    {0x00,0x00}
+};
+
+/* 320*240 QVGA */
+static  struct reginfo sensor_qvga[] =
+{
+    {0x00,0x00}
+};
+
+/* 176X144 QCIF*/
+static struct reginfo sensor_qcif[] =
+{
+    {0x00,0x00}
+};
+
+static  struct reginfo sensor_ClrFmt_YUYV[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_ClrFmt_UYVY[]=
+{
+    {0x00, 0x00}
+};
+
+
+#if CONFIG_SENSOR_WhiteBalance
+static  struct reginfo sensor_WhiteB_Auto[]=
+{
+	{0x84, 0x6C},		//Contrast 4
+	{0x85, 0x78},
+	{0x86, 0x8C},
+	{0x87, 0x9E},
+	{0x88, 0xBB},
+	{0x89, 0xD2},
+	{0x8A, 0xE6},
+	{0x6C, 0x40},
+	{0x6D, 0x30},
+	{0x6E, 0x48},
+	{0x6F, 0x60},
+	{0x70, 0x70},
+	{0x71, 0x70},
+	{0x72, 0x70},
+	{0x73, 0x70},
+	{0x74, 0x60},
+	{0x75, 0x60},
+	{0x76, 0x50},
+	{0x77, 0x48},
+	{0x78, 0x3A},
+	{0x79, 0x2E},
+	{0x7A, 0x28},
+	{0x7B, 0x22},
+
+	{0x0f, 0x4a},		//Saturation 3
+	{0x27, 0x80},
+	{0x28, 0x80},
+	{0x2c, 0x80},
+	{0x62, 0x60},
+	{0x63, 0xe0},
+	{0x64, 0x04},
+	{0x65, 0x00},
+	{0x66, 0x01},
+	{0x24, 0x70},
+	{0x25, 0x64},
+
+	{0x4f, 0x2e},		//Brightness 3
+	{0x50, 0x31},
+	{0x51, 0x02},
+	{0x52, 0x0e},
+	{0x53, 0x1e},
+	{0x54, 0x2d},
+
+	{0x11, 0x80},
+	{0x14, 0x2a},
+	{0x13, 0xe7},
+	{0x66, 0x05},
+
+    {0x00, 0x00}
+};
+/* Cloudy Colour Temperature : 6500K - 8000K  */
+static  struct reginfo sensor_WhiteB_Cloudy[]=
+{
+	{0x7C,0x04},		//Contrast 5
+	{0x7D,0x09},
+	{0x7E,0x13},
+	{0x7F,0x29},
+	{0x80,0x35},
+	{0x81,0x41},
+	{0x82,0x4D},
+	{0x83,0x59},
+	{0x84,0x64},
+	{0x85,0x6F},
+	{0x86,0x85},
+	{0x87,0x97},
+	{0x88,0xB7},
+	{0x89,0xCF},
+	{0x8A,0xE3},
+	{0x6C,0x40},
+	{0x6D,0x50},
+	{0x6E,0x50},
+	{0x6F,0x58},
+	{0x70,0x60},
+	{0x71,0x60},
+	{0x72,0x60},
+	{0x73,0x60},
+	{0x74,0x58},
+	{0x75,0x58},
+	{0x76,0x58},
+	{0x77,0x48},
+	{0x78,0x40},
+	{0x79,0x30},
+	{0x7A,0x28},
+	{0x7B,0x26},
+
+
+
+	{0x4f,0x3a},		//Saturation 4
+	{0x50,0x3d},
+	{0x51,0x03},
+	{0x52,0x12},
+	{0x53,0x26},
+	{0x54,0x38},
+	{0x4f, 0x2e},		//Brightness 3
+	{0x50, 0x31},
+	{0x51, 0x02},
+	{0x52, 0x0e},
+	{0x53, 0x1e},
+	{0x54, 0x2d},
+
+	{0x11,0x80},
+	{0x14,0x0a},
+	{0x13,0xc7},
+	{0x66,0x05},
+    {0x00, 0x00}
+};
+/* ClearDay Colour Temperature : 5000K - 6500K  */
+static  struct reginfo sensor_WhiteB_ClearDay[]=
+{
+    //Sunny
+	{0x7C,0x04},		//Contrast 5
+	{0x7D,0x09},
+	{0x7E,0x13},
+	{0x7F,0x29},
+	{0x80,0x35},
+	{0x81,0x41},
+	{0x82,0x4D},
+	{0x83,0x59},
+	{0x84,0x64},
+	{0x85,0x6F},
+	{0x86,0x85},
+	{0x87,0x97},
+	{0x88,0xB7},
+	{0x89,0xCF},
+	{0x8A,0xE3},
+	{0x6C,0x40},
+	{0x6D,0x50},
+	{0x6E,0x50},
+	{0x6F,0x58},
+	{0x70,0x60},
+	{0x71,0x60},
+	{0x72,0x60},
+	{0x73,0x60},
+	{0x74,0x58},
+	{0x75,0x58},
+	{0x76,0x58},
+	{0x77,0x48},
+	{0x78,0x40},
+	{0x79,0x30},
+	{0x7A,0x28},
+	{0x7B,0x26},
+
+
+
+	{0x4f,0x3a},		//Saturation 4
+	{0x50,0x3d},
+	{0x51,0x03},
+	{0x52,0x12},
+	{0x53,0x26},
+	{0x54,0x38},
+	{0x4f, 0x2e},		//Brightness 3
+	{0x50, 0x31},
+	{0x51, 0x02},
+	{0x52, 0x0e},
+	{0x53, 0x1e},
+	{0x54, 0x2d},
+
+	{0x11,0x80},
+	{0x14,0x0a},
+	{0x13,0xc7},
+	{0x66,0x05},
+    {0x00, 0x00}
+};
+/* Office Colour Temperature : 3500K - 5000K  */
+static  struct reginfo sensor_WhiteB_TungstenLamp1[]=
+{
+    //Office
+	{0x84, 0x6C},		//Contrast 4
+	{0x85, 0x78},
+	{0x86, 0x8C},
+	{0x87, 0x9E},
+	{0x88, 0xBB},
+	{0x89, 0xD2},
+	{0x8A, 0xE6},
+	{0x6C, 0x40},
+	{0x6D, 0x30},
+	{0x6E, 0x48},
+	{0x6F, 0x60},
+	{0x70, 0x70},
+	{0x71, 0x70},
+	{0x72, 0x70},
+	{0x73, 0x70},
+	{0x74, 0x60},
+	{0x75, 0x60},
+	{0x76, 0x50},
+	{0x77, 0x48},
+	{0x78, 0x3A},
+	{0x79, 0x2E},
+	{0x7A, 0x28},
+	{0x7B, 0x22},
+
+	{0x0f, 0x4a},		//Saturation 3
+	{0x27, 0x80},
+	{0x28, 0x80},
+	{0x2c, 0x80},
+	{0x62, 0x60},
+	{0x63, 0xe0},
+	{0x64, 0x04},
+	{0x65, 0x00},
+	{0x66, 0x01},
+	{0x24, 0x70},
+	{0x25, 0x64},
+
+	{0x4f, 0x2e},		//Brightness 3
+	{0x50, 0x31},
+	{0x51, 0x02},
+	{0x52, 0x0e},
+	{0x53, 0x1e},
+	{0x54, 0x2d},
+
+	{0x11,0x80},
+	{0x14,0x2a},
+	{0x13,0xe7},
+	{0x66,0x05},
+
+    {0x00, 0x00}
+
+
+};
+/* Home Colour Temperature : 2500K - 3500K  */
+static  struct reginfo sensor_WhiteB_TungstenLamp2[]=
+{
+    //Home
+	{0x84, 0x6C},		//Contrast 4
+	{0x85, 0x78},
+	{0x86, 0x8C},
+	{0x87, 0x9E},
+	{0x88, 0xBB},
+	{0x89, 0xD2},
+	{0x8A, 0xE6},
+	{0x6C, 0x40},
+	{0x6D, 0x30},
+	{0x6E, 0x48},
+	{0x6F, 0x60},
+	{0x70, 0x70},
+	{0x71, 0x70},
+	{0x72, 0x70},
+	{0x73, 0x70},
+	{0x74, 0x60},
+	{0x75, 0x60},
+	{0x76, 0x50},
+	{0x77, 0x48},
+	{0x78, 0x3A},
+	{0x79, 0x2E},
+	{0x7A, 0x28},
+	{0x7B, 0x22},
+
+	{0x0f, 0x4a},		//Saturation 3
+	{0x27, 0x80},
+	{0x28, 0x80},
+	{0x2c, 0x80},
+	{0x62, 0x60},
+	{0x63, 0xe0},
+	{0x64, 0x04},
+	{0x65, 0x00},
+	{0x66, 0x01},
+	{0x24, 0x70},
+	{0x25, 0x64},
+
+	{0x4f, 0x2e},		//Brightness 3
+	{0x50, 0x31},
+	{0x51, 0x02},
+	{0x52, 0x0e},
+	{0x53, 0x1e},
+	{0x54, 0x2d},
+
+	{0x11, 0x80},
+	{0x14, 0x2a},
+	{0x13, 0xe7},
+	{0x66, 0x05},
+    {0x00, 0x00}
+};
+static struct reginfo *sensor_WhiteBalanceSeqe[] = {sensor_WhiteB_Auto, sensor_WhiteB_TungstenLamp1,sensor_WhiteB_TungstenLamp2,
+    sensor_WhiteB_ClearDay, sensor_WhiteB_Cloudy,NULL,
+};
+#endif
+
+#if CONFIG_SENSOR_Brightness
+static  struct reginfo sensor_Brightness0[]=
+{
+    // Brightness -2
+    {0x3301, 0xff},//bit[7]:1, enable SDE
+    {0x3391, 0x04},
+    {0x3390, 0x49},
+    {0x339a, 0x20},
+    {0x0000, 0x00}
+};
+
+static  struct reginfo sensor_Brightness1[]=
+{
+    // Brightness -1
+    {0x3301, 0xff},//bit[7]:1, enable SDE
+    {0x3391, 0x04},
+    {0x3390, 0x49},
+    {0x339a, 0x10},
+    {0x0000, 0x00}
+};
+
+static  struct reginfo sensor_Brightness2[]=
+{
+    //  Brightness 0
+    {0x3301, 0xff},//bit[7]:1, enable SDE
+    {0x3391, 0x00},
+    {0x3390, 0x41},
+    {0x339a, 0x00},
+    {0x0000, 0x00}
+};
+
+static  struct reginfo sensor_Brightness3[]=
+{
+    // Brightness +1
+    {0x3301, 0xff},//bit[7]:1, enable SDE
+    {0x3391, 0x04},
+    {0x3390, 0x41},
+    {0x339a, 0x10},
+    {0x0000, 0x00}
+};
+
+static  struct reginfo sensor_Brightness4[]=
+{
+    //  Brightness +2
+    {0x3301, 0xff},//bit[7]:1, enable SDE
+    {0x3391, 0x04},
+    {0x3390, 0x41},
+    {0x339a, 0x20},
+    {0x0000, 0x00}
+};
+
+static  struct reginfo sensor_Brightness5[]=
+{
+    //  Brightness +3
+    {0x3301, 0xff},//bit[7]:1, enable SDE
+    {0x3391, 0x04}, //bit[2] enable
+    {0x3390, 0x41}, //bit[3] sign of brightness
+    {0x339a, 0x30},
+    {0x0000, 0x00}
+};
+static struct reginfo *sensor_BrightnessSeqe[] = {sensor_Brightness0, sensor_Brightness1, sensor_Brightness2, sensor_Brightness3,
+    sensor_Brightness4, sensor_Brightness5,NULL,
+};
+
+#endif
+
+#if CONFIG_SENSOR_Effect
+static  struct reginfo sensor_Effect_Normal[] =
+{
+	{0x3a,0x0d},
+	{0x67,0x80},
+	{0x68,0x80},
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Effect_WandB[] =
+{
+	{0x3a,0x1d},
+	{0x67,0x80},
+	{0x68,0x80},
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Effect_Sepia[] =
+{
+	{0x3a,0x1d},
+	{0x67,0x40},
+	{0x68,0xa0},
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Effect_Negative[] =
+{
+    //Negative
+	{0x3a,0x2d},
+	{0x67,0x80},
+	{0x68,0x80},
+    {0x00, 0x00}
+};
+static  struct reginfo sensor_Effect_Bluish[] =
+{
+    // Bluish
+	{0x3a,0x1d},
+	{0x67,0xc0},
+	{0x68,0x80},
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Effect_Green[] =
+{
+    //  Greenish
+	{0x3a,0x1d},
+	{0x67,0x40},
+	{0x68,0x40},
+    {0x00, 0x00}
+};
+static struct reginfo *sensor_EffectSeqe[] = {sensor_Effect_Normal, sensor_Effect_WandB, sensor_Effect_Negative,sensor_Effect_Sepia,
+    sensor_Effect_Bluish, sensor_Effect_Green,NULL,
+};
+#endif
+#if CONFIG_SENSOR_Exposure
+static  struct reginfo sensor_Exposure0[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Exposure1[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Exposure2[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Exposure3[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Exposure4[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Exposure5[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Exposure6[]=
+{
+    {0x00, 0x00}
+};
+
+static struct reginfo *sensor_ExposureSeqe[] = {sensor_Exposure0, sensor_Exposure1, sensor_Exposure2, sensor_Exposure3,
+    sensor_Exposure4, sensor_Exposure5,sensor_Exposure6,NULL,
+};
+#endif
+#if CONFIG_SENSOR_Saturation
+static  struct reginfo sensor_Saturation0[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Saturation1[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Saturation2[]=
+{
+    {0x00, 0x00}
+};
+static struct reginfo *sensor_SaturationSeqe[] = {sensor_Saturation0, sensor_Saturation1, sensor_Saturation2, NULL,};
+
+#endif
+#if CONFIG_SENSOR_Contrast
+static  struct reginfo sensor_Contrast0[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Contrast1[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Contrast2[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Contrast3[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Contrast4[]=
+{
+    {0x00, 0x00}
+};
+
+
+static  struct reginfo sensor_Contrast5[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_Contrast6[]=
+{
+    {0x00, 0x00}
+};
+static struct reginfo *sensor_ContrastSeqe[] = {sensor_Contrast0, sensor_Contrast1, sensor_Contrast2, sensor_Contrast3,
+    sensor_Contrast4, sensor_Contrast5, sensor_Contrast6, NULL,
+};
+
+#endif
+#if CONFIG_SENSOR_Mirror
+static  struct reginfo sensor_MirrorOn[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_MirrorOff[]=
+{
+    {0x00, 0x00}
+};
+static struct reginfo *sensor_MirrorSeqe[] = {sensor_MirrorOff, sensor_MirrorOn,NULL,};
+#endif
+#if CONFIG_SENSOR_Flip
+static  struct reginfo sensor_FlipOn[]=
+{
+    {0x00, 0x00}
+};
+
+static  struct reginfo sensor_FlipOff[]=
+{
+    {0x00, 0x00}
+};
+static struct reginfo *sensor_FlipSeqe[] = {sensor_FlipOff, sensor_FlipOn,NULL,};
+
+#endif
+#if CONFIG_SENSOR_Scene
+static  struct reginfo sensor_SceneAuto[] =
+{
+{0x00, 0x00}
+};
+
+static  struct reginfo sensor_SceneNight[] =
+{
+{0x00, 0x00}
+};
+static struct reginfo *sensor_SceneSeqe[] = {sensor_SceneAuto, sensor_SceneNight,NULL,};
+
+#endif
+#if CONFIG_SENSOR_DigitalZoom
+static struct reginfo sensor_Zoom0[] =
+{
+    {0x0, 0x0},
+};
+
+static struct reginfo sensor_Zoom1[] =
+{
+     {0x0, 0x0},
+};
+
+static struct reginfo sensor_Zoom2[] =
+{
+    {0x0, 0x0},
+};
+
+
+static struct reginfo sensor_Zoom3[] =
+{
+    {0x0, 0x0},
+};
+static struct reginfo *sensor_ZoomSeqe[] = {sensor_Zoom0, sensor_Zoom1, sensor_Zoom2, sensor_Zoom3, NULL,};
+#endif
+static const struct v4l2_querymenu sensor_menus[] =
+{
+	#if CONFIG_SENSOR_WhiteBalance
+    { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 0,  .name = "auto",  .reserved = 0, }, {  .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 1, .name = "incandescent",  .reserved = 0,},
+    { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 2,  .name = "fluorescent", .reserved = 0,}, {  .id = V4L2_CID_DO_WHITE_BALANCE, .index = 3,  .name = "daylight", .reserved = 0,},
+    { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 4,  .name = "cloudy-daylight", .reserved = 0,},
+    #endif
+
+	#if CONFIG_SENSOR_Effect
+    { .id = V4L2_CID_EFFECT,  .index = 0,  .name = "none",  .reserved = 0, }, {  .id = V4L2_CID_EFFECT,  .index = 1, .name = "mono",  .reserved = 0,},
+    { .id = V4L2_CID_EFFECT,  .index = 2,  .name = "negative", .reserved = 0,}, {  .id = V4L2_CID_EFFECT, .index = 3,  .name = "sepia", .reserved = 0,},
+    { .id = V4L2_CID_EFFECT,  .index = 4, .name = "posterize", .reserved = 0,} ,{ .id = V4L2_CID_EFFECT,  .index = 5,  .name = "aqua", .reserved = 0,},
+    #endif
+
+	#if CONFIG_SENSOR_Scene
+    { .id = V4L2_CID_SCENE,  .index = 0, .name = "auto", .reserved = 0,} ,{ .id = V4L2_CID_SCENE,  .index = 1,  .name = "night", .reserved = 0,},
+    #endif
+
+	#if CONFIG_SENSOR_Flash
+    { .id = V4L2_CID_FLASH,  .index = 0,  .name = "off",  .reserved = 0, }, {  .id = V4L2_CID_FLASH,  .index = 1, .name = "auto",  .reserved = 0,},
+    { .id = V4L2_CID_FLASH,  .index = 2,  .name = "on", .reserved = 0,}, {  .id = V4L2_CID_FLASH, .index = 3,  .name = "torch", .reserved = 0,},
+    #endif
+};
+
+static const struct v4l2_queryctrl sensor_controls[] =
+{
+	#if CONFIG_SENSOR_WhiteBalance
+    {
+        .id		= V4L2_CID_DO_WHITE_BALANCE,
+        .type		= V4L2_CTRL_TYPE_MENU,
+        .name		= "White Balance Control",
+        .minimum	= 0,
+        .maximum	= 4,
+        .step		= 1,
+        .default_value = 0,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_Brightness
+	{
+        .id		= V4L2_CID_BRIGHTNESS,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "Brightness Control",
+        .minimum	= -3,
+        .maximum	= 2,
+        .step		= 1,
+        .default_value = 0,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_Effect
+	{
+        .id		= V4L2_CID_EFFECT,
+        .type		= V4L2_CTRL_TYPE_MENU,
+        .name		= "Effect Control",
+        .minimum	= 0,
+        .maximum	= 5,
+        .step		= 1,
+        .default_value = 0,
+    },
+	#endif
+
+	#if CONFIG_SENSOR_Exposure
+	{
+        .id		= V4L2_CID_EXPOSURE,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "Exposure Control",
+        .minimum	= 0,
+        .maximum	= 6,
+        .step		= 1,
+        .default_value = 0,
+    },
+	#endif
+
+	#if CONFIG_SENSOR_Saturation
+	{
+        .id		= V4L2_CID_SATURATION,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "Saturation Control",
+        .minimum	= 0,
+        .maximum	= 2,
+        .step		= 1,
+        .default_value = 0,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_Contrast
+	{
+        .id		= V4L2_CID_CONTRAST,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "Contrast Control",
+        .minimum	= -3,
+        .maximum	= 3,
+        .step		= 1,
+        .default_value = 0,
+    },
+	#endif
+
+	#if CONFIG_SENSOR_Mirror
+	{
+        .id		= V4L2_CID_HFLIP,
+        .type		= V4L2_CTRL_TYPE_BOOLEAN,
+        .name		= "Mirror Control",
+        .minimum	= 0,
+        .maximum	= 1,
+        .step		= 1,
+        .default_value = 1,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_Flip
+	{
+        .id		= V4L2_CID_VFLIP,
+        .type		= V4L2_CTRL_TYPE_BOOLEAN,
+        .name		= "Flip Control",
+        .minimum	= 0,
+        .maximum	= 1,
+        .step		= 1,
+        .default_value = 1,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_Scene
+    {
+        .id		= V4L2_CID_SCENE,
+        .type		= V4L2_CTRL_TYPE_MENU,
+        .name		= "Scene Control",
+        .minimum	= 0,
+        .maximum	= 1,
+        .step		= 1,
+        .default_value = 0,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_DigitalZoom
+    {
+        .id		= V4L2_CID_ZOOM_RELATIVE,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "DigitalZoom Control",
+        .minimum	= -1,
+        .maximum	= 1,
+        .step		= 1,
+        .default_value = 0,
+    }, {
+        .id		= V4L2_CID_ZOOM_ABSOLUTE,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "DigitalZoom Control",
+        .minimum	= 0,
+        .maximum	= 3,
+        .step		= 1,
+        .default_value = 0,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_Focus
+	{
+        .id		= V4L2_CID_FOCUS_RELATIVE,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "Focus Control",
+        .minimum	= -1,
+        .maximum	= 1,
+        .step		= 1,
+        .default_value = 0,
+    }, {
+        .id		= V4L2_CID_FOCUS_ABSOLUTE,
+        .type		= V4L2_CTRL_TYPE_INTEGER,
+        .name		= "Focus Control",
+        .minimum	= 0,
+        .maximum	= 255,
+        .step		= 1,
+        .default_value = 125,
+    },
+    #endif
+
+	#if CONFIG_SENSOR_Flash
+	{
+        .id		= V4L2_CID_FLASH,
+        .type		= V4L2_CTRL_TYPE_MENU,
+        .name		= "Flash Control",
+        .minimum	= 0,
+        .maximum	= 3,
+        .step		= 1,
+        .default_value = 0,
+    },
+	#endif
+};
+
+static int sensor_probe(struct i2c_client *client, const struct i2c_device_id *did);
+static int sensor_video_probe(struct soc_camera_device *icd, struct i2c_client *client);
+static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
+static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
+static int sensor_g_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);
+static int sensor_s_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);
+static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg);
+static int sensor_resume(struct soc_camera_device *icd);
+static int sensor_set_bus_param(struct soc_camera_device *icd,unsigned long flags);
+static unsigned long sensor_query_bus_param(struct soc_camera_device *icd);
+
+static struct soc_camera_ops sensor_ops =
+{
+    .suspend                     = sensor_suspend,
+    .resume                       = sensor_resume,
+    .set_bus_param		= sensor_set_bus_param,
+    .query_bus_param	= sensor_query_bus_param,
+    .controls		= sensor_controls,
+    .menus                         = sensor_menus,
+    .num_controls		= ARRAY_SIZE(sensor_controls),
+    .num_menus		= ARRAY_SIZE(sensor_menus),
+};
+
+#define COL_FMT(_name, _depth, _fourcc, _colorspace) \
+	{ .name = _name, .depth = _depth, .fourcc = _fourcc, \
+	.colorspace = _colorspace }
+
+#define JPG_FMT(_name, _depth, _fourcc) \
+	COL_FMT(_name, _depth, _fourcc, V4L2_COLORSPACE_JPEG)
+
+static const struct soc_camera_data_format sensor_colour_formats[] = {
+	JPG_FMT(SENSOR_NAME_STRING(UYVY), 16, V4L2_PIX_FMT_UYVY),
+	JPG_FMT(SENSOR_NAME_STRING(YUYV), 16, V4L2_PIX_FMT_YUYV),
+};
+
+typedef struct sensor_info_priv_s
+{
+    int whiteBalance;
+    int brightness;
+    int contrast;
+    int saturation;
+    int effect;
+    int scene;
+    int digitalzoom;
+    int focus;
+    int flash;
+    int exposure;
+    unsigned char mirror;                                        /* HFLIP */
+    unsigned char flip;                                          /* VFLIP */
+    unsigned int winseqe_cur_addr;
+	unsigned int pixfmt;
+
+} sensor_info_priv_t;
+
+struct sensor
+{
+    struct v4l2_subdev subdev;
+    struct i2c_client *client;
+    sensor_info_priv_t info_priv;
+    int model;	/* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */
+};
+
+static struct sensor* to_sensor(const struct i2c_client *client)
+{
+    return container_of(i2c_get_clientdata(client), struct sensor, subdev);
+}
+
+/* sensor register write */
+static int sensor_write(struct i2c_client *client, u8 reg, u8 val)
+{
+    int err,cnt;
+    u8 buf[2];
+    struct i2c_msg msg[1];
+
+    buf[0] = reg & 0xFF;
+    buf[1] = val;
+
+    msg->addr = client->addr;
+    msg->flags = client->flags;
+    msg->buf = buf;
+    msg->len = sizeof(buf);
+    msg->scl_rate = CONFIG_SENSOR_I2C_SPEED;                                        /* ddl@rock-chips.com : 100kHz */
+    msg->read_type = 0;               /* fpga i2c:0==I2C_NORMAL : direct use number not enum for don't want include spi_fpga.h */
+
+    cnt = 3;
+    err = -EAGAIN;
+
+    while ((cnt--) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */
+        err = i2c_transfer(client->adapter, msg, 1);
+
+        if (err >= 0) {
+            return 0;
+        } else {
+            SENSOR_TR("\n %s write reg failed, try to write again!\n",SENSOR_NAME_STRING());
+            udelay(10);
+        }
+    }
+
+    return err;
+}
+
+/* sensor register read */
+static int sensor_read(struct i2c_client *client, u8 reg, u8 *val)
+{
+    int err,cnt;
+    //u8 buf[2];
+    u8 buf[1];
+    struct i2c_msg msg[2];
+
+    //buf[0] = reg >> 8;
+    buf[0] = reg;
+    buf[1] = reg & 0xFF;
+
+    msg[0].addr = client->addr;
+    msg[0].flags = client->flags;
+    msg[0].buf = buf;
+    msg[0].len = sizeof(buf);
+    msg[0].scl_rate = CONFIG_SENSOR_I2C_SPEED;       /* ddl@rock-chips.com : 100kHz */
+    msg[0].read_type = 2;   /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
+
+    msg[1].addr = client->addr;
+    msg[1].flags = client->flags|I2C_M_RD;
+    msg[1].buf = buf;
+    msg[1].len = 1;
+    msg[1].scl_rate = CONFIG_SENSOR_I2C_SPEED;                       /* ddl@rock-chips.com : 100kHz */
+    msg[1].read_type = 2;                             /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
+
+    cnt = 1;
+    err = -EAGAIN;
+    while ((cnt--) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */
+        err = i2c_transfer(client->adapter, msg, 2);
+
+        if (err >= 0) {
+            *val = buf[0];
+            return 0;
+        } else {
+        	SENSOR_TR("\n %s read reg failed, try to read again! reg:0x%x \n",SENSOR_NAME_STRING(),(unsigned int)val);
+            udelay(10);
+        }
+    }
+
+    return err;
+}
+
+/* write a array of registers  */
+#if 1
+static int sensor_write_array(struct i2c_client *client, struct reginfo *regarray)
+{
+    int err;
+    int i = 0;
+
+    while (regarray[i].reg != 0)
+    {
+        err = sensor_write(client, regarray[i].reg, regarray[i].val);
+        if (err != 0)
+        {
+            SENSOR_TR("%s..write failed current i = %d\n", SENSOR_NAME_STRING(),i);
+            return err;
+        }
+        i++;
+    }
+    return 0;
+}
+#else
+static int sensor_write_array(struct i2c_client *client, struct reginfo *regarray)
+{
+    int err;
+    int i = 0;
+	u8 val_read;
+    while (regarray[i].reg != 0)
+    {
+        err = sensor_write(client, regarray[i].reg, regarray[i].val);
+        if (err != 0)
+        {
+            SENSOR_TR("%s..write failed current i = %d\n", SENSOR_NAME_STRING(),i);
+            return err;
+        }
+		err = sensor_read(client, regarray[i].reg, &val_read);
+		SENSOR_TR("%s..reg[0x%x]=0x%x,0x%x\n", SENSOR_NAME_STRING(),regarray[i].reg, val_read, regarray[i].val);
+        i++;
+    }
+    return 0;
+}
+#endif
+
+static int sensor_init(struct v4l2_subdev *sd, u32 val)
+{
+    struct i2c_client *client = sd->priv;
+    struct soc_camera_device *icd = client->dev.platform_data;
+    struct sensor *sensor = to_sensor(client);
+	const struct v4l2_queryctrl *qctrl;
+    int ret;
+
+    SENSOR_DG("\n%s..%s.. \n",SENSOR_NAME_STRING(),__FUNCTION__);
+
+    /* soft reset */
+    ret = sensor_write(client, 0x12, 0x80);
+    if (ret != 0)
+    {
+        SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
+        ret = -ENODEV;
+		goto sensor_INIT_ERR;
+    }
+
+    mdelay(5);  //delay 5 microseconds
+
+    ret = sensor_write_array(client, sensor_init_data);
+    if (ret != 0)
+    {
+        SENSOR_TR("error: %s initial failed\n",SENSOR_NAME_STRING());
+        goto sensor_INIT_ERR;
+    }
+
+    icd->user_width = SENSOR_INIT_WIDTH;
+    icd->user_height = SENSOR_INIT_HEIGHT;
+    sensor->info_priv.winseqe_cur_addr  = (int)SENSOR_INIT_WINSEQADR;
+	sensor->info_priv.pixfmt = SENSOR_INIT_PIXFMT;
+
+    /* sensor sensor information for initialization  */
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);
+	if (qctrl)
+    	sensor->info_priv.whiteBalance = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_BRIGHTNESS);
+	if (qctrl)
+    	sensor->info_priv.brightness = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);
+	if (qctrl)
+    	sensor->info_priv.effect = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EXPOSURE);
+	if (qctrl)
+        sensor->info_priv.exposure = qctrl->default_value;
+
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SATURATION);
+	if (qctrl)
+        sensor->info_priv.saturation = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_CONTRAST);
+	if (qctrl)
+        sensor->info_priv.contrast = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_HFLIP);
+	if (qctrl)
+        sensor->info_priv.mirror = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_VFLIP);
+	if (qctrl)
+        sensor->info_priv.flip = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SCENE);
+	if (qctrl)
+        sensor->info_priv.scene = qctrl->default_value;
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
+	if (qctrl)
+        sensor->info_priv.digitalzoom = qctrl->default_value;
+
+    /* ddl@rock-chips.com : if sensor support auto focus and flash, programer must run focus and flash code  */
+	#if CONFIG_SENSOR_Focus
+    sensor_set_focus();
+    qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FOCUS_ABSOLUTE);
+	if (qctrl)
+        sensor->info_priv.focus = qctrl->default_value;
+	#endif
+
+	#if CONFIG_SENSOR_Flash
+	sensor_set_flash();
+	qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FLASH);
+	if (qctrl)
+        sensor->info_priv.flash = qctrl->default_value;
+    #endif
+
+    SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,icd->user_width,icd->user_height);
+
+    return 0;
+sensor_INIT_ERR:
+    return ret;
+}
+
+static int sensor_deactivate(struct v4l2_subdev *sd)
+{
+	//struct i2c_client *client = sd->priv;
+	//u8 reg_val;
+
+	SENSOR_DG("\n%s..%s.. \n",SENSOR_NAME_STRING(),__FUNCTION__);
+
+	/* ddl@rock-chips.com : all sensor output pin must change to input for other sensor */
+
+
+	return 0;
+}
+static  struct reginfo sensor_power_down_sequence[]=
+{
+    {0x00,0x00}
+};
+static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg)
+{
+    int ret;
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+    struct soc_camera_link *icl;
+
+
+    if (pm_msg.event == PM_EVENT_SUSPEND)
+    {
+        SENSOR_DG("\n %s Enter Suspend.. \n", SENSOR_NAME_STRING());
+        ret = sensor_write_array(client, sensor_power_down_sequence) ;
+        if (ret != 0)
+        {
+            SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);
+            return ret;
+        }
+        else
+        {
+            icl = to_soc_camera_link(icd);
+            if (icl->power) {
+                ret = icl->power(icd->pdev, 0);
+                if (ret < 0) {
+				    SENSOR_TR("\n %s suspend fail for turn on power!\n", SENSOR_NAME_STRING());
+                    return -EINVAL;
+                }
+            }
+        }
+    }
+    else
+    {
+        SENSOR_TR("\n %s cann't suppout Suspend..\n",SENSOR_NAME_STRING());
+        return -EINVAL;
+    }
+    return 0;
+}
+
+static int sensor_resume(struct soc_camera_device *icd)
+{
+    struct soc_camera_link *icl;
+    int ret;
+
+    icl = to_soc_camera_link(icd);
+    if (icl->power) {
+        ret = icl->power(icd->pdev, 1);
+        if (ret < 0) {
+			SENSOR_TR("\n %s resume fail for turn on power!\n", SENSOR_NAME_STRING());
+            return -EINVAL;
+        }
+    }
+
+	SENSOR_DG("\n %s Enter Resume.. \n", SENSOR_NAME_STRING());
+
+    return 0;
+
+}
+
+static int sensor_set_bus_param(struct soc_camera_device *icd,
+                                unsigned long flags)
+{
+
+    return 0;
+}
+
+static unsigned long sensor_query_bus_param(struct soc_camera_device *icd)
+{
+    struct soc_camera_link *icl = to_soc_camera_link(icd);
+    unsigned long flags = SENSOR_BUS_PARAM;
+
+    return soc_camera_apply_sensor_flags(icl, flags);
+}
+
+static int sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+    struct i2c_client *client = sd->priv;
+    struct soc_camera_device *icd = client->dev.platform_data;
+    struct sensor *sensor = to_sensor(client);
+    struct v4l2_pix_format *pix = &f->fmt.pix;
+
+    pix->width		= icd->user_width;
+    pix->height		= icd->user_height;
+    pix->pixelformat	= sensor->info_priv.pixfmt;
+    pix->field		= V4L2_FIELD_NONE;
+    pix->colorspace		= V4L2_COLORSPACE_JPEG;
+
+    return 0;
+}
+static int sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+    struct i2c_client *client = sd->priv;
+    struct sensor *sensor = to_sensor(client);
+    struct v4l2_pix_format *pix = &f->fmt.pix;
+    struct reginfo *winseqe_set_addr=NULL;
+	char readval;
+    int ret=0, set_w,set_h;
+
+	if (sensor->info_priv.pixfmt != pix->pixelformat) {
+		switch (pix->pixelformat)
+		{
+			case V4L2_PIX_FMT_YUYV:
+			{
+				//winseqe_set_addr = sensor_ClrFmt_YUYV;
+				sensor_read(client, 0x3a, &readval);
+				sensor_write(client,0x3a, readval&0xf7);
+				sensor_read(client,0x3d,&readval);
+				sensor_write(client,0x3d,readval&0xfe);
+				break;
+			}
+			case V4L2_PIX_FMT_UYVY:
+			{
+				//winseqe_set_addr = sensor_ClrFmt_UYVY;
+				sensor_read(client, 0x3a, &readval);
+				sensor_write(client,0x3a, readval|0x08);
+				sensor_read(client,0x3d,&readval);
+				sensor_write(client,0x3d,readval&0xfe);
+				break;
+			}
+			default:
+				break;
+		}
+		if (winseqe_set_addr != NULL) {
+            sensor_write_array(client, winseqe_set_addr);
+			sensor->info_priv.pixfmt = pix->pixelformat;
+
+			SENSOR_DG("%s Pixelformat(0x%x) set success!\n", SENSOR_NAME_STRING(),pix->pixelformat);
+		} else {
+			SENSOR_TR("%s Pixelformat(0x%x) is invalidate!\n", SENSOR_NAME_STRING(),pix->pixelformat);
+		}
+	}
+
+    set_w = pix->width;
+    set_h = pix->height;
+
+	if (((set_w <= 176) && (set_h <= 144)) && sensor_qcif[0].reg)
+	{
+		winseqe_set_addr = sensor_qcif;
+        set_w = 176;
+        set_h = 144;
+	}
+	else if (((set_w <= 320) && (set_h <= 240)) && sensor_qvga[0].reg)
+    {
+        winseqe_set_addr = sensor_qvga;
+        set_w = 320;
+        set_h = 240;
+    }
+    else if (((set_w <= 352) && (set_h<= 288)) && sensor_cif[0].reg)
+    {
+        winseqe_set_addr = sensor_cif;
+        set_w = 352;
+        set_h = 288;
+    }
+    else if (((set_w <= 640) && (set_h <= 480)) && sensor_vga[0].reg)
+    {
+        winseqe_set_addr = sensor_vga;
+        set_w = 640;
+        set_h = 480;
+    }
+    else if (((set_w <= 800) && (set_h <= 600)) && sensor_svga[0].reg)
+    {
+        winseqe_set_addr = sensor_svga;
+        set_w = 800;
+        set_h = 600;
+    }
+    else if (((set_w <= 1280) && (set_h <= 1024)) && sensor_sxga[0].reg)
+    {
+        winseqe_set_addr = sensor_sxga;
+        set_w = 1280;
+        set_h = 1024;
+    }
+    else
+    {
+        winseqe_set_addr = SENSOR_INIT_WINSEQADR;               /* ddl@rock-chips.com : Sensor output smallest size if  isn't support app  */
+        set_w = SENSOR_INIT_WIDTH;
+        set_h = SENSOR_INIT_HEIGHT;
+		ret = -1;
+		SENSOR_TR("\n %s..%s Format is Invalidate. pix->width = %d.. pix->height = %d\n",SENSOR_NAME_STRING(),__FUNCTION__,pix->width,pix->height);
+    }
+
+    if ((int)winseqe_set_addr  != sensor->info_priv.winseqe_cur_addr)
+    {
+        ret |= sensor_write_array(client, winseqe_set_addr);
+        if (ret != 0) {
+            SENSOR_TR("%s set format capability failed\n", SENSOR_NAME_STRING());
+            goto sensor_s_fmt_end;
+        }
+
+        sensor->info_priv.winseqe_cur_addr  = (int)winseqe_set_addr;
+
+
+        SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,set_w,set_h);
+    }
+    else
+    {
+        SENSOR_TR("\n %s .. Current Format is validate. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),set_w,set_h);
+    }
+
+	pix->width = set_w;
+    pix->height = set_h;
+
+sensor_s_fmt_end:
+    return ret;
+}
+
+static int sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
+{
+    struct v4l2_pix_format *pix = &f->fmt.pix;
+    bool bayer = pix->pixelformat == V4L2_PIX_FMT_UYVY ||
+        pix->pixelformat == V4L2_PIX_FMT_YUYV;
+
+    /*
+    * With Bayer format enforce even side lengths, but let the user play
+    * with the starting pixel
+    */
+
+    if (pix->height > SENSOR_MAX_HEIGHT)
+        pix->height = SENSOR_MAX_HEIGHT;
+    else if (pix->height < SENSOR_MIN_HEIGHT)
+        pix->height = SENSOR_MIN_HEIGHT;
+    else if (bayer)
+        pix->height = ALIGN(pix->height, 2);
+
+    if (pix->width > SENSOR_MAX_WIDTH)
+        pix->width = SENSOR_MAX_WIDTH;
+    else if (pix->width < SENSOR_MIN_WIDTH)
+        pix->width = SENSOR_MIN_WIDTH;
+    else if (bayer)
+        pix->width = ALIGN(pix->width, 2);
+
+    return 0;
+}
+
+ static int sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id)
+{
+    struct i2c_client *client = sd->priv;
+
+    if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
+        return -EINVAL;
+
+    if (id->match.addr != client->addr)
+        return -ENODEV;
+
+    id->ident = SENSOR_V4L2_IDENT;      /* ddl@rock-chips.com :  Return OV9650  identifier */
+    id->revision = 0;
+
+    return 0;
+}
+#if CONFIG_SENSOR_Brightness
+static int sensor_set_brightness(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_BrightnessSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_BrightnessSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+	SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_Effect
+static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_EffectSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_EffectSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+	SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_Exposure
+static int sensor_set_exposure(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_ExposureSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_ExposureSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+	SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_Saturation
+static int sensor_set_saturation(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_SaturationSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_SaturationSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+    SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_Contrast
+static int sensor_set_contrast(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_ContrastSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_ContrastSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+    SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_Mirror
+static int sensor_set_mirror(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_MirrorSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_MirrorSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+    SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_Flip
+static int sensor_set_flip(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_FlipSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_FlipSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+    SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_Scene
+static int sensor_set_scene(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_SceneSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_SceneSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+    SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_WhiteBalance
+static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+
+    if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
+    {
+        if (sensor_WhiteBalanceSeqe[value - qctrl->minimum] != NULL)
+        {
+            if (sensor_write_array(client, sensor_WhiteBalanceSeqe[value - qctrl->minimum]) != 0)
+            {
+                SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+                return -EINVAL;
+            }
+            SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
+            return 0;
+        }
+    }
+	SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
+    return -EINVAL;
+}
+#endif
+#if CONFIG_SENSOR_DigitalZoom
+static int sensor_set_digitalzoom(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int *value)
+{
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+    struct sensor *sensor = to_sensor(client);
+	const struct v4l2_queryctrl *qctrl_info;
+    int digitalzoom_cur, digitalzoom_total;
+
+	qctrl_info = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
+	if (qctrl_info)
+		return -EINVAL;
+
+    digitalzoom_cur = sensor->info_priv.digitalzoom;
+    digitalzoom_total = qctrl_info->maximum;
+
+    if ((*value > 0) && (digitalzoom_cur >= digitalzoom_total))
+    {
+        SENSOR_TR("%s digitalzoom is maximum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
+        return -EINVAL;
+    }
+
+    if  ((*value < 0) && (digitalzoom_cur <= qctrl_info->minimum))
+    {
+        SENSOR_TR("%s digitalzoom is minimum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
+        return -EINVAL;
+    }
+
+    if ((*value > 0) && ((digitalzoom_cur + *value) > digitalzoom_total))
+    {
+        *value = digitalzoom_total - digitalzoom_cur;
+    }
+
+    if ((*value < 0) && ((digitalzoom_cur + *value) < 0))
+    {
+        *value = 0 - digitalzoom_cur;
+    }
+
+    digitalzoom_cur += *value;
+
+    if (sensor_ZoomSeqe[digitalzoom_cur] != NULL)
+    {
+        if (sensor_write_array(client, sensor_ZoomSeqe[digitalzoom_cur]) != 0)
+        {
+            SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
+            return -EINVAL;
+        }
+        SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, *value);
+        return 0;
+    }
+
+    return -EINVAL;
+}
+#endif
+static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+    struct i2c_client *client = sd->priv;
+    struct sensor *sensor = to_sensor(client);
+    const struct v4l2_queryctrl *qctrl;
+
+    qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
+
+    if (!qctrl)
+    {
+        SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
+        return -EINVAL;
+    }
+
+    switch (ctrl->id)
+    {
+        case V4L2_CID_BRIGHTNESS:
+            {
+                ctrl->value = sensor->info_priv.brightness;
+                break;
+            }
+        case V4L2_CID_SATURATION:
+            {
+                ctrl->value = sensor->info_priv.saturation;
+                break;
+            }
+        case V4L2_CID_CONTRAST:
+            {
+                ctrl->value = sensor->info_priv.contrast;
+                break;
+            }
+        case V4L2_CID_DO_WHITE_BALANCE:
+            {
+                ctrl->value = sensor->info_priv.whiteBalance;
+                break;
+            }
+        case V4L2_CID_EXPOSURE:
+            {
+                ctrl->value = sensor->info_priv.exposure;
+                break;
+            }
+        case V4L2_CID_HFLIP:
+            {
+                ctrl->value = sensor->info_priv.mirror;
+                break;
+            }
+        case V4L2_CID_VFLIP:
+            {
+                ctrl->value = sensor->info_priv.flip;
+                break;
+            }
+        default :
+                break;
+    }
+    return 0;
+}
+
+
+
+static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
+{
+    struct i2c_client *client = sd->priv;
+    struct sensor *sensor = to_sensor(client);
+    struct soc_camera_device *icd = client->dev.platform_data;
+    const struct v4l2_queryctrl *qctrl;
+
+
+    qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
+
+    if (!qctrl)
+    {
+        SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
+        return -EINVAL;
+    }
+
+    switch (ctrl->id)
+    {
+#if CONFIG_SENSOR_Brightness
+        case V4L2_CID_BRIGHTNESS:
+            {
+                if (ctrl->value != sensor->info_priv.brightness)
+                {
+                    if (sensor_set_brightness(icd, qctrl,ctrl->value) != 0)
+                    {
+                        return -EINVAL;
+                    }
+                    sensor->info_priv.brightness = ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Exposure
+        case V4L2_CID_EXPOSURE:
+            {
+                if (ctrl->value != sensor->info_priv.exposure)
+                {
+                    if (sensor_set_exposure(icd, qctrl,ctrl->value) != 0)
+                    {
+                        return -EINVAL;
+                    }
+                    sensor->info_priv.exposure = ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Saturation
+        case V4L2_CID_SATURATION:
+            {
+                if (ctrl->value != sensor->info_priv.saturation)
+                {
+                    if (sensor_set_saturation(icd, qctrl,ctrl->value) != 0)
+                    {
+                        return -EINVAL;
+                    }
+                    sensor->info_priv.saturation = ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Contrast
+        case V4L2_CID_CONTRAST:
+            {
+                if (ctrl->value != sensor->info_priv.contrast)
+                {
+                    if (sensor_set_contrast(icd, qctrl,ctrl->value) != 0)
+                    {
+                        return -EINVAL;
+                    }
+                    sensor->info_priv.contrast = ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_WhiteBalance
+        case V4L2_CID_DO_WHITE_BALANCE:
+            {
+                if (ctrl->value != sensor->info_priv.whiteBalance)
+                {
+                    if (sensor_set_whiteBalance(icd, qctrl,ctrl->value) != 0)
+                    {
+                        return -EINVAL;
+                    }
+                    sensor->info_priv.whiteBalance = ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Mirror
+        case V4L2_CID_HFLIP:
+            {
+                if (ctrl->value != sensor->info_priv.mirror)
+                {
+                    if (sensor_set_mirror(icd, qctrl,ctrl->value) != 0)
+                        return -EINVAL;
+                    sensor->info_priv.mirror = ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Flip
+        case V4L2_CID_VFLIP:
+            {
+                if (ctrl->value != sensor->info_priv.flip)
+                {
+                    if (sensor_set_flip(icd, qctrl,ctrl->value) != 0)
+                        return -EINVAL;
+                    sensor->info_priv.flip = ctrl->value;
+                }
+                break;
+            }
+#endif
+        default:
+            break;
+    }
+
+    return 0;
+}
+static int sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl)
+{
+    const struct v4l2_queryctrl *qctrl;
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+    struct sensor *sensor = to_sensor(client);
+
+    qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
+
+    if (!qctrl)
+    {
+        SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
+        return -EINVAL;
+    }
+
+    switch (ext_ctrl->id)
+    {
+        case V4L2_CID_SCENE:
+            {
+                ext_ctrl->value = sensor->info_priv.scene;
+                break;
+            }
+        case V4L2_CID_EFFECT:
+            {
+                ext_ctrl->value = sensor->info_priv.effect;
+                break;
+            }
+        case V4L2_CID_ZOOM_ABSOLUTE:
+            {
+                ext_ctrl->value = sensor->info_priv.digitalzoom;
+                break;
+            }
+        case V4L2_CID_ZOOM_RELATIVE:
+            {
+                return -EINVAL;
+            }
+        case V4L2_CID_FOCUS_ABSOLUTE:
+            {
+                ext_ctrl->value = sensor->info_priv.focus;
+                break;
+            }
+        case V4L2_CID_FOCUS_RELATIVE:
+            {
+                return -EINVAL;
+            }
+        case V4L2_CID_FLASH:
+            {
+                ext_ctrl->value = sensor->info_priv.flash;
+                break;
+            }
+        default :
+            break;
+    }
+    return 0;
+}
+static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl)
+{
+    const struct v4l2_queryctrl *qctrl;
+    struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
+    struct sensor *sensor = to_sensor(client);
+    int val_offset;
+
+    qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
+
+    if (!qctrl)
+    {
+        SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
+        return -EINVAL;
+    }
+
+	val_offset = 0;
+    switch (ext_ctrl->id)
+    {
+#if CONFIG_SENSOR_Scene
+        case V4L2_CID_SCENE:
+            {
+                if (ext_ctrl->value != sensor->info_priv.scene)
+                {
+                    if (sensor_set_scene(icd, qctrl,ext_ctrl->value) != 0)
+                        return -EINVAL;
+                    sensor->info_priv.scene = ext_ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Effect
+        case V4L2_CID_EFFECT:
+            {
+                if (ext_ctrl->value != sensor->info_priv.effect)
+                {
+                    if (sensor_set_effect(icd, qctrl,ext_ctrl->value) != 0)
+                        return -EINVAL;
+                    sensor->info_priv.effect= ext_ctrl->value;
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_DigitalZoom
+        case V4L2_CID_ZOOM_ABSOLUTE:
+            {
+                if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
+                    return -EINVAL;
+
+                if (ext_ctrl->value != sensor->info_priv.digitalzoom)
+                {
+                    val_offset = ext_ctrl->value -sensor->info_priv.digitalzoom;
+
+                    if (sensor_set_digitalzoom(icd, qctrl,&val_offset) != 0)
+                        return -EINVAL;
+                    sensor->info_priv.digitalzoom += val_offset;
+
+                    SENSOR_DG("%s digitalzoom is %x\n",SENSOR_NAME_STRING(),  sensor->info_priv.digitalzoom);
+                }
+
+                break;
+            }
+        case V4L2_CID_ZOOM_RELATIVE:
+            {
+                if (ext_ctrl->value)
+                {
+                    if (sensor_set_digitalzoom(icd, qctrl,&ext_ctrl->value) != 0)
+                        return -EINVAL;
+                    sensor->info_priv.digitalzoom += ext_ctrl->value;
+
+                    SENSOR_DG("%s digitalzoom is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.digitalzoom);
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Focus
+        case V4L2_CID_FOCUS_ABSOLUTE:
+            {
+                if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
+                    return -EINVAL;
+
+                if (ext_ctrl->value != sensor->info_priv.focus)
+                {
+                    val_offset = ext_ctrl->value -sensor->info_priv.focus;
+
+                    sensor->info_priv.focus += val_offset;
+                }
+
+                break;
+            }
+        case V4L2_CID_FOCUS_RELATIVE:
+            {
+                if (ext_ctrl->value)
+                {
+                    sensor->info_priv.focus += ext_ctrl->value;
+
+                    SENSOR_DG("%s focus is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.focus);
+                }
+                break;
+            }
+#endif
+#if CONFIG_SENSOR_Flash
+        case V4L2_CID_FLASH:
+            {
+                sensor->info_priv.flash = ext_ctrl->value;
+
+                SENSOR_DG("%s flash is %x\n",SENSOR_NAME_STRING(), sensor->info_priv.flash);
+                break;
+            }
+#endif
+        default:
+            break;
+    }
+
+    return 0;
+}
+
+static int sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
+{
+    struct i2c_client *client = sd->priv;
+    struct soc_camera_device *icd = client->dev.platform_data;
+    int i, error_cnt=0, error_idx=-1;
+
+
+    for (i=0; i<ext_ctrl->count; i++) {
+        if (sensor_g_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
+            error_cnt++;
+            error_idx = i;
+        }
+    }
+
+    if (error_cnt > 1)
+        error_idx = ext_ctrl->count;
+
+    if (error_idx != -1) {
+        ext_ctrl->error_idx = error_idx;
+        return -EINVAL;
+    } else {
+        return 0;
+    }
+}
+
+static int sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
+{
+    struct i2c_client *client = sd->priv;
+    struct soc_camera_device *icd = client->dev.platform_data;
+    int i, error_cnt=0, error_idx=-1;
+
+
+    for (i=0; i<ext_ctrl->count; i++) {
+        if (sensor_s_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
+            error_cnt++;
+            error_idx = i;
+        }
+    }
+
+    if (error_cnt > 1)
+        error_idx = ext_ctrl->count;
+
+    if (error_idx != -1) {
+        ext_ctrl->error_idx = error_idx;
+        return -EINVAL;
+    } else {
+        return 0;
+    }
+}
+
+/* Interface active, can use i2c. If it fails, it can indeed mean, that
+ * this wasn't our capture interface, so, we wait for the right one */
+static int sensor_video_probe(struct soc_camera_device *icd,
+			       struct i2c_client *client)
+{
+    char pid = 0;
+    int ret;
+    struct sensor *sensor = to_sensor(client);
+
+    /* We must have a parent by now. And it cannot be a wrong one.
+     * So this entire test is completely redundant. */
+    if (!icd->dev.parent ||
+	    to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
+		return -ENODEV;
+
+    /* soft reset */
+    ret = sensor_write(client, 0x12, 0x80);
+    if (ret != 0)
+    {
+        SENSOR_TR("soft reset %s failed\n",SENSOR_NAME_STRING());
+        return -ENODEV;
+    }
+    mdelay(50);          //delay 5 microseconds
+
+    /* check if it is an sensor sensor */
+    ret = sensor_read(client, 0x0a, &pid);
+    if (ret != 0) {
+        SENSOR_TR("%s read chip id high byte failed\n",SENSOR_NAME_STRING());
+        ret = -ENODEV;
+        goto sensor_video_probe_err;
+    }
+
+    SENSOR_DG("\n %s  pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
+    if (pid == SENSOR_ID) {
+        sensor->model = SENSOR_V4L2_IDENT;
+    } else {
+        SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
+        ret = -ENODEV;
+        goto sensor_video_probe_err;
+    }
+
+    icd->formats = sensor_colour_formats;
+    icd->num_formats = ARRAY_SIZE(sensor_colour_formats);
+
+    return 0;
+
+sensor_video_probe_err:
+
+    return ret;
+}
+
+static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
+{
+	SENSOR_DG("\n%s..%s..cmd:%x \n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);
+	switch (cmd)
+	{
+		case RK29_CAM_SUBDEV_DEACTIVATE:
+		{
+			sensor_deactivate(sd);
+			break;
+		}
+		default:
+			break;
+	}
+
+	return 0;
+
+}
+static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {
+	.init		= sensor_init,
+	.g_ctrl		= sensor_g_control,
+	.s_ctrl		= sensor_s_control,
+	.g_ext_ctrls          = sensor_g_ext_controls,
+	.s_ext_ctrls          = sensor_s_ext_controls,
+	.g_chip_ident	= sensor_g_chip_ident,
+	.ioctl = sensor_ioctl,
+};
+
+static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {
+	.s_fmt		= sensor_s_fmt,
+	.g_fmt		= sensor_g_fmt,
+	.try_fmt	= sensor_try_fmt,
+};
+
+static struct v4l2_subdev_ops sensor_subdev_ops = {
+	.core	= &sensor_subdev_core_ops,
+	.video = &sensor_subdev_video_ops,
+};
+
+static int sensor_probe(struct i2c_client *client,
+			 const struct i2c_device_id *did)
+{
+    struct sensor *sensor;
+    struct soc_camera_device *icd = client->dev.platform_data;
+    struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+    struct soc_camera_link *icl;
+    int ret;
+
+    SENSOR_DG("\n%s..%s..%d..\n",__FUNCTION__,__FILE__,__LINE__);
+    if (!icd) {
+        dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());
+        return -EINVAL;
+    }
+
+    icl = to_soc_camera_link(icd);
+    if (!icl) {
+        dev_err(&client->dev, "%s driver needs platform data\n", SENSOR_NAME_STRING());
+        return -EINVAL;
+    }
+
+    if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
+        dev_warn(&adapter->dev,
+        	 "I2C-Adapter doesn't support I2C_FUNC_I2C\n");
+        return -EIO;
+    }
+
+    sensor = kzalloc(sizeof(struct sensor), GFP_KERNEL);
+    if (!sensor)
+        return -ENOMEM;
+
+    v4l2_i2c_subdev_init(&sensor->subdev, client, &sensor_subdev_ops);
+
+    /* Second stage probe - when a capture adapter is there */
+    icd->ops		= &sensor_ops;
+    icd->y_skip_top		= 0;
+
+    ret = sensor_video_probe(icd, client);
+    if (ret) {
+        icd->ops = NULL;
+        i2c_set_clientdata(client, NULL);
+        kfree(sensor);
+    }
+    SENSOR_DG("\n%s..%s..%d  ret = %x \n",__FUNCTION__,__FILE__,__LINE__,ret);
+    return ret;
+}
+
+static int sensor_remove(struct i2c_client *client)
+{
+    struct sensor *sensor = to_sensor(client);
+    struct soc_camera_device *icd = client->dev.platform_data;
+
+    icd->ops = NULL;
+    i2c_set_clientdata(client, NULL);
+    client->driver = NULL;
+    kfree(sensor);
+
+    return 0;
+}
+
+static const struct i2c_device_id sensor_id[] = {
+	{SENSOR_NAME_STRING(), 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, sensor_id);
+
+static struct i2c_driver sensor_i2c_driver = {
+	.driver = {
+		.name = SENSOR_NAME_STRING(),
+	},
+	.probe		= sensor_probe,
+	.remove		= sensor_remove,
+	.id_table	= sensor_id,
+};
+
+static int __init sensor_mod_init(void)
+{
+    SENSOR_DG("\n%s..%s.. \n",__FUNCTION__,SENSOR_NAME_STRING());
+    return i2c_add_driver(&sensor_i2c_driver);
+}
+
+static void __exit sensor_mod_exit(void)
+{
+    i2c_del_driver(&sensor_i2c_driver);
+}
+
+device_initcall_sync(sensor_mod_init);
+module_exit(sensor_mod_exit);
+
+MODULE_DESCRIPTION(SENSOR_NAME_STRING(Camera sensor driver));
+MODULE_AUTHOR("ddl <kernel@rock-chips>");
+MODULE_LICENSE("GPL");
+
+
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 2c2e6e03b11f..9c222309b34e 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -1161,9 +1161,10 @@ enum  v4l2_exposure_auto_type {
 
 /* ddl@rock-chips.com : Add ioctrl -  V4L2_CID_SCENE for camera scene control */
 #define V4L2_CID_CAMERA_CLASS_BASE_ROCK                      (V4L2_CID_CAMERA_CLASS_BASE + 30)
-#define V4L2_CID_SCENE			(V4L2_CID_CAMERA_CLASS_BASE_ROCK+1)             
-#define V4L2_CID_EFFECT			(V4L2_CID_CAMERA_CLASS_BASE_ROCK+2) 
-#define V4L2_CID_FLASH                      (V4L2_CID_CAMERA_CLASS_BASE_ROCK+3) 
+#define V4L2_CID_SCENE			(V4L2_CID_CAMERA_CLASS_BASE_ROCK+1)
+#define V4L2_CID_EFFECT			(V4L2_CID_CAMERA_CLASS_BASE_ROCK+2)
+#define V4L2_CID_FLASH                      (V4L2_CID_CAMERA_CLASS_BASE_ROCK+3)
+#define V4L2_CID_FOCUS_CONTINUOUS     (V4L2_CID_CAMERA_CLASS_BASE_ROCK+4)
 
 
 /* FM Modulator class control IDs */
diff --git a/include/media/v4l2-chip-ident.h b/include/media/v4l2-chip-ident.h
index 55cda236b628..9ef00c42ada1 100644
--- a/include/media/v4l2-chip-ident.h
+++ b/include/media/v4l2-chip-ident.h
@@ -68,6 +68,7 @@ enum {
 	V4L2_IDENT_OV2659 = 258,
 	V4L2_IDENT_OV3640 = 259,
 	V4L2_IDENT_OV5642 = 260,
+	V4L2_IDENT_OV7675 = 261,
 
 	/* module saa7146: reserved range 300-309 */
 	V4L2_IDENT_SAA7146 = 300,
-- 
2.34.1