/*
 * A V4L2 driver for samsung s5k4ec cameras.
 *
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/videodev2.h>
#include <linux/clk.h>
#include <media/v4l2-device.h>
#include <media/v4l2-chip-ident.h>
#include <media/v4l2-mediabus.h>
#include <linux/io.h>
#include "camera.h"
#include "sensor_helper.h"

MODULE_AUTHOR("raymonxiu");
MODULE_DESCRIPTION("A low-level driver for samsung s5k4ec mipi sensors");
MODULE_LICENSE("GPL");

//for internel driver debug
#define DEV_DBG_EN      1
#if(DEV_DBG_EN == 1)
#define vfe_dev_dbg(x,arg...) printk("[S5K4EC_MIPI]"x,##arg)
#else
#define vfe_dev_dbg(x,arg...)
#endif
#define vfe_dev_err(x,arg...) printk("[S5K4EC_MIPI]"x,##arg)
#define vfe_dev_print(x,arg...) printk("[S5K4EC_MIPI]"x,##arg)

#define LOG_ERR_RET(x)  { \
                          int ret;  \
                          ret = x; \
                          if(ret < 0) {\
                            vfe_dev_err("error at %s\n",__func__);  \
                            return ret; \
                          } \
                        }

//define module timing
#define MCLK              (24*1000*1000)
#define VREF_POL          V4L2_MBUS_VSYNC_ACTIVE_HIGH
#define HREF_POL          V4L2_MBUS_HSYNC_ACTIVE_HIGH
#define CLK_POL           V4L2_MBUS_PCLK_SAMPLE_RISING
#define V4L2_IDENT_SENSOR 0x4ec



#define CONTINUEOUS_AF

#define AF_WIN_NEW_COORD

unsigned int coarse_af_pd=0;

/*
 * Our nominal (default) frame rate.
 */
#define SENSOR_FRAME_RATE 30

/*
 * The s5k4ec sits on i2c with ID 0x5a
 */
#define I2C_ADDR 0x5a
#define SENSOR_NAME "s5k4ec_mipi"
/* Registers */


static int sensor_s_band_filter(struct v4l2_subdev *sd,
		enum v4l2_power_line_frequency value);


/*
 * Information we maintain about a known sensor.
 */
struct sensor_format_struct;  /* coming later */

struct cfg_array { /* coming later */
	struct regval_list * regs;
	int size;
};

static inline struct sensor_info *to_state(struct v4l2_subdev *sd)
{
	return container_of(sd, struct sensor_info, sd);
}


/*
 * The default register settings
 *
 */

static struct regval_list sensor_default_regs[] = {
//==================================================================================
// 00.History
//==================================================================================
//2010 : EVT1.1
//20110429 : LSI CSE Standard
//20110728 : Sequence Changed
//20110728 : ESD Check Register Address Changed
//20110829 : TnP Changed by S.Y.Lee
//20120104 : init Parm Update sequence changed
//20120201 : Flash�� �ֺ��� Green Noise ���� setting
//20120228 : Add Brightness Block
//==================================================================================

//==================================================================================
// 01.Start Setting
//==================================================================================

{0xFCFC, 0xD000},
{0x0010, 0x0001},
{0x1030, 0x0000},
{0x0014, 0x0001},

//p10 //Delay 10ms



//==================================================================================
//02.ETC Setting
//==================================================================================

{0x002A,	0x1082},
{0x0F12,	0x0000},	//cregs_d0_d4_cd10 //D4[9:8], D3[7:6], D2[5:4], D1[3:2], D0[1:0]
{0x0F12,	0x0000},	//cregs_d5_d9_cd10 //D9[9:8], D8[7:6], D7[5:4], D6[3:2], D5[1:0]
{0x002A,	0x1088},
{0x0F12,	0x0000},	//cregs_clks_output_cd10 //SDA[11:10], SCL[9:8], PCLK[7:6], VSYNC[3:2], HSYNC[1:0]

//==================================================================================
// 03.Analog Setting & ASP Control
//==================================================================================

//This register is for FACTORY ONLY.
//If you change it without prior notification
//YOU are RESPONSIBLE for the FAILURE that will happen in the future

{0x0028, 0xD000},
{0x002A, 0x007A},
{0x0f12, 0x0000},
{0x002A, 0xE406},	 //[7]f_ladlc_en [6:5]f max [4]fadlc_en [3:2]L max [1]ladlc_en [0]adlc_ch_sel
{0x0F12, 0x0092},
{0x002A, 0xE410},
{0x0F12, 0x3804},	 //[15:8]fadlc_filter_co_b [7:0]fadlc_filter_co_a
{0x002A, 0xE41A},
{0x0F12, 0x0010},
{0x002A, 0xE420},
{0x0F12, 0x0003},	 //adlc_fadlc_filter_refresh
{0x0F12, 0x0060},	 //adlc_filter_level_diff_threshold
{0x002A, 0xE42E},
{0x0F12, 0x0004},	 //dithered l-ADLC(4bit)
{0x002A, 0xF400},
{0x0F12, 0x5A3C},	 //[15:8]stx_width [7:0]dstx_width
{0x0F12, 0x0023},	 //[14]binning_test [13]gain_mode [11:12]row_id [10]cfpn_test [9]pd_pix [8]teg_en [7]adc_res [6]smp_en [5]ldb_en [4]ld_en [3]clp_en [2]srx_en [1]dshut_en [0]dcds_en
{0x0F12, 0x8080},	 //CDS option
{0x0F12, 0x03AF},	 //[11:6]rst_mx [5:0]sig_mx
{0x0F12, 0x000A},	 //Avg mode
{0x0F12, 0xAA54},	 //x1~x1.49:No MS x1.5~x3.99:MS2 x4~x16:MS4
{0x0F12, 0x0040},	 //RMP option [6]1: RES gain
{0x0F12, 0x464E},	 //[14]msoff_en [13:8]off_rst [7:0]adc_sat
{0x0F12, 0x0240},	 //bist_sig_width_e
{0x0F12, 0x0240},	 //bist_sig_width_o
{0x0F12, 0x0040},	 //[9]dbs_bist_en [8:0]bist_rst_width
{0x0F12, 0x1000},	 //[15]aac_en [14]GCLK_DIV2_EN [13:10]dl_cont [9:8]dbs_mode [7:0]dbs_option
{0x0F12, 0x55cc},	 //bias [15:12]pix [11:8]pix_bst [7:4]comp2 [3:0]comp1
{0x0F12, 0xD000},	 //[15:8]clp_lvl [7:0]ref_option [5]pix_bst_en
{0x0F12, 0x0010},	 //[7:0]monit
{0x0F12, 0x0202},	 //[15:8]dbr_tune_tgsl [7:0]dbr_tune_pix
{0x0F12, 0x0401},	 //[15:8]dbr_tune_ntg [7:0]dbr_tune_rg
{0x0F12, 0x0022},	 //[15:8]reg_option [7:4]rosc_tune_ncp [3:0]rosc_tune_cp
{0x0F12, 0x0088},	 //PD [8]inrush_ctrl [7]fblv [6]reg_ntg [5]reg_tgsl [4]reg_rg [3]reg_pix [2]ncp_rosc [1]cp_rosc [0]cp
{0x0F12, 0x009F},	 //[9]capa_ctrl_en [8:7]fb_lv [6:5]dbr_clk_sel [4:0]cp_capa
{0x0F12, 0x0000},	 //[15:0]blst_en_cintr
{0x0F12, 0x1800},	 //[11]blst_en [10]rfpn_test [9]sl_off [8]tx_off [7:0]rdv_option
{0x0F12, 0x0088},	 //[15:0]pmg_reg_tune
{0x0F12, 0x0000},	 //[15:1]analog_dummy [0]pd_reg_test
{0x0F12, 0x2428},	 //[13:11]srx_gap1 [10:8]srx_gap0 [7:0]stx_gap
{0x0F12, 0x0000},	 //[0]atx_option
{0x0F12, 0x03EE},	 //aig_avg_half
{0x0F12, 0x0000},	 //[0]hvs_test_reg
{0x0F12, 0x0000},	 //[0]dbus_bist_auto
{0x0F12, 0x0000},	 //[7:0]dbr_option
{0x002A, 0xF552},
{0x0F12, 0x0708},	 //[7:0]lat_st [15:8]lat_width
{0x0F12, 0x080C},	 //[7:0]hold_st [15:8]hold_width

//For subsampling Size

{0x0028, 0x7000},
{0x002A, 0x18BC},
{0x0F12, 0x0004},
{0x0F12, 0x05B6},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0001},
{0x0F12, 0x05BA},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0007},
{0x0F12, 0x05BA},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x01F4},
{0x0F12, 0x024E},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x01F4},
{0x0F12, 0x05B6},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x01F4},
{0x0F12, 0x05BA},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x01F4},
{0x0F12, 0x024F},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0075},
{0x0F12, 0x00CF},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0075},
{0x0F12, 0x00D6},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0004},
{0x0F12, 0x01F4},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x00F0},
{0x0F12, 0x01F4},
{0x0F12, 0x029E},
{0x0F12, 0x05B2},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x01F8},
{0x0F12, 0x0228},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0208},
{0x0F12, 0x0238},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0218},
{0x0F12, 0x0238},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0001},
{0x0F12, 0x0009},
{0x0F12, 0x00DE},
{0x0F12, 0x05C0},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x00DF},
{0x0F12, 0x00E4},
{0x0F12, 0x01F8},
{0x0F12, 0x01FD},
{0x0F12, 0x05B6},
{0x0F12, 0x05BB},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x01F8},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0077},
{0x0F12, 0x007E},
{0x0F12, 0x024F},
{0x0F12, 0x025E},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},

 // For Capture

{0x0F12, 0x0004},
{0x0F12, 0x09D1},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0001},
{0x0F12, 0x09D5},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0008},
{0x0F12, 0x09D5},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02AA},
{0x0F12, 0x0326},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02AA},
{0x0F12, 0x09D1},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02AA},
{0x0F12, 0x09D5},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02AA},
{0x0F12, 0x0327},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0008},
{0x0F12, 0x0084},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0008},
{0x0F12, 0x008D},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0008},
{0x0F12, 0x02AA},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x00AA},
{0x0F12, 0x02AA},
{0x0F12, 0x03AD},
{0x0F12, 0x09CD},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02AE},
{0x0F12, 0x02DE},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02BE},
{0x0F12, 0x02EE},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02CE},
{0x0F12, 0x02EE},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0001},
{0x0F12, 0x0009},
{0x0F12, 0x0095},
{0x0F12, 0x09DB},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0096},
{0x0F12, 0x009B},
{0x0F12, 0x02AE},
{0x0F12, 0x02B3},
{0x0F12, 0x09D1},
{0x0F12, 0x09D6},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x02AE},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0009},
{0x0F12, 0x0010},
{0x0F12, 0x0327},
{0x0F12, 0x0336},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x0F12, 0x0000},
{0x002A, 0x1AF8},
{0x0F12, 0x5A3C},    //senHal_TuneStr_AngTuneData1_2_D000F400 register at subsampling
{0x002A, 0x1896},
{0x0F12, 0x0002},    //senHal_SamplingType	0002 03EE: PLA setting
{0x0F12, 0x0000},    //senHal_SamplingMode 0 : 2 PLA / 1 : 4PLA
{0x0F12, 0x0003},
{0x002A, 0x189E},
{0x0F12, 0x0FB0},
{0x002A, 0x18AC},
{0x0F12, 0x0060},
{0x0F12, 0x0060},
{0x0F12, 0x05C0},
{0x0F12, 0x05C0},
{0x002A, 0x1AEA},
{0x0F12, 0x8080},
{0x0F12, 0x0080},
{0x002A, 0x1AE0},
{0x0F12, 0x0000},
{0x002A, 0x1A72},
{0x0F12, 0x0000},
{0x002A, 0x18A2},
{0x0F12, 0x0004},
{0x002A, 0x1A6A},
{0x0F12, 0x009A},
{0x002A, 0x385E},
{0x0F12, 0x024C},
{0x002A, 0x0EE6},
{0x0F12, 0x0000},
{0x002A, 0x1B2A},
{0x0F12, 0x0300},
{0x0F12, 0x00D6},
{0x0F12, 0x008D},
{0x0F12, 0x00CF},
{0x0F12, 0x0084},

//==================================================================================


