drivers/media/video/hi704.c

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