2 * Driver for OV5642 CMOS Image Sensor from OmniVision
4 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/videodev2.h>
12 #include <linux/slab.h>
13 #include <linux/i2c.h>
14 #include <linux/log2.h>
15 #include <linux/platform_device.h>
16 #include <linux/delay.h>
17 #include <linux/circ_buf.h>
18 #include <linux/miscdevice.h>
19 #include <media/v4l2-common.h>
20 #include <media/v4l2-chip-ident.h>
21 #include <media/soc_camera.h>
22 //#include <mach/gpio.h>
23 #include <plat/rk_camera.h>
24 #include <linux/delay.h>
30 module_param(debug, int, S_IRUGO|S_IWUSR);
32 #define dprintk(level, fmt, arg...) do { \
34 printk(KERN_WARNING fmt , ## arg); } while (0)
36 #define SENSOR_TR(format, ...) printk(KERN_ERR format, ## __VA_ARGS__)
37 #define SENSOR_DG(format, ...) dprintk(1, format, ## __VA_ARGS__)
40 #define _CONS(a,b) a##b
41 #define CONS(a,b) _CONS(a,b)
44 #define _STR(x) __STR(x)
45 #define STR(x) _STR(x)
47 #define MIN(x,y) ((x<y) ? x: y)
48 #define MAX(x,y) ((x>y) ? x: y)
50 /* Sensor Driver Configuration */
51 #define SENSOR_NAME RK29_CAM_SENSOR_S5K5CA
52 #define SENSOR_V4L2_IDENT V4L2_IDENT_S5K5CA
53 #define SENSOR_ID 0x05ca
54 #define SENSOR_ID_REG SEQUENCE_END
55 #define SENSOR_RESET_REG SEQUENCE_END
56 #define SENSOR_RESET_VAL 0x00
57 #define SENSOR_MIN_WIDTH 640
58 #define SENSOR_MIN_HEIGHT 480
59 #define SENSOR_MAX_WIDTH 2048
60 #define SENSOR_MAX_HEIGHT 1536
61 #define SENSOR_INIT_WIDTH 640 /* Sensor pixel size for sensor_init_data array */
62 #define SENSOR_INIT_HEIGHT 480
63 #define SENSOR_INIT_WINSEQADR sensor_vga
64 #define SENSOR_INIT_PIXFMT V4L2_MBUS_FMT_UYVY8_2X8
66 #define CONFIG_SENSOR_WhiteBalance 1
67 #define CONFIG_SENSOR_Brightness 0
68 #define CONFIG_SENSOR_Contrast 0
69 #define CONFIG_SENSOR_Saturation 0
70 #define CONFIG_SENSOR_Effect 1
71 #define CONFIG_SENSOR_Scene 1
72 #define CONFIG_SENSOR_AntiBanding 0
73 #define CONFIG_SENSOR_DigitalZoom 0
74 #define CONFIG_SENSOR_Focus 0
75 #define CONFIG_SENSOR_Exposure 0
76 #define CONFIG_SENSOR_Flash 0
77 #define CONFIG_SENSOR_Mirror 0
78 #define CONFIG_SENSOR_Flip 0
79 #define CONFIG_SENSOR_Focus 0
82 #define CONFIG_SENSOR_I2C_SPEED 400000 /* Hz */
83 /* Sensor write register continues by preempt_disable/preempt_enable for current process not be scheduled */
84 #define CONFIG_SENSOR_I2C_NOSCHED 0
85 #define CONFIG_SENSOR_I2C_RDWRCHK 0
88 #define SENSOR_BUS_PARAM (SOCAM_MASTER | SOCAM_PCLK_SAMPLE_RISING |\
89 SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_HIGH |\
90 SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8 |SOCAM_MCLK_24MHZ)
92 #define COLOR_TEMPERATURE_CLOUDY_DN 6500
93 #define COLOR_TEMPERATURE_CLOUDY_UP 8000
94 #define COLOR_TEMPERATURE_CLEARDAY_DN 5000
95 #define COLOR_TEMPERATURE_CLEARDAY_UP 6500
96 #define COLOR_TEMPERATURE_OFFICE_DN 3500
97 #define COLOR_TEMPERATURE_OFFICE_UP 5000
98 #define COLOR_TEMPERATURE_HOME_DN 2500
99 #define COLOR_TEMPERATURE_HOME_UP 3500
101 #define SENSOR_NAME_STRING(a) STR(CONS(SENSOR_NAME, a))
102 #define SENSOR_NAME_VARFUN(a) CONS(SENSOR_NAME, a)
104 #define SENSOR_AF_IS_ERR (0x00<<0)
105 #define SENSOR_AF_IS_OK (0x01<<0)
106 #define SENSOR_INIT_IS_ERR (0x00<<28)
107 #define SENSOR_INIT_IS_OK (0x01<<28)
109 #if CONFIG_SENSOR_Focus
110 #define SENSOR_AF_MODE_INFINITY 0
111 #define SENSOR_AF_MODE_MACRO 1
112 #define SENSOR_AF_MODE_FIXED 2
113 #define SENSOR_AF_MODE_AUTO 3
114 #define SENSOR_AF_MODE_CONTINUOUS 4
115 #define SENSOR_AF_MODE_CLOSE 5
118 /* init 640X480 SVGA */
119 static struct reginfo sensor_init_data[] =
121 {0xFCFC, 0xD000}, //Reset //
122 {0x0010, 0x0001}, //Clear host interrupt so main will wait //
123 {0x1030, 0x0000}, //ARM go //
124 {0x0014, 0x0001}, //Wait100mSec //
125 {SEQUENCE_WAIT_MS,100}, //DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
175 {0x0F12, 0xFA0C},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
182 {0x0F12, 0xFA05},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
198 {0x0F12, 0xF9F5},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
202 {0x0F12, 0xF9F1},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
206 {0x0F12, 0xF9ED},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
230 {0x0F12, 0x2E75},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
234 {0x0F12, 0x2EFF},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
236 {0x0F12, 0x2F23},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
238 {0x0F12, 0x2FCD},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
240 {0x0F12, 0x2FE1},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
242 {0x0F12, 0x2FB5},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
246 {0x0F12, 0x3067},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
250 {0x0F12, 0x30B5},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
262 {0x0F12, 0x49C2},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
267 {0x0F12, 0xF9B8},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
279 {0x0F12, 0xF9AC},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
286 {0x0F12, 0xF9A5},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
297 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
303 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
348 {0x0F12, 0xF96D},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
352 {0x0F12, 0xF969},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
363 {0x0F12, 0xF96C},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
372 {0x0F12, 0xF955},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
388 {0x0F12, 0xF95B},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
391 {0x0F12, 0xF958},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
397 {0x0F12, 0xF95A},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
426 {0x0F12, 0xF91F},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
429 {0x0F12, 0xF942},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
455 {0x0F12, 0xF930},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
466 {0x0F12, 0x2C00},//DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
467 {0x0F12, 0xD00B},//DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
470 {0x0F12, 0x4869},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
473 {0x0F12, 0x4969},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
483 {0x0F12, 0x4865},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
485 {0x0F12, 0xE7A1},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
491 {0x0F12, 0x4962},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
497 {0x0F12, 0xE74A},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
501 {0x0F12, 0x485E},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
504 {0x0F12, 0x4853},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
507 {0x0F12, 0xE740},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
510 {0x0F12, 0x4C54},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
520 {0x0F12, 0x4C4B},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
523 {0x0F12, 0x4D53},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
527 {0x0F12, 0x484C},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
535 {0x0F12, 0x484D},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
571 {0x0F12, 0x483C},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
574 {0x0F12, 0xE748},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
578 {0x0F12, 0x4839},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
584 {0x0F12, 0x4937},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
657 {0x0F12, 0xE693},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
659 //BEGIN: DTS2012071201781: del by huyouhua 00136760 at 2012-7-20
662 //END: DTS2012071201781: del by huyouhua 00136760 at 2012-7-20
699 {0x0F12, 0x7000},//DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
700 {0x0F12, 0x3274},//DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
836 {0x0F12, 0x7E77},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
840 //========================================================
841 // CIs/APs/An setting - 400LsB sYsCLK 32MHz
842 //========================================================
843 // This regis are for FACTORY ONLY. If you change it without prior notification,
844 // YOU are REsIBLE for the FAILURE that will happen in the future.
845 //========================================================
846 {0x0028, 0x7000},//DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
857 {0x0F12, 0x0001}, // slope calibration tolerance in units of 1/256
863 {0x0F12, 0x01CC}, //ADC sAT of 450mV for 10bit default in EVT1
865 {0x0F12, 0x0C80}, // 3200 Max. Reset ramp DCLK counts {default 2048 0x800}
866 {0x0F12, 0x0578}, // 1400 Max. Reset ramp DCLK counts for x3.5
868 {0x0F12, 0x0190}, // 400 Reset ramp for x1 in DCLK counts
870 {0x0F12, 0x00A0}, // 160 LsB
871 {0x0F12, 0x0010}, // reset threshold
873 {0x0F12, 0x006A}, // 106 additional timing columns.
875 {0x0F12, 0x08AC}, // 2220 ADC columns in normal mode including Hold & Latch
876 {0x0F12, 0x0050}, // 80 addition of ADC columns in Y-ave mode {default 244 0x74}
878 {0x002A, 0x1696}, // based on APs guidelines
879 {0x0F12, 0x0000}, // based on APs guidelines
880 {0x0F12, 0x0000}, // default. 1492 used for ADC dark characteristics
881 {0x0F12, 0x00C6}, // default. 1492 used for ADC dark characteristics
883 //BEGIN: DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
885 {0x0F12, 0x0B00}, //#senHal_ExpMinPixels //disable CINTR 0
886 //END: DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
887 {0x002A, 0x1690}, // when set double sampling is activated - requires different set of pointers
890 {0x002A, 0x12B0}, // comp and pixel bias control 0xF40E - default for EVT1
891 {0x0F12, 0x0055}, // comp and pixel bias control 0xF40E for binning mode
894 {0x002A, 0x337A}, // [7] - is used for rest-only mode {EVT0 value is 0xD and HW 0x6}
897 //BEGIN:DTS2012071201781: del by huyouhua 00136760 at 2012-7-20
902 //END:DTS2012071201781: del by huyouhua 00136760 at 2012-7-20
910 #if defined(CURRENT_4MA)
912 {0x0F12, 0x0155}, //set IO driving current 4mA for Data
913 {0x0F12, 0x0155}, //set IO driving current 4ma for Data
914 {0x0F12, 0x1555}, //set IO driving current
915 {0x0F12, 0x0555}, //set IO driving current 4ma for PCLK/HSYNC/Vsync
916 #elif defined(CURRENT_8MA)
918 {0x0F12, 0x02aa}, //set IO driving current 8mA for Data
919 {0x0F12, 0x02aa}, //set IO driving current
920 {0x0F12, 0x1555}, //set IO driving current
921 {0x0F12, 0x059a}, //set IO driving current
922 #elif defined(CURRENT_12MA)
924 {0x0F12, 0x03ff}, //set IO driving current 12mA for Data
925 {0x0F12, 0x03ff}, //set IO driving current
926 {0x0F12, 0x1555}, //set IO driving current
927 {0x0F12, 0x05df}, //set IO driving current
928 //BEGIN: DTS2012071201781 add by huyouhua 00136760 at 2012-7-23
929 #elif defined(CURRENT_SLIM)
931 {0x0F12, 0x0155},//------- //#Tune_TP_IO_DrivingCurrent_D0_D4_cs10Set IO driving current---------------
932 {0x0F12, 0x0155},//------- //#Tune_TP_IO_DrivingCurrent_D9_D5_cs10Set IO driving current---------------
933 {0x0F12, 0x1555},//------- //#Tune_TP_IO_DrivingCurrent_GPIO_cd10 Set IO driving current---------------
934 //{0x0F12, 0x05DF}//0x0555},//------- - //059A//05DF//#Tune_TP_IO_DrivingCurrent_CLKs_cd10 Set IO driving current-
935 {0x0F12, 0x059A},//0x0555},//------- - //059A//05DF//#Tune_TP_IO_DrivingCurrent_CLKs_cd10 Set IO driving current-
937 //END: DTS2012071201781 add by huyouhua 00136760 at 2012-7-23
940 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
942 {0x0F12, 0x0007}, //evt1_senHal_Dblr2Value // [3:0]- specifies the target (default 7)- DCLK = 64MHz instead of 116MHz.
944 {0x0F12, 0x0000}, //from ALEX //Enable Bayer Downscaler
945 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
948 {0x0F12, 0x0003}, //senHal_pContSenModesRegsArray[0][0]2 700012D2
949 {0x0F12, 0x0003}, //senHal_pContSenModesRegsArray[0][1]2 700012D4
950 {0x0F12, 0x0003}, //senHal_pContSenModesRegsArray[0][2]2 700012D6
951 {0x0F12, 0x0003}, //senHal_pContSenModesRegsArray[0][3]2 700012D8
952 {0x0F12, 0x0884}, //senHal_pContSenModesRegsArray[1][0]2 700012DA
953 {0x0F12, 0x08CF}, //senHal_pContSenModesRegsArray[1][1]2 700012DC
954 {0x0F12, 0x0500}, //senHal_pContSenModesRegsArray[1][2]2 700012DE
955 {0x0F12, 0x054B}, //senHal_pContSenModesRegsArray[1][3]2 700012E0
956 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[2][0]2 700012E2
957 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[2][1]2 700012E4
958 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[2][2]2 700012E6
959 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[2][3]2 700012E8
960 {0x0F12, 0x0885}, //senHal_pContSenModesRegsArray[3][0]2 700012EA
961 {0x0F12, 0x0467}, //senHal_pContSenModesRegsArray[3][1]2 700012EC
962 {0x0F12, 0x0501}, //senHal_pContSenModesRegsArray[3][2]2 700012EE
963 {0x0F12, 0x02A5}, //senHal_pContSenModesRegsArray[3][3]2 700012F0
964 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[4][0]2 700012F2
965 {0x0F12, 0x046A}, //senHal_pContSenModesRegsArray[4][1]2 700012F4
966 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[4][2]2 700012F6
967 {0x0F12, 0x02A8}, //senHal_pContSenModesRegsArray[4][3]2 700012F8
968 {0x0F12, 0x0885}, //senHal_pContSenModesRegsArray[5][0]2 700012FA
969 {0x0F12, 0x08D0}, //senHal_pContSenModesRegsArray[5][1]2 700012FC
970 {0x0F12, 0x0501}, //senHal_pContSenModesRegsArray[5][2]2 700012FE
971 {0x0F12, 0x054C}, //senHal_pContSenModesRegsArray[5][3]2 70001300
972 {0x0F12, 0x0006}, //senHal_pContSenModesRegsArray[6][0]2 70001302
973 {0x0F12, 0x0020}, //senHal_pContSenModesRegsArray[6][1]2 70001304
974 {0x0F12, 0x0006}, //senHal_pContSenModesRegsArray[6][2]2 70001306
975 {0x0F12, 0x0020}, //senHal_pContSenModesRegsArray[6][3]2 70001308
976 {0x0F12, 0x0881}, //senHal_pContSenModesRegsArray[7][0]2 7000130A
977 {0x0F12, 0x0463}, //senHal_pContSenModesRegsArray[7][1]2 7000130C
978 {0x0F12, 0x04FD}, //senHal_pContSenModesRegsArray[7][2]2 7000130E
979 {0x0F12, 0x02A1}, //senHal_pContSenModesRegsArray[7][3]2 70001310
980 {0x0F12, 0x0006}, //senHal_pContSenModesRegsArray[8][0]2 70001312
981 {0x0F12, 0x0489}, //senHal_pContSenModesRegsArray[8][1]2 70001314
982 {0x0F12, 0x0006}, //senHal_pContSenModesRegsArray[8][2]2 70001316
983 {0x0F12, 0x02C7}, //senHal_pContSenModesRegsArray[8][3]2 70001318
984 {0x0F12, 0x0881}, //senHal_pContSenModesRegsArray[9][0]2 7000131A
985 {0x0F12, 0x08CC}, //senHal_pContSenModesRegsArray[9][1]2 7000131C
986 {0x0F12, 0x04FD}, //senHal_pContSenModesRegsArray[9][2]2 7000131E
987 {0x0F12, 0x0548}, //senHal_pContSenModesRegsArray[9][3]2 70001320
988 {0x0F12, 0x03A2}, //senHal_pContSenModesRegsArray[10][0] 2 70001322
989 {0x0F12, 0x01D3}, //senHal_pContSenModesRegsArray[10][1] 2 70001324
990 {0x0F12, 0x01E0}, //senHal_pContSenModesRegsArray[10][2] 2 70001326
991 {0x0F12, 0x00F2}, //senHal_pContSenModesRegsArray[10][3] 2 70001328
992 {0x0F12, 0x03F2}, //senHal_pContSenModesRegsArray[11][0] 2 7000132A
993 {0x0F12, 0x0223}, //senHal_pContSenModesRegsArray[11][1] 2 7000132C
994 {0x0F12, 0x0230}, //senHal_pContSenModesRegsArray[11][2] 2 7000132E
995 {0x0F12, 0x0142}, //senHal_pContSenModesRegsArray[11][3] 2 70001330
996 {0x0F12, 0x03A2}, //senHal_pContSenModesRegsArray[12][0] 2 70001332
997 {0x0F12, 0x063C}, //senHal_pContSenModesRegsArray[12][1] 2 70001334
998 {0x0F12, 0x01E0}, //senHal_pContSenModesRegsArray[12][2] 2 70001336
999 {0x0F12, 0x0399}, //senHal_pContSenModesRegsArray[12][3] 2 70001338
1000 {0x0F12, 0x03F2}, //senHal_pContSenModesRegsArray[13][0] 2 7000133A
1001 {0x0F12, 0x068C}, //senHal_pContSenModesRegsArray[13][1] 2 7000133C
1002 {0x0F12, 0x0230}, //senHal_pContSenModesRegsArray[13][2] 2 7000133E
1003 {0x0F12, 0x03E9}, //senHal_pContSenModesRegsArray[13][3] 2 70001340
1004 {0x0F12, 0x0002}, //senHal_pContSenModesRegsArray[14][0] 2 70001342
1005 {0x0F12, 0x0002}, //senHal_pContSenModesRegsArray[14][1] 2 70001344
1006 {0x0F12, 0x0002}, //senHal_pContSenModesRegsArray[14][2] 2 70001346
1007 {0x0F12, 0x0002}, //senHal_pContSenModesRegsArray[14][3] 2 70001348
1008 {0x0F12, 0x003C}, //senHal_pContSenModesRegsArray[15][0] 2 7000134A
1009 {0x0F12, 0x003C}, //senHal_pContSenModesRegsArray[15][1] 2 7000134C
1010 {0x0F12, 0x003C}, //senHal_pContSenModesRegsArray[15][2] 2 7000134E
1011 {0x0F12, 0x003C}, //senHal_pContSenModesRegsArray[15][3] 2 70001350
1012 {0x0F12, 0x01D3}, //senHal_pContSenModesRegsArray[16][0] 2 70001352
1013 {0x0F12, 0x01D3}, //senHal_pContSenModesRegsArray[16][1] 2 70001354
1014 {0x0F12, 0x00F2}, //senHal_pContSenModesRegsArray[16][2] 2 70001356
1015 {0x0F12, 0x00F2}, //senHal_pContSenModesRegsArray[16][3] 2 70001358
1016 {0x0F12, 0x020B}, //senHal_pContSenModesRegsArray[17][0] 2 7000135A
1017 {0x0F12, 0x024A}, //senHal_pContSenModesRegsArray[17][1] 2 7000135C
1018 {0x0F12, 0x012A}, //senHal_pContSenModesRegsArray[17][2] 2 7000135E
1019 {0x0F12, 0x0169}, //senHal_pContSenModesRegsArray[17][3] 2 70001360
1020 {0x0F12, 0x0002}, //senHal_pContSenModesRegsArray[18][0] 2 70001362
1021 {0x0F12, 0x046B}, //senHal_pContSenModesRegsArray[18][1] 2 70001364
1022 {0x0F12, 0x0002}, //senHal_pContSenModesRegsArray[18][2] 2 70001366
1023 {0x0F12, 0x02A9}, //senHal_pContSenModesRegsArray[18][3] 2 70001368
1024 {0x0F12, 0x0419}, //senHal_pContSenModesRegsArray[19][0] 2 7000136A
1025 {0x0F12, 0x04A5}, //senHal_pContSenModesRegsArray[19][1] 2 7000136C
1026 {0x0F12, 0x0257}, //senHal_pContSenModesRegsArray[19][2] 2 7000136E
1027 {0x0F12, 0x02E3}, //senHal_pContSenModesRegsArray[19][3] 2 70001370
1028 {0x0F12, 0x0630}, //senHal_pContSenModesRegsArray[20][0] 2 70001372
1029 {0x0F12, 0x063C}, //senHal_pContSenModesRegsArray[20][1] 2 70001374
1030 {0x0F12, 0x038D}, //senHal_pContSenModesRegsArray[20][2] 2 70001376
1031 {0x0F12, 0x0399}, //senHal_pContSenModesRegsArray[20][3] 2 70001378
1032 {0x0F12, 0x0668}, //senHal_pContSenModesRegsArray[21][0] 2 7000137A
1033 {0x0F12, 0x06B3}, //senHal_pContSenModesRegsArray[21][1] 2 7000137C
1034 {0x0F12, 0x03C5}, //senHal_pContSenModesRegsArray[21][2] 2 7000137E
1035 {0x0F12, 0x0410}, //senHal_pContSenModesRegsArray[21][3] 2 70001380
1036 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[22][0] 2 70001382
1037 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[22][1] 2 70001384
1038 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[22][2] 2 70001386
1039 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[22][3] 2 70001388
1040 {0x0F12, 0x03A2}, //senHal_pContSenModesRegsArray[23][0] 2 7000138A
1041 {0x0F12, 0x01D3}, //senHal_pContSenModesRegsArray[23][1] 2 7000138C
1042 {0x0F12, 0x01E0}, //senHal_pContSenModesRegsArray[23][2] 2 7000138E
1043 {0x0F12, 0x00F2}, //senHal_pContSenModesRegsArray[23][3] 2 70001390
1044 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[24][0] 2 70001392
1045 {0x0F12, 0x0461}, //senHal_pContSenModesRegsArray[24][1] 2 70001394
1046 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[24][2] 2 70001396
1047 {0x0F12, 0x029F}, //senHal_pContSenModesRegsArray[24][3] 2 70001398
1048 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[25][0] 2 7000139A
1049 {0x0F12, 0x063C}, //senHal_pContSenModesRegsArray[25][1] 2 7000139C
1050 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[25][2] 2 7000139E
1051 {0x0F12, 0x0399}, //senHal_pContSenModesRegsArray[25][3] 2 700013A0
1052 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[26][0] 2 700013A2
1053 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[26][1] 2 700013A4
1054 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[26][2] 2 700013A6
1055 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[26][3] 2 700013A8
1056 {0x0F12, 0x01D0}, //senHal_pContSenModesRegsArray[27][0] 2 700013AA
1057 {0x0F12, 0x01D0}, //senHal_pContSenModesRegsArray[27][1] 2 700013AC
1058 {0x0F12, 0x00EF}, //senHal_pContSenModesRegsArray[27][2] 2 700013AE
1059 {0x0F12, 0x00EF}, //senHal_pContSenModesRegsArray[27][3] 2 700013B0
1060 {0x0F12, 0x020C}, //senHal_pContSenModesRegsArray[28][0] 2 700013B2
1061 {0x0F12, 0x024B}, //senHal_pContSenModesRegsArray[28][1] 2 700013B4
1062 {0x0F12, 0x012B}, //senHal_pContSenModesRegsArray[28][2] 2 700013B6
1063 {0x0F12, 0x016A}, //senHal_pContSenModesRegsArray[28][3] 2 700013B8
1064 {0x0F12, 0x039F}, //senHal_pContSenModesRegsArray[29][0] 2 700013BA
1065 {0x0F12, 0x045E}, //senHal_pContSenModesRegsArray[29][1] 2 700013BC
1066 {0x0F12, 0x01DD}, //senHal_pContSenModesRegsArray[29][2] 2 700013BE
1067 {0x0F12, 0x029C}, //senHal_pContSenModesRegsArray[29][3] 2 700013C0
1068 {0x0F12, 0x041A}, //senHal_pContSenModesRegsArray[30][0] 2 700013C2
1069 {0x0F12, 0x04A6}, //senHal_pContSenModesRegsArray[30][1] 2 700013C4
1070 {0x0F12, 0x0258}, //senHal_pContSenModesRegsArray[30][2] 2 700013C6
1071 {0x0F12, 0x02E4}, //senHal_pContSenModesRegsArray[30][3] 2 700013C8
1072 {0x0F12, 0x062D}, //senHal_pContSenModesRegsArray[31][0] 2 700013CA
1073 {0x0F12, 0x0639}, //senHal_pContSenModesRegsArray[31][1] 2 700013CC
1074 {0x0F12, 0x038A}, //senHal_pContSenModesRegsArray[31][2] 2 700013CE
1075 {0x0F12, 0x0396}, //senHal_pContSenModesRegsArray[31][3] 2 700013D0
1076 {0x0F12, 0x0669}, //senHal_pContSenModesRegsArray[32][0] 2 700013D2
1077 {0x0F12, 0x06B4}, //senHal_pContSenModesRegsArray[32][1] 2 700013D4
1078 {0x0F12, 0x03C6}, //senHal_pContSenModesRegsArray[32][2] 2 700013D6
1079 {0x0F12, 0x0411}, //senHal_pContSenModesRegsArray[32][3] 2 700013D8
1080 {0x0F12, 0x087C}, //senHal_pContSenModesRegsArray[33][0] 2 700013DA
1081 {0x0F12, 0x08C7}, //senHal_pContSenModesRegsArray[33][1] 2 700013DC
1082 {0x0F12, 0x04F8}, //senHal_pContSenModesRegsArray[33][2] 2 700013DE
1083 {0x0F12, 0x0543}, //senHal_pContSenModesRegsArray[33][3] 2 700013E0
1084 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[34][0] 2 700013E2
1085 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[34][1] 2 700013E4
1086 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[34][2] 2 700013E6
1087 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[34][3] 2 700013E8
1088 {0x0F12, 0x01D0}, //senHal_pContSenModesRegsArray[35][0] 2 700013EA
1089 {0x0F12, 0x01D0}, //senHal_pContSenModesRegsArray[35][1] 2 700013EC
1090 {0x0F12, 0x00EF}, //senHal_pContSenModesRegsArray[35][2] 2 700013EE
1091 {0x0F12, 0x00EF}, //senHal_pContSenModesRegsArray[35][3] 2 700013F0
1092 {0x0F12, 0x020F}, //senHal_pContSenModesRegsArray[36][0] 2 700013F2
1093 {0x0F12, 0x024E}, //senHal_pContSenModesRegsArray[36][1] 2 700013F4
1094 {0x0F12, 0x012E}, //senHal_pContSenModesRegsArray[36][2] 2 700013F6
1095 {0x0F12, 0x016D}, //senHal_pContSenModesRegsArray[36][3] 2 700013F8
1096 {0x0F12, 0x039F}, //senHal_pContSenModesRegsArray[37][0] 2 700013FA
1097 {0x0F12, 0x045E}, //senHal_pContSenModesRegsArray[37][1] 2 700013FC
1098 {0x0F12, 0x01DD}, //senHal_pContSenModesRegsArray[37][2] 2 700013FE
1099 {0x0F12, 0x029C}, //senHal_pContSenModesRegsArray[37][3] 2 70001400
1100 {0x0F12, 0x041D}, //senHal_pContSenModesRegsArray[38][0] 2 70001402
1101 {0x0F12, 0x04A9}, //senHal_pContSenModesRegsArray[38][1] 2 70001404
1102 {0x0F12, 0x025B}, //senHal_pContSenModesRegsArray[38][2] 2 70001406
1103 {0x0F12, 0x02E7}, //senHal_pContSenModesRegsArray[38][3] 2 70001408
1104 {0x0F12, 0x062D}, //senHal_pContSenModesRegsArray[39][0] 2 7000140A
1105 {0x0F12, 0x0639}, //senHal_pContSenModesRegsArray[39][1] 2 7000140C
1106 {0x0F12, 0x038A}, //senHal_pContSenModesRegsArray[39][2] 2 7000140E
1107 {0x0F12, 0x0396}, //senHal_pContSenModesRegsArray[39][3] 2 70001410
1108 {0x0F12, 0x066C}, //senHal_pContSenModesRegsArray[40][0] 2 70001412
1109 {0x0F12, 0x06B7}, //senHal_pContSenModesRegsArray[40][1] 2 70001414
1110 {0x0F12, 0x03C9}, //senHal_pContSenModesRegsArray[40][2] 2 70001416
1111 {0x0F12, 0x0414}, //senHal_pContSenModesRegsArray[40][3] 2 70001418
1112 {0x0F12, 0x087C}, //senHal_pContSenModesRegsArray[41][0] 2 7000141A
1113 {0x0F12, 0x08C7}, //senHal_pContSenModesRegsArray[41][1] 2 7000141C
1114 {0x0F12, 0x04F8}, //senHal_pContSenModesRegsArray[41][2] 2 7000141E
1115 {0x0F12, 0x0543}, //senHal_pContSenModesRegsArray[41][3] 2 70001420
1116 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[42][0] 2 70001422
1117 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[42][1] 2 70001424
1118 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[42][2] 2 70001426
1119 {0x0F12, 0x0040}, //senHal_pContSenModesRegsArray[42][3] 2 70001428
1120 {0x0F12, 0x01D0}, //senHal_pContSenModesRegsArray[43][0] 2 7000142A
1121 {0x0F12, 0x01D0}, //senHal_pContSenModesRegsArray[43][1] 2 7000142C
1122 {0x0F12, 0x00EF}, //senHal_pContSenModesRegsArray[43][2] 2 7000142E
1123 {0x0F12, 0x00EF}, //senHal_pContSenModesRegsArray[43][3] 2 70001430
1124 {0x0F12, 0x020F}, //senHal_pContSenModesRegsArray[44][0] 2 70001432
1125 {0x0F12, 0x024E}, //senHal_pContSenModesRegsArray[44][1] 2 70001434
1126 {0x0F12, 0x012E}, //senHal_pContSenModesRegsArray[44][2] 2 70001436
1127 {0x0F12, 0x016D}, //senHal_pContSenModesRegsArray[44][3] 2 70001438
1128 {0x0F12, 0x039F}, //senHal_pContSenModesRegsArray[45][0] 2 7000143A
1129 {0x0F12, 0x045E}, //senHal_pContSenModesRegsArray[45][1] 2 7000143C
1130 {0x0F12, 0x01DD}, //senHal_pContSenModesRegsArray[45][2] 2 7000143E
1131 {0x0F12, 0x029C}, //senHal_pContSenModesRegsArray[45][3] 2 70001440
1132 {0x0F12, 0x041D}, //senHal_pContSenModesRegsArray[46][0] 2 70001442
1133 {0x0F12, 0x04A9}, //senHal_pContSenModesRegsArray[46][1] 2 70001444
1134 {0x0F12, 0x025B}, //senHal_pContSenModesRegsArray[46][2] 2 70001446
1135 {0x0F12, 0x02E7}, //senHal_pContSenModesRegsArray[46][3] 2 70001448
1136 {0x0F12, 0x062D}, //senHal_pContSenModesRegsArray[47][0] 2 7000144A
1137 {0x0F12, 0x0639}, //senHal_pContSenModesRegsArray[47][1] 2 7000144C
1138 {0x0F12, 0x038A}, //senHal_pContSenModesRegsArray[47][2] 2 7000144E
1139 {0x0F12, 0x0396}, //senHal_pContSenModesRegsArray[47][3] 2 70001450
1140 {0x0F12, 0x066C}, //senHal_pContSenModesRegsArray[48][0] 2 70001452
1141 {0x0F12, 0x06B7}, //senHal_pContSenModesRegsArray[48][1] 2 70001454
1142 {0x0F12, 0x03C9}, //senHal_pContSenModesRegsArray[48][2] 2 70001456
1143 {0x0F12, 0x0414}, //senHal_pContSenModesRegsArray[48][3] 2 70001458
1144 {0x0F12, 0x087C}, //senHal_pContSenModesRegsArray[49][0] 2 7000145A
1145 {0x0F12, 0x08C7}, //senHal_pContSenModesRegsArray[49][1] 2 7000145C
1146 {0x0F12, 0x04F8}, //senHal_pContSenModesRegsArray[49][2] 2 7000145E
1147 {0x0F12, 0x0543}, //senHal_pContSenModesRegsArray[49][3] 2 70001460
1148 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[50][0] 2 70001462
1149 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[50][1] 2 70001464
1150 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[50][2] 2 70001466
1151 {0x0F12, 0x003D}, //senHal_pContSenModesRegsArray[50][3] 2 70001468
1152 {0x0F12, 0x01D2}, //senHal_pContSenModesRegsArray[51][0] 2 7000146A
1153 {0x0F12, 0x01D2}, //senHal_pContSenModesRegsArray[51][1] 2 7000146C
1154 {0x0F12, 0x00F1}, //senHal_pContSenModesRegsArray[51][2] 2 7000146E
1155 {0x0F12, 0x00F1}, //senHal_pContSenModesRegsArray[51][3] 2 70001470
1156 {0x0F12, 0x020C}, //senHal_pContSenModesRegsArray[52][0] 2 70001472
1157 {0x0F12, 0x024B}, //senHal_pContSenModesRegsArray[52][1] 2 70001474
1158 {0x0F12, 0x012B}, //senHal_pContSenModesRegsArray[52][2] 2 70001476
1159 {0x0F12, 0x016A}, //senHal_pContSenModesRegsArray[52][3] 2 70001478
1160 {0x0F12, 0x03A1}, //senHal_pContSenModesRegsArray[53][0] 2 7000147A
1161 {0x0F12, 0x0460}, //senHal_pContSenModesRegsArray[53][1] 2 7000147C
1162 {0x0F12, 0x01DF}, //senHal_pContSenModesRegsArray[53][2] 2 7000147E
1163 {0x0F12, 0x029E}, //senHal_pContSenModesRegsArray[53][3] 2 70001480
1164 {0x0F12, 0x041A}, //senHal_pContSenModesRegsArray[54][0] 2 70001482
1165 {0x0F12, 0x04A6}, //senHal_pContSenModesRegsArray[54][1] 2 70001484
1166 {0x0F12, 0x0258}, //senHal_pContSenModesRegsArray[54][2] 2 70001486
1167 {0x0F12, 0x02E4}, //senHal_pContSenModesRegsArray[54][3] 2 70001488
1168 {0x0F12, 0x062F}, //senHal_pContSenModesRegsArray[55][0] 2 7000148A
1169 {0x0F12, 0x063B}, //senHal_pContSenModesRegsArray[55][1] 2 7000148C
1170 {0x0F12, 0x038C}, //senHal_pContSenModesRegsArray[55][2] 2 7000148E
1171 {0x0F12, 0x0398}, //senHal_pContSenModesRegsArray[55][3] 2 70001490
1172 {0x0F12, 0x0669}, //senHal_pContSenModesRegsArray[56][0] 2 70001492
1173 {0x0F12, 0x06B4}, //senHal_pContSenModesRegsArray[56][1] 2 70001494
1174 {0x0F12, 0x03C6}, //senHal_pContSenModesRegsArray[56][2] 2 70001496
1175 {0x0F12, 0x0411}, //senHal_pContSenModesRegsArray[56][3] 2 70001498
1176 {0x0F12, 0x087E}, //senHal_pContSenModesRegsArray[57][0] 2 7000149A
1177 {0x0F12, 0x08C9}, //senHal_pContSenModesRegsArray[57][1] 2 7000149C
1178 {0x0F12, 0x04FA}, //senHal_pContSenModesRegsArray[57][2] 2 7000149E
1179 {0x0F12, 0x0545}, //senHal_pContSenModesRegsArray[57][3] 2 700014A0
1180 {0x0F12, 0x03A2}, //senHal_pContSenModesRegsArray[58][0] 2 700014A2
1181 {0x0F12, 0x01D3}, //senHal_pContSenModesRegsArray[58][1] 2 700014A4
1182 {0x0F12, 0x01E0}, //senHal_pContSenModesRegsArray[58][2] 2 700014A6
1183 {0x0F12, 0x00F2}, //senHal_pContSenModesRegsArray[58][3] 2 700014A8
1184 {0x0F12, 0x03AF}, //senHal_pContSenModesRegsArray[59][0] 2 700014AA
1185 {0x0F12, 0x01E0}, //senHal_pContSenModesRegsArray[59][1] 2 700014AC
1186 {0x0F12, 0x01ED}, //senHal_pContSenModesRegsArray[59][2] 2 700014AE
1187 {0x0F12, 0x00FF}, //senHal_pContSenModesRegsArray[59][3] 2 700014B0
1188 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[60][0] 2 700014B2
1189 {0x0F12, 0x0461}, //senHal_pContSenModesRegsArray[60][1] 2 700014B4
1190 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[60][2] 2 700014B6
1191 {0x0F12, 0x029F}, //senHal_pContSenModesRegsArray[60][3] 2 700014B8
1192 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[61][0] 2 700014BA
1193 {0x0F12, 0x046E}, //senHal_pContSenModesRegsArray[61][1] 2 700014BC
1194 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[61][2] 2 700014BE
1195 {0x0F12, 0x02AC}, //senHal_pContSenModesRegsArray[61][3] 2 700014C0
1196 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[62][0] 2 700014C2
1197 {0x0F12, 0x063C}, //senHal_pContSenModesRegsArray[62][1] 2 700014C4
1198 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[62][2] 2 700014C6
1199 {0x0F12, 0x0399}, //senHal_pContSenModesRegsArray[62][3] 2 700014C8
1200 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[63][0] 2 700014CA
1201 {0x0F12, 0x0649}, //senHal_pContSenModesRegsArray[63][1] 2 700014CC
1202 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[63][2] 2 700014CE
1203 {0x0F12, 0x03A6}, //senHal_pContSenModesRegsArray[63][3] 2 700014D0
1204 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[64][0] 2 700014D2
1205 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[64][1] 2 700014D4
1206 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[64][2] 2 700014D6
1207 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[64][3] 2 700014D8
1208 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[65][0] 2 700014DA
1209 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[65][1] 2 700014DC
1210 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[65][2] 2 700014DE
1211 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[65][3] 2 700014E0
1212 {0x0F12, 0x03AA}, //senHal_pContSenModesRegsArray[66][0] 2 700014E2
1213 {0x0F12, 0x01DB}, //senHal_pContSenModesRegsArray[66][1] 2 700014E4
1214 {0x0F12, 0x01E8}, //senHal_pContSenModesRegsArray[66][2] 2 700014E6
1215 {0x0F12, 0x00FA}, //senHal_pContSenModesRegsArray[66][3] 2 700014E8
1216 {0x0F12, 0x03B7}, //senHal_pContSenModesRegsArray[67][0] 2 700014EA
1217 {0x0F12, 0x01E8}, //senHal_pContSenModesRegsArray[67][1] 2 700014EC
1218 {0x0F12, 0x01F5}, //senHal_pContSenModesRegsArray[67][2] 2 700014EE
1219 {0x0F12, 0x0107}, //senHal_pContSenModesRegsArray[67][3] 2 700014F0
1220 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[68][0] 2 700014F2
1221 {0x0F12, 0x0469}, //senHal_pContSenModesRegsArray[68][1] 2 700014F4
1222 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[68][2] 2 700014F6
1223 {0x0F12, 0x02A7}, //senHal_pContSenModesRegsArray[68][3] 2 700014F8
1224 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[69][0] 2 700014FA
1225 {0x0F12, 0x0476}, //senHal_pContSenModesRegsArray[69][1] 2 700014FC
1226 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[69][2] 2 700014FE
1227 {0x0F12, 0x02B4}, //senHal_pContSenModesRegsArray[69][3] 2 70001500
1228 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[70][0] 2 70001502
1229 {0x0F12, 0x0644}, //senHal_pContSenModesRegsArray[70][1] 2 70001504
1230 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[70][2] 2 70001506
1231 {0x0F12, 0x03A1}, //senHal_pContSenModesRegsArray[70][3] 2 70001508
1232 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[71][0] 2 7000150A
1233 {0x0F12, 0x0651}, //senHal_pContSenModesRegsArray[71][1] 2 7000150C
1234 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[71][2] 2 7000150E
1235 {0x0F12, 0x03AE}, //senHal_pContSenModesRegsArray[71][3] 2 70001510
1236 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[72][0] 2 70001512
1237 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[72][1] 2 70001514
1238 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[72][2] 2 70001516
1239 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[72][3] 2 70001518
1240 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[73][0] 2 7000151A
1241 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[73][1] 2 7000151C
1242 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[73][2] 2 7000151E
1243 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[73][3] 2 70001520
1244 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[74][0] 2 70001522
1245 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[74][1] 2 70001524
1246 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[74][2] 2 70001526
1247 {0x0F12, 0x0001}, //senHal_pContSenModesRegsArray[74][3] 2 70001528
1248 {0x0F12, 0x000F}, //senHal_pContSenModesRegsArray[75][0] 2 7000152A
1249 {0x0F12, 0x000F}, //senHal_pContSenModesRegsArray[75][1] 2 7000152C
1250 {0x0F12, 0x000F}, //senHal_pContSenModesRegsArray[75][2] 2 7000152E
1251 {0x0F12, 0x000F}, //senHal_pContSenModesRegsArray[75][3] 2 70001530
1252 {0x0F12, 0x05AD}, //senHal_pContSenModesRegsArray[76][0] 2 70001532
1253 {0x0F12, 0x03DE}, //senHal_pContSenModesRegsArray[76][1] 2 70001534
1254 {0x0F12, 0x030A}, //senHal_pContSenModesRegsArray[76][2] 2 70001536
1255 {0x0F12, 0x021C}, //senHal_pContSenModesRegsArray[76][3] 2 70001538
1256 {0x0F12, 0x062F}, //senHal_pContSenModesRegsArray[77][0] 2 7000153A
1257 {0x0F12, 0x0460}, //senHal_pContSenModesRegsArray[77][1] 2 7000153C
1258 {0x0F12, 0x038C}, //senHal_pContSenModesRegsArray[77][2] 2 7000153E
1259 {0x0F12, 0x029E}, //senHal_pContSenModesRegsArray[77][3] 2 70001540
1260 {0x0F12, 0x07FC}, //senHal_pContSenModesRegsArray[78][0] 2 70001542
1261 {0x0F12, 0x0847}, //senHal_pContSenModesRegsArray[78][1] 2 70001544
1262 {0x0F12, 0x0478}, //senHal_pContSenModesRegsArray[78][2] 2 70001546
1263 {0x0F12, 0x04C3}, //senHal_pContSenModesRegsArray[78][3] 2 70001548
1264 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[79][0] 2 7000154A
1265 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[79][1] 2 7000154C
1266 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[79][2] 2 7000154E
1267 {0x0F12, 0x0000}, //senHal_pContSenModesRegsArray[79][3] 2 70001550
1270 //============================================================
1271 // AF Interface setting
1272 //============================================================
1273 {0x0028, 0x7000},//DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
1275 {0x0F12, 0x0000}, //REG_TC_IPRM_AuxGpios : 0 - no Flash
1277 {0x0F12, 0x0003}, //REG_TC_IPRM_CM_Init_AfModeType : 3 - AFD_VCM_I2C
1278 {0x0F12, 0x0000}, //REG_TC_IPRM_CM_Init_PwmConfig1 : 0 - no PWM
1280 {0x0F12, 0x0041}, //REG_TC_IPRM_CM_Init_GpioConfig1 : 4 - GPIO4
1282 {0x0F12, 0x2A0C}, //REG_TC_IPRM_CM_Init_Mi2cBits : MSCL - GPIO1 MSDA - GPIO2 Device ID {0C}
1283 {0x0F12, 0x0190}, //REG_TC_IPRM_CM_Init_Mi2cRateKhz : MI2C Speed - 400KHz
1284 //BEGIN: DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
1285 {0x002A, 0x1196}, //afd_usFlags 0100=low,0000=high
1287 //END: DTS2012071201781: add by huyouhua 00136760 at 2012-7-20
1288 //============================================================
1289 // AF Parameter setting
1290 //============================================================
1291 // AF Window Settings
1293 {0x0F12, 0x0100}, //#REG_TC_AF_FstWinStartX
1294 {0x0F12, 0x00E3}, //#REG_TC_AF_FstWinStartY //DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
1295 {0x0F12, 0x0200}, //#REG_TC_AF_FstWinSizeX
1296 {0x0F12, 0x0238}, //#REG_TC_AF_FstWinSizeY
1297 {0x0F12, 0x018C}, //#REG_TC_AF_ScndWinStartX
1298 {0x0F12, 0x0166}, //#REG_TC_AF_ScndWinStartY //DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
1299 {0x0F12, 0x00E6}, //#REG_TC_AF_ScndWinSizeX
1300 {0x0F12, 0x0132}, //#REG_TC_AF_ScndWinSizeY
1301 {0x0F12, 0x0001}, //#REG_TC_AF_WinSizesUpdated
1303 // AF Setot Settings
1305 {0x0F12, 0x00FF}, //#skl_af_StatOvlpExpFactor
1307 // AF Scene Settings
1309 {0x0F12, 0x0003}, //#af_scene_usSaturatedScene
1311 // AF Fine Search Settings
1313 {0x0F12, 0x1000}, //FineSearch Disable //#af_search_usSingleAfFlags
1315 {0x0F12, 0x0004}, //#af_search_usFinePeakCount
1317 {0x0F12, 0x0202}, //#af_pos_usFineStepNumSize
1319 // AF Peak Threshold Setting
1320 {0x002A, 0x10CA}, //#af_search_usPeakThr
1323 // AF Default Position
1325 {0x0F12, 0x003C}, //#af_pos_usHomePos //DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
1326 {0x0F12, 0x783C}, //#af_pos_usLowConfPos //DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
1328 // AF LowConfThr Setting
1329 {0x002A, 0x10F4}, //LowEdgeBoth GRAD
1331 {0x002A, 0x1100}, //LowLight HPF
1336 {0x0F12, 0x0030},//af_stat_usMinStatVal
1339 {0x002A, 0x1154}, // normBrThr
1344 {0x0F12, 0x0000}, //#af_search_usCapturePolicy: Focus_Priority, 0002 : Shutter_Priority_Fixed, 0001 : Shutter_Priority_Last_BFP 0000: Shutter_Priority_Current
1346 {0x0F12, 0x003C}, //#af_pos_usCaptureFixedPo// 0x0008
1348 // AF Lens Position Table Settings
1350 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
1351 {0x0F12, 0x0010}, //#af_pos_usTableLastInd// 16 Steps 091222
1352 {0x0F12, 0x003C}, //#af_pos_usTable_0_// af_pos_usTable
1353 {0x0F12, 0x003F}, //#af_pos_usTable_1_
1354 {0x0F12, 0x0042}, //#af_pos_usTable_2_
1355 {0x0F12, 0x0045}, //#af_pos_usTable_3_
1356 {0x0F12, 0x0048}, //#af_pos_usTable_4_
1357 {0x0F12, 0x004B}, //#af_pos_usTable_5_
1358 {0x0F12, 0x004E}, //#af_pos_usTable_6_
1359 {0x0F12, 0x0051}, //#af_pos_usTable_7_
1360 {0x0F12, 0x0054}, //#af_pos_usTable_8_
1361 {0x0F12, 0x0057}, //#af_pos_usTable_9_
1362 {0x0F12, 0x005A}, //#af_pos_usTable_10_
1363 {0x0F12, 0x005E}, //#af_pos_usTable_11_
1364 {0x0F12, 0x0061}, //#af_pos_usTable_12_
1365 {0x0F12, 0x0064}, //#af_pos_usTable_13_
1366 {0x0F12, 0x0068}, //#af_pos_usTable_14_
1367 {0x0F12, 0x006C}, //#af_pos_usTable_15_
1368 {0x0F12, 0x0078}, //#af_pos_usTable_16_
1369 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
1371 {0x0F12, 0x0003}, //init
1372 //BEGIN: DTS2012071201781: del by huyouhua 00136760 at 2012-7-20
1373 //{0x002A, 0x12B8}, //disable CINTR 0
1375 //END: DTS2012071201781: del by huyouhua 00136760 at 2012-7-20
1376 //============================================================
1378 //============================================================
1392 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
1394 {0x0F12, 0x5DC0}, //#lt_uMaxExp1 60ms
1396 {0x0F12, 0x6D60}, //#lt_uMaxExp2 70ms
1399 {0x0F12, 0x9C40}, //#evt1_lt_uMaxExp3 100ms
1401 {0x0F12, 0x3880},//BB80 //#evt1_lt_uMaxExp4 120ms
1402 {0x0F12, 0x0001},//0000
1403 // Set capture exposure time
1405 {0x0F12, 0x5DC0}, //#lt_uCapMaxExp160ms
1407 {0x0F12, 0x6D60}, //#lt_uCapMaxExp270ms
1410 {0x0F12, 0x9C40}, //#evt1_lt_uCapMaxExp3 100ms
1412 {0x0F12, 0xBB80}, //#evt1_lt_uCapMaxExp4 120ms
1416 {0x0F12, 0x0150}, //#lt_uMaxAnGain1
1417 {0x0F12, 0x0280}, //#lt_uMaxAnGain2
1419 {0x0F12, 0x02A0}, //#evt1_lt_uMaxAnGain3
1420 {0x0F12, 0x0800}, //#evt1_lt_uMaxAnGain4
1423 {0x0F12, 0x0100}, //#lt_uMaxDigGain
1424 {0x0F12, 0x0A00}, //#lt_uMaxTotGain
1427 {0x0F12, 0001}, //#evt1_senHal_bExpandForbid //expand forbidde zone
1430 //0F12 0111 //#lt_uLimitHigh
1431 //0F12 00F0 //#lt_uLimitLow
1433 //============================================================
1435 //============================================================
1436 //Calibrations go here
1437 //============================================================
1439 //============================================================
1440 // param_start TVAR_ash_GASAlpha
1443 {0x0F12, 0x00FE}, //TVAR_ash_GASAlpha[0]
1444 {0x0F12, 0x00E0}, //TVAR_ash_GASAlpha[1]
1445 {0x0F12, 0x00F0}, //TVAR_ash_GASAlpha[2]
1446 {0x0F12, 0x00FE}, //TVAR_ash_GASAlpha[3]
1447 {0x0F12, 0x00F0}, //TVAR_ash_GASAlpha[4]
1448 {0x0F12, 0x00E0}, //TVAR_ash_GASAlpha[5]
1449 {0x0F12, 0x00C0}, //TVAR_ash_GASAlpha[6]
1450 {0x0F12, 0x00E0}, //TVAR_ash_GASAlpha[7]
1451 {0x0F12, 0x00EF}, //TVAR_ash_GASAlpha[8]
1452 {0x0F12, 0x00FF}, //TVAR_ash_GASAlpha[9]
1453 {0x0F12, 0x00F9}, //TVAR_ash_GASAlpha[10]
1454 {0x0F12, 0x00E0}, //TVAR_ash_GASAlpha[11]
1455 {0x0F12, 0x00CE}, //TVAR_ash_GASAlpha[12]
1456 {0x0F12, 0x00FF}, //TVAR_ash_GASAlpha[13]
1457 {0x0F12, 0x0100}, //TVAR_ash_GASAlpha[14]
1458 {0x0F12, 0x00E0}, //TVAR_ash_GASAlpha[15]
1459 {0x0F12, 0x00DF}, //TVAR_ash_GASAlpha[16]
1460 {0x0F12, 0x00F4}, //TVAR_ash_GASAlpha[17]
1461 {0x0F12, 0x00F3}, //TVAR_ash_GASAlpha[18]
1462 {0x0F12, 0x00F5}, //TVAR_ash_GASAlpha[19]
1463 {0x0F12, 0x00E0}, //TVAR_ash_GASAlpha[20]
1464 {0x0F12, 0x00E9}, //TVAR_ash_GASAlpha[21]
1465 {0x0F12, 0x00E6}, //TVAR_ash_GASAlpha[22]
1466 {0x0F12, 0x00F6}, //TVAR_ash_GASAlpha[23]
1467 {0x0F12, 0x00CE}, //TVAR_ash_GASAlpha[24]
1468 {0x0F12, 0x00E9}, //TVAR_ash_GASAlpha[25]
1469 {0x0F12, 0x00E6}, //TVAR_ash_GASAlpha[26]
1470 {0x0F12, 0x00F6}, //TVAR_ash_GASAlpha[27]
1471 // param_end TVAR_ash_GASAlpha
1472 // param_start TVAR_ash_GASOutdoorAlpha
1474 {0x0F12, 0x00E4}, //TVAR_ash_GASOutdoorAlpha[0]
1475 {0x0F12, 0x00E9}, //TVAR_ash_GASOutdoorAlpha[1]
1476 {0x0F12, 0x00E6}, //TVAR_ash_GASOutdoorAlpha[2]
1477 {0x0F12, 0x00F6}, //TVAR_ash_GASOutdoorAlpha[3]
1478 // param_end TVAR_ash_GASOutdoorAlpha
1479 // param_start ash_GASBeta
1481 {0x0F12, 0x0060}, //ash_GASBeta[0]
1482 {0x0F12, 0x002B}, //ash_GASBeta[1]
1483 {0x0F12, 0x002F}, //ash_GASBeta[2]
1484 {0x0F12, 0x0000}, //ash_GASBeta[3]
1485 {0x0F12, 0x0052}, //ash_GASBeta[4]
1486 {0x0F12, 0x0026}, //ash_GASBeta[5]
1487 {0x0F12, 0x0029}, //ash_GASBeta[6]
1488 {0x0F12, 0x0000}, //ash_GASBeta[7]
1489 {0x0F12, 0x0010}, //ash_GASBeta[8]
1490 {0x0F12, 0x0026}, //ash_GASBeta[9]
1491 {0x0F12, 0x0028}, //ash_GASBeta[10]
1492 {0x0F12, 0x0000}, //ash_GASBeta[11]
1493 {0x0F12, 0x0010}, //ash_GASBeta[12]
1494 {0x0F12, 0x0026}, //ash_GASBeta[13]
1495 {0x0F12, 0x0027}, //ash_GASBeta[14]
1496 {0x0F12, 0x0000}, //ash_GASBeta[15]
1497 {0x0F12, 0x0023}, //ash_GASBeta[16]
1498 {0x0F12, 0x001F}, //ash_GASBeta[17]
1499 {0x0F12, 0x001F}, //ash_GASBeta[18]
1500 {0x0F12, 0x0000}, //ash_GASBeta[19]
1501 {0x0F12, 0x0025}, //ash_GASBeta[20]
1502 {0x0F12, 0x0017}, //ash_GASBeta[21]
1503 {0x0F12, 0x0016}, //ash_GASBeta[22]
1504 {0x0F12, 0x0000}, //ash_GASBeta[23]
1505 {0x0F12, 0x0025}, //ash_GASBeta[24]
1506 {0x0F12, 0x0017}, //ash_GASBeta[25]
1507 {0x0F12, 0x0016}, //ash_GASBeta[26]
1508 {0x0F12, 0x0000}, //ash_GASBeta[27]
1509 // param_end ash_GASBeta
1510 // param_start ash_GASOutdoorBeta
1512 {0x0F12, 0x0025}, //ash_GASOutdoorBeta[0]
1513 {0x0F12, 0x0017}, //ash_GASOutdoorBeta[1]
1514 {0x0F12, 0x0016}, //ash_GASOutdoorBeta[2]
1515 {0x0F12, 0x0000}, //ash_GASOutdoorBeta[3]
1516 // param_end ash_GASOutdoorBeta
1518 {0x0F12, 0x0000}, //ash_bParabolicEstimation
1519 {0x0F12, 0x0400}, //ash_uParabolicCenterX
1520 {0x0F12, 0x0300}, //ash_uParabolicCenterY
1521 {0x0F12, 0x0010}, //ash_uParabolicScalingA
1522 {0x0F12, 0x0011}, //ash_uParabolicScalingB
1523 // param_start TVAR_ash_pGAS
1525 {0x0F12, 0x025B}, //TVAR_ash_pGAS[0]
1526 {0x0F12, 0x01B4}, //TVAR_ash_pGAS[1]
1527 {0x0F12, 0x0156}, //TVAR_ash_pGAS[2]
1528 {0x0F12, 0x0112}, //TVAR_ash_pGAS[3]
1529 {0x0F12, 0x00EE}, //TVAR_ash_pGAS[4]
1530 {0x0F12, 0x00D8}, //TVAR_ash_pGAS[5]
1531 {0x0F12, 0x00CE}, //TVAR_ash_pGAS[6]
1532 {0x0F12, 0x00D4}, //TVAR_ash_pGAS[7]
1533 {0x0F12, 0x00E6}, //TVAR_ash_pGAS[8]
1534 {0x0F12, 0x010B}, //TVAR_ash_pGAS[9]
1535 {0x0F12, 0x0141}, //TVAR_ash_pGAS[10]
1536 {0x0F12, 0x019F}, //TVAR_ash_pGAS[11]
1537 {0x0F12, 0x027A}, //TVAR_ash_pGAS[12]
1538 {0x0F12, 0x01CD}, //TVAR_ash_pGAS[13]
1539 {0x0F12, 0x0174}, //TVAR_ash_pGAS[14]
1540 {0x0F12, 0x0115}, //TVAR_ash_pGAS[15]
1541 {0x0F12, 0x00D8}, //TVAR_ash_pGAS[16]
1542 {0x0F12, 0x00B2}, //TVAR_ash_pGAS[17]
1543 {0x0F12, 0x009C}, //TVAR_ash_pGAS[18]
1544 {0x0F12, 0x0092}, //TVAR_ash_pGAS[19]
1545 {0x0F12, 0x009A}, //TVAR_ash_pGAS[20]
1546 {0x0F12, 0x00B0}, //TVAR_ash_pGAS[21]
1547 {0x0F12, 0x00D9}, //TVAR_ash_pGAS[22]
1548 {0x0F12, 0x0111}, //TVAR_ash_pGAS[23]
1549 {0x0F12, 0x015F}, //TVAR_ash_pGAS[24]
1550 {0x0F12, 0x01DD}, //TVAR_ash_pGAS[25]
1551 {0x0F12, 0x0176}, //TVAR_ash_pGAS[26]
1552 {0x0F12, 0x0128}, //TVAR_ash_pGAS[27]
1553 {0x0F12, 0x00D1}, //TVAR_ash_pGAS[28]
1554 {0x0F12, 0x0097}, //TVAR_ash_pGAS[29]
1555 {0x0F12, 0x006F}, //TVAR_ash_pGAS[30]
1556 {0x0F12, 0x0056}, //TVAR_ash_pGAS[31]
1557 {0x0F12, 0x004D}, //TVAR_ash_pGAS[32]
1558 {0x0F12, 0x0057}, //TVAR_ash_pGAS[33]
1559 {0x0F12, 0x0073}, //TVAR_ash_pGAS[34]
1560 {0x0F12, 0x009E}, //TVAR_ash_pGAS[35]
1561 {0x0F12, 0x00D9}, //TVAR_ash_pGAS[36]
1562 {0x0F12, 0x0122}, //TVAR_ash_pGAS[37]
1563 {0x0F12, 0x0173}, //TVAR_ash_pGAS[38]
1564 {0x0F12, 0x0144}, //TVAR_ash_pGAS[39]
1565 {0x0F12, 0x00FE}, //TVAR_ash_pGAS[40]
1566 {0x0F12, 0x00A9}, //TVAR_ash_pGAS[41]
1567 {0x0F12, 0x006F}, //TVAR_ash_pGAS[42]
1568 {0x0F12, 0x0043}, //TVAR_ash_pGAS[43]
1569 {0x0F12, 0x0028}, //TVAR_ash_pGAS[44]
1570 {0x0F12, 0x001F}, //TVAR_ash_pGAS[45]
1571 {0x0F12, 0x002A}, //TVAR_ash_pGAS[46]
1572 {0x0F12, 0x0049}, //TVAR_ash_pGAS[47]
1573 {0x0F12, 0x0079}, //TVAR_ash_pGAS[48]
1574 {0x0F12, 0x00B6}, //TVAR_ash_pGAS[49]
1575 {0x0F12, 0x0102}, //TVAR_ash_pGAS[50]
1576 {0x0F12, 0x014F}, //TVAR_ash_pGAS[51]
1577 {0x0F12, 0x012D}, //TVAR_ash_pGAS[52]
1578 {0x0F12, 0x00E7}, //TVAR_ash_pGAS[53]
1579 {0x0F12, 0x0094}, //TVAR_ash_pGAS[54]
1580 {0x0F12, 0x0056}, //TVAR_ash_pGAS[55]
1581 {0x0F12, 0x0028}, //TVAR_ash_pGAS[56]
1582 {0x0F12, 0x000E}, //TVAR_ash_pGAS[57]
1583 {0x0F12, 0x0007}, //TVAR_ash_pGAS[58]
1584 {0x0F12, 0x0011}, //TVAR_ash_pGAS[59]
1585 {0x0F12, 0x0030}, //TVAR_ash_pGAS[60]
1586 {0x0F12, 0x0063}, //TVAR_ash_pGAS[61]
1587 {0x0F12, 0x00A6}, //TVAR_ash_pGAS[62]
1588 {0x0F12, 0x00F2}, //TVAR_ash_pGAS[63]
1589 {0x0F12, 0x013D}, //TVAR_ash_pGAS[64]
1590 {0x0F12, 0x0126}, //TVAR_ash_pGAS[65]
1591 {0x0F12, 0x00E1}, //TVAR_ash_pGAS[66]
1592 {0x0F12, 0x008D}, //TVAR_ash_pGAS[67]
1593 {0x0F12, 0x004E}, //TVAR_ash_pGAS[68]
1594 {0x0F12, 0x0022}, //TVAR_ash_pGAS[69]
1595 {0x0F12, 0x0007}, //TVAR_ash_pGAS[70]
1596 {0x0F12, 0x0000}, //TVAR_ash_pGAS[71]
1597 {0x0F12, 0x000A}, //TVAR_ash_pGAS[72]
1598 {0x0F12, 0x0028}, //TVAR_ash_pGAS[73]
1599 {0x0F12, 0x005E}, //TVAR_ash_pGAS[74]
1600 {0x0F12, 0x00A3}, //TVAR_ash_pGAS[75]
1601 {0x0F12, 0x00F0}, //TVAR_ash_pGAS[76]
1602 {0x0F12, 0x013B}, //TVAR_ash_pGAS[77]
1603 {0x0F12, 0x0133}, //TVAR_ash_pGAS[78]
1604 {0x0F12, 0x00EE}, //TVAR_ash_pGAS[79]
1605 {0x0F12, 0x0099}, //TVAR_ash_pGAS[80]
1606 {0x0F12, 0x005A}, //TVAR_ash_pGAS[81]
1607 {0x0F12, 0x002D}, //TVAR_ash_pGAS[82]
1608 {0x0F12, 0x0013}, //TVAR_ash_pGAS[83]
1609 {0x0F12, 0x000B}, //TVAR_ash_pGAS[84]
1610 {0x0F12, 0x0016}, //TVAR_ash_pGAS[85]
1611 {0x0F12, 0x0035}, //TVAR_ash_pGAS[86]
1612 {0x0F12, 0x006C}, //TVAR_ash_pGAS[87]
1613 {0x0F12, 0x00B2}, //TVAR_ash_pGAS[88]
1614 {0x0F12, 0x0100}, //TVAR_ash_pGAS[89]
1615 {0x0F12, 0x0148}, //TVAR_ash_pGAS[90]
1616 {0x0F12, 0x0153}, //TVAR_ash_pGAS[91]
1617 {0x0F12, 0x0107}, //TVAR_ash_pGAS[92]
1618 {0x0F12, 0x00B4}, //TVAR_ash_pGAS[93]
1619 {0x0F12, 0x0078}, //TVAR_ash_pGAS[94]
1620 {0x0F12, 0x004B}, //TVAR_ash_pGAS[95]
1621 {0x0F12, 0x0030}, //TVAR_ash_pGAS[96]
1622 {0x0F12, 0x002A}, //TVAR_ash_pGAS[97]
1623 {0x0F12, 0x0036}, //TVAR_ash_pGAS[98]
1624 {0x0F12, 0x0057}, //TVAR_ash_pGAS[99]
1625 {0x0F12, 0x008B}, //TVAR_ash_pGAS[100]
1626 {0x0F12, 0x00D1}, //TVAR_ash_pGAS[101]
1627 {0x0F12, 0x0121}, //TVAR_ash_pGAS[102]
1628 {0x0F12, 0x016A}, //TVAR_ash_pGAS[103]
1629 {0x0F12, 0x0189}, //TVAR_ash_pGAS[104]
1630 {0x0F12, 0x0138}, //TVAR_ash_pGAS[105]
1631 {0x0F12, 0x00DF}, //TVAR_ash_pGAS[106]
1632 {0x0F12, 0x00A8}, //TVAR_ash_pGAS[107]
1633 {0x0F12, 0x007E}, //TVAR_ash_pGAS[108]
1634 {0x0F12, 0x0065}, //TVAR_ash_pGAS[109]
1635 {0x0F12, 0x005F}, //TVAR_ash_pGAS[110]
1636 {0x0F12, 0x006A}, //TVAR_ash_pGAS[111]
1637 {0x0F12, 0x008C}, //TVAR_ash_pGAS[112]
1638 {0x0F12, 0x00BF}, //TVAR_ash_pGAS[113]
1639 {0x0F12, 0x00FE}, //TVAR_ash_pGAS[114]
1640 {0x0F12, 0x0150}, //TVAR_ash_pGAS[115]
1641 {0x0F12, 0x019E}, //TVAR_ash_pGAS[116]
1642 {0x0F12, 0x01D5}, //TVAR_ash_pGAS[117]
1643 {0x0F12, 0x0181}, //TVAR_ash_pGAS[118]
1644 {0x0F12, 0x0125}, //TVAR_ash_pGAS[119]
1645 {0x0F12, 0x00EA}, //TVAR_ash_pGAS[120]
1646 {0x0F12, 0x00C7}, //TVAR_ash_pGAS[121]
1647 {0x0F12, 0x00B2}, //TVAR_ash_pGAS[122]
1648 {0x0F12, 0x00AC}, //TVAR_ash_pGAS[123]
1649 {0x0F12, 0x00BA}, //TVAR_ash_pGAS[124]
1650 {0x0F12, 0x00D5}, //TVAR_ash_pGAS[125]
1651 {0x0F12, 0x0100}, //TVAR_ash_pGAS[126]
1652 {0x0F12, 0x0140}, //TVAR_ash_pGAS[127]
1653 {0x0F12, 0x019B}, //TVAR_ash_pGAS[128]
1654 {0x0F12, 0x0217}, //TVAR_ash_pGAS[129]
1655 {0x0F12, 0x0280}, //TVAR_ash_pGAS[130]
1656 {0x0F12, 0x01CC}, //TVAR_ash_pGAS[131]
1657 {0x0F12, 0x0176}, //TVAR_ash_pGAS[132]
1658 {0x0F12, 0x0131}, //TVAR_ash_pGAS[133]
1659 {0x0F12, 0x010E}, //TVAR_ash_pGAS[134]
1660 {0x0F12, 0x00FF}, //TVAR_ash_pGAS[135]
1661 {0x0F12, 0x00FC}, //TVAR_ash_pGAS[136]
1662 {0x0F12, 0x0103}, //TVAR_ash_pGAS[137]
1663 {0x0F12, 0x011B}, //TVAR_ash_pGAS[138]
1664 {0x0F12, 0x0146}, //TVAR_ash_pGAS[139]
1665 {0x0F12, 0x018B}, //TVAR_ash_pGAS[140]
1666 {0x0F12, 0x01F8}, //TVAR_ash_pGAS[141]
1667 {0x0F12, 0x02DD}, //TVAR_ash_pGAS[142]
1668 {0x0F12, 0x0232}, //TVAR_ash_pGAS[143]
1669 {0x0F12, 0x018A}, //TVAR_ash_pGAS[144]
1670 {0x0F12, 0x0127}, //TVAR_ash_pGAS[145]
1671 {0x0F12, 0x00EF}, //TVAR_ash_pGAS[146]
1672 {0x0F12, 0x00CA}, //TVAR_ash_pGAS[147]
1673 {0x0F12, 0x00B4}, //TVAR_ash_pGAS[148]
1674 {0x0F12, 0x00AB}, //TVAR_ash_pGAS[149]
1675 {0x0F12, 0x00B1}, //TVAR_ash_pGAS[150]
1676 {0x0F12, 0x00C3}, //TVAR_ash_pGAS[151]
1677 {0x0F12, 0x00E5}, //TVAR_ash_pGAS[152]
1678 {0x0F12, 0x0118}, //TVAR_ash_pGAS[153]
1679 {0x0F12, 0x0168}, //TVAR_ash_pGAS[154]
1680 {0x0F12, 0x023A}, //TVAR_ash_pGAS[155]
1681 {0x0F12, 0x019A}, //TVAR_ash_pGAS[156]
1682 {0x0F12, 0x013E}, //TVAR_ash_pGAS[157]
1683 {0x0F12, 0x00E5}, //TVAR_ash_pGAS[158]
1684 {0x0F12, 0x00B1}, //TVAR_ash_pGAS[159]
1685 {0x0F12, 0x008E}, //TVAR_ash_pGAS[160]
1686 {0x0F12, 0x0079}, //TVAR_ash_pGAS[161]
1687 {0x0F12, 0x0072}, //TVAR_ash_pGAS[162]
1688 {0x0F12, 0x0078}, //TVAR_ash_pGAS[163]
1689 {0x0F12, 0x008E}, //TVAR_ash_pGAS[164]
1690 {0x0F12, 0x00B2}, //TVAR_ash_pGAS[165]
1691 {0x0F12, 0x00E1}, //TVAR_ash_pGAS[166]
1692 {0x0F12, 0x0121}, //TVAR_ash_pGAS[167]
1693 {0x0F12, 0x019A}, //TVAR_ash_pGAS[168]
1694 {0x0F12, 0x014D}, //TVAR_ash_pGAS[169]
1695 {0x0F12, 0x0100}, //TVAR_ash_pGAS[170]
1696 {0x0F12, 0x00AE}, //TVAR_ash_pGAS[171]
1697 {0x0F12, 0x007F}, //TVAR_ash_pGAS[172]
1698 {0x0F12, 0x005B}, //TVAR_ash_pGAS[173]
1699 {0x0F12, 0x0043}, //TVAR_ash_pGAS[174]
1700 {0x0F12, 0x003B}, //TVAR_ash_pGAS[175]
1701 {0x0F12, 0x0045}, //TVAR_ash_pGAS[176]
1702 {0x0F12, 0x005E}, //TVAR_ash_pGAS[177]
1703 {0x0F12, 0x0083}, //TVAR_ash_pGAS[178]
1704 {0x0F12, 0x00B4}, //TVAR_ash_pGAS[179]
1705 {0x0F12, 0x00EF}, //TVAR_ash_pGAS[180]
1706 {0x0F12, 0x0139}, //TVAR_ash_pGAS[181]
1707 {0x0F12, 0x0120}, //TVAR_ash_pGAS[182]
1708 {0x0F12, 0x00DB}, //TVAR_ash_pGAS[183]
1709 {0x0F12, 0x008D}, //TVAR_ash_pGAS[184]
1710 {0x0F12, 0x005D}, //TVAR_ash_pGAS[185]
1711 {0x0F12, 0x0037}, //TVAR_ash_pGAS[186]
1712 {0x0F12, 0x001F}, //TVAR_ash_pGAS[187]
1713 {0x0F12, 0x0017}, //TVAR_ash_pGAS[188]
1714 {0x0F12, 0x0022}, //TVAR_ash_pGAS[189]
1715 {0x0F12, 0x003D}, //TVAR_ash_pGAS[190]
1716 {0x0F12, 0x0066}, //TVAR_ash_pGAS[191]
1717 {0x0F12, 0x009A}, //TVAR_ash_pGAS[192]
1718 {0x0F12, 0x00D7}, //TVAR_ash_pGAS[193]
1719 {0x0F12, 0x011A}, //TVAR_ash_pGAS[194]
1720 {0x0F12, 0x0108}, //TVAR_ash_pGAS[195]
1721 {0x0F12, 0x00C7}, //TVAR_ash_pGAS[196]
1722 {0x0F12, 0x007B}, //TVAR_ash_pGAS[197]
1723 {0x0F12, 0x004A}, //TVAR_ash_pGAS[198]
1724 {0x0F12, 0x0023}, //TVAR_ash_pGAS[199]
1725 {0x0F12, 0x000B}, //TVAR_ash_pGAS[200]
1726 {0x0F12, 0x0005}, //TVAR_ash_pGAS[201]
1727 {0x0F12, 0x000E}, //TVAR_ash_pGAS[202]
1728 {0x0F12, 0x002A}, //TVAR_ash_pGAS[203]
1729 {0x0F12, 0x0055}, //TVAR_ash_pGAS[204]
1730 {0x0F12, 0x008D}, //TVAR_ash_pGAS[205]
1731 {0x0F12, 0x00C9}, //TVAR_ash_pGAS[206]
1732 {0x0F12, 0x0104}, //TVAR_ash_pGAS[207]
1733 {0x0F12, 0x0100}, //TVAR_ash_pGAS[208]
1734 {0x0F12, 0x00C0}, //TVAR_ash_pGAS[209]
1735 {0x0F12, 0x0076}, //TVAR_ash_pGAS[210]
1736 {0x0F12, 0x0044}, //TVAR_ash_pGAS[211]
1737 {0x0F12, 0x001E}, //TVAR_ash_pGAS[212]
1738 {0x0F12, 0x0006}, //TVAR_ash_pGAS[213]
1739 {0x0F12, 0x0000}, //TVAR_ash_pGAS[214]
1740 {0x0F12, 0x0009}, //TVAR_ash_pGAS[215]
1741 {0x0F12, 0x0024}, //TVAR_ash_pGAS[216]
1742 {0x0F12, 0x0052}, //TVAR_ash_pGAS[217]
1743 {0x0F12, 0x008B}, //TVAR_ash_pGAS[218]
1744 {0x0F12, 0x00C8}, //TVAR_ash_pGAS[219]
1745 {0x0F12, 0x0104}, //TVAR_ash_pGAS[220]
1746 {0x0F12, 0x0109}, //TVAR_ash_pGAS[221]
1747 {0x0F12, 0x00C9}, //TVAR_ash_pGAS[222]
1748 {0x0F12, 0x007F}, //TVAR_ash_pGAS[223]
1749 {0x0F12, 0x004D}, //TVAR_ash_pGAS[224]
1750 {0x0F12, 0x0027}, //TVAR_ash_pGAS[225]
1751 {0x0F12, 0x0010}, //TVAR_ash_pGAS[226]
1752 {0x0F12, 0x000A}, //TVAR_ash_pGAS[227]
1753 {0x0F12, 0x0014}, //TVAR_ash_pGAS[228]
1754 {0x0F12, 0x002F}, //TVAR_ash_pGAS[229]
1755 {0x0F12, 0x005D}, //TVAR_ash_pGAS[230]
1756 {0x0F12, 0x0098}, //TVAR_ash_pGAS[231]
1757 {0x0F12, 0x00D7}, //TVAR_ash_pGAS[232]
1758 {0x0F12, 0x010E}, //TVAR_ash_pGAS[233]
1759 {0x0F12, 0x0125}, //TVAR_ash_pGAS[234]
1760 {0x0F12, 0x00E0}, //TVAR_ash_pGAS[235]
1761 {0x0F12, 0x0094}, //TVAR_ash_pGAS[236]
1762 {0x0F12, 0x0066}, //TVAR_ash_pGAS[237]
1763 {0x0F12, 0x0040}, //TVAR_ash_pGAS[238]
1764 {0x0F12, 0x002A}, //TVAR_ash_pGAS[239]
1765 {0x0F12, 0x0024}, //TVAR_ash_pGAS[240]
1766 {0x0F12, 0x002F}, //TVAR_ash_pGAS[241]
1767 {0x0F12, 0x004C}, //TVAR_ash_pGAS[242]
1768 {0x0F12, 0x0078}, //TVAR_ash_pGAS[243]
1769 {0x0F12, 0x00B3}, //TVAR_ash_pGAS[244]
1770 {0x0F12, 0x00F4}, //TVAR_ash_pGAS[245]
1771 {0x0F12, 0x012F}, //TVAR_ash_pGAS[246]
1772 {0x0F12, 0x0153}, //TVAR_ash_pGAS[247]
1773 {0x0F12, 0x0108}, //TVAR_ash_pGAS[248]
1774 {0x0F12, 0x00B9}, //TVAR_ash_pGAS[249]
1775 {0x0F12, 0x008D}, //TVAR_ash_pGAS[250]
1776 {0x0F12, 0x006B}, //TVAR_ash_pGAS[251]
1777 {0x0F12, 0x0055}, //TVAR_ash_pGAS[252]
1778 {0x0F12, 0x0050}, //TVAR_ash_pGAS[253]
1779 {0x0F12, 0x005D}, //TVAR_ash_pGAS[254]
1780 {0x0F12, 0x007A}, //TVAR_ash_pGAS[255]
1781 {0x0F12, 0x00A4}, //TVAR_ash_pGAS[256]
1782 {0x0F12, 0x00D9}, //TVAR_ash_pGAS[257]
1783 {0x0F12, 0x011D}, //TVAR_ash_pGAS[258]
1784 {0x0F12, 0x015E}, //TVAR_ash_pGAS[259]
1785 {0x0F12, 0x019C}, //TVAR_ash_pGAS[260]
1786 {0x0F12, 0x0144}, //TVAR_ash_pGAS[261]
1787 {0x0F12, 0x00F3}, //TVAR_ash_pGAS[262]
1788 {0x0F12, 0x00C2}, //TVAR_ash_pGAS[263]
1789 {0x0F12, 0x00A4}, //TVAR_ash_pGAS[264]
1790 {0x0F12, 0x0093}, //TVAR_ash_pGAS[265]
1791 {0x0F12, 0x008F}, //TVAR_ash_pGAS[266]
1792 {0x0F12, 0x009C}, //TVAR_ash_pGAS[267]
1793 {0x0F12, 0x00B5}, //TVAR_ash_pGAS[268]
1794 {0x0F12, 0x00DA}, //TVAR_ash_pGAS[269]
1795 {0x0F12, 0x010E}, //TVAR_ash_pGAS[270]
1796 {0x0F12, 0x015E}, //TVAR_ash_pGAS[271]
1797 {0x0F12, 0x01C9}, //TVAR_ash_pGAS[272]
1798 {0x0F12, 0x0239}, //TVAR_ash_pGAS[273]
1799 {0x0F12, 0x0186}, //TVAR_ash_pGAS[274]
1800 {0x0F12, 0x0137}, //TVAR_ash_pGAS[275]
1801 {0x0F12, 0x00FF}, //TVAR_ash_pGAS[276]
1802 {0x0F12, 0x00DE}, //TVAR_ash_pGAS[277]
1803 {0x0F12, 0x00CF}, //TVAR_ash_pGAS[278]
1804 {0x0F12, 0x00CE}, //TVAR_ash_pGAS[279]
1805 {0x0F12, 0x00D5}, //TVAR_ash_pGAS[280]
1806 {0x0F12, 0x00ED}, //TVAR_ash_pGAS[281]
1807 {0x0F12, 0x0113}, //TVAR_ash_pGAS[282]
1808 {0x0F12, 0x014E}, //TVAR_ash_pGAS[283]
1809 {0x0F12, 0x01B0}, //TVAR_ash_pGAS[284]
1810 {0x0F12, 0x0285}, //TVAR_ash_pGAS[285]
1811 {0x0F12, 0x020F}, //TVAR_ash_pGAS[286]
1812 {0x0F12, 0x0173}, //TVAR_ash_pGAS[287]
1813 {0x0F12, 0x0112}, //TVAR_ash_pGAS[288]
1814 {0x0F12, 0x00DE}, //TVAR_ash_pGAS[289]
1815 {0x0F12, 0x00BF}, //TVAR_ash_pGAS[290]
1816 {0x0F12, 0x00AD}, //TVAR_ash_pGAS[291]
1817 {0x0F12, 0x00A8}, //TVAR_ash_pGAS[292]
1818 {0x0F12, 0x00B3}, //TVAR_ash_pGAS[293]
1819 {0x0F12, 0x00CC}, //TVAR_ash_pGAS[294]
1820 {0x0F12, 0x00F2}, //TVAR_ash_pGAS[295]
1821 {0x0F12, 0x0126}, //TVAR_ash_pGAS[296]
1822 {0x0F12, 0x0176}, //TVAR_ash_pGAS[297]
1823 {0x0F12, 0x024B}, //TVAR_ash_pGAS[298]
1824 {0x0F12, 0x0180}, //TVAR_ash_pGAS[299]
1825 {0x0F12, 0x012F}, //TVAR_ash_pGAS[300]
1826 {0x0F12, 0x00D5}, //TVAR_ash_pGAS[301]
1827 {0x0F12, 0x00A7}, //TVAR_ash_pGAS[302]
1828 {0x0F12, 0x0087}, //TVAR_ash_pGAS[303]
1829 {0x0F12, 0x0075}, //TVAR_ash_pGAS[304]
1830 {0x0F12, 0x0072}, //TVAR_ash_pGAS[305]
1831 {0x0F12, 0x007E}, //TVAR_ash_pGAS[306]
1832 {0x0F12, 0x0096}, //TVAR_ash_pGAS[307]
1833 {0x0F12, 0x00BE}, //TVAR_ash_pGAS[308]
1834 {0x0F12, 0x00EF}, //TVAR_ash_pGAS[309]
1835 {0x0F12, 0x012F}, //TVAR_ash_pGAS[310]
1836 {0x0F12, 0x01A7}, //TVAR_ash_pGAS[311]
1837 {0x0F12, 0x013C}, //TVAR_ash_pGAS[312]
1838 {0x0F12, 0x00F5}, //TVAR_ash_pGAS[313]
1839 {0x0F12, 0x00A5}, //TVAR_ash_pGAS[314]
1840 {0x0F12, 0x0078}, //TVAR_ash_pGAS[315]
1841 {0x0F12, 0x0057}, //TVAR_ash_pGAS[316]
1842 {0x0F12, 0x0042}, //TVAR_ash_pGAS[317]
1843 {0x0F12, 0x003D}, //TVAR_ash_pGAS[318]
1844 {0x0F12, 0x0049}, //TVAR_ash_pGAS[319]
1845 {0x0F12, 0x0066}, //TVAR_ash_pGAS[320]
1846 {0x0F12, 0x008F}, //TVAR_ash_pGAS[321]
1847 {0x0F12, 0x00C0}, //TVAR_ash_pGAS[322]
1848 {0x0F12, 0x00FD}, //TVAR_ash_pGAS[323]
1849 {0x0F12, 0x0144}, //TVAR_ash_pGAS[324]
1850 {0x0F12, 0x0115}, //TVAR_ash_pGAS[325]
1851 {0x0F12, 0x00D6}, //TVAR_ash_pGAS[326]
1852 {0x0F12, 0x0089}, //TVAR_ash_pGAS[327]
1853 {0x0F12, 0x005B}, //TVAR_ash_pGAS[328]
1854 {0x0F12, 0x0036}, //TVAR_ash_pGAS[329]
1855 {0x0F12, 0x001F}, //TVAR_ash_pGAS[330]
1856 {0x0F12, 0x0018}, //TVAR_ash_pGAS[331]
1857 {0x0F12, 0x0024}, //TVAR_ash_pGAS[332]
1858 {0x0F12, 0x0043}, //TVAR_ash_pGAS[333]
1859 {0x0F12, 0x006F}, //TVAR_ash_pGAS[334]
1860 {0x0F12, 0x00A5}, //TVAR_ash_pGAS[335]
1861 {0x0F12, 0x00E0}, //TVAR_ash_pGAS[336]
1862 {0x0F12, 0x0122}, //TVAR_ash_pGAS[337]
1863 {0x0F12, 0x0104}, //TVAR_ash_pGAS[338]
1864 {0x0F12, 0x00C7}, //TVAR_ash_pGAS[339]
1865 {0x0F12, 0x007B}, //TVAR_ash_pGAS[340]
1866 {0x0F12, 0x004A}, //TVAR_ash_pGAS[341]
1867 {0x0F12, 0x0023}, //TVAR_ash_pGAS[342]
1868 {0x0F12, 0x000B}, //TVAR_ash_pGAS[343]
1869 {0x0F12, 0x0005}, //TVAR_ash_pGAS[344]
1870 {0x0F12, 0x0010}, //TVAR_ash_pGAS[345]
1871 {0x0F12, 0x002E}, //TVAR_ash_pGAS[346]
1872 {0x0F12, 0x005B}, //TVAR_ash_pGAS[347]
1873 {0x0F12, 0x0094}, //TVAR_ash_pGAS[348]
1874 {0x0F12, 0x00D0}, //TVAR_ash_pGAS[349]
1875 {0x0F12, 0x010C}, //TVAR_ash_pGAS[350]
1876 {0x0F12, 0x0105}, //TVAR_ash_pGAS[351]
1877 {0x0F12, 0x00C5}, //TVAR_ash_pGAS[352]
1878 {0x0F12, 0x007A}, //TVAR_ash_pGAS[353]
1879 {0x0F12, 0x0047}, //TVAR_ash_pGAS[354]
1880 {0x0F12, 0x0021}, //TVAR_ash_pGAS[355]
1881 {0x0F12, 0x0008}, //TVAR_ash_pGAS[356]
1882 {0x0F12, 0x0000}, //TVAR_ash_pGAS[357]
1883 {0x0F12, 0x0009}, //TVAR_ash_pGAS[358]
1884 {0x0F12, 0x0026}, //TVAR_ash_pGAS[359]
1885 {0x0F12, 0x0054}, //TVAR_ash_pGAS[360]
1886 {0x0F12, 0x008E}, //TVAR_ash_pGAS[361]
1887 {0x0F12, 0x00CA}, //TVAR_ash_pGAS[362]
1888 {0x0F12, 0x0106}, //TVAR_ash_pGAS[363]
1889 {0x0F12, 0x0116}, //TVAR_ash_pGAS[364]
1890 {0x0F12, 0x00D3}, //TVAR_ash_pGAS[365]
1891 {0x0F12, 0x0088}, //TVAR_ash_pGAS[366]
1892 {0x0F12, 0x0054}, //TVAR_ash_pGAS[367]
1893 {0x0F12, 0x002C}, //TVAR_ash_pGAS[368]
1894 {0x0F12, 0x0012}, //TVAR_ash_pGAS[369]
1895 {0x0F12, 0x0009}, //TVAR_ash_pGAS[370]
1896 {0x0F12, 0x0013}, //TVAR_ash_pGAS[371]
1897 {0x0F12, 0x002E}, //TVAR_ash_pGAS[372]
1898 {0x0F12, 0x005C}, //TVAR_ash_pGAS[373]
1899 {0x0F12, 0x0095}, //TVAR_ash_pGAS[374]
1900 {0x0F12, 0x00D4}, //TVAR_ash_pGAS[375]
1901 {0x0F12, 0x010D}, //TVAR_ash_pGAS[376]
1902 {0x0F12, 0x013A}, //TVAR_ash_pGAS[377]
1903 {0x0F12, 0x00EE}, //TVAR_ash_pGAS[378]
1904 {0x0F12, 0x00A1}, //TVAR_ash_pGAS[379]
1905 {0x0F12, 0x006F}, //TVAR_ash_pGAS[380]
1906 {0x0F12, 0x0047}, //TVAR_ash_pGAS[381]
1907 {0x0F12, 0x002C}, //TVAR_ash_pGAS[382]
1908 {0x0F12, 0x0023}, //TVAR_ash_pGAS[383]
1909 {0x0F12, 0x002D}, //TVAR_ash_pGAS[384]
1910 {0x0F12, 0x0047}, //TVAR_ash_pGAS[385]
1911 {0x0F12, 0x0072}, //TVAR_ash_pGAS[386]
1912 {0x0F12, 0x00AB}, //TVAR_ash_pGAS[387]
1913 {0x0F12, 0x00EB}, //TVAR_ash_pGAS[388]
1914 {0x0F12, 0x0127}, //TVAR_ash_pGAS[389]
1915 {0x0F12, 0x016C}, //TVAR_ash_pGAS[390]
1916 {0x0F12, 0x011B}, //TVAR_ash_pGAS[391]
1917 {0x0F12, 0x00CA}, //TVAR_ash_pGAS[392]
1918 {0x0F12, 0x0099}, //TVAR_ash_pGAS[393]
1919 {0x0F12, 0x0074}, //TVAR_ash_pGAS[394]
1920 {0x0F12, 0x0059}, //TVAR_ash_pGAS[395]
1921 {0x0F12, 0x0050}, //TVAR_ash_pGAS[396]
1922 {0x0F12, 0x0057}, //TVAR_ash_pGAS[397]
1923 {0x0F12, 0x0072}, //TVAR_ash_pGAS[398]
1924 {0x0F12, 0x0099}, //TVAR_ash_pGAS[399]
1925 {0x0F12, 0x00CB}, //TVAR_ash_pGAS[400]
1926 {0x0F12, 0x0111}, //TVAR_ash_pGAS[401]
1927 {0x0F12, 0x0155}, //TVAR_ash_pGAS[402]
1928 {0x0F12, 0x01BA}, //TVAR_ash_pGAS[403]
1929 {0x0F12, 0x015D}, //TVAR_ash_pGAS[404]
1930 {0x0F12, 0x0107}, //TVAR_ash_pGAS[405]
1931 {0x0F12, 0x00D3}, //TVAR_ash_pGAS[406]
1932 {0x0F12, 0x00AE}, //TVAR_ash_pGAS[407]
1933 {0x0F12, 0x0099}, //TVAR_ash_pGAS[408]
1934 {0x0F12, 0x008F}, //TVAR_ash_pGAS[409]
1935 {0x0F12, 0x0096}, //TVAR_ash_pGAS[410]
1936 {0x0F12, 0x00AB}, //TVAR_ash_pGAS[411]
1937 {0x0F12, 0x00CD}, //TVAR_ash_pGAS[412]
1938 {0x0F12, 0x00FE}, //TVAR_ash_pGAS[413]
1939 {0x0F12, 0x014D}, //TVAR_ash_pGAS[414]
1940 {0x0F12, 0x01BC}, //TVAR_ash_pGAS[415]
1941 {0x0F12, 0x025D}, //TVAR_ash_pGAS[416]
1942 {0x0F12, 0x01A6}, //TVAR_ash_pGAS[417]
1943 {0x0F12, 0x0151}, //TVAR_ash_pGAS[418]
1944 {0x0F12, 0x0115}, //TVAR_ash_pGAS[419]
1945 {0x0F12, 0x00F0}, //TVAR_ash_pGAS[420]
1946 {0x0F12, 0x00DA}, //TVAR_ash_pGAS[421]
1947 {0x0F12, 0x00D0}, //TVAR_ash_pGAS[422]
1948 {0x0F12, 0x00D3}, //TVAR_ash_pGAS[423]
1949 {0x0F12, 0x00E5}, //TVAR_ash_pGAS[424]
1950 {0x0F12, 0x0108}, //TVAR_ash_pGAS[425]
1951 {0x0F12, 0x013F}, //TVAR_ash_pGAS[426]
1952 {0x0F12, 0x019E}, //TVAR_ash_pGAS[427]
1953 {0x0F12, 0x0271}, //TVAR_ash_pGAS[428]
1954 {0x0F12, 0x01B8}, //TVAR_ash_pGAS[429]
1955 {0x0F12, 0x013B}, //TVAR_ash_pGAS[430]
1956 {0x0F12, 0x00E6}, //TVAR_ash_pGAS[431]
1957 {0x0F12, 0x00BB}, //TVAR_ash_pGAS[432]
1958 {0x0F12, 0x00A5}, //TVAR_ash_pGAS[433]
1959 {0x0F12, 0x009A}, //TVAR_ash_pGAS[434]
1960 {0x0F12, 0x0096}, //TVAR_ash_pGAS[435]
1961 {0x0F12, 0x00A0}, //TVAR_ash_pGAS[436]
1962 {0x0F12, 0x00B1}, //TVAR_ash_pGAS[437]
1963 {0x0F12, 0x00D0}, //TVAR_ash_pGAS[438]
1964 {0x0F12, 0x00FE}, //TVAR_ash_pGAS[439]
1965 {0x0F12, 0x0148}, //TVAR_ash_pGAS[440]
1966 {0x0F12, 0x01EF}, //TVAR_ash_pGAS[441]
1967 {0x0F12, 0x0133}, //TVAR_ash_pGAS[442]
1968 {0x0F12, 0x00F9}, //TVAR_ash_pGAS[443]
1969 {0x0F12, 0x00B0}, //TVAR_ash_pGAS[444]
1970 {0x0F12, 0x008A}, //TVAR_ash_pGAS[445]
1971 {0x0F12, 0x0074}, //TVAR_ash_pGAS[446]
1972 {0x0F12, 0x0069}, //TVAR_ash_pGAS[447]
1973 {0x0F12, 0x0068}, //TVAR_ash_pGAS[448]
1974 {0x0F12, 0x0071}, //TVAR_ash_pGAS[449]
1975 {0x0F12, 0x0085}, //TVAR_ash_pGAS[450]
1976 {0x0F12, 0x00A4}, //TVAR_ash_pGAS[451]
1977 {0x0F12, 0x00CC}, //TVAR_ash_pGAS[452]
1978 {0x0F12, 0x0106}, //TVAR_ash_pGAS[453]
1979 {0x0F12, 0x0161}, //TVAR_ash_pGAS[454]
1980 {0x0F12, 0x00F6}, //TVAR_ash_pGAS[455]
1981 {0x0F12, 0x00C0}, //TVAR_ash_pGAS[456]
1982 {0x0F12, 0x0080}, //TVAR_ash_pGAS[457]
1983 {0x0F12, 0x005F}, //TVAR_ash_pGAS[458]
1984 {0x0F12, 0x0048}, //TVAR_ash_pGAS[459]
1985 {0x0F12, 0x003B}, //TVAR_ash_pGAS[460]
1986 {0x0F12, 0x0039}, //TVAR_ash_pGAS[461]
1987 {0x0F12, 0x0043}, //TVAR_ash_pGAS[462]
1988 {0x0F12, 0x0059}, //TVAR_ash_pGAS[463]
1989 {0x0F12, 0x0078}, //TVAR_ash_pGAS[464]
1990 {0x0F12, 0x00A0}, //TVAR_ash_pGAS[465]
1991 {0x0F12, 0x00D5}, //TVAR_ash_pGAS[466]
1992 {0x0F12, 0x0107}, //TVAR_ash_pGAS[467]
1993 {0x0F12, 0x00CE}, //TVAR_ash_pGAS[468]
1994 {0x0F12, 0x00A0}, //TVAR_ash_pGAS[469]
1995 {0x0F12, 0x0063}, //TVAR_ash_pGAS[470]
1996 {0x0F12, 0x0043}, //TVAR_ash_pGAS[471]
1997 {0x0F12, 0x0029}, //TVAR_ash_pGAS[472]
1998 {0x0F12, 0x001B}, //TVAR_ash_pGAS[473]
1999 {0x0F12, 0x0018}, //TVAR_ash_pGAS[474]
2000 {0x0F12, 0x0020}, //TVAR_ash_pGAS[475]
2001 {0x0F12, 0x0037}, //TVAR_ash_pGAS[476]
2002 {0x0F12, 0x0059}, //TVAR_ash_pGAS[477]
2003 {0x0F12, 0x0082}, //TVAR_ash_pGAS[478]
2004 {0x0F12, 0x00B6}, //TVAR_ash_pGAS[479]
2005 {0x0F12, 0x00E5}, //TVAR_ash_pGAS[480]
2006 {0x0F12, 0x00BC}, //TVAR_ash_pGAS[481]
2007 {0x0F12, 0x008F}, //TVAR_ash_pGAS[482]
2008 {0x0F12, 0x0054}, //TVAR_ash_pGAS[483]
2009 {0x0F12, 0x0031}, //TVAR_ash_pGAS[484]
2010 {0x0F12, 0x0017}, //TVAR_ash_pGAS[485]
2011 {0x0F12, 0x0008}, //TVAR_ash_pGAS[486]
2012 {0x0F12, 0x0006}, //TVAR_ash_pGAS[487]
2013 {0x0F12, 0x000D}, //TVAR_ash_pGAS[488]
2014 {0x0F12, 0x0022}, //TVAR_ash_pGAS[489]
2015 {0x0F12, 0x0044}, //TVAR_ash_pGAS[490]
2016 {0x0F12, 0x0070}, //TVAR_ash_pGAS[491]
2017 {0x0F12, 0x00A3}, //TVAR_ash_pGAS[492]
2018 {0x0F12, 0x00CF}, //TVAR_ash_pGAS[493]
2019 {0x0F12, 0x00B7}, //TVAR_ash_pGAS[494]
2020 {0x0F12, 0x008A}, //TVAR_ash_pGAS[495]
2021 {0x0F12, 0x0051}, //TVAR_ash_pGAS[496]
2022 {0x0F12, 0x002D}, //TVAR_ash_pGAS[497]
2023 {0x0F12, 0x0013}, //TVAR_ash_pGAS[498]
2024 {0x0F12, 0x0005}, //TVAR_ash_pGAS[499]
2025 {0x0F12, 0x0000}, //TVAR_ash_pGAS[500]
2026 {0x0F12, 0x0006}, //TVAR_ash_pGAS[501]
2027 {0x0F12, 0x001A}, //TVAR_ash_pGAS[502]
2028 {0x0F12, 0x003B}, //TVAR_ash_pGAS[503]
2029 {0x0F12, 0x0069}, //TVAR_ash_pGAS[504]
2030 {0x0F12, 0x009A}, //TVAR_ash_pGAS[505]
2031 {0x0F12, 0x00C8}, //TVAR_ash_pGAS[506]
2032 {0x0F12, 0x00C3}, //TVAR_ash_pGAS[507]
2033 {0x0F12, 0x0093}, //TVAR_ash_pGAS[508]
2034 {0x0F12, 0x005A}, //TVAR_ash_pGAS[509]
2035 {0x0F12, 0x0036}, //TVAR_ash_pGAS[510]
2036 {0x0F12, 0x001B}, //TVAR_ash_pGAS[511]
2037 {0x0F12, 0x000D}, //TVAR_ash_pGAS[512]
2038 {0x0F12, 0x0008}, //TVAR_ash_pGAS[513]
2039 {0x0F12, 0x000D}, //TVAR_ash_pGAS[514]
2040 {0x0F12, 0x0020}, //TVAR_ash_pGAS[515]
2041 {0x0F12, 0x0041}, //TVAR_ash_pGAS[516]
2042 {0x0F12, 0x006C}, //TVAR_ash_pGAS[517]
2043 {0x0F12, 0x00A0}, //TVAR_ash_pGAS[518]
2044 {0x0F12, 0x00CC}, //TVAR_ash_pGAS[519]
2045 {0x0F12, 0x00DE}, //TVAR_ash_pGAS[520]
2046 {0x0F12, 0x00AA}, //TVAR_ash_pGAS[521]
2047 {0x0F12, 0x0070}, //TVAR_ash_pGAS[522]
2048 {0x0F12, 0x004D}, //TVAR_ash_pGAS[523]
2049 {0x0F12, 0x0032}, //TVAR_ash_pGAS[524]
2050 {0x0F12, 0x0023}, //TVAR_ash_pGAS[525]
2051 {0x0F12, 0x001E}, //TVAR_ash_pGAS[526]
2052 {0x0F12, 0x0024}, //TVAR_ash_pGAS[527]
2053 {0x0F12, 0x0036}, //TVAR_ash_pGAS[528]
2054 {0x0F12, 0x0055}, //TVAR_ash_pGAS[529]
2055 {0x0F12, 0x007E}, //TVAR_ash_pGAS[530]
2056 {0x0F12, 0x00B3}, //TVAR_ash_pGAS[531]
2057 {0x0F12, 0x00E3}, //TVAR_ash_pGAS[532]
2058 {0x0F12, 0x010B}, //TVAR_ash_pGAS[533]
2059 {0x0F12, 0x00D0}, //TVAR_ash_pGAS[534]
2060 {0x0F12, 0x0091}, //TVAR_ash_pGAS[535]
2061 {0x0F12, 0x0070}, //TVAR_ash_pGAS[536]
2062 {0x0F12, 0x0058}, //TVAR_ash_pGAS[537]
2063 {0x0F12, 0x0048}, //TVAR_ash_pGAS[538]
2064 {0x0F12, 0x0044}, //TVAR_ash_pGAS[539]
2065 {0x0F12, 0x0048}, //TVAR_ash_pGAS[540]
2066 {0x0F12, 0x005A}, //TVAR_ash_pGAS[541]
2067 {0x0F12, 0x0075}, //TVAR_ash_pGAS[542]
2068 {0x0F12, 0x009A}, //TVAR_ash_pGAS[543]
2069 {0x0F12, 0x00D2}, //TVAR_ash_pGAS[544]
2070 {0x0F12, 0x010B}, //TVAR_ash_pGAS[545]
2071 {0x0F12, 0x014F}, //TVAR_ash_pGAS[546]
2072 {0x0F12, 0x010B}, //TVAR_ash_pGAS[547]
2073 {0x0F12, 0x00C5}, //TVAR_ash_pGAS[548]
2074 {0x0F12, 0x00A0}, //TVAR_ash_pGAS[549]
2075 {0x0F12, 0x008A}, //TVAR_ash_pGAS[550]
2076 {0x0F12, 0x007F}, //TVAR_ash_pGAS[551]
2077 {0x0F12, 0x0079}, //TVAR_ash_pGAS[552]
2078 {0x0F12, 0x007D}, //TVAR_ash_pGAS[553]
2079 {0x0F12, 0x008A}, //TVAR_ash_pGAS[554]
2080 {0x0F12, 0x00A1}, //TVAR_ash_pGAS[555]
2081 {0x0F12, 0x00C6}, //TVAR_ash_pGAS[556]
2082 {0x0F12, 0x0107}, //TVAR_ash_pGAS[557]
2083 {0x0F12, 0x0164}, //TVAR_ash_pGAS[558]
2084 {0x0F12, 0x01E0}, //TVAR_ash_pGAS[559]
2085 {0x0F12, 0x014B}, //TVAR_ash_pGAS[560]
2086 {0x0F12, 0x0107}, //TVAR_ash_pGAS[561]
2087 {0x0F12, 0x00D7}, //TVAR_ash_pGAS[562]
2088 {0x0F12, 0x00BF}, //TVAR_ash_pGAS[563]
2089 {0x0F12, 0x00B2}, //TVAR_ash_pGAS[564]
2090 {0x0F12, 0x00AE}, //TVAR_ash_pGAS[565]
2091 {0x0F12, 0x00AF}, //TVAR_ash_pGAS[566]
2092 {0x0F12, 0x00B8}, //TVAR_ash_pGAS[567]
2093 {0x0F12, 0x00D1}, //TVAR_ash_pGAS[568]
2094 {0x0F12, 0x00FE}, //TVAR_ash_pGAS[569]
2095 {0x0F12, 0x014D}, //TVAR_ash_pGAS[570]
2096 {0x0F12, 0x01FD}, //TVAR_ash_pGAS[571]
2097 // param_end TVAR_ash_pGAS
2099 {0x0F12, 0x0001}, //ash_bLumaMode
2101 {0x0F12, 0x025F}, //awbb_GLocusR
2103 {0x0F12, 0x0376}, //awbb_GLocusB
2104 // param_start TVAR_ash_AwbAshCord
2106 {0x0F12, 0x00C0}, //TVAR_ash_AwbAshCord[0]
2107 {0x0F12, 0x00E0}, //TVAR_ash_AwbAshCord[1]
2108 {0x0F12, 0x00FA}, //TVAR_ash_AwbAshCord[2]
2109 {0x0F12, 0x011D}, //TVAR_ash_AwbAshCord[3]
2110 {0x0F12, 0x0144}, //TVAR_ash_AwbAshCord[4]
2111 {0x0F12, 0x0173}, //TVAR_ash_AwbAshCord[5]
2112 {0x0F12, 0x0180}, //TVAR_ash_AwbAshCord[6]
2113 // param_end TVAR_ash_AwbAshCord
2115 {0x0F12, 0x013E}, //seti_uContrastCenter
2119 {0x0F12, 0x010B}, //ash_CGrasAlphas[0]
2120 {0x0F12, 0x0103}, //ash_CGrasAlphas[1]
2121 {0x0F12, 0x00FC}, //ash_CGrasAlphas[2]
2122 {0x0F12, 0x010C}, //ash_CGrasAlphas[3]
2123 //============================================================
2125 //============================================================
2127 //============================================================
2128 // param_start awbb_IndoorGrZones_m_BGrid
2130 {0x0F12, 0x03C9}, //awbb_IndoorGrZones_m_BGrid[0]
2131 {0x0F12, 0x040A}, //awbb_IndoorGrZones_m_BGrid[1]
2132 {0x0F12, 0x038B}, //awbb_IndoorGrZones_m_BGrid[2]
2133 {0x0F12, 0x0405}, //awbb_IndoorGrZones_m_BGrid[3]
2134 {0x0F12, 0x0356}, //awbb_IndoorGrZones_m_BGrid[4]
2135 {0x0F12, 0x0400}, //awbb_IndoorGrZones_m_BGrid[5]
2136 {0x0F12, 0x0322}, //awbb_IndoorGrZones_m_BGrid[6]
2137 {0x0F12, 0x03DF}, //awbb_IndoorGrZones_m_BGrid[7]
2138 {0x0F12, 0x02E9}, //awbb_IndoorGrZones_m_BGrid[8]
2139 {0x0F12, 0x03B0}, //awbb_IndoorGrZones_m_BGrid[9]
2140 {0x0F12, 0x02B6}, //awbb_IndoorGrZones_m_BGrid[10]
2141 {0x0F12, 0x0380}, //awbb_IndoorGrZones_m_BGrid[11]
2142 {0x0F12, 0x0296}, //awbb_IndoorGrZones_m_BGrid[12]
2143 {0x0F12, 0x034F}, //awbb_IndoorGrZones_m_BGrid[13]
2144 {0x0F12, 0x027F}, //awbb_IndoorGrZones_m_BGrid[14]
2145 {0x0F12, 0x031A}, //awbb_IndoorGrZones_m_BGrid[15]
2146 {0x0F12, 0x026C}, //awbb_IndoorGrZones_m_BGrid[16]
2147 {0x0F12, 0x02F5}, //awbb_IndoorGrZones_m_BGrid[17]
2148 {0x0F12, 0x0256}, //awbb_IndoorGrZones_m_BGrid[18]
2149 {0x0F12, 0x02DA}, //awbb_IndoorGrZones_m_BGrid[19]
2150 {0x0F12, 0x0241}, //awbb_IndoorGrZones_m_BGrid[20]
2151 {0x0F12, 0x02C4}, //awbb_IndoorGrZones_m_BGrid[21]
2152 {0x0F12, 0x0228}, //awbb_IndoorGrZones_m_BGrid[22]
2153 {0x0F12, 0x02AB}, //awbb_IndoorGrZones_m_BGrid[23]
2154 {0x0F12, 0x0213}, //awbb_IndoorGrZones_m_BGrid[24]
2155 {0x0F12, 0x0292}, //awbb_IndoorGrZones_m_BGrid[25]
2156 {0x0F12, 0x01FF}, //awbb_IndoorGrZones_m_BGrid[26]
2157 {0x0F12, 0x0278}, //awbb_IndoorGrZones_m_BGrid[27]
2158 {0x0F12, 0x01F4}, //awbb_IndoorGrZones_m_BGrid[28]
2159 {0x0F12, 0x025F}, //awbb_IndoorGrZones_m_BGrid[29]
2160 {0x0F12, 0x0202}, //awbb_IndoorGrZones_m_BGrid[30]
2161 {0x0F12, 0x0234}, //awbb_IndoorGrZones_m_BGrid[31]
2162 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[32]
2163 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[33]
2164 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[34]
2165 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[35]
2166 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[36]
2167 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[37]
2168 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[38]
2169 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_BGrid[39]
2170 // param_end awbb_IndoorGrZones_m_BGrid
2173 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_GridStep
2176 {0x0F12, 0x0000}, //awbb_IndoorGrZones_m_Boffs
2177 // param_start awbb_LowBrGrZones_m_BGrid
2179 {0x0F12, 0x03D4}, //awbb_LowBrGrZones_m_BGrid[0] //
2180 {0x0F12, 0x043E}, //awbb_LowBrGrZones_m_BGrid[1] //
2181 {0x0F12, 0x035C}, //awbb_LowBrGrZones_m_BGrid[2] //
2182 {0x0F12, 0x0438}, //awbb_LowBrGrZones_m_BGrid[3] //
2183 {0x0F12, 0x02F0}, //awbb_LowBrGrZones_m_BGrid[4] //
2184 {0x0F12, 0x042D}, //awbb_LowBrGrZones_m_BGrid[5] //
2185 {0x0F12, 0x029A}, //awbb_LowBrGrZones_m_BGrid[6] //
2186 {0x0F12, 0x03EF}, //awbb_LowBrGrZones_m_BGrid[7] //
2187 {0x0F12, 0x025E}, //awbb_LowBrGrZones_m_BGrid[8] //
2188 {0x0F12, 0x0395}, //awbb_LowBrGrZones_m_BGrid[9] //
2189 {0x0F12, 0x022E}, //awbb_LowBrGrZones_m_BGrid[10] //
2190 {0x0F12, 0x0346}, //awbb_LowBrGrZones_m_BGrid[11] //
2191 {0x0F12, 0x0200}, //awbb_LowBrGrZones_m_BGrid[12] //
2192 {0x0F12, 0x02F6}, //awbb_LowBrGrZones_m_BGrid[13] //
2193 {0x0F12, 0x01CE}, //awbb_LowBrGrZones_m_BGrid[14] //
2194 {0x0F12, 0x02C8}, //awbb_LowBrGrZones_m_BGrid[15] //
2195 {0x0F12, 0x01BB}, //awbb_LowBrGrZones_m_BGrid[16] //
2196 {0x0F12, 0x0287}, //awbb_LowBrGrZones_m_BGrid[17] //
2197 {0x0F12, 0x01E2}, //awbb_LowBrGrZones_m_BGrid[18] //
2198 {0x0F12, 0x0239}, //awbb_LowBrGrZones_m_BGrid[19] //
2199 {0x0F12, 0x0000}, //awbb_LowBrGrZones_m_BGrid[20] //
2200 {0x0F12, 0x0000}, //awbb_LowBrGrZones_m_BGrid[21] //
2201 {0x0F12, 0x0000}, //awbb_LowBrGrZones_m_BGrid[22] //
2202 {0x0F12, 0x0000}, //awbb_LowBrGrZones_m_BGrid[23] //
2203 // param_end awbb_LowBrGrZones_m_BGrid
2206 {0x0F12, 0x0000}, //awbb_LowBrGrZones_m_GridStep
2209 {0x0F12, 0x0000}, //awbb_LowBrGrZones_m_Boffs
2210 // param_start awbb_OutdoorGrZones_m_BGrid
2212 {0x0F12, 0x031A},//02A8 //awbb_OutdoorGrZones_m_BGrid[0]
2213 {0x0F12, 0x0382},//02C2 //awbb_OutdoorGrZones_m_BGrid[1]
2214 {0x0F12, 0x02E3},//0270 //awbb_OutdoorGrZones_m_BGrid[2]
2215 {0x0F12, 0x038B},//02B4 //awbb_OutdoorGrZones_m_BGrid[3]
2216 {0x0F12, 0x02B7},//025C //awbb_OutdoorGrZones_m_BGrid[4]
2217 {0x0F12, 0x035D},//02A0 //awbb_OutdoorGrZones_m_BGrid[5]
2218 {0x0F12, 0x0297},//0240 //awbb_OutdoorGrZones_m_BGrid[6]
2219 {0x0F12, 0x032A},//0288 //awbb_OutdoorGrZones_m_BGrid[7]
2220 {0x0F12, 0x0285},//0230 //awbb_OutdoorGrZones_m_BGrid[8]
2221 {0x0F12, 0x0302},//026E //awbb_OutdoorGrZones_m_BGrid[9]
2222 {0x0F12, 0x0271},//0222 //awbb_OutdoorGrZones_m_BGrid[10]
2223 {0x0F12, 0x02DF},//025A //awbb_OutdoorGrZones_m_BGrid[11]
2224 {0x0F12, 0x025D},//0220 //awbb_OutdoorGrZones_m_BGrid[12]
2225 {0x0F12, 0x02C7},//023A //awbb_OutdoorGrZones_m_BGrid[13]
2226 {0x0F12, 0x0241},//0000 //awbb_OutdoorGrZones_m_BGrid[14]
2227 {0x0F12, 0x02B5},//0000 //awbb_OutdoorGrZones_m_BGrid[15]
2228 {0x0F12, 0x0229},//0000 //awbb_OutdoorGrZones_m_BGrid[16]
2229 {0x0F12, 0x029B},//0000 //awbb_OutdoorGrZones_m_BGrid[17]
2230 {0x0F12, 0x0212},//0000 //awbb_OutdoorGrZones_m_BGrid[18]
2231 {0x0F12, 0x0280},//0000 //awbb_OutdoorGrZones_m_BGrid[19]
2232 {0x0F12, 0x0205},//0000 //awbb_OutdoorGrZones_m_BGrid[20]
2233 {0x0F12, 0x026A},//0000 //awbb_OutdoorGrZones_m_BGrid[21]
2234 {0x0F12, 0x020A},//0000 //awbb_OutdoorGrZones_m_BGrid[22]
2235 {0x0F12, 0x023F},//0000 //awbb_OutdoorGrZones_m_BGrid[23]
2236 // param_end awbb_OutdoorGrZones_m_BGrid
2239 {0x0F12, 0x0000}, //awbb_OutdoorGrZones_m_GridStep
2241 {0x0F12, 0x0157}, //01FE
2242 {0x0F12, 0x0000}, //awbb_OutdoorGrZones_m_Boffs
2246 {0x0F12, 0x0000}, //awbb_CrclLowT_R_c
2249 {0x0F12, 0x0000}, //awbb_CrclLowT_B_c
2252 {0x0F12, 0x0000}, //awbb_CrclLowT_Rad_c
2255 {0x0F12, 0x013D}, //awbb_IntcR
2256 {0x0F12, 0x011E}, //awbb_IntcB
2258 {0x0F12, 0x0396}, //04A2 //awbb_MvEq_RBthresh
2260 {0x0F12, 0x0584}, //awbb_LowTempRB
2263 // param_start awbb_GridCorr_R
2265 {0x0F12, 0x003C}, //awbb_GridCorr_R[0]
2266 {0x0F12, 0x0050}, //awbb_GridCorr_R[1]
2267 {0x0F12, 0x0064}, //awbb_GridCorr_R[2]
2268 {0x0F12, 0x0000}, //awbb_GridCorr_R[3]
2269 {0x0F12, 0x0014}, //awbb_GridCorr_R[4]
2270 {0x0F12, 0x0014}, //awbb_GridCorr_R[5]
2271 {0x0F12, 0x003C}, //awbb_GridCorr_R[6]
2272 {0x0F12, 0x0050}, //awbb_GridCorr_R[7]
2273 {0x0F12, 0x0064}, //awbb_GridCorr_R[8]
2274 {0x0F12, 0x0000}, //awbb_GridCorr_R[9]
2275 {0x0F12, 0x0014}, //awbb_GridCorr_R[10]
2276 {0x0F12, 0x0014}, //awbb_GridCorr_R[11]
2277 {0x0F12, 0x003C}, //awbb_GridCorr_R[12]
2278 {0x0F12, 0x0050}, //awbb_GridCorr_R[13]
2279 {0x0F12, 0x0064}, //awbb_GridCorr_R[14]
2280 {0x0F12, 0x0000}, //awbb_GridCorr_R[15]
2281 {0x0F12, 0x0014}, //awbb_GridCorr_R[16]
2282 {0x0F12, 0x0014}, //awbb_GridCorr_R[17]
2283 // param_end awbb_GridCorr_R
2284 // param_start awbb_GridCorr_B
2286 {0x0F12, 0xFFEC}, //awbb_GridCorr_B[0]
2287 {0x0F12, 0xFFEC}, //awbb_GridCorr_B[1]
2288 {0x0F12, 0x0078}, //awbb_GridCorr_B[2]
2289 {0x0F12, 0xFFE2}, //awbb_GridCorr_B[3]
2290 {0x0F12, 0xFFE2}, //awbb_GridCorr_B[4]
2291 {0x0F12, 0xFFB0}, //awbb_GridCorr_B[5]
2292 {0x0F12, 0xFFEC}, //awbb_GridCorr_B[6]
2293 {0x0F12, 0xFFEC}, //awbb_GridCorr_B[7]
2294 {0x0F12, 0x0078}, //awbb_GridCorr_B[8]
2295 {0x0F12, 0xFFE2}, //awbb_GridCorr_B[9]
2296 {0x0F12, 0xFFE2}, //awbb_GridCorr_B[10]
2297 {0x0F12, 0xFFB0}, //awbb_GridCorr_B[11]
2298 {0x0F12, 0xFFEC}, //awbb_GridCorr_B[12]
2299 {0x0F12, 0xFFEC}, //awbb_GridCorr_B[13]
2300 {0x0F12, 0x0078}, //awbb_GridCorr_B[14]
2301 {0x0F12, 0xFFE2}, //awbb_GridCorr_B[15]
2302 {0x0F12, 0xFFE2}, //awbb_GridCorr_B[16]
2303 {0x0F12, 0xFFB0}, //awbb_GridCorr_B[17]
2304 // param_end awbb_GridCorr_B
2305 // param_start awbb_GridConst_1
2307 {0x0F12, 0x02D9}, //awbb_GridConst_1[0]
2308 {0x0F12, 0x0357}, //awbb_GridConst_1[1]
2309 {0x0F12, 0x03D1}, //awbb_GridConst_1[2]
2310 // param_end awbb_GridConst_1
2311 // param_start awbb_GridConst_2
2313 {0x0F12, 0x0DE9}, //awbb_GridConst_2[0]
2314 {0x0F12, 0x0EDD}, //awbb_GridConst_2[1]
2315 {0x0F12, 0x0F42}, //awbb_GridConst_2[2]
2316 {0x0F12, 0x0F54}, //awbb_GridConst_2[3]
2317 {0x0F12, 0x0FAE}, //awbb_GridConst_2[4]
2318 {0x0F12, 0x1011}, //awbb_GridConst_2[5]
2319 // param_end awbb_GridConst_2
2321 {0x0F12, 0x00BA}, //awbb_GridCoeff_R_1
2322 {0x0F12, 0x00AF}, //awbb_GridCoeff_B_1
2323 {0x0F12, 0x0049}, //awbb_GridCoeff_R_2
2324 {0x0F12, 0x00F5}, //awbb_GridCoeff_B_2
2327 {0x0F12, 0x0002}, //awbb_GridEnable
2328 //============================================================
2330 //============================================================
2332 //============================================================
2335 {0x0F12, 0x010E}, //lt_uLimitHigh
2336 {0x0F12, 0x00F5}, //lt_uLimitLow
2337 //disable contrast, enable illumination
2339 {0x0F12, 0x0001}, //
2342 {0x0F12, 0x00C0}, //SARR_IllumType[0]
2343 {0x0F12, 0x00E0}, //SARR_IllumType[1]
2344 {0x0F12, 0x00F0}, //SARR_IllumType[2]
2345 {0x0F12, 0x0129}, //SARR_IllumType[3]
2346 {0x0F12, 0x0156}, //SARR_IllumType[4]
2347 {0x0F12, 0x017F}, //SARR_IllumType[5]
2348 {0x0F12, 0x018F}, //SARR_IllumType[6]
2351 {0x0F12, 0x0120}, //SARR_IllumTypeF[0]
2352 {0x0F12, 0x0120}, //SARR_IllumTypeF[1]
2353 {0x0F12, 0x0120}, //SARR_IllumTypeF[2]
2354 {0x0F12, 0x0100}, //SARR_IllumTypeF[3]
2355 {0x0F12, 0x0100}, //SARR_IllumTypeF[4]
2356 {0x0F12, 0x0100}, //SARR_IllumTypeF[5]
2357 {0x0F12, 0x0100}, //SARR_IllumTypeF[6]
2361 {0x0F12, 0x0046}, //TVAR_ae_BrAve
2364 {0x002A, 0x0f7e}, //AE weight/
2365 {0x0F12, 0x0101},//0000
2366 {0x0F12, 0x0101},//0000
2367 {0x0F12, 0x0101},//0000
2368 {0x0F12, 0x0101},//0000
2369 {0x0F12, 0x0101},//0101
2370 {0x0F12, 0x0101},//0101
2371 {0x0F12, 0x0101},//0101
2372 {0x0F12, 0x0101},//0101
2373 {0x0F12, 0x0101},//0101
2374 {0x0F12, 0x0303},//0101
2375 {0x0F12, 0x0303},//0101
2376 {0x0F12, 0x0101},//0101
2377 {0x0F12, 0x0101},//0101
2378 {0x0F12, 0x0303},//0401
2379 {0x0F12, 0x0303},//0104
2380 {0x0F12, 0x0101},//0101
2381 {0x0F12, 0x0101},//0101
2382 {0x0F12, 0x0303},//0401
2383 {0x0F12, 0x0303},//0104
2384 {0x0F12, 0x0101},//0101
2385 {0x0F12, 0x0101},//0101
2386 {0x0F12, 0x0303},//0201
2387 {0x0F12, 0x0303},//0102
2388 {0x0F12, 0x0101},//0101
2389 {0x0F12, 0x0101},//0101
2390 {0x0F12, 0x0101},//0201
2391 {0x0F12, 0x0101},//0102
2392 {0x0F12, 0x0101},//0101
2393 {0x0F12, 0x0101},//0101
2394 {0x0F12, 0x0101},//0101
2395 {0x0F12, 0x0101},//0101
2396 {0x0F12, 0x0101},//0101
2397 //============================================================
2399 //============================================================
2401 {0x0F12, 0x0000}, //#SARR_usDualGammaLutRGBIndoor[0][0] 0000
2402 {0x0F12, 0x0008}, //#SARR_usDualGammaLutRGBIndoor[0][1] 0008
2403 {0x0F12, 0x0013}, //#SARR_usDualGammaLutRGBIndoor[0][2] 0013
2404 {0x0F12, 0x002C}, //#SARR_usDualGammaLutRGBIndoor[0][3] 002C
2405 {0x0F12, 0x0061}, //#SARR_usDualGammaLutRGBIndoor[0][4] 0061
2406 {0x0F12, 0x00C8}, //#SARR_usDualGammaLutRGBIndoor[0][5] 00C8
2407 {0x0F12, 0x0113}, //#SARR_usDualGammaLutRGBIndoor[0][6] 0113
2408 {0x0F12, 0x0132}, //#SARR_usDualGammaLutRGBIndoor[0][7] 0132
2409 {0x0F12, 0x014C}, //#SARR_usDualGammaLutRGBIndoor[0][8] 014C
2410 {0x0F12, 0x0179}, //#SARR_usDualGammaLutRGBIndoor[0][9] 0179
2411 {0x0F12, 0x01A4}, //#SARR_usDualGammaLutRGBIndoor[0][10] 01A4
2412 {0x0F12, 0x01CD}, //#SARR_usDualGammaLutRGBIndoor[0][11] 01CD
2413 {0x0F12, 0x01F4}, //#SARR_usDualGammaLutRGBIndoor[0][12] 01F4
2414 {0x0F12, 0x0239}, //#SARR_usDualGammaLutRGBIndoor[0][13] 0239
2415 {0x0F12, 0x0278}, //#SARR_usDualGammaLutRGBIndoor[0][14] 0278
2416 {0x0F12, 0x02E0}, //#SARR_usDualGammaLutRGBIndoor[0][15] 02E0
2417 {0x0F12, 0x0333}, //#SARR_usDualGammaLutRGBIndoor[0][16] 0333
2418 {0x0F12, 0x037B}, //#SARR_usDualGammaLutRGBIndoor[0][17] 037B
2419 {0x0F12, 0x03BF}, //#SARR_usDualGammaLutRGBIndoor[0][18] 03BF
2420 {0x0F12, 0x03FF}, //#SARR_usDualGammaLutRGBIndoor[0][19] 03FF
2421 {0x0F12, 0x0000}, //#SARR_usDualGammaLutRGBIndoor[1][0] 0000
2422 {0x0F12, 0x0008}, //#SARR_usDualGammaLutRGBIndoor[1][1] 0008
2423 {0x0F12, 0x0013}, //#SARR_usDualGammaLutRGBIndoor[1][2] 0013
2424 {0x0F12, 0x002C}, //#SARR_usDualGammaLutRGBIndoor[1][3] 002C
2425 {0x0F12, 0x0061}, //#SARR_usDualGammaLutRGBIndoor[1][4] 0061
2426 {0x0F12, 0x00C8}, //#SARR_usDualGammaLutRGBIndoor[1][5] 00C8
2427 {0x0F12, 0x0113}, //#SARR_usDualGammaLutRGBIndoor[1][6] 0113
2428 {0x0F12, 0x0132}, //#SARR_usDualGammaLutRGBIndoor[1][7] 0132
2429 {0x0F12, 0x014C}, //#SARR_usDualGammaLutRGBIndoor[1][8] 014C
2430 {0x0F12, 0x0179}, //#SARR_usDualGammaLutRGBIndoor[1][9] 0179
2431 {0x0F12, 0x01A4}, //#SARR_usDualGammaLutRGBIndoor[1][10] 01A4
2432 {0x0F12, 0x01CD}, //#SARR_usDualGammaLutRGBIndoor[1][11] 01CD
2433 {0x0F12, 0x01F4}, //#SARR_usDualGammaLutRGBIndoor[1][12] 01F4
2434 {0x0F12, 0x0239}, //#SARR_usDualGammaLutRGBIndoor[1][13] 0239
2435 {0x0F12, 0x0278}, //#SARR_usDualGammaLutRGBIndoor[1][14] 0278
2436 {0x0F12, 0x02E0}, //#SARR_usDualGammaLutRGBIndoor[1][15] 02E0
2437 {0x0F12, 0x0333}, //#SARR_usDualGammaLutRGBIndoor[1][16] 0333
2438 {0x0F12, 0x037B}, //#SARR_usDualGammaLutRGBIndoor[1][17] 037B
2439 {0x0F12, 0x03BF}, //#SARR_usDualGammaLutRGBIndoor[1][18] 03BF
2440 {0x0F12, 0x03FF}, //#SARR_usDualGammaLutRGBIndoor[1][19] 03FF
2441 {0x0F12, 0x0000}, //#SARR_usDualGammaLutRGBIndoor[2][0] 0000
2442 {0x0F12, 0x0008}, //#SARR_usDualGammaLutRGBIndoor[2][1] 0008
2443 {0x0F12, 0x0013}, //#SARR_usDualGammaLutRGBIndoor[2][2] 0013
2444 {0x0F12, 0x002C}, //#SARR_usDualGammaLutRGBIndoor[2][3] 002C
2445 {0x0F12, 0x0061}, //#SARR_usDualGammaLutRGBIndoor[2][4] 0061
2446 {0x0F12, 0x00C8}, //#SARR_usDualGammaLutRGBIndoor[2][5] 00C8
2447 {0x0F12, 0x0113}, //#SARR_usDualGammaLutRGBIndoor[2][6] 0113
2448 {0x0F12, 0x0132}, //#SARR_usDualGammaLutRGBIndoor[2][7] 0132
2449 {0x0F12, 0x014C}, //#SARR_usDualGammaLutRGBIndoor[2][8] 014C
2450 {0x0F12, 0x0179}, //#SARR_usDualGammaLutRGBIndoor[2][9] 0179
2451 {0x0F12, 0x01A4}, //#SARR_usDualGammaLutRGBIndoor[2][10] 01A4
2452 {0x0F12, 0x01CD}, //#SARR_usDualGammaLutRGBIndoor[2][11] 01CD
2453 {0x0F12, 0x01F4}, //#SARR_usDualGammaLutRGBIndoor[2][12] 01F4
2454 {0x0F12, 0x0239}, //#SARR_usDualGammaLutRGBIndoor[2][13] 0239
2455 {0x0F12, 0x0278}, //#SARR_usDualGammaLutRGBIndoor[2][14] 0278
2456 {0x0F12, 0x02E0}, //#SARR_usDualGammaLutRGBIndoor[2][15] 02E0
2457 {0x0F12, 0x0333}, //#SARR_usDualGammaLutRGBIndoor[2][16] 0333
2458 {0x0F12, 0x037B}, //#SARR_usDualGammaLutRGBIndoor[2][17] 037B
2459 {0x0F12, 0x03BF}, //#SARR_usDualGammaLutRGBIndoor[2][18] 03BF
2460 {0x0F12, 0x03FF}, //#SARR_usDualGammaLutRGBIndoor[2][19] 03FF
2463 {0x0F12, 0x0000}, //#SARR_usDualGammaLutRGBOutdoor[0][0] 0000
2464 {0x0F12, 0x0008}, //#SARR_usDualGammaLutRGBOutdoor[0][1] 0008
2465 {0x0F12, 0x0013}, //#SARR_usDualGammaLutRGBOutdoor[0][2] 0013
2466 {0x0F12, 0x002C}, //#SARR_usDualGammaLutRGBOutdoor[0][3] 002C
2467 {0x0F12, 0x0061}, //#SARR_usDualGammaLutRGBOutdoor[0][4] 0061
2468 {0x0F12, 0x00C8}, //#SARR_usDualGammaLutRGBOutdoor[0][5] 00C8
2469 {0x0F12, 0x0113}, //#SARR_usDualGammaLutRGBOutdoor[0][6] 0113
2470 {0x0F12, 0x0132}, //#SARR_usDualGammaLutRGBOutdoor[0][7] 0132
2471 {0x0F12, 0x014C}, //#SARR_usDualGammaLutRGBOutdoor[0][8] 014C
2472 {0x0F12, 0x0179}, //#SARR_usDualGammaLutRGBOutdoor[0][9] 0179
2473 {0x0F12, 0x01A4}, //#SARR_usDualGammaLutRGBOutdoor[0][10] 01A4
2474 {0x0F12, 0x01CD}, //#SARR_usDualGammaLutRGBOutdoor[0][11] 01CD
2475 {0x0F12, 0x01F4}, //#SARR_usDualGammaLutRGBOutdoor[0][12] 01F4
2476 {0x0F12, 0x0239}, //#SARR_usDualGammaLutRGBOutdoor[0][13] 0239
2477 {0x0F12, 0x0278}, //#SARR_usDualGammaLutRGBOutdoor[0][14] 0278
2478 {0x0F12, 0x02E0}, //#SARR_usDualGammaLutRGBOutdoor[0][15] 02E0
2479 {0x0F12, 0x0333}, //#SARR_usDualGammaLutRGBOutdoor[0][16] 0333
2480 {0x0F12, 0x037B}, //#SARR_usDualGammaLutRGBOutdoor[0][17] 037B
2481 {0x0F12, 0x03BF}, //#SARR_usDualGammaLutRGBOutdoor[0][18] 03BF
2482 {0x0F12, 0x03FF}, //#SARR_usDualGammaLutRGBOutdoor[0][19] 03FF
2483 {0x0F12, 0x0000}, //#SARR_usDualGammaLutRGBOutdoor[1][0] 0000
2484 {0x0F12, 0x0008}, //#SARR_usDualGammaLutRGBOutdoor[1][1] 0008
2485 {0x0F12, 0x0013}, //#SARR_usDualGammaLutRGBOutdoor[1][2] 0013
2486 {0x0F12, 0x002C}, //#SARR_usDualGammaLutRGBOutdoor[1][3] 002C
2487 {0x0F12, 0x0061}, //#SARR_usDualGammaLutRGBOutdoor[1][4] 0061
2488 {0x0F12, 0x00C8}, //#SARR_usDualGammaLutRGBOutdoor[1][5] 00C8
2489 {0x0F12, 0x0113}, //#SARR_usDualGammaLutRGBOutdoor[1][6] 0113
2490 {0x0F12, 0x0132}, //#SARR_usDualGammaLutRGBOutdoor[1][7] 0132
2491 {0x0F12, 0x014C}, //#SARR_usDualGammaLutRGBOutdoor[1][8] 014C
2492 {0x0F12, 0x0179}, //#SARR_usDualGammaLutRGBOutdoor[1][9] 0179
2493 {0x0F12, 0x01A4}, //#SARR_usDualGammaLutRGBOutdoor[1][10] 01A4
2494 {0x0F12, 0x01CD}, //#SARR_usDualGammaLutRGBOutdoor[1][11] 01CD
2495 {0x0F12, 0x01F4}, //#SARR_usDualGammaLutRGBOutdoor[1][12] 01F4
2496 {0x0F12, 0x0239}, //#SARR_usDualGammaLutRGBOutdoor[1][13] 0239
2497 {0x0F12, 0x0278}, //#SARR_usDualGammaLutRGBOutdoor[1][14] 0278
2498 {0x0F12, 0x02E0}, //#SARR_usDualGammaLutRGBOutdoor[1][15] 02E0
2499 {0x0F12, 0x0333}, //#SARR_usDualGammaLutRGBOutdoor[1][16] 0333
2500 {0x0F12, 0x037B}, //#SARR_usDualGammaLutRGBOutdoor[1][17] 037B
2501 {0x0F12, 0x03BF}, //#SARR_usDualGammaLutRGBOutdoor[1][18] 03BF
2502 {0x0F12, 0x03FF}, //#SARR_usDualGammaLutRGBOutdoor[1][19] 03FF
2503 {0x0F12, 0x0000}, //#SARR_usDualGammaLutRGBOutdoor[2][0] 0000
2504 {0x0F12, 0x0008}, //#SARR_usDualGammaLutRGBOutdoor[2][1] 0008
2505 {0x0F12, 0x0013}, //#SARR_usDualGammaLutRGBOutdoor[2][2] 0013
2506 {0x0F12, 0x002C}, //#SARR_usDualGammaLutRGBOutdoor[2][3] 002C
2507 {0x0F12, 0x0061}, //#SARR_usDualGammaLutRGBOutdoor[2][4] 0061
2508 {0x0F12, 0x00C8}, //#SARR_usDualGammaLutRGBOutdoor[2][5] 00C8
2509 {0x0F12, 0x0113}, //#SARR_usDualGammaLutRGBOutdoor[2][6] 0113
2510 {0x0F12, 0x0132}, //#SARR_usDualGammaLutRGBOutdoor[2][7] 0132
2511 {0x0F12, 0x014C}, //#SARR_usDualGammaLutRGBOutdoor[2][8] 014C
2512 {0x0F12, 0x0179}, //#SARR_usDualGammaLutRGBOutdoor[2][9] 0179
2513 {0x0F12, 0x01A4}, //#SARR_usDualGammaLutRGBOutdoor[2][10] 01A4
2514 {0x0F12, 0x01CD}, //#SARR_usDualGammaLutRGBOutdoor[2][11] 01CD
2515 {0x0F12, 0x01F4}, //#SARR_usDualGammaLutRGBOutdoor[2][12] 01F4
2516 {0x0F12, 0x0239}, //#SARR_usDualGammaLutRGBOutdoor[2][13] 0239
2517 {0x0F12, 0x0278}, //#SARR_usDualGammaLutRGBOutdoor[2][14] 0278
2518 {0x0F12, 0x02E0}, //#SARR_usDualGammaLutRGBOutdoor[2][15] 02E0
2519 {0x0F12, 0x0333}, //#SARR_usDualGammaLutRGBOutdoor[2][16] 0333
2520 {0x0F12, 0x037B}, //#SARR_usDualGammaLutRGBOutdoor[2][17] 037B
2521 {0x0F12, 0x03BF}, //#SARR_usDualGammaLutRGBOutdoor[2][18] 03BF
2522 {0x0F12, 0x03FF}, //#SARR_usDualGammaLutRGBOutdoor[2][19] 03FF
2524 //============================================================
2526 //============================================================
2528 {0x0F12, 0x00C0}, //SARR_AwbCcmCord[0]
2529 {0x0F12, 0x00F8}, //SARR_AwbCcmCord[1]
2530 {0x0F12, 0x0112}, //SARR_AwbCcmCord[2]
2531 {0x0F12, 0x014A}, //SARR_AwbCcmCord[3]
2532 {0x0F12, 0x0156}, //SARR_AwbCcmCord[4]
2533 {0x0F12, 0x017F}, //SARR_AwbCcmCord[5]
2535 // param_start TVAR_wbt_pBaseCcms
2538 {0x0F12, 0x01C3},//02D5 //TVAR_wbt_pBaseCcms[0]
2539 {0x0F12, 0xFF89},//FF53 //TVAR_wbt_pBaseCcms[1]
2540 {0x0F12, 0xFFE5},//FF83 //TVAR_wbt_pBaseCcms[2]
2541 {0x0F12, 0xFF26},//FEE9 //TVAR_wbt_pBaseCcms[3]
2542 {0x0F12, 0x028E},//01A2 //TVAR_wbt_pBaseCcms[4]
2543 {0x0F12, 0xFF80},//FDFE //TVAR_wbt_pBaseCcms[5]
2544 {0x0F12, 0x0002},//FFFC //TVAR_wbt_pBaseCcms[6]
2545 {0x0F12, 0xFFA8},//FF5F //TVAR_wbt_pBaseCcms[7]
2546 {0x0F12, 0x01F0},//02AD //TVAR_wbt_pBaseCcms[8]
2547 {0x0F12, 0x0125},//0125 //TVAR_wbt_pBaseCcms[9]
2548 {0x0F12, 0x0119},//0119 //TVAR_wbt_pBaseCcms[10]
2549 {0x0F12, 0xFE5A},//FE5A //TVAR_wbt_pBaseCcms[11]
2550 {0x0F12, 0x0179},//00D9 //TVAR_wbt_pBaseCcms[12]
2551 {0x0F12, 0xFF8A},//FF26 //TVAR_wbt_pBaseCcms[13]
2552 {0x0F12, 0x0180},//013C //TVAR_wbt_pBaseCcms[14]
2553 {0x0F12, 0xFEC2},//FEC0 //TVAR_wbt_pBaseCcms[15]
2554 {0x0F12, 0x0176},//01F3 //TVAR_wbt_pBaseCcms[16]
2555 {0x0F12, 0x0094},//0109 //TVAR_wbt_pBaseCcms[17]
2557 {0x0F12, 0x01C3},//022B //TVAR_wbt_pBaseCcms[18]
2558 {0x0F12, 0xFF89},//FF73 //TVAR_wbt_pBaseCcms[19]
2559 {0x0F12, 0xFFE5},//FFC3 //TVAR_wbt_pBaseCcms[20]
2560 {0x0F12, 0xFF26},//FEED //TVAR_wbt_pBaseCcms[21]
2561 {0x0F12, 0x028E},//01B9 //TVAR_wbt_pBaseCcms[22]
2562 {0x0F12, 0xFF80},//FF0D //TVAR_wbt_pBaseCcms[23]
2563 {0x0F12, 0x0002},//FFE7 //TVAR_wbt_pBaseCcms[24]
2564 {0x0F12, 0xFFA8},//FFD3 //TVAR_wbt_pBaseCcms[25]
2565 {0x0F12, 0x01F0},//022F //TVAR_wbt_pBaseCcms[26]
2566 {0x0F12, 0x0125},//0118 //TVAR_wbt_pBaseCcms[27]
2567 {0x0F12, 0x0119},//012C //TVAR_wbt_pBaseCcms[28]
2568 {0x0F12, 0xFE5A},//FED0 //TVAR_wbt_pBaseCcms[29]
2569 {0x0F12, 0x0179},//0212 //TVAR_wbt_pBaseCcms[30]
2570 {0x0F12, 0xFF8A},//FF46 //TVAR_wbt_pBaseCcms[31]
2571 {0x0F12, 0x0180},//01F2 //TVAR_wbt_pBaseCcms[32]
2572 {0x0F12, 0xFEC2},//FED4 //TVAR_wbt_pBaseCcms[33]
2573 {0x0F12, 0x0176},//018C //TVAR_wbt_pBaseCcms[34]
2574 {0x0F12, 0x0094},//013C //TVAR_wbt_pBaseCcms[35]
2576 {0x0F12, 0x01CA},//0121 //TVAR_wbt_pBaseCcms[36]
2577 {0x0F12, 0xFF89},//FF8D //TVAR_wbt_pBaseCcms[37]
2578 {0x0F12, 0xFFE0},//FFA7 //TVAR_wbt_pBaseCcms[38]
2579 {0x0F12, 0xFF26},//FF3D //TVAR_wbt_pBaseCcms[39]
2580 {0x0F12, 0x028E},//02D0 //TVAR_wbt_pBaseCcms[40]
2581 {0x0F12, 0xFF80},//FE31 //TVAR_wbt_pBaseCcms[41]
2582 {0x0F12, 0x0020},//0016 //TVAR_wbt_pBaseCcms[42]
2583 {0x0F12, 0xFFF8},//003B //TVAR_wbt_pBaseCcms[43]
2584 {0x0F12, 0x01E0},//02E1 //TVAR_wbt_pBaseCcms[44]
2585 {0x0F12, 0x0120},//0175 //TVAR_wbt_pBaseCcms[45]
2586 {0x0F12, 0x00FA},//009C //TVAR_wbt_pBaseCcms[46]
2587 {0x0F12, 0xFF12},//FE3A //TVAR_wbt_pBaseCcms[47]
2588 {0x0F12, 0x0179},//0189 //TVAR_wbt_pBaseCcms[48]
2589 {0x0F12, 0xFF8A},//FF6A //TVAR_wbt_pBaseCcms[49]
2590 {0x0F12, 0x0180},//0298 //TVAR_wbt_pBaseCcms[50]
2591 {0x0F12, 0xFEC2},//FF14 //TVAR_wbt_pBaseCcms[51]
2592 {0x0F12, 0x0176},//01BD //TVAR_wbt_pBaseCcms[52]
2593 {0x0F12, 0x0094},//00FB //TVAR_wbt_pBaseCcms[53]
2595 {0x0F12, 0x01CA},//018A//0262 //TVAR_wbt_pBaseCcms[54]
2596 {0x0F12, 0xFF89},//FFC9//FFAB //TVAR_wbt_pBaseCcms[55]
2597 {0x0F12, 0xFFE0},//0005//FFFB //TVAR_wbt_pBaseCcms[56]
2598 {0x0F12, 0xFF26},//FFC1 //TVAR_wbt_pBaseCcms[57]
2599 {0x0F12, 0x028E},//0292 //TVAR_wbt_pBaseCcms[58]
2600 {0x0F12, 0xFF80},//FF81 //TVAR_wbt_pBaseCcms[59]
2601 {0x0F12, 0x0020},//0069 //TVAR_wbt_pBaseCcms[60]
2602 {0x0F12, 0xFFF8},//0057 //TVAR_wbt_pBaseCcms[61]
2603 {0x0F12, 0x01E0},//0296 //TVAR_wbt_pBaseCcms[62]
2604 {0x0F12, 0x0120},//00FF//015F //TVAR_wbt_pBaseCcms[63]
2605 {0x0F12, 0x00FA},//00E2//0112 //TVAR_wbt_pBaseCcms[64]
2606 {0x0F12, 0xFF12},//FF4D//FF17 //TVAR_wbt_pBaseCcms[65]
2607 {0x0F12, 0x0179},//024E //TVAR_wbt_pBaseCcms[66]
2608 {0x0F12, 0xFF8A},//0001 //TVAR_wbt_pBaseCcms[67]
2609 {0x0F12, 0x0180},//0276 //TVAR_wbt_pBaseCcms[68]
2610 {0x0F12, 0xFEC2},//FEE2 //TVAR_wbt_pBaseCcms[69]
2611 {0x0F12, 0x0176},//0236 //TVAR_wbt_pBaseCcms[70]
2612 {0x0F12, 0x0094},//014A //TVAR_wbt_pBaseCcms[71]
2614 //BEGIN: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2615 //{0x0F12, 0x018A},//01C5 //TVAR_wbt_pBaseCcms[72]
2616 //{0x0F12, 0xFFC9},//FFA8 //TVAR_wbt_pBaseCcms[73]
2617 //{0x0F12, 0x0005},//FFBA //TVAR_wbt_pBaseCcms[74]
2618 {0x0F12, 0x01A9},//01C5 //TVAR_wbt_pBaseCcms[72]
2619 {0x0F12, 0xFFB6},//FFA8 //TVAR_wbt_pBaseCcms[73]
2620 {0x0F12, 0xFFF9},//FFBA //TVAR_wbt_pBaseCcms[74]
2621 //END: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2622 {0x0F12, 0xFF56},//FF06 //TVAR_wbt_pBaseCcms[75]
2623 {0x0F12, 0x0230},//0258 //TVAR_wbt_pBaseCcms[76]
2624 {0x0F12, 0xFFA0},//FF52 //TVAR_wbt_pBaseCcms[77]
2625 //BEGIN: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2626 //{0x0F12, 0x0020},//0036 //TVAR_wbt_pBaseCcms[78]
2627 //{0x0F12, 0xFFF8},//FFFA //TVAR_wbt_pBaseCcms[79]
2628 //{0x0F12, 0x01E0},//01D7 //TVAR_wbt_pBaseCcms[80]
2629 //{0x0F12, 0x00FF},//00DE //TVAR_wbt_pBaseCcms[81]
2630 //{0x0F12, 0x00E2},//013B //TVAR_wbt_pBaseCcms[82]
2631 //{0x0F12, 0xFF4D},//FF30 //TVAR_wbt_pBaseCcms[83]
2632 {0x0F12, 0x000E},//0036 //TVAR_wbt_pBaseCcms[78]
2633 {0x0F12, 0xFFE0},//FFFA //TVAR_wbt_pBaseCcms[79]
2634 {0x0F12, 0x020A},//01D7 //TVAR_wbt_pBaseCcms[80]
2635 {0x0F12, 0x010C},//00DE //TVAR_wbt_pBaseCcms[81]
2636 {0x0F12, 0x00EC},//013B //TVAR_wbt_pBaseCcms[82]
2637 {0x0F12, 0xFF36},//FF30 //TVAR_wbt_pBaseCcms[83]
2638 //END: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2639 {0x0F12, 0x0179},//0168 //TVAR_wbt_pBaseCcms[84]
2640 {0x0F12, 0xFF8A},//FF6F //TVAR_wbt_pBaseCcms[85]
2641 {0x0F12, 0x0180},//0164 //TVAR_wbt_pBaseCcms[86]
2642 {0x0F12, 0xFEC2},//FEDB //TVAR_wbt_pBaseCcms[87]
2643 {0x0F12, 0x0176},//0195 //TVAR_wbt_pBaseCcms[88]
2644 {0x0F12, 0x0094},//00E7 //TVAR_wbt_pBaseCcms[89]
2646 //BEGIN: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2647 //{0x0F12, 0x018A},//019E //TVAR_wbt_pBaseCcms[90]
2648 //{0x0F12, 0xFFC9},//FF8A //TVAR_wbt_pBaseCcms[91]
2649 //{0x0F12, 0x0005},//FFCE //TVAR_wbt_pBaseCcms[92]
2650 {0x0F12, 0x01A9},//019E //TVAR_wbt_pBaseCcms[90]
2651 {0x0F12, 0xFFB6},//FF8A //TVAR_wbt_pBaseCcms[91]
2652 {0x0F12, 0xFFF9},//FFCE //TVAR_wbt_pBaseCcms[92]
2653 //END: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2654 {0x0F12, 0xFF56},//FF06 //TVAR_wbt_pBaseCcms[93]
2655 {0x0F12, 0x0230},//0258 //TVAR_wbt_pBaseCcms[94]
2656 {0x0F12, 0xFFA0},//FF52 //TVAR_wbt_pBaseCcms[95]
2657 //BEGIN: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2658 //{0x0F12, 0x0020},//0036 //TVAR_wbt_pBaseCcms[96]
2659 //{0x0F12, 0xFFF8},//FFFA //TVAR_wbt_pBaseCcms[97]
2660 //{0x0F12, 0x01E0},//01D7 //TVAR_wbt_pBaseCcms[98]
2661 //{0x0F12, 0x00FF},//00DE //TVAR_wbt_pBaseCcms[99]
2662 //{0x0F12, 0x00E2},//013B //TVAR_wbt_pBaseCcms[100]
2663 //{0x0F12, 0xFF4D},//FF30 //TVAR_wbt_pBaseCcms[101]
2664 {0x0F12, 0x000E},//0036 //TVAR_wbt_pBaseCcms[96]
2665 {0x0F12, 0xFFE0},//FFFA //TVAR_wbt_pBaseCcms[97]
2666 {0x0F12, 0x020A},//01D7 //TVAR_wbt_pBaseCcms[98]
2667 {0x0F12, 0x010C},//00DE //TVAR_wbt_pBaseCcms[99]
2668 {0x0F12, 0x00EC},//013B //TVAR_wbt_pBaseCcms[100]
2669 {0x0F12, 0xFF36},//FF30 //TVAR_wbt_pBaseCcms[101]
2670 //END: DTS2012071201781 modify by huyouhua at 2012-7-24 for D65 Sat too small
2671 {0x0F12, 0x0179},//0168 //TVAR_wbt_pBaseCcms[102]
2672 {0x0F12, 0xFF8A},//FF6F //TVAR_wbt_pBaseCcms[103]
2673 {0x0F12, 0x0180},//0164 //TVAR_wbt_pBaseCcms[104]
2674 {0x0F12, 0xFEC2},//FEDB //TVAR_wbt_pBaseCcms[105]
2675 {0x0F12, 0x0176},//0195 //TVAR_wbt_pBaseCcms[106]
2676 {0x0F12, 0x0094},//00E7 //TVAR_wbt_pBaseCcms[107]
2677 // param_end TVAR_wbt_pBaseCcms
2678 // param_start TVAR_wbt_pOutdoorCcm
2680 {0x0F12, 0x018A},//01C7 //TVAR_wbt_pOutdoorCcm[0]
2681 {0x0F12, 0xFFC9},//FFA0 //TVAR_wbt_pOutdoorCcm[1]
2682 {0x0F12, 0x0005},//FFE8 //TVAR_wbt_pOutdoorCcm[2]
2683 {0x0F12, 0xFF26},//FF11 //TVAR_wbt_pOutdoorCcm[3]
2684 {0x0F12, 0x028E},//01F4 //TVAR_wbt_pOutdoorCcm[4]
2685 {0x0F12, 0xFF80},//FF38 //TVAR_wbt_pOutdoorCcm[5]
2686 {0x0F12, 0x0020},//FFDF //TVAR_wbt_pOutdoorCcm[6]
2687 {0x0F12, 0xFFF8},//FFD3 //TVAR_wbt_pOutdoorCcm[7]
2688 {0x0F12, 0x01E0},//01CC //TVAR_wbt_pOutdoorCcm[8]
2689 {0x0F12, 0x00FF},//011D //TVAR_wbt_pOutdoorCcm[9]
2690 {0x0F12, 0x00E2},//0157 //TVAR_wbt_pOutdoorCcm[10]
2691 {0x0F12, 0xFF4D},//FF16 //TVAR_wbt_pOutdoorCcm[11]
2692 {0x0F12, 0x0179},//01DA //TVAR_wbt_pOutdoorCcm[12]
2693 {0x0F12, 0xFF8A},//FF3A //TVAR_wbt_pOutdoorCcm[13]
2694 {0x0F12, 0x0180},//01B6 //TVAR_wbt_pOutdoorCcm[14]
2695 {0x0F12, 0xFEC2},//FF2A //TVAR_wbt_pOutdoorCcm[15]
2696 {0x0F12, 0x0176},//0176 //TVAR_wbt_pOutdoorCcm[16]
2697 {0x0F12, 0x0094},//0114 //TVAR_wbt_pOutdoorCcm[17]
2698 // param_end TVAR_wbt_pOutdoorCcm
2699 //============================================================
2701 //============================================================
2702 // param_start afit_uNoiseIndInDoor
2703 //============================================================
2705 {0x0F12, 0x0041}, //afit_uNoiseIndInDoor[0]
2706 {0x0F12, 0x00A5}, //afit_uNoiseIndInDoor[1]
2707 {0x0F12, 0x016B}, //afit_uNoiseIndInDoor[2]
2708 {0x0F12, 0x0226}, //afit_uNoiseIndInDoor[3]
2709 {0x0F12, 0x02EA}, //afit_uNoiseIndInDoor[4]
2710 // param_end afit_uNoiseIndInDoor
2711 // param_start TVAR_afit_pBaseVals
2713 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[0]
2714 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[1]
2715 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[2]
2716 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[3]
2717 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[4]
2718 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[5]
2719 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[6]
2720 {0x0F12, 0x009C}, //TVAR_afit_pBaseVals[7]
2721 {0x0F12, 0x017C}, //TVAR_afit_pBaseVals[8]
2722 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[9]
2723 {0x0F12, 0x000C}, //TVAR_afit_pBaseVals[10]
2724 {0x0F12, 0x0010}, //TVAR_afit_pBaseVals[11]
2725 {0x0F12, 0x0104}, //TVAR_afit_pBaseVals[12]
2726 {0x0F12, 0x03E8}, //TVAR_afit_pBaseVals[13]
2727 {0x0F12, 0x0023}, //TVAR_afit_pBaseVals[14]
2728 {0x0F12, 0x012C}, //TVAR_afit_pBaseVals[15]
2729 {0x0F12, 0x0070}, //TVAR_afit_pBaseVals[16]
2730 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[17]
2731 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[18]
2732 {0x0F12, 0x01AA}, //TVAR_afit_pBaseVals[19]
2733 {0x0F12, 0x0064}, //TVAR_afit_pBaseVals[20]
2734 {0x0F12, 0x0064}, //TVAR_afit_pBaseVals[21]
2735 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[22]
2736 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[23]
2737 {0x0F12, 0x002A}, //TVAR_afit_pBaseVals[24]
2738 {0x0F12, 0x0024}, //TVAR_afit_pBaseVals[25]
2739 {0x0F12, 0x002A}, //TVAR_afit_pBaseVals[26]
2740 {0x0F12, 0x0024}, //TVAR_afit_pBaseVals[27]
2741 {0x0F12, 0x002A}, //TVAR_afit_pBaseVals[28]
2742 {0x0F12, 0x0024}, //TVAR_afit_pBaseVals[29]
2743 {0x0F12, 0x0A0F}, //TVAR_afit_pBaseVals[30]
2744 {0x0F12, 0x1701}, //TVAR_afit_pBaseVals[31]
2745 {0x0F12, 0x0229}, //TVAR_afit_pBaseVals[32]
2746 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[33]
2747 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[34]
2748 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[35]
2749 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[36]
2750 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[37]
2751 {0x0F12, 0x053B}, //TVAR_afit_pBaseVals[38]
2752 {0x0F12, 0x0505}, //TVAR_afit_pBaseVals[39]
2753 {0x0F12, 0x0301}, //TVAR_afit_pBaseVals[40]
2754 {0x0F12, 0x8007}, //TVAR_afit_pBaseVals[41]
2755 {0x0F12, 0x051E}, //TVAR_afit_pBaseVals[42]
2756 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[43]
2757 {0x0F12, 0x0F0F}, //TVAR_afit_pBaseVals[44]
2758 {0x0F12, 0x0A05}, //TVAR_afit_pBaseVals[45]
2759 {0x0F12, 0x103C}, //TVAR_afit_pBaseVals[46]
2760 {0x0F12, 0x0A28}, //TVAR_afit_pBaseVals[47]
2761 {0x0F12, 0x0002}, //TVAR_afit_pBaseVals[48]
2762 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[49]
2763 {0x0F12, 0x1002}, //TVAR_afit_pBaseVals[50]
2764 {0x0F12, 0x001D}, //TVAR_afit_pBaseVals[51]
2765 {0x0F12, 0x0900}, //TVAR_afit_pBaseVals[52]
2766 {0x0F12, 0x0600}, //TVAR_afit_pBaseVals[53]
2767 {0x0F12, 0x0504}, //TVAR_afit_pBaseVals[54]
2768 {0x0F12, 0x0305}, //TVAR_afit_pBaseVals[55]
2769 {0x0F12, 0x5A03}, //TVAR_afit_pBaseVals[56]
2770 {0x0F12, 0x006E}, //TVAR_afit_pBaseVals[57]
2771 {0x0F12, 0x0A78}, //TVAR_afit_pBaseVals[58]
2772 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[59]
2773 {0x0F12, 0x3232}, //TVAR_afit_pBaseVals[60]
2774 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[61]
2775 {0x0F12, 0x5001}, //TVAR_afit_pBaseVals[62]
2776 {0x0F12, 0x7850}, //TVAR_afit_pBaseVals[63]
2777 {0x0F12, 0x2878}, //TVAR_afit_pBaseVals[64]
2778 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[65]
2779 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[66]
2780 {0x0F12, 0x1E07}, //TVAR_afit_pBaseVals[67]
2781 {0x0F12, 0x070A}, //TVAR_afit_pBaseVals[68]
2782 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[69]
2783 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[70]
2784 {0x0F12, 0x0F40}, //TVAR_afit_pBaseVals[71]
2785 {0x0F12, 0x400F}, //TVAR_afit_pBaseVals[72]
2786 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[73]
2787 {0x0F12, 0x3203}, //TVAR_afit_pBaseVals[74]
2788 {0x0F12, 0x0132}, //TVAR_afit_pBaseVals[75]
2789 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[76]
2790 {0x0F12, 0x5050}, //TVAR_afit_pBaseVals[77]
2791 {0x0F12, 0x7878}, //TVAR_afit_pBaseVals[78]
2792 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[79]
2793 {0x0F12, 0x030A}, //TVAR_afit_pBaseVals[80]
2794 {0x0F12, 0x0714}, //TVAR_afit_pBaseVals[81]
2795 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[82]
2796 {0x0F12, 0xFF07}, //TVAR_afit_pBaseVals[83]
2797 {0x0F12, 0x0432}, //TVAR_afit_pBaseVals[84]
2798 {0x0F12, 0x4050}, //TVAR_afit_pBaseVals[85]
2799 {0x0F12, 0x0F0F}, //TVAR_afit_pBaseVals[86]
2800 {0x0F12, 0x0440}, //TVAR_afit_pBaseVals[87]
2801 {0x0F12, 0x0302}, //TVAR_afit_pBaseVals[88]
2802 {0x0F12, 0x3232}, //TVAR_afit_pBaseVals[89]
2803 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[90]
2804 {0x0F12, 0x5001}, //TVAR_afit_pBaseVals[91]
2805 {0x0F12, 0x7850}, //TVAR_afit_pBaseVals[92]
2806 {0x0F12, 0x2878}, //TVAR_afit_pBaseVals[93]
2807 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[94]
2808 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[95]
2809 {0x0F12, 0x1E07}, //TVAR_afit_pBaseVals[96]
2810 {0x0F12, 0x070A}, //TVAR_afit_pBaseVals[97]
2811 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[98]
2812 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[99]
2813 {0x0F12, 0x0F40}, //TVAR_afit_pBaseVals[100]
2814 {0x0F12, 0x400F}, //TVAR_afit_pBaseVals[101]
2815 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[102]
2816 {0x0F12, 0x0003}, //TVAR_afit_pBaseVals[103]
2817 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[104]
2818 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[105]
2819 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[106]
2820 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[107]
2821 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[108]
2822 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[109]
2823 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[110]
2824 {0x0F12, 0x009C}, //TVAR_afit_pBaseVals[111]
2825 {0x0F12, 0x017C}, //TVAR_afit_pBaseVals[112]
2826 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[113]
2827 {0x0F12, 0x000C}, //TVAR_afit_pBaseVals[114]
2828 {0x0F12, 0x0010}, //TVAR_afit_pBaseVals[115]
2829 {0x0F12, 0x0104}, //TVAR_afit_pBaseVals[116]
2830 {0x0F12, 0x03E8}, //TVAR_afit_pBaseVals[117]
2831 {0x0F12, 0x0023}, //TVAR_afit_pBaseVals[118]
2832 {0x0F12, 0x012C}, //TVAR_afit_pBaseVals[119]
2833 {0x0F12, 0x0070}, //TVAR_afit_pBaseVals[120]
2834 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[121]
2835 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[122]
2836 {0x0F12, 0x01AA}, //TVAR_afit_pBaseVals[123]
2837 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[124]
2838 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[125]
2839 {0x0F12, 0x0005}, //TVAR_afit_pBaseVals[126]
2840 {0x0F12, 0x0005}, //TVAR_afit_pBaseVals[127]
2841 {0x0F12, 0x002A}, //TVAR_afit_pBaseVals[128]
2842 {0x0F12, 0x0024}, //TVAR_afit_pBaseVals[129]
2843 {0x0F12, 0x002A}, //TVAR_afit_pBaseVals[130]
2844 {0x0F12, 0x0024}, //TVAR_afit_pBaseVals[131]
2845 {0x0F12, 0x002A}, //TVAR_afit_pBaseVals[132]
2846 {0x0F12, 0x0024}, //TVAR_afit_pBaseVals[133]
2847 {0x0F12, 0x0A0F}, //TVAR_afit_pBaseVals[134]
2848 {0x0F12, 0x1701}, //TVAR_afit_pBaseVals[135]
2849 {0x0F12, 0x0229}, //TVAR_afit_pBaseVals[136]
2850 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[137]
2851 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[138]
2852 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[139]
2853 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[140]
2854 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[141]
2855 {0x0F12, 0x053B}, //TVAR_afit_pBaseVals[142]
2856 {0x0F12, 0x0505}, //TVAR_afit_pBaseVals[143]
2857 {0x0F12, 0x0301}, //TVAR_afit_pBaseVals[144]
2858 {0x0F12, 0x8007}, //TVAR_afit_pBaseVals[145]
2859 {0x0F12, 0x051E}, //TVAR_afit_pBaseVals[146]
2860 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[147]
2861 {0x0F12, 0x0F0F}, //TVAR_afit_pBaseVals[148]
2862 {0x0F12, 0x0A04}, //TVAR_afit_pBaseVals[149]
2863 {0x0F12, 0x103C}, //TVAR_afit_pBaseVals[150]
2864 {0x0F12, 0x0A28}, //TVAR_afit_pBaseVals[151]
2865 {0x0F12, 0x0002}, //TVAR_afit_pBaseVals[152]
2866 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[153]
2867 {0x0F12, 0x1002}, //TVAR_afit_pBaseVals[154]
2868 {0x0F12, 0x001D}, //TVAR_afit_pBaseVals[155]
2869 {0x0F12, 0x0900}, //TVAR_afit_pBaseVals[156]
2870 {0x0F12, 0x0600}, //TVAR_afit_pBaseVals[157]
2871 {0x0F12, 0x0504}, //TVAR_afit_pBaseVals[158]
2872 {0x0F12, 0x0305}, //TVAR_afit_pBaseVals[159]
2873 {0x0F12, 0x5F03}, //TVAR_afit_pBaseVals[160]
2874 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[161]
2875 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[162]
2876 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[163]
2877 {0x0F12, 0x3232}, //TVAR_afit_pBaseVals[164]
2878 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[165]
2879 {0x0F12, 0x2A01}, //TVAR_afit_pBaseVals[166]
2880 {0x0F12, 0x3232}, //TVAR_afit_pBaseVals[167]
2881 {0x0F12, 0x2830}, //TVAR_afit_pBaseVals[168]
2882 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[169]
2883 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[170]
2884 {0x0F12, 0x1E07}, //TVAR_afit_pBaseVals[171]
2885 {0x0F12, 0x070A}, //TVAR_afit_pBaseVals[172]
2886 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[173]
2887 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[174]
2888 {0x0F12, 0x0F40}, //TVAR_afit_pBaseVals[175]
2889 {0x0F12, 0x400F}, //TVAR_afit_pBaseVals[176]
2890 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[177]
2891 {0x0F12, 0x3203}, //TVAR_afit_pBaseVals[178]
2892 {0x0F12, 0x0132}, //TVAR_afit_pBaseVals[179]
2893 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[180]
2894 {0x0F12, 0x262A}, //TVAR_afit_pBaseVals[181]
2895 {0x0F12, 0x3032}, //TVAR_afit_pBaseVals[182]
2896 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[183]
2897 {0x0F12, 0x030A}, //TVAR_afit_pBaseVals[184]
2898 {0x0F12, 0x0714}, //TVAR_afit_pBaseVals[185]
2899 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[186]
2900 {0x0F12, 0xFF07}, //TVAR_afit_pBaseVals[187]
2901 {0x0F12, 0x0432}, //TVAR_afit_pBaseVals[188]
2902 {0x0F12, 0x4050}, //TVAR_afit_pBaseVals[189]
2903 {0x0F12, 0x0F0F}, //TVAR_afit_pBaseVals[190]
2904 {0x0F12, 0x0440}, //TVAR_afit_pBaseVals[191]
2905 {0x0F12, 0x0302}, //TVAR_afit_pBaseVals[192]
2906 {0x0F12, 0x3232}, //TVAR_afit_pBaseVals[193]
2907 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[194]
2908 {0x0F12, 0x2A01}, //TVAR_afit_pBaseVals[195]
2909 {0x0F12, 0x3226}, //TVAR_afit_pBaseVals[196]
2910 {0x0F12, 0x2830}, //TVAR_afit_pBaseVals[197]
2911 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[198]
2912 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[199]
2913 {0x0F12, 0x1E07}, //TVAR_afit_pBaseVals[200]
2914 {0x0F12, 0x070A}, //TVAR_afit_pBaseVals[201]
2915 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[202]
2916 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[203]
2917 {0x0F12, 0x0F40}, //TVAR_afit_pBaseVals[204]
2918 {0x0F12, 0x400F}, //TVAR_afit_pBaseVals[205]
2919 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[206]
2920 {0x0F12, 0x0003}, //TVAR_afit_pBaseVals[207]
2921 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[208]
2922 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[209]
2923 {0x0F12, 0x000f}, //TVAR_afit_pBaseVals[210]//DTS2012071201781:modify by huyouhua at 2012-7-23
2924 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[211]
2925 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[212]
2926 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[213]
2927 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[214]
2928 {0x0F12, 0x009C}, //TVAR_afit_pBaseVals[215]
2929 {0x0F12, 0x017C}, //TVAR_afit_pBaseVals[216]
2930 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[217]
2931 {0x0F12, 0x000C}, //TVAR_afit_pBaseVals[218]
2932 {0x0F12, 0x0010}, //TVAR_afit_pBaseVals[219]
2933 {0x0F12, 0x012C}, //TVAR_afit_pBaseVals[220]
2934 {0x0F12, 0x03E8}, //TVAR_afit_pBaseVals[221]
2935 {0x0F12, 0x0041}, //TVAR_afit_pBaseVals[222]
2936 {0x0F12, 0x005A}, //TVAR_afit_pBaseVals[223]
2937 {0x0F12, 0x0070}, //TVAR_afit_pBaseVals[224]
2938 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[225]
2939 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[226]
2940 {0x0F12, 0x01AA}, //TVAR_afit_pBaseVals[227]
2941 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[228]
2942 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[229]
2943 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[230]
2944 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[231]
2945 {0x0F12, 0x0032}, //TVAR_afit_pBaseVals[232]
2946 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[233]
2947 {0x0F12, 0x0032}, //TVAR_afit_pBaseVals[234]
2948 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[235]
2949 {0x0F12, 0x0032}, //TVAR_afit_pBaseVals[236]
2950 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[237]
2951 {0x0F12, 0x0A0F}, //TVAR_afit_pBaseVals[238]
2952 {0x0F12, 0x1701}, //TVAR_afit_pBaseVals[239]
2953 {0x0F12, 0x0229}, //TVAR_afit_pBaseVals[240]
2954 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[241]
2955 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[242]
2956 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[243]
2957 {0x0F12, 0x0404}, //TVAR_afit_pBaseVals[244]
2958 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[245]
2959 {0x0F12, 0x043B}, //TVAR_afit_pBaseVals[246]
2960 {0x0F12, 0x0505}, //TVAR_afit_pBaseVals[247]
2961 {0x0F12, 0x0301}, //TVAR_afit_pBaseVals[248]
2962 {0x0F12, 0x8007}, //TVAR_afit_pBaseVals[249]
2963 {0x0F12, 0x051E}, //TVAR_afit_pBaseVals[250]
2964 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[251]
2965 {0x0F12, 0x0F0F}, //TVAR_afit_pBaseVals[252]
2966 {0x0F12, 0x0A03}, //TVAR_afit_pBaseVals[253]
2967 {0x0F12, 0x0A3C}, //TVAR_afit_pBaseVals[254]
2968 {0x0F12, 0x0528}, //TVAR_afit_pBaseVals[255]
2969 {0x0F12, 0x0002}, //TVAR_afit_pBaseVals[256]
2970 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[257]
2971 {0x0F12, 0x1002}, //TVAR_afit_pBaseVals[258]
2972 {0x0F12, 0x001D}, //TVAR_afit_pBaseVals[259]
2973 {0x0F12, 0x0900}, //TVAR_afit_pBaseVals[260]
2974 {0x0F12, 0x0600}, //TVAR_afit_pBaseVals[261]
2975 {0x0F12, 0x0504}, //TVAR_afit_pBaseVals[262]
2976 {0x0F12, 0x0305}, //TVAR_afit_pBaseVals[263]
2977 {0x0F12, 0x6902}, //TVAR_afit_pBaseVals[264]
2978 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[265]
2979 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[266]
2980 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[267]
2981 {0x0F12, 0x2D2D}, //TVAR_afit_pBaseVals[268]
2982 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[269]
2983 {0x0F12, 0x2001}, //TVAR_afit_pBaseVals[270]
2984 {0x0F12, 0x2026}, //TVAR_afit_pBaseVals[271]
2985 {0x0F12, 0x281E}, //TVAR_afit_pBaseVals[272]
2986 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[273]
2987 {0x0F12, 0x0A03}, //TVAR_afit_pBaseVals[274]
2988 {0x0F12, 0x1E0A}, //TVAR_afit_pBaseVals[275]
2989 {0x0F12, 0x070A}, //TVAR_afit_pBaseVals[276]
2990 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[277]
2991 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[278]
2992 {0x0F12, 0x0F40}, //TVAR_afit_pBaseVals[279]
2993 {0x0F12, 0x400F}, //TVAR_afit_pBaseVals[280]
2994 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[281]
2995 {0x0F12, 0x3203}, //TVAR_afit_pBaseVals[282]
2996 {0x0F12, 0x0132}, //TVAR_afit_pBaseVals[283]
2997 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[284]
2998 {0x0F12, 0x1C20}, //TVAR_afit_pBaseVals[285]
2999 {0x0F12, 0x1C1E}, //TVAR_afit_pBaseVals[286]
3000 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[287]
3001 {0x0F12, 0x030A}, //TVAR_afit_pBaseVals[288]
3002 {0x0F12, 0x0A0A}, //TVAR_afit_pBaseVals[289]
3003 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[290]
3004 {0x0F12, 0xFF07}, //TVAR_afit_pBaseVals[291]
3005 {0x0F12, 0x0432}, //TVAR_afit_pBaseVals[292]
3006 {0x0F12, 0x4050}, //TVAR_afit_pBaseVals[293]
3007 {0x0F12, 0x0F0F}, //TVAR_afit_pBaseVals[294]
3008 {0x0F12, 0x0440}, //TVAR_afit_pBaseVals[295]
3009 {0x0F12, 0x0302}, //TVAR_afit_pBaseVals[296]
3010 {0x0F12, 0x3232}, //TVAR_afit_pBaseVals[297]
3011 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[298]
3012 {0x0F12, 0x2001}, //TVAR_afit_pBaseVals[299]
3013 {0x0F12, 0x1E1C}, //TVAR_afit_pBaseVals[300]
3014 {0x0F12, 0x281C}, //TVAR_afit_pBaseVals[301]
3015 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[302]
3016 {0x0F12, 0x0A03}, //TVAR_afit_pBaseVals[303]
3017 {0x0F12, 0x1E0A}, //TVAR_afit_pBaseVals[304]
3018 {0x0F12, 0x070A}, //TVAR_afit_pBaseVals[305]
3019 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[306]
3020 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[307]
3021 {0x0F12, 0x0F40}, //TVAR_afit_pBaseVals[308]
3022 {0x0F12, 0x400F}, //TVAR_afit_pBaseVals[309]
3023 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[310]
3024 {0x0F12, 0x0003}, //TVAR_afit_pBaseVals[311]
3025 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[312]
3026 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[313]
3027 {0x0F12, 0x000f}, //TVAR_afit_pBaseVals[314]//DTS2012071201781:modify by huyouhua at 2012-7-23
3028 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[315]
3029 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[316]
3030 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[317]
3031 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[318]
3032 {0x0F12, 0x009C}, //TVAR_afit_pBaseVals[319]
3033 {0x0F12, 0x017C}, //TVAR_afit_pBaseVals[320]
3034 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[321]
3035 {0x0F12, 0x000C}, //TVAR_afit_pBaseVals[322]
3036 {0x0F12, 0x0010}, //TVAR_afit_pBaseVals[323]
3037 {0x0F12, 0x012C}, //TVAR_afit_pBaseVals[324]
3038 {0x0F12, 0x03E8}, //TVAR_afit_pBaseVals[325]
3039 {0x0F12, 0x0050}, //TVAR_afit_pBaseVals[326]
3040 {0x0F12, 0x00C8}, //TVAR_afit_pBaseVals[327]
3041 {0x0F12, 0x0070}, //TVAR_afit_pBaseVals[328]
3042 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[329]
3043 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[330]
3044 {0x0F12, 0x01AA}, //TVAR_afit_pBaseVals[331]
3045 {0x0F12, 0x0014}, //TVAR_afit_pBaseVals[332]
3046 {0x0F12, 0x0014}, //TVAR_afit_pBaseVals[333]
3047 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[334]
3048 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[335]
3049 {0x0F12, 0x0032}, //TVAR_afit_pBaseVals[336]
3050 {0x0F12, 0x0023}, //TVAR_afit_pBaseVals[337]
3051 {0x0F12, 0x0032}, //TVAR_afit_pBaseVals[338]
3052 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[339]
3053 {0x0F12, 0x0032}, //TVAR_afit_pBaseVals[340]
3054 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[341]
3055 {0x0F12, 0x0A0F}, //TVAR_afit_pBaseVals[342]
3056 {0x0F12, 0x1701}, //TVAR_afit_pBaseVals[343]
3057 {0x0F12, 0x0229}, //TVAR_afit_pBaseVals[344]
3058 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[345]
3059 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[346]
3060 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[347]
3061 {0x0F12, 0x0404}, //TVAR_afit_pBaseVals[348]
3062 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[349]
3063 {0x0F12, 0x033B}, //TVAR_afit_pBaseVals[350]
3064 {0x0F12, 0x0505}, //TVAR_afit_pBaseVals[351]
3065 {0x0F12, 0x0301}, //TVAR_afit_pBaseVals[352]
3066 {0x0F12, 0x8007}, //TVAR_afit_pBaseVals[353]
3067 {0x0F12, 0x051E}, //TVAR_afit_pBaseVals[354]
3068 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[355]
3069 {0x0F12, 0x0F0F}, //TVAR_afit_pBaseVals[356]
3070 {0x0F12, 0x0A03}, //TVAR_afit_pBaseVals[357]
3071 {0x0F12, 0x0A3C}, //TVAR_afit_pBaseVals[358]
3072 {0x0F12, 0x0828}, //TVAR_afit_pBaseVals[359]
3073 {0x0F12, 0x0002}, //TVAR_afit_pBaseVals[360]
3074 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[361]
3075 {0x0F12, 0x1002}, //TVAR_afit_pBaseVals[362]
3076 {0x0F12, 0x001D}, //TVAR_afit_pBaseVals[363]
3077 {0x0F12, 0x0900}, //TVAR_afit_pBaseVals[364]
3078 {0x0F12, 0x0600}, //TVAR_afit_pBaseVals[365]
3079 {0x0F12, 0x0504}, //TVAR_afit_pBaseVals[366]
3080 {0x0F12, 0x0305}, //TVAR_afit_pBaseVals[367]
3081 {0x0F12, 0x6F02}, //TVAR_afit_pBaseVals[368]
3082 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[369]
3083 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[370]
3084 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[371]
3085 {0x0F12, 0x323C}, //TVAR_afit_pBaseVals[372]
3086 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[373]
3087 {0x0F12, 0x1A01}, //TVAR_afit_pBaseVals[374]
3088 {0x0F12, 0x1A1E}, //TVAR_afit_pBaseVals[375]
3089 {0x0F12, 0x2818}, //TVAR_afit_pBaseVals[376]
3090 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[377]
3091 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[378]
3092 {0x0F12, 0x1905}, //TVAR_afit_pBaseVals[379]
3093 {0x0F12, 0x060E}, //TVAR_afit_pBaseVals[380]
3094 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[381]
3095 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[382]
3096 {0x0F12, 0x1440}, //TVAR_afit_pBaseVals[383]
3097 {0x0F12, 0x4015}, //TVAR_afit_pBaseVals[384]
3098 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[385]
3099 {0x0F12, 0x3C03}, //TVAR_afit_pBaseVals[386]
3100 {0x0F12, 0x013C}, //TVAR_afit_pBaseVals[387]
3101 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[388]
3102 {0x0F12, 0x141A}, //TVAR_afit_pBaseVals[389]
3103 {0x0F12, 0x181A}, //TVAR_afit_pBaseVals[390]
3104 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[391]
3105 {0x0F12, 0x030A}, //TVAR_afit_pBaseVals[392]
3106 {0x0F12, 0x0614}, //TVAR_afit_pBaseVals[393]
3107 {0x0F12, 0x0A19}, //TVAR_afit_pBaseVals[394]
3108 {0x0F12, 0xFF06}, //TVAR_afit_pBaseVals[395]
3109 {0x0F12, 0x0432}, //TVAR_afit_pBaseVals[396]
3110 {0x0F12, 0x4050}, //TVAR_afit_pBaseVals[397]
3111 {0x0F12, 0x1514}, //TVAR_afit_pBaseVals[398]
3112 {0x0F12, 0x0440}, //TVAR_afit_pBaseVals[399]
3113 {0x0F12, 0x0302}, //TVAR_afit_pBaseVals[400]
3114 {0x0F12, 0x3C3C}, //TVAR_afit_pBaseVals[401]
3115 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[402]
3116 {0x0F12, 0x1A01}, //TVAR_afit_pBaseVals[403]
3117 {0x0F12, 0x1A14}, //TVAR_afit_pBaseVals[404]
3118 {0x0F12, 0x2818}, //TVAR_afit_pBaseVals[405]
3119 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[406]
3120 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[407]
3121 {0x0F12, 0x1906}, //TVAR_afit_pBaseVals[408]
3122 {0x0F12, 0x060A}, //TVAR_afit_pBaseVals[409]
3123 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[410]
3124 {0x0F12, 0x5004}, //TVAR_afit_pBaseVals[411]
3125 {0x0F12, 0x1440}, //TVAR_afit_pBaseVals[412]
3126 {0x0F12, 0x4015}, //TVAR_afit_pBaseVals[413]
3127 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[414]
3128 {0x0F12, 0x0003}, //TVAR_afit_pBaseVals[415]
3129 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[416]
3130 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[417]
3131 {0x0F12, 0x000f}, //TVAR_afit_pBaseVals[418]//DTS2012071201781:modify by huyouhua at 2012-7-23
3132 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[419]
3133 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[420]
3134 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[421]
3135 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[422]
3136 {0x0F12, 0x009C}, //TVAR_afit_pBaseVals[423]
3137 {0x0F12, 0x017C}, //TVAR_afit_pBaseVals[424]
3138 {0x0F12, 0x03FF}, //TVAR_afit_pBaseVals[425]
3139 {0x0F12, 0x000C}, //TVAR_afit_pBaseVals[426]
3140 {0x0F12, 0x0010}, //TVAR_afit_pBaseVals[427]
3141 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[428]
3142 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[429]
3143 {0x0F12, 0x0046}, //TVAR_afit_pBaseVals[430]
3144 {0x0F12, 0x0050}, //TVAR_afit_pBaseVals[431]
3145 {0x0F12, 0x0070}, //TVAR_afit_pBaseVals[432]
3146 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[433]
3147 {0x0F12, 0x0004}, //TVAR_afit_pBaseVals[434]
3148 {0x0F12, 0x01AA}, //TVAR_afit_pBaseVals[435]
3149 {0x0F12, 0x0014}, //TVAR_afit_pBaseVals[436]
3150 {0x0F12, 0x0014}, //TVAR_afit_pBaseVals[437]
3151 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[438]
3152 {0x0F12, 0x000A}, //TVAR_afit_pBaseVals[439]
3153 {0x0F12, 0x002D}, //TVAR_afit_pBaseVals[440]
3154 {0x0F12, 0x0019}, //TVAR_afit_pBaseVals[441]
3155 {0x0F12, 0x0023}, //TVAR_afit_pBaseVals[442]
3156 {0x0F12, 0x0023}, //TVAR_afit_pBaseVals[443]
3157 {0x0F12, 0x0023}, //TVAR_afit_pBaseVals[444]
3158 {0x0F12, 0x0023}, //TVAR_afit_pBaseVals[445]
3159 {0x0F12, 0x0A0F}, //TVAR_afit_pBaseVals[446]
3160 {0x0F12, 0x1701}, //TVAR_afit_pBaseVals[447]
3161 {0x0F12, 0x0229}, //TVAR_afit_pBaseVals[448]
3162 {0x0F12, 0x1403}, //TVAR_afit_pBaseVals[449]
3163 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[450]
3164 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[451]
3165 {0x0F12, 0x0606}, //TVAR_afit_pBaseVals[452]
3166 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[453]
3167 {0x0F12, 0x033B}, //TVAR_afit_pBaseVals[454]
3168 {0x0F12, 0x0505}, //TVAR_afit_pBaseVals[455]
3169 {0x0F12, 0x0301}, //TVAR_afit_pBaseVals[456]
3170 {0x0F12, 0x8007}, //TVAR_afit_pBaseVals[457]
3171 {0x0F12, 0x051E}, //TVAR_afit_pBaseVals[458]
3172 {0x0F12, 0x0A1E}, //TVAR_afit_pBaseVals[459]
3173 {0x0F12, 0x0000}, //TVAR_afit_pBaseVals[460]
3174 {0x0F12, 0x0A03}, //TVAR_afit_pBaseVals[461]
3175 {0x0F12, 0x1E3C}, //TVAR_afit_pBaseVals[462]
3176 {0x0F12, 0x1028}, //TVAR_afit_pBaseVals[463]
3177 {0x0F12, 0x0002}, //TVAR_afit_pBaseVals[464]
3178 {0x0F12, 0x00FF}, //TVAR_afit_pBaseVals[465]
3179 {0x0F12, 0x1002}, //TVAR_afit_pBaseVals[466]
3180 {0x0F12, 0x001E}, //TVAR_afit_pBaseVals[467]
3181 {0x0F12, 0x0900}, //TVAR_afit_pBaseVals[468]
3182 {0x0F12, 0x0600}, //TVAR_afit_pBaseVals[469]
3183 {0x0F12, 0x0504}, //TVAR_afit_pBaseVals[470]
3184 {0x0F12, 0x0305}, //TVAR_afit_pBaseVals[471]
3185 {0x0F12, 0x8002}, //TVAR_afit_pBaseVals[472]
3186 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[473]
3187 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[474]
3188 {0x0F12, 0x0080}, //TVAR_afit_pBaseVals[475]
3189 {0x0F12, 0x4646}, //TVAR_afit_pBaseVals[476]
3190 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[477]
3191 {0x0F12, 0x1801}, //TVAR_afit_pBaseVals[478]
3192 {0x0F12, 0x141C}, //TVAR_afit_pBaseVals[479]
3193 {0x0F12, 0x2812}, //TVAR_afit_pBaseVals[480]
3194 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[481]
3195 {0x0F12, 0x1003}, //TVAR_afit_pBaseVals[482]
3196 {0x0F12, 0x1405}, //TVAR_afit_pBaseVals[483]
3197 {0x0F12, 0x050C}, //TVAR_afit_pBaseVals[484]
3198 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[485]
3199 {0x0F12, 0x5204}, //TVAR_afit_pBaseVals[486]
3200 {0x0F12, 0x1440}, //TVAR_afit_pBaseVals[487]
3201 {0x0F12, 0x4015}, //TVAR_afit_pBaseVals[488]
3202 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[489]
3203 {0x0F12, 0x5003}, //TVAR_afit_pBaseVals[490]
3204 {0x0F12, 0x0150}, //TVAR_afit_pBaseVals[491]
3205 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[492]
3206 {0x0F12, 0x1418}, //TVAR_afit_pBaseVals[493]
3207 {0x0F12, 0x1214}, //TVAR_afit_pBaseVals[494]
3208 {0x0F12, 0x0028}, //TVAR_afit_pBaseVals[495]
3209 {0x0F12, 0x030A}, //TVAR_afit_pBaseVals[496]
3210 {0x0F12, 0x0A10}, //TVAR_afit_pBaseVals[497]
3211 {0x0F12, 0x0819}, //TVAR_afit_pBaseVals[498]
3212 {0x0F12, 0xFF05}, //TVAR_afit_pBaseVals[499]
3213 {0x0F12, 0x0432}, //TVAR_afit_pBaseVals[500]
3214 {0x0F12, 0x4052}, //TVAR_afit_pBaseVals[501]
3215 {0x0F12, 0x1514}, //TVAR_afit_pBaseVals[502]
3216 {0x0F12, 0x0440}, //TVAR_afit_pBaseVals[503]
3217 {0x0F12, 0x0302}, //TVAR_afit_pBaseVals[504]
3218 {0x0F12, 0x5050}, //TVAR_afit_pBaseVals[505]
3219 {0x0F12, 0x0101}, //TVAR_afit_pBaseVals[506]
3220 {0x0F12, 0x1801}, //TVAR_afit_pBaseVals[507]
3221 {0x0F12, 0x1414}, //TVAR_afit_pBaseVals[508]
3222 {0x0F12, 0x2812}, //TVAR_afit_pBaseVals[509]
3223 {0x0F12, 0x0A00}, //TVAR_afit_pBaseVals[510]
3224 {0x0F12, 0x1003}, //TVAR_afit_pBaseVals[511]
3225 {0x0F12, 0x190A}, //TVAR_afit_pBaseVals[512]
3226 {0x0F12, 0x0508}, //TVAR_afit_pBaseVals[513]
3227 {0x0F12, 0x32FF}, //TVAR_afit_pBaseVals[514]
3228 {0x0F12, 0x5204}, //TVAR_afit_pBaseVals[515]
3229 {0x0F12, 0x1440}, //TVAR_afit_pBaseVals[516]
3230 {0x0F12, 0x4015}, //TVAR_afit_pBaseVals[517]
3231 {0x0F12, 0x0204}, //TVAR_afit_pBaseVals[518]
3232 {0x0F12, 0x0003}, //TVAR_afit_pBaseVals[519]
3233 // param_end TVAR_afit_pBaseVals
3234 // param_start afit_pConstBaseVals
3236 {0x0F12, 0x7F7A}, //afit_pConstBaseVals[0]
3237 {0x0F12, 0x779D}, //afit_pConstBaseVals[1]
3238 {0x0F12, 0xBE7E}, //afit_pConstBaseVals[2]
3239 {0x0F12, 0xF7BC}, //afit_pConstBaseVals[3]
3240 {0x0F12, 0x7E06}, //afit_pConstBaseVals[4]
3241 {0x0F12, 0x0053}, //afit_pConstBaseVals[5]
3242 // param_end afit_pConstBaseVals
3244 // Fill RAM with alternative op-codes
3245 {0x0028, 0x7000}, // start add MSW
3246 {0x002A, 0x2CE8}, // start add LSW
3247 {0x0F12, 0x0007}, // Modify LSB to control AWBB_YThreshLow
3248 {0x0F12, 0x00e2}, //
3249 {0x0F12, 0x0005}, // Modify LSB to control AWBB_YThreshLowBrLow
3250 {0x0F12, 0x00E2}, //
3251 //////////////////////////////////////////////////////////////////////////
3252 //============================================================
3254 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3256 //================================================================================================
3258 //================================================================================================
3261 //hex(CLK you want) * 1000)
3263 //hex((CLK you want) * 1000 / 4)
3265 //hex((CLK you want) * 1000 / 4)
3266 //================================================================================================
3267 //Set input CLK //24MHz
3269 {0x0F12, 0x5DC0}, //5FB4 //5DC0=24MCLK #REG_TC_IPRM_InClockLSBs
3270 {0x0F12, 0x0000}, //#REG_TC_IPRM_InClockMSBs
3272 {0x0F12, 0x0002}, //#REG_TC_IPRM_UseNPviClocks //Number of PLL setting
3273 //Set system CLK //40MHz
3275 {0x0F12, 0x38a4 }, //2904 //2BF2 //#REG_TC_IPRM_OpClk4KHz_0
3276 {0x0F12, 0x37A4}, //3A88 //#REG_TC_IPRM_MinOutRate4KHz_0
3277 {0x0F12, 0x39A4}, //3AA8 //#REG_TC_IPRM_MaxOutRate4KHz_0
3278 {0x0F12, 0x38A4}, //2904 //2BF2 //#REG_TC_IPRM_OpClk4KHz_1
3279 //Set pixel CLK //60MHz (0x3A98)
3280 {0x0F12, 0x2EA0}, //#REG_TC_IPRM_MinOutRate4KHz_1
3281 {0x0F12, 0x2EE0}, //#REG_TC_IPRM_MaxOutRate4KHz_1
3284 {0x0F12, 0x0001}, //#REG_TC_IPRM_InitParamsUpdated
3286 {SEQUENCE_WAIT_MS,100},//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3287 //================================================================================================
3288 //SET PREVIEW CONFIGURATION_0
3292 //================================================================================================
3294 {0x0F12, 0x0280}, //0400 //#REG_0TC_PCFG_usWidth//1024
3295 {0x0F12, 0x01E0}, //0300 //#REG_0TC_PCFG_usHeight //768 026E
3296 {0x0F12, 0x0005}, //#REG_0TC_PCFG_Format 0270
3297 {0x0F12, 0x39a4}, //3AA8 //#REG_0TC_PCFG_usMaxOut4KHzRate 0272
3298 {0x0F12, 0x37a4}, //3A88 //#REG_0TC_PCFG_usMinOut4KHzRate 0274
3299 {0x0F12, 0x0100}, //#REG_0TC_PCFG_OutClkPerPix88 0276
3300 {0x0F12, 0x0800}, //#REG_0TC_PCFG_uMaxBpp88 027
3301 {0x0F12, 0x0052}, //#REG_0TC_PCFG_PVIMask //s0050 = FALSE in MSM6290 : s0052 = TRUE in MSM6800 //reg 027A
3302 {0x0F12, 0x4000}, //#REG_0TC_PCFG_OIFMask
3303 {0x0F12, 0x0400}, //0x01E0},//#REG_0TC_PCFG_usJpegPacketSize //DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3304 {0x0F12, 0x0000}, //#REG_0TC_PCFG_usJpegTotalPackets
3305 {0x0F12, 0x0000}, //#REG_0TC_PCFG_uClockInd
3306 {0x0F12, 0x0000}, //#REG_0TC_PCFG_usFrTimeType
3307 {0x0F12, 0x0001}, //#REG_0TC_PCFG_FrRateQualityType
3308 {0x0F12, 0x0190}, //03E8 #REG_0TC_PCFG_usMaxFrTimeMsecMult10 min 25fps
3309 {0x0F12, 0x0190}, //029a #REG_0TC_PCFG_usMinFrTimeMsecMult10 max 25fps
3310 {0x0F12, 0x0000}, //#REG_0TC_PCFG_bSmearOutput
3311 {0x0F12, 0x0000}, //#REG_0TC_PCFG_sSaturation
3312 {0x0F12, 0x0000}, //#REG_0TC_PCFG_sSharpBlur
3313 {0x0F12, 0x0000}, //#REG_0TC_PCFG_sColorTemp
3314 {0x0F12, 0x0000}, //#REG_0TC_PCFG_uDeviceGammaIndex
3315 {0x0F12, 0x0003}, //#REG_0TC_PCFG_uPrevMirror
3316 {0x0F12, 0x0003}, //#REG_0TC_PCFG_uCaptureMirror
3317 {0x0F12, 0x0000}, //#REG_0TC_PCFG_uRotation
3318 //================================================================================================
3319 //SET PREVIEW CONFIGURATION_1
3323 //================================================================================================
3325 {0x0F12, 0x0500}, //0400 //#REG_0TC_PCFG_usWidth//1024
3326 {0x0F12, 0x02D0}, //0300 //#REG_0TC_PCFG_usHeight //768 026E
3327 {0x0F12, 0x0005}, //#REG_0TC_PCFG_Format 0270
3328 {0x0F12, 0x2ee0}, //3AA8 //#REG_0TC_PCFG_usMaxOut4KHzRate 0272
3329 {0x0F12, 0x2ea0}, //3A88 //#REG_0TC_PCFG_usMinOut4KHzRate 0274
3330 {0x0F12, 0x0100}, //#REG_0TC_PCFG_OutClkPerPix88 0276
3331 {0x0F12, 0x0800}, //#REG_0TC_PCFG_uMaxBpp88 027
3332 {0x0F12, 0x0052}, //#REG_0TC_PCFG_PVIMask //s0050 = FALSE in MSM6290 : s0052 = TRUE in MSM6800 //reg 027A
3333 {0x0F12, 0x4000}, //#REG_0TC_PCFG_OIFMask
3334 {0x0F12, 0x0400}, //0x01E0}, //#REG_0TC_PCFG_usJpegPacketSize//DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3335 {0x0F12, 0x0000}, //#REG_0TC_PCFG_usJpegTotalPackets
3336 {0x0F12, 0x0001}, //#REG_0TC_PCFG_uClockInd
3337 {0x0F12, 0x0000}, //#REG_0TC_PCFG_usFrTimeType
3338 {0x0F12, 0x0002}, //1 //#REG_0TC_PCFG_FrRateQualityType
3339 {0x0F12, 0x029a}, //03E8 #REG_0TC_PCFG_usMaxFrTimeMsecMult10 //15fps
3340 {0x0F12, 0x029a}, //029a #REG_0TC_PCFG_usMinFrTimeMsecMult10 //15fps
3341 {0x0F12, 0x0000}, //#REG_0TC_PCFG_bSmearOutput
3342 {0x0F12, 0x0000}, //#REG_0TC_PCFG_sSaturation
3343 {0x0F12, 0x0000}, //#REG_0TC_PCFG_sSharpBlur
3344 {0x0F12, 0x0000}, //#REG_0TC_PCFG_sColorTemp
3345 {0x0F12, 0x0000}, //#REG_0TC_PCFG_uDeviceGammaIndex
3346 {0x0F12, 0x0003}, //#REG_0TC_PCFG_uPrevMirror
3347 {0x0F12, 0x0003}, //#REG_0TC_PCFG_uCaptureMirror
3348 {0x0F12, 0x0000}, //#REG_0TC_PCFG_uRotation
3349 //================================================================================================
3350 //APPLY PREVIEW CONFIGURATION & RUN PREVIEW
3351 //================================================================================================
3353 {0x0F12, 0x0000}, //#REG_TC_GP_ActivePrevConfig //Select preview configuration_0
3355 {0x0F12, 0x0001}, //#REG_TC_GP_PrevOpenAfterChange
3357 {0x0F12, 0x0001}, //#REG_TC_GP_NewConfigSync //Update preview configuration
3359 {0x0F12, 0x0001}, //#REG_TC_GP_PrevConfigChanged
3361 {0x0F12, 0x0001}, //#REG_TC_GP_EnablePreview //Start preview
3362 {0x0F12, 0x0001}, //#REG_TC_GP_EnablePreviewChanged
3363 //================================================================================================
3364 //SET CAPTURE CONFIGURATION_0
3367 //# FPS : 5 ~ 7.5fps
3368 //================================================================================================
3370 {0x0F12, 0x0000}, //#REG_0TC_CCFG_uCaptureModeJpEG
3371 {0x0F12, 0x0800}, //#REG_0TC_CCFG_usWidth
3372 {0x0F12, 0x0600}, //#REG_0TC_CCFG_usHeight
3373 {0x0F12, 0x0005}, //#REG_0TC_CCFG_Format//5:YUV9:JPEG
3374 //{0x0F12, 0x39ae}, //3AA8 //#REG_0TC_CCFG_usMaxOut4KHzRate
3375 {0x0F12, 0x39a4}, //#REG_0TC_CCFG_usMaxOut4KHzRate//DTS2012071201781:modify by huyouhua at 2012-7-23
3376 {0x0F12, 0x37a4}, //3A88 //#REG_0TC_CCFG_usMinOut4KHzRate
3377 {0x0F12, 0x0100}, //#REG_0TC_CCFG_OutClkPerPix88
3378 {0x0F12, 0x0800}, //#REG_0TC_CCFG_uMaxBpp88
3379 {0x0F12, 0x0052}, //#REG_0TC_CCFG_PVIMask
3380 {0x0F12, 0x0050}, //#REG_0TC_CCFG_OIFMask edison
3381 //BEGIN: DTS2012071201781 modify by huyouhua at 2012-7-23
3382 //{0x0F12, 0x01E0}, //#REG_0TC_CCFG_usJpegPacketSize
3383 //{0x0F12, 0x08fc}, //#REG_0TC_CCFG_usJpegTotalPackets
3384 {0x0F12, 0x03C0}, //#REG_0TC_CCFG_usJpegPacketSize
3385 //END: DTS2012071201781 modify by huyouhua at 2012-7-23
3386 {0x0F12, 0x0000}, //#REG_0TC_CCFG_uClockInd
3387 {0x0F12, 0x0000}, //#REG_0TC_CCFG_usFrTimeType
3388 {0x0F12, 0x0000}, //#REG_0TC_CCFG_FrRateQualityType
3389 {0x0F12, 0x0002}, //#REG_0TC_CCFG_FrRateQualityType//DTS2012071201781:add by huyouhua at 2012-7-23
3390 {0x0F12, 0x07D0}, //#REG_0TC_CCFG_usMaxFrTimeMsecMult10 //5fps
3391 {0x0F12, 0x0535}, //#REG_0TC_CCFG_usMinFrTimeMsecMult10 //7.5fps
3392 {0x0F12, 0x0000}, //#REG_0TC_CCFG_bSmearOutput
3393 {0x0F12, 0x0000}, //#REG_0TC_CCFG_sSaturation
3394 {0x0F12, 0x0000}, //#REG_0TC_CCFG_sSharpBlur
3395 {0x0F12, 0x0000}, //#REG_0TC_CCFG_sColorTemp
3396 {0x0F12, 0x0000}, //#REG_0TC_CCFG_uDeviceGammaIndex
3397 //================================================================================================
3398 //SET CAPTURE CONFIGURATION_1
3402 //================================================================================================
3408 {SEQUENCE_WAIT_MS,50},
3409 {SEQUENCE_END, 0x00}
3412 static struct reginfo sensor_720p[]=
3435 {SEQUENCE_END, 0x00}
3438 static struct reginfo sensor_1080p[]=
3440 {SEQUENCE_END, 0x00}
3443 /* 2592X1944 QSXGA */
3444 static struct reginfo sensor_qsxga[] =
3446 {SEQUENCE_END, 0x00}
3448 /* 2048*1536 QXGA */
3449 static struct reginfo sensor_qxga[] =
3452 {0x002a ,0x0244},//#REG_TC_GP_ActiveCapConfig num
3454 {0x0f12 ,0x0001},//#REG_TC_GP_CapConfigChanged
3456 {0x0f12 ,0x0001},//#REG_TC_GP_NewConfigSync
3458 {0x0f12 ,0x0001},//#REG_TC_GP_EnableCapture
3459 {0x0f12 ,0x0001},//#REG_TC_GP_EnableCaptureChanged
3460 {SEQUENCE_END, 0x00}
3463 /* 1600X1200 UXGA */
3464 static struct reginfo sensor_uxga[] =
3466 {SEQUENCE_END, 0x00}
3469 /* 1280X1024 SXGA */
3470 static struct reginfo sensor_sxga[] =
3472 {SEQUENCE_END, 0x00}
3475 static struct reginfo sensor_xga[] =
3477 {SEQUENCE_END, 0x00}
3480 static struct reginfo sensor_svga[] =
3482 {SEQUENCE_END, 0x0},
3486 static struct reginfo sensor_vga[] =
3509 {SEQUENCE_END, 0x0},
3512 static struct reginfo sensor_cif[] =
3514 {SEQUENCE_END, 0x0},
3518 static struct reginfo sensor_qvga[] =
3520 {SEQUENCE_END, 0x0},
3524 static struct reginfo sensor_qcif[] =
3526 {SEQUENCE_END, 0x0},
3529 static struct reginfo sensor_ClrFmt_YUYV[]=
3531 {SEQUENCE_END, 0x00}
3534 static struct reginfo sensor_ClrFmt_UYVY[]=
3536 {SEQUENCE_END, 0x00}
3539 #if CONFIG_SENSOR_WhiteBalance
3540 static struct reginfo sensor_WhiteB_Auto[]=
3544 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3547 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3548 {SEQUENCE_END, 0x00}
3552 static struct reginfo sensor_WhiteB_TungstenLamp1[]=
3556 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3559 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3568 {SEQUENCE_END, 0x00}
3572 static struct reginfo sensor_WhiteB_TungstenLamp2[]=
3585 {SEQUENCE_END, 0x00}
3589 static struct reginfo sensor_WhiteB_ClearDay[]=
3593 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3596 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3605 {SEQUENCE_END, 0x00}
3609 static struct reginfo sensor_WhiteB_Cloudy[]=
3613 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3616 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3625 {SEQUENCE_END, 0x00}
3628 static struct reginfo *sensor_WhiteBalanceSeqe[] = {sensor_WhiteB_Auto, sensor_WhiteB_TungstenLamp1,sensor_WhiteB_TungstenLamp2,
3629 sensor_WhiteB_ClearDay, sensor_WhiteB_Cloudy, NULL,};
3632 #if CONFIG_SENSOR_Brightness
3633 static struct reginfo sensor_Brightness0[]=
3635 {SEQUENCE_END, 0x00}
3638 static struct reginfo sensor_Brightness1[]=
3640 {SEQUENCE_END, 0x00}
3643 static struct reginfo sensor_Brightness2[]=
3645 {SEQUENCE_END, 0x00}
3648 static struct reginfo sensor_Brightness3[]=
3650 {SEQUENCE_END, 0x00}
3653 static struct reginfo sensor_Brightness4[]=
3655 {SEQUENCE_END, 0x00}
3658 static struct reginfo sensor_Brightness5[]=
3660 {SEQUENCE_END, 0x00}
3662 static struct reginfo *sensor_BrightnessSeqe[] = {sensor_Brightness0, sensor_Brightness1, sensor_Brightness2, sensor_Brightness3,
3663 sensor_Brightness4, sensor_Brightness5,NULL,
3668 #if CONFIG_SENSOR_Effect
3669 static struct reginfo sensor_Effect_Normal[] =
3674 {SEQUENCE_END, 0x00}
3677 static struct reginfo sensor_Effect_WandB[] =
3682 {SEQUENCE_END, 0x00}
3685 static struct reginfo sensor_Effect_Sepia[] =
3690 {SEQUENCE_END, 0x00}
3693 static struct reginfo sensor_Effect_Negative[] =
3697 //BEGIN: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3700 //END: DTS2012071201781: modify by huyouhua 00136760 at 2012-7-20
3701 {SEQUENCE_END, 0x00}
3704 static struct reginfo sensor_Effect_Bluish[] =
3709 {SEQUENCE_END, 0x00}
3712 static struct reginfo sensor_Effect_Green[] =
3717 {SEQUENCE_END, 0x00}
3720 static struct reginfo *sensor_EffectSeqe[] = {sensor_Effect_Normal, sensor_Effect_WandB, sensor_Effect_Negative,sensor_Effect_Sepia,
3721 sensor_Effect_Bluish, sensor_Effect_Green,NULL,
3725 #if CONFIG_SENSOR_Exposure
3726 static struct reginfo sensor_Exposure0[]=
3728 {SEQUENCE_END, 0x00}
3731 static struct reginfo sensor_Exposure1[]=
3733 {SEQUENCE_END, 0x00}
3736 static struct reginfo sensor_Exposure2[]=
3738 {SEQUENCE_END, 0x00}
3741 static struct reginfo sensor_Exposure3[]=
3743 {SEQUENCE_END, 0x00}
3746 static struct reginfo sensor_Exposure4[]=
3748 {SEQUENCE_END, 0x00}
3751 static struct reginfo sensor_Exposure5[]=
3753 {SEQUENCE_END, 0x00}
3756 static struct reginfo sensor_Exposure6[]=
3758 {SEQUENCE_END, 0x00}
3761 static struct reginfo *sensor_ExposureSeqe[] = {sensor_Exposure0, sensor_Exposure1, sensor_Exposure2, sensor_Exposure3,
3762 sensor_Exposure4, sensor_Exposure5,sensor_Exposure6,NULL,
3765 #if CONFIG_SENSOR_Saturation
3766 static struct reginfo sensor_Saturation0[]=
3768 {SEQUENCE_END, 0x00}
3771 static struct reginfo sensor_Saturation1[]=
3773 {SEQUENCE_END, 0x00}
3776 static struct reginfo sensor_Saturation2[]=
3778 {SEQUENCE_END, 0x00}
3780 static struct reginfo *sensor_SaturationSeqe[] = {sensor_Saturation0, sensor_Saturation1, sensor_Saturation2, NULL,};
3783 #if CONFIG_SENSOR_Contrast
3784 static struct reginfo sensor_Contrast0[]=
3786 {SEQUENCE_END, 0x00}
3789 static struct reginfo sensor_Contrast1[]=
3791 {SEQUENCE_END, 0x00}
3794 static struct reginfo sensor_Contrast2[]=
3796 {SEQUENCE_END, 0x00}
3799 static struct reginfo sensor_Contrast3[]=
3801 {SEQUENCE_END, 0x00}
3804 static struct reginfo sensor_Contrast4[]=
3806 {SEQUENCE_END, 0x00}
3810 static struct reginfo sensor_Contrast5[]=
3812 {SEQUENCE_END, 0x00}
3815 static struct reginfo sensor_Contrast6[]=
3817 {SEQUENCE_END, 0x00}
3819 static struct reginfo *sensor_ContrastSeqe[] = {sensor_Contrast0, sensor_Contrast1, sensor_Contrast2, sensor_Contrast3,
3820 sensor_Contrast4, sensor_Contrast5, sensor_Contrast6, NULL,
3824 #if CONFIG_SENSOR_Mirror
3825 static struct reginfo sensor_MirrorOn[]=
3827 {SEQUENCE_END, 0x00}
3830 static struct reginfo sensor_MirrorOff[]=
3832 {SEQUENCE_END, 0x00}
3834 static struct reginfo *sensor_MirrorSeqe[] = {sensor_MirrorOff, sensor_MirrorOn,NULL,};
3836 #if CONFIG_SENSOR_Flip
3837 static struct reginfo sensor_FlipOn[]=
3839 {SEQUENCE_END, 0x00}
3842 static struct reginfo sensor_FlipOff[]=
3844 {SEQUENCE_END, 0x00}
3846 static struct reginfo *sensor_FlipSeqe[] = {sensor_FlipOff, sensor_FlipOn,NULL,};
3850 #if CONFIG_SENSOR_Scene
3851 static struct reginfo sensor_SceneNormal[] =
3860 {SEQUENCE_WAIT_MS,50},
3874 {SEQUENCE_END, 0x00}
3877 static struct reginfo sensor_SceneNight[] =
3886 {SEQUENCE_WAIT_MS,50},
3900 {SEQUENCE_END, 0x00}
3902 static struct reginfo *sensor_SceneSeqe[] = {sensor_SceneNormal, sensor_SceneNight, NULL,};
3905 #if CONFIG_SENSOR_AntiBanding
3906 static struct reginfo sensor_AntiBanding_50HZ[] =
3915 {SEQUENCE_END, 0x00}
3918 static struct reginfo sensor_AntiBanding_60HZ[] =
3927 {SEQUENCE_END, 0x00}
3929 static struct reginfo *sensor_AntiBandingSeqe[] = {sensor_AntiBanding_50HZ, sensor_AntiBanding_60HZ, NULL,};
3932 #if CONFIG_SENSOR_DigitalZoom
3933 static struct reginfo sensor_Zoom0[] =
3935 {SEQUENCE_END, 0x0},
3938 static struct reginfo sensor_Zoom1[] =
3940 {SEQUENCE_END, 0x0},
3943 static struct reginfo sensor_Zoom2[] =
3945 {SEQUENCE_END, 0x0},
3949 static struct reginfo sensor_Zoom3[] =
3951 {SEQUENCE_END, 0x0},
3953 static struct reginfo *sensor_ZoomSeqe[] = {sensor_Zoom0, sensor_Zoom1, sensor_Zoom2, sensor_Zoom3, NULL,};
3955 static struct v4l2_querymenu sensor_menus[] =
3957 #if CONFIG_SENSOR_WhiteBalance
3958 { .id = V4L2_CID_DO_WHITE_BALANCE, .index = 0, .name = "auto", .reserved = 0, },
3959 { .id = V4L2_CID_DO_WHITE_BALANCE, .index = 1, .name = "incandescent", .reserved = 0,},
3960 { .id = V4L2_CID_DO_WHITE_BALANCE, .index = 2, .name = "fluorescent", .reserved = 0,},
3961 { .id = V4L2_CID_DO_WHITE_BALANCE, .index = 3, .name = "daylight", .reserved = 0,},
3962 { .id = V4L2_CID_DO_WHITE_BALANCE, .index = 4, .name = "cloudy-daylight", .reserved = 0,},
3965 #if CONFIG_SENSOR_Effect
3966 { .id = V4L2_CID_EFFECT, .index = 0, .name = "none", .reserved = 0,},
3967 { .id = V4L2_CID_EFFECT, .index = 1, .name = "mono", .reserved = 0,},
3968 { .id = V4L2_CID_EFFECT, .index = 2, .name = "negative", .reserved = 0,},
3969 { .id = V4L2_CID_EFFECT, .index = 3, .name = "sepia", .reserved = 0,},
3970 { .id = V4L2_CID_EFFECT, .index = 4, .name = "posterize", .reserved = 0,} ,
3971 //{ .id = V4L2_CID_EFFECT, .index = 5, .name = "aqua", .reserved = 0,},
3974 #if CONFIG_SENSOR_Scene
3975 { .id = V4L2_CID_SCENE, .index = 0, .name = "auto", .reserved = 0,},
3976 { .id = V4L2_CID_SCENE, .index = 1, .name = "night", .reserved = 0,},
3979 #if CONFIG_SENSOR_AntiBanding
3980 { .id = V4L2_CID_ANTIBANDING, .index = 0, .name = "50hz", .reserved = 0,},
3981 { .id = V4L2_CID_ANTIBANDING, .index = 1, .name = "60hz", .reserved = 0,},
3984 #if CONFIG_SENSOR_Flash
3985 { .id = V4L2_CID_FLASH, .index = 0, .name = "off", .reserved = 0, }, { .id = V4L2_CID_FLASH, .index = 1, .name = "auto", .reserved = 0,},
3986 { .id = V4L2_CID_FLASH, .index = 2, .name = "on", .reserved = 0,}, { .id = V4L2_CID_FLASH, .index = 3, .name = "torch", .reserved = 0,},
3990 static const struct v4l2_queryctrl sensor_controls[] =
3992 #if CONFIG_SENSOR_WhiteBalance
3994 .id = V4L2_CID_DO_WHITE_BALANCE,
3995 .type = V4L2_CTRL_TYPE_MENU,
3996 .name = "White Balance Control",
4004 #if CONFIG_SENSOR_Brightness
4006 .id = V4L2_CID_BRIGHTNESS,
4007 .type = V4L2_CTRL_TYPE_INTEGER,
4008 .name = "Brightness Control",
4016 #if CONFIG_SENSOR_Effect
4018 .id = V4L2_CID_EFFECT,
4019 .type = V4L2_CTRL_TYPE_MENU,
4020 .name = "Effect Control",
4028 #if CONFIG_SENSOR_Exposure
4030 .id = V4L2_CID_EXPOSURE,
4031 .type = V4L2_CTRL_TYPE_INTEGER,
4032 .name = "Exposure Control",
4040 #if CONFIG_SENSOR_Saturation
4042 .id = V4L2_CID_SATURATION,
4043 .type = V4L2_CTRL_TYPE_INTEGER,
4044 .name = "Saturation Control",
4052 #if CONFIG_SENSOR_Contrast
4054 .id = V4L2_CID_CONTRAST,
4055 .type = V4L2_CTRL_TYPE_INTEGER,
4056 .name = "Contrast Control",
4064 #if CONFIG_SENSOR_Mirror
4066 .id = V4L2_CID_HFLIP,
4067 .type = V4L2_CTRL_TYPE_BOOLEAN,
4068 .name = "Mirror Control",
4076 #if CONFIG_SENSOR_Flip
4078 .id = V4L2_CID_VFLIP,
4079 .type = V4L2_CTRL_TYPE_BOOLEAN,
4080 .name = "Flip Control",
4088 #if CONFIG_SENSOR_Scene
4090 .id = V4L2_CID_SCENE,
4091 .type = V4L2_CTRL_TYPE_MENU,
4092 .name = "Scene Control",
4100 #if CONFIG_SENSOR_AntiBanding
4102 .id = V4L2_CID_ANTIBANDING,
4103 .type = V4L2_CTRL_TYPE_MENU,
4104 .name = "AntiBanding Control",
4112 #if CONFIG_SENSOR_DigitalZoom
4114 .id = V4L2_CID_ZOOM_RELATIVE,
4115 .type = V4L2_CTRL_TYPE_INTEGER,
4116 .name = "DigitalZoom Control",
4122 .id = V4L2_CID_ZOOM_ABSOLUTE,
4123 .type = V4L2_CTRL_TYPE_INTEGER,
4124 .name = "DigitalZoom Control",
4132 #if CONFIG_SENSOR_Focus
4134 .id = V4L2_CID_FOCUS_RELATIVE,
4135 .type = V4L2_CTRL_TYPE_INTEGER,
4136 .name = "Focus Control",
4142 .id = V4L2_CID_FOCUS_ABSOLUTE,
4143 .type = V4L2_CTRL_TYPE_INTEGER,
4144 .name = "Focus Control",
4148 .default_value = 125,
4152 #if CONFIG_SENSOR_Flash
4154 .id = V4L2_CID_FLASH,
4155 .type = V4L2_CTRL_TYPE_MENU,
4156 .name = "Flash Control",
4165 static int sensor_probe(struct i2c_client *client, const struct i2c_device_id *did);
4166 static int sensor_video_probe(struct soc_camera_device *icd, struct i2c_client *client);
4167 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
4168 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
4169 static int sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl);
4170 static int sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl);
4171 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg);
4172 static int sensor_resume(struct soc_camera_device *icd);
4173 static int sensor_set_bus_param(struct soc_camera_device *icd,unsigned long flags);
4174 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd);
4175 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);
4176 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);
4177 static int sensor_deactivate(struct i2c_client *client);
4179 static struct soc_camera_ops sensor_ops =
4181 .suspend = sensor_suspend,
4182 .resume = sensor_resume,
4183 .set_bus_param = sensor_set_bus_param,
4184 .query_bus_param = sensor_query_bus_param,
4185 .controls = sensor_controls,
4186 .menus = sensor_menus,
4187 .num_controls = ARRAY_SIZE(sensor_controls),
4188 .num_menus = ARRAY_SIZE(sensor_menus),
4192 /* only one fixed colorspace per pixelcode */
4193 struct sensor_datafmt {
4194 enum v4l2_mbus_pixelcode code;
4195 enum v4l2_colorspace colorspace;
4198 /* Find a data format by a pixel code in an array */
4199 static const struct sensor_datafmt *sensor_find_datafmt(
4200 enum v4l2_mbus_pixelcode code, const struct sensor_datafmt *fmt,
4204 for (i = 0; i < n; i++)
4205 if (fmt[i].code == code)
4211 static const struct sensor_datafmt sensor_colour_fmts[] = {
4212 {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG}
4214 enum sensor_work_state
4216 sensor_work_ready = 0,
4221 struct i2c_client *client;
4222 struct delayed_work dwork;
4223 enum sensor_work_state state;
4226 typedef struct sensor_info_priv_s
4241 unsigned char mirror; /* HFLIP */
4242 unsigned char flip; /* VFLIP */
4249 struct reginfo *winseqe_cur_addr;
4250 struct sensor_datafmt fmt;
4251 unsigned int enable;
4252 unsigned int funmodule_state;
4253 } sensor_info_priv_t;
4257 struct sensor_parameter
4259 unsigned short int preview_maxlines;
4260 unsigned short int preview_exposure;
4261 unsigned short int preview_line_width;
4262 unsigned short int preview_gain;
4264 unsigned short int capture_framerate;
4265 unsigned short int preview_framerate;
4270 struct v4l2_subdev subdev;
4271 struct i2c_client *client;
4272 sensor_info_priv_t info_priv;
4273 struct sensor_parameter parameter;
4274 struct workqueue_struct *sensor_wq;
4275 struct sensor_work sensor_wk;
4276 struct mutex wq_lock;
4277 int model; /* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */
4278 #if CONFIG_SENSOR_I2C_NOSCHED
4279 atomic_t tasklock_cnt;
4281 struct rk29camera_platform_data *sensor_io_request;
4282 struct rk29camera_gpio_res *sensor_gpio_res;
4285 static struct sensor* to_sensor(const struct i2c_client *client)
4287 return container_of(i2c_get_clientdata(client), struct sensor, subdev);
4290 static int sensor_task_lock(struct i2c_client *client, int lock)
4292 #if CONFIG_SENSOR_I2C_NOSCHED
4294 struct sensor *sensor = to_sensor(client);
4297 if (atomic_read(&sensor->tasklock_cnt) == 0) {
4298 while ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt>0)) {
4299 SENSOR_TR("\n %s will obtain i2c in atomic, but i2c bus is locked! Wait...\n",SENSOR_NAME_STRING());
4303 if ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt<=0)) {
4304 SENSOR_TR("\n %s obtain i2c fail in atomic!!\n",SENSOR_NAME_STRING());
4305 goto sensor_task_lock_err;
4310 atomic_add(1, &sensor->tasklock_cnt);
4312 if (atomic_read(&sensor->tasklock_cnt) > 0) {
4313 atomic_sub(1, &sensor->tasklock_cnt);
4315 if (atomic_read(&sensor->tasklock_cnt) == 0)
4320 sensor_task_lock_err:
4328 /* sensor register write */
4329 static int sensor_write(struct i2c_client *client, u16 reg, u16 val)
4333 struct i2c_msg msg[1];
4337 case SEQUENCE_WAIT_MS:
4344 case SEQUENCE_WAIT_US:
4350 case SEQUENCE_PROPERTY:
4357 buf[1] = reg & 0xFF;
4359 buf[3] = val & 0xFF;
4361 msg->addr = client->addr;
4362 msg->flags = client->flags;
4364 msg->len = sizeof(buf);
4365 msg->scl_rate = CONFIG_SENSOR_I2C_SPEED; /* ddl@rock-chips.com : 100kHz */
4366 msg->read_type = 0; /* fpga i2c:0==I2C_NORMAL : direct use number not enum for don't want include spi_fpga.h */
4371 while ((cnt-- > 0) && (err < 0)) { /* ddl@rock-chips.com : Transfer again if transent is failed */
4372 err = i2c_transfer(client->adapter, msg, 1);
4377 SENSOR_TR("\n %s write reg(0x%x, val:0x%x) failed, try to write again!\n",SENSOR_NAME_STRING(),reg, val);
4386 /* sensor register read */
4387 static int sensor_read(struct i2c_client *client, u16 reg, u16 *val)
4390 struct i2c_msg msg[2];
4393 buf[0] = (u8)reg >> 8;
4394 buf[1] = (u8)reg & 0xFF;
4396 msg[0].addr = client->addr;
4397 msg[0].flags = client->flags;
4399 msg[0].len = sizeof(buf);
4400 msg[0].scl_rate = CONFIG_SENSOR_I2C_SPEED; /* ddl@rock-chips.com : 100kHz */
4401 msg[0].read_type = 2; /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
4403 msg[1].addr = client->addr;
4404 msg[1].flags = client->flags|I2C_M_RD;
4406 msg[1].len = sizeof(buf);
4407 msg[1].scl_rate = CONFIG_SENSOR_I2C_SPEED; /* ddl@rock-chips.com : 100kHz */
4408 msg[1].read_type = 2; /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
4410 err = i2c_transfer(client->adapter, msg, 2);
4413 *val = (buf[0] << 8)|(buf[1] & 0xFF);
4414 SENSOR_DG("%s read reg(0x%x val:0x%x) success\n",SENSOR_NAME_STRING(),reg,*val);
4417 SENSOR_TR("%s read reg(0x%x) failed!",SENSOR_NAME_STRING(),reg);
4423 /* write a array of registers */
4424 static int sensor_write_array(struct i2c_client *client, struct reginfo *regarray)
4428 #if CONFIG_SENSOR_I2C_RDWRCHK
4433 if (sensor_task_lock(client, 1) < 0)
4434 goto sensor_write_array_end;
4435 while (regarray[i].reg != SEQUENCE_END)
4438 err = sensor_write(client, regarray[i].reg, regarray[i].val);
4442 SENSOR_TR("%s..write failed current reg:0x%x, Write array again !\n", SENSOR_NAME_STRING(),regarray[i].reg);
4446 SENSOR_TR("%s..write array failed!!!\n", SENSOR_NAME_STRING());
4448 goto sensor_write_array_end;
4451 #if CONFIG_SENSOR_I2C_RDWRCHK
4452 sensor_read(client, regarray[i].reg, &valchk);
4453 if (valchk != regarray[i].val)
4454 SENSOR_TR("%s Reg:0x%x write(0x%x, 0x%x) fail\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);
4461 sensor_write_array_end:
4462 sensor_task_lock(client,0);
4466 #if CONFIG_SENSOR_I2C_RDWRCHK
4467 static int sensor_readchk_array(struct i2c_client *client, struct reginfo *regarray)
4475 while (regarray[i].reg != SEQUENCE_END)
4477 sensor_read(client, regarray[i].reg, &valchk);
4478 if (valchk != regarray[i].val)
4479 SENSOR_TR("%s Reg:0x%x read(0x%x, 0x%x) error\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);
4486 #if CONFIG_SENSOR_Focus
4488 static int sensor_af_single(struct i2c_client *client)
4493 sensor_af_single_end:
4497 static int sensor_af_const(struct i2c_client *client)
4501 sensor_af_const_end:
4505 static int sensor_af_zoneupdate(struct i2c_client *client)
4509 sensor_af_zoneupdate_end:
4513 static int sensor_af_init(struct i2c_client *client)
4521 static int sensor_ioctrl(struct soc_camera_device *icd,enum rk29sensor_power_cmd cmd, int on)
4523 struct soc_camera_link *icl = to_soc_camera_link(icd);
4524 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4525 struct sensor *sensor = to_sensor(client);
4532 if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {
4533 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Reset, on);
4537 case Sensor_PowerDown:
4539 if (icl->powerdown) {
4540 ret = icl->powerdown(icd->pdev, on);
4541 if (ret == RK29_CAM_IO_SUCCESS) {
4545 icl->reset(icd->pdev);
4547 } else if (ret == RK29_CAM_EIO_REQUESTFAIL) {
4549 goto sensor_power_end;
4556 if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {
4557 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Flash, on);
4563 SENSOR_TR("%s cmd(0x%x) is unknown!",SENSOR_NAME_STRING(),cmd);
4572 static int sensor_init(struct v4l2_subdev *sd, u32 val)
4574 struct i2c_client *client = v4l2_get_subdevdata(sd);
4575 struct soc_camera_device *icd = client->dev.platform_data;
4576 struct sensor *sensor = to_sensor(client);
4577 const struct v4l2_queryctrl *qctrl;
4578 const struct sensor_datafmt *fmt;
4582 SENSOR_DG("\n%s..%s.. \n",SENSOR_NAME_STRING(),__FUNCTION__);
4584 sensor_ioctrl(icd,Sensor_Reset, 1);
4585 if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {
4587 goto sensor_INIT_ERR;
4591 sensor_ioctrl(icd,Sensor_Reset, 0);
4594 if (sensor_task_lock(client,1)<0)
4595 goto sensor_INIT_ERR;
4597 #if (SENSOR_RESET_REG != SEQUENCE_END)
4598 ret = sensor_write(client, SENSOR_RESET_REG, SENSOR_RESET_VAL);
4600 SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
4602 goto sensor_INIT_ERR;
4605 mdelay(5); //delay 5 microseconds
4608 /* check if it is an sensor sensor */
4609 #if (SENSOR_ID_REG != SEQUENCE_END)
4610 ret = sensor_read(client, SENSOR_ID_REG, &pid);
4612 SENSOR_TR("read chip id failed\n");
4614 goto sensor_INIT_ERR;
4617 SENSOR_DG("\n %s pid = 0x%x \n", SENSOR_NAME_STRING(), pid);
4621 if (pid == SENSOR_ID) {
4622 sensor->model = SENSOR_V4L2_IDENT;
4624 SENSOR_TR("error: %s mismatched pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
4626 goto sensor_INIT_ERR;
4628 ret = sensor_write_array(client, sensor_init_data);
4631 SENSOR_TR("error: %s initial failed\n",SENSOR_NAME_STRING());
4632 goto sensor_INIT_ERR;
4634 sensor_task_lock(client,0);
4635 sensor->info_priv.winseqe_cur_addr = SENSOR_INIT_WINSEQADR;
4636 fmt = sensor_find_datafmt(SENSOR_INIT_PIXFMT,sensor_colour_fmts, ARRAY_SIZE(sensor_colour_fmts));
4638 SENSOR_TR("error: %s initial array colour fmts is not support!!",SENSOR_NAME_STRING());
4640 goto sensor_INIT_ERR;
4642 sensor->info_priv.fmt = *fmt;
4644 /* sensor sensor information for initialization */
4645 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);
4647 sensor->info_priv.whiteBalance = qctrl->default_value;
4648 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_BRIGHTNESS);
4650 sensor->info_priv.brightness = qctrl->default_value;
4651 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);
4653 sensor->info_priv.effect = qctrl->default_value;
4654 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EXPOSURE);
4656 sensor->info_priv.exposure = qctrl->default_value;
4658 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SATURATION);
4660 sensor->info_priv.saturation = qctrl->default_value;
4661 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_CONTRAST);
4663 sensor->info_priv.contrast = qctrl->default_value;
4664 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_HFLIP);
4666 sensor->info_priv.mirror = qctrl->default_value;
4667 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_VFLIP);
4669 sensor->info_priv.flip = qctrl->default_value;
4670 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SCENE);
4672 sensor->info_priv.scene = qctrl->default_value;
4673 #if CONFIG_SENSOR_AntiBanding
4674 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ANTIBANDING);
4676 sensor->info_priv.antibanding = qctrl->default_value;
4678 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
4680 sensor->info_priv.digitalzoom = qctrl->default_value;
4682 /* ddl@rock-chips.com : if sensor support auto focus and flash, programer must run focus and flash code */
4683 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FOCUS_ABSOLUTE);
4685 sensor->info_priv.focus = qctrl->default_value;
4687 #if CONFIG_SENSOR_Flash
4688 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FLASH);
4690 sensor->info_priv.flash = qctrl->default_value;
4692 SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),((val == 0)?__FUNCTION__:"sensor_reinit"),icd->user_width,icd->user_height);
4694 sensor->info_priv.funmodule_state |= SENSOR_INIT_IS_OK;
4697 sensor->info_priv.funmodule_state |= SENSOR_INIT_IS_OK;
4698 sensor_task_lock(client,0);
4699 sensor_deactivate(client);
4703 static int sensor_deactivate(struct i2c_client *client)
4705 struct soc_camera_device *icd = client->dev.platform_data;
4706 struct sensor *sensor = to_sensor(client);
4708 SENSOR_DG("\n%s..%s.. Enter\n",SENSOR_NAME_STRING(),__FUNCTION__);
4710 /* ddl@rock-chips.com : all sensor output pin must change to input for other sensor */
4711 //sensor_task_lock(client, 1);
4712 sensor_ioctrl(icd, Sensor_PowerDown, 1);
4715 /* ddl@rock-chips.com : sensor config init width , because next open sensor quickly(soc_camera_open -> Try to configure with default parameters) */
4716 icd->user_width = SENSOR_INIT_WIDTH;
4717 icd->user_height = SENSOR_INIT_HEIGHT;
4718 sensor->info_priv.funmodule_state &= ~SENSOR_INIT_IS_OK;
4723 static struct reginfo sensor_suspend_sequence[]=
4728 static struct reginfo sensor_resume_sequence[]=
4732 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg)
4735 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4737 if (pm_msg.event == PM_EVENT_SUSPEND) {
4738 SENSOR_DG("\n %s Enter Suspend.. \n", SENSOR_NAME_STRING());
4739 ret = sensor_write_array(client, sensor_suspend_sequence) ;
4741 SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);
4745 ret = sensor_ioctrl(icd, Sensor_PowerDown, 1);
4747 SENSOR_TR("\n %s suspend fail for turn on power!\n", SENSOR_NAME_STRING());
4752 SENSOR_TR("\n %s cann't suppout Suspend..\n",SENSOR_NAME_STRING());
4759 static int sensor_resume(struct soc_camera_device *icd)
4762 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4764 ret = sensor_ioctrl(icd, Sensor_PowerDown, 0);
4766 SENSOR_TR("\n %s resume fail for turn on power!\n", SENSOR_NAME_STRING());
4770 ret = sensor_write_array(client, sensor_resume_sequence) ;
4772 SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);
4777 SENSOR_DG("\n %s Enter Resume.. \n", SENSOR_NAME_STRING());
4782 static int sensor_set_bus_param(struct soc_camera_device *icd,
4783 unsigned long flags)
4788 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd)
4790 struct soc_camera_link *icl = to_soc_camera_link(icd);
4791 unsigned long flags = SENSOR_BUS_PARAM;
4793 return soc_camera_apply_sensor_flags(icl, flags);
4796 static int sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
4798 struct i2c_client *client = v4l2_get_subdevdata(sd);
4799 struct soc_camera_device *icd = client->dev.platform_data;
4800 struct sensor *sensor = to_sensor(client);
4802 mf->width = icd->user_width;
4803 mf->height = icd->user_height;
4804 mf->code = sensor->info_priv.fmt.code;
4805 mf->colorspace = sensor->info_priv.fmt.colorspace;
4806 mf->field = V4L2_FIELD_NONE;
4811 static bool sensor_fmt_capturechk(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
4815 if ((mf->width == 1024) && (mf->height == 768)) {
4817 } else if ((mf->width == 1280) && (mf->height == 1024)) {
4819 } else if ((mf->width == 1600) && (mf->height == 1200)) {
4821 } else if ((mf->width == 2048) && (mf->height == 1536)) {
4823 } else if ((mf->width == 2592) && (mf->height == 1944)) {
4828 SENSOR_DG("%s %dx%d is capture format\n", __FUNCTION__, mf->width, mf->height);
4832 static bool sensor_fmt_videochk(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
4836 if ((mf->width == 1280) && (mf->height == 720)) {
4838 } else if ((mf->width == 1920) && (mf->height == 1080)) {
4843 SENSOR_DG("%s %dx%d is video format\n", __FUNCTION__, mf->width, mf->height);
4847 static struct reginfo* sensor_fmt_catch(int set_w, int set_h, int *ret_w, int *ret_h)
4849 struct reginfo *winseqe_set_addr = NULL;
4851 if (((set_w <= 176) && (set_h <= 144)) && (sensor_qcif[0].reg!=SEQUENCE_END)) {
4852 winseqe_set_addr = sensor_qcif;
4855 } else if (((set_w <= 320) && (set_h <= 240)) && (sensor_qvga[0].reg!=SEQUENCE_END)) {
4856 winseqe_set_addr = sensor_qvga;
4859 } else if (((set_w <= 352) && (set_h<= 288)) && (sensor_cif[0].reg!=SEQUENCE_END)) {
4860 winseqe_set_addr = sensor_cif;
4863 } else if (((set_w <= 640) && (set_h <= 480)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
4864 winseqe_set_addr = sensor_vga;
4868 #if CONFIG_SENSOR_FOR_CTS
4869 /**lzg@rockchip.com: forbid to preview with resolution 1280*1024*/
4870 else if (((set_w <= 800) && (set_h <= 600)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
4871 winseqe_set_addr = sensor_vga;
4876 else if (((set_w <= 800) && (set_h <= 600)) && (sensor_svga[0].reg!=SEQUENCE_END)) {
4877 winseqe_set_addr = sensor_svga;
4882 else if (((set_w <= 1024) && (set_h <= 768)) && (sensor_xga[0].reg!=SEQUENCE_END)) {
4883 winseqe_set_addr = sensor_xga;
4886 } else if (((set_w <= 1280) && (set_h <= 720)) && (sensor_720p[0].reg!=SEQUENCE_END)) {
4887 winseqe_set_addr = sensor_720p;
4890 } else if (((set_w <= 1280) && (set_h <= 1024)) && (sensor_sxga[0].reg!=SEQUENCE_END)) {
4891 winseqe_set_addr = sensor_sxga;
4894 } else if (((set_w <= 1600) && (set_h <= 1200)) && (sensor_uxga[0].reg!=SEQUENCE_END)) {
4895 winseqe_set_addr = sensor_uxga;
4899 #if CONFIG_SENSOR_FOR_CTS
4900 /**lzg@rockchip.com: forbid to preview with resolution 1280*1024*/
4901 else if (((set_w <= 1920) && (set_h <= 1080)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
4902 winseqe_set_addr = sensor_vga;
4907 else if (((set_w <= 1920) && (set_h <= 1080)) && (sensor_1080p[0].reg!=SEQUENCE_END)) {
4908 winseqe_set_addr = sensor_1080p;
4913 else if (((set_w <= 2048) && (set_h <= 1536)) && (sensor_qxga[0].reg!=SEQUENCE_END)) {
4914 winseqe_set_addr = sensor_qxga;
4917 } else if (((set_w <= 2592) && (set_h <= 1944)) && (sensor_qsxga[0].reg!=SEQUENCE_END)) {
4918 winseqe_set_addr = sensor_qsxga;
4923 return winseqe_set_addr;
4926 static int sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
4928 struct i2c_client *client = v4l2_get_subdevdata(sd);
4929 const struct sensor_datafmt *fmt;
4930 struct sensor *sensor = to_sensor(client);
4931 struct reginfo *winseqe_set_addr=NULL;
4932 int ret=0, set_w,set_h;
4934 fmt = sensor_find_datafmt(mf->code, sensor_colour_fmts,
4935 ARRAY_SIZE(sensor_colour_fmts));
4938 goto sensor_s_fmt_end;
4941 if (sensor->info_priv.fmt.code != mf->code) {
4944 case V4L2_MBUS_FMT_YUYV8_2X8:
4946 winseqe_set_addr = sensor_ClrFmt_YUYV;
4949 case V4L2_MBUS_FMT_UYVY8_2X8:
4951 winseqe_set_addr = sensor_ClrFmt_UYVY;
4957 if (winseqe_set_addr != NULL) {
4958 sensor_write_array(client, winseqe_set_addr);
4959 sensor->info_priv.fmt.code = mf->code;
4960 sensor->info_priv.fmt.colorspace= mf->colorspace;
4961 SENSOR_DG("%s v4l2_mbus_code:%d set success!\n", SENSOR_NAME_STRING(),mf->code);
4963 SENSOR_TR("%s v4l2_mbus_code:%d is invalidate!\n", SENSOR_NAME_STRING(),mf->code);
4970 winseqe_set_addr = sensor_fmt_catch(set_w, set_h, &set_w, &set_h);
4972 if ((winseqe_set_addr != sensor->info_priv.winseqe_cur_addr) && winseqe_set_addr) {
4973 #if CONFIG_SENSOR_Flash
4974 if (sensor_fmt_capturechk(sd,mf) == true) { /* ddl@rock-chips.com : Capture */
4975 if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
4976 sensor_ioctrl(icd, Sensor_Flash, Flash_On);
4977 SENSOR_DG("%s flash on in capture!\n", SENSOR_NAME_STRING());
4979 } else { /* ddl@rock-chips.com : Video */
4980 if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
4981 sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
4982 SENSOR_DG("%s flash off in preivew!\n", SENSOR_NAME_STRING());
4986 ret |= sensor_write_array(client, winseqe_set_addr);
4988 SENSOR_TR("%s set format capability failed\n", SENSOR_NAME_STRING());
4989 #if CONFIG_SENSOR_Flash
4990 if (sensor_fmt_capturechk(sd,mf) == true) {
4991 if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
4992 sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
4993 SENSOR_TR("%s Capture format set fail, flash off !\n", SENSOR_NAME_STRING());
4997 goto sensor_s_fmt_end;
5000 sensor->info_priv.winseqe_cur_addr = (struct reginfo *)winseqe_set_addr;
5002 SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,set_w,set_h);
5004 SENSOR_TR("\n %s .. Current Format is validate. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),set_w,set_h);
5014 static int sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
5016 struct i2c_client *client = v4l2_get_subdevdata(sd);
5017 struct sensor *sensor = to_sensor(client);
5018 const struct sensor_datafmt *fmt;
5019 int ret = 0, set_w,set_h;;
5021 fmt = sensor_find_datafmt(mf->code, sensor_colour_fmts,
5022 ARRAY_SIZE(sensor_colour_fmts));
5024 fmt = &sensor->info_priv.fmt;
5025 mf->code = fmt->code;
5028 if (mf->height > SENSOR_MAX_HEIGHT)
5029 mf->height = SENSOR_MAX_HEIGHT;
5030 else if (mf->height < SENSOR_MIN_HEIGHT)
5031 mf->height = SENSOR_MIN_HEIGHT;
5033 if (mf->width > SENSOR_MAX_WIDTH)
5034 mf->width = SENSOR_MAX_WIDTH;
5035 else if (mf->width < SENSOR_MIN_WIDTH)
5036 mf->width = SENSOR_MIN_WIDTH;
5041 if (((set_w <= 176) && (set_h <= 144)) && sensor_qcif[0].reg)
5046 else if (((set_w <= 320) && (set_h <= 240)) && sensor_qvga[0].reg)
5051 else if (((set_w <= 352) && (set_h<= 288)) && sensor_cif[0].reg)
5056 else if (((set_w <= 640) && (set_h <= 480)) && sensor_vga[0].reg)
5061 else if (((set_w <= 800) && (set_h <= 600)) && sensor_svga[0].reg)
5066 else if (((set_w <= 1280) && (set_h <= 720)) && sensor_720p[0].reg)
5071 else if (((set_w <= 1024) && (set_h <= 768)) && sensor_xga[0].reg)
5076 else if (((set_w <= 1280) && (set_h <= 1024)) && sensor_sxga[0].reg)
5081 else if (((set_w <= 1600) && (set_h <= 1200)) && sensor_uxga[0].reg)
5086 else if (((set_w <= 2048) && (set_h <= 1536)) && sensor_qxga[0].reg)
5092 { /* ddl@rock-chips.com : Sensor output smallest size if isn't support app */
5093 set_w = SENSOR_INIT_WIDTH;
5094 set_h = SENSOR_INIT_HEIGHT;
5098 mf->colorspace = fmt->colorspace;
5103 static int sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id)
5105 struct i2c_client *client = v4l2_get_subdevdata(sd);
5107 if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
5110 if (id->match.addr != client->addr)
5113 id->ident = SENSOR_V4L2_IDENT; /* ddl@rock-chips.com : Return s5k6aa identifier */
5118 #if CONFIG_SENSOR_Brightness
5119 static int sensor_set_brightness(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5121 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5123 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5125 if (sensor_BrightnessSeqe[value - qctrl->minimum] != NULL)
5127 if (sensor_write_array(client, sensor_BrightnessSeqe[value - qctrl->minimum]) != 0)
5129 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5132 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5136 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5140 #if CONFIG_SENSOR_Effect
5141 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5143 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5145 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5147 if (sensor_EffectSeqe[value - qctrl->minimum] != NULL)
5149 if (sensor_write_array(client, sensor_EffectSeqe[value - qctrl->minimum]) != 0)
5151 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5154 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5158 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5162 #if CONFIG_SENSOR_Exposure
5163 static int sensor_set_exposure(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5165 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5167 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5169 if (sensor_ExposureSeqe[value - qctrl->minimum] != NULL)
5171 if (sensor_write_array(client, sensor_ExposureSeqe[value - qctrl->minimum]) != 0)
5173 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5176 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5180 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5184 #if CONFIG_SENSOR_Saturation
5185 static int sensor_set_saturation(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5187 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5189 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5191 if (sensor_SaturationSeqe[value - qctrl->minimum] != NULL)
5193 if (sensor_write_array(client, sensor_SaturationSeqe[value - qctrl->minimum]) != 0)
5195 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5198 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5202 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5206 #if CONFIG_SENSOR_Contrast
5207 static int sensor_set_contrast(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5209 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5211 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5213 if (sensor_ContrastSeqe[value - qctrl->minimum] != NULL)
5215 if (sensor_write_array(client, sensor_ContrastSeqe[value - qctrl->minimum]) != 0)
5217 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5220 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5224 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5228 #if CONFIG_SENSOR_Mirror
5229 static int sensor_set_mirror(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5231 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5233 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5235 if (sensor_MirrorSeqe[value - qctrl->minimum] != NULL)
5237 if (sensor_write_array(client, sensor_MirrorSeqe[value - qctrl->minimum]) != 0)
5239 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5242 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5246 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5250 #if CONFIG_SENSOR_Flip
5251 static int sensor_set_flip(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5253 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5255 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5257 if (sensor_FlipSeqe[value - qctrl->minimum] != NULL)
5259 if (sensor_write_array(client, sensor_FlipSeqe[value - qctrl->minimum]) != 0)
5261 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5264 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5268 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5272 #if CONFIG_SENSOR_Scene
5273 static int sensor_set_scene(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5275 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5277 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5279 if (sensor_SceneSeqe[value - qctrl->minimum] != NULL)
5281 if (sensor_write_array(client, sensor_SceneSeqe[value - qctrl->minimum]) != 0)
5283 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5286 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5290 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5294 #if CONFIG_SENSOR_AntiBanding
5295 static int sensor_set_antibanding(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5297 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5299 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5301 if (sensor_AntiBandingSeqe[value - qctrl->minimum] != NULL)
5303 if (sensor_write_array(client, sensor_AntiBandingSeqe[value - qctrl->minimum]) != 0)
5305 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5308 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5312 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5316 #if CONFIG_SENSOR_WhiteBalance
5317 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5319 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5321 if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
5323 if (sensor_WhiteBalanceSeqe[value - qctrl->minimum] != NULL)
5325 if (sensor_write_array(client, sensor_WhiteBalanceSeqe[value - qctrl->minimum]) != 0)
5327 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5330 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5334 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5338 #if CONFIG_SENSOR_DigitalZoom
5339 static int sensor_set_digitalzoom(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int *value)
5341 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5342 struct sensor *sensor = to_sensor(client);
5343 const struct v4l2_queryctrl *qctrl_info;
5344 int digitalzoom_cur, digitalzoom_total;
5346 qctrl_info = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
5350 digitalzoom_cur = sensor->info_priv.digitalzoom;
5351 digitalzoom_total = qctrl_info->maximum;
5353 if ((*value > 0) && (digitalzoom_cur >= digitalzoom_total))
5355 SENSOR_TR("%s digitalzoom is maximum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
5359 if ((*value < 0) && (digitalzoom_cur <= qctrl_info->minimum))
5361 SENSOR_TR("%s digitalzoom is minimum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
5365 if ((*value > 0) && ((digitalzoom_cur + *value) > digitalzoom_total))
5367 *value = digitalzoom_total - digitalzoom_cur;
5370 if ((*value < 0) && ((digitalzoom_cur + *value) < 0))
5372 *value = 0 - digitalzoom_cur;
5375 digitalzoom_cur += *value;
5377 if (sensor_ZoomSeqe[digitalzoom_cur] != NULL)
5379 if (sensor_write_array(client, sensor_ZoomSeqe[digitalzoom_cur]) != 0)
5381 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
5384 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, *value);
5391 #if CONFIG_SENSOR_Flash
5392 static int sensor_set_flash(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
5394 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5395 struct sensor *sensor = to_sensor(client);
5396 const struct v4l2_queryctrl *qctrl_info;
5398 if ((value >= qctrl->minimum) && (value <= qctrl->maximum)) {
5399 if (value == 3) { /* ddl@rock-chips.com: torch */
5400 sensor_ioctrl(icd, Sensor_Flash, Flash_Torch); /* Flash On */
5402 sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
5404 SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
5408 SENSOR_TR("\n %s..%s valure = %d is invalidate.. \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
5412 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
5414 struct i2c_client *client = v4l2_get_subdevdata(sd);
5415 struct sensor *sensor = to_sensor(client);
5416 const struct v4l2_queryctrl *qctrl;
5418 qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
5422 SENSOR_TR("\n %s ioctrl id = %d is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
5428 case V4L2_CID_BRIGHTNESS:
5430 ctrl->value = sensor->info_priv.brightness;
5433 case V4L2_CID_SATURATION:
5435 ctrl->value = sensor->info_priv.saturation;
5438 case V4L2_CID_CONTRAST:
5440 ctrl->value = sensor->info_priv.contrast;
5443 case V4L2_CID_DO_WHITE_BALANCE:
5445 ctrl->value = sensor->info_priv.whiteBalance;
5448 case V4L2_CID_EXPOSURE:
5450 ctrl->value = sensor->info_priv.exposure;
5453 case V4L2_CID_HFLIP:
5455 ctrl->value = sensor->info_priv.mirror;
5458 case V4L2_CID_VFLIP:
5460 ctrl->value = sensor->info_priv.flip;
5471 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
5473 struct i2c_client *client = v4l2_get_subdevdata(sd);
5474 struct sensor *sensor = to_sensor(client);
5475 struct soc_camera_device *icd = client->dev.platform_data;
5476 const struct v4l2_queryctrl *qctrl;
5479 qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
5483 SENSOR_TR("\n %s ioctrl id = %d is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
5489 #if CONFIG_SENSOR_Brightness
5490 case V4L2_CID_BRIGHTNESS:
5492 if (ctrl->value != sensor->info_priv.brightness)
5494 if (sensor_set_brightness(icd, qctrl,ctrl->value) != 0)
5498 sensor->info_priv.brightness = ctrl->value;
5503 #if CONFIG_SENSOR_Exposure
5504 case V4L2_CID_EXPOSURE:
5506 if (ctrl->value != sensor->info_priv.exposure)
5508 if (sensor_set_exposure(icd, qctrl,ctrl->value) != 0)
5512 sensor->info_priv.exposure = ctrl->value;
5517 #if CONFIG_SENSOR_Saturation
5518 case V4L2_CID_SATURATION:
5520 if (ctrl->value != sensor->info_priv.saturation)
5522 if (sensor_set_saturation(icd, qctrl,ctrl->value) != 0)
5526 sensor->info_priv.saturation = ctrl->value;
5531 #if CONFIG_SENSOR_Contrast
5532 case V4L2_CID_CONTRAST:
5534 if (ctrl->value != sensor->info_priv.contrast)
5536 if (sensor_set_contrast(icd, qctrl,ctrl->value) != 0)
5540 sensor->info_priv.contrast = ctrl->value;
5545 #if CONFIG_SENSOR_WhiteBalance
5546 case V4L2_CID_DO_WHITE_BALANCE:
5548 if (ctrl->value != sensor->info_priv.whiteBalance)
5550 if (sensor_set_whiteBalance(icd, qctrl,ctrl->value) != 0)
5554 sensor->info_priv.whiteBalance = ctrl->value;
5559 #if CONFIG_SENSOR_Mirror
5560 case V4L2_CID_HFLIP:
5562 if (ctrl->value != sensor->info_priv.mirror)
5564 if (sensor_set_mirror(icd, qctrl,ctrl->value) != 0)
5566 sensor->info_priv.mirror = ctrl->value;
5571 #if CONFIG_SENSOR_Flip
5572 case V4L2_CID_VFLIP:
5574 if (ctrl->value != sensor->info_priv.flip)
5576 if (sensor_set_flip(icd, qctrl,ctrl->value) != 0)
5578 sensor->info_priv.flip = ctrl->value;
5589 static int sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl)
5591 const struct v4l2_queryctrl *qctrl;
5592 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5593 struct sensor *sensor = to_sensor(client);
5595 qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
5599 SENSOR_TR("\n %s ioctrl id = %d is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
5603 switch (ext_ctrl->id)
5605 case V4L2_CID_SCENE:
5607 ext_ctrl->value = sensor->info_priv.scene;
5610 #if CONFIG_SENSOR_AntiBanding
5611 case V4L2_CID_ANTIBANDING:
5613 ext_ctrl->value = sensor->info_priv.antibanding;
5617 case V4L2_CID_EFFECT:
5619 ext_ctrl->value = sensor->info_priv.effect;
5622 case V4L2_CID_ZOOM_ABSOLUTE:
5624 ext_ctrl->value = sensor->info_priv.digitalzoom;
5627 case V4L2_CID_ZOOM_RELATIVE:
5631 case V4L2_CID_FOCUS_ABSOLUTE:
5633 ext_ctrl->value = sensor->info_priv.focus;
5636 case V4L2_CID_FOCUS_RELATIVE:
5640 case V4L2_CID_FLASH:
5642 ext_ctrl->value = sensor->info_priv.flash;
5650 static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl)
5652 const struct v4l2_queryctrl *qctrl;
5653 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
5654 struct sensor *sensor = to_sensor(client);
5657 qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
5661 SENSOR_TR("\n %s ioctrl id = %d is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
5666 switch (ext_ctrl->id)
5668 #if CONFIG_SENSOR_Scene
5669 case V4L2_CID_SCENE:
5671 if (ext_ctrl->value != sensor->info_priv.scene)
5673 if (sensor_set_scene(icd, qctrl,ext_ctrl->value) != 0)
5675 sensor->info_priv.scene = ext_ctrl->value;
5680 #if CONFIG_SENSOR_AntiBanding
5681 case V4L2_CID_ANTIBANDING:
5683 if (ext_ctrl->value != sensor->info_priv.antibanding)
5685 if (sensor_set_antibanding(icd, qctrl,ext_ctrl->value) != 0)
5687 sensor->info_priv.antibanding = ext_ctrl->value;
5692 #if CONFIG_SENSOR_Effect
5693 case V4L2_CID_EFFECT:
5695 if (ext_ctrl->value != sensor->info_priv.effect)
5697 if (sensor_set_effect(icd, qctrl,ext_ctrl->value) != 0)
5699 sensor->info_priv.effect= ext_ctrl->value;
5704 #if CONFIG_SENSOR_DigitalZoom
5705 case V4L2_CID_ZOOM_ABSOLUTE:
5707 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
5710 if (ext_ctrl->value != sensor->info_priv.digitalzoom)
5712 val_offset = ext_ctrl->value -sensor->info_priv.digitalzoom;
5714 if (sensor_set_digitalzoom(icd, qctrl,&val_offset) != 0)
5716 sensor->info_priv.digitalzoom += val_offset;
5718 SENSOR_DG("%s digitalzoom is %x\n",SENSOR_NAME_STRING(), sensor->info_priv.digitalzoom);
5723 case V4L2_CID_ZOOM_RELATIVE:
5725 if (ext_ctrl->value)
5727 if (sensor_set_digitalzoom(icd, qctrl,&ext_ctrl->value) != 0)
5729 sensor->info_priv.digitalzoom += ext_ctrl->value;
5731 SENSOR_DG("%s digitalzoom is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.digitalzoom);
5736 #if CONFIG_SENSOR_Focus
5737 case V4L2_CID_FOCUS_ABSOLUTE:
5739 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
5742 if (ext_ctrl->value != sensor->info_priv.focus)
5744 val_offset = ext_ctrl->value -sensor->info_priv.focus;
5746 sensor->info_priv.focus += val_offset;
5751 case V4L2_CID_FOCUS_RELATIVE:
5753 if (ext_ctrl->value)
5755 sensor->info_priv.focus += ext_ctrl->value;
5757 SENSOR_DG("%s focus is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.focus);
5762 #if CONFIG_SENSOR_Flash
5763 case V4L2_CID_FLASH:
5765 if (sensor_set_flash(icd, qctrl,ext_ctrl->value) != 0)
5767 sensor->info_priv.flash = ext_ctrl->value;
5769 SENSOR_DG("%s flash is %x\n",SENSOR_NAME_STRING(), sensor->info_priv.flash);
5780 static int sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
5782 struct i2c_client *client = v4l2_get_subdevdata(sd);
5783 struct soc_camera_device *icd = client->dev.platform_data;
5784 int i, error_cnt=0, error_idx=-1;
5787 for (i=0; i<ext_ctrl->count; i++) {
5788 if (sensor_g_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
5795 error_idx = ext_ctrl->count;
5797 if (error_idx != -1) {
5798 ext_ctrl->error_idx = error_idx;
5805 static int sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
5807 struct i2c_client *client = v4l2_get_subdevdata(sd);
5808 struct soc_camera_device *icd = client->dev.platform_data;
5809 int i, error_cnt=0, error_idx=-1;
5812 for (i=0; i<ext_ctrl->count; i++) {
5813 if (sensor_s_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
5820 error_idx = ext_ctrl->count;
5822 if (error_idx != -1) {
5823 ext_ctrl->error_idx = error_idx;
5829 static int sensor_s_stream(struct v4l2_subdev *sd, int enable)
5831 struct i2c_client *client = v4l2_get_subdevdata(sd);
5832 struct sensor *sensor = to_sensor(client);
5835 sensor->info_priv.enable = 1;
5836 } else if (enable == 0) {
5837 sensor->info_priv.enable = 0;
5842 /* Interface active, can use i2c. If it fails, it can indeed mean, that
5843 * this wasn't our capture interface, so, we wait for the right one */
5844 static int sensor_video_probe(struct soc_camera_device *icd,
5845 struct i2c_client *client)
5848 struct sensor *sensor = to_sensor(client);
5850 /* We must have a parent by now. And it cannot be a wrong one.
5851 * So this entire test is completely redundant. */
5852 if (!icd->dev.parent ||
5853 to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
5856 if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {
5858 goto sensor_video_probe_err;
5862 ret = sensor_write(client, 0x002c, 0x0000);
5864 SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
5866 goto sensor_video_probe_err;
5870 #if (SENSOR_RESET_REG != SEQUENCE_END)
5871 ret = sensor_write(client, SENSOR_RESET_REG, SENSOR_RESET_VAL);
5873 SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
5875 goto sensor_video_probe_err;
5878 mdelay(5); //delay 5 microseconds
5881 /* check if it is an sensor sensor */
5882 #if (SENSOR_ID_REG != SEQUENCE_END)
5883 ret = sensor_read(client, SENSOR_ID_REG, &pid);
5885 SENSOR_TR("read chip id failed\n");
5887 goto sensor_video_probe_err;
5890 SENSOR_DG("\n %s pid = 0x%x \n", SENSOR_NAME_STRING(), pid);
5895 if (pid == SENSOR_ID) {
5896 sensor->model = SENSOR_V4L2_IDENT;
5898 SENSOR_TR("error: %s mismatched pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
5900 goto sensor_video_probe_err;
5905 sensor_video_probe_err:
5909 static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
5911 struct i2c_client *client = v4l2_get_subdevdata(sd);
5912 struct soc_camera_device *icd = client->dev.platform_data;
5913 struct sensor *sensor = to_sensor(client);
5915 #if CONFIG_SENSOR_Flash
5919 SENSOR_DG("\n%s..%s..cmd:%x \n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);
5922 case RK29_CAM_SUBDEV_DEACTIVATE:
5924 sensor_deactivate(client);
5927 case RK29_CAM_SUBDEV_IOREQUEST:
5929 sensor->sensor_io_request = (struct rk29camera_platform_data*)arg;
5930 if (sensor->sensor_io_request != NULL) {
5931 if (sensor->sensor_io_request->gpio_res[0].dev_name &&
5932 (strcmp(sensor->sensor_io_request->gpio_res[0].dev_name, dev_name(icd->pdev)) == 0)) {
5933 sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[0];
5934 } else if (sensor->sensor_io_request->gpio_res[1].dev_name &&
5935 (strcmp(sensor->sensor_io_request->gpio_res[1].dev_name, dev_name(icd->pdev)) == 0)) {
5936 sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[1];
5939 SENSOR_TR("%s %s RK29_CAM_SUBDEV_IOREQUEST fail\n",SENSOR_NAME_STRING(),__FUNCTION__);
5941 goto sensor_ioctl_end;
5943 /* ddl@rock-chips.com : if gpio_flash havn't been set in board-xxx.c, sensor driver must notify is not support flash control
5945 #if CONFIG_SENSOR_Flash
5946 if (sensor->sensor_gpio_res) {
5947 if (sensor->sensor_gpio_res->gpio_flash == INVALID_GPIO) {
5948 for (i = 0; i < icd->ops->num_controls; i++) {
5949 if (V4L2_CID_FLASH == icd->ops->controls[i].id) {
5950 memset(&icd->ops->controls[i],0x00,sizeof(struct v4l2_queryctrl));
5953 sensor->info_priv.flash = 0xff;
5954 SENSOR_DG("%s flash gpio is invalidate!\n",SENSOR_NAME_STRING());
5962 SENSOR_TR("%s %s cmd(0x%x) is unknown !\n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);
5970 static int sensor_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
5971 enum v4l2_mbus_pixelcode *code)
5973 if (index >= ARRAY_SIZE(sensor_colour_fmts))
5976 *code = sensor_colour_fmts[index].code;
5979 static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {
5980 .init = sensor_init,
5981 .g_ctrl = sensor_g_control,
5982 .s_ctrl = sensor_s_control,
5983 .g_ext_ctrls = sensor_g_ext_controls,
5984 .s_ext_ctrls = sensor_s_ext_controls,
5985 .g_chip_ident = sensor_g_chip_ident,
5986 .ioctl = sensor_ioctl,
5989 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {
5990 .s_mbus_fmt = sensor_s_fmt,
5991 .g_mbus_fmt = sensor_g_fmt,
5992 .try_mbus_fmt = sensor_try_fmt,
5993 .enum_mbus_fmt = sensor_enum_fmt,
5994 .s_stream = sensor_s_stream,
5996 static struct v4l2_subdev_ops sensor_subdev_ops = {
5997 .core = &sensor_subdev_core_ops,
5998 .video = &sensor_subdev_video_ops,
6001 static int sensor_probe(struct i2c_client *client,
6002 const struct i2c_device_id *did)
6004 struct sensor *sensor;
6005 struct soc_camera_device *icd = client->dev.platform_data;
6006 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
6007 struct soc_camera_link *icl;
6008 //struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
6011 SENSOR_DG("\n%s..%s..%d..\n",__FUNCTION__,__FILE__,__LINE__);
6013 dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());
6017 icl = to_soc_camera_link(icd);
6019 dev_err(&client->dev, "%s driver needs platform data\n", SENSOR_NAME_STRING());
6023 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
6024 dev_warn(&adapter->dev,
6025 "I2C-Adapter doesn't support I2C_FUNC_I2C\n");
6029 sensor = kzalloc(sizeof(struct sensor), GFP_KERNEL);
6033 v4l2_i2c_subdev_init(&sensor->subdev, client, &sensor_subdev_ops);
6035 /* Second stage probe - when a capture adapter is there */
6036 icd->ops = &sensor_ops;
6037 sensor->info_priv.fmt = sensor_colour_fmts[0];
6039 ret = sensor_video_probe(icd, client);
6042 i2c_set_clientdata(client, NULL);
6046 SENSOR_DG("\n%s..%s..%d ret = %x \n",__FUNCTION__,__FILE__,__LINE__,ret);
6050 static int sensor_remove(struct i2c_client *client)
6052 struct sensor *sensor = to_sensor(client);
6053 struct soc_camera_device *icd = client->dev.platform_data;
6056 i2c_set_clientdata(client, NULL);
6057 client->driver = NULL;
6063 static const struct i2c_device_id sensor_id[] = {
6064 {SENSOR_NAME_STRING(), 0 },
6067 MODULE_DEVICE_TABLE(i2c, sensor_id);
6069 static struct i2c_driver sensor_i2c_driver = {
6071 .name = SENSOR_NAME_STRING(),
6073 .probe = sensor_probe,
6074 .remove = sensor_remove,
6075 .id_table = sensor_id,
6078 static int __init sensor_mod_init(void)
6080 //SENSOR_DG("\n%s..%s.. \n",__FUNCTION__,SENSOR_NAME_STRING());
6081 printk(">>>>>>>>>>\n%s..%s.. \n",__FUNCTION__,SENSOR_NAME_STRING());
6082 return i2c_add_driver(&sensor_i2c_driver);
6085 static void __exit sensor_mod_exit(void)
6087 i2c_del_driver(&sensor_i2c_driver);
6090 device_initcall_sync(sensor_mod_init);
6091 module_exit(sensor_mod_exit);
6093 MODULE_DESCRIPTION(SENSOR_NAME_STRING(Camera sensor driver));
6094 MODULE_AUTHOR("ddl <kernel@rock-chips>");
6095 MODULE_LICENSE("GPL");
projects / firefly-linux-kernel-4.4.55.git / blob