//=================================================================================
// 05.Trap and Patch
//=================================================================================
// Start of Patch data
{0x0028, 0x7000},
{0x002A, 0x3AF8},
{0x0F12, 0xB570},	 // 70003AF8
{0x0F12, 0x4B39},	 // 70003AFA
{0x0F12, 0x4939},	 // 70003AFC
{0x0F12, 0x483A},	 // 70003AFE
{0x0F12, 0x2200},	 // 70003B00
{0x0F12, 0xC008},	 // 70003B02
{0x0F12, 0x6001},	 // 70003B04
{0x0F12, 0x4939},	 // 70003B06
{0x0F12, 0x4839},	 // 70003B08
{0x0F12, 0x2401},	 // 70003B0A
{0x0F12, 0xF000},	 // 70003B0C
{0x0F12, 0xFBEC},	 // 70003B0E
{0x0F12, 0x4938},	 // 70003B10
{0x0F12, 0x4839},	 // 70003B12
{0x0F12, 0x2502},	 // 70003B14
{0x0F12, 0x0022},	 // 70003B16
{0x0F12, 0xF000},	 // 70003B18
{0x0F12, 0xFBE6},	 // 70003B1A
{0x0F12, 0x4837},	 // 70003B1C
{0x0F12, 0x0261},	 // 70003B1E
{0x0F12, 0x8001},	 // 70003B20
{0x0F12, 0x2100},	 // 70003B22
{0x0F12, 0x8041},	 // 70003B24
{0x0F12, 0x4936},	 // 70003B26
{0x0F12, 0x4836},	 // 70003B28
{0x0F12, 0x6041},	 // 70003B2A
{0x0F12, 0x4936},	 // 70003B2C
{0x0F12, 0x4837},	 // 70003B2E
{0x0F12, 0x2403},	 // 70003B30
{0x0F12, 0x002A},	 // 70003B32
{0x0F12, 0xF000},	 // 70003B34
{0x0F12, 0xFBD8},	 // 70003B36
{0x0F12, 0x4832},	 // 70003B38
{0x0F12, 0x4935},	 // 70003B3A
{0x0F12, 0x30C0},	 // 70003B3C
{0x0F12, 0x63C1},	 // 70003B3E
{0x0F12, 0x4930},	 // 70003B40
{0x0F12, 0x4834},	 // 70003B42
{0x0F12, 0x3980},	 // 70003B44
{0x0F12, 0x6408},	 // 70003B46
{0x0F12, 0x4833},	 // 70003B48
{0x0F12, 0x4934},	 // 70003B4A
{0x0F12, 0x6388},	 // 70003B4C
{0x0F12, 0x4934},	 // 70003B4E
{0x0F12, 0x4834},	 // 70003B50
{0x0F12, 0x0022},	 // 70003B52
{0x0F12, 0x2504},	 // 70003B54
{0x0F12, 0xF000},	 // 70003B56
{0x0F12, 0xFBC7},	 // 70003B58
{0x0F12, 0x4933},	 // 70003B5A
{0x0F12, 0x4833},	 // 70003B5C
{0x0F12, 0x2405},	 // 70003B5E
{0x0F12, 0x002A},	 // 70003B60
{0x0F12, 0xF000},	 // 70003B62
{0x0F12, 0xF881},	 // 70003B64
{0x0F12, 0x491F},	 // 70003B66
{0x0F12, 0x4830},	 // 70003B68
{0x0F12, 0x0022},	 // 70003B6A
{0x0F12, 0x2506},	 // 70003B6C
{0x0F12, 0x39B6},	 // 70003B6E
{0x0F12, 0x1D80},	 // 70003B70
{0x0F12, 0xF000},	 // 70003B72
{0x0F12, 0xF879},	 // 70003B74
{0x0F12, 0x482D},	 // 70003B76
{0x0F12, 0x492D},	 // 70003B78
{0x0F12, 0x2407},	 // 70003B7A
{0x0F12, 0x002A},	 // 70003B7C
{0x0F12, 0x300C},	 // 70003B7E
{0x0F12, 0xF000},	 // 70003B80
{0x0F12, 0xF872},	 // 70003B82
{0x0F12, 0x4829},	 // 70003B84
{0x0F12, 0x492B},	 // 70003B86
{0x0F12, 0x0022},	 // 70003B88
{0x0F12, 0x2508},	 // 70003B8A
{0x0F12, 0x3010},	 // 70003B8C
{0x0F12, 0xF000},	 // 70003B8E
{0x0F12, 0xF86B},	 // 70003B90
{0x0F12, 0x4929},	 // 70003B92
{0x0F12, 0x4829},	 // 70003B94
{0x0F12, 0x2409},	 // 70003B96
{0x0F12, 0x002A},	 // 70003B98
{0x0F12, 0xF000},	 // 70003B9A
{0x0F12, 0xFBA5},	 // 70003B9C
{0x0F12, 0x4928},	 // 70003B9E
{0x0F12, 0x4828},	 // 70003BA0
{0x0F12, 0x0022},	 // 70003BA2
{0x0F12, 0x250A},	 // 70003BA4
{0x0F12, 0xF000},	 // 70003BA6
{0x0F12, 0xFB9F},	 // 70003BA8
{0x0F12, 0x4927},	 // 70003BAA
{0x0F12, 0x4827},	 // 70003BAC
{0x0F12, 0x240B},	 // 70003BAE
{0x0F12, 0x002A},	 // 70003BB0
{0x0F12, 0xF000},	 // 70003BB2
{0x0F12, 0xFB99},	 // 70003BB4
{0x0F12, 0x4926},	 // 70003BB6
{0x0F12, 0x4826},	 // 70003BB8
{0x0F12, 0x0022},	 // 70003BBA
{0x0F12, 0x250C},	 // 70003BBC
{0x0F12, 0xF000},	 // 70003BBE
{0x0F12, 0xFB93},	 // 70003BC0
{0x0F12, 0x4925},	 // 70003BC2
{0x0F12, 0x4825},	 // 70003BC4
{0x0F12, 0x240D},	 // 70003BC6
{0x0F12, 0x002A},	 // 70003BC8
{0x0F12, 0xF000},	 // 70003BCA
{0x0F12, 0xFB8D},	 // 70003BCC
{0x0F12, 0x4924},	 // 70003BCE
{0x0F12, 0x4824},	 // 70003BD0
{0x0F12, 0x0022},	 // 70003BD2
{0x0F12, 0xF000},	 // 70003BD4
{0x0F12, 0xFB88},	 // 70003BD6
{0x0F12, 0xBC70},	 // 70003BD8
{0x0F12, 0xBC08},	 // 70003BDA
{0x0F12, 0x4718},	 // 70003BDC
{0x0F12, 0x0000},	 // 70003BDE
{0x0F12, 0x017B},	 // 70003BE0
{0x0F12, 0x4EC2},	 // 70003BE2
{0x0F12, 0x037F},	 // 70003BE4
{0x0F12, 0x0000},	 // 70003BE6
{0x0F12, 0x1F90},	 // 70003BE8
{0x0F12, 0x7000},	 // 70003BEA
{0x0F12, 0x3C81},	 // 70003BEC
{0x0F12, 0x7000},	 // 70003BEE
{0x0F12, 0xE38B},	 // 70003BF0
{0x0F12, 0x0000},	 // 70003BF2
{0x0F12, 0x3CB9},	 // 70003BF4
{0x0F12, 0x7000},	 // 70003BF6
{0x0F12, 0xC3B1},	 // 70003BF8
{0x0F12, 0x0000},	 // 70003BFA
{0x0F12, 0x4780},	 // 70003BFC
{0x0F12, 0x7000},	 // 70003BFE
{0x0F12, 0x3D17},	 // 70003C00
{0x0F12, 0x7000},	 // 70003C02
{0x0F12, 0x0080},	 // 70003C04
{0x0F12, 0x7000},	 // 70003C06
{0x0F12, 0x3D53},	 // 70003C08
{0x0F12, 0x7000},	 // 70003C0A
{0x0F12, 0xB49D},	 // 70003C0C
{0x0F12, 0x0000},	 // 70003C0E
{0x0F12, 0x3DFF},	 // 70003C10
{0x0F12, 0x7000},	 // 70003C12
{0x0F12, 0x3DB3},	 // 70003C14
{0x0F12, 0x7000},	 // 70003C16
{0x0F12, 0xFFFF},	 // 70003C18
{0x0F12, 0x00FF},	 // 70003C1A
{0x0F12, 0x17E0},	 // 70003C1C
{0x0F12, 0x7000},	 // 70003C1E
{0x0F12, 0x3F7B},	 // 70003C20
{0x0F12, 0x7000},	 // 70003C22
{0x0F12, 0x053D},	 // 70003C24
{0x0F12, 0x0000},	 // 70003C26
{0x0F12, 0x0000},	 // 70003C28
{0x0F12, 0x0A89},	 // 70003C2A
{0x0F12, 0x6CD2},	 // 70003C2C
{0x0F12, 0x0000},	 // 70003C2E
{0x0F12, 0x0000},	 // 70003C30
{0x0F12, 0x0A9A},	 // 70003C32
{0x0F12, 0x0000},	 // 70003C34
{0x0F12, 0x02D2},	 // 70003C36
{0x0F12, 0x3FC9},	 // 70003C38
{0x0F12, 0x7000},	 // 70003C3A
{0x0F12, 0x9E65},	 // 70003C3C
{0x0F12, 0x0000},	 // 70003C3E
{0x0F12, 0x403D},	 // 70003C40
{0x0F12, 0x7000},	 // 70003C42
{0x0F12, 0x7C49},	 // 70003C44
{0x0F12, 0x0000},	 // 70003C46
{0x0F12, 0x40B1},	 // 70003C48
{0x0F12, 0x7000},	 // 70003C4A
{0x0F12, 0x7C63},	 // 70003C4C
{0x0F12, 0x0000},	 // 70003C4E
{0x0F12, 0x40CD},	 // 70003C50
{0x0F12, 0x7000},	 // 70003C52
{0x0F12, 0x8F01},	 // 70003C54
{0x0F12, 0x0000},	 // 70003C56
{0x0F12, 0x416F},	 // 70003C58
{0x0F12, 0x7000},	 // 70003C5A
{0x0F12, 0x7F3F},	 // 70003C5C
{0x0F12, 0x0000},	 // 70003C5E
{0x0F12, 0x41FD},	 // 70003C60
{0x0F12, 0x7000},	 // 70003C62
{0x0F12, 0x98C5},	 // 70003C64
{0x0F12, 0x0000},	 // 70003C66
{0x0F12, 0xB570},	 // 70003C68
{0x0F12, 0x000C},	 // 70003C6A
{0x0F12, 0x0015},	 // 70003C6C
{0x0F12, 0x0029},	 // 70003C6E
{0x0F12, 0xF000},	 // 70003C70
{0x0F12, 0xFB42},	 // 70003C72
{0x0F12, 0x49F8},	 // 70003C74
{0x0F12, 0x00A8},	 // 70003C76
{0x0F12, 0x500C},	 // 70003C78
{0x0F12, 0xBC70},	 // 70003C7A
{0x0F12, 0xBC08},	 // 70003C7C
{0x0F12, 0x4718},	 // 70003C7E
{0x0F12, 0x6808},	 // 70003C80
{0x0F12, 0x0400},	 // 70003C82
{0x0F12, 0x0C00},	 // 70003C84
{0x0F12, 0x6849},	 // 70003C86
{0x0F12, 0x0409},	 // 70003C88
{0x0F12, 0x0C09},	 // 70003C8A
{0x0F12, 0x4AF3},	 // 70003C8C
{0x0F12, 0x8992},	 // 70003C8E
{0x0F12, 0x2A00},	 // 70003C90
{0x0F12, 0xD00D},	 // 70003C92
{0x0F12, 0x2300},	 // 70003C94
{0x0F12, 0x1A89},	 // 70003C96
{0x0F12, 0xD400},	 // 70003C98
{0x0F12, 0x000B},	 // 70003C9A
{0x0F12, 0x0419},	 // 70003C9C
{0x0F12, 0x0C09},	 // 70003C9E
{0x0F12, 0x23FF},	 // 70003CA0
{0x0F12, 0x33C1},	 // 70003CA2
{0x0F12, 0x1810},	 // 70003CA4
{0x0F12, 0x4298},	 // 70003CA6
{0x0F12, 0xD800},	 // 70003CA8
{0x0F12, 0x0003},	 // 70003CAA
{0x0F12, 0x0418},	 // 70003CAC
{0x0F12, 0x0C00},	 // 70003CAE
{0x0F12, 0x4AEB},	 // 70003CB0
{0x0F12, 0x8150},	 // 70003CB2
{0x0F12, 0x8191},	 // 70003CB4
{0x0F12, 0x4770},	 // 70003CB6
{0x0F12, 0xB5F3},	 // 70003CB8
{0x0F12, 0x0004},	 // 70003CBA
{0x0F12, 0xB081},	 // 70003CBC
{0x0F12, 0x9802},	 // 70003CBE
{0x0F12, 0x6800},	 // 70003CC0
{0x0F12, 0x0600},	 // 70003CC2
{0x0F12, 0x0E00},	 // 70003CC4
{0x0F12, 0x2201},	 // 70003CC6
{0x0F12, 0x0015},	 // 70003CC8
{0x0F12, 0x0021},	 // 70003CCA
{0x0F12, 0x3910},	 // 70003CCC
{0x0F12, 0x408A},	 // 70003CCE
{0x0F12, 0x40A5},	 // 70003CD0
{0x0F12, 0x4FE4},	 // 70003CD2
{0x0F12, 0x0016},	 // 70003CD4
{0x0F12, 0x2C10},	 // 70003CD6
{0x0F12, 0xDA03},	 // 70003CD8
{0x0F12, 0x8839},	 // 70003CDA
{0x0F12, 0x43A9},	 // 70003CDC
{0x0F12, 0x8039},	 // 70003CDE
{0x0F12, 0xE002},	 // 70003CE0
{0x0F12, 0x8879},	 // 70003CE2
{0x0F12, 0x43B1},	 // 70003CE4
{0x0F12, 0x8079},	 // 70003CE6
{0x0F12, 0xF000},	 // 70003CE8
{0x0F12, 0xFB0E},	 // 70003CEA
{0x0F12, 0x2C10},	 // 70003CEC
{0x0F12, 0xDA03},	 // 70003CEE
{0x0F12, 0x8839},	 // 70003CF0
{0x0F12, 0x4329},	 // 70003CF2
{0x0F12, 0x8039},	 // 70003CF4
{0x0F12, 0xE002},	 // 70003CF6
{0x0F12, 0x8879},	 // 70003CF8
{0x0F12, 0x4331},	 // 70003CFA
{0x0F12, 0x8079},	 // 70003CFC
{0x0F12, 0x49DA},	 // 70003CFE
{0x0F12, 0x8809},	 // 70003D00
{0x0F12, 0x2900},	 // 70003D02
{0x0F12, 0xD102},	 // 70003D04
{0x0F12, 0xF000},	 // 70003D06
{0x0F12, 0xFB07},	 // 70003D08
{0x0F12, 0x2000},	 // 70003D0A
{0x0F12, 0x9902},	 // 70003D0C
{0x0F12, 0x6008},	 // 70003D0E
{0x0F12, 0xBCFE},	 // 70003D10
{0x0F12, 0xBC08},	 // 70003D12
{0x0F12, 0x4718},	 // 70003D14
{0x0F12, 0xB538},	 // 70003D16
{0x0F12, 0x9C04},	 // 70003D18
{0x0F12, 0x0015},	 // 70003D1A
{0x0F12, 0x002A},	 // 70003D1C
{0x0F12, 0x9400},	 // 70003D1E
{0x0F12, 0xF000},	 // 70003D20
{0x0F12, 0xFB02},	 // 70003D22
{0x0F12, 0x4AD1},	 // 70003D24
{0x0F12, 0x8811},	 // 70003D26
{0x0F12, 0x2900},	 // 70003D28
{0x0F12, 0xD00F},	 // 70003D2A
{0x0F12, 0x8820},	 // 70003D2C
{0x0F12, 0x4281},	 // 70003D2E
{0x0F12, 0xD20C},	 // 70003D30
{0x0F12, 0x8861},	 // 70003D32
{0x0F12, 0x8853},	 // 70003D34
{0x0F12, 0x4299},	 // 70003D36
{0x0F12, 0xD200},	 // 70003D38
{0x0F12, 0x1E40},	 // 70003D3A
{0x0F12, 0x0400},	 // 70003D3C
{0x0F12, 0x0C00},	 // 70003D3E
{0x0F12, 0x8020},	 // 70003D40
{0x0F12, 0x8851},	 // 70003D42
{0x0F12, 0x8061},	 // 70003D44
{0x0F12, 0x4368},	 // 70003D46
{0x0F12, 0x1840},	 // 70003D48
{0x0F12, 0x6060},	 // 70003D4A
{0x0F12, 0xBC38},	 // 70003D4C
{0x0F12, 0xBC08},	 // 70003D4E
{0x0F12, 0x4718},	 // 70003D50
{0x0F12, 0xB5F8},	 // 70003D52
{0x0F12, 0x0004},	 // 70003D54
{0x0F12, 0x6808},	 // 70003D56
{0x0F12, 0x0400},	 // 70003D58
{0x0F12, 0x0C00},	 // 70003D5A
{0x0F12, 0x2201},	 // 70003D5C
{0x0F12, 0x0015},	 // 70003D5E
{0x0F12, 0x0021},	 // 70003D60
{0x0F12, 0x3910},	 // 70003D62
{0x0F12, 0x408A},	 // 70003D64
{0x0F12, 0x40A5},	 // 70003D66
{0x0F12, 0x4FBE},	 // 70003D68
{0x0F12, 0x0016},	 // 70003D6A
{0x0F12, 0x2C10},	 // 70003D6C
{0x0F12, 0xDA03},	 // 70003D6E
{0x0F12, 0x8839},	 // 70003D70
{0x0F12, 0x43A9},	 // 70003D72
{0x0F12, 0x8039},	 // 70003D74
{0x0F12, 0xE002},	 // 70003D76
{0x0F12, 0x8879},	 // 70003D78
{0x0F12, 0x43B1},	 // 70003D7A
{0x0F12, 0x8079},	 // 70003D7C
{0x0F12, 0xF000},	 // 70003D7E
{0x0F12, 0xFADB},	 // 70003D80
{0x0F12, 0x2C10},	 // 70003D82
{0x0F12, 0xDA03},	 // 70003D84
{0x0F12, 0x8838},	 // 70003D86
{0x0F12, 0x4328},	 // 70003D88
{0x0F12, 0x8038},	 // 70003D8A
{0x0F12, 0xE002},	 // 70003D8C
{0x0F12, 0x8878},	 // 70003D8E
{0x0F12, 0x4330},	 // 70003D90
{0x0F12, 0x8078},	 // 70003D92
{0x0F12, 0x48B6},	 // 70003D94
{0x0F12, 0x8800},	 // 70003D96
{0x0F12, 0x0400},	 // 70003D98
{0x0F12, 0xD507},	 // 70003D9A
{0x0F12, 0x4BB5},	 // 70003D9C
{0x0F12, 0x7819},	 // 70003D9E
{0x0F12, 0x4AB5},	 // 70003DA0
{0x0F12, 0x7810},	 // 70003DA2
{0x0F12, 0x7018},	 // 70003DA4
{0x0F12, 0x7011},	 // 70003DA6
{0x0F12, 0x49B4},	 // 70003DA8
{0x0F12, 0x8188},	 // 70003DAA
{0x0F12, 0xBCF8},	 // 70003DAC
{0x0F12, 0xBC08},	 // 70003DAE
{0x0F12, 0x4718},	 // 70003DB0
{0x0F12, 0xB538},	 // 70003DB2
{0x0F12, 0x48B2},	 // 70003DB4
{0x0F12, 0x4669},	 // 70003DB6
{0x0F12, 0xF000},	 // 70003DB8
{0x0F12, 0xFAC6},	 // 70003DBA
{0x0F12, 0x48B1},	 // 70003DBC
{0x0F12, 0x49B0},	 // 70003DBE
{0x0F12, 0x69C2},	 // 70003DC0
{0x0F12, 0x2400},	 // 70003DC2
{0x0F12, 0x31A8},	 // 70003DC4
{0x0F12, 0x2A00},	 // 70003DC6
{0x0F12, 0xD008},	 // 70003DC8
{0x0F12, 0x61C4},	 // 70003DCA
{0x0F12, 0x684A},	 // 70003DCC
{0x0F12, 0x6242},	 // 70003DCE
{0x0F12, 0x6282},	 // 70003DD0
{0x0F12, 0x466B},	 // 70003DD2
{0x0F12, 0x881A},	 // 70003DD4
{0x0F12, 0x6302},	 // 70003DD6
{0x0F12, 0x885A},	 // 70003DD8
{0x0F12, 0x6342},	 // 70003DDA
{0x0F12, 0x6A02},	 // 70003DDC
{0x0F12, 0x2A00},	 // 70003DDE
{0x0F12, 0xD00A},	 // 70003DE0
{0x0F12, 0x6204},	 // 70003DE2
{0x0F12, 0x6849},	 // 70003DE4
{0x0F12, 0x6281},	 // 70003DE6
{0x0F12, 0x466B},	 // 70003DE8
{0x0F12, 0x8819},	 // 70003DEA
{0x0F12, 0x6301},	 // 70003DEC
{0x0F12, 0x8859},	 // 70003DEE
{0x0F12, 0x6341},	 // 70003DF0
{0x0F12, 0x49A5},	 // 70003DF2
{0x0F12, 0x88C9},	 // 70003DF4
{0x0F12, 0x63C1},	 // 70003DF6
{0x0F12, 0xF000},	 // 70003DF8
{0x0F12, 0xFAAE},	 // 70003DFA
{0x0F12, 0xE7A6},	 // 70003DFC
{0x0F12, 0xB5F0},	 // 70003DFE
{0x0F12, 0xB08B},	 // 70003E00
{0x0F12, 0x20FF},	 // 70003E02
{0x0F12, 0x1C40},	 // 70003E04
{0x0F12, 0x49A1},	 // 70003E06
{0x0F12, 0x89CC},	 // 70003E08
{0x0F12, 0x4E9E},	 // 70003E0A
{0x0F12, 0x6AB1},	 // 70003E0C
{0x0F12, 0x4284},	 // 70003E0E
{0x0F12, 0xD101},	 // 70003E10
{0x0F12, 0x489F},	 // 70003E12
{0x0F12, 0x6081},	 // 70003E14
{0x0F12, 0x6A70},	 // 70003E16
{0x0F12, 0x0200},	 // 70003E18
{0x0F12, 0xF000},	 // 70003E1A
{0x0F12, 0xFAA5},	 // 70003E1C
{0x0F12, 0x0400},	 // 70003E1E
{0x0F12, 0x0C00},	 // 70003E20
{0x0F12, 0x4A96},	 // 70003E22
{0x0F12, 0x8A11},	 // 70003E24
{0x0F12, 0x9109},	 // 70003E26
{0x0F12, 0x2101},	 // 70003E28
{0x0F12, 0x0349},	 // 70003E2A
{0x0F12, 0x4288},	 // 70003E2C
{0x0F12, 0xD200},	 // 70003E2E
{0x0F12, 0x0001},	 // 70003E30
{0x0F12, 0x4A92},	 // 70003E32
{0x0F12, 0x8211},	 // 70003E34
{0x0F12, 0x4D97},	 // 70003E36
{0x0F12, 0x8829},	 // 70003E38
{0x0F12, 0x9108},	 // 70003E3A
{0x0F12, 0x4A8B},	 // 70003E3C
{0x0F12, 0x2303},	 // 70003E3E
{0x0F12, 0x3222},	 // 70003E40
{0x0F12, 0x1F91},	 // 70003E42
{0x0F12, 0xF000},	 // 70003E44
{0x0F12, 0xFA96},	 // 70003E46
{0x0F12, 0x8028},	 // 70003E48
{0x0F12, 0x488E},	 // 70003E4A
{0x0F12, 0x4987},	 // 70003E4C
{0x0F12, 0x6BC2},	 // 70003E4E
{0x0F12, 0x6AC0},	 // 70003E50
{0x0F12, 0x4282},	 // 70003E52
{0x0F12, 0xD201},	 // 70003E54
{0x0F12, 0x8CC8},	 // 70003E56
{0x0F12, 0x8028},	 // 70003E58
{0x0F12, 0x88E8},	 // 70003E5A
{0x0F12, 0x9007},	 // 70003E5C
{0x0F12, 0x2240},	 // 70003E5E
{0x0F12, 0x4310},	 // 70003E60
{0x0F12, 0x80E8},	 // 70003E62
{0x0F12, 0x2000},	 // 70003E64
{0x0F12, 0x0041},	 // 70003E66
{0x0F12, 0x194B},	 // 70003E68
{0x0F12, 0x001E},	 // 70003E6A
{0x0F12, 0x3680},	 // 70003E6C
{0x0F12, 0x8BB2},	 // 70003E6E
{0x0F12, 0xAF04},	 // 70003E70
{0x0F12, 0x527A},	 // 70003E72
{0x0F12, 0x4A7D},	 // 70003E74
{0x0F12, 0x188A},	 // 70003E76
{0x0F12, 0x8897},	 // 70003E78
{0x0F12, 0x83B7},	 // 70003E7A
{0x0F12, 0x33A0},	 // 70003E7C
{0x0F12, 0x891F},	 // 70003E7E
{0x0F12, 0xAE01},	 // 70003E80
{0x0F12, 0x5277},	 // 70003E82
{0x0F12, 0x8A11},	 // 70003E84
{0x0F12, 0x8119},	 // 70003E86
{0x0F12, 0x1C40},	 // 70003E88
{0x0F12, 0x0400},	 // 70003E8A
{0x0F12, 0x0C00},	 // 70003E8C
{0x0F12, 0x2806},	 // 70003E8E
{0x0F12, 0xD3E9},	 // 70003E90
{0x0F12, 0xF000},	 // 70003E92
{0x0F12, 0xFA77},	 // 70003E94
{0x0F12, 0xF000},	 // 70003E96
{0x0F12, 0xFA7D},	 // 70003E98
{0x0F12, 0x4F79},	 // 70003E9A
{0x0F12, 0x37A8},	 // 70003E9C
{0x0F12, 0x2800},	 // 70003E9E
{0x0F12, 0xD10A},	 // 70003EA0
{0x0F12, 0x1FE0},	 // 70003EA2
{0x0F12, 0x38FD},	 // 70003EA4
{0x0F12, 0xD001},	 // 70003EA6
{0x0F12, 0x1CC0},	 // 70003EA8
{0x0F12, 0xD105},	 // 70003EAA
{0x0F12, 0x4874},	 // 70003EAC
{0x0F12, 0x8829},	 // 70003EAE
{0x0F12, 0x3818},	 // 70003EB0
{0x0F12, 0x6840},	 // 70003EB2
{0x0F12, 0x4348},	 // 70003EB4
{0x0F12, 0x6078},	 // 70003EB6
{0x0F12, 0x4972},	 // 70003EB8
{0x0F12, 0x6878},	 // 70003EBA
{0x0F12, 0x6B89},	 // 70003EBC
{0x0F12, 0x4288},	 // 70003EBE
{0x0F12, 0xD300},	 // 70003EC0
{0x0F12, 0x0008},	 // 70003EC2
{0x0F12, 0x6078},	 // 70003EC4
{0x0F12, 0x2000},	 // 70003EC6
{0x0F12, 0x0041},	 // 70003EC8
{0x0F12, 0xAA04},	 // 70003ECA
{0x0F12, 0x5A53},	 // 70003ECC
{0x0F12, 0x194A},	 // 70003ECE
{0x0F12, 0x269C},	 // 70003ED0
{0x0F12, 0x52B3},	 // 70003ED2
{0x0F12, 0xAB01},	 // 70003ED4
{0x0F12, 0x5A59},	 // 70003ED6
{0x0F12, 0x32A0},	 // 70003ED8
{0x0F12, 0x8111},	 // 70003EDA
{0x0F12, 0x1C40},	 // 70003EDC
{0x0F12, 0x0400},	 // 70003EDE
{0x0F12, 0x0C00},	 // 70003EE0
{0x0F12, 0x2806},	 // 70003EE2
{0x0F12, 0xD3F0},	 // 70003EE4
{0x0F12, 0x4965},	 // 70003EE6
{0x0F12, 0x9809},	 // 70003EE8
{0x0F12, 0x8208},	 // 70003EEA
{0x0F12, 0x9808},	 // 70003EEC
{0x0F12, 0x8028},	 // 70003EEE
{0x0F12, 0x9807},	 // 70003EF0
{0x0F12, 0x80E8},	 // 70003EF2
{0x0F12, 0x1FE0},	 // 70003EF4
{0x0F12, 0x38FD},	 // 70003EF6
{0x0F12, 0xD13B},	 // 70003EF8
{0x0F12, 0x4D64},	 // 70003EFA
{0x0F12, 0x89E8},	 // 70003EFC
{0x0F12, 0x1FC1},	 // 70003EFE
{0x0F12, 0x39FF},	 // 70003F00
{0x0F12, 0xD136},	 // 70003F02
{0x0F12, 0x4C5F},	 // 70003F04
{0x0F12, 0x8AE0},	 // 70003F06
{0x0F12, 0xF000},	 // 70003F08
{0x0F12, 0xFA4C},	 // 70003F0A
{0x0F12, 0x0006},	 // 70003F0C
{0x0F12, 0x8B20},	 // 70003F0E
{0x0F12, 0xF000},	 // 70003F10
{0x0F12, 0xFA50},	 // 70003F12
{0x0F12, 0x9000},	 // 70003F14
{0x0F12, 0x6AA1},	 // 70003F16
{0x0F12, 0x6878},	 // 70003F18
{0x0F12, 0x1809},	 // 70003F1A
{0x0F12, 0x0200},	 // 70003F1C
{0x0F12, 0xF000},	 // 70003F1E
{0x0F12, 0xFA23},	 // 70003F20
{0x0F12, 0x0400},	 // 70003F22
{0x0F12, 0x0C00},	 // 70003F24
{0x0F12, 0x0022},	 // 70003F26
{0x0F12, 0x3246},	 // 70003F28
{0x0F12, 0x0011},	 // 70003F2A
{0x0F12, 0x310A},	 // 70003F2C
{0x0F12, 0x2305},	 // 70003F2E
{0x0F12, 0xF000},	 // 70003F30
{0x0F12, 0xFA20},	 // 70003F32
{0x0F12, 0x66E8},	 // 70003F34
{0x0F12, 0x6B23},	 // 70003F36
{0x0F12, 0x0002},	 // 70003F38
{0x0F12, 0x0031},	 // 70003F3A
{0x0F12, 0x0018},	 // 70003F3C
{0x0F12, 0xF000},	 // 70003F3E
{0x0F12, 0xFA41},	 // 70003F40
{0x0F12, 0x466B},	 // 70003F42
{0x0F12, 0x8518},	 // 70003F44
{0x0F12, 0x6EEA},	 // 70003F46
{0x0F12, 0x6B60},	 // 70003F48
{0x0F12, 0x9900},	 // 70003F4A
{0x0F12, 0xF000},	 // 70003F4C
{0x0F12, 0xFA3A},	 // 70003F4E
{0x0F12, 0x466B},	 // 70003F50
{0x0F12, 0x8558},	 // 70003F52
{0x0F12, 0x0029},	 // 70003F54
{0x0F12, 0x980A},	 // 70003F56
{0x0F12, 0x3170},	 // 70003F58
{0x0F12, 0xF000},	 // 70003F5A
{0x0F12, 0xFA3B},	 // 70003F5C
{0x0F12, 0x0028},	 // 70003F5E
{0x0F12, 0x3060},	 // 70003F60
{0x0F12, 0x8A02},	 // 70003F62
{0x0F12, 0x4946},	 // 70003F64
{0x0F12, 0x3128},	 // 70003F66
{0x0F12, 0x808A},	 // 70003F68
{0x0F12, 0x8A42},	 // 70003F6A
{0x0F12, 0x80CA},	 // 70003F6C
{0x0F12, 0x8A80},	 // 70003F6E
{0x0F12, 0x8108},	 // 70003F70
{0x0F12, 0xB00B},	 // 70003F72
{0x0F12, 0xBCF0},	 // 70003F74
{0x0F12, 0xBC08},	 // 70003F76
{0x0F12, 0x4718},	 // 70003F78
{0x0F12, 0xB570},	 // 70003F7A
{0x0F12, 0x2400},	 // 70003F7C
{0x0F12, 0x4D46},	 // 70003F7E
{0x0F12, 0x4846},	 // 70003F80
{0x0F12, 0x8881},	 // 70003F82
{0x0F12, 0x4846},	 // 70003F84
{0x0F12, 0x8041},	 // 70003F86
{0x0F12, 0x2101},	 // 70003F88
{0x0F12, 0x8001},	 // 70003F8A
{0x0F12, 0xF000},	 // 70003F8C
{0x0F12, 0xFA2A},	 // 70003F8E
{0x0F12, 0x4842},	 // 70003F90
{0x0F12, 0x3820},	 // 70003F92
{0x0F12, 0x8BC0},	 // 70003F94
{0x0F12, 0xF000},	 // 70003F96
{0x0F12, 0xFA2D},	 // 70003F98
{0x0F12, 0x4B42},	 // 70003F9A
{0x0F12, 0x220D},	 // 70003F9C
{0x0F12, 0x0712},	 // 70003F9E
{0x0F12, 0x18A8},	 // 70003FA0
{0x0F12, 0x8806},	 // 70003FA2
{0x0F12, 0x00E1},	 // 70003FA4
{0x0F12, 0x18C9},	 // 70003FA6
{0x0F12, 0x81CE},	 // 70003FA8
{0x0F12, 0x8846},	 // 70003FAA
{0x0F12, 0x818E},	 // 70003FAC
{0x0F12, 0x8886},	 // 70003FAE
{0x0F12, 0x824E},	 // 70003FB0
{0x0F12, 0x88C0},	 // 70003FB2
{0x0F12, 0x8208},	 // 70003FB4
{0x0F12, 0x3508},	 // 70003FB6
{0x0F12, 0x042D},	 // 70003FB8
{0x0F12, 0x0C2D},	 // 70003FBA
{0x0F12, 0x1C64},	 // 70003FBC
{0x0F12, 0x0424},	 // 70003FBE
{0x0F12, 0x0C24},	 // 70003FC0
{0x0F12, 0x2C07},	 // 70003FC2
{0x0F12, 0xD3EC},	 // 70003FC4
{0x0F12, 0xE658},	 // 70003FC6
{0x0F12, 0xB510},	 // 70003FC8
{0x0F12, 0x4834},	 // 70003FCA
{0x0F12, 0x4C34},	 // 70003FCC
{0x0F12, 0x88C0},	 // 70003FCE
{0x0F12, 0x8060},	 // 70003FD0
{0x0F12, 0x2001},	 // 70003FD2
{0x0F12, 0x8020},	 // 70003FD4
{0x0F12, 0x4831},	 // 70003FD6
{0x0F12, 0x3820},	 // 70003FD8
{0x0F12, 0x8BC0},	 // 70003FDA
{0x0F12, 0xF000},	 // 70003FDC
{0x0F12, 0xFA0A},	 // 70003FDE
{0x0F12, 0x88E0},	 // 70003FE0
{0x0F12, 0x4A31},	 // 70003FE2
{0x0F12, 0x2800},	 // 70003FE4
{0x0F12, 0xD003},	 // 70003FE6
{0x0F12, 0x4930},	 // 70003FE8
{0x0F12, 0x8849},	 // 70003FEA
{0x0F12, 0x2900},	 // 70003FEC
{0x0F12, 0xD009},	 // 70003FEE
{0x0F12, 0x2001},	 // 70003FF0
{0x0F12, 0x03C0},	 // 70003FF2
{0x0F12, 0x8050},	 // 70003FF4
{0x0F12, 0x80D0},	 // 70003FF6
{0x0F12, 0x2000},	 // 70003FF8
{0x0F12, 0x8090},	 // 70003FFA
{0x0F12, 0x8110},	 // 70003FFC
{0x0F12, 0xBC10},	 // 70003FFE
{0x0F12, 0xBC08},	 // 70004000
{0x0F12, 0x4718},	 // 70004002
{0x0F12, 0x8050},	 // 70004004
{0x0F12, 0x8920},	 // 70004006
{0x0F12, 0x80D0},	 // 70004008
{0x0F12, 0x8960},	 // 7000400A
{0x0F12, 0x0400},	 // 7000400C
{0x0F12, 0x1400},	 // 7000400E
{0x0F12, 0x8090},	 // 70004010
{0x0F12, 0x89A1},	 // 70004012
{0x0F12, 0x0409},	 // 70004014
{0x0F12, 0x1409},	 // 70004016
{0x0F12, 0x8111},	 // 70004018
{0x0F12, 0x89E3},	 // 7000401A
{0x0F12, 0x8A24},	 // 7000401C
{0x0F12, 0x2B00},	 // 7000401E
{0x0F12, 0xD104},	 // 70004020
{0x0F12, 0x17C3},	 // 70004022
{0x0F12, 0x0F5B},	 // 70004024
{0x0F12, 0x1818},	 // 70004026
{0x0F12, 0x10C0},	 // 70004028
{0x0F12, 0x8090},	 // 7000402A
{0x0F12, 0x2C00},	 // 7000402C
{0x0F12, 0xD1E6},	 // 7000402E
{0x0F12, 0x17C8},	 // 70004030
{0x0F12, 0x0F40},	 // 70004032
{0x0F12, 0x1840},	 // 70004034
{0x0F12, 0x10C0},	 // 70004036
{0x0F12, 0x8110},	 // 70004038
{0x0F12, 0xE7E0},	 // 7000403A
{0x0F12, 0xB510},	 // 7000403C
{0x0F12, 0x000C},	 // 7000403E
{0x0F12, 0x4919},	 // 70004040
{0x0F12, 0x2204},	 // 70004042
{0x0F12, 0x6820},	 // 70004044
{0x0F12, 0x5E8A},	 // 70004046
{0x0F12, 0x0140},	 // 70004048
{0x0F12, 0x1A80},	 // 7000404A
{0x0F12, 0x0280},	 // 7000404C
{0x0F12, 0x8849},	 // 7000404E
{0x0F12, 0xF000},	 // 70004050
{0x0F12, 0xF9D8},	 // 70004052
{0x0F12, 0x6020},	 // 70004054
{0x0F12, 0xE7D2},	 // 70004056
{0x0F12, 0x38D4},	 // 70004058
{0x0F12, 0x7000},	 // 7000405A
{0x0F12, 0x17D0},	 // 7000405C
{0x0F12, 0x7000},	 // 7000405E
{0x0F12, 0x5000},	 // 70004060
{0x0F12, 0xD000},	 // 70004062
{0x0F12, 0x1100},	 // 70004064
{0x0F12, 0xD000},	 // 70004066
{0x0F12, 0x171A},	 // 70004068
{0x0F12, 0x7000},	 // 7000406A
{0x0F12, 0x4780},	 // 7000406C
{0x0F12, 0x7000},	 // 7000406E
{0x0F12, 0x2FCA},	 // 70004070
{0x0F12, 0x7000},	 // 70004072
{0x0F12, 0x2FC5},	 // 70004074
{0x0F12, 0x7000},	 // 70004076
{0x0F12, 0x2FC6},	 // 70004078
{0x0F12, 0x7000},	 // 7000407A
{0x0F12, 0x2ED8},	 // 7000407C
{0x0F12, 0x7000},	 // 7000407E
{0x0F12, 0x2BD0},	 // 70004080
{0x0F12, 0x7000},	 // 70004082
{0x0F12, 0x17E0},	 // 70004084
{0x0F12, 0x7000},	 // 70004086
{0x0F12, 0x2DE8},	 // 70004088
{0x0F12, 0x7000},	 // 7000408A
{0x0F12, 0x37E0},	 // 7000408C
{0x0F12, 0x7000},	 // 7000408E
{0x0F12, 0x210C},	 // 70004090
{0x0F12, 0x7000},	 // 70004092
{0x0F12, 0x1484},	 // 70004094
{0x0F12, 0x7000},	 // 70004096
{0x0F12, 0xA006},	 // 70004098
{0x0F12, 0x0000},	 // 7000409A
{0x0F12, 0x0724},	 // 7000409C
{0x0F12, 0x7000},	 // 7000409E
{0x0F12, 0xA000},	 // 700040A0
{0x0F12, 0xD000},	 // 700040A2
{0x0F12, 0x2270},	 // 700040A4
{0x0F12, 0x7000},	 // 700040A6
{0x0F12, 0x2558},	 // 700040A8
{0x0F12, 0x7000},	 // 700040AA
{0x0F12, 0x146C},	 // 700040AC
{0x0F12, 0x7000},	 // 700040AE
{0x0F12, 0xB510},	 // 700040B0
{0x0F12, 0x000C},	 // 700040B2
{0x0F12, 0x4983},	 // 700040B4
{0x0F12, 0x2208},	 // 700040B6
{0x0F12, 0x6820},	 // 700040B8
{0x0F12, 0x5E8A},	 // 700040BA
{0x0F12, 0x0140},	 // 700040BC
{0x0F12, 0x1A80},	 // 700040BE
{0x0F12, 0x0280},	 // 700040C0
{0x0F12, 0x88C9},	 // 700040C2
{0x0F12, 0xF000},	 // 700040C4
{0x0F12, 0xF99E},	 // 700040C6
{0x0F12, 0x6020},	 // 700040C8
{0x0F12, 0xE798},	 // 700040CA
{0x0F12, 0xB5FE},	 // 700040CC
{0x0F12, 0x000C},	 // 700040CE
{0x0F12, 0x6825},	 // 700040D0
{0x0F12, 0x6866},	 // 700040D2
{0x0F12, 0x68A0},	 // 700040D4
{0x0F12, 0x9001},	 // 700040D6
{0x0F12, 0x68E7},	 // 700040D8
{0x0F12, 0x1BA8},	 // 700040DA
{0x0F12, 0x42B5},	 // 700040DC
{0x0F12, 0xDA00},	 // 700040DE
{0x0F12, 0x1B70},	 // 700040E0
{0x0F12, 0x9000},	 // 700040E2
{0x0F12, 0x4977},	 // 700040E4
{0x0F12, 0x4878},	 // 700040E6
{0x0F12, 0x884A},	 // 700040E8
{0x0F12, 0x8843},	 // 700040EA
{0x0F12, 0x435A},	 // 700040EC
{0x0F12, 0x2304},	 // 700040EE
{0x0F12, 0x5ECB},	 // 700040F0
{0x0F12, 0x0A92},	 // 700040F2
{0x0F12, 0x18D2},	 // 700040F4
{0x0F12, 0x02D2},	 // 700040F6
{0x0F12, 0x0C12},	 // 700040F8
{0x0F12, 0x88CB},	 // 700040FA
{0x0F12, 0x8880},	 // 700040FC
{0x0F12, 0x4343},	 // 700040FE
{0x0F12, 0x0A98},	 // 70004100
{0x0F12, 0x2308},	 // 70004102
{0x0F12, 0x5ECB},	 // 70004104
{0x0F12, 0x18C0},	 // 70004106
{0x0F12, 0x02C0},	 // 70004108
{0x0F12, 0x0C00},	 // 7000410A
{0x0F12, 0x0411},	 // 7000410C
{0x0F12, 0x0400},	 // 7000410E
{0x0F12, 0x1409},	 // 70004110
{0x0F12, 0x1400},	 // 70004112
{0x0F12, 0x1A08},	 // 70004114
{0x0F12, 0x496C},	 // 70004116
{0x0F12, 0x39E0},	 // 70004118
{0x0F12, 0x6148},	 // 7000411A
{0x0F12, 0x9801},	 // 7000411C
{0x0F12, 0x3040},	 // 7000411E
{0x0F12, 0x7880},	 // 70004120
{0x0F12, 0x2800},	 // 70004122
{0x0F12, 0xD103},	 // 70004124
{0x0F12, 0x9801},	 // 70004126
{0x0F12, 0x0029},	 // 70004128
{0x0F12, 0xF000},	 // 7000412A
{0x0F12, 0xF971},	 // 7000412C
{0x0F12, 0x8839},	 // 7000412E
{0x0F12, 0x9800},	 // 70004130
{0x0F12, 0x4281},	 // 70004132
{0x0F12, 0xD814},	 // 70004134
{0x0F12, 0x8879},	 // 70004136
{0x0F12, 0x9800},	 // 70004138
{0x0F12, 0x4281},	 // 7000413A
{0x0F12, 0xD20C},	 // 7000413C
{0x0F12, 0x9801},	 // 7000413E
{0x0F12, 0x0029},	 // 70004140
{0x0F12, 0xF000},	 // 70004142
{0x0F12, 0xF96D},	 // 70004144
{0x0F12, 0x9801},	 // 70004146
{0x0F12, 0x0029},	 // 70004148
{0x0F12, 0xF000},	 // 7000414A
{0x0F12, 0xF969},	 // 7000414C
{0x0F12, 0x9801},	 // 7000414E
{0x0F12, 0x0029},	 // 70004150
{0x0F12, 0xF000},	 // 70004152
{0x0F12, 0xF965},	 // 70004154
{0x0F12, 0xE003},	 // 70004156
{0x0F12, 0x9801},	 // 70004158
{0x0F12, 0x0029},	 // 7000415A
{0x0F12, 0xF000},	 // 7000415C
{0x0F12, 0xF960},	 // 7000415E
{0x0F12, 0x9801},	 // 70004160
{0x0F12, 0x0032},	 // 70004162
{0x0F12, 0x0039},	 // 70004164
{0x0F12, 0xF000},	 // 70004166
{0x0F12, 0xF963},	 // 70004168
{0x0F12, 0x6020},	 // 7000416A
{0x0F12, 0xE5D0},	 // 7000416C
{0x0F12, 0xB57C},	 // 7000416E
{0x0F12, 0x4856},	 // 70004170
{0x0F12, 0xA901},	 // 70004172
{0x0F12, 0x0004},	 // 70004174
{0x0F12, 0xF000},	 // 70004176
{0x0F12, 0xF8E7},	 // 70004178
{0x0F12, 0x466B},	 // 7000417A
{0x0F12, 0x88D9},	 // 7000417C
{0x0F12, 0x8898},	 // 7000417E
{0x0F12, 0x4B51},	 // 70004180
{0x0F12, 0x3346},	 // 70004182
{0x0F12, 0x1E9A},	 // 70004184
{0x0F12, 0xF000},	 // 70004186
{0x0F12, 0xF95B},	 // 70004188
{0x0F12, 0x4850},	 // 7000418A
{0x0F12, 0x494E},	 // 7000418C
{0x0F12, 0x3812},	 // 7000418E
{0x0F12, 0x3140},	 // 70004190
{0x0F12, 0x8A42},	 // 70004192
{0x0F12, 0x888B},	 // 70004194
{0x0F12, 0x18D2},	 // 70004196
{0x0F12, 0x8242},	 // 70004198
{0x0F12, 0x8AC2},	 // 7000419A
{0x0F12, 0x88C9},	 // 7000419C
{0x0F12, 0x1851},	 // 7000419E
{0x0F12, 0x82C1},	 // 700041A0
{0x0F12, 0x0020},	 // 700041A2
{0x0F12, 0x4669},	 // 700041A4
{0x0F12, 0xF000},	 // 700041A6
{0x0F12, 0xF8CF},	 // 700041A8
{0x0F12, 0x4849},	 // 700041AA
{0x0F12, 0x214D},	 // 700041AC
{0x0F12, 0x8301},	 // 700041AE
{0x0F12, 0x2196},	 // 700041B0
{0x0F12, 0x8381},	 // 700041B2
{0x0F12, 0x211D},	 // 700041B4
{0x0F12, 0x3020},	 // 700041B6
{0x0F12, 0x8001},	 // 700041B8
{0x0F12, 0xF000},	 // 700041BA
{0x0F12, 0xF949},	 // 700041BC
{0x0F12, 0xF000},	 // 700041BE
{0x0F12, 0xF94F},	 // 700041C0
{0x0F12, 0x4844},	 // 700041C2
{0x0F12, 0x4C44},	 // 700041C4
{0x0F12, 0x6E00},	 // 700041C6
{0x0F12, 0x60E0},	 // 700041C8
{0x0F12, 0x466B},	 // 700041CA
{0x0F12, 0x8818},	 // 700041CC
{0x0F12, 0x8859},	 // 700041CE
{0x0F12, 0x0025},	 // 700041D0
{0x0F12, 0x1A40},	 // 700041D2
{0x0F12, 0x3540},	 // 700041D4
{0x0F12, 0x61A8},	 // 700041D6
{0x0F12, 0x483B},	 // 700041D8
{0x0F12, 0x9900},	 // 700041DA
{0x0F12, 0x3060},	 // 700041DC
{0x0F12, 0xF000},	 // 700041DE
{0x0F12, 0xF947},	 // 700041E0
{0x0F12, 0x466B},	 // 700041E2
{0x0F12, 0x8819},	 // 700041E4
{0x0F12, 0x1DE0},	 // 700041E6
{0x0F12, 0x30F9},	 // 700041E8
{0x0F12, 0x8741},	 // 700041EA
{0x0F12, 0x8859},	 // 700041EC
{0x0F12, 0x8781},	 // 700041EE
{0x0F12, 0x2000},	 // 700041F0
{0x0F12, 0x71A0},	 // 700041F2
{0x0F12, 0x74A8},	 // 700041F4
{0x0F12, 0xBC7C},	 // 700041F6
{0x0F12, 0xBC08},	 // 700041F8
{0x0F12, 0x4718},	 // 700041FA
{0x0F12, 0xB5F8},	 // 700041FC
{0x0F12, 0x0005},	 // 700041FE
{0x0F12, 0x6808},	 // 70004200
{0x0F12, 0x0400},	 // 70004202
{0x0F12, 0x0C00},	 // 70004204
{0x0F12, 0x684A},	 // 70004206
{0x0F12, 0x0412},	 // 70004208
{0x0F12, 0x0C12},	 // 7000420A
{0x0F12, 0x688E},	 // 7000420C
{0x0F12, 0x68CC},	 // 7000420E
{0x0F12, 0x492C},	 // 70004210
{0x0F12, 0x884B},	 // 70004212
{0x0F12, 0x4343},	 // 70004214
{0x0F12, 0x0A98},	 // 70004216
{0x0F12, 0x2304},	 // 70004218
{0x0F12, 0x5ECB},	 // 7000421A
{0x0F12, 0x18C0},	 // 7000421C
{0x0F12, 0x02C0},	 // 7000421E
{0x0F12, 0x0C00},	 // 70004220
{0x0F12, 0x88CB},	 // 70004222
{0x0F12, 0x4353},	 // 70004224
{0x0F12, 0x0A9A},	 // 70004226
{0x0F12, 0x2308},	 // 70004228
{0x0F12, 0x5ECB},	 // 7000422A
{0x0F12, 0x18D1},	 // 7000422C
{0x0F12, 0x02C9},	 // 7000422E
{0x0F12, 0x0C09},	 // 70004230
{0x0F12, 0x2701},	 // 70004232
{0x0F12, 0x003A},	 // 70004234
{0x0F12, 0x40AA},	 // 70004236
{0x0F12, 0x9200},	 // 70004238
{0x0F12, 0x002A},	 // 7000423A
{0x0F12, 0x3A10},	 // 7000423C
{0x0F12, 0x4097},	 // 7000423E
{0x0F12, 0x2D10},	 // 70004240
{0x0F12, 0xDA06},	 // 70004242
{0x0F12, 0x4A25},	 // 70004244
{0x0F12, 0x9B00},	 // 70004246
{0x0F12, 0x8812},	 // 70004248
{0x0F12, 0x439A},	 // 7000424A
{0x0F12, 0x4B23},	 // 7000424C
{0x0F12, 0x801A},	 // 7000424E
{0x0F12, 0xE003},	 // 70004250
{0x0F12, 0x4B22},	 // 70004252
{0x0F12, 0x885A},	 // 70004254
{0x0F12, 0x43BA},	 // 70004256
{0x0F12, 0x805A},	 // 70004258
{0x0F12, 0x0023},	 // 7000425A
{0x0F12, 0x0032},	 // 7000425C
{0x0F12, 0xF000},	 // 7000425E
{0x0F12, 0xF8EF},	 // 70004260
{0x0F12, 0x2D10},	 // 70004262
{0x0F12, 0xDA05},	 // 70004264
{0x0F12, 0x491D},	 // 70004266
{0x0F12, 0x9A00},	 // 70004268
{0x0F12, 0x8808},	 // 7000426A
{0x0F12, 0x4310},	 // 7000426C
{0x0F12, 0x8008},	 // 7000426E
{0x0F12, 0xE003},	 // 70004270
{0x0F12, 0x481A},	 // 70004272
{0x0F12, 0x8841},	 // 70004274
{0x0F12, 0x4339},	 // 70004276
{0x0F12, 0x8041},	 // 70004278
{0x0F12, 0x4D17},	 // 7000427A
{0x0F12, 0x2000},	 // 7000427C
{0x0F12, 0x3580},	 // 7000427E
{0x0F12, 0x88AA},	 // 70004280
{0x0F12, 0x5E30},	 // 70004282
{0x0F12, 0x2100},	 // 70004284
{0x0F12, 0xF000},	 // 70004286
{0x0F12, 0xF8FB},	 // 70004288
{0x0F12, 0x8030},	 // 7000428A
{0x0F12, 0x2000},	 // 7000428C
{0x0F12, 0x88AA},	 // 7000428E
{0x0F12, 0x5E20},	 // 70004290
{0x0F12, 0x2100},	 // 70004292
{0x0F12, 0xF000},	 // 70004294
{0x0F12, 0xF8F4},	 // 70004296
{0x0F12, 0x8020},	 // 70004298
{0x0F12, 0xE587},	 // 7000429A
{0x0F12, 0xB510},	 // 7000429C
{0x0F12, 0xF000},	 // 7000429E
{0x0F12, 0xF8F7},	 // 700042A0
{0x0F12, 0x4A0F},	 // 700042A2
{0x0F12, 0x8D50},	 // 700042A4
{0x0F12, 0x2800},	 // 700042A6
{0x0F12, 0xD007},	 // 700042A8
{0x0F12, 0x490A},	 // 700042AA
{0x0F12, 0x31C0},	 // 700042AC
{0x0F12, 0x684B},	 // 700042AE
{0x0F12, 0x490C},	 // 700042B0
{0x0F12, 0x4283},	 // 700042B2
{0x0F12, 0xD202},	 // 700042B4
{0x0F12, 0x8D90},	 // 700042B6
{0x0F12, 0x81C8},	 // 700042B8
{0x0F12, 0xE6A0},	 // 700042BA
{0x0F12, 0x8DD0},	 // 700042BC
{0x0F12, 0x81C8},	 // 700042BE
{0x0F12, 0xE69D},	 // 700042C0
{0x0F12, 0x0000},	 // 700042C2
{0x0F12, 0x2558},	 // 700042C4
{0x0F12, 0x7000},	 // 700042C6
{0x0F12, 0x2AB8},	 // 700042C8
{0x0F12, 0x7000},	 // 700042CA
{0x0F12, 0x145E},	 // 700042CC
{0x0F12, 0x7000},	 // 700042CE
{0x0F12, 0x2698},	 // 700042D0
{0x0F12, 0x7000},	 // 700042D2
{0x0F12, 0x2BB8},	 // 700042D4
{0x0F12, 0x7000},	 // 700042D6
{0x0F12, 0x2998},	 // 700042D8
{0x0F12, 0x7000},	 // 700042DA
{0x0F12, 0x1100},	 // 700042DC
{0x0F12, 0xD000},	 // 700042DE
{0x0F12, 0x4780},	 // 700042E0
{0x0F12, 0x7000},	 // 700042E2
{0x0F12, 0xE200},	 // 700042E4
{0x0F12, 0xD000},	 // 700042E6
{0x0F12, 0x4778},	 // 700042E8
{0x0F12, 0x46C0},	 // 700042EA
{0x0F12, 0xC000},	 // 700042EC
{0x0F12, 0xE59F},	 // 700042EE
{0x0F12, 0xFF1C},	 // 700042F0
{0x0F12, 0xE12F},	 // 700042F2
{0x0F12, 0x1789},	 // 700042F4
{0x0F12, 0x0001},	 // 700042F6
{0x0F12, 0x4778},	 // 700042F8
{0x0F12, 0x46C0},	 // 700042FA
{0x0F12, 0xC000},	 // 700042FC
{0x0F12, 0xE59F},	 // 700042FE
{0x0F12, 0xFF1C},	 // 70004300
{0x0F12, 0xE12F},	 // 70004302
{0x0F12, 0x16F1},	 // 70004304
{0x0F12, 0x0001},	 // 70004306
{0x0F12, 0x4778},	 // 70004308
{0x0F12, 0x46C0},	 // 7000430A
{0x0F12, 0xC000},	 // 7000430C
{0x0F12, 0xE59F},	 // 7000430E
{0x0F12, 0xFF1C},	 // 70004310
{0x0F12, 0xE12F},	 // 70004312
{0x0F12, 0xC3B1},	 // 70004314
{0x0F12, 0x0000},	 // 70004316
{0x0F12, 0x4778},	 // 70004318
{0x0F12, 0x46C0},	 // 7000431A
{0x0F12, 0xC000},	 // 7000431C
{0x0F12, 0xE59F},	 // 7000431E
{0x0F12, 0xFF1C},	 // 70004320
{0x0F12, 0xE12F},	 // 70004322
{0x0F12, 0xC36D},	 // 70004324
{0x0F12, 0x0000},	 // 70004326
{0x0F12, 0x4778},	 // 70004328
{0x0F12, 0x46C0},	 // 7000432A
{0x0F12, 0xC000},	 // 7000432C
{0x0F12, 0xE59F},	 // 7000432E
{0x0F12, 0xFF1C},	 // 70004330
{0x0F12, 0xE12F},	 // 70004332
{0x0F12, 0xF6D7},	 // 70004334
{0x0F12, 0x0000},	 // 70004336
{0x0F12, 0x4778},	 // 70004338
{0x0F12, 0x46C0},	 // 7000433A
{0x0F12, 0xC000},	 // 7000433C
{0x0F12, 0xE59F},	 // 7000433E
{0x0F12, 0xFF1C},	 // 70004340
{0x0F12, 0xE12F},	 // 70004342
{0x0F12, 0xB49D},	 // 70004344
{0x0F12, 0x0000},	 // 70004346
{0x0F12, 0x4778},	 // 70004348
{0x0F12, 0x46C0},	 // 7000434A
{0x0F12, 0xC000},	 // 7000434C
{0x0F12, 0xE59F},	 // 7000434E
{0x0F12, 0xFF1C},	 // 70004350
{0x0F12, 0xE12F},	 // 70004352
{0x0F12, 0x7EDF},	 // 70004354
{0x0F12, 0x0000},	 // 70004356
{0x0F12, 0x4778},	 // 70004358
{0x0F12, 0x46C0},	 // 7000435A
{0x0F12, 0xC000},	 // 7000435C
{0x0F12, 0xE59F},	 // 7000435E
{0x0F12, 0xFF1C},	 // 70004360
{0x0F12, 0xE12F},	 // 70004362
{0x0F12, 0x448D},	 // 70004364
{0x0F12, 0x0000},	 // 70004366
{0x0F12, 0x4778},	 // 70004368
{0x0F12, 0x46C0},	 // 7000436A
{0x0F12, 0xF004},	 // 7000436C
{0x0F12, 0xE51F},	 // 7000436E
{0x0F12, 0x29EC},	 // 70004370
{0x0F12, 0x0001},	 // 70004372
{0x0F12, 0x4778},	 // 70004374
{0x0F12, 0x46C0},	 // 70004376
{0x0F12, 0xC000},	 // 70004378
{0x0F12, 0xE59F},	 // 7000437A
{0x0F12, 0xFF1C},	 // 7000437C
{0x0F12, 0xE12F},	 // 7000437E
{0x0F12, 0x2EF1},	 // 70004380
{0x0F12, 0x0000},	 // 70004382
{0x0F12, 0x4778},	 // 70004384
{0x0F12, 0x46C0},	 // 70004386
{0x0F12, 0xC000},	 // 70004388
{0x0F12, 0xE59F},	 // 7000438A
{0x0F12, 0xFF1C},	 // 7000438C
{0x0F12, 0xE12F},	 // 7000438E
{0x0F12, 0xEE03},	 // 70004390
{0x0F12, 0x0000},	 // 70004392
{0x0F12, 0x4778},	 // 70004394
{0x0F12, 0x46C0},	 // 70004396
{0x0F12, 0xC000},	 // 70004398
{0x0F12, 0xE59F},	 // 7000439A
{0x0F12, 0xFF1C},	 // 7000439C
{0x0F12, 0xE12F},	 // 7000439E
{0x0F12, 0xA58B},	 // 700043A0
{0x0F12, 0x0000},	 // 700043A2
{0x0F12, 0x4778},	 // 700043A4
{0x0F12, 0x46C0},	 // 700043A6
{0x0F12, 0xC000},	 // 700043A8
{0x0F12, 0xE59F},	 // 700043AA
{0x0F12, 0xFF1C},	 // 700043AC
{0x0F12, 0xE12F},	 // 700043AE
{0x0F12, 0x7C49},	 // 700043B0
{0x0F12, 0x0000},	 // 700043B2
{0x0F12, 0x4778},	 // 700043B4
{0x0F12, 0x46C0},	 // 700043B6
{0x0F12, 0xC000},	 // 700043B8
{0x0F12, 0xE59F},	 // 700043BA
{0x0F12, 0xFF1C},	 // 700043BC
{0x0F12, 0xE12F},	 // 700043BE
{0x0F12, 0x7C63},	 // 700043C0
{0x0F12, 0x0000},	 // 700043C2
{0x0F12, 0x4778},	 // 700043C4
{0x0F12, 0x46C0},	 // 700043C6
{0x0F12, 0xC000},	 // 700043C8
{0x0F12, 0xE59F},	 // 700043CA
{0x0F12, 0xFF1C},	 // 700043CC
{0x0F12, 0xE12F},	 // 700043CE
{0x0F12, 0x2DB7},	 // 700043D0
{0x0F12, 0x0000},	 // 700043D2
{0x0F12, 0x4778},	 // 700043D4
{0x0F12, 0x46C0},	 // 700043D6
{0x0F12, 0xC000},	 // 700043D8
{0x0F12, 0xE59F},	 // 700043DA
{0x0F12, 0xFF1C},	 // 700043DC
{0x0F12, 0xE12F},	 // 700043DE
{0x0F12, 0xEB3D},	 // 700043E0
{0x0F12, 0x0000},	 // 700043E2
{0x0F12, 0x4778},	 // 700043E4
{0x0F12, 0x46C0},	 // 700043E6
{0x0F12, 0xC000},	 // 700043E8
{0x0F12, 0xE59F},	 // 700043EA
{0x0F12, 0xFF1C},	 // 700043EC
{0x0F12, 0xE12F},	 // 700043EE
{0x0F12, 0xF061},	 // 700043F0
{0x0F12, 0x0000},	 // 700043F2
{0x0F12, 0x4778},	 // 700043F4
{0x0F12, 0x46C0},	 // 700043F6
{0x0F12, 0xC000},	 // 700043F8
{0x0F12, 0xE59F},	 // 700043FA
{0x0F12, 0xFF1C},	 // 700043FC
{0x0F12, 0xE12F},	 // 700043FE
{0x0F12, 0xF0EF},	 // 70004400
{0x0F12, 0x0000},	 // 70004402
{0x0F12, 0x4778},	 // 70004404
{0x0F12, 0x46C0},	 // 70004406
{0x0F12, 0xF004},	 // 70004408
{0x0F12, 0xE51F},	 // 7000440A
{0x0F12, 0x2824},	 // 7000440C
{0x0F12, 0x0001},	 // 7000440E
{0x0F12, 0x4778},	 // 70004410
{0x0F12, 0x46C0},	 // 70004412
{0x0F12, 0xC000},	 // 70004414
{0x0F12, 0xE59F},	 // 70004416
{0x0F12, 0xFF1C},	 // 70004418
{0x0F12, 0xE12F},	 // 7000441A
{0x0F12, 0x8EDD},	 // 7000441C
{0x0F12, 0x0000},	 // 7000441E
{0x0F12, 0x4778},	 // 70004420
{0x0F12, 0x46C0},	 // 70004422
{0x0F12, 0xC000},	 // 70004424
{0x0F12, 0xE59F},	 // 70004426
{0x0F12, 0xFF1C},	 // 70004428
{0x0F12, 0xE12F},	 // 7000442A
{0x0F12, 0x8DCB},	 // 7000442C
{0x0F12, 0x0000},	 // 7000442E
{0x0F12, 0x4778},	 // 70004430
{0x0F12, 0x46C0},	 // 70004432
{0x0F12, 0xC000},	 // 70004434
{0x0F12, 0xE59F},	 // 70004436
{0x0F12, 0xFF1C},	 // 70004438
{0x0F12, 0xE12F},	 // 7000443A
{0x0F12, 0x8E17},	 // 7000443C
{0x0F12, 0x0000},	 // 7000443E
{0x0F12, 0x4778},	 // 70004440
{0x0F12, 0x46C0},	 // 70004442
{0x0F12, 0xC000},	 // 70004444
{0x0F12, 0xE59F},	 // 70004446
{0x0F12, 0xFF1C},	 // 70004448
{0x0F12, 0xE12F},	 // 7000444A
{0x0F12, 0x98C5},	 // 7000444C
{0x0F12, 0x0000},	 // 7000444E
{0x0F12, 0x4778},	 // 70004450
{0x0F12, 0x46C0},	 // 70004452
{0x0F12, 0xC000},	 // 70004454
{0x0F12, 0xE59F},	 // 70004456
{0x0F12, 0xFF1C},	 // 70004458
{0x0F12, 0xE12F},	 // 7000445A
{0x0F12, 0x7C7D},	 // 7000445C
{0x0F12, 0x0000},	 // 7000445E
{0x0F12, 0x4778},	 // 70004460
{0x0F12, 0x46C0},	 // 70004462
{0x0F12, 0xC000},	 // 70004464
{0x0F12, 0xE59F},	 // 70004466
{0x0F12, 0xFF1C},	 // 70004468
{0x0F12, 0xE12F},	 // 7000446A
{0x0F12, 0x7E31},	 // 7000446C
{0x0F12, 0x0000},	 // 7000446E
{0x0F12, 0x4778},	 // 70004470
{0x0F12, 0x46C0},	 // 70004472
{0x0F12, 0xC000},	 // 70004474
{0x0F12, 0xE59F},	 // 70004476
{0x0F12, 0xFF1C},	 // 70004478
{0x0F12, 0xE12F},	 // 7000447A
{0x0F12, 0x7EAB},	 // 7000447C
{0x0F12, 0x0000},	 // 7000447E
{0x0F12, 0x4778},	 // 70004480
{0x0F12, 0x46C0},	 // 70004482
{0x0F12, 0xC000},	 // 70004484
{0x0F12, 0xE59F},	 // 70004486
{0x0F12, 0xFF1C},	 // 70004488
{0x0F12, 0xE12F},	 // 7000448A
{0x0F12, 0x7501},	 // 7000448C
{0x0F12, 0x0000},	 // 7000448E
{0x0F12, 0x4778},	 // 70004490
{0x0F12, 0x46C0},	 // 70004492
{0x0F12, 0xC000},	 // 70004494
{0x0F12, 0xE59F},	 // 70004496
{0x0F12, 0xFF1C},	 // 70004498
{0x0F12, 0xE12F},	 // 7000449A
{0x0F12, 0xF63F},	 // 7000449C
{0x0F12, 0x0000},	 // 7000449E

