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 <mach/rk29_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       640                     /* Sensor pixel size for sensor_init_data array */\r
  54 #define SENSOR_INIT_HEIGHT  480\r
  55 #define SENSOR_INIT_WINSEQADR sensor_vga\r
  56 #define SENSOR_INIT_PIXFMT V4L2_PIX_FMT_UYVY\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         0\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 struct reginfo\r
  93 {\r
  94     u8 reg;\r
  95     u8 val;\r
  96 };\r
  97 \r
  98 /* init 352X288 SVGA */\r
  99 static struct reginfo sensor_init_data[] =\r
 100 {\r
 101        {0x00,  0x00},  \r
 102         {0x04,  0x00},  //Group A 0x10\r
 103         {0x05,  0x0F},  //UXGA Output\r
 104         {0x06,  0x86}, \r
 105         {0x07,  0x08}, \r
 106 \r
 107 \r
 108         {0x08,  0xa2},  //PLL off\r
 109         {0x09,  0x12},  \r
 110         {0x0A,  0x12},  \r
 111         {0x10,  0x17},  \r
 112         {0x11,  0x01}, \r
 113         {0x12,  0x8A}, \r
 114         {0x13,  0x1a}, \r
 115         {0x14,  0x27}, \r
 116         {0x15,  0x22}, \r
 117 \r
 118         {0x17,  0xCb},  \r
 119         {0x18,  0x38},  \r
 120         \r
 121         {0x40,  0x0f}, \r
 122         {0x41,  0x17}, \r
 123         {0x42,  0x52}, \r
 124         {0x43,  0x80}, \r
 125         {0x44,  0x00}, \r
 126         {0x45,  0x00}, \r
 127 \r
 128 //Flicker - 50Hz  - Still mode ,     \r
 129         {0x00,  0x00}, \r
 130         {0x20,  0x00}, \r
 131         {0x21,  0x02}, \r
 132         {0x23,  0x29},//15}, \r
 133         {0x00,  0x01}, \r
 134         {0x35,  0x50},//3c}, \r
 135 \r
 136 //Flicker - 50Hz - Preview mode 24MHz MCLK\r
 137         {0x00,  0x00}, \r
 138         {0x24,  0x00}, \r
 139         {0x25,  0xe6},//10}, \r
 140         {0x27,  0x0d},//4b}, \r
 141         {0x00,  0x01}, \r
 142         {0x34,  0x80},//64}, \r
 143 \r
 144 \r
 145 //AE Block \r
 146         {0x00,  0x01}, \r
 147         {0x10,  0x00}, \r
 148         {0x11,  0x0a}, //.0c\r
 149         {0x12,  0x78}, \r
 150         {0x13,  0x78}, \r
 151         {0x14,  0x78}, \r
 152         {0x17,  0xC4}, \r
 153         {0x1c,  0x05},    \r
 154 \r
 155         {0x36,  0x28},  //26\r
 156 \r
 157         {0x40,  0x40},  //Max Again  //anyuan\r
 158         //{0x41,  0x20}, \r
 159         //{0x42,  0x20}, \r
 160         //{0x43,  0x00}, \r
 161         //{0x44,  0x00}, \r
 162         //{0x45,  0x01}, \r
 163         //{0x46,  0x1c}, \r
 164         //{0x47,  0x11}, \r
 165         //{0x48,  0x15}, \r
 166         //{0x49,  0x17}, \r
 167         //{0x4A,  0x1a}, \r
 168         //{0x4B,  0x1c}, \r
 169         //{0x4C,  0x1e}, \r
 170         //{0x4D,  0x1e}, \r
 171         //{0x4E,  0x0f}, \r
 172         //{0x4F,  0x09}, \r
 173         //{0x50,  0x07}, \r
 174         //{0x51,  0x05}, \r
 175         //{0x52,  0x04}, \r
 176         //{0x53,  0x03}, \r
 177         //{0x54,  0x02}, \r
 178         //{0x55,  0x01}, \r
 179         //{0x66,  0x00}, \r
 180         //{0x67,  0x00}, \r
 181         //{0x68,  0x00}, \r
 182         //{0x69,  0x00}, \r
 183         //{0x6a,  0x00}, \r
 184         //{0x6b,  0x00},\r
 185 \r
 186         {0x70,  0xc4}, \r
 187         {0x73,  0x22}, \r
 188         {0x74,  0x07}, \r
 189         {0x77,  0xd0}, \r
 190         {0x78,  0xd8}, \r
 191         {0x79,  0x70}, \r
 192   //\r
 193         {0x90,  0x00}, \r
 194         {0x92,  0x0c}, //0bank 0x11 °ú µ¿ÀÏ \r
 195         {0x95,  0x40},  //0 bank 0x40 °ú µ¿ÀÏ  \r
 196         //AWB Block\r
 197 \r
 198         {0x00,  0x02}, \r
 199         {0x10,  0xD3}, \r
 200         {0x11,  0x11}, \r
 201         {0x13,  0x7e}, \r
 202         {0x14,  0x7c}, \r
 203         {0x15,  0xee}, \r
 204         {0x16,  0x80}, \r
 205         {0x17,  0xd0}, \r
 206         {0x18,  0x80}, \r
 207         {0x19,  0x98}, \r
 208         {0x1A,  0x68}, \r
 209         {0x1B,  0x98}, \r
 210         {0x1C,  0x68}, \r
 211         {0x1D,  0x90}, \r
 212         {0x1E,  0x74}, \r
 213         {0x20,  0xF0}, \r
 214         {0x21,  0x85}, \r
 215         {0x22,  0xB4}, \r
 216         {0x23,  0x20}, \r
 217         {0x25,  0x20}, \r
 218         {0x26,  0x05}, \r
 219         {0x27,  0x78}, \r
 220         {0x28,  0xd8}, \r
 221         {0x29,  0xb8}, \r
 222         {0x2A,  0x88}, \r
 223         {0x30,  0x00}, \r
 224         {0x31,  0x10}, \r
 225         {0x32,  0x00}, \r
 226         {0x33,  0x10}, \r
 227         {0x34,  0x06}, \r
 228         {0x35,  0x30}, \r
 229         {0x36,  0x04}, \r
 230         {0x37,  0xA0}, \r
 231         {0x40,  0x01}, \r
 232         {0x41,  0x04}, \r
 233         {0x42,  0x08}, \r
 234         {0x43,  0x10}, \r
 235         {0x44,  0x13}, \r
 236         {0x45,  0x6B}, \r
 237         {0x46,  0x82},  \r
 238 \r
 239 \r
 240 \r
 241 //CMA change  -D65~A\r
 242         {0x53,  0xa1},  //AWB R Gain for D30 to D20\r
 243         {0x54,  0xc0},  //AWB B Gain for D30 to D20\r
 244         {0x55,  0xa1},  //AWB R Gain for D20 to D30\r
 245         {0x56,  0xc0},  //AWB B Gain for D20 to D30\r
 246         {0x57,  0xc8},  //AWB R Gain for D65 to D30\r
 247         {0x58,  0xa0},  //AWB B Gain for D65 to D30\r
 248         {0x59,  0xc8},  //AWB R Gain for D30 to D65\r
 249         {0x5A,  0xa0},  //AWB B Gain for D30 to D65\r
 250 \r
 251   {0x64,  0x00},\r
 252   {0x65,  0x00},\r
 253   {0x66,  0x00},\r
 254   {0x67,  0x00},\r
 255   {0x68,  0xa5},\r
 256   {0x69,  0xb4},\r
 257   {0x6a,  0xb3},\r
 258   {0x6b,  0xac},\r
 259   {0x6c,  0xb7},\r
 260   {0x6d,  0x98},\r
 261   {0x6e,  0xba},\r
 262   {0x6f,  0x90},\r
 263   \r
 264   {0x70,  0xbf},\r
 265   {0x71,  0x9b},\r
 266   {0x72,  0xce},\r
 267   {0x73,  0x8c},\r
 268   {0x74,  0x7f},\r
 269   {0x75,  0x8c},\r
 270   {0x76,  0xad},\r
 271   {0x77,  0xba},\r
 272   {0x78,  0x8f},\r
 273   {0x79,  0x9a},\r
 274   {0x7A,  0xa3},\r
 275   {0x7B,  0xac},\r
 276   {0x7C,  0xa0},\r
 277   {0x7D,  0xa9},\r
 278   {0x7E,  0x95},\r
 279   {0x7F,  0xac},\r
 280   {0x80,  0xad},\r
 281   {0x81,  0xbc},\r
 282   {0x82,  0x98},\r
 283   {0x83,  0xa4},\r
 284   {0x84,  0x00},\r
 285   {0x85,  0x00},\r
 286   {0x86,  0x00},\r
 287   {0x87,  0x00},\r
 288   {0x88,  0xc9},\r
 289   {0x89,  0xd5},\r
 290   {0x8a,  0x70},\r
 291   {0x8b,  0x7b},\r
 292   {0x8c,  0xd0},\r
 293   {0x8d,  0xe5},\r
 294   {0x8e,  0x58},\r
 295   {0x8f,  0x70},\r
 296     \r
 297         {0xB4,  0x05},  \r
 298         {0xB5,  0x0F},  \r
 299         {0xB6,  0x06},  \r
 300         {0xB7,  0x06},  \r
 301         {0xB8,  0x40},  \r
 302         {0xB9,  0x10},  \r
 303         {0xBA,  0x06},  \r
 304 \r
 305 //IDP\r
 306         {0x00,  0x03}, \r
 307         {0x10,  0xFF}, \r
 308         {0x11,  0x1D}, \r
 309         {0x12,  0x1D}, \r
 310         {0x13,  0xFF}, \r
 311         {0x14,  0x00}, \r
 312         {0x15,  0xc0}, \r
 313 \r
 314 //DPC\r
 315         {0x30,  0x88},  //DPCNRCTRL\r
 316         {0x31,  0x14},  //DPTHR @ AGAIN = 00\r
 317         {0x32,  0x10},  //DPTHR @ AGAIN = 20\r
 318         {0x33,  0x0c},  //DPTHR @ AGAIN = 40\r
 319         {0x34,  0x08},  //DPTHR @ AGAIN = 60\r
 320         {0x35,  0x04},  //DPTHR @ AGAIN = 80\r
 321         {0x36,  0x44},  //DPTHVRNG\r
 322         {0x37,  0x66},  //DPNUMBER\r
 323         {0x38,  0x00},  //0x00  // NRTHR0 @ AGAIN = 00\r
 324         {0x39,  0x04},  //0x0C  // NRTHR1 @ AGAIN = 20\r
 325         {0x3A,  0x04},  //0x18  // NRTHR2 @ AGAIN = 40\r
 326         {0x3B,  0x2c},  //0x30  // NRTHR3 @ AGAIN = 60\r
 327         {0x3C,  0x3c},  //                 NRTHR4 @ AGAIN = 80\r
 328         {0x3D,  0x04},  //NRTHVRNG0 @ AGAIN = 00\r
 329         {0x3E,  0x04},  //NRTHVRNG1 @ AGAIN = 20\r
 330         {0x3F,  0x04},  //NRTHVRNG2 @ AGAIN = 40\r
 331         {0x40,  0x2c},  //NRTHVRNG3 @ AGAIN = 60\r
 332         {0x41,  0x3c},  //NRTHVRNG4 @ AGAIN = 80\r
 333         {0x42,  0xff},  //NRTHVRNGMAX\r
 334         {0x43,  0x40},  //NRTHRWGT\r
 335         {0x44,  0x40},  //BASELVL\r
 336         {0x45,  0x06},  //SHUMAXH\r
 337         {0x46,  0x40},  //SHUMAXL\r
 338         {0x47,  0x30},  //ILLUMITHDRK\r
 339 \r
 340 // shading\r
 341         {0x50,  0x0a},  //0x00      \r
 342         {0x51,  0x20},  //0x45  \r
 343         {0x52,  0x12},  //0x24      \r
 344         {0x53,  0x12},  //0x24 \r
 345                                       \r
 346         {0x54,  0x22},  //0x00      \r
 347         {0x55,  0x18},  //0x40  \r
 348         {0x56,  0x08},  //0x10      \r
 349         {0x57,  0x10},  //0x20 \r
 350                                         \r
 351         {0x58,  0x22},  //0x00      \r
 352         {0x59,  0x18},  //0x40  \r
 353         {0x5A,  0x08},  //0x10      \r
 354         {0x5B,  0x10},  //0x20 \r
 355                                        \r
 356         {0x5C,  0x25},  //0x04      \r
 357         {0x5D,  0x1a},  //0x55  \r
 358         {0x5E,  0x12},  //0x25    \r
 359         {0x5F,  0x10},  //0x20 \r
 360              \r
 361         {0x60,  0x32},  //0x32                   \r
 362         {0x61,  0x20},  //20//\r
 363         {0x62,  0x58},  //67\r
 364 //      {0x63,  0x89 //8c R Center start gain\r
 365 //      {0x66,  0x79 //B Center start gain   73               \r
 366         {0x6B,  0x00}, //01 //01                 \r
 367         {0x6C,  0x01}, //22                   \r
 368         {0x6D,  0x23}, //22                   \r
 369         {0x6E,  0x55}, //55                   \r
 370         {0x6F,  0x55}, //77                   \r
 371         {0x70,  0x55}, //65                   \r
 372         {0x71,  0x00}, //01 //AB (6)               \r
 373         {0x72,  0x01}, //23     (5)             \r
 374         {0x73,  0x23}, //33     (4)            \r
 375         {0x74,  0x44}, //45     (3)             \r
 376         {0x75,  0x45}, //55     (2)               \r
 377         {0x76,  0x66}, //55     (1)             \r
 378         {0x77,  0x00}, //01 //AB (6)                 \r
 379         {0x78,  0x01}, //23     (5)              \r
 380         {0x79,  0x23}, //33     (4)              \r
 381         {0x7A,  0x44}, //45     (3)              \r
 382         {0x7B,  0x45}, //55     (2)                \r
 383         {0x7C,  0x66}, //55     (1)              \r
 384         {0x7D,  0x00}, //00    //00                   \r
 385         {0x7E,  0x00}, //00    //00                   \r
 386         {0x7F,  0x12}, //11    //12                   \r
 387         {0x80,  0x33}, //33    //33 //44               \r
 388         {0x81,  0x44}, //33    //33 //44                  \r
 389         {0x82,  0x55}, //22    //44 //45 \r
 390         //{0x83,  0x14}, \r
 391         //{0x84,  0x0f}, \r
 392 \r
 393         {0x94,0x02},\r
 394         {0x95,0x80},\r
 395         {0x96,0x01},\r
 396         {0x97,0xe0}, \r
 397 \r
 398 //Interpolation\r
 399         {0xA0,  0x3F},\r
 400         {0xA1,  0x05},\r
 401         {0xA2,  0xB7},\r
 402         {0xA3,  0xB7},\r
 403         {0xA4,  0x04},\r
 404         {0xA5,  0xFF},\r
 405         {0xA6,  0x04},\r
 406         {0xA7,  0xFF},\r
 407         {0xA8,  0x00},\r
 408         {0xA9,  0x00},\r
 409         {0xAA,  0x00},\r
 410         {0xAB,  0x00},\r
 411         {0xAC,  0x60},\r
 412         {0xAD,  0x18},\r
 413         {0xAE,  0x10},\r
 414         {0xAF,  0x20},\r
 415         {0xB0,  0x08},\r
 416         {0xB1,  0x00},\r
 417 \r
 418 //Color Matrix for D65\r
 419 #if 0\r
 420         {0xC0,  0x2F}, // CMASB D20 or D30 or Dark Condition Color Matrix Selection\r
 421         {0xC1,  0x66}, \r
 422         {0xC2,  0xd4}, \r
 423         {0xC3,  0x05}, \r
 424         {0xC4,  0xf0}, \r
 425         {0xC5,  0x5a}, \r
 426         {0xC6,  0xf5}, \r
 427         {0xC7,  0xf9}, \r
 428         {0xC8,  0xbf}, \r
 429         {0xC9,  0x88}, \r
 430         {0xCA,  0xa0}, \r
 431         {0xCB,  0x50}, \r
 432         {0xCC,  0xe2}, \r
 433         {0xCD,  0x00}, \r
 434         {0xCE,  0x00}, \r
 435 #else\r
 436 {0xC0,  0x2F}, // CMASB D20 or D30 or Dark Condition Color Matrix Selection\r
 437 {0xC1,  0x71}, \r
 438 {0xC2,  0xcc}, \r
 439 {0xC3,  0x01}, \r
 440 {0xC4,  0xe8}, \r
 441 {0xC5,  0x68}, \r
 442 {0xC6,  0xef}, \r
 443 {0xC7,  0xfa}, \r
 444 {0xC8,  0xc6}, \r
 445 {0xC9,  0x7e}, \r
 446 {0xCA,  0xec}, \r
 447 {0xCB,  0x67}, \r
 448 {0xCC,  0x34}, \r
 449 {0xCD,  0x3a}, \r
 450 {0xCE,  0x08},\r
 451 \r
 452 #endif\r
 453 //Color Matrix for CWF\r
 454         {0xD0,  0x2F}, \r
 455         {0xD1,  0x66}, \r
 456         {0xD2,  0xd4}, \r
 457         {0xD3,  0x05}, \r
 458         {0xD4,  0xf0}, \r
 459         {0xD5,  0x5a}, \r
 460         {0xD6,  0xf5}, \r
 461         {0xD7,  0xe9}, \r
 462         {0xD8,  0xbf}, \r
 463         {0xD9,  0x88},\r
 464         {0xDA,  0xa0}, \r
 465         {0xDB,  0x50}, \r
 466         {0xDC,  0xe2}, \r
 467         {0xDD,  0x00}, \r
 468         {0xDE,  0x00}, \r
 469 \r
 470 //Color Matrix for A\r
 471         {0xE0,  0x2F}, \r
 472         {0xE1,  0x6e}, \r
 473         {0xE2,  0xc7}, \r
 474         {0xE3,  0x0d}, \r
 475         {0xE4,  0xe3}, \r
 476         {0xE5,  0x61}, \r
 477         {0xE6,  0xfa}, \r
 478         {0xE7,  0xe5}, \r
 479         {0xE8,  0xcb}, \r
 480         {0xE9,  0x8e}, \r
 481         {0xEA,  0xc4}, \r
 482         {0xEB,  0x04}, \r
 483         {0xEC,  0xf3}, \r
 484         {0xED,  0xdd}, \r
 485         {0xEE,  0x06}, \r
 486 \r
 487 //IDP 4\r
 488         {0x00,  0x04}, \r
 489 \r
 490 //Gamma - r   \r
 491         {0x10,  0x00}, \r
 492         {0x11,  0x04}, \r
 493         {0x12,  0x10},\r
 494         {0x13,  0x20},\r
 495         {0x14,  0x40},\r
 496         {0x15,  0x5c},\r
 497         {0x16,  0x74},\r
 498         {0x17,  0x84},\r
 499         {0x18,  0x98},\r
 500         {0x19,  0xa4},\r
 501         {0x1A,  0xb0},\r
 502         {0x1B,  0xc8},\r
 503         {0x1C,  0xdc},\r
 504         {0x1D,  0xf0},\r
 505         {0x1E,  0xf8},\r
 506         {0x1F,  0xFF},\r
 507                         \r
 508 //Gamma - G             \r
 509         {0x20,  0x00}, \r
 510         {0x21,  0x04}, \r
 511         {0x22,  0x10},\r
 512         {0x23,  0x20},\r
 513         {0x24,  0x40},\r
 514         {0x25,  0x5c},\r
 515         {0x26,  0x74},\r
 516         {0x27,  0x84},\r
 517         {0x28,  0x98},\r
 518         {0x29,  0xa4},\r
 519         {0x2A,  0xb0},\r
 520         {0x2B,  0xc8},\r
 521         {0x2C,  0xdc},\r
 522         {0x2D,  0xf0},\r
 523         {0x2E,  0xf8},\r
 524         {0x2F,  0xFF},\r
 525                         \r
 526 //Gamma - B             \r
 527         {0x30,  0x00}, \r
 528         {0x31,  0x04}, \r
 529         {0x32,  0x10},\r
 530         {0x33,  0x20},\r
 531         {0x34,  0x40},\r
 532         {0x35,  0x5c},\r
 533         {0x36,  0x74},\r
 534         {0x37,  0x84},\r
 535         {0x38,  0x98},\r
 536         {0x39,  0xa4},\r
 537         {0x3A,  0xb0},\r
 538         {0x3B,  0xc8},\r
 539         {0x3C,  0xdc},\r
 540         {0x3D,  0xf0},\r
 541         {0x3E,  0xf8},\r
 542         {0x3F,  0xFF},\r
 543 \r
 544 //DARK GAMMA\r
 545         {0x40,  0x00}, \r
 546         {0x41,  0x0b}, \r
 547         {0x42,  0x15},\r
 548         {0x43,  0x29},\r
 549         {0x44,  0x47},\r
 550         {0x45,  0x5D},\r
 551         {0x46,  0x72},\r
 552         {0x47,  0x83},\r
 553         {0x48,  0x92},\r
 554         {0x49,  0xA0},\r
 555         {0x4A,  0xac},\r
 556         {0x4B,  0xc6},\r
 557         {0x4C,  0xdA},\r
 558         {0x4D,  0xeC},\r
 559         {0x4E,  0xf6},\r
 560         {0x4F,  0xFF},\r
 561   \r
 562         {0x50,  0x00}, //DARK GAMMA on/off\r
 563         \r
 564 //CSC                   \r
 565         {0x60,  0x33}, \r
 566         {0x61,  0x20}, \r
 567         {0x62,  0xE4}, \r
 568         {0x63,  0xFA}, \r
 569         {0x64,  0x13}, \r
 570         {0x65,  0x25}, \r
 571         {0x66,  0x07}, \r
 572         {0x67,  0xF5}, \r
 573         {0x68,  0xEA}, \r
 574         {0x69,  0x20}, \r
 575         {0x6A,  0xC8}, \r
 576         {0x6B,  0xC4}, \r
 577         {0x6C,  0x84}, \r
 578         {0x6D,  0x04}, \r
 579         {0x6E,  0x0C}, \r
 580         {0x6F,  0x00}, \r
 581                         \r
 582 //Edge                  \r
 583 // {0x70,  0x00},\r
 584 // {0x71,  0x18},\r
 585 // {0x72,  0x18},\r
 586 // {0x73,  0x04},\r
 587 // {0x74,  0x08},\r
 588 // {0x76,  0x20},\r
 589 // {0x77,  0x04},\r
 590 // {0x78,  0x08},\r
 591 // {0x7a,  0x20},\r
 592 // {0x7d,  0x08},\r
 593 // {0X7e,  0x30},\r
 594 \r
 595         {0x80,  0x22}, \r
 596         {0x81,  0x14}, \r
 597         {0x82,  0x14}, \r
 598         {0x83,  0x04}, \r
 599         {0x84,  0x06}, \r
 600         {0x85,  0x06}, \r
 601         {0x87,  0x04},\r
 602         {0x88,  0x10},\r
 603         {0x89,  0x06},\r
 604         {0X90,  0x06},\r
 605         {0x91,  0x03},\r
 606         {0x93,  0xe0},\r
 607 \r
 608 //Cr/Cb Coring\r
 609         {0x94,  0x00}, \r
 610         {0x95,  0x00}, \r
 611         {0x96,  0x4C}, \r
 612         {0x97,  0x76}, \r
 613         {0x9A,  0xf5}, \r
 614 \r
 615         {0xA1,  0x08},   //@ 0\r
 616         {0xA2,  0x10},   //@ 20\r
 617         {0xA3,  0x16},   //@ 40\r
 618         {0xA4,  0x20},   //@ 60\r
 619         {0xA5,  0x30},   //@ 80\r
 620         {0xA6,  0xa0}, \r
 621         {0xA7,  0x06}, \r
 622         {0xA8,  0x40}, \r
 623 \r
 624         {0xA9,  0x38}, \r
 625         {0xAa,  0x35}, \r
 626 \r
 627         {0xAc,  0xff}, \r
 628         {0xAd,  0x09}, \r
 629         {0xAe,  0x96}, \r
 630         {0xAf,  0x18}, \r
 631 \r
 632         {0xB2,  0x38},   //color suppression start\r
 633         {0xB3,  0x53}, \r
 634         {0xB6,  0x00}, \r
 635         \r
 636 //Color Saturation\r
 637         {0xBC, 0x10}, \r
 638         {0xBD, 0x10}, \r
 639         {0xBE, 0x10}, \r
 640         {0xBF, 0x10}, \r
 641         {0xc0, 0x10}, \r
 642         {0xc1, 0x10},   \r
 643         {0xc2, 0x10}, \r
 644         {0xc3, 0x10}, \r
 645         {0xc4, 0x10}, \r
 646         {0xc5, 0x10}, \r
 647 \r
 648         {0xcc, 0x04}, \r
 649         {0xcd, 0x40}, \r
 650         {0xce, 0x00}, \r
 651                       \r
 652 //IDP 3                 \r
 653         {0x00,  0x05}, \r
 654                         \r
 655 //Memory                \r
 656         {0x40,  0x15}, \r
 657         {0x41,  0x28}, \r
 658         {0x42,  0x04}, \r
 659         {0x43,  0x15}, \r
 660         {0x44,  0x28}, \r
 661         {0x45,  0x04}, \r
 662         {0x46,  0x15}, \r
 663         {0x47,  0x28}, \r
 664         {0x48,  0x04}, \r
 665                         \r
 666 //Knee                  \r
 667         {0x90,  0xca},  //\r
 668         {0x91,  0x81},  //knee function selection/knee point H\r
 669         {0x92,  0x00},  //knee point L\r
 670         {0x93,  0x50},  //Knee gain\r
 671         {0x94,  0x41},  //[6:4]knee start H/[2:0]Knee END H\r
 672         {0x95,  0x7e},  //knee start L\r
 673         {0x96,  0x48},  //knee END L\r
 674                         \r
 675 //ADG                   \r
 676         {0x99,  0xC0}, \r
 677         {0xA0,  0x10}, \r
 678         {0xA1,  0x22}, \r
 679         {0xA2,  0x36}, \r
 680         {0xA3,  0x49}, \r
 681         {0xA4,  0x5D}, \r
 682         {0xA5,  0x70}, \r
 683         {0xA6,  0x82}, \r
 684         {0xA7,  0x94}, \r
 685         {0xA8,  0xA5}, \r
 686         {0xA9,  0xB5}, \r
 687         {0xAA,  0xC3}, \r
 688         {0xAB,  0xD1}, \r
 689         {0xAC,  0xDE}, \r
 690         {0xAD,  0xEA}, \r
 691         {0xAE,  0xF5}, \r
 692         {0xAF,  0xFF}, \r
 693                         \r
 694 //YXGMA                 \r
 695         {0xB0,  0xc0},  //YGMACTRL\r
 696         {0xB1,  0x04},  //YGMASLOP\r
 697         {0xB8,  0x0f},  //DRKTHR1\r
 698         {0xB9,  0x10},  //DRKTHR2\r
 699         //{0xBA,  0x38},  //DRKTHR3\r
 700         //{0xBB,  0x39},  //DRKTHR4\r
 701         {0xC0,  0x03}, \r
 702         {0xC1,  0x0E}, \r
 703         {0xC2,  0x16}, \r
 704         {0xC3,  0x24}, \r
 705         {0xC4,  0x3F}, \r
 706         {0xC5,  0x56}, \r
 707         {0xC6,  0x6A}, \r
 708         {0xC7,  0x7C}, \r
 709         {0xC8,  0x8C}, \r
 710         {0xC9,  0x98}, \r
 711         {0xCA,  0xA2}, \r
 712         {0xCB,  0xB8}, \r
 713         {0xCC,  0xCD}, \r
 714         {0xCD,  0xE2}, \r
 715         {0xCE,  0xF0}, \r
 716         {0xCF,  0xFF}, \r
 717 \r
 718 \r
 719 // edge value adjustment\r
 720         {0xe0,  0x81}, \r
 721         {0xe1,  0x83}, \r
 722         {0xe2,  0x07}, \r
 723         {0xe3,  0x0c}, \r
 724         {0xe4,  0x14}, \r
 725         {0xe5,  0x1c}, \r
 726 \r
 727 \r
 728 //Sensor on\r
 729         {0x00,  0x00}, \r
 730         {0x03,  0xc5}, \r
 731         {0x00,  0x01}, \r
 732         {0x10,  0x84}, \r
 733         {0x00,  0x02}, \r
 734         {0x10,  0xd3}, \r
 735         {0xff,  0xff}, \r
 736 \r
 737 \r
 738 };\r
 739 \r
 740 /* 1600X1200 UXGA */\r
 741 static struct reginfo sensor_uxga[] =\r
 742 {\r
 743    {0x00,0x00},\r
 744    {0x04,0x10},\r
 745    {0x05,0x8f},\r
 746    {0x00,0x03},\r
 747    {0x94,0x06},\r
 748    {0x95,0x40},\r
 749    {0x96,0x04},\r
 750    {0x97,0xb0}, \r
 751    {0xff, 0xff},\r
 752 };\r
 753 \r
 754 /* 1280X1024 SXGA */\r
 755 static struct reginfo sensor_sxga[] =\r
 756 {\r
 757        {0x00,0x00},\r
 758        {0x04,0x10},\r
 759        {0x05,0x8b},\r
 760         {0x00,0x03},\r
 761         {0x94,0x05},\r
 762         {0x95,0x00},\r
 763         {0x96,0x04},\r
 764         {0x97,0x00}, \r
 765         {0xff, 0xff}, \r
 766 };\r
 767 static struct reginfo sensor_xga[] =\r
 768 {\r
 769         {0xff, 0xff}\r
 770 };\r
 771 /* 800X600 SVGA*/\r
 772 static struct reginfo sensor_svga[] =\r
 773 {\r
 774     {0x00,0x03},\r
 775     {0x94,0x03},\r
 776     {0x95,0x20},\r
 777     {0x96,0x02},\r
 778     {0x97,0x58}, \r
 779     {0xff, 0xff}\r
 780 };\r
 781 \r
 782 /* 640X480 VGA */\r
 783 static struct reginfo sensor_vga[] =\r
 784 {\r
 785       {0x00,0x00},\r
 786       {0x04,0x00},\r
 787       {0x05,0x0f},\r
 788       {0x00,0x03},\r
 789       {0x94,0x02}, //0x02\r
 790       {0x95,0x80}, //0x80\r
 791       {0x96,0x01},//0x01\r
 792       {0x97,0xe0}, //0xe0\r
 793       {0xff, 0xff}, \r
 794 };\r
 795 \r
 796 /* 352X288 CIF */\r
 797 static struct reginfo sensor_cif[] =\r
 798 {\r
 799     {0x00,0x03},\r
 800     {0x94,0x01},\r
 801     {0x95,0x60},\r
 802     {0x96,0x01},\r
 803     {0x97,0x20}, \r
 804     {0xff, 0xff}, \r
 805 };\r
 806 \r
 807 /* 320*240 QVGA */\r
 808 static  struct reginfo sensor_qvga[] =\r
 809 {\r
 810        {0x00,0x03},\r
 811        {0x94,0x01},\r
 812        {0x95,0x40},\r
 813        {0x96,0x00},\r
 814        {0x97,0xf0}, \r
 815        {0xff, 0xff}, \r
 816 };\r
 817 \r
 818 /* 176X144 QCIF*/\r
 819 static struct reginfo sensor_qcif[] =\r
 820 {\r
 821        {0x00,0x03},\r
 822        {0x94,0x00},\r
 823        {0x95,0xB0},\r
 824        {0x96,0x00},\r
 825        {0x97,0x90}, \r
 826        {0xff, 0xff},\r
 827 };\r
 828 \r
 829 static  struct reginfo sensor_ClrFmt_YUYV[]=\r
 830 {\r
 831     {0xff, 0xff}\r
 832 };\r
 833 \r
 834 static  struct reginfo sensor_ClrFmt_UYVY[]=\r
 835 {\r
 836     {0xff, 0xff}\r
 837 };\r
 838 \r
 839 #if CONFIG_SENSOR_WhiteBalance\r
 840 static  struct reginfo sensor_WhiteB_Auto[]={\r
 841     {0x00, 0x02},\r
 842     {0x10, 0xd3},\r
 843     {0xff, 0xff}\r
 844 };\r
 845 /* Cloudy Colour Temperature : 6500K - 8000K  */\r
 846 static  struct reginfo sensor_WhiteB_Cloudy[]=\r
 847 {\r
 848     {0x00, 0x02},\r
 849     {0x10, 0x00},\r
 850     {0x50, 0xd0},\r
 851     {0x51, 0x88},\r
 852     {0xff, 0xff}\r
 853 };\r
 854 /* ClearDay Colour Temperature : 5000K - 6500K  */\r
 855 static  struct reginfo sensor_WhiteB_ClearDay[]=\r
 856 {\r
 857     {0x00, 0x02},\r
 858     {0x10, 0x00},\r
 859     {0x50, 0xaa},\r
 860     {0x51, 0x90},\r
 861     {0xff, 0xff}\r
 862 \r
 863 };\r
 864 /* Office Colour Temperature : 3500K - 5000K  */\r
 865 static  struct reginfo sensor_WhiteB_TungstenLamp1[]=\r
 866 {\r
 867     {0x00, 0x02},\r
 868     {0x10, 0x00},\r
 869     {0x50, 0xc2},\r
 870     {0x51, 0x9e},\r
 871     {0xff, 0xff}\r
 872 };\r
 873 /* Home Colour Temperature : 2500K - 3500K  */\r
 874 static  struct reginfo sensor_WhiteB_TungstenLamp2[]=\r
 875 {\r
 876     {0x00, 0x02},\r
 877     {0x10, 0x00},\r
 878     {0x50, 0xaa},\r
 879     {0x51, 0xbe},\r
 880     {0xff, 0xff}\r
 881 };\r
 882 static struct reginfo *sensor_WhiteBalanceSeqe[] = {sensor_WhiteB_Auto, sensor_WhiteB_TungstenLamp1,sensor_WhiteB_TungstenLamp2,\r
 883     sensor_WhiteB_ClearDay, sensor_WhiteB_Cloudy,NULL,\r
 884 };\r
 885 #endif\r
 886 \r
 887 #if CONFIG_SENSOR_Brightness\r
 888 static  struct reginfo sensor_Brightness0[]=\r
 889 {\r
 890     // Brightness -2\r
 891     {0x00, 0x04},\r
 892     {0xb6, 0xa0},\r
 893     {0xff, 0xff}\r
 894 \r
 895 };\r
 896 \r
 897 static  struct reginfo sensor_Brightness1[]=\r
 898 {\r
 899     // Brightness -1\r
 900     {0x00, 0x04},\r
 901     {0xb6, 0x90},\r
 902     {0xff, 0xff}\r
 903 \r
 904 };\r
 905 \r
 906 static  struct reginfo sensor_Brightness2[]=\r
 907 {\r
 908     //  Brightness 0\r
 909     {0x00, 0x04},\r
 910     {0xb6, 0x00},\r
 911     {0xff, 0xff}\r
 912 \r
 913 };\r
 914 \r
 915 static  struct reginfo sensor_Brightness3[]=\r
 916 {\r
 917     // Brightness +1\r
 918    {0x00, 0x04},\r
 919    {0xb6, 0x10},\r
 920    {0xff, 0xff}\r
 921 \r
 922 };\r
 923 \r
 924 static  struct reginfo sensor_Brightness4[]=\r
 925 {\r
 926     //  Brightness +2\r
 927    {0x00, 0x04},\r
 928    {0xb6, 0x20},\r
 929    {0xff, 0xff}\r
 930 \r
 931 };\r
 932 \r
 933 static  struct reginfo sensor_Brightness5[]=\r
 934 {\r
 935    {0x00, 0x04},\r
 936    {0xb6, 0x30},\r
 937    {0xff, 0xff}\r
 938 };\r
 939 static struct reginfo *sensor_BrightnessSeqe[] = {sensor_Brightness0, sensor_Brightness1, sensor_Brightness2, sensor_Brightness3,\r
 940     sensor_Brightness4, sensor_Brightness5,NULL,\r
 941 };\r
 942 \r
 943 #endif\r
 944 \r
 945 #if CONFIG_SENSOR_Effect\r
 946 static  struct reginfo sensor_Effect_Normal[] =\r
 947 {\r
 948     {0x00, 0x04},\r
 949     {0xd9, 0x00},\r
 950     {0xff, 0xff}\r
 951 };\r
 952 \r
 953 static  struct reginfo sensor_Effect_WandB[] =\r
 954 {\r
 955     {0x00, 0x04},\r
 956     {0xd9, 0x40},\r
 957     {0x00, 0x00},\r
 958     {0xff, 0xff}\r
 959 };\r
 960 \r
 961 static  struct reginfo sensor_Effect_Sepia[] =\r
 962 {\r
 963     {0x00, 0x04},\r
 964     {0xd9, 0x80},\r
 965     {0xda, 0x60},\r
 966     {0xdb, 0xa0},\r
 967     {0xff, 0xff}\r
 968 };\r
 969 \r
 970 static  struct reginfo sensor_Effect_Negative[] =\r
 971 {\r
 972    {0x00, 0x04},\r
 973    {0xd9, 0x20},\r
 974    {0xff, 0xff}\r
 975 };\r
 976 static  struct reginfo sensor_Effect_Bluish[] =\r
 977 {\r
 978     // Bluish\r
 979     {0x00, 0x04},\r
 980     {0xd9, 0x80},\r
 981     {0xda, 0xc0},\r
 982     {0xdb, 0x60},\r
 983     {0xff, 0xff}\r
 984 };\r
 985 \r
 986 static  struct reginfo sensor_Effect_Green[] =\r
 987 {\r
 988     //  Greenish\r
 989     {0x00, 0x04},\r
 990     {0xd9, 0x80},\r
 991     {0xda, 0x50},\r
 992     {0xdb, 0x50},\r
 993     {0xff, 0xff}\r
 994 };\r
 995 static struct reginfo *sensor_EffectSeqe[] = {sensor_Effect_Normal, sensor_Effect_WandB, sensor_Effect_Negative,sensor_Effect_Sepia,\r
 996     sensor_Effect_Bluish, sensor_Effect_Green,NULL,\r
 997 };\r
 998 #endif\r
 999 #if CONFIG_SENSOR_Exposure\r
