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_PIX_FMT_YUYV
  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 #define COL_FMT(_name, _depth, _fourcc, _colorspace) \
2936         { .name = _name, .depth = _depth, .fourcc = _fourcc, \
2937         .colorspace = _colorspace }
2938
2939 #define JPG_FMT(_name, _depth, _fourcc) \
2940         COL_FMT(_name, _depth, _fourcc, V4L2_COLORSPACE_JPEG)
2941
2942 static const struct soc_camera_data_format sensor_colour_formats[] = {
2943         JPG_FMT(SENSOR_NAME_STRING(UYVY), 16, V4L2_PIX_FMT_UYVY),
2944 };
2945 enum sensor_work_state
2946 {
2947         sensor_work_ready = 0,
2948         sensor_working,
2949 };
2950 struct sensor_work
2951 {
2952         struct i2c_client *client;
2953         struct delayed_work dwork;
2954         enum sensor_work_state state;
2955 };
2956
2957 typedef struct sensor_info_priv_s
2958 {
2959     int whiteBalance;
2960     int brightness;
2961     int contrast;
2962     int saturation;
2963     int effect;
2964     int scene;
2965     int digitalzoom;
2966     int focus;
2967         int auto_focus;
2968         int affm_reinit;
2969     int flash;
2970     int exposure;
2971     unsigned char mirror;                                        /* HFLIP */
2972     unsigned char flip;                                          /* VFLIP */
2973         bool snap2preview;
2974         bool video2preview;
2975         int capture_w;
2976         int capture_h;
2977         int preview_w;
2978         int preview_h;
2979     struct reginfo *winseqe_cur_addr;
2980         unsigned int pixfmt;
2981         unsigned int enable;
2982         unsigned int funmodule_state;
2983 } sensor_info_priv_t;
2984
2985
2986
2987 struct sensor_parameter
2988 {
2989         unsigned short int preview_maxlines;
2990         unsigned short int preview_exposure;
2991         unsigned short int preview_line_width;
2992         unsigned short int preview_gain;
2993
2994         unsigned short int capture_framerate;
2995         unsigned short int preview_framerate;
2996 };
2997
2998 struct sensor
2999 {
3000     struct v4l2_subdev subdev;
3001     struct i2c_client *client;
3002     sensor_info_priv_t info_priv;
3003         struct sensor_parameter parameter;
3004         struct workqueue_struct *sensor_wq;
3005         struct sensor_work sensor_wk;
3006         struct mutex wq_lock;
3007     int model;  /* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */
3008 #if CONFIG_SENSOR_I2C_NOSCHED
3009         atomic_t tasklock_cnt;
3010 #endif
3011         struct rk29camera_platform_data *sensor_io_request;
3012     struct rk29camera_gpio_res *sensor_gpio_res;
3013 };
3014
3015 static struct sensor* to_sensor(const struct i2c_client *client)
3016 {
3017     return container_of(i2c_get_clientdata(client), struct sensor, subdev);
3018 }
3019
3020 static int sensor_task_lock(struct i2c_client *client, int lock)
3021 {
3022 #if CONFIG_SENSOR_I2C_NOSCHED
3023         int cnt = 3;
3024     struct sensor *sensor = to_sensor(client);
3025
3026         if (lock) {
3027                 if (atomic_read(&sensor->tasklock_cnt) == 0) {
3028                         while ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt>0)) {
3029                                 SENSOR_TR("\n %s will obtain i2c in atomic, but i2c bus is locked! Wait...\n",SENSOR_NAME_STRING());
3030                                 msleep(35);
3031                                 cnt--;
3032                         }
3033                         if ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt<=0)) {
3034                                 SENSOR_TR("\n %s obtain i2c fail in atomic!!\n",SENSOR_NAME_STRING());
3035                                 goto sensor_task_lock_err;
3036                         }
3037                         preempt_disable();
3038                 }
3039
3040                 atomic_add(1, &sensor->tasklock_cnt);
3041         } else {
3042                 if (atomic_read(&sensor->tasklock_cnt) > 0) {
3043                         atomic_sub(1, &sensor->tasklock_cnt);
3044
3045                         if (atomic_read(&sensor->tasklock_cnt) == 0)
3046                                 preempt_enable();
3047                 }
3048         }
3049         return 0;
3050 sensor_task_lock_err:
3051         return -1;
3052 #else
3053     return 0;
3054 #endif
3055
3056 }
3057
3058 /* sensor register write */
3059 static int sensor_write(struct i2c_client *client, u16 reg, u16 val)
3060 {
3061     int err=0,cnt;
3062     u8 buf[4];
3063     struct i2c_msg msg[1];
3064
3065         switch (reg)
3066         {
3067                 case SEQUENCE_WAIT_MS:
3068                 {
3069                         msleep(val);
3070                         break;
3071                 }
3072
3073                 case SEQUENCE_WAIT_US:
3074                 {
3075                         udelay(val);
3076                         break;
3077                 }
3078
3079                 case SEQUENCE_PROPERTY:
3080                 {
3081                         break;
3082                 }
3083                 default:
3084                 {
3085                     buf[0] = reg >> 8;
3086                     buf[1] = reg & 0xFF;
3087                     buf[2] = val >> 8;
3088                         buf[3] = val & 0xFF;
3089
3090                     msg->addr = client->addr;
3091                     msg->flags = client->flags;
3092                     msg->buf = buf;
3093                     msg->len = sizeof(buf);
3094                     msg->scl_rate = CONFIG_SENSOR_I2C_SPEED;         /* ddl@rock-chips.com : 100kHz */
3095                     msg->read_type = 0;               /* fpga i2c:0==I2C_NORMAL : direct use number not enum for don't want include spi_fpga.h */
3096
3097                     cnt = 3;
3098                     err = -EAGAIN;
3099
3100                     while ((cnt-- > 0) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */
3101                         err = i2c_transfer(client->adapter, msg, 1);
3102
3103                         if (err >= 0) {
3104                             return 0;
3105                         } else {
3106                             SENSOR_TR("\n %s write reg(0x%x, val:0x%x) failed, try to write again!\n",SENSOR_NAME_STRING(),reg, val);
3107                             udelay(10);
3108                         }
3109                     }
3110                 }
3111         }
3112     return err;
3113 }
3114
3115 /* sensor register read */
3116 static int sensor_read(struct i2c_client *client, u16 reg, u16 *val)
3117 {
3118         u8 buf[2];
3119         struct i2c_msg msg[2];
3120         int err = 0;
3121
3122         buf[0] = (u8)reg >> 8;
3123         buf[1] = (u8)reg & 0xFF;
3124
3125         msg[0].addr = client->addr;
3126         msg[0].flags = client->flags;
3127         msg[0].buf = buf;
3128         msg[0].len = sizeof(buf);
3129         msg[0].scl_rate = CONFIG_SENSOR_I2C_SPEED;       /* ddl@rock-chips.com : 100kHz */
3130         msg[0].read_type = 2;   /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
3131
3132         msg[1].addr = client->addr;
3133         msg[1].flags = client->flags|I2C_M_RD;
3134         msg[1].buf = buf;
3135         msg[1].len = sizeof(buf);
3136         msg[1].scl_rate = CONFIG_SENSOR_I2C_SPEED;                       /* ddl@rock-chips.com : 100kHz */
3137         msg[1].read_type = 2;                             /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */
3138
3139         err = i2c_transfer(client->adapter, msg, 2);
3140
3141         if(err >= 0) {
3142                 *val = (buf[0] << 8)|(buf[1] & 0xFF);
3143                 SENSOR_DG("%s read reg(0x%x val:0x%x) success\n",SENSOR_NAME_STRING(),reg,*val);
3144                 return 0;
3145         } else {
3146                 SENSOR_TR("%s read reg(0x%x) failed!",SENSOR_NAME_STRING(),reg);
3147         }
3148
3149         return err;
3150 }
3151
3152 /* write a array of registers  */
3153 static int sensor_write_array(struct i2c_client *client, struct reginfo *regarray)
3154 {
3155     int err = 0, cnt;
3156     int i = 0;
3157 #if CONFIG_SENSOR_I2C_RDWRCHK
3158         char valchk;
3159 #endif
3160
3161         cnt = 0;
3162         if (sensor_task_lock(client, 1) < 0)
3163                 goto sensor_write_array_end;
3164     while (regarray[i].reg != SEQUENCE_END)
3165     {
3166
3167         err = sensor_write(client, regarray[i].reg, regarray[i].val);
3168         if (err < 0)
3169         {
3170             if (cnt-- > 0) {
3171                             SENSOR_TR("%s..write failed current reg:0x%x, Write array again !\n", SENSOR_NAME_STRING(),regarray[i].reg);
3172                                 i = 0;
3173                                 continue;
3174             } else {
3175                 SENSOR_TR("%s..write array failed!!!\n", SENSOR_NAME_STRING());
3176                 err = -EPERM;
3177                                 goto sensor_write_array_end;
3178             }
3179         } else {
3180         #if CONFIG_SENSOR_I2C_RDWRCHK
3181                         sensor_read(client, regarray[i].reg, &valchk);
3182                         if (valchk != regarray[i].val)
3183                                 SENSOR_TR("%s Reg:0x%x write(0x%x, 0x%x) fail\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);
3184                 #endif
3185         }
3186
3187         i++;
3188     }
3189
3190 sensor_write_array_end:
3191         sensor_task_lock(client,0);
3192     return err;
3193 }
3194
3195 #if CONFIG_SENSOR_I2C_RDWRCHK
3196 static int sensor_readchk_array(struct i2c_client *client, struct reginfo *regarray)
3197 {
3198     int cnt;
3199     int i = 0;
3200         char valchk;
3201
3202         cnt = 0;
3203         valchk = 0;
3204     while (regarray[i].reg != SEQUENCE_END)
3205     {
3206                 sensor_read(client, regarray[i].reg, &valchk);
3207                 if (valchk != regarray[i].val)
3208                         SENSOR_TR("%s Reg:0x%x read(0x%x, 0x%x) error\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);
3209
3210         i++;
3211     }
3212     return 0;
3213 }
3214 #endif
3215 #if CONFIG_SENSOR_Focus
3216
3217 static int sensor_af_single(struct i2c_client *client)
3218 {
3219         int ret = 0;
3220
3221
3222 sensor_af_single_end:
3223         return ret;
3224 }
3225
3226 static int sensor_af_const(struct i2c_client *client)
3227 {
3228         int ret = 0;
3229
3230 sensor_af_const_end:
3231         return ret;
3232 }
3233
3234 static int sensor_af_zoneupdate(struct i2c_client *client)
3235 {
3236         int ret = 0;
3237
3238 sensor_af_zoneupdate_end:
3239         return ret;
3240 }
3241
3242 static int sensor_af_init(struct i2c_client *client)
3243 {
3244         int ret = 0;
3245
3246         return ret;
3247 }
3248 #endif
3249
3250 static int sensor_ioctrl(struct soc_camera_device *icd,enum rk29sensor_power_cmd cmd, int on)
3251 {
3252         struct soc_camera_link *icl = to_soc_camera_link(icd);
3253         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3254     struct sensor *sensor = to_sensor(client);
3255         int ret = 0;
3256
3257         switch (cmd)
3258         {
3259                 case Sensor_Reset:
3260                 {
3261                         if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {
3262                                 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Reset, on);
3263                         }
3264                         break;
3265                 }
3266                 case Sensor_PowerDown:
3267                 {
3268                         if (icl->powerdown) {
3269                                 ret = icl->powerdown(icd->pdev, on);
3270                                 if (ret == RK29_CAM_IO_SUCCESS) {
3271                                         if (on == 0) {
3272                                                 mdelay(2);
3273                                                 if (icl->reset)
3274                                                         icl->reset(icd->pdev);
3275                                         }
3276                                 } else if (ret == RK29_CAM_EIO_REQUESTFAIL) {
3277                                         ret = -ENODEV;
3278                                         goto sensor_power_end;
3279                                 }
3280                         }
3281                         break;
3282                 }
3283                 case Sensor_Flash:
3284                 {
3285                         if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {
3286                                 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Flash, on);
3287                         }
3288                         break;
3289                 }
3290                 default:
3291                 {
3292                         SENSOR_TR("%s cmd(0x%x) is unknown!",SENSOR_NAME_STRING(),cmd);
3293                         break;
3294                 }
3295         }
3296
3297 sensor_power_end:
3298         return ret;
3299 }
3300
3301 static int sensor_init(struct v4l2_subdev *sd, u32 val)
3302 {
3303     struct i2c_client *client = sd->priv;
3304     struct soc_camera_device *icd = client->dev.platform_data;
3305     struct sensor *sensor = to_sensor(client);
3306         const struct v4l2_queryctrl *qctrl;
3307     int ret;
3308     u16 pid = 0;
3309
3310     SENSOR_DG("\n%s..%s.. \n",SENSOR_NAME_STRING(),__FUNCTION__);
3311
3312         sensor_ioctrl(icd,Sensor_Reset, 1);
3313         if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {
3314                 ret = -ENODEV;
3315                 goto sensor_INIT_ERR;
3316         }
3317
3318         udelay(50);
3319         sensor_ioctrl(icd,Sensor_Reset, 0);
3320         mdelay(1);
3321     /* soft reset */
3322         if (sensor_task_lock(client,1)<0)
3323                 goto sensor_INIT_ERR;
3324
3325 #if (SENSOR_RESET_REG != SEQUENCE_END)
3326     ret = sensor_write(client, SENSOR_RESET_REG, SENSOR_RESET_VAL);
3327     if (ret != 0) {
3328         SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
3329         ret = -ENODEV;
3330                 goto sensor_INIT_ERR;
3331     }
3332
3333     mdelay(5);  //delay 5 microseconds
3334 #endif
3335
3336         /* check if it is an sensor sensor */
3337 #if (SENSOR_ID_REG != SEQUENCE_END)
3338     ret = sensor_read(client, SENSOR_ID_REG, &pid);
3339     if (ret != 0) {
3340         SENSOR_TR("read chip id failed\n");
3341         ret = -ENODEV;
3342         goto sensor_INIT_ERR;
3343     }
3344
3345     SENSOR_DG("\n %s  pid = 0x%x \n", SENSOR_NAME_STRING(), pid);
3346 #else
3347         pid = SENSOR_ID;
3348 #endif
3349     if (pid == SENSOR_ID) {
3350         sensor->model = SENSOR_V4L2_IDENT;
3351     } else {
3352         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
3353         ret = -ENODEV;
3354         goto sensor_INIT_ERR;
3355     }
3356
3357     ret = sensor_write_array(client, sensor_init_data);
3358     if (ret != 0)
3359     {
3360         SENSOR_TR("error: %s initial failed\n",SENSOR_NAME_STRING());
3361         goto sensor_INIT_ERR;
3362     }
3363         sensor_task_lock(client,0);
3364     sensor->info_priv.winseqe_cur_addr  = SENSOR_INIT_WINSEQADR;
3365         sensor->info_priv.pixfmt = SENSOR_INIT_PIXFMT;
3366
3367     /* sensor sensor information for initialization  */
3368         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);
3369         if (qctrl)
3370         sensor->info_priv.whiteBalance = qctrl->default_value;
3371         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_BRIGHTNESS);
3372         if (qctrl)
3373         sensor->info_priv.brightness = qctrl->default_value;
3374         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);
3375         if (qctrl)
3376         sensor->info_priv.effect = qctrl->default_value;
3377         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EXPOSURE);
3378         if (qctrl)
3379         sensor->info_priv.exposure = qctrl->default_value;
3380
3381         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SATURATION);
3382         if (qctrl)
3383         sensor->info_priv.saturation = qctrl->default_value;
3384         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_CONTRAST);
3385         if (qctrl)
3386         sensor->info_priv.contrast = qctrl->default_value;
3387         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_HFLIP);
3388         if (qctrl)
3389         sensor->info_priv.mirror = qctrl->default_value;
3390         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_VFLIP);
3391         if (qctrl)
3392         sensor->info_priv.flip = qctrl->default_value;
3393         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SCENE);
3394         if (qctrl)
3395         sensor->info_priv.scene = qctrl->default_value;
3396         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
3397         if (qctrl)
3398         sensor->info_priv.digitalzoom = qctrl->default_value;
3399
3400     /* ddl@rock-chips.com : if sensor support auto focus and flash, programer must run focus and flash code  */
3401         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FOCUS_ABSOLUTE);
3402         if (qctrl)
3403         sensor->info_priv.focus = qctrl->default_value;
3404
3405         #if CONFIG_SENSOR_Flash
3406         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FLASH);
3407         if (qctrl)
3408         sensor->info_priv.flash = qctrl->default_value;
3409     #endif
3410     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);
3411     sensor->info_priv.funmodule_state |= SENSOR_INIT_IS_OK;
3412     return 0;
3413 sensor_INIT_ERR:
3414     sensor->info_priv.funmodule_state |= SENSOR_INIT_IS_OK;
3415         sensor_task_lock(client,0);
3416         sensor_deactivate(client);
3417     return ret;
3418 }
3419
3420 static int sensor_deactivate(struct i2c_client *client)
3421 {
3422         struct soc_camera_device *icd = client->dev.platform_data;
3423     struct sensor *sensor = to_sensor(client);
3424
3425         SENSOR_DG("\n%s..%s.. Enter\n",SENSOR_NAME_STRING(),__FUNCTION__);
3426
3427         /* ddl@rock-chips.com : all sensor output pin must change to input for other sensor */
3428         //sensor_task_lock(client, 1);
3429         sensor_ioctrl(icd, Sensor_PowerDown, 1);
3430     msleep(100);
3431
3432         /* ddl@rock-chips.com : sensor config init width , because next open sensor quickly(soc_camera_open -> Try to configure with default parameters) */
3433         icd->user_width = SENSOR_INIT_WIDTH;
3434     icd->user_height = SENSOR_INIT_HEIGHT;
3435     sensor->info_priv.funmodule_state &= ~SENSOR_INIT_IS_OK;
3436
3437         return 0;
3438 }
3439
3440 static  struct reginfo sensor_suspend_sequence[]=
3441 {
3442         {0x0028, 0x7000},
3443         {0x002A, setot_usForceClocksSettings},
3444         {0x0F12, 0x001E},
3445         {0x002A, setot_usConfigClocksSettings},
3446         {0x0F12, 0x001E},
3447         {0x002A, REG_TC_GP_EnablePreview},
3448         {0x0F12, 0x0000},
3449         {0x002A, REG_TC_GP_EnablePreviewChanged},
3450         {0x0F12, 0x0001},
3451         {SEQUENCE_WAIT_MS, 100},
3452         {0x0028, 0xD000},
3453         {0x002A, 0xB0B0},
3454         {0x0F12, 0x0001},
3455         {SEQUENCE_WAIT_MS, 100},
3456         {0x002A, 0xB0B4},
3457         {0x0F12, 0x0000},
3458         {0x002A, 0xB0A0},
3459         {0x0F12, 0x0031},
3460         {0x002A, 0xB0A0},
3461         {0x0F12, 0x0010},
3462         {0x002A, 0xB0A0},
3463         {0x0F12, 0x0000},
3464         {0x0028, 0x7000},
3465         {0x002A, REG_TC_GP_SleepMode},
3466         {0x0F12, 0x0001},
3467         {0x002A, REG_TC_GP_SleepModeChanged},
3468         {0x0F12, 0x0001},
3469
3470     {SEQUENCE_END,0x00}
3471 };
3472
3473 static struct reginfo sensor_resume_sequence[]=
3474 {
3475         {0x0028, 0x7000},
3476         {0x002A, REG_TC_GP_SleepMode},
3477         {0x0F12, 0x0000},
3478         {0x002A, REG_TC_GP_SleepModeChanged},
3479         {0x0F12, 0x0001},
3480         {0x0028, 0xD000},
3481         {0x002A, 0x1000},
3482         {0x0F12, 0x0001},
3483         {0x002A, 0x003A},
3484         {0x0F12, 0x0000},
3485         {SEQUENCE_WAIT_MS, 200},
3486         {0x002A, 0xB0B0},
3487         {0x0F12, 0x0000},
3488         {0x002A, 0xB0A0},
3489         {0x0F12, 0x003B},
3490         {0x002A, 0xB0B4},
3491         {0x0F12, 0x0800},
3492         {SEQUENCE_WAIT_MS, 10},
3493         {0x0028, 0x7000},
3494         {0x002A, REG_TC_GP_EnablePreview},
3495         {0x0F12, 0x0001},
3496         {0x002A, REG_TC_GP_EnablePreviewChanged},
3497         {0x0F12, 0x0001},
3498
3499     {SEQUENCE_END,0x00}
3500 };
3501 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg)
3502 {
3503     int ret;
3504     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3505
3506     if (pm_msg.event == PM_EVENT_SUSPEND) {
3507         SENSOR_DG("\n %s Enter Suspend.. \n", SENSOR_NAME_STRING());
3508         ret = sensor_write_array(client, sensor_suspend_sequence) ;
3509         if (ret != 0) {
3510             SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);
3511             return ret;
3512         } else {
3513                 mdelay(100);
3514             ret = sensor_ioctrl(icd, Sensor_PowerDown, 1);
3515             if (ret < 0) {
3516                             SENSOR_TR("\n %s suspend fail for turn on power!\n", SENSOR_NAME_STRING());
3517                 return -EINVAL;
3518             }
3519         }
3520     } else {
3521         SENSOR_TR("\n %s cann't suppout Suspend..\n",SENSOR_NAME_STRING());
3522         return -EINVAL;
3523     }
3524
3525     return 0;
3526 }
3527
3528 static int sensor_resume(struct soc_camera_device *icd)
3529 {
3530         int ret;
3531         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3532
3533     ret = sensor_ioctrl(icd, Sensor_PowerDown, 0);
3534     if (ret < 0) {
3535                 SENSOR_TR("\n %s resume fail for turn on power!\n", SENSOR_NAME_STRING());
3536         return -EINVAL;
3537     } else {
3538         udelay(5);
3539                 ret = sensor_write_array(client, sensor_resume_sequence) ;
3540             if (ret != 0) {
3541                 SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);
3542                         return -EINVAL;
3543             }
3544     }
3545
3546         SENSOR_DG("\n %s Enter Resume.. \n", SENSOR_NAME_STRING());
3547
3548         return 0;
3549 }
3550
3551 static int sensor_set_bus_param(struct soc_camera_device *icd,
3552                                 unsigned long flags)
3553 {
3554     return 0;
3555 }
3556
3557 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd)
3558 {
3559     struct soc_camera_link *icl = to_soc_camera_link(icd);
3560     unsigned long flags = SENSOR_BUS_PARAM;
3561
3562     return soc_camera_apply_sensor_flags(icl, flags);
3563 }
3564
3565 static int sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
3566 {
3567     struct i2c_client *client = sd->priv;
3568     struct soc_camera_device *icd = client->dev.platform_data;
3569     struct sensor *sensor = to_sensor(client);
3570     struct v4l2_pix_format *pix = &f->fmt.pix;
3571
3572     pix->width          = icd->user_width;
3573     pix->height         = icd->user_height;
3574     pix->pixelformat    = sensor->info_priv.pixfmt;
3575     pix->field          = V4L2_FIELD_NONE;
3576     pix->colorspace             = V4L2_COLORSPACE_JPEG;
3577
3578     return 0;
3579 }
3580 static bool sensor_fmt_capturechk(struct v4l2_subdev *sd, struct v4l2_format *f)
3581 {
3582     bool ret = false;
3583
3584         if ((f->fmt.pix.width == 1024) && (f->fmt.pix.height == 768)) {
3585                 ret = true;
3586         } else if ((f->fmt.pix.width == 1280) && (f->fmt.pix.height == 1024)) {
3587                 ret = true;
3588         } else if ((f->fmt.pix.width == 1600) && (f->fmt.pix.height == 1200)) {
3589                 ret = true;
3590         } else if ((f->fmt.pix.width == 2048) && (f->fmt.pix.height == 1536)) {
3591                 ret = true;
3592         } else if ((f->fmt.pix.width == 2592) && (f->fmt.pix.height == 1944)) {
3593                 ret = true;
3594         }
3595
3596         if (ret == true)
3597                 SENSOR_DG("%s %dx%d is capture format\n", __FUNCTION__, f->fmt.pix.width, f->fmt.pix.height);
3598         return ret;
3599 }
3600
3601 static bool sensor_fmt_videochk(struct v4l2_subdev *sd, struct v4l2_format *f)
3602 {
3603     bool ret = false;
3604
3605         if ((f->fmt.pix.width == 1280) && (f->fmt.pix.height == 720)) {
3606                 ret = true;
3607         } else if ((f->fmt.pix.width == 1920) && (f->fmt.pix.height == 1080)) {
3608                 ret = true;
3609         }
3610
3611         if (ret == true)
3612                 SENSOR_DG("%s %dx%d is video format\n", __FUNCTION__, f->fmt.pix.width, f->fmt.pix.height);
3613         return ret;
3614 }
3615 static struct reginfo* sensor_fmt_catch(int set_w, int set_h, int *ret_w, int *ret_h)
3616 {
3617         struct reginfo *winseqe_set_addr = NULL;
3618
3619         if (((set_w <= 176) && (set_h <= 144)) && (sensor_qcif[0].reg!=SEQUENCE_END)) {
3620                 winseqe_set_addr = sensor_qcif;
3621         *ret_w = 176;
3622         *ret_h = 144;
3623         } else if (((set_w <= 320) && (set_h <= 240)) && (sensor_qvga[0].reg!=SEQUENCE_END)) {
3624         winseqe_set_addr = sensor_qvga;
3625         *ret_w = 320;
3626         *ret_h = 240;
3627         } else if (((set_w <= 352) && (set_h<= 288)) && (sensor_cif[0].reg!=SEQUENCE_END)) {
3628         winseqe_set_addr = sensor_cif;
3629         *ret_w = 352;
3630         *ret_h = 288;
3631     } else if (((set_w <= 640) && (set_h <= 480)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
3632         winseqe_set_addr = sensor_vga;
3633         *ret_w = 640;
3634         *ret_h = 480;
3635     }
3636 #if CONFIG_SENSOR_FOR_CTS
3637    /**lzg@rockchip.com: forbid to preview with resolution 1280*1024*/
3638     else if (((set_w <= 800) && (set_h <= 600)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
3639             winseqe_set_addr = sensor_vga;
3640             *ret_w = 640;
3641             *ret_h = 480;
3642         }
3643 #else
3644     else if (((set_w <= 800) && (set_h <= 600)) && (sensor_svga[0].reg!=SEQUENCE_END)) {
3645         winseqe_set_addr = sensor_svga;
3646         *ret_w = 800;
3647         *ret_h = 600;
3648     }
3649 #endif
3650     else if (((set_w <= 1024) && (set_h <= 768)) && (sensor_xga[0].reg!=SEQUENCE_END)) {
3651         winseqe_set_addr = sensor_xga;
3652         *ret_w = 1024;
3653         *ret_h = 768;
3654         } else if (((set_w <= 1280) && (set_h <= 720)) && (sensor_720p[0].reg!=SEQUENCE_END)) {
3655         winseqe_set_addr = sensor_720p;
3656         *ret_w = 1280;
3657         *ret_h = 720;
3658     } else if (((set_w <= 1280) && (set_h <= 1024)) && (sensor_sxga[0].reg!=SEQUENCE_END)) {
3659         winseqe_set_addr = sensor_sxga;
3660         *ret_w = 1280;
3661         *ret_h = 1024;
3662     } else if (((set_w <= 1600) && (set_h <= 1200)) && (sensor_uxga[0].reg!=SEQUENCE_END)) {
3663         winseqe_set_addr = sensor_uxga;
3664         *ret_w = 1600;
3665         *ret_h = 1200;
3666         }
3667 #if CONFIG_SENSOR_FOR_CTS
3668    /**lzg@rockchip.com: forbid to preview with resolution 1280*1024*/
3669     else if (((set_w <= 1920) && (set_h <= 1080)) && (sensor_vga[0].reg!=SEQUENCE_END)) {
3670         winseqe_set_addr = sensor_vga;
3671         *ret_w = 640;
3672         *ret_h = 480;
3673     }
3674 #else
3675     else if (((set_w <= 1920) && (set_h <= 1080)) && (sensor_1080p[0].reg!=SEQUENCE_END)) {
3676         winseqe_set_addr = sensor_1080p;
3677         *ret_w = 1920;
3678         *ret_h = 1080;
3679     }
3680 #endif
3681     else if (((set_w <= 2048) && (set_h <= 1536)) && (sensor_qxga[0].reg!=SEQUENCE_END)) {
3682         winseqe_set_addr = sensor_qxga;
3683         *ret_w = 2048;
3684         *ret_h = 1536;
3685     } else if (((set_w <= 2592) && (set_h <= 1944)) && (sensor_qsxga[0].reg!=SEQUENCE_END)) {
3686         winseqe_set_addr = sensor_qsxga;
3687         *ret_w = 2592;
3688         *ret_h = 1944;
3689     }
3690
3691         return winseqe_set_addr;
3692 }
3693
3694 static int sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
3695 {
3696     struct i2c_client *client = sd->priv;
3697     struct sensor *sensor = to_sensor(client);
3698     struct v4l2_pix_format *pix = &f->fmt.pix;
3699     struct reginfo *winseqe_set_addr=NULL;
3700     int ret=0, set_w,set_h;
3701
3702         if (sensor->info_priv.pixfmt != pix->pixelformat) {
3703                 switch (pix->pixelformat)
3704                 {
3705                         case V4L2_PIX_FMT_YUYV:
3706                         {
3707                                 winseqe_set_addr = sensor_ClrFmt_YUYV;
3708                                 break;
3709                         }
3710                         case V4L2_PIX_FMT_UYVY:
3711                         {
3712                                 winseqe_set_addr = sensor_ClrFmt_UYVY;
3713                                 break;
3714                         }
3715                         default:
3716                                 break;
3717                 }
3718                 if (winseqe_set_addr != NULL) {
3719             sensor_write_array(client, winseqe_set_addr);
3720                         sensor->info_priv.pixfmt = pix->pixelformat;
3721
3722                         SENSOR_DG("%s Pixelformat(0x%x) set success!\n", SENSOR_NAME_STRING(),pix->pixelformat);
3723                 } else {
3724                         SENSOR_TR("%s Pixelformat(0x%x) is invalidate!\n", SENSOR_NAME_STRING(),pix->pixelformat);
3725                 }
3726         }
3727
3728     set_w = pix->width;
3729     set_h = pix->height;
3730
3731         winseqe_set_addr = sensor_fmt_catch(set_w, set_h, &set_w, &set_h);
3732
3733     if ((winseqe_set_addr  != sensor->info_priv.winseqe_cur_addr) && winseqe_set_addr) {
3734         #if CONFIG_SENSOR_Flash
3735         if (sensor_fmt_capturechk(sd,f) == true) {      /* ddl@rock-chips.com : Capture */
3736             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
3737                 sensor_ioctrl(icd, Sensor_Flash, Flash_On);
3738                 SENSOR_DG("%s flash on in capture!\n", SENSOR_NAME_STRING());
3739             }
3740         } else {                                        /* ddl@rock-chips.com : Video */
3741             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
3742                 sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
3743                 SENSOR_DG("%s flash off in preivew!\n", SENSOR_NAME_STRING());
3744             }
3745         }
3746         #endif
3747         ret |= sensor_write_array(client, winseqe_set_addr);
3748         if (ret != 0) {
3749             SENSOR_TR("%s set format capability failed\n", SENSOR_NAME_STRING());
3750             #if CONFIG_SENSOR_Flash
3751             if (sensor_fmt_capturechk(sd,f) == true) {
3752                 if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {
3753                     sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
3754                     SENSOR_TR("%s Capture format set fail, flash off !\n", SENSOR_NAME_STRING());
3755                 }
3756             }
3757             #endif
3758             goto sensor_s_fmt_end;
3759         }
3760
3761         sensor->info_priv.winseqe_cur_addr  = (int)winseqe_set_addr;
3762
3763
3764         SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,set_w,set_h);
3765     } else {
3766         SENSOR_TR("\n %s .. Current Format is validate. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),set_w,set_h);
3767     }
3768
3769         pix->width = set_w;
3770     pix->height = set_h;
3771
3772 sensor_s_fmt_end:
3773     return ret;
3774 }
3775
3776 static int sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)
3777 {
3778         int ret = 0;
3779     struct v4l2_pix_format *pix = &f->fmt.pix;
3780         int set_w,set_h;
3781     bool bayer = pix->pixelformat == V4L2_PIX_FMT_UYVY ||
3782         pix->pixelformat == V4L2_PIX_FMT_YUYV;
3783
3784     /*
3785     * With Bayer format enforce even side lengths, but let the user play
3786     * with the starting pixel
3787     */
3788         set_w = pix->width;
3789         set_h = pix->height;
3790
3791     if (pix->height > SENSOR_MAX_HEIGHT)
3792         pix->height = SENSOR_MAX_HEIGHT;
3793     else if (pix->height < SENSOR_MIN_HEIGHT)
3794         pix->height = SENSOR_MIN_HEIGHT;
3795     else if (bayer)
3796         pix->height = ALIGN(pix->height, 2);
3797
3798     if (pix->width > SENSOR_MAX_WIDTH)
3799         pix->width = SENSOR_MAX_WIDTH;
3800     else if (pix->width < SENSOR_MIN_WIDTH)
3801         pix->width = SENSOR_MIN_WIDTH;
3802     else if (bayer)
3803         pix->width = ALIGN(pix->width, 2);
3804
3805         if (sensor_fmt_catch(pix->width, pix->height, &pix->width, &pix->height) == NULL) {
3806                 pix->width = 0;
3807                 pix->height = 0;
3808         }
3809
3810     return ret;
3811 }
3812
3813  static int sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id)
3814 {
3815     struct i2c_client *client = sd->priv;
3816
3817     if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)
3818         return -EINVAL;
3819
3820     if (id->match.addr != client->addr)
3821         return -ENODEV;
3822
3823     id->ident = SENSOR_V4L2_IDENT;      /* ddl@rock-chips.com :  Return s5k6aa  identifier */
3824     id->revision = 0;
3825
3826     return 0;
3827 }
3828 #if CONFIG_SENSOR_Brightness
3829 static int sensor_set_brightness(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3830 {
3831     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3832
3833     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3834     {
3835         if (sensor_BrightnessSeqe[value - qctrl->minimum] != NULL)
3836         {
3837             if (sensor_write_array(client, sensor_BrightnessSeqe[value - qctrl->minimum]) != 0)
3838             {
3839                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3840                 return -EINVAL;
3841             }
3842             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3843             return 0;
3844         }
3845     }
3846         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3847     return -EINVAL;
3848 }
3849 #endif
3850 #if CONFIG_SENSOR_Effect
3851 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3852 {
3853     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3854
3855     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3856     {
3857         if (sensor_EffectSeqe[value - qctrl->minimum] != NULL)
3858         {
3859             if (sensor_write_array(client, sensor_EffectSeqe[value - qctrl->minimum]) != 0)
3860             {
3861                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3862                 return -EINVAL;
3863             }
3864             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3865             return 0;
3866         }
3867     }
3868         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3869     return -EINVAL;
3870 }
3871 #endif
3872 #if CONFIG_SENSOR_Exposure
3873 static int sensor_set_exposure(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3874 {
3875     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3876
3877     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3878     {
3879         if (sensor_ExposureSeqe[value - qctrl->minimum] != NULL)
3880         {
3881             if (sensor_write_array(client, sensor_ExposureSeqe[value - qctrl->minimum]) != 0)
3882             {
3883                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3884                 return -EINVAL;
3885             }
3886             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3887             return 0;
3888         }
3889     }
3890         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3891     return -EINVAL;
3892 }
3893 #endif
3894 #if CONFIG_SENSOR_Saturation
3895 static int sensor_set_saturation(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3896 {
3897     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3898
3899     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3900     {
3901         if (sensor_SaturationSeqe[value - qctrl->minimum] != NULL)
3902         {
3903             if (sensor_write_array(client, sensor_SaturationSeqe[value - qctrl->minimum]) != 0)
3904             {
3905                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3906                 return -EINVAL;
3907             }
3908             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3909             return 0;
3910         }
3911     }
3912     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3913     return -EINVAL;
3914 }
3915 #endif
3916 #if CONFIG_SENSOR_Contrast
3917 static int sensor_set_contrast(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3918 {
3919     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3920
3921     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3922     {
3923         if (sensor_ContrastSeqe[value - qctrl->minimum] != NULL)
3924         {
3925             if (sensor_write_array(client, sensor_ContrastSeqe[value - qctrl->minimum]) != 0)
3926             {
3927                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3928                 return -EINVAL;
3929             }
3930             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3931             return 0;
3932         }
3933     }
3934     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3935     return -EINVAL;
3936 }
3937 #endif
3938 #if CONFIG_SENSOR_Mirror
3939 static int sensor_set_mirror(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3940 {
3941     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3942
3943     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3944     {
3945         if (sensor_MirrorSeqe[value - qctrl->minimum] != NULL)
3946         {
3947             if (sensor_write_array(client, sensor_MirrorSeqe[value - qctrl->minimum]) != 0)
3948             {
3949                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3950                 return -EINVAL;
3951             }
3952             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3953             return 0;
3954         }
3955     }
3956     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3957     return -EINVAL;
3958 }
3959 #endif
3960 #if CONFIG_SENSOR_Flip
3961 static int sensor_set_flip(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3962 {
3963     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3964
3965     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3966     {
3967         if (sensor_FlipSeqe[value - qctrl->minimum] != NULL)
3968         {
3969             if (sensor_write_array(client, sensor_FlipSeqe[value - qctrl->minimum]) != 0)
3970             {
3971                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3972                 return -EINVAL;
3973             }
3974             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3975             return 0;
3976         }
3977     }
3978     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
3979     return -EINVAL;
3980 }
3981 #endif
3982 #if CONFIG_SENSOR_Scene
3983 static int sensor_set_scene(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
3984 {
3985     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
3986
3987     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
3988     {
3989         if (sensor_SceneSeqe[value - qctrl->minimum] != NULL)
3990         {
3991             if (sensor_write_array(client, sensor_SceneSeqe[value - qctrl->minimum]) != 0)
3992             {
3993                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
3994                 return -EINVAL;
3995             }
3996             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
3997             return 0;
3998         }
3999     }
4000     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4001     return -EINVAL;
4002 }
4003 #endif
4004 #if CONFIG_SENSOR_WhiteBalance
4005 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
4006 {
4007     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4008
4009     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))
4010     {
4011         if (sensor_WhiteBalanceSeqe[value - qctrl->minimum] != NULL)
4012         {
4013             if (sensor_write_array(client, sensor_WhiteBalanceSeqe[value - qctrl->minimum]) != 0)
4014             {
4015                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
4016                 return -EINVAL;
4017             }
4018             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
4019             return 0;
4020         }
4021     }
4022         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4023     return -EINVAL;
4024 }
4025 #endif
4026 #if CONFIG_SENSOR_DigitalZoom
4027 static int sensor_set_digitalzoom(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int *value)
4028 {
4029     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4030     struct sensor *sensor = to_sensor(client);
4031         const struct v4l2_queryctrl *qctrl_info;
4032     int digitalzoom_cur, digitalzoom_total;
4033
4034         qctrl_info = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);
4035         if (qctrl_info)
4036                 return -EINVAL;
4037
4038     digitalzoom_cur = sensor->info_priv.digitalzoom;
4039     digitalzoom_total = qctrl_info->maximum;
4040
4041     if ((*value > 0) && (digitalzoom_cur >= digitalzoom_total))
4042     {
4043         SENSOR_TR("%s digitalzoom is maximum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
4044         return -EINVAL;
4045     }
4046
4047     if  ((*value < 0) && (digitalzoom_cur <= qctrl_info->minimum))
4048     {
4049         SENSOR_TR("%s digitalzoom is minimum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);
4050         return -EINVAL;
4051     }
4052
4053     if ((*value > 0) && ((digitalzoom_cur + *value) > digitalzoom_total))
4054     {
4055         *value = digitalzoom_total - digitalzoom_cur;
4056     }
4057
4058     if ((*value < 0) && ((digitalzoom_cur + *value) < 0))
4059     {
4060         *value = 0 - digitalzoom_cur;
4061     }
4062
4063     digitalzoom_cur += *value;
4064
4065     if (sensor_ZoomSeqe[digitalzoom_cur] != NULL)
4066     {
4067         if (sensor_write_array(client, sensor_ZoomSeqe[digitalzoom_cur]) != 0)
4068         {
4069             SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);
4070             return -EINVAL;
4071         }
4072         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, *value);
4073         return 0;
4074     }
4075
4076     return -EINVAL;
4077 }
4078 #endif
4079 #if CONFIG_SENSOR_Flash
4080 static int sensor_set_flash(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)
4081 {
4082     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4083     struct sensor *sensor = to_sensor(client);
4084         const struct v4l2_queryctrl *qctrl_info;
4085
4086     if ((value >= qctrl->minimum) && (value <= qctrl->maximum)) {
4087         if (value == 3) {       /* ddl@rock-chips.com: torch */
4088             sensor_ioctrl(icd, Sensor_Flash, Flash_Torch);   /* Flash On */
4089         } else {
4090             sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
4091         }
4092         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);
4093         return 0;
4094     }
4095
4096         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);
4097     return -EINVAL;
4098 }
4099 #endif
4100 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
4101 {
4102     struct i2c_client *client = sd->priv;
4103     struct sensor *sensor = to_sensor(client);
4104     const struct v4l2_queryctrl *qctrl;
4105
4106     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
4107
4108     if (!qctrl)
4109     {
4110         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
4111         return -EINVAL;
4112     }
4113
4114     switch (ctrl->id)
4115     {
4116         case V4L2_CID_BRIGHTNESS:
4117             {
4118                 ctrl->value = sensor->info_priv.brightness;
4119                 break;
4120             }
4121         case V4L2_CID_SATURATION:
4122             {
4123                 ctrl->value = sensor->info_priv.saturation;
4124                 break;
4125             }
4126         case V4L2_CID_CONTRAST:
4127             {
4128                 ctrl->value = sensor->info_priv.contrast;
4129                 break;
4130             }
4131         case V4L2_CID_DO_WHITE_BALANCE:
4132             {
4133                 ctrl->value = sensor->info_priv.whiteBalance;
4134                 break;
4135             }
4136         case V4L2_CID_EXPOSURE:
4137             {
4138                 ctrl->value = sensor->info_priv.exposure;
4139                 break;
4140             }
4141         case V4L2_CID_HFLIP:
4142             {
4143                 ctrl->value = sensor->info_priv.mirror;
4144                 break;
4145             }
4146         case V4L2_CID_VFLIP:
4147             {
4148                 ctrl->value = sensor->info_priv.flip;
4149                 break;
4150             }
4151         default :
4152                 break;
4153     }
4154     return 0;
4155 }
4156
4157
4158
4159 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
4160 {
4161     struct i2c_client *client = sd->priv;
4162     struct sensor *sensor = to_sensor(client);
4163     struct soc_camera_device *icd = client->dev.platform_data;
4164     const struct v4l2_queryctrl *qctrl;
4165
4166
4167     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);
4168
4169     if (!qctrl)
4170     {
4171         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);
4172         return -EINVAL;
4173     }
4174
4175     switch (ctrl->id)
4176     {
4177 #if CONFIG_SENSOR_Brightness
4178         case V4L2_CID_BRIGHTNESS:
4179             {
4180                 if (ctrl->value != sensor->info_priv.brightness)
4181                 {
4182                     if (sensor_set_brightness(icd, qctrl,ctrl->value) != 0)
4183                     {
4184                         return -EINVAL;
4185                     }
4186                     sensor->info_priv.brightness = ctrl->value;
4187                 }
4188                 break;
4189             }
4190 #endif
4191 #if CONFIG_SENSOR_Exposure
4192         case V4L2_CID_EXPOSURE:
4193             {
4194                 if (ctrl->value != sensor->info_priv.exposure)
4195                 {
4196                     if (sensor_set_exposure(icd, qctrl,ctrl->value) != 0)
4197                     {
4198                         return -EINVAL;
4199                     }
4200                     sensor->info_priv.exposure = ctrl->value;
4201                 }
4202                 break;
4203             }
4204 #endif
4205 #if CONFIG_SENSOR_Saturation
4206         case V4L2_CID_SATURATION:
4207             {
4208                 if (ctrl->value != sensor->info_priv.saturation)
4209                 {
4210                     if (sensor_set_saturation(icd, qctrl,ctrl->value) != 0)
4211                     {
4212                         return -EINVAL;
4213                     }
4214                     sensor->info_priv.saturation = ctrl->value;
4215                 }
4216                 break;
4217             }
4218 #endif
4219 #if CONFIG_SENSOR_Contrast
4220         case V4L2_CID_CONTRAST:
4221             {
4222                 if (ctrl->value != sensor->info_priv.contrast)
4223                 {
4224                     if (sensor_set_contrast(icd, qctrl,ctrl->value) != 0)
4225                     {
4226                         return -EINVAL;
4227                     }
4228                     sensor->info_priv.contrast = ctrl->value;
4229                 }
4230                 break;
4231             }
4232 #endif
4233 #if CONFIG_SENSOR_WhiteBalance
4234         case V4L2_CID_DO_WHITE_BALANCE:
4235             {
4236                 if (ctrl->value != sensor->info_priv.whiteBalance)
4237                 {
4238                     if (sensor_set_whiteBalance(icd, qctrl,ctrl->value) != 0)
4239                     {
4240                         return -EINVAL;
4241                     }
4242                     sensor->info_priv.whiteBalance = ctrl->value;
4243                 }
4244                 break;
4245             }
4246 #endif
4247 #if CONFIG_SENSOR_Mirror
4248         case V4L2_CID_HFLIP:
4249             {
4250                 if (ctrl->value != sensor->info_priv.mirror)
4251                 {
4252                     if (sensor_set_mirror(icd, qctrl,ctrl->value) != 0)
4253                         return -EINVAL;
4254                     sensor->info_priv.mirror = ctrl->value;
4255                 }
4256                 break;
4257             }
4258 #endif
4259 #if CONFIG_SENSOR_Flip
4260         case V4L2_CID_VFLIP:
4261             {
4262                 if (ctrl->value != sensor->info_priv.flip)
4263                 {
4264                     if (sensor_set_flip(icd, qctrl,ctrl->value) != 0)
4265                         return -EINVAL;
4266                     sensor->info_priv.flip = ctrl->value;
4267                 }
4268                 break;
4269             }
4270 #endif
4271         default:
4272             break;
4273     }
4274
4275     return 0;
4276 }
4277 static int sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl)
4278 {
4279     const struct v4l2_queryctrl *qctrl;
4280     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4281     struct sensor *sensor = to_sensor(client);
4282
4283     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
4284
4285     if (!qctrl)
4286     {
4287         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
4288         return -EINVAL;
4289     }
4290
4291     switch (ext_ctrl->id)
4292     {
4293         case V4L2_CID_SCENE:
4294             {
4295                 ext_ctrl->value = sensor->info_priv.scene;
4296                 break;
4297             }
4298         case V4L2_CID_EFFECT:
4299             {
4300                 ext_ctrl->value = sensor->info_priv.effect;
4301                 break;
4302             }
4303         case V4L2_CID_ZOOM_ABSOLUTE:
4304             {
4305                 ext_ctrl->value = sensor->info_priv.digitalzoom;
4306                 break;
4307             }
4308         case V4L2_CID_ZOOM_RELATIVE:
4309             {
4310                 return -EINVAL;
4311             }
4312         case V4L2_CID_FOCUS_ABSOLUTE:
4313             {
4314                 ext_ctrl->value = sensor->info_priv.focus;
4315                 break;
4316             }
4317         case V4L2_CID_FOCUS_RELATIVE:
4318             {
4319                 return -EINVAL;
4320             }
4321         case V4L2_CID_FLASH:
4322             {
4323                 ext_ctrl->value = sensor->info_priv.flash;
4324                 break;
4325             }
4326         default :
4327             break;
4328     }
4329     return 0;
4330 }
4331 static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl)
4332 {
4333     const struct v4l2_queryctrl *qctrl;
4334     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
4335     struct sensor *sensor = to_sensor(client);
4336     int val_offset;
4337
4338     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);
4339
4340     if (!qctrl)
4341     {
4342         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);
4343         return -EINVAL;
4344     }
4345
4346         val_offset = 0;
4347     switch (ext_ctrl->id)
4348     {
4349 #if CONFIG_SENSOR_Scene
4350         case V4L2_CID_SCENE:
4351             {
4352                 if (ext_ctrl->value != sensor->info_priv.scene)
4353                 {
4354                     if (sensor_set_scene(icd, qctrl,ext_ctrl->value) != 0)
4355                         return -EINVAL;
4356                     sensor->info_priv.scene = ext_ctrl->value;
4357                 }
4358                 break;
4359             }
4360 #endif
4361 #if CONFIG_SENSOR_Effect
4362         case V4L2_CID_EFFECT:
4363             {
4364                 if (ext_ctrl->value != sensor->info_priv.effect)
4365                 {
4366                     if (sensor_set_effect(icd, qctrl,ext_ctrl->value) != 0)
4367                         return -EINVAL;
4368                     sensor->info_priv.effect= ext_ctrl->value;
4369                 }
4370                 break;
4371             }
4372 #endif
4373 #if CONFIG_SENSOR_DigitalZoom
4374         case V4L2_CID_ZOOM_ABSOLUTE:
4375             {
4376                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
4377                     return -EINVAL;
4378
4379                 if (ext_ctrl->value != sensor->info_priv.digitalzoom)
4380                 {
4381                     val_offset = ext_ctrl->value -sensor->info_priv.digitalzoom;
4382
4383                     if (sensor_set_digitalzoom(icd, qctrl,&val_offset) != 0)
4384                         return -EINVAL;
4385                     sensor->info_priv.digitalzoom += val_offset;
4386
4387                     SENSOR_DG("%s digitalzoom is %x\n",SENSOR_NAME_STRING(),  sensor->info_priv.digitalzoom);
4388                 }
4389
4390                 break;
4391             }
4392         case V4L2_CID_ZOOM_RELATIVE:
4393             {
4394                 if (ext_ctrl->value)
4395                 {
4396                     if (sensor_set_digitalzoom(icd, qctrl,&ext_ctrl->value) != 0)
4397                         return -EINVAL;
4398                     sensor->info_priv.digitalzoom += ext_ctrl->value;
4399
4400                     SENSOR_DG("%s digitalzoom is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.digitalzoom);
4401                 }
4402                 break;
4403             }
4404 #endif
4405 #if CONFIG_SENSOR_Focus
4406         case V4L2_CID_FOCUS_ABSOLUTE:
4407             {
4408                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))
4409                     return -EINVAL;
4410
4411                 if (ext_ctrl->value != sensor->info_priv.focus)
4412                 {
4413                     val_offset = ext_ctrl->value -sensor->info_priv.focus;
4414
4415                     sensor->info_priv.focus += val_offset;
4416                 }
4417
4418                 break;
4419             }
4420         case V4L2_CID_FOCUS_RELATIVE:
4421             {
4422                 if (ext_ctrl->value)
4423                 {
4424                     sensor->info_priv.focus += ext_ctrl->value;
4425
4426                     SENSOR_DG("%s focus is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.focus);
4427                 }
4428                 break;
4429             }
4430 #endif
4431 #if CONFIG_SENSOR_Flash
4432         case V4L2_CID_FLASH:
4433             {
4434                 if (sensor_set_flash(icd, qctrl,ext_ctrl->value) != 0)
4435                     return -EINVAL;
4436                 sensor->info_priv.flash = ext_ctrl->value;
4437
4438                 SENSOR_DG("%s flash is %x\n",SENSOR_NAME_STRING(), sensor->info_priv.flash);
4439                 break;
4440             }
4441 #endif
4442         default:
4443             break;
4444     }
4445
4446     return 0;
4447 }
4448
4449 static int sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
4450 {
4451     struct i2c_client *client = sd->priv;
4452     struct soc_camera_device *icd = client->dev.platform_data;
4453     int i, error_cnt=0, error_idx=-1;
4454
4455
4456     for (i=0; i<ext_ctrl->count; i++) {
4457         if (sensor_g_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
4458             error_cnt++;
4459             error_idx = i;
4460         }
4461     }
4462
4463     if (error_cnt > 1)
4464         error_idx = ext_ctrl->count;
4465
4466     if (error_idx != -1) {
4467         ext_ctrl->error_idx = error_idx;
4468         return -EINVAL;
4469     } else {
4470         return 0;
4471     }
4472 }
4473
4474 static int sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)
4475 {
4476     struct i2c_client *client = sd->priv;
4477     struct soc_camera_device *icd = client->dev.platform_data;
4478     int i, error_cnt=0, error_idx=-1;
4479
4480
4481     for (i=0; i<ext_ctrl->count; i++) {
4482         if (sensor_s_ext_control(icd, &ext_ctrl->controls[i]) != 0) {
4483             error_cnt++;
4484             error_idx = i;
4485         }
4486     }
4487
4488     if (error_cnt > 1)
4489         error_idx = ext_ctrl->count;
4490
4491     if (error_idx != -1) {
4492         ext_ctrl->error_idx = error_idx;
4493         return -EINVAL;
4494     } else {
4495         return 0;
4496     }
4497 }
4498 static int sensor_s_stream(struct v4l2_subdev *sd, int enable)
4499 {
4500         struct i2c_client *client = sd->priv;
4501     struct sensor *sensor = to_sensor(client);
4502
4503         if (enable == 1) {
4504                 sensor->info_priv.enable = 1;
4505         } else if (enable == 0) {
4506                 sensor->info_priv.enable = 0;
4507         }
4508
4509         return 0;
4510 }
4511 /* Interface active, can use i2c. If it fails, it can indeed mean, that
4512  * this wasn't our capture interface, so, we wait for the right one */
4513 static int sensor_video_probe(struct soc_camera_device *icd,
4514                                struct i2c_client *client)
4515 {
4516     int ret,pid = 0;
4517     struct sensor *sensor = to_sensor(client);
4518
4519     /* We must have a parent by now. And it cannot be a wrong one.
4520      * So this entire test is completely redundant. */
4521     if (!icd->dev.parent ||
4522             to_soc_camera_host(icd->dev.parent)->nr != icd->iface)
4523                 return -ENODEV;
4524
4525         if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {
4526                 ret = -ENODEV;
4527                 goto sensor_video_probe_err;
4528         }
4529
4530     /* soft reset */
4531 #if (SENSOR_RESET_REG != SEQUENCE_END)
4532     ret = sensor_write(client, SENSOR_RESET_REG, SENSOR_RESET_VAL);
4533     if (ret != 0) {
4534         SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());
4535         ret = -ENODEV;
4536                 goto sensor_video_probe_err;
4537     }
4538
4539     mdelay(5);  //delay 5 microseconds
4540 #endif
4541
4542         /* check if it is an sensor sensor */
4543 #if (SENSOR_ID_REG != SEQUENCE_END)
4544     ret = sensor_read(client, SENSOR_ID_REG, &pid);
4545     if (ret != 0) {
4546         SENSOR_TR("read chip id failed\n");
4547         ret = -ENODEV;
4548         goto sensor_video_probe_err;
4549     }
4550
4551     SENSOR_DG("\n %s  pid = 0x%x \n", SENSOR_NAME_STRING(), pid);
4552 #else
4553         pid = SENSOR_ID;
4554 #endif
4555
4556     if (pid == SENSOR_ID) {
4557         sensor->model = SENSOR_V4L2_IDENT;
4558     } else {
4559         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);
4560         ret = -ENODEV;
4561         goto sensor_video_probe_err;
4562     }
4563
4564     icd->formats = sensor_colour_formats;
4565     icd->num_formats = ARRAY_SIZE(sensor_colour_formats);
4566
4567     return 0;
4568
4569 sensor_video_probe_err:
4570
4571     return ret;
4572 }
4573 static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
4574 {
4575         struct i2c_client *client = sd->priv;
4576     struct soc_camera_device *icd = client->dev.platform_data;
4577     struct sensor *sensor = to_sensor(client);
4578     int ret = 0;
4579 #if CONFIG_SENSOR_Flash
4580     int i;
4581 #endif
4582
4583         SENSOR_DG("\n%s..%s..cmd:%x \n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);
4584         switch (cmd)
4585         {
4586                 case RK29_CAM_SUBDEV_DEACTIVATE:
4587                 {
4588                         sensor_deactivate(client);
4589                         break;
4590                 }
4591                 case RK29_CAM_SUBDEV_IOREQUEST:
4592                 {
4593                         sensor->sensor_io_request = (struct rk29camera_platform_data*)arg;
4594             if (sensor->sensor_io_request != NULL) {
4595                 if (sensor->sensor_io_request->gpio_res[0].dev_name &&
4596                     (strcmp(sensor->sensor_io_request->gpio_res[0].dev_name, dev_name(icd->pdev)) == 0)) {
4597                     sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[0];
4598                 } else if (sensor->sensor_io_request->gpio_res[1].dev_name &&
4599                     (strcmp(sensor->sensor_io_request->gpio_res[1].dev_name, dev_name(icd->pdev)) == 0)) {
4600                     sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[1];
4601                 }
4602             } else {
4603                 SENSOR_TR("%s %s RK29_CAM_SUBDEV_IOREQUEST fail\n",SENSOR_NAME_STRING(),__FUNCTION__);
4604                 ret = -EINVAL;
4605                 goto sensor_ioctl_end;
4606             }
4607             /* ddl@rock-chips.com : if gpio_flash havn't been set in board-xxx.c, sensor driver must notify is not support flash control
4608                for this project */
4609             #if CONFIG_SENSOR_Flash
4610                 if (sensor->sensor_gpio_res) {
4611                 if (sensor->sensor_gpio_res->gpio_flash == INVALID_GPIO) {
4612                     for (i = 0; i < icd->ops->num_controls; i++) {
4613                                 if (V4L2_CID_FLASH == icd->ops->controls[i].id) {
4614                                         memset(&icd->ops->controls[i],0x00,sizeof(struct v4l2_queryctrl));
4615                                 }
4616                     }
4617                     sensor->info_priv.flash = 0xff;
4618                     SENSOR_DG("%s flash gpio is invalidate!\n",SENSOR_NAME_STRING());
4619                 }
4620                 }
4621             #endif
4622                         break;
4623                 }
4624                 default:
4625                 {
4626                         SENSOR_TR("%s %s cmd(0x%x) is unknown !\n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);
4627                         break;
4628                 }
4629         }
4630 sensor_ioctl_end:
4631         return ret;
4632
4633 }
4634 static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {
4635         .init           = sensor_init,
4636         .g_ctrl         = sensor_g_control,
4637         .s_ctrl         = sensor_s_control,
4638         .g_ext_ctrls          = sensor_g_ext_controls,
4639         .s_ext_ctrls          = sensor_s_ext_controls,
4640         .g_chip_ident   = sensor_g_chip_ident,
4641         .ioctl = sensor_ioctl,
4642 };
4643
4644 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {
4645         .s_fmt          = sensor_s_fmt,
4646         .g_fmt          = sensor_g_fmt,
4647         .try_fmt        = sensor_try_fmt,
4648         .s_stream   = sensor_s_stream,
4649 };
4650
4651 static struct v4l2_subdev_ops sensor_subdev_ops = {
4652         .core   = &sensor_subdev_core_ops,
4653         .video = &sensor_subdev_video_ops,
4654 };
4655
4656 static int sensor_probe(struct i2c_client *client,
4657                          const struct i2c_device_id *did)
4658 {
4659     struct sensor *sensor;
4660     struct soc_camera_device *icd = client->dev.platform_data;
4661     struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
4662     struct soc_camera_link *icl;
4663     int ret;
4664
4665     SENSOR_DG("\n%s..%s..%d..\n",__FUNCTION__,__FILE__,__LINE__);
4666     if (!icd) {
4667         dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());
4668         return -EINVAL;
4669     }
4670
4671     icl = to_soc_camera_link(icd);
4672     if (!icl) {
4673         dev_err(&client->dev, "%s driver needs platform data\n", SENSOR_NAME_STRING());
4674         return -EINVAL;
4675     }
4676
4677     if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
4678         dev_warn(&adapter->dev,
4679                  "I2C-Adapter doesn't support I2C_FUNC_I2C\n");
4680         return -EIO;
4681     }
4682
4683     sensor = kzalloc(sizeof(struct sensor), GFP_KERNEL);
4684     if (!sensor)
4685         return -ENOMEM;
4686
4687     v4l2_i2c_subdev_init(&sensor->subdev, client, &sensor_subdev_ops);
4688
4689     /* Second stage probe - when a capture adapter is there */
4690     icd->ops            = &sensor_ops;
4691     icd->y_skip_top             = 0;
4692
4693     ret = sensor_video_probe(icd, client);
4694     if (ret) {
4695         icd->ops = NULL;
4696         i2c_set_clientdata(client, NULL);
4697         kfree(sensor);
4698     }
4699     SENSOR_DG("\n%s..%s..%d  ret = %x \n",__FUNCTION__,__FILE__,__LINE__,ret);
4700     return ret;
4701 }
4702
4703 static int sensor_remove(struct i2c_client *client)
4704 {
4705     struct sensor *sensor = to_sensor(client);
4706     struct soc_camera_device *icd = client->dev.platform_data;
4707
4708     icd->ops = NULL;
4709     i2c_set_clientdata(client, NULL);
4710     client->driver = NULL;
4711     kfree(sensor);
4712
4713     return 0;
4714 }
4715
4716 static const struct i2c_device_id sensor_id[] = {
4717         {SENSOR_NAME_STRING(), 0 },
4718         { }
4719 };
4720 MODULE_DEVICE_TABLE(i2c, sensor_id);
4721
4722 static struct i2c_driver sensor_i2c_driver = {
4723         .driver = {
4724                 .name = SENSOR_NAME_STRING(),
4725         },
4726         .probe          = sensor_probe,
4727         .remove         = sensor_remove,
4728         .id_table       = sensor_id,
4729 };
4730
4731 static int __init sensor_mod_init(void)
4732 {
4733     SENSOR_DG("\n%s..%s.. \n",__FUNCTION__,SENSOR_NAME_STRING());
4734     return i2c_add_driver(&sensor_i2c_driver);
4735 }
4736
4737 static void __exit sensor_mod_exit(void)
4738 {
4739     i2c_del_driver(&sensor_i2c_driver);
4740 }
4741
4742 device_initcall_sync(sensor_mod_init);
4743 module_exit(sensor_mod_exit);
4744
4745 MODULE_DESCRIPTION(SENSOR_NAME_STRING(Camera sensor driver));
4746 MODULE_AUTHOR("ddl <kernel@rock-chips>");
4747 MODULE_LICENSE("GPL");
4748