// End of Patch Data(Last : 7000449Eh)
// Total Size 2472 (09A8)
// Addr : 3AF8  Size : 2470(9A6h)

//TNP_USER_MBCV_CONTROL
//TNP_4EC_MBR_TUNE
//TNP_4EC_FORBIDDEN_TUNE
//TNP_AF_FINESEARCH_DRIVEBACK
//TNP_FLASH_ALG
//TNP_GAS_ALPHA_OTP
//TNP_AWB_MODUL_COMP
//TNP_AWB_INIT_QUEUE
//TNP_AWB_GRID_LOWBR
//TNP_AWB_GRID_MODULECOMP

{0x0028, 0xD000},
{0x002A, 0x1000},
{0x0F12, 0x0001},

//==================================================================================
// 13.Flash Setting
//==================================================================================



//==================================================================================
// 12.AF Setting
//==================================================================================
{0x0028, 0x7000},
{0x002A, 0x01FC},
{0x0F12, 0x0001},	 //REG_TC_IPRM_LedGpio
{0x002A, 0x01FE},
{0x0F12, 0x0003},	 //REG_TC_IPRM_CM_Init_AfModeType VCM IIC
{0x0F12, 0x0000},	 //REG_TC_IPRM_CM_Init_PwmConfig1
{0x002A, 0x0204},
{0x0F12, 0x0061},	 //REG_TC_IPRM_CM_Init_GpioConfig1 AF Enable GPIO 6	 //
{0x002A, 0x020C},
{0x0F12, 0x2F0C},	 //REG_TC_IPRM_CM_Init_Mi2cBits
{0x0F12, 0x0190},	 //REG_TC_IPRM_CM_Init_Mi2cRateKhz IIC Speed
{0x002A, 0x0294},
{0x0F12, 0x01C7},	 //REG_TC_AF_FstWinStartX
{0x0F12, 0x01C7},	 //REG_TC_AF_FstWinStartY
{0x0F12, 0x0072},	 //REG_TC_AF_FstWinSizeX
{0x0F12, 0x0072},	 //REG_TC_AF_FstWinSizeY
{0x0F12, 0x01D5},	 //REG_TC_AF_ScndWinStartX
{0x0F12, 0x01D5},	 //REG_TC_AF_ScndWinStartY
{0x0F12, 0x0055},	 //REG_TC_AF_ScndWinSizeX
{0x0F12, 0x0055},	 //REG_TC_AF_ScndWinSizeY
{0x0F12, 0x0001},	 //REG_TC_AF_WinSizesUpdated

{0x002A, 0x070E},
{0x0F12, 0x00FF},	 //skl_af_StatOvlpExpFactor
{0x002A, 0x071E},
{0x0F12, 0x0000},	 //skl_af_bAfStatOff
{0x002A, 0x163C},
{0x0F12, 0x0000},	 //af_search_usAeStable
{0x002A, 0x1648},
{0x0F12, 0x9000},	 //af_search_usSingleAfFlags
{0x002A, 0x1652},
{0x0F12, 0x0002},	 //af_search_usFinePeakCount
{0x0F12, 0x0000},	 //af_search_usFineMaxScale
{0x002A, 0x15E0},
{0x0F12, 0x0902},	 //af_pos_usFineStepNumSize

{0x002A, 0x164C},
{0x0F12, 0x0003},	 //af_search_usMinPeakSamples
{0x002A, 0x163E},
{0x0F12, 0x00E5},	 //af_search_usPeakThr Full search (E5 90%)
{0x0F12, 0x0098},	 //af_search_usPeakThrLow
{0x002A, 0x15D4},
{0x0F12, 0x0020},	 //af_pos_usHomePos
{0x0F12, 0xD020},	 //af_pos_usLowConfPos
{0x002A, 0x169A},
{0x0F12, 0xFF95},	 //af_search_usConfCheckOrder_1_
{0x002A, 0x166A},
{0x0F12, 0x0280},	 //af_search_usConfThr_4_
{0x002A, 0x1676},
{0x0F12, 0x03FF},	 //af_search_usConfThr_10_
{0x0F12, 0x0320},	 //af_search_usConfThr_11_
{0x002A, 0x16BC},
{0x0F12, 0x0030},	 //af_stat_usMinStatVal
{0x002A, 0x16E0},
{0x0F12, 0x0060},	 //af_scene_usSceneLowNormBrThr
{0x002A, 0x16D4},
{0x0F12, 0x0010},	 //af_stat_usBpfThresh
{0x002A, 0x1656},
{0x0F12, 0x0000},	 //af_search_usCapturePolicy
{0x002A, 0x15E6},
{0x0F12, 0x003C},	 //af_pos_usCaptureFixedPos

{0x0F12, 0x0018},	 //af_pos_usTableLastInd
{0x0F12, 0x002A},	 //af_pos_usTable_0_
{0x0F12, 0x0030},	 //af_pos_usTable_1_
{0x0F12, 0x0036},	 //af_pos_usTable_2_
{0x0F12, 0x003C},	 //af_pos_usTable_3_
{0x0F12, 0x0042},	 //af_pos_usTable_4_
{0x0F12, 0x0048},	 //af_pos_usTable_5_
{0x0F12, 0x004E},	 //af_pos_usTable_6_
{0x0F12, 0x0054},	 //af_pos_usTable_7_
{0x0F12, 0x005A},	 //af_pos_usTable_8_
{0x0F12, 0x0060},	 //af_pos_usTable_9_
{0x0F12, 0x0066},	 //af_pos_usTable_10
{0x0F12, 0x006C},	 //af_pos_usTable_11_
{0x0F12, 0x0072},	 //af_pos_usTable_12_
{0x0F12, 0x0078},	 //af_pos_usTable_13_
{0x0F12, 0x007E},	 //af_pos_usTable_14_
{0x0F12, 0x0084},	 //af_pos_usTable_15_
{0x0F12, 0x008A},	 //af_pos_usTable_16_
{0x0F12, 0x0090},	 //af_pos_usTable_17_
{0x0F12, 0x0096},	 //af_pos_usTable_18_
{0x0F12, 0x009C},	 //af_pos_usTable_19_
{0x0F12, 0x00A2},	 //af_pos_usTable_20_
{0x0F12, 0x00A8},	 //af_pos_usTable_21_
{0x0F12, 0x00AE},	 //af_pos_usTable_22_
{0x0F12, 0x00B4},	 //af_pos_usTable_23_
{0x0F12, 0x00BA},	 //af_pos_usTable_24_

{0x002A, 0x1722},
{0x0F12, 0x8000},	 //afd_usParam_0_
{0x0F12, 0x0006},	 //afd_usParam_1_
{0x0F12, 0x3FF0},	 //afd_usParam_2_
{0x0F12, 0x03E8},	 //afd_usParam_3_
{0x0F12, 0x0000},	 //afd_usParam_4_
{0x0F12, 0x0020},	 //afd_usParam_5_
{0x0F12, 0x0010},	 //afd_usParam_6_
{0x0F12, 0x0010},	 //afd_usParam_7_
{0x0F12, 0x0040},	 //afd_usParam_8_
{0x0F12, 0x0080},	 //afd_usParam_9_
{0x0F12, 0x00C0},	 //afd_usParam_10_
{0x0F12, 0x00E0},	 //afd_usParam_11_

{0x002A, 0x028C},
{0x0F12, 0x0003},	 //REG_TC_AF_AfCmd

//==================================================================================
//04.Gas_Anti Shading_Otp
//==================================================================================
{0x002A, 0x08B4},
{0x0F12, 0x0001},	 //wbt_bUseOutdoorASH

// Refer Mon_AWB_RotGain
{0x002A, 0x08BC},
{0x0F12, 0x00C0},	 //TVAR_ash_AwbAshCord_0_ 2300K
{0x0F12, 0x00DF},	 //TVAR_ash_AwbAshCord_1_ 2750K
{0x0F12, 0x0100},	 //TVAR_ash_AwbAshCord_2_ 3300K
{0x0F12, 0x0125},	 //TVAR_ash_AwbAshCord_3_ 4150K
{0x0F12, 0x015F},	 //TVAR_ash_AwbAshCord_4_ 5250K
{0x0F12, 0x017C},	 //TVAR_ash_AwbAshCord_5_ 6400K
{0x0F12, 0x0194},	 //TVAR_ash_AwbAshCord_6_ 7500K

// GAS Alpha Table
{0x002A, 0x08F6},
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_0__0_ R   // 2300K
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_0__1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_0__2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_0__3_ B
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_1__0_ R   // 2750K
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_1__1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_1__2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_1__3_ B
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_2__0_ R   // 3300K
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_2__1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_2__2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_2__3_ B
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_3__0_ R   // 4150K
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_3__1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_3__2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_3__3_ B
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_4__0_ R   // 5250K
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_4__1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_4__2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_4__3_ B
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_5__0_ R   // 6400K
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_5__1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_5__2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_5__3_ B
{0x0F12, 0x4500},	 //TVAR_ash_GASAlpha_6__0_ R   // 7500K
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_6__1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_6__2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASAlpha_6__3_ B

// Outdoor GAS Alpha
{0x0F12, 0x4800},	 //TVAR_ash_GASOutdoorAlpha_0_ R
{0x0F12, 0x4200},	 //TVAR_ash_GASOutdoorAlpha_1_ GR
{0x0F12, 0x4000},	 //TVAR_ash_GASOutdoorAlpha_2_ GB
{0x0F12, 0x4000},	 //TVAR_ash_GASOutdoorAlpha_3_ B

{0x002A, 0x08F4},
{0x0F12, 0x0001},	 //ash_bUseGasAlpha

//==================================================================================
// 09.Auto Flicker Detection
//==================================================================================

{0x002A, 0x0F30},
{0x0F12, 0x0001},   	 //AFC_D_ConvAccelerPower

// Auto Flicker (60Mhz start)
{0x002A, 0x0F2A},
{0x0F12, 0x0000},	 //AFC_Default BIT[0] 1:60Hz 0:50Hz
{0x002A, 0x04E6},
{0x0F12, 0x077F},	 //REG_TC_DBG 7F: 60Hz  5F:50Hz


//==================================================================================
// 10.AE Setting
//==================================================================================

//AE Target
{0x002A, 0x1484},
{0x0F12, 0x003C},   	 //TVAR_ae_BrAve

//ae_StatMode bit[3] BLC has to be bypassed to prevent AE weight change especially backlight scene
{0x002A, 0x148A},
{0x0F12, 0x000F},  	  //ae_StatMode

{0x002A, 0x0588},
{0x0F12, 0x0000},	 //lt_uInitPostToleranceCnt

//AE_state
{0x002A, 0x0544},
{0x0F12, 0x0111},  	  //lt_uLimitHigh
{0x0F12, 0x00EF},  	  //lt_uLimitLow

//AE Concept
{0x002A, 0x0608},
{0x0F12, 0x0001}, 	 //lt_ExpGain_uSubsamplingmode
{0x0F12, 0x0001},	 //lt_ExpGain_uNonSubsampling
{0x0F12, 0x0800},	 //lt_ExpGain_ExpCurveGainMaxStr
{0x0F12, 0x0100},   	 //lt_ExpGain_ExpCurveGainMaxStr_0__uMaxDigGain

//Exposure
{0x002A, 0x0610},	 //lt_ExpGain_ExpCurveGainMaxStr_0__ulExpIn_0
{0x0F12, 0x0001},
{0x0F12, 0x0000},
{0x0F12, 0x0A3C},
{0x0F12, 0x0000},
{0x0F12, 0x0D04},
{0x0F12, 0x0000},
{0x0F12, 0x4008},
{0x0F12, 0x0000},
{0x0F12, 0x7000},
{0x0F12, 0x0000},
{0x0F12, 0x9C00},
{0x0F12, 0x0000},
{0x0F12, 0xAD00},
{0x0F12, 0x0001},
{0x0F12, 0xF1D4},
{0x0F12, 0x0002},
{0x0F12, 0xDC00},
{0x0F12, 0x0005},
{0x0F12, 0xDC00},
{0x0F12, 0x0005},

{0x002A, 0x0638},	 //lt_ExpGain_ExpCurveGainMaxStr_0__ulExpOut_0_
{0x0F12, 0x0001},
{0x0F12, 0x0000},
{0x0F12, 0x0A3C},
{0x0F12, 0x0000},
{0x0F12, 0x0D05},
{0x0F12, 0x0000},
{0x0F12, 0x3408},
{0x0F12, 0x0000},
{0x0F12, 0x3408},
{0x0F12, 0x0000},
{0x0F12, 0x6810},
{0x0F12, 0x0000},
{0x0F12, 0x8214},
{0x0F12, 0x0000},
{0x0F12, 0xC350},
{0x0F12, 0x0000},
{0x0F12, 0xC350},
{0x0F12, 0x0000},
{0x0F12, 0xC350},
{0x0F12, 0x0000},

//Gain
{0x002A, 0x05A2},
{0x0F12, 0x1000},	 //lt_uMaxTotGain

// Lei Control
{0x002A, 0x06B8},
{0x0F12, 0x452C},
{0x0F12, 0x0005},  	  //lt_uMaxLei

//==================================================================================
// 11.AE Weight (Normal)
//==================================================================================

{0x002A, 0x1492},
{0x0F12, 0x0100},	 //ae_WeightTbl_16_0_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_1_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_2_
{0x0F12, 0x0001},	 //ae_WeightTbl_16_3_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_4_
{0x0F12, 0x0201},	 //ae_WeightTbl_16_5_
{0x0F12, 0x0102},	 //ae_WeightTbl_16_6_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_7_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_8_
{0x0F12, 0x0202},	 //ae_WeightTbl_16_9_
{0x0F12, 0x0202},	 //ae_WeightTbl_16_10_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_11_
{0x0F12, 0x0201},	 //ae_WeightTbl_16_12_
{0x0F12, 0x0302},	 //ae_WeightTbl_16_13_
{0x0F12, 0x0203},	 //ae_WeightTbl_16_14_
{0x0F12, 0x0102},	 //ae_WeightTbl_16_15_
{0x0F12, 0x0201},	 //ae_WeightTbl_16_16_
{0x0F12, 0x0302},	 //ae_WeightTbl_16_17_
{0x0F12, 0x0203},	 //ae_WeightTbl_16_18_
{0x0F12, 0x0102},	 //ae_WeightTbl_16_19_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_20_
{0x0F12, 0x0202},	 //ae_WeightTbl_16_21_
{0x0F12, 0x0202},	 //ae_WeightTbl_16_22_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_23_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_24_
{0x0F12, 0x0201},	 //ae_WeightTbl_16_25_
{0x0F12, 0x0102},	 //ae_WeightTbl_16_26_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_27_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_28_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_29_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_30_
{0x0F12, 0x0101},	 //ae_WeightTbl_16_31_

//==================================================================================
// 14.AWB-BASIC setting
//==================================================================================

// AWB init Start point
{0x002A, 0x145E},
{0x0F12, 0x0580},	 //awbb_GainsInit_0_
{0x0F12, 0x0428},	 //awbb_GainsInit_1_
{0x0F12, 0x0780},	 //awbb_GainsInit_2_

// AWB Convergence Speed
{0x002A, 0x1464},
{0x0F12, 0x0008},	 //awbb_WpFilterMinThr
{0x0F12, 0x0190},	 //awbb_WpFilterMaxThr
{0x0F12, 0x00A0},	 //awbb_WpFilterCoef
{0x0F12, 0x0004},	 //awbb_WpFilterSize
{0x0F12, 0x0002},	 //awbb_GridEnable

{0x002A, 0x144E},
{0x0F12, 0x0000},	 //awbb_RGainOff
{0x0F12, 0x0000},	 //awbb_BGainOff
{0x0F12, 0x0000},	 //awbb_GGainOff
{0x0f12, 0x00C2},	 //awbb_Alpha_Comp_Mode
{0x0F12, 0x0002},	 //awbb_Rpl_InvalidOutDoor
{0x0F12, 0x0001},	 //awbb_UseGrThrCorr
{0x0F12, 0x0074},	 //awbb_Use_Filters
{0x0F12, 0x0001},	 //awbb_CorrectMinNumPatches

// White Locus
{0x002A, 0x11F0},
{0x0F12, 0x012C},	 //awbb_IntcR
{0x0F12, 0x0121},	 //awbb_IntcB
{0x0F12, 0x02DF},	 //awbb_GLocusR
{0x0F12, 0x0314},	 //awbb_GLocusB

{0x002A, 0x120E},
{0x0F12, 0x0000},	 //awbb_MovingScale10
{0x0F12, 0x05FD},	 //awbb_GamutWidthThr1
{0x0F12, 0x036B},	 //awbb_GamutHeightThr1
{0x0F12, 0x0020},	 //awbb_GamutWidthThr2
{0x0F12, 0x001A},	 //awbb_GamutHeightThr2

{0x002A, 0x1278},
{0x0F12, 0xFEF7},	 //awbb_SCDetectionMap_SEC_StartR_B
{0x0F12, 0x0021},	 //awbb_SCDetectionMap_SEC_StepR_B
{0x0F12, 0x07D0},	 //awbb_SCDetectionMap_SEC_SunnyNB
{0x0F12, 0x07D0},	 //awbb_SCDetectionMap_SEC_StepNB
{0x0F12, 0x01C8},	 //awbb_SCDetectionMap_SEC_LowTempR_B
{0x0F12, 0x0096},	 //awbb_SCDetectionMap_SEC_SunnyNBZone
{0x0F12, 0x0004},	 //awbb_SCDetectionMap_SEC_LowTempR_BZone

{0x002A, 0x1224},
{0x0F12, 0x0032},	 //awbb_LowBr
{0x0F12, 0x001E},	 //awbb_LowBr_NBzone
{0x0F12, 0x00E2},	 //awbb_YThreshHigh
{0x0F12, 0x0010},	 //awbb_YThreshLow_Norm
{0x0F12, 0x0002},	 //awbb_YThreshLow_Low
{0x002A, 0x2BA4},
{0x0F12, 0x0002},	         //Mon_AWB_ByPassMode

{0x002A, 0x11FC},
{0x0F12, 0x000C},	 //awbb_MinNumOfFinalPatches

{0x002A, 0x1208},
{0x0F12, 0x0020},          //awbb_MinNumOfChromaclassifpatches

// Indoor Zone
{0x002A, 0x101C},
{0x0F12, 0x0360},	 //awbb_IndoorGrZones_m_BGrid_0__m_left
{0x0F12, 0x036C},	 //awbb_IndoorGrZones_m_BGrid_0__m_right
{0x0F12, 0x0320},	 //awbb_IndoorGrZones_m_BGrid_1__m_left
{0x0F12, 0x038A},	 //awbb_IndoorGrZones_m_BGrid_1__m_right
{0x0F12, 0x02E8},	 //awbb_IndoorGrZones_m_BGrid_2__m_left
{0x0F12, 0x0380},	 //awbb_IndoorGrZones_m_BGrid_2__m_right
{0x0F12, 0x02BE},	 //awbb_IndoorGrZones_m_BGrid_3__m_left
{0x0F12, 0x035A},	 //awbb_IndoorGrZones_m_BGrid_3__m_right
{0x0F12, 0x0298},	 //awbb_IndoorGrZones_m_BGrid_4__m_left
{0x0F12, 0x0334},	 //awbb_IndoorGrZones_m_BGrid_4__m_right
{0x0F12, 0x0272},	 //awbb_IndoorGrZones_m_BGrid_5__m_left
{0x0F12, 0x030E},	 //awbb_IndoorGrZones_m_BGrid_5__m_right
{0x0F12, 0x024C},	 //awbb_IndoorGrZones_m_BGrid_6__m_left
{0x0F12, 0x02EA},	 //awbb_IndoorGrZones_m_BGrid_6__m_right
{0x0F12, 0x0230},	 //awbb_IndoorGrZones_m_BGrid_7__m_left
{0x0F12, 0x02CC},	 //awbb_IndoorGrZones_m_BGrid_7__m_right
{0x0F12, 0x0214},	 //awbb_IndoorGrZones_m_BGrid_8__m_left
{0x0F12, 0x02B0},	 //awbb_IndoorGrZones_m_BGrid_8__m_right
{0x0F12, 0x01F8},	 //awbb_IndoorGrZones_m_BGrid_9__m_left
{0x0F12, 0x0294},	 //awbb_IndoorGrZones_m_BGrid_9__m_right
{0x0F12, 0x01DC},	 //awbb_IndoorGrZones_m_BGrid_10__m_left
{0x0F12, 0x0278},	 //awbb_IndoorGrZones_m_BGrid_10__m_right
{0x0F12, 0x01C0},	 //awbb_IndoorGrZones_m_BGrid_11__m_left
{0x0F12, 0x0264},	 //awbb_IndoorGrZones_m_BGrid_11__m_right
{0x0F12, 0x01AA},	 //awbb_IndoorGrZones_m_BGrid_12__m_left
{0x0F12, 0x0250},	 //awbb_IndoorGrZones_m_BGrid_12__m_right
{0x0F12, 0x0196},	 //awbb_IndoorGrZones_m_BGrid_13__m_left
{0x0F12, 0x023C},	 //awbb_IndoorGrZones_m_BGrid_13__m_right
{0x0F12, 0x0180},	 //awbb_IndoorGrZones_m_BGrid_14__m_left
{0x0F12, 0x0228},	 //awbb_IndoorGrZones_m_BGrid_14__m_right
{0x0F12, 0x016C},	 //awbb_IndoorGrZones_m_BGrid_15__m_left
{0x0F12, 0x0214},	 //awbb_IndoorGrZones_m_BGrid_15__m_right
{0x0F12, 0x0168},	 //awbb_IndoorGrZones_m_BGrid_16__m_left
{0x0F12, 0x0200},	 //awbb_IndoorGrZones_m_BGrid_16__m_right
{0x0F12, 0x0172},	 //awbb_IndoorGrZones_m_BGrid_17__m_left
{0x0F12, 0x01EC},	 //awbb_IndoorGrZones_m_BGrid_17__m_right
{0x0F12, 0x019A},	 //awbb_IndoorGrZones_m_BGrid_18__m_left
{0x0F12, 0x01D8},	 //awbb_IndoorGrZones_m_BGrid_18__m_right
{0x0F12, 0x0000},	 //awbb_IndoorGrZones_m_BGrid_19__m_left
{0x0F12, 0x0000},	 //awbb_IndoorGrZones_m_BGrid_19__m_right

{0x0F12, 0x0005},	 //awbb_IndoorGrZones_m_GridStep
{0x002A, 0x1070},
{0x0F12, 0x0013},	 //awbb_IndoorGrZones_ZInfo_m_GridSz
{0x002A, 0x1074},
{0x0F12, 0x00EC},	 //awbb_IndoorGrZones_m_Boffs

// Outdoor Zone
{0x002A, 0x1078},
{0x0F12, 0x0232},	 //awbb_OutdoorGrZones_m_BGrid_0__m_left
{0x0F12, 0x025A},	 //awbb_OutdoorGrZones_m_BGrid_0__m_right
{0x0F12, 0x021E},	 //awbb_OutdoorGrZones_m_BGrid_1__m_left
{0x0F12, 0x0274},	 //awbb_OutdoorGrZones_m_BGrid_1__m_right
{0x0F12, 0x020E},	 //awbb_OutdoorGrZones_m_BGrid_2__m_left
{0x0F12, 0x028E},	 //awbb_OutdoorGrZones_m_BGrid_2__m_right
{0x0F12, 0x0200},	 //awbb_OutdoorGrZones_m_BGrid_3__m_left
{0x0F12, 0x0290},	 //awbb_OutdoorGrZones_m_BGrid_3__m_right
{0x0F12, 0x01F4},	 //awbb_OutdoorGrZones_m_BGrid_4__m_left
{0x0F12, 0x0286},	 //awbb_OutdoorGrZones_m_BGrid_4__m_right
{0x0F12, 0x01E8},	 //awbb_OutdoorGrZones_m_BGrid_5__m_left
{0x0F12, 0x027E},	 //awbb_OutdoorGrZones_m_BGrid_5__m_right
{0x0F12, 0x01DE},	 //awbb_OutdoorGrZones_m_BGrid_6__m_left
{0x0F12, 0x0274},	 //awbb_OutdoorGrZones_m_BGrid_6__m_right
{0x0F12, 0x01D2},	 //awbb_OutdoorGrZones_m_BGrid_7__m_left
{0x0F12, 0x0268},	 //awbb_OutdoorGrZones_m_BGrid_7__m_right
{0x0F12, 0x01D0},	 //awbb_OutdoorGrZones_m_BGrid_8__m_left
{0x0F12, 0x025E},	 //awbb_OutdoorGrZones_m_BGrid_8__m_right
{0x0F12, 0x01D6},	 //awbb_OutdoorGrZones_m_BGrid_9__m_left
{0x0F12, 0x0252},	 //awbb_OutdoorGrZones_m_BGrid_9__m_right
{0x0F12, 0x01E2},	 //awbb_OutdoorGrZones_m_BGrid_10__m_left
{0x0F12, 0x0248},	 //awbb_OutdoorGrZones_m_BGrid_10__m_right
{0x0F12, 0x01F4},	 //awbb_OutdoorGrZones_m_BGrid_11__m_left
{0x0F12, 0x021A},	 //awbb_OutdoorGrZones_m_BGrid_11__m_right

{0x0F12, 0x0004},	 //awbb_OutdoorGrZones_m_GridStep
{0x002A, 0x10AC},
{0x0F12, 0x000C},	 //awbb_OutdoorGrZones_ZInfo_m_GridSz
{0x002A, 0x10B0},
{0x0F12, 0x01DA},	 //awbb_OutdoorGrZones_m_Boffs

// Low Brightness Zone
{0x002A, 0x10B4},
{0x0F12, 0x0348},	 //awbb_LowBrGrZones_m_BGrid_0__m_left
{0x0F12, 0x03B6},	 //awbb_LowBrGrZones_m_BGrid_0__m_right
{0x0F12, 0x02B8},	 //awbb_LowBrGrZones_m_BGrid_1__m_left
{0x0F12, 0x03B6},	 //awbb_LowBrGrZones_m_BGrid_1__m_right
{0x0F12, 0x0258},	 //awbb_LowBrGrZones_m_BGrid_2__m_left
{0x0F12, 0x038E},	 //awbb_LowBrGrZones_m_BGrid_2__m_right
{0x0F12, 0x0212},	 //awbb_LowBrGrZones_m_BGrid_3__m_left
{0x0F12, 0x0348},	 //awbb_LowBrGrZones_m_BGrid_3__m_right
{0x0F12, 0x01CC},	 //awbb_LowBrGrZones_m_BGrid_4__m_left
{0x0F12, 0x030C},	 //awbb_LowBrGrZones_m_BGrid_4__m_right
{0x0F12, 0x01A2},	 //awbb_LowBrGrZones_m_BGrid_5__m_left
{0x0F12, 0x02D2},	 //awbb_LowBrGrZones_m_BGrid_5__m_right
{0x0F12, 0x0170},	 //awbb_LowBrGrZones_m_BGrid_6__m_left
{0x0F12, 0x02A6},	 //awbb_LowBrGrZones_m_BGrid_6__m_right
{0x0F12, 0x014C},	 //awbb_LowBrGrZones_m_BGrid_7__m_left
{0x0F12, 0x0280},	 //awbb_LowBrGrZones_m_BGrid_7__m_right
{0x0F12, 0x0128},	 //awbb_LowBrGrZones_m_BGrid_8__m_left
{0x0F12, 0x025C},	 //awbb_LowBrGrZones_m_BGrid_8__m_right
{0x0F12, 0x0146},	 //awbb_LowBrGrZones_m_BGrid_9__m_left
{0x0F12, 0x0236},	 //awbb_LowBrGrZones_m_BGrid_9__m_right
{0x0F12, 0x0164},	 //awbb_LowBrGrZones_m_BGrid_10__m_left
{0x0F12, 0x0212},	 //awbb_LowBrGrZones_m_BGrid_10__m_right
{0x0F12, 0x0000},	 //awbb_LowBrGrZones_m_BGrid_11__m_left
{0x0F12, 0x0000},	 //awbb_LowBrGrZones_m_BGrid_11__m_right

{0x0F12, 0x0006},	 //awbb_LowBrGrZones_m_GridStep
{0x002A, 0x10E8},
{0x0F12, 0x000B},	 //awbb_LowBrGrZones_ZInfo_m_GridSz
{0x002A, 0x10EC},
{0x0F12, 0x00D2},	 //awbb_LowBrGrZones_m_Boffs

// Low Temp. Zone
{0x002A, 0x10F0},
{0x0F12, 0x039A},
{0x0F12, 0x0000},	 //awbb_CrclLowT_R_c
{0x0F12, 0x00FE},
{0x0F12, 0x0000},	 //awbb_CrclLowT_B_c
{0x0F12, 0x2284},
{0x0F12, 0x0000},	         //awbb_CrclLowT_Rad_c

//AWB - GridCorrection
{0x002A, 0x1434},
{0x0F12, 0x02C1},	 //awbb_GridConst_1_0_
{0x0F12, 0x033A},	 //awbb_GridConst_1_1_
{0x0F12, 0x038A},	 //awbb_GridConst_1_2_
{0x0F12, 0x101A},	 //awbb_GridConst_2_0_
{0x0F12, 0x1075},	 //awbb_GridConst_2_1_
{0x0F12, 0x113D},	 //awbb_GridConst_2_2_
{0x0F12, 0x113F},	 //awbb_GridConst_2_3_
{0x0F12, 0x11AF},	 //awbb_GridConst_2_4_
{0x0F12, 0x11F0},	 //awbb_GridConst_2_5_
{0x0F12, 0x00B2},	 //awbb_GridCoeff_R_1
{0x0F12, 0x00B8},	 //awbb_GridCoeff_B_1
{0x0F12, 0x00CA},	 //awbb_GridCoeff_R_2
{0x0F12, 0x009D},	 //awbb_GridCoeff_B_2

// Indoor Grid Offset
{0x002A, 0x13A4},
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_0__0_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_0__1_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_0__2_
{0x0F12, 0xFFA0},	 //awbb_GridCorr_R_0__3_
{0x0F12, 0xFFEE},	 //awbb_GridCorr_R_0__4_
{0x0F12, 0x0096},	 //awbb_GridCorr_R_0__5_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_1__0_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_1__1_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_1__2_
{0x0F12, 0xFFA0},	 //awbb_GridCorr_R_1__3_
{0x0F12, 0xFFEE},	 //awbb_GridCorr_R_1__4_
{0x0F12, 0x0096},	 //awbb_GridCorr_R_1__5_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_2__0_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_2__1_
{0x0F12, 0xFFE0},	 //awbb_GridCorr_R_2__2_
{0x0F12, 0xFFA0},	 //awbb_GridCorr_R_2__3_
{0x0F12, 0xFFEE},	 //awbb_GridCorr_R_2__4_
{0x0F12, 0x0096},	 //awbb_GridCorr_R_2__5_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_0__0_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_0__1_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_0__2_
{0x0F12, 0xFF38},	 //awbb_GridCorr_B_0__3_
{0x0F12, 0xFEF2},	 //awbb_GridCorr_B_0__4_
{0x0F12, 0xFE5C},	 //awbb_GridCorr_B_0__5_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_1__0_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_1__1_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_1__2_
{0x0F12, 0xFF38},	 //awbb_GridCorr_B_1__3_
{0x0F12, 0xFEF2},	 //awbb_GridCorr_B_1__4_
{0x0F12, 0xFE5C},	 //awbb_GridCorr_B_1__5_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_2__0_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_2__1_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_B_2__2_
{0x0F12, 0xFF38},	 //awbb_GridCorr_B_2__3_
{0x0F12, 0xFEF2},	 //awbb_GridCorr_B_2__4_
{0x0F12, 0xFE5C},	 //awbb_GridCorr_B_2__5_

// Outdoor Grid Offset
{0x0F12, 0xFFC0},	 //awbb_GridCorr_R_Out_0__0_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_0__1_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_0__2_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_0__3_
{0x0F12, 0x0000},	 //awbb_GridCorr_R_Out_0__4_
{0x0F12, 0x0000},	 //awbb_GridCorr_R_Out_0__5_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_R_Out_1__0_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_1__1_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_1__2_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_1__3_
{0x0F12, 0x0000},	 //awbb_GridCorr_R_Out_1__4_
{0x0F12, 0x0000},	 //awbb_GridCorr_R_Out_1__5_
{0x0F12, 0xFFC0},	 //awbb_GridCorr_R_Out_2__0_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_2__1_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_2__2_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_R_Out_2__3_
{0x0F12, 0x0000},	 //awbb_GridCorr_R_Out_2__4_
{0x0F12, 0x0000},	 //awbb_GridCorr_R_Out_2__5_
{0x0F12, 0x0010},	 //awbb_GridCorr_B_Out_0__0_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_0__1_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_0__2_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_0__3_
{0x0F12, 0x0000},	 //awbb_GridCorr_B_Out_0__4_
{0x0F12, 0x0000},	 //awbb_GridCorr_B_Out_0__5_
{0x0F12, 0x0010},	 //awbb_GridCorr_B_Out_1__0_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_1__1_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_1__2_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_1__3_
{0x0F12, 0x0000},	 //awbb_GridCorr_B_Out_1__4_
{0x0F12, 0x0000},	 //awbb_GridCorr_B_Out_1__5_
{0x0F12, 0x0010},	 //awbb_GridCorr_B_Out_2__0_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_2__1_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_2__2_
{0x0F12, 0xFFD0},	 //awbb_GridCorr_B_Out_2__3_
{0x0F12, 0x0000},	 //awbb_GridCorr_B_Out_2__4_
{0x0F12, 0x0000},	 //awbb_GridCorr_B_Out_2__5_

