drivers/media/video/ov3660.c

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