drivers/media/video/s5k6aa.c

   1 /*
   2  * Driver for OV5642 CMOS Image Sensor from OmniVision
   3  *
   4  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
   5  *
   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.
   9  */
  10
  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 <plat/rk_camera.h>
  23 #include <linux/delay.h>
  24 #include "s5k6aa.h"
  25 static int debug;
  26 module_param(debug, int, S_IRUGO|S_IWUSR);
  27
  28 #define dprintk(level, fmt, arg...) do {                        \
  29         if (debug >= level)                                     \
  30         printk(KERN_WARNING fmt , ## arg); } while (0)
  31
  32 #define SENSOR_TR(format, ...) printk(KERN_ERR format, ## __VA_ARGS__)
  33 #define SENSOR_DG(format, ...) dprintk(1, format, ## __VA_ARGS__)
  34
  35
  36 #define _CONS(a,b) a##b
  37 #define CONS(a,b) _CONS(a,b)
  38
  39 #define __STR(x) #x
  40 #define _STR(x) __STR(x)
  41 #define STR(x) _STR(x)
  42
  43 #define MIN(x,y)   ((x<y) ? x: y)
  44 #define MAX(x,y)    ((x>y) ? x: y)
  45
  46 /* Sensor Driver Configuration */
  47 #define SENSOR_NAME RK29_CAM_SENSOR_S5K6AA
  48 #define SENSOR_V4L2_IDENT V4L2_IDENT_S5K66A
  49 #define SENSOR_ID 0x06aa
  50 #define SENSOR_ID_REG SEQUENCE_END//0x015a
  51 #define SENSOR_RESET_REG SEQUENCE_END
  52 #define SENSOR_RESET_VAL 0x00
  53 #define SENSOR_MIN_WIDTH    640
  54 #define SENSOR_MIN_HEIGHT   480
  55 #define SENSOR_MAX_WIDTH    1280
  56 #define SENSOR_MAX_HEIGHT   1024
  57 #define SENSOR_INIT_WIDTH       640                     /* Sensor pixel size for sensor_init_data array */
  58 #define SENSOR_INIT_HEIGHT  480
  59 #define SENSOR_INIT_WINSEQADR sensor_vga
  60 #define SENSOR_INIT_PIXFMT V4L2_MBUS_FMT_YUYV8_2X8
  61
  62 #define CONFIG_SENSOR_WhiteBalance      0
  63 #define CONFIG_SENSOR_Brightness        0
  64 #define CONFIG_SENSOR_Contrast      0
  65 #define CONFIG_SENSOR_Saturation    0
  66 #define CONFIG_SENSOR_Effect        0
  67 #define CONFIG_SENSOR_Scene         0
  68 #define CONFIG_SENSOR_DigitalZoom   0
  69 #define CONFIG_SENSOR_Focus         0
  70 #define CONFIG_SENSOR_Exposure      0
  71 #define CONFIG_SENSOR_Flash         0
  72 #define CONFIG_SENSOR_Mirror        1
  73 #define CONFIG_SENSOR_Flip          0
  74 #define CONFIG_SENSOR_Focus         0
  75
  76
  77 #define CONFIG_SENSOR_I2C_SPEED     250000       /* Hz */
  78 /* Sensor write register continues by preempt_disable/preempt_enable for current process not be scheduled */
  79 #define CONFIG_SENSOR_I2C_NOSCHED   0
  80 #define CONFIG_SENSOR_I2C_RDWRCHK   0
  81
  82
  83 #define SENSOR_BUS_PARAM  (SOCAM_MASTER | SOCAM_PCLK_SAMPLE_RISING |\
  84                           SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_HIGH |\
  85                           SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8  |SOCAM_MCLK_24MHZ)
  86
  87 #define COLOR_TEMPERATURE_CLOUDY_DN  6500
  88 #define COLOR_TEMPERATURE_CLOUDY_UP    8000
  89 #define COLOR_TEMPERATURE_CLEARDAY_DN  5000
  90 #define COLOR_TEMPERATURE_CLEARDAY_UP    6500
  91 #define COLOR_TEMPERATURE_OFFICE_DN     3500
  92 #define COLOR_TEMPERATURE_OFFICE_UP     5000
  93 #define COLOR_TEMPERATURE_HOME_DN       2500
  94 #define COLOR_TEMPERATURE_HOME_UP       3500
  95
  96 #define SENSOR_NAME_STRING(a) STR(CONS(SENSOR_NAME, a))
  97 #define SENSOR_NAME_VARFUN(a) CONS(SENSOR_NAME, a)
  98
  99 #define SENSOR_AF_IS_ERR    (0x00<<0)
 100 #define SENSOR_AF_IS_OK         (0x01<<0)
 101 #define SENSOR_INIT_IS_ERR   (0x00<<28)
 102 #define SENSOR_INIT_IS_OK    (0x01<<28)
 103
 104 #if CONFIG_SENSOR_Focus
 105 #define SENSOR_AF_MODE_INFINITY    0
 106 #define SENSOR_AF_MODE_MACRO       1
 107 #define SENSOR_AF_MODE_FIXED       2
 108 #define SENSOR_AF_MODE_AUTO        3
 109 #define SENSOR_AF_MODE_CONTINUOUS  4
 110 #define SENSOR_AF_MODE_CLOSE       5
 111 #endif
 112
 113 //flash off in fixed time to prevent from too hot , zyc
 114 struct  flash_timer{
 115     struct soc_camera_device *icd;
 116         struct hrtimer timer;
 117 };
 118 static enum hrtimer_restart flash_off_func(struct hrtimer *timer);
 119
 120 static struct  flash_timer flash_off_timer;
 121 //for user defined if user want to customize the series , zyc
 122 #ifdef CONFIG_S5K6AA_USER_DEFINED_SERIES
 123 #include "s5k6aa_user_series.c"
 124 #else
 125
 126 /* init 640X480 SVGA */
 127 static struct reginfo sensor_init_data[] =
 128 {
 129         {0x0010,0x0001},        // Reset
 130         {0x1030,0x0000},        // Clear host interrupt so main will wait
 131         {0x0014,0x0001},        // ARM go
 132         // Wait100mSec
 133         {SEQUENCE_WAIT_MS,50},
 134         // Start TP part
 135         {0x0028,0x7000},        // start add MSW
 136         {0x002A,0x1d60},        // start add LSW
 137         {0x0F12,0xb570},
 138         {0x0F12,0x4928},
 139         {0x0F12,0x4828},
 140         {0x0F12,0x2205},
 141         {0x0F12,0xf000},
 142         {0x0F12,0xf922},
 143         {0x0F12,0x4927},
 144         {0x0F12,0x2002},
 145         {0x0F12,0x83c8},
 146         {0x0F12,0x2001},
 147         {0x0F12,0x3120},
 148         {0x0F12,0x8088},
 149         {0x0F12,0x4925},
 150         {0x0F12,0x4826},
 151         {0x0F12,0x2204},
 152         {0x0F12,0xf000},
 153         {0x0F12,0xf917},
 154         {0x0F12,0x4925},
 155         {0x0F12,0x4825},
 156         {0x0F12,0x2206},
 157         {0x0F12,0xf000},
 158         {0x0F12,0xf912},
 159         {0x0F12,0x4924},
 160         {0x0F12,0x4825},
 161         {0x0F12,0x2207},
 162         {0x0F12,0xf000},
 163         {0x0F12,0xf90d},
 164         {0x0F12,0x4924},
 165         {0x0F12,0x4824},
 166         {0x0F12,0x2208},
 167         {0x0F12,0xf000},
 168         {0x0F12,0xf908},
 169         {0x0F12,0x4923},
 170         {0x0F12,0x4824},
 171         {0x0F12,0x2209},
 172         {0x0F12,0xf000},
 173         {0x0F12,0xf903},
 174         {0x0F12,0x4923},
 175         {0x0F12,0x4823},
 176         {0x0F12,0x60c1},
 177         {0x0F12,0x6882},
 178         {0x0F12,0x1a51},
 179         {0x0F12,0x8201},
 180         {0x0F12,0x4c22},
 181         {0x0F12,0x2607},
 182         {0x0F12,0x6821},
 183         {0x0F12,0x0736},
 184         {0x0F12,0x42b1},
 185         {0x0F12,0xda05},
 186         {0x0F12,0x4820},
 187         {0x0F12,0x22d8},
 188         {0x0F12,0x1c05},
 189         {0x0F12,0xf000},
 190         {0x0F12,0xf8fa},
 191         {0x0F12,0x6025},
 192         {0x0F12,0x68a1},
 193         {0x0F12,0x42b1},
 194         {0x0F12,0xda07},
 195         {0x0F12,0x481b},
 196         {0x0F12,0x2224},
 197         {0x0F12,0x3824},
 198         {0x0F12,0xf000},
 199         {0x0F12,0xf8f1},
 200         {0x0F12,0x4819},
 201         {0x0F12,0x3824},
 202         {0x0F12,0x60a0},
 203         {0x0F12,0x4d18},
 204         {0x0F12,0x6d29},
 205         {0x0F12,0x42b1},
 206         {0x0F12,0xda07},
 207         {0x0F12,0x4815},
 208         {0x0F12,0x228f},
 209         {0x0F12,0x00d2},
 210         {0x0F12,0x30d8},
 211         {0x0F12,0x1c04},
 212         {0x0F12,0xf000},
 213         {0x0F12,0xf8e3},
 214         {0x0F12,0x652c},
 215         {0x0F12,0xbc70},
 216         {0x0F12,0xbc08},
 217         {0x0F12,0x4718},
 218         {0x0F12,0x0000},
 219         {0x0F12,0x1f53},
 220         {0x0F12,0x7000},
 221         {0x0F12,0x127b},
 222         {0x0F12,0x0000},
 223         {0x0F12,0x0398},
 224         {0x0F12,0x7000},
 225         {0x0F12,0x1e4d},
 226         {0x0F12,0x7000},
 227         {0x0F12,0x890d},
 228         {0x0F12,0x0000},
 229         {0x0F12,0x1e73},
 230         {0x0F12,0x7000},
 231         {0x0F12,0x27a9},
 232         {0x0F12,0x0000},
 233         {0x0F12,0x1e91},
 234         {0x0F12,0x7000},
 235         {0x0F12,0x27c5},
 236         {0x0F12,0x0000},
 237         {0x0F12,0x1ef7},
 238         {0x0F12,0x7000},
 239         {0x0F12,0x285f},
 240         {0x0F12,0x0000},
 241         {0x0F12,0x1eb3},
 242         {0x0F12,0x7000},
 243         {0x0F12,0x28ff},
 244         {0x0F12,0x0000},
 245         {0x0F12,0x206c},
 246         {0x0F12,0x7000},
 247         {0x0F12,0x04ac},
 248         {0x0F12,0x7000},
 249         {0x0F12,0x06cc},
 250         {0x0F12,0x7000},
 251         {0x0F12,0x23a4},
 252         {0x0F12,0x7000},
 253         {0x0F12,0x0704},
 254         {0x0F12,0x7000},
 255         {0x0F12,0xb510},
 256         {0x0F12,0x1c04},
 257         {0x0F12,0x484d},
 258         {0x0F12,0xf000},
 259         {0x0F12,0xf8bb},
 260         {0x0F12,0x4a4d},
 261         {0x0F12,0x4b4d},
 262         {0x0F12,0x8811},
 263         {0x0F12,0x885b},
 264         {0x0F12,0x8852},
 265         {0x0F12,0x4359},
 266         {0x0F12,0x1889},
 267         {0x0F12,0x4288},
 268         {0x0F12,0xd800},
 269         {0x0F12,0x1c08},
 270         {0x0F12,0x6020},
 271         {0x0F12,0xbc10},
 272         {0x0F12,0xbc08},
 273         {0x0F12,0x4718},
 274         {0x0F12,0xb510},
 275         {0x0F12,0x1c04},
 276         {0x0F12,0xf000},
 277         {0x0F12,0xf8b1},
 278         {0x0F12,0x4944},
 279         {0x0F12,0x8989},
 280         {0x0F12,0x4348},
 281         {0x0F12,0x0200},
 282         {0x0F12,0x0c00},
 283         {0x0F12,0x2101},
 284         {0x0F12,0x0349},
 285         {0x0F12,0xf000},
 286         {0x0F12,0xf8b0},
 287         {0x0F12,0x6020},
 288         {0x0F12,0xe7ed},
 289         {0x0F12,0xb510},
 290         {0x0F12,0x1c04},
 291         {0x0F12,0xf000},
 292         {0x0F12,0xf8b2},
 293         {0x0F12,0x6821},
 294         {0x0F12,0x0409},
 295         {0x0F12,0x0c09},
 296         {0x0F12,0x1a40},
 297         {0x0F12,0x493a},
 298         {0x0F12,0x6849},
 299         {0x0F12,0x4281},
 300         {0x0F12,0xd800},
 301         {0x0F12,0x1c08},
 302         {0x0F12,0xf000},
 303         {0x0F12,0xf8af},
 304         {0x0F12,0x6020},
 305         {0x0F12,0xe7dc},
 306         {0x0F12,0xb570},
 307         {0x0F12,0x6801},
 308         {0x0F12,0x040d},
 309         {0x0F12,0x0c2d},
 310         {0x0F12,0x6844},
 311         {0x0F12,0x4833},
 312         {0x0F12,0x8981},
 313         {0x0F12,0x1c28},
 314         {0x0F12,0xf000},
 315         {0x0F12,0xf893},
 316         {0x0F12,0x8060},
 317         {0x0F12,0x4932},
 318         {0x0F12,0x69c9},
 319         {0x0F12,0xf000},
 320         {0x0F12,0xf8a6},
 321         {0x0F12,0x1c01},
 322         {0x0F12,0x80a0},
 323         {0x0F12,0x0228},
 324         {0x0F12,0xf000},
 325         {0x0F12,0xf8a9},
 326         {0x0F12,0x0400},
 327         {0x0F12,0x0c00},
 328         {0x0F12,0x8020},
 329         {0x0F12,0x492d},
 330         {0x0F12,0x2300},
 331         {0x0F12,0x5ec9},
 332         {0x0F12,0x4288},
 333         {0x0F12,0xda02},
 334         {0x0F12,0x20ff},
 335         {0x0F12,0x3001},
 336         {0x0F12,0x8020},
 337         {0x0F12,0xbc70},
 338         {0x0F12,0xbc08},
 339         {0x0F12,0x4718},
 340         {0x0F12,0xb570},
 341         {0x0F12,0x1c04},
 342         {0x0F12,0x4828},
 343         {0x0F12,0x4926},
 344         {0x0F12,0x7803},
 345         {0x0F12,0x6a8a},
 346         {0x0F12,0x2b00},
 347         {0x0F12,0xd100},
 348         {0x0F12,0x6a0a},
 349         {0x0F12,0x4d20},
 350         {0x0F12,0x2b00},
 351         {0x0F12,0x68a8},
 352         {0x0F12,0xd100},
 353         {0x0F12,0x6868},
 354         {0x0F12,0x6823},
 355         {0x0F12,0x8dc9},
 356         {0x0F12,0x434a},
 357         {0x0F12,0x0a12},
 358         {0x0F12,0x429a},
 359         {0x0F12,0xd30d},
 360         {0x0F12,0x4d20},
 361         {0x0F12,0x26ff},
 362         {0x0F12,0x8828},
 363         {0x0F12,0x3601},
 364         {0x0F12,0x43b0},
 365         {0x0F12,0x8028},
 366         {0x0F12,0x6820},
 367         {0x0F12,0xf000},
 368         {0x0F12,0xf884},
 369         {0x0F12,0x6020},
 370         {0x0F12,0x8828},
 371         {0x0F12,0x4330},
 372         {0x0F12,0x8028},
 373         {0x0F12,0xe7da},
 374         {0x0F12,0x1c0a},
 375         {0x0F12,0x4342},
 376         {0x0F12,0x0a12},
 377         {0x0F12,0x429a},
 378         {0x0F12,0xd304},
 379         {0x0F12,0x0218},
 380         {0x0F12,0xf000},
 381         {0x0F12,0xf871},
 382         {0x0F12,0x6020},
 383         {0x0F12,0xe7f4},
 384         {0x0F12,0x6020},
 385         {0x0F12,0xe7f2},
 386         {0x0F12,0xb510},
 387         {0x0F12,0x4913},
 388         {0x0F12,0x8fc8},
 389         {0x0F12,0x2800},
 390         {0x0F12,0xd007},
 391         {0x0F12,0x2000},
 392         {0x0F12,0x87c8},
 393         {0x0F12,0x8f88},
 394         {0x0F12,0x4c11},
 395         {0x0F12,0x2800},
 396         {0x0F12,0xd002},
 397         {0x0F12,0x2008},
 398         {0x0F12,0x8020},
 399         {0x0F12,0xe77e},
 400         {0x0F12,0x480d},
 401         {0x0F12,0x3060},
 402         {0x0F12,0x8900},
 403         {0x0F12,0x2800},
 404         {0x0F12,0xd103},
 405         {0x0F12,0x480c},
 406         {0x0F12,0x2101},
 407         {0x0F12,0xf000},
 408         {0x0F12,0xf864},
 409         {0x0F12,0x2010},
 410         {0x0F12,0x8020},
 411         {0x0F12,0xe7f2},
 412         {0x0F12,0x0000},
 413         {0x0F12,0xf4b0},
 414         {0x0F12,0x0000},
 415         {0x0F12,0x2058},
 416         {0x0F12,0x7000},
 417         {0x0F12,0x1554},
 418         {0x0F12,0x7000},
 419         {0x0F12,0x0080},
 420         {0x0F12,0x7000},
 421         {0x0F12,0x046c},
 422         {0x0F12,0x7000},
 423         {0x0F12,0x0468},
 424         {0x0F12,0x7000},
 425         {0x0F12,0x1100},
 426         {0x0F12,0xd000},
 427         {0x0F12,0x01b8},
 428         {0x0F12,0x7000},
 429         {0x0F12,0x044e},
 430         {0x0F12,0x7000},
 431         {0x0F12,0x0450},
 432         {0x0F12,0x7000},
 433         {0x0F12,0x4778},
 434         {0x0F12,0x46c0},
 435         {0x0F12,0xc000},
 436         {0x0F12,0xe59f},
 437         {0x0F12,0xff1c},
 438         {0x0F12,0xe12f},
 439         {0x0F12,0x9ce7},
 440         {0x0F12,0x0000},
 441         {0x0F12,0x4778},
 442         {0x0F12,0x46c0},
 443         {0x0F12,0xf004},
 444         {0x0F12,0xe51f},
 445         {0x0F12,0x9fb8},
 446         {0x0F12,0x0000},
 447         {0x0F12,0x4778},
 448         {0x0F12,0x46c0},
 449         {0x0F12,0xc000},
 450         {0x0F12,0xe59f},
 451         {0x0F12,0xff1c},
 452         {0x0F12,0xe12f},
 453         {0x0F12,0x88df},
 454         {0x0F12,0x0000},
 455         {0x0F12,0x4778},
 456         {0x0F12,0x46c0},
 457         {0x0F12,0xc000},
 458         {0x0F12,0xe59f},
 459         {0x0F12,0xff1c},
 460         {0x0F12,0xe12f},
 461         {0x0F12,0x275d},
 462         {0x0F12,0x0000},
 463         {0x0F12,0x4778},
 464         {0x0F12,0x46c0},
 465         {0x0F12,0xc000},
 466         {0x0F12,0xe59f},
 467         {0x0F12,0xff1c},
 468         {0x0F12,0xe12f},
 469         {0x0F12,0x1ed3},
 470         {0x0F12,0x0000},
 471         {0x0F12,0x4778},
 472         {0x0F12,0x46c0},
 473         {0x0F12,0xc000},
 474         {0x0F12,0xe59f},
 475         {0x0F12,0xff1c},
 476         {0x0F12,0xe12f},
 477         {0x0F12,0x26f9},
 478         {0x0F12,0x0000},
 479         {0x0F12,0x4778},
 480         {0x0F12,0x46c0},
 481         {0x0F12,0xc000},
 482         {0x0F12,0xe59f},
 483         {0x0F12,0xff1c},
 484         {0x0F12,0xe12f},
 485         {0x0F12,0x4027},
 486         {0x0F12,0x0000},
 487         {0x0F12,0x4778},
 488         {0x0F12,0x46c0},
 489         {0x0F12,0xc000},
 490         {0x0F12,0xe59f},
 491         {0x0F12,0xff1c},
 492         {0x0F12,0xe12f},
 493         {0x0F12,0x9f03},
 494         {0x0F12,0x0000},
 495         {0x0F12,0x4778},
 496         {0x0F12,0x46c0},
 497         {0x0F12,0xf004},
 498         {0x0F12,0xe51f},
 499         {0x0F12,0xa144},
 500         {0x0F12,0x0000},
 501         {0x0F12,0x4778},
 502         {0x0F12,0x46c0},
 503         {0x0F12,0xc000},
 504         {0x0F12,0xe59f},
 505         {0x0F12,0xff1c},
 506         {0x0F12,0xe12f},
 507         {0x0F12,0x285f},
 508         {0x0F12,0x0000},
 509         {0x0F12,0x4778},
 510         {0x0F12,0x46c0},
 511         {0x0F12,0xc000},
 512         {0x0F12,0xe59f},
 513         {0x0F12,0xff1c},
 514         {0x0F12,0xe12f},
 515         {0x0F12,0x2001},
 516         {0x0F12,0x0000},
 517         {0x0F12,0x0000},
 518         {0x0F12,0x0000},
 519         {0x0F12,0xe848},
 520         {0x0F12,0x0001},
 521         {0x0F12,0xe848},
 522         {0x0F12,0x0001},
 523         {0x0F12,0x0500},
 524         {0x0F12,0x0000},
 525         {0x0F12,0x0000},
 526         {0x0F12,0x0000},
 527         // End TP part
 528
 529
 530         // Start tuning part
 531
 532         //      Write memory example:
 533         //      m70003000 10CE
 534         //      Write HW register example:
 535         //      1004 5678
 536
 537         {0x002A,0x0e3a},  // #awbb_Alpha_Comp_Mode
 538         {0x0F12,0x02C2},
 539
 540         // Analog Settings
 541         {0x002A,0x112a},  //#senHal_SenRegsModes3_pSenModesRegsArray3[8]
 542         {0x0F12,0x0000},
 543         {0x002A,0x1132},  //#senHal_SenRegsModes3_pSenModesRegsArray3[12]
 544         {0x0F12,0x0000},
 545         {0x002A,0x113e},  //#senHal_SenRegsModes3_pSenModesRegsArray3[18]
 546         {0x0F12,0x0000},
 547         {0x002A,0x115c},  //#senHal_SenRegsModes3_pSenModesRegsArray3[33]
 548         {0x0F12,0x0000},
 549         {0x002A,0x1164},  //#senHal_SenRegsModes3_pSenModesRegsArray3[37]
 550         {0x0F12,0x0000},
 551         {0x002A,0x1174},  //#senHal_SenRegsModes3_pSenModesRegsArray3[45]
 552         {0x0F12,0x0000},
 553         {0x002A,0x1178},  //#senHal_SenRegsModes3_pSenModesRegsArray3[47]
 554         {0x0F12,0x0000},
 555
 556         {0x002A,0x077a},  //#msm_uOffsetNoBin[0][0]
 557         {0x0F12,0x0000},  //#msm_uOffsetNoBin[0][1]
 558         {0x0F12,0x0000},        //#msm_uOffsetNoBin[1][0]
 559         {0x0F12,0x0000},        //#msm_uOffsetNoBin[1][1]
 560         {0x0F12,0x0000},        //#msm_uOffsetNoBin[2][0]
 561         {0x0F12,0x0000},        //#msm_uOffsetNoBin[2][1]
 562         {0x0F12,0x0000},        //#msm_uOffsetNoBin[3][0]
 563         {0x0F12,0x0000},        //#msm_uOffsetNoBin[3][1]
 564         {0x0F12,0x0000},
 565
 566         {0x002A,0x07a2},  //#msm_sAnalogOffset[0]
 567         {0x0F12,0x0000},         //#msm_sAnalogOffset[1]
 568         {0x0F12,0x0000},         //#msm_sAnalogOffset[2]
 569         {0x0F12,0x0000},         //#msm_sAnalogOffset[3]
 570         {0x0F12,0x0000},
 571
 572         {0x002A,0x07b6},  //#msm_NonLinearOfsOutput[0]
 573         {0x0F12,0x0000},         //#msm_NonLinearOfsOutput[1]
 574         {0x0F12,0x0002},         //#msm_NonLinearOfsOutput[2]
 575         {0x0F12,0x0004},         //#msm_NonLinearOfsOutput[3]
 576         {0x0F12,0x0004},         //#msm_NonLinearOfsOutput[4]
 577         {0x0F12,0x0005},         //#msm_NonLinearOfsOutput[5]
 578         {0x0F12,0x0005},
 579
 580         //      param_start     TVAR_ash_GASAlpha
 581         {0x002A,0x0712},
 582         {0x0F12,0x0149},
 583         {0x0F12,0x011B},
 584         {0x0F12,0x0120},
 585         {0x0F12,0x00EF},
 586         {0x0F12,0x00C3},
 587         {0x0F12,0x00D2},
 588         {0x0F12,0x00DC},
 589         {0x0F12,0x00B8},
 590         {0x0F12,0x0106},
 591         {0x0F12,0x00DE},
 592         {0x0F12,0x00E3},
 593         {0x0F12,0x00CC},
 594         {0x0F12,0x00BD},
 595         {0x0F12,0x00E1},
 596         {0x0F12,0x00D8},
 597         {0x0F12,0x00D0},
 598         {0x0F12,0x00BE},
 599         {0x0F12,0x00EC},
 600         {0x0F12,0x00EA},
 601         {0x0F12,0x00F2},
 602         {0x0F12,0x00BE},
 603         {0x0F12,0x00EB},
 604         {0x0F12,0x00E5},
 605         {0x0F12,0x00F9},
 606         {0x0F12,0x0100},  //0x00BE
 607         {0x0F12,0x00D5},
 608         {0x0F12,0x00D8},
 609         {0x0F12,0x00E6},
 610
 611         //      param_end       TVAR_ash_GASAlpha
 612         //      param_start     TVAR_ash_GASOutdoorAlpha
 613         {0x0F12,0x00FD},
 614         {0x0F12,0x00F7},
 615         {0x0F12,0x00F3},
 616         {0x0F12,0x00FF},
 617         //      param_end       TVAR_ash_GASOutdoorAlpha
 618         {0x002A,0x075A},
 619         {0x0F12,0x0001},
 620         {0x0F12,0x02A1},
 621         {0x0F12,0x0225},
 622         {0x0F12,0x000D},
 623         {0x0F12,0x000D},
 624         //      param_start     TVAR_ash_pGAS
 625         {0x002A,0x247C},
 626         {0x0F12,0x0164},        //TVAR_ash_pGAS[0]   0128  //018C
 627         {0x0F12,0x0122},        //TVAR_ash_pGAS[1]   00F6  //0147
 628         {0x0F12,0x00E4},        //TVAR_ash_pGAS[2]   00C7  //010E
 629         {0x0F12,0x00B8},        //TVAR_ash_pGAS[3]   00B7  //00E5
 630         {0x0F12,0x009D},        //TVAR_ash_pGAS[4]   00AA  //00C5
 631         {0x0F12,0x008D},        //TVAR_ash_pGAS[5]   009D  //00B0
 632         {0x0F12,0x0083},        //TVAR_ash_pGAS[6]   0097  //00A7
 633         {0x0F12,0x0088},        //TVAR_ash_pGAS[7]   0097  //00AA
 634         {0x0F12,0x009C},        //TVAR_ash_pGAS[8]   009E  //00B8
 635         {0x0F12,0x00BB},        //TVAR_ash_pGAS[9]   00A9  //00D1
 636         {0x0F12,0x00E5},        //TVAR_ash_pGAS[10]  00B4  //00F7
 637         {0x0F12,0x0121},        //TVAR_ash_pGAS[11]  00CA  //0130
 638         {0x0F12,0x0169},        //TVAR_ash_pGAS[12]  0105  //016F
 639         {0x0F12,0x0138},        //TVAR_ash_pGAS[13]  00DA  //0148
 640         {0x0F12,0x00FB},        //TVAR_ash_pGAS[14]  00B4  //010A
 641         {0x0F12,0x00B9},        //TVAR_ash_pGAS[15]  0099  //00D2
 642         {0x0F12,0x008C},        //TVAR_ash_pGAS[16]  0089  //00AB
 643         {0x0F12,0x006E},        //TVAR_ash_pGAS[17]  0077  //008F
 644         {0x0F12,0x005B},        //TVAR_ash_pGAS[18]  006A  //007B
 645         {0x0F12,0x0053},        //TVAR_ash_pGAS[19]  0063  //0073
 646         {0x0F12,0x0059},        //TVAR_ash_pGAS[20]  0064  //0075
 647         {0x0F12,0x006B},        //TVAR_ash_pGAS[21]  006D  //0085
 648         {0x0F12,0x0086},        //TVAR_ash_pGAS[22]  007B  //009D
 649         {0x0F12,0x00B1},        //TVAR_ash_pGAS[23]  008B  //00C1
 650         {0x0F12,0x00E9},        //TVAR_ash_pGAS[24]  009C  //00F7
 651         {0x0F12,0x012F},        //TVAR_ash_pGAS[25]  00BD  //0134
 652         {0x0F12,0x0111},        //TVAR_ash_pGAS[26]  00A4  //0111
 653         {0x0F12,0x00D1},        //TVAR_ash_pGAS[27]  0093  //00D5
 654         {0x0F12,0x0094},        //TVAR_ash_pGAS[28]  0079  //00A1
 655         {0x0F12,0x0069},        //TVAR_ash_pGAS[29]  0063  //007B
 656         {0x0F12,0x004A},        //TVAR_ash_pGAS[30]  004F  //005F
 657         {0x0F12,0x0036},        //TVAR_ash_pGAS[31]  0040  //004B
 658         {0x0F12,0x002C},        //TVAR_ash_pGAS[32]  0039  //0043
 659         {0x0F12,0x0032},        //TVAR_ash_pGAS[33]  003B  //0046
 660         {0x0F12,0x0042},        //TVAR_ash_pGAS[34]  0044  //0057
 661         {0x0F12,0x0060},        //TVAR_ash_pGAS[35]  0054  //0072
 662         {0x0F12,0x008A},        //TVAR_ash_pGAS[36]  006A  //0093
 663         {0x0F12,0x00C0},        //TVAR_ash_pGAS[37]  0081  //00C7
 664         {0x0F12,0x0103},        //TVAR_ash_pGAS[38]  009B  //00FD
 665         {0x0F12,0x00F9},        //TVAR_ash_pGAS[39]  008D  //00EA
 666         {0x0F12,0x00B7},        //TVAR_ash_pGAS[40]  007E  //00B1
 667         {0x0F12,0x007E},        //TVAR_ash_pGAS[41]  005F  //0080
 668         {0x0F12,0x0054},        //TVAR_ash_pGAS[42]  0046  //005A
 669         {0x0F12,0x0033},        //TVAR_ash_pGAS[43]  0032  //003D
 670         {0x0F12,0x001B},        //TVAR_ash_pGAS[44]  0023  //0029
 671         {0x0F12,0x0013},        //TVAR_ash_pGAS[45]  001C  //0021
 672         {0x0F12,0x0018},        //TVAR_ash_pGAS[46]  001E  //0025
 673         {0x0F12,0x002A},        //TVAR_ash_pGAS[47]  0026  //0036
 674         {0x0F12,0x004A},        //TVAR_ash_pGAS[48]  0038  //0051
 675         {0x0F12,0x0075},        //TVAR_ash_pGAS[49]  004F  //0074
 676         {0x0F12,0x00AC},        //TVAR_ash_pGAS[50]  006A  //00A3
 677         {0x0F12,0x00F0},        //TVAR_ash_pGAS[51]  0088  //00DA
 678         {0x0F12,0x00EF},        //TVAR_ash_pGAS[52]  0081  //00D2
 679         {0x0F12,0x00AE},        //TVAR_ash_pGAS[53]  0070  //009B
 680         {0x0F12,0x0076},        //TVAR_ash_pGAS[54]  004F  //006B
 681         {0x0F12,0x004A},        //TVAR_ash_pGAS[55]  0034  //0043
 682         {0x0F12,0x0025},        //TVAR_ash_pGAS[56]  001F  //0027
 683         {0x0F12,0x000D},        //TVAR_ash_pGAS[57]  0010  //0013
 684         {0x0F12,0x0004},        //TVAR_ash_pGAS[58]  0009  //000A
 685         {0x0F12,0x000A},        //TVAR_ash_pGAS[59]  000B  //000F
 686         {0x0F12,0x001E},        //TVAR_ash_pGAS[60]  0015  //0021
 687         {0x0F12,0x003F},        //TVAR_ash_pGAS[61]  0026  //003D
 688         {0x0F12,0x006C},        //TVAR_ash_pGAS[62]  0040  //0060
 689         {0x0F12,0x00A7},        //TVAR_ash_pGAS[63]  005D  //0091
 690         {0x0F12,0x00EA},        //TVAR_ash_pGAS[64]  007E  //00C2
 691         {0x0F12,0x00F6},        //TVAR_ash_pGAS[65]  007C  //00C6
 692         {0x0F12,0x00B3},        //TVAR_ash_pGAS[66]  0068  //0094
 693         {0x0F12,0x007B},        //TVAR_ash_pGAS[67]  0047  //0063
 694         {0x0F12,0x004C},        //TVAR_ash_pGAS[68]  002C  //003B
 695         {0x0F12,0x0024},        //TVAR_ash_pGAS[69]  0017  //001E
 696         {0x0F12,0x000B},        //TVAR_ash_pGAS[70]  0007  //0009
 697         {0x0F12,0x0000},        //TVAR_ash_pGAS[71]  0000  //0000
 698         {0x0F12,0x0007},        //TVAR_ash_pGAS[72]  0002  //0006
 699         {0x0F12,0x001E},        //TVAR_ash_pGAS[73]  000D  //0019
 700         {0x0F12,0x0041},        //TVAR_ash_pGAS[74]  0020  //0035
 701         {0x0F12,0x0071},        //TVAR_ash_pGAS[75]  003A  //005A
 702         {0x0F12,0x00AD},        //TVAR_ash_pGAS[76]  0059  //0089
 703         {0x0F12,0x00F3},        //TVAR_ash_pGAS[77]  007E  //00BA
 704         {0x0F12,0x010B},        //TVAR_ash_pGAS[78]  007E  //00C8
 705         {0x0F12,0x00C6},        //TVAR_ash_pGAS[79]  006A  //0095
 706         {0x0F12,0x0089},        //TVAR_ash_pGAS[80]  0048  //0063
 707         {0x0F12,0x0058},        //TVAR_ash_pGAS[81]  002D  //003D
 708         {0x0F12,0x0032},        //TVAR_ash_pGAS[82]  0018  //0020
 709         {0x0F12,0x0017},        //TVAR_ash_pGAS[83]  0008  //000D
 710         {0x0F12,0x000D},        //TVAR_ash_pGAS[84]  0001  //0004
 711         {0x0F12,0x0015},        //TVAR_ash_pGAS[85]  0003  //0009
 712         {0x0F12,0x002D},        //TVAR_ash_pGAS[86]  000E  //001C
 713         {0x0F12,0x0053},        //TVAR_ash_pGAS[87]  0021  //0038
 714         {0x0F12,0x0085},        //TVAR_ash_pGAS[88]  003D  //005F
 715         {0x0F12,0x00C4},        //TVAR_ash_pGAS[89]  0060  //008E
 716         {0x0F12,0x010B},        //TVAR_ash_pGAS[90]  0086  //00BE
 717         {0x0F12,0x012F},        //TVAR_ash_pGAS[91]  0087  //00D7
 718         {0x0F12,0x00E7},        //TVAR_ash_pGAS[92]  0073  //00A1
 719         {0x0F12,0x00A7},        //TVAR_ash_pGAS[93]  0051  //006E
 720         {0x0F12,0x0073},        //TVAR_ash_pGAS[94]  0036  //0049
 721         {0x0F12,0x004E},        //TVAR_ash_pGAS[95]  0022  //002D
 722         {0x0F12,0x0033},        //TVAR_ash_pGAS[96]  0013  //001B
 723         {0x0F12,0x002A},        //TVAR_ash_pGAS[97]  000B  //0014
 724         {0x0F12,0x0032},        //TVAR_ash_pGAS[98]  000D  //001A
 725         {0x0F12,0x004B},        //TVAR_ash_pGAS[99]  0019  //002C
 726         {0x0F12,0x0072},        //TVAR_ash_pGAS[100] 002C  //0048
 727         {0x0F12,0x00A7},        //TVAR_ash_pGAS[101] 004A  //006C
 728         {0x0F12,0x00E9},        //TVAR_ash_pGAS[102] 006F  //009D
 729         {0x0F12,0x0133},        //TVAR_ash_pGAS[103] 0093  //00D1
 730         {0x0F12,0x0162},        //TVAR_ash_pGAS[104] 0099  //00F3
 731         {0x0F12,0x0110},        //TVAR_ash_pGAS[105] 0086  //00B9
 732         {0x0F12,0x00CE},        //TVAR_ash_pGAS[106] 0066  //0086
 733         {0x0F12,0x009B},        //TVAR_ash_pGAS[107] 004A  //0063
 734         {0x0F12,0x0078},        //TVAR_ash_pGAS[108] 0035  //0047
 735         {0x0F12,0x0060},        //TVAR_ash_pGAS[109] 0025  //0034
 736         {0x0F12,0x0057},        //TVAR_ash_pGAS[110] 001E  //002E
 737         {0x0F12,0x0061},        //TVAR_ash_pGAS[111] 0021  //0034
 738         {0x0F12,0x0079},        //TVAR_ash_pGAS[112] 002C  //0046
 739         {0x0F12,0x00A2},        //TVAR_ash_pGAS[113] 0041  //0062
 740         {0x0F12,0x00D8},        //TVAR_ash_pGAS[114] 0061  //0087
 741         {0x0F12,0x011E},        //TVAR_ash_pGAS[115] 0087  //00B8
 742         {0x0F12,0x016E},        //TVAR_ash_pGAS[116] 00A8  //00F2
 743         {0x0F12,0x01A8},        //TVAR_ash_pGAS[117] 00B8  //011D
 744         {0x0F12,0x014D},        //TVAR_ash_pGAS[118] 00A1  //00E5
 745         {0x0F12,0x0104},        //TVAR_ash_pGAS[119] 0084  //00B0
 746         {0x0F12,0x00D5},        //TVAR_ash_pGAS[120] 0069  //0089
 747         {0x0F12,0x00B3},        //TVAR_ash_pGAS[121] 0054  //006F
 748         {0x0F12,0x009B},        //TVAR_ash_pGAS[122] 0044  //005D
 749         {0x0F12,0x0095},        //TVAR_ash_pGAS[123] 003E  //0057
 750         {0x0F12,0x009E},        //TVAR_ash_pGAS[124] 0040  //005D
 751         {0x0F12,0x00B7},        //TVAR_ash_pGAS[125] 004C  //006E
 752         {0x0F12,0x00E1},        //TVAR_ash_pGAS[126] 0063  //008B
 753         {0x0F12,0x0119},        //TVAR_ash_pGAS[127] 0083  //00B3
 754         {0x0F12,0x0166},        //TVAR_ash_pGAS[128] 00A8  //00E6
 755         {0x0F12,0x01C6},        //TVAR_ash_pGAS[129] 00C9  //0129
 756         {0x0F12,0x01F1},        //TVAR_ash_pGAS[130] 00EE  //013E
 757         {0x0F12,0x0199},        //TVAR_ash_pGAS[131] 00C4  //010D
 758         {0x0F12,0x014D},        //TVAR_ash_pGAS[132] 00AB  //00D8
 759         {0x0F12,0x011A},        //TVAR_ash_pGAS[133] 0091  //00B2
 760         {0x0F12,0x00F5},        //TVAR_ash_pGAS[134] 007B  //0096
 761         {0x0F12,0x00DD},        //TVAR_ash_pGAS[135] 006D  //0084
 762         {0x0F12,0x00D8},        //TVAR_ash_pGAS[136] 0066  //007E
 763         {0x0F12,0x00E4},        //TVAR_ash_pGAS[137] 0068  //0083
 764         {0x0F12,0x00FB},        //TVAR_ash_pGAS[138] 0075  //0096
 765         {0x0F12,0x0128},        //TVAR_ash_pGAS[139] 008E  //00B3
 766         {0x0F12,0x0166},        //TVAR_ash_pGAS[140] 00AF  //00DB
 767         {0x0F12,0x01BC},        //TVAR_ash_pGAS[141] 00D0  //0117
 768         {0x0F12,0x0228},        //TVAR_ash_pGAS[142] 00F7  //0151
 769         {0x0F12,0x0133},        //TVAR_ash_pGAS[143] 00E3  //014A
 770         {0x0F12,0x00F7},        //TVAR_ash_pGAS[144] 00AB  //0108
 771         {0x0F12,0x00BF},        //TVAR_ash_pGAS[145] 0086  //00D7
 772         {0x0F12,0x0097},        //TVAR_ash_pGAS[146] 0081  //00B5
 773         {0x0F12,0x0081},        //TVAR_ash_pGAS[147] 0078  //009E
 774         {0x0F12,0x0074},        //TVAR_ash_pGAS[148] 0071  //0090
 775         {0x0F12,0x006A},        //TVAR_ash_pGAS[149] 006B  //0089
 776         {0x0F12,0x006B},        //TVAR_ash_pGAS[150] 0069  //0089
 777         {0x0F12,0x007B},        //TVAR_ash_pGAS[151] 006A  //0090
 778         {0x0F12,0x008F},        //TVAR_ash_pGAS[152] 006E  //00A0
 779         {0x0F12,0x00B1},        //TVAR_ash_pGAS[153] 0071  //00B8
 780         {0x0F12,0x00E4},        //TVAR_ash_pGAS[154] 007D  //00E6
 781         {0x0F12,0x0128},        //TVAR_ash_pGAS[155] 00B0  //011F
 782         {0x0F12,0x010B},        //TVAR_ash_pGAS[156] 0096  //010B
 783         {0x0F12,0x00D4},        //TVAR_ash_pGAS[157] 0071  //00CE
 784         {0x0F12,0x0098},        //TVAR_ash_pGAS[158] 0061  //00A4
 785         {0x0F12,0x006F},        //TVAR_ash_pGAS[159] 005B  //0085
 786         {0x0F12,0x0056},        //TVAR_ash_pGAS[160] 0051  //0073
 787         {0x0F12,0x0045},        //TVAR_ash_pGAS[161] 0049  //0064
 788         {0x0F12,0x003D},        //TVAR_ash_pGAS[162] 0043  //005D
 789         {0x0F12,0x0040},        //TVAR_ash_pGAS[163] 0042  //005E
 790         {0x0F12,0x004D},        //TVAR_ash_pGAS[164] 0044  //0066
 791         {0x0F12,0x0060},        //TVAR_ash_pGAS[165] 004C  //0076
 792         {0x0F12,0x0081},        //TVAR_ash_pGAS[166] 0051  //008F
 793         {0x0F12,0x00B0},        //TVAR_ash_pGAS[167] 0056  //00B7
 794         {0x0F12,0x00EB},        //TVAR_ash_pGAS[168] 006F  //00EB
 795         {0x0F12,0x00EC},        //TVAR_ash_pGAS[169] 006B  //00D7
 796         {0x0F12,0x00B0},        //TVAR_ash_pGAS[170] 005B  //00A3
 797         {0x0F12,0x007C},        //TVAR_ash_pGAS[171] 004E  //007C
 798         {0x0F12,0x0054},        //TVAR_ash_pGAS[172] 0043  //0061
 799         {0x0F12,0x0039},        //TVAR_ash_pGAS[173] 0037  //004C
 800         {0x0F12,0x0029},        //TVAR_ash_pGAS[174] 002E  //003F
 801         {0x0F12,0x001E},        //TVAR_ash_pGAS[175] 0029  //0038
 802         {0x0F12,0x0021},        //TVAR_ash_pGAS[176] 0028  //003A
 803         {0x0F12,0x002D},        //TVAR_ash_pGAS[177] 002B  //0044
 804         {0x0F12,0x0044},        //TVAR_ash_pGAS[178] 0033  //0056
 805         {0x0F12,0x0064},        //TVAR_ash_pGAS[179] 003D  //006D
 806         {0x0F12,0x008F},        //TVAR_ash_pGAS[180] 0046  //0091
 807         {0x0F12,0x00C8},        //TVAR_ash_pGAS[181] 0056  //00BD
 808         {0x0F12,0x00D6},        //TVAR_ash_pGAS[182] 0058  //00B7
 809         {0x0F12,0x009B},        //TVAR_ash_pGAS[183] 004C  //0086
 810         {0x0F12,0x0068},        //TVAR_ash_pGAS[184] 003B  //0062
 811         {0x0F12,0x0043},        //TVAR_ash_pGAS[185] 002E  //0046
 812         {0x0F12,0x0026},        //TVAR_ash_pGAS[186] 0022  //0031
 813         {0x0F12,0x0013},        //TVAR_ash_pGAS[187] 0019  //0022
 814         {0x0F12,0x000B},        //TVAR_ash_pGAS[188] 0014  //001C
 815         {0x0F12,0x000E},        //TVAR_ash_pGAS[189] 0014  //001E
 816         {0x0F12,0x001C},        //TVAR_ash_pGAS[190] 0017  //0029
 817         {0x0F12,0x0033},        //TVAR_ash_pGAS[191] 0020  //003B
 818         {0x0F12,0x0054},        //TVAR_ash_pGAS[192] 002C  //0055
 819         {0x0F12,0x0080},        //TVAR_ash_pGAS[193] 0039  //0076
 820         {0x0F12,0x00B9},        //TVAR_ash_pGAS[194] 004A  //00A0
 821         {0x0F12,0x00D1},        //TVAR_ash_pGAS[195] 004F  //00A1
 822         {0x0F12,0x0094},        //TVAR_ash_pGAS[196] 0043  //0074
 823         {0x0F12,0x0061},        //TVAR_ash_pGAS[197] 002F  //0050
 824         {0x0F12,0x003B},        //TVAR_ash_pGAS[198] 0022  //0033
 825         {0x0F12,0x001C},        //TVAR_ash_pGAS[199] 0015  //001E
 826         {0x0F12,0x0008},        //TVAR_ash_pGAS[200] 000C  //000F
 827         {0x0F12,0x0001},        //TVAR_ash_pGAS[201] 0007  //0009
 828         {0x0F12,0x0004},        //TVAR_ash_pGAS[202] 0007  //000B
 829         {0x0F12,0x0012},        //TVAR_ash_pGAS[203] 000B  //0017
 830         {0x0F12,0x002B},        //TVAR_ash_pGAS[204] 0016  //002A
 831         {0x0F12,0x0050},        //TVAR_ash_pGAS[205] 0023  //0044
 832         {0x0F12,0x007E},        //TVAR_ash_pGAS[206] 0032  //0066
 833         {0x0F12,0x00B6},        //TVAR_ash_pGAS[207] 0046  //008C
 834         {0x0F12,0x00D6},        //TVAR_ash_pGAS[208] 004C  //0098
 835         {0x0F12,0x0098},        //TVAR_ash_pGAS[209] 003E  //006D
 836         {0x0F12,0x0067},        //TVAR_ash_pGAS[210] 002a  //0049
 837         {0x0F12,0x003D},        //TVAR_ash_pGAS[211] 001C  //002B
 838         {0x0F12,0x001D},        //TVAR_ash_pGAS[212] 000F  //0016
 839         {0x0F12,0x0009},        //TVAR_ash_pGAS[213] 0006  //0006
 840         {0x0F12,0x0000},        //TVAR_ash_pGAS[214] 0001  //0000
 841         {0x0F12,0x0004},        //TVAR_ash_pGAS[215] 0002  //0004
 842         {0x0F12,0x0014},        //TVAR_ash_pGAS[216] 0007  //0010
 843         {0x0F12,0x002F},        //TVAR_ash_pGAS[217] 0013  //0023
 844         {0x0F12,0x0057},        //TVAR_ash_pGAS[218] 0021  //003E
 845         {0x0F12,0x0085},        //TVAR_ash_pGAS[219] 0032  //0060
 846         {0x0F12,0x00C1},        //TVAR_ash_pGAS[220] 0048  //0085
 847         {0x0F12,0x00EA},        //TVAR_ash_pGAS[221] 004D  //0098
 848         {0x0F12,0x00AA},        //TVAR_ash_pGAS[222] 0040  //006E
 849         {0x0F12,0x0076},        //TVAR_ash_pGAS[223] 002C  //0048
 850         {0x0F12,0x004B},        //TVAR_ash_pGAS[224] 001E  //002C
 851         {0x0F12,0x002A},        //TVAR_ash_pGAS[225] 0011  //0018
 852         {0x0F12,0x0015},        //TVAR_ash_pGAS[226] 0008  //0009
 853         {0x0F12,0x000C},        //TVAR_ash_pGAS[227] 0004  //0003
 854         {0x0F12,0x0012},        //TVAR_ash_pGAS[228] 0004  //0006
 855         {0x0F12,0x0024},        //TVAR_ash_pGAS[229] 000A  //0012
 856         {0x0F12,0x0041},        //TVAR_ash_pGAS[230] 0017  //0026
 857         {0x0F12,0x006A},        //TVAR_ash_pGAS[231] 0026  //0042
 858         {0x0F12,0x009C},        //TVAR_ash_pGAS[232] 0039  //0063
 859         {0x0F12,0x00D9},        //TVAR_ash_pGAS[233] 0051  //0089
 860         {0x0F12,0x010A},        //TVAR_ash_pGAS[234] 0054  //00A3
 861         {0x0F12,0x00C9},        //TVAR_ash_pGAS[235] 0048  //0076
 862         {0x0F12,0x0092},        //TVAR_ash_pGAS[236] 0034  //0051
 863         {0x0F12,0x0065},        //TVAR_ash_pGAS[237] 0026  //0035
 864         {0x0F12,0x0045},        //TVAR_ash_pGAS[238] 001A  //0021
 865         {0x0F12,0x002E},        //TVAR_ash_pGAS[239] 0012  //0013
 866         {0x0F12,0x0027},        //TVAR_ash_pGAS[240] 000D  //000E
 867         {0x0F12,0x002E},        //TVAR_ash_pGAS[241] 000E  //0012
 868         {0x0F12,0x0041},        //TVAR_ash_pGAS[242] 0014  //001E
 869         {0x0F12,0x005F},        //TVAR_ash_pGAS[243] 0021  //0032
 870         {0x0F12,0x008A},        //TVAR_ash_pGAS[244] 0033  //004D
 871         {0x0F12,0x00BF},        //TVAR_ash_pGAS[245] 0048  //006F
 872         {0x0F12,0x00FE},        //TVAR_ash_pGAS[246] 005C  //0097
 873         {0x0F12,0x0137},        //TVAR_ash_pGAS[247] 0063  //00B7
 874         {0x0F12,0x00EF},        //TVAR_ash_pGAS[248] 0057  //0089
 875         {0x0F12,0x00B4},        //TVAR_ash_pGAS[249] 0045  //0062
 876         {0x0F12,0x0089},        //TVAR_ash_pGAS[250] 0036  //0048
 877         {0x0F12,0x006C},        //TVAR_ash_pGAS[251] 002B  //0034
 878         {0x0F12,0x0058},        //TVAR_ash_pGAS[252] 0022  //0028
 879         {0x0F12,0x0051},        //TVAR_ash_pGAS[253] 001E  //0023
 880         {0x0F12,0x0059},        //TVAR_ash_pGAS[254] 001F  //0027
 881         {0x0F12,0x006B},        //TVAR_ash_pGAS[255] 0026  //0033
 882         {0x0F12,0x008B},        //TVAR_ash_pGAS[256] 0034  //0047
 883         {0x0F12,0x00B7},        //TVAR_ash_pGAS[257] 0047  //0061
 884         {0x0F12,0x00EE},        //TVAR_ash_pGAS[258] 005D  //0085
 885         {0x0F12,0x0135},        //TVAR_ash_pGAS[259] 0070  //00B1
 886         {0x0F12,0x0175},        //TVAR_ash_pGAS[260] 007C  //00DE
 887         {0x0F12,0x0123},        //TVAR_ash_pGAS[261] 006B  //00AA
 888         {0x0F12,0x00E3},        //TVAR_ash_pGAS[262] 005C  //0082
 889         {0x0F12,0x00BB},        //TVAR_ash_pGAS[263] 004E  //0067
 890         {0x0F12,0x00A0},        //TVAR_ash_pGAS[264] 0043  //0055
 891         {0x0F12,0x008E},        //TVAR_ash_pGAS[265] 003B  //0049
 892         {0x0F12,0x008A},        //TVAR_ash_pGAS[266] 0037  //0044
 893         {0x0F12,0x0091},        //TVAR_ash_pGAS[267] 0039  //0048
 894         {0x0F12,0x00A5},        //TVAR_ash_pGAS[268] 0040  //0054
 895         {0x0F12,0x00C4},        //TVAR_ash_pGAS[269] 0050  //0066
 896         {0x0F12,0x00F1},        //TVAR_ash_pGAS[270] 0064  //0083
 897         {0x0F12,0x012F},        //TVAR_ash_pGAS[271] 007A  //00A8
 898         {0x0F12,0x0183},        //TVAR_ash_pGAS[272] 008D  //00E0
 899         {0x0F12,0x01B5},        //TVAR_ash_pGAS[273] 00AD  //00FE
 900         {0x0F12,0x0163},        //TVAR_ash_pGAS[274] 0088  //00CC
 901         {0x0F12,0x0124},        //TVAR_ash_pGAS[275] 007B  //00A2
 902         {0x0F12,0x00F8},        //TVAR_ash_pGAS[276] 006D  //0085
 903         {0x0F12,0x00DA},        //TVAR_ash_pGAS[277] 0062  //0072
 904         {0x0F12,0x00C9},        //TVAR_ash_pGAS[278] 005B  //0066
 905         {0x0F12,0x00C4},        //TVAR_ash_pGAS[279] 0057  //0062
 906         {0x0F12,0x00CE},        //TVAR_ash_pGAS[280] 005A  //0065
 907         {0x0F12,0x00E1},        //TVAR_ash_pGAS[281] 0061  //0072
 908         {0x0F12,0x0103},        //TVAR_ash_pGAS[282] 0073  //0085
 909         {0x0F12,0x0136},        //TVAR_ash_pGAS[283] 0088  //00A2
 910         {0x0F12,0x017F},        //TVAR_ash_pGAS[284] 009E  //00D0
 911         {0x0F12,0x01E0},        //TVAR_ash_pGAS[285] 00BB  //0103
 912         {0x0F12,0x0148},        //TVAR_ash_pGAS[286] 00F3  //0153
 913         {0x0F12,0x0108},        //TVAR_ash_pGAS[287] 00B8  //010D
 914         {0x0F12,0x00C8},        //TVAR_ash_pGAS[288] 008D  //00D8
 915         {0x0F12,0x009F},        //TVAR_ash_pGAS[289] 0082  //00B3
 916         {0x0F12,0x0082},        //TVAR_ash_pGAS[290] 0077  //009A
 917         {0x0F12,0x0073},        //TVAR_ash_pGAS[291] 006E  //008A
 918         {0x0F12,0x0068},        //TVAR_ash_pGAS[292] 0069  //0083
 919         {0x0F12,0x006C},        //TVAR_ash_pGAS[293] 006A  //0087
 920         {0x0F12,0x007E},        //TVAR_ash_pGAS[294] 0071  //0095
 921         {0x0F12,0x009B},        //TVAR_ash_pGAS[295] 007B  //00AC
 922         {0x0F12,0x00C2},        //TVAR_ash_pGAS[296] 0086  //00CF
 923         {0x0F12,0x0100},        //TVAR_ash_pGAS[297] 0098  //0106
 924         {0x0F12,0x014D},        //TVAR_ash_pGAS[298] 00D3  //0149
 925         {0x0F12,0x0121},        //TVAR_ash_pGAS[299] 00A4  //0116
 926         {0x0F12,0x00E6},        //TVAR_ash_pGAS[300] 007E  //00D6
 927         {0x0F12,0x00A4},        //TVAR_ash_pGAS[301] 006A  //00A8
 928         {0x0F12,0x0078},        //TVAR_ash_pGAS[302] 0060  //0087
 929         {0x0F12,0x005A},        //TVAR_ash_pGAS[303] 0053  //0071
 930         {0x0F12,0x0046},        //TVAR_ash_pGAS[304] 0048  //0061
 931         {0x0F12,0x003E},        //TVAR_ash_pGAS[305] 0044  //005B
 932         {0x0F12,0x0043},        //TVAR_ash_pGAS[306] 0045  //005E
 933         {0x0F12,0x0052},        //TVAR_ash_pGAS[307] 004C  //006D
 934         {0x0F12,0x006B},        //TVAR_ash_pGAS[308] 0059  //0083
 935         {0x0F12,0x0093},        //TVAR_ash_pGAS[309] 0066  //00A4
 936         {0x0F12,0x00C9},        //TVAR_ash_pGAS[310] 006F  //00D5
 937         {0x0F12,0x010D},        //TVAR_ash_pGAS[311] 008C  //0113
 938         {0x0F12,0x0103},        //TVAR_ash_pGAS[312] 007A  //00E6
 939         {0x0F12,0x00C3},        //TVAR_ash_pGAS[313] 0069  //00AE
 940         {0x0F12,0x0089},        //TVAR_ash_pGAS[314] 0058  //0084
 941         {0x0F12,0x005E},        //TVAR_ash_pGAS[315] 004A  //0065
 942         {0x0F12,0x003E},        //TVAR_ash_pGAS[316] 003A  //004D
 943         {0x0F12,0x002A},        //TVAR_ash_pGAS[317] 002F  //003D
 944         {0x0F12,0x001F},        //TVAR_ash_pGAS[318] 0029  //0037
 945         {0x0F12,0x0023},        //TVAR_ash_pGAS[319] 002a  //003B
 946         {0x0F12,0x0032},        //TVAR_ash_pGAS[320] 0031  //004B
 947         {0x0F12,0x004E},        //TVAR_ash_pGAS[321] 003F  //0063
 948         {0x0F12,0x0074},        //TVAR_ash_pGAS[322] 004F  //0080
 949         {0x0F12,0x00A5},        //TVAR_ash_pGAS[323] 005C  //00AB
 950         {0x0F12,0x00E6},        //TVAR_ash_pGAS[324] 006F  //00DF
 951         {0x0F12,0x00EF},        //TVAR_ash_pGAS[325] 0068  //00C5
 952         {0x0F12,0x00AD},        //TVAR_ash_pGAS[326] 005C  //0092
 953         {0x0F12,0x0076},        //TVAR_ash_pGAS[327] 0047  //006B
 954         {0x0F12,0x004D},        //TVAR_ash_pGAS[328] 0037  //004B
 955         {0x0F12,0x002C},        //TVAR_ash_pGAS[329] 0027  //0034
 956         {0x0F12,0x0015},        //TVAR_ash_pGAS[330] 001B  //0023
 957         {0x0F12,0x000C},        //TVAR_ash_pGAS[331] 0015  //001C
 958         {0x0F12,0x0010},        //TVAR_ash_pGAS[332] 0016  //0020
 959         {0x0F12,0x001F},        //TVAR_ash_pGAS[333] 001C  //002E
 960         {0x0F12,0x003B},        //TVAR_ash_pGAS[334] 0029  //0047
 961         {0x0F12,0x0061},        //TVAR_ash_pGAS[335] 003A  //0066
 962         {0x0F12,0x0092},        //TVAR_ash_pGAS[336] 004B  //008C
 963         {0x0F12,0x00D2},        //TVAR_ash_pGAS[337] 005E  //00BB
 964         {0x0F12,0x00E8},        //TVAR_ash_pGAS[338] 0060  //00B0
 965         {0x0F12,0x00A8},        //TVAR_ash_pGAS[339] 0053  //0081
 966         {0x0F12,0x0071},        //TVAR_ash_pGAS[340] 003B  //005A
 967         {0x0F12,0x0046},        //TVAR_ash_pGAS[341] 002a  //0039
 968         {0x0F12,0x0023},        //TVAR_ash_pGAS[342] 001A  //0021
 969         {0x0F12,0x000B},        //TVAR_ash_pGAS[343] 000D  //0010
 970         {0x0F12,0x0002},        //TVAR_ash_pGAS[344] 0007  //0009
 971         {0x0F12,0x0005},        //TVAR_ash_pGAS[345] 0007  //000C
 972         {0x0F12,0x0014},        //TVAR_ash_pGAS[346] 000D  //001B
 973         {0x0F12,0x0030},        //TVAR_ash_pGAS[347] 001A  //0033
 974         {0x0F12,0x0058},        //TVAR_ash_pGAS[348] 002B  //0050
 975         {0x0F12,0x008A},        //TVAR_ash_pGAS[349] 003D  //0078
 976         {0x0F12,0x00C8},        //TVAR_ash_pGAS[350] 0053  //00A1
 977         {0x0F12,0x00EF},        //TVAR_ash_pGAS[351] 005C  //00A8
 978         {0x0F12,0x00AD},        //TVAR_ash_pGAS[352] 004E  //007B
 979         {0x0F12,0x0077},        //TVAR_ash_pGAS[353] 0036  //0054
 980         {0x0F12,0x0048},        //TVAR_ash_pGAS[354] 0023  //0032
 981         {0x0F12,0x0023},        //TVAR_ash_pGAS[355] 0014  //0019
 982         {0x0F12,0x000B},        //TVAR_ash_pGAS[356] 0007  //0008
 983         {0x0F12,0x0000},        //TVAR_ash_pGAS[357] 0000  //0000
 984         {0x0F12,0x0003},        //TVAR_ash_pGAS[358] 0000  //0004
 985         {0x0F12,0x0013},        //TVAR_ash_pGAS[359] 0006  //0012
 986         {0x0F12,0x0030},        //TVAR_ash_pGAS[360] 0012  //0028
 987         {0x0F12,0x0059},        //TVAR_ash_pGAS[361] 0023  //0046
 988         {0x0F12,0x008A},        //TVAR_ash_pGAS[362] 0034  //006B
 989         {0x0F12,0x00CA},        //TVAR_ash_pGAS[363] 004C  //0093
 990         {0x0F12,0x0104},        //TVAR_ash_pGAS[364] 005E  //00A9
 991         {0x0F12,0x00C0},        //TVAR_ash_pGAS[365] 004F  //007C
 992         {0x0F12,0x0087},        //TVAR_ash_pGAS[366] 0037  //0054
 993         {0x0F12,0x0057},        //TVAR_ash_pGAS[367] 0024  //0034
 994         {0x0F12,0x0031},        //TVAR_ash_pGAS[368] 0015  //001B
 995         {0x0F12,0x0018},        //TVAR_ash_pGAS[369] 0008  //000A
 996         {0x0F12,0x000C},        //TVAR_ash_pGAS[370] 0001  //0002
 997         {0x0F12,0x0010},        //TVAR_ash_pGAS[371] 0000  //0004
 998         {0x0F12,0x0020},        //TVAR_ash_pGAS[372] 0005  //0012
 999         {0x0F12,0x003D},        //TVAR_ash_pGAS[373] 0010  //0027
1000         {0x0F12,0x0067},        //TVAR_ash_pGAS[374] 0021  //0045
1001         {0x0F12,0x009A},        //TVAR_ash_pGAS[375] 0033  //0069
1002         {0x0F12,0x00D9},        //TVAR_ash_pGAS[376] 004A  //0090
1003         {0x0F12,0x0126},        //TVAR_ash_pGAS[377] 0064  //00B4
1004         {0x0F12,0x00E1},        //TVAR_ash_pGAS[378] 0056  //0086
1005         {0x0F12,0x00A3},        //TVAR_ash_pGAS[379] 003F  //005C
1006         {0x0F12,0x0071},        //TVAR_ash_pGAS[380] 002C  //003C
1007         {0x0F12,0x004C},        //TVAR_ash_pGAS[381] 001D  //0024
1008         {0x0F12,0x0031},        //TVAR_ash_pGAS[382] 0011  //0014
1009         {0x0F12,0x0025},        //TVAR_ash_pGAS[383] 0008  //000D
1010         {0x0F12,0x0029},        //TVAR_ash_pGAS[384] 0006  //000F
1011         {0x0F12,0x003A},        //TVAR_ash_pGAS[385] 000B  //001B
1012         {0x0F12,0x0057},        //TVAR_ash_pGAS[386] 0015  //002F
1013         {0x0F12,0x0081},        //TVAR_ash_pGAS[387] 0025  //004B
1014         {0x0F12,0x00B4},        //TVAR_ash_pGAS[388] 0038  //006E
1015         {0x0F12,0x00F4},        //TVAR_ash_pGAS[389] 004B  //0097
1016         {0x0F12,0x0154},        //TVAR_ash_pGAS[390] 0072  //00CA
1017         {0x0F12,0x0107},        //TVAR_ash_pGAS[391] 0064  //0098
1018         {0x0F12,0x00C6},        //TVAR_ash_pGAS[392] 004E  //006E
1019         {0x0F12,0x0095},        //TVAR_ash_pGAS[393] 003B  //0050
1020         {0x0F12,0x0074},        //TVAR_ash_pGAS[394] 002C  //0037
1021         {0x0F12,0x005A},        //TVAR_ash_pGAS[395] 001F  //0027
1022         {0x0F12,0x004F},        //TVAR_ash_pGAS[396] 0018  //0020
1023         {0x0F12,0x0053},        //TVAR_ash_pGAS[397] 0015  //0022
1024         {0x0F12,0x0062},        //TVAR_ash_pGAS[398] 0018  //002D
1025         {0x0F12,0x007F},        //TVAR_ash_pGAS[399] 0022  //0042
1026         {0x0F12,0x00A8},        //TVAR_ash_pGAS[400] 0032  //005B
1027         {0x0F12,0x00DC},        //TVAR_ash_pGAS[401] 0044  //0080
1028         {0x0F12,0x0120},        //TVAR_ash_pGAS[402] 0054  //00AA
1029         {0x0F12,0x0193},        //TVAR_ash_pGAS[403] 0089  //00F0
1030         {0x0F12,0x013B},        //TVAR_ash_pGAS[404] 0077  //00BA
1031         {0x0F12,0x00F6},        //TVAR_ash_pGAS[405] 0065  //008E
1032         {0x0F12,0x00C9},        //TVAR_ash_pGAS[406] 0052  //006F
1033         {0x0F12,0x00A8},        //TVAR_ash_pGAS[407] 0043  //0058
1034         {0x0F12,0x0090},        //TVAR_ash_pGAS[408] 0037  //0048
1035         {0x0F12,0x0086},        //TVAR_ash_pGAS[409] 002F  //0041
1036         {0x0F12,0x008A},        //TVAR_ash_pGAS[410] 002C  //0042
1037         {0x0F12,0x0099},        //TVAR_ash_pGAS[411] 002F  //004C
1038         {0x0F12,0x00B5},        //TVAR_ash_pGAS[412] 0038  //005F
1039         {0x0F12,0x00DD},        //TVAR_ash_pGAS[413] 0048  //007A
1040         {0x0F12,0x0117},        //TVAR_ash_pGAS[414] 0058  //009D
1041         {0x0F12,0x0166},        //TVAR_ash_pGAS[415] 0068  //00D2
1042         {0x0F12,0x01D6},        //TVAR_ash_pGAS[416] 00BC  //0112
1043         {0x0F12,0x017D},        //TVAR_ash_pGAS[417] 0092  //00DD
1044         {0x0F12,0x0138},        //TVAR_ash_pGAS[418] 0082  //00AF
1045         {0x0F12,0x0108},        //TVAR_ash_pGAS[419] 006F  //008F
1046         {0x0F12,0x00E3},        //TVAR_ash_pGAS[420] 0061  //0077
1047         {0x0F12,0x00CD},        //TVAR_ash_pGAS[421] 0055  //0066
1048         {0x0F12,0x00C2},        //TVAR_ash_pGAS[422] 004E  //005F
1049         {0x0F12,0x00C7},        //TVAR_ash_pGAS[423] 004A  //005F
1050         {0x0F12,0x00D4},        //TVAR_ash_pGAS[424] 004C  //006A
1051         {0x0F12,0x00F1},        //TVAR_ash_pGAS[425] 0056  //007C
1052         {0x0F12,0x011F},        //TVAR_ash_pGAS[426] 0066  //0097
1053         {0x0F12,0x015F},        //TVAR_ash_pGAS[427] 0073  //00C2
1054         {0x0F12,0x01B7},        //TVAR_ash_pGAS[428] 008B  //00F2
1055         {0x0F12,0x00D1},        //TVAR_ash_pGAS[429] 0087  //00EE
1056         {0x0F12,0x00A9},        //TVAR_ash_pGAS[430] 0069  //00C2
1057         {0x0F12,0x0080},        //TVAR_ash_pGAS[431] 0053  //009B
1058         {0x0F12,0x0064},        //TVAR_ash_pGAS[432] 0052  //0085
1059         {0x0F12,0x0055},        //TVAR_ash_pGAS[433] 0050  //0074
1060         {0x0F12,0x004E},        //TVAR_ash_pGAS[434] 0050  //006A
1061         {0x0F12,0x0047},        //TVAR_ash_pGAS[435] 004F  //0067
1062         {0x0F12,0x004B},        //TVAR_ash_pGAS[436] 0052  //006B
1063         {0x0F12,0x005E},        //TVAR_ash_pGAS[437] 0057  //0076
1064         {0x0F12,0x0077},        //TVAR_ash_pGAS[438] 005D  //0089
1065         {0x0F12,0x0094},        //TVAR_ash_pGAS[439] 0060  //00A3
1066         {0x0F12,0x00BF},        //TVAR_ash_pGAS[440] 0068  //00CE
1067         {0x0F12,0x00F1},        //TVAR_ash_pGAS[441] 0090  //0102
1068         {0x0F12,0x00BB},        //TVAR_ash_pGAS[442] 0050  //00C2
1069         {0x0F12,0x0095},        //TVAR_ash_pGAS[443] 003F  //0097
1070         {0x0F12,0x0067},        //TVAR_ash_pGAS[444] 003A  //0076
1071         {0x0F12,0x0049},        //TVAR_ash_pGAS[445] 003A  //0062
1072         {0x0F12,0x0036},        //TVAR_ash_pGAS[446] 0035  //0054
1073         {0x0F12,0x002C},        //TVAR_ash_pGAS[447] 0033  //004B
1074         {0x0F12,0x0027},        //TVAR_ash_pGAS[448] 0033  //0047
1075         {0x0F12,0x002E},        //TVAR_ash_pGAS[449] 0036  //004C
1076         {0x0F12,0x003C},        //TVAR_ash_pGAS[450] 003B  //0057
1077         {0x0F12,0x004F},        //TVAR_ash_pGAS[451] 0043  //006A
1078         {0x0F12,0x006F},        //TVAR_ash_pGAS[452] 0048  //0084
1079         {0x0F12,0x0097},        //TVAR_ash_pGAS[453] 004A  //00AE
1080         {0x0F12,0x00C7},        //TVAR_ash_pGAS[454] 005D  //00DF
1081         {0x0F12,0x00A5},        //TVAR_ash_pGAS[455] 002D  //009A
1082         {0x0F12,0x0079},        //TVAR_ash_pGAS[456] 002D  //0075
1083         {0x0F12,0x0052},        //TVAR_ash_pGAS[457] 002B  //0058
1084         {0x0F12,0x0036},        //TVAR_ash_pGAS[458] 0029  //0045
1085         {0x0F12,0x0023},        //TVAR_ash_pGAS[459] 0023  //0039
1086         {0x0F12,0x0017},        //TVAR_ash_pGAS[460] 0020  //002F
1087         {0x0F12,0x0012},        //TVAR_ash_pGAS[461] 001F  //002C
1088         {0x0F12,0x0017},        //TVAR_ash_pGAS[462] 0023  //0030
1089         {0x0F12,0x0024},        //TVAR_ash_pGAS[463] 0027  //003D
1090         {0x0F12,0x0039},        //TVAR_ash_pGAS[464] 002F  //0050
1091         {0x0F12,0x0055},        //TVAR_ash_pGAS[465] 0036  //0067
1092         {0x0F12,0x007A},        //TVAR_ash_pGAS[466] 003A  //008B
1093         {0x0F12,0x00A8},        //TVAR_ash_pGAS[467] 0043  //00B4
1094         {0x0F12,0x0097},        //TVAR_ash_pGAS[468] 001F  //0080
1095         {0x0F12,0x0069},        //TVAR_ash_pGAS[469] 0023  //005E
1096         {0x0F12,0x0045},        //TVAR_ash_pGAS[470] 001D  //0044
1097         {0x0F12,0x002B},        //TVAR_ash_pGAS[471] 001A  //0032
1098         {0x0F12,0x0018},        //TVAR_ash_pGAS[472] 0015  //0024
1099         {0x0F12,0x000B},        //TVAR_ash_pGAS[473] 0012  //001A
1100         {0x0F12,0x0006},        //TVAR_ash_pGAS[474] 0010  //0017
1101         {0x0F12,0x000A},        //TVAR_ash_pGAS[475] 0013  //001B
1102         {0x0F12,0x0017},        //TVAR_ash_pGAS[476] 0017  //0027
1103         {0x0F12,0x002B},        //TVAR_ash_pGAS[477] 001E  //0039
1104         {0x0F12,0x0047},        //TVAR_ash_pGAS[478] 0025  //004F
1105         {0x0F12,0x006B},        //TVAR_ash_pGAS[479] 002B  //006E
1106         {0x0F12,0x0097},        //TVAR_ash_pGAS[480] 0034  //0092
1107         {0x0F12,0x0092},        //TVAR_ash_pGAS[481] 0017  //006E
1108         {0x0F12,0x0065},        //TVAR_ash_pGAS[482] 001B  //004F
1109         {0x0F12,0x0042},        //TVAR_ash_pGAS[483] 0015  //0037
1110         {0x0F12,0x0028},        //TVAR_ash_pGAS[484] 0011  //0023
1111         {0x0F12,0x0013},        //TVAR_ash_pGAS[485] 000B  //0016
1112         {0x0F12,0x0005},        //TVAR_ash_pGAS[486] 0008  //000C
1113         {0x0F12,0x0000},        //TVAR_ash_pGAS[487] 0006  //0008
1114         {0x0F12,0x0004},        //TVAR_ash_pGAS[488] 0008  //000C
1115         {0x0F12,0x000F},        //TVAR_ash_pGAS[489] 000B  //0017
1116         {0x0F12,0x0025},        //TVAR_ash_pGAS[490] 0012  //0028
1117         {0x0F12,0x0040},        //TVAR_ash_pGAS[491] 0018  //003D
1118         {0x0F12,0x0064},        //TVAR_ash_pGAS[492] 001E  //005B
1119         {0x0F12,0x008F},        //TVAR_ash_pGAS[493] 0028  //007A
1120         {0x0F12,0x0098},        //TVAR_ash_pGAS[494] 0014  //0068
1121         {0x0F12,0x006A},        //TVAR_ash_pGAS[495] 0016  //004A
1122         {0x0F12,0x004A},        //TVAR_ash_pGAS[496] 0011  //0032
1123         {0x0F12,0x002E},        //TVAR_ash_pGAS[497] 000C  //001D
1124         {0x0F12,0x0016},        //TVAR_ash_pGAS[498] 0007  //0011
1125         {0x0F12,0x0007},        //TVAR_ash_pGAS[499] 0002  //0005
1126         {0x0F12,0x0000},        //TVAR_ash_pGAS[500] 0000  //0000
1127         {0x0F12,0x0004},        //TVAR_ash_pGAS[501] 0001  //0005
1128         {0x0F12,0x0011},        //TVAR_ash_pGAS[502] 0005  //000F
1129         {0x0F12,0x0026},        //TVAR_ash_pGAS[503] 000A  //001E
1130         {0x0F12,0x0042},        //TVAR_ash_pGAS[504] 000F  //0033
1131         {0x0F12,0x0064},        //TVAR_ash_pGAS[505] 0014  //004E
1132         {0x0F12,0x008F},        //TVAR_ash_pGAS[506] 001E  //006C
1133         {0x0F12,0x00A9},        //TVAR_ash_pGAS[507] 0015  //006C
1134         {0x0F12,0x007B},        //TVAR_ash_pGAS[508] 0016  //004C
1135         {0x0F12,0x0057},        //TVAR_ash_pGAS[509] 0011  //0033
1136         {0x0F12,0x0039},        //TVAR_ash_pGAS[510] 000D  //0020
1137         {0x0F12,0x0021},        //TVAR_ash_pGAS[511] 0007  //0013
1138         {0x0F12,0x0012},        //TVAR_ash_pGAS[512] 0003  //0008
1139         {0x0F12,0x000C},        //TVAR_ash_pGAS[513] 0000  //0003
1140         {0x0F12,0x0010},        //TVAR_ash_pGAS[514] 0000  //0006
1141         {0x0F12,0x001D},        //TVAR_ash_pGAS[515] 0002  //000E
1142         {0x0F12,0x0031},        //TVAR_ash_pGAS[516] 0007  //001C
1143         {0x0F12,0x004E},        //TVAR_ash_pGAS[517] 000C  //0032
1144         {0x0F12,0x0071},        //TVAR_ash_pGAS[518] 0010  //004B
1145         {0x0F12,0x009C},        //TVAR_ash_pGAS[519] 0019  //0067
1146         {0x0F12,0x00C6},        //TVAR_ash_pGAS[520] 0019  //0076
1147         {0x0F12,0x0097},        //TVAR_ash_pGAS[521] 001C  //0055
1148         {0x0F12,0x006E},        //TVAR_ash_pGAS[522] 0016  //003A
1149         {0x0F12,0x004E},        //TVAR_ash_pGAS[523] 0012  //0028
1150         {0x0F12,0x0038},        //TVAR_ash_pGAS[524] 000D  //001A
1151         {0x0F12,0x0028},        //TVAR_ash_pGAS[525] 0009  //0010
1152         {0x0F12,0x0022},        //TVAR_ash_pGAS[526] 0005  //000C
1153         {0x0F12,0x0027},        //TVAR_ash_pGAS[527] 0003  //000E
1154         {0x0F12,0x0034},        //TVAR_ash_pGAS[528] 0005  //0016
1155         {0x0F12,0x0047},        //TVAR_ash_pGAS[529] 0009  //0022
1156         {0x0F12,0x0064},        //TVAR_ash_pGAS[530] 000D  //0035
1157         {0x0F12,0x0088},        //TVAR_ash_pGAS[531] 0011  //004F
1158         {0x0F12,0x00B3},        //TVAR_ash_pGAS[532] 0017  //006C
1159         {0x0F12,0x00EB},        //TVAR_ash_pGAS[533] 0024  //0089
1160         {0x0F12,0x00B3},        //TVAR_ash_pGAS[534] 0026  //0066
1161         {0x0F12,0x008A},        //TVAR_ash_pGAS[535] 0021  //0049
1162         {0x0F12,0x006C},        //TVAR_ash_pGAS[536] 001D  //0037
1163         {0x0F12,0x005A},        //TVAR_ash_pGAS[537] 0018  //002A
1164         {0x0F12,0x004B},        //TVAR_ash_pGAS[538] 0014  //0020
1165         {0x0F12,0x0047},        //TVAR_ash_pGAS[539] 000F  //001C
1166         {0x0F12,0x004C},        //TVAR_ash_pGAS[540] 000D  //001E
1167         {0x0F12,0x0057},        //TVAR_ash_pGAS[541] 000E  //0024
1168         {0x0F12,0x006A},        //TVAR_ash_pGAS[542] 0012  //0030
1169         {0x0F12,0x0086},        //TVAR_ash_pGAS[543] 0016  //0042
1170         {0x0F12,0x00A9},        //TVAR_ash_pGAS[544] 0019  //005D
1171         {0x0F12,0x00D9},        //TVAR_ash_pGAS[545] 001B  //007D
1172         {0x0F12,0x011D},        //TVAR_ash_pGAS[546] 0036  //00A9
1173         {0x0F12,0x00DE},        //TVAR_ash_pGAS[547] 0035  //0084
1174         {0x0F12,0x00B2},        //TVAR_ash_pGAS[548] 0032  //0066
1175         {0x0F12,0x0097},        //TVAR_ash_pGAS[549] 002E  //0052
1176         {0x0F12,0x0087},        //TVAR_ash_pGAS[550] 002a  //0045
1177         {0x0F12,0x007A},        //TVAR_ash_pGAS[551] 0026  //003B
1178         {0x0F12,0x0077},        //TVAR_ash_pGAS[552] 0021  //0036
1179         {0x0F12,0x007A},        //TVAR_ash_pGAS[553] 001F  //0038
1180         {0x0F12,0x0086},        //TVAR_ash_pGAS[554] 001F  //003E
1181         {0x0F12,0x0098},        //TVAR_ash_pGAS[555] 0024  //004A
1182         {0x0F12,0x00B3},        //TVAR_ash_pGAS[556] 0027  //005E
1183         {0x0F12,0x00DA},        //TVAR_ash_pGAS[557] 002a  //0077
1184         {0x0F12,0x0112},        //TVAR_ash_pGAS[558] 0028  //009E
1185         {0x0F12,0x0149},        //TVAR_ash_pGAS[559] 005C  //00BC
1186         {0x0F12,0x0114},        //TVAR_ash_pGAS[560] 004A  //009C
1187         {0x0F12,0x00EB},        //TVAR_ash_pGAS[561] 0049  //007D
1188         {0x0F12,0x00CE},        //TVAR_ash_pGAS[562] 0046  //0069
1189         {0x0F12,0x00B9},        //TVAR_ash_pGAS[563] 0041  //005A
1190         {0x0F12,0x00AD},        //TVAR_ash_pGAS[564] 003E  //0052
1191         {0x0F12,0x00A8},        //TVAR_ash_pGAS[565] 003A  //004C
1192         {0x0F12,0x00AF},        //TVAR_ash_pGAS[566] 0037  //004D
1193         {0x0F12,0x00B8},        //TVAR_ash_pGAS[567] 0037  //0054
1194         {0x0F12,0x00CB},        //TVAR_ash_pGAS[568] 003B  //0060
1195         {0x0F12,0x00EC},        //TVAR_ash_pGAS[569] 003F  //0072
1196         {0x0F12,0x0119},        //TVAR_ash_pGAS[570] 0040  //0093
1197         {0x0F12,0x0153},        //TVAR_ash_pGAS[571] 0041  //00B6
1198         //      param_end       TVAR_ash_pGAS
1199         {0x002A,0x0F12},
1200         {0x0F12,0x02BC},
1201         {0x0F12,0x0347},
1202         //      param_start     TVAR_ash_AwbAshCord
1203         {0x002A,0x0704},
1204         {0x0F12,0x00BF},
1205         {0x0F12,0x00E6},
1206         {0x0F12,0x00F2},
1207         {0x0F12,0x0143},
1208         {0x0F12,0x0178},
1209         {0x0F12,0x01A3},
1210         {0x0F12,0x01B5},
1211         //      param_end       TVAR_ash_AwbAshCord
1212
1213         {0x002A,0x0754},  //#TVAR_ash_pGAS
1214         {0x0F12,0x247C},
1215         {0x0F12,0x7000},
1216
1217         //
1218         //      param_start     awbb_IndoorGrZones_m_BGrid
1219         {0x002A,0x0C50},
1220         {0x0F12,0x03AE},  //03BE        //awbb_IndoorGrZones_m_BGrid[0]            03C6
1221         {0x0F12,0x03DB},  //03EB        //awbb_IndoorGrZones_m_BGrid[1]            03F3
1222         {0x0F12,0x0399},  //03A9        //awbb_IndoorGrZones_m_BGrid[2]            03B1
1223         {0x0F12,0x03DB},  //03EB        //awbb_IndoorGrZones_m_BGrid[3]            03F3
1224         {0x0F12,0x0382},  //0392        //awbb_IndoorGrZones_m_BGrid[4]            039A
1225         {0x0F12,0x03DB},  //03EB        //awbb_IndoorGrZones_m_BGrid[5]            03F3
1226         {0x0F12,0x036B},  //037B        //awbb_IndoorGrZones_m_BGrid[6]            0383
1227         {0x0F12,0x03CE},  //03DE        //awbb_IndoorGrZones_m_BGrid[7]            03E6
1228         {0x0F12,0x034E},  //035E        //awbb_IndoorGrZones_m_BGrid[8]            0366
1229         {0x0F12,0x03BD},  //03CD        //awbb_IndoorGrZones_m_BGrid[9]            03D5
1230         {0x0F12,0x0330},  //0340        //awbb_IndoorGrZones_m_BGrid[10]           0348
1231         {0x0F12,0x03A8},  //03B8        //awbb_IndoorGrZones_m_BGrid[11]           03C0
1232         {0x0F12,0x0316},  //0326        //awbb_IndoorGrZones_m_BGrid[12]           032E
1233         {0x0F12,0x0391},  //03A1        //awbb_IndoorGrZones_m_BGrid[13]           03A9
1234         {0x0F12,0x02FA},  //030A        //awbb_IndoorGrZones_m_BGrid[14]           0312
1235         {0x0F12,0x0376},  //0386        //awbb_IndoorGrZones_m_BGrid[15]           038E
1236         {0x0F12,0x02E0},  //02F0        //awbb_IndoorGrZones_m_BGrid[16]           02F8
1237         {0x0F12,0x035D},  //036D        //awbb_IndoorGrZones_m_BGrid[17]           0375
1238         {0x0F12,0x02CC},  //02DC        //awbb_IndoorGrZones_m_BGrid[18]           02E4
1239         {0x0F12,0x0344},  //0354        //awbb_IndoorGrZones_m_BGrid[19]           035C
1240         {0x0F12,0x02B7},  //02C7        //awbb_IndoorGrZones_m_BGrid[20]           02CF
1241         {0x0F12,0x032F},  //033F        //awbb_IndoorGrZones_m_BGrid[21]           0347
1242         {0x0F12,0x02A7},  //02B7        //awbb_IndoorGrZones_m_BGrid[22]           02BF
1243         {0x0F12,0x0318},  //0328        //awbb_IndoorGrZones_m_BGrid[23]           0330
1244         {0x0F12,0x0296},  //02A6        //awbb_IndoorGrZones_m_BGrid[24]           02AE
1245         {0x0F12,0x0301},  //0311        //awbb_IndoorGrZones_m_BGrid[25]           0319
1246         {0x0F12,0x0286},  //0296        //awbb_IndoorGrZones_m_BGrid[26]           029E
1247         {0x0F12,0x02ED},  //02FD        //awbb_IndoorGrZones_m_BGrid[27]           0305
1248         {0x0F12,0x0279},  //0289        //awbb_IndoorGrZones_m_BGrid[28]           0291
1249         {0x0F12,0x02DB},  //02EB        //awbb_IndoorGrZones_m_BGrid[29]           02F3
1250         {0x0F12,0x026C},  //027C        //awbb_IndoorGrZones_m_BGrid[30]           0284
1251         {0x0F12,0x02CD},  //02DD        //awbb_IndoorGrZones_m_BGrid[31]           02E5
1252         {0x0F12,0x025E},  //026E        //awbb_IndoorGrZones_m_BGrid[32]           0276
1253         {0x0F12,0x02BF},  //02CF        //awbb_IndoorGrZones_m_BGrid[33]           02D7
1254         {0x0F12,0x0252},  //0262        //awbb_IndoorGrZones_m_BGrid[34]           026A
1255         {0x0F12,0x02B2},  //02C2        //awbb_IndoorGrZones_m_BGrid[35]           02CA
1256         {0x0F12,0x0249},  //0259        //awbb_IndoorGrZones_m_BGrid[36]           0261
1257         {0x0F12,0x02A7},  //02B7        //awbb_IndoorGrZones_m_BGrid[37]           02BF
1258         {0x0F12,0x023B},  //024B        //awbb_IndoorGrZones_m_BGrid[38]           0253
1259         {0x0F12,0x029B},  //02AB        //awbb_IndoorGrZones_m_BGrid[39]           02B3
1260         {0x0F12,0x0231},  //0241        //awbb_IndoorGrZones_m_BGrid[40]           0249
1261         {0x0F12,0x028D},  //029D        //awbb_IndoorGrZones_m_BGrid[41]           02A5
1262         {0x0F12,0x0227},  //0237        //awbb_IndoorGrZones_m_BGrid[42]           023F
1263         {0x0F12,0x0281},  //0291        //awbb_IndoorGrZones_m_BGrid[43]           0299
1264         {0x0F12,0x021D},  //022D        //awbb_IndoorGrZones_m_BGrid[44]           0235
1265         {0x0F12,0x0277},  //0287        //awbb_IndoorGrZones_m_BGrid[45]           028F
1266         {0x0F12,0x0216},  //0226        //awbb_IndoorGrZones_m_BGrid[46]           022E
1267         {0x0F12,0x026E},  //027E        //awbb_IndoorGrZones_m_BGrid[47]           0286
1268         {0x0F12,0x020C},  //021C        //awbb_IndoorGrZones_m_BGrid[48]           0224
1269         {0x0F12,0x0263},  //0273        //awbb_IndoorGrZones_m_BGrid[49]           027B
1270         {0x0F12,0x0204},  //0214        //awbb_IndoorGrZones_m_BGrid[50]           021C
1271         {0x0F12,0x0257},  //0267        //awbb_IndoorGrZones_m_BGrid[51]           026F
1272         {0x0F12,0x01F7},  //0207        //awbb_IndoorGrZones_m_BGrid[52]           020F
1273         {0x0F12,0x024A},  //025A        //awbb_IndoorGrZones_m_BGrid[53]           0262
1274         {0x0F12,0x01E4},  //01F4        //awbb_IndoorGrZones_m_BGrid[54]           01FC
1275         {0x0F12,0x023D},  //024D        //awbb_IndoorGrZones_m_BGrid[55]           0255
1276         {0x0F12,0x01CC},  //01DC        //awbb_IndoorGrZones_m_BGrid[56]           01F3
1277         {0x0F12,0x022A},  //023A        //awbb_IndoorGrZones_m_BGrid[57]           0242
1278         {0x0F12,0x01E5},  //01F5        //awbb_IndoorGrZones_m_BGrid[58]           01FD
1279         {0x0F12,0x020E},  //021E        //awbb_IndoorGrZones_m_BGrid[59]           0226
1280         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[60]           0000
1281         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[61]           0000
1282         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[62]           0000
1283         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[63]           0000
1284         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[64]           0000
1285         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[65]           0000
1286         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[66]           0000
1287         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[67]           0000
1288         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[68]           0000
1289         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[69]           0000
1290         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[70]           0000
1291         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[71]           0000
1292         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[72]           0000
1293         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[73]           0000
1294         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[74]           0000
1295         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[75]           0000
1296         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[76]           0000
1297         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[77]           0000
1298         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[78]           0000
1299         {0x0F12,0x0000},  //0000        //awbb_IndoorGrZones_m_BGrid[79]           0000
1300         //      param_end       awbb_IndoorGrZones_m_BGrid      0cf0 //#awbb_IndoorGrZones_m_GridStep
1301         {0x002a,0x0cf0},
1302         {0x0F12,0x0004},
1303         {0x0F12,0x0000},
1304         {0x002A,0x0cf8},  //#awbb_IndoorGrZones_m_Boffs
1305         {0x0F12,0x00f7}, //EC
1306         {0x0F12,0x0000},
1307         //      param_start     awbb_LowBrGrZones_m_BGrid
1308         {0x002A,0x0D84},
1309         {0x0F12,0x0406},  //0406        //awbb_LowBrGrZones_m_BGrid[0] 0406
1310         {0x0F12,0x0467},  //0467        //awbb_LowBrGrZones_m_BGrid[1] 0467
1311         {0x0F12,0x0371},  //0371        //awbb_LowBrGrZones_m_BGrid[2] 0371
1312         {0x0F12,0x04B0},  //04B0        //awbb_LowBrGrZones_m_BGrid[3] 04B0
1313         {0x0F12,0x02E5},  //02E5        //awbb_LowBrGrZones_m_BGrid[4] 02E5
1314         {0x0F12,0x0481},  //0481        //awbb_LowBrGrZones_m_BGrid[5] 0481
1315         {0x0F12,0x0298},  //0298        //awbb_LowBrGrZones_m_BGrid[6] 0298
1316         {0x0F12,0x042E},  //042E        //awbb_LowBrGrZones_m_BGrid[7] 042E
1317         {0x0F12,0x0260},  //0260        //awbb_LowBrGrZones_m_BGrid[8] 0260
1318         {0x0F12,0x03DE},  //03DE        //awbb_LowBrGrZones_m_BGrid[9] 03DE
1319         {0x0F12,0x022F},  //022F        //awbb_LowBrGrZones_m_BGrid[10]022F
1320         {0x0F12,0x0391},  //0391        //awbb_LowBrGrZones_m_BGrid[11]0391
1321         {0x0F12,0x0201},  //0201        //awbb_LowBrGrZones_m_BGrid[12]0201
1322         {0x0F12,0x034D},  //034D        //awbb_LowBrGrZones_m_BGrid[13]034D
1323         {0x0F12,0x01DA},  //01DA        //awbb_LowBrGrZones_m_BGrid[14]01DA
1324         {0x0F12,0x0310},  //0310        //awbb_LowBrGrZones_m_BGrid[15]0310
1325         {0x0F12,0x01B3},  //01B3        //awbb_LowBrGrZones_m_BGrid[16]01B3
1326         {0x0F12,0x02D4},  //02D4        //awbb_LowBrGrZones_m_BGrid[17]02D4
1327         {0x0F12,0x018F},  //018F        //awbb_LowBrGrZones_m_BGrid[18]018F
1328         {0x0F12,0x0297},  //0297        //awbb_LowBrGrZones_m_BGrid[19]0297
1329         {0x0F12,0x0181},  //0181        //awbb_LowBrGrZones_m_BGrid[20]0181
1330         {0x0F12,0x0271},  //0271        //awbb_LowBrGrZones_m_BGrid[21]0271
1331         {0x0F12,0x0181},  //0181        //awbb_LowBrGrZones_m_BGrid[22]0181
1332         {0x0F12,0x022A},  //022A        //awbb_LowBrGrZones_m_BGrid[23]022A
1333         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[24]0000
1334         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[25]0000
1335         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[26]0000
1336         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[27]0000
1337         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[28]0000
1338         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[29]0000
1339         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[30]0000
1340         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[31]0000
1341         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[32]0000
1342         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[33]0000
1343         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[34]0000
1344         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[35]0000
1345         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[36]0000
1346         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[37]0000
1347         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[38]0000
1348         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[39]0000
1349         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[40]0000
1350         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[41]0000
1351         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[42]0000
1352         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[43]0000
1353         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[44]0000
1354         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[45]0000
1355         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[46]0000
1356         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[47]0000
1357         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[48]0000
1358         {0x0F12,0x0000},  //0000        //awbb_LowBrGrZones_m_BGrid[49]0000
1359         //      param_end       awbb_LowBrGrZones_m_BGrid
1360         {0x002A,0x0de8},  //#awbb_LowBrGrZones_m_GridStep
1361         {0x0F12,0x0006},
1362         {0x0F12,0x0000},
1363         {0x002A,0x0df0},  //#awbb_LowBrGrZones_m_Boffs
1364         {0x0F12,0x0081},
1365         {0x0F12,0x0000},
1366         //      param_start     awbb_OutdoorGrZones_m_BGrid
1367         {0x002A,0x0D08},
1368         {0x0F12,0x0257},  //02C5  //0349  //035E        //awbb_OutdoorGrZones_m_BGrid[0] 036B
1369         {0x0F12,0x0287},  //032D  //0363  //0378        //awbb_OutdoorGrZones_m_BGrid[1] 0385
1370         {0x0F12,0x0245},  //02B2  //032C  //0341        //awbb_OutdoorGrZones_m_BGrid[2] 034E
1371         {0x0F12,0x0287},  //0315  //036E  //0383        //awbb_OutdoorGrZones_m_BGrid[3] 0390
1372         {0x0F12,0x0237},  //02A0  //030F  //0324        //awbb_OutdoorGrZones_m_BGrid[4] 0331
1373         {0x0F12,0x027D},  //02FE  //036E  //0383        //awbb_OutdoorGrZones_m_BGrid[5] 0390
1374         {0x0F12,0x022A},  //0290  //02F3  //0308        //awbb_OutdoorGrZones_m_BGrid[6] 0315
1375         {0x0F12,0x0270},  //02E9  //035C  //0371        //awbb_OutdoorGrZones_m_BGrid[7] 037E
1376         {0x0F12,0x0220},  //0280  //02D8  //02ED        //awbb_OutdoorGrZones_m_BGrid[8] 02FA
1377         {0x0F12,0x0263},  //02D7  //0343  //0358        //awbb_OutdoorGrZones_m_BGrid[9] 0365
1378         {0x0F12,0x0217},  //0274  //02C5  //02DA        //awbb_OutdoorGrZones_m_BGrid[10]02E7
1379         {0x0F12,0x0256},  //02C7  //032D  //0342        //awbb_OutdoorGrZones_m_BGrid[11]034F
1380         {0x0F12,0x020F},  //0266  //02B2  //02C7        //awbb_OutdoorGrZones_m_BGrid[12]02D4
1381         {0x0F12,0x024A},  //02B9  //0315  //032A        //awbb_OutdoorGrZones_m_BGrid[13]0337
1382         {0x0F12,0x020F},  //0259  //02A0  //02B5        //awbb_OutdoorGrZones_m_BGrid[14]02C2
1383         {0x0F12,0x023E},  //02AF  //02FE  //0313        //awbb_OutdoorGrZones_m_BGrid[15]0320
1384         {0x0F12,0x0000},  //024F  //0290  //02A5        //awbb_OutdoorGrZones_m_BGrid[16]02B2
1385         {0x0F12,0x0000},  //02A3  //02E9  //02FB        //awbb_OutdoorGrZones_m_BGrid[17]0308
1386         {0x0F12,0x0000},  //0241  //0280  //0295        //awbb_OutdoorGrZones_m_BGrid[18]02A2
1387         {0x0F12,0x0000},  //0297  //02D7  //02EB        //awbb_OutdoorGrZones_m_BGrid[19]02F8
1388         {0x0F12,0x0000},  //0235  //0274  //0289        //awbb_OutdoorGrZones_m_BGrid[20]0296
1389         {0x0F12,0x0000},  //0287  //02C7  //02DB        //awbb_OutdoorGrZones_m_BGrid[21]02E8
1390         {0x0F12,0x0000},  //022C  //0266  //027B        //awbb_OutdoorGrZones_m_BGrid[22]0288
1391         {0x0F12,0x0000},  //027C  //02B9  //02CC        //awbb_OutdoorGrZones_m_BGrid[23]02D9
1392         {0x0F12,0x0000},  //0222  //0259  //026E        //awbb_OutdoorGrZones_m_BGrid[24]027B
1393         {0x0F12,0x0000},  //0271  //02AF  //02C0        //awbb_OutdoorGrZones_m_BGrid[25]02CD
1394         {0x0F12,0x0000},  //021A  //024F  //0260        //awbb_OutdoorGrZones_m_BGrid[26]026D
1395         {0x0F12,0x0000},  //026A  //02A3  //02B3        //awbb_OutdoorGrZones_m_BGrid[27]02C0
1396         {0x0F12,0x0000},  //0213  //0241  //0256        //awbb_OutdoorGrZones_m_BGrid[28]0263
1397         {0x0F12,0x0000},  //0261  //0297  //02A7        //awbb_OutdoorGrZones_m_BGrid[29]02B4
1398         {0x0F12,0x0000},  //0209  //0235  //024A        //awbb_OutdoorGrZones_m_BGrid[30]0257
1399         {0x0F12,0x0000},  //0254  //0287  //029C        //awbb_OutdoorGrZones_m_BGrid[31]02A9
1400         {0x0F12,0x0000},  //01FE  //022C  //023F        //awbb_OutdoorGrZones_m_BGrid[32]024C
1401         {0x0F12,0x0000},  //0248  //027C  //028D        //awbb_OutdoorGrZones_m_BGrid[33]029A
1402         {0x0F12,0x0000},  //01F0  //0222  //0234        //awbb_OutdoorGrZones_m_BGrid[34]0241
1403         {0x0F12,0x0000},  //023A  //0271  //0283        //awbb_OutdoorGrZones_m_BGrid[35]0290
1404         {0x0F12,0x0000},  //01D4  //021A  //022C        //awbb_OutdoorGrZones_m_BGrid[36]0239
1405         {0x0F12,0x0000},  //0228  //026A  //0279        //awbb_OutdoorGrZones_m_BGrid[37]0286
1406         {0x0F12,0x0000},  //01EB  //0213  //0225        //awbb_OutdoorGrZones_m_BGrid[38]0232
1407         {0x0F12,0x0000},  //0209  //0261  //0271        //awbb_OutdoorGrZones_m_BGrid[39]027E
1408         {0x0F12,0x0000},  //0000  //0209  //021A        //awbb_OutdoorGrZones_m_BGrid[40]0227
1409         {0x0F12,0x0000},  //0000  //0254  //0266        //awbb_OutdoorGrZones_m_BGrid[41]0273
1410         {0x0F12,0x0000},  //0000  //01FE  //0210        //awbb_OutdoorGrZones_m_BGrid[42]021D
1411         {0x0F12,0x0000},  //0000  //0248  //0259        //awbb_OutdoorGrZones_m_BGrid[43]0266
1412         {0x0F12,0x0000},  //0000  //01F0  //0205        //awbb_OutdoorGrZones_m_BGrid[44]0212
1413         {0x0F12,0x0000},  //0000  //023A  //024A        //awbb_OutdoorGrZones_m_BGrid[45]0257
1414         {0x0F12,0x0000},  //0000  //01D4  //01E9        //awbb_OutdoorGrZones_m_BGrid[46]0202
1415         {0x0F12,0x0000},  //0000  //0228  //0239        //awbb_OutdoorGrZones_m_BGrid[47]0246
1416         {0x0F12,0x0000},  //0000  //01EB  //01F8        //awbb_OutdoorGrZones_m_BGrid[48]0209
1417         {0x0F12,0x0000},  //0000  //0209  //021E        //awbb_OutdoorGrZones_m_BGrid[49]022B
1418         //      param_end       awbb_OutdoorGrZones_m_BGrid
1419         {0x002A,0x0d6c},  //#awbb_OutdoorGrZones_m_GridStep
1420         {0x0F12,0x0004},
1421         {0x0F12,0x0000},
1422         {0x002A,0x0d74},  //#awbb_OutdoorGrZones_m_Boffs
1423         {0x0F12,0x0222}, //0195 //0145 //013d //0131
1424         {0x0F12,0x0000},
1425         {0x002A,0x0e00},  //#awbb_CrclLowT_R_c
1426         {0x0F12,0x03cf}, //034A
1427         {0x0F12,0x0000},
1428         {0x002A,0x0e04},  //#awbb_CrclLowT_B_c
1429         {0x0F12,0x012e}, //0176
1430         {0x0F12,0x0000},
1431         {0x002A,0x0e08},  //#awbb_CrclLowT_Rad_c
1432         {0x0F12,0xdf21}, //67C3 //6fc3 //71B8
1433         {0x0F12,0x0000},
1434         {0x002A,0x0E1A},
1435         {0x0F12,0x0135}, //012F
1436         {0x0F12,0x0120},
1437
1438         //// awbb_LowTempRB
1439         //002A 0E68
1440         //0F12 04F2
1441
1442         //      param_start     SARR_usGammaLutRGBIndoor
1443         {0x002A,0x04C8},
1444         {0x0F12,0x0000},
1445         {0x0F12,0x0004},
1446         {0x0F12,0x0009},
1447         {0x0F12,0x0015},
1448         {0x0F12,0x0034},
1449         {0x0F12,0x0088},
1450         {0x0F12,0x00ED},
1451         {0x0F12,0x0155},
1452         {0x0F12,0x0201},
1453         {0x0F12,0x0276},
1454         {0x0F12,0x0307},
1455         {0x0F12,0x0362},
1456         {0x0F12,0x03A9},
1457         {0x0F12,0x03D5},
1458         {0x0F12,0x03F4},
1459         {0x0F12,0x03FF},
1460         {0x0F12,0x0000},
1461         {0x0F12,0x0004},
1462         {0x0F12,0x0009},
1463         {0x0F12,0x0015},
1464         {0x0F12,0x0034},
1465         {0x0F12,0x0088},
1466         {0x0F12,0x00ED},
1467         {0x0F12,0x0155},
1468         {0x0F12,0x0201},
1469         {0x0F12,0x0276},
1470         {0x0F12,0x0307},
1471         {0x0F12,0x0362},
1472         {0x0F12,0x03A9},
1473         {0x0F12,0x03D5},
1474         {0x0F12,0x03F4},
1475         {0x0F12,0x03FF},
1476         {0x0F12,0x0000},
1477         {0x0F12,0x0004},
1478         {0x0F12,0x0009},
1479         {0x0F12,0x0015},
1480         {0x0F12,0x0034},
1481         {0x0F12,0x0088},
1482         {0x0F12,0x00ED},
1483         {0x0F12,0x0155},
1484         {0x0F12,0x0201},
1485         {0x0F12,0x0276},
1486         {0x0F12,0x0307},
1487         {0x0F12,0x0362},
1488         {0x0F12,0x03A9},
1489         {0x0F12,0x03D5},
1490         {0x0F12,0x03F4},
1491         {0x0F12,0x03FF},
1492         //      param_end       SARR_usGammaLutRGBIndoor
1493
1494
1495         {0x002A,0x1000},
1496         {0x0F12,0x003e}, // AE Target
1497
1498         // SAAR_IllumType
1499         {0x002A,0x108E},
1500         {0x0F12,0x00C0},
1501         {0x0F12,0x00E7},
1502         {0x0F12,0x00F9},
1503         {0x0F12,0x0142},
1504         {0x0F12,0x0179},
1505         {0x0F12,0x01A4},
1506         {0x0F12,0x01B8},   //SAAR_IllumF
1507         {0x0F12,0x0112},
1508         {0x0F12,0x0122},
1509         {0x0F12,0x0136},
1510         {0x0F12,0x00F6},
1511         {0x0F12,0x0100},
1512         {0x0F12,0x00FE},
1513         {0x0F12,0x0100},
1514
1515         {0x002A,0x1AC8},
1516         {0x0F12,0x0000},   //   param_start     TVAR_wbt_pBaseCcms
1517         {0x002A,0x23A4},
1518         {0x0F12,0x0213},
1519         {0x0F12,0xFF95},
1520         {0x0F12,0xFFF6},
1521         {0x0F12,0x0067},
1522         {0x0F12,0x0118},
1523         {0x0F12,0xFF1F},
1524         {0x0F12,0xFF0A},
1525         {0x0F12,0x01A9},
1526         {0x0F12,0xFF6E},
1527         {0x0F12,0xFECE},
1528         {0x0F12,0x01C7},
1529         {0x0F12,0x012E},
1530         {0x0F12,0xFFE9},
1531         {0x0F12,0x0009},
1532         {0x0F12,0x01FD},
1533         {0x0F12,0x015B},
1534         {0x0F12,0xFF0C},
1535         {0x0F12,0x014F},
1536         {0x0F12,0x0213},
1537         {0x0F12,0xFF95},
1538         {0x0F12,0xFFF6},
1539         {0x0F12,0x0067},
1540         {0x0F12,0x0118},
1541         {0x0F12,0xFF1F},
1542         {0x0F12,0xFF0A},
1543         {0x0F12,0x01A9},
1544         {0x0F12,0xFF6E},
1545         {0x0F12,0xFECE},
1546         {0x0F12,0x01C7},
1547         {0x0F12,0x012E},
1548         {0x0F12,0xFFE9},
1549         {0x0F12,0x0009},
1550         {0x0F12,0x01FD},
1551         {0x0F12,0x015B},
1552         {0x0F12,0xFF0C},
1553         {0x0F12,0x014F},
1554         {0x0F12,0x0213},
1555         {0x0F12,0xFF95},
1556         {0x0F12,0xFFF6},
1557         {0x0F12,0x0067},
1558         {0x0F12,0x0118},
1559         {0x0F12,0xFF1F},
1560         {0x0F12,0xFF0A},
1561         {0x0F12,0x01A9},
1562         {0x0F12,0xFF6E},
1563         {0x0F12,0xFECE},
1564         {0x0F12,0x01C7},
1565         {0x0F12,0x012E},
1566         {0x0F12,0xFFE9},
1567         {0x0F12,0x0009},
1568         {0x0F12,0x01FD},
1569         {0x0F12,0x015B},
1570         {0x0F12,0xFF0C},
1571         {0x0F12,0x014F},
1572         {0x0F12,0x0213},
1573         {0x0F12,0xFF95},
1574         {0x0F12,0xFFF6},
1575         {0x0F12,0x0067},
1576         {0x0F12,0x0118},
1577         {0x0F12,0xFF1F},
1578         {0x0F12,0xFF0A},
1579         {0x0F12,0x01A9},
1580         {0x0F12,0xFF6E},
1581         {0x0F12,0xFECE},
1582         {0x0F12,0x01C7},
1583         {0x0F12,0x012E},
1584         {0x0F12,0xFFE9},
1585         {0x0F12,0x0009},
1586         {0x0F12,0x01FD},
1587         {0x0F12,0x015B},
1588         {0x0F12,0xFF0C},
1589         {0x0F12,0x014F},
1590         {0x0F12,0x0213},
1591         {0x0F12,0xFF95},
1592         {0x0F12,0xFFF6},
1593         {0x0F12,0x0067},
1594         {0x0F12,0x0118},
1595         {0x0F12,0xFF1F},
1596         {0x0F12,0xFF0A},
1597         {0x0F12,0x01A9},
1598         {0x0F12,0xFF6E},
1599         {0x0F12,0xFECE},
1600         {0x0F12,0x01C7},
1601         {0x0F12,0x012E},
1602         {0x0F12,0xFFE9},
1603         {0x0F12,0x0009},
1604         {0x0F12,0x01FD},
1605         {0x0F12,0x015B},
1606         {0x0F12,0xFF0C},
1607         {0x0F12,0x014F},
1608         {0x0F12,0x0213},
1609         {0x0F12,0xFF95},
1610         {0x0F12,0xFFF6},
1611         {0x0F12,0x0067},
1612         {0x0F12,0x0118},
1613         {0x0F12,0xFF1F},
1614         {0x0F12,0xFF0A},
1615         {0x0F12,0x01A9},
1616         {0x0F12,0xFF6E},
1617         {0x0F12,0xFECE},
1618         {0x0F12,0x01C7},
1619         {0x0F12,0x012E},
1620         {0x0F12,0xFFE9},
1621         {0x0F12,0x0009},
1622         {0x0F12,0x01FD},
1623         {0x0F12,0x015B},
1624         {0x0F12,0xFF0C},
1625         {0x0F12,0x014F},
1626         //      param_end       TVAR_wbt_pBaseCcms
1627         //      param_start     TVAR_wbt_pOutdoorCcm
1628         {0x002A,0x2380},
1629         {0x0F12,0x01AF},
1630         {0x0F12,0xFFD5},
1631         {0x0F12,0x001D},
1632         {0x0F12,0x0080},
1633         {0x0F12,0x00BA},
1634         {0x0F12,0xFF61},
1635         {0x0F12,0xFF21},
1636         {0x0F12,0x0164},
1637         {0x0F12,0xFF96},
1638         {0x0F12,0xFF0F},
1639         {0x0F12,0x019A},
1640         {0x0F12,0x0117},
1641         {0x0F12,0xFFE8},
1642         {0x0F12,0x0041},
1643         {0x0F12,0x01C8},
1644         {0x0F12,0x0173},
1645         {0x0F12,0xFF35},
1646         {0x0F12,0x013C},   //   param_end       TVAR_wbt_pOutdoorCcm
1647
1648         {0x002A,0x06DA},
1649         {0x0F12,0x00BF},
1650         {0x0F12,0x00E6},
1651         {0x0F12,0x00F2},
1652         {0x0F12,0x0143},
1653         {0x0F12,0x0178},
1654         {0x0F12,0x01A3},  //    param_start     SARR_uNormBrInDoor
1655         {0x002A,0x07E8},
1656         {0x0F12,0x000A},
1657         {0x0F12,0x0019},
1658         {0x0F12,0x007D},
1659         {0x0F12,0x01F4},
1660         {0x0F12,0x1388},
1661         //      param_end       SARR_uNormBrInDoor
1662         //      param_start     afit_uNoiseIndInDoor
1663         {0x002A,0x07D0},
1664         {0x0F12,0x0030},
1665         {0x0F12,0x0046},
1666         {0x0F12,0x0088},
1667         {0x0F12,0x0205},
1668         {0x0F12,0x02BC},
1669         //      param_end       afit_uNoiseIndInDoor
1670         {0x002A,0x07E6},
1671         {0x0F12,0x0001},
1672         //      param_start     TVAR_afit_pBaseVals
1673         {0x002A,0x0828},
1674         {0x0F12,0x000B},   //TVAR_afit_pBaseVals[0]
1675         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[1]
1676         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[2]
1677         {0x0F12,0xFFAA},         //TVAR_afit_pBaseVals[3]
1678         {0x0F12,0x0019},         //TVAR_afit_pBaseVals[4]
1679         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[5]
1680         {0x0F12,0x0032},         //TVAR_afit_pBaseVals[6]
1681         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[7]
1682         {0x0F12,0x00FF},         //TVAR_afit_pBaseVals[8]
1683         {0x0F12,0x000A},         //TVAR_afit_pBaseVals[9]
1684         {0x0F12,0x0004},         //TVAR_afit_pBaseVals[10]
1685         {0x0F12,0x000A},         //TVAR_afit_pBaseVals[11]
1686         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[12]
1687         {0x0F12,0x0064},         //TVAR_afit_pBaseVals[13]
1688         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[14]
1689         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[15]
1690         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[16]
1691         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[17]
1692         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[18]
1693         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[19]
1694         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[20]
1695         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[21]
1696         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[22]
1697         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[23]
1698         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[24]
1699         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[25]
1700         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[26]
1701         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[27]
1702         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[28]
1703         {0x0F12,0x0106},         //TVAR_afit_pBaseVals[29]
1704         {0x0F12,0x006F},         //TVAR_afit_pBaseVals[30]
1705         {0x0F12,0x054C},         //TVAR_afit_pBaseVals[31]
1706         {0x0F12,0x0A4C},         //TVAR_afit_pBaseVals[32]
1707         {0x0F12,0x0203},         //TVAR_afit_pBaseVals[33]
1708         {0x0F12,0x0203},         //TVAR_afit_pBaseVals[34]
1709         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[35]
1710         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[36]
1711         {0x0F12,0x2828},         //TVAR_afit_pBaseVals[37]
1712         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[38]
1713         {0x0F12,0x0230},         //TVAR_afit_pBaseVals[39]
1714         {0x0F12,0x0480},         //TVAR_afit_pBaseVals[40]
1715         {0x0F12,0x0804},         //TVAR_afit_pBaseVals[41]
1716         {0x0F12,0x030A},         //TVAR_afit_pBaseVals[42]
1717         {0x0F12,0x1403},         //TVAR_afit_pBaseVals[43]
1718         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[44]
1719         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[45]
1720         {0x0F12,0x0500},         //TVAR_afit_pBaseVals[46]
1721         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[47]
1722         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[48]
1723         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[49]
1724         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[50]
1725         {0x0F12,0x0200},         //TVAR_afit_pBaseVals[51]
1726         {0x0F12,0x0400},         //TVAR_afit_pBaseVals[52]
1727         {0x0F12,0x0200},         //TVAR_afit_pBaseVals[53]
1728         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[54]
1729         {0x0F12,0x0A00},         //TVAR_afit_pBaseVals[55]
1730         {0x0F12,0x100A},         //TVAR_afit_pBaseVals[56]
1731         {0x0F12,0x0150},         //TVAR_afit_pBaseVals[57]
1732         {0x0F12,0x0130},         //TVAR_afit_pBaseVals[58]
1733         {0x0F12,0x0100},         //TVAR_afit_pBaseVals[59]
1734         {0x0F12,0x8032},   //805A        //TVAR_afit_pBaseVals[60]
1735         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[61]
1736         {0x0F12,0x001C},         //TVAR_afit_pBaseVals[62]
1737         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[63]
1738         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[64]
1739         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[65]
1740         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[66]
1741         {0x0F12,0x000C},         //TVAR_afit_pBaseVals[67]
1742         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[68]
1743         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[69]
1744         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[70]
1745         {0x0F12,0x00A0},         //TVAR_afit_pBaseVals[71]
1746         {0x0F12,0x000A},         //TVAR_afit_pBaseVals[72]
1747         {0x0F12,0x0004},         //TVAR_afit_pBaseVals[73]
1748         {0x0F12,0x0012},         //TVAR_afit_pBaseVals[74]
1749         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[75]
1750         {0x0F12,0x0064},         //TVAR_afit_pBaseVals[76]
1751         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[77]
1752         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[78]
1753         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[79]
1754         {0x0F12,0x0200},         //TVAR_afit_pBaseVals[80]
1755         {0x0F12,0x0200},         //TVAR_afit_pBaseVals[81]
1756         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[82]
1757         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[83]
1758         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[84]
1759         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[85]
1760         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[86]
1761         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[87]
1762         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[88]
1763         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[89]
1764         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[90]
1765         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[91]
1766         {0x0F12,0x0106},         //TVAR_afit_pBaseVals[92]
1767         {0x0F12,0x006F},         //TVAR_afit_pBaseVals[93]
1768         {0x0F12,0x053D},         //TVAR_afit_pBaseVals[94]
1769         {0x0F12,0x0A3D},         //TVAR_afit_pBaseVals[95]
1770         {0x0F12,0x0203},         //TVAR_afit_pBaseVals[96]
1771         {0x0F12,0x0203},         //TVAR_afit_pBaseVals[97]
1772         {0x0F12,0x0C23},         //TVAR_afit_pBaseVals[98]
1773         {0x0F12,0x230C},         //TVAR_afit_pBaseVals[99]
1774         {0x0F12,0x1919},         //TVAR_afit_pBaseVals[100]
1775         {0x0F12,0x0303},         //TVAR_afit_pBaseVals[101]
1776         {0x0F12,0x0220},         //TVAR_afit_pBaseVals[102]
1777         {0x0F12,0x0480},         //TVAR_afit_pBaseVals[103]
1778         {0x0F12,0x0804},         //TVAR_afit_pBaseVals[104]
1779         {0x0F12,0x030A},         //TVAR_afit_pBaseVals[105]
1780         {0x0F12,0x1403},         //TVAR_afit_pBaseVals[106]
1781         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[107]
1782         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[108]
1783         {0x0F12,0x0500},         //TVAR_afit_pBaseVals[109]
1784         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[110]
1785         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[111]
1786         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[112]
1787         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[113]
1788         {0x0F12,0x0200},         //TVAR_afit_pBaseVals[114]
1789         {0x0F12,0x0400},         //TVAR_afit_pBaseVals[115]
1790         {0x0F12,0x0200},         //TVAR_afit_pBaseVals[116]
1791         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[117]
1792         {0x0F12,0x0500},         //TVAR_afit_pBaseVals[118]
1793         {0x0F12,0x1008},         //TVAR_afit_pBaseVals[119]
1794         {0x0F12,0x0160},         //TVAR_afit_pBaseVals[120]
1795         {0x0F12,0x0150},         //TVAR_afit_pBaseVals[121]
1796         {0x0F12,0x0100},         //TVAR_afit_pBaseVals[122]
1797         {0x0F12,0x803C},   //8064        //TVAR_afit_pBaseVals[123]
1798         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[124]
1799         {0x0F12,0x0016},         //TVAR_afit_pBaseVals[125]
1800         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[126]
1801         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[127]
1802         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[128]
1803         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[129]
1804         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[130]
1805         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[131]
1806         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[132]
1807         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[133]
1808         {0x0F12,0x0050},         //TVAR_afit_pBaseVals[134]
1809         {0x0F12,0x000A},         //TVAR_afit_pBaseVals[135]
1810         {0x0F12,0x0003},         //TVAR_afit_pBaseVals[136]
1811         {0x0F12,0x0019},         //TVAR_afit_pBaseVals[137]
1812         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[138]
1813         {0x0F12,0x0064},         //TVAR_afit_pBaseVals[139]
1814         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[140]
1815         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[141]
1816         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[142]
1817         {0x0F12,0x0002},         //TVAR_afit_pBaseVals[143]
1818         {0x0F12,0x0002},         //TVAR_afit_pBaseVals[144]
1819         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[145]
1820         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[146]
1821         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[147]
1822         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[148]
1823         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[149]
1824         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[150]
1825         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[151]
1826         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[152]
1827         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[153]
1828         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[154]
1829         {0x0F12,0x0106},         //TVAR_afit_pBaseVals[155]
1830         {0x0F12,0x006F},         //TVAR_afit_pBaseVals[156]
1831         {0x0F12,0x050A},         //TVAR_afit_pBaseVals[157]
1832         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[158]
1833         {0x0F12,0x0203},         //TVAR_afit_pBaseVals[159]
1834         {0x0F12,0x0203},         //TVAR_afit_pBaseVals[160]
1835         {0x0F12,0x1946},         //TVAR_afit_pBaseVals[161]
1836         {0x0F12,0x4619},         //TVAR_afit_pBaseVals[162]
1837         {0x0F12,0x0F0F},         //TVAR_afit_pBaseVals[163]
1838         {0x0F12,0x0606},         //TVAR_afit_pBaseVals[164]
1839         {0x0F12,0x020F},         //TVAR_afit_pBaseVals[165]
1840         {0x0F12,0x0480},         //TVAR_afit_pBaseVals[166]
1841         {0x0F12,0x0804},         //TVAR_afit_pBaseVals[167]
1842         {0x0F12,0x030A},         //TVAR_afit_pBaseVals[168]
1843         {0x0F12,0x1403},         //TVAR_afit_pBaseVals[169]
1844         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[170]
1845         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[171]
1846         {0x0F12,0x0500},         //TVAR_afit_pBaseVals[172]
1847         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[173]
1848         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[174]
1849         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[175]
1850         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[176]
1851         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[177]
1852         {0x0F12,0x0404},         //TVAR_afit_pBaseVals[178]
1853         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[179]
1854         {0x0F12,0x0402},         //TVAR_afit_pBaseVals[180]
1855         {0x0F12,0x0002},         //TVAR_afit_pBaseVals[181]
1856         {0x0F12,0x1006},         //TVAR_afit_pBaseVals[182]
1857         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[183]
1858         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[184]
1859         {0x0F12,0x0100},         //TVAR_afit_pBaseVals[185]
1860         {0x0F12,0x8046},  //0x8067       //TVAR_afit_pBaseVals[186]
1861         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[187]
1862         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[188]
1863         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[189]
1864         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[190]
1865         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[191]
1866         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[192]
1867         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[193]
1868         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[194]
1869         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[195]
1870         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[196]
1871         {0x0F12,0x000A},         //TVAR_afit_pBaseVals[197]
1872         {0x0F12,0x000A},         //TVAR_afit_pBaseVals[198]
1873         {0x0F12,0x0003},         //TVAR_afit_pBaseVals[199]
1874         {0x0F12,0x0019},         //TVAR_afit_pBaseVals[200]
1875         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[201]
1876         {0x0F12,0x0064},         //TVAR_afit_pBaseVals[202]
1877         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[203]
1878         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[204]
1879         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[205]
1880         {0x0F12,0x0002},         //TVAR_afit_pBaseVals[206]
1881         {0x0F12,0x0002},         //TVAR_afit_pBaseVals[207]
1882         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[208]
1883         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[209]
1884         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[210]
1885         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[211]
1886         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[212]
1887         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[213]
1888         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[214]
1889         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[215]
1890         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[216]
1891         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[217]
1892         {0x0F12,0x0106},         //TVAR_afit_pBaseVals[218]
1893         {0x0F12,0x006F},         //TVAR_afit_pBaseVals[219]
1894         {0x0F12,0x0505},         //TVAR_afit_pBaseVals[220]
1895         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[221]
1896         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[222]
1897         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[223]
1898         {0x0F12,0x1946},         //TVAR_afit_pBaseVals[224]
1899         {0x0F12,0x4619},         //TVAR_afit_pBaseVals[225]
1900         {0x0F12,0x0F0F},         //TVAR_afit_pBaseVals[226]
1901         {0x0F12,0x0606},         //TVAR_afit_pBaseVals[227]
1902         {0x0F12,0x020F},         //TVAR_afit_pBaseVals[228]
1903         {0x0F12,0x0480},         //TVAR_afit_pBaseVals[229]
1904         {0x0F12,0x0804},         //TVAR_afit_pBaseVals[230]
1905         {0x0F12,0x030A},         //TVAR_afit_pBaseVals[231]
1906         {0x0F12,0x1403},         //TVAR_afit_pBaseVals[232]
1907         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[233]
1908         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[234]
1909         {0x0F12,0x0500},         //TVAR_afit_pBaseVals[235]
1910         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[236]
1911         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[237]
1912         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[238]
1913         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[239]
1914         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[240]
1915         {0x0F12,0x0404},         //TVAR_afit_pBaseVals[241]
1916         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[242]
1917         {0x0F12,0x0402},         //TVAR_afit_pBaseVals[243]
1918         {0x0F12,0x0002},         //TVAR_afit_pBaseVals[244]
1919         {0x0F12,0x1006},         //TVAR_afit_pBaseVals[245]
1920         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[246]
1921         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[247]
1922         {0x0F12,0x0100},         //TVAR_afit_pBaseVals[248]
1923         {0x0F12,0x8046}, //5A  //0x806B  //TVAR_afit_pBaseVals[249]
1924         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[250]
1925         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[251]
1926         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[252]
1927         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[253]
1928         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[254]
1929         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[255]
1930         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[256]
1931         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[257]
1932         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[258]
1933         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[259]
1934         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[260]
1935         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[261]
1936         {0x0F12,0x0003},         //TVAR_afit_pBaseVals[262]
1937         {0x0F12,0x0019},         //TVAR_afit_pBaseVals[263]
1938         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[264]
1939         {0x0F12,0x0064},         //TVAR_afit_pBaseVals[265]
1940         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[266]
1941         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[267]
1942         {0x0F12,0x0000},         //TVAR_afit_pBaseVals[268]
1943         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[269]
1944         {0x0F12,0x000F},         //TVAR_afit_pBaseVals[270]
1945         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[271]
1946         {0x0F12,0x03FF},         //TVAR_afit_pBaseVals[272]
1947         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[273]
1948         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[274]
1949         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[275]
1950         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[276]
1951         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[277]
1952         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[278]
1953         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[279]
1954         {0x0F12,0x0028},         //TVAR_afit_pBaseVals[280]
1955         {0x0F12,0x0106},         //TVAR_afit_pBaseVals[281]
1956         {0x0F12,0x006F},         //TVAR_afit_pBaseVals[282]
1957         {0x0F12,0x0505},         //TVAR_afit_pBaseVals[283]
1958         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[284]
1959         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[285]
1960         {0x0F12,0x0202},         //TVAR_afit_pBaseVals[286]
1961         {0x0F12,0x1946},         //TVAR_afit_pBaseVals[287]
1962         {0x0F12,0x4619},         //TVAR_afit_pBaseVals[288]
1963         {0x0F12,0x0F0F},         //TVAR_afit_pBaseVals[289]
1964         {0x0F12,0x0606},         //TVAR_afit_pBaseVals[290]
1965         {0x0F12,0x020F},         //TVAR_afit_pBaseVals[291]
1966         {0x0F12,0x0480},         //TVAR_afit_pBaseVals[292]
1967         {0x0F12,0x0804},         //TVAR_afit_pBaseVals[293]
1968         {0x0F12,0x030A},         //TVAR_afit_pBaseVals[294]
1969         {0x0F12,0x1403},         //TVAR_afit_pBaseVals[295]
1970         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[296]
1971         {0x0F12,0x0014},         //TVAR_afit_pBaseVals[297]
1972         {0x0F12,0x0500},         //TVAR_afit_pBaseVals[298]
1973         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[299]
1974         {0x0F12,0x1414},         //TVAR_afit_pBaseVals[300]
1975         {0x0F12,0x0A0A},         //TVAR_afit_pBaseVals[301]
1976         {0x0F12,0x0005},         //TVAR_afit_pBaseVals[302]
1977         {0x0F12,0x0303},         //TVAR_afit_pBaseVals[303]
1978         {0x0F12,0x0707},         //TVAR_afit_pBaseVals[304]
1979         {0x0F12,0x0303},         //TVAR_afit_pBaseVals[305]
1980         {0x0F12,0x0806},         //TVAR_afit_pBaseVals[306]
1981         {0x0F12,0x0004},         //TVAR_afit_pBaseVals[307]
1982         {0x0F12,0x1006},         //TVAR_afit_pBaseVals[308]
1983         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[309]
1984         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[310]
1985         {0x0F12,0x0100},         //TVAR_afit_pBaseVals[311]
1986         {0x0F12,0x8046}, //5A   //0x806B //TVAR_afit_pBaseVals[312]
1987         {0x0F12,0x0180},         //TVAR_afit_pBaseVals[313]
1988         {0x0F12,0x0000},      ////TVAR_afit_pBaseVals[314]      param_end       TVAR_afit_pBaseVals
1989                           //    param_sta afit_pConstBaseVals
1990         {0x0F12,0x03FC},
1991         {0x0F12,0x03FF},
1992         {0x0F12,0x0500},
1993         {0x0F12,0x0400},
1994         {0x0F12,0x0000},
1995         {0x0F12,0x0000},
1996         {0x0F12,0x0000},
1997         {0x0F12,0x0300},
1998         {0x0F12,0x0002},
1999         {0x0F12,0x0300},
2000         {0x0F12,0x0203},
2001         {0x0F12,0x0003},
2002         {0x0F12,0x0000},
2003         {0x0F12,0x0204},
2004         {0x0F12,0x0000},
2005         {0x0F12,0xFDD6},
2006         {0x0F12,0x43C1},
2007         {0x0F12,0xF0FA},
2008         {0x0F12,0x0001},  //    param_end       afit_pConstBaseVals
2009
2010         {0x002A,0x06d4},  //#TVAR_wbt_pOutdoorCcm
2011         {0x0F12,0x2380},
2012         {0x0F12,0x7000},
2013         {0x002A,0x06cc},  //#TVAR_wbt_pBaseCcms
2014         {0x0F12,0x23A4},
2015         {0x0F12,0x7000},
2016         {0x002A,0x06e8},  //#TVAR_wbt_pBaseCcmsAddr[0]
2017         {0x0F12,0x23A4},
2018         {0x0F12,0x7000},
2019         {0x002A,0x06EC},  //#TVAR_wbt_pBaseCcmsAddr[1]
2020         {0x0F12,0x23C8},
2021         {0x0F12,0x7000},
2022         {0x002A,0x06f0},  //#TVAR_wbt_pBaseCcmsAddr[2]
2023         {0x0F12,0x23EC},
2024         {0x0F12,0x7000},
2025         {0x002A,0x06f4},  //#TVAR_wbt_pBaseCcmsAddr[3]
2026         {0x0F12,0x2410},
2027         {0x0F12,0x7000},
2028         {0x002A,0x06f8},  //#TVAR_wbt_pBaseCcmsAddr[4]
2029         {0x0F12,0x2434},
2030         {0x0F12,0x7000},
2031         {0x002A,0x06fc},  //#TVAR_wbt_pBaseCcmsAddr[5]
2032         {0x0F12,0x2458},
2033         {0x0F12,0x7000},  // End tuning part
2034         {0x1000,0x0001},
2035         //1000  0001    // Set host interrupt so main start run
2036         //p10   // Wait10mSec
2037         {SEQUENCE_WAIT_MS,20},
2038
2039
2040
2041         // Set Flicker
2042
2043         //=================================================================================================
2044         // Set Flicker
2045         //=================================================================================================
2046
2047         ////1. Auto Flicker 60Hz Start
2048         //{0x002A, AFC_Default60Hz},
2049         //{0x0F12, 0x0001},  // #AFC_Default60Hz  1: Auto Flicker 60Hz start 0: Auto Flicker 50Hz start
2050         //{0x002A, REG_TC_DBG_AutoAlgEnBits},
2051         //{0x0F12, 0x007F},  // #REG_TC_DBG_AutoAlgEnBits  //default : 007F
2052
2053         ////2. Auto Flicker 50Hz Start
2054         //{0x002A, 0xAFC_Default60Hz},
2055         //{0x0F12, 0x0000},     //1: Auto Flicker 60Hz start 0: Auto Flicker 50Hz start
2056         //{0x002A, 0xREG_TC_DBG_AutoAlgEnBits},
2057         //{0x0F12, 0x007F},     //default : 007F
2058
2059         //3. Manual Flicker 60Hz
2060         //{0x002A, 0xREG_TC_DBG_AutoAlgEnBits},  //default : 007F
2061         //{0x0F12, 0x005F},
2062         //{0x002A, 0xREG_SF_USER_FlickerQuant},  //Flicker 50Hz:0001/60Hz:0002/off:0000
2063         //{0x0F12, 0x0002},
2064         //{0x002A, 0xREG_SF_USER_FlickerQuantChanged}, //if change 0001 write
2065         //{0x0F12, 0x0001},
2066
2067         //4. Manual Flicker 50Hz
2068         {0x002A, REG_TC_DBG_AutoAlgEnBits}, //default : 007F
2069         {0x0F12, 0x005F},
2070         {0x002A, REG_SF_USER_FlickerQuant},  //Flicker 50Hz:0001/60Hz:0002/off:0000
2071         {0x0F12, 0x0001},
2072         {0x002A, REG_SF_USER_FlickerQuantChanged}, //if change 0001 write
2073         {0x0F12, 0x0001},
2074
2075         //5. Flicker Off
2076         //{0x002A, 0xREG_TC_DBG_AutoAlgEnBits},  //default : 007F
2077         //{0x0F12, 0x005F},
2078         //{0x002A, 0xREG_SF_USER_FlickerQuant},  //Flicker 50Hz:0001/60Hz:0002/off:0000
2079         //{0x0F12, 0x0000},
2080         //{0x002A, 0xREG_SF_USER_FlickerQuantChanged}, //if change 0001 write
2081         //{0x0F12, 0x0001},
2082
2083         //{0x002A, 0xAFC_ManualQuant},
2084         //{0x0F12, 0x0001},
2085
2086
2087         {0x002A,lt_uMaxExp1},
2088         {0x0F12,0xC350},        // #lt_uMaxExp1         : 66.6ms                //30fps:  30fps-> 33.3ms->410A
2089         {0x0F12,0x0000},
2090         {0x002A,lt_uMaxExp2},
2091         {0x0F12,0x8488},        // #lt_uMaxExp2         : 250ms
2092         {0x0F12,0x0002},
2093         {0x002A,lt_uCapMaxExp1},
2094         {0x0F12,0xE848},        // #lt_uCapMaxExp1      : 133.3ms = 0x1045a  //edison : 10fps = 100ms=0xc350
2095         {0x0F12,0x0001},
2096         {0x002A,lt_uCapMaxExp2},
2097         {0x0F12,0x8488},        // #lt_uCapMaxExp2      : 250ms
2098         {0x0F12,0x0002},
2099         {0x002A,lt_uMaxAnGain1},
2100         {0x0F12,0x0280}, //0280         // #lt_uMaxAnGain1      : X 2.51¡§¡§
2101         {0x002A,lt_uMaxAnGain2},
2102         {0x0F12,0x0600}, //0500         // #lt_uMaxAnGain2      : X 6.01¡§¡§
2103         {0x002A,lt_uMaxDigGain},
2104         {0x0F12,0x0100}, //0200         // #lt_uMaxDigGain
2105         //{0x0F12  0007         // #ae_StatMode
2106
2107         //clk Settings
2108         {0x002A,0x01b8},   // input=24MHz
2109         {0x0F12,0x5dc0},   // #REG_TC_IPRM_InClockLSBs
2110         {0x002A,0x01ba},
2111         {0x0F12,0x0000},
2112         {0x002A,0x01c6},   // #REG_TC_IPRM_UseNPviClocks 1 PLL configurations
2113         {0x0F12,0x0002},
2114         {0x002A,0x01cc},   // 1st system CLK
2115         {0x0F12,0x0bb8}, //1964   //#REG_TC_IPRM_sysClocks[0]
2116         {0x0F12,0x0bb8},   //#REG_TC_IPRM_MinOutRate4KHz_0
2117         {0x0F12,0x0bb8},   //#REG_TC_IPRM_MaxOutRate4KHz_0
2118
2119         {0x0F12,0x1770},   //#REG_TC_IPRM_sysClocks[1]
2120         {0x0F12,0x1770}, //2ee0   //#REG_TC_IPRM_MinOutRate4KHz_1
2121         {0x0F12,0x1770}, //2ee0   //#REG_TC_IPRM_MaxOutRate4KHz_1
2122         {0x002A,0x01e0},   //#REG_TC_IPRM_InitParamsUpdated
2123         {0x0F12,0x0001},
2124         //p10
2125
2126
2127         //PREVIEW CONFIGURATION 0 (VGA, YUV, 6.5~12fps)
2128         {0x002A,0x0242},
2129         {0x0F12,0x0280}, //0500         //Width
2130         {0x0F12,0x01e0}, //0400   //Height
2131         {0x0F12,0x0005},   //Format, 5:YUV422
2132         {0x0F12,0x1770},   //MaxOut4KHzRate, 1770 = 24M
2133         {0x0F12,0x1770},   //MinOut4KHzRate, 1770 = 24M
2134         {0x0F12,0x0052},   //PVIMask, default = 42
2135         {0x0F12,0x0001},   //ClockInd, 0-2
2136         {0x0F12,0x0000},   //FrTimeType, 0:Dynamic, 1:Fix for not accuarte, 2:Fix for accuarte
2137         {0x0F12,0x0000},   //FrRateQualityType, 1:Binning enable, 2:Binning disable
2138         {0x0F12,0x0600}, //0535 //04E2   //MaxFrTime, 14d = 33.3ms(333-6500) //7.5FPS
2139         {0x0F12,0x0320}, //03E8 //04E2   //MinFrTime, 14d = 33.3ms(333-6500) //15 FPS
2140
2141         //=================================================================================================
2142         // Set Preview Config 1 --- For Night Mode     //  4~12fps
2143         //=================================================================================================
2144         {0x002A, REG_1TC_PCFG_usWidth},
2145         {0x0F12, 0x0280},   // #REG_0TC_PCFG_usWidth
2146         {0x002A, REG_1TC_PCFG_usHeight},
2147         {0x0F12, 0x01e0},   // #REG_0TC_PCFG_usHeight
2148         {0x002A, REG_1TC_PCFG_Format},
2149         {0x0F12, 0x0005},   // #REG_0TC_PCFG_Format  : YUV
2150         {0x002A, REG_1TC_PCFG_usMaxOut4KHzRate},
2151         {0x0F12, 0x1770},   // #REG_0TC_PCFG_usMaxOut4KHzRate
2152         {0x002A, REG_1TC_PCFG_usMinOut4KHzRate},
2153         {0x0F12, 0x1770},   // #REG_0TC_PCFG_usMinOut4KHzRate
2154         {0x002A, REG_1TC_PCFG_PVIMask},
2155         {0x0F12, 0x0052},   // #REG_0TC_PCFG_PVIMask (x2: PCLK rising  # x0: PCLK Falling)
2156         {0x002A, REG_1TC_PCFG_uClockInd},
2157         {0x0F12, 0x0001},    // #REG_0TC_PCFG_uClockInd
2158         {0x002A, REG_1TC_PCFG_usFrTimeType},
2159         {0x0F12, 0x0000},   // #REG_0TC_PCFG_usFrTimeType
2160         {0x002A, REG_1TC_PCFG_FrRateQualityType},
2161         {0x0F12, 0x0000},   // #REG_0TC_PCFG_FrRateQualityType
2162         {0x002A, REG_1TC_PCFG_usMaxFrTimeMsecMult10},
2163         {0x0F12, 0x0CE4},  //09C4 // 4FPS 029A  // #REG_0TC_PCFG_usMaxFrTimeMsecMult10 : 5fps
2164         {0x002A, REG_1TC_PCFG_usMinFrTimeMsecMult10},
2165         {0x0F12, 0x0320},  //  // #REG_0TC_PCFG_usMinFrTimeMsecMult10 : 10fps
2166         //WRITE 70000262 0003 // #REG_0TC_PCFG_uPrevMirror
2167         //WRITE 70000264 0003 // #REG_0TC_PCFG_uCaptureMirror
2168    /*lzg@rock-chips.com, FIH:image to be mirrored*/
2169 #if  CONFIG_SENSOR_NONE_FLIP_MIRROR
2170         {0x002A, 0x0262},
2171         {0x0F12, 0x0000},
2172         {0x002A, 0x0264},
2173         {0x0F12, 0x0000},
2174 #elif CONFIG_SENSOR_MIRROR
2175         {0x002A, 0x0262},
2176         {0x0F12, 0x0001},
2177         {0x002A, 0x0264},
2178         {0x0F12, 0x0001},
2179 #elif CONFIG_SENSOR_FLIPE
2180         {0x002A, 0x0262},
2181         {0x0F12, 0x0002},
2182         {0x002A, 0x0264},
2183         {0x0F12, 0x0002},
2184 #elif CONFIG_SENSOR_NONE_FLIP_MIRROR
2185         {0x002A, 0x0262},
2186         {0x0F12, 0x0003},
2187         {0x002A, 0x0264},
2188         {0x0F12, 0x0003},
2189 #endif
2190    //=================================================================================================
2191         // Set Preview Config 2 --- For Video record(normal)     // 12fps
2192         //=================================================================================================
2193         {0x002A,  REG_2TC_PCFG_usWidth},
2194         {0x0F12,  0x0280},  // #REG_0TC_PCFG_usWidth
2195         {0x002A,  REG_2TC_PCFG_usHeight},
2196         {0x0F12,  0x01e0},  // #REG_0TC_PCFG_usHeight
2197         {0x002A,  REG_2TC_PCFG_Format},
2198         {0x0F12,  0x0005},  // #REG_0TC_PCFG_Format  : YUV
2199         {0x002A,  REG_2TC_PCFG_usMaxOut4KHzRate},
2200         {0x0F12,  0x0BB8}, //1770  // #REG_0TC_PCFG_usMaxOut4KHzRate
2201         {0x002A,  REG_2TC_PCFG_usMinOut4KHzRate},
2202         {0x0F12,  0x0BB8}, //1770  // #REG_0TC_PCFG_usMinOut4KHzRate
2203         {0x002A,  REG_2TC_PCFG_PVIMask},
2204         {0x0F12,  0x0052},  // #REG_0TC_PCFG_PVIMask (x2: PCLK rising  # x0: PCLK Falling)
2205         {0x002A,  REG_2TC_PCFG_uClockInd},
2206         {0x0F12,  0x0001},   // #REG_0TC_PCFG_uClockInd
2207         {0x002A,  REG_2TC_PCFG_usFrTimeType},
2208         {0x0F12,  0x0002}, //0  // #REG_0TC_PCFG_usFrTimeType
2209         {0x002A,  REG_2TC_PCFG_FrRateQualityType},
2210         {0x0F12,  0x0000},  // #REG_0TC_PCFG_FrRateQualityType
2211         {0x002A,  REG_2TC_PCFG_usMaxFrTimeMsecMult10},
2212         {0x0F12,  0x0320}, //07D0 //029A  // #REG_0TC_PCFG_usMaxFrTimeMsecMult10 : 5fps
2213         {0x002A,  REG_2TC_PCFG_usMinFrTimeMsecMult10},
2214         {0x0F12,  0x0000},//0320 //03E8 // #REG_0TC_PCFG_usMinFrTimeMsecMult10 : 10fps
2215
2216
2217         //=================================================================================================
2218         // Set Preview Config 3 --- For Video Record(Night Mode)    //  12fps
2219         //=================================================================================================
2220         {0x002A, REG_3TC_PCFG_usWidth},
2221         {0x0F12, 0x0280},  // #REG_0TC_PCFG_usWidth
2222         {0x002A, REG_3TC_PCFG_usHeight},
2223         {0x0F12, 0x01e0},  // #REG_0TC_PCFG_usHeight
2224         {0x002A, REG_3TC_PCFG_Format},
2225         {0x0F12, 0x0005},  // #REG_0TC_PCFG_Format  : YUV
2226         {0x002A, REG_3TC_PCFG_usMaxOut4KHzRate},
2227         {0x0F12, 0x0BB8}, //1770  // #REG_0TC_PCFG_usMaxOut4KHzRate
2228         {0x002A, REG_3TC_PCFG_usMinOut4KHzRate},
2229         {0x0F12, 0x0BB8}, //1770  // #REG_0TC_PCFG_usMinOut4KHzRate
2230         {0x002A, REG_3TC_PCFG_PVIMask},
2231         {0x0F12, 0x0052},  // #REG_0TC_PCFG_PVIMask (x2: PCLK rising  # x0: PCLK Falling)
2232         {0x002A, REG_3TC_PCFG_uClockInd},
2233         {0x0F12, 0x0001},   // #REG_0TC_PCFG_uClockInd
2234         {0x002A, REG_3TC_PCFG_usFrTimeType},
2235         {0x0F12, 0x0002}, //0  // #REG_0TC_PCFG_usFrTimeType
2236         {0x002A, REG_3TC_PCFG_FrRateQualityType},
2237         {0x0F12, 0x0000},  // #REG_0TC_PCFG_FrRateQualityType
2238         {0x002A, REG_3TC_PCFG_usMaxFrTimeMsecMult10},
2239         {0x0F12, 0x03e8}, //029A  // #REG_0TC_PCFG_usMaxFrTimeMsecMult10 : 5fps
2240         {0x002A, REG_3TC_PCFG_usMinFrTimeMsecMult10},
2241         {0x0F12, 0x0000},//0320 //03E8 // #REG_0TC_PCFG_usMinFrTimeMsecMult10 : 10fps
2242
2243         //Preview
2244         {0x002A,0x021c},   //REG_TC_GP_ActivePrevConfig
2245         {0x0F12,0x0000},
2246         {0x002A,0x0220},   //REG_TC_GP_PrevOpenAfterChange
2247         {0x0F12,0x0001},
2248         {0x002A,0x01f8},   //REG_TC_GP_NewConfigSync
2249         {0x0F12,0x0001},
2250         {0x002A,0x021e},   //REG_TC_GP_PrevConfigChanged
2251         {0x0F12,0x0001},
2252         {0x002A,0x01f0},   //REG_TC_GP_EnablePreview
2253         {0x0F12,0x0001},
2254         {0x002A,0x01f2},   //REG_TC_GP_EnablePreviewChanged
2255         {0x0F12,0x0001},
2256
2257
2258          //=================================================================================================
2259          // Set Capture Config   // normal mode
2260          //=================================================================================================
2261          {0x002A,REG_0TC_CCFG_uCaptureMode},
2262          {0x0F12,0x0000},  // #REG_0TC_CCFG_uCaptureMode : AE/AWB off when caputre
2263          {0x002A,REG_0TC_CCFG_usWidth},
2264          {0x0F12,0x0500},
2265          {0x002A,REG_0TC_CCFG_usHeight},
2266          {0x0F12,0x0400},
2267          {0x002A,REG_0TC_CCFG_Format},
2268          {0x0F12,0x0005},  // #REG_0TC_CCFG_Format  : YUV
2269          {0x002A,REG_0TC_CCFG_usMaxOut4KHzRate},
2270          {0x0F12,0x0bb8}, //05DC //0BC8 //1964 //0BB8  // #REG_0TC_CCFG_usMaxOut4KHzRate
2271          {0x002A,REG_0TC_CCFG_usMinOut4KHzRate},
2272          {0x0F12,0x0bb8}, //05DC //0BA8 //1964 //0BB8   // #REG_0TC_CCFG_usMinOut4KHzRate
2273          {0x002A,REG_0TC_CCFG_PVIMask},
2274          {0x0F12,0x0052},  // #REG_0TC_CCFG_PVIMask (x2: PCLK rising  # x0: PCLK Falling)
2275          {0x002A,REG_0TC_CCFG_uClockInd},
2276          {0x0F12,0x0000},  // #REG_0TC_CCFG_uClockInd
2277          {0x002A,REG_0TC_CCFG_usFrTimeType},
2278          {0x0F12,0x0002}, //0  // #REG_0TC_CCFG_usFrTimeType
2279          {0x002A,REG_0TC_CCFG_FrRateQualityType},
2280          {0x0F12,0x0002},  // #REG_0TC_CCFG_FrRateQualityType
2281          {0x002A,REG_0TC_CCFG_usMaxFrTimeMsecMult10},
2282          {0x0F12,0x09C4}, //0x09C4  // #REG_0TC_CCFG_usMaxFrTimeMsecMult10 : 4fps
2283          {0x002A,REG_0TC_CCFG_usMinFrTimeMsecMult10},
2284          {0x0F12,0x0000}, //03e8  // #REG_0TC_CCFG_usMinFrTimeMsecMult10 :
2285         {SEQUENCE_END, 0x00}
2286 };
2287
2288
2289
2290
2291 static struct reginfo sensor_720p[]=
2292 {
2293         {SEQUENCE_END, 0x00}
2294 };
2295 static struct reginfo sensor_1080p[]=
2296 {
2297         {SEQUENCE_END, 0x00}
2298 };
2299 /* 2592X1944 QSXGA */
2300 static struct reginfo sensor_qsxga[] =
2301 {
2302         {SEQUENCE_END, 0x00}
2303 };
2304 /* 2048*1536 QXGA */
2305 static struct reginfo sensor_qxga[] =
2306 {
2307         {SEQUENCE_END, 0x00}
2308 };
2309
2310 /* 1600X1200 UXGA */
2311 static struct reginfo sensor_uxga[] =
2312 {
2313         {SEQUENCE_END, 0x00}
2314 };
2315
2316 /* 1280X1024 SXGA */
2317 static struct reginfo sensor_sxga[] =
2318 {
2319         {0x0028, 0x7000},
2320         //002A 03F8
2321         ////0F12 0079 // #REG_TC_DBG_AutoAlgEnBits, default : 007F0028 7000
2322         //002A 0496
2323         //0F12 0300 //0220 //0330       // #lt_uMaxAnGain2
2324         {0x002A, REG_TC_GP_ActiveCapConfig},
2325         {0x0F12, 0x0000},
2326         {0x002A, REG_TC_GP_NewConfigSync},
2327         {0x0F12, 0x0001},
2328         {0x002A, REG_TC_GP_CapConfigChanged},
2329         {0x0F12, 0x0001},
2330         {0x002A, REG_TC_GP_EnableCapture},
2331         {0x0F12, 0x0001},
2332         {0x002A, REG_TC_GP_EnableCaptureChanged},
2333         {0x0F12, 0x0001},
2334         {SEQUENCE_END, 0x00}
2335 };
2336 /*  1024X768 XGA */
2337 static struct reginfo sensor_xga[] =
2338 {
2339         {SEQUENCE_END, 0x00}
2340 };
2341 /* 800X600 SVGA*/
2342 static struct reginfo sensor_svga[] =
2343 {
2344     {SEQUENCE_END, 0x0},
2345 };
2346
2347 /* 640X480 VGA */
2348 static struct reginfo sensor_vga[] =
2349 {
2350         {0x0028, 0x7000},
2351         {0x002A, REG_TC_GP_ActivePrevConfig},
2352         {0x0F12, 0x0000},
2353
2354         {0x002A, REG_TC_GP_PrevOpenAfterChange},
2355         {0x0F12, 0x0001},
2356         {0x002A, REG_TC_GP_NewConfigSync},
2357         {0x0F12, 0x0001},
2358         {0x002A, REG_TC_GP_PrevConfigChanged},
2359         {0x0F12, 0x0001},
2360     {SEQUENCE_END, 0x0},
2361 };
2362
2363 /* 352X288 CIF */
2364 static struct reginfo sensor_cif[] =
2365 {
2366     {SEQUENCE_END, 0x0},
2367 };
2368
2369 /* 320*240 QVGA */
2370 static  struct reginfo sensor_qvga[] =
2371 {
2372     {SEQUENCE_END, 0x0},
2373 };
2374
2375 /* 176X144 QCIF*/
2376 static struct reginfo sensor_qcif[] =
2377 {
2378     {SEQUENCE_END, 0x0},
2379 };
2380 #endif
2381 #if 0
2382 /* 160X120 QQVGA*/
2383 static struct reginfo s5k6aa_qqvga[] =
2384 {
2385
2386     {0x300E, 0x34},
2387     {0x3011, 0x01},
2388     {0x3012, 0x10},
2389     {0x302a, 0x02},
2390     {0x302b, 0xE6},
2391     {0x306f, 0x14},
2392     {0x3362, 0x90},
2393
2394     {0x3070, 0x5d},
2395     {0x3072, 0x5d},
2396     {0x301c, 0x07},
2397     {0x301d, 0x07},
2398
2399     {0x3020, 0x01},
2400     {0x3021, 0x18},
2401     {0x3022, 0x00},
2402     {0x3023, 0x06},
2403     {0x3024, 0x06},
2404     {0x3025, 0x58},
2405     {0x3026, 0x02},
2406     {0x3027, 0x61},
2407     {0x3088, 0x00},
2408     {0x3089, 0xa0},
2409     {0x308a, 0x00},
2410     {0x308b, 0x78},
2411     {0x3316, 0x64},
2412     {0x3317, 0x25},
2413     {0x3318, 0x80},
2414     {0x3319, 0x08},
2415     {0x331a, 0x0a},
2416     {0x331b, 0x07},
2417     {0x331c, 0x80},
2418     {0x331d, 0x38},
2419     {0x3100, 0x00},
2420     {0x3302, 0x11},
2421
2422     {SEQUENCE_END, 0x0},
2423 };
2424
2425
2426
2427 static  struct reginfo s5k6aa_Sharpness_auto[] =
2428 {
2429     {SEQUENCE_END, 0x00},
2430 };
2431
2432 static  struct reginfo s5k6aa_Sharpness1[] =
2433 {
2434     {0x3306, 0x08},
2435     {0x3371, 0x00}
2436 };
2437
2438 static  struct reginfo s5k6aa_Sharpness2[][3] =
2439 {
2440     //Sharpness 2
2441     {0x3306, 0x08},
2442     {0x3371, 0x01},
2443 };
2444
2445 static  struct reginfo s5k6aa_Sharpness3[] =
2446 {
2447     //default
2448     {0x3306, 0x08},
2449     {0x332d, 0x02},
2450 };
2451 static  struct reginfo s5k6aa_Sharpness4[]=
2452 {
2453     //Sharpness 4
2454     {0x3306, 0x08},
2455     {0x332d, 0x03},
2456 };
2457
2458 static  struct reginfo s5k6aa_Sharpness5[] =
2459 {
2460     //Sharpness 5
2461     {0x3306, 0x08},
2462     {0x332d, 0x04},
2463 };
2464 #endif
2465
2466 static  struct reginfo sensor_ClrFmt_YUYV[]=
2467 {
2468     {SEQUENCE_END, 0x00}
2469 };
2470
2471 static  struct reginfo sensor_ClrFmt_UYVY[]=
2472 {
2473     {SEQUENCE_END, 0x00}
2474 };
2475
2476 #if CONFIG_SENSOR_WhiteBalance
2477 static  struct reginfo sensor_WhiteB_Auto[]=
2478 {
2479     {SEQUENCE_END, 0x00}
2480 };
2481 /* Cloudy Colour Temperature : 6500K - 8000K  */
2482 static  struct reginfo sensor_WhiteB_Cloudy[]=
2483 {
2484     {SEQUENCE_END, 0x00}
2485 };
2486 /* ClearDay Colour Temperature : 5000K - 6500K  */
2487 static  struct reginfo sensor_WhiteB_ClearDay[]=
2488 {
2489     {SEQUENCE_END, 0x00}
2490 };
2491 /* Office Colour Temperature : 3500K - 5000K  */
2492 static  struct reginfo sensor_WhiteB_TungstenLamp1[]=
2493 {
2494     {SEQUENCE_END, 0x00}
2495
2496 };
2497 /* Home Colour Temperature : 2500K - 3500K  */
2498 static  struct reginfo sensor_WhiteB_TungstenLamp2[]=
2499 {
2500     {SEQUENCE_END, 0x00}
2501 };
2502 static struct reginfo *sensor_WhiteBalanceSeqe[] = {sensor_WhiteB_Auto, sensor_WhiteB_TungstenLamp1,sensor_WhiteB_TungstenLamp2,
2503     sensor_WhiteB_ClearDay, sensor_WhiteB_Cloudy,NULL,
2504 };
2505 #endif
2506
2507 #if CONFIG_SENSOR_Brightness
2508 static  struct reginfo sensor_Brightness0[]=
2509 {
2510     {SEQUENCE_END, 0x00}
2511 };
2512
2513 static  struct reginfo sensor_Brightness1[]=
2514 {
2515     {SEQUENCE_END, 0x00}
2516 };
2517
2518 static  struct reginfo sensor_Brightness2[]=
2519 {
2520     {SEQUENCE_END, 0x00}
2521 };
2522
2523 static  struct reginfo sensor_Brightness3[]=
2524 {
2525     {SEQUENCE_END, 0x00}
2526 };
2527
2528 static  struct reginfo sensor_Brightness4[]=
2529 {
2530     {SEQUENCE_END, 0x00}
2531 };
2532
2533 static  struct reginfo sensor_Brightness5[]=
2534 {
2535     {SEQUENCE_END, 0x00}
2536 };
2537 static struct reginfo *sensor_BrightnessSeqe[] = {sensor_Brightness0, sensor_Brightness1, sensor_Brightness2, sensor_Brightness3,
2538     sensor_Brightness4, sensor_Brightness5,NULL,
2539 };
2540
2541 #endif
2542
2543 #if CONFIG_SENSOR_Effect
2544 static  struct reginfo sensor_Effect_Normal[] =
2545 {
2546     {SEQUENCE_END, 0x00}
2547 };
2548
2549 static  struct reginfo sensor_Effect_WandB[] =
2550 {
2551     {SEQUENCE_END, 0x00}
2552 };
2553
2554 static  struct reginfo sensor_Effect_Sepia[] =
2555 {
2556     {SEQUENCE_END, 0x00}
2557 };
2558
2559 static  struct reginfo sensor_Effect_Negative[] =
2560 {
2561     {SEQUENCE_END, 0x00}
2562 };
2563 static  struct reginfo sensor_Effect_Bluish[] =
2564 {
2565     {SEQUENCE_END, 0x00}
2566 };
2567
2568 static  struct reginfo sensor_Effect_Green[] =
2569 {
2570     {SEQUENCE_END, 0x00}
2571 };
2572 static struct reginfo *sensor_EffectSeqe[] = {sensor_Effect_Normal, sensor_Effect_WandB, sensor_Effect_Negative,sensor_Effect_Sepia,
2573     sensor_Effect_Bluish, sensor_Effect_Green,NULL,
2574 };
2575 #endif
2576 #if CONFIG_SENSOR_Exposure
2577 static  struct reginfo sensor_Exposure0[]=
2578 {
2579     {SEQUENCE_END, 0x00}
2580 };
2581
2582 static  struct reginfo sensor_Exposure1[]=
2583 {
2584     {SEQUENCE_END, 0x00}
2585 };
2586
2587 static  struct reginfo sensor_Exposure2[]=
2588 {
2589     {SEQUENCE_END, 0x00}
2590 };
2591
2592 static  struct reginfo sensor_Exposure3[]=
2593 {
2594     {SEQUENCE_END, 0x00}
2595 };
2596
2597 static  struct reginfo sensor_Exposure4[]=
2598 {
2599     {SEQUENCE_END, 0x00}
2600 };
2601
2602 static  struct reginfo sensor_Exposure5[]=
2603 {
2604     {SEQUENCE_END, 0x00}
2605 };
2606
2607 static  struct reginfo sensor_Exposure6[]=
2608 {
2609     {SEQUENCE_END, 0x00}
2610 };
2611
2612 static struct reginfo *sensor_ExposureSeqe[] = {sensor_Exposure0, sensor_Exposure1, sensor_Exposure2, sensor_Exposure3,
2613     sensor_Exposure4, sensor_Exposure5,sensor_Exposure6,NULL,
2614 };
2615 #endif
2616 #if CONFIG_SENSOR_Saturation
2617 static  struct reginfo sensor_Saturation0[]=
2618 {
2619     {SEQUENCE_END, 0x00}
2620 };
2621
2622 static  struct reginfo sensor_Saturation1[]=
2623 {
2624     {SEQUENCE_END, 0x00}
2625 };
2626
2627 static  struct reginfo sensor_Saturation2[]=
2628 {
2629     {SEQUENCE_END, 0x00}
2630 };
2631 static struct reginfo *sensor_SaturationSeqe[] = {sensor_Saturation0, sensor_Saturation1, sensor_Saturation2, NULL,};
2632
2633 #endif
2634 #if CONFIG_SENSOR_Contrast
2635 static  struct reginfo sensor_Contrast0[]=
2636 {
2637     {SEQUENCE_END, 0x00}
2638 };
2639
2640 static  struct reginfo sensor_Contrast1[]=
2641 {
2642     {SEQUENCE_END, 0x00}
2643 };
2644
2645 static  struct reginfo sensor_Contrast2[]=
2646 {
2647     {SEQUENCE_END, 0x00}
2648 };
2649
2650 static  struct reginfo sensor_Contrast3[]=
2651 {
2652     {SEQUENCE_END, 0x00}
2653 };
2654
2655 static  struct reginfo sensor_Contrast4[]=
2656 {
2657     {SEQUENCE_END, 0x00}
2658 };
2659
2660
2661 static  struct reginfo sensor_Contrast5[]=
2662 {
2663     {SEQUENCE_END, 0x00}
2664 };
2665
2666 static  struct reginfo sensor_Contrast6[]=
2667 {
2668     {SEQUENCE_END, 0x00}
2669 };
2670 static struct reginfo *sensor_ContrastSeqe[] = {sensor_Contrast0, sensor_Contrast1, sensor_Contrast2, sensor_Contrast3,
2671     sensor_Contrast4, sensor_Contrast5, sensor_Contrast6, NULL,
2672 };
2673
2674 #endif
2675 #if CONFIG_SENSOR_Mirror
2676 static  struct reginfo sensor_MirrorOn[]=
2677 {
2678     {SEQUENCE_END, 0x00}
2679 };
2680
2681 static  struct reginfo sensor_MirrorOff[]=
2682 {
2683     {SEQUENCE_END, 0x00}
2684 };
2685 static struct reginfo *sensor_MirrorSeqe[] = {sensor_MirrorOff, sensor_MirrorOn,NULL,};
2686 #endif
2687 #if CONFIG_SENSOR_Flip
2688 static  struct reginfo sensor_FlipOn[]=
2689 {
2690     {SEQUENCE_END, 0x00}
2691 };
2692
2693 static  struct reginfo sensor_FlipOff[]=
2694 {
2695     {SEQUENCE_END, 0x00}
2696 };
2697 static struct reginfo *sensor_FlipSeqe[] = {sensor_FlipOff, sensor_FlipOn,NULL,};
2698
2699 #endif
2700 #if CONFIG_SENSOR_Scene
2701 static  struct reginfo sensor_SceneAuto[] =
2702 {
2703     {SEQUENCE_END, 0x00}
2704 };
2705
2706 static  struct reginfo sensor_SceneNight[] =
2707 {
2708     {SEQUENCE_END, 0x00}
2709 };
2710 static struct reginfo *sensor_SceneSeqe[] = {sensor_SceneAuto, sensor_SceneNight,NULL,};
2711
2712 #endif
2713 #if CONFIG_SENSOR_DigitalZoom
2714 static struct reginfo sensor_Zoom0[] =
2715 {
2716     {SEQUENCE_END, 0x0},
2717 };
2718
2719 static struct reginfo sensor_Zoom1[] =
2720 {
2721      {SEQUENCE_END, 0x0},
2722 };
2723
2724 static struct reginfo sensor_Zoom2[] =
2725 {
2726     {SEQUENCE_END, 0x0},
2727 };
2728
2729
2730 static struct reginfo sensor_Zoom3[] =
2731 {
2732     {SEQUENCE_END, 0x0},
2733 };
2734 static struct reginfo *sensor_ZoomSeqe[] = {sensor_Zoom0, sensor_Zoom1, sensor_Zoom2, sensor_Zoom3, NULL,};
2735 #endif
2736 static const struct v4l2_querymenu sensor_menus[] =
2737 {
2738         #if CONFIG_SENSOR_WhiteBalance
2739     { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 0,  .name = "auto",  .reserved = 0, }, {  .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 1, .name = "incandescent",  .reserved = 0,},
2740     { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 2,  .name = "fluorescent", .reserved = 0,}, {  .id = V4L2_CID_DO_WHITE_BALANCE, .index = 3,  .name = "daylight", .reserved = 0,},
2741     { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 4,  .name = "cloudy-daylight", .reserved = 0,},
2742     #endif
2743
2744         #if CONFIG_SENSOR_Effect
2745     { .id = V4L2_CID_EFFECT,  .index = 0,  .name = "none",  .reserved = 0, }, {  .id = V4L2_CID_EFFECT,  .index = 1, .name = "mono",  .reserved = 0,},
2746     { .id = V4L2_CID_EFFECT,  .index = 2,  .name = "negative", .reserved = 0,}, {  .id = V4L2_CID_EFFECT, .index = 3,  .name = "sepia", .reserved = 0,},
2747     { .id = V4L2_CID_EFFECT,  .index = 4, .name = "posterize", .reserved = 0,} ,{ .id = V4L2_CID_EFFECT,  .index = 5,  .name = "aqua", .reserved = 0,},
2748     #endif
2749
2750         #if CONFIG_SENSOR_Scene
2751     { .id = V4L2_CID_SCENE,  .index = 0, .name = "auto", .reserved = 0,} ,{ .id = V4L2_CID_SCENE,  .index = 1,  .name = "night", .reserved = 0,},
2752     #endif
2753
2754         #if CONFIG_SENSOR_Flash
2755     { .id = V4L2_CID_FLASH,  .index = 0,  .name = "off",  .reserved = 0, }, {  .id = V4L2_CID_FLASH,  .index = 1, .name = "auto",  .reserved = 0,},
2756     { .id = V4L2_CID_FLASH,  .index = 2,  .name = "on", .reserved = 0,}, {  .id = V4L2_CID_FLASH, .index = 3,  .name = "torch", .reserved = 0,},
2757     #endif
2758 };
2759
2760 static  struct v4l2_queryctrl sensor_controls[] =
2761 {
2762         #if CONFIG_SENSOR_WhiteBalance
2763     {
2764         .id             = V4L2_CID_DO_WHITE_BALANCE,
2765         .type           = V4L2_CTRL_TYPE_MENU,
2766         .name           = "White Balance Control",
2767         .minimum        = 0,
2768         .maximum        = 4,
2769         .step           = 1,
2770         .default_value = 0,
2771     },
2772     #endif
2773
2774         #if CONFIG_SENSOR_Brightness
2775         {
2776         .id             = V4L2_CID_BRIGHTNESS,
2777         .type           = V4L2_CTRL_TYPE_INTEGER,
2778         .name           = "Brightness Control",
2779         .minimum        = -3,
2780         .maximum        = 2,
2781         .step           = 1,
2782         .default_value = 0,
2783     },
2784     #endif
2785
2786         #if CONFIG_SENSOR_Effect
2787         {
2788         .id             = V4L2_CID_EFFECT,
2789         .type           = V4L2_CTRL_TYPE_MENU,
2790         .name           = "Effect Control",
2791         .minimum        = 0,
2792         .maximum        = 5,
2793         .step           = 1,
2794         .default_value = 0,
2795     },
2796         #endif
2797
2798         #if CONFIG_SENSOR_Exposure
2799         {
2800         .id             = V4L2_CID_EXPOSURE,
2801         .type           = V4L2_CTRL_TYPE_INTEGER,
2802         .name           = "Exposure Control",
2803         .minimum        = 0,
2804         .maximum        = 6,
2805         .step           = 1,
2806         .default_value = 0,
2807     },
2808         #endif
2809
2810         #if CONFIG_SENSOR_Saturation
2811         {
2812         .id             = V4L2_CID_SATURATION,
2813         .type           = V4L2_CTRL_TYPE_INTEGER,
2814         .name           = "Saturation Control",
2815         .minimum        = 0,
2816         .maximum        = 2,
2817         .step           = 1,
2818         .default_value = 0,
2819     },
2820     #endif
2821
2822         #if CONFIG_SENSOR_Contrast
2823         {
2824         .id             = V4L2_CID_CONTRAST,
2825         .type           = V4L2_CTRL_TYPE_INTEGER,
2826         .name           = "Contrast Control",
2827         .minimum        = -3,
2828         .maximum        = 3,
2829         .step           = 1,
2830         .default_value = 0,
2831     },
2832         #endif
2833
2834         #if CONFIG_SENSOR_Mirror
2835         {
2836         .id             = V4L2_CID_HFLIP,
2837         .type           = V4L2_CTRL_TYPE_BOOLEAN,
2838         .name           = "Mirror Control",
2839         .minimum        = 0,
2840         .maximum        = 1,
2841         .step           = 1,
2842         .default_value = 1,
2843     },
2844     #endif
2845
2846         #if CONFIG_SENSOR_Flip
2847         {
2848         .id             = V4L2_CID_VFLIP,
2849         .type           = V4L2_CTRL_TYPE_BOOLEAN,
2850         .name           = "Flip Control",
2851         .minimum        = 0,
2852         .maximum        = 1,
2853         .step           = 1,
2854         .default_value = 1,
2855     },
2856     #endif
2857
2858         #if CONFIG_SENSOR_Scene
2859     {
2860         .id             = V4L2_CID_SCENE,
2861         .type           = V4L2_CTRL_TYPE_MENU,
2862         .name           = "Scene Control",
2863         .minimum        = 0,
2864         .maximum        = 1,
2865         .step           = 1,
2866         .default_value = 0,
2867     },
2868     #endif
2869
2870         #if CONFIG_SENSOR_DigitalZoom
2871     {
2872         .id             = V4L2_CID_ZOOM_RELATIVE,
2873         .type           = V4L2_CTRL_TYPE_INTEGER,
2874         .name           = "DigitalZoom Control",
2875         .minimum        = -1,
2876         .maximum        = 1,
2877         .step           = 1,
2878         .default_value = 0,
2879     }, {
2880         .id             = V4L2_CID_ZOOM_ABSOLUTE,
2881         .type           = V4L2_CTRL_TYPE_INTEGER,
2882         .name           = "DigitalZoom Control",
2883         .minimum        = 0,
2884         .maximum        = 3,
2885         .step           = 1,
2886         .default_value = 0,
2887     },
2888     #endif
2889
2890         #if CONFIG_SENSOR_Focus
2891         {
2892         .id             = V4L2_CID_FOCUS_RELATIVE,
2893         .type           = V4L2_CTRL_TYPE_INTEGER,
2894         .name           = "Focus Control",
2895         .minimum        = -1,
2896         .maximum        = 1,
2897         .step           = 1,
2898         .default_value = 0,
2899     }, {
2900         .id             = V4L2_CID_FOCUS_ABSOLUTE,
2901         .type           = V4L2_CTRL_TYPE_INTEGER,
2902         .name           = "Focus Control",
2903         .minimum        = 0,
2904         .maximum        = 255,
2905         .step           = 1,
2906         .default_value = 125,
2907     },
2908     #endif
2909
2910         #if CONFIG_SENSOR_Flash
2911         {
2912         .id             = V4L2_CID_FLASH,
2913         .type           = V4L2_CTRL_TYPE_MENU,
2914         .name           = "Flash Control",
2915         .minimum        = 0,
2916         .maximum        = 3,
2917         .step           = 1,
2918         .default_value = 0,
2919     },
2920         #endif
2921 };
2922
2923 static int sensor_probe(struct i2c_client *client, const struct i2c_device_id *did);
2924 static int sensor_video_probe(struct soc_camera_device *icd, struct i2c_client *client);
2925 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
2926 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
2927 static int sensor_g_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);
2928 static int sensor_s_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);
2929 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg);
2930 static int sensor_resume(struct soc_camera_device *icd);
2931 static int sensor_set_bus_param(struct soc_camera_device *icd,unsigned long flags);
2932 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd);
2933 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);
2934 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);
2935 static int sensor_deactivate(struct i2c_client *client);
2936
2937 static struct soc_camera_ops sensor_ops =
2938 {
2939     .suspend                     = sensor_suspend,
2940     .resume                       = sensor_resume,
2941     .set_bus_param              = sensor_set_bus_param,
2942     .query_bus_param    = sensor_query_bus_param,
2943     .controls           = sensor_controls,
2944     .menus                         = sensor_menus,
2945     .num_controls               = ARRAY_SIZE(sensor_controls),
2946     .num_menus          = ARRAY_SIZE(sensor_menus),
2947 };
2948
2949
2950 /* only one fixed colorspace per pixelcode */
2951 struct sensor_datafmt {
2952         enum v4l2_mbus_pixelcode code;
2953         enum v4l2_colorspace colorspace;
2954 };
2955
2956 /* Find a data format by a pixel code in an array */
2957 static const struct sensor_datafmt *sensor_find_datafmt(
2958         enum v4l2_mbus_pixelcode code, const struct sensor_datafmt *fmt,
2959         int n)
2960 {
2961         int i;
2962         for (i = 0; i < n; i++)
2963                 if (fmt[i].code == code)
2964                         return fmt + i;
2965
2966         return NULL;
2967 }
2968
2969 static const struct sensor_datafmt sensor_colour_fmts[] = {
2970     {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG}
2971 };
2972 enum sensor_work_state
2973 {
2974         sensor_work_ready = 0,
2975         sensor_working,
2976 };
2977 struct sensor_work
2978 {
2979         struct i2c_client *client;
2980         struct delayed_work dwork;
2981         enum sensor_work_state state;
2982 };
2983
2984 typedef struct sensor_info_priv_s
2985 {
2986     int whiteBalance;
2987     int brightness;
2988     int contrast;
2989     int saturation;
2990     int effect;
2991     int scene;
2992     int digitalzoom;
2993     int focus;
2994         int auto_focus;
2995         int affm_reinit;
2996     int flash;
2997     int exposure;
2998     unsigned char mirror;                                        /* HFLIP */
2999     unsigned char flip;                                          /* VFLIP */
3000         bool snap2preview;
3001         bool video2preview;
3002         int capture_w;
3003         int capture_h;
3004         int preview_w;
3005         int preview_h;
3006     struct reginfo *winseqe_cur_addr;
3007         struct sensor_datafmt fmt;
3008         unsigned int enable;
3009         unsigned int funmodule_state;
3010 } sensor_info_priv_t;
3011
3012
3013
3014 struct sensor_parameter
3015 {
3016         unsigned short int preview_maxlines;
3017         unsigned short int preview_exposure;
3018         unsigned short int preview_line_width;
3019         unsigned short int preview_gain;
3020
3021         unsigned short int capture_framerate;
3022         unsigned short int preview_framerate;
3023 };
3024
3025 struct sensor
3026 {
3027     struct v4l2_subdev subdev;
3028     struct i2c_client *client;
3029     sensor_info_priv_t info_priv;
3030         struct sensor_parameter parameter;
3031         struct workqueue_struct *sensor_wq;
3032         struct sensor_work sensor_wk;
3033         struct mutex wq_lock;
3034     int model;  /* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */
3035 #if CONFIG_SENSOR_I2C_NOSCHED
3036         atomic_t tasklock_cnt;
3037 #endif
3038         struct rk29camera_platform_data *sensor_io_request;
3039     struct rk29camera_gpio_res *sensor_gpio_res;
3040 };
3041
3042 static struct sensor* to_sensor(const struct i2c_client *client)
3043 {
3044     return container_of(i2c_get_clientdata(client), struct sensor, subdev);
3045 }
3046
3047 static int sensor_task_lock(struct i2c_client *client, int lock)
3048 {
3049 #if CONFIG_SENSOR_I2C_NOSCHED
3050         int cnt = 3;
3051     struct sensor *sensor = to_sensor(client);
3052
3053         if (lock) {
3054                 if (atomic_read(&sensor->tasklock_cnt) == 0) {
3055                         while ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt>0)) {
3056                                 SENSOR_TR("\n %s will obtain i2c in atomic, but i2c bus is locked! Wait...\n",SENSOR_NAME_STRING());
3057                                 msleep(35);
3058                                 cnt--;
3059                         }
3060                         if ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt<=0)) {
3061                                 SENSOR_TR("\n %s obtain i2c fail in atomic!!\n",SENSOR_NAME_STRING());
3062                                 goto sensor_task_lock_err;
3063                         }
3064                         preempt_disable();
3065                 }
3066
3067                 atomic_add(1, &sensor->tasklock_cnt);
3068         } else {
3069                 if (atomic_read(&sensor->tasklock_cnt) > 0) {
3070                         atomic_sub(1, &sensor->tasklock_cnt);
3071
3072                         if (atomic_read(&sensor->tasklock_cnt) == 0)
3073                                 preempt_enable();
3074                 }
3075         }
3076         return 0;
3077 sensor_task_lock_err:
3078         return -1;
3079 #else
3080     return 0;
3081 #endif
3082
3083 }
3084
3085 /* sensor register write */
3086 static int sensor_write(struct i2c_client *client, u16 reg, u16 val)
3087 {
3088     int err=0,cnt;
3089     u8 buf[4];
3090     struct i2c_msg msg[1];
3091
3092         switch (reg)
3093         {
3094                 case SEQUENCE_WAIT_MS:
3095                 {
3096                         msleep(val);
3097                         break;
3098                 }
3099
3100                 case SEQUENCE_WAIT_US:
3101                 {
3102                         udelay(val);
3103                         break;
3104                 }
3105
3106                 case SEQUENCE_PROPERTY:
3107                 {
3108                         break;
3109                 }
3110                 default:
3111                 {
3112                     buf[0] = reg >> 8;
3113                     buf[1] = reg & 0xFF;
3114                     buf[2] = val >> 8;
3115                         buf[3] = val & 0xFF;
3116
3117                     msg->addr = client->addr;
3118                     msg->flags = client->flags;
3119                     msg->buf = buf;
3120                     msg->len = sizeof(buf);
3121                     msg->scl_rate = CONFIG_SENSOR_I2C_SPEED;         /* ddl@rock-chips.com : 100kHz */
3122                     msg->read_type = 0;               /* fpga i2c:0==I2C_NORMAL : direct use number not enum for don't want include spi_fpga.h */
3123
3124                     cnt = 3;
3125                     err = -EAGAIN;
3126
3127                     while ((cnt-- > 0) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */
3128                         err = i2c_transfer(client->adapter, msg, 1);
3129
3130                         if (err >= 0) {
3131                             return 0;
3132                         } else {
3133                             SENSOR_TR("\n %s write reg(0x%x, val:0x%x) failed, try to write again!\n",SENSOR_NAME_STRING(),reg, val);
3134                             udelay(10);
3135                         }
3136                     }
3137                 }
3138         }
3139     return err;
3140 }
3141
3142 /* sensor register read */
3143 static int sensor_read(struct i2c_client *client, u16 reg, u16 *val)
3144 {
3145         u8 buf[2];
3146         struct i2c_msg msg[2];
3147         int err = 0;
3148
3149         buf[0] = (u8)reg >> 8;
3150         buf[1] = (u8)reg & 0xFF;
3151
3152         msg[0].addr = client->addr;
3153         msg[0].flags = client->flags;
3154         msg[0].buf = buf;
3155         msg[0].len = sizeof(buf);
3156         msg[0].scl_rate = CONFIG_SENSOR_I2C_SPEED;       /* ddl@rock-chips.com : 100kHz */
3157         msg[0].read_type = 2;   /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
3158
3159         msg[1].addr = client->addr;
3160         msg[1].flags = client->flags|I2C_M_RD;
3161         msg[1].buf = buf;
3162         msg[1].len = sizeof(buf);
3163         msg[1].scl_rate = CONFIG_SENSOR_I2C_SPEED;                       /* ddl@rock-chips.com : 100kHz */
3164         msg[1].read_type = 2;                             /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
3165
3166         err = i2c_transfer(client->adapter, msg, 2);
3167
3168         if(err >= 0) {
3169                 *val = (buf[0] << 8)|(buf[1] & 0xFF);
3170                 SENSOR_DG("%s read reg(0x%x val:0x%x) success\n",SENSOR_NAME_STRING(),reg,*val);
3171                 return 0;
3172         } else {
3173                 SENSOR_TR("%s read reg(0x%x) failed!",SENSOR_NAME_STRING(),reg);
3174         }
3175
3176         return err;
3177 }
3178
3179 /* write a array of registers  */
3180 static int sensor_write_array(struct i2c_client *client, struct reginfo *regarray)
3181 {
3182     int err = 0, cnt;
3183     int i = 0;
3184 #if CONFIG_SENSOR_I2C_RDWRCHK
3185         char valchk;
3186 #endif
3187
3188         cnt = 0;
3189         if (sensor_task_lock(client, 1) < 0)
3190                 goto sensor_write_array_end;
3191     while (regarray[i].reg != SEQUENCE_END)
3192     {
3193
3194         err = sensor_write(client, regarray[i].reg, regarray[i].val);
3195         if (err < 0)
3196         {
3197             if (cnt-- > 0) {
3198                             SENSOR_TR("%s..write failed current reg:0x%x, Write array again !\n", SENSOR_NAME_STRING(),regarray[i].reg);
3199                                 i = 0;
3200                                 continue;
3201             } else {
3202                 SENSOR_TR("%s..write array failed!!!\n", SENSOR_NAME_STRING());
3203                 err = -EPERM;
3204                                 goto sensor_write_array_end;
3205             }
3206         } else {
3207         #if CONFIG_SENSOR_I2C_RDWRCHK
3208                         sensor_read(client, regarray[i].reg, &valchk);
3209                         if (valchk != regarray[i].val)
3210                                 SENSOR_TR("%s Reg:0x%x write(0x%x, 0x%x) fail\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);
3211                 #endif
3212         }
3213
3214         i++;
3215     }
3216
3217 sensor_write_array_end:
3218         sensor_task_lock(client,0);
3219     return err;
3220 }
3221
3222 #if CONFIG_SENSOR_I2C_RDWRCHK
3223 static int sensor_readchk_array(struct i2c_client *client, struct reginfo *regarray)
3224 {
3225     int cnt;
3226     int i = 0;
3227         char valchk;
3228
3229         cnt = 0;
3230         valchk = 0;
3231     while (regarray[i].reg != SEQUENCE_END)
3232     {
3233                 sensor_read(client, regarray[i].reg, &valchk);
3234                 if (valchk != regarray[i].val)
3235                         SENSOR_TR("%s Reg:0x%x read(0x%x, 0x%x) error\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);
3236
3237         i++;
3238     }
3239     return 0;
3240 }
3241 #endif
3242 #if CONFIG_SENSOR_Focus
3243
3244 static int sensor_af_single(struct i2c_client *client)
3245 {
3246         int ret = 0;
3247
3248
3249 sensor_af_single_end:
3250         return ret;
3251 }
3252
3253 static int sensor_af_const(struct i2c_client *client)
3254 {
3255         int ret = 0;
3256
3257 sensor_af_const_end:
3258         return ret;
3259 }
3260
3261 static int sensor_af_zoneupdate(struct i2c_client *client)
3262 {
3263         int ret = 0;
3264
3265 sensor_af_zoneupdate_end:
3266         return ret;
3267 }
3268
3269 static int sensor_af_init(struct i2c_client *client)
3270 {
3271         int ret = 0;
3272
3273         return ret;
3274 }
3275 #endif
3276
3277 static int sensor_ioctrl(struct soc_camera_device *icd,enum rk29sensor_power_cmd cmd, int on)
3278 {
3279         struct soc_camera_link *icl = to_soc_camera_link(icd);
3280         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3281     struct sensor *sensor = to_sensor(client);
3282         int ret = 0;
3283
3284         switch (cmd)
3285         {
3286                 case Sensor_Reset:
3287                 {
3288                         if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {
3289                                 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Reset, on);
3290                         }
3291                         break;
3292                 }
3293                 case Sensor_PowerDown:
3294                 {
3295                         if (icl->powerdown) {
3296                                 ret = icl->powerdown(icd->pdev, on);
3297                                 if (ret == RK29_CAM_IO_SUCCESS) {
3298                                         if (on == 0) {
3299                                                 mdelay(2);
3300                                                 if (icl->reset)
3301                                                         icl->reset(icd->pdev);
3302                                         }
3303                                 } else if (ret == RK29_CAM_EIO_REQUESTFAIL) {
3304                                         ret = -ENODEV;
3305                                         goto sensor_power_end;
3306                                 }
3307                         }
3308                         break;
3309                 }
3310                 case Sensor_Flash:
3311                 {
3312                         if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {
3313                                 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Flash, on);
3314                 if(on){
3315                     //flash off after 2 secs
3316                         hrtimer_cancel(&(flash_off_timer.timer));
3317                         hrtimer_start(&(flash_off_timer.timer),ktime_set(0, 800*1000*1000),HRTIMER_MODE_REL);
3318                     }
3319                         }
3320                         break;
3321                 }
3322                 default:
3323                 {
3324                         SENSOR_TR("%s cmd(0x%x) is unknown!",SENSOR_NAME_STRING(),cmd);
3325                         break;
3326                 }
3327         }
3328
3329 sensor_power_end:
3330         return ret;
3331 }
3332
3333 static enum hrtimer_restart flash_off_func(struct hrtimer *timer){
3334         struct flash_timer *fps_timer = container_of(timer, struct flash_timer, timer);
3335     sensor_ioctrl(fps_timer->icd,Sensor_Flash,0);
3336         SENSOR_DG("%s %s !!!!!!",SENSOR_NAME_STRING(),__FUNCTION__);
3337     return 0;
3338
3339 }
3340
3341 static int sensor_init(struct v4l2_subdev *sd, u32 val)
3342 {
3343     struct i2c_client *client = v4l2_get_subdevdata(sd);
3344     struct soc_camera_device *icd = client->dev.platform_data;
3345     struct sensor *sensor = to_sensor(client);
3346         const struct v4l2_queryctrl *qctrl;
3347     const struct sensor_datafmt *fmt;
3348     int ret;
3349     u16 pid = 0;
3350
3351     SENSOR_DG("\n%s..%s.. \n",SENSOR_NAME_STRING(),__FUNCTION__);
3352
3353         sensor_ioctrl(icd,Sensor_Reset, 1);
3354         if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {
3355                 ret = -ENODEV;
3356                 goto sensor_INIT_ERR;
3357         }
3358
3359         udelay(50);
3360         sensor_ioctrl(icd,Sensor_Reset, 0);
3361         mdelay(1);
3362     /* soft reset */
3363         if (sensor_task_lock(client,1)<0)
3364                 goto sensor_INIT_ERR;
3365
3366 #if (SENSOR_RESET_REG != SEQUENCE_END)
3367     ret = sensor_write(client, SENSOR_RESET_REG, SENSOR_RESET_VAL);
3368     if (ret != 0) {
3369         SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
3370         ret = -ENODEV;
3371                 goto sensor_INIT_ERR;
3372     }
3373
3374     mdelay(5);  //delay 5 microseconds
3375 #endif
3376
3377         /* check if it is an sensor sensor */
3378 #if (SENSOR_ID_REG != SEQUENCE_END)
3379     ret = sensor_read(client, SENSOR_ID_REG, &pid);
3380     if (ret != 0) {
3381         SENSOR_TR("read chip id failed\n");
3382         ret = -ENODEV;
3383         goto sensor_INIT_ERR;
3384     }
3385
3386     SENSOR_DG("\n %s  pid = 0x%x \n", SENSOR_NAME_STRING(), pid);
3387 #else
3388         pid = SENSOR_ID;
3389 #endif
3390     if (pid == SENSOR_ID) {
3391         sensor->model = SENSOR_V4L2_IDENT;
3392     } else {
3393         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
3394         ret = -ENODEV;
3395         goto sensor_INIT_ERR;
3396     }
3397
3398     ret = sensor_write_array(client, sensor_init_data);
3399     if (ret != 0)
3400     {
3401         SENSOR_TR("error: %s initial failed\n",SENSOR_NAME_STRING());
3402         goto sensor_INIT_ERR;
3403     }
3404         sensor_task_lock(client,0);
3405     sensor->info_priv.winseqe_cur_addr  = SENSOR_INIT_WINSEQADR;
3406         fmt = sensor_find_datafmt(SENSOR_INIT_PIXFMT,sensor_colour_fmts, ARRAY_SIZE(sensor_colour_fmts));
3407     if (!fmt) {
3408         SENSOR_TR("error: %s initial array colour fmts is not support!!",SENSOR_NAME_STRING());
3409         ret = -EINVAL;
3410         goto sensor_INIT_ERR;
3411     }
3412         sensor->info_priv.fmt = *fmt;
3413
3414     /* sensor sensor information for initialization  */
3415         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);
3416         if (qctrl)
3417         sensor->info_priv.whiteBalance = qctrl->default_value;
3418         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_BRIGHTNESS);
3419         if (qctrl)
3420         sensor->info_priv.brightness = qctrl->default_value;
3421         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);
3422         if (qctrl)
3423         sensor->info_priv.effect = qctrl->default_value;
3424         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EXPOSURE);
3425         if (qctrl)
3426         sensor->info_priv.exposure = qctrl->default_value;
3427
3428         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SATURATION);
3429         if (qctrl)
3430         sensor->info_priv.saturation = qctrl->default_value;
3431         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_CONTRAST);
3432         if (qctrl)
3433         sensor->info_priv.contrast = qctrl->default_value;
3434         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_HFLIP);
3435         if (qctrl)
3436         sensor->info_priv.mirror = qctrl->default_value;
3437         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_VFLIP);
3438         if (qctrl)
3439         sensor->info_priv.flip = qctrl->default_value;
3440         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SCENE);
3441         if (qctrl)
3442         sensor->info_priv.scene = qctrl->default_value;
3443         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
3444         if (qctrl)
3445         sensor->info_priv.digitalzoom = qctrl->default_value;
3446
3447     /* ddl@rock-chips.com : if sensor support auto focus and flash, programer must run focus and flash code  */
3448         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FOCUS_ABSOLUTE);
3449         if (qctrl)
3450         sensor->info_priv.focus = qctrl->default_value;
3451
3452         #if CONFIG_SENSOR_Flash
3453         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FLASH);
3454         if (qctrl)
3455         sensor->info_priv.flash = qctrl->default_value;
3456
3457     flash_off_timer.icd = icd;
3458         flash_off_timer.timer.function = flash_off_func;
3459
3460     #endif
3461     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);
3462     sensor->info_priv.funmodule_state |= SENSOR_INIT_IS_OK;
3463     return 0;
3464 sensor_INIT_ERR:
3465     sensor->info_priv.funmodule_state |= SENSOR_INIT_IS_OK;
3466         sensor_task_lock(client,0);
3467         sensor_deactivate(client);
3468     return ret;
3469 }
3470
3471 static int sensor_deactivate(struct i2c_client *client)
3472 {
3473         struct soc_camera_device *icd = client->dev.platform_data;
3474     struct sensor *sensor = to_sensor(client);
3475
3476         SENSOR_DG("\n%s..%s.. Enter\n",SENSOR_NAME_STRING(),__FUNCTION__);
3477
3478         /* ddl@rock-chips.com : all sensor output pin must change to input for other sensor */
3479         //sensor_task_lock(client, 1);
3480         sensor_ioctrl(icd, Sensor_PowerDown, 1);
3481     msleep(100);
3482
3483         /* ddl@rock-chips.com : sensor config init width , because next open sensor quickly(soc_camera_open -> Try to configure with default parameters) */
3484         icd->user_width = SENSOR_INIT_WIDTH;
3485     icd->user_height = SENSOR_INIT_HEIGHT;
3486     sensor->info_priv.funmodule_state &= ~SENSOR_INIT_IS_OK;
3487
3488         return 0;
3489 }
3490
3491 static  struct reginfo sensor_suspend_sequence[]=
3492 {
3493         {0x0028, 0x7000},
3494         {0x002A, setot_usForceClocksSettings},
3495         {0x0F12, 0x001E},
3496         {0x002A, setot_usConfigClocksSettings},
3497         {0x0F12, 0x001E},
3498         {0x002A, REG_TC_GP_EnablePreview},
3499         {0x0F12, 0x0000},
3500         {0x002A, REG_TC_GP_EnablePreviewChanged},
3501         {0x0F12, 0x0001},
3502         {SEQUENCE_WAIT_MS, 100},
3503         {0x0028, 0xD000},
3504         {0x002A, 0xB0B0},
3505         {0x0F12, 0x0001},
3506         {SEQUENCE_WAIT_MS, 100},
3507         {0x002A, 0xB0B4},
3508         {0x0F12, 0x0000},
3509         {0x002A, 0xB0A0},
3510         {0x0F12, 0x0031},
3511         {0x002A, 0xB0A0},
3512         {0x0F12, 0x0010},
3513         {0x002A, 0xB0A0},
3514         {0x0F12, 0x0000},
3515         {0x0028, 0x7000},
3516         {0x002A, REG_TC_GP_SleepMode},
3517         {0x0F12, 0x0001},
3518         {0x002A, REG_TC_GP_SleepModeChanged},
3519         {0x0F12, 0x0001},
3520
3521     {SEQUENCE_END,0x00}
3522 };
3523
3524 static struct reginfo sensor_resume_sequence[]=
3525 {
3526         {0x0028, 0x7000},
3527         {0x002A, REG_TC_GP_SleepMode},
3528         {0x0F12, 0x0000},
3529         {0x002A, REG_TC_GP_SleepModeChanged},
3530         {0x0F12, 0x0001},
3531         {0x0028, 0xD000},
3532         {0x002A, 0x1000},
3533         {0x0F12, 0x0001},
3534         {0x002A, 0x003A},
3535         {0x0F12, 0x0000},
3536         {SEQUENCE_WAIT_MS, 200},
3537         {0x002A, 0xB0B0},
3538         {0x0F12, 0x0000},
3539         {0x002A, 0xB0A0},
3540         {0x0F12, 0x003B},
3541         {0x002A, 0xB0B4},
3542         {0x0F12, 0x0800},
3543         {SEQUENCE_WAIT_MS, 10},
3544         {0x0028, 0x7000},
3545         {0x002A, REG_TC_GP_EnablePreview},
3546         {0x0F12, 0x0001},
3547         {0x002A, REG_TC_GP_EnablePreviewChanged},
3548         {0x0F12, 0x0001},
3549
3550     {SEQUENCE_END,0x00}
3551 };
3552 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg)
3553 {
3554     int ret;
3555     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3556
3557     if (pm_msg.event == PM_EVENT_SUSPEND) {
3558         SENSOR_DG("\n %s Enter Suspend.. \n", SENSOR_NAME_STRING());
3559         ret = sensor_write_array(client, sensor_suspend_sequence) ;
3560         if (ret != 0) {
3561             SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);
3562             return ret;
3563         } else {
3564                 mdelay(100);
3565             ret = sensor_ioctrl(icd, Sensor_PowerDown, 1);
3566             if (ret < 0) {
3567                             SENSOR_TR("\n %s suspend fail for turn on power!\n", SENSOR_NAME_STRING());
3568                 return -EINVAL;
3569             }
3570         }
3571     } else {
3572         SENSOR_TR("\n %s cann't suppout Suspend..\n",SENSOR_NAME_STRING());
3573         return -EINVAL;
3574     }
3575
3576     return 0;
3577 }
3578
3579 static int sensor_resume(struct soc_camera_device *icd)
3580 {
3581         int ret;
3582         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3583
3584     ret = sensor_ioctrl(icd, Sensor_PowerDown, 0);
3585     if (ret < 0) {
3586                 SENSOR_TR("\n %s resume fail for turn on power!\n", SENSOR_NAME_STRING());
3587         return -EINVAL;
3588     } else {
3589         udelay(5);
3590                 ret = sensor_write_array(client, sensor_resume_sequence) ;
3591             if (ret != 0) {
3592                 SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);
3593                         return -EINVAL;
3594             }
3595     }
3596
3597         SENSOR_DG("\n %s Enter Resume.. \n", SENSOR_NAME_STRING());
3598
3599         return 0;
3600 }
3601
3602 static int sensor_set_bus_param(struct soc_camera_device *icd,
3603                                 unsigned long flags)
3604 {
3605     return 0;
3606 }
3607
3608 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd)
3609 {
3610     struct soc_camera_link *icl = to_soc_camera_link(icd);
3611     unsigned long flags = SENSOR_BUS_PARAM;
3612
3613     return soc_camera_apply_sensor_flags(icl, flags);
3614 }
3615
3616 static int sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
3617 {
3618     struct i2c_client *client = v4l2_get_subdevdata(sd);
3619     struct soc_camera_device *icd = client->dev.platform_data;
3620     struct sensor *sensor = to_sensor(client);
3621
3622     mf->width   = icd->user_width;
3623         mf->height      = icd->user_height;
3624         mf->code        = sensor->info_priv.fmt.code;
3625         mf->colorspace  = sensor->info_priv.fmt.colorspace;
3626         mf->field       = V4L2_FIELD_NONE;
3627
3628     return 0;
3629 }
3630 static bool sensor_fmt_capturechk(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
3631 {
3632     bool ret = false;
3633
3634         if ((mf->width == 1024) && (mf->height == 768)) {
3635                 ret = true;
3636         } else if ((mf->width == 1280) && (mf->height == 1024)) {
3637                 ret = true;
3638         } else if ((mf->width == 1600) && (mf->height == 1200)) {
3639                 ret = true;
3640         } else if ((mf->width == 2048) && (mf->height == 1536)) {
3641                 ret = true;
3642         } else if ((mf->width == 2592) && (mf->height == 1944)) {
3643                 ret = true;
3644         }
3645
3646         if (ret == true)
3647                 SENSOR_DG("%s %dx%d is capture format\n", __FUNCTION__, mf->width, mf->height);
3648         return ret;
3649 }
3650
3651 static bool sensor_fmt_videochk(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
3652 {
3653     bool ret = false;
3654
3655         if ((mf->width == 1280) && (mf->height == 720)) {
3656                 ret = true;
3657         } else if ((mf->width == 1920) && (mf->height == 1080)) {
3658                 ret = true;
3659         }
3660
3661         if (ret == true)
3662                 SENSOR_DG("%s %dx%d is video format\n", __FUNCTION__, mf->width, mf->height);
3663         return ret;
3664 }
3665 static struct reginfo* sensor_fmt_catch(int set_w, int set_h, int *ret_w, int *ret_h)
3666 {
3667         struct reginfo *winseqe_set_addr = NULL;
3668
3669         if (((set_w <= 176) && (set_h <= 144)) && (sensor_qcif[0].reg!=SEQUENCE_END)) {
3670                 winseqe_set_addr = sensor_qcif;
3671         *ret_w = 176;
3672         *ret_h = 144;
3673         } else if (((set_w <= 320) && (set_h <= 240)) && (sensor_qvga[0].reg!=SEQUENCE_END)) {
3674         winseqe_set_addr = sensor_qvga;
3675         *ret_w = 320;
3676         *ret_h = 240;
3677         } else if (((set_w <= 352) && (set_h<= 288)) && (sensor_cif[0].reg!=SEQUENCE_END)) {
3678         winseqe_set_addr = sensor_cif;
3679         *ret_w = 352;
3680         *ret_h = 288;
3681     } else if (((set_w <= 640) && (set_h <= 480)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
3682         winseqe_set_addr = sensor_vga;
3683         *ret_w = 640;
3684         *ret_h = 480;
3685     }
3686 #if CONFIG_SENSOR_FOR_CTS
3687    /**lzg@rockchip.com: forbid to preview with resolution 1280*1024*/
3688     else if (((set_w <= 800) && (set_h <= 600)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
3689             winseqe_set_addr = sensor_vga;
3690             *ret_w = 640;
3691             *ret_h = 480;
3692         }
3693 #else
3694     else if (((set_w <= 800) && (set_h <= 600)) && (sensor_svga[0].reg!=SEQUENCE_END)) {
3695         winseqe_set_addr = sensor_svga;
3696         *ret_w = 800;
3697         *ret_h = 600;
3698     }
3699 #endif
3700     else if (((set_w <= 1024) && (set_h <= 768)) && (sensor_xga[0].reg!=SEQUENCE_END)) {
3701         winseqe_set_addr = sensor_xga;
3702         *ret_w = 1024;
3703         *ret_h = 768;
3704         } else if (((set_w <= 1280) && (set_h <= 720)) && (sensor_720p[0].reg!=SEQUENCE_END)) {
3705         winseqe_set_addr = sensor_720p;
3706         *ret_w = 1280;
3707         *ret_h = 720;
3708     } else if (((set_w <= 1280) && (set_h <= 1024)) && (sensor_sxga[0].reg!=SEQUENCE_END)) {
3709         winseqe_set_addr = sensor_sxga;
3710         *ret_w = 1280;
3711         *ret_h = 1024;
3712     } else if (((set_w <= 1600) && (set_h <= 1200)) && (sensor_uxga[0].reg!=SEQUENCE_END)) {
3713         winseqe_set_addr = sensor_uxga;
3714         *ret_w = 1600;
3715         *ret_h = 1200;
3716         }
3717 #if CONFIG_SENSOR_FOR_CTS
3718    /**lzg@rockchip.com: forbid to preview with resolution 1280*1024*/
3719     else if (((set_w <= 1920) && (set_h <= 1080)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
3720         winseqe_set_addr = sensor_vga;
3721         *ret_w = 640;
3722         *ret_h = 480;
3723     }
3724 #else
3725     else if (((set_w <= 1920) && (set_h <= 1080)) && (sensor_1080p[0].reg!=SEQUENCE_END)) {
3726         winseqe_set_addr = sensor_1080p;
3727         *ret_w = 1920;
3728         *ret_h = 1080;
3729     }
3730 #endif
3731     else if (((set_w <= 2048) && (set_h <= 1536)) && (sensor_qxga[0].reg!=SEQUENCE_END)) {
3732         winseqe_set_addr = sensor_qxga;
3733         *ret_w = 2048;
3734         *ret_h = 1536;
3735     } else if (((set_w <= 2592) && (set_h <= 1944)) && (sensor_qsxga[0].reg!=SEQUENCE_END)) {
3736         winseqe_set_addr = sensor_qsxga;
3737         *ret_w = 2592;
3738         *ret_h = 1944;
3739     }
3740
3741         return winseqe_set_addr;
3742 }
3743
3744 static int sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
3745 {
3746     struct i2c_client *client = v4l2_get_subdevdata(sd);
3747     const struct sensor_datafmt *fmt;
3748     struct sensor *sensor = to_sensor(client);
3749     struct reginfo *winseqe_set_addr=NULL;
3750     int ret=0, set_w,set_h;
3751
3752         fmt = sensor_find_datafmt(mf->code, sensor_colour_fmts,
3753                                    ARRAY_SIZE(sensor_colour_fmts));
3754         if (!fmt) {
3755         ret = -EINVAL;
3756         goto sensor_s_fmt_end;
3757     }
3758
3759         if (sensor->info_priv.fmt.code != mf->code) {
3760                 switch (mf->code)
3761                 {
3762                         case V4L2_MBUS_FMT_YUYV8_2X8:
3763                         {
3764                                 winseqe_set_addr = sensor_ClrFmt_YUYV;
3765                                 break;
3766                         }
3767                         case V4L2_MBUS_FMT_UYVY8_2X8:
3768                         {
3769                                 winseqe_set_addr = sensor_ClrFmt_UYVY;
3770                                 break;
3771                         }
3772                         default:
3773                                 break;
3774                 }
3775                 if (winseqe_set_addr != NULL) {
3776             sensor_write_array(client, winseqe_set_addr);
3777                         sensor->info_priv.fmt.code = mf->code;
3778             sensor->info_priv.fmt.colorspace= mf->colorspace;
3779                         SENSOR_DG("%s v4l2_mbus_code:%d set success!\n", SENSOR_NAME_STRING(),mf->code);
3780                 } else {
3781                         SENSOR_TR("%s v4l2_mbus_code:%d is invalidate!\n", SENSOR_NAME_STRING(),mf->code);
3782                 }
3783         }
3784
3785     set_w = mf->width;
3786     set_h = mf->height;
3787
3788         winseqe_set_addr = sensor_fmt_catch(set_w, set_h, &set_w, &set_h);
3789
3790     if ((winseqe_set_addr  != sensor->info_priv.winseqe_cur_addr) && winseqe_set_addr) {
3791         #if CONFIG_SENSOR_Flash
3792         if (sensor_fmt_capturechk(sd,mf) == true) {      /* ddl@rock-chips.com : Capture */
3793             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
3794                 sensor_ioctrl(icd, Sensor_Flash, Flash_On);
3795                 SENSOR_DG("%s flash on in capture!\n", SENSOR_NAME_STRING());
3796             }
3797         } else {                                        /* ddl@rock-chips.com : Video */
3798             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
3799                 sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
3800                 SENSOR_DG("%s flash off in preivew!\n", SENSOR_NAME_STRING());
3801             }
3802         }
3803         #endif
3804         ret |= sensor_write_array(client, winseqe_set_addr);
3805         if (ret != 0) {
3806             SENSOR_TR("%s set format capability failed\n", SENSOR_NAME_STRING());
3807             #if CONFIG_SENSOR_Flash
3808             if (sensor_fmt_capturechk(sd,mf) == true) {
3809                 if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
3810                     sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
3811                     SENSOR_TR("%s Capture format set fail, flash off !\n", SENSOR_NAME_STRING());
3812                 }
3813             }
3814             #endif
3815             goto sensor_s_fmt_end;
3816         }
3817
3818         sensor->info_priv.winseqe_cur_addr  = (int)winseqe_set_addr;
3819
3820
3821         SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,set_w,set_h);
3822     } else {
3823         SENSOR_TR("\n %s .. Current Format is validate. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),set_w,set_h);
3824     }
3825
3826         mf->width = set_w;
3827     mf->height = set_h;
3828
3829 sensor_s_fmt_end:
3830     return ret;
3831 }
3832
3833 static int sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)
3834 {
3835     struct i2c_client *client = v4l2_get_subdevdata(sd);
3836     struct sensor *sensor = to_sensor(client);
3837     const struct sensor_datafmt *fmt;
3838     int ret = 0;
3839
3840         fmt = sensor_find_datafmt(mf->code, sensor_colour_fmts,
3841                                    ARRAY_SIZE(sensor_colour_fmts));
3842         if (fmt == NULL) {
3843                 fmt = &sensor->info_priv.fmt;
3844         mf->code = fmt->code;
3845         }
3846
3847     if (mf->height > SENSOR_MAX_HEIGHT)
3848         mf->height = SENSOR_MAX_HEIGHT;
3849     else if (mf->height < SENSOR_MIN_HEIGHT)
3850         mf->height = SENSOR_MIN_HEIGHT;
3851
3852     if (mf->width > SENSOR_MAX_WIDTH)
3853         mf->width = SENSOR_MAX_WIDTH;
3854     else if (mf->width < SENSOR_MIN_WIDTH)
3855         mf->width = SENSOR_MIN_WIDTH;
3856
3857     mf->colorspace = fmt->colorspace;
3858
3859     return ret;
3860 }
3861
3862  static int sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id)
3863 {
3864     struct i2c_client *client = v4l2_get_subdevdata(sd);
3865
3866     if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
3867         return -EINVAL;
3868
3869     if (id->match.addr != client->addr)
3870         return -ENODEV;
3871
3872     id->ident = SENSOR_V4L2_IDENT;      /* ddl@rock-chips.com :  Return s5k6aa  identifier */
3873     id->revision = 0;
3874
3875     return 0;
3876 }
3877 #if CONFIG_SENSOR_Brightness
3878 static int sensor_set_brightness(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3879 {
3880     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3881
3882     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3883     {
3884         if (sensor_BrightnessSeqe[value - qctrl->minimum] != NULL)
3885         {
3886             if (sensor_write_array(client, sensor_BrightnessSeqe[value - qctrl->minimum]) != 0)
3887             {
3888                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3889                 return -EINVAL;
3890             }
3891             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3892             return 0;
3893         }
3894     }
3895         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3896     return -EINVAL;
3897 }
3898 #endif
3899 #if CONFIG_SENSOR_Effect
3900 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3901 {
3902     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3903
3904     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3905     {
3906         if (sensor_EffectSeqe[value - qctrl->minimum] != NULL)
3907         {
3908             if (sensor_write_array(client, sensor_EffectSeqe[value - qctrl->minimum]) != 0)
3909             {
3910                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3911                 return -EINVAL;
3912             }
3913             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3914             return 0;
3915         }
3916     }
3917         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3918     return -EINVAL;
3919 }
3920 #endif
3921 #if CONFIG_SENSOR_Exposure
3922 static int sensor_set_exposure(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3923 {
3924     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3925
3926     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3927     {
3928         if (sensor_ExposureSeqe[value - qctrl->minimum] != NULL)
3929         {
3930             if (sensor_write_array(client, sensor_ExposureSeqe[value - qctrl->minimum]) != 0)
3931             {
3932                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3933                 return -EINVAL;
3934             }
3935             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3936             return 0;
3937         }
3938     }
3939         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3940     return -EINVAL;
3941 }
3942 #endif
3943 #if CONFIG_SENSOR_Saturation
3944 static int sensor_set_saturation(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3945 {
3946     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3947
3948     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3949     {
3950         if (sensor_SaturationSeqe[value - qctrl->minimum] != NULL)
3951         {
3952             if (sensor_write_array(client, sensor_SaturationSeqe[value - qctrl->minimum]) != 0)
3953             {
3954                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3955                 return -EINVAL;
3956             }
3957             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3958             return 0;
3959         }
3960     }
3961     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3962     return -EINVAL;
3963 }
3964 #endif
3965 #if CONFIG_SENSOR_Contrast
3966 static int sensor_set_contrast(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3967 {
3968     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3969
3970     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3971     {
3972         if (sensor_ContrastSeqe[value - qctrl->minimum] != NULL)
3973         {
3974             if (sensor_write_array(client, sensor_ContrastSeqe[value - qctrl->minimum]) != 0)
3975             {
3976                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3977                 return -EINVAL;
3978             }
3979             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3980             return 0;
3981         }
3982     }
3983     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3984     return -EINVAL;
3985 }
3986 #endif
3987 #if CONFIG_SENSOR_Mirror
3988 static int sensor_set_mirror(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3989 {
3990     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3991
3992     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3993     {
3994         if (sensor_MirrorSeqe[value - qctrl->minimum] != NULL)
3995         {
3996             if (sensor_write_array(client, sensor_MirrorSeqe[value - qctrl->minimum]) != 0)
3997             {
3998                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3999                 return -EINVAL;
4000             }
4001             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
4002             return 0;
4003         }
4004     }
4005     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4006     return -EINVAL;
4007 }
4008 #endif
4009 #if CONFIG_SENSOR_Flip
4010 static int sensor_set_flip(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
4011 {
4012     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4013
4014     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
4015     {
4016         if (sensor_FlipSeqe[value - qctrl->minimum] != NULL)
4017         {
4018             if (sensor_write_array(client, sensor_FlipSeqe[value - qctrl->minimum]) != 0)
4019             {
4020                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
4021                 return -EINVAL;
4022             }
4023             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
4024             return 0;
4025         }
4026     }
4027     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4028     return -EINVAL;
4029 }
4030 #endif
4031 #if CONFIG_SENSOR_Scene
4032 static int sensor_set_scene(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
4033 {
4034     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4035
4036     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
4037     {
4038         if (sensor_SceneSeqe[value - qctrl->minimum] != NULL)
4039         {
4040             if (sensor_write_array(client, sensor_SceneSeqe[value - qctrl->minimum]) != 0)
4041             {
4042                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
4043                 return -EINVAL;
4044             }
4045             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
4046             return 0;
4047         }
4048     }
4049     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4050     return -EINVAL;
4051 }
4052 #endif
4053 #if CONFIG_SENSOR_WhiteBalance
4054 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
4055 {
4056     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4057
4058     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
4059     {
4060         if (sensor_WhiteBalanceSeqe[value - qctrl->minimum] != NULL)
4061         {
4062             if (sensor_write_array(client, sensor_WhiteBalanceSeqe[value - qctrl->minimum]) != 0)
4063             {
4064                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
4065                 return -EINVAL;
4066             }
4067             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
4068             return 0;
4069         }
4070     }
4071         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4072     return -EINVAL;
4073 }
4074 #endif
4075 #if CONFIG_SENSOR_DigitalZoom
4076 static int sensor_set_digitalzoom(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int *value)
4077 {
4078     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4079     struct sensor *sensor = to_sensor(client);
4080         const struct v4l2_queryctrl *qctrl_info;
4081     int digitalzoom_cur, digitalzoom_total;
4082
4083         qctrl_info = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
4084         if (qctrl_info)
4085                 return -EINVAL;
4086
4087     digitalzoom_cur = sensor->info_priv.digitalzoom;
4088     digitalzoom_total = qctrl_info->maximum;
4089
4090     if ((*value > 0) && (digitalzoom_cur >= digitalzoom_total))
4091     {
4092         SENSOR_TR("%s digitalzoom is maximum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
4093         return -EINVAL;
4094     }
4095
4096     if  ((*value < 0) && (digitalzoom_cur <= qctrl_info->minimum))
4097     {
4098         SENSOR_TR("%s digitalzoom is minimum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
4099         return -EINVAL;
4100     }
4101
4102     if ((*value > 0) && ((digitalzoom_cur + *value) > digitalzoom_total))
4103     {
4104         *value = digitalzoom_total - digitalzoom_cur;
4105     }
4106
4107     if ((*value < 0) && ((digitalzoom_cur + *value) < 0))
4108     {
4109         *value = 0 - digitalzoom_cur;
4110     }
4111
4112     digitalzoom_cur += *value;
4113
4114     if (sensor_ZoomSeqe[digitalzoom_cur] != NULL)
4115     {
4116         if (sensor_write_array(client, sensor_ZoomSeqe[digitalzoom_cur]) != 0)
4117         {
4118             SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
4119             return -EINVAL;
4120         }
4121         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, *value);
4122         return 0;
4123     }
4124
4125     return -EINVAL;
4126 }
4127 #endif
4128 #if CONFIG_SENSOR_Flash
4129 static int sensor_set_flash(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
4130 {
4131     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4132     struct sensor *sensor = to_sensor(client);
4133         const struct v4l2_queryctrl *qctrl_info;
4134
4135     if ((value >= qctrl->minimum) && (value <= qctrl->maximum)) {
4136         if (value == 3) {       /* ddl@rock-chips.com: torch */
4137             sensor_ioctrl(icd, Sensor_Flash, Flash_Torch);   /* Flash On */
4138         } else {
4139             sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
4140         }
4141         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
4142         return 0;
4143     }
4144
4145         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4146     return -EINVAL;
4147 }
4148 #endif
4149 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
4150 {
4151     struct i2c_client *client = v4l2_get_subdevdata(sd);
4152     struct sensor *sensor = to_sensor(client);
4153     const struct v4l2_queryctrl *qctrl;
4154
4155     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
4156
4157     if (!qctrl)
4158     {
4159         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
4160         return -EINVAL;
4161     }
4162
4163     switch (ctrl->id)
4164     {
4165         case V4L2_CID_BRIGHTNESS:
4166             {
4167                 ctrl->value = sensor->info_priv.brightness;
4168                 break;
4169             }
4170         case V4L2_CID_SATURATION:
4171             {
4172                 ctrl->value = sensor->info_priv.saturation;
4173                 break;
4174             }
4175         case V4L2_CID_CONTRAST:
4176             {
4177                 ctrl->value = sensor->info_priv.contrast;
4178                 break;
4179             }
4180         case V4L2_CID_DO_WHITE_BALANCE:
4181             {
4182                 ctrl->value = sensor->info_priv.whiteBalance;
4183                 break;
4184             }
4185         case V4L2_CID_EXPOSURE:
4186             {
4187                 ctrl->value = sensor->info_priv.exposure;
4188                 break;
4189             }
4190         case V4L2_CID_HFLIP:
4191             {
4192                 ctrl->value = sensor->info_priv.mirror;
4193                 break;
4194             }
4195         case V4L2_CID_VFLIP:
4196             {
4197                 ctrl->value = sensor->info_priv.flip;
4198                 break;
4199             }
4200         default :
4201                 break;
4202     }
4203     return 0;
4204 }
4205
4206
4207
4208 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
4209 {
4210     struct i2c_client *client = v4l2_get_subdevdata(sd);
4211     struct sensor *sensor = to_sensor(client);
4212     struct soc_camera_device *icd = client->dev.platform_data;
4213     const struct v4l2_queryctrl *qctrl;
4214
4215
4216     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
4217
4218     if (!qctrl)
4219     {
4220         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
4221         return -EINVAL;
4222     }
4223
4224     switch (ctrl->id)
4225     {
4226 #if CONFIG_SENSOR_Brightness
4227         case V4L2_CID_BRIGHTNESS:
4228             {
4229                 if (ctrl->value != sensor->info_priv.brightness)
4230                 {
4231                     if (sensor_set_brightness(icd, qctrl,ctrl->value) != 0)
4232                     {
4233                         return -EINVAL;
4234                     }
4235                     sensor->info_priv.brightness = ctrl->value;
4236                 }
4237                 break;
4238             }
4239 #endif
4240 #if CONFIG_SENSOR_Exposure
4241         case V4L2_CID_EXPOSURE:
4242             {
4243                 if (ctrl->value != sensor->info_priv.exposure)
4244                 {
4245                     if (sensor_set_exposure(icd, qctrl,ctrl->value) != 0)
4246                     {
4247                         return -EINVAL;
4248                     }
4249                     sensor->info_priv.exposure = ctrl->value;
4250                 }
4251                 break;
4252             }
4253 #endif
4254 #if CONFIG_SENSOR_Saturation
4255         case V4L2_CID_SATURATION:
4256             {
4257                 if (ctrl->value != sensor->info_priv.saturation)
4258                 {
4259                     if (sensor_set_saturation(icd, qctrl,ctrl->value) != 0)
4260                     {
4261                         return -EINVAL;
4262                     }
4263                     sensor->info_priv.saturation = ctrl->value;
4264                 }
4265                 break;
4266             }
4267 #endif
4268 #if CONFIG_SENSOR_Contrast
4269         case V4L2_CID_CONTRAST:
4270             {
4271                 if (ctrl->value != sensor->info_priv.contrast)
4272                 {
4273                     if (sensor_set_contrast(icd, qctrl,ctrl->value) != 0)
4274                     {
4275                         return -EINVAL;
4276                     }
4277                     sensor->info_priv.contrast = ctrl->value;
4278                 }
4279                 break;
4280             }
4281 #endif
4282 #if CONFIG_SENSOR_WhiteBalance
4283         case V4L2_CID_DO_WHITE_BALANCE:
4284             {
4285                 if (ctrl->value != sensor->info_priv.whiteBalance)
4286                 {
4287                     if (sensor_set_whiteBalance(icd, qctrl,ctrl->value) != 0)
4288                     {
4289                         return -EINVAL;
4290                     }
4291                     sensor->info_priv.whiteBalance = ctrl->value;
4292                 }
4293                 break;
4294             }
4295 #endif
4296 #if CONFIG_SENSOR_Mirror
4297         case V4L2_CID_HFLIP:
4298             {
4299                 if (ctrl->value != sensor->info_priv.mirror)
4300                 {
4301                     if (sensor_set_mirror(icd, qctrl,ctrl->value) != 0)
4302                         return -EINVAL;
4303                     sensor->info_priv.mirror = ctrl->value;
4304                 }
4305                 break;
4306             }
4307 #endif
4308 #if CONFIG_SENSOR_Flip
4309         case V4L2_CID_VFLIP:
4310             {
4311                 if (ctrl->value != sensor->info_priv.flip)
4312                 {
4313                     if (sensor_set_flip(icd, qctrl,ctrl->value) != 0)
4314                         return -EINVAL;
4315                     sensor->info_priv.flip = ctrl->value;
4316                 }
4317                 break;
4318             }
4319 #endif
4320         default:
4321             break;
4322     }
4323
4324     return 0;
4325 }
4326 static int sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl)
4327 {
4328     const struct v4l2_queryctrl *qctrl;
4329     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4330     struct sensor *sensor = to_sensor(client);
4331
4332     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
4333
4334     if (!qctrl)
4335     {
4336         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
4337         return -EINVAL;
4338     }
4339
4340     switch (ext_ctrl->id)
4341     {
4342         case V4L2_CID_SCENE:
4343             {
4344                 ext_ctrl->value = sensor->info_priv.scene;
4345                 break;
4346             }
4347         case V4L2_CID_EFFECT:
4348             {
4349                 ext_ctrl->value = sensor->info_priv.effect;
4350                 break;
4351             }
4352         case V4L2_CID_ZOOM_ABSOLUTE:
4353             {
4354                 ext_ctrl->value = sensor->info_priv.digitalzoom;
4355                 break;
4356             }
4357         case V4L2_CID_ZOOM_RELATIVE:
4358             {
4359                 return -EINVAL;
4360             }
4361         case V4L2_CID_FOCUS_ABSOLUTE:
4362             {
4363                 ext_ctrl->value = sensor->info_priv.focus;
4364                 break;
4365             }
4366         case V4L2_CID_FOCUS_RELATIVE:
4367             {
4368                 return -EINVAL;
4369             }
4370         case V4L2_CID_FLASH:
4371             {
4372                 ext_ctrl->value = sensor->info_priv.flash;
4373                 break;
4374             }
4375         default :
4376             break;
4377     }
4378     return 0;
4379 }
4380 static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl)
4381 {
4382     const struct v4l2_queryctrl *qctrl;
4383     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4384     struct sensor *sensor = to_sensor(client);
4385     int val_offset;
4386
4387     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
4388
4389     if (!qctrl)
4390     {
4391         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
4392         return -EINVAL;
4393     }
4394
4395         val_offset = 0;
4396     switch (ext_ctrl->id)
4397     {
4398 #if CONFIG_SENSOR_Scene
4399         case V4L2_CID_SCENE:
4400             {
4401                 if (ext_ctrl->value != sensor->info_priv.scene)
4402                 {
4403                     if (sensor_set_scene(icd, qctrl,ext_ctrl->value) != 0)
4404                         return -EINVAL;
4405                     sensor->info_priv.scene = ext_ctrl->value;
4406                 }
4407                 break;
4408             }
4409 #endif
4410 #if CONFIG_SENSOR_Effect
4411         case V4L2_CID_EFFECT:
4412             {
4413                 if (ext_ctrl->value != sensor->info_priv.effect)
4414                 {
4415                     if (sensor_set_effect(icd, qctrl,ext_ctrl->value) != 0)
4416                         return -EINVAL;
4417                     sensor->info_priv.effect= ext_ctrl->value;
4418                 }
4419                 break;
4420             }
4421 #endif
4422 #if CONFIG_SENSOR_DigitalZoom
4423         case V4L2_CID_ZOOM_ABSOLUTE:
4424             {
4425                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
4426                     return -EINVAL;
4427
4428                 if (ext_ctrl->value != sensor->info_priv.digitalzoom)
4429                 {
4430                     val_offset = ext_ctrl->value -sensor->info_priv.digitalzoom;
4431
4432                     if (sensor_set_digitalzoom(icd, qctrl,&val_offset) != 0)
4433                         return -EINVAL;
4434                     sensor->info_priv.digitalzoom += val_offset;
4435
4436                     SENSOR_DG("%s digitalzoom is %x\n",SENSOR_NAME_STRING(),  sensor->info_priv.digitalzoom);
4437                 }
4438
4439                 break;
4440             }
4441         case V4L2_CID_ZOOM_RELATIVE:
4442             {
4443                 if (ext_ctrl->value)
4444                 {
4445                     if (sensor_set_digitalzoom(icd, qctrl,&ext_ctrl->value) != 0)
4446                         return -EINVAL;
4447                     sensor->info_priv.digitalzoom += ext_ctrl->value;
4448
4449                     SENSOR_DG("%s digitalzoom is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.digitalzoom);
4450                 }
4451                 break;
4452             }
4453 #endif
4454 #if CONFIG_SENSOR_Focus
4455         case V4L2_CID_FOCUS_ABSOLUTE:
4456             {
4457                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
4458                     return -EINVAL;
4459
4460                 if (ext_ctrl->value != sensor->info_priv.focus)
4461                 {
4462                     val_offset = ext_ctrl->value -sensor->info_priv.focus;
4463
4464                     sensor->info_priv.focus += val_offset;
4465                 }
4466
4467                 break;
4468             }
4469         case V4L2_CID_FOCUS_RELATIVE:
4470             {
4471                 if (ext_ctrl->value)
4472                 {
4473                     sensor->info_priv.focus += ext_ctrl->value;
4474
4475                     SENSOR_DG("%s focus is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.focus);
4476                 }
4477                 break;
4478             }
4479 #endif
4480 #if CONFIG_SENSOR_Flash
4481         case V4L2_CID_FLASH:
4482             {
4483                 if (sensor_set_flash(icd, qctrl,ext_ctrl->value) != 0)
4484                     return -EINVAL;
4485                 sensor->info_priv.flash = ext_ctrl->value;
4486
4487                 SENSOR_DG("%s flash is %x\n",SENSOR_NAME_STRING(), sensor->info_priv.flash);
4488                 break;
4489             }
4490 #endif
4491         default:
4492             break;
4493     }
4494
4495     return 0;
4496 }
4497
4498 static int sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
4499 {
4500     struct i2c_client *client = v4l2_get_subdevdata(sd);
4501     struct soc_camera_device *icd = client->dev.platform_data;
4502     int i, error_cnt=0, error_idx=-1;
4503
4504
4505     for (i=0; i<ext_ctrl->count; i++) {
4506         if (sensor_g_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
4507             error_cnt++;
4508             error_idx = i;
4509         }
4510     }
4511
4512     if (error_cnt > 1)
4513         error_idx = ext_ctrl->count;
4514
4515     if (error_idx != -1) {
4516         ext_ctrl->error_idx = error_idx;
4517         return -EINVAL;
4518     } else {
4519         return 0;
4520     }
4521 }
4522
4523 static int sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
4524 {
4525     struct i2c_client *client = v4l2_get_subdevdata(sd);
4526     struct soc_camera_device *icd = client->dev.platform_data;
4527     int i, error_cnt=0, error_idx=-1;
4528
4529
4530     for (i=0; i<ext_ctrl->count; i++) {
4531         if (sensor_s_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
4532             error_cnt++;
4533             error_idx = i;
4534         }
4535     }
4536
4537     if (error_cnt > 1)
4538         error_idx = ext_ctrl->count;
4539
4540     if (error_idx != -1) {
4541         ext_ctrl->error_idx = error_idx;
4542         return -EINVAL;
4543     } else {
4544         return 0;
4545     }
4546 }
4547 static int sensor_s_stream(struct v4l2_subdev *sd, int enable)
4548 {
4549         struct i2c_client *client = v4l2_get_subdevdata(sd);
4550     struct sensor *sensor = to_sensor(client);
4551
4552         if (enable == 1) {
4553                 sensor->info_priv.enable = 1;
4554         } else if (enable == 0) {
4555                 sensor->info_priv.enable = 0;
4556         }
4557
4558         return 0;
4559 }
4560 /* Interface active, can use i2c. If it fails, it can indeed mean, that
4561  * this wasn't our capture interface, so, we wait for the right one */
4562 static int sensor_video_probe(struct soc_camera_device *icd,
4563                                struct i2c_client *client)
4564 {
4565     int ret,pid = 0;
4566     struct sensor *sensor = to_sensor(client);
4567
4568     /* We must have a parent by now. And it cannot be a wrong one.
4569      * So this entire test is completely redundant. */
4570     if (!icd->dev.parent ||
4571             to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
4572                 return -ENODEV;
4573
4574         if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {
4575                 ret = -ENODEV;
4576                 goto sensor_video_probe_err;
4577         }
4578
4579     /* soft reset */
4580 #if (SENSOR_RESET_REG != SEQUENCE_END)
4581     ret = sensor_write(client, SENSOR_RESET_REG, SENSOR_RESET_VAL);
4582     if (ret != 0) {
4583         SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
4584         ret = -ENODEV;
4585                 goto sensor_video_probe_err;
4586     }
4587
4588     mdelay(5);  //delay 5 microseconds
4589 #endif
4590
4591         /* check if it is an sensor sensor */
4592 #if (SENSOR_ID_REG != SEQUENCE_END)
4593     ret = sensor_read(client, SENSOR_ID_REG, &pid);
4594     if (ret != 0) {
4595         SENSOR_TR("read chip id failed\n");
4596         ret = -ENODEV;
4597         goto sensor_video_probe_err;
4598     }
4599
4600     SENSOR_DG("\n %s  pid = 0x%x \n", SENSOR_NAME_STRING(), pid);
4601 #else
4602         pid = SENSOR_ID;
4603 #endif
4604
4605     if (pid == SENSOR_ID) {
4606         sensor->model = SENSOR_V4L2_IDENT;
4607     } else {
4608         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
4609         ret = -ENODEV;
4610         goto sensor_video_probe_err;
4611     }
4612
4613     return 0;
4614
4615 sensor_video_probe_err:
4616
4617     return ret;
4618 }
4619 static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
4620 {
4621         struct i2c_client *client = v4l2_get_subdevdata(sd);
4622     struct soc_camera_device *icd = client->dev.platform_data;
4623     struct sensor *sensor = to_sensor(client);
4624     int ret = 0;
4625 #if CONFIG_SENSOR_Flash
4626     int i;
4627 #endif
4628
4629         SENSOR_DG("\n%s..%s..cmd:%x \n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);
4630         switch (cmd)
4631         {
4632                 case RK29_CAM_SUBDEV_DEACTIVATE:
4633                 {
4634                         sensor_deactivate(client);
4635                         break;
4636                 }
4637                 case RK29_CAM_SUBDEV_IOREQUEST:
4638                 {
4639                         sensor->sensor_io_request = (struct rk29camera_platform_data*)arg;
4640             if (sensor->sensor_io_request != NULL) {
4641                 if (sensor->sensor_io_request->gpio_res[0].dev_name &&
4642                     (strcmp(sensor->sensor_io_request->gpio_res[0].dev_name, dev_name(icd->pdev)) == 0)) {
4643                     sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[0];
4644                 } else if (sensor->sensor_io_request->gpio_res[1].dev_name &&
4645                     (strcmp(sensor->sensor_io_request->gpio_res[1].dev_name, dev_name(icd->pdev)) == 0)) {
4646                     sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[1];
4647                 }
4648             } else {
4649                 SENSOR_TR("%s %s RK29_CAM_SUBDEV_IOREQUEST fail\n",SENSOR_NAME_STRING(),__FUNCTION__);
4650                 ret = -EINVAL;
4651                 goto sensor_ioctl_end;
4652             }
4653             /* ddl@rock-chips.com : if gpio_flash havn't been set in board-xxx.c, sensor driver must notify is not support flash control
4654                for this project */
4655             #if CONFIG_SENSOR_Flash
4656                 if (sensor->sensor_gpio_res) {
4657                 if (sensor->sensor_gpio_res->gpio_flash == INVALID_GPIO) {
4658                     for (i = 0; i < icd->ops->num_controls; i++) {
4659                                 if (V4L2_CID_FLASH == icd->ops->controls[i].id) {
4660                                         //memset((char*)&icd->ops->controls[i],0x00,sizeof(struct v4l2_queryctrl));
4661                               sensor_controls[i].id=0xffff;
4662                                 }
4663                     }
4664                     sensor->info_priv.flash = 0xff;
4665                     SENSOR_DG("%s flash gpio is invalidate!\n",SENSOR_NAME_STRING());
4666                 }else{ //two cameras are the same,need to deal diffrently ,zyc
4667                     for (i = 0; i < icd->ops->num_controls; i++) {
4668                            if(0xffff == icd->ops->controls[i].id){
4669                               sensor_controls[i].id=V4L2_CID_FLASH;
4670                            }
4671                     }
4672                 }
4673                 }
4674             #endif
4675                         break;
4676                 }
4677                 default:
4678                 {
4679                         SENSOR_TR("%s %s cmd(0x%x) is unknown !\n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);
4680                         break;
4681                 }
4682         }
4683 sensor_ioctl_end:
4684         return ret;
4685
4686 }
4687 static int sensor_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
4688                             enum v4l2_mbus_pixelcode *code)
4689 {
4690         if (index >= ARRAY_SIZE(sensor_colour_fmts))
4691                 return -EINVAL;
4692
4693         *code = sensor_colour_fmts[index].code;
4694         return 0;
4695 }
4696 static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {
4697         .init           = sensor_init,
4698         .g_ctrl         = sensor_g_control,
4699         .s_ctrl         = sensor_s_control,
4700         .g_ext_ctrls          = sensor_g_ext_controls,
4701         .s_ext_ctrls          = sensor_s_ext_controls,
4702         .g_chip_ident   = sensor_g_chip_ident,
4703         .ioctl = sensor_ioctl,
4704 };
4705
4706 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {
4707         .s_mbus_fmt     = sensor_s_fmt,
4708         .g_mbus_fmt     = sensor_g_fmt,
4709         .try_mbus_fmt   = sensor_try_fmt,
4710         .enum_mbus_fmt  = sensor_enum_fmt,
4711     .s_stream   = sensor_s_stream,
4712 };
4713 static struct v4l2_subdev_ops sensor_subdev_ops = {
4714         .core   = &sensor_subdev_core_ops,
4715         .video = &sensor_subdev_video_ops,
4716 };
4717
4718 static int sensor_probe(struct i2c_client *client,
4719                          const struct i2c_device_id *did)
4720 {
4721     struct sensor *sensor;
4722     struct soc_camera_device *icd = client->dev.platform_data;
4723     struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
4724     struct soc_camera_link *icl;
4725     int ret;
4726
4727     SENSOR_DG("\n%s..%s..%d..\n",__FUNCTION__,__FILE__,__LINE__);
4728     if (!icd) {
4729         dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());
4730         return -EINVAL;
4731     }
4732
4733     icl = to_soc_camera_link(icd);
4734     if (!icl) {
4735         dev_err(&client->dev, "%s driver needs platform data\n", SENSOR_NAME_STRING());
4736         return -EINVAL;
4737     }
4738
4739     if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
4740         dev_warn(&adapter->dev,
4741                  "I2C-Adapter doesn't support I2C_FUNC_I2C\n");
4742         return -EIO;
4743     }
4744
4745     sensor = kzalloc(sizeof(struct sensor), GFP_KERNEL);
4746     if (!sensor)
4747         return -ENOMEM;
4748
4749     v4l2_i2c_subdev_init(&sensor->subdev, client, &sensor_subdev_ops);
4750
4751     /* Second stage probe - when a capture adapter is there */
4752     icd->ops            = &sensor_ops;
4753     sensor->info_priv.fmt = sensor_colour_fmts[0];
4754
4755     ret = sensor_video_probe(icd, client);
4756     if (ret) {
4757         icd->ops = NULL;
4758         i2c_set_clientdata(client, NULL);
4759         kfree(sensor);
4760     }
4761         hrtimer_init(&(flash_off_timer.timer), CLOCK_MONOTONIC, HRTIMER_MODE_REL);
4762     SENSOR_DG("\n%s..%s..%d  ret = %x \n",__FUNCTION__,__FILE__,__LINE__,ret);
4763     return ret;
4764 }
4765
4766 static int sensor_remove(struct i2c_client *client)
4767 {
4768     struct sensor *sensor = to_sensor(client);
4769     struct soc_camera_device *icd = client->dev.platform_data;
4770
4771     icd->ops = NULL;
4772     i2c_set_clientdata(client, NULL);
4773     client->driver = NULL;
4774     kfree(sensor);
4775
4776     return 0;
4777 }
4778
4779 static const struct i2c_device_id sensor_id[] = {
4780         {SENSOR_NAME_STRING(), 0 },
4781         { }
4782 };
4783 MODULE_DEVICE_TABLE(i2c, sensor_id);
4784
4785 static struct i2c_driver sensor_i2c_driver = {
4786         .driver = {
4787                 .name = SENSOR_NAME_STRING(),
4788         },
4789         .probe          = sensor_probe,
4790         .remove         = sensor_remove,
4791         .id_table       = sensor_id,
4792 };
4793
4794 static int __init sensor_mod_init(void)
4795 {
4796     SENSOR_DG("\n%s..%s.. \n",__FUNCTION__,SENSOR_NAME_STRING());
4797     return i2c_add_driver(&sensor_i2c_driver);
4798 }
4799
4800 static void __exit sensor_mod_exit(void)
4801 {
4802     i2c_del_driver(&sensor_i2c_driver);
4803 }
4804
4805 device_initcall_sync(sensor_mod_init);
4806 module_exit(sensor_mod_exit);
4807
4808 MODULE_DESCRIPTION(SENSOR_NAME_STRING(Camera sensor driver));
4809 MODULE_AUTHOR("ddl <kernel@rock-chips>");
4810 MODULE_LICENSE("GPL");
4811