//==================================================================================
// 15.CCM Setting
//==================================================================================

{0x002A, 0x08A6},
{0x0F12, 0x0050},	 //SARR_AwbCcmCord_0_
{0x0F12, 0x00F0},	 //SARR_AwbCcmCord_1_
{0x0F12, 0x0110},	 //SARR_AwbCcmCord_2_
{0x0F12, 0x0120},	 //SARR_AwbCcmCord_3_
{0x0F12, 0x0130},	 //SARR_AwbCcmCord_4_
{0x0F12, 0x0162},	 //SARR_AwbCcmCord_5_

{0x0F12, 0x0001},	 //wbt_bUseOutdoorCCM

{0x002A, 0x0898},
{0x0F12, 0x4800},	 //TVAR_wbt_pBaseCcms
{0x0F12, 0x7000},
{0x002A, 0x08A0},
{0x0F12, 0x48D8},	 //TVAR_wbt_pOutdoorCcm
{0x0F12, 0x7000},

{0x002A, 0x4800},
{0x0F12, 0x0119},	 //TVAR_wbt_pBaseCcms[0]  // Horizon
{0x0F12, 0xFFA9},	 //TVAR_wbt_pBaseCcms[1]
{0x0F12, 0xFF9D},	 //TVAR_wbt_pBaseCcms[2]
{0x0F12, 0xFF30},	 //TVAR_wbt_pBaseCcms[3]
{0x0F12, 0x0130},	 //TVAR_wbt_pBaseCcms[4]
{0x0F12, 0xFF8E},	 //TVAR_wbt_pBaseCcms[5]
{0x0F12, 0xFFF8},	 //TVAR_wbt_pBaseCcms[6]
{0x0F12, 0xFFAC},	 //TVAR_wbt_pBaseCcms[7]
{0x0F12, 0x0137},	 //TVAR_wbt_pBaseCcms[8]
{0x0F12, 0x0087},	 //TVAR_wbt_pBaseCcms[9]
{0x0F12, 0x00D0},	 //TVAR_wbt_pBaseCcms[10]
{0x0F12, 0xFEE3},	 //TVAR_wbt_pBaseCcms[11]
{0x0F12, 0x0162},	 //TVAR_wbt_pBaseCcms[12]
{0x0F12, 0xFF77},	 //TVAR_wbt_pBaseCcms[13]
{0x0F12, 0x00E8},	 //TVAR_wbt_pBaseCcms[14]
{0x0F12, 0xFF40},	 //TVAR_wbt_pBaseCcms[15]
{0x0F12, 0x0114},	 //TVAR_wbt_pBaseCcms[16]
{0x0F12, 0x00F4},	 //TVAR_wbt_pBaseCcms[17]

{0x0F12, 0x0119},	 //TVAR_wbt_pBaseCcms[18]  // IncandA
{0x0F12, 0xFFA9},	 //TVAR_wbt_pBaseCcms[19]
{0x0F12, 0xFF9D},	 //TVAR_wbt_pBaseCcms[20]
{0x0F12, 0xFF30},	 //TVAR_wbt_pBaseCcms[21]
{0x0F12, 0x0130},	 //TVAR_wbt_pBaseCcms[22]
{0x0F12, 0xFF8E},	 //TVAR_wbt_pBaseCcms[23]
{0x0F12, 0xFFF8},	 //TVAR_wbt_pBaseCcms[24]
{0x0F12, 0xFFAC},	 //TVAR_wbt_pBaseCcms[25]
{0x0F12, 0x0137},	 //TVAR_wbt_pBaseCcms[26]
{0x0F12, 0x0087},	 //TVAR_wbt_pBaseCcms[27]
{0x0F12, 0x00D0},	 //TVAR_wbt_pBaseCcms[28]
{0x0F12, 0xFEE3},	 //TVAR_wbt_pBaseCcms[29]
{0x0F12, 0x0162},	 //TVAR_wbt_pBaseCcms[30]
{0x0F12, 0xFF77},	 //TVAR_wbt_pBaseCcms[31]
{0x0F12, 0x00E8},	 //TVAR_wbt_pBaseCcms[32]
{0x0F12, 0xFF40},	 //TVAR_wbt_pBaseCcms[33]
{0x0F12, 0x0114},	 //TVAR_wbt_pBaseCcms[34]
{0x0F12, 0x00F4},	 //TVAR_wbt_pBaseCcms[35]

{0x0F12, 0x0204},	 //TVAR_wbt_pBaseCcms[36]  // WW
{0x0F12, 0xFFB2},	 //TVAR_wbt_pBaseCcms[37]
{0x0F12, 0xFFF5},	 //TVAR_wbt_pBaseCcms[38]
{0x0F12, 0xFEE7},	 //TVAR_wbt_pBaseCcms[39]
{0x0F12, 0x0161},	 //TVAR_wbt_pBaseCcms[40]
{0x0F12, 0xFF10},	 //TVAR_wbt_pBaseCcms[41]
{0x0F12, 0xFFDD},	 //TVAR_wbt_pBaseCcms[42]
{0x0F12, 0xFFE6},	 //TVAR_wbt_pBaseCcms[43]
{0x0F12, 0x01B2},	 //TVAR_wbt_pBaseCcms[44]
{0x0F12, 0x00F2},	 //TVAR_wbt_pBaseCcms[45]
{0x0F12, 0x00CA},	 //TVAR_wbt_pBaseCcms[46]
{0x0F12, 0xFF48},	 //TVAR_wbt_pBaseCcms[47]
{0x0F12, 0x0151},	 //TVAR_wbt_pBaseCcms[48]
{0x0F12, 0xFF50},	 //TVAR_wbt_pBaseCcms[49]
{0x0F12, 0x0147},	 //TVAR_wbt_pBaseCcms[50]
{0x0F12, 0xFF75},	 //TVAR_wbt_pBaseCcms[51]
{0x0F12, 0x01BA},	 //TVAR_wbt_pBaseCcms[52]
{0x0F12, 0x018C},	 //TVAR_wbt_pBaseCcms[53]

{0x0F12, 0x0204},	 //TVAR_wbt_pBaseCcms[54]  // CW
{0x0F12, 0xFFB2},	 //TVAR_wbt_pBaseCcms[55]
{0x0F12, 0xFFF5},	 //TVAR_wbt_pBaseCcms[56]
{0x0F12, 0xFEF1},	 //TVAR_wbt_pBaseCcms[57]
{0x0F12, 0x014E},	 //TVAR_wbt_pBaseCcms[58]
{0x0F12, 0xFF18},	 //TVAR_wbt_pBaseCcms[59]
{0x0F12, 0xFFE6},	 //TVAR_wbt_pBaseCcms[60]
{0x0F12, 0xFFDD},	 //TVAR_wbt_pBaseCcms[61]
{0x0F12, 0x01B2},	 //TVAR_wbt_pBaseCcms[62]
{0x0F12, 0x00F2},	 //TVAR_wbt_pBaseCcms[63]
{0x0F12, 0x00CA},	 //TVAR_wbt_pBaseCcms[64]
{0x0F12, 0xFF48},	 //TVAR_wbt_pBaseCcms[65]
{0x0F12, 0x0151},	 //TVAR_wbt_pBaseCcms[66]
{0x0F12, 0xFF50},	 //TVAR_wbt_pBaseCcms[67]
{0x0F12, 0x0147},	 //TVAR_wbt_pBaseCcms[68]
{0x0F12, 0xFF75},	 //TVAR_wbt_pBaseCcms[69]
{0x0F12, 0x0187},	 //TVAR_wbt_pBaseCcms[70]
{0x0F12, 0x01BF},	 //TVAR_wbt_pBaseCcms[71]

{0x0F12, 0x0204},	 //TVAR_wbt_pBaseCcms[72]  // D50
{0x0F12, 0xFFB2},	 //TVAR_wbt_pBaseCcms[73]
{0x0F12, 0xFFF5},	 //TVAR_wbt_pBaseCcms[74]
{0x0F12, 0xFEF1},	 //TVAR_wbt_pBaseCcms[75]
{0x0F12, 0x014E},	 //TVAR_wbt_pBaseCcms[76]
{0x0F12, 0xFF18},	 //TVAR_wbt_pBaseCcms[77]
{0x0F12, 0xFFE6},	 //TVAR_wbt_pBaseCcms[78]
{0x0F12, 0xFFDD},	 //TVAR_wbt_pBaseCcms[79]
{0x0F12, 0x01B2},	 //TVAR_wbt_pBaseCcms[80]
{0x0F12, 0x00F2},	 //TVAR_wbt_pBaseCcms[81]
{0x0F12, 0x00CA},	 //TVAR_wbt_pBaseCcms[82]
{0x0F12, 0xFF48},	 //TVAR_wbt_pBaseCcms[83]
{0x0F12, 0x0151},	 //TVAR_wbt_pBaseCcms[84]
{0x0F12, 0xFF50},	 //TVAR_wbt_pBaseCcms[85]
{0x0F12, 0x0147},	 //TVAR_wbt_pBaseCcms[86]
{0x0F12, 0xFF75},	 //TVAR_wbt_pBaseCcms[87]
{0x0F12, 0x0187},	 //TVAR_wbt_pBaseCcms[88]
{0x0F12, 0x01BF},	 //TVAR_wbt_pBaseCcms[89]

{0x0F12, 0x0204},	 //TVAR_wbt_pBaseCcms[90]  // D65
{0x0F12, 0xFFB2},	 //TVAR_wbt_pBaseCcms[91]
{0x0F12, 0xFFF5},	 //TVAR_wbt_pBaseCcms[92]
{0x0F12, 0xFEF1},	 //TVAR_wbt_pBaseCcms[93]
{0x0F12, 0x014E},	 //TVAR_wbt_pBaseCcms[94]
{0x0F12, 0xFF18},	 //TVAR_wbt_pBaseCcms[95]
{0x0F12, 0xFFE6},	 //TVAR_wbt_pBaseCcms[96]
{0x0F12, 0xFFDD},	 //TVAR_wbt_pBaseCcms[97]
{0x0F12, 0x01B2},	 //TVAR_wbt_pBaseCcms[98]
{0x0F12, 0x00F2},	 //TVAR_wbt_pBaseCcms[99]
{0x0F12, 0x00CA},	 //TVAR_wbt_pBaseCcms[100]
{0x0F12, 0xFF48},	 //TVAR_wbt_pBaseCcms[101]
{0x0F12, 0x0151},	 //TVAR_wbt_pBaseCcms[102]
{0x0F12, 0xFF50},	 //TVAR_wbt_pBaseCcms[103]
{0x0F12, 0x0147},	 //TVAR_wbt_pBaseCcms[104]
{0x0F12, 0xFF75},	 //TVAR_wbt_pBaseCcms[105]
{0x0F12, 0x0187},	 //TVAR_wbt_pBaseCcms[106]
{0x0F12, 0x01BF},	 //TVAR_wbt_pBaseCcms[107]

{0x0F12, 0x01E5},	 //TVAR_wbt_pOutdoorCcm[0]
{0x0F12, 0xFFA4},	 //TVAR_wbt_pOutdoorCcm[1]
{0x0F12, 0xFFDC},	 //TVAR_wbt_pOutdoorCcm[2]
{0x0F12, 0xFE87},	 //TVAR_wbt_pOutdoorCcm[3]
{0x0F12, 0x013C},	 //TVAR_wbt_pOutdoorCcm[4]
{0x0F12, 0xFF2A},	 //TVAR_wbt_pOutdoorCcm[5]
{0x0F12, 0xFFD2},	 //TVAR_wbt_pOutdoorCcm[6]
{0x0F12, 0xFFDF},	 //TVAR_wbt_pOutdoorCcm[7]
{0x0F12, 0x0236},	 //TVAR_wbt_pOutdoorCcm[8]
{0x0F12, 0x00EC},	 //TVAR_wbt_pOutdoorCcm[9]
{0x0F12, 0x00F8},	 //TVAR_wbt_pOutdoorCcm[10]
{0x0F12, 0xFF34},	 //TVAR_wbt_pOutdoorCcm[11]
{0x0F12, 0x01CE},	 //TVAR_wbt_pOutdoorCcm[12]
{0x0F12, 0xFF83},	 //TVAR_wbt_pOutdoorCcm[13]
{0x0F12, 0x0195},	 //TVAR_wbt_pOutdoorCcm[14]
{0x0F12, 0xFEF3},	 //TVAR_wbt_pOutdoorCcm[15]
{0x0F12, 0x0126},	 //TVAR_wbt_pOutdoorCcm[16]
{0x0F12, 0x0162},	 //TVAR_wbt_pOutdoorCcm[17]


//==================================================================================
// 16.GAMMA
//==================================================================================

// Indoor Gamma
{0x002A, 0x0734},
{0x0F12, 0x0001},	 //SARR_usGammaLutRGBIndoor_0__0_
{0x0F12, 0x0003},	 //SARR_usGammaLutRGBIndoor_0__1_
{0x0F12, 0x000F},	 //SARR_usGammaLutRGBIndoor_0__2_
{0x0F12, 0x002B},	 //SARR_usGammaLutRGBIndoor_0__3_
{0x0F12, 0x0069},	 //SARR_usGammaLutRGBIndoor_0__4_
{0x0F12, 0x00D9},	 //SARR_usGammaLutRGBIndoor_0__5_
{0x0F12, 0x0138},	 //SARR_usGammaLutRGBIndoor_0__6_
{0x0F12, 0x0163},	 //SARR_usGammaLutRGBIndoor_0__7_
{0x0F12, 0x0189},	 //SARR_usGammaLutRGBIndoor_0__8_
{0x0F12, 0x01C6},	 //SARR_usGammaLutRGBIndoor_0__9_
{0x0F12, 0x01F8},	 //SARR_usGammaLutRGBIndoor_0__10_
{0x0F12, 0x0222},	 //SARR_usGammaLutRGBIndoor_0__11_
{0x0F12, 0x0249},	 //SARR_usGammaLutRGBIndoor_0__12_
{0x0F12, 0x028D},	 //SARR_usGammaLutRGBIndoor_0__13_
{0x0F12, 0x02C9},	 //SARR_usGammaLutRGBIndoor_0__14_
{0x0F12, 0x0327},	 //SARR_usGammaLutRGBIndoor_0__15_
{0x0F12, 0x0371},	 //SARR_usGammaLutRGBIndoor_0__16_
{0x0F12, 0x03AC},	 //SARR_usGammaLutRGBIndoor_0__17_
{0x0F12, 0x03DD},	 //SARR_usGammaLutRGBIndoor_0__18_
{0x0F12, 0x03FF},	 //SARR_usGammaLutRGBIndoor_0__19_
{0x0F12, 0x0001},	 //SARR_usGammaLutRGBIndoor_1__0_
{0x0F12, 0x0003},	 //SARR_usGammaLutRGBIndoor_1__1_
{0x0F12, 0x000F},	 //SARR_usGammaLutRGBIndoor_1__2_
{0x0F12, 0x002B},	 //SARR_usGammaLutRGBIndoor_1__3_
{0x0F12, 0x0069},	 //SARR_usGammaLutRGBIndoor_1__4_
{0x0F12, 0x00D9},	 //SARR_usGammaLutRGBIndoor_1__5_
{0x0F12, 0x0138},	 //SARR_usGammaLutRGBIndoor_1__6_
{0x0F12, 0x0163},	 //SARR_usGammaLutRGBIndoor_1__7_
{0x0F12, 0x0189},	 //SARR_usGammaLutRGBIndoor_1__8_
{0x0F12, 0x01C6},	 //SARR_usGammaLutRGBIndoor_1__9_
{0x0F12, 0x01F8},	 //SARR_usGammaLutRGBIndoor_1__10_
{0x0F12, 0x0222},	 //SARR_usGammaLutRGBIndoor_1__11_
{0x0F12, 0x0249},	 //SARR_usGammaLutRGBIndoor_1__12_
{0x0F12, 0x028D},	 //SARR_usGammaLutRGBIndoor_1__13_
{0x0F12, 0x02C9},	 //SARR_usGammaLutRGBIndoor_1__14_
{0x0F12, 0x0327},	 //SARR_usGammaLutRGBIndoor_1__15_
{0x0F12, 0x0371},	 //SARR_usGammaLutRGBIndoor_1__16_
{0x0F12, 0x03AC},	 //SARR_usGammaLutRGBIndoor_1__17_
{0x0F12, 0x03DD},	 //SARR_usGammaLutRGBIndoor_1__18_
{0x0F12, 0x03FF},	 //SARR_usGammaLutRGBIndoor_1__19_
{0x0F12, 0x0001},	 //SARR_usGammaLutRGBIndoor_2__0_
{0x0F12, 0x0003},	 //SARR_usGammaLutRGBIndoor_2__1_
{0x0F12, 0x000F},	 //SARR_usGammaLutRGBIndoor_2__2_
{0x0F12, 0x002B},	 //SARR_usGammaLutRGBIndoor_2__3_
{0x0F12, 0x0069},	 //SARR_usGammaLutRGBIndoor_2__4_
{0x0F12, 0x00D9},	 //SARR_usGammaLutRGBIndoor_2__5_
{0x0F12, 0x0138},	 //SARR_usGammaLutRGBIndoor_2__6_
{0x0F12, 0x0163},	 //SARR_usGammaLutRGBIndoor_2__7_
{0x0F12, 0x0189},	 //SARR_usGammaLutRGBIndoor_2__8_
{0x0F12, 0x01C6},	 //SARR_usGammaLutRGBIndoor_2__9_
{0x0F12, 0x01F8},	 //SARR_usGammaLutRGBIndoor_2__10_
{0x0F12, 0x0222},	 //SARR_usGammaLutRGBIndoor_2__11_
{0x0F12, 0x0249},	 //SARR_usGammaLutRGBIndoor_2__12_
{0x0F12, 0x028D},	 //SARR_usGammaLutRGBIndoor_2__13_
{0x0F12, 0x02C9},	 //SARR_usGammaLutRGBIndoor_2__14_
{0x0F12, 0x0327},	 //SARR_usGammaLutRGBIndoor_2__15_
{0x0F12, 0x0371},	 //SARR_usGammaLutRGBIndoor_2__16_
{0x0F12, 0x03AC},	 //SARR_usGammaLutRGBIndoor_2__17_
{0x0F12, 0x03DD},	 //SARR_usGammaLutRGBIndoor_2__18_
{0x0F12, 0x03FF},	 //SARR_usGammaLutRGBIndoor_2__19_

// Outdoor Gamma
{0x0F12, 0x0001},	 //SARR_usGammaLutRGBOutdoor_0__0_
{0x0F12, 0x000B},	 //SARR_usGammaLutRGBOutdoor_0__1_
{0x0F12, 0x0019},	 //SARR_usGammaLutRGBOutdoor_0__2_
{0x0F12, 0x0036},	 //SARR_usGammaLutRGBOutdoor_0__3_
{0x0F12, 0x006F},	 //SARR_usGammaLutRGBOutdoor_0__4_
{0x0F12, 0x00D8},	 //SARR_usGammaLutRGBOutdoor_0__5_
{0x0F12, 0x0135},	 //SARR_usGammaLutRGBOutdoor_0__6_
{0x0F12, 0x015F},	 //SARR_usGammaLutRGBOutdoor_0__7_
{0x0F12, 0x0185},	 //SARR_usGammaLutRGBOutdoor_0__8_
{0x0F12, 0x01C1},	 //SARR_usGammaLutRGBOutdoor_0__9_
{0x0F12, 0x01F3},	 //SARR_usGammaLutRGBOutdoor_0__10_
{0x0F12, 0x0220},	 //SARR_usGammaLutRGBOutdoor_0__11_
{0x0F12, 0x024A},	 //SARR_usGammaLutRGBOutdoor_0__12_
{0x0F12, 0x0291},	 //SARR_usGammaLutRGBOutdoor_0__13_
{0x0F12, 0x02D0},	 //SARR_usGammaLutRGBOutdoor_0__14_
{0x0F12, 0x032A},	 //SARR_usGammaLutRGBOutdoor_0__15_
{0x0F12, 0x036A},	 //SARR_usGammaLutRGBOutdoor_0__16_
{0x0F12, 0x039F},	 //SARR_usGammaLutRGBOutdoor_0__17_
{0x0F12, 0x03CC},	 //SARR_usGammaLutRGBOutdoor_0__18_
{0x0F12, 0x03F9},	 //SARR_usGammaLutRGBOutdoor_0__19_
{0x0F12, 0x0001},	 //SARR_usGammaLutRGBOutdoor_1__0_
{0x0F12, 0x000B},	 //SARR_usGammaLutRGBOutdoor_1__1_
{0x0F12, 0x0019},	 //SARR_usGammaLutRGBOutdoor_1__2_
{0x0F12, 0x0036},	 //SARR_usGammaLutRGBOutdoor_1__3_
{0x0F12, 0x006F},	 //SARR_usGammaLutRGBOutdoor_1__4_
{0x0F12, 0x00D8},	 //SARR_usGammaLutRGBOutdoor_1__5_
{0x0F12, 0x0135},	 //SARR_usGammaLutRGBOutdoor_1__6_
{0x0F12, 0x015F},	 //SARR_usGammaLutRGBOutdoor_1__7_
{0x0F12, 0x0185},	 //SARR_usGammaLutRGBOutdoor_1__8_
{0x0F12, 0x01C1},	 //SARR_usGammaLutRGBOutdoor_1__9_
{0x0F12, 0x01F3},	 //SARR_usGammaLutRGBOutdoor_1__10_
{0x0F12, 0x0220},	 //SARR_usGammaLutRGBOutdoor_1__11_
{0x0F12, 0x024A},	 //SARR_usGammaLutRGBOutdoor_1__12_
{0x0F12, 0x0291},	 //SARR_usGammaLutRGBOutdoor_1__13_
{0x0F12, 0x02D0},	 //SARR_usGammaLutRGBOutdoor_1__14_
{0x0F12, 0x032A},	 //SARR_usGammaLutRGBOutdoor_1__15_
{0x0F12, 0x036A},	 //SARR_usGammaLutRGBOutdoor_1__16_
{0x0F12, 0x039F},	 //SARR_usGammaLutRGBOutdoor_1__17_
{0x0F12, 0x03CC},	 //SARR_usGammaLutRGBOutdoor_1__18_
{0x0F12, 0x03F9},	 //SARR_usGammaLutRGBOutdoor_1__19_
{0x0F12, 0x0001},	 //SARR_usGammaLutRGBOutdoor_2__0_
{0x0F12, 0x000B},	 //SARR_usGammaLutRGBOutdoor_2__1_
{0x0F12, 0x0019},	 //SARR_usGammaLutRGBOutdoor_2__2_
{0x0F12, 0x0036},	 //SARR_usGammaLutRGBOutdoor_2__3_
{0x0F12, 0x006F},	 //SARR_usGammaLutRGBOutdoor_2__4_
{0x0F12, 0x00D8},	 //SARR_usGammaLutRGBOutdoor_2__5_
{0x0F12, 0x0135},	 //SARR_usGammaLutRGBOutdoor_2__6_
{0x0F12, 0x015F},	 //SARR_usGammaLutRGBOutdoor_2__7_
{0x0F12, 0x0185},	 //SARR_usGammaLutRGBOutdoor_2__8_
{0x0F12, 0x01C1},	 //SARR_usGammaLutRGBOutdoor_2__9_
{0x0F12, 0x01F3},	 //SARR_usGammaLutRGBOutdoor_2__10_
{0x0F12, 0x0220},	 //SARR_usGammaLutRGBOutdoor_2__11_
{0x0F12, 0x024A},	 //SARR_usGammaLutRGBOutdoor_2__12_
{0x0F12, 0x0291},	 //SARR_usGammaLutRGBOutdoor_2__13_
{0x0F12, 0x02D0},	 //SARR_usGammaLutRGBOutdoor_2__14_
{0x0F12, 0x032A},	 //SARR_usGammaLutRGBOutdoor_2__15_
{0x0F12, 0x036A},	 //SARR_usGammaLutRGBOutdoor_2__16_
{0x0F12, 0x039F},	 //SARR_usGammaLutRGBOutdoor_2__17_
{0x0F12, 0x03CC},	 //SARR_usGammaLutRGBOutdoor_2__18_
{0x0F12, 0x03F9},	 //SARR_usGammaLutRGBOutdoor_2__19_

//==================================================================================
// 17.AFIT
//==================================================================================
{0x002A, 0x0944},
{0x0F12, 0x0050},	 //afit_uNoiseIndInDoor
{0x0F12, 0x00B0},	 //afit_uNoiseIndInDoor
{0x0F12, 0x0196},	 //afit_uNoiseIndInDoor
{0x0F12, 0x0245},	 //afit_uNoiseIndInDoor
{0x0F12, 0x0300},	 //afit_uNoiseIndInDoor

{0x002A, 0x0938},
{0x0F12, 0x0000},	 // on/off AFIT by NB option
{0x0F12, 0x0014},	 //SARR_uNormBrInDoor
{0x0F12, 0x00D2},	 //SARR_uNormBrInDoor
{0x0F12, 0x0384},	 //SARR_uNormBrInDoor
{0x0F12, 0x07D0},	 //SARR_uNormBrInDoor
{0x0F12, 0x1388},	 //SARR_uNormBrInDoor

{0x002A, 0x0976},
{0x0F12, 0x0070},	 //afit_usGamutTh
{0x0F12, 0x0005},	 //afit_usNeargrayOffset
{0x0F12, 0x0000},	 //afit_bUseSenBpr
{0x0F12, 0x01CC},	 //afit_usBprThr_0_
{0x0F12, 0x01CC},	 //afit_usBprThr_1_
{0x0F12, 0x01CC},	 //afit_usBprThr_2_
{0x0F12, 0x01CC},	 //afit_usBprThr_3_
{0x0F12, 0x01CC},	 //afit_usBprThr_4_
{0x0F12, 0x0180},	 //afit_NIContrastAFITValue
{0x0F12, 0x0196},	 //afit_NIContrastTh

