drivers/media/video/sid130B.c

   1 /*\r
   2 o* Driver for MT9M001 CMOS Image Sensor from Micron\r
   3  *\r
   4  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>\r
   5  *\r
   6  * This program is free software; you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License version 2 as\r
   8  * published by the Free Software Foundation.\r
   9  */\r
  10 \r
  11 #include <linux/videodev2.h>\r
  12 #include <linux/slab.h>\r
  13 #include <linux/i2c.h>\r
  14 #include <linux/log2.h>\r
  15 #include <linux/platform_device.h>\r
  16 #include <linux/delay.h>\r
  17 #include <linux/circ_buf.h>\r
  18 #include <linux/miscdevice.h>\r
  19 #include <media/v4l2-common.h>\r
  20 #include <media/v4l2-chip-ident.h>\r
  21 #include <media/soc_camera.h>\r
  22 #include <plat/rk_camera.h>\r
  23 \r
  24 static int debug;\r
  25 module_param(debug, int, S_IRUGO|S_IWUSR);\r
  26 \r
  27 #define dprintk(level, fmt, arg...) do {                        \\r
  28         if (debug >= level)                                     \\r
  29         printk(KERN_WARNING fmt , ## arg); } while (0)\r
  30 \r
  31 #define SENSOR_TR(format, ...) printk(KERN_ERR format, ## __VA_ARGS__)\r
  32 #define SENSOR_DG(format, ...) dprintk(1, format, ## __VA_ARGS__)\r
  33 \r
  34 \r
  35 #define _CONS(a,b) a##b\r
  36 #define CONS(a,b) _CONS(a,b)\r
  37 \r
  38 #define __STR(x) #x\r
  39 #define _STR(x) __STR(x)\r
  40 #define STR(x) _STR(x)\r
  41 \r
  42 #define MIN(x,y)   ((x<y) ? x: y)\r
  43 #define MAX(x,y)    ((x>y) ? x: y)\r
  44 \r
  45 /* Sensor Driver Configuration */\r
  46 #define SENSOR_NAME sid130B\r
  47 #define SENSOR_V4L2_IDENT V4L2_IDENT_SID130B\r
  48 #define SENSOR_ID 0x1B\r
  49 #define SENSOR_MIN_WIDTH    176\r
  50 #define SENSOR_MIN_HEIGHT   144\r
  51 #define SENSOR_MAX_WIDTH    1600\r
  52 #define SENSOR_MAX_HEIGHT   1200\r
  53 #define SENSOR_INIT_WIDTH       800                     /* Sensor pixel size for sensor_init_data array */\r
  54 #define SENSOR_INIT_HEIGHT  600\r
  55 #define SENSOR_INIT_WINSEQADR sensor_svga\r
  56 #define SENSOR_INIT_PIXFMT V4L2_MBUS_FMT_UYVY8_2X8\r
  57 \r
  58 #define CONFIG_SENSOR_WhiteBalance 1\r
  59 #define CONFIG_SENSOR_Brightness        0\r
  60 #define CONFIG_SENSOR_Contrast      0\r
  61 #define CONFIG_SENSOR_Saturation    0\r
  62 #define CONFIG_SENSOR_Effect        1\r
  63 #define CONFIG_SENSOR_Scene         0\r
  64 #define CONFIG_SENSOR_DigitalZoom   0\r
  65 #define CONFIG_SENSOR_Focus         0\r
  66 #define CONFIG_SENSOR_Exposure      0\r
  67 #define CONFIG_SENSOR_Flash         1\r
  68 #define CONFIG_SENSOR_Mirror        0\r
  69 #define CONFIG_SENSOR_Flip          0\r
  70 \r
  71 #define CONFIG_SENSOR_I2C_SPEED     80000       /* Hz */\r
  72 /* Sensor write register continues by preempt_disable/preempt_enable for current process not be scheduled */\r
  73 #define CONFIG_SENSOR_I2C_NOSCHED   0\r
  74 #define CONFIG_SENSOR_I2C_RDWRCHK   0\r
  75 \r
  76 #define SENSOR_BUS_PARAM  (SOCAM_MASTER | SOCAM_PCLK_SAMPLE_RISING |\\r
  77                           SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW|\\r
  78                           SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8  |SOCAM_MCLK_24MHZ)\r
  79 \r
  80 #define COLOR_TEMPERATURE_CLOUDY_DN  6500\r
  81 #define COLOR_TEMPERATURE_CLOUDY_UP    8000\r
  82 #define COLOR_TEMPERATURE_CLEARDAY_DN  5000\r
  83 #define COLOR_TEMPERATURE_CLEARDAY_UP    6500\r
  84 #define COLOR_TEMPERATURE_OFFICE_DN     3500\r
  85 #define COLOR_TEMPERATURE_OFFICE_UP     5000\r
  86 #define COLOR_TEMPERATURE_HOME_DN       2500\r
  87 #define COLOR_TEMPERATURE_HOME_UP       3500\r
  88 \r
  89 #define SENSOR_NAME_STRING(a) STR(CONS(SENSOR_NAME, a))\r
  90 #define SENSOR_NAME_VARFUN(a) CONS(SENSOR_NAME, a)\r
  91 \r
  92 #define SENSOR_AF_IS_ERR    (0x00<<0)\r
  93 #define SENSOR_AF_IS_OK         (0x01<<0)\r
  94 #define SENSOR_INIT_IS_ERR   (0x00<<28)\r
  95 #define SENSOR_INIT_IS_OK    (0x01<<28)\r
  96 \r
  97 struct reginfo\r
  98 {\r
  99     u8 reg;\r
 100     u8 val;\r
 101 };\r
 102 \r
 103 //flash off in fixed time to prevent from too hot , zyc\r
 104 struct  flash_timer{\r
 105     struct soc_camera_device *icd;\r
 106         struct hrtimer timer;\r
 107 };\r
 108 static enum hrtimer_restart flash_off_func(struct hrtimer *timer);\r
 109 \r
 110 static struct  flash_timer flash_off_timer;\r
 111 //for user defined if user want to customize the series , zyc\r
 112 #ifdef CONFIG_SID130B_USER_DEFINED_SERIES\r
 113 #include "sid130B_user_series.c"\r
 114 #else\r
 115 /* init 352X288 SVGA */\r
 116 static struct reginfo sensor_init_data[] =\r
 117 {\r
 118 #if 0\r
 119            {0x00,  0x00},  \r
 120         {0x04,  0x00},  //Group A 0x10\r
 121         {0x05,  0x0F},  //UXGA Output\r
 122         {0x06,  0x86}, \r
 123         {0x07,  0x08}, \r
 124 \r
 125 \r
 126         {0x08,  0xa2},  //PLL off\r
 127         {0x09,  0x12},  \r
 128         {0x0A,  0x12},  \r
 129         {0x10,  0x17},  \r
 130         {0x11,  0x01}, \r
 131         {0x12,  0x8A}, \r
 132         {0x13,  0x1a}, \r
 133         {0x14,  0x27}, \r
 134         {0x15,  0x22}, \r
 135 \r
 136         {0x17,  0xCb},  \r
 137         {0x18,  0x38},  \r
 138         \r
 139         {0x40,  0x0f}, \r
 140         {0x41,  0x17}, \r
 141         {0x42,  0x52}, \r
 142         {0x43,  0x80}, \r
 143         {0x44,  0x00}, \r
 144         {0x45,  0x00}, \r
 145 \r
 146 //Flicker - 50Hz  - Still mode ,     \r
 147         {0x00,  0x00}, \r
 148         {0x20,  0x00}, \r
 149         {0x21,  0x02}, \r
 150         {0x23,  0x29},//15}, \r
 151         {0x00,  0x01}, \r
 152         {0x35,  0x50},//3c}, \r
 153 \r
 154 //Flicker - 50Hz - Preview mode 24MHz MCLK\r
 155         {0x00,  0x00}, \r
 156         {0x24,  0x00}, \r
 157         {0x25,  0xe6},//10}, \r
 158         {0x27,  0x0d},//4b}, \r
 159         {0x00,  0x01}, \r
 160         {0x34,  0x80},//64}, \r
 161 \r
 162 \r
 163 //AE Block \r
 164         {0x00,  0x01}, \r
 165         {0x10,  0x00}, \r
 166         {0x11,  0x0a}, //.0c\r
 167         {0x12,  0x78}, \r
 168         {0x13,  0x78}, \r
 169         {0x14,  0x78}, \r
 170         {0x17,  0xC4}, \r
 171         {0x1c,  0x05},    \r
 172 \r
 173         {0x36,  0x28},  //26\r
 174 \r
 175         {0x40,  0x40},  //Max Again  //anyuan\r
 176         //{0x41,  0x20}, \r
 177         //{0x42,  0x20}, \r
 178         //{0x43,  0x00}, \r
 179         //{0x44,  0x00}, \r
 180         //{0x45,  0x01}, \r
 181         //{0x46,  0x1c}, \r
 182         //{0x47,  0x11}, \r
 183         //{0x48,  0x15}, \r
 184         //{0x49,  0x17}, \r
 185         //{0x4A,  0x1a}, \r
 186         //{0x4B,  0x1c}, \r
 187         //{0x4C,  0x1e}, \r
 188         //{0x4D,  0x1e}, \r
 189         //{0x4E,  0x0f}, \r
 190         //{0x4F,  0x09}, \r
 191         //{0x50,  0x07}, \r
 192         //{0x51,  0x05}, \r
 193         //{0x52,  0x04}, \r
 194         //{0x53,  0x03}, \r
 195         //{0x54,  0x02}, \r
 196         //{0x55,  0x01}, \r
 197         //{0x66,  0x00}, \r
 198         //{0x67,  0x00}, \r
 199         //{0x68,  0x00}, \r
 200         //{0x69,  0x00}, \r
 201         //{0x6a,  0x00}, \r
 202         //{0x6b,  0x00},\r
 203 \r
 204         {0x70,  0xc4}, \r
 205         {0x73,  0x22}, \r
 206         {0x74,  0x07}, \r
 207         {0x77,  0xd0}, \r
 208         {0x78,  0xd8}, \r
 209         {0x79,  0x70}, \r
 210   //\r
 211         {0x90,  0x00}, \r
 212         {0x92,  0x0c}, //0bank 0x11 °ú µ¿ÀÏ \r
 213         {0x95,  0x40},  //0 bank 0x40 °ú µ¿ÀÏ  \r
 214         //AWB Block\r
 215 \r
 216         {0x00,  0x02}, \r
 217         {0x10,  0xD3}, \r
 218         {0x11,  0x11}, \r
 219         {0x13,  0x7e}, \r
 220         {0x14,  0x7c}, \r
 221         {0x15,  0xee}, \r
 222         {0x16,  0x80}, \r
 223         {0x17,  0xd0}, \r
 224         {0x18,  0x80}, \r
 225         {0x19,  0x98}, \r
 226         {0x1A,  0x68}, \r
 227         {0x1B,  0x98}, \r
 228         {0x1C,  0x68}, \r
 229         {0x1D,  0x90}, \r
 230         {0x1E,  0x74}, \r
 231         {0x20,  0xF0}, \r
 232         {0x21,  0x85}, \r
 233         {0x22,  0xB4}, \r
 234         {0x23,  0x20}, \r
 235         {0x25,  0x20}, \r
 236         {0x26,  0x05}, \r
 237         {0x27,  0x78}, \r
 238         {0x28,  0xd8}, \r
 239         {0x29,  0xb8}, \r
 240         {0x2A,  0x88}, \r
 241         {0x30,  0x00}, \r
 242         {0x31,  0x10}, \r
 243         {0x32,  0x00}, \r
 244         {0x33,  0x10}, \r
 245         {0x34,  0x06}, \r
 246         {0x35,  0x30}, \r
 247         {0x36,  0x04}, \r
 248         {0x37,  0xA0}, \r
 249         {0x40,  0x01}, \r
 250         {0x41,  0x04}, \r
 251         {0x42,  0x08}, \r
 252         {0x43,  0x10}, \r
 253         {0x44,  0x13}, \r
 254         {0x45,  0x6B}, \r
 255         {0x46,  0x82},  \r
 256 \r
 257 \r
 258 \r
 259 //CMA change  -D65~A\r
 260         {0x53,  0xa1},  //AWB R Gain for D30 to D20\r
 261         {0x54,  0xc0},  //AWB B Gain for D30 to D20\r
 262         {0x55,  0xa1},  //AWB R Gain for D20 to D30\r
 263         {0x56,  0xc0},  //AWB B Gain for D20 to D30\r
 264         {0x57,  0xc8},  //AWB R Gain for D65 to D30\r
 265         {0x58,  0xa0},  //AWB B Gain for D65 to D30\r
 266         {0x59,  0xc8},  //AWB R Gain for D30 to D65\r
 267         {0x5A,  0xa0},  //AWB B Gain for D30 to D65\r
 268 \r
 269   {0x64,  0x00},\r
 270   {0x65,  0x00},\r
 271   {0x66,  0x00},\r
 272   {0x67,  0x00},\r
 273   {0x68,  0xa5},\r
 274   {0x69,  0xb4},\r
 275   {0x6a,  0xb3},\r
 276   {0x6b,  0xac},\r
 277   {0x6c,  0xb7},\r
 278   {0x6d,  0x98},\r
 279   {0x6e,  0xba},\r
 280   {0x6f,  0x90},\r
 281   \r
 282   {0x70,  0xbf},\r
 283   {0x71,  0x9b},\r
 284   {0x72,  0xce},\r
 285   {0x73,  0x8c},\r
 286   {0x74,  0x7f},\r
 287   {0x75,  0x8c},\r
 288   {0x76,  0xad},\r
 289   {0x77,  0xba},\r
 290   {0x78,  0x8f},\r
 291   {0x79,  0x9a},\r
 292   {0x7A,  0xa3},\r
 293   {0x7B,  0xac},\r
 294   {0x7C,  0xa0},\r
 295   {0x7D,  0xa9},\r
 296   {0x7E,  0x95},\r
 297   {0x7F,  0xac},\r
 298   {0x80,  0xad},\r
 299   {0x81,  0xbc},\r
 300   {0x82,  0x98},\r
 301   {0x83,  0xa4},\r
 302   {0x84,  0x00},\r
 303   {0x85,  0x00},\r
 304   {0x86,  0x00},\r
 305   {0x87,  0x00},\r
 306   {0x88,  0xc9},\r
 307   {0x89,  0xd5},\r
 308   {0x8a,  0x70},\r
 309   {0x8b,  0x7b},\r
 310   {0x8c,  0xd0},\r
 311   {0x8d,  0xe5},\r
 312   {0x8e,  0x58},\r
 313   {0x8f,  0x70},\r
 314     \r
 315         {0xB4,  0x05},  \r
 316         {0xB5,  0x0F},  \r
 317         {0xB6,  0x06},  \r
 318         {0xB7,  0x06},  \r
 319         {0xB8,  0x40},  \r
 320         {0xB9,  0x10},  \r
 321         {0xBA,  0x06},  \r
 322 \r
 323 //IDP\r
 324         {0x00,  0x03}, \r
 325         {0x10,  0xFF}, \r
 326         {0x11,  0x1D}, \r
 327         {0x12,  0x1D}, \r
 328         {0x13,  0xFF}, \r
 329         {0x14,  0x00}, \r
 330         {0x15,  0xc0}, \r
 331 \r
 332 //DPC\r
 333         {0x30,  0x88},  //DPCNRCTRL\r
 334         {0x31,  0x14},  //DPTHR @ AGAIN = 00\r
 335         {0x32,  0x10},  //DPTHR @ AGAIN = 20\r
 336         {0x33,  0x0c},  //DPTHR @ AGAIN = 40\r
 337         {0x34,  0x08},  //DPTHR @ AGAIN = 60\r
 338         {0x35,  0x04},  //DPTHR @ AGAIN = 80\r
 339         {0x36,  0x44},  //DPTHVRNG\r
 340         {0x37,  0x66},  //DPNUMBER\r
 341         {0x38,  0x00},  //0x00  // NRTHR0 @ AGAIN = 00\r
 342         {0x39,  0x04},  //0x0C  // NRTHR1 @ AGAIN = 20\r
 343         {0x3A,  0x04},  //0x18  // NRTHR2 @ AGAIN = 40\r
 344         {0x3B,  0x2c},  //0x30  // NRTHR3 @ AGAIN = 60\r
 345         {0x3C,  0x3c},  //                 NRTHR4 @ AGAIN = 80\r
 346         {0x3D,  0x04},  //NRTHVRNG0 @ AGAIN = 00\r
 347         {0x3E,  0x04},  //NRTHVRNG1 @ AGAIN = 20\r
 348         {0x3F,  0x04},  //NRTHVRNG2 @ AGAIN = 40\r
 349         {0x40,  0x2c},  //NRTHVRNG3 @ AGAIN = 60\r
 350         {0x41,  0x3c},  //NRTHVRNG4 @ AGAIN = 80\r
 351         {0x42,  0xff},  //NRTHVRNGMAX\r
 352         {0x43,  0x40},  //NRTHRWGT\r
 353         {0x44,  0x40},  //BASELVL\r
 354         {0x45,  0x06},  //SHUMAXH\r
 355         {0x46,  0x40},  //SHUMAXL\r
 356         {0x47,  0x30},  //ILLUMITHDRK\r
 357 \r
 358 // shading\r
 359         {0x50,  0x0a},  //0x00      \r
 360         {0x51,  0x20},  //0x45  \r
 361         {0x52,  0x12},  //0x24      \r
 362         {0x53,  0x12},  //0x24 \r
 363                                       \r
 364         {0x54,  0x22},  //0x00      \r
 365         {0x55,  0x18},  //0x40  \r
 366         {0x56,  0x08},  //0x10      \r
 367         {0x57,  0x10},  //0x20 \r
 368                                         \r
 369         {0x58,  0x22},  //0x00      \r
 370         {0x59,  0x18},  //0x40  \r
 371         {0x5A,  0x08},  //0x10      \r
 372         {0x5B,  0x10},  //0x20 \r
 373                                        \r
 374         {0x5C,  0x25},  //0x04      \r
 375         {0x5D,  0x1a},  //0x55  \r
 376         {0x5E,  0x12},  //0x25    \r
 377         {0x5F,  0x10},  //0x20 \r
 378              \r
 379         {0x60,  0x32},  //0x32                   \r
 380         {0x61,  0x20},  //20//\r
 381         {0x62,  0x58},  //67\r
 382 //      {0x63,  0x89 //8c R Center start gain\r
 383 //      {0x66,  0x79 //B Center start gain   73               \r
 384         {0x6B,  0x00}, //01 //01                 \r
 385         {0x6C,  0x01}, //22                   \r
 386         {0x6D,  0x23}, //22                   \r
 387         {0x6E,  0x55}, //55                   \r
 388         {0x6F,  0x55}, //77                   \r
 389         {0x70,  0x55}, //65                   \r
 390         {0x71,  0x00}, //01 //AB (6)               \r
 391         {0x72,  0x01}, //23     (5)             \r
 392         {0x73,  0x23}, //33     (4)            \r
 393         {0x74,  0x44}, //45     (3)             \r
 394         {0x75,  0x45}, //55     (2)               \r
 395         {0x76,  0x66}, //55     (1)             \r
 396         {0x77,  0x00}, //01 //AB (6)                 \r
 397         {0x78,  0x01}, //23     (5)              \r
 398         {0x79,  0x23}, //33     (4)              \r
 399         {0x7A,  0x44}, //45     (3)              \r
 400         {0x7B,  0x45}, //55     (2)                \r
 401         {0x7C,  0x66}, //55     (1)              \r
 402         {0x7D,  0x00}, //00    //00                   \r
 403         {0x7E,  0x00}, //00    //00                   \r
 404         {0x7F,  0x12}, //11    //12                   \r
 405         {0x80,  0x33}, //33    //33 //44               \r
 406         {0x81,  0x44}, //33    //33 //44                  \r
 407         {0x82,  0x55}, //22    //44 //45 \r
 408         //{0x83,  0x14}, \r
 409         //{0x84,  0x0f}, \r
 410 \r
 411         {0x94,0x02},\r
 412         {0x95,0x80},\r
 413         {0x96,0x01},\r
 414         {0x97,0xe0}, \r
 415 \r
 416 //Interpolation\r
 417         {0xA0,  0x3F},\r
 418         {0xA1,  0x05},\r
 419         {0xA2,  0xB7},\r
 420         {0xA3,  0xB7},\r
 421         {0xA4,  0x04},\r
 422         {0xA5,  0xFF},\r
 423         {0xA6,  0x04},\r
 424         {0xA7,  0xFF},\r
 425         {0xA8,  0x00},\r
 426         {0xA9,  0x00},\r
 427         {0xAA,  0x00},\r
 428         {0xAB,  0x00},\r
 429         {0xAC,  0x60},\r
 430         {0xAD,  0x18},\r
 431         {0xAE,  0x10},\r
 432         {0xAF,  0x20},\r
 433         {0xB0,  0x08},\r
 434         {0xB1,  0x00},\r
 435 \r
 436 //Color Matrix for D65\r
 437 #if 0\r
 438         {0xC0,  0x2F}, // CMASB D20 or D30 or Dark Condition Color Matrix Selection\r
 439         {0xC1,  0x66}, \r
 440         {0xC2,  0xd4}, \r
 441         {0xC3,  0x05}, \r
 442         {0xC4,  0xf0}, \r
 443         {0xC5,  0x5a}, \r
 444         {0xC6,  0xf5}, \r
 445         {0xC7,  0xf9}, \r
 446         {0xC8,  0xbf}, \r
 447         {0xC9,  0x88}, \r
 448         {0xCA,  0xa0}, \r
 449         {0xCB,  0x50}, \r
 450         {0xCC,  0xe2}, \r
 451         {0xCD,  0x00}, \r
 452         {0xCE,  0x00}, \r
 453 #else\r
 454 {0xC0,  0x2F}, // CMASB D20 or D30 or Dark Condition Color Matrix Selection\r
 455 {0xC1,  0x71}, \r
 456 {0xC2,  0xcc}, \r
 457 {0xC3,  0x01}, \r
 458 {0xC4,  0xe8}, \r
 459 {0xC5,  0x68}, \r
 460 {0xC6,  0xef}, \r
 461 {0xC7,  0xfa}, \r
 462 {0xC8,  0xc6}, \r
 463 {0xC9,  0x7e}, \r
 464 {0xCA,  0xec}, \r
 465 {0xCB,  0x67}, \r
 466 {0xCC,  0x34}, \r
 467 {0xCD,  0x3a}, \r
 468 {0xCE,  0x08},\r
 469 \r
 470 #endif\r
 471 //Color Matrix for CWF\r
 472         {0xD0,  0x2F}, \r
 473         {0xD1,  0x66}, \r
 474         {0xD2,  0xd4}, \r
 475         {0xD3,  0x05}, \r
 476         {0xD4,  0xf0}, \r
 477         {0xD5,  0x5a}, \r
 478         {0xD6,  0xf5}, \r
 479         {0xD7,  0xe9}, \r
 480         {0xD8,  0xbf}, \r
 481         {0xD9,  0x88},\r
 482         {0xDA,  0xa0}, \r
 483         {0xDB,  0x50}, \r
 484         {0xDC,  0xe2}, \r
 485         {0xDD,  0x00}, \r
 486         {0xDE,  0x00}, \r
 487 \r
 488 //Color Matrix for A\r
 489         {0xE0,  0x2F}, \r
 490         {0xE1,  0x6e}, \r
 491         {0xE2,  0xc7}, \r
 492         {0xE3,  0x0d}, \r
 493         {0xE4,  0xe3}, \r
 494         {0xE5,  0x61}, \r
 495         {0xE6,  0xfa}, \r
 496         {0xE7,  0xe5}, \r
 497         {0xE8,  0xcb}, \r
 498         {0xE9,  0x8e}, \r
 499         {0xEA,  0xc4}, \r
 500         {0xEB,  0x04}, \r
 501         {0xEC,  0xf3}, \r
 502         {0xED,  0xdd}, \r
 503         {0xEE,  0x06}, \r
 504 \r
 505 //IDP 4\r
 506         {0x00,  0x04}, \r
 507 \r
 508 //Gamma - r   \r
 509         {0x10,  0x00}, \r
 510         {0x11,  0x04}, \r
 511         {0x12,  0x10},\r
 512         {0x13,  0x20},\r
 513         {0x14,  0x40},\r
 514         {0x15,  0x5c},\r
 515         {0x16,  0x74},\r
 516         {0x17,  0x84},\r
 517         {0x18,  0x98},\r
 518         {0x19,  0xa4},\r
 519         {0x1A,  0xb0},\r
 520         {0x1B,  0xc8},\r
 521         {0x1C,  0xdc},\r
 522         {0x1D,  0xf0},\r
 523         {0x1E,  0xf8},\r
 524         {0x1F,  0xFF},\r
 525                         \r
 526 //Gamma - G             \r
 527         {0x20,  0x00}, \r
 528         {0x21,  0x04}, \r
 529         {0x22,  0x10},\r
 530         {0x23,  0x20},\r
 531         {0x24,  0x40},\r
 532         {0x25,  0x5c},\r
 533         {0x26,  0x74},\r
 534         {0x27,  0x84},\r
 535         {0x28,  0x98},\r
 536         {0x29,  0xa4},\r
 537         {0x2A,  0xb0},\r
 538         {0x2B,  0xc8},\r
 539         {0x2C,  0xdc},\r
 540         {0x2D,  0xf0},\r
 541         {0x2E,  0xf8},\r
 542         {0x2F,  0xFF},\r
 543                         \r
 544 //Gamma - B             \r
 545         {0x30,  0x00}, \r
 546         {0x31,  0x04}, \r
 547         {0x32,  0x10},\r
 548         {0x33,  0x20},\r
 549         {0x34,  0x40},\r
 550         {0x35,  0x5c},\r
 551         {0x36,  0x74},\r
 552         {0x37,  0x84},\r
 553         {0x38,  0x98},\r
 554         {0x39,  0xa4},\r
 555         {0x3A,  0xb0},\r
 556         {0x3B,  0xc8},\r
 557         {0x3C,  0xdc},\r
 558         {0x3D,  0xf0},\r
 559         {0x3E,  0xf8},\r
 560         {0x3F,  0xFF},\r
 561 \r
 562 //DARK GAMMA\r
 563         {0x40,  0x00}, \r
 564         {0x41,  0x0b}, \r
 565         {0x42,  0x15},\r
 566         {0x43,  0x29},\r
 567         {0x44,  0x47},\r
 568         {0x45,  0x5D},\r
 569         {0x46,  0x72},\r
 570         {0x47,  0x83},\r
 571         {0x48,  0x92},\r
 572         {0x49,  0xA0},\r
 573         {0x4A,  0xac},\r
 574         {0x4B,  0xc6},\r
 575         {0x4C,  0xdA},\r
 576         {0x4D,  0xeC},\r
 577         {0x4E,  0xf6},\r
 578         {0x4F,  0xFF},\r
 579   \r
 580         {0x50,  0x00}, //DARK GAMMA on/off\r
 581         \r
 582 //CSC                   \r
 583         {0x60,  0x33}, \r
 584         {0x61,  0x20}, \r
 585         {0x62,  0xE4}, \r
 586         {0x63,  0xFA}, \r
 587         {0x64,  0x13}, \r
 588         {0x65,  0x25}, \r
 589         {0x66,  0x07}, \r
 590         {0x67,  0xF5}, \r
 591         {0x68,  0xEA}, \r
 592         {0x69,  0x20}, \r
 593         {0x6A,  0xC8}, \r
 594         {0x6B,  0xC4}, \r
 595         {0x6C,  0x84}, \r
 596         {0x6D,  0x04}, \r
 597         {0x6E,  0x0C}, \r
 598         {0x6F,  0x00}, \r
 599                         \r
 600 //Edge                  \r
 601 // {0x70,  0x00},\r
 602 // {0x71,  0x18},\r
 603 // {0x72,  0x18},\r
 604 // {0x73,  0x04},\r
 605 // {0x74,  0x08},\r
 606 // {0x76,  0x20},\r
 607 // {0x77,  0x04},\r
 608 // {0x78,  0x08},\r
 609 // {0x7a,  0x20},\r
 610 // {0x7d,  0x08},\r
 611 // {0X7e,  0x30},\r
 612 \r
 613         {0x80,  0x22}, \r
 614         {0x81,  0x14}, \r
 615         {0x82,  0x14}, \r
 616         {0x83,  0x04}, \r
 617         {0x84,  0x06}, \r
 618         {0x85,  0x06}, \r
 619         {0x87,  0x04},\r
 620         {0x88,  0x10},\r
 621         {0x89,  0x06},\r
 622         {0X90,  0x06},\r
 623         {0x91,  0x03},\r
 624         {0x93,  0xe0},\r
 625 \r
 626 //Cr/Cb Coring\r
 627         {0x94,  0x00}, \r
 628         {0x95,  0x00}, \r
 629         {0x96,  0x4C}, \r
 630         {0x97,  0x76}, \r
 631         {0x9A,  0xf5}, \r
 632 \r
 633         {0xA1,  0x08},   //@ 0\r
 634         {0xA2,  0x10},   //@ 20\r
 635         {0xA3,  0x16},   //@ 40\r
 636         {0xA4,  0x20},   //@ 60\r
 637         {0xA5,  0x30},   //@ 80\r
 638         {0xA6,  0xa0}, \r
 639         {0xA7,  0x06}, \r
 640         {0xA8,  0x40}, \r
 641 \r
 642         {0xA9,  0x38}, \r
 643         {0xAa,  0x35}, \r
 644 \r
 645         {0xAc,  0xff}, \r
 646         {0xAd,  0x09}, \r
 647         {0xAe,  0x96}, \r
 648         {0xAf,  0x18}, \r
 649 \r
 650         {0xB2,  0x38},   //color suppression start\r
 651         {0xB3,  0x53}, \r
 652         {0xB6,  0x00}, \r
 653         \r
 654 //Color Saturation\r
 655         {0xBC, 0x10}, \r
 656         {0xBD, 0x10}, \r
 657         {0xBE, 0x10}, \r
 658         {0xBF, 0x10}, \r
 659         {0xc0, 0x10}, \r
 660         {0xc1, 0x10},   \r
 661         {0xc2, 0x10}, \r
 662         {0xc3, 0x10}, \r
 663         {0xc4, 0x10}, \r
 664         {0xc5, 0x10}, \r
 665 \r
 666         {0xcc, 0x04}, \r
 667         {0xcd, 0x40}, \r
 668         {0xce, 0x00}, \r
 669                       \r
 670 //IDP 3                 \r
 671         {0x00,  0x05}, \r
 672                         \r
 673 //Memory                \r
 674         {0x40,  0x15}, \r
 675         {0x41,  0x28}, \r
 676         {0x42,  0x04}, \r
 677         {0x43,  0x15}, \r
 678         {0x44,  0x28}, \r
 679         {0x45,  0x04}, \r
 680         {0x46,  0x15}, \r
 681         {0x47,  0x28}, \r
 682         {0x48,  0x04}, \r
 683                         \r
 684 //Knee                  \r
 685         {0x90,  0xca},  //\r
 686         {0x91,  0x81},  //knee function selection/knee point H\r
 687         {0x92,  0x00},  //knee point L\r
 688         {0x93,  0x50},  //Knee gain\r
 689         {0x94,  0x41},  //[6:4]knee start H/[2:0]Knee END H\r
 690         {0x95,  0x7e},  //knee start L\r
 691         {0x96,  0x48},  //knee END L\r
 692                         \r
 693 //ADG                   \r
 694         {0x99,  0xC0}, \r
 695         {0xA0,  0x10}, \r
 696         {0xA1,  0x22}, \r
 697         {0xA2,  0x36}, \r
 698         {0xA3,  0x49}, \r
 699         {0xA4,  0x5D}, \r
 700         {0xA5,  0x70}, \r
 701         {0xA6,  0x82}, \r
 702         {0xA7,  0x94}, \r
 703         {0xA8,  0xA5}, \r
 704         {0xA9,  0xB5}, \r
 705         {0xAA,  0xC3}, \r
 706         {0xAB,  0xD1}, \r
 707         {0xAC,  0xDE}, \r
 708         {0xAD,  0xEA}, \r
 709         {0xAE,  0xF5}, \r
 710         {0xAF,  0xFF}, \r
 711                         \r
 712 //YXGMA                 \r
 713         {0xB0,  0xc0},  //YGMACTRL\r
 714         {0xB1,  0x04},  //YGMASLOP\r
 715         {0xB8,  0x0f},  //DRKTHR1\r
 716         {0xB9,  0x10},  //DRKTHR2\r
 717         //{0xBA,  0x38},  //DRKTHR3\r
 718         //{0xBB,  0x39},  //DRKTHR4\r
 719         {0xC0,  0x03}, \r
 720         {0xC1,  0x0E}, \r
 721         {0xC2,  0x16}, \r
 722         {0xC3,  0x24}, \r
 723         {0xC4,  0x3F}, \r
 724         {0xC5,  0x56}, \r
 725         {0xC6,  0x6A}, \r
 726         {0xC7,  0x7C}, \r
 727         {0xC8,  0x8C}, \r
 728         {0xC9,  0x98}, \r
 729         {0xCA,  0xA2}, \r
 730         {0xCB,  0xB8}, \r
 731         {0xCC,  0xCD}, \r
 732         {0xCD,  0xE2}, \r
 733         {0xCE,  0xF0}, \r
 734         {0xCF,  0xFF}, \r
 735 \r
 736 \r
 737 // edge value adjustment\r
 738         {0xe0,  0x81}, \r
 739         {0xe1,  0x83}, \r
 740         {0xe2,  0x07}, \r
 741         {0xe3,  0x0c}, \r
 742         {0xe4,  0x14}, \r
 743         {0xe5,  0x1c}, \r
 744 \r
 745 \r
 746 //Sensor on\r
 747         {0x00,  0x00}, \r
 748         {0x03,  0xc5}, \r
 749         {0x00,  0x01}, \r
 750         {0x10,  0x84}, \r
 751         {0x00,  0x02}, \r
 752         {0x10,  0xd3}, \r
 753         {0xff,  0xff}, \r
 754 #else\r
 755 \r
 756      {0x00,  0x00},  \r
 757         {0x04,  0x00},  //Group A 0x10\r
 758         {0x05,  0x0F},  //UXGA Output\r
 759         {0x06,  0x86}, \r
 760         {0x07,  0x08}, \r
 761 \r
 762 \r
 763         {0x08,  0xa2},  //PLL on\r
 764         {0x09,  0x12},  \r
 765         {0x0A,  0x12},  \r
 766         {0x10,  0x13},//17},  \r
 767         {0x11,  0x01}, \r
 768         {0x12,  0x8A}, \r
 769 \r
 770     {0x13, 0x1a},//16},    \r
 771     {0x15, 0x22},//16},    \r
 772     {0x14, 0x27},//16},    \r
 773     {0x17, 0xcb},//CF},    \r
 774     {0x18, 0x38},//34},    \r
 775     {0x41, 0x17},    \r
 776     {0x42, 0x52},    \r
 777                                               \r
 778     //Flicker - 50Hz  - Still mode            \r
 779     {0x00, 0x00},    \r
 780         {0x20,  0x00}, \r
 781         {0x21,  0x02}, \r
 782         {0x23,  0x29},//15}, \r
 783         {0x00,  0x01}, \r
 784         {0x35,  0x50},//3c}, \r
 785 \r
 786     //Flicker - 50Hz - Preview mode 24MHz MCLK\r
 787     {0x00, 0x00},    \r
 788     {0x24, 0x00},    \r
 789         {0x25,  0xe6},//10}, \r
 790         {0x27,  0x0d},//4b}, \r
 791         {0x00,  0x01}, \r
 792         {0x34,  0x80},//64}, \r
 793         \r
 794     //AE Block                                \r
 795     {0x00, 0x01},    \r
 796     {0x10, 0x80},    \r
 797     {0x11, 0x0A},    \r
 798     {0x12, 0x74},    \r
 799     {0x13, 0x74},    \r
 800     {0x14, 0x70},    \r
 801     {0x17, 0xC4},    \r
 802     {0x1c, 0x02},    \r
 803                                               \r
 804     {0x19, 0x00},//0x\r
 805     {0x1A, 0x00},//0x\r
 806     {0x1c, 0x02},    \r
 807                                               \r
 808     {0x36, 0x26},    \r
 809                                               \r
 810     {0x40, 0x40}, //M\r
 811 #if 0                                         \r
 812     {0x41, 0x28},    \r
 813     {0x42, 0x28},    \r
 814     {0x43, 0x08},    \r
 815     {0x44, 0x08},    \r
 816     {0x45, 0x09},    \r
 817     {0x46, 0x17},    \r
 818     {0x47, 0x1D},    \r
 819     {0x48, 0x21},    \r
 820     {0x49, 0x23},    \r
 821     {0x4A, 0x24},    \r
 822     {0x4B, 0x26},    \r
 823     {0x4C, 0x27},    \r
 824     {0x4D, 0x27},    \r
 825     {0x4E, 0x1A},    \r
 826     {0x4F, 0x14},    \r
 827     {0x50, 0x11},    \r
 828     {0x51, 0x0F},    \r
 829     {0x52, 0x0D},    \r
 830     {0x53, 0x0C},    \r
 831     {0x54, 0x0A},    \r
 832     {0x55, 0x09},    \r
 833 #else                                         \r
 834     {0x41, 0x20},    \r
 835     {0x42, 0x20},    \r
 836     {0x43, 0x00},    \r
 837     {0x44, 0x00},    \r
 838     {0x45, 0x01},    \r
 839     {0x46, 0x0c},    \r
 840     {0x47, 0x11},    \r
 841     {0x48, 0x15},    \r
 842     {0x49, 0x17},    \r
 843     {0x4A, 0x1a},    \r
 844     {0x4B, 0x1c},    \r
 845     {0x4C, 0x1e},    \r
 846     {0x4D, 0x1e},    \r
 847     {0x4E, 0x0f},    \r
 848     {0x4F, 0x09},    \r
 849     {0x50, 0x07},    \r
 850     {0x51, 0x05},    \r
 851     {0x52, 0x04},    \r
 852     {0x53, 0x03},    \r
 853     {0x54, 0x02},    \r
 854     {0x55, 0x01},    \r
 855     {0x60, 0x7e},    \r
 856     {0x61, 0xff},    \r
 857     {0x62, 0xff},    \r
 858     {0x63, 0xff},    \r
 859     {0x64, 0xff},    \r
 860     {0x65, 0x7e},    \r
 861     {0x66, 0x50},    \r
 862     {0x67, 0x50},    \r
 863     {0x68, 0x50},    \r
 864     {0x69, 0x50},    \r
 865     {0x6A, 0x50},    \r
 866     {0x6B, 0x00},    \r
 867     {0x6C, 0x06},  \r
 868         {0x9a, 0x80},\r
 869         {0x6b, 0x80},\r
 870 \r
 871 \r
 872 #endif                                        \r
 873                                               \r
 874     //AWB Block                               \r
 875     {0x00, 0x02},    \r
 876     {0x10, 0xD3},    \r
 877     {0x11, 0x11},    \r
 878     {0x13, 0x80},    \r
 879     {0x14, 0x80},    \r
 880     {0x15, 0xE0},//FE},    \r
 881     {0x16, 0x88},    \r
 882     {0x17, 0xD0},    \r
 883     {0x18, 0x78},    \r
 884     {0x19, 0x98},    \r
 885     {0x1A, 0x68},    \r
 886     {0x1B, 0x8d},    \r
 887     {0x1C, 0x68},    \r
 888     {0x1D, 0x8C},    \r
 889     {0x1E, 0x74},    \r
 890     {0x20, 0xF0},    \r
 891     {0x21, 0x70},    \r
 892     {0x22, 0xa8},    \r
 893     {0x23, 0x10},    \r
 894     {0x25, 0x20},    \r
 895     {0x26, 0x05},    \r
 896     {0x27, 0x63},    \r
 897     {0x28, 0x63},    \r
 898     {0x29, 0xA0},    \r
 899     {0x2A, 0x89},    \r
 900     {0x30, 0x00},    \r
 901     {0x31, 0x10},    \r
 902     {0x32, 0x00},    \r
 903     {0x33, 0x10},    \r
 904     {0x34, 0x06},    \r
 905     {0x35, 0x30},    \r
 906     {0x36, 0x04},    \r
 907     {0x37, 0xA0},    \r
 908     {0x40, 0x01},    \r
 909     {0x41, 0x04},    \r
 910     {0x42, 0x08},    \r
 911     {0x43, 0x10},    \r
 912     {0x44, 0x13},    \r
 913     {0x45, 0x6B},    \r
 914     {0x46, 0x82},    \r
 915     {0x52, 0x82},    \r
 916          \r
 917 \r
 918 \r
 919     //CMA change  -D65~A                      \r
 920     {0x53, 0x86}, //A\r
 921     {0x54, 0xA0}, //A\r
 922     {0x55, 0x88}, //A\r
 923     {0x56, 0x9F}, //A\r
 924     {0x57, 0xA5}, //A\r
 925     {0x58, 0x89}, //A\r
 926     {0x59, 0xA6}, //A\r
 927     {0x5A, 0x87}, //A\r
 928                                               \r
 929     {0x64, 0x00}, //T\r
 930     {0x65, 0x00},    \r
 931     {0x66, 0x00}, //T\r
 932     {0x67, 0x00},    \r
 933     {0x68, 0xA5}, //T\r
 934     {0x69, 0xB4},    \r
 935     {0x6A, 0xB3}, //T\r
 936     {0x6B, 0xAC},    \r
 937     {0x6C, 0xB7}, //T\r
 938     {0x6D, 0x98},    \r
 939     {0x6E, 0xBA}, //T\r
 940     {0x6F, 0x90},    \r
 941     {0x70, 0xBF}, //T\r
 942     {0x71, 0x9B},    \r
 943     {0x72, 0xCE}, //T\r
 944     {0x73, 0x8C},    \r
 945 \r
 946          \r
 947                  //IDP\r
 948          \r
 949 \r
 950     {0x74, 0x7F}, //T\r
 951     {0x75, 0x8C}, //T\r
 952     {0x76, 0xAD}, //T\r
 953     {0x77, 0xBA}, //T\r
 954     {0x78, 0x8F}, //T\r
 955     {0x79, 0x9A}, //T\r
 956     {0x7A, 0xA3}, //T\r
 957     {0x7B, 0xAC}, //T\r
 958     {0x7C, 0xA0}, //T\r
 959     {0x7D, 0xA9}, //T\r
 960     {0x7E, 0x95}, //T\r
 961     {0x7F, 0xAC}, //T\r
 962     {0x80, 0xAD}, //T\r
 963     {0x81, 0xBC}, //T\r
 964     {0x82, 0x98}, //T\r
 965     {0x83, 0xA4}, //T\r
 966     {0x84, 0x00}, //T\r
 967     {0x85, 0x00}, //T\r
 968     {0x86, 0x00}, //T\r
 969     {0x87, 0x00}, //T\r
 970     {0x88, 0xC9}, //T\r
 971     {0x89, 0xD5}, //T\r
 972     {0x8A, 0x70}, //T\r
 973     {0x8B, 0x7B}, //T\r
 974     {0x8C, 0xD0}, //T\r
 975     {0x8D, 0xE5}, //T\r
 976     {0x8E, 0x58}, //T\r
 977     {0x8F, 0x70}, //T\r
 978                                               \r
 979     {0xB4, 0x05},    \r
 980     {0xB5, 0x0F},    \r
 981     {0xB6, 0x06},    \r
 982     {0xB7, 0x06},    \r
 983     {0xB8, 0x40},    \r
 984     {0xB9, 0x10},    \r
 985     {0xBA, 0x06},    \r
 986                                               \r
 987     //IDP                                     \r
 988     {0x00, 0x03},    \r
 989     {0x10, 0xFF},    \r
 990     {0x11, 0x1D},    \r
 991     {0x12, 0x1D},    \r
 992     {0x13, 0xFB},    \r
 993     {0x14, 0x00}, \r
 994     {0x15, 0xc0},    \r
 995                                               \r
 996     //DPC                                     \r
 997     {0x30, 0x88}, //D\r
 998     {0x31, 0x14},//04}, //D\r
 999     {0x32, 0x10}, //D\r
1000     {0x33, 0x0C}, //D\r
1001     {0x34, 0x08}, //D\r
1002     {0x35, 0x04}, //D\r
1003     {0x36, 0x44}, //D\r
1004     {0x37, 0x66}, //D\r
1005     {0x38, 0x00}, //0\r
1006     {0x39, 0x08}, //0\r
1007     {0x3A, 0x08}, //0\r
1008     {0x3B, 0x20}, //0\r
1009     {0x3C, 0x20}, // \r
1010     {0x3D, 0x04}, //N\r
1011     {0x3E, 0x08}, //N\r
1012     {0x3F, 0x10}, //N\r
1013     {0x40, 0x10}, //N\r
1014     {0x41, 0x20}, //N\r
1015     {0x42, 0xFF}, //N\r
1016     {0x43, 0x40},//F0}, //N\r
1017     {0x44, 0x40}, //B\r
1018     {0x45, 0x06},//09}, //S\r
1019     {0x46, 0x40}, //S\r
1020     {0x47, 0x30}, //I\r
1021 \r
1022                 //DPC\r
1023  #if 0                                             \r
1024     //Shading                                 \r
1025     {0x50, 0x24}, //R\r
1026     {0x51, 0x44}, //R\r
1027     {0x52, 0x20}, //R\r
1028     {0x53, 0x30}, //R\r
1029                                               \r
1030     {0x54, 0x20}, //G\r
1031     {0x55, 0x20}, //G\r
1032     {0x56, 0x00}, //G\r
1033     {0x57, 0x10}, //G\r
1034                                               \r
1035     {0x58, 0x20}, //G\r
1036     {0x59, 0x20}, //G\r
1037     {0x5A, 0x00}, //G\r
1038     {0x5B, 0x10}, //G\r
1039                                               \r
1040     {0x5C, 0x34}, //B\r
1041     {0x5D, 0x48}, //B\r
1042     {0x5E, 0x18}, //B\r
1043     {0x5F, 0x2a}, //B\r
1044                                               \r
1045     {0x60, 0x32}, //#\r
1046     {0x61, 0x00}, //#\r
1047     {0x62, 0x67}, //#\r
1048                                               \r
1049     {0x6B, 0x23},    \r
1050     {0x6C, 0x44},    \r
1051     {0x6D, 0x45},    \r
1052     {0x6E, 0x67},    \r
1053     {0x6F, 0x8a},    \r
1054     {0x70, 0x89}, \r
1055     \r
1056     {0x71, 0x34},    \r
1057     {0x72, 0x45},    \r
1058     {0x73, 0x56},    \r
1059     {0x74, 0x77},    \r
1060     {0x75, 0x78},    \r
1061     {0x76, 0x89},    \r
1062 \r
1063         {0x77, 0x34},    \r
1064     {0x78, 0x45},    \r
1065     {0x79, 0x56},    \r
1066     {0x7A, 0x77},    \r
1067     {0x7B, 0x78},    \r
1068     {0x7C, 0x89},    \r
1069 \r
1070         {0x7D, 0x22},    \r
1071     {0x7E, 0x32},    \r
1072     {0x7F, 0x34},    \r
1073     {0x80, 0x45},    \r
1074     {0x81, 0x56},    \r
1075     {0x82, 0x67},    \r
1076     {0x83, 0x1f},    \r
1077     {0x84, 0x50},    \r
1078 #endif\r
1079 \r
1080     //Shading                                 \r
1081     {0x50, 0x0b}, //R\r
1082     {0x51, 0x0b}, //R\r
1083     {0x52, 0x19}, //R\r
1084     {0x53, 0x18}, //R\r
1085                                               \r
1086     {0x54, 0x10}, //G\r
1087     {0x55, 0x00}, //G\r
1088     {0x56, 0x08}, //G\r
1089     {0x57, 0x00}, //G\r
1090                                               \r
1091     {0x58, 0x10}, //G\r
1092     {0x59, 0x00}, //G\r
1093     {0x5A, 0x08}, //G\r
1094     {0x5B, 0x00}, //G\r
1095                                               \r
1096     {0x5C, 0x14}, //B\r
1097     {0x5D, 0x0f}, //B\r
1098     {0x5E, 0x24}, //B\r
1099     {0x5F, 0x12}, //B\r
1100                                               \r
1101     {0x60, 0x32}, //#\r
1102     {0x61, 0x00}, //#\r
1103     {0x62, 0x67}, //#\r
1104                                               \r
1105     {0x6B, 0x23},    \r
1106     {0x6C, 0x44},    \r
1107     {0x6D, 0x44},    \r
1108     {0x6E, 0x45},    \r
1109     {0x6F, 0x44},    \r
1110     {0x70, 0x00}, \r
1111     \r
1112     {0x71, 0x23},    \r
1113     {0x72, 0x44},    \r
1114     {0x73, 0x55},    \r
1115     {0x74, 0x55},    \r
1116     {0x75, 0x55},    \r
1117     {0x76, 0x00},    \r
1118 \r
1119         {0x77, 0x23},    \r
1120     {0x78, 0x44},    \r
1121     {0x79, 0x55},    \r
1122     {0x7A, 0x55},    \r
1123     {0x7B, 0x55},    \r
1124     {0x7C, 0x00},    \r
1125 \r
1126         {0x7D, 0x23},    \r
1127     {0x7E, 0x44},    \r
1128     {0x7F, 0x34},    \r
1129     {0x80, 0x43},    \r
1130     {0x81, 0x44},    \r
1131     {0x82, 0x00},    \r
1132     {0x83, 0x12},    \r
1133     {0x84, 0x14},\r
1134 \r
1135                                               \r
1136     //Interpolation                           \r
1137     {0xA0, 0x2F},    \r
1138     {0xA1, 0xB7},    \r
1139     {0xA2, 0xB7},    \r
1140     {0xA3, 0xB7},    \r
1141     {0xA4, 0x04},    \r
1142     {0xA5, 0xFF},    \r
1143     {0xA6, 0x06},    \r
1144     {0xA7, 0xFF},    \r
1145     {0xA8, 0x00},    \r
1146     {0xA9, 0x00},    \r
1147     {0xAA, 0x00},    \r
1148     {0xAB, 0x00},    \r
1149     {0xAC, 0x60},    \r
1150     {0xAD, 0x18},    \r
1151     {0xAE, 0x0c},    \r
1152     {0xAF, 0x14},    \r
1153     {0xB0, 0x08},    \r
1154     {0xB1, 0x00},    \r
1155 \r
1156 \r
1157     //Color Matrix for D65                    \r
1158     {0xC0, 0xAF},// C\r
1159     {0xC1, 0x66},    \r
1160     {0xC2, 0xd4},    \r
1161     {0xC3, 0x06},    \r
1162     {0xC4, 0xf0},    \r
1163     {0xC5, 0x5a},    \r
1164     {0xC6, 0xF6},    \r
1165     {0xC7, 0xF9},    \r
1166     {0xC8, 0xbf},    \r
1167     {0xC9, 0x88},    \r
1168     {0xCA, 0x00},    \r
1169     {0xCB, 0x00},    \r
1170     {0xCC, 0x00},    \r
1171     {0xCD, 0x00},    \r
1172     {0xCE, 0x00},    \r
1173     //Color Matrix for CWF                    \r
1174     {0xD0, 0x2F},    \r
1175     {0xD1, 0x72},    \r
1176     {0xD2, 0xC9},    \r
1177     {0xD3, 0x04},    \r
1178     {0xD4, 0xE3},    \r
1179     {0xD5, 0x60},    \r
1180     {0xD6, 0xFC},    \r
1181     {0xD7, 0xF5},    \r
1182     {0xD8, 0xb0},    \r
1183     {0xD9, 0x99},    \r
1184     {0xDA, 0xC3},    \r
1185     {0xDB, 0x14},    \r
1186     {0xDC, 0x3A},    \r
1187     {0xDD, 0xAD},    \r
1188     {0xDE, 0x09},    \r
1189                                               \r
1190     //Color Matrix for A                      \r
1191     {0xE0, 0x2F},    \r
1192     {0xE1, 0x5C},    \r
1193     {0xE2, 0xDD},    \r
1194     {0xE3, 0x06},    \r
1195     {0xE4, 0xE0},    \r
1196     {0xE5, 0x69},    \r
1197     {0xE6, 0xF6},    \r
1198     {0xE7, 0xE5},    \r
1199     {0xE8, 0xAB},    \r
1200     {0xE9, 0xAE},    \r
1201     {0xEA, 0x6A},    \r
1202     {0xEB, 0x01},    \r
1203     {0xEC, 0x2D},    \r
1204     {0xED, 0xEE},    \r
1205     {0xEE, 0x04},    \r
1206                                               \r
1207     //IDP 2                                   \r
1208     {0x00, 0x04},    \r
1209                                               \r
1210     //Gamma - R                               \r
1211     {0x10, 0x00},    \r
1212     {0x11, 0x06},    \r
1213     {0x12, 0x0e},    \r
1214     {0x13, 0x20},    \r
1215     {0x14, 0x40},    \r
1216     {0x15, 0x5e},    \r
1217     {0x16, 0x74},    \r
1218     {0x17, 0x87},    \r
1219     {0x18, 0x98},    \r
1220     {0x19, 0xa6},    \r
1221     {0x1A, 0xb3},    \r
1222     {0x1B, 0xca},    \r
1223     {0x1C, 0xde},    \r
1224     {0x1D, 0xf0},    \r
1225     {0x1E, 0xf8},    \r
1226     {0x1F, 0xff},    \r
1227 \r
1228 \r
1229     //Gamma - G                               \r
1230     {0x20, 0x00},    \r
1231     {0x21, 0x06},    \r
1232     {0x22, 0x0e},    \r
1233     {0x23, 0x20},    \r
1234     {0x24, 0x40},    \r
1235     {0x25, 0x5e},    \r
1236     {0x26, 0x74},    \r
1237     {0x27, 0x87},    \r
1238     {0x28, 0x98},    \r
1239     {0x29, 0xa6},    \r
1240     {0x2A, 0xb3},    \r
1241     {0x2B, 0xca},    \r
1242     {0x2C, 0xde},    \r
1243     {0x2D, 0xf0},    \r
1244     {0x2E, 0xf8},    \r
1245     {0x2F, 0xff},    \r
1246                                               \r
1247     //Gamma - B                               \r
1248     {0x30, 0x00},    \r
1249     {0x31, 0x06},    \r
1250     {0x32, 0x0e},    \r
1251     {0x33, 0x20},    \r
1252     {0x34, 0x40},    \r
1253     {0x35, 0x5e},    \r
1254     {0x36, 0x74},    \r
1255     {0x37, 0x87},    \r
1256     {0x38, 0x98},    \r
1257     {0x39, 0xa6},    \r
1258     {0x3A, 0xb3},    \r
1259     {0x3B, 0xca},    \r
1260     {0x3C, 0xde},    \r
1261     {0x3D, 0xf0},    \r
1262     {0x3E, 0xf8},    \r
1263     {0x3F, 0xff},    \r
1264                                               \r
1265     //CSC                                     \r
1266     {0x60, 0x33},    \r
1267     {0x61, 0x20},    \r
1268     {0x62, 0xE4},    \r
1269     {0x63, 0xFA},    \r
1270     {0x64, 0x13},    \r
1271     {0x65, 0x25},    \r
1272     {0x66, 0x07},    \r
1273     {0x67, 0xF5},    \r
1274     {0x68, 0xEA},    \r
1275     {0x69, 0x20},    \r
1276     {0x6A, 0xC8},    \r
1277     {0x6B, 0xC4},    \r
1278     {0x6C, 0x84},    \r
1279     {0x6D, 0x04},    \r
1280     {0x6E, 0x0C},    \r
1281     {0x6F, 0x00},    \r
1282 \r
1283 \r
1284     //Edge                                    \r
1285     {0x80, 0xa2},    \r
1286     {0x81, 0x10},    \r
1287     {0x82, 0x10},    \r
1288     {0x83, 0x04},    \r
1289     {0x84, 0x0a},    \r
1290     {0x85, 0x06},    \r
1291     {0x86, 0x00},    \r
1292     {0x87, 0x04},    \r
1293     {0x88, 0x0a},    \r
1294     {0x89, 0x06},    \r
1295     {0x8a, 0x10},    \r
1296     {0x8b, 0x30},    \r
1297     {0x8c, 0x30},    \r
1298     {0X90, 0x16},    \r
1299     {0x91, 0x03},    \r
1300     {0x93, 0xE0},    \r
1301 \r
1302     //Cr/Cb Coring                            \r
1303     {0x94, 0x00},    \r
1304     {0x95, 0x00},    \r
1305     {0x96, 0x4c},    \r
1306     {0x97, 0x66},    \r
1307     {0x9A, 0xf5},    \r
1308     {0xA1, 0x08},    \r
1309     {0xA2, 0x10},    \r
1310     {0xA3, 0x16},    \r
1311     {0xA4, 0x14},    \r
1312     {0xA5, 0x18},    \r
1313     {0xA6, 0xa0},    \r
1314     {0xA7, 0x06},    \r
1315     {0xA8, 0x40},    \r
1316                                               \r
1317     {0xA9, 0x20},    \r
1318     {0xAA, 0x28},    \r
1319     {0xAc, 0xff},    \r
1320     {0xAd, 0x09},    \r
1321     {0xAe, 0x18},    \r
1322     {0xAf, 0x18},    \r
1323                                               \r
1324     {0xB2, 0x24},    \r
1325     {0xB3, 0x54},    \r
1326     {0xB6, 0x08},    \r
1327                                             \r
1328     //Color Saturation                        \r
1329     {0xBC, 0x10},    \r
1330     {0xBD, 0x10},    \r
1331     {0xBE, 0x10},    \r
1332     {0xBF, 0x10},    \r
1333     {0xc2, 0x12},    \r
1334     {0xc3, 0x12},    \r
1335                                               \r
1336     //IDP 3                                   \r
1337     {0x00, 0x05},    \r
1338                                               \r
1339     //Memory                                  \r
1340     {0x40, 0x15},    \r
1341     {0x41, 0x28},    \r
1342     {0x42, 0x04},    \r
1343     {0x43, 0x15},    \r
1344     {0x44, 0x28},    \r
1345     {0x45, 0x04},    \r
1346     {0x46, 0x15},    \r
1347     {0x47, 0x28},    \r
1348     {0x48, 0x04},    \r
1349                                               \r
1350     //Knee                                    \r
1351     {0x90, 0x00}, // \r
1352     {0x91, 0x00}, //k\r
1353     {0x92, 0x00}, //k\r
1354     {0x93, 0x00}, //K\r
1355     {0x94, 0x00}, //[\r
1356     {0x95, 0x00}, //k\r
1357     {0x96, 0x00}, //k\r
1358                                               \r
1359     //ADG                                     \r
1360     #if 0                                     \r
1361     {0x99, 0xC0},    \r
1362     {0xA0, 0x10},    \r
1363     {0xA1, 0x22},    \r
1364     {0xA2, 0x36},    \r
1365     {0xA3, 0x49},    \r
1366     {0xA4, 0x5D},    \r
1367     {0xA5, 0x70},    \r
1368     {0xA6, 0x82},    \r
1369     {0xA7, 0x94},    \r
1370     {0xA8, 0xA5},    \r
1371     {0xA9, 0xB5},    \r
1372     {0xAA, 0xC3},    \r
1373     {0xAB, 0xD1},    \r
1374     {0xAC, 0xDE},    \r
1375     {0xAD, 0xEA},    \r
1376     {0xAE, 0xF5},    \r
1377     {0xAF, 0xFF},    \r
1378     //YXGMA                                   \r
1379     {0xB0, 0xc0}, //Y\r
1380     {0xB1, 0x04}, //Y\r
1381     {0xB8, 0x0f}, //D\r
1382     {0xB9, 0x10}, //D\r
1383     //{0xBA, 0x38}, /\r
1384     //{0xBB, 0x39}, /\r
1385     {0xC0, 0x03},    \r
1386     {0xC1, 0x0E},    \r
1387     {0xC2, 0x16},    \r
1388     {0xC3, 0x24},    \r
1389     {0xC4, 0x3F},    \r
1390     {0xC5, 0x56},    \r
1391     {0xC6, 0x6A},    \r
1392     {0xC7, 0x7C},    \r
1393     {0xC8, 0x8C},    \r
1394     {0xC9, 0x98},    \r
1395     {0xCA, 0xA2},    \r
1396     {0xCB, 0xB8},    \r
1397     {0xCC, 0xCD},    \r
1398     {0xCD, 0xE2},    \r
1399     {0xCE, 0xF0},    \r
1400     {0xCF, 0xFF},    \r
1401    #else                                      \r
1402     {0x99, 0x00},    \r
1403     {0xA0, 0x00},    \r
1404     {0xA1, 0x00},    \r
1405     {0xA2, 0x00},    \r
1406     {0xA3, 0x00},    \r
1407     {0xA4, 0x00},    \r
1408     {0xA5, 0x00},    \r
1409     {0xA6, 0x00},    \r
1410     {0xA7, 0x00},    \r
1411     {0xA8, 0x00},    \r
1412     {0xA9, 0x00},    \r
1413     {0xAA, 0x00},    \r
1414     {0xAB, 0x00},    \r
1415     {0xAC, 0x00},    \r
1416     {0xAD, 0x00},    \r
1417     {0xAE, 0x00},    \r
1418     {0xAF, 0x00},    \r
1419                                               \r
1420     //YXGMA                                   \r
1421     {0xB0, 0x00}, //Y\r
1422     {0xB1, 0x00}, //Y\r
1423     {0xB8, 0x00}, //D\r
1424     {0xB9, 0x00}, //D\r
1425     //{0xBA, 0x38}, /\r
1426     //{0xBB, 0x39}, /\r
1427     {0xC0, 0x00},    \r
1428     {0xC1, 0x00},    \r
1429     {0xC2, 0x00},    \r
1430     {0xC3, 0x00},    \r
1431     {0xC4, 0x00},    \r
1432     {0xC5, 0x00},    \r
1433     {0xC6, 0x00},    \r
1434     {0xC7, 0x00},    \r
1435     {0xC8, 0x00},    \r
1436     {0xC9, 0x00},    \r
1437     {0xCA, 0x00},    \r
1438     {0xCB, 0x00},    \r
1439     {0xCC, 0x00},    \r
1440     {0xCD, 0x00},    \r
1441     {0xCE, 0x00},    \r
1442     {0xCF, 0x00},    \r
1443     {0xe0, 0x01},    \r
1444     {0xe1, 0x03},    \r
1445     {0xe2, 0x04},    \r
1446     {0xe3, 0x0c},    \r
1447     {0xe4, 0x11},    \r
1448     {0xe5, 0x16},    \r
1449     {0xe6, 0x1b},    \r
1450     {0xe7, 0x24},    \r
1451     {0xe8, 0x30},    \r
1452   #endif                                      \r
1453     //Sensor on                               \r
1454         {0x00,  0x00}, \r
1455         {0x03,  0xc5}, \r
1456         {0x00,  0x01}, \r
1457         {0x10,  0x84}, \r
1458         {0x00,  0x02}, \r
1459         {0x10,  0xd3}, \r
1460         {0xff,  0xff},                            \r
1461   \r
1462 \r
1463 #endif\r
1464 };\r
1465 \r
1466 /* 1600X1200 UXGA */\r
1467 static struct reginfo sensor_uxga[] =\r
1468 {\r
1469    {0x00,0x00},\r
1470    {0x04,0x10},\r
1471    {0x05,0x8f},\r
1472    {0x00,0x03},\r
1473    {0x94,0x06},\r
1474    {0x95,0x40},\r
1475    {0x96,0x04},\r
1476    {0x97,0xb0}, \r
1477    {0xff, 0xff},\r
1478 };\r
1479 \r
1480 /* 1280X1024 SXGA */\r
1481 static struct reginfo sensor_sxga[] =\r
1482 {\r
1483        {0x00,0x00},\r
1484        {0x04,0x10},\r
1485        {0x05,0x8b},\r
1486         {0x00,0x03},\r
1487         {0x94,0x05},\r
1488         {0x95,0x00},\r
1489         {0x96,0x04},\r
1490         {0x97,0x00}, \r
1491         {0xff, 0xff}, \r
1492 };\r
1493 static struct reginfo sensor_xga[] =\r
1494 {\r
1495         {0xff, 0xff}\r
1496 };\r
1497 /* 800X600 SVGA*/\r
1498 static struct reginfo sensor_svga[] =\r
1499 {\r
1500     {0x00,0x03},\r
1501     {0x94,0x03},\r
1502     {0x95,0x20},\r
1503     {0x96,0x02},\r
1504     {0x97,0x58}, \r
1505     {0xff, 0xff}\r
1506 };\r
1507 \r
1508 /* 640X480 VGA */\r
1509 static struct reginfo sensor_vga[] =\r
1510 {\r
1511       {0x00,0x00},\r
1512       {0x04,0x00},\r
1513       {0x05,0x0f},\r
1514       {0x00,0x03},\r
1515       {0x94,0x02}, //0x02\r
1516       {0x95,0x80}, //0x80\r
1517       {0x96,0x01},//0x01\r
1518       {0x97,0xe0}, //0xe0\r
1519       {0xff, 0xff}, \r
1520 };\r
1521 \r
1522 /* 352X288 CIF */\r
1523 static struct reginfo sensor_cif[] =\r
1524 {\r
1525     {0x00,0x03},\r
1526     {0x94,0x01},\r
1527     {0x95,0x60},\r
1528     {0x96,0x01},\r
1529     {0x97,0x20}, \r
1530     {0xff, 0xff}, \r
1531 };\r
1532 \r
1533 /* 320*240 QVGA */\r
1534 static  struct reginfo sensor_qvga[] =\r
1535 {\r
1536        {0x00,0x03},\r
1537        {0x94,0x01},\r
1538        {0x95,0x40},\r
1539        {0x96,0x00},\r
1540        {0x97,0xf0}, \r
1541        {0xff, 0xff}, \r
1542 };\r
1543 \r
1544 /* 176X144 QCIF*/\r
1545 static struct reginfo sensor_qcif[] =\r
1546 {\r
1547        {0x00,0x03},\r
1548        {0x94,0x00},\r
1549        {0x95,0xB0},\r
1550        {0x96,0x00},\r
1551        {0x97,0x90}, \r
1552        {0xff, 0xff},\r
1553 };\r
1554 #endif\r
1555 static  struct reginfo sensor_ClrFmt_YUYV[]=\r
1556 {\r
1557     {0xff, 0xff}\r
1558 };\r
1559 \r
1560 static  struct reginfo sensor_ClrFmt_UYVY[]=\r
1561 {\r
1562     {0xff, 0xff}\r
1563 };\r
1564 \r
1565 #if CONFIG_SENSOR_WhiteBalance\r
1566 static  struct reginfo sensor_WhiteB_Auto[]={\r
1567     {0x00, 0x02},\r
1568     {0x10, 0xd3},\r
1569     {0xff, 0xff}\r
1570 };\r
1571 /* Cloudy Colour Temperature : 6500K - 8000K  */\r
1572 static  struct reginfo sensor_WhiteB_Cloudy[]=\r
1573 {\r
1574     {0x00, 0x02},\r
1575     {0x10, 0x00},\r
1576     {0x50, 0xd0},\r
1577     {0x51, 0x88},\r
1578     {0xff, 0xff}\r
1579 };\r
1580 /* ClearDay Colour Temperature : 5000K - 6500K  */\r
1581 static  struct reginfo sensor_WhiteB_ClearDay[]=\r
1582 {\r
1583     {0x00, 0x02},\r
1584     {0x10, 0x00},\r
1585     {0x50, 0xaa},\r
1586     {0x51, 0x90},\r
1587     {0xff, 0xff}\r
1588 \r
1589 };\r
1590 /* Office Colour Temperature : 3500K - 5000K  */\r
1591 static  struct reginfo sensor_WhiteB_TungstenLamp1[]=\r
1592 {\r
1593     {0x00, 0x02},\r
1594     {0x10, 0x00},\r
1595     {0x50, 0xc2},\r
1596     {0x51, 0x9e},\r
1597     {0xff, 0xff}\r
1598 };\r
1599 /* Home Colour Temperature : 2500K - 3500K  */\r
1600 static  struct reginfo sensor_WhiteB_TungstenLamp2[]=\r
1601 {\r
1602     {0x00, 0x02},\r
1603     {0x10, 0x00},\r
1604     {0x50, 0xaa},\r
1605     {0x51, 0xbe},\r
1606     {0xff, 0xff}\r
1607 };\r
1608 static struct reginfo *sensor_WhiteBalanceSeqe[] = {sensor_WhiteB_Auto, sensor_WhiteB_TungstenLamp1,sensor_WhiteB_TungstenLamp2,\r
1609     sensor_WhiteB_ClearDay, sensor_WhiteB_Cloudy,NULL,\r
1610 };\r
1611 #endif\r
1612 \r
1613 #if CONFIG_SENSOR_Brightness\r
1614 static  struct reginfo sensor_Brightness0[]=\r
1615 {\r
1616     // Brightness -2\r
1617     {0x00, 0x04},\r
1618     {0xb6, 0xa0},\r
1619     {0xff, 0xff}\r
1620 \r
1621 };\r
1622 \r
1623 static  struct reginfo sensor_Brightness1[]=\r
1624 {\r
1625     // Brightness -1\r
1626     {0x00, 0x04},\r
1627     {0xb6, 0x90},\r
1628     {0xff, 0xff}\r
1629 \r
1630 };\r
1631 \r
1632 static  struct reginfo sensor_Brightness2[]=\r
1633 {\r
1634     //  Brightness 0\r
1635     {0x00, 0x04},\r
1636     {0xb6, 0x00},\r
1637     {0xff, 0xff}\r
1638 \r
1639 };\r
1640 \r
1641 static  struct reginfo sensor_Brightness3[]=\r
1642 {\r
1643     // Brightness +1\r
1644    {0x00, 0x04},\r
1645    {0xb6, 0x10},\r
1646    {0xff, 0xff}\r
1647 \r
1648 };\r
1649 \r
1650 static  struct reginfo sensor_Brightness4[]=\r
1651 {\r
1652     //  Brightness +2\r
1653    {0x00, 0x04},\r
1654    {0xb6, 0x20},\r
1655    {0xff, 0xff}\r
1656 \r
1657 };\r
1658 \r
1659 static  struct reginfo sensor_Brightness5[]=\r
1660 {\r
1661    {0x00, 0x04},\r
1662    {0xb6, 0x30},\r
1663    {0xff, 0xff}\r
1664 };\r
1665 static struct reginfo *sensor_BrightnessSeqe[] = {sensor_Brightness0, sensor_Brightness1, sensor_Brightness2, sensor_Brightness3,\r
1666     sensor_Brightness4, sensor_Brightness5,NULL,\r
1667 };\r
1668 \r
1669 #endif\r
1670 \r
1671 #if CONFIG_SENSOR_Effect\r
1672 static  struct reginfo sensor_Effect_Normal[] =\r
1673 {\r
1674     {0x00, 0x04},\r
1675     {0xd9, 0x00},\r
1676     {0xff, 0xff}\r
1677 };\r
1678 \r
1679 static  struct reginfo sensor_Effect_WandB[] =\r
1680 {\r
1681     {0x00, 0x04},\r
1682     {0xd9, 0x40},\r
1683     {0x00, 0x00},\r
1684     {0xff, 0xff}\r
1685 };\r
1686 \r
1687 static  struct reginfo sensor_Effect_Sepia[] =\r
1688 {\r
1689     {0x00, 0x04},\r
1690     {0xd9, 0x80},\r
1691     {0xda, 0x60},\r
1692     {0xdb, 0xa0},\r
1693     {0xff, 0xff}\r
1694 };\r
1695 \r
1696 static  struct reginfo sensor_Effect_Negative[] =\r
1697 {\r
1698    {0x00, 0x04},\r
1699    {0xd9, 0x20},\r
1700    {0xff, 0xff}\r
1701 };\r
1702 static  struct reginfo sensor_Effect_Bluish[] =\r
1703 {\r
1704     // Bluish\r
1705     {0x00, 0x04},\r
1706     {0xd9, 0x80},\r
1707     {0xda, 0xc0},\r
1708     {0xdb, 0x60},\r
1709     {0xff, 0xff}\r
1710 };\r
1711 \r
1712 static  struct reginfo sensor_Effect_Green[] =\r
1713 {\r
1714     //  Greenish\r
1715     {0x00, 0x04},\r
1716     {0xd9, 0x80},\r
1717     {0xda, 0x50},\r
1718     {0xdb, 0x50},\r
1719     {0xff, 0xff}\r
1720 };\r
1721 static struct reginfo *sensor_EffectSeqe[] = {sensor_Effect_Normal, sensor_Effect_WandB, sensor_Effect_Negative,sensor_Effect_Sepia,\r
1722     sensor_Effect_Bluish, sensor_Effect_Green,NULL,\r
1723 };\r
1724 #endif\r
1725 #if CONFIG_SENSOR_Exposure\r
1726 static  struct reginfo sensor_Exposure0[]=\r
1727 {\r
1728     //-3\r
1729    {0xff, 0xff}\r
1730 };\r
1731 \r
1732 static  struct reginfo sensor_Exposure1[]=\r
1733 {\r
1734     //-2\r
1735     {0xff, 0xff}\r
1736 };\r
1737 \r
1738 static  struct reginfo sensor_Exposure2[]=\r
1739 {\r
1740     //-0.3EV\r
1741    {0xff, 0xff}\r
1742 };\r
1743 \r
1744 static  struct reginfo sensor_Exposure3[]=\r
1745 {\r
1746     //default\r
1747   {0xff, 0xff}\r
1748 };\r
1749 \r
1750 static  struct reginfo sensor_Exposure4[]=\r
1751 {\r
1752     // 1\r
1753   {0xff, 0xff}\r
1754 };\r
1755 \r
1756 static  struct reginfo sensor_Exposure5[]=\r
1757 {\r
1758     // 2\r
1759   {0xff, 0xff}\r
1760 };\r
1761 \r
1762 static  struct reginfo sensor_Exposure6[]=\r
1763 {\r
1764     // 3\r
1765    {0xff, 0xff}\r
1766 };\r
1767 \r
1768 static struct reginfo *sensor_ExposureSeqe[] = {sensor_Exposure0, sensor_Exposure1, sensor_Exposure2, sensor_Exposure3,\r
1769     sensor_Exposure4, sensor_Exposure5,sensor_Exposure6,NULL,\r
1770 };\r
1771 #endif\r
1772 #if CONFIG_SENSOR_Saturation\r
1773 static  struct reginfo sensor_Saturation0[]=\r
1774 {\r
1775     {0xff, 0xff}\r
1776 };\r
1777 \r
1778 static  struct reginfo sensor_Saturation1[]=\r
1779 {\r
1780    {0xff, 0xff}\r
1781 };\r
1782 \r
1783 static  struct reginfo sensor_Saturation2[]=\r
1784 {\r
1785   {0xff, 0xff}\r
1786 };\r
1787 static struct reginfo *sensor_SaturationSeqe[] = {sensor_Saturation0, sensor_Saturation1, sensor_Saturation2, NULL,};\r
1788 \r
1789 #endif\r
1790 #if CONFIG_SENSOR_Contrast\r
1791 static  struct reginfo sensor_Contrast0[]=\r
1792 {\r
1793     {0xff, 0xff}\r
1794 };\r
1795 \r
1796 static  struct reginfo sensor_Contrast1[]=\r
1797 {\r
1798    {0xff, 0xff}\r
1799 };\r
1800 \r
1801 static  struct reginfo sensor_Contrast2[]=\r
1802 {\r
1803     {0xff, 0xff}\r
1804 };\r
1805 \r
1806 static  struct reginfo sensor_Contrast3[]=\r
1807 {\r
1808     {0xff, 0xff}\r
1809 };\r
1810 \r
1811 static  struct reginfo sensor_Contrast4[]=\r
1812 {\r
1813    {0xff, 0xff}\r
1814 };\r
1815 \r
1816 \r
1817 static  struct reginfo sensor_Contrast5[]=\r
1818 {\r
1819     {0xff, 0xff}\r
1820 };\r
1821 \r
1822 static  struct reginfo sensor_Contrast6[]=\r
1823 {\r
1824     {0xff, 0xff}\r
1825 };\r
1826 static struct reginfo *sensor_ContrastSeqe[] = {sensor_Contrast0, sensor_Contrast1, sensor_Contrast2, sensor_Contrast3,\r
1827     sensor_Contrast4, sensor_Contrast5, sensor_Contrast6, NULL,\r
1828 };\r
1829 \r
1830 #endif\r
1831 #if CONFIG_SENSOR_Mirror\r
1832 static  struct reginfo sensor_MirrorOn[]=\r
1833 {\r
1834     {0xff, 0xff}\r
1835 };\r
1836 \r
1837 static  struct reginfo sensor_MirrorOff[]=\r
1838 {\r
1839      {0xff, 0xff}\r
1840 };\r
1841 static struct reginfo *sensor_MirrorSeqe[] = {sensor_MirrorOff, sensor_MirrorOn,NULL,};\r
1842 #endif\r
1843 #if CONFIG_SENSOR_Flip\r
1844 static  struct reginfo sensor_FlipOn[]=\r
1845 {\r
1846     {0xff, 0xff}\r
1847 };\r
1848 \r
1849 static  struct reginfo sensor_FlipOff[]=\r
1850 {\r
1851      {0xff, 0xff}\r
1852 };\r
1853 static struct reginfo *sensor_FlipSeqe[] = {sensor_FlipOff, sensor_FlipOn,NULL,};\r
1854 \r
1855 #endif\r
1856 #if CONFIG_SENSOR_Scene\r
1857 static  struct reginfo sensor_SceneAuto[] =\r
1858 {\r
1859    {0x00, 0x01},\r
1860    {0x11, 0x0a},\r
1861    {0x00, 0x04},\r
1862    {0xb6, 0x00},\r
1863    {0xff, 0xff}\r
1864 };\r
1865 \r
1866 static  struct reginfo sensor_SceneNight[] =\r
1867 {\r
1868    {0x00, 0x01},\r
1869    {0x11, 0x14},\r
1870    {0x00, 0x04},\r
1871    {0xb6, 0x10},\r
1872    {0xff, 0xff}\r
1873 };\r
1874 static struct reginfo *sensor_SceneSeqe[] = {sensor_SceneAuto, sensor_SceneNight,NULL,};\r
1875 \r
1876 #endif\r
1877 #if CONFIG_SENSOR_DigitalZoom\r
1878 static struct reginfo sensor_Zoom0[] =\r
1879 {\r
1880     {0xff, 0xff}\r
1881 };\r
1882 \r
1883 static struct reginfo sensor_Zoom1[] =\r
1884 {\r
1885      {0xff, 0xff}\r
1886 };\r
1887 \r
1888 static struct reginfo sensor_Zoom2[] =\r
1889 {\r
1890     {0xff, 0xff}\r
1891 };\r
1892 \r
1893 \r
1894 static struct reginfo sensor_Zoom3[] =\r
1895 {\r
1896     {0xff, 0xff}\r
1897 };\r
1898 static struct reginfo *sensor_ZoomSeqe[] = {sensor_Zoom0, sensor_Zoom1, sensor_Zoom2, sensor_Zoom3, NULL,};\r
1899 #endif\r
1900 static  struct v4l2_querymenu sensor_menus[] =\r
1901 {\r
1902         #if CONFIG_SENSOR_WhiteBalance\r
1903     { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 0,  .name = "auto",  .reserved = 0, }, {  .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 1, .name = "incandescent",  .reserved = 0,},\r
1904     { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 2,  .name = "fluorescent", .reserved = 0,}, {  .id = V4L2_CID_DO_WHITE_BALANCE, .index = 3,  .name = "daylight", .reserved = 0,},\r
1905     { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 4,  .name = "cloudy-daylight", .reserved = 0,},\r
1906     #endif\r
1907 \r
1908         #if CONFIG_SENSOR_Effect\r
1909     { .id = V4L2_CID_EFFECT,  .index = 0,  .name = "none",  .reserved = 0, }, {  .id = V4L2_CID_EFFECT,  .index = 1, .name = "mono",  .reserved = 0,},\r
1910     { .id = V4L2_CID_EFFECT,  .index = 2,  .name = "negative", .reserved = 0,}, {  .id = V4L2_CID_EFFECT, .index = 3,  .name = "sepia", .reserved = 0,},\r
1911     { .id = V4L2_CID_EFFECT,  .index = 4, .name = "posterize", .reserved = 0,} ,{ .id = V4L2_CID_EFFECT,  .index = 5,  .name = "aqua", .reserved = 0,},\r
1912     #endif\r
1913 \r
1914         #if CONFIG_SENSOR_Scene\r
1915     { .id = V4L2_CID_SCENE,  .index = 0, .name = "auto", .reserved = 0,} ,{ .id = V4L2_CID_SCENE,  .index = 1,  .name = "night", .reserved = 0,},\r
1916     #endif\r
1917 \r
1918         #if CONFIG_SENSOR_Flash\r
1919     { .id = V4L2_CID_FLASH,  .index = 0,  .name = "off",  .reserved = 0, }, {  .id = V4L2_CID_FLASH,  .index = 1, .name = "auto",  .reserved = 0,},\r
1920     { .id = V4L2_CID_FLASH,  .index = 2,  .name = "on", .reserved = 0,}, {  .id = V4L2_CID_FLASH, .index = 3,  .name = "torch", .reserved = 0,},\r
1921     #endif\r
1922 };\r
1923 \r
1924 static  struct v4l2_queryctrl sensor_controls[] =\r
1925 {\r
1926         #if CONFIG_SENSOR_WhiteBalance\r
1927     {\r
1928         .id             = V4L2_CID_DO_WHITE_BALANCE,\r
1929         .type           = V4L2_CTRL_TYPE_MENU,\r
1930         .name           = "White Balance Control",\r
1931         .minimum        = 0,\r
1932         .maximum        = 4,\r
1933         .step           = 1,\r
1934         .default_value = 0,\r
1935     },\r
1936     #endif\r
1937 \r
1938         #if CONFIG_SENSOR_Brightness\r
1939         {\r
1940         .id             = V4L2_CID_BRIGHTNESS,\r
1941         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1942         .name           = "Brightness Control",\r
1943         .minimum        = -3,\r
1944         .maximum        = 2,\r
1945         .step           = 1,\r
1946         .default_value = 0,\r
1947     },\r
1948     #endif\r
1949 \r
1950         #if CONFIG_SENSOR_Effect\r
1951         {\r
1952         .id             = V4L2_CID_EFFECT,\r
1953         .type           = V4L2_CTRL_TYPE_MENU,\r
1954         .name           = "Effect Control",\r
1955         .minimum        = 0,\r
1956         .maximum        = 5,\r
1957         .step           = 1,\r
1958         .default_value = 0,\r
1959     },\r
1960         #endif\r
1961 \r
1962         #if CONFIG_SENSOR_Exposure\r
1963         {\r
1964         .id             = V4L2_CID_EXPOSURE,\r
1965         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1966         .name           = "Exposure Control",\r
1967         .minimum        = 0,\r
1968         .maximum        = 6,\r
1969         .step           = 1,\r
1970         .default_value = 0,\r
1971     },\r
1972         #endif\r
1973 \r
1974         #if CONFIG_SENSOR_Saturation\r
1975         {\r
1976         .id             = V4L2_CID_SATURATION,\r
1977         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1978         .name           = "Saturation Control",\r
1979         .minimum        = 0,\r
1980         .maximum        = 2,\r
1981         .step           = 1,\r
1982         .default_value = 0,\r
1983     },\r
1984     #endif\r
1985 \r
1986         #if CONFIG_SENSOR_Contrast\r
1987         {\r
1988         .id             = V4L2_CID_CONTRAST,\r
1989         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1990         .name           = "Contrast Control",\r
1991         .minimum        = -3,\r
1992         .maximum        = 3,\r
1993         .step           = 1,\r
1994         .default_value = 0,\r
1995     },\r
1996         #endif\r
1997 \r
1998         #if CONFIG_SENSOR_Mirror\r
1999         {\r
2000         .id             = V4L2_CID_HFLIP,\r
2001         .type           = V4L2_CTRL_TYPE_BOOLEAN,\r
2002         .name           = "Mirror Control",\r
2003         .minimum        = 0,\r
2004         .maximum        = 1,\r
2005         .step           = 1,\r
2006         .default_value = 1,\r
2007     },\r
2008     #endif\r
2009 \r
2010         #if CONFIG_SENSOR_Flip\r
2011         {\r
2012         .id             = V4L2_CID_VFLIP,\r
2013         .type           = V4L2_CTRL_TYPE_BOOLEAN,\r
2014         .name           = "Flip Control",\r
2015         .minimum        = 0,\r
2016         .maximum        = 1,\r
2017         .step           = 1,\r
2018         .default_value = 1,\r
2019     },\r
2020     #endif\r
2021 \r
2022         #if CONFIG_SENSOR_Scene\r
2023     {\r
2024         .id             = V4L2_CID_SCENE,\r
2025         .type           = V4L2_CTRL_TYPE_MENU,\r
2026         .name           = "Scene Control",\r
2027         .minimum        = 0,\r
2028         .maximum        = 1,\r
2029         .step           = 1,\r
2030         .default_value = 0,\r
2031     },\r
2032     #endif\r
2033 \r
2034         #if CONFIG_SENSOR_DigitalZoom\r
2035     {\r
2036         .id             = V4L2_CID_ZOOM_RELATIVE,\r
2037         .type           = V4L2_CTRL_TYPE_INTEGER,\r
2038         .name           = "DigitalZoom Control",\r
2039         .minimum        = -1,\r
2040         .maximum        = 1,\r
2041         .step           = 1,\r
2042         .default_value = 0,\r
2043     }, {\r
2044         .id             = V4L2_CID_ZOOM_ABSOLUTE,\r
2045         .type           = V4L2_CTRL_TYPE_INTEGER,\r
2046         .name           = "DigitalZoom Control",\r
2047         .minimum        = 0,\r
2048         .maximum        = 3,\r
2049         .step           = 1,\r
2050         .default_value = 0,\r
2051     },\r
2052     #endif\r
2053 \r
2054         #if CONFIG_SENSOR_Focus\r
2055         {\r
2056         .id             = V4L2_CID_FOCUS_RELATIVE,\r
2057         .type           = V4L2_CTRL_TYPE_INTEGER,\r
2058         .name           = "Focus Control",\r
2059         .minimum        = -1,\r
2060         .maximum        = 1,\r
2061         .step           = 1,\r
2062         .default_value = 0,\r
2063     }, {\r
2064         .id             = V4L2_CID_FOCUS_ABSOLUTE,\r
2065         .type           = V4L2_CTRL_TYPE_INTEGER,\r
2066         .name           = "Focus Control",\r
2067         .minimum        = 0,\r
2068         .maximum        = 255,\r
2069         .step           = 1,\r
2070         .default_value = 125,\r
2071     },\r
2072     #endif\r
2073 \r
2074         #if CONFIG_SENSOR_Flash\r
2075         {\r
2076         .id             = V4L2_CID_FLASH,\r
2077         .type           = V4L2_CTRL_TYPE_MENU,\r
2078         .name           = "Flash Control",\r
2079         .minimum        = 0,\r
2080         .maximum        = 3,\r
2081         .step           = 1,\r
2082         .default_value = 0,\r
2083     },\r
2084         #endif\r
2085 };\r
2086 \r
2087 static int sensor_probe(struct i2c_client *client, const struct i2c_device_id *did);\r
2088 static int sensor_video_probe(struct soc_camera_device *icd, struct i2c_client *client);\r
2089 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);\r
2090 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);\r
2091 static int sensor_g_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);\r
2092 static int sensor_s_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);\r
2093 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg);\r
2094 static int sensor_resume(struct soc_camera_device *icd);\r
2095 static int sensor_set_bus_param(struct soc_camera_device *icd,unsigned long flags);\r
2096 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd);\r
2097 #if CONFIG_SENSOR_Effect\r
2098 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);\r
2099 #endif\r
2100 #if CONFIG_SENSOR_WhiteBalance\r
2101 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);\r
2102 #endif\r
2103 static int sensor_deactivate(struct i2c_client *client);\r
2104 \r
2105 static struct soc_camera_ops sensor_ops =\r
2106 {\r
2107     .suspend                     = sensor_suspend,\r
2108     .resume                       = sensor_resume,\r
2109     .set_bus_param              = sensor_set_bus_param,\r
2110     .query_bus_param    = sensor_query_bus_param,\r
2111     .controls           = sensor_controls,\r
2112     .menus                         = sensor_menus,\r
2113     .num_controls               = ARRAY_SIZE(sensor_controls),\r
2114     .num_menus          = ARRAY_SIZE(sensor_menus),\r
2115 };\r
2116 \r
2117 /* only one fixed colorspace per pixelcode */\r
2118 struct sensor_datafmt {\r
2119         enum v4l2_mbus_pixelcode code;\r
2120         enum v4l2_colorspace colorspace;\r
2121 };\r
2122 \r
2123 /* Find a data format by a pixel code in an array */\r
2124 static const struct sensor_datafmt *sensor_find_datafmt(\r
2125         enum v4l2_mbus_pixelcode code, const struct sensor_datafmt *fmt,\r
2126         int n)\r
2127 {\r
2128         int i;\r
2129         for (i = 0; i < n; i++)\r
2130                 if (fmt[i].code == code)\r
2131                         return fmt + i;\r
2132 \r
2133         return NULL;\r
2134 }\r
2135 \r
2136 static const struct sensor_datafmt sensor_colour_fmts[] = {\r
2137     {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG},\r
2138     {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG}     \r
2139 };\r
2140 \r
2141 typedef struct sensor_info_priv_s\r
2142 {\r
2143     int whiteBalance;\r
2144     int brightness;\r
2145     int contrast;\r
2146     int saturation;\r
2147     int effect;\r
2148     int scene;\r
2149     int digitalzoom;\r
2150     int focus;\r
2151     int flash;\r
2152     int exposure;\r
2153         bool snap2preview;\r
2154         bool video2preview;\r
2155     unsigned char mirror;                                        /* HFLIP */\r
2156     unsigned char flip;                                          /* VFLIP */\r
2157     unsigned int winseqe_cur_addr;\r
2158         struct sensor_datafmt fmt;\r
2159     unsigned int funmodule_state;\r
2160 } sensor_info_priv_t;\r
2161 \r
2162 struct sensor\r
2163 {\r
2164     struct v4l2_subdev subdev;\r
2165     struct i2c_client *client;\r
2166     sensor_info_priv_t info_priv;\r
2167     int model;  /* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */\r
2168 #if CONFIG_SENSOR_I2C_NOSCHED\r
2169         atomic_t tasklock_cnt;\r
2170 #endif\r
2171         struct rk29camera_platform_data *sensor_io_request;\r
2172     struct rk29camera_gpio_res *sensor_gpio_res;\r
2173 };\r
2174 \r
2175 static struct sensor* to_sensor(const struct i2c_client *client)\r
2176 {\r
2177     return container_of(i2c_get_clientdata(client), struct sensor, subdev);\r
2178 }\r
2179 \r
2180 static int sensor_task_lock(struct i2c_client *client, int lock)\r
2181 {\r
2182 #if CONFIG_SENSOR_I2C_NOSCHED\r
2183         int cnt = 3;\r
2184     struct sensor *sensor = to_sensor(client);\r
2185 \r
2186         if (lock) {\r
2187                 if (atomic_read(&sensor->tasklock_cnt) == 0) {\r
2188                         while ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt>0)) {\r
2189                                 SENSOR_TR("\n %s will obtain i2c in atomic, but i2c bus is locked! Wait...\n",SENSOR_NAME_STRING());\r
2190                                 msleep(35);\r
2191                                 cnt--;\r
2192                         }\r
2193                         if ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt<=0)) {\r
2194                                 SENSOR_TR("\n %s obtain i2c fail in atomic!!\n",SENSOR_NAME_STRING());\r
2195                                 goto sensor_task_lock_err;\r
2196                         }\r
2197                         preempt_disable();\r
2198                 }\r
2199 \r
2200                 atomic_add(1, &sensor->tasklock_cnt);\r
2201         } else {\r
2202                 if (atomic_read(&sensor->tasklock_cnt) > 0) {\r
2203                         atomic_sub(1, &sensor->tasklock_cnt);\r
2204 \r
2205                         if (atomic_read(&sensor->tasklock_cnt) == 0)\r
2206                                 preempt_enable();\r
2207                 }\r
2208         }\r
2209         return 0;\r
2210 sensor_task_lock_err:\r
2211         return -1;  \r
2212 #else\r
2213     return 0;\r
2214 #endif\r
2215 \r
2216 }\r
2217 \r
2218 /* sensor register write */\r
2219 static int sensor_write(struct i2c_client *client, u8 reg, u8 val)\r
2220 {\r
2221     int err,cnt;\r
2222     u8 buf[2];\r
2223     struct i2c_msg msg[1];\r
2224 \r
2225     //buf[0] = reg >> 8;\r
2226     buf[0] = reg & 0xFF;\r
2227     buf[1] = val;\r
2228         //printk("%s----%d-----\n",__func__,__LINE__);\r
2229 \r
2230     msg->addr = client->addr;\r
2231     msg->flags = client->flags;\r
2232     msg->buf = buf;\r
2233     msg->len = sizeof(buf);\r
2234     msg->scl_rate = CONFIG_SENSOR_I2C_SPEED;         /* ddl@rock-chips.com : 100kHz */\r
2235     msg->read_type = 0;               /* fpga i2c:0==I2C_NORMAL : direct use number not enum for don't want include spi_fpga.h */\r
2236 \r
2237     cnt = 3;\r
2238     err = -EAGAIN;\r
2239 \r
2240     while ((cnt-- > 0) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */\r
2241         err = i2c_transfer(client->adapter, msg, 1);\r
2242 \r
2243         if (err >= 0) {\r
2244             return 0;\r
2245         } else {\r
2246             SENSOR_TR("\n %s write reg(0x%x, val:0x%x) failed, try to write again!\n",SENSOR_NAME_STRING(),reg, val);\r
2247             udelay(10);\r
2248         }\r
2249     }\r
2250 \r
2251     return err;\r
2252 }\r
2253 #if 0\r
2254 /* sensor register read */\r
2255 static int sensor_read(struct i2c_client *client, u8 reg, u8 *val)\r
2256 {\r
2257     int err,cnt;\r
2258     u8 buf[1];\r
2259     struct i2c_msg msg[2];\r
2260 \r
2261    // buf[0] = reg >> 8;\r
2262     buf[0] = reg & 0xFF;\r
2263 \r
2264     msg[0].addr = client->addr;\r
2265     msg[0].flags = client->flags;\r
2266     msg[0].buf = buf;\r
2267     msg[0].len = sizeof(buf);\r
2268     msg[0].scl_rate = CONFIG_SENSOR_I2C_SPEED;       /* ddl@rock-chips.com : 100kHz */\r
2269     msg[0].read_type = 2;   /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */\r
2270 \r
2271     msg[1].addr = client->addr;\r
2272     msg[1].flags = client->flags|I2C_M_RD;\r
2273     msg[1].buf = buf;\r
2274     msg[1].len = 1;\r
2275     msg[1].scl_rate = CONFIG_SENSOR_I2C_SPEED;                       /* ddl@rock-chips.com : 100kHz */\r
2276     msg[1].read_type = 2;                             /* fpga i2c:0==I2C_NO_STOP : direct use number not enum for don't want include spi_fpga.h */\r
2277 \r
2278     cnt = 3;\r
2279     err = -EAGAIN;\r
2280     while ((cnt-- > 0) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */\r
2281         err = i2c_transfer(client->adapter, msg, 2);\r
2282 \r
2283         if (err >= 0) {\r
2284             *val = buf[0];\r
2285             return 0;\r
2286         } else {\r
2287                 SENSOR_TR("\n %s read reg(0x%x val:0x%x) failed, try to read again! \n",SENSOR_NAME_STRING(),reg, *val);\r
2288             udelay(10);\r
2289         }\r
2290     }\r
2291 \r
2292     return err;\r
2293 }\r
2294 #endif\r
2295 /* write a array of registers  */\r
2296 static int sensor_write_array(struct i2c_client *client, struct reginfo *regarray)\r
2297 {\r
2298     int err = 0, cnt;\r
2299     int i = 0;\r
2300 #if CONFIG_SENSOR_I2C_RDWRCHK    \r
2301         char valchk;\r
2302 #endif\r
2303 \r
2304         cnt = 0;\r
2305         if (sensor_task_lock(client, 1) < 0)\r
2306                 goto sensor_write_array_end;\r
2307     while (regarray[i].reg != 0xff)\r
2308     {\r
2309         err = sensor_write(client, regarray[i].reg, regarray[i].val);\r
2310         if (err < 0)\r
2311         {\r
2312             if (cnt-- > 0) {\r
2313                             SENSOR_TR("%s..write failed current reg:0x%x, Write array again !\n", SENSOR_NAME_STRING(),regarray[i].reg);\r
2314                                 i = 0;\r
2315                                 continue;\r
2316             } else {\r
2317                 SENSOR_TR("%s..write array failed!!!\n", SENSOR_NAME_STRING());\r
2318                 err = -EPERM;\r
2319                                 goto sensor_write_array_end;\r
2320             }\r
2321         } else {\r
2322         #if CONFIG_SENSOR_I2C_RDWRCHK\r
2323                         sensor_read(client, regarray[i].reg, &valchk);\r
2324                         if (valchk != regarray[i].val)\r
2325                                 SENSOR_TR("%s Reg:0x%x write(0x%x, 0x%x) fail\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);\r
2326                 #endif\r
2327         }\r
2328         i++;\r
2329     }\r
2330 \r
2331 sensor_write_array_end:\r
2332         sensor_task_lock(client,0);\r
2333         return err;\r
2334 }\r
2335 #if CONFIG_SENSOR_I2C_RDWRCHK\r
2336 static int sensor_readchk_array(struct i2c_client *client, struct reginfo *regarray)\r
2337 {\r
2338     int cnt;\r
2339     int i = 0;\r
2340         char valchk;\r
2341 \r
2342         cnt = 0;\r
2343         valchk = 0;\r
2344     while (regarray[i].reg != 0xff)\r
2345     {\r
2346                 sensor_read(client, regarray[i].reg, &valchk);\r
2347                 if (valchk != regarray[i].val)\r
2348                         SENSOR_TR("%s Reg:0x%x read(0x%x, 0x%x) error\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);\r
2349 \r
2350         i++;\r
2351     }\r
2352     return 0;\r
2353 }\r
2354 #endif\r
2355 static int sensor_ioctrl(struct soc_camera_device *icd,enum rk29sensor_power_cmd cmd, int on)\r
2356 {\r
2357         struct soc_camera_link *icl = to_soc_camera_link(icd);\r
2358         int ret = 0;\r
2359 \r
2360     SENSOR_DG("%s %s  cmd(%d) on(%d)\n",SENSOR_NAME_STRING(),__FUNCTION__,cmd,on);\r
2361         switch (cmd)\r
2362         {\r
2363                 case Sensor_PowerDown:\r
2364                 {\r
2365                         if (icl->powerdown) {\r
2366                                 ret = icl->powerdown(icd->pdev, on);\r
2367                                 if (ret == RK29_CAM_IO_SUCCESS) {\r
2368                                         if (on == 0) {\r
2369                                                 mdelay(2);\r
2370                                                 if (icl->reset)\r
2371                                                         icl->reset(icd->pdev);\r
2372                                         }\r
2373                                 } else if (ret == RK29_CAM_EIO_REQUESTFAIL) {\r
2374                                         ret = -ENODEV;\r
2375                                         goto sensor_power_end;\r
2376                                 }\r
2377                         }\r
2378                         break;\r
2379                 }\r
2380                 case Sensor_Flash:\r
2381                 {\r
2382                         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2383                 struct sensor *sensor = to_sensor(client);\r
2384 \r
2385                         if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {\r
2386                                 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Flash, on);\r
2387                 if(on){\r
2388                     //flash off after 2 secs\r
2389                         hrtimer_cancel(&(flash_off_timer.timer));\r
2390                         hrtimer_start(&(flash_off_timer.timer),ktime_set(0, 800*1000*1000),HRTIMER_MODE_REL);\r
2391                     }\r
2392                         }\r
2393             break;\r
2394                 }\r
2395                 default:\r
2396                 {\r
2397                         SENSOR_TR("%s %s cmd(0x%x) is unknown!",SENSOR_NAME_STRING(),__FUNCTION__,cmd);\r
2398                         break;\r
2399                 }\r
2400         }\r
2401 sensor_power_end:\r
2402         return ret;\r
2403 }\r
2404 \r
2405 static enum hrtimer_restart flash_off_func(struct hrtimer *timer){\r
2406         struct flash_timer *fps_timer = container_of(timer, struct flash_timer, timer);\r
2407     sensor_ioctrl(fps_timer->icd,Sensor_Flash,0);\r
2408         SENSOR_DG("%s %s !!!!!!",SENSOR_NAME_STRING(),__FUNCTION__);\r
2409     return 0;\r
2410     \r
2411 }\r
2412 static int sensor_init(struct v4l2_subdev *sd, u32 val)\r
2413 {\r
2414     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
2415     struct soc_camera_device *icd = client->dev.platform_data;\r
2416     struct sensor *sensor = to_sensor(client);\r
2417         const struct v4l2_queryctrl *qctrl;\r
2418     const struct sensor_datafmt *fmt;\r
2419     int ret;\r
2420 \r
2421     SENSOR_DG("\n%s..%s.. \n",SENSOR_NAME_STRING(),__FUNCTION__);\r
2422 \r
2423      if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {\r
2424           ret = -ENODEV;\r
2425           goto sensor_INIT_ERR;\r
2426      }\r
2427      msleep(100);\r
2428 #if 0\r
2429     /* soft reset */\r
2430         if (sensor_task_lock(client,1)<0)\r
2431                 goto sensor_INIT_ERR;\r
2432     ret = sensor_write(client, 0x3012, 0x80);\r
2433     if (ret != 0)\r
2434     {\r
2435         SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());\r
2436         ret = -ENODEV;\r
2437                 goto sensor_INIT_ERR;\r
2438     }\r
2439 \r
2440     mdelay(5);  //delay 5 microseconds\r
2441         /* check if it is an sensor sensor */\r
2442     ret = sensor_read(client, 0x300a, &value);\r
2443     if (ret != 0) {\r
2444         SENSOR_TR("read chip id high byte failed\n");\r
2445         ret = -ENODEV;\r
2446         goto sensor_INIT_ERR;\r
2447     }\r
2448 \r
2449     pid |= (value << 8);\r
2450 \r
2451     ret = sensor_read(client, 0x300b, &value);\r
2452     if (ret != 0) {\r
2453         SENSOR_TR("read chip id low byte failed\n");\r
2454         ret = -ENODEV;\r
2455         goto sensor_INIT_ERR;\r
2456     }\r
2457 \r
2458     pid |= (value & 0xff);\r
2459     SENSOR_DG("\n %s  pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
2460     if (pid == SENSOR_ID) {\r
2461         sensor->model = SENSOR_V4L2_IDENT;\r
2462     } else {\r
2463         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
2464         ret = -ENODEV;\r
2465         goto sensor_INIT_ERR;\r
2466     }\r
2467 #endif\r
2468 #if 0\r
2469    sensor_read(client,0x01,&value);\r
2470     pid = (value & 0xff);\r
2471     SENSOR_DG("\n %s  pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
2472     if (pid == SENSOR_ID) {\r
2473         sensor->model = SENSOR_V4L2_IDENT;\r
2474     } else {\r
2475         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
2476         ret = -ENODEV;\r
2477         goto sensor_INIT_ERR;\r
2478     }\r
2479 #endif\r
2480 \r
2481     ret = sensor_write_array(client, sensor_init_data);\r
2482     if (ret != 0)\r
2483     {\r
2484         SENSOR_TR("error: %s initial failed\n",SENSOR_NAME_STRING());\r
2485         goto sensor_INIT_ERR;\r
2486     }\r
2487     sensor_task_lock(client,0);\r
2488     sensor->info_priv.winseqe_cur_addr  = (int)SENSOR_INIT_WINSEQADR;\r
2489     fmt = sensor_find_datafmt(SENSOR_INIT_PIXFMT,sensor_colour_fmts, ARRAY_SIZE(sensor_colour_fmts));\r
2490     if (!fmt) {\r
2491         SENSOR_TR("error: %s initial array colour fmts is not support!!",SENSOR_NAME_STRING());\r
2492         ret = -EINVAL;\r
2493         goto sensor_INIT_ERR;\r
2494     }\r
2495         sensor->info_priv.fmt = *fmt;\r
2496 \r
2497     /* sensor sensor information for initialization  */\r
2498         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
2499         if (qctrl)\r
2500         sensor->info_priv.whiteBalance = qctrl->default_value;\r
2501         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_BRIGHTNESS);\r
2502         if (qctrl)\r
2503         sensor->info_priv.brightness = qctrl->default_value;\r
2504         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
2505         if (qctrl)\r
2506         sensor->info_priv.effect = qctrl->default_value;\r
2507         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EXPOSURE);\r
2508         if (qctrl)\r
2509         sensor->info_priv.exposure = qctrl->default_value;\r
2510 \r
2511         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SATURATION);\r
2512         if (qctrl)\r
2513         sensor->info_priv.saturation = qctrl->default_value;\r
2514         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_CONTRAST);\r
2515         if (qctrl)\r
2516         sensor->info_priv.contrast = qctrl->default_value;\r
2517         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_HFLIP);\r
2518         if (qctrl)\r
2519         sensor->info_priv.mirror = qctrl->default_value;\r
2520         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_VFLIP);\r
2521         if (qctrl)\r
2522         sensor->info_priv.flip = qctrl->default_value;\r
2523         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SCENE);\r
2524         if (qctrl)\r
2525         sensor->info_priv.scene = qctrl->default_value;\r
2526         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);\r
2527         if (qctrl)\r
2528         sensor->info_priv.digitalzoom = qctrl->default_value;\r
2529 \r
2530     /* ddl@rock-chips.com : if sensor support auto focus and flash, programer must run focus and flash code  */\r
2531         #if CONFIG_SENSOR_Focus\r
2532     sensor_set_focus();\r
2533     qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FOCUS_ABSOLUTE);\r
2534         if (qctrl)\r
2535         sensor->info_priv.focus = qctrl->default_value;\r
2536         #endif\r
2537 \r
2538         #if CONFIG_SENSOR_Flash\r
2539         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FLASH);\r
2540         if (qctrl)\r
2541         sensor->info_priv.flash = qctrl->default_value;\r
2542     flash_off_timer.icd = icd;\r
2543         flash_off_timer.timer.function = flash_off_func;\r
2544     #endif\r
2545 \r
2546     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);\r
2547     sensor->info_priv.funmodule_state |= SENSOR_INIT_IS_OK;\r
2548     return 0;\r
2549 sensor_INIT_ERR:\r
2550     sensor->info_priv.funmodule_state &= ~SENSOR_INIT_IS_OK;\r
2551         sensor_task_lock(client,0);\r
2552         sensor_deactivate(client);\r
2553     return ret;\r
2554 }\r
2555 \r
2556 static int sensor_deactivate(struct i2c_client *client)\r
2557 {\r
2558         struct soc_camera_device *icd = client->dev.platform_data;\r
2559     struct sensor *sensor = to_sensor(client);\r
2560     \r
2561         SENSOR_DG("\n%s..%s.. Enter\n",SENSOR_NAME_STRING(),__FUNCTION__);\r
2562 \r
2563         /* ddl@rock-chips.com : all sensor output pin must change to input for other sensor */\r
2564         \r
2565         sensor_ioctrl(icd, Sensor_PowerDown, 1);\r
2566 \r
2567         /* ddl@rock-chips.com : sensor config init width , because next open sensor quickly(soc_camera_open -> Try to configure with default parameters) */\r
2568         icd->user_width = SENSOR_INIT_WIDTH;\r
2569     icd->user_height = SENSOR_INIT_HEIGHT;\r
2570         msleep(100);\r
2571 \r
2572     sensor->info_priv.funmodule_state &= ~SENSOR_INIT_IS_OK;\r
2573         return 0;\r
2574 }\r
2575 \r
2576 static  struct reginfo sensor_power_down_sequence[]=\r
2577 {\r
2578     {0xff,0xff}\r
2579 };\r
2580 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg)\r
2581 {\r
2582     int ret;\r
2583     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2584 \r
2585     if (pm_msg.event == PM_EVENT_SUSPEND) {\r
2586         SENSOR_DG("\n %s Enter Suspend.. \n", SENSOR_NAME_STRING());\r
2587         ret = sensor_write_array(client, sensor_power_down_sequence) ;\r
2588         if (ret != 0) {\r
2589             SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);\r
2590             return ret;\r
2591         } else {\r
2592             ret = sensor_ioctrl(icd, Sensor_PowerDown, 1);\r
2593             if (ret < 0) {\r
2594                             SENSOR_TR("\n %s suspend fail for turn on power!\n", SENSOR_NAME_STRING());\r
2595                 return -EINVAL;\r
2596             }\r
2597         }\r
2598     } else {\r
2599         SENSOR_TR("\n %s cann't suppout Suspend..\n",SENSOR_NAME_STRING());\r
2600         return -EINVAL;\r
2601     }\r
2602     return 0;\r
2603 }\r
2604 \r
2605 static int sensor_resume(struct soc_camera_device *icd)\r
2606 {\r
2607         int ret;\r
2608 \r
2609     ret = sensor_ioctrl(icd, Sensor_PowerDown, 0);\r
2610     if (ret < 0) {\r
2611                 SENSOR_TR("\n %s resume fail for turn on power!\n", SENSOR_NAME_STRING());\r
2612         return -EINVAL;\r
2613     }\r
2614 \r
2615         SENSOR_DG("\n %s Enter Resume.. \n", SENSOR_NAME_STRING());\r
2616 \r
2617     return 0;\r
2618 \r
2619 }\r
2620 \r
2621 static int sensor_set_bus_param(struct soc_camera_device *icd,\r
2622                                 unsigned long flags)\r
2623 {\r
2624 \r
2625     return 0;\r
2626 }\r
2627 \r
2628 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd)\r
2629 {\r
2630     struct soc_camera_link *icl = to_soc_camera_link(icd);\r
2631     unsigned long flags = SENSOR_BUS_PARAM;\r
2632 \r
2633     return soc_camera_apply_sensor_flags(icl, flags);\r
2634 }\r
2635 \r
2636 static int sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)\r
2637 {\r
2638     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
2639     struct soc_camera_device *icd = client->dev.platform_data;\r
2640     struct sensor *sensor = to_sensor(client);\r
2641 \r
2642     mf->width   = icd->user_width;\r
2643         mf->height      = icd->user_height;\r
2644         mf->code        = sensor->info_priv.fmt.code;\r
2645         mf->colorspace  = sensor->info_priv.fmt.colorspace;\r
2646         mf->field       = V4L2_FIELD_NONE;\r
2647 \r
2648     return 0;\r
2649 }\r
2650 static bool sensor_fmt_capturechk(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)\r
2651 {\r
2652     bool ret = false;\r
2653 \r
2654         if ((mf->width == 1024) && (mf->height == 768)) {\r
2655                 ret = true;\r
2656         } else if ((mf->width == 1280) && (mf->height == 1024)) {\r
2657                 ret = true;\r
2658         } else if ((mf->width == 1600) && (mf->height == 1200)) {\r
2659                 ret = true;\r
2660         } else if ((mf->width == 2048) && (mf->height == 1536)) {\r
2661                 ret = true;\r
2662         } else if ((mf->width == 2592) && (mf->height == 1944)) {\r
2663                 ret = true;\r
2664         }\r
2665 \r
2666         if (ret == true)\r
2667                 SENSOR_DG("%s %dx%d is capture format\n", __FUNCTION__, mf->width, mf->height);\r
2668         return ret;\r
2669 }\r
2670 \r
2671 static bool sensor_fmt_videochk(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)\r
2672 {\r
2673     bool ret = false;\r
2674 \r
2675         if ((mf->width == 1280) && (mf->height == 720)) {\r
2676                 ret = true;\r
2677         } else if ((mf->width == 1920) && (mf->height == 1080)) {\r
2678                 ret = true;\r
2679         }\r
2680 \r
2681         if (ret == true)\r
2682                 SENSOR_DG("%s %dx%d is video format\n", __FUNCTION__, mf->width, mf->height);\r
2683         return ret;\r
2684 }\r
2685 static int sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)\r
2686 {\r
2687     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
2688     struct sensor *sensor = to_sensor(client);\r
2689     const struct sensor_datafmt *fmt;\r
2690         const struct v4l2_queryctrl *qctrl;\r
2691         struct soc_camera_device *icd = client->dev.platform_data;\r
2692     struct reginfo *winseqe_set_addr=NULL;\r
2693     int ret=0, set_w,set_h;\r
2694 \r
2695         fmt = sensor_find_datafmt(mf->code, sensor_colour_fmts,\r
2696                                    ARRAY_SIZE(sensor_colour_fmts));\r
2697         if (!fmt) {\r
2698         ret = -EINVAL;\r
2699         goto sensor_s_fmt_end;\r
2700     }\r
2701 \r
2702         if (sensor->info_priv.fmt.code != mf->code) {\r
2703                 switch (mf->code)\r
2704                 {\r
2705                         case V4L2_MBUS_FMT_YUYV8_2X8:\r
2706                         {\r
2707                                 winseqe_set_addr = sensor_ClrFmt_YUYV;\r
2708                                 break;\r
2709                         }\r
2710                         case V4L2_MBUS_FMT_UYVY8_2X8:\r
2711                         {\r
2712                                 winseqe_set_addr = sensor_ClrFmt_UYVY;\r
2713                                 break;\r
2714                         }\r
2715                         default:\r
2716                                 break;\r
2717                 }\r
2718                 if (winseqe_set_addr != NULL) {\r
2719             sensor_write_array(client, winseqe_set_addr);\r
2720                         sensor->info_priv.fmt.code = mf->code;\r
2721             sensor->info_priv.fmt.colorspace= mf->colorspace;            \r
2722                         SENSOR_DG("%s v4l2_mbus_code:%d set success!\n", SENSOR_NAME_STRING(),mf->code);\r
2723                 } else {\r
2724                         SENSOR_TR("%s v4l2_mbus_code:%d is invalidate!\n", SENSOR_NAME_STRING(),mf->code);\r
2725                 }\r
2726         }\r
2727 \r
2728     set_w = mf->width;\r
2729     set_h = mf->height;\r
2730 \r
2731         if (((set_w <= 176) && (set_h <= 144)) &&( sensor_qcif[0].reg!=0xff))\r
2732         {\r
2733                 winseqe_set_addr = sensor_qcif;\r
2734         set_w = 176;\r
2735         set_h = 144;\r
2736         }\r
2737         else if (((set_w <= 320) && (set_h <= 240)) && (sensor_qvga[0].reg!=0xff))\r
2738     {\r
2739         winseqe_set_addr = sensor_qvga;\r
2740         set_w = 320;\r
2741         set_h = 240;\r
2742     }\r
2743     else if (((set_w <= 352) && (set_h<= 288)) && (sensor_cif[0].reg!=0xff))\r
2744     {\r
2745         winseqe_set_addr = sensor_cif;\r
2746         set_w = 352;\r
2747         set_h = 288;\r
2748     }\r
2749     else if (((set_w <= 640) && (set_h <= 480)) &&( sensor_vga[0].reg!=0xff))\r
2750     {\r
2751         winseqe_set_addr = sensor_vga;\r
2752         set_w =640;\r
2753         set_h = 480;\r
2754     }\r
2755     else if (((set_w <= 800) && (set_h <= 600)) && (sensor_svga[0].reg!=0xff))\r
2756     {\r
2757         winseqe_set_addr = sensor_svga;\r
2758         set_w = 800;\r
2759         set_h = 600;\r
2760     }\r
2761         else if (((set_w <= 1024) && (set_h <= 768)) &&( sensor_xga[0].reg!=0xff))\r
2762     {\r
2763         winseqe_set_addr = sensor_xga;\r
2764         set_w = 1024;\r
2765         set_h = 768;\r
2766     }\r
2767     else if (((set_w <= 1280) && (set_h <= 1024)) && (sensor_sxga[0].reg!=0xff))\r
2768     {\r
2769         winseqe_set_addr = sensor_sxga;\r
2770         set_w = 1280;\r
2771         set_h = 1024;\r
2772     }\r
2773     else if (((set_w <= 1600) && (set_h <= 1200)) && (sensor_uxga[0].reg!=0xff))\r
2774     {\r
2775         winseqe_set_addr = sensor_uxga;\r
2776         set_w = 1600;\r
2777         set_h = 1200;\r
2778     }\r
2779     else\r
2780     {\r
2781         winseqe_set_addr = SENSOR_INIT_WINSEQADR;               /* ddl@rock-chips.com : Sensor output smallest size if  isn't support app  */\r
2782         set_w = SENSOR_INIT_WIDTH;\r
2783         set_h = SENSOR_INIT_HEIGHT;             \r
2784                 SENSOR_TR("\n %s..%s Format is Invalidate. pix->width = %d.. pix->height = %d\n",SENSOR_NAME_STRING(),__FUNCTION__,mf->width,mf->height);\r
2785     }\r
2786 \r
2787     if ((int)winseqe_set_addr  != sensor->info_priv.winseqe_cur_addr) {\r
2788         #if CONFIG_SENSOR_Flash\r
2789         if (sensor_fmt_capturechk(sd,mf) == true) {      /* ddl@rock-chips.com : Capture */\r
2790             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {\r
2791                 sensor_ioctrl(icd, Sensor_Flash, Flash_On);\r
2792                 SENSOR_DG("%s flash on in capture!\n", SENSOR_NAME_STRING());\r
2793             }           \r
2794         } else {                                        /* ddl@rock-chips.com : Video */\r
2795             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {\r
2796                 sensor_ioctrl(icd, Sensor_Flash, Flash_Off);\r
2797                 SENSOR_DG("%s flash off in preivew!\n", SENSOR_NAME_STRING());\r
2798             }\r
2799         }\r
2800         #endif\r
2801         ret |= sensor_write_array(client, winseqe_set_addr);\r
2802         if (ret != 0) {\r
2803             SENSOR_TR("%s set format capability failed\n", SENSOR_NAME_STRING());\r
2804             #if CONFIG_SENSOR_Flash\r
2805             if (sensor_fmt_capturechk(sd,mf) == true) {\r
2806                 if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {\r
2807                     sensor_ioctrl(icd, Sensor_Flash, Flash_Off);\r
2808                     SENSOR_TR("%s Capture format set fail, flash off !\n", SENSOR_NAME_STRING());\r
2809                 }\r
2810             }\r
2811             #endif\r
2812             goto sensor_s_fmt_end;\r
2813         }\r
2814 \r
2815         sensor->info_priv.winseqe_cur_addr  = (int)winseqe_set_addr;\r
2816 \r
2817                 if (sensor_fmt_capturechk(sd,mf) == true) {                                 /* ddl@rock-chips.com : Capture */\r
2818         #if CONFIG_SENSOR_Effect\r
2819                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
2820                         sensor_set_effect(icd, qctrl,sensor->info_priv.effect);\r
2821         #endif\r
2822         #if CONFIG_SENSOR_WhiteBalance\r
2823                         if (sensor->info_priv.whiteBalance != 0) {\r
2824                                 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
2825                                 sensor_set_whiteBalance(icd, qctrl,sensor->info_priv.whiteBalance);\r
2826                         }\r
2827         #endif\r
2828                         sensor->info_priv.snap2preview = true;\r
2829                 } else if (sensor_fmt_videochk(sd,mf) == true) {                        /* ddl@rock-chips.com : Video */\r
2830                 #if CONFIG_SENSOR_Effect\r
2831                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
2832                         sensor_set_effect(icd, qctrl,sensor->info_priv.effect);\r
2833         #endif\r
2834         #if CONFIG_SENSOR_WhiteBalance\r
2835                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
2836                         sensor_set_whiteBalance(icd, qctrl,sensor->info_priv.whiteBalance);\r
2837         #endif\r
2838                         sensor->info_priv.video2preview = true;\r
2839                 } else if ((sensor->info_priv.snap2preview == true) || (sensor->info_priv.video2preview == true)) {\r
2840                 #if CONFIG_SENSOR_Effect\r
2841                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
2842                         sensor_set_effect(icd, qctrl,sensor->info_priv.effect);\r
2843         #endif\r
2844         #if CONFIG_SENSOR_WhiteBalance\r
2845                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
2846                         sensor_set_whiteBalance(icd, qctrl,sensor->info_priv.whiteBalance);\r
2847         #endif\r
2848                         sensor->info_priv.video2preview = false;\r
2849                         sensor->info_priv.snap2preview = false;\r
2850                 }\r
2851         SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,set_w,set_h);\r
2852     }\r
2853     else\r
2854     {\r
2855         SENSOR_DG("\n %s .. Current Format is validate. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),set_w,set_h);\r
2856     }\r
2857 \r
2858         mf->width = set_w;\r
2859     mf->height = set_h;\r
2860 \r
2861 sensor_s_fmt_end:\r
2862     return ret;\r
2863 }\r
2864 \r
2865 static int sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf)\r
2866 {\r
2867     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
2868     struct sensor *sensor = to_sensor(client);\r
2869     const struct sensor_datafmt *fmt;\r
2870     int ret = 0,set_w,set_h;\r
2871    \r
2872         fmt = sensor_find_datafmt(mf->code, sensor_colour_fmts,\r
2873                                    ARRAY_SIZE(sensor_colour_fmts));\r
2874         if (fmt == NULL) {\r
2875                 fmt = &sensor->info_priv.fmt;\r
2876         mf->code = fmt->code;\r
2877         } \r
2878 \r
2879     if (mf->height > SENSOR_MAX_HEIGHT)\r
2880         mf->height = SENSOR_MAX_HEIGHT;\r
2881     else if (mf->height < SENSOR_MIN_HEIGHT)\r
2882         mf->height = SENSOR_MIN_HEIGHT;\r
2883 \r
2884     if (mf->width > SENSOR_MAX_WIDTH)\r
2885         mf->width = SENSOR_MAX_WIDTH;\r
2886     else if (mf->width < SENSOR_MIN_WIDTH)\r
2887         mf->width = SENSOR_MIN_WIDTH;\r
2888 \r
2889     set_w = mf->width;\r
2890     set_h = mf->height;\r
2891 \r
2892         if (((set_w <= 176) && (set_h <= 144)) &&( sensor_qcif[0].reg!=0xff))\r
2893         {\r
2894         set_w = 176;\r
2895         set_h = 144;\r
2896         }\r
2897         else if (((set_w <= 320) && (set_h <= 240)) && (sensor_qvga[0].reg!=0xff))\r
2898     {\r
2899         set_w = 320;\r
2900         set_h = 240;\r
2901     }\r
2902     else if (((set_w <= 352) && (set_h<= 288)) && (sensor_cif[0].reg!=0xff))\r
2903     {\r
2904         set_w = 352;\r
2905         set_h = 288;\r
2906     }\r
2907     else if (((set_w <= 640) && (set_h <= 480)) &&( sensor_vga[0].reg!=0xff))\r
2908     {\r
2909         set_w =640;\r
2910         set_h = 480;\r
2911     }\r
2912     else if (((set_w <= 800) && (set_h <= 600)) && (sensor_svga[0].reg!=0xff))\r
2913     {\r
2914         set_w = 800;\r
2915         set_h = 600;\r
2916     }\r
2917         else if (((set_w <= 1024) && (set_h <= 768)) &&( sensor_xga[0].reg!=0xff))\r
2918     {\r
2919         set_w = 1024;\r
2920         set_h = 768;\r
2921     }\r
2922     else if (((set_w <= 1280) && (set_h <= 1024)) && (sensor_sxga[0].reg!=0xff))\r
2923     {\r
2924         set_w = 1280;\r
2925         set_h = 1024;\r
2926     }\r
2927     else if (((set_w <= 1600) && (set_h <= 1200)) && (sensor_uxga[0].reg!=0xff))\r
2928     {\r
2929         set_w = 1600;\r
2930         set_h = 1200;\r
2931     }\r
2932     else\r
2933     {\r
2934         set_w = SENSOR_INIT_WIDTH;\r
2935         set_h = SENSOR_INIT_HEIGHT;             \r
2936     }\r
2937     mf->width = set_w;\r
2938     mf->height = set_h;  \r
2939     mf->colorspace = fmt->colorspace;\r
2940     \r
2941     return ret;\r
2942 }\r
2943 \r
2944  static int sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id)\r
2945 {\r
2946     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
2947 \r
2948     if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)\r
2949         return -EINVAL;\r
2950 \r
2951     if (id->match.addr != client->addr)\r
2952         return -ENODEV;\r
2953 \r
2954     id->ident = SENSOR_V4L2_IDENT;      /* ddl@rock-chips.com :  Return OV2655  identifier */\r
2955     id->revision = 0;\r
2956 \r
2957     return 0;\r
2958 }\r
2959 #if CONFIG_SENSOR_Brightness\r
2960 static int sensor_set_brightness(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2961 {\r
2962     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2963 \r
2964     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2965     {\r
2966         if (sensor_BrightnessSeqe[value - qctrl->minimum] != NULL)\r
2967         {\r
2968             if (sensor_write_array(client, sensor_BrightnessSeqe[value - qctrl->minimum]) != 0)\r
2969             {\r
2970                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2971                 return -EINVAL;\r
2972             }\r
2973             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2974             return 0;\r
2975         }\r
2976     }\r
2977         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2978     return -EINVAL;\r
2979 }\r
2980 #endif\r
2981 #if CONFIG_SENSOR_Effect\r
2982 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2983 {\r
2984     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2985 \r
2986     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2987     {\r
2988         if (sensor_EffectSeqe[value - qctrl->minimum] != NULL)\r
2989         {\r
2990             if (sensor_write_array(client, sensor_EffectSeqe[value - qctrl->minimum]) != 0)\r
2991             {\r
2992                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2993                 return -EINVAL;\r
2994             }\r
2995             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2996             return 0;\r
2997         }\r
2998     }\r
2999         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3000     return -EINVAL;\r
3001 }\r
3002 #endif\r
3003 #if CONFIG_SENSOR_Exposure\r
3004 static int sensor_set_exposure(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3005 {\r
3006     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3007 \r
3008     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
3009     {\r
3010         if (sensor_ExposureSeqe[value - qctrl->minimum] != NULL)\r
3011         {\r
3012             if (sensor_write_array(client, sensor_ExposureSeqe[value - qctrl->minimum]) != 0)\r
3013             {\r
3014                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3015                 return -EINVAL;\r
3016             }\r
3017             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3018             return 0;\r
3019         }\r
3020     }\r
3021         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3022     return -EINVAL;\r
3023 }\r
3024 #endif\r
3025 #if CONFIG_SENSOR_Saturation\r
3026 static int sensor_set_saturation(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3027 {\r
3028     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3029 \r
3030     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
3031     {\r
3032         if (sensor_SaturationSeqe[value - qctrl->minimum] != NULL)\r
3033         {\r
3034             if (sensor_write_array(client, sensor_SaturationSeqe[value - qctrl->minimum]) != 0)\r
3035             {\r
3036                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3037                 return -EINVAL;\r
3038             }\r
3039             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3040             return 0;\r
3041         }\r
3042     }\r
3043     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3044     return -EINVAL;\r
3045 }\r
3046 #endif\r
3047 #if CONFIG_SENSOR_Contrast\r
3048 static int sensor_set_contrast(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3049 {\r
3050     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3051 \r
3052     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
3053     {\r
3054         if (sensor_ContrastSeqe[value - qctrl->minimum] != NULL)\r
3055         {\r
3056             if (sensor_write_array(client, sensor_ContrastSeqe[value - qctrl->minimum]) != 0)\r
3057             {\r
3058                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3059                 return -EINVAL;\r
3060             }\r
3061             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3062             return 0;\r
3063         }\r
3064     }\r
3065     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3066     return -EINVAL;\r
3067 }\r
3068 #endif\r
3069 #if CONFIG_SENSOR_Mirror\r
3070 static int sensor_set_mirror(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3071 {\r
3072     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3073 \r
3074     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
3075     {\r
3076         if (sensor_MirrorSeqe[value - qctrl->minimum] != NULL)\r
3077         {\r
3078             if (sensor_write_array(client, sensor_MirrorSeqe[value - qctrl->minimum]) != 0)\r
3079             {\r
3080                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3081                 return -EINVAL;\r
3082             }\r
3083             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3084             return 0;\r
3085         }\r
3086     }\r
3087     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3088     return -EINVAL;\r
3089 }\r
3090 #endif\r
3091 #if CONFIG_SENSOR_Flip\r
3092 static int sensor_set_flip(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3093 {\r
3094     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3095 \r
3096     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
3097     {\r
3098         if (sensor_FlipSeqe[value - qctrl->minimum] != NULL)\r
3099         {\r
3100             if (sensor_write_array(client, sensor_FlipSeqe[value - qctrl->minimum]) != 0)\r
3101             {\r
3102                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3103                 return -EINVAL;\r
3104             }\r
3105             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3106             return 0;\r
3107         }\r
3108     }\r
3109     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3110     return -EINVAL;\r
3111 }\r
3112 #endif\r
3113 #if CONFIG_SENSOR_Scene\r
3114 static int sensor_set_scene(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3115 {\r
3116     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3117 \r
3118     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
3119     {\r
3120         if (sensor_SceneSeqe[value - qctrl->minimum] != NULL)\r
3121         {\r
3122             if (sensor_write_array(client, sensor_SceneSeqe[value - qctrl->minimum]) != 0)\r
3123             {\r
3124                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3125                 return -EINVAL;\r
3126             }\r
3127             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3128             return 0;\r
3129         }\r
3130     }\r
3131     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3132     return -EINVAL;\r
3133 }\r
3134 #endif\r
3135 #if CONFIG_SENSOR_WhiteBalance\r
3136 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3137 {\r
3138     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3139 \r
3140     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
3141     {\r
3142         if (sensor_WhiteBalanceSeqe[value - qctrl->minimum] != NULL)\r
3143         {\r
3144             if (sensor_write_array(client, sensor_WhiteBalanceSeqe[value - qctrl->minimum]) != 0)\r
3145             {\r
3146                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3147                 return -EINVAL;\r
3148             }\r
3149             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3150             return 0;\r
3151         }\r
3152     }\r
3153         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3154     return -EINVAL;\r
3155 }\r
3156 #endif\r
3157 #if CONFIG_SENSOR_DigitalZoom\r
3158 static int sensor_set_digitalzoom(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3159 {\r
3160     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3161     struct sensor *sensor = to_sensor(client);\r
3162         const struct v4l2_queryctrl *qctrl_info;\r
3163     int digitalzoom_cur, digitalzoom_total;\r
3164 \r
3165         qctrl_info = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);\r
3166         if (qctrl_info)\r
3167                 return -EINVAL;\r
3168 \r
3169     digitalzoom_cur = sensor->info_priv.digitalzoom;\r
3170     digitalzoom_total = qctrl_info->maximum;\r
3171 \r
3172     if ((value > 0) && (digitalzoom_cur >= digitalzoom_total))\r
3173     {\r
3174         SENSOR_TR("%s digitalzoom is maximum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);\r
3175         return -EINVAL;\r
3176     }\r
3177 \r
3178     if  ((value < 0) && (digitalzoom_cur <= qctrl_info->minimum))\r
3179     {\r
3180         SENSOR_TR("%s digitalzoom is minimum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);\r
3181         return -EINVAL;\r
3182     }\r
3183 \r
3184     if ((value > 0) && ((digitalzoom_cur + value) > digitalzoom_total))\r
3185     {\r
3186         value = digitalzoom_total - digitalzoom_cur;\r
3187     }\r
3188 \r
3189     if ((value < 0) && ((digitalzoom_cur + value) < 0))\r
3190     {\r
3191         value = 0 - digitalzoom_cur;\r
3192     }\r
3193 \r
3194     digitalzoom_cur += value;\r
3195 \r
3196     if (sensor_ZoomSeqe[digitalzoom_cur] != NULL)\r
3197     {\r
3198         if (sensor_write_array(client, sensor_ZoomSeqe[digitalzoom_cur]) != 0)\r
3199         {\r
3200             SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
3201             return -EINVAL;\r
3202         }\r
3203         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3204         return 0;\r
3205     }\r
3206 \r
3207     return -EINVAL;\r
3208 }\r
3209 #endif\r
3210 #if CONFIG_SENSOR_Flash\r
3211 static int sensor_set_flash(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
3212 {    \r
3213     if ((value >= qctrl->minimum) && (value <= qctrl->maximum)) {\r
3214         if (value == 3) {       /* ddl@rock-chips.com: torch */\r
3215             sensor_ioctrl(icd, Sensor_Flash, Flash_Torch);   /* Flash On */\r
3216         } else {\r
3217             sensor_ioctrl(icd, Sensor_Flash, Flash_Off);\r
3218         }\r
3219         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
3220         return 0;\r
3221     }\r
3222     \r
3223         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
3224     return -EINVAL;\r
3225 }\r
3226 #endif\r
3227 \r
3228 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)\r
3229 {\r
3230     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
3231     struct sensor *sensor = to_sensor(client);\r
3232     const struct v4l2_queryctrl *qctrl;\r
3233 \r
3234     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);\r
3235 \r
3236     if (!qctrl)\r
3237     {\r
3238         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);\r
3239         return -EINVAL;\r
3240     }\r
3241 \r
3242     switch (ctrl->id)\r
3243     {\r
3244         case V4L2_CID_BRIGHTNESS:\r
3245             {\r
3246                 ctrl->value = sensor->info_priv.brightness;\r
3247                 break;\r
3248             }\r
3249         case V4L2_CID_SATURATION:\r
3250             {\r
3251                 ctrl->value = sensor->info_priv.saturation;\r
3252                 break;\r
3253             }\r
3254         case V4L2_CID_CONTRAST:\r
3255             {\r
3256                 ctrl->value = sensor->info_priv.contrast;\r
3257                 break;\r
3258             }\r
3259         case V4L2_CID_DO_WHITE_BALANCE:\r
3260             {\r
3261                 ctrl->value = sensor->info_priv.whiteBalance;\r
3262                 break;\r
3263             }\r
3264         case V4L2_CID_EXPOSURE:\r
3265             {\r
3266                 ctrl->value = sensor->info_priv.exposure;\r
3267                 break;\r
3268             }\r
3269         case V4L2_CID_HFLIP:\r
3270             {\r
3271                 ctrl->value = sensor->info_priv.mirror;\r
3272                 break;\r
3273             }\r
3274         case V4L2_CID_VFLIP:\r
3275             {\r
3276                 ctrl->value = sensor->info_priv.flip;\r
3277                 break;\r
3278             }\r
3279         default :\r
3280                 break;\r
3281     }\r
3282     return 0;\r
3283 }\r
3284 \r
3285 \r
3286 \r
3287 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)\r
3288 {\r
3289     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
3290     struct sensor *sensor = to_sensor(client);\r
3291     struct soc_camera_device *icd = client->dev.platform_data;\r
3292     const struct v4l2_queryctrl *qctrl;\r
3293 \r
3294 \r
3295     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);\r
3296 \r
3297     if (!qctrl)\r
3298     {\r
3299         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);\r
3300         return -EINVAL;\r
3301     }\r
3302 \r
3303     switch (ctrl->id)\r
3304     {\r
3305 #if CONFIG_SENSOR_Brightness\r
3306         case V4L2_CID_BRIGHTNESS:\r
3307             {\r
3308                 if (ctrl->value != sensor->info_priv.brightness)\r
3309                 {\r
3310                     if (sensor_set_brightness(icd, qctrl,ctrl->value) != 0)\r
3311                     {\r
3312                         return -EINVAL;\r
3313                     }\r
3314                     sensor->info_priv.brightness = ctrl->value;\r
3315                 }\r
3316                 break;\r
3317             }\r
3318 #endif\r
3319 #if CONFIG_SENSOR_Exposure\r
3320         case V4L2_CID_EXPOSURE:\r
3321             {\r
3322                 if (ctrl->value != sensor->info_priv.exposure)\r
3323                 {\r
3324                     if (sensor_set_exposure(icd, qctrl,ctrl->value) != 0)\r
3325                     {\r
3326                         return -EINVAL;\r
3327                     }\r
3328                     sensor->info_priv.exposure = ctrl->value;\r
3329                 }\r
3330                 break;\r
3331             }\r
3332 #endif\r
3333 #if CONFIG_SENSOR_Saturation\r
3334         case V4L2_CID_SATURATION:\r
3335             {\r
3336                 if (ctrl->value != sensor->info_priv.saturation)\r
3337                 {\r
3338                     if (sensor_set_saturation(icd, qctrl,ctrl->value) != 0)\r
3339                     {\r
3340                         return -EINVAL;\r
3341                     }\r
3342                     sensor->info_priv.saturation = ctrl->value;\r
3343                 }\r
3344                 break;\r
3345             }\r
3346 #endif\r
3347 #if CONFIG_SENSOR_Contrast\r
3348         case V4L2_CID_CONTRAST:\r
3349             {\r
3350                 if (ctrl->value != sensor->info_priv.contrast)\r
3351                 {\r
3352                     if (sensor_set_contrast(icd, qctrl,ctrl->value) != 0)\r
3353                     {\r
3354                         return -EINVAL;\r
3355                     }\r
3356                     sensor->info_priv.contrast = ctrl->value;\r
3357                 }\r
3358                 break;\r
3359             }\r
3360 #endif\r
3361 #if CONFIG_SENSOR_WhiteBalance\r
3362         case V4L2_CID_DO_WHITE_BALANCE:\r
3363             {\r
3364                 if (ctrl->value != sensor->info_priv.whiteBalance)\r
3365                 {\r
3366                     if (sensor_set_whiteBalance(icd, qctrl,ctrl->value) != 0)\r
3367                     {\r
3368                         return -EINVAL;\r
3369                     }\r
3370                     sensor->info_priv.whiteBalance = ctrl->value;\r
3371                 }\r
3372                 break;\r
3373             }\r
3374 #endif\r
3375 #if CONFIG_SENSOR_Mirror\r
3376         case V4L2_CID_HFLIP:\r
3377             {\r
3378                 if (ctrl->value != sensor->info_priv.mirror)\r
3379                 {\r
3380                     if (sensor_set_mirror(icd, qctrl,ctrl->value) != 0)\r
3381                         return -EINVAL;\r
3382                     sensor->info_priv.mirror = ctrl->value;\r
3383                 }\r
3384                 break;\r
3385             }\r
3386 #endif\r
3387 #if CONFIG_SENSOR_Flip\r
3388         case V4L2_CID_VFLIP:\r
3389             {\r
3390                 if (ctrl->value != sensor->info_priv.flip)\r
3391                 {\r
3392                     if (sensor_set_flip(icd, qctrl,ctrl->value) != 0)\r
3393                         return -EINVAL;\r
3394                     sensor->info_priv.flip = ctrl->value;\r
3395                 }\r
3396                 break;\r
3397             }\r
3398 #endif\r
3399         default:\r
3400             break;\r
3401     }\r
3402 \r
3403     return 0;\r
3404 }\r
3405 static int sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl)\r
3406 {\r
3407     const struct v4l2_queryctrl *qctrl;\r
3408     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3409     struct sensor *sensor = to_sensor(client);\r
3410 \r
3411     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);\r
3412 \r
3413     if (!qctrl)\r
3414     {\r
3415         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);\r
3416         return -EINVAL;\r
3417     }\r
3418 \r
3419     switch (ext_ctrl->id)\r
3420     {\r
3421         case V4L2_CID_SCENE:\r
3422             {\r
3423                 ext_ctrl->value = sensor->info_priv.scene;\r
3424                 break;\r
3425             }\r
3426         case V4L2_CID_EFFECT:\r
3427             {\r
3428                 ext_ctrl->value = sensor->info_priv.effect;\r
3429                 break;\r
3430             }\r
3431         case V4L2_CID_ZOOM_ABSOLUTE:\r
3432             {\r
3433                 ext_ctrl->value = sensor->info_priv.digitalzoom;\r
3434                 break;\r
3435             }\r
3436         case V4L2_CID_ZOOM_RELATIVE:\r
3437             {\r
3438                 return -EINVAL;\r
3439             }\r
3440         case V4L2_CID_FOCUS_ABSOLUTE:\r
3441             {\r
3442                 ext_ctrl->value = sensor->info_priv.focus;\r
3443                 break;\r
3444             }\r
3445         case V4L2_CID_FOCUS_RELATIVE:\r
3446             {\r
3447                 return -EINVAL;\r
3448             }\r
3449         case V4L2_CID_FLASH:\r
3450             {\r
3451                 ext_ctrl->value = sensor->info_priv.flash;\r
3452                 break;\r
3453             }\r
3454         default :\r
3455             break;\r
3456     }\r
3457     return 0;\r
3458 }\r
3459 static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl)\r
3460 {\r
3461     const struct v4l2_queryctrl *qctrl;\r
3462     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
3463     struct sensor *sensor = to_sensor(client);\r
3464     int val_offset;\r
3465 \r
3466     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);\r
3467 \r
3468     if (!qctrl)\r
3469     {\r
3470         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);\r
3471         return -EINVAL;\r
3472     }\r
3473 \r
3474         val_offset = 0;\r
3475     switch (ext_ctrl->id)\r
3476     {\r
3477 #if CONFIG_SENSOR_Scene\r
3478         case V4L2_CID_SCENE:\r
3479             {\r
3480                 if (ext_ctrl->value != sensor->info_priv.scene)\r
3481                 {\r
3482                     if (sensor_set_scene(icd, qctrl,ext_ctrl->value) != 0)\r
3483                         return -EINVAL;\r
3484                     sensor->info_priv.scene = ext_ctrl->value;\r
3485                 }\r
3486                 break;\r
3487             }\r
3488 #endif\r
3489 #if CONFIG_SENSOR_Effect\r
3490         case V4L2_CID_EFFECT:\r
3491             {\r
3492                 if (ext_ctrl->value != sensor->info_priv.effect)\r
3493                 {\r
3494                     if (sensor_set_effect(icd, qctrl,ext_ctrl->value) != 0)\r
3495                         return -EINVAL;\r
3496                     sensor->info_priv.effect= ext_ctrl->value;\r
3497                 }\r
3498                 break;\r
3499             }\r
3500 #endif\r
3501 #if CONFIG_SENSOR_DigitalZoom\r
3502         case V4L2_CID_ZOOM_ABSOLUTE:\r
3503             {\r
3504                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))\r
3505                     return -EINVAL;\r
3506 \r
3507                 if (ext_ctrl->value != sensor->info_priv.digitalzoom)\r
3508                 {\r
3509                     val_offset = ext_ctrl->value -sensor->info_priv.digitalzoom;\r
3510 \r
3511                     if (sensor_set_digitalzoom(icd, qctrl,&val_offset) != 0)\r
3512                         return -EINVAL;\r
3513                     sensor->info_priv.digitalzoom += val_offset;\r
3514 \r
3515                     SENSOR_DG("%s digitalzoom is %x\n",SENSOR_NAME_STRING(),  sensor->info_priv.digitalzoom);\r
3516                 }\r
3517 \r
3518                 break;\r
3519             }\r
3520         case V4L2_CID_ZOOM_RELATIVE:\r
3521             {\r
3522                 if (ext_ctrl->value)\r
3523                 {\r
3524                     if (sensor_set_digitalzoom(icd, qctrl,&ext_ctrl->value) != 0)\r
3525                         return -EINVAL;\r
3526                     sensor->info_priv.digitalzoom += ext_ctrl->value;\r
3527 \r
3528                     SENSOR_DG("%s digitalzoom is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.digitalzoom);\r
3529                 }\r
3530                 break;\r
3531             }\r
3532 #endif\r
3533 #if CONFIG_SENSOR_Focus\r
3534         case V4L2_CID_FOCUS_ABSOLUTE:\r
3535             {\r
3536                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))\r
3537                     return -EINVAL;\r
3538 \r
3539                 if (ext_ctrl->value != sensor->info_priv.focus)\r
3540                 {\r
3541                     val_offset = ext_ctrl->value -sensor->info_priv.focus;\r
3542 \r
3543                     sensor->info_priv.focus += val_offset;\r
3544                 }\r
3545 \r
3546                 break;\r
3547             }\r
3548         case V4L2_CID_FOCUS_RELATIVE:\r
3549             {\r
3550                 if (ext_ctrl->value)\r
3551                 {\r
3552                     sensor->info_priv.focus += ext_ctrl->value;\r
3553 \r
3554                     SENSOR_DG("%s focus is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.focus);\r
3555                 }\r
3556                 break;\r
3557             }\r
3558 #endif\r
3559 #if CONFIG_SENSOR_Flash\r
3560         case V4L2_CID_FLASH:\r
3561             {\r
3562                 if (sensor_set_flash(icd, qctrl,ext_ctrl->value) != 0)\r
3563                     return -EINVAL;\r
3564                 sensor->info_priv.flash = ext_ctrl->value;\r
3565 \r
3566                 SENSOR_DG("%s flash is %x\n",SENSOR_NAME_STRING(), sensor->info_priv.flash);\r
3567                 break;\r
3568             }\r
3569 #endif\r
3570         default:\r
3571             break;\r
3572     }\r
3573 \r
3574     return 0;\r
3575 }\r
3576 \r
3577 static int sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)\r
3578 {\r
3579     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
3580     struct soc_camera_device *icd = client->dev.platform_data;\r
3581     int i, error_cnt=0, error_idx=-1;\r
3582 \r
3583 \r
3584     for (i=0; i<ext_ctrl->count; i++) {\r
3585         if (sensor_g_ext_control(icd, &ext_ctrl->controls[i]) != 0) {\r
3586             error_cnt++;\r
3587             error_idx = i;\r
3588         }\r
3589     }\r
3590 \r
3591     if (error_cnt > 1)\r
3592         error_idx = ext_ctrl->count;\r
3593 \r
3594     if (error_idx != -1) {\r
3595         ext_ctrl->error_idx = error_idx;\r
3596         return -EINVAL;\r
3597     } else {\r
3598         return 0;\r
3599     }\r
3600 }\r
3601 \r
3602 static int sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)\r
3603 {\r
3604     struct i2c_client *client = v4l2_get_subdevdata(sd);\r
3605     struct soc_camera_device *icd = client->dev.platform_data;\r
3606     int i, error_cnt=0, error_idx=-1;\r
3607 \r
3608 \r
3609     for (i=0; i<ext_ctrl->count; i++) {\r
3610         if (sensor_s_ext_control(icd, &ext_ctrl->controls[i]) != 0) {\r
3611             error_cnt++;\r
3612             error_idx = i;\r
3613         }\r
3614     }\r
3615 \r
3616     if (error_cnt > 1)\r
3617         error_idx = ext_ctrl->count;\r
3618 \r
3619     if (error_idx != -1) {\r
3620         ext_ctrl->error_idx = error_idx;\r
3621         return -EINVAL;\r
3622     } else {\r
3623         return 0;\r
3624     }\r
3625 }\r
3626 \r
3627 /* Interface active, can use i2c. If it fails, it can indeed mean, that\r
3628  * this wasn't our capture interface, so, we wait for the right one */\r
3629 static int sensor_video_probe(struct soc_camera_device *icd,\r
3630                                struct i2c_client *client)\r
3631 {\r
3632     int ret;\r
3633     \r
3634 \r
3635     /* We must have a parent by now. And it cannot be a wrong one.\r
3636      * So this entire test is completely redundant. */\r
3637     if (!icd->dev.parent ||\r
3638             to_soc_camera_host(icd->dev.parent)->nr != icd->iface)\r
3639                 return -ENODEV;\r
3640 \r
3641         if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {\r
3642                 ret = -ENODEV;\r
3643                 goto sensor_video_probe_err;\r
3644         }\r
3645 #if 0\r
3646     /* soft reset */\r
3647     ret = sensor_write(client, 0x3012, 0x80);\r
3648     if (ret != 0)\r
3649     {\r
3650         SENSOR_TR("soft reset %s failed\n",SENSOR_NAME_STRING());\r
3651         return -ENODEV;\r
3652     }\r
3653     mdelay(5);          //delay 5 microseconds\r
3654 \r
3655     /* check if it is an sensor sensor */\r
3656     ret = sensor_read(client, 0x300a, &value);\r
3657     if (ret != 0) {\r
3658         SENSOR_TR("read chip id high byte failed\n");\r
3659         ret = -ENODEV;\r
3660         goto sensor_video_probe_err;\r
3661     }\r
3662 \r
3663     \r
3664     ret = sensor_read(client, 0x01, &value);\r
3665     if (ret != 0) {\r
3666         SENSOR_TR("read chip id low byte failed\n");\r
3667         ret = -ENODEV;\r
3668         goto sensor_video_probe_err;\r
3669     }\r
3670 \r
3671     pid = (value & 0xff);\r
3672     SENSOR_DG("\n %s  pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
3673     if (pid == SENSOR_ID) {\r
3674         sensor->model = SENSOR_V4L2_IDENT;\r
3675     } else {\r
3676         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
3677         ret = -ENODEV;\r
3678         goto sensor_video_probe_err;\r
3679     }\r
3680 #endif\r
3681 \r
3682     return 0;\r
3683 \r
3684 sensor_video_probe_err:\r
3685 \r
3686     return ret;\r
3687 }\r
3688 static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)\r
3689 {\r
3690         struct i2c_client *client = v4l2_get_subdevdata(sd);\r
3691     struct soc_camera_device *icd = client->dev.platform_data;\r
3692     struct sensor *sensor = to_sensor(client);\r
3693     int ret = 0;\r
3694 #if CONFIG_SENSOR_Flash \r
3695     int i;\r
3696 #endif\r
3697     \r
3698         SENSOR_DG("\n%s..%s..cmd:%x \n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);\r
3699         switch (cmd)\r
3700         {\r
3701                 case RK29_CAM_SUBDEV_DEACTIVATE:\r
3702                 {\r
3703                         sensor_deactivate(client);\r
3704                         break;\r
3705                 }\r
3706 \r
3707                 case RK29_CAM_SUBDEV_IOREQUEST:\r
3708                 {\r
3709                         sensor->sensor_io_request = (struct rk29camera_platform_data*)arg;           \r
3710             if (sensor->sensor_io_request != NULL) { \r
3711                 sensor->sensor_gpio_res = NULL;\r
3712                 for (i=0; i<RK29_CAM_SUPPORT_NUMS;i++) {\r
3713                     if (sensor->sensor_io_request->gpio_res[i].dev_name && \r
3714                         (strcmp(sensor->sensor_io_request->gpio_res[i].dev_name, dev_name(icd->pdev)) == 0)) {\r
3715                         sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[i];\r
3716                     }\r
3717                 }\r
3718                 if (sensor->sensor_gpio_res == NULL) {\r
3719                     SENSOR_TR("%s %s obtain gpio resource failed when RK29_CAM_SUBDEV_IOREQUEST \n",SENSOR_NAME_STRING(),__FUNCTION__);\r
3720                     ret = -EINVAL;\r
3721                     goto sensor_ioctl_end;\r
3722                 }\r
3723             } else {\r
3724                 SENSOR_TR("%s %s RK29_CAM_SUBDEV_IOREQUEST fail\n",SENSOR_NAME_STRING(),__FUNCTION__);\r
3725                 ret = -EINVAL;\r
3726                 goto sensor_ioctl_end;\r
3727             }\r
3728             /* ddl@rock-chips.com : if gpio_flash havn't been set in board-xxx.c, sensor driver must notify is not support flash control \r
3729                for this project */\r
3730             #if CONFIG_SENSOR_Flash     \r
3731                 if (sensor->sensor_gpio_res) { \r
3732                 if (sensor->sensor_gpio_res->gpio_flash == INVALID_GPIO) {\r
3733                     for (i = 0; i < icd->ops->num_controls; i++) {\r
3734                                 if (V4L2_CID_FLASH == icd->ops->controls[i].id) {\r
3735                                         //memset((char*)&icd->ops->controls[i],0x00,sizeof(struct v4l2_queryctrl));  \r
3736                               sensor_controls[i].id=0xffff;                             \r
3737                                 }\r
3738                     }\r
3739                     sensor->info_priv.flash = 0xff;\r
3740                     SENSOR_DG("%s flash gpio is invalidate!\n",SENSOR_NAME_STRING());\r
3741                 }else{ //two cameras are the same,need to deal diffrently ,zyc\r
3742                     for (i = 0; i < icd->ops->num_controls; i++) {\r
3743                            if(0xffff == icd->ops->controls[i].id){\r
3744                               sensor_controls[i].id=V4L2_CID_FLASH;\r
3745                            }               \r
3746                     }\r
3747                 }\r
3748                 }\r
3749             #endif\r
3750                         break;\r
3751                 }\r
3752                 default:\r
3753                 {\r
3754                         SENSOR_TR("%s %s cmd(0x%x) is unknown !\n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);\r
3755                         break;\r
3756                 }\r
3757         }\r
3758 sensor_ioctl_end:\r
3759         return ret;\r
3760 \r
3761 }\r
3762 static int sensor_enum_fmt(struct v4l2_subdev *sd, unsigned int index,\r
3763                             enum v4l2_mbus_pixelcode *code)\r
3764 {\r
3765         if (index >= ARRAY_SIZE(sensor_colour_fmts))\r
3766                 return -EINVAL;\r
3767 \r
3768         *code = sensor_colour_fmts[index].code;\r
3769         return 0;\r
3770 }\r
3771 static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {\r
3772         .init           = sensor_init,\r
3773         .g_ctrl         = sensor_g_control,\r
3774         .s_ctrl         = sensor_s_control,\r
3775         .g_ext_ctrls          = sensor_g_ext_controls,\r
3776         .s_ext_ctrls          = sensor_s_ext_controls,\r
3777         .g_chip_ident   = sensor_g_chip_ident,\r
3778         .ioctl = sensor_ioctl,\r
3779 };\r
3780 \r
3781 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {\r
3782         .s_mbus_fmt     = sensor_s_fmt,\r
3783         .g_mbus_fmt     = sensor_g_fmt,\r
3784         .try_mbus_fmt   = sensor_try_fmt,\r
3785         .enum_mbus_fmt  = sensor_enum_fmt,\r
3786 };\r
3787 \r
3788 static struct v4l2_subdev_ops sensor_subdev_ops = {\r
3789         .core   = &sensor_subdev_core_ops,\r
3790         .video = &sensor_subdev_video_ops,\r
3791 };\r
3792 \r
3793 static int sensor_probe(struct i2c_client *client,\r
3794                          const struct i2c_device_id *did)\r
3795 {\r
3796     struct sensor *sensor;\r
3797     struct soc_camera_device *icd = client->dev.platform_data;\r
3798     struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);\r
3799     struct soc_camera_link *icl;\r
3800     int ret;\r
3801 \r
3802     SENSOR_DG("\n%s..%s..%d..\n",__FUNCTION__,__FILE__,__LINE__);\r
3803     if (!icd) {\r
3804         dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());\r
3805         return -EINVAL;\r
3806     }\r
3807 \r
3808     icl = to_soc_camera_link(icd);\r
3809     if (!icl) {\r
3810         dev_err(&client->dev, "%s driver needs platform data\n", SENSOR_NAME_STRING());\r
3811         return -EINVAL;\r
3812     }\r
3813 \r
3814     if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {\r
3815         dev_warn(&adapter->dev,\r
3816                  "I2C-Adapter doesn't support I2C_FUNC_I2C\n");\r
3817         return -EIO;\r
3818     }\r
3819 \r
3820     sensor = kzalloc(sizeof(struct sensor), GFP_KERNEL);\r
3821     if (!sensor)\r
3822         return -ENOMEM;\r
3823 \r
3824     v4l2_i2c_subdev_init(&sensor->subdev, client, &sensor_subdev_ops);\r
3825 \r
3826     /* Second stage probe - when a capture adapter is there */\r
3827     icd->ops            = &sensor_ops;\r
3828     sensor->info_priv.fmt = sensor_colour_fmts[0];\r
3829         #if CONFIG_SENSOR_I2C_NOSCHED\r
3830         atomic_set(&sensor->tasklock_cnt,0);\r
3831         #endif\r
3832 \r
3833     ret = sensor_video_probe(icd, client);\r
3834     if (ret < 0) {\r
3835         icd->ops = NULL;\r
3836         i2c_set_clientdata(client, NULL);\r
3837         kfree(sensor);\r
3838                 sensor = NULL;\r
3839     }\r
3840         hrtimer_init(&(flash_off_timer.timer), CLOCK_MONOTONIC, HRTIMER_MODE_REL);\r
3841     SENSOR_DG("\n%s..%s..%d  ret = %x \n",__FUNCTION__,__FILE__,__LINE__,ret);\r
3842     return ret;\r
3843 }\r
3844 \r
3845 static int sensor_remove(struct i2c_client *client)\r
3846 {\r
3847     struct sensor *sensor = to_sensor(client);\r
3848     struct soc_camera_device *icd = client->dev.platform_data;\r
3849 \r
3850     icd->ops = NULL;\r
3851     i2c_set_clientdata(client, NULL);\r
3852     client->driver = NULL;\r
3853     kfree(sensor);\r
3854         sensor = NULL;\r
3855     return 0;\r
3856 }\r
3857 \r
3858 static const struct i2c_device_id sensor_id[] = {\r
3859         {SENSOR_NAME_STRING(), 0 },\r
3860         { }\r
3861 };\r
3862 MODULE_DEVICE_TABLE(i2c, sensor_id);\r
3863 \r
3864 static struct i2c_driver sensor_i2c_driver = {\r
3865         .driver = {\r
3866                 .name = SENSOR_NAME_STRING(),\r
3867         },\r
3868         .probe          = sensor_probe,\r
3869         .remove         = sensor_remove,\r
3870         .id_table       = sensor_id,\r
3871 };\r
3872 \r
3873 static int __init sensor_mod_init(void)\r
3874 {\r
3875     SENSOR_DG("\n%s..%s.. \n",__FUNCTION__,SENSOR_NAME_STRING());\r
3876     return i2c_add_driver(&sensor_i2c_driver);\r
3877 }\r
3878 \r
3879 static void __exit sensor_mod_exit(void)\r
3880 {\r
3881     i2c_del_driver(&sensor_i2c_driver);\r
3882 }\r
3883 \r
3884 device_initcall_sync(sensor_mod_init);\r
3885 module_exit(sensor_mod_exit);\r
3886 \r
3887 MODULE_DESCRIPTION(SENSOR_NAME_STRING(Camera sensor driver));\r
3888 MODULE_AUTHOR("ddl <kernel@rock-chips>");\r
3889 MODULE_LICENSE("GPL");\r