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