{0x002A, 0x098C},
{0x0F12, 0x0000},	 //7000098C	 //_BRIGHTNESS	AFIT 0
{0x0F12, 0x0000},	 //7000098E	 //_CONTRAST
{0x0F12, 0x0000},	 //70000990	 //_SATURATION
{0x0F12, 0x0000},	 //70000992	 //_SHARP_BLUR
{0x0F12, 0x0000},	 //70000994	 //_GLAMOUR
{0x0F12, 0x00C0},	 //70000996	 //_bnr_edge_high
{0x0F12, 0x0064},	 //70000998	 //_postdmsc_iLowBright
{0x0F12, 0x0384},	 //7000099A	 //_postdmsc_iHighBright
{0x0F12, 0x005F},	 //7000099C	 //_postdmsc_iLowSat
{0x0F12, 0x01F4},	 //7000099E	 //_postdmsc_iHighSat
{0x0F12, 0x0070},	 //700009A0	 //_postdmsc_iTune
{0x0F12, 0x0040},	 //700009A2	 //_yuvemix_mNegRanges_0
{0x0F12, 0x00A0},	 //700009A4	 //_yuvemix_mNegRanges_1
{0x0F12, 0x0100},	 //700009A6	 //_yuvemix_mNegRanges_2
{0x0F12, 0x0010},	 //700009A8	 //_yuvemix_mPosRanges_0
{0x0F12, 0x0040},	 //700009AA	 //_yuvemix_mPosRanges_1
{0x0F12, 0x00A0},	 //700009AC	 //_yuvemix_mPosRanges_2
{0x0F12, 0x1430},	 //700009AE	 //_bnr_edge_low  [7:0] AFIT8_bnr_repl_thresh
{0x0F12, 0x0201},	 //700009B0	 //_bnr_repl_force  [7:0] AFIT8_bnr_iHotThreshHigh
{0x0F12, 0x0204},	 //700009B2	 //_bnr_iHotThreshLow   [7:0] AFIT8_bnr_iColdThreshHigh
{0x0F12, 0x3604},	 //700009B4	 //_bnr_iColdThreshLow   [7:0] AFIT8_bnr_DispTH_Low
{0x0F12, 0x032A},	 //700009B6	 //_bnr_DispTH_High   [7:0] AFIT8_bnr_DISP_Limit_Low
{0x0F12, 0x0403},	 //700009B8	 //_bnr_DISP_Limit_High   [7:0] AFIT8_bnr_iDistSigmaMin
{0x0F12, 0x1B06},	 //700009BA	 //_bnr_iDistSigmaMax   [7:0] AFIT8_bnr_iDiffSigmaLow
{0x0F12, 0x6015},	 //700009BC	 //_bnr_iDiffSigmaHigh   [7:0] AFIT8_bnr_iNormalizedSTD_TH
{0x0F12, 0x00C0},	 //700009BE	 //_bnr_iNormalizedSTD_Limit   [7:0] AFIT8_bnr_iDirNRTune
{0x0F12, 0x6080},	 //700009C0	 //_bnr_iDirMinThres   [7:0] AFIT8_bnr_iDirFltDiffThresHigh
{0x0F12, 0x4080},	 //700009C2	 //_bnr_iDirFltDiffThresLow   [7:0] AFIT8_bnr_iDirSmoothPowerHigh
{0x0F12, 0x0640},	 //700009C4	 //_bnr_iDirSmoothPowerLow   [7:0] AFIT8_bnr_iLowMaxSlopeAllowed
{0x0F12, 0x0306},	 //700009C6	 //_bnr_iHighMaxSlopeAllowed   [7:0] AFIT8_bnr_iLowSlopeThresh
{0x0F12, 0x2003},	 //700009C8	 //_bnr_iHighSlopeThresh   [7:0] AFIT8_bnr_iSlopenessTH
{0x0F12, 0xFF01},	 //700009CA	 //_bnr_iSlopeBlurStrength   [7:0] AFIT8_bnr_iSlopenessLimit
{0x0F12, 0x0000},	 //700009CC	 //_bnr_AddNoisePower1   [7:0] AFIT8_bnr_AddNoisePower2
{0x0F12, 0x0400},	 //700009CE	 //_bnr_iRadialTune   [7:0] AFIT8_bnr_iRadialPower
{0x0F12, 0x365A},	 //700009D0	 //_bnr_iRadialLimit   [7:0] AFIT8_ee_iFSMagThLow
{0x0F12, 0x102A},	 //700009D2	 //_ee_iFSMagThHigh   [7:0] AFIT8_ee_iFSVarThLow
{0x0F12, 0x000B},	 //700009D4	 //_ee_iFSVarThHigh   [7:0] AFIT8_ee_iFSThLow
{0x0F12, 0x0600},	 //700009D6	 //_ee_iFSThHigh   [7:0] AFIT8_ee_iFSmagPower
{0x0F12, 0x5A0F},	 //700009D8	 //_ee_iFSVarCountTh   [7:0] AFIT8_ee_iRadialLimit
{0x0F12, 0x0505},	 //700009DA	 //_ee_iRadialPower   [7:0] AFIT8_ee_iSmoothEdgeSlope
{0x0F12, 0x1802},	 //700009DC	 //_ee_iROADThres   [7:0] AFIT8_ee_iROADMaxNR
{0x0F12, 0x0000},	 //700009DE	 //_ee_iROADSubMaxNR   [7:0] AFIT8_ee_iROADSubThres
{0x0F12, 0x2006},	 //700009E0	 //_ee_iROADNeiThres   [7:0] AFIT8_ee_iROADNeiMaxNR
{0x0F12, 0x3028},	 //700009E2	 //_ee_iSmoothEdgeThres   [7:0] AFIT8_ee_iMSharpen
{0x0F12, 0x0418},	 //700009E4	 //_ee_iWSharpen   [7:0] AFIT8_ee_iMShThresh
{0x0F12, 0x0101},	 //700009E6	 //_ee_iWShThresh   [7:0] AFIT8_ee_iReduceNegative
{0x0F12, 0x0800},	 //700009E8	 //_ee_iEmbossCentAdd   [7:0] AFIT8_ee_iShDespeckle
{0x0F12, 0x1804},	 //700009EA	 //_ee_iReduceEdgeThresh   [7:0] AFIT8_dmsc_iEnhThresh
{0x0F12, 0x4008},	 //700009EC	 //_dmsc_iDesatThresh   [7:0] AFIT8_dmsc_iDemBlurHigh
{0x0F12, 0x0540},	 //700009EE	 //_dmsc_iDemBlurLow   [7:0] AFIT8_dmsc_iDemBlurRange
{0x0F12, 0x8006},	 //700009F0	 //_dmsc_iDecisionThresh   [7:0] AFIT8_dmsc_iCentGrad
{0x0F12, 0x0020},	 //700009F2	 //_dmsc_iMonochrom   [7:0] AFIT8_dmsc_iGBDenoiseVal
{0x0F12, 0x0000},	 //700009F4	 //_dmsc_iGRDenoiseVal   [7:0] AFIT8_dmsc_iEdgeDesatThrHigh
{0x0F12, 0x2000},	 //700009F6	 //_dmsc_iEdgeDesatThrLow   [7:0] AFIT8_dmsc_iEdgeDesat
{0x0F12, 0x0000},	 //700009F8	 //_dmsc_iNearGrayDesat   [7:0] AFIT8_dmsc_iEdgeDesatLimit
{0x0F12, 0x1E10},	 //700009FA	 //_postdmsc_iBCoeff   [7:0] AFIT8_postdmsc_iGCoeff
{0x0F12, 0x000B},	 //700009FC	 //_postdmsc_iWideMult   [7:0] AFIT8_yuvemix_mNegSlopes_0
{0x0F12, 0x0607},	 //700009FE	 //_yuvemix_mNegSlopes_1   [7:0] AFIT8_yuvemix_mNegSlopes_2
{0x0F12, 0x0005},	 //70000A00	 //_yuvemix_mNegSlopes_3   [7:0] AFIT8_yuvemix_mPosSlopes_0
{0x0F12, 0x0607},	 //70000A02	 //_yuvemix_mPosSlopes_1   [7:0] AFIT8_yuvemix_mPosSlopes_2
{0x0F12, 0x0705},	 //70000A04	 //_yuvemix_mPosSlopes_3   [7:0] AFIT8_yuviirnr_iXSupportY
{0x0F12, 0x0206},	 //70000A06	 //_yuviirnr_iXSupportUV   [7:0] AFIT8_yuviirnr_iLowYNorm
{0x0F12, 0x0304},	 //70000A08	 //_yuviirnr_iHighYNorm   [7:0] AFIT8_yuviirnr_iLowUVNorm
{0x0F12, 0x0309},	 //70000A0A	 //_yuviirnr_iHighUVNorm   [7:0] AFIT8_yuviirnr_iYNormShift
{0x0F12, 0x0305},	 //70000A0C	 //_yuviirnr_iUVNormShift   [7:0] AFIT8_yuviirnr_iVertLength_Y
{0x0F12, 0x2006},	 //70000A0E	 //_yuviirnr_iVertLength_UV   [7:0] AFIT8_yuviirnr_iDiffThreshL_Y
{0x0F12, 0x1320},	 //70000A10	 //_yuviirnr_iDiffThreshH_Y   [7:0] AFIT8_yuviirnr_iDiffThreshL_UV
{0x0F12, 0x1014},	 //70000A12	 //_yuviirnr_iDiffThreshH_UV   [7:0] AFIT8_yuviirnr_iMaxThreshL_Y
{0x0F12, 0x1010},	 //70000A14	 //_yuviirnr_iMaxThreshH_Y   [7:0] AFIT8_yuviirnr_iMaxThreshL_UV
{0x0F12, 0x0C10},	 //70000A16	 //_yuviirnr_iMaxThreshH_UV   [7:0] AFIT8_yuviirnr_iYNRStrengthL
{0x0F12, 0x1A0C},	 //70000A18	 //_yuviirnr_iYNRStrengthH   [7:0] AFIT8_yuviirnr_iUVNRStrengthL
{0x0F12, 0x4A18},	 //70000A1A	 //_yuviirnr_iUVNRStrengthH   [7:0] AFIT8_byr_gras_iShadingPower
{0x0F12, 0x0080},	 //70000A1C	 //_RGBGamma2_iLinearity   [7:0] AFIT8_RGBGamma2_iDarkReduce
{0x0F12, 0x0350},	 //70000A1E	 //_ccm_oscar_iSaturation   [7:0] AFIT8_RGB2YUV_iYOffset
{0x0F12, 0x0180},	 //70000A20	 //_RGB2YUV_iRGBGain   [7:0] AFIT8_bnr_nClustLevel_H
{0x0F12, 0x0A0A},	 //70000A22	 //_bnr_iClustMulT_H   [7:0] AFIT8_bnr_iClustMulT_C
{0x0F12, 0x0101},	 //70000A24	 //_bnr_iClustThresh_H   [7:0] AFIT8_bnr_iClustThresh_C
{0x0F12, 0x2A36},	 //70000A26	 //_bnr_iDenThreshLow   [7:0] AFIT8_bnr_iDenThreshHigh
{0x0F12, 0x6024},	 //70000A28	 //_ee_iLowSharpPower   [7:0] AFIT8_ee_iHighSharpPower
{0x0F12, 0x2A36},	 //70000A2A	 //_ee_iLowShDenoise   [7:0] AFIT8_ee_iHighShDenoise
{0x0F12, 0xFFFF},	 //70000A2C	 //_ee_iLowSharpClamp   [7:0] AFIT8_ee_iHighSharpClamp
{0x0F12, 0x0808},	 //70000A2E	 //_ee_iReduceEdgeMinMult   [7:0] AFIT8_ee_iReduceEdgeSlope
{0x0F12, 0x0A01},	 //70000A30	 //_bnr_nClustLevel_H_Bin   [7:0] AFIT8_bnr_iClustMulT_H_Bin
{0x0F12, 0x010A},	 //70000A32	 //_bnr_iClustMulT_C_Bin   [7:0] AFIT8_bnr_iClustThresh_H_Bin
{0x0F12, 0x2701},	 //70000A34	 //_bnr_iClustThresh_C_Bin   [7:0] AFIT8_bnr_iDenThreshLow_Bin
{0x0F12, 0x241E},	 //70000A36	 //_bnr_iDenThreshHigh_Bin   [7:0] AFIT8_ee_iLowSharpPower_Bin
{0x0F12, 0x2E60},	 //70000A38	 //_ee_iHighSharpPower_Bin   [7:0] AFIT8_ee_iLowShDenoise_Bin
{0x0F12, 0xFF22},	 //70000A3A	 //_ee_iHighShDenoise_Bin   [7:0] AFIT8_ee_iLowSharpClamp_Bin
{0x0F12, 0x40FF},	 //70000A3C	 //_ee_iHighSharpClamp_Bin   [7:0] AFIT8_ee_iReduceEdgeMinMult_Bin
{0x0F12, 0x0009},	 //70000A3E	 //_ee_iReduceEdgeSlope_Bin [7:0]
{0x0F12, 0x0001},	 //70000A40	 //_bnr_nClustLevel_C      [0]
{0x0F12, 0x0000},	 //70000A42	 //_BRIGHTNESS	AFIT 1
{0x0F12, 0x0000},	 //70000A44	 //_CONTRAST
{0x0F12, 0x0000},	 //70000A46	 //_SATURATION
{0x0F12, 0x0000},	 //70000A48	 //_SHARP_BLUR
{0x0F12, 0x0000},	 //70000A4A	 //_GLAMOUR
{0x0F12, 0x00C0},	 //70000A4C	 //_bnr_edge_high
{0x0F12, 0x0064},	 //70000A4E	 //_postdmsc_iLowBright
{0x0F12, 0x0384},	 //70000A50	 //_postdmsc_iHighBright
{0x0F12, 0x0051},	 //70000A52	 //_postdmsc_iLowSat
{0x0F12, 0x01F4},	 //70000A54	 //_postdmsc_iHighSat
{0x0F12, 0x0070},	 //70000A56	 //_postdmsc_iTune
{0x0F12, 0x0040},	 //70000A58	 //_yuvemix_mNegRanges_0
{0x0F12, 0x00A0},	 //70000A5A	 //_yuvemix_mNegRanges_1
{0x0F12, 0x0100},	 //70000A5C	 //_yuvemix_mNegRanges_2
{0x0F12, 0x0010},	 //70000A5E	 //_yuvemix_mPosRanges_0
{0x0F12, 0x0060},	 //70000A60	 //_yuvemix_mPosRanges_1
{0x0F12, 0x0100},	 //70000A62	 //_yuvemix_mPosRanges_2
{0x0F12, 0x1430},	 //70000A64	 //_bnr_edge_low  [7:0] AFIT8_bnr_repl_thresh
{0x0F12, 0x0201},	 //70000A66	 //_bnr_repl_force  [7:0] AFIT8_bnr_iHotThreshHigh
{0x0F12, 0x0204},	 //70000A68	 //_bnr_iHotThreshLow   [7:0] AFIT8_bnr_iColdThreshHigh
{0x0F12, 0x2404},	 //70000A6A	 //_bnr_iColdThreshLow   [7:0] AFIT8_bnr_DispTH_Low
{0x0F12, 0x031B},	 //70000A6C	 //_bnr_DispTH_High   [7:0] AFIT8_bnr_DISP_Limit_Low
{0x0F12, 0x0103},	 //70000A6E	 //_bnr_DISP_Limit_High   [7:0] AFIT8_bnr_iDistSigmaMin
{0x0F12, 0x1205},	 //70000A70	 //_bnr_iDistSigmaMax   [7:0] AFIT8_bnr_iDiffSigmaLow
{0x0F12, 0x400D},	 //70000A72	 //_bnr_iDiffSigmaHigh   [7:0] AFIT8_bnr_iNormalizedSTD_TH
{0x0F12, 0x0080},	 //70000A74	 //_bnr_iNormalizedSTD_Limit   [7:0] AFIT8_bnr_iDirNRTune
{0x0F12, 0x1980},	 //70000A76	 //_bnr_iDirMinThres   [7:0] AFIT8_bnr_iDirFltDiffThresHigh
{0x0F12, 0x272E},	 //70000A78	 //_bnr_iDirFltDiffThresLow   [7:0] AFIT8_bnr_iDirSmoothPowerHigh
{0x0F12, 0x0629},	 //70000A7A	 //_bnr_iDirSmoothPowerLow   [7:0] AFIT8_bnr_iLowMaxSlopeAllowed
{0x0F12, 0x0306},	 //70000A7C	 //_bnr_iHighMaxSlopeAllowed   [7:0] AFIT8_bnr_iLowSlopeThresh
{0x0F12, 0x2003},	 //70000A7E	 //_bnr_iHighSlopeThresh   [7:0] AFIT8_bnr_iSlopenessTH
{0x0F12, 0xFF01},	 //70000A80	 //_bnr_iSlopeBlurStrength   [7:0] AFIT8_bnr_iSlopenessLimit
{0x0F12, 0x0404},	 //70000A82	 //_bnr_AddNoisePower1   [7:0] AFIT8_bnr_AddNoisePower2
{0x0F12, 0x0300},	 //70000A84	 //_bnr_iRadialTune   [7:0] AFIT8_bnr_iRadialPower
{0x0F12, 0x245A},	 //70000A86	 //_bnr_iRadialLimit   [7:0] AFIT8_ee_iFSMagThLow
{0x0F12, 0x1018},	 //70000A88	 //_ee_iFSMagThHigh   [7:0] AFIT8_ee_iFSVarThLow
{0x0F12, 0x000B},	 //70000A8A	 //_ee_iFSVarThHigh   [7:0] AFIT8_ee_iFSThLow
{0x0F12, 0x0B00},	 //70000A8C	 //_ee_iFSThHigh   [7:0] AFIT8_ee_iFSmagPower
{0x0F12, 0x5A0F},	 //70000A8E	 //_ee_iFSVarCountTh   [7:0] AFIT8_ee_iRadialLimit
{0x0F12, 0x0505},	 //70000A90	 //_ee_iRadialPower   [7:0] AFIT8_ee_iSmoothEdgeSlope
{0x0F12, 0x1802},	 //70000A92	 //_ee_iROADThres   [7:0] AFIT8_ee_iROADMaxNR
{0x0F12, 0x0000},	 //70000A94	 //_ee_iROADSubMaxNR   [7:0] AFIT8_ee_iROADSubThres
{0x0F12, 0x2006},	 //70000A96	 //_ee_iROADNeiThres   [7:0] AFIT8_ee_iROADNeiMaxNR
{0x0F12, 0x3828},	 //70000A98	 //_ee_iSmoothEdgeThres   [7:0] AFIT8_ee_iMSharpen
{0x0F12, 0x0425},	 //70000A9A	 //_ee_iWSharpen   [7:0] AFIT8_ee_iMShThresh
{0x0F12, 0x0101},	 //70000A9C	 //_ee_iWShThresh   [7:0] AFIT8_ee_iReduceNegative
{0x0F12, 0x0800},	 //70000A9E	 //_ee_iEmbossCentAdd   [7:0] AFIT8_ee_iShDespeckle
{0x0F12, 0x1004},	 //70000AA0	 //_ee_iReduceEdgeThresh   [7:0] AFIT8_dmsc_iEnhThresh
{0x0F12, 0x4008},	 //70000AA2	 //_dmsc_iDesatThresh   [7:0] AFIT8_dmsc_iDemBlurHigh
{0x0F12, 0x0540},	 //70000AA4	 //_dmsc_iDemBlurLow   [7:0] AFIT8_dmsc_iDemBlurRange
{0x0F12, 0x8006},	 //70000AA6	 //_dmsc_iDecisionThresh   [7:0] AFIT8_dmsc_iCentGrad
{0x0F12, 0x0020},	 //70000AA8	 //_dmsc_iMonochrom   [7:0] AFIT8_dmsc_iGBDenoiseVal
{0x0F12, 0x0000},	 //70000AAA	 //_dmsc_iGRDenoiseVal   [7:0] AFIT8_dmsc_iEdgeDesatThrHigh
{0x0F12, 0x2000},	 //70000AAC	 //_dmsc_iEdgeDesatThrLow   [7:0] AFIT8_dmsc_iEdgeDesat
{0x0F12, 0x0000},	 //70000AAE	 //_dmsc_iNearGrayDesat   [7:0] AFIT8_dmsc_iEdgeDesatLimit
{0x0F12, 0x1E10},	 //70000AB0	 //_postdmsc_iBCoeff   [7:0] AFIT8_postdmsc_iGCoeff
{0x0F12, 0x000B},	 //70000AB2	 //_postdmsc_iWideMult   [7:0] AFIT8_yuvemix_mNegSlopes_0
{0x0F12, 0x0607},	 //70000AB4	 //_yuvemix_mNegSlopes_1   [7:0] AFIT8_yuvemix_mNegSlopes_2
{0x0F12, 0x0005},	 //70000AB6	 //_yuvemix_mNegSlopes_3   [7:0] AFIT8_yuvemix_mPosSlopes_0
{0x0F12, 0x0607},	 //70000AB8	 //_yuvemix_mPosSlopes_1   [7:0] AFIT8_yuvemix_mPosSlopes_2
{0x0F12, 0x0405},	 //70000ABA	 //_yuvemix_mPosSlopes_3   [7:0] AFIT8_yuviirnr_iXSupportY
{0x0F12, 0x0205},	 //70000ABC	 //_yuviirnr_iXSupportUV   [7:0] AFIT8_yuviirnr_iLowYNorm
{0x0F12, 0x0304},	 //70000ABE	 //_yuviirnr_iHighYNorm   [7:0] AFIT8_yuviirnr_iLowUVNorm
{0x0F12, 0x0409},	 //70000AC0	 //_yuviirnr_iHighUVNorm   [7:0] AFIT8_yuviirnr_iYNormShift
{0x0F12, 0x0306},	 //70000AC2	 //_yuviirnr_iUVNormShift   [7:0] AFIT8_yuviirnr_iVertLength_Y
{0x0F12, 0x0407},	 //70000AC4	 //_yuviirnr_iVertLength_UV   [7:0] AFIT8_yuviirnr_iDiffThreshL_Y
{0x0F12, 0x2204},	 //70000AC6	 //_yuviirnr_iDiffThreshH_Y   [7:0] AFIT8_yuviirnr_iDiffThreshL_UV
{0x0F12, 0x021C},	 //70000AC8	 //_yuviirnr_iDiffThreshH_UV   [7:0] AFIT8_yuviirnr_iMaxThreshL_Y
{0x0F12, 0x1102},	 //70000ACA	 //_yuviirnr_iMaxThreshH_Y   [7:0] AFIT8_yuviirnr_iMaxThreshL_UV
{0x0F12, 0x0611},	 //70000ACC	 //_yuviirnr_iMaxThreshH_UV   [7:0] AFIT8_yuviirnr_iYNRStrengthL
{0x0F12, 0x1A02},	 //70000ACE	 //_yuviirnr_iYNRStrengthH   [7:0] AFIT8_yuviirnr_iUVNRStrengthL
{0x0F12, 0x8018},	 //70000AD0	 //_yuviirnr_iUVNRStrengthH   [7:0] AFIT8_byr_gras_iShadingPower
{0x0F12, 0x0080},	 //70000AD2	 //_RGBGamma2_iLinearity   [7:0] AFIT8_RGBGamma2_iDarkReduce
{0x0F12, 0x0374},	 //70000AD4	 //_ccm_oscar_iSaturation   [7:0] AFIT8_RGB2YUV_iYOffset //
{0x0F12, 0x0180},	 //70000AD6	 //_RGB2YUV_iRGBGain   [7:0] AFIT8_bnr_nClustLevel_H
{0x0F12, 0x0A0A},	 //70000AD8	 //_bnr_iClustMulT_H   [7:0] AFIT8_bnr_iClustMulT_C
{0x0F12, 0x0101},	 //70000ADA	 //_bnr_iClustThresh_H   [7:0] AFIT8_bnr_iClustThresh_C
{0x0F12, 0x141D},	 //70000ADC	 //_bnr_iDenThreshLow   [7:0] AFIT8_bnr_iDenThreshHigh
{0x0F12, 0x6024},	 //70000ADE	 //_ee_iLowSharpPower   [7:0] AFIT8_ee_iHighSharpPower
{0x0F12, 0x1217},	 //70000AE0	 //_ee_iLowShDenoise   [7:0] AFIT8_ee_iHighShDenoise
{0x0F12, 0xFFFF},	 //70000AE2	 //_ee_iLowSharpClamp   [7:0] AFIT8_ee_iHighSharpClamp
{0x0F12, 0x0808},	 //70000AE4	 //_ee_iReduceEdgeMinMult   [7:0] AFIT8_ee_iReduceEdgeSlope
{0x0F12, 0x0A01},	 //70000AE6	 //_bnr_nClustLevel_H_Bin   [7:0] AFIT8_bnr_iClustMulT_H_Bin
{0x0F12, 0x010A},	 //70000AE8	 //_bnr_iClustMulT_C_Bin   [7:0] AFIT8_bnr_iClustThresh_H_Bin
{0x0F12, 0x0001},	 //70000AEA	 //_bnr_iClustThresh_C_Bin   [7:0] AFIT8_bnr_iDenThreshLow_Bin
{0x0F12, 0x2400},	 //70000AEC	 //_bnr_iDenThreshHigh_Bin   [7:0] AFIT8_ee_iLowSharpPower_Bin
{0x0F12, 0x1660},	 //70000AEE	 //_ee_iHighSharpPower_Bin   [7:0] AFIT8_ee_iLowShDenoise_Bin
{0x0F12, 0xFF10},	 //70000AF0	 //_ee_iHighShDenoise_Bin   [7:0] AFIT8_ee_iLowSharpClamp_Bin
{0x0F12, 0x40FF},	 //70000AF2	 //_ee_iHighSharpClamp_Bin   [7:0] AFIT8_ee_iReduceEdgeMinMult_Bin
{0x0F12, 0x0009},	 //70000AF4	 //_ee_iReduceEdgeSlope_Bin [7:0]
{0x0F12, 0x0001},	 //70000AF6	 //_bnr_nClustLevel_C      [0]
{0x0F12, 0x0000},	 //70000AF8	 //_BRIGHTNESS	AFIT 2
{0x0F12, 0x0000},	 //70000AFA	 //_CONTRAST
{0x0F12, 0x0000},	 //70000AFC	 //_SATURATION
{0x0F12, 0x0000},	 //70000AFE	 //_SHARP_BLUR
{0x0F12, 0x0000},	 //70000B00	 //_GLAMOUR
{0x0F12, 0x00C0},	 //70000B02	 //_bnr_edge_high
{0x0F12, 0x0064},	 //70000B04	 //_postdmsc_iLowBright
{0x0F12, 0x0384},	 //70000B06	 //_postdmsc_iHighBright
{0x0F12, 0x0043},	 //70000B08	 //_postdmsc_iLowSat
{0x0F12, 0x01F4},	 //70000B0A	 //_postdmsc_iHighSat
{0x0F12, 0x0070},	 //70000B0C	 //_postdmsc_iTune
{0x0F12, 0x0040},	 //70000B0E	 //_yuvemix_mNegRanges_0
{0x0F12, 0x00A0},	 //70000B10	 //_yuvemix_mNegRanges_1
{0x0F12, 0x0100},	 //70000B12	 //_yuvemix_mNegRanges_2
{0x0F12, 0x0010},	 //70000B14	 //_yuvemix_mPosRanges_0
{0x0F12, 0x0060},	 //70000B16	 //_yuvemix_mPosRanges_1
{0x0F12, 0x0100},	 //70000B18	 //_yuvemix_mPosRanges_2
{0x0F12, 0x1430},	 //70000B1A	 //_bnr_edge_low  [7:0] AFIT8_bnr_repl_thresh
{0x0F12, 0x0201},	 //70000B1C	 //_bnr_repl_force  [7:0] AFIT8_bnr_iHotThreshHigh
{0x0F12, 0x0204},	 //70000B1E	 //_bnr_iHotThreshLow   [7:0] AFIT8_bnr_iColdThreshHigh
{0x0F12, 0x1B04},	 //70000B20	 //_bnr_iColdThreshLow   [7:0] AFIT8_bnr_DispTH_Low
{0x0F12, 0x0312},	 //70000B22	 //_bnr_DispTH_High   [7:0] AFIT8_bnr_DISP_Limit_Low
{0x0F12, 0x0003},	 //70000B24	 //_bnr_DISP_Limit_High   [7:0] AFIT8_bnr_iDistSigmaMin
{0x0F12, 0x0C03},	 //70000B26	 //_bnr_iDistSigmaMax   [7:0] AFIT8_bnr_iDiffSigmaLow
{0x0F12, 0x2806},	 //70000B28	 //_bnr_iDiffSigmaHigh   [7:0] AFIT8_bnr_iNormalizedSTD_TH
{0x0F12, 0x0060},	 //70000B2A	 //_bnr_iNormalizedSTD_Limit   [7:0] AFIT8_bnr_iDirNRTune
{0x0F12, 0x1580},	 //70000B2C	 //_bnr_iDirMinThres   [7:0] AFIT8_bnr_iDirFltDiffThresHigh
{0x0F12, 0x2020},	 //70000B2E	 //_bnr_iDirFltDiffThresLow   [7:0] AFIT8_bnr_iDirSmoothPowerHigh
{0x0F12, 0x0620},	 //70000B30	 //_bnr_iDirSmoothPowerLow   [7:0] AFIT8_bnr_iLowMaxSlopeAllowed
{0x0F12, 0x0306},	 //70000B32	 //_bnr_iHighMaxSlopeAllowed   [7:0] AFIT8_bnr_iLowSlopeThresh
{0x0F12, 0x2003},	 //70000B34	 //_bnr_iHighSlopeThresh   [7:0] AFIT8_bnr_iSlopenessTH
{0x0F12, 0xFF01},	 //70000B36	 //_bnr_iSlopeBlurStrength   [7:0] AFIT8_bnr_iSlopenessLimit
{0x0F12, 0x0404},	 //70000B38	 //_bnr_AddNoisePower1   [7:0] AFIT8_bnr_AddNoisePower2
{0x0F12, 0x0300},	 //70000B3A	 //_bnr_iRadialTune   [7:0] AFIT8_bnr_iRadialPower
{0x0F12, 0x145A},	 //70000B3C	 //_bnr_iRadialLimit   [7:0] AFIT8_ee_iFSMagThLow
{0x0F12, 0x1010},	 //70000B3E	 //_ee_iFSMagThHigh   [7:0] AFIT8_ee_iFSVarThLow
{0x0F12, 0x000B},	 //70000B40	 //_ee_iFSVarThHigh   [7:0] AFIT8_ee_iFSThLow
{0x0F12, 0x0E00},	 //70000B42	 //_ee_iFSThHigh   [7:0] AFIT8_ee_iFSmagPower
{0x0F12, 0x5A0F},	 //70000B44	 //_ee_iFSVarCountTh   [7:0] AFIT8_ee_iRadialLimit
{0x0F12, 0x0504},	 //70000B46	 //_ee_iRadialPower   [7:0] AFIT8_ee_iSmoothEdgeSlope
{0x0F12, 0x1802},	 //70000B48	 //_ee_iROADThres   [7:0] AFIT8_ee_iROADMaxNR
{0x0F12, 0x0000},	 //70000B4A	 //_ee_iROADSubMaxNR   [7:0] AFIT8_ee_iROADSubThres
{0x0F12, 0x2006},	 //70000B4C	 //_ee_iROADNeiThres   [7:0] AFIT8_ee_iROADNeiMaxNR
{0x0F12, 0x3828},	 //70000B4E	 //_ee_iSmoothEdgeThres   [7:0] AFIT8_ee_iMSharpen
{0x0F12, 0x0428},	 //70000B50	 //_ee_iWSharpen   [7:0] AFIT8_ee_iMShThresh
{0x0F12, 0x0101},	 //70000B52	 //_ee_iWShThresh   [7:0] AFIT8_ee_iReduceNegative
{0x0F12, 0x8000},	 //70000B54	 //_ee_iEmbossCentAdd   [7:0] AFIT8_ee_iShDespeckle
{0x0F12, 0x0A04},	 //70000B56	 //_ee_iReduceEdgeThresh   [7:0] AFIT8_dmsc_iEnhThresh
{0x0F12, 0x4008},	 //70000B58	 //_dmsc_iDesatThresh   [7:0] AFIT8_dmsc_iDemBlurHigh
{0x0F12, 0x0540},	 //70000B5A	 //_dmsc_iDemBlurLow   [7:0] AFIT8_dmsc_iDemBlurRange
{0x0F12, 0x8006},	 //70000B5C	 //_dmsc_iDecisionThresh   [7:0] AFIT8_dmsc_iCentGrad
{0x0F12, 0x0020},	 //70000B5E	 //_dmsc_iMonochrom   [7:0] AFIT8_dmsc_iGBDenoiseVal
{0x0F12, 0x0000},	 //70000B60	 //_dmsc_iGRDenoiseVal   [7:0] AFIT8_dmsc_iEdgeDesatThrHigh
{0x0F12, 0x2000},	 //70000B62	 //_dmsc_iEdgeDesatThrLow   [7:0] AFIT8_dmsc_iEdgeDesat
{0x0F12, 0x0000},	 //70000B64	 //_dmsc_iNearGrayDesat   [7:0] AFIT8_dmsc_iEdgeDesatLimit
{0x0F12, 0x1E10},	 //70000B66	 //_postdmsc_iBCoeff   [7:0] AFIT8_postdmsc_iGCoeff
{0x0F12, 0x000B},	 //70000B68	 //_postdmsc_iWideMult   [7:0] AFIT8_yuvemix_mNegSlopes_0
{0x0F12, 0x0607},	 //70000B6A	 //_yuvemix_mNegSlopes_1   [7:0] AFIT8_yuvemix_mNegSlopes_2
{0x0F12, 0x0005},	 //70000B6C	 //_yuvemix_mNegSlopes_3   [7:0] AFIT8_yuvemix_mPosSlopes_0
{0x0F12, 0x0607},	 //70000B6E	 //_yuvemix_mPosSlopes_1   [7:0] AFIT8_yuvemix_mPosSlopes_2
{0x0F12, 0x0405},	 //70000B70	 //_yuvemix_mPosSlopes_3   [7:0] AFIT8_yuviirnr_iXSupportY
{0x0F12, 0x0207},	 //70000B72	 //_yuviirnr_iXSupportUV   [7:0] AFIT8_yuviirnr_iLowYNorm
{0x0F12, 0x0304},	 //70000B74	 //_yuviirnr_iHighYNorm   [7:0] AFIT8_yuviirnr_iLowUVNorm
{0x0F12, 0x0409},	 //70000B76	 //_yuviirnr_iHighUVNorm   [7:0] AFIT8_yuviirnr_iYNormShift
{0x0F12, 0x0306},	 //70000B78	 //_yuviirnr_iUVNormShift   [7:0] AFIT8_yuviirnr_iVertLength_Y
{0x0F12, 0x0407},	 //70000B7A	 //_yuviirnr_iVertLength_UV   [7:0] AFIT8_yuviirnr_iDiffThreshL_Y
{0x0F12, 0x2404},	 //70000B7C	 //_yuviirnr_iDiffThreshH_Y   [7:0] AFIT8_yuviirnr_iDiffThreshL_UV
{0x0F12, 0x0221},	 //70000B7E	 //_yuviirnr_iDiffThreshH_UV   [7:0] AFIT8_yuviirnr_iMaxThreshL_Y
{0x0F12, 0x1202},	 //70000B80	 //_yuviirnr_iMaxThreshH_Y   [7:0] AFIT8_yuviirnr_iMaxThreshL_UV
{0x0F12, 0x0613},	 //70000B82	 //_yuviirnr_iMaxThreshH_UV   [7:0] AFIT8_yuviirnr_iYNRStrengthL
{0x0F12, 0x1A02},	 //70000B84	 //_yuviirnr_iYNRStrengthH   [7:0] AFIT8_yuviirnr_iUVNRStrengthL
{0x0F12, 0x8018},	 //70000B86	 //_yuviirnr_iUVNRStrengthH   [7:0] AFIT8_byr_gras_iShadingPower
{0x0F12, 0x0080},	 //70000B88	 //_RGBGamma2_iLinearity   [7:0] AFIT8_RGBGamma2_iDarkReduce
{0x0F12, 0x0080},	 //70000B8A	 //_ccm_oscar_iSaturation   [7:0] AFIT8_RGB2YUV_iYOffset //
{0x0F12, 0x0180},	 //70000B8C	 //_RGB2YUV_iRGBGain   [7:0] AFIT8_bnr_nClustLevel_H
{0x0F12, 0x0A0A},	 //70000B8E	 //_bnr_iClustMulT_H   [7:0] AFIT8_bnr_iClustMulT_C
{0x0F12, 0x0101},	 //70000B90	 //_bnr_iClustThresh_H   [7:0] AFIT8_bnr_iClustThresh_C
{0x0F12, 0x121B},	 //70000B92	 //_bnr_iDenThreshLow   [7:0] AFIT8_bnr_iDenThreshHigh
{0x0F12, 0x6024},	 //70000B94	 //_ee_iLowSharpPower   [7:0] AFIT8_ee_iHighSharpPower
{0x0F12, 0x0C0C},	 //70000B96	 //_ee_iLowShDenoise   [7:0] AFIT8_ee_iHighShDenoise
{0x0F12, 0xFFFF},	 //70000B98	 //_ee_iLowSharpClamp   [7:0] AFIT8_ee_iHighSharpClamp
{0x0F12, 0x0808},	 //70000B9A	 //_ee_iReduceEdgeMinMult   [7:0] AFIT8_ee_iReduceEdgeSlope
{0x0F12, 0x0A01},	 //70000B9C	 //_bnr_nClustLevel_H_Bin   [7:0] AFIT8_bnr_iClustMulT_H_Bin
{0x0F12, 0x010A},	 //70000B9E	 //_bnr_iClustMulT_C_Bin   [7:0] AFIT8_bnr_iClustThresh_H_Bin
{0x0F12, 0x0001},	 //70000BA0	 //_bnr_iClustThresh_C_Bin   [7:0] AFIT8_bnr_iDenThreshLow_Bin
{0x0F12, 0x2400},	 //70000BA2	 //_bnr_iDenThreshHigh_Bin   [7:0] AFIT8_ee_iLowSharpPower_Bin
{0x0F12, 0x0460},	 //70000BA4	 //_ee_iHighSharpPower_Bin   [7:0] AFIT8_ee_iLowShDenoise_Bin
{0x0F12, 0xFF04},	 //70000BA6	 //_ee_iHighShDenoise_Bin   [7:0] AFIT8_ee_iLowSharpClamp_Bin
{0x0F12, 0x40FF},	 //70000BA8	 //_ee_iHighSharpClamp_Bin   [7:0] AFIT8_ee_iReduceEdgeMinMult_Bin
{0x0F12, 0x0009},	 //70000BAA	 //_ee_iReduceEdgeSlope_Bin [7:0]
{0x0F12, 0x0001},	 //70000BAC	 //_bnr_nClustLevel_C      [0]
{0x0F12, 0x0000},	 //70000BAE	 //_BRIGHTNESS	AFIT 3
{0x0F12, 0x0000},	 //70000BB0	 //_CONTRAST
{0x0F12, 0x0000},	 //70000BB2	 //_SATURATION
{0x0F12, 0x0000},	 //70000BB4	 //_SHARP_BLUR
{0x0F12, 0x0000},	 //70000BB6	 //_GLAMOUR
{0x0F12, 0x00C0},	 //70000BB8	 //_bnr_edge_high
{0x0F12, 0x0064},	 //70000BBA	 //_postdmsc_iLowBright
{0x0F12, 0x0384},	 //70000BBC	 //_postdmsc_iHighBright
{0x0F12, 0x0032},	 //70000BBE	 //_postdmsc_iLowSat
{0x0F12, 0x01F4},	 //70000BC0	 //_postdmsc_iHighSat
{0x0F12, 0x0070},	 //70000BC2	 //_postdmsc_iTune
{0x0F12, 0x0040},	 //70000BC4	 //_yuvemix_mNegRanges_0
{0x0F12, 0x00A0},	 //70000BC6	 //_yuvemix_mNegRanges_1
{0x0F12, 0x0100},	 //70000BC8	 //_yuvemix_mNegRanges_2
{0x0F12, 0x0010},	 //70000BCA	 //_yuvemix_mPosRanges_0
{0x0F12, 0x0060},	 //70000BCC	 //_yuvemix_mPosRanges_1
{0x0F12, 0x0100},	 //70000BCE	 //_yuvemix_mPosRanges_2
{0x0F12, 0x1430},	 //70000BD0	 //_bnr_edge_low  [7:0] AFIT8_bnr_repl_thresh
{0x0F12, 0x0201},	 //70000BD2	 //_bnr_repl_force  [7:0] AFIT8_bnr_iHotThreshHigh
{0x0F12, 0x0204},	 //70000BD4	 //_bnr_iHotThreshLow   [7:0] AFIT8_bnr_iColdThreshHigh
{0x0F12, 0x1504},	 //70000BD6	 //_bnr_iColdThreshLow   [7:0] AFIT8_bnr_DispTH_Low
{0x0F12, 0x030F},	 //70000BD8	 //_bnr_DispTH_High   [7:0] AFIT8_bnr_DISP_Limit_Low
{0x0F12, 0x0003},	 //70000BDA	 //_bnr_DISP_Limit_High   [7:0] AFIT8_bnr_iDistSigmaMin
{0x0F12, 0x0902},	 //70000BDC	 //_bnr_iDistSigmaMax   [7:0] AFIT8_bnr_iDiffSigmaLow
{0x0F12, 0x2004},	 //70000BDE	 //_bnr_iDiffSigmaHigh   [7:0] AFIT8_bnr_iNormalizedSTD_TH
{0x0F12, 0x0050},	 //70000BE0	 //_bnr_iNormalizedSTD_Limit   [7:0] AFIT8_bnr_iDirNRTune
{0x0F12, 0x1140},	 //70000BE2	 //_bnr_iDirMinThres   [7:0] AFIT8_bnr_iDirFltDiffThresHigh
{0x0F12, 0x201C},	 //70000BE4	 //_bnr_iDirFltDiffThresLow   [7:0] AFIT8_bnr_iDirSmoothPowerHigh
{0x0F12, 0x0620},	 //70000BE6	 //_bnr_iDirSmoothPowerLow   [7:0] AFIT8_bnr_iLowMaxSlopeAllowed
{0x0F12, 0x0306},	 //70000BE8	 //_bnr_iHighMaxSlopeAllowed   [7:0] AFIT8_bnr_iLowSlopeThresh
{0x0F12, 0x2003},	 //70000BEA	 //_bnr_iHighSlopeThresh   [7:0] AFIT8_bnr_iSlopenessTH
{0x0F12, 0xFF01},	 //70000BEC	 //_bnr_iSlopeBlurStrength   [7:0] AFIT8_bnr_iSlopenessLimit
{0x0F12, 0x0404},	 //70000BEE	 //_bnr_AddNoisePower1   [7:0] AFIT8_bnr_AddNoisePower2
{0x0F12, 0x0300},	 //70000BF0	 //_bnr_iRadialTune   [7:0] AFIT8_bnr_iRadialPower
{0x0F12, 0x145A},	 //70000BF2	 //_bnr_iRadialLimit   [7:0] AFIT8_ee_iFSMagThLow
{0x0F12, 0x1010},	 //70000BF4	 //_ee_iFSMagThHigh   [7:0] AFIT8_ee_iFSVarThLow
{0x0F12, 0x000B},	 //70000BF6	 //_ee_iFSVarThHigh   [7:0] AFIT8_ee_iFSThLow
{0x0F12, 0x1000},	 //70000BF8	 //_ee_iFSThHigh   [7:0] AFIT8_ee_iFSmagPower
{0x0F12, 0x5A0F},	 //70000BFA	 //_ee_iFSVarCountTh   [7:0] AFIT8_ee_iRadialLimit
{0x0F12, 0x0503},	 //70000BFC	 //_ee_iRadialPower   [7:0] AFIT8_ee_iSmoothEdgeSlope
{0x0F12, 0x1802},	 //70000BFE	 //_ee_iROADThres   [7:0] AFIT8_ee_iROADMaxNR
{0x0F12, 0x0000},	 //70000C00	 //_ee_iROADSubMaxNR   [7:0] AFIT8_ee_iROADSubThres
{0x0F12, 0x2006},	 //70000C02	 //_ee_iROADNeiThres   [7:0] AFIT8_ee_iROADNeiMaxNR
{0x0F12, 0x3C28},	 //70000C04	 //_ee_iSmoothEdgeThres   [7:0] AFIT8_ee_iMSharpen
{0x0F12, 0x042C},	 //70000C06	 //_ee_iWSharpen   [7:0] AFIT8_ee_iMShThresh
{0x0F12, 0x0101},	 //70000C08	 //_ee_iWShThresh   [7:0] AFIT8_ee_iReduceNegative
{0x0F12, 0xFF00},	 //70000C0A	 //_ee_iEmbossCentAdd   [7:0] AFIT8_ee_iShDespeckle
{0x0F12, 0x0904},	 //70000C0C	 //_ee_iReduceEdgeThresh   [7:0] AFIT8_dmsc_iEnhThresh
{0x0F12, 0x4008},	 //70000C0E	 //_dmsc_iDesatThresh   [7:0] AFIT8_dmsc_iDemBlurHigh
{0x0F12, 0x0540},	 //70000C10	 //_dmsc_iDemBlurLow   [7:0] AFIT8_dmsc_iDemBlurRange
{0x0F12, 0x8006},	 //70000C12	 //_dmsc_iDecisionThresh   [7:0] AFIT8_dmsc_iCentGrad
{0x0F12, 0x0020},	 //70000C14	 //_dmsc_iMonochrom   [7:0] AFIT8_dmsc_iGBDenoiseVal
{0x0F12, 0x0000},	 //70000C16	 //_dmsc_iGRDenoiseVal   [7:0] AFIT8_dmsc_iEdgeDesatThrHigh
{0x0F12, 0x2000},	 //70000C18	 //_dmsc_iEdgeDesatThrLow   [7:0] AFIT8_dmsc_iEdgeDesat
{0x0F12, 0x0000},	 //70000C1A	 //_dmsc_iNearGrayDesat   [7:0] AFIT8_dmsc_iEdgeDesatLimit
{0x0F12, 0x1E10},	 //70000C1C	 //_postdmsc_iBCoeff   [7:0] AFIT8_postdmsc_iGCoeff
{0x0F12, 0x000B},	 //70000C1E	 //_postdmsc_iWideMult   [7:0] AFIT8_yuvemix_mNegSlopes_0
{0x0F12, 0x0607},	 //70000C20	 //_yuvemix_mNegSlopes_1   [7:0] AFIT8_yuvemix_mNegSlopes_2
{0x0F12, 0x0005},	 //70000C22	 //_yuvemix_mNegSlopes_3   [7:0] AFIT8_yuvemix_mPosSlopes_0
{0x0F12, 0x0607},	 //70000C24	 //_yuvemix_mPosSlopes_1   [7:0] AFIT8_yuvemix_mPosSlopes_2
{0x0F12, 0x0405},	 //70000C26	 //_yuvemix_mPosSlopes_3   [7:0] AFIT8_yuviirnr_iXSupportY
{0x0F12, 0x0206},	 //70000C28	 //_yuviirnr_iXSupportUV   [7:0] AFIT8_yuviirnr_iLowYNorm
{0x0F12, 0x0304},	 //70000C2A	 //_yuviirnr_iHighYNorm   [7:0] AFIT8_yuviirnr_iLowUVNorm
{0x0F12, 0x0409},	 //70000C2C	 //_yuviirnr_iHighUVNorm   [7:0] AFIT8_yuviirnr_iYNormShift
{0x0F12, 0x0305},	 //70000C2E	 //_yuviirnr_iUVNormShift   [7:0] AFIT8_yuviirnr_iVertLength_Y
{0x0F12, 0x0406},	 //70000C30	 //_yuviirnr_iVertLength_UV   [7:0] AFIT8_yuviirnr_iDiffThreshL_Y
{0x0F12, 0x2804},	 //70000C32	 //_yuviirnr_iDiffThreshH_Y   [7:0] AFIT8_yuviirnr_iDiffThreshL_UV
{0x0F12, 0x0228},	 //70000C34	 //_yuviirnr_iDiffThreshH_UV   [7:0] AFIT8_yuviirnr_iMaxThreshL_Y
{0x0F12, 0x1402},	 //70000C36	 //_yuviirnr_iMaxThreshH_Y   [7:0] AFIT8_yuviirnr_iMaxThreshL_UV
{0x0F12, 0x0618},	 //70000C38	 //_yuviirnr_iMaxThreshH_UV   [7:0] AFIT8_yuviirnr_iYNRStrengthL
{0x0F12, 0x1A02},	 //70000C3A	 //_yuviirnr_iYNRStrengthH   [7:0] AFIT8_yuviirnr_iUVNRStrengthL
{0x0F12, 0x8018},	 //70000C3C	 //_yuviirnr_iUVNRStrengthH   [7:0] AFIT8_byr_gras_iShadingPower
{0x0F12, 0x0080},	 //70000C3E	 //_RGBGamma2_iLinearity   [7:0] AFIT8_RGBGamma2_iDarkReduce
{0x0F12, 0x0080},	 //70000C40	 //_ccm_oscar_iSaturation   [7:0] AFIT8_RGB2YUV_iYOffset //
{0x0F12, 0x0180},	 //70000C42	 //_RGB2YUV_iRGBGain   [7:0] AFIT8_bnr_nClustLevel_H
{0x0F12, 0x0A0A},	 //70000C44	 //_bnr_iClustMulT_H   [7:0] AFIT8_bnr_iClustMulT_C
{0x0F12, 0x0101},	 //70000C46	 //_bnr_iClustThresh_H   [7:0] AFIT8_bnr_iClustThresh_C
{0x0F12, 0x0F15},	 //70000C48	 //_bnr_iDenThreshLow   [7:0] AFIT8_bnr_iDenThreshHigh
{0x0F12, 0x6024},	 //70000C4A	 //_ee_iLowSharpPower   [7:0] AFIT8_ee_iHighSharpPower
{0x0F12, 0x0A0A},	 //70000C4C	 //_ee_iLowShDenoise   [7:0] AFIT8_ee_iHighShDenoise
{0x0F12, 0xFFFF},	 //70000C4E	 //_ee_iLowSharpClamp   [7:0] AFIT8_ee_iHighSharpClamp
{0x0F12, 0x0808},	 //70000C50	 //_ee_iReduceEdgeMinMult   [7:0] AFIT8_ee_iReduceEdgeSlope
{0x0F12, 0x0A01},	 //70000C52	 //_bnr_nClustLevel_H_Bin   [7:0] AFIT8_bnr_iClustMulT_H_Bin
{0x0F12, 0x010A},	 //70000C54	 //_bnr_iClustMulT_C_Bin   [7:0] AFIT8_bnr_iClustThresh_H_Bin
{0x0F12, 0x0001},	 //70000C56	 //_bnr_iClustThresh_C_Bin   [7:0] AFIT8_bnr_iDenThreshLow_Bin
{0x0F12, 0x2400},	 //70000C58	 //_bnr_iDenThreshHigh_Bin   [7:0] AFIT8_ee_iLowSharpPower_Bin
{0x0F12, 0x0260},	 //70000C5A	 //_ee_iHighSharpPower_Bin   [7:0] AFIT8_ee_iLowShDenoise_Bin
{0x0F12, 0xFF02},	 //70000C5C	 //_ee_iHighShDenoise_Bin   [7:0] AFIT8_ee_iLowSharpClamp_Bin
{0x0F12, 0x40FF},	 //70000C5E	 //_ee_iHighSharpClamp_Bin   [7:0] AFIT8_ee_iReduceEdgeMinMult_Bin
{0x0F12, 0x0009},	 //70000C60	 //_ee_iReduceEdgeSlope_Bin [7:0]
{0x0F12, 0x0001},	 //70000C62	 //_bnr_nClustLevel_C      [0]
{0x0F12, 0x0000},	 //70000C64	 //_BRIGHTNESS	AFIT 4
{0x0F12, 0x0000},	 //70000C66	 //_CONTRAST
{0x0F12, 0x0000},	 //70000C68	 //_SATURATION
{0x0F12, 0x0000},	 //70000C6A	 //_SHARP_BLUR
{0x0F12, 0x0000},	 //70000C6C	 //_GLAMOUR
{0x0F12, 0x00C0},	 //70000C6E	 //_bnr_edge_high
{0x0F12, 0x0064},	 //70000C70	 //_postdmsc_iLowBright
{0x0F12, 0x0384},	 //70000C72	 //_postdmsc_iHighBright
{0x0F12, 0x0032},	 //70000C74	 //_postdmsc_iLowSat
{0x0F12, 0x01F4},	 //70000C76	 //_postdmsc_iHighSat
{0x0F12, 0x0070},	 //70000C78	 //_postdmsc_iTune
{0x0F12, 0x0040},	 //70000C7A	 //_yuvemix_mNegRanges_0
{0x0F12, 0x00A0},	 //70000C7C	 //_yuvemix_mNegRanges_1
{0x0F12, 0x0100},	 //70000C7E	 //_yuvemix_mNegRanges_2
{0x0F12, 0x0010},	 //70000C80	 //_yuvemix_mPosRanges_0
{0x0F12, 0x0060},	 //70000C82	 //_yuvemix_mPosRanges_1
{0x0F12, 0x0100},	 //70000C84	 //_yuvemix_mPosRanges_2
{0x0F12, 0x1430},	 //70000C86	 //_bnr_edge_low  [7:0] AFIT8_bnr_repl_thresh
{0x0F12, 0x0201},	 //70000C88	 //_bnr_repl_force  [7:0] AFIT8_bnr_iHotThreshHigh
{0x0F12, 0x0204},	 //70000C8A	 //_bnr_iHotThreshLow   [7:0] AFIT8_bnr_iColdThreshHigh
{0x0F12, 0x0F04},	 //70000C8C	 //_bnr_iColdThreshLow   [7:0] AFIT8_bnr_DispTH_Low
{0x0F12, 0x030C},	 //70000C8E	 //_bnr_DispTH_High   [7:0] AFIT8_bnr_DISP_Limit_Low
{0x0F12, 0x0003},	 //70000C90	 //_bnr_DISP_Limit_High   [7:0] AFIT8_bnr_iDistSigmaMin
{0x0F12, 0x0602},	 //70000C92	 //_bnr_iDistSigmaMax   [7:0] AFIT8_bnr_iDiffSigmaLow
{0x0F12, 0x1803},	 //70000C94	 //_bnr_iDiffSigmaHigh   [7:0] AFIT8_bnr_iNormalizedSTD_TH
{0x0F12, 0x0040},	 //70000C96	 //_bnr_iNormalizedSTD_Limit   [7:0] AFIT8_bnr_iDirNRTune
{0x0F12, 0x0E20},	 //70000C98	 //_bnr_iDirMinThres   [7:0] AFIT8_bnr_iDirFltDiffThresHigh
{0x0F12, 0x2018},	 //70000C9A	 //_bnr_iDirFltDiffThresLow   [7:0] AFIT8_bnr_iDirSmoothPowerHigh
{0x0F12, 0x0620},	 //70000C9C	 //_bnr_iDirSmoothPowerLow   [7:0] AFIT8_bnr_iLowMaxSlopeAllowed
{0x0F12, 0x0306},	 //70000C9E	 //_bnr_iHighMaxSlopeAllowed   [7:0] AFIT8_bnr_iLowSlopeThresh
{0x0F12, 0x2003},	 //70000CA0	 //_bnr_iHighSlopeThresh   [7:0] AFIT8_bnr_iSlopenessTH
{0x0F12, 0xFF01},	 //70000CA2	 //_bnr_iSlopeBlurStrength   [7:0] AFIT8_bnr_iSlopenessLimit
{0x0F12, 0x0404},	 //70000CA4	 //_bnr_AddNoisePower1   [7:0] AFIT8_bnr_AddNoisePower2
{0x0F12, 0x0200},	 //70000CA6	 //_bnr_iRadialTune   [7:0] AFIT8_bnr_iRadialPower
{0x0F12, 0x145A},	 //70000CA8	 //_bnr_iRadialLimit   [7:0] AFIT8_ee_iFSMagThLow
{0x0F12, 0x1010},	 //70000CAA	 //_ee_iFSMagThHigh   [7:0] AFIT8_ee_iFSVarThLow
{0x0F12, 0x000B},	 //70000CAC	 //_ee_iFSVarThHigh   [7:0] AFIT8_ee_iFSThLow
{0x0F12, 0x1200},	 //70000CAE	 //_ee_iFSThHigh   [7:0] AFIT8_ee_iFSmagPower
{0x0F12, 0x5A0F},	 //70000CB0	 //_ee_iFSVarCountTh   [7:0] AFIT8_ee_iRadialLimit
{0x0F12, 0x0502},	 //70000CB2	 //_ee_iRadialPower   [7:0] AFIT8_ee_iSmoothEdgeSlope
{0x0F12, 0x1802},	 //70000CB4	 //_ee_iROADThres   [7:0] AFIT8_ee_iROADMaxNR
{0x0F12, 0x0000},	 //70000CB6	 //_ee_iROADSubMaxNR   [7:0] AFIT8_ee_iROADSubThres
{0x0F12, 0x2006},	 //70000CB8	 //_ee_iROADNeiThres   [7:0] AFIT8_ee_iROADNeiMaxNR
{0x0F12, 0x4028},	 //70000CBA	 //_ee_iSmoothEdgeThres   [7:0] AFIT8_ee_iMSharpen
{0x0F12, 0x0430},	 //70000CBC	 //_ee_iWSharpen   [7:0] AFIT8_ee_iMShThresh
{0x0F12, 0x0101},	 //70000CBE	 //_ee_iWShThresh   [7:0] AFIT8_ee_iReduceNegative
{0x0F12, 0xFF00},	 //70000CC0	 //_ee_iEmbossCentAdd   [7:0] AFIT8_ee_iShDespeckle
{0x0F12, 0x0804},	 //70000CC2	 //_ee_iReduceEdgeThresh   [7:0] AFIT8_dmsc_iEnhThresh
{0x0F12, 0x4008},	 //70000CC4	 //_dmsc_iDesatThresh   [7:0] AFIT8_dmsc_iDemBlurHigh
{0x0F12, 0x0540},	 //70000CC6	 //_dmsc_iDemBlurLow   [7:0] AFIT8_dmsc_iDemBlurRange
{0x0F12, 0x8006},	 //70000CC8	 //_dmsc_iDecisionThresh   [7:0] AFIT8_dmsc_iCentGrad
{0x0F12, 0x0020},	 //70000CCA	 //_dmsc_iMonochrom   [7:0] AFIT8_dmsc_iGBDenoiseVal
{0x0F12, 0x0000},	 //70000CCC	 //_dmsc_iGRDenoiseVal   [7:0] AFIT8_dmsc_iEdgeDesatThrHigh
{0x0F12, 0x2000},	 //70000CCE	 //_dmsc_iEdgeDesatThrLow   [7:0] AFIT8_dmsc_iEdgeDesat
{0x0F12, 0x0000},	 //70000CD0	 //_dmsc_iNearGrayDesat   [7:0] AFIT8_dmsc_iEdgeDesatLimit
{0x0F12, 0x1E10},	 //70000CD2	 //_postdmsc_iBCoeff   [7:0] AFIT8_postdmsc_iGCoeff
{0x0F12, 0x000B},	 //70000CD4	 //_postdmsc_iWideMult   [7:0] AFIT8_yuvemix_mNegSlopes_0
{0x0F12, 0x0607},	 //70000CD6	 //_yuvemix_mNegSlopes_1   [7:0] AFIT8_yuvemix_mNegSlopes_2
{0x0F12, 0x0005},	 //70000CD8	 //_yuvemix_mNegSlopes_3   [7:0] AFIT8_yuvemix_mPosSlopes_0
{0x0F12, 0x0607},	 //70000CDA	 //_yuvemix_mPosSlopes_1   [7:0] AFIT8_yuvemix_mPosSlopes_2
{0x0F12, 0x0405},	 //70000CDC	 //_yuvemix_mPosSlopes_3   [7:0] AFIT8_yuviirnr_iXSupportY
{0x0F12, 0x0205},	 //70000CDE	 //_yuviirnr_iXSupportUV   [7:0] AFIT8_yuviirnr_iLowYNorm
{0x0F12, 0x0304},	 //70000CE0	 //_yuviirnr_iHighYNorm   [7:0] AFIT8_yuviirnr_iLowUVNorm
{0x0F12, 0x0409},	 //70000CE2	 //_yuviirnr_iHighUVNorm   [7:0] AFIT8_yuviirnr_iYNormShift
{0x0F12, 0x0306},	 //70000CE4	 //_yuviirnr_iUVNormShift   [7:0] AFIT8_yuviirnr_iVertLength_Y
{0x0F12, 0x0407},	 //70000CE6	 //_yuviirnr_iVertLength_UV   [7:0] AFIT8_yuviirnr_iDiffThreshL_Y
{0x0F12, 0x2C04},	 //70000CE8	 //_yuviirnr_iDiffThreshH_Y   [7:0] AFIT8_yuviirnr_iDiffThreshL_UV
{0x0F12, 0x022C},	 //70000CEA	 //_yuviirnr_iDiffThreshH_UV   [7:0] AFIT8_yuviirnr_iMaxThreshL_Y
{0x0F12, 0x1402},	 //70000CEC	 //_yuviirnr_iMaxThreshH_Y   [7:0] AFIT8_yuviirnr_iMaxThreshL_UV
{0x0F12, 0x0618},	 //70000CEE	 //_yuviirnr_iMaxThreshH_UV   [7:0] AFIT8_yuviirnr_iYNRStrengthL
{0x0F12, 0x1A02},	 //70000CF0	 //_yuviirnr_iYNRStrengthH   [7:0] AFIT8_yuviirnr_iUVNRStrengthL
{0x0F12, 0x8018},	 //70000CF2	 //_yuviirnr_iUVNRStrengthH   [7:0] AFIT8_byr_gras_iShadingPower
{0x0F12, 0x0080},	 //70000CF4	 //_RGBGamma2_iLinearity   [7:0] AFIT8_RGBGamma2_iDarkReduce
{0x0F12, 0x0080},	 //70000CF6	 //_ccm_oscar_iSaturation   [7:0] AFIT8_RGB2YUV_iYOffset //
{0x0F12, 0x0180},	 //70000CF8	 //_RGB2YUV_iRGBGain   [7:0] AFIT8_bnr_nClustLevel_H
{0x0F12, 0x0A0A},	 //70000CFA	 //_bnr_iClustMulT_H   [7:0] AFIT8_bnr_iClustMulT_C
{0x0F12, 0x0101},	 //70000CFC	 //_bnr_iClustThresh_H   [7:0] AFIT8_bnr_iClustThresh_C
{0x0F12, 0x0C0F},	 //70000CFE	 //_bnr_iDenThreshLow   [7:0] AFIT8_bnr_iDenThreshHigh
{0x0F12, 0x6024},	 //70000D00	 //_ee_iLowSharpPower   [7:0] AFIT8_ee_iHighSharpPower
{0x0F12, 0x0808},	 //70000D02	 //_ee_iLowShDenoise   [7:0] AFIT8_ee_iHighShDenoise
{0x0F12, 0xFFFF},	 //70000D04	 //_ee_iLowSharpClamp   [7:0] AFIT8_ee_iHighSharpClamp
{0x0F12, 0x0808},	 //70000D06	 //_ee_iReduceEdgeMinMult   [7:0] AFIT8_ee_iReduceEdgeSlope
{0x0F12, 0x0A01},	 //70000D08	 //_bnr_nClustLevel_H_Bin   [7:0] AFIT8_bnr_iClustMulT_H_Bin
{0x0F12, 0x010A},	 //70000D0A	 //_bnr_iClustMulT_C_Bin   [7:0] AFIT8_bnr_iClustThresh_H_Bin
{0x0F12, 0x0001},	 //70000D0C	 //_bnr_iClustThresh_C_Bin   [7:0] AFIT8_bnr_iDenThreshLow_Bin
{0x0F12, 0x2400},	 //70000D0E	 //_bnr_iDenThreshHigh_Bin   [7:0] AFIT8_ee_iLowSharpPower_Bin
{0x0F12, 0x0060},	 //70000D10	 //_ee_iHighSharpPower_Bin   [7:0] AFIT8_ee_iLowShDenoise_Bin
{0x0F12, 0xFF00},	 //70000D12	 //_ee_iHighShDenoise_Bin   [7:0] AFIT8_ee_iLowSharpClamp_Bin
{0x0F12, 0x40FF},	 //70000D14	 //_ee_iHighSharpClamp_Bin   [7:0] AFIT8_ee_iReduceEdgeMinMult_Bin
{0x0F12, 0x0009},	 //70000D16	 //_ee_iReduceEdgeSlope_Bin [7:0]
{0x0F12, 0x0001},	 //70000D18	 //_bnr_nClustLevel_C      [0]   bWideWide[1]