1000 static  struct reginfo sensor_Exposure0[]=\r
1001 {\r
1002     //-3\r
1003    {0xff, 0xff}\r
1004 };\r
1005 \r
1006 static  struct reginfo sensor_Exposure1[]=\r
1007 {\r
1008     //-2\r
1009     {0xff, 0xff}\r
1010 };\r
1011 \r
1012 static  struct reginfo sensor_Exposure2[]=\r
1013 {\r
1014     //-0.3EV\r
1015    {0xff, 0xff}\r
1016 };\r
1017 \r
1018 static  struct reginfo sensor_Exposure3[]=\r
1019 {\r
1020     //default\r
1021   {0xff, 0xff}\r
1022 };\r
1023 \r
1024 static  struct reginfo sensor_Exposure4[]=\r
1025 {\r
1026     // 1\r
1027   {0xff, 0xff}\r
1028 };\r
1029 \r
1030 static  struct reginfo sensor_Exposure5[]=\r
1031 {\r
1032     // 2\r
1033   {0xff, 0xff}\r
1034 };\r
1035 \r
1036 static  struct reginfo sensor_Exposure6[]=\r
1037 {\r
1038     // 3\r
1039    {0xff, 0xff}\r
1040 };\r
1041 \r
1042 static struct reginfo *sensor_ExposureSeqe[] = {sensor_Exposure0, sensor_Exposure1, sensor_Exposure2, sensor_Exposure3,\r
1043     sensor_Exposure4, sensor_Exposure5,sensor_Exposure6,NULL,\r
1044 };\r
1045 #endif\r
1046 #if CONFIG_SENSOR_Saturation\r
1047 static  struct reginfo sensor_Saturation0[]=\r
1048 {\r
1049     {0xff, 0xff}\r
1050 };\r
1051 \r
1052 static  struct reginfo sensor_Saturation1[]=\r
1053 {\r
1054    {0xff, 0xff}\r
1055 };\r
1056 \r
1057 static  struct reginfo sensor_Saturation2[]=\r
1058 {\r
1059   {0xff, 0xff}\r
1060 };\r
1061 static struct reginfo *sensor_SaturationSeqe[] = {sensor_Saturation0, sensor_Saturation1, sensor_Saturation2, NULL,};\r
1062 \r
1063 #endif\r
1064 #if CONFIG_SENSOR_Contrast\r
1065 static  struct reginfo sensor_Contrast0[]=\r
1066 {\r
1067     {0xff, 0xff}\r
1068 };\r
1069 \r
1070 static  struct reginfo sensor_Contrast1[]=\r
1071 {\r
1072    {0xff, 0xff}\r
1073 };\r
1074 \r
1075 static  struct reginfo sensor_Contrast2[]=\r
1076 {\r
1077     {0xff, 0xff}\r
1078 };\r
1079 \r
1080 static  struct reginfo sensor_Contrast3[]=\r
1081 {\r
1082     {0xff, 0xff}\r
1083 };\r
1084 \r
1085 static  struct reginfo sensor_Contrast4[]=\r
1086 {\r
1087    {0xff, 0xff}\r
1088 };\r
1089 \r
1090 \r
1091 static  struct reginfo sensor_Contrast5[]=\r
1092 {\r
1093     {0xff, 0xff}\r
1094 };\r
1095 \r
1096 static  struct reginfo sensor_Contrast6[]=\r
1097 {\r
1098     {0xff, 0xff}\r
1099 };\r
1100 static struct reginfo *sensor_ContrastSeqe[] = {sensor_Contrast0, sensor_Contrast1, sensor_Contrast2, sensor_Contrast3,\r
1101     sensor_Contrast4, sensor_Contrast5, sensor_Contrast6, NULL,\r
1102 };\r
1103 \r
1104 #endif\r
1105 #if CONFIG_SENSOR_Mirror\r
1106 static  struct reginfo sensor_MirrorOn[]=\r
1107 {\r
1108     {0xff, 0xff}\r
1109 };\r
1110 \r
1111 static  struct reginfo sensor_MirrorOff[]=\r
1112 {\r
1113      {0xff, 0xff}\r
1114 };\r
1115 static struct reginfo *sensor_MirrorSeqe[] = {sensor_MirrorOff, sensor_MirrorOn,NULL,};\r
1116 #endif\r
1117 #if CONFIG_SENSOR_Flip\r
1118 static  struct reginfo sensor_FlipOn[]=\r
1119 {\r
1120     {0xff, 0xff}\r
1121 };\r
1122 \r
1123 static  struct reginfo sensor_FlipOff[]=\r
1124 {\r
1125      {0xff, 0xff}\r
1126 };\r
1127 static struct reginfo *sensor_FlipSeqe[] = {sensor_FlipOff, sensor_FlipOn,NULL,};\r
1128 \r
1129 #endif\r
1130 #if CONFIG_SENSOR_Scene\r
1131 static  struct reginfo sensor_SceneAuto[] =\r
1132 {\r
1133    {0x00, 0x01},\r
1134    {0x11, 0x0a},\r
1135    {0x00, 0x04},\r
1136    {0xb6, 0x00},\r
1137    {0xff, 0xff}\r
1138 };\r
1139 \r
1140 static  struct reginfo sensor_SceneNight[] =\r
1141 {\r
1142    {0x00, 0x01},\r
1143    {0x11, 0x14},\r
1144    {0x00, 0x04},\r
1145    {0xb6, 0x10},\r
1146    {0xff, 0xff}\r
1147 };\r
1148 static struct reginfo *sensor_SceneSeqe[] = {sensor_SceneAuto, sensor_SceneNight,NULL,};\r
1149 \r
1150 #endif\r
1151 #if CONFIG_SENSOR_DigitalZoom\r
1152 static struct reginfo sensor_Zoom0[] =\r
1153 {\r
1154     {0xff, 0xff}\r
1155 };\r
1156 \r
1157 static struct reginfo sensor_Zoom1[] =\r
1158 {\r
1159      {0xff, 0xff}\r
1160 };\r
1161 \r
1162 static struct reginfo sensor_Zoom2[] =\r
1163 {\r
1164     {0xff, 0xff}\r
1165 };\r
1166 \r
1167 \r
1168 static struct reginfo sensor_Zoom3[] =\r
1169 {\r
1170     {0xff, 0xff}\r
1171 };\r
1172 static struct reginfo *sensor_ZoomSeqe[] = {sensor_Zoom0, sensor_Zoom1, sensor_Zoom2, sensor_Zoom3, NULL,};\r
1173 #endif\r
1174 static const struct v4l2_querymenu sensor_menus[] =\r
1175 {\r
1176         #if CONFIG_SENSOR_WhiteBalance\r
1177     { .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
1178     { .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
1179     { .id = V4L2_CID_DO_WHITE_BALANCE,  .index = 4,  .name = "cloudy-daylight", .reserved = 0,},\r
1180     #endif\r
1181 \r
1182         #if CONFIG_SENSOR_Effect\r
1183     { .id = V4L2_CID_EFFECT,  .index = 0,  .name = "none",  .reserved = 0, }, {  .id = V4L2_CID_EFFECT,  .index = 1, .name = "mono",  .reserved = 0,},\r
1184     { .id = V4L2_CID_EFFECT,  .index = 2,  .name = "negative", .reserved = 0,}, {  .id = V4L2_CID_EFFECT, .index = 3,  .name = "sepia", .reserved = 0,},\r
1185     { .id = V4L2_CID_EFFECT,  .index = 4, .name = "posterize", .reserved = 0,} ,{ .id = V4L2_CID_EFFECT,  .index = 5,  .name = "aqua", .reserved = 0,},\r
1186     #endif\r
1187 \r
1188         #if CONFIG_SENSOR_Scene\r
1189     { .id = V4L2_CID_SCENE,  .index = 0, .name = "auto", .reserved = 0,} ,{ .id = V4L2_CID_SCENE,  .index = 1,  .name = "night", .reserved = 0,},\r
1190     #endif\r
1191 \r
1192         #if CONFIG_SENSOR_Flash\r
1193     { .id = V4L2_CID_FLASH,  .index = 0,  .name = "off",  .reserved = 0, }, {  .id = V4L2_CID_FLASH,  .index = 1, .name = "auto",  .reserved = 0,},\r
1194     { .id = V4L2_CID_FLASH,  .index = 2,  .name = "on", .reserved = 0,}, {  .id = V4L2_CID_FLASH, .index = 3,  .name = "torch", .reserved = 0,},\r
1195     #endif\r
1196 };\r
1197 \r
1198 static const struct v4l2_queryctrl sensor_controls[] =\r
1199 {\r
1200         #if CONFIG_SENSOR_WhiteBalance\r
1201     {\r
1202         .id             = V4L2_CID_DO_WHITE_BALANCE,\r
1203         .type           = V4L2_CTRL_TYPE_MENU,\r
1204         .name           = "White Balance Control",\r
1205         .minimum        = 0,\r
1206         .maximum        = 4,\r
1207         .step           = 1,\r
1208         .default_value = 0,\r
1209     },\r
1210     #endif\r
1211 \r
1212         #if CONFIG_SENSOR_Brightness\r
1213         {\r
1214         .id             = V4L2_CID_BRIGHTNESS,\r
1215         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1216         .name           = "Brightness Control",\r
1217         .minimum        = -3,\r
1218         .maximum        = 2,\r
1219         .step           = 1,\r
1220         .default_value = 0,\r
1221     },\r
1222     #endif\r
1223 \r
1224         #if CONFIG_SENSOR_Effect\r
1225         {\r
1226         .id             = V4L2_CID_EFFECT,\r
1227         .type           = V4L2_CTRL_TYPE_MENU,\r
1228         .name           = "Effect Control",\r
1229         .minimum        = 0,\r
1230         .maximum        = 5,\r
1231         .step           = 1,\r
1232         .default_value = 0,\r
1233     },\r
1234         #endif\r
1235 \r
1236         #if CONFIG_SENSOR_Exposure\r
1237         {\r
1238         .id             = V4L2_CID_EXPOSURE,\r
1239         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1240         .name           = "Exposure Control",\r
1241         .minimum        = 0,\r
1242         .maximum        = 6,\r
1243         .step           = 1,\r
1244         .default_value = 0,\r
1245     },\r
1246         #endif\r
1247 \r
1248         #if CONFIG_SENSOR_Saturation\r
1249         {\r
1250         .id             = V4L2_CID_SATURATION,\r
1251         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1252         .name           = "Saturation Control",\r
1253         .minimum        = 0,\r
1254         .maximum        = 2,\r
1255         .step           = 1,\r
1256         .default_value = 0,\r
1257     },\r
1258     #endif\r
1259 \r
1260         #if CONFIG_SENSOR_Contrast\r
1261         {\r
1262         .id             = V4L2_CID_CONTRAST,\r
1263         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1264         .name           = "Contrast Control",\r
1265         .minimum        = -3,\r
1266         .maximum        = 3,\r
1267         .step           = 1,\r
1268         .default_value = 0,\r
1269     },\r
1270         #endif\r
1271 \r
1272         #if CONFIG_SENSOR_Mirror\r
1273         {\r
1274         .id             = V4L2_CID_HFLIP,\r
1275         .type           = V4L2_CTRL_TYPE_BOOLEAN,\r
1276         .name           = "Mirror Control",\r
1277         .minimum        = 0,\r
1278         .maximum        = 1,\r
1279         .step           = 1,\r
1280         .default_value = 1,\r
1281     },\r
1282     #endif\r
1283 \r
1284         #if CONFIG_SENSOR_Flip\r
1285         {\r
1286         .id             = V4L2_CID_VFLIP,\r
1287         .type           = V4L2_CTRL_TYPE_BOOLEAN,\r
1288         .name           = "Flip Control",\r
1289         .minimum        = 0,\r
1290         .maximum        = 1,\r
1291         .step           = 1,\r
1292         .default_value = 1,\r
1293     },\r
1294     #endif\r
1295 \r
1296         #if CONFIG_SENSOR_Scene\r
1297     {\r
1298         .id             = V4L2_CID_SCENE,\r
1299         .type           = V4L2_CTRL_TYPE_MENU,\r
1300         .name           = "Scene Control",\r
1301         .minimum        = 0,\r
1302         .maximum        = 1,\r
1303         .step           = 1,\r
1304         .default_value = 0,\r
1305     },\r
1306     #endif\r
1307 \r
1308         #if CONFIG_SENSOR_DigitalZoom\r
1309     {\r
1310         .id             = V4L2_CID_ZOOM_RELATIVE,\r
1311         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1312         .name           = "DigitalZoom Control",\r
1313         .minimum        = -1,\r
1314         .maximum        = 1,\r
1315         .step           = 1,\r
1316         .default_value = 0,\r
1317     }, {\r
1318         .id             = V4L2_CID_ZOOM_ABSOLUTE,\r
1319         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1320         .name           = "DigitalZoom Control",\r
1321         .minimum        = 0,\r
1322         .maximum        = 3,\r
1323         .step           = 1,\r
1324         .default_value = 0,\r
1325     },\r
1326     #endif\r
1327 \r
1328         #if CONFIG_SENSOR_Focus\r
1329         {\r
1330         .id             = V4L2_CID_FOCUS_RELATIVE,\r
1331         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1332         .name           = "Focus Control",\r
1333         .minimum        = -1,\r
1334         .maximum        = 1,\r
1335         .step           = 1,\r
1336         .default_value = 0,\r
1337     }, {\r
1338         .id             = V4L2_CID_FOCUS_ABSOLUTE,\r
1339         .type           = V4L2_CTRL_TYPE_INTEGER,\r
1340         .name           = "Focus Control",\r
1341         .minimum        = 0,\r
1342         .maximum        = 255,\r
1343         .step           = 1,\r
1344         .default_value = 125,\r
1345     },\r
1346     #endif\r
1347 \r
1348         #if CONFIG_SENSOR_Flash\r
1349         {\r
1350         .id             = V4L2_CID_FLASH,\r
1351         .type           = V4L2_CTRL_TYPE_MENU,\r
1352         .name           = "Flash Control",\r
1353         .minimum        = 0,\r
1354         .maximum        = 3,\r
1355         .step           = 1,\r
1356         .default_value = 0,\r
1357     },\r
1358         #endif\r
1359 };\r
1360 \r
1361 static int sensor_probe(struct i2c_client *client, const struct i2c_device_id *did);\r
1362 static int sensor_video_probe(struct soc_camera_device *icd, struct i2c_client *client);\r
1363 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);\r
1364 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);\r
1365 static int sensor_g_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);\r
1366 static int sensor_s_ext_controls(struct v4l2_subdev *sd,  struct v4l2_ext_controls *ext_ctrl);\r
1367 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg);\r
1368 static int sensor_resume(struct soc_camera_device *icd);\r
1369 static int sensor_set_bus_param(struct soc_camera_device *icd,unsigned long flags);\r
1370 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd);\r
1371 #if CONFIG_SENSOR_Effect\r
1372 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);\r
1373 #endif\r
1374 #if CONFIG_SENSOR_WhiteBalance\r
1375 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value);\r
1376 #endif\r
1377 static int sensor_deactivate(struct i2c_client *client);\r
1378 \r
1379 static struct soc_camera_ops sensor_ops =\r
1380 {\r
1381     .suspend                     = sensor_suspend,\r
1382     .resume                       = sensor_resume,\r
1383     .set_bus_param              = sensor_set_bus_param,\r
1384     .query_bus_param    = sensor_query_bus_param,\r
1385     .controls           = sensor_controls,\r
1386     .menus                         = sensor_menus,\r
1387     .num_controls               = ARRAY_SIZE(sensor_controls),\r
1388     .num_menus          = ARRAY_SIZE(sensor_menus),\r
1389 };\r
1390 \r
1391 #define COL_FMT(_name, _depth, _fourcc, _colorspace) \\r
1392         { .name = _name, .depth = _depth, .fourcc = _fourcc, \\r
1393         .colorspace = _colorspace }\r
1394 \r
1395 #define JPG_FMT(_name, _depth, _fourcc) \\r
1396         COL_FMT(_name, _depth, _fourcc, V4L2_COLORSPACE_JPEG)\r
1397 \r
1398 static const struct soc_camera_data_format sensor_colour_formats[] = {\r
1399         JPG_FMT(SENSOR_NAME_STRING(UYVY), 16, V4L2_PIX_FMT_UYVY),\r
1400         JPG_FMT(SENSOR_NAME_STRING(YUYV), 16, V4L2_PIX_FMT_YUYV),\r
1401 };\r
1402 \r
1403 typedef struct sensor_info_priv_s\r
1404 {\r
1405     int whiteBalance;\r
1406     int brightness;\r
1407     int contrast;\r
1408     int saturation;\r
1409     int effect;\r
1410     int scene;\r
1411     int digitalzoom;\r
1412     int focus;\r
1413     int flash;\r
1414     int exposure;\r
1415         bool snap2preview;\r
1416         bool video2preview;\r
1417     unsigned char mirror;                                        /* HFLIP */\r
1418     unsigned char flip;                                          /* VFLIP */\r
1419     unsigned int winseqe_cur_addr;\r
1420         unsigned int pixfmt;\r
1421 \r
1422 } sensor_info_priv_t;\r
1423 \r
1424 struct sensor\r
1425 {\r
1426     struct v4l2_subdev subdev;\r
1427     struct i2c_client *client;\r
1428     sensor_info_priv_t info_priv;\r
1429     int model;  /* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */\r
1430 #if CONFIG_SENSOR_I2C_NOSCHED\r
1431         atomic_t tasklock_cnt;\r
1432 #endif\r
1433         struct rk29camera_platform_data *sensor_io_request;\r
1434     struct rk29camera_gpio_res *sensor_gpio_res;\r
1435 };\r
1436 \r
1437 static struct sensor* to_sensor(const struct i2c_client *client)\r
1438 {\r
1439     return container_of(i2c_get_clientdata(client), struct sensor, subdev);\r
1440 }\r
1441 \r
1442 static int sensor_task_lock(struct i2c_client *client, int lock)\r
1443 {\r
1444 #if CONFIG_SENSOR_I2C_NOSCHED\r
1445         int cnt = 3;\r
1446     struct sensor *sensor = to_sensor(client);\r
1447 \r
1448         if (lock) {\r
1449                 if (atomic_read(&sensor->tasklock_cnt) == 0) {\r
1450                         while ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt>0)) {\r
1451                                 SENSOR_TR("\n %s will obtain i2c in atomic, but i2c bus is locked! Wait...\n",SENSOR_NAME_STRING());\r
1452                                 msleep(35);\r
1453                                 cnt--;\r
1454                         }\r
1455                         if ((atomic_read(&client->adapter->bus_lock.count) < 1) && (cnt<=0)) {\r
1456                                 SENSOR_TR("\n %s obtain i2c fail in atomic!!\n",SENSOR_NAME_STRING());\r
1457                                 goto sensor_task_lock_err;\r
1458                         }\r
1459                         preempt_disable();\r
1460                 }\r
1461 \r
1462                 atomic_add(1, &sensor->tasklock_cnt);\r
1463         } else {\r
1464                 if (atomic_read(&sensor->tasklock_cnt) > 0) {\r
1465                         atomic_sub(1, &sensor->tasklock_cnt);\r
1466 \r
1467                         if (atomic_read(&sensor->tasklock_cnt) == 0)\r
1468                                 preempt_enable();\r
1469                 }\r
1470         }\r
1471         return 0;\r
1472 sensor_task_lock_err:\r
1473         return -1;  \r
1474 #else\r
1475     return 0;\r
1476 #endif\r
1477 \r
1478 }\r
1479 \r
1480 /* sensor register write */\r
1481 static int sensor_write(struct i2c_client *client, u8 reg, u8 val)\r
1482 {\r
1483     int err,cnt;\r
1484     u8 buf[2];\r
1485     struct i2c_msg msg[1];\r
1486 \r
1487     //buf[0] = reg >> 8;\r
1488     buf[0] = reg & 0xFF;\r
1489     buf[1] = val;\r
1490 \r
1491     msg->addr = client->addr;\r
1492     msg->flags = client->flags;\r
1493     msg->buf = buf;\r
1494     msg->len = sizeof(buf);\r
1495     msg->scl_rate = CONFIG_SENSOR_I2C_SPEED;         /* ddl@rock-chips.com : 100kHz */\r
1496     msg->read_type = 0;               /* fpga i2c:0==I2C_NORMAL : direct use number not enum for don't want include spi_fpga.h */\r
1497 \r
1498     cnt = 3;\r
1499     err = -EAGAIN;\r
1500 \r
1501     while ((cnt-- > 0) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */\r
1502         err = i2c_transfer(client->adapter, msg, 1);\r
1503 \r
1504         if (err >= 0) {\r
1505             return 0;\r
1506         } else {\r
1507             SENSOR_TR("\n %s write reg(0x%x, val:0x%x) failed, try to write again!\n",SENSOR_NAME_STRING(),reg, val);\r
1508             udelay(10);\r
1509         }\r
1510     }\r
1511 \r
1512     return err;\r
1513 }\r
1514 \r
1515 /* sensor register read */\r
1516 static int sensor_read(struct i2c_client *client, u8 reg, u8 *val)\r
1517 {\r
1518     int err,cnt;\r
1519     u8 buf[1];\r
1520     struct i2c_msg msg[2];\r
1521 \r
1522    // buf[0] = reg >> 8;\r
1523     buf[0] = reg & 0xFF;\r
1524 \r
1525     msg[0].addr = client->addr;\r
1526     msg[0].flags = client->flags;\r
1527     msg[0].buf = buf;\r
1528     msg[0].len = sizeof(buf);\r
1529     msg[0].scl_rate = CONFIG_SENSOR_I2C_SPEED;       /* ddl@rock-chips.com : 100kHz */\r
1530     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
1531 \r
1532     msg[1].addr = client->addr;\r
1533     msg[1].flags = client->flags|I2C_M_RD;\r
1534     msg[1].buf = buf;\r
1535     msg[1].len = 1;\r
1536     msg[1].scl_rate = CONFIG_SENSOR_I2C_SPEED;                       /* ddl@rock-chips.com : 100kHz */\r
1537     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
1538 \r
1539     cnt = 3;\r
1540     err = -EAGAIN;\r
1541     while ((cnt-- > 0) && (err < 0)) {                       /* ddl@rock-chips.com :  Transfer again if transent is failed   */\r
1542         err = i2c_transfer(client->adapter, msg, 2);\r
1543 \r
1544         if (err >= 0) {\r
1545             *val = buf[0];\r
1546             return 0;\r
1547         } else {\r
1548                 SENSOR_TR("\n %s read reg(0x%x val:0x%x) failed, try to read again! \n",SENSOR_NAME_STRING(),reg, *val);\r
1549             udelay(10);\r
1550         }\r
1551     }\r
1552 \r
1553     return err;\r
1554 }\r
1555 \r
1556 /* write a array of registers  */\r
1557 static int sensor_write_array(struct i2c_client *client, struct reginfo *regarray)\r
1558 {\r
1559     int err = 0, cnt;\r
1560     int i = 0;\r
1561 #if CONFIG_SENSOR_I2C_RDWRCHK    \r
1562         char valchk;\r
1563 #endif\r
1564 \r
1565         cnt = 0;\r
1566         if (sensor_task_lock(client, 1) < 0)\r
1567                 goto sensor_write_array_end;\r
1568     while (regarray[i].reg != 0xff)\r
1569     {\r
1570         err = sensor_write(client, regarray[i].reg, regarray[i].val);\r
1571         if (err < 0)\r
1572         {\r
1573             if (cnt-- > 0) {\r
1574                             SENSOR_TR("%s..write failed current reg:0x%x, Write array again !\n", SENSOR_NAME_STRING(),regarray[i].reg);\r
1575                                 i = 0;\r
1576                                 continue;\r
1577             } else {\r
1578                 SENSOR_TR("%s..write array failed!!!\n", SENSOR_NAME_STRING());\r
1579                 err = -EPERM;\r
1580                                 goto sensor_write_array_end;\r
1581             }\r
1582         } else {\r
1583         #if CONFIG_SENSOR_I2C_RDWRCHK\r
1584                         sensor_read(client, regarray[i].reg, &valchk);\r
1585                         if (valchk != regarray[i].val)\r
1586                                 SENSOR_TR("%s Reg:0x%x write(0x%x, 0x%x) fail\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);\r
1587                 #endif\r
1588         }\r
1589         i++;\r
1590     }\r
1591 \r
1592 sensor_write_array_end:\r
1593         sensor_task_lock(client,0);\r
1594         return err;\r
1595 }\r
1596 #if CONFIG_SENSOR_I2C_RDWRCHK\r
1597 static int sensor_readchk_array(struct i2c_client *client, struct reginfo *regarray)\r
1598 {\r
1599     int cnt;\r
1600     int i = 0;\r
1601         char valchk;\r
1602 \r
1603         cnt = 0;\r
1604         valchk = 0;\r
1605     while (regarray[i].reg != 0xff)\r
1606     {\r
1607                 sensor_read(client, regarray[i].reg, &valchk);\r
1608                 if (valchk != regarray[i].val)\r
1609                         SENSOR_TR("%s Reg:0x%x read(0x%x, 0x%x) error\n",SENSOR_NAME_STRING(), regarray[i].reg, regarray[i].val, valchk);\r
1610 \r
1611         i++;\r
1612     }\r
1613     return 0;\r
1614 }\r
1615 #endif\r
1616 static int sensor_ioctrl(struct soc_camera_device *icd,enum rk29sensor_power_cmd cmd, int on)\r
1617 {\r
1618         struct soc_camera_link *icl = to_soc_camera_link(icd);\r
1619         int ret = 0;\r
1620 \r
1621     SENSOR_DG("%s %s  cmd(%d) on(%d)\n",SENSOR_NAME_STRING(),__FUNCTION__,cmd,on);\r
1622         switch (cmd)\r
1623         {\r
1624                 case Sensor_PowerDown:\r
1625                 {\r
1626                         if (icl->powerdown) {\r
1627                                 ret = icl->powerdown(icd->pdev, on);\r
1628                                 if (ret == RK29_CAM_IO_SUCCESS) {\r
1629                                         if (on == 0) {\r
1630                                                 mdelay(2);\r
1631                                                 if (icl->reset)\r
1632                                                         icl->reset(icd->pdev);\r
1633                                         }\r
1634                                 } else if (ret == RK29_CAM_EIO_REQUESTFAIL) {\r
1635                                         ret = -ENODEV;\r
1636                                         goto sensor_power_end;\r
1637                                 }\r
1638                         }\r
1639                         break;\r
1640                 }\r
1641                 case Sensor_Flash:\r
1642                 {\r
1643                         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
1644                 struct sensor *sensor = to_sensor(client);\r
1645 \r
1646                         if (sensor->sensor_io_request && sensor->sensor_io_request->sensor_ioctrl) {\r
1647                                 sensor->sensor_io_request->sensor_ioctrl(icd->pdev,Cam_Flash, on);\r
1648                         }\r
1649             break;\r
1650                 }\r
1651                 default:\r
1652                 {\r
1653                         SENSOR_TR("%s %s cmd(0x%x) is unknown!",SENSOR_NAME_STRING(),__FUNCTION__,cmd);\r
1654                         break;\r
1655                 }\r
1656         }\r
1657 sensor_power_end:\r
1658         return ret;\r
1659 }\r
1660 static int sensor_init(struct v4l2_subdev *sd, u32 val)\r
1661 {\r
1662     struct i2c_client *client = sd->priv;\r
1663     struct soc_camera_device *icd = client->dev.platform_data;\r
1664     struct sensor *sensor = to_sensor(client);\r
1665         const struct v4l2_queryctrl *qctrl;\r
1666     char value;\r
1667     int ret,pid = 0;\r
1668 \r
1669     SENSOR_DG("\n%s..%s.. \n",SENSOR_NAME_STRING(),__FUNCTION__);\r
1670 \r
1671      if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {\r
1672           ret = -ENODEV;\r
1673           goto sensor_INIT_ERR;\r
1674      }\r
1675      msleep(100);\r
1676 #if 0\r
1677     /* soft reset */\r
1678         if (sensor_task_lock(client,1)<0)\r
1679                 goto sensor_INIT_ERR;\r
1680     ret = sensor_write(client, 0x3012, 0x80);\r
1681     if (ret != 0)\r
1682     {\r
1683         SENSOR_TR("%s soft reset sensor failed\n",SENSOR_NAME_STRING());\r
1684         ret = -ENODEV;\r
1685                 goto sensor_INIT_ERR;\r
1686     }\r
1687 \r
1688     mdelay(5);  //delay 5 microseconds\r
1689         /* check if it is an sensor sensor */\r
1690     ret = sensor_read(client, 0x300a, &value);\r
1691     if (ret != 0) {\r
1692         SENSOR_TR("read chip id high byte failed\n");\r
1693         ret = -ENODEV;\r
1694         goto sensor_INIT_ERR;\r
1695     }\r
1696 \r
1697     pid |= (value << 8);\r
1698 \r
1699     ret = sensor_read(client, 0x300b, &value);\r
1700     if (ret != 0) {\r
1701         SENSOR_TR("read chip id low byte failed\n");\r
1702         ret = -ENODEV;\r
1703         goto sensor_INIT_ERR;\r
1704     }\r
1705 \r
1706     pid |= (value & 0xff);\r
1707     SENSOR_DG("\n %s  pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
1708     if (pid == SENSOR_ID) {\r
1709         sensor->model = SENSOR_V4L2_IDENT;\r
1710     } else {\r
1711         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
1712         ret = -ENODEV;\r
1713         goto sensor_INIT_ERR;\r
1714     }\r
1715 #endif\r
1716 #if 0\r
1717    sensor_read(client,0x01,&value);\r
1718     pid = (value & 0xff);\r
1719     SENSOR_DG("\n %s  pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
1720     if (pid == SENSOR_ID) {\r
1721         sensor->model = SENSOR_V4L2_IDENT;\r
1722     } else {\r
1723         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
1724         ret = -ENODEV;\r
1725         goto sensor_INIT_ERR;\r
1726     }\r
1727 #endif\r
1728     ret = sensor_write_array(client, sensor_init_data);\r
1729     if (ret != 0)\r
1730     {\r
1731         SENSOR_TR("error: %s initial failed\n",SENSOR_NAME_STRING());\r
1732         goto sensor_INIT_ERR;\r
1733     }\r
1734     sensor_task_lock(client,0);\r
1735    // icd->user_width = SENSOR_INIT_WIDTH;\r
1736     //icd->user_height = SENSOR_INIT_HEIGHT;\r
1737       sensor->info_priv.winseqe_cur_addr  = (int)SENSOR_INIT_WINSEQADR;\r
1738       sensor->info_priv.pixfmt = SENSOR_INIT_PIXFMT;\r
1739 \r
1740     /* sensor sensor information for initialization  */\r
1741         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
1742         if (qctrl)\r
1743         sensor->info_priv.whiteBalance = qctrl->default_value;\r
1744         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_BRIGHTNESS);\r
1745         if (qctrl)\r
1746         sensor->info_priv.brightness = qctrl->default_value;\r
1747         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
1748         if (qctrl)\r
1749         sensor->info_priv.effect = qctrl->default_value;\r
1750         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EXPOSURE);\r
1751         if (qctrl)\r
1752         sensor->info_priv.exposure = qctrl->default_value;\r
1753 \r
1754         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SATURATION);\r
1755         if (qctrl)\r
1756         sensor->info_priv.saturation = qctrl->default_value;\r
1757         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_CONTRAST);\r
1758         if (qctrl)\r
1759         sensor->info_priv.contrast = qctrl->default_value;\r
1760         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_HFLIP);\r
1761         if (qctrl)\r
1762         sensor->info_priv.mirror = qctrl->default_value;\r
1763         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_VFLIP);\r
1764         if (qctrl)\r
1765         sensor->info_priv.flip = qctrl->default_value;\r
1766         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_SCENE);\r
1767         if (qctrl)\r
1768         sensor->info_priv.scene = qctrl->default_value;\r
1769         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);\r
1770         if (qctrl)\r
1771         sensor->info_priv.digitalzoom = qctrl->default_value;\r
1772 \r
1773     /* ddl@rock-chips.com : if sensor support auto focus and flash, programer must run focus and flash code  */\r
1774         #if CONFIG_SENSOR_Focus\r
1775     sensor_set_focus();\r
1776     qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FOCUS_ABSOLUTE);\r
1777         if (qctrl)\r
1778         sensor->info_priv.focus = qctrl->default_value;\r
1779         #endif\r
1780 \r
1781         #if CONFIG_SENSOR_Flash\r
1782         sensor_set_flash();\r
1783         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_FLASH);\r
1784         if (qctrl)\r
1785         sensor->info_priv.flash = qctrl->default_value;\r
1786     #endif\r
1787 \r
1788     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
1789 \r
1790     return 0;\r
1791 sensor_INIT_ERR:\r
1792         sensor_task_lock(client,0);\r
1793         sensor_deactivate(client);\r
1794     return ret;\r
1795 }\r
1796 \r
1797 static int sensor_deactivate(struct i2c_client *client)\r
1798 {\r
1799         struct soc_camera_device *icd = client->dev.platform_data;\r
1800 \r
1801         SENSOR_DG("\n%s..%s.. Enter\n",SENSOR_NAME_STRING(),__FUNCTION__);\r
1802 \r
1803         /* ddl@rock-chips.com : all sensor output pin must change to input for other sensor */\r
1804         //sensor_task_lock(client, 1);\r
1805        //sensor_write(client, 0x30b0, 0x00);\r
1806         //sensor_write(client, 0x30b1, 0x00);\r
1807         //sensor_task_lock(client, 0);\r
1808         sensor_ioctrl(icd, Sensor_PowerDown, 1);\r
1809 \r
1810         /* ddl@rock-chips.com : sensor config init width , because next open sensor quickly(soc_camera_open -> Try to configure with default parameters) */\r
1811         icd->user_width = SENSOR_INIT_WIDTH;\r
1812        icd->user_height = SENSOR_INIT_HEIGHT;\r
1813         msleep(100);\r
1814         return 0;\r
1815 }\r
1816 \r
1817 static  struct reginfo sensor_power_down_sequence[]=\r
1818 {\r
1819     {0xff,0xff}\r
1820 };\r
1821 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg)\r
1822 {\r
1823     int ret;\r
1824     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
1825 \r
1826     if (pm_msg.event == PM_EVENT_SUSPEND) {\r
1827         SENSOR_DG("\n %s Enter Suspend.. \n", SENSOR_NAME_STRING());\r
1828         ret = sensor_write_array(client, sensor_power_down_sequence) ;\r
1829         if (ret != 0) {\r
1830             SENSOR_TR("\n %s..%s WriteReg Fail.. \n", SENSOR_NAME_STRING(),__FUNCTION__);\r
1831             return ret;\r
1832         } else {\r
1833             ret = sensor_ioctrl(icd, Sensor_PowerDown, 1);\r
1834             if (ret < 0) {\r
1835                             SENSOR_TR("\n %s suspend fail for turn on power!\n", SENSOR_NAME_STRING());\r
1836                 return -EINVAL;\r
1837             }\r
1838         }\r
1839     } else {\r
1840         SENSOR_TR("\n %s cann't suppout Suspend..\n",SENSOR_NAME_STRING());\r
1841         return -EINVAL;\r
1842     }\r
1843     return 0;\r
1844 }\r
1845 \r
1846 static int sensor_resume(struct soc_camera_device *icd)\r
1847 {\r
1848         int ret;\r
1849 \r
1850     ret = sensor_ioctrl(icd, Sensor_PowerDown, 0);\r
1851     if (ret < 0) {\r
1852                 SENSOR_TR("\n %s resume fail for turn on power!\n", SENSOR_NAME_STRING());\r
1853         return -EINVAL;\r
1854     }\r
1855 \r
1856         SENSOR_DG("\n %s Enter Resume.. \n", SENSOR_NAME_STRING());\r
1857 \r
1858     return 0;\r
1859 \r
1860 }\r
1861 \r
1862 static int sensor_set_bus_param(struct soc_camera_device *icd,\r
1863                                 unsigned long flags)\r
1864 {\r
1865 \r
1866     return 0;\r
1867 }\r
1868 \r
1869 static unsigned long sensor_query_bus_param(struct soc_camera_device *icd)\r
1870 {\r
1871     struct soc_camera_link *icl = to_soc_camera_link(icd);\r
1872     unsigned long flags = SENSOR_BUS_PARAM;\r
1873 \r
1874     return soc_camera_apply_sensor_flags(icl, flags);\r
1875 }\r
1876 \r
1877 static int sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)\r
1878 {\r
1879     struct i2c_client *client = sd->priv;\r
1880     struct soc_camera_device *icd = client->dev.platform_data;\r
1881     struct sensor *sensor = to_sensor(client);\r
1882     struct v4l2_pix_format *pix = &f->fmt.pix;\r
1883 \r
1884     pix->width          = icd->user_width;\r
1885     pix->height         = icd->user_height;\r
1886     pix->pixelformat    = sensor->info_priv.pixfmt;\r
1887     pix->field          = V4L2_FIELD_NONE;\r
1888     pix->colorspace             = V4L2_COLORSPACE_JPEG;\r
1889 \r
1890     return 0;\r
1891 }\r
1892 static bool sensor_fmt_capturechk(struct v4l2_subdev *sd, struct v4l2_format *f)\r
1893 {\r
1894     bool ret = false;\r
1895 \r
1896         if ((f->fmt.pix.width == 1024) && (f->fmt.pix.height == 768)) {\r
1897                 ret = true;\r
1898         } else if ((f->fmt.pix.width == 1280) && (f->fmt.pix.height == 1024)) {\r
1899                 ret = true;\r
1900         } else if ((f->fmt.pix.width == 1600) && (f->fmt.pix.height == 1200)) {\r
1901                 ret = true;\r
1902         } else if ((f->fmt.pix.width == 2048) && (f->fmt.pix.height == 1536)) {\r
1903                 ret = true;\r
1904         } else if ((f->fmt.pix.width == 2592) && (f->fmt.pix.height == 1944)) {\r
1905                 ret = true;\r
1906         }\r
1907 \r
1908         if (ret == true)\r
1909                 SENSOR_DG("%s %dx%d is capture format\n", __FUNCTION__, f->fmt.pix.width, f->fmt.pix.height);\r
1910         return ret;\r
1911 }\r
1912 \r
1913 static bool sensor_fmt_videochk(struct v4l2_subdev *sd, struct v4l2_format *f)\r
1914 {\r
1915     bool ret = false;\r
1916 \r
1917         if ((f->fmt.pix.width == 1280) && (f->fmt.pix.height == 720)) {\r
1918                 ret = true;\r
1919         } else if ((f->fmt.pix.width == 1920) && (f->fmt.pix.height == 1080)) {\r
1920                 ret = true;\r
1921         }\r
1922 \r
1923         if (ret == true)\r
1924                 SENSOR_DG("%s %dx%d is video format\n", __FUNCTION__, f->fmt.pix.width, f->fmt.pix.height);\r
1925         return ret;\r
1926 }\r
1927 static int sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)\r
1928 {\r
1929     struct i2c_client *client = sd->priv;\r
1930     struct sensor *sensor = to_sensor(client);\r
1931     struct v4l2_pix_format *pix = &f->fmt.pix;\r
1932         const struct v4l2_queryctrl *qctrl;\r
1933         struct soc_camera_device *icd = client->dev.platform_data;\r
1934     struct reginfo *winseqe_set_addr=NULL;\r
1935     int ret=0, set_w,set_h;\r
1936 \r
1937         if (sensor->info_priv.pixfmt != pix->pixelformat) {\r
1938                 switch (pix->pixelformat)\r
1939                 {\r
1940                         case V4L2_PIX_FMT_YUYV:\r
1941                         {\r
1942                                 winseqe_set_addr = sensor_ClrFmt_YUYV;\r
1943                                 break;\r
1944                         }\r
1945                         case V4L2_PIX_FMT_UYVY:\r
1946                         {\r
1947                                 winseqe_set_addr = sensor_ClrFmt_UYVY;\r
1948                                 break;\r
1949                         }\r
1950                         default:\r
1951                                 break;\r
1952                 }\r
1953                 if (winseqe_set_addr != NULL) {\r
1954             sensor_write_array(client, winseqe_set_addr);\r
1955                         sensor->info_priv.pixfmt = pix->pixelformat;\r
1956 \r
1957                         SENSOR_DG("%s Pixelformat(0x%x) set success!\n", SENSOR_NAME_STRING(),pix->pixelformat);\r
1958                 } else {\r
1959                         SENSOR_TR("%s Pixelformat(0x%x) is invalidate!\n", SENSOR_NAME_STRING(),pix->pixelformat);\r
1960                 }\r
1961         }\r
1962 \r
1963     set_w = pix->width;\r
1964     set_h = pix->height;\r
1965 \r
1966         if (((set_w <= 176) && (set_h <= 144)) &&( sensor_qcif[0].reg!=0xff))\r
1967         {\r
1968                 winseqe_set_addr = sensor_qcif;\r
1969         set_w = 176;\r
1970         set_h = 144;\r
1971         }\r
1972         else if (((set_w <= 320) && (set_h <= 240)) && (sensor_qvga[0].reg!=0xff))\r
1973     {\r
1974         winseqe_set_addr = sensor_qvga;\r
1975         set_w = 320;\r
1976         set_h = 240;\r
1977     }\r
1978     else if (((set_w <= 352) && (set_h<= 288)) && (sensor_cif[0].reg!=0xff))\r
1979     {\r
1980         winseqe_set_addr = sensor_cif;\r
1981         set_w = 352;\r
1982         set_h = 288;\r
1983     }\r
1984     else if (((set_w <= 640) && (set_h <= 480)) &&( sensor_vga[0].reg!=0xff))\r
1985     {\r
1986         winseqe_set_addr = sensor_vga;\r
1987         set_w =640;\r
1988         set_h = 480;\r
1989     }\r
1990     else if (((set_w <= 800) && (set_h <= 600)) && (sensor_svga[0].reg!=0xff))\r
1991     {\r
1992         winseqe_set_addr = sensor_svga;\r
1993         set_w = 800;\r
1994         set_h = 600;\r
1995     }\r
1996         else if (((set_w <= 1024) && (set_h <= 768)) &&( sensor_xga[0].reg!=0xff))\r
1997     {\r
1998         winseqe_set_addr = sensor_xga;\r
1999         set_w = 1024;\r
2000         set_h = 768;\r
2001     }\r
2002     else if (((set_w <= 1280) && (set_h <= 1024)) && (sensor_sxga[0].reg!=0xff))\r
2003     {\r
2004         winseqe_set_addr = sensor_sxga;\r
2005         set_w = 1280;\r
2006         set_h = 1024;\r
2007     }\r
2008     else if (((set_w <= 1600) && (set_h <= 1200)) && (sensor_uxga[0].reg!=0xff))\r
2009     {\r
2010         winseqe_set_addr = sensor_uxga;\r
2011         set_w = 1600;\r
2012         set_h = 1200;\r
2013     }\r
2014     else\r
2015     {\r
2016         winseqe_set_addr = SENSOR_INIT_WINSEQADR;               /* ddl@rock-chips.com : Sensor output smallest size if  isn't support app  */\r
2017         set_w = SENSOR_INIT_WIDTH;\r
2018         set_h = SENSOR_INIT_HEIGHT;\r
2019                 ret = -1;\r
2020                 SENSOR_TR("\n %s..%s Format is Invalidate. pix->width = %d.. pix->height = %d\n",SENSOR_NAME_STRING(),__FUNCTION__,pix->width,pix->height);\r
2021     }\r
2022 \r
2023     if ((int)winseqe_set_addr  != sensor->info_priv.winseqe_cur_addr) {\r
2024         #if CONFIG_SENSOR_Flash\r
2025         if (sensor_fmt_capturechk(sd,f) == true) {      /* ddl@rock-chips.com : Capture */\r
2026             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {\r
2027                 sensor_ioctrl(icd, Sensor_Flash, Flash_On);\r
2028                 SENSOR_DG("%s flash on in capture!\n", SENSOR_NAME_STRING());\r
2029             }           \r
2030         } else {                                        /* ddl@rock-chips.com : Video */\r
2031             if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {\r
2032                 sensor_ioctrl(icd, Sensor_Flash, Flash_Off);\r
2033                 SENSOR_DG("%s flash off in preivew!\n", SENSOR_NAME_STRING());\r
2034             }\r
2035         }\r
2036         #endif\r
2037         ret |= sensor_write_array(client, winseqe_set_addr);\r
2038         if (ret != 0) {\r
2039             SENSOR_TR("%s set format capability failed\n", SENSOR_NAME_STRING());\r
2040             #if CONFIG_SENSOR_Flash\r
2041             if (sensor_fmt_capturechk(sd,f) == true) {\r
2042                 if ((sensor->info_priv.flash == 1) || (sensor->info_priv.flash == 2)) {\r
2043                     sensor_ioctrl(icd, Sensor_Flash, Flash_Off);\r
2044                     SENSOR_TR("%s Capture format set fail, flash off !\n", SENSOR_NAME_STRING());\r
2045                 }\r
2046             }\r
2047             #endif\r
2048             goto sensor_s_fmt_end;\r
2049         }\r
2050 \r
2051         sensor->info_priv.winseqe_cur_addr  = (int)winseqe_set_addr;\r
2052 \r
2053                 if (sensor_fmt_capturechk(sd,f) == true) {                                  /* ddl@rock-chips.com : Capture */\r
2054         #if CONFIG_SENSOR_Effect\r
2055                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
2056                         sensor_set_effect(icd, qctrl,sensor->info_priv.effect);\r
2057         #endif\r
2058         #if CONFIG_SENSOR_WhiteBalance\r
2059                         if (sensor->info_priv.whiteBalance != 0) {\r
2060                                 qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
2061                                 sensor_set_whiteBalance(icd, qctrl,sensor->info_priv.whiteBalance);\r
2062                         }\r
2063         #endif\r
2064                         sensor->info_priv.snap2preview = true;\r
2065                 } else if (sensor_fmt_videochk(sd,f) == true) {                 /* ddl@rock-chips.com : Video */\r
2066                 #if CONFIG_SENSOR_Effect\r
2067                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
2068                         sensor_set_effect(icd, qctrl,sensor->info_priv.effect);\r
2069         #endif\r
2070         #if CONFIG_SENSOR_WhiteBalance\r
2071                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
2072                         sensor_set_whiteBalance(icd, qctrl,sensor->info_priv.whiteBalance);\r
2073         #endif\r
2074                         sensor->info_priv.video2preview = true;\r
2075                 } else if ((sensor->info_priv.snap2preview == true) || (sensor->info_priv.video2preview == true)) {\r
2076                 #if CONFIG_SENSOR_Effect\r
2077                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_EFFECT);\r
2078                         sensor_set_effect(icd, qctrl,sensor->info_priv.effect);\r
2079         #endif\r
2080         #if CONFIG_SENSOR_WhiteBalance\r
2081                         qctrl = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_DO_WHITE_BALANCE);\r
2082                         sensor_set_whiteBalance(icd, qctrl,sensor->info_priv.whiteBalance);\r
2083         #endif\r
2084                         sensor->info_priv.video2preview = false;\r
2085                         sensor->info_priv.snap2preview = false;\r
2086                 }\r
2087         SENSOR_DG("\n%s..%s.. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),__FUNCTION__,set_w,set_h);\r
2088     }\r
2089     else\r
2090     {\r
2091         SENSOR_DG("\n %s .. Current Format is validate. icd->width = %d.. icd->height %d\n",SENSOR_NAME_STRING(),set_w,set_h);\r
2092     }\r
2093 \r
2094         pix->width = set_w;\r
2095     pix->height = set_h;\r
2096 \r
2097 sensor_s_fmt_end:\r
2098     return ret;\r
2099 }\r
2100 \r
2101 static int sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *f)\r
2102 {\r
2103     struct v4l2_pix_format *pix = &f->fmt.pix;\r
2104     bool bayer = pix->pixelformat == V4L2_PIX_FMT_UYVY ||\r
2105         pix->pixelformat == V4L2_PIX_FMT_YUYV;\r
2106 \r
2107     /*\r
2108     * With Bayer format enforce even side lengths, but let the user play\r
2109     * with the starting pixel\r
2110     */\r
2111     if (pix->height > SENSOR_MAX_HEIGHT)\r
2112         pix->height = SENSOR_MAX_HEIGHT;\r
2113     else if (pix->height < SENSOR_MIN_HEIGHT)\r
2114         pix->height = SENSOR_MIN_HEIGHT;\r
2115     else if (bayer)\r
2116         pix->height = ALIGN(pix->height, 2);\r
2117 \r
2118     if (pix->width > SENSOR_MAX_WIDTH)\r
2119         pix->width = SENSOR_MAX_WIDTH;\r
2120     else if (pix->width < SENSOR_MIN_WIDTH)\r
2121         pix->width = SENSOR_MIN_WIDTH;\r
2122     else if (bayer)\r
2123         pix->width = ALIGN(pix->width, 2);\r
2124     return 0;\r
2125 }\r
2126 \r
2127  static int sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id)\r
2128 {\r
2129     struct i2c_client *client = sd->priv;\r
2130 \r
2131     if (id->match.type != V4L2_CHIP_MATCH_I2C_ADDR)\r
2132         return -EINVAL;\r
2133 \r
2134     if (id->match.addr != client->addr)\r
2135         return -ENODEV;\r
2136 \r
2137     id->ident = SENSOR_V4L2_IDENT;      /* ddl@rock-chips.com :  Return OV2655  identifier */\r
2138     id->revision = 0;\r
2139 \r
2140     return 0;\r
2141 }\r
2142 #if CONFIG_SENSOR_Brightness\r
2143 static int sensor_set_brightness(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2144 {\r
2145     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2146 \r
2147     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2148     {\r
2149         if (sensor_BrightnessSeqe[value - qctrl->minimum] != NULL)\r
2150         {\r
2151             if (sensor_write_array(client, sensor_BrightnessSeqe[value - qctrl->minimum]) != 0)\r
2152             {\r
2153                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2154                 return -EINVAL;\r
2155             }\r
2156             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2157             return 0;\r
2158         }\r
2159     }\r
2160         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2161     return -EINVAL;\r
2162 }\r
2163 #endif\r
2164 #if CONFIG_SENSOR_Effect\r
2165 static int sensor_set_effect(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2166 {\r
2167     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2168 \r
2169     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2170     {\r
2171         if (sensor_EffectSeqe[value - qctrl->minimum] != NULL)\r
2172         {\r
2173             if (sensor_write_array(client, sensor_EffectSeqe[value - qctrl->minimum]) != 0)\r
2174             {\r
2175                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2176                 return -EINVAL;\r
2177             }\r
2178             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2179             return 0;\r
2180         }\r
2181     }\r
2182         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2183     return -EINVAL;\r
2184 }\r
2185 #endif\r
2186 #if CONFIG_SENSOR_Exposure\r
2187 static int sensor_set_exposure(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2188 {\r
2189     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2190 \r
2191     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2192     {\r
2193         if (sensor_ExposureSeqe[value - qctrl->minimum] != NULL)\r
2194         {\r
2195             if (sensor_write_array(client, sensor_ExposureSeqe[value - qctrl->minimum]) != 0)\r
2196             {\r
2197                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2198                 return -EINVAL;\r
2199             }\r
2200             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2201             return 0;\r
2202         }\r
2203     }\r
2204         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2205     return -EINVAL;\r
2206 }\r
2207 #endif\r
2208 #if CONFIG_SENSOR_Saturation\r
2209 static int sensor_set_saturation(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2210 {\r
2211     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2212 \r
2213     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2214     {\r
2215         if (sensor_SaturationSeqe[value - qctrl->minimum] != NULL)\r
2216         {\r
2217             if (sensor_write_array(client, sensor_SaturationSeqe[value - qctrl->minimum]) != 0)\r
2218             {\r
2219                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2220                 return -EINVAL;\r
2221             }\r
2222             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2223             return 0;\r
2224         }\r
2225     }\r
2226     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2227     return -EINVAL;\r
2228 }\r
2229 #endif\r
2230 #if CONFIG_SENSOR_Contrast\r
2231 static int sensor_set_contrast(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2232 {\r
2233     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2234 \r
2235     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2236     {\r
2237         if (sensor_ContrastSeqe[value - qctrl->minimum] != NULL)\r
2238         {\r
2239             if (sensor_write_array(client, sensor_ContrastSeqe[value - qctrl->minimum]) != 0)\r
2240             {\r
2241                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2242                 return -EINVAL;\r
2243             }\r
2244             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2245             return 0;\r
2246         }\r
2247     }\r
2248     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2249     return -EINVAL;\r
2250 }\r
2251 #endif\r
2252 #if CONFIG_SENSOR_Mirror\r
2253 static int sensor_set_mirror(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2254 {\r
2255     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2256 \r
2257     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2258     {\r
2259         if (sensor_MirrorSeqe[value - qctrl->minimum] != NULL)\r
2260         {\r
2261             if (sensor_write_array(client, sensor_MirrorSeqe[value - qctrl->minimum]) != 0)\r
2262             {\r
2263                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2264                 return -EINVAL;\r
2265             }\r
2266             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2267             return 0;\r
2268         }\r
2269     }\r
2270     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2271     return -EINVAL;\r
2272 }\r
2273 #endif\r
2274 #if CONFIG_SENSOR_Flip\r
2275 static int sensor_set_flip(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2276 {\r
2277     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2278 \r
2279     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2280     {\r
2281         if (sensor_FlipSeqe[value - qctrl->minimum] != NULL)\r
2282         {\r
2283             if (sensor_write_array(client, sensor_FlipSeqe[value - qctrl->minimum]) != 0)\r
2284             {\r
2285                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2286                 return -EINVAL;\r
2287             }\r
2288             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2289             return 0;\r
2290         }\r
2291     }\r
2292     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2293     return -EINVAL;\r
2294 }\r
2295 #endif\r
2296 #if CONFIG_SENSOR_Scene\r
2297 static int sensor_set_scene(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2298 {\r
2299     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2300 \r
2301     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2302     {\r
2303         if (sensor_SceneSeqe[value - qctrl->minimum] != NULL)\r
2304         {\r
2305             if (sensor_write_array(client, sensor_SceneSeqe[value - qctrl->minimum]) != 0)\r
2306             {\r
2307                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2308                 return -EINVAL;\r
2309             }\r
2310             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2311             return 0;\r
2312         }\r
2313     }\r
2314     SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2315     return -EINVAL;\r
2316 }\r
2317 #endif\r
2318 #if CONFIG_SENSOR_WhiteBalance\r
2319 static int sensor_set_whiteBalance(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2320 {\r
2321     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2322 \r
2323     if ((value >= qctrl->minimum) && (value <= qctrl->maximum))\r
2324     {\r
2325         if (sensor_WhiteBalanceSeqe[value - qctrl->minimum] != NULL)\r
2326         {\r
2327             if (sensor_write_array(client, sensor_WhiteBalanceSeqe[value - qctrl->minimum]) != 0)\r
2328             {\r
2329                 SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2330                 return -EINVAL;\r
2331             }\r
2332             SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2333             return 0;\r
2334         }\r
2335     }\r
2336         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2337     return -EINVAL;\r
2338 }\r
2339 #endif\r
2340 #if CONFIG_SENSOR_DigitalZoom\r
2341 static int sensor_set_digitalzoom(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int *value)\r
2342 {\r
2343     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2344     struct sensor *sensor = to_sensor(client);\r
2345         const struct v4l2_queryctrl *qctrl_info;\r
2346     int digitalzoom_cur, digitalzoom_total;\r
2347 \r
2348         qctrl_info = soc_camera_find_qctrl(&sensor_ops, V4L2_CID_ZOOM_ABSOLUTE);\r
2349         if (qctrl_info)\r
2350                 return -EINVAL;\r
2351 \r
2352     digitalzoom_cur = sensor->info_priv.digitalzoom;\r
2353     digitalzoom_total = qctrl_info->maximum;\r
2354 \r
2355     if ((*value > 0) && (digitalzoom_cur >= digitalzoom_total))\r
2356     {\r
2357         SENSOR_TR("%s digitalzoom is maximum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);\r
2358         return -EINVAL;\r
2359     }\r
2360 \r
2361     if  ((*value < 0) && (digitalzoom_cur <= qctrl_info->minimum))\r
2362     {\r
2363         SENSOR_TR("%s digitalzoom is minimum - %x\n", SENSOR_NAME_STRING(), digitalzoom_cur);\r
2364         return -EINVAL;\r
2365     }\r
2366 \r
2367     if ((*value > 0) && ((digitalzoom_cur + *value) > digitalzoom_total))\r
2368     {\r
2369         *value = digitalzoom_total - digitalzoom_cur;\r
2370     }\r
2371 \r
2372     if ((*value < 0) && ((digitalzoom_cur + *value) < 0))\r
2373     {\r
2374         *value = 0 - digitalzoom_cur;\r
2375     }\r
2376 \r
2377     digitalzoom_cur += *value;\r
2378 \r
2379     if (sensor_ZoomSeqe[digitalzoom_cur] != NULL)\r
2380     {\r
2381         if (sensor_write_array(client, sensor_ZoomSeqe[digitalzoom_cur]) != 0)\r
2382         {\r
2383             SENSOR_TR("%s..%s WriteReg Fail.. \n",SENSOR_NAME_STRING(), __FUNCTION__);\r
2384             return -EINVAL;\r
2385         }\r
2386         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, *value);\r
2387         return 0;\r
2388     }\r
2389 \r
2390     return -EINVAL;\r
2391 }\r
2392 #endif\r
2393 #if CONFIG_SENSOR_Flash\r
2394 static int sensor_set_flash(struct soc_camera_device *icd, const struct v4l2_queryctrl *qctrl, int value)\r
2395 {    \r
2396     if ((value >= qctrl->minimum) && (value <= qctrl->maximum)) {\r
2397         if (value == 3) {       /* ddl@rock-chips.com: torch */\r
2398             sensor_ioctrl(icd, Sensor_Flash, Flash_Torch);   /* Flash On */\r
2399         } else {\r
2400             sensor_ioctrl(icd, Sensor_Flash, Flash_Off);\r
2401         }\r
2402         SENSOR_DG("%s..%s : %x\n",SENSOR_NAME_STRING(),__FUNCTION__, value);\r
2403         return 0;\r
2404     }\r
2405     \r
2406         SENSOR_TR("\n %s..%s valure = %d is invalidate..    \n",SENSOR_NAME_STRING(),__FUNCTION__,value);\r
2407     return -EINVAL;\r
2408 }\r
2409 #endif\r
2410 \r
2411 static int sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)\r
2412 {\r
2413     struct i2c_client *client = sd->priv;\r
2414     struct sensor *sensor = to_sensor(client);\r
2415     const struct v4l2_queryctrl *qctrl;\r
2416 \r
2417     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);\r
2418 \r
2419     if (!qctrl)\r
2420     {\r
2421         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);\r
2422         return -EINVAL;\r
2423     }\r
2424 \r
2425     switch (ctrl->id)\r
2426     {\r
2427         case V4L2_CID_BRIGHTNESS:\r
2428             {\r
2429                 ctrl->value = sensor->info_priv.brightness;\r
2430                 break;\r
2431             }\r
2432         case V4L2_CID_SATURATION:\r
2433             {\r
2434                 ctrl->value = sensor->info_priv.saturation;\r
2435                 break;\r
2436             }\r
2437         case V4L2_CID_CONTRAST:\r
2438             {\r
2439                 ctrl->value = sensor->info_priv.contrast;\r
2440                 break;\r
2441             }\r
2442         case V4L2_CID_DO_WHITE_BALANCE:\r
2443             {\r
2444                 ctrl->value = sensor->info_priv.whiteBalance;\r
2445                 break;\r
2446             }\r
2447         case V4L2_CID_EXPOSURE:\r
2448             {\r
2449                 ctrl->value = sensor->info_priv.exposure;\r
2450                 break;\r
2451             }\r
2452         case V4L2_CID_HFLIP:\r
2453             {\r
2454                 ctrl->value = sensor->info_priv.mirror;\r
2455                 break;\r
2456             }\r
2457         case V4L2_CID_VFLIP:\r
2458             {\r
2459                 ctrl->value = sensor->info_priv.flip;\r
2460                 break;\r
2461             }\r
2462         default :\r
2463                 break;\r
2464     }\r
2465     return 0;\r
2466 }\r
2467 \r
2468 \r
2469 \r
2470 static int sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl)\r
2471 {\r
2472     struct i2c_client *client = sd->priv;\r
2473     struct sensor *sensor = to_sensor(client);\r
2474     struct soc_camera_device *icd = client->dev.platform_data;\r
2475     const struct v4l2_queryctrl *qctrl;\r
2476 \r
2477 \r
2478     qctrl = soc_camera_find_qctrl(&sensor_ops, ctrl->id);\r
2479 \r
2480     if (!qctrl)\r
2481     {\r
2482         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ctrl->id);\r
2483         return -EINVAL;\r
2484     }\r
2485 \r
2486     switch (ctrl->id)\r
2487     {\r
2488 #if CONFIG_SENSOR_Brightness\r
2489         case V4L2_CID_BRIGHTNESS:\r
2490             {\r
2491                 if (ctrl->value != sensor->info_priv.brightness)\r
2492                 {\r
2493                     if (sensor_set_brightness(icd, qctrl,ctrl->value) != 0)\r
2494                     {\r
2495                         return -EINVAL;\r
2496                     }\r
2497                     sensor->info_priv.brightness = ctrl->value;\r
2498                 }\r
2499                 break;\r
2500             }\r
2501 #endif\r
2502 #if CONFIG_SENSOR_Exposure\r
2503         case V4L2_CID_EXPOSURE:\r
2504             {\r
2505                 if (ctrl->value != sensor->info_priv.exposure)\r
2506                 {\r
2507                     if (sensor_set_exposure(icd, qctrl,ctrl->value) != 0)\r
2508                     {\r
2509                         return -EINVAL;\r
2510                     }\r
2511                     sensor->info_priv.exposure = ctrl->value;\r
2512                 }\r
2513                 break;\r
2514             }\r
2515 #endif\r
2516 #if CONFIG_SENSOR_Saturation\r
2517         case V4L2_CID_SATURATION:\r
2518             {\r
2519                 if (ctrl->value != sensor->info_priv.saturation)\r
2520                 {\r
2521                     if (sensor_set_saturation(icd, qctrl,ctrl->value) != 0)\r
2522                     {\r
2523                         return -EINVAL;\r
2524                     }\r
2525                     sensor->info_priv.saturation = ctrl->value;\r
2526                 }\r
2527                 break;\r
2528             }\r
2529 #endif\r
2530 #if CONFIG_SENSOR_Contrast\r
2531         case V4L2_CID_CONTRAST:\r
2532             {\r
2533                 if (ctrl->value != sensor->info_priv.contrast)\r
2534                 {\r
2535                     if (sensor_set_contrast(icd, qctrl,ctrl->value) != 0)\r
2536                     {\r
2537                         return -EINVAL;\r
2538                     }\r
2539                     sensor->info_priv.contrast = ctrl->value;\r
2540                 }\r
2541                 break;\r
2542             }\r
2543 #endif\r
2544 #if CONFIG_SENSOR_WhiteBalance\r
2545         case V4L2_CID_DO_WHITE_BALANCE:\r
2546             {\r
2547                 if (ctrl->value != sensor->info_priv.whiteBalance)\r
2548                 {\r
2549                     if (sensor_set_whiteBalance(icd, qctrl,ctrl->value) != 0)\r
2550                     {\r
2551                         return -EINVAL;\r
2552                     }\r
2553                     sensor->info_priv.whiteBalance = ctrl->value;\r
2554                 }\r
2555                 break;\r
2556             }\r
2557 #endif\r
2558 #if CONFIG_SENSOR_Mirror\r
2559         case V4L2_CID_HFLIP:\r
2560             {\r
2561                 if (ctrl->value != sensor->info_priv.mirror)\r
2562                 {\r
2563                     if (sensor_set_mirror(icd, qctrl,ctrl->value) != 0)\r
2564                         return -EINVAL;\r
2565                     sensor->info_priv.mirror = ctrl->value;\r
2566                 }\r
2567                 break;\r
2568             }\r
2569 #endif\r
2570 #if CONFIG_SENSOR_Flip\r
2571         case V4L2_CID_VFLIP:\r
2572             {\r
2573                 if (ctrl->value != sensor->info_priv.flip)\r
2574                 {\r
2575                     if (sensor_set_flip(icd, qctrl,ctrl->value) != 0)\r
2576                         return -EINVAL;\r
2577                     sensor->info_priv.flip = ctrl->value;\r
2578                 }\r
2579                 break;\r
2580             }\r
2581 #endif\r
2582         default:\r
2583             break;\r
2584     }\r
2585 \r
2586     return 0;\r
2587 }\r
2588 static int sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl)\r
2589 {\r
2590     const struct v4l2_queryctrl *qctrl;\r
2591     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2592     struct sensor *sensor = to_sensor(client);\r
2593 \r
2594     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);\r
2595 \r
2596     if (!qctrl)\r
2597     {\r
2598         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);\r
2599         return -EINVAL;\r
2600     }\r
2601 \r
2602     switch (ext_ctrl->id)\r
2603     {\r
2604         case V4L2_CID_SCENE:\r
2605             {\r
2606                 ext_ctrl->value = sensor->info_priv.scene;\r
2607                 break;\r
2608             }\r
2609         case V4L2_CID_EFFECT:\r
2610             {\r
2611                 ext_ctrl->value = sensor->info_priv.effect;\r
2612                 break;\r
2613             }\r
2614         case V4L2_CID_ZOOM_ABSOLUTE:\r
2615             {\r
2616                 ext_ctrl->value = sensor->info_priv.digitalzoom;\r
2617                 break;\r
2618             }\r
2619         case V4L2_CID_ZOOM_RELATIVE:\r
2620             {\r
2621                 return -EINVAL;\r
2622             }\r
2623         case V4L2_CID_FOCUS_ABSOLUTE:\r
2624             {\r
2625                 ext_ctrl->value = sensor->info_priv.focus;\r
2626                 break;\r
2627             }\r
2628         case V4L2_CID_FOCUS_RELATIVE:\r
2629             {\r
2630                 return -EINVAL;\r
2631             }\r
2632         case V4L2_CID_FLASH:\r
2633             {\r
2634                 ext_ctrl->value = sensor->info_priv.flash;\r
2635                 break;\r
2636             }\r
2637         default :\r
2638             break;\r
2639     }\r
2640     return 0;\r
2641 }\r
2642 static int sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl)\r
2643 {\r
2644     const struct v4l2_queryctrl *qctrl;\r
2645     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
2646     struct sensor *sensor = to_sensor(client);\r
2647     int val_offset;\r
2648 \r
2649     qctrl = soc_camera_find_qctrl(&sensor_ops, ext_ctrl->id);\r
2650 \r
2651     if (!qctrl)\r
2652     {\r
2653         SENSOR_TR("\n %s ioctrl id = %d  is invalidate \n", SENSOR_NAME_STRING(), ext_ctrl->id);\r
2654         return -EINVAL;\r
2655     }\r
2656 \r
2657         val_offset = 0;\r
2658     switch (ext_ctrl->id)\r
2659     {\r
2660 #if CONFIG_SENSOR_Scene\r
2661         case V4L2_CID_SCENE:\r
2662             {\r
2663                 if (ext_ctrl->value != sensor->info_priv.scene)\r
2664                 {\r
2665                     if (sensor_set_scene(icd, qctrl,ext_ctrl->value) != 0)\r
2666                         return -EINVAL;\r
2667                     sensor->info_priv.scene = ext_ctrl->value;\r
2668                 }\r
2669                 break;\r
2670             }\r
2671 #endif\r
2672 #if CONFIG_SENSOR_Effect\r
2673         case V4L2_CID_EFFECT:\r
2674             {\r
2675                 if (ext_ctrl->value != sensor->info_priv.effect)\r
2676                 {\r
2677                     if (sensor_set_effect(icd, qctrl,ext_ctrl->value) != 0)\r
2678                         return -EINVAL;\r
2679                     sensor->info_priv.effect= ext_ctrl->value;\r
2680                 }\r
2681                 break;\r
2682             }\r
2683 #endif\r
2684 #if CONFIG_SENSOR_DigitalZoom\r
2685         case V4L2_CID_ZOOM_ABSOLUTE:\r
2686             {\r
2687                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))\r
2688                     return -EINVAL;\r
2689 \r
2690                 if (ext_ctrl->value != sensor->info_priv.digitalzoom)\r
2691                 {\r
2692                     val_offset = ext_ctrl->value -sensor->info_priv.digitalzoom;\r
2693 \r
2694                     if (sensor_set_digitalzoom(icd, qctrl,&val_offset) != 0)\r
2695                         return -EINVAL;\r
2696                     sensor->info_priv.digitalzoom += val_offset;\r
2697 \r
2698                     SENSOR_DG("%s digitalzoom is %x\n",SENSOR_NAME_STRING(),  sensor->info_priv.digitalzoom);\r
2699                 }\r
2700 \r
2701                 break;\r
2702             }\r
2703         case V4L2_CID_ZOOM_RELATIVE:\r
2704             {\r
2705                 if (ext_ctrl->value)\r
2706                 {\r
2707                     if (sensor_set_digitalzoom(icd, qctrl,&ext_ctrl->value) != 0)\r
2708                         return -EINVAL;\r
2709                     sensor->info_priv.digitalzoom += ext_ctrl->value;\r
2710 \r
2711                     SENSOR_DG("%s digitalzoom is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.digitalzoom);\r
2712                 }\r
2713                 break;\r
2714             }\r
2715 #endif\r
2716 #if CONFIG_SENSOR_Focus\r
2717         case V4L2_CID_FOCUS_ABSOLUTE:\r
2718             {\r
2719                 if ((ext_ctrl->value < qctrl->minimum) || (ext_ctrl->value > qctrl->maximum))\r
2720                     return -EINVAL;\r
2721 \r
2722                 if (ext_ctrl->value != sensor->info_priv.focus)\r
2723                 {\r
2724                     val_offset = ext_ctrl->value -sensor->info_priv.focus;\r
2725 \r
2726                     sensor->info_priv.focus += val_offset;\r
2727                 }\r
2728 \r
2729                 break;\r
2730             }\r
2731         case V4L2_CID_FOCUS_RELATIVE:\r
2732             {\r
2733                 if (ext_ctrl->value)\r
2734                 {\r
2735                     sensor->info_priv.focus += ext_ctrl->value;\r
2736 \r
2737                     SENSOR_DG("%s focus is %x\n", SENSOR_NAME_STRING(), sensor->info_priv.focus);\r
2738                 }\r
2739                 break;\r
2740             }\r
2741 #endif\r
2742 #if CONFIG_SENSOR_Flash\r
2743         case V4L2_CID_FLASH:\r
2744             {\r
2745                 if (sensor_set_flash(icd, qctrl,ext_ctrl->value) != 0)\r
2746                     return -EINVAL;\r
2747                 sensor->info_priv.flash = ext_ctrl->value;\r
2748 \r
2749                 SENSOR_DG("%s flash is %x\n",SENSOR_NAME_STRING(), sensor->info_priv.flash);\r
2750                 break;\r
2751             }\r
2752 #endif\r
2753         default:\r
2754             break;\r
2755     }\r
2756 \r
2757     return 0;\r
2758 }\r
2759 \r
2760 static int sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)\r
2761 {\r
2762     struct i2c_client *client = sd->priv;\r
2763     struct soc_camera_device *icd = client->dev.platform_data;\r
2764     int i, error_cnt=0, error_idx=-1;\r
2765 \r
2766 \r
2767     for (i=0; i<ext_ctrl->count; i++) {\r
2768         if (sensor_g_ext_control(icd, &ext_ctrl->controls[i]) != 0) {\r
2769             error_cnt++;\r
2770             error_idx = i;\r
2771         }\r
2772     }\r
2773 \r
2774     if (error_cnt > 1)\r
2775         error_idx = ext_ctrl->count;\r
2776 \r
2777     if (error_idx != -1) {\r
2778         ext_ctrl->error_idx = error_idx;\r
2779         return -EINVAL;\r
2780     } else {\r
2781         return 0;\r
2782     }\r
2783 }\r
2784 \r
2785 static int sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl)\r
2786 {\r
2787     struct i2c_client *client = sd->priv;\r
2788     struct soc_camera_device *icd = client->dev.platform_data;\r
2789     int i, error_cnt=0, error_idx=-1;\r
2790 \r
2791 \r
2792     for (i=0; i<ext_ctrl->count; i++) {\r
2793         if (sensor_s_ext_control(icd, &ext_ctrl->controls[i]) != 0) {\r
2794             error_cnt++;\r
2795             error_idx = i;\r
2796         }\r
2797     }\r
2798 \r
2799     if (error_cnt > 1)\r
2800         error_idx = ext_ctrl->count;\r
2801 \r
2802     if (error_idx != -1) {\r
2803         ext_ctrl->error_idx = error_idx;\r
2804         return -EINVAL;\r
2805     } else {\r
2806         return 0;\r
2807     }\r
2808 }\r
2809 \r
2810 /* Interface active, can use i2c. If it fails, it can indeed mean, that\r
2811  * this wasn't our capture interface, so, we wait for the right one */\r
2812 static int sensor_video_probe(struct soc_camera_device *icd,\r
2813                                struct i2c_client *client)\r
2814 {\r
2815     char value;\r
2816     int ret,pid = 0;\r
2817     struct sensor *sensor = to_sensor(client);\r
2818 \r
2819     /* We must have a parent by now. And it cannot be a wrong one.\r
2820      * So this entire test is completely redundant. */\r
2821     if (!icd->dev.parent ||\r
2822             to_soc_camera_host(icd->dev.parent)->nr != icd->iface)\r
2823                 return -ENODEV;\r
2824 \r
2825         if (sensor_ioctrl(icd, Sensor_PowerDown, 0) < 0) {\r
2826                 ret = -ENODEV;\r
2827                 goto sensor_video_probe_err;\r
2828         }\r
2829 #if 0\r
2830     /* soft reset */\r
2831     ret = sensor_write(client, 0x3012, 0x80);\r
2832     if (ret != 0)\r
2833     {\r
2834         SENSOR_TR("soft reset %s failed\n",SENSOR_NAME_STRING());\r
2835         return -ENODEV;\r
2836     }\r
2837     mdelay(5);          //delay 5 microseconds\r
2838 \r
2839     /* check if it is an sensor sensor */\r
2840     ret = sensor_read(client, 0x300a, &value);\r
2841     if (ret != 0) {\r
2842         SENSOR_TR("read chip id high byte failed\n");\r
2843         ret = -ENODEV;\r
2844         goto sensor_video_probe_err;\r
2845     }\r
2846 \r
2847     \r
2848     ret = sensor_read(client, 0x01, &value);\r
2849     if (ret != 0) {\r
2850         SENSOR_TR("read chip id low byte failed\n");\r
2851         ret = -ENODEV;\r
2852         goto sensor_video_probe_err;\r
2853     }\r
2854 \r
2855     pid = (value & 0xff);\r
2856     SENSOR_DG("\n %s  pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
2857     if (pid == SENSOR_ID) {\r
2858         sensor->model = SENSOR_V4L2_IDENT;\r
2859     } else {\r
2860         SENSOR_TR("error: %s mismatched   pid = 0x%x\n", SENSOR_NAME_STRING(), pid);\r
2861         ret = -ENODEV;\r
2862         goto sensor_video_probe_err;\r
2863     }\r
2864 #endif\r
2865     icd->formats = sensor_colour_formats;\r
2866     icd->num_formats = ARRAY_SIZE(sensor_colour_formats);\r
2867 \r
2868     return 0;\r
2869 \r
2870 sensor_video_probe_err:\r
2871 \r
2872     return ret;\r
2873 }\r
2874 static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)\r
2875 {\r
2876         struct i2c_client *client = sd->priv;\r
2877     struct soc_camera_device *icd = client->dev.platform_data;\r
2878     struct sensor *sensor = to_sensor(client);\r
2879     int ret = 0;\r
2880 #if CONFIG_SENSOR_Flash \r
2881     int i;\r
2882 #endif\r
2883     \r
2884         SENSOR_DG("\n%s..%s..cmd:%x \n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);\r
2885         switch (cmd)\r
2886         {\r
2887                 case RK29_CAM_SUBDEV_DEACTIVATE:\r
2888                 {\r
2889                         sensor_deactivate(client);\r
2890                         break;\r
2891                 }\r
2892 \r
2893                 case RK29_CAM_SUBDEV_IOREQUEST:\r
2894                 {\r
2895                         sensor->sensor_io_request = (struct rk29camera_platform_data*)arg;           \r
2896             if (sensor->sensor_io_request != NULL) { \r
2897                 if (sensor->sensor_io_request->gpio_res[0].dev_name && \r
2898                     (strcmp(sensor->sensor_io_request->gpio_res[0].dev_name, dev_name(icd->pdev)) == 0)) {\r
2899                     sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[0];\r
2900                 } else if (sensor->sensor_io_request->gpio_res[1].dev_name && \r
2901                     (strcmp(sensor->sensor_io_request->gpio_res[1].dev_name, dev_name(icd->pdev)) == 0)) {\r
2902                     sensor->sensor_gpio_res = (struct rk29camera_gpio_res*)&sensor->sensor_io_request->gpio_res[1];\r
2903                 }\r
2904             } else {\r
2905                 SENSOR_TR("%s %s RK29_CAM_SUBDEV_IOREQUEST fail\n",SENSOR_NAME_STRING(),__FUNCTION__);\r
2906                 ret = -EINVAL;\r
2907                 goto sensor_ioctl_end;\r
2908             }\r
2909             /* 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
2910                for this project */\r
2911             #if CONFIG_SENSOR_Flash     \r
2912                 if (sensor->sensor_gpio_res) { \r
2913                 if (sensor->sensor_gpio_res->gpio_flash == INVALID_GPIO) {\r
2914                     for (i = 0; i < icd->ops->num_controls; i++) {\r
2915                                 if (V4L2_CID_FLASH == icd->ops->controls[i].id) {\r
2916                                         memset((char*)&icd->ops->controls[i],0x00,sizeof(struct v4l2_queryctrl));                                       \r
2917                                 }\r
2918                     }\r
2919                     sensor->info_priv.flash = 0xff;\r
2920                     SENSOR_DG("%s flash gpio is invalidate!\n",SENSOR_NAME_STRING());\r
2921                 }\r
2922                 }\r
2923             #endif\r
2924                         break;\r
2925                 }\r
2926                 default:\r
2927                 {\r
2928                         SENSOR_TR("%s %s cmd(0x%x) is unknown !\n",SENSOR_NAME_STRING(),__FUNCTION__,cmd);\r
2929                         break;\r
2930                 }\r
2931         }\r
2932 sensor_ioctl_end:\r
2933         return ret;\r
2934 \r
2935 }\r
2936 static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {\r
2937         .init           = sensor_init,\r
2938         .g_ctrl         = sensor_g_control,\r
2939         .s_ctrl         = sensor_s_control,\r
2940         .g_ext_ctrls          = sensor_g_ext_controls,\r
2941         .s_ext_ctrls          = sensor_s_ext_controls,\r
2942         .g_chip_ident   = sensor_g_chip_ident,\r
2943         .ioctl = sensor_ioctl,\r
2944 };\r
2945 \r
2946 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {\r
2947         .s_fmt          = sensor_s_fmt,\r
2948         .g_fmt          = sensor_g_fmt,\r
2949         .try_fmt        = sensor_try_fmt,\r
2950 };\r
2951 \r
2952 static struct v4l2_subdev_ops sensor_subdev_ops = {\r
2953         .core   = &sensor_subdev_core_ops,\r
2954         .video = &sensor_subdev_video_ops,\r
2955 };\r
2956 \r
2957 static int sensor_probe(struct i2c_client *client,\r
2958                          const struct i2c_device_id *did)\r
2959 {\r
2960     struct sensor *sensor;\r
2961     struct soc_camera_device *icd = client->dev.platform_data;\r
2962     struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);\r
2963     struct soc_camera_link *icl;\r
2964     int ret;\r
2965 \r
2966     SENSOR_DG("\n%s..%s..%d..\n",__FUNCTION__,__FILE__,__LINE__);\r
2967     if (!icd) {\r
2968         dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());\r
2969         return -EINVAL;\r
2970     }\r
2971 \r
2972     icl = to_soc_camera_link(icd);\r
2973     if (!icl) {\r
2974         dev_err(&client->dev, "%s driver needs platform data\n", SENSOR_NAME_STRING());\r
2975         return -EINVAL;\r
2976     }\r
2977 \r
2978     if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {\r
2979         dev_warn(&adapter->dev,\r
2980                  "I2C-Adapter doesn't support I2C_FUNC_I2C\n");\r
2981         return -EIO;\r
2982     }\r
2983 \r
2984     sensor = kzalloc(sizeof(struct sensor), GFP_KERNEL);\r
2985     if (!sensor)\r
2986         return -ENOMEM;\r
2987 \r
2988     v4l2_i2c_subdev_init(&sensor->subdev, client, &sensor_subdev_ops);\r
2989 \r
2990     /* Second stage probe - when a capture adapter is there */\r
2991     icd->ops            = &sensor_ops;\r
2992     icd->y_skip_top             = 0;\r
2993         #if CONFIG_SENSOR_I2C_NOSCHED\r
2994         atomic_set(&sensor->tasklock_cnt,0);\r
2995         #endif\r
2996 \r
2997     ret = sensor_video_probe(icd, client);\r
2998     if (ret < 0) {\r
2999         icd->ops = NULL;\r
3000         i2c_set_clientdata(client, NULL);\r
3001         kfree(sensor);\r
3002                 sensor = NULL;\r
3003     }\r
3004     SENSOR_DG("\n%s..%s..%d  ret = %x \n",__FUNCTION__,__FILE__,__LINE__,ret);\r
3005     return ret;\r
3006 }\r
3007 \r
3008 static int sensor_remove(struct i2c_client *client)\r
3009 {\r
3010     struct sensor *sensor = to_sensor(client);\r
3011     struct soc_camera_device *icd = client->dev.platform_data;\r
3012 \r
3013     icd->ops = NULL;\r
3014     i2c_set_clientdata(client, NULL);\r
3015     client->driver = NULL;\r
3016     kfree(sensor);\r
3017         sensor = NULL;\r
3018     return 0;\r
3019 }\r
3020 \r
3021 static const struct i2c_device_id sensor_id[] = {\r
3022         {SENSOR_NAME_STRING(), 0 },\r
3023         { }\r
3024 };\r
3025 MODULE_DEVICE_TABLE(i2c, sensor_id);\r
3026 \r
3027 static struct i2c_driver sensor_i2c_driver = {\r
3028         .driver = {\r
3029                 .name = SENSOR_NAME_STRING(),\r
3030         },\r
3031         .probe          = sensor_probe,\r
3032         .remove         = sensor_remove,\r
3033         .id_table       = sensor_id,\r
3034 };\r
3035 \r
3036 static int __init sensor_mod_init(void)\r
3037 {\r
3038     SENSOR_DG("\n%s..%s.. \n",__FUNCTION__,SENSOR_NAME_STRING());\r
3039     return i2c_add_driver(&sensor_i2c_driver);\r
3040 }\r
3041 \r
3042 static void __exit sensor_mod_exit(void)\r
3043 {\r
3044     i2c_del_driver(&sensor_i2c_driver);\r
3045 }\r
3046 \r
3047 device_initcall_sync(sensor_mod_init);\r
3048 module_exit(sensor_mod_exit);\r
3049 \r
3050 MODULE_DESCRIPTION(SENSOR_NAME_STRING(Camera sensor driver));\r
3051 MODULE_AUTHOR("ddl <kernel@rock-chips>");\r
3052 MODULE_LICENSE("GPL");