drivers/media/video/nt99240_2way.c

   1 \r
   2 #include "generic_sensor.h"\r
   3 /*
   4 *      Driver Version Note\r
   5 *v0.0.1: this driver is compatible with generic_sensor\r
   6 *v0.1.1:\r
   7 *        add sensor_focus_af_const_pause_usr_cb;\r
   8 */\r
   9 static int version = KERNEL_VERSION(0,1,1);\r
  10 module_param(version, int, S_IRUGO);\r
  11 \r
  12 static int debug =1;\r
  13 module_param(debug, int, S_IRUGO|S_IWUSR);\r
  14 \r
  15 #define dprintk(level, fmt, arg...) do {                        \\r
  16         if (debug >= level)                                     \\r
  17         printk(KERN_WARNING fmt , ## arg); } while (0)\r
  18 \r
  19 /* Sensor Driver Configuration Begin */\r
  20 #define SENSOR_NAME RK29_CAM_SENSOR_NT99240\r
  21 #define SENSOR_V4L2_IDENT V4L2_IDENT_NT99240\r
  22 #define SENSOR_ID 0x2400\r
  23 #define SENSOR_BUS_PARAM                     (SOCAM_MASTER |\\r
  24                                              SOCAM_PCLK_SAMPLE_RISING|SOCAM_HSYNC_ACTIVE_HIGH| SOCAM_VSYNC_ACTIVE_HIGH|\\r
  25                                              SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATAWIDTH_8  |SOCAM_MCLK_24MHZ)\r
  26 #define SENSOR_PREVIEW_W                     800\r
  27 #define SENSOR_PREVIEW_H                     600\r
  28 #define SENSOR_PREVIEW_FPS                   15000     // 15fps \r
  29 #define SENSOR_FULLRES_L_FPS                 5000      // 5fps\r
  30 #define SENSOR_FULLRES_H_FPS                 10000      // 10fps\r
  31 #define SENSOR_720P_FPS                      15000\r
  32 #define SENSOR_1080P_FPS                     0\r
  33 \r
  34 #define SENSOR_REGISTER_LEN                  2         // sensor register address bytes\r
  35 #define SENSOR_VALUE_LEN                     1         // sensor register value bytes\r
  36                                     \r
  37 static unsigned int SensorConfiguration = 0;\r
  38 static unsigned int SensorChipID[] = {SENSOR_ID};\r
  39 \r
  40 /* Sensor Driver Configuration End */\r
  41 \r
  42 \r
  43 #define SENSOR_NAME_STRING(a) STR(CONS(SENSOR_NAME, a))\r
  44 #define SENSOR_NAME_VARFUN(a) CONS(SENSOR_NAME, a)\r
  45 \r
  46 #define SensorRegVal(a,b) CONS4(SensorReg,SENSOR_REGISTER_LEN,Val,SENSOR_VALUE_LEN)(a,b)\r
  47 #define sensor_write(client,reg,v) CONS4(sensor_write_reg,SENSOR_REGISTER_LEN,val,SENSOR_VALUE_LEN)(client,(reg),(v))\r
  48 #define sensor_read(client,reg,v) CONS4(sensor_read_reg,SENSOR_REGISTER_LEN,val,SENSOR_VALUE_LEN)(client,(reg),(v))\r
  49 #define sensor_write_array generic_sensor_write_array\r
  50 \r
  51 struct sensor_parameter\r
  52 {\r
  53         unsigned int PreviewDummyPixels;\r
  54         unsigned int CaptureDummyPixels;\r
  55         unsigned int preview_exposure;\r
  56         unsigned short int preview_line_width;\r
  57         unsigned short int preview_gain_dr;\r
  58         unsigned short int preview_gain_ar;\r
  59         unsigned short int preview_gain_dgr;\r
  60         unsigned short int preview_gain_agr;\r
  61         unsigned short int preview_gain_dgb;\r
  62         unsigned short int preview_gain_agb;\r
  63         unsigned short int preview_gain_db;\r
  64         unsigned short int preview_gain_ab;\r
  65         unsigned short int preview_gain_dglobal;\r
  66         unsigned short int preview_gain_aglobal;\r
  67         unsigned short int preview_awb_r;\r
  68         unsigned short int preview_awb_b;\r
  69         \r
  70 \r
  71         unsigned short int PreviewPclk;\r
  72         unsigned short int CapturePclk;\r
  73         char awb[6];\r
  74 };\r
  75 \r
  76 struct specific_sensor{\r
  77         struct generic_sensor common_sensor;\r
  78         //define user data below\r
  79         struct sensor_parameter parameter;\r
  80 \r
  81 };\r
  82 \r
  83 /*\r
  84 *  The follow setting need been filled.\r
  85 *  \r
  86 *  Must Filled:\r
  87 *  sensor_init_data :               Sensor initial setting;\r
  88 *  sensor_fullres_lowfps_data :     Sensor full resolution setting with best auality, recommand for video;\r
  89 *  sensor_preview_data :            Sensor preview resolution setting, recommand it is vga or svga;\r
  90 *  sensor_softreset_data :          Sensor software reset register;\r
  91 *  sensor_check_id_data :           Sensir chip id register;\r
  92 *\r
  93 *  Optional filled:\r
  94 *  sensor_fullres_highfps_data:     Sensor full resolution setting with high framerate, recommand for video;\r
  95 *  sensor_720p:                     Sensor 720p setting, it is for video;\r
  96 *  sensor_1080p:                    Sensor 1080p setting, it is for video;\r
  97 *\r
  98 *  :::::WARNING:::::\r
  99 *  The SensorEnd which is the setting end flag must be filled int the last of each setting;\r
 100 */\r
 101 \r
 102 /* Sensor initial setting */\r
 103 static struct rk_sensor_reg sensor_init_data[] ={\r
 104         {0x32F0, 0x01},\r
 105         {0x3028, 0x07},\r
 106         {0x3029, 0x00},\r
 107         {0x302a, 0x04},\r
 108         {0x3290, 0x01},\r
 109         {0x3291, 0x94},\r
 110         {0x3296, 0x01},\r
 111         {0x3297, 0x6D},\r
 112         {0x3210, 0x3A},\r
 113         {0x3211, 0x3A},\r
 114         {0x3212, 0x3A},\r
 115         {0x3213, 0x3A},\r
 116         {0x3214, 0x2A},\r
 117         {0x3215, 0x2A},\r
 118         {0x3216, 0x2A},\r
 119         {0x3217, 0x2A},\r
 120         {0x3218, 0x2A},\r
 121         {0x3219, 0x2A},\r
 122         {0x321A, 0x2A},\r
 123         {0x321B, 0x2A},\r
 124         {0x321C, 0x22},\r
 125         {0x321D, 0x22},\r
 126         {0x321E, 0x22},\r
 127         {0x321F, 0x22},\r
 128         {0x3230, 0x30},\r
 129         {0x3231, 0x00},\r
 130         {0x3232, 0xCF},\r
 131         {0x3233, 0x00},\r
 132         {0x3234, 0x05},\r
 133         {0x3302, 0x00},\r
 134         {0x3303, 0x5F},\r
 135         {0x3304, 0x00},\r
 136         {0x3305, 0x7E},\r
 137         {0x3306, 0x00},\r
 138         {0x3307, 0x22},\r
 139         {0x3308, 0x07},\r
 140         {0x3309, 0xC3},\r
 141         {0x330A, 0x07},\r
 142         {0x330B, 0x33},\r
 143         {0x330C, 0x01},\r
 144         {0x330D, 0x0A},\r
 145         {0x330E, 0x00},\r
 146         {0x330F, 0xD3},\r
 147         {0x3310, 0x07},\r
 148         {0x3311, 0x3B},\r
 149         {0x3312, 0x07},\r
 150         {0x3313, 0xF2},\r
 151         {0x3024, 0x00},\r
 152         {0x303E, 0x04},\r
 153         {0x303F, 0x02},\r
 154         {0x3040, 0xFF},\r
 155         {0x3041, 0x02},\r
 156         {0x3051, 0xE0},\r
 157         {0x3052, 0x10},\r
 158         {0x305f, 0x22},\r
 159         {0x32b0, 0x00},\r
 160         {0x32b1, 0x90},\r
 161         {0x32BB, 0x0b},\r
 162         {0x32bd, 0x08},\r
 163         {0x32be, 0x06},\r
 164         {0x32bf, 0x4a},\r
 165         {0x32c0, 0x20},\r
 166         {0x32C3, 0x06},\r
 167         {0x32c5, 0x28},\r
 168         {0x32cd, 0x02},\r
 169         {0x32d3, 0x12},\r
 170         {0x3118, 0xF2},\r
 171         {0x3119, 0xF2},\r
 172         {0x311A, 0x13},\r
 173         {0x3106, 0x03},\r
 174         {0x3108, 0x00},\r
 175         {0x3112, 0xF1},\r
 176         {0x3113, 0x55},\r
 177         {0x3114, 0x05},\r
 178         {0x3012, 0x03},\r
 179         {0x3013, 0xC0},\r
 180         {0x3326, 0x02},\r
 181         {0x3327, 0x04},\r
 182         {0x3328, 0x04},\r
 183         {0x3329, 0x02},\r
 184         {0x332A, 0x02},\r
 185         {0x332B, 0x1D},\r
 186         {0x332C, 0x1D},\r
 187         {0x332D, 0x04},\r
 188         {0x332E, 0x1E},\r
 189         {0x332F, 0x1F},\r
 190         {0x32f6, 0x0B},\r
 191         {0x3343, 0xE0},\r
 192         {0x333B, 0x10},\r
 193         {0x333C, 0x14},\r
 194         {0x333D, 0x30},\r
 195         {0x333E, 0x30},\r
 196         {0x333F, 0x88},\r
 197         {0x3340, 0x84},\r
 198         {0x3341, 0x50},\r
 199         {0x3342, 0x50},\r
 200         {0x3344, 0x20},\r
 201         {0x3345, 0x28},\r
 202         {0x3346, 0x3F},\r
 203         {0x3347, 0x3F},\r
 204         {0x3348, 0xF0},\r
 205         {0x3349, 0x40},\r
 206         {0x334A, 0x40},\r
 207         {0x334B, 0x20},\r
 208         {0x334C, 0x20},\r
 209         {0x334D, 0x00},\r
 210         {0x32f6, 0x0B},\r
 211         {0x32f9, 0x63},\r
 212         {0x32fA, 0x36},\r
 213         {0x3338, 0x18},\r
 214         {0x3339, 0xC6},\r
 215         {0x333A, 0x6C},\r
 216         {0x3109, 0x82},\r
 217         SensorEnd\r
 218 };\r
 219 /* Senor full resolution setting: recommand for capture */\r
 220 static struct rk_sensor_reg sensor_fullres_lowfps_data[] ={\r
 221         {0x3200, 0x3e},\r
 222         {0x3201, 0x0f},\r
 223         {0x3028, 0x07},\r
 224         {0x3029, 0x00},\r
 225         {0x302a, 0x04},\r
 226         {0x3022, 0x24},\r
 227         {0x3023, 0x24},\r
 228         {0x3128, 0x01},\r
 229         {0x3002, 0x00},\r
 230         {0x3003, 0x04},\r
 231         {0x3004, 0x00},\r
 232         {0x3005, 0x04},\r
 233         {0x3006, 0x06},\r
 234         {0x3007, 0x43},\r
 235         {0x3008, 0x04},\r
 236         {0x3009, 0xb3},\r
 237         {0x300a, 0x09},\r
 238         {0x300b, 0xc4},\r
 239         {0x300c, 0x07},\r
 240         {0x300d, 0x80},\r
 241         {0x300e, 0x06},\r
 242         {0x300f, 0x40},\r
 243         {0x3010, 0x04},\r
 244         {0x3011, 0xb0},\r
 245         {0x3052, 0x10},\r
 246         {0x32bb, 0x1b},\r
 247         {0x32bc, 0x40},\r
 248         {0x32c1, 0x27},\r
 249         {0x32c2, 0x80},\r
 250         {0x32c8, 0x60},\r
 251         {0x32c9, 0x50},\r
 252         {0x32c4, 0x00},\r
 253         {0x3201, 0x3f},\r
 254         {0x3021, 0x06},\r
 255         {0x3060, 0x01},\r
 256         SensorEnd\r
 257 };\r
 258 /* Senor full resolution setting: recommand for video */\r
 259 static struct rk_sensor_reg sensor_fullres_highfps_data[] ={\r
 260         {0x3200, 0x3e},\r
 261         {0x3201, 0x0f},\r
 262         {0x3028, 0x07},\r
 263         {0x3029, 0x00},\r
 264         {0x302a, 0x04},\r
 265         {0x3022, 0x24},\r
 266         {0x3023, 0x24},\r
 267         {0x3128, 0x01},\r
 268         {0x3002, 0x00},\r
 269         {0x3003, 0x04},\r
 270         {0x3004, 0x00},\r
 271         {0x3005, 0x04},\r
 272         {0x3006, 0x06},\r
 273         {0x3007, 0x43},\r
 274         {0x3008, 0x04},\r
 275         {0x3009, 0xb3},\r
 276         {0x300a, 0x08},\r
 277         {0x300b, 0x34},\r
 278         {0x300c, 0x04},\r
 279         {0x300d, 0xbd},\r
 280         {0x300e, 0x06},\r
 281         {0x300f, 0x40},\r
 282         {0x3010, 0x04},\r
 283         {0x3011, 0xb0},\r
 284         {0x3052, 0x10},\r
 285         {0x32bb, 0x1b},\r
 286         {0x32bc, 0x40},\r
 287         {0x32c1, 0x24},\r
 288         {0x32c2, 0x74},\r
 289         {0x32c8, 0x72},\r
 290         {0x32c9, 0x5f},\r
 291         {0x32c4, 0x00},\r
 292         {0x3201, 0x3f},\r
 293         {0x3021, 0x16},\r
 294         {0x3060, 0x01},\r
 295         SensorEnd\r
 296 };\r
 297 /* Preview resolution setting*/\r
 298 static struct rk_sensor_reg sensor_preview_data[] =\r
 299 {\r
 300         {0x32e0, 0x03},\r
 301         {0x32e1, 0x20},\r
 302         {0x32e2, 0x02},\r
 303         {0x32e3, 0x58},\r
 304         {0x32e4, 0x01},\r
 305         {0x32e5, 0x00},\r
 306         {0x32e6, 0x00},\r
 307         {0x32e7, 0x00},\r
 308         {0x3200, 0x3e},\r
 309         {0x3201, 0x0f},\r
 310         {0x3028, 0x07},\r
 311         {0x3029, 0x00},\r
 312         {0x302a, 0x04},\r
 313         {0x3022, 0x24},\r
 314         {0x3023, 0x64},\r
 315         {0x3128, 0x01},\r
 316         {0x3002, 0x00},\r
 317         {0x3003, 0x04},\r
 318         {0x3004, 0x00},\r
 319         {0x3005, 0x04},\r
 320         {0x3006, 0x06},\r
 321         {0x3007, 0x43},\r
 322         {0x3008, 0x04},\r
 323         {0x3009, 0xb3},\r
 324         {0x300a, 0x09},\r
 325         {0x300b, 0xc4},\r
 326         {0x300c, 0x02},\r
 327         {0x300d, 0x80},\r
 328         {0x300e, 0x06},\r
 329         {0x300f, 0x40},\r
 330         {0x3010, 0x02},\r
 331         {0x3011, 0x58},\r
 332         {0x3052, 0x10},\r
 333         {0x32bb, 0x1b},\r
 334         {0x32bc, 0x40},\r
 335         {0x32c1, 0x22},\r
 336         {0x32c2, 0xa0},\r
 337         {0x32c8, 0x60},\r
 338         {0x32c9, 0x50},\r
 339         {0x32c4, 0x00},\r
 340         {0x3201, 0x7f},\r
 341         {0x3021, 0x06},\r
 342         {0x3060, 0x01},\r
 343         SensorEnd\r
 344 };\r
 345 /* 1280x720 */\r
 346 static struct rk_sensor_reg sensor_720p[]={\r
 347         {0x3200, 0x3e},\r
 348         {0x3201, 0x0f},\r
 349         {0x3028, 0x07},\r
 350         {0x3029, 0x00},\r
 351         {0x302a, 0x04},\r
 352         {0x3022, 0x24},\r
 353         {0x3023, 0x24},\r
 354         {0x3128, 0x01},\r
 355         {0x3002, 0x00},\r
 356         {0x3003, 0xa4},\r
 357         {0x3004, 0x00},\r
 358         {0x3005, 0xf4},\r
 359         {0x3006, 0x05},\r
 360         {0x3007, 0xa3},\r
 361         {0x3008, 0x03},\r
 362         {0x3009, 0xc3},\r
 363         {0x300a, 0x06},\r
 364         {0x300b, 0xf4},\r
 365         {0x300c, 0x03},\r
 366         {0x300d, 0x82},\r
 367         {0x300e, 0x05},\r
 368         {0x300f, 0x00},\r
 369         {0x3010, 0x02},\r
 370         {0x3011, 0xd0},\r
 371         {0x3052, 0x10},\r
 372         {0x32bb, 0x1b},\r
 373         {0x32bc, 0x40},\r
 374         {0x32c1, 0x23},\r
 375         {0x32c2, 0xaa},\r
 376         {0x32c8, 0x86},\r
 377         {0x32c9, 0x70},\r
 378         {0x32c4, 0x00},\r
 379         {0x3201, 0x3f},\r
 380         {0x3021, 0x16},\r
 381         {0x3060, 0x01},\r
 382         SensorEnd\r
 383 };\r
 384 \r
 385 /* 1920x1080 */\r
 386 static struct rk_sensor_reg sensor_1080p[]={\r
 387         SensorEnd\r
 388 };\r
 389 \r
 390 \r
 391 static struct rk_sensor_reg sensor_softreset_data[]={\r
 392     SensorRegVal(0x3021,0x61),\r
 393         SensorEnd\r
 394 };\r
 395 \r
 396 static struct rk_sensor_reg sensor_check_id_data[]={\r
 397     SensorRegVal(0x3000,0),\r
 398     SensorRegVal(0x3001,0),\r
 399         SensorEnd\r
 400 };\r
 401 /*\r
 402 *  The following setting must been filled, if the function is turn on by CONFIG_SENSOR_xxxx\r
 403 */\r
 404 static struct rk_sensor_reg sensor_WhiteB_Auto[]=\r
 405 {\r
 406         {0x3201, 0x7F},\r
 407         SensorEnd\r
 408 };\r
 409 /* Cloudy Colour Temperature : 6500K - 8000K  */\r
 410 static  struct rk_sensor_reg sensor_WhiteB_Cloudy[]=\r
 411 {\r
 412         //[WB-CLOUDY]\r
 413         {0x3201, 0x6F},\r
 414         {0x3290, 0x01},\r
 415         {0x3291, 0x51},\r
 416         {0x3296, 0x01},\r
 417         {0x3297, 0x00},\r
 418         SensorEnd\r
 419 };\r
 420 /* ClearDay Colour Temperature : 5000K - 6500K  */\r
 421 static  struct rk_sensor_reg sensor_WhiteB_ClearDay[]=\r
 422 {\r
 423         //[WB-DAYLIGHT]\r
 424         {0x3201, 0x6F},\r
 425         {0x3290, 0x01},\r
 426         {0x3291, 0xD8},\r
 427         {0x3296, 0x01},\r
 428         {0x3297, 0x58}, \r
 429         SensorEnd\r
 430 };\r
 431 /* Office Colour Temperature : 3500K - 5000K  */\r
 432 static  struct rk_sensor_reg sensor_WhiteB_TungstenLamp1[]=\r
 433 {\r
 434         //[WB-INCANDESCENCE]\r
 435         {0x3201, 0x6F},\r
 436         {0x3290, 0x01},\r
 437         {0x3291, 0x30},\r
 438         {0x3296, 0x01},\r
 439         {0x3297, 0xCB},\r
 440         SensorEnd\r
 441 \r
 442 };\r
 443 /* Home Colour Temperature : 2500K - 3500K      */\r
 444 static  struct rk_sensor_reg sensor_WhiteB_TungstenLamp2[]=\r
 445 {\r
 446         //[WB-FLUORESCENT]\r
 447         {0x3201, 0x6F},\r
 448         {0x3290, 0x02},\r
 449         {0x3291, 0x00},\r
 450         {0x3296, 0x02},\r
 451         {0x3297, 0x00},\r
 452         SensorEnd\r
 453 };\r
 454 static  struct rk_sensor_reg sensor_WhiteB_TungstenLamp3[]=\r
 455 {\r
 456         //[WB-TUNGSTEN]\r
 457         {0x3201, 0x6F},\r
 458         {0x3290, 0x01},\r
 459         {0x3291, 0x00},\r
 460         {0x3296, 0x02},\r
 461         {0x3297, 0x20},\r
 462         SensorEnd\r
 463 };\r
 464 \r
 465 static struct rk_sensor_reg *sensor_WhiteBalanceSeqe[] = {sensor_WhiteB_Auto, sensor_WhiteB_TungstenLamp1,sensor_WhiteB_TungstenLamp2,\r
 466         sensor_WhiteB_ClearDay, sensor_WhiteB_Cloudy, sensor_WhiteB_TungstenLamp3,NULL,\r
 467 };\r
 468 \r
 469 static  struct rk_sensor_reg sensor_Brightness0[]=\r
 470 {\r
 471         // Brightness -2\r
 472         SensorEnd\r
 473 };\r
 474 \r
 475 static  struct rk_sensor_reg sensor_Brightness1[]=\r
 476 {\r
 477         // Brightness -1\r
 478 \r
 479         SensorEnd\r
 480 };\r
 481 \r
 482 static  struct rk_sensor_reg sensor_Brightness2[]=\r
 483 {\r
 484         //      Brightness 0\r
 485 \r
 486         SensorEnd\r
 487 };\r
 488 \r
 489 static  struct rk_sensor_reg sensor_Brightness3[]=\r
 490 {\r
 491         // Brightness +1\r
 492 \r
 493         SensorEnd\r
 494 };\r
 495 \r
 496 static  struct rk_sensor_reg sensor_Brightness4[]=\r
 497 {\r
 498         //      Brightness +2\r
 499 \r
 500         SensorEnd\r
 501 };\r
 502 \r
 503 static  struct rk_sensor_reg sensor_Brightness5[]=\r
 504 {\r
 505         //      Brightness +3\r
 506 \r
 507         SensorEnd\r
 508 };\r
 509 static struct rk_sensor_reg *sensor_BrightnessSeqe[] = {sensor_Brightness0, sensor_Brightness1, sensor_Brightness2, sensor_Brightness3,\r
 510         sensor_Brightness4, sensor_Brightness5,NULL,\r
 511 };\r
 512 \r
 513 static  struct rk_sensor_reg sensor_Effect_Normal[] =\r
 514 {\r
 515         {0x32F1, 0x00},\r
 516         SensorEnd\r
 517 };\r
 518 \r
 519 static  struct rk_sensor_reg sensor_Effect_WandB[] =\r
 520 {       \r
 521         //[SE-GrayScale]\r
 522         {0x32F1, 0x01}, \r
 523 };\r
 524 \r
 525 static  struct rk_sensor_reg sensor_Effect_Sepia[] =\r
 526 {\r
 527         //[SE-SEPIA]\r
 528         {0x32F1, 0x02},\r
 529         SensorEnd\r
 530 };\r
 531 \r
 532 static  struct rk_sensor_reg sensor_Effect_Inverse[] =\r
 533 {\r
 534         //[SE-Inverse] \r
 535         {0x32F1, 0x03},\r
 536         SensorEnd\r
 537 };\r
 538 static  struct rk_sensor_reg sensor_Effect_Bluish[] =\r
 539 {\r
 540         //[SE-SEPIABlue]\r
 541         {0x32F1, 0x05},\r
 542         {0x32F4, 0xF0},\r
 543         {0x32F5, 0x80},\r
 544         SensorEnd\r
 545 };\r
 546 \r
 547 static  struct rk_sensor_reg sensor_Effect_Green[] =\r
 548 {\r
 549         //[SE-SEPIAGreen]\r
 550         {0x32F1, 0x05},\r
 551         {0x32F4, 0x60},\r
 552         {0x32F5, 0x20},\r
 553         SensorEnd\r
 554 };\r
 555 \r
 556 static  struct rk_sensor_reg sensor_Effect_Solarization[] =\r
 557 {\r
 558         \r
 559         //[SE-Solarization]\r
 560         {0x32F1, 0x04},\r
 561         SensorEnd\r
 562 };\r
 563 \r
 564 \r
 565 static struct rk_sensor_reg *sensor_EffectSeqe[] = {sensor_Effect_Normal, sensor_Effect_WandB, sensor_Effect_Inverse,sensor_Effect_Sepia,\r
 566         sensor_Effect_Bluish, sensor_Effect_Green,sensor_Effect_Solarization,NULL,\r
 567 };\r
 568 \r
 569 static  struct rk_sensor_reg sensor_Exposure04[]=\r
 570 {\r
 571         //[EV-4]                                \r
 572         {0x32F6, 0X0C},\r
 573         {0x32F2, 0x40},\r
 574         SensorEnd\r
 575 };\r
 576 \r
 577 static  struct rk_sensor_reg sensor_Exposure03[]=\r
 578 {\r
 579         //[EV-3]              \r
 580         {0x32F6, 0X0C},\r
 581         {0x32F2, 0x50},\r
 582         SensorEnd\r
 583 };\r
 584 \r
 585 static  struct rk_sensor_reg sensor_Exposure02[]=\r
 586 {\r
 587         //[EV-2]                                \r
 588         {0x32F6, 0X0C},\r
 589         {0x32F2, 0x60},\r
 590         SensorEnd\r
 591 };\r
 592 \r
 593 static  struct rk_sensor_reg sensor_Exposure01[]=\r
 594 {\r
 595         //[EV-1]                                \r
 596         {0x32F6, 0X0C},\r
 597         {0x32F2, 0x70},\r
 598         SensorEnd\r
 599 };\r
 600 \r
 601 static  struct rk_sensor_reg sensor_Exposure00[]=\r
 602 {\r
 603         \r
 604         //[EV+0]                                \r
 605         {0x32F6, 0X0C},\r
 606         {0x32F2, 0x80},\r
 607         SensorEnd\r
 608 };\r
 609 \r
 610 static  struct rk_sensor_reg sensor_Exposure11[]=\r
 611 {\r
 612         //[EV+1]              \r
 613         {0x32F6, 0X0C},\r
 614         {0x32F2, 0x90},\r
 615         SensorEnd\r
 616 };\r
 617 \r
 618 static  struct rk_sensor_reg sensor_Exposure12[]=\r
 619 {\r
 620         //[EV+2]                                \r
 621         {0x32F6, 0X0C},\r
 622         {0x32F2, 0xA0},\r
 623         SensorEnd\r
 624 };\r
 625 \r
 626 static  struct rk_sensor_reg sensor_Exposure13[]=\r
 627 {\r
 628         //[EV+3]                                \r
 629         {0x32F6, 0X0C},\r
 630         {0x32F2, 0xB0},\r
 631         SensorEnd\r
 632 };\r
 633 \r
 634 static  struct rk_sensor_reg sensor_Exposure14[]=\r
 635 {\r
 636         //[EV+4]                                \r
 637         {0x32F6, 0X0C},\r
 638         {0x32F2, 0xC0},\r
 639         SensorEnd\r
 640 };\r
 641 \r
 642 static struct rk_sensor_reg *sensor_ExposureSeqe[] = {sensor_Exposure04,sensor_Exposure03, sensor_Exposure02, sensor_Exposure01, sensor_Exposure00,\r
 643         sensor_Exposure11, sensor_Exposure12,sensor_Exposure13,sensor_Exposure14,NULL,\r
 644 };\r
 645 \r
 646 static  struct rk_sensor_reg sensor_Saturation0[]=\r
 647 {\r
 648         SensorEnd\r
 649 };\r
 650 \r
 651 static  struct rk_sensor_reg sensor_Saturation1[]=\r
 652 {\r
 653         SensorEnd\r
 654 };\r
 655 \r
 656 static  struct rk_sensor_reg sensor_Saturation2[]=\r
 657 {\r
 658         SensorEnd\r
 659 };\r
 660 static struct rk_sensor_reg *sensor_SaturationSeqe[] = {sensor_Saturation0, sensor_Saturation1, sensor_Saturation2, NULL,};\r
 661 \r
 662 static  struct rk_sensor_reg sensor_Contrast04[]=\r
 663 {\r
 664         //[Contrast : -4]   \r
 665         {0x32F6, 0x0C}, \r
 666         {0x32C2, 0x40},\r
 667         {0x32F2, 0x40},\r
 668         SensorEnd\r
 669 };\r
 670 \r
 671 static  struct rk_sensor_reg sensor_Contrast03[]=\r
 672 {\r
 673         //[Contrast : -3]        \r
 674         {0x32F6, 0x0C},    \r
 675         {0x32C2, 0x30},\r
 676         {0x32F2, 0x50},\r
 677         SensorEnd\r
 678 };\r
 679 \r
 680 static  struct rk_sensor_reg sensor_Contrast02[]=\r
 681 {\r
 682         //[Contrast : -2]    \r
 683         {0x32F6, 0x0C},  \r
 684         {0x32C2, 0x20},\r
 685         {0x32F2, 0x60},\r
 686         SensorEnd\r
 687 };\r
 688 \r
 689 static  struct rk_sensor_reg sensor_Contrast01[]=\r
 690 {\r
 691         //[Contrast : -1] \r
 692         {0x32F6, 0x0C},         \r
 693         {0x32C2, 0x10},\r
 694         {0x32F2, 0x70},\r
 695         SensorEnd\r
 696 };\r
 697 \r
 698 static  struct rk_sensor_reg sensor_Contrast00[]=\r
 699 {\r
 700         //[Contrast : 0]        \r
 701         {0x32F6, 0x0C},     \r
 702         {0x32C2, 0x00},\r
 703         {0x32F2, 0x80},\r
 704         SensorEnd\r
 705 };\r
 706 \r
 707 static  struct rk_sensor_reg sensor_Contrast11[]=\r
 708 {\r
 709         //[Contrast : +1]   \r
 710         {0x32F6, 0x0C},   \r
 711         {0x32C2, 0xF0},\r
 712         {0x32F2, 0x90},\r
 713         SensorEnd\r
 714 };\r
 715 \r
 716 \r
 717 static  struct rk_sensor_reg sensor_Contrast12[]=\r
 718 {\r
 719         //[Contrast : +2]  \r
 720         {0x32F6, 0x0C},    \r
 721         {0x32C2, 0xE0},\r
 722         {0x32F2, 0xA0},\r
 723         SensorEnd\r
 724 };\r
 725 \r
 726 static  struct rk_sensor_reg sensor_Contrast13[]=\r
 727 {\r
 728         //[Contrast : +3]        \r
 729         {0x32F6, 0x0C},    \r
 730         {0x32C2, 0xD0},\r
 731         {0x32F2, 0xB0},\r
 732         SensorEnd\r
 733 };\r
 734 \r
 735 static  struct rk_sensor_reg sensor_Contrast14[]=\r
 736 {\r
 737         //[Contrast : +4] \r
 738         {0x32F6, 0x0C},         \r
 739         {0x32C2, 0xC0},\r
 740         {0x32F2, 0xC0},\r
 741         SensorEnd\r
 742 };\r
 743 \r
 744 static struct rk_sensor_reg *sensor_ContrastSeqe[] = {sensor_Contrast04, sensor_Contrast03, sensor_Contrast02, sensor_Contrast01,\r
 745         sensor_Contrast00, sensor_Contrast11, sensor_Contrast12, sensor_Contrast13, sensor_Contrast14,NULL,\r
 746 };\r
 747 \r
 748 static  struct rk_sensor_reg sensor_SceneAuto[] =\r
 749 {\r
 750         SensorEnd\r
 751 };\r
 752 \r
 753 static  struct rk_sensor_reg sensor_SceneNight[] =\r
 754 {\r
 755         SensorEnd\r
 756 };\r
 757 static struct rk_sensor_reg *sensor_SceneSeqe[] = {sensor_SceneAuto, sensor_SceneNight,NULL,};\r
 758 \r
 759 static struct rk_sensor_reg sensor_Zoom0[] =\r
 760 {\r
 761         SensorEnd\r
 762 };\r
 763 \r
 764 static struct rk_sensor_reg sensor_Zoom1[] =\r
 765 {\r
 766         SensorEnd\r
 767 };\r
 768 \r
 769 static struct rk_sensor_reg sensor_Zoom2[] =\r
 770 {\r
 771         SensorEnd\r
 772 };\r
 773 \r
 774 \r
 775 static struct rk_sensor_reg sensor_Zoom3[] =\r
 776 {\r
 777         SensorEnd\r
 778 };\r
 779 static struct rk_sensor_reg *sensor_ZoomSeqe[] = {sensor_Zoom0, sensor_Zoom1, sensor_Zoom2, sensor_Zoom3, NULL,};\r
 780 \r
 781 /*\r
 782 * User could be add v4l2_querymenu in sensor_controls by new_usr_v4l2menu\r
 783 */\r
 784 static struct v4l2_querymenu sensor_menus[] =\r
 785 {\r
 786         //white balance\r
 787         new_usr_v4l2menu(V4L2_CID_DO_WHITE_BALANCE,0,"auto",0),\r
 788         new_usr_v4l2menu(V4L2_CID_DO_WHITE_BALANCE,1,"incandescent",0),\r
 789         new_usr_v4l2menu(V4L2_CID_DO_WHITE_BALANCE,2,"fluorescent",0),\r
 790         new_usr_v4l2menu(V4L2_CID_DO_WHITE_BALANCE,3,"daylight",0),\r
 791         new_usr_v4l2menu(V4L2_CID_DO_WHITE_BALANCE,4,"cloudy-daylight",0),\r
 792         new_usr_v4l2menu(V4L2_CID_DO_WHITE_BALANCE,5,"tungsten",0),\r
 793 \r
 794         //speical effect\r
 795         new_usr_v4l2menu(V4L2_CID_EFFECT,0,"none",0),\r
 796         new_usr_v4l2menu(V4L2_CID_EFFECT,1,"mono",0),\r
 797         new_usr_v4l2menu(V4L2_CID_EFFECT,2,"negative",0),\r
 798         new_usr_v4l2menu(V4L2_CID_EFFECT,3,"sepia",0),\r
 799         new_usr_v4l2menu(V4L2_CID_EFFECT,4,"posterize",0),\r
 800         new_usr_v4l2menu(V4L2_CID_EFFECT,5,"aqua",0),\r
 801         new_usr_v4l2menu(V4L2_CID_EFFECT,6,"solarize",0),\r
 802 };\r
 803 /*\r
 804 * User could be add v4l2_queryctrl in sensor_controls by new_user_v4l2ctrl\r
 805 */\r
 806 static struct sensor_v4l2ctrl_usr_s sensor_controls[] =\r
 807 {\r
 808         new_user_v4l2ctrl(V4L2_CID_DO_WHITE_BALANCE,V4L2_CTRL_TYPE_MENU,"White Balance Control", 0, 5, 1, 0,sensor_v4l2ctrl_default_cb, sensor_WhiteBalanceSeqe),\r
 809         new_user_v4l2ctrl(V4L2_CID_EXPOSURE,V4L2_CTRL_TYPE_INTEGER,"Exposure Control", -4, 4, 1, 0,sensor_v4l2ctrl_default_cb, sensor_ExposureSeqe),\r
 810         new_user_v4l2ctrl(V4L2_CID_EFFECT,V4L2_CTRL_TYPE_MENU,"Effect Control", 0, 6, 1, 0,sensor_v4l2ctrl_default_cb, sensor_EffectSeqe),\r
 811         new_user_v4l2ctrl(V4L2_CID_CONTRAST,V4L2_CTRL_TYPE_INTEGER,"Contrast Control", -4, 4, 1, 0,sensor_v4l2ctrl_default_cb, sensor_ContrastSeqe),\r
 812 };\r
 813 \r
 814 //MUST define the current used format as the first item   \r
 815 static struct rk_sensor_datafmt sensor_colour_fmts[] = {\r
 816         {V4L2_MBUS_FMT_YUYV8_2X8, V4L2_COLORSPACE_JPEG},\r
 817         {V4L2_MBUS_FMT_UYVY8_2X8, V4L2_COLORSPACE_JPEG} \r
 818 };\r
 819 static struct soc_camera_ops sensor_ops;\r
 820 \r
 821 \r
 822 /*\r
 823 **********************************************************\r
 824 * Following is local code:\r
 825 * \r
 826 * Please codeing your program here \r
 827 **********************************************************\r
 828 */\r
 829 static int sensor_parameter_record(struct i2c_client *client)\r
 830 {\r
 831         u8 ret_l,ret_h;\r
 832         int tp_l,tp_h;\r
 833         \r
 834         struct generic_sensor *sensor = to_generic_sensor(client);\r
 835         struct specific_sensor *spsensor = to_specific_sensor(sensor);\r
 836 \r
 837     sensor_read(client, 0x3200, &ret_l);\r
 838     sensor_write(client, 0x3200, ret_l&0xf9); \r
 839         sensor_read(client, 0x3201, &ret_l);\r
 840     sensor_write(client, 0x3201, ret_l&0xcf);  //stop ae awb\r
 841 \r
 842         //read back ae\r
 843         sensor_read(client,0x3012,&ret_h);\r
 844         sensor_read(client,0x3013, &ret_l);\r
 845         tp_l = ret_l;\r
 846         tp_h = ret_h;\r
 847         spsensor->parameter.preview_exposure = ((tp_h<<8) & 0xF0) |((tp_l) & 0x0F);\r
 848         \r
 849         //Read back AGC Gain for preview\r
 850         sensor_read(client,0x3014, &ret_l);\r
 851         spsensor->parameter.preview_gain_dr = ret_l;\r
 852         sensor_read(client,0x3015, &ret_l);\r
 853         spsensor->parameter.preview_gain_ar = ret_l;\r
 854         sensor_read(client,0x3016, &ret_l);\r
 855         spsensor->parameter.preview_gain_dgr = ret_l;\r
 856         sensor_read(client,0x3017, &ret_l);\r
 857         spsensor->parameter.preview_gain_agr = ret_l;\r
 858         sensor_read(client,0x3018, &ret_l);\r
 859         spsensor->parameter.preview_gain_dgb = ret_l;\r
 860         sensor_read(client,0x3019, &ret_l);\r
 861         spsensor->parameter.preview_gain_agb = ret_l;\r
 862         sensor_read(client,0x301a, &ret_l);\r
 863         spsensor->parameter.preview_gain_db = ret_l;\r
 864         sensor_read(client,0x301b, &ret_l);\r
 865         spsensor->parameter.preview_gain_ab = ret_l;\r
 866         sensor_read(client,0x301c, &ret_l);\r
 867         spsensor->parameter.preview_gain_dglobal= ret_l;\r
 868         sensor_read(client,0x301d, &ret_l);\r
 869         spsensor->parameter.preview_gain_aglobal= ret_l;\r
 870 \r
 871         spsensor->parameter.CapturePclk = 48000;\r
 872         spsensor->parameter.PreviewPclk = 48000;\r
 873         sensor_read(client,0x300a, &ret_h);\r
 874         sensor_read(client,0x300b, &ret_l);\r
 875         tp_l = ret_l;\r
 876         tp_h = ret_h;\r
 877         spsensor->parameter.PreviewDummyPixels = (tp_l&0x0F) | ((tp_h<<8)&0xF0);\r
 878         spsensor->parameter.CaptureDummyPixels = 0;\r
 879 \r
 880         #if 0\r
 881         sensor_read(client,0x3290, &ret_h);\r
 882         sensor_read(client,0x3291, &ret_l);\r
 883         tp_l = ret_l;\r
 884         tp_h = ret_h;\r
 885         spsensor->parameter.preview_awb_r = (tp_l&0x0F) | ((tp_h<<8)&0x10);\r
 886 \r
 887         sensor_read(client,0x3296, &ret_h);\r
 888         sensor_read(client,0x3297, &ret_l);\r
 889         tp_l = ret_l;\r
 890         tp_h = ret_h;\r
 891         spsensor->parameter.preview_awb_b = (tp_l&0x0F) | ((tp_h<<8)&0x10);\r
 892         #endif\r
 893         return 0;\r
 894 }\r
 895 #define OV2659_FULL_PERIOD_PIXEL_NUMS  (1940)  // default pixel#(w/o dummy pixels) in UXGA mode\r
 896 #define OV2659_FULL_PERIOD_LINE_NUMS   (1238)  // default line#(w/o dummy lines) in UXGA mode\r
 897 #define OV2659_PV_PERIOD_PIXEL_NUMS   (970)  // default pixel#(w/o dummy pixels) in SVGA mode\r
 898 #define OV2659_PV_PERIOD_LINE_NUMS        (618)   // default line#(w/o dummy lines) in SVGA mode\r
 899 \r
 900 /* SENSOR EXPOSURE LINE LIMITATION */\r
 901 #define OV2659_FULL_EXPOSURE_LIMITATION   (1236)\r
 902 #define OV2659_PV_EXPOSURE_LIMITATION     (618)\r
 903 \r
 904 // SENSOR UXGA SIZE\r
 905 #define OV2659_IMAGE_SENSOR_FULL_WIDTH    (1600)\r
 906 #define OV2659_IMAGE_SENSOR_FULL_HEIGHT   (1200)\r
 907 \r
 908 #define OV2659_FULL_GRAB_WIDTH                          (OV2659_IMAGE_SENSOR_FULL_WIDTH - 16)\r
 909 #define OV2659_FULL_GRAB_HEIGHT                         (OV2659_IMAGE_SENSOR_FULL_HEIGHT - 12)\r
 910 \r
 911 static int sensor_ae_transfer(struct i2c_client *client)\r
 912 {\r
 913         //unsigned int prev_line_len,cap_line_len,shutter;\r
 914         struct generic_sensor *sensor = to_generic_sensor(client);\r
 915         struct specific_sensor *spsensor = to_specific_sensor(sensor);\r
 916         int preview_ae_integration, capture_ae_integration;\r
 917         int capture_pixel;\r
 918         u8 ret_h,ret_l;\r
 919         int val_h, val_l;\r
 920         \r
 921         mdelay(100);\r
 922         \r
 923         sensor_read(client, 0x3200, &ret_h);\r
 924         val_h=ret_h;\r
 925     sensor_write(client, 0x3200, ret_h&0xfd); \r
 926         sensor_read(client, 0x3201, &ret_l);\r
 927         val_l=ret_l;\r
 928     sensor_write(client, 0x3201, ret_l&0xdf);  //stop ae awb\r
 929         \r
 930         sensor_read(client,0x300a, &ret_h);\r
 931         sensor_read(client,0x300b, &ret_l);\r
 932         capture_pixel = (ret_l&0x0F) | ((ret_h<<8)&0xF0);\r
 933         preview_ae_integration = spsensor->parameter.preview_exposure*spsensor->parameter.PreviewDummyPixels;\r
 934         capture_ae_integration = preview_ae_integration/capture_pixel;\r
 935         \r
 936         //write back ae\r
 937         sensor_write(client,0x3012,(capture_ae_integration>>8)&0x0F);\r
 938         sensor_write(client,0x3013,capture_ae_integration&0x0F);\r
 939                 \r
 940         //write back AGC Gain for preview\r
 941         sensor_write(client,0x3014, spsensor->parameter.preview_gain_dr);\r
 942         sensor_write(client,0x3015, spsensor->parameter.preview_gain_ar);\r
 943         sensor_write(client,0x3016, spsensor->parameter.preview_gain_dgr);\r
 944         sensor_write(client,0x3017, spsensor->parameter.preview_gain_agr);\r
 945         sensor_write(client,0x3018, spsensor->parameter.preview_gain_dgb);\r
 946         sensor_write(client,0x3019, spsensor->parameter.preview_gain_agb);\r
 947         sensor_write(client,0x301a, spsensor->parameter.preview_gain_db);\r
 948         sensor_write(client,0x301b, spsensor->parameter.preview_gain_ab);\r
 949         sensor_write(client,0x301c, spsensor->parameter.preview_gain_dglobal);\r
 950         sensor_write(client,0x301d, spsensor->parameter.preview_gain_aglobal);\r
 951 \r
 952         #if 0\r
 953         sensor_write(client,0x3290, (spsensor->parameter.preview_awb_r>>8)&0x01);\r
 954         sensor_write(client,0x3291, spsensor->parameter.preview_awb_r&0x0F);\r
 955         sensor_write(client,0x3296, (spsensor->parameter.preview_awb_b>>8)&0x01 );\r
 956         sensor_write(client,0x3297, spsensor->parameter.preview_awb_b&0x0F );\r
 957         #endif\r
 958 \r
 959     //sensor_write(client, 0x3200, val_h); \r
 960     //sensor_write(client, 0x3201, val_l);  //enable ae awb\r
 961         return 0;\r
 962 }\r
 963 /*\r
 964 **********************************************************\r
 965 * Following is callback\r
 966 * If necessary, you could coding these callback\r
 967 **********************************************************\r
 968 */\r
 969 /*\r
 970 * the function is called in open sensor  \r
 971 */\r
 972 static int sensor_activate_cb(struct i2c_client *client)\r
 973 {\r
 974     SENSOR_DG("%s",__FUNCTION__);\r
 975         \r
 976         \r
 977         return 0;\r
 978 }\r
 979 /*\r
 980 * the function is called in close sensor\r
 981 */\r
 982 static int sensor_deactivate_cb(struct i2c_client *client)\r
 983 {\r
 984         struct generic_sensor *sensor = to_generic_sensor(client);\r
 985 \r
 986     SENSOR_DG("%s",__FUNCTION__);\r
 987     \r
 988         /* ddl@rock-chips.com : all sensor output pin must switch into Hi-Z */\r
 989         if (sensor->info_priv.funmodule_state & SENSOR_INIT_IS_OK) {\r
 990                 sensor->info_priv.funmodule_state &= ~SENSOR_INIT_IS_OK;;\r
 991         }\r
 992         \r
 993         return 0;\r
 994 }\r
 995 /*\r
 996 * the function is called before sensor register setting in VIDIOC_S_FMT  \r
 997 */\r
 998 static int sensor_s_fmt_cb_th(struct i2c_client *client,struct v4l2_mbus_framefmt *mf, bool capture)\r
 999 {\r
1000         printk("set fmt set!!!!!!!!!!!!");\r
1001         \r
1002     if (capture) {\r
1003                 sensor_parameter_record(client);\r
1004                 printk("set fmt set!!!!!!!!!!!!");     \r
1005     }\r
1006         \r
1007 \r
1008     return 0;\r
1009 }\r
1010 /*\r
1011 * the function is called after sensor register setting finished in VIDIOC_S_FMT  \r
1012 */\r
1013 static int sensor_s_fmt_cb_bh (struct i2c_client *client,struct v4l2_mbus_framefmt *mf, bool capture)\r
1014 {\r
1015     if (capture) {\r
1016                 sensor_ae_transfer(client);\r
1017                 printk("set fmt set!!!!!!!!!!!!");      \r
1018     }\r
1019         \r
1020 \r
1021     return 0;\r
1022 }\r
1023 \r
1024 static int sensor_try_fmt_cb_th(struct i2c_client *client,struct v4l2_mbus_framefmt *mf)\r
1025 {\r
1026         return 0;\r
1027 }\r
1028 \r
1029 static int sensor_softrest_usr_cb(struct i2c_client *client,struct rk_sensor_reg *series)\r
1030 {\r
1031         \r
1032         return 0;\r
1033 }\r
1034 static int sensor_check_id_usr_cb(struct i2c_client *client,struct rk_sensor_reg *series)\r
1035 {\r
1036         return 0;\r
1037 }\r
1038 \r
1039 static int sensor_suspend(struct soc_camera_device *icd, pm_message_t pm_msg)\r
1040 {\r
1041         //struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
1042                 \r
1043         if (pm_msg.event == PM_EVENT_SUSPEND) {\r
1044                 SENSOR_DG("Suspend");\r
1045                 \r
1046         } else {\r
1047                 SENSOR_TR("pm_msg.event(0x%x) != PM_EVENT_SUSPEND\n",pm_msg.event);\r
1048                 return -EINVAL;\r
1049         }\r
1050         return 0;\r
1051 }\r
1052 \r
1053 static int sensor_resume(struct soc_camera_device *icd)\r
1054 {\r
1055 \r
1056         SENSOR_DG("Resume");\r
1057 \r
1058         return 0;\r
1059 \r
1060 }\r
1061 static int sensor_mirror_cb (struct i2c_client *client, int mirror)\r
1062 {\r
1063         char val;\r
1064         int err = 0;\r
1065     \r
1066     SENSOR_DG("mirror: %d",mirror);\r
1067         if (mirror) {\r
1068                 err = sensor_read(client, 0x3022, &val);\r
1069                 if (err == 0) {\r
1070                         val |= 0x02;\r
1071                         err = sensor_write(client, 0x3022, val);\r
1072                 }\r
1073         } else {\r
1074                 err = sensor_read(client, 0x3022, &val);\r
1075                 if (err == 0) {\r
1076                         val &= 0xfd;\r
1077                         err = sensor_write(client, 0x3022, val);\r
1078                 }\r
1079         }\r
1080 \r
1081         return err;    \r
1082 }\r
1083 /*\r
1084 * the function is v4l2 control V4L2_CID_HFLIP callback  \r
1085 */\r
1086 static int sensor_v4l2ctrl_mirror_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info, \r
1087                                                      struct v4l2_ext_control *ext_ctrl)\r
1088 {\r
1089         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
1090 \r
1091     if (sensor_mirror_cb(client,ext_ctrl->value) != 0)\r
1092                 SENSOR_TR("sensor_mirror failed, value:0x%x",ext_ctrl->value);\r
1093         \r
1094         SENSOR_DG("sensor_mirror success, value:0x%x",ext_ctrl->value);\r
1095         return 0;\r
1096 }\r
1097 \r
1098 static int sensor_flip_cb(struct i2c_client *client, int flip)\r
1099 {\r
1100         char val;\r
1101         int err = 0;    \r
1102 \r
1103 \r
1104     SENSOR_DG("flip: %d",flip);\r
1105         if (flip) {\r
1106                 err = sensor_read(client, 0x3022, &val);\r
1107                 if (err == 0) {\r
1108                         val |= 0x01;\r
1109                         err = sensor_write(client, 0x3022, val);\r
1110                 }\r
1111         } else {\r
1112                 err = sensor_read(client, 0x3022, &val);\r
1113                 if (err == 0) {\r
1114                         val &= 0xfe;\r
1115                         err = sensor_write(client, 0x3022, val);\r
1116                 }\r
1117         }\r
1118 \r
1119         return err;       \r
1120 }\r
1121 /*\r
1122 * the function is v4l2 control V4L2_CID_VFLIP callback  \r
1123 */\r
1124 static int sensor_v4l2ctrl_flip_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info, \r
1125                                                      struct v4l2_ext_control *ext_ctrl)\r
1126 {\r
1127         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
1128 \r
1129     if (sensor_flip_cb(client,ext_ctrl->value) != 0)\r
1130                 SENSOR_TR("sensor_flip failed, value:0x%x",ext_ctrl->value);\r
1131         \r
1132         SENSOR_DG("sensor_flip success, value:0x%x",ext_ctrl->value);\r
1133         return 0;\r
1134 }\r
1135 \r
1136 static int sensor_focus_init_usr_cb(struct i2c_client *client){\r
1137         return 0;\r
1138 }\r
1139 \r
1140 static int sensor_focus_af_single_usr_cb(struct i2c_client *client){\r
1141         return 0;\r
1142 }\r
1143 \r
1144 static int sensor_focus_af_near_usr_cb(struct i2c_client *client){\r
1145         return 0;\r
1146 }\r
1147 \r
1148 static int sensor_focus_af_far_usr_cb(struct i2c_client *client){\r
1149         return 0;\r
1150 }\r
1151 \r
1152 static int sensor_focus_af_specialpos_usr_cb(struct i2c_client *client,int pos){\r
1153         return 0;\r
1154 }\r
1155 \r
1156 static int sensor_focus_af_const_usr_cb(struct i2c_client *client){\r
1157         return 0;\r
1158 }\r
1159 static int sensor_focus_af_const_pause_usr_cb(struct i2c_client *client)
1160 {
1161     return 0;
1162 }\r
1163 static int sensor_focus_af_close_usr_cb(struct i2c_client *client){\r
1164         return 0;\r
1165 }\r
1166 \r
1167 static int sensor_focus_af_zoneupdate_usr_cb(struct i2c_client *client, int *zone_tm_pos)\r
1168 {\r
1169         return 0;\r
1170 }\r
1171 \r
1172 /*\r
1173 face defect call back\r
1174 */\r
1175 static int      sensor_face_detect_usr_cb(struct i2c_client *client,int on){\r
1176         return 0;\r
1177 }\r
1178 \r
1179 /*\r
1180 *   The function can been run in sensor_init_parametres which run in sensor_probe, so user can do some\r
1181 * initialization in the function. \r
1182 */\r
1183 static void sensor_init_parameters_user(struct specific_sensor* spsensor,struct soc_camera_device *icd)\r
1184 {\r
1185     return;\r
1186 }\r
1187 \r
1188 /*\r
1189 * :::::WARNING:::::\r
1190 * It is not allowed to modify the following code\r
1191 */\r
1192 \r
1193 sensor_init_parameters_default_code();\r
1194 \r
1195 sensor_v4l2_struct_initialization();\r
1196 \r
1197 sensor_probe_default_code();\r
1198 \r
1199 sensor_remove_default_code();\r
1200 \r
1201 sensor_driver_default_module_code();\r
1202 \r
1203 \r
1204 \r
1205 \r