{0x0F12, 0x23CE},	 //70000D1A	 //[0]CAFITB_bnr_bypass
{0x0F12, 0xFDC8},	 //70000D1C	 //[0]CAFITB_bnr_bSlopenessTune
{0x0F12, 0x112E},	 //70000D1E	 //[0]CAFITB_ee_bReduceNegMedSh
{0x0F12, 0x93A5},	 //70000D20	 //[0]CAFITB_dmsc_bDoDesat
{0x0F12, 0xFE67},	 //70000D22	 //[0]CAFITB_postdmsc_bSat
{0x0F12, 0x0000},	 //70000D24	 //[0]CAFITB_yuviirnr_bWideY

//==================================================================================
// 06.Clock Setting
//==================================================================================
//Input Clock (Mclk)
{0x002A, 0x01F8},
{0x0F12, 0x5DC0},	 //REG_TC_IPRM_InClockLSBs
{0x002A, 0x0212},
{0x0F12, 0x0000},	 //REG_TC_IPRM_UseNPviClocks
{0x0F12, 0x0002},	 //REG_TC_IPRM_UseNMipiClocks
{0x0F12, 0x0002},	 //REG_TC_IPRM_NumberOfMipiLanes

//System Clock & Output clock (Pclk)

{0x002A, 0x021A},
{0x0F12, 0x3A98},	 //REG_TC_IPRM_OpClk4KHz_0
{0x0F12, 0x278D},	 //4F1A	 //REG_TC_IPRM_MinOutRate4KHz_0
{0x0F12, 0x278D},	 //4F1A	 //REG_TC_IPRM_MaxOutRate4KHz_0

{0x0F12, 0x4F1A},	 //REG_TC_IPRM_OpClk4KHz_11
{0x0F12, 0x278D},	 //4F1A	 //REG_TC_IPRM_MinOutRate4KHz_1
{0x0F12, 0x278D},	 //4F1A	 //REG_TC_IPRM_MaxOutRate4KHz_1

{0x002A, 0x022C},
{0x0F12, 0x0001},	 //REG_TC_IPRM_InitParamsUpdated


//==================================================================================
// 08.Preview & Capture Configration Setting
//==================================================================================
//Preview config[0] 64480  7.5~15fps
{0x002A, 0x02A6},
{0x0F12, 0x0280},	 //REG_0TC_PCFG_usWidth
{0x0F12, 0x01E0},	 //REG_0TC_PCFG_usHeight
{0x0F12, 0x0005},	 //REG_0TC_PCFG_Format
{0x0F12, 0x278D},	 //4F1A	 //REG_0TC_PCFG_usMaxOut4KHzRate
{0x0F12, 0x278D},	 //4F1A	 //REG_0TC_PCFG_usMinOut4KHzRate
{0x0F12, 0x0100},	 //REG_0TC_PCFG_OutClkPerPix88
{0x0F12, 0x0300},	 //REG_0TC_PCFG_uBpp88
{0x0F12, 0x0002},	 //REG_0TC_PCFG_PVIMask
{0x0F12, 0x0000},	 //REG_0TC_PCFG_OIFMask
{0x0F12, 0x01E0},	 //REG_0TC_PCFG_usJpegPacketSize
{0x0F12, 0x0000},	 //REG_0TC_PCFG_usJpegTotalPackets
{0x0F12, 0x0000},	 //REG_0TC_PCFG_uClockInd
{0x0F12, 0x0000},	 //REG_0TC_PCFG_usFrTimeType
{0x0F12, 0x0001},	 //REG_0TC_PCFG_FrRateQualityType
{0x0F12, 0x03E8},	 //029A  //REG_0TC_PCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x014A},	 //REG_0TC_PCFG_usMinFrTimeMsecMult10
{0x002A, 0x02D0},
{0x0F12, 0x0002},	 //REG_0TC_PCFG_uPrevMirror
{0x0F12, 0x0002},	 //REG_0TC_PCFG_uCaptureMirror

//Capture Config[0] 2561920   7.5~15fps
{0x002A, 0x0396},
{0x0F12, 0x0001},	 //REG_0TC_CCFG_uCaptureMode
{0x0F12, 0x0A00},	 //REG_0TC_CCFG_usWidth
{0x0F12, 0x0780},	 //REG_0TC_CCFG_usHeight
{0x0F12, 0x0005},	 //REG_0TC_CCFG_Format
{0x0F12, 0x278D},	 //4F1A	 //REG_0TC_CCFG_usMaxOut4KHzRate
{0x0F12, 0x278D},	 //4F1A	 //REG_0TC_CCFG_usMinOut4KHzRate
{0x0F12, 0x0100},	 //REG_0TC_CCFG_OutClkPerPix88
{0x0F12, 0x0300},	 //REG_0TC_CCFG_uBpp88
{0x0F12, 0x0002},	 //REG_0TC_CCFG_PVIMask
{0x0F12, 0x0070},	 //REG_0TC_CCFG_OIFMask
{0x0F12, 0x0810},	 //REG_0TC_CCFG_usJpegPacketSize
{0x0F12, 0x0900},	 //REG_0TC_CCFG_usJpegTotalPackets
{0x0F12, 0x0001},	 //REG_0TC_CCFG_uClockInd
{0x0F12, 0x0000},	 //REG_0TC_CCFG_usFrTimeType
{0x0F12, 0x0002},	 //REG_0TC_CCFG_FrRateQualityType
{0x0F12, 0x07d0},	 //REG_0TC_CCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x07d0},	 //REG_0TC_CCFG_usMinFrTimeMsecMult10




//==================================================================================
// 19.Select Cofigration Display
//==================================================================================
//PREVIEW

{0x0028, 0x7000},//many insert
{0x002A, 0x0266},
{0x0F12, 0x0000},	 //REG_TC_GP_ActivePrevConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	 //REG_TC_GP_PrevOpenAfterChange
{0x002A, 0x024E},
{0x0F12, 0x0001},	 //REG_TC_GP_NewConfigSync
{0x002A, 0x0268},
{0x0F12, 0x0001},	 //REG_TC_GP_PrevConfigChanged
{0x002A, 0x0270},
{0x0F12, 0x0001},	 //REG_TC_GP_CapConfigChanged
{0x002A, 0x023E},
{0x0F12, 0x0001},	 //REG_TC_GP_EnablePreview
{0x0F12, 0x0001},	 //REG_TC_GP_EnablePreviewChanged
//===================================================================================
// 22. ESD Check
//===================================================================================

{0x002A,	0x01A8},
{0x0F12,	0xAAAA},

//===================================================================================
// 23. Brightness min/Max
//===================================================================================
{0x0028,	0x147C},
{0x002A,	0x01AA},
{0x0F12,	0x0180},	//bp_uMaxBrightnessFactor
{0x0028,	0x1482},
{0x002A,	0x01AC},
{0x0F12,	0x0180},	//bp_uMinBrightnessFactor

//===================================================================================
// 24.ISSUE
//===================================================================================
//20110728 : Sequence Changed by image dev.(by J.M.Ahn)
//20110728 : ESD Check Register Address Change
//20110829 : TnP Changed by S.Y.Lee
//20120104 : init Parm Update sequence changed(by J.M.Ahn)
//20120201 : Flash�� �ֺ��� Green Noise ���� setting (by J.M.Ahn)
//20120228 : Add Brightness Block
//20120717 : Lowtemp bypass ��Ŵ
};
////////////////////////////////////////////////////////////////
// Automatically written by Setfile Rule Check function.
// Date: 2013-04-26 10:37:00
//WRITE #REG_TC_GP_InvokeReadOTPData 0001
////////////////////////////////////////////////////////////////

#if 0
//for capture
static struct regval_list sensor_qsxga_regs[] = { //qsxga: 2560*1920  5fps
/* capture setting */

//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
{0x002A, 0x0396},
{0x0F12, 0x0001},	//REG_0TC_CCFG_uCaptureMode
{0x0F12, 0x0A00},	//REG_0TC_CCFG_usWidth
{0x0F12, 0x0780},	//REG_0TC_CCFG_usHeight
{0x002A, 0x03AE},
{0x0F12, 0x0000},	//REG_0TC_CCFG_uClockInd
{0x002A, 0x03B4},
{0x0F12, 0x07D0},	//REG_0TC_CCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x07D0},	//REG_0TC_CCFG_usMinFrTimeMsecMult10

//==================================================================================
// 21.Select Cofigration Display
//==================================================================================
//CAPTURE
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x026E},
{0x0F12, 0x0000}, //REG_TC_GP_ActiveCapConfig
{0x0F12, 0x0001}, // /
{0x002A, 0x0242}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_EnableCapture
{0x002A, 0x024E}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_NewConfigSync
{0x002A, 0x0244}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_EnableCaptureChanged

{0xffff, 0x00c8},  //delay 200ms
};


#else
//for capture
static struct regval_list sensor_qsxga_regs[] = { //qsxga: 2560*1920  7fps
/* capture setting */

//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
{0x002A, 0x0396},
{0x0F12, 0x0001},	//REG_0TC_CCFG_uCaptureMode
{0x0F12, 0x0A00},	//REG_0TC_CCFG_usWidth
{0x0F12, 0x0780},	//REG_0TC_CCFG_usHeight
{0x002A, 0x03AE},
{0x0F12, 0x0000},	//REG_0TC_CCFG_uClockInd
{0x002A, 0x03B4},
{0x0F12, 0x0535},	//REG_0TC_CCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x0535},	//REG_0TC_CCFG_usMinFrTimeMsecMult10

//==================================================================================
// 21.Select Cofigration Display
//==================================================================================
//CAPTURE
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x026E},
{0x0F12, 0x0000}, //REG_TC_GP_ActiveCapConfig
{0x0F12, 0x0001}, // /
{0x002A, 0x0242}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_EnableCapture
{0x002A, 0x024E}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_NewConfigSync
{0x002A, 0x0244}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_EnableCaptureChanged

{0xffff, 0x00c8},  //delay 200ms
};
#endif

static struct regval_list sensor_qxga_regs[] = { //qxga: 2048*1536
/* capture setting */

//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
{0x002A, 0x0396},
{0x0F12, 0x0001},	//REG_0TC_CCFG_uCaptureMode
{0x0F12, 0x0800},	//REG_0TC_CCFG_usWidth
{0x0F12, 0x0600},	//REG_0TC_CCFG_usHeight
{0x002A, 0x03AE},
{0x0F12, 0x0000},	//REG_0TC_CCFG_uClockInd
{0x002A, 0x03B4},
{0x0F12, 0x0535},	//REG_0TC_CCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x0535},	//REG_0TC_CCFG_usMinFrTimeMsecMult10

//==================================================================================
// 21.Select Cofigration Display
//==================================================================================
//CAPTURE
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x026E},
{0x0F12, 0x0000}, //REG_TC_GP_ActiveCapConfig
{0x0F12, 0x0001}, // /
{0x002A, 0x0242}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_EnableCapture
{0x002A, 0x024E}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_NewConfigSync
{0x002A, 0x0244}, //
{0x0F12, 0x0001}, // /#REG_TC_GP_EnableCaptureChanged

{0xffff, 0x00c8},  //delay 200ms
};


//for video
static struct regval_list sensor_1080p_regs[] = { //1080: 1920*1080
/* preview setting */

{0x002A, 0x18AC},
{0x0F12, 0x0060}, //senHal_uAddColsBin
{0x0F12, 0x0060}, //senHal_uAddColsNoBin
{0x0F12, 0x05C0}, //senHal_uMinColsBin
{0x0F12, 0x0A96}, //05C0 //senHal_uMinColsNoBin

//==================================================================================
// 19.Input Size Setting
//==================================================================================
//Input Size
{0x002A, 0x0250},
{0x0F12, 0x0780},	//REG_TC_GP_PrevReqInputWidth
{0x0F12, 0x0438},	//REG_TC_GP_PrevReqInputHeight
{0x0F12, 0x014E},	//REG_TC_GP_PrevInputWidthOfs
{0x0F12, 0x01B0},	//REG_TC_GP_PrevInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_GP_CapReqInputWidth
{0x0F12, 0x0780},	//REG_TC_GP_CapReqInputHeight
{0x0F12, 0x0010},	//REG_TC_GP_CapInputWidthOfs
{0x0F12, 0x000C},	//REG_TC_GP_CapInputHeightOfs

{0x002A, 0x0494},
{0x0F12, 0x0780},	//REG_TC_PZOOM_ZoomInputWidth
{0x0F12, 0x0438},	//REG_TC_PZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_CZOOM_ZoomInputWidth
{0x0F12, 0x0780},	//REG_TC_CZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputHeightOfs

{0x002A, 0x0262},
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInPre
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInCap

//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x02A6},
{0x0F12, 0x0780},	//280 REG_0TC_PCFG_usWidth
{0x0F12, 0x0438},	//1E0 REG_0TC_PCFG_usHeight
{0x002A, 0x02BC},
{0x0F12, 0x0001},	//REG_0TC_PCFG_uClockInd
{0x0F12, 0x0001},	//REG_0TC_PCFG_usFrTimeType
{0x0F12, 0x0000},	//REG_0TC_PCFG_FrRateQualityType
{0x0F12, 0x029A},	//REG_0TC_PCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x029A},	//REG_0TC_PCFG_usMinFrTimeMsecMult10

{0x002A, 0x022C},
{0x0F12, 0x0001},	//REG_TC_IPRM_InitParamsUpdated

//==================================================================================
// 21.Select Cofigration Display
//==================================================================================
//PREVIEW
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x0266},
{0x0f12, 0x0000},	//REG_TC_GP_ActivePrevConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_PrevOpenAfterChange
{0x002A, 0x0268},
{0x0F12, 0x0001},	//REG_TC_GP_PrevConfigChanged
{0x002A, 0x026E},
{0x0f12, 0x0000},       //REG_TC_GP_ActiveCapConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_CapOpenAfterChange
{0x002A, 0x0270},
{0x0F12, 0x0001},	//REG_TC_GP_CapConfigChanged

{0x002A, 0x024E},
{0x0F12, 0x0001},	//REG_TC_GP_NewConfigSync
{0x002A, 0x023E},
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreview
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreviewChanged


{0xffff, 0x00c8},  //delay 200ms
};

static struct regval_list sensor_720p_regs[] = { //1280*720
/* preview setting */

{0x002A, 0x18AC},
{0x0F12, 0x0060}, //senHal_uAddColsBin
{0x0F12, 0x0060}, //senHal_uAddColsNoBin
{0x0F12, 0x05C0}, //senHal_uMinColsBin
{0x0F12, 0x0A96}, //05C0 //senHal_uMinColsNoBin

//==================================================================================
// 19.Input Size Setting
//==================================================================================
//Input Size
{0x002A, 0x0250},
{0x0F12, 0x0A00},	//REG_TC_GP_PrevReqInputWidth
{0x0F12, 0x05A0},	//REG_TC_GP_PrevReqInputHeight
{0x0F12, 0x0010},	//REG_TC_GP_PrevInputWidthOfs
{0x0F12, 0x00FC},	//REG_TC_GP_PrevInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_GP_CapReqInputWidth
{0x0F12, 0x0780},	//REG_TC_GP_CapReqInputHeight
{0x0F12, 0x0010},	//REG_TC_GP_CapInputWidthOfs
{0x0F12, 0x000C},	//REG_TC_GP_CapInputHeightOfs

{0x002A, 0x0494},
{0x0F12, 0x0A00},	//REG_TC_PZOOM_ZoomInputWidth
{0x0F12, 0x05A0},	//REG_TC_PZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_CZOOM_ZoomInputWidth
{0x0F12, 0x0780},	//REG_TC_CZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputHeightOfs

{0x002A, 0x0262},
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInPre
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInCap

//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x02A6},
{0x0F12, 0x0500},	//280 REG_0TC_PCFG_usWidth
{0x0F12, 0x02D0},	//1E0 REG_0TC_PCFG_usHeight
{0x002A, 0x02BC},
{0x0F12, 0x0000},	//REG_0TC_PCFG_uClockInd
{0x0F12, 0x0001},	//REG_0TC_PCFG_usFrTimeType
{0x0F12, 0x0001},	//REG_0TC_PCFG_FrRateQualityType
{0x0F12, 0x014D},	//REG_0TC_PCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x014D},	//REG_0TC_PCFG_usMinFrTimeMsecMult10

{0x002A, 0x022C},
{0x0F12, 0x0001},	//REG_TC_IPRM_InitParamsUpdated

//==================================================================================
// 21.Select Cofigration Display
//==================================================================================
//PREVIEW
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x0266},
{0x0f12, 0x0000},	//REG_TC_GP_ActivePrevConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_PrevOpenAfterChange
{0x002A, 0x0268},
{0x0F12, 0x0001},	//REG_TC_GP_PrevConfigChanged
{0x002A, 0x026E},
{0x0f12, 0x0000},       //REG_TC_GP_ActiveCapConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_CapOpenAfterChange
{0x002A, 0x0270},
{0x0F12, 0x0001},	//REG_TC_GP_CapConfigChanged

{0x002A, 0x024E},
{0x0F12, 0x0001},	//REG_TC_GP_NewConfigSync
{0x002A, 0x023E},
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreview
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreviewChanged

{0xffff, 0x00c8},  //delay 200ms
};

static struct regval_list sensor_vga_regs[] = { //VGA:  640*480
#if 0  //vga 7.5~30fps
/* preview setting */

{0x002A, 0x18AC},
{0x0F12, 0x0060}, //senHal_uAddColsBin
{0x0F12, 0x0060}, //senHal_uAddColsNoBin
{0x0F12, 0x05C0}, //senHal_uMinColsBin
{0x0F12, 0x05C0}, //senHal_uMinColsNoBin

//==================================================================================
// 19.Input Size Setting
//==================================================================================
//Input Size
{0x002A, 0x0250},
{0x0F12, 0x0A00},	//REG_TC_GP_PrevReqInputWidth
{0x0F12, 0x0780},	//REG_TC_GP_PrevReqInputHeight
{0x0F12, 0x0010},	//REG_TC_GP_PrevInputWidthOfs
{0x0F12, 0x000C},	//REG_TC_GP_PrevInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_GP_CapReqInputWidth
{0x0F12, 0x0780},	//REG_TC_GP_CapReqInputHeight
{0x0F12, 0x0010},	//REG_TC_GP_CapInputWidthOfs
{0x0F12, 0x000C},	//REG_TC_GP_CapInputHeightOfs

{0x002A, 0x0494},
{0x0F12, 0x0A00},	//REG_TC_PZOOM_ZoomInputWidth
{0x0F12, 0x0780},	//REG_TC_PZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_CZOOM_ZoomInputWidth
{0x0F12, 0x0780},	//REG_TC_CZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputHeightOfs

{0x002A, 0x0262},
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInPre
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInCap

//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x02A6},
{0x0F12, 0x0280},	//REG_0TC_PCFG_usWidth
{0x0F12, 0x01E0},	//REG_0TC_PCFG_usHeight
{0x002A, 0x02BC},
{0x0F12, 0x0000},	//REG_0TC_PCFG_uClockInd
{0x0F12, 0x0000},	//REG_0TC_PCFG_usFrTimeType
{0x0F12, 0x0001},	//REG_0TC_PCFG_FrRateQualityType
{0x0F12, 0x0535},	//REG_0TC_PCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x014D},	//REG_0TC_PCFG_usMinFrTimeMsecMult10

{0x002A, 0x022C},
{0x0F12, 0x0001},	//REG_TC_IPRM_InitParamsUpdated

//==================================================================================
// 21.Select Cofigration Display
//==================================================================================
//PREVIEW
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x0266},
{0x0f12, 0x0000},	//REG_TC_GP_ActivePrevConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_PrevOpenAfterChange
{0x002A, 0x0268},
{0x0F12, 0x0001},	//REG_TC_GP_PrevConfigChanged
{0x002A, 0x026E},
{0x0f12, 0x0000},       //REG_TC_GP_ActiveCapConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_CapOpenAfterChange
{0x002A, 0x0270},
{0x0F12, 0x0001},	//REG_TC_GP_CapConfigChanged

{0x002A, 0x024E},
{0x0F12, 0x0001},	//REG_TC_GP_NewConfigSync
{0x002A, 0x023E},
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreview
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreviewChanged

{0xffff, 0x00c8},  //delay 200ms
#else			//vga fix 30fps
/* preview setting */

{0x002A, 0x18AC},
{0x0F12, 0x0060}, //senHal_uAddColsBin
{0x0F12, 0x0060}, //senHal_uAddColsNoBin
{0x0F12, 0x05C0}, //senHal_uMinColsBin
{0x0F12, 0x05C0}, //05C0 //senHal_uMinColsNoBin

//==================================================================================
// 19.Input Size Setting
//==================================================================================
//Input Size
{0x002A, 0x0250},
{0x0F12, 0x0A00},	//REG_TC_GP_PrevReqInputWidth
{0x0F12, 0x0780},	//REG_TC_GP_PrevReqInputHeight
{0x0F12, 0x0010},	//REG_TC_GP_PrevInputWidthOfs
{0x0F12, 0x000C},	//REG_TC_GP_PrevInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_GP_CapReqInputWidth
{0x0F12, 0x0780},	//REG_TC_GP_CapReqInputHeight
{0x0F12, 0x0010},	//REG_TC_GP_CapInputWidthOfs
{0x0F12, 0x000C},	//REG_TC_GP_CapInputHeightOfs

{0x002A, 0x0494},
{0x0F12, 0x0A00},	//REG_TC_PZOOM_ZoomInputWidth
{0x0F12, 0x0780},	//REG_TC_PZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_PZOOM_ZoomInputHeightOfs
{0x0F12, 0x0A00},	//REG_TC_CZOOM_ZoomInputWidth
{0x0F12, 0x0780},	//REG_TC_CZOOM_ZoomInputHeight
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputWidthOfs
{0x0F12, 0x0000},	//REG_TC_CZOOM_ZoomInputHeightOfs

{0x002A, 0x0262},
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInPre
{0x0F12, 0x0001},	//REG_TC_GP_bUseReqInputInCap

//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x02A6},
{0x0F12, 0x0280},	//280 REG_0TC_PCFG_usWidth
{0x0F12, 0x01E0},	//1E0 REG_0TC_PCFG_usHeight
{0x002A, 0x02BC},
{0x0F12, 0x0000},	//REG_0TC_PCFG_uClockInd
{0x0F12, 0x0002},	//REG_0TC_PCFG_usFrTimeType
{0x0F12, 0x0001},	//REG_0TC_PCFG_FrRateQualityType
{0x0F12, 0x014D},	//REG_0TC_PCFG_usMaxFrTimeMsecMult10
{0x0F12, 0x0000},	//REG_0TC_PCFG_usMinFrTimeMsecMult10

//==================================================================================
// 21.Select Cofigration Display
//==================================================================================
//PREVIEW
{0x0028, 0x7000},
{0x002A, 0x0266},
{0x0f12, 0x0000}, //REG_TC_GP_ActivePrevConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_PrevOpenAfterChange
{0x002A, 0x0268},
{0x0F12, 0x0001},	//REG_TC_GP_PrevConfigChanged
{0x002A, 0x026E},
{0x0f12, 0x0000}, //REG_TC_GP_ActiveCapConfig
{0x002A, 0x026A},
{0x0F12, 0x0001},	//REG_TC_GP_CapOpenAfterChange
{0x002A, 0x0270},
{0x0F12, 0x0001},	//REG_TC_GP_CapConfigChanged

{0x002A, 0x024E},
{0x0F12, 0x0001},	//REG_TC_GP_NewConfigSync
{0x002A, 0x023E},
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreview
{0x0F12, 0x0001},	//REG_TC_GP_EnablePreviewChanged

//{0xffff, 0x00,150},
#endif

//{0xFCFC, 0xD000},
//{0x0028, 0x7000},
//{0x002A, 0x0236},
//{0x0F12, 0x0040},   //Control value
};

#if 0
//misc
static struct regval_list sensor_oe_disable_regs[] = {
};
#endif

//static struct regval_list sensor_sw_stby_on_regs[] = {
//  //
//  //{REG_TERM,VAL_TERM},
//};
//
//static struct regval_list sensor_sw_stby_off_regs[] = {
//  //
//  //{REG_TERM,VAL_TERM},
//};

#if 0
//stuff about auto focus
static struct regval_list sensor_af_fw_regs[] = {
};
#endif

static struct regval_list sensor_ae_awb_lockon_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x2C5E}, // /* AE Lock On */
{0x0F12, 0x0000},
};

static struct regval_list sensor_ae_awb_lockoff_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x2C5E}, // /* AE Lock Off */
{0x0F12, 0x0001},
};

static struct regval_list sensor_af_single_trig_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x028E},
{0x0F12, 0x0000},
{0x002A, 0x028C},
{0x0F12, 0x0005},
};

static struct regval_list sensor_af_continueous_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x028E},
{0x0F12, 0x0000},
{0x002A, 0x028C},
{0x0F12, 0x0006},
};

static struct regval_list sensor_af_infinity_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x028E}, // write [7000 028E, REG_TC_AF_AfCmdParam]
{0x0F12, 0x0000}, // write lens position from 0000 to 00FF. 0000 means infinity and 00FF means macro.
{0x002A, 0x028C},
{0x0F12, 0x0004}, // write [7000 028C, REG_TC_AF_AfCmd] = 0004 , manual AF.

//{0xffff, 0x0064},	// delay 150ms

{0x002A, 0x1648},
{0x0F12, 0x9002},
};

//static struct regval_list sensor_af_macro_regs[] = {
//{0xFCFC, 0xD000},
//{0x0028, 0x7000},
//{0x002A, 0x028E}, // write [7000 028E, REG_TC_AF_AfCmdParam]
//{0x0F12, 0x00D0}, // write lens position from 0000 to 00FF. 0000 means infinity and 00FF means macro.
//{0x002A, 0x028C},
//{0x0F12, 0x0004}, // write [7000 028C, REG_TC_AF_AfCmd] = 0004 , manual AF.
//
//{0xffff, 0x00,150},	// delay 150ms
//
//{0x002A, 0x1648},
//{0x0F12, 0x9002},
//};



/*
 * The white balance settings
 * Here only tune the R G B channel gain.
 * The white balance enalbe bit is modified in sensor_s_autowb and sensor_s_wb
 */
static struct regval_list sensor_wb_manual[] = {
  //{0x3406,0x1 },
  //{REG_TERM,VAL_TERM},
};

static struct regval_list sensor_wb_auto_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x04E6},
{0x0F12, 0x077F},
};

static struct regval_list sensor_wb_incandescence_regs[] = {
	//bai re guang
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x04E6},
{0x0F12, 0x0777},
{0x002A, 0x04BA},
{0x0F12, 0x0430},
{0x002A, 0x04BE},
{0x0F12, 0x03D0},
{0x002A, 0x04C2},
{0x0F12, 0x09F0},
{0x002A, 0x04C6},
{0x0F12, 0x0001},
};

static struct regval_list sensor_wb_fluorescent_regs[] = {
	//ri guang deng
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x04E6},
{0x0F12, 0x0777},
{0x002A, 0x04BA},
{0x0F12, 0x06C0},
{0x002A, 0x04BE},
{0x0F12, 0x0440},
{0x002A, 0x04C2},
{0x0F12, 0x07A0},
{0x002A, 0x04C6},
{0x0F12, 0x0001},
};

static struct regval_list sensor_wb_tungsten_regs[] = {
	//wu si deng
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x04E6},
{0x0F12, 0x0777},
{0x002A, 0x04BA},
{0x0F12, 0x0540},
{0x002A, 0x04BE},
{0x0F12, 0x03D0},
{0x002A, 0x04C2},
{0x0F12, 0x08F0},
{0x002A, 0x04C6},
{0x0F12, 0x0001},
};

static struct regval_list sensor_wb_horizon[] = {
//null
};

static struct regval_list sensor_wb_daylight_regs[] = {
	//tai yang guang
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x04E6},
{0x0F12, 0x0777},
{0x002A, 0x04BA},
{0x0F12, 0x0620},
{0x002A, 0x04BE},
{0x0F12, 0x03D0},
{0x002A, 0x04C2},
{0x0F12, 0x0580},
{0x002A, 0x04C6},
{0x0F12, 0x0001},
};

static struct regval_list sensor_wb_flash[] = {
//null
};

static struct regval_list sensor_wb_cloud_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x04E6},
{0x0F12, 0x0777},
{0x002A, 0x04BA},
{0x0F12, 0x06D0},
{0x002A, 0x04BE},
{0x0F12, 0x03D0},
{0x002A, 0x04C2},
{0x0F12, 0x0520},
{0x002A, 0x04C6},
{0x0F12, 0x0001},
};

static struct regval_list sensor_wb_shade[] = {
//null
};

static struct cfg_array sensor_wb[] = {
	{
		.regs = sensor_wb_manual,             //V4L2_WHITE_BALANCE_MANUAL
		.size = ARRAY_SIZE(sensor_wb_manual),
	},
	{
		.regs = sensor_wb_auto_regs,          //V4L2_WHITE_BALANCE_AUTO
		.size = ARRAY_SIZE(sensor_wb_auto_regs),
	},
	{
		.regs = sensor_wb_incandescence_regs, //V4L2_WHITE_BALANCE_INCANDESCENT
		.size = ARRAY_SIZE(sensor_wb_incandescence_regs),
	},
	{
		.regs = sensor_wb_fluorescent_regs,   //V4L2_WHITE_BALANCE_FLUORESCENT
		.size = ARRAY_SIZE(sensor_wb_fluorescent_regs),
	},
	{
		.regs = sensor_wb_tungsten_regs,      //V4L2_WHITE_BALANCE_FLUORESCENT_H
		.size = ARRAY_SIZE(sensor_wb_tungsten_regs),
	},
	{
		.regs = sensor_wb_horizon,            //V4L2_WHITE_BALANCE_HORIZON
		.size = ARRAY_SIZE(sensor_wb_horizon),
	},
	{
		.regs = sensor_wb_daylight_regs,      //V4L2_WHITE_BALANCE_DAYLIGHT
		.size = ARRAY_SIZE(sensor_wb_daylight_regs),
	},
	{
		.regs = sensor_wb_flash,              //V4L2_WHITE_BALANCE_FLASH
		.size = ARRAY_SIZE(sensor_wb_flash),
	},
	{
		.regs = sensor_wb_cloud_regs,         //V4L2_WHITE_BALANCE_CLOUDY
		.size = ARRAY_SIZE(sensor_wb_cloud_regs),
	},
	{
		.regs = sensor_wb_shade,              //V4L2_WHITE_BALANCE_SHADE
		.size = ARRAY_SIZE(sensor_wb_shade),
	},
};


/*
 * The color effect settings
 */
static struct regval_list sensor_colorfx_none_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023C},
{0x0F12, 0x0000},	//REG_TC_GP_SpecialEffects
};

static struct regval_list sensor_colorfx_bw_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023C},
{0x0F12, 0x0001},	//REG_TC_GP_SpecialEffects
};

static struct regval_list sensor_colorfx_sepia_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023C},
{0x0F12, 0x0004},	//REG_TC_GP_SpecialEffects
};

static struct regval_list sensor_colorfx_negative_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023C},
{0x0F12, 0x0003},	//REG_TC_GP_SpecialEffects
};

static struct regval_list sensor_colorfx_emboss_regs[] = {

};

static struct regval_list sensor_colorfx_sketch_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023C},
{0x0F12, 0x0009},	//REG_TC_GP_SpecialEffects
};

static struct regval_list sensor_colorfx_sky_blue_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023C},
{0x0F12, 0x0007},	//REG_TC_GP_SpecialEffects
};

static struct regval_list sensor_colorfx_grass_green_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023C},
{0x0F12, 0x0009},	//REG_TC_GP_SpecialEffects
};

static struct regval_list sensor_colorfx_skin_whiten_regs[] = {
//NULL
};

static struct regval_list sensor_colorfx_vivid_regs[] = {
//NULL
};

static struct regval_list sensor_colorfx_aqua_regs[] = {
//null
};

static struct regval_list sensor_colorfx_art_freeze_regs[] = {
//null
};

static struct regval_list sensor_colorfx_silhouette_regs[] = {
//null
};

static struct regval_list sensor_colorfx_solarization_regs[] = {
//null
};

static struct regval_list sensor_colorfx_antique_regs[] = {
//null
};

static struct regval_list sensor_colorfx_set_cbcr_regs[] = {
//null
};

static struct cfg_array sensor_colorfx[] = {
	{
		.regs = sensor_colorfx_none_regs,         //V4L2_COLORFX_NONE = 0,
		.size = ARRAY_SIZE(sensor_colorfx_none_regs),
	},
	{
		.regs = sensor_colorfx_bw_regs,           //V4L2_COLORFX_BW   = 1,
		.size = ARRAY_SIZE(sensor_colorfx_bw_regs),
	},
	{
		.regs = sensor_colorfx_sepia_regs,        //V4L2_COLORFX_SEPIA  = 2,
		.size = ARRAY_SIZE(sensor_colorfx_sepia_regs),
	},
	{
		.regs = sensor_colorfx_negative_regs,     //V4L2_COLORFX_NEGATIVE = 3,
		.size = ARRAY_SIZE(sensor_colorfx_negative_regs),
	},
	{
		.regs = sensor_colorfx_emboss_regs,       //V4L2_COLORFX_EMBOSS = 4,
		.size = ARRAY_SIZE(sensor_colorfx_emboss_regs),
	},
	{
		.regs = sensor_colorfx_sketch_regs,       //V4L2_COLORFX_SKETCH = 5,
		.size = ARRAY_SIZE(sensor_colorfx_sketch_regs),
	},
	{
		.regs = sensor_colorfx_sky_blue_regs,     //V4L2_COLORFX_SKY_BLUE = 6,
		.size = ARRAY_SIZE(sensor_colorfx_sky_blue_regs),
	},
	{
		.regs = sensor_colorfx_grass_green_regs,  //V4L2_COLORFX_GRASS_GREEN = 7,
		.size = ARRAY_SIZE(sensor_colorfx_grass_green_regs),
	},
	{
		.regs = sensor_colorfx_skin_whiten_regs,  //V4L2_COLORFX_SKIN_WHITEN = 8,
		.size = ARRAY_SIZE(sensor_colorfx_skin_whiten_regs),
	},
	{
		.regs = sensor_colorfx_vivid_regs,        //V4L2_COLORFX_VIVID = 9,
		.size = ARRAY_SIZE(sensor_colorfx_vivid_regs),
	},
	{
		.regs = sensor_colorfx_aqua_regs,         //V4L2_COLORFX_AQUA = 10,
		.size = ARRAY_SIZE(sensor_colorfx_aqua_regs),
	},
	{
		.regs = sensor_colorfx_art_freeze_regs,   //V4L2_COLORFX_ART_FREEZE = 11,
		.size = ARRAY_SIZE(sensor_colorfx_art_freeze_regs),
	},
	{
		.regs = sensor_colorfx_silhouette_regs,   //V4L2_COLORFX_SILHOUETTE = 12,
		.size = ARRAY_SIZE(sensor_colorfx_silhouette_regs),
	},
	{
		.regs = sensor_colorfx_solarization_regs, //V4L2_COLORFX_SOLARIZATION = 13,
		.size = ARRAY_SIZE(sensor_colorfx_solarization_regs),
	},
	{
		.regs = sensor_colorfx_antique_regs,      //V4L2_COLORFX_ANTIQUE = 14,
		.size = ARRAY_SIZE(sensor_colorfx_antique_regs),
	},
	{
		.regs = sensor_colorfx_set_cbcr_regs,     //V4L2_COLORFX_SET_CBCR = 15,
		.size = ARRAY_SIZE(sensor_colorfx_set_cbcr_regs),
	},
};

/*
 * The power frequency
 */
static struct regval_list sensor_flicker_50hz_regs[] = {
{0x002A, 0x04E6},
{0x0F12, 0x075F},	//REG_TC_DBG 7F: 60Hz  5F:50Hz
{0x002a, 0x04d6},
{0x0F12, 0x0001},	//REG_SF_USER_FlickerQuant 01h : 50hz  02h : 60hz
{0x0F12, 0x0001},	//REG_SF_USER_FlickerQuantChanged
};

static struct regval_list sensor_flicker_60hz_regs[] = {
{0x002A, 0x04E6},
{0x0F12, 0x075F},	//REG_TC_DBG 7F: 60Hz  5F:50Hz
{0x002a, 0x04d6},
{0x0f12, 0x0002},	//REG_SF_USER_FlickerQuant 01h : 50hz  02h : 60hz
{0x0F12, 0x0001},	//REG_SF_USER_FlickerQuantChanged
};

/*
 * The brightness setttings
 */
static struct regval_list sensor_brightness_neg4_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x0024},
};

static struct regval_list sensor_brightness_neg3_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x002A},
};

static struct regval_list sensor_brightness_neg2_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x0030},
};

static struct regval_list sensor_brightness_neg1_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x0036},
};

static struct regval_list sensor_brightness_zero_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x003C},
};

static struct regval_list sensor_brightness_pos1_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x0047},
};

static struct regval_list sensor_brightness_pos2_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x0052},
};

static struct regval_list sensor_brightness_pos3_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x0057},
};

static struct regval_list sensor_brightness_pos4_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x1484},
{0x0F12, 0x0068},
};

static struct cfg_array sensor_brightness[] = {
	{
		.regs = sensor_brightness_neg4_regs,
		.size = ARRAY_SIZE(sensor_brightness_neg4_regs),
	},
	{
		.regs = sensor_brightness_neg3_regs,
		.size = ARRAY_SIZE(sensor_brightness_neg3_regs),
	},
	{
		.regs = sensor_brightness_neg2_regs,
		.size = ARRAY_SIZE(sensor_brightness_neg2_regs),
	},
	{
		.regs = sensor_brightness_neg1_regs,
		.size = ARRAY_SIZE(sensor_brightness_neg1_regs),
	},
	{
		.regs = sensor_brightness_zero_regs,
		.size = ARRAY_SIZE(sensor_brightness_zero_regs),
	},
	{
		.regs = sensor_brightness_pos1_regs,
		.size = ARRAY_SIZE(sensor_brightness_pos1_regs),
	},
	{
		.regs = sensor_brightness_pos2_regs,
		.size = ARRAY_SIZE(sensor_brightness_pos2_regs),
	},
	{
		.regs = sensor_brightness_pos3_regs,
		.size = ARRAY_SIZE(sensor_brightness_pos3_regs),
	},
	{
		.regs = sensor_brightness_pos4_regs,
		.size = ARRAY_SIZE(sensor_brightness_pos4_regs),
	},
};

/*
 * The contrast setttings
 */
static struct regval_list sensor_contrast_neg4_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0xFF80},   //Control value
};

static struct regval_list sensor_contrast_neg3_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0xFFA0},   //Control value
};

static struct regval_list sensor_contrast_neg2_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0xFFC0},   //Control value
};

static struct regval_list sensor_contrast_neg1_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0xFFE0},   //Control value
};

static struct regval_list sensor_contrast_zero_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0x0000},   //Control value
};

static struct regval_list sensor_contrast_pos1_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0x0020},   //Control value
};

static struct regval_list sensor_contrast_pos2_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0x0040},   //Control value
};

static struct regval_list sensor_contrast_pos3_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0x0060},   //Control value
};

static struct regval_list sensor_contrast_pos4_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0232},
{0x0F12, 0x0080},   //Control value
};

static struct cfg_array sensor_contrast[] = {
	{
		.regs = sensor_contrast_neg4_regs,
		.size = ARRAY_SIZE(sensor_contrast_neg4_regs),
	},
	{
		.regs = sensor_contrast_neg3_regs,
		.size = ARRAY_SIZE(sensor_contrast_neg3_regs),
	},
	{
		.regs = sensor_contrast_neg2_regs,
		.size = ARRAY_SIZE(sensor_contrast_neg2_regs),
	},
	{
		.regs = sensor_contrast_neg1_regs,
		.size = ARRAY_SIZE(sensor_contrast_neg1_regs),
	},
	{
		.regs = sensor_contrast_zero_regs,
		.size = ARRAY_SIZE(sensor_contrast_zero_regs),
	},
	{
		.regs = sensor_contrast_pos1_regs,
		.size = ARRAY_SIZE(sensor_contrast_pos1_regs),
	},
	{
		.regs = sensor_contrast_pos2_regs,
		.size = ARRAY_SIZE(sensor_contrast_pos2_regs),
	},
	{
		.regs = sensor_contrast_pos3_regs,
		.size = ARRAY_SIZE(sensor_contrast_pos3_regs),
	},
	{
		.regs = sensor_contrast_pos4_regs,
		.size = ARRAY_SIZE(sensor_contrast_pos4_regs),
	},
};

/*
 * The saturation setttings
 */
static struct regval_list sensor_saturation_neg4_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0xFF80},   //Control value
};

static struct regval_list sensor_saturation_neg3_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0xFFA0},   //Control value
};

static struct regval_list sensor_saturation_neg2_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0xFFC0},   //Control value
};

static struct regval_list sensor_saturation_neg1_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0xFFE0},   //Control value
};

static struct regval_list sensor_saturation_zero_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0x0000},   //Control value
};

static struct regval_list sensor_saturation_pos1_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0x0020},   //Control value
};

static struct regval_list sensor_saturation_pos2_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0x0040},   //Control value
};

static struct regval_list sensor_saturation_pos3_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0x0060},   //Control value
};

static struct regval_list sensor_saturation_pos4_regs[] = {
{0x0028, 0x7000},
{0x002A, 0x0234},
{0x0F12, 0x0080},   //Control value
};

static struct cfg_array sensor_saturation[] = {
	{
		.regs = sensor_saturation_neg4_regs,
		.size = ARRAY_SIZE(sensor_saturation_neg4_regs),
	},
	{
		.regs = sensor_saturation_neg3_regs,
		.size = ARRAY_SIZE(sensor_saturation_neg3_regs),
	},
	{
		.regs = sensor_saturation_neg2_regs,
		.size = ARRAY_SIZE(sensor_saturation_neg2_regs),
	},
	{
		.regs = sensor_saturation_neg1_regs,
		.size = ARRAY_SIZE(sensor_saturation_neg1_regs),
	},
	{
		.regs = sensor_saturation_zero_regs,
		.size = ARRAY_SIZE(sensor_saturation_zero_regs),
	},
	{
		.regs = sensor_saturation_pos1_regs,
		.size = ARRAY_SIZE(sensor_saturation_pos1_regs),
	},
	{
		.regs = sensor_saturation_pos2_regs,
		.size = ARRAY_SIZE(sensor_saturation_pos2_regs),
	},
	{
		.regs = sensor_saturation_pos3_regs,
		.size = ARRAY_SIZE(sensor_saturation_pos3_regs),
	},
	{
		.regs = sensor_saturation_pos4_regs,
		.size = ARRAY_SIZE(sensor_saturation_pos4_regs),
	},
};

/*
 * The exposure target setttings
 */
static struct regval_list sensor_ev_neg4_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x0080},   //Control value
};

static struct regval_list sensor_ev_neg3_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x00A0},   //Control value
};

static struct regval_list sensor_ev_neg2_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x00C0},   //Control value
};

static struct regval_list sensor_ev_neg1_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x00E0},   //Control value
};

static struct regval_list sensor_ev_zero_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x0100},   //Control value
};

static struct regval_list sensor_ev_pos1_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x0120},   //Control value
};

static struct regval_list sensor_ev_pos2_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x0140},   //Control value
};

static struct regval_list sensor_ev_pos3_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x0160},   //Control value
};

static struct regval_list sensor_ev_pos4_regs[] = {
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x023A},
{0x0F12, 0x0180},   //Control value
};

static struct cfg_array sensor_ev[] = {
	{
		.regs = sensor_ev_neg4_regs,
		.size = ARRAY_SIZE(sensor_ev_neg4_regs),
	},
	{
		.regs = sensor_ev_neg3_regs,
		.size = ARRAY_SIZE(sensor_ev_neg3_regs),
	},
	{
		.regs = sensor_ev_neg2_regs,
		.size = ARRAY_SIZE(sensor_ev_neg2_regs),
	},
	{
		.regs = sensor_ev_neg1_regs,
		.size = ARRAY_SIZE(sensor_ev_neg1_regs),
	},
	{
		.regs = sensor_ev_zero_regs,
		.size = ARRAY_SIZE(sensor_ev_zero_regs),
	},
	{
		.regs = sensor_ev_pos1_regs,
		.size = ARRAY_SIZE(sensor_ev_pos1_regs),
	},
	{
		.regs = sensor_ev_pos2_regs,
		.size = ARRAY_SIZE(sensor_ev_pos2_regs),
	},
	{
		.regs = sensor_ev_pos3_regs,
		.size = ARRAY_SIZE(sensor_ev_pos3_regs),
	},
	{
		.regs = sensor_ev_pos4_regs,
		.size = ARRAY_SIZE(sensor_ev_pos4_regs),
	},
};


/*
 * Here we'll try to encapsulate the changes for just the output
 * video format.
 *
 */
static struct regval_list sensor_fmt_mipi_yuv422[] = {


{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x02B4},
{0x0F12, 0x0040},	//REG_0TC_PCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
{0x002A, 0x03A6},
{0x0F12, 0x0040},	//REG_0TC_CCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11





};

#if 0
static struct regval_list sensor_fmt_yuv422_yuyv[] = {
	//YUYV
	//==================================================================================
	// 20.Preview & Capture Configration Setting
	//==================================================================================
	//{0xFFFF, 0x0000},
	{0xFCFC, 0xD000},
	{0x0028, 0x7000},
	{0x002A, 0x02B4},
	{0x0F12, 0x0040},	//REG_0TC_PCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
	{0x002A, 0x03A6},
	{0x0F12, 0x0040},	//REG_0TC_CCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
};

static struct regval_list sensor_fmt_yuv422_yvyu[] = {
	//==================================================================================
	// 20.Preview & Capture Configration Setting
	//==================================================================================
	//{0xFFFF, 0x0000},
	{0xFCFC, 0xD000},
	{0x0028, 0x7000},
	{0x002A, 0x02B4},
	{0x0F12, 0x0060},	//REG_0TC_PCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
	{0x002A, 0x03A6},
	{0x0F12, 0x0060},	//REG_0TC_CCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
};

static struct regval_list sensor_fmt_yuv422_vyuy[] = {
	//==================================================================================
	// 20.Preview & Capture Configration Setting
	//==================================================================================
	//{0xFFFF, 0x0000},
	{0xFCFC, 0xD000},
	{0x0028, 0x7000},
	{0x002A, 0x02B4},
	{0x0F12, 0x0070},	//REG_0TC_PCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
	{0x002A, 0x03A6},
	{0x0F12, 0x0070},	//REG_0TC_CCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
};

static struct regval_list sensor_fmt_yuv422_uyvy[] = {
//==================================================================================
// 20.Preview & Capture Configration Setting
//==================================================================================
//{0xFFFF, 0x0000},
{0xFCFC, 0xD000},
{0x0028, 0x7000},
{0x002A, 0x02B4},
{0x0F12, 0x0050},	//REG_0TC_PCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
{0x002A, 0x03A6},
{0x0F12, 0x0050},	//REG_0TC_CCFG_PVIMask    [5:4] YUYV 00 / UYVY 01 / YVYU 10 / VYUV 11
};
#endif

static int sensor_g_hflip(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->hflip;
	return 0;
}

static int sensor_s_hflip(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);
	unsigned short pre_val,cap_val;
	struct regval_list regs[] = {
		////==================================================================================
		//// 20.Preview & Capture Configration Setting
		////==================================================================================
		//{0xFCFC, 0xD000},
		//{0x0028, 0x7000},
		//{0x002A, 0x02D0},
		//{0x0F12, 0x0000},	//REG_0TC_PCFG_uPrevMirror     Original 00 / H Mirror 05 / V Mirror 0A / HV Mirror 0F
		//{0x0F12, 0x0000},	//REG_0TC_PCFG_uCaptureMirror  Original 00 / H Mirror 05 / V Mirror 0A / HV Mirror 0F

		//==================================================================================
		// 21.Select Cofigration Display
		//==================================================================================
		//PREVIEW
		{0xFCFC, 0xD000},
		{0x0028, 0x7000},
		{0x002A, 0x0266},
		{0x0f12, 0x0000},	//REG_TC_GP_ActivePrevConfig
		{0x002A, 0x026A},
		{0x0F12, 0x0001},	//REG_TC_GP_PrevOpenAfterChange
		{0x002A, 0x024E},
		{0x0F12, 0x0001},	//REG_TC_GP_NewConfigSync
		{0x002A, 0x0268},
		{0x0F12, 0x0001},	//REG_TC_GP_PrevConfigChanged
		{0x002A, 0x023E},
		{0x0F12, 0x0001},	//REG_TC_GP_EnablePreview
		{0x0F12, 0x0001},	//REG_TC_GP_EnablePreviewChanged;
  };

	if(info->hflip == value)
		return 0;

	sensor_write(sd, 0x002c , 0x7000);
	sensor_write(sd, 0x002e , 0x02d0);
	sensor_read(sd, 0x0f12, &pre_val);
	sensor_read(sd, 0x0f12, &cap_val);
	sensor_write(sd, 0x0028, 0x7000);
	sensor_write(sd, 0x002a, 0x02d0);

	switch (value) {
		case 0:
		  pre_val &= 0xfa;
		  cap_val &= 0xfa;
			break;
		case 1:
		  pre_val |= 0x05;
		  cap_val |= 0x05;
			break;
		default:
			return -EINVAL;
	}

	sensor_write(sd, 0x0f12, pre_val);
	sensor_write(sd, 0x0f12, cap_val);

	ret = sensor_write_array(sd, regs, ARRAY_SIZE(regs));
	if (ret < 0) {
		vfe_dev_err("sensor_write err at sensor_s_hflip!\n");
		return ret;
	}

	info->hflip = value;

	return 0;
}

static int sensor_g_vflip(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->vflip;
	return 0;
}

static int sensor_s_vflip(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);
	unsigned short pre_val,cap_val;
	struct regval_list regs[] = {
		////==================================================================================
		//// 20.Preview & Capture Configration Setting
		////==================================================================================
		//{0xFCFC, 0xD000},
		//{0x0028, 0x7000},
		//{0x002A, 0x02D0},
		//{0x0F12, 0x0000},	//REG_0TC_PCFG_uPrevMirror     Original 00 / H Mirror 05 / V Mirror 0A / HV Mirror 0F
		//{0x0F12, 0x0000},	//REG_0TC_PCFG_uCaptureMirror  Original 00 / H Mirror 05 / V Mirror 0A / HV Mirror 0F

		//==================================================================================
		// 21.Select Cofigration Display
		//==================================================================================
		//PREVIEW
		{0xFCFC, 0xD000},
		{0x0028, 0x7000},
		{0x002A, 0x0266},
		{0x0f12, 0x0000},	//REG_TC_GP_ActivePrevConfig
		{0x002A, 0x026A},
		{0x0F12, 0x0001},	//REG_TC_GP_PrevOpenAfterChange
		{0x002A, 0x024E},
		{0x0F12, 0x0001},	//REG_TC_GP_NewConfigSync
		{0x002A, 0x0268},
		{0x0F12, 0x0001},	//REG_TC_GP_PrevConfigChanged
		{0x002A, 0x023E},
		{0x0F12, 0x0001},	//REG_TC_GP_EnablePreview
		{0x0F12, 0x0001},	//REG_TC_GP_EnablePreviewChanged;
 	};

	if(info->vflip == value)
		return 0;

	sensor_write(sd, 0x0028, 0x7000);
	sensor_write(sd, 0x002a, 0x02d0);
	sensor_write(sd, 0x002c , 0x7000);
	sensor_write(sd, 0x002e , 0x02d0);
	sensor_read(sd, 0x0f12, &pre_val);
	sensor_read(sd, 0x0f12, &cap_val);

	switch (value) {
		case 0:
		  pre_val &= 0xf5;
		  cap_val &= 0xf5;
			break;
		case 1:
		  pre_val |= 0x0A;
		  cap_val |= 0x0A;
			break;
		default:
			return -EINVAL;
	}

	sensor_write(sd, 0x0f12, pre_val);
	sensor_write(sd, 0x0f12, cap_val);

	ret = sensor_write_array(sd, regs, ARRAY_SIZE(regs));
	if (ret < 0) {
		vfe_dev_err("sensor_write err at sensor_s_vflip!\n");
		return ret;
	}

	info->vflip = value;

	return 0;
}

/* stuff about exposure when capturing image */

static int sensor_set_exposure(struct v4l2_subdev *sd)
{
	return 0;
}

/* stuff about auto focus */
static int sensor_download_af_fw(struct v4l2_subdev *sd)
{
	return 0;
}

static int sensor_ae_awb_lockon(struct v4l2_subdev *sd)
{
	int ret;

	ret = sensor_write_array(sd, sensor_ae_awb_lockon_regs , ARRAY_SIZE(sensor_ae_awb_lockon_regs));
	if(ret < 0)
		vfe_dev_err("sensor_ae_awb_lockon error!\n");

	return ret;
};

static int sensor_ae_awb_lockoff(struct v4l2_subdev *sd)
{
	int ret;

	ret = sensor_write_array(sd, sensor_ae_awb_lockoff_regs , ARRAY_SIZE(sensor_ae_awb_lockoff_regs));
	if(ret < 0)
		vfe_dev_err("sensor_ae_awb_lockoff error!\n");

	return ret;
};

static int sensor_s_single_af(struct v4l2_subdev *sd)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	vfe_dev_print("sensor_s_single_af\n");

	info->focus_status = 0;	//idle
	coarse_af_pd = 0;
	//ae lock on
	sensor_ae_awb_lockon(sd);

	//single trigger
	ret = sensor_write_array(sd, sensor_af_single_trig_regs , ARRAY_SIZE(sensor_af_single_trig_regs));
	if(ret < 0) {
		vfe_dev_err("sensor_s_single_af error!\n");
		sensor_ae_awb_lockoff(sd);
	} else if(ret == 0) {
		info->focus_status = 1;	//busy
	}

	return ret;
}

static int sensor_g_single_af(struct v4l2_subdev *sd)
{
	unsigned short rdval;
	int ret;
	struct sensor_info *info = to_state(sd);

	vfe_dev_dbg("sensor_g_single_af\n");
	vfe_dev_dbg("coarse_af_pd = %d\n",coarse_af_pd);
	if(coarse_af_pd != 1) {
		//wait for 1st af complete
		rdval = 0xffff;
		sensor_write(sd, 0x002c , 0x7000);
		sensor_write(sd, 0x002e , 0x2eee);
		ret =  sensor_read(sd, 0x0f12 , &rdval);
		if (ret < 0)
		{
			vfe_dev_err("sensor_g_single_af read error !\n");
			ret = -EAGAIN;
			goto af_out;
		}

		if(rdval == 0x0001 ) {
			vfe_dev_dbg("Single AF 1st is busy,value = 0x%4x\n",rdval);
			msleep(50);
			coarse_af_pd = 0;
			return EBUSY;
		} else if (rdval == 0x0002) {
			//focus ok
			coarse_af_pd = 1;
			vfe_dev_print("Single AF 1st is complete,value = 0x%4x\n",rdval);
		} else {
			vfe_dev_print("Single AF 1st is failed,value = 0x%4x\n",rdval);
			info->focus_status = 0;	//idle
			coarse_af_pd = 2;
			ret = EFAULT;
			goto af_out;
		}
	}

	//wait for 2nd af complete
	rdval = 0xffff;
	sensor_write(sd, 0x002c , 0x7000);
	sensor_write(sd, 0x002e , 0x2207);
	ret =  sensor_read(sd, 0x0f12 , &rdval);
	if (ret < 0)
	{
		vfe_dev_err("sensor_g_single_af read error !\n");
		goto af_out;
	}

	if((rdval&0xff00)!=0x0000) {
		vfe_dev_dbg("Single AF 2nd is busy,value = 0x%4x\n",rdval);
		return EBUSY;
	}

	vfe_dev_print("Single AF 2nd is complete,value = 0x%4x\n",rdval);
	info->focus_status = 0;	//idle

	ret = 0;
af_out:

	//ae lock off
	sensor_ae_awb_lockoff(sd);

	return ret;
}

static int sensor_g_contin_af(struct v4l2_subdev *sd)
{
  	return V4L2_AUTO_FOCUS_STATUS_IDLE;
}

static int sensor_g_af_status(struct v4l2_subdev *sd)
{
	int ret=0;
	struct sensor_info *info = to_state(sd);

	if(info->auto_focus==1)
		ret = sensor_g_contin_af(sd);
	else
		ret = sensor_g_single_af(sd);

	return ret;
}

static int sensor_s_init_af(struct v4l2_subdev *sd)
{
	int ret;
	struct sensor_info *info = to_state(sd);
	ret=sensor_download_af_fw(sd);
	if(ret==0)
		info->af_first_flag=0;
	//other config
	return ret;
}

static int sensor_s_infinity_af(struct v4l2_subdev *sd)
{
	int ret;

	vfe_dev_print("sensor_s_infinity_af\n");
	ret = sensor_write_array(sd,sensor_af_infinity_regs,ARRAY_SIZE(sensor_af_infinity_regs));
	if(ret < 0)
		vfe_dev_err("sensor_s_infinity_af error\n");

	return ret;
}

static int sensor_s_pause_af(struct v4l2_subdev *sd)
{
	return 0;
}

static int sensor_s_release_af(struct v4l2_subdev *sd)
{
	return 0;
}

static int sensor_s_continueous_af(struct v4l2_subdev *sd, int value)
{
	int ret = 0;
	struct sensor_info *info = to_state(sd);

	vfe_dev_print("sensor_s_continueous_af[0x%x]\n",value);

	if(value==1)
	{
		ret = sensor_write_array(sd,sensor_af_continueous_regs,ARRAY_SIZE(sensor_af_continueous_regs));
		if(ret < 0)
			vfe_dev_err("sensor_s_continueous_af error\n");
		info->auto_focus=1;
	}
	else
	{
		LOG_ERR_RET(sensor_s_infinity_af(sd));
		info->auto_focus=0;
	}

	return ret;
}

static int sensor_s_af_zone(struct v4l2_subdev *sd,
														struct v4l2_win_coordinate * win_c)
{
	struct sensor_info *info = to_state(sd);

	int x1,y1,x2,y2;
	unsigned int xc,yc;
	unsigned int prv_x,prv_y;

	int fst_win_start_x,fst_win_start_y;
	int fst_disp_start_x,fst_disp_start_y;
	int fst_win_size_x = 512,fst_win_size_y = 568;
	int fst_disp_size_x,fst_disp_size_y;
	int scnd_win_start_x,scnd_win_start_y;
	int scnd_disp_start_x,scnd_disp_start_y;
	int scnd_win_size_x = 116,scnd_win_size_y = 306;
	int scnd_disp_size_x,scnd_disp_size_y;

	if(info->focus_status == 1)	//can not set af zone when focus is busy
		return 0;

	if(info->width == 0 || info->height == 0) {
		vfe_dev_err("current width or height is zero!\n");
		return -EINVAL;
	}
	vfe_dev_print("sensor_s_af_zone\n");

	prv_x=(int)info->width;
	prv_y=(int)info->height;

	x1=win_c->x1;
	y1=win_c->y1;
	x2=win_c->x2;
	y2=win_c->y2;

#ifdef AF_WIN_NEW_COORD
	xc=prv_x*((unsigned int)(2000+x1+x2)/2)/2000;
	yc=(prv_y*((unsigned int)(2000+y1+y2)/2)/2000);
#else
	xc=(x1+x2)/2;
	yc=(y1+y2)/2;
#endif
	vfe_dev_dbg("af zone input xc=%d,yc=%d\n",xc,yc);

	//first window

	fst_disp_size_x = fst_win_size_x * info->width /1024;

	if(xc + fst_disp_size_x/2 > info->width) {
		fst_disp_start_x = info->width - fst_disp_size_x;
	} else if(xc - (fst_disp_size_x/2) < 0) {
		fst_disp_start_x = 0;
	} else {
		fst_disp_start_x = xc - (fst_disp_size_x/2);
	}

	fst_disp_size_y = fst_win_size_y * info->height /1024;
	if(yc + fst_disp_size_y/2 > info->height) {
		fst_disp_start_y = info->height - fst_disp_size_y;
	} else if(yc - fst_disp_size_y/2 < 0) {
		fst_disp_start_y = 0;
	} else {
		fst_disp_start_y = yc - fst_disp_size_y/2;
	}

	fst_win_start_x = fst_disp_start_x * 1024 / info->width;
	fst_win_start_y = fst_disp_start_y * 1024 / info->height;

	//second window

	scnd_disp_size_x = scnd_win_size_x * info->width /1024;
	if(xc + scnd_disp_size_x/2 > info->width) {
		scnd_disp_start_x = info->width - scnd_disp_size_x;
	} else if(xc - scnd_disp_size_x/2 < 0) {
		scnd_disp_start_x = 0;
	} else {
		scnd_disp_start_x = xc - scnd_disp_size_x/2;
	}

	scnd_disp_size_y = scnd_win_size_y * info->height /1024;
	if(yc + scnd_disp_size_y/2 > info->height) {
		scnd_disp_start_y = info->height - scnd_disp_size_y;
	} else if(yc - scnd_disp_size_y/2 < 0) {
		scnd_disp_start_y = 0;
	} else {
		scnd_disp_start_y = yc - scnd_disp_size_y/2;
	}

	scnd_win_start_x = scnd_disp_start_x * 1024 / info->width;
	scnd_win_start_y = scnd_disp_start_y * 1024 / info->height;

	sensor_write(sd, 0x0028, 0x7000);
	sensor_write(sd, 0x002a, 0x0294);
	sensor_write(sd, 0x0f12, fst_win_start_x);	//REG_TC_AF_FstWinStartX
	sensor_write(sd, 0x0f12, fst_win_start_y);	//REG_TC_AF_FstWinStartY
	sensor_write(sd, 0x0f12, fst_win_size_x); 	//REG_TC_AF_FstWinSizeX
	sensor_write(sd, 0x0f12, fst_win_size_y); 	//REG_TC_AF_FstWinSizeY
	sensor_write(sd, 0x0f12, scnd_win_start_x); //REG_TC_AF_ScndWinStartX
	sensor_write(sd, 0x0f12, scnd_win_start_y);	//REG_TC_AF_ScndWinStartY
	sensor_write(sd, 0x0f12, scnd_win_size_x);	//REG_TC_AF_ScndWinSizeX
	sensor_write(sd, 0x0f12, scnd_win_size_y);	//REG_TC_AF_ScndWinSizeY
	sensor_write(sd, 0x0f12, 0x0001);						//REG_TC_AF_WinSizesUpdated;

	vfe_dev_dbg("af zone 1st window stx=%d,sty=%d,width=%d,height=%d\n",fst_win_start_x,fst_win_start_y,fst_win_size_x,fst_win_size_y);
	vfe_dev_dbg("af zone 2nd window stx=%d,sty=%d,width=%d,height=%d\n",scnd_win_start_x,scnd_win_start_y,scnd_win_size_x,scnd_win_size_y);

	usleep_range(30000,31000);
	return 0;
}

static int sensor_g_autogain(struct v4l2_subdev *sd, __s32 *value)
{
	return -EINVAL;
}

static int sensor_s_autogain(struct v4l2_subdev *sd, int value)
{
	return -EINVAL;
}

static int sensor_g_autoexp(struct v4l2_subdev *sd, __s32 *value)
{
	return -EINVAL;
}

static int sensor_s_autoexp(struct v4l2_subdev *sd,
		enum v4l2_exposure_auto_type value)
{
	return -EINVAL;
}

static int sensor_g_autowb(struct v4l2_subdev *sd, int *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->autowb;
	return 0;
}

static int sensor_s_autowb(struct v4l2_subdev *sd, int value)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	ret = sensor_write_array(sd, sensor_wb_auto_regs, ARRAY_SIZE(sensor_wb_auto_regs));
	if (ret < 0) {
		vfe_dev_err("sensor_write_array err at sensor_s_autowb!\n");
		return ret;
	}

	usleep_range(10000,12000);
	info->autowb = value;

	return 0;
}

static int sensor_g_hue(struct v4l2_subdev *sd, __s32 *value)
{
	return -EINVAL;
}

static int sensor_s_hue(struct v4l2_subdev *sd, int value)
{
	return -EINVAL;
}

static int sensor_g_gain(struct v4l2_subdev *sd, __s32 *value)
{
	return -EINVAL;
}

static int sensor_s_gain(struct v4l2_subdev *sd, int value)
{
	return -EINVAL;
}

static int sensor_g_band_filter(struct v4l2_subdev *sd,
		__s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->band_filter;
	return 0;
}

static int sensor_s_band_filter(struct v4l2_subdev *sd,
		enum v4l2_power_line_frequency value)
{
	struct sensor_info *info = to_state(sd);

	int ret = 0;

	switch(value) {
		case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED:
			break;
		case V4L2_CID_POWER_LINE_FREQUENCY_50HZ:
			ret = sensor_write_array(sd, sensor_flicker_50hz_regs, ARRAY_SIZE(sensor_flicker_50hz_regs));
			if (ret < 0)
				vfe_dev_err("sensor_write_array err at sensor_s_band_filter!\n");
			break;
		case V4L2_CID_POWER_LINE_FREQUENCY_60HZ:
			ret = sensor_write_array(sd, sensor_flicker_60hz_regs, ARRAY_SIZE(sensor_flicker_60hz_regs));
			if (ret < 0)
				vfe_dev_err("sensor_write_array err at sensor_s_band_filter!\n");
		  break;
		case V4L2_CID_POWER_LINE_FREQUENCY_AUTO:
		  break;
	}
	//usleep_range(10000,12000);
	info->band_filter = value;
	return ret;
}

static int sensor_g_brightness(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->brightness;
	return 0;
}

static int sensor_s_brightness(struct v4l2_subdev *sd, int value)
{
	struct sensor_info *info = to_state(sd);

	if(info->brightness == value)
		return 0;

	if(value < -4 || value > 4)
		return -ERANGE;

	LOG_ERR_RET(sensor_write_array(sd, sensor_brightness[value+4].regs, sensor_brightness[value+4].size))

	info->brightness = value;
	return 0;
}

static int sensor_g_contrast(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->contrast;
	return 0;
}

static int sensor_s_contrast(struct v4l2_subdev *sd, int value)
{
	struct sensor_info *info = to_state(sd);

	if(info->contrast == value)
		return 0;

	if(value < -4 || value > 4)
		return -ERANGE;

	LOG_ERR_RET(sensor_write_array(sd, sensor_contrast[value+4].regs, sensor_contrast[value+4].size))

	info->contrast = value;
	return 0;
}

static int sensor_g_saturation(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->saturation;
	return 0;
}

static int sensor_s_saturation(struct v4l2_subdev *sd, int value)
{
	struct sensor_info *info = to_state(sd);

	if(info->saturation == value)
		return 0;

	if(value < -4 || value > 4)
		return -ERANGE;

	LOG_ERR_RET(sensor_write_array(sd, sensor_saturation[value+4].regs, sensor_saturation[value+4].size))

	info->saturation = value;
	return 0;
}

static int sensor_g_exp_bias(struct v4l2_subdev *sd, __s32 *value)
{
	struct sensor_info *info = to_state(sd);

	*value = info->exp_bias;
	return 0;
}

static int sensor_s_exp_bias(struct v4l2_subdev *sd, int value)
{
	struct sensor_info *info = to_state(sd);

	if(info->exp_bias == value)
		return 0;

	if(value < -4 || value > 4)
		return -ERANGE;

	LOG_ERR_RET(sensor_write_array(sd, sensor_ev[value+4].regs, sensor_ev[value+4].size))

	info->exp_bias = value;
	return 0;
}

static int sensor_g_wb(struct v4l2_subdev *sd, int *value)
{
	struct sensor_info *info = to_state(sd);
	enum v4l2_auto_n_preset_white_balance *wb_type = (enum v4l2_auto_n_preset_white_balance*)value;

	*wb_type = info->wb;

	return 0;
}

static int sensor_s_wb(struct v4l2_subdev *sd,
    enum v4l2_auto_n_preset_white_balance value)
{
	struct sensor_info *info = to_state(sd);

	if(info->capture_mode == V4L2_MODE_IMAGE)
		return 0;

	if(info->wb == value)
		return 0;

	LOG_ERR_RET(sensor_write_array(sd, sensor_wb[value].regs ,sensor_wb[value].size) )

	if (value == V4L2_WHITE_BALANCE_AUTO)
		info->autowb = 1;
	else
		info->autowb = 0;

	info->wb = value;
	return 0;
}

static int sensor_g_colorfx(struct v4l2_subdev *sd,
    __s32 *value)
{
	struct sensor_info *info = to_state(sd);
	enum v4l2_colorfx *clrfx_type = (enum v4l2_colorfx*)value;

	*clrfx_type = info->clrfx;
	return 0;
}

static int sensor_s_colorfx(struct v4l2_subdev *sd,
    enum v4l2_colorfx value)
{
	struct sensor_info *info = to_state(sd);

	if(info->clrfx == value)
		return 0;

	LOG_ERR_RET(sensor_write_array(sd, sensor_colorfx[value].regs, sensor_colorfx[value].size))

	info->clrfx = value;
	return 0;
}

static int sensor_g_flash_mode(struct v4l2_subdev *sd,
    __s32 *value)
{
	struct sensor_info *info = to_state(sd);
	enum v4l2_flash_led_mode *flash_mode = (enum v4l2_flash_led_mode*)value;

	*flash_mode = info->flash_mode;
	return 0;
}

static int sensor_s_flash_mode(struct v4l2_subdev *sd,
    enum v4l2_flash_led_mode value)
{
	struct sensor_info *info = to_state(sd);

	info->flash_mode = value;
	return 0;
}


/*
 * Stuff that knows about the sensor.
 */

static int sensor_power(struct v4l2_subdev *sd, int on)
{
	switch(on)
	{
		case CSI_SUBDEV_STBY_ON:
			vfe_dev_dbg("CSI_SUBDEV_STBY_ON\n");
			cci_lock(sd);
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			usleep_range(1000,1200);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_LOW);
			usleep_range(1000,1200);
			vfe_set_mclk(sd,OFF);
			cci_unlock(sd);
			break;
		case CSI_SUBDEV_STBY_OFF:
			vfe_dev_dbg("CSI_SUBDEV_STBY_OFF\n");
			cci_lock(sd);
			vfe_set_mclk_freq(sd,MCLK);
			vfe_set_mclk(sd,ON);
			usleep_range(1000,1200);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_HIGH);
			usleep_range(1000,1200);
			vfe_gpio_write(sd,RESET,CSI_GPIO_HIGH);
			usleep_range(1000,1200);
			cci_unlock(sd);
			break;
		case CSI_SUBDEV_PWR_ON:
			vfe_dev_dbg("CSI_SUBDEV_PWR_ON\n");
			cci_lock(sd);
			vfe_gpio_set_status(sd,PWDN,1);//set the gpio to output
			vfe_gpio_set_status(sd,RESET,1);//set the gpio to output
			vfe_gpio_write(sd,PWDN,CSI_GPIO_LOW);
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			vfe_gpio_write(sd,POWER_EN,CSI_GPIO_HIGH);
			vfe_set_pmu_channel(sd,IOVDD,ON);
			vfe_set_pmu_channel(sd,AVDD,ON);
			vfe_set_pmu_channel(sd,DVDD,ON);
			vfe_set_pmu_channel(sd,AFVDD,ON);
			usleep_range(10000,12000);
      vfe_set_mclk_freq(sd,MCLK);
			vfe_set_mclk(sd,ON);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_HIGH);
			usleep_range(10000,12000);
			vfe_gpio_write(sd,RESET,CSI_GPIO_HIGH);
			usleep_range(10000,12000);
			cci_unlock(sd);
			break;
		case CSI_SUBDEV_PWR_OFF:
			vfe_dev_dbg("CSI_SUBDEV_PWR_OFF\n");
			cci_lock(sd);
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			udelay(100);
			vfe_set_mclk(sd,OFF);
			udelay(10);
			vfe_gpio_write(sd,PWDN,CSI_GPIO_LOW);
			vfe_gpio_write(sd,POWER_EN,CSI_GPIO_LOW);
			vfe_set_pmu_channel(sd,IOVDD,OFF);
			vfe_set_pmu_channel(sd,AVDD,OFF);
			vfe_set_pmu_channel(sd,DVDD,OFF);
			vfe_set_pmu_channel(sd,AFVDD,OFF);
			vfe_gpio_set_status(sd,PWDN,0);//set the gpio to input
			vfe_gpio_set_status(sd,RESET,0);//set the gpio to input
			cci_unlock(sd);
			break;
		default:
			return -EINVAL;
	}

	return 0;
}

static int sensor_reset(struct v4l2_subdev *sd, u32 val)
{
	switch(val)
	{
		case 0:
			vfe_gpio_write(sd,RESET,CSI_GPIO_HIGH);
			usleep_range(10000,12000);
			break;
		case 1:
			vfe_gpio_write(sd,RESET,CSI_GPIO_LOW);
			usleep_range(10000,12000);
			break;
		default:
			return -EINVAL;
	}

	return 0;
}

static int sensor_detect(struct v4l2_subdev *sd)
{
	int ret;
	data_type rdval=0xffff;

	ret = sensor_write(sd, 0x002c, 0x7000);
	ret = sensor_write(sd, 0x002e, 0x01a4);
	if (ret < 0)
	{
		vfe_dev_err("sensor_write err at sensor_detect!\n");
		return ret;
	}

	ret = sensor_read(sd, 0x0f12, &rdval);

	if(rdval != 0x4ec0 )
	{
		vfe_dev_err("id read from sensor is 0x%4x,not 0x4ec0\n",rdval);
		return -ENODEV;
	}

	return 0;
}

static int sensor_init(struct v4l2_subdev *sd, u32 val)
{
	int ret;
	struct sensor_info *info = to_state(sd);

	vfe_dev_dbg("sensor_init\n");

	/*Make sure it is a target sensor*/
	ret = sensor_detect(sd);
	if (ret) {
		vfe_dev_err("chip found is not an target chip.\n");
		return ret;
	}

	vfe_get_standby_mode(sd,&info->stby_mode);

	if((info->stby_mode == HW_STBY || info->stby_mode == SW_STBY) \
	  && info->init_first_flag == 0) {
		vfe_dev_print("stby_mode and init_first_flag = 0\n");
		return 0;
	}

	info->focus_status = 0;
	info->width = 0;
	info->height = 0;
	info->brightness = 0;
	info->contrast = 0;
	info->saturation = 0;
	info->hue = 0;
	info->hflip = 0;
	info->vflip = 0;
	info->gain = 0;
	info->autogain = 1;
	info->exp = 0;
	info->autoexp = 0;
	info->autowb = 1;
	info->wb = V4L2_WHITE_BALANCE_AUTO;
	info->clrfx = V4L2_COLORFX_NONE;
	info->band_filter = V4L2_CID_POWER_LINE_FREQUENCY_50HZ;
	info->tpf.numerator = 1;
	info->tpf.denominator = 30;    /* 30fps */
	info->width = 0;
	info->height = 0;

	ret = sensor_write_array(sd, sensor_default_regs , ARRAY_SIZE(sensor_default_regs));
	if(ret < 0) {
		vfe_dev_err("write sensor_default_regs error\n");
		return ret;
	}

	sensor_s_band_filter(sd, V4L2_CID_POWER_LINE_FREQUENCY_50HZ);

	if(info->stby_mode == 0)
		info->init_first_flag = 0;

  	info->preview_first_flag = 1;
	return 0;
}

static void sensor_s_af_win(struct v4l2_subdev *sd, struct v4l2_win_setting * af_win)
{
	sensor_s_af_zone(sd, &af_win->coor[0]);
}
static void sensor_s_ae_win(struct v4l2_subdev *sd, struct v4l2_win_setting * ae_win)
{

}

static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
{
	int ret=0;
	switch(cmd) {
		case SET_AUTO_FOCUS_WIN:
			sensor_s_af_win(sd, (struct v4l2_win_setting *)arg);
			break;
		case SET_AUTO_EXPOSURE_WIN:
			sensor_s_ae_win(sd, (struct v4l2_win_setting *)arg);
			break;
		default:
			return -EINVAL;
	}
	return ret;
}


/*
 * Store information about the video data format.
 */
static struct sensor_format_struct {
	__u8 *desc;
	//__u32 pixelformat;
	enum v4l2_mbus_pixelcode mbus_code;//linux-3.0
	struct regval_list *regs;
	int	regs_size;
	int bpp;   /* Bytes per pixel */
} sensor_formats[] = {
	{
		.desc   = "MIPI YUV422",
		.mbus_code  = V4L2_MBUS_FMT_UYVY8_16X1,
		.regs     = sensor_fmt_mipi_yuv422,
		.regs_size = ARRAY_SIZE(sensor_fmt_mipi_yuv422),
		.bpp    = 2,
	},

	/*{
		.desc		= "YUYV 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_YUYV8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_yuyv,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_yuyv),
		.bpp		= 2,
	},
	{
		.desc		= "YVYU 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_YVYU8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_yvyu,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_yvyu),
		.bpp		= 2,
	},
	{
		.desc		= "UYVY 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_UYVY8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_uyvy,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_uyvy),
		.bpp		= 2,
	},
	{
		.desc		= "VYUY 4:2:2",
		.mbus_code	= V4L2_MBUS_FMT_VYUY8_2X8,//linux-3.0
		.regs 		= sensor_fmt_yuv422_vyuy,
		.regs_size = ARRAY_SIZE(sensor_fmt_yuv422_vyuy),
		.bpp		= 2,
	},*/
//	{
//		.desc		= "Raw RGB Bayer",
//		.mbus_code	= V4L2_MBUS_FMT_SBGGR8_1X8,//linux-3.0
//		.regs 		= sensor_fmt_raw,
//		.regs_size = ARRAY_SIZE(sensor_fmt_raw),
//		.bpp		= 1
//	},
};
#define N_FMTS ARRAY_SIZE(sensor_formats)



/*
 * Then there is the issue of window sizes.  Try to capture the info here.
 */


static struct sensor_win_size sensor_win_sizes[] = {
	/* qsxga: 2592*1936 */
	{
		.width			= QSXGA_WIDTH,
		.height 		= QSXGA_HEIGHT,
		.regs			  = sensor_qsxga_regs,
	    .hoffset    = 0,
	    .voffset    = 0,
		.regs_size	= ARRAY_SIZE(sensor_qsxga_regs),
		.set_size		= NULL,
	},
	/* qxga: 2048*1536 */
	{
		.width			= QXGA_WIDTH,
		.height 		= QXGA_HEIGHT,
	    .hoffset    = 0,
	    .voffset    = 0,
		.regs			  = sensor_qxga_regs,
		.regs_size	= ARRAY_SIZE(sensor_qxga_regs),
		.set_size		= NULL,
	},
	/* 1080P */
	{
		.width			= HD1080_WIDTH,
		.height			= HD1080_HEIGHT,
	    .hoffset    = 0,
	    .voffset    = 0,
		.regs 			= sensor_1080p_regs,
		.regs_size	= ARRAY_SIZE(sensor_1080p_regs),
		.set_size		= NULL,
	},

	/* 720p */
	{
		.width			= HD720_WIDTH,
		.height			= HD720_HEIGHT,
	    .hoffset    = 0,
	    .voffset    = 0,
		.regs 			= sensor_720p_regs,
		.regs_size	= ARRAY_SIZE(sensor_720p_regs),
		.set_size		= NULL,
	},
	/* VGA */
	{
		.width			= VGA_WIDTH,
		.height			= VGA_HEIGHT,
	    .hoffset    = 0,
	    .voffset    = 0,
		.regs				= sensor_vga_regs,
		.regs_size	= ARRAY_SIZE(sensor_vga_regs),
		.set_size		= NULL,
	},
};

#define N_WIN_SIZES (ARRAY_SIZE(sensor_win_sizes))




static int sensor_enum_fmt(struct v4l2_subdev *sd, unsigned index,
                 enum v4l2_mbus_pixelcode *code)
{
	if (index >= N_FMTS)//linux-3.0
		return -EINVAL;

	*code = sensor_formats[index].mbus_code;
	return 0;
}

static int sensor_enum_size(struct v4l2_subdev *sd,
                            struct v4l2_frmsizeenum *fsize)
{
	if(fsize->index > N_WIN_SIZES-1)
		return -EINVAL;

	fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
	fsize->discrete.width = sensor_win_sizes[fsize->index].width;
	fsize->discrete.height = sensor_win_sizes[fsize->index].height;

	return 0;
}


static int sensor_try_fmt_internal(struct v4l2_subdev *sd,
    struct v4l2_mbus_framefmt *fmt,
    struct sensor_format_struct **ret_fmt,
    struct sensor_win_size **ret_wsize)
{
	int index;
	struct sensor_win_size *wsize;

	for (index = 0; index < N_FMTS; index++)
		if (sensor_formats[index].mbus_code == fmt->code)
			break;

	if (index >= N_FMTS)
		return -EINVAL;

	if (ret_fmt != NULL)
		*ret_fmt = sensor_formats + index;

	/*
	* Fields: the sensor devices claim to be progressive.
	*/

	fmt->field = V4L2_FIELD_NONE;

	/*
	* Round requested image size down to the nearest
	* we support, but not below the smallest.
	*/
	for (wsize = sensor_win_sizes; wsize < sensor_win_sizes + N_WIN_SIZES; wsize++)
		if (fmt->width >= wsize->width && fmt->height >= wsize->height)
			break;

	if (wsize >= sensor_win_sizes + N_WIN_SIZES)
		wsize--;   /* Take the smallest one */
	if (ret_wsize != NULL)
		*ret_wsize = wsize;
	/*
	* Note the size we'll actually handle.
	*/
	fmt->width = wsize->width;
	fmt->height = wsize->height;
	fmt->reserved[0] = wsize->hoffset;
	fmt->reserved[1] = wsize->voffset;

	return 0;
}

static int sensor_try_fmt(struct v4l2_subdev *sd,
             struct v4l2_mbus_framefmt *fmt)
{
	return sensor_try_fmt_internal(sd, fmt, NULL, NULL);
}

static int sensor_g_mbus_config(struct v4l2_subdev *sd,
           struct v4l2_mbus_config *cfg)
{
	cfg->type = V4L2_MBUS_PARALLEL;
	cfg->flags = V4L2_MBUS_MASTER | VREF_POL | HREF_POL | CLK_POL ;

	return 0;
}

/*
 * Set a format.
 */
static int sensor_s_fmt(struct v4l2_subdev *sd,
             struct v4l2_mbus_framefmt *fmt)//linux-3.0
{
	int ret;
	struct sensor_format_struct *sensor_fmt;
	struct sensor_win_size *wsize;
	struct sensor_info *info = to_state(sd);

	vfe_dev_dbg("sensor_s_fmt\n");

	ret = sensor_try_fmt_internal(sd, fmt, &sensor_fmt, &wsize);
	if (ret)
		return ret;

	if(info->fmt == sensor_fmt && info->width == wsize->width && info->height == wsize->height)
	{
		vfe_dev_print("format and size remain the same\n");
		goto update;
	}

	if(info->capture_mode == V4L2_MODE_VIDEO ||
	   info->capture_mode == V4L2_MODE_PREVIEW)
	{

	}
	else if(info->capture_mode == V4L2_MODE_IMAGE)
	{
		//capture
		ret = sensor_set_exposure(sd);
		if (ret < 0)
		{
			vfe_dev_err("sensor_set_exposure err !\n");
			return ret;
		}
	}

	ret = sensor_write_array(sd, sensor_fmt->regs , sensor_fmt->regs_size);
	if (ret < 0)
		return ret;

	ret = 0;
	if (wsize->regs)
		LOG_ERR_RET(sensor_write_array(sd, wsize->regs , wsize->regs_size));

	if (wsize->set_size)
		LOG_ERR_RET(wsize->set_size(sd));

	if(info->capture_mode == V4L2_MODE_VIDEO || info->capture_mode == V4L2_MODE_PREVIEW)
	{

	}

update:
	info->fmt = sensor_fmt;
	info->width = wsize->width;
	info->height = wsize->height;

	vfe_dev_print("s_fmt set width = %d, height = %d\n",wsize->width,wsize->height);

	return 0;
}


/*
 * Implement G/S_PARM.  There is a "high quality" mode we could try
 * to do someday; for now, we just do the frame rate tweak.
 */
static int sensor_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
	struct v4l2_captureparm *cp = &parms->parm.capture;
	struct sensor_info *info = to_state(sd);

	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		return -EINVAL;

	memset(cp, 0, sizeof(struct v4l2_captureparm));
	cp->capability = V4L2_CAP_TIMEPERFRAME;
	cp->capturemode = info->capture_mode;

	cp->timeperframe.numerator = info->tpf.numerator;
	cp->timeperframe.denominator = info->tpf.denominator;

	return 0;
}

static int sensor_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
	struct v4l2_captureparm *cp = &parms->parm.capture;
	struct v4l2_fract *tpf = &cp->timeperframe;
	struct sensor_info *info = to_state(sd);
	unsigned char div;

	vfe_dev_dbg("sensor_s_parm\n");

	if (parms->type != V4L2_BUF_TYPE_VIDEO_CAPTURE){
		vfe_dev_dbg("parms->type!=V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
		return -EINVAL;
	}

	if (info->tpf.numerator == 0){
		vfe_dev_dbg("info->tpf.numerator == 0\n");
		return -EINVAL;
	}

	info->capture_mode = cp->capturemode;

	if (info->capture_mode == V4L2_MODE_IMAGE) {
		vfe_dev_dbg("capture mode is not video mode,can not set frame rate!\n");
		return 0;
	}

	if (tpf->numerator == 0 || tpf->denominator == 0) {
		tpf->numerator = 1;
		tpf->denominator = SENSOR_FRAME_RATE;/* Reset to full rate */
		vfe_dev_err("sensor frame rate reset to full rate!\n");
	}

	div = SENSOR_FRAME_RATE/(tpf->denominator/tpf->numerator);
	if(div > 15 || div == 0)
	{
		vfe_dev_print("SENSOR_FRAME_RATE=%d\n",SENSOR_FRAME_RATE);
		vfe_dev_print("tpf->denominator=%d\n",tpf->denominator);
		vfe_dev_print("tpf->numerator=%d\n",tpf->numerator);
		return -EINVAL;
	}

	vfe_dev_dbg("set frame rate %d\n",tpf->denominator/tpf->numerator);

	info->tpf.denominator = SENSOR_FRAME_RATE;
	info->tpf.numerator = div;

	if(info->tpf.denominator/info->tpf.numerator < 30)
		info->low_speed = 1;

	return 0;
}


static int sensor_queryctrl(struct v4l2_subdev *sd,
    struct v4l2_queryctrl *qc)
{
  /* Fill in min, max, step and default value for these controls. */
  /* see include/linux/videodev2.h for details */
//  vfe_dev_dbg("queryctrl qc->id=0x%8x\n", qc->id);
  switch (qc->id) {
//  case V4L2_CID_BRIGHTNESS:
//    return v4l2_ctrl_query_fill(qc, -4, 4, 1, 1);
//  case V4L2_CID_CONTRAST:
//    return v4l2_ctrl_query_fill(qc, -4, 4, 1, 1);
//  case V4L2_CID_SATURATION:
//    return v4l2_ctrl_query_fill(qc, -4, 4, 1, 1);
//  case V4L2_CID_HUE:
//    return v4l2_ctrl_query_fill(qc, -180, 180, 5, 0);
	case V4L2_CID_VFLIP:
	case V4L2_CID_HFLIP:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
//  case V4L2_CID_GAIN:
//    return v4l2_ctrl_query_fill(qc, 0, 255, 1, 128);
//  case V4L2_CID_AUTOGAIN:
//    return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
	case V4L2_CID_EXPOSURE:
	case V4L2_CID_AUTO_EXPOSURE_BIAS:
		return v4l2_ctrl_query_fill(qc, -4, 4, 1, 0);
	case V4L2_CID_EXPOSURE_AUTO:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
		return v4l2_ctrl_query_fill(qc, 0, 9, 1, 1);
	case V4L2_CID_AUTO_WHITE_BALANCE:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
	case V4L2_CID_COLORFX:
		return v4l2_ctrl_query_fill(qc, 0, 15, 1, 0);
	case V4L2_CID_FLASH_LED_MODE:
		return v4l2_ctrl_query_fill(qc, 0, 4, 1, 0);
//  case V4L2_CID_3A_LOCK:
//    return v4l2_ctrl_query_fill(qc, 0, V4L2_LOCK_FOCUS, 1, 0);
//  case V4L2_CID_AUTO_FOCUS_RANGE:
//    return v4l2_ctrl_query_fill(qc, 0, 0, 0, 0);//only auto
	case V4L2_CID_AUTO_FOCUS_INIT:
	case V4L2_CID_AUTO_FOCUS_RELEASE:
	case V4L2_CID_AUTO_FOCUS_START:
	case V4L2_CID_AUTO_FOCUS_STOP:
	case V4L2_CID_AUTO_FOCUS_STATUS:
		return v4l2_ctrl_query_fill(qc, 0, 0, 0, 0);
	case V4L2_CID_FOCUS_AUTO:
		return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
	}
	return -EINVAL;
}

static int sensor_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	switch (ctrl->id) {
	case V4L2_CID_BRIGHTNESS:
		return sensor_g_brightness(sd, &ctrl->value);
	case V4L2_CID_CONTRAST:
		return sensor_g_contrast(sd, &ctrl->value);
	case V4L2_CID_SATURATION:
		return sensor_g_saturation(sd, &ctrl->value);
	case V4L2_CID_HUE:
		return sensor_g_hue(sd, &ctrl->value);
	case V4L2_CID_VFLIP:
		return sensor_g_vflip(sd, &ctrl->value);
	case V4L2_CID_HFLIP:
		return sensor_g_hflip(sd, &ctrl->value);
	case V4L2_CID_GAIN:
		return sensor_g_gain(sd, &ctrl->value);
	case V4L2_CID_AUTOGAIN:
		return sensor_g_autogain(sd, &ctrl->value);
	case V4L2_CID_EXPOSURE:
	case V4L2_CID_AUTO_EXPOSURE_BIAS:
		return sensor_g_exp_bias(sd, &ctrl->value);
	case V4L2_CID_EXPOSURE_AUTO:
		return sensor_g_autoexp(sd, &ctrl->value);
	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
		return sensor_g_wb(sd, &ctrl->value);
	case V4L2_CID_AUTO_WHITE_BALANCE:
		return sensor_g_autowb(sd, &ctrl->value);
	case V4L2_CID_COLORFX:
		return sensor_g_colorfx(sd, &ctrl->value);
	case V4L2_CID_FLASH_LED_MODE:
		return sensor_g_flash_mode(sd, &ctrl->value);
	case V4L2_CID_POWER_LINE_FREQUENCY:
		return sensor_g_band_filter(sd, &ctrl->value);
//  case V4L2_CID_3A_LOCK:
//  	return sensor_g_3a_lock(sd);
//  case V4L2_CID_AUTO_FOCUS_RANGE:
//  	ctrl->value=0;//only auto
//  	return 0;
//  case V4L2_CID_AUTO_FOCUS_INIT:
//  case V4L2_CID_AUTO_FOCUS_RELEASE:
//  case V4L2_CID_AUTO_FOCUS_START:
//  case V4L2_CID_AUTO_FOCUS_STOP:
	case V4L2_CID_AUTO_FOCUS_STATUS:
		return sensor_g_af_status(sd);
//  case V4L2_CID_FOCUS_AUTO:
	}
	return -EINVAL;
}

static int sensor_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
	switch (ctrl->id) {
	case V4L2_CID_BRIGHTNESS:
		return sensor_s_brightness(sd, ctrl->value);
	case V4L2_CID_CONTRAST:
		return sensor_s_contrast(sd, ctrl->value);
	case V4L2_CID_SATURATION:
		return sensor_s_saturation(sd, ctrl->value);
	case V4L2_CID_HUE:
		return sensor_s_hue(sd, ctrl->value);
	case V4L2_CID_VFLIP:
		return sensor_s_vflip(sd, ctrl->value);
	case V4L2_CID_HFLIP:
		return sensor_s_hflip(sd, ctrl->value);
	case V4L2_CID_GAIN:
		return sensor_s_gain(sd, ctrl->value);
	case V4L2_CID_AUTOGAIN:
		return sensor_s_autogain(sd, ctrl->value);
	case V4L2_CID_EXPOSURE:
	case V4L2_CID_AUTO_EXPOSURE_BIAS:
		return sensor_s_exp_bias(sd, ctrl->value);
	case V4L2_CID_EXPOSURE_AUTO:
		return sensor_s_autoexp(sd,(enum v4l2_exposure_auto_type) ctrl->value);
	case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
		return sensor_s_wb(sd,(enum v4l2_auto_n_preset_white_balance) ctrl->value);
	case V4L2_CID_AUTO_WHITE_BALANCE:
		return sensor_s_autowb(sd, ctrl->value);
	case V4L2_CID_COLORFX:
		return sensor_s_colorfx(sd,(enum v4l2_colorfx) ctrl->value);
	case V4L2_CID_FLASH_LED_MODE:
		return sensor_s_flash_mode(sd,(enum v4l2_flash_led_mode) ctrl->value);
	case V4L2_CID_POWER_LINE_FREQUENCY:
		return sensor_s_band_filter(sd,(enum v4l2_power_line_frequency) ctrl->value);
//    case V4L2_CID_3A_LOCK:
//    	return sensor_s_3a_lock(sd, ctrl->value);
//    case V4L2_CID_AUTO_FOCUS_RANGE:
//  	  return 0;
	case V4L2_CID_AUTO_FOCUS_INIT:
		return sensor_s_init_af(sd);
	case V4L2_CID_AUTO_FOCUS_RELEASE:
		return sensor_s_release_af(sd);
	case V4L2_CID_AUTO_FOCUS_START:
		return sensor_s_single_af(sd);
	case V4L2_CID_AUTO_FOCUS_STOP:
		return sensor_s_pause_af(sd);
	//  case V4L2_CID_AUTO_FOCUS_STATUS:
	case V4L2_CID_FOCUS_AUTO:
		return sensor_s_continueous_af(sd, ctrl->value);
	}
	return -EINVAL;
}


static int sensor_g_chip_ident(struct v4l2_subdev *sd,
    struct v4l2_dbg_chip_ident *chip)
{
	struct i2c_client *client = v4l2_get_subdevdata(sd);

	return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_SENSOR, 0);
}


/* ----------------------------------------------------------------------- */

static const struct v4l2_subdev_core_ops sensor_core_ops = {
	.g_chip_ident = sensor_g_chip_ident,
	.g_ctrl = sensor_g_ctrl,
	.s_ctrl = sensor_s_ctrl,
	.queryctrl = sensor_queryctrl,
	.reset = sensor_reset,
	.init = sensor_init,
	.s_power = sensor_power,
	.ioctl = sensor_ioctl,
};

static const struct v4l2_subdev_video_ops sensor_video_ops = {
	.enum_mbus_fmt = sensor_enum_fmt,
	.enum_framesizes = sensor_enum_size,
	.try_mbus_fmt = sensor_try_fmt,
	.s_mbus_fmt = sensor_s_fmt,
	.s_parm = sensor_s_parm,
	.g_parm = sensor_g_parm,
	.g_mbus_config = sensor_g_mbus_config,
};

static const struct v4l2_subdev_ops sensor_ops = {
	.core = &sensor_core_ops,
	.video = &sensor_video_ops,
};


/* ----------------------------------------------------------------------- */
static struct cci_driver cci_drv = {
	.name = SENSOR_NAME,
	.addr_width = CCI_BITS_16,
	.data_width = CCI_BITS_16,
};

static int sensor_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct v4l2_subdev *sd;
	struct sensor_info *info;
	info = kzalloc(sizeof(struct sensor_info), GFP_KERNEL);
	if (info == NULL)
		return -ENOMEM;
	sd = &info->sd;
	cci_dev_probe_helper(sd, client, &sensor_ops, &cci_drv);

	info->fmt = &sensor_formats[0];
	info->af_first_flag = 1;
	info->init_first_flag = 1;
	info->auto_focus = 0;

	return 0;
}


static int sensor_remove(struct i2c_client *client)
{
	struct v4l2_subdev *sd;

	sd = cci_dev_remove_helper(client, &cci_drv);
	kfree(to_state(sd));
	return 0;
}

static const struct i2c_device_id sensor_id[] = {
	{ SENSOR_NAME, 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, sensor_id);

static struct i2c_driver sensor_driver = {
	.driver = {
		.owner = THIS_MODULE,
		.name = SENSOR_NAME,
	},
	.probe = sensor_probe,
	.remove = sensor_remove,
	.id_table = sensor_id,
};
static __init int init_sensor(void)
{
	return cci_dev_init_helper(&sensor_driver);
}

static __exit void exit_sensor(void)
{
	cci_dev_exit_helper(&sensor_driver);
}

module_init(init_sensor);
module_exit(exit_sensor);