projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / imgsensor / src / mt8127 / ov2659_yuv / ov2659yuv_Sensor.c
CommitLineData
6fa3eb70
S		 1#include <linux/videodev2.h>
2#include <linux/i2c.h>
3#include <linux/platform_device.h>
4#include <linux/delay.h>
5#include <linux/cdev.h>
6#include <linux/uaccess.h>
7#include <linux/fs.h>
8#include <asm/atomic.h>
9#include <asm/io.h>
10#include <asm/system.h>
11#include "kd_camera_hw.h"
12#include "kd_imgsensor.h"
13#include "kd_imgsensor_define.h"
14#include "kd_imgsensor_errcode.h"
15#include "kd_camera_feature.h"
16#include "ov2659yuv_Sensor.h"
17#include "ov2659yuv_Camera_Sensor_para.h"
18#include "ov2659yuv_CameraCustomized.h"
19
20#define OV2659YUV_DEBUG
21#ifdef OV2659YUV_DEBUG
22#define OV2659SENSORDB printk
23#else
24#define OV2659SENSORDB(x,...)
25#endif
26
27static DEFINE_SPINLOCK(ov2659_drv_lock);
28
29extern int iReadReg(u16 a_u2Addr , u8 * a_puBuff , u16 i2cId);
30extern int iWriteReg(u16 a_u2Addr , u32 a_u4Data , u32 a_u4Bytes , u16 i2cId);
31
32#define OV2659_write_cmos_sensor(addr, para) iWriteReg((u16) addr , (u32) para ,1,OV2659_WRITE_ID)
33#define mDELAY(ms) mdelay(ms)
34#define OV2659_TEST_PATTERN_CHECKSUM (0x1c936910) // 0x7ba87eae
35
36static struct
37{
38 kal_uint8 IsPVmode;
39 kal_uint32 PreviewDummyPixels;
40 kal_uint32 PreviewDummyLines;
41 kal_uint32 CaptureDummyPixels;
42 kal_uint32 CaptureDummyLines;
43 kal_uint32 PreviewPclk;
44 kal_uint32 CapturePclk;
45 kal_uint32 PreviewShutter;
46 kal_uint32 SensorGain;
47 kal_uint32 sceneMode;
48 kal_uint32 SensorShutter;
49 unsigned char isoSpeed;
50 OV2659_SENSOR_MODE SensorMode;
51} OV2659Sensor;
52
53UINT16 WBcount = 0;
54
55MSDK_SENSOR_CONFIG_STRUCT OV2659SensorConfigData;
56
57
58
59kal_uint16 OV2659_read_cmos_sensor(kal_uint32 addr)
60{
61 kal_uint16 get_byte=0;
62
63 iReadReg((u16)addr, (u8*)&get_byte, OV2659_WRITE_ID);
64
65 return get_byte;
66}
67
68
69
70kal_uint32 OV2659_gain_check(kal_uint32 gain)
71{
72 gain = (gain > OV2659_MAX_GAIN) ? OV2659_MAX_GAIN : gain;
73 gain = (gain < OV2659_MIN_GAIN) ? OV2659_MIN_GAIN : gain;
74
75 return gain;
76}
77
78
79
80static void OV2659_set_AE_mode(kal_bool AE_enable)
81{
82 kal_uint8 AeTemp;
83
84 AeTemp = OV2659_read_cmos_sensor(0x3503);
85
86 if (AE_enable == KAL_TRUE)
87 {
88 OV2659SENSORDB("[OV2659_set_AE_mode] enable\n");
89
90 OV2659_write_cmos_sensor(0x3503, (AeTemp & (~0x07)));
91 }
92 else
93 {
94 OV2659SENSORDB("[OV2659_set_AE_mode] disable\n");
95
96 OV2659_write_cmos_sensor(0x3503, (AeTemp | 0x07));
97 }
98}
99
100
101
102static void OV2659WriteShutter(kal_uint32 shutter)
103{
104 kal_uint32 extra_exposure_lines = 0;
105
106 OV2659SENSORDB("[OV2659WriteShutter] shutter=%d\n", shutter);
107
108 if (OV2659Sensor.IsPVmode)
109 {
110 if (shutter <= OV2659_PV_EXPOSURE_LIMITATION)
111 extra_exposure_lines = 0;
112 else
113 extra_exposure_lines = shutter - OV2659_PV_EXPOSURE_LIMITATION;
114 }
115 else
116 {
117 if (shutter <= OV2659_FULL_EXPOSURE_LIMITATION)
118 extra_exposure_lines = 0;
119 else
120 extra_exposure_lines = shutter - OV2659_FULL_EXPOSURE_LIMITATION;
121 }
122
123 shutter *= 16;
124
125 OV2659_write_cmos_sensor(0x3502, shutter & 0x00FF);
126 OV2659_write_cmos_sensor(0x3501, ((shutter & 0x0FF00) >>8));
127 OV2659_write_cmos_sensor(0x3500, ((shutter & 0xFF0000) >> 16));
128
129 if(extra_exposure_lines>0)
130 {
131 OV2659_write_cmos_sensor(0x3507, extra_exposure_lines & 0xFF);
132 OV2659_write_cmos_sensor(0x3506, (extra_exposure_lines & 0xFF00) >> 8);
133 }
134 else
135 {
136 OV2659_write_cmos_sensor(0x3507, 0x00);
137 OV2659_write_cmos_sensor(0x3506, 0x00);
138 }
139}
140
141
142
143static void OV2659WriteSensorGain(kal_uint32 gain)
144{
145 kal_uint16 temp_reg = 0;
146
147 OV2659SENSORDB("[OV2659WriteSensorGain] gain=%d\n", gain);
148
149 gain = OV2659_gain_check(gain);
150 temp_reg = gain&0xFF;
151
152 OV2659_write_cmos_sensor(0x350B, temp_reg);
153}
154
155
156
157void OV2659_night_mode(kal_bool enable)
158{
159 kal_uint16 night = OV2659_read_cmos_sensor(0x3A00);
160
161 if (enable)
162 {
163 OV2659SENSORDB("[OV2659_night_mode] enable\n");
164
165 OV2659_write_cmos_sensor(0x3A00, night | 0x04); // 25fps-5fps
166 OV2659_write_cmos_sensor(0x3a02, 0x0e);
167 OV2659_write_cmos_sensor(0x3a03, 0x70);
168 OV2659_write_cmos_sensor(0x3a14, 0x0e);
169 OV2659_write_cmos_sensor(0x3a15, 0x70);
170 }
171 else
172 {
173 OV2659SENSORDB("[OV2659_night_mode] disable\n");
174
175 OV2659_write_cmos_sensor(0x3A00, night | 0x04); //25fps-12.5fps
176 OV2659_write_cmos_sensor(0x3a02, 0x07);
177 OV2659_write_cmos_sensor(0x3a03, 0x38);
178 OV2659_write_cmos_sensor(0x3a14, 0x07);
179 OV2659_write_cmos_sensor(0x3a15, 0x38);
180 }
181}
182
183
184
185void OV2659_set_contrast(UINT16 para)
186{
187 OV2659SENSORDB("[OV2659_set_contrast]para=%d\n", para);
188
189 switch (para)
190 {
191 case ISP_CONTRAST_HIGH:
192 OV2659_write_cmos_sensor(0x3208, 0x00);
193 OV2659_write_cmos_sensor(0x5080, 0x28);
194 OV2659_write_cmos_sensor(0x5081, 0x28);
195 OV2659_write_cmos_sensor(0x3208, 0x10);
196 OV2659_write_cmos_sensor(0x3208, 0xa0);
197 break;
198 case ISP_CONTRAST_MIDDLE:
199 OV2659_write_cmos_sensor(0x3208, 0x00);
200 OV2659_write_cmos_sensor(0x5080, 0x20);
201 OV2659_write_cmos_sensor(0x5081, 0x20);
202 OV2659_write_cmos_sensor(0x3208, 0x10);
203 OV2659_write_cmos_sensor(0x3208, 0xa0);
204 break;
205 case ISP_CONTRAST_LOW:
206 OV2659_write_cmos_sensor(0x3208, 0x00);
207 OV2659_write_cmos_sensor(0x5080, 0x18);
208 OV2659_write_cmos_sensor(0x5081, 0x18);
209 OV2659_write_cmos_sensor(0x3208, 0x10);
210 OV2659_write_cmos_sensor(0x3208, 0xa0);
211 break;
212 default:
213 break;
214 }
215}
216
217
218
219void OV2659_set_brightness(UINT16 para)
220{
221 OV2659SENSORDB("[OV5645MIPI_set_brightness]para=%d\n", para);
222
223 switch (para)
224 {
225 case ISP_BRIGHT_HIGH:
226 OV2659_write_cmos_sensor(0x3208, 0x00);
227 OV2659_write_cmos_sensor(0x3a0f, 0x50);
228 OV2659_write_cmos_sensor(0x3a10, 0x48);
229 OV2659_write_cmos_sensor(0x3a11, 0xa0);
230 OV2659_write_cmos_sensor(0x3a1b, 0x50);
231 OV2659_write_cmos_sensor(0x3a1e, 0x48);
232 OV2659_write_cmos_sensor(0x3a1f, 0x24);
233 OV2659_write_cmos_sensor(0x3208, 0x10);
234 OV2659_write_cmos_sensor(0x3208, 0xa0);
235 break;
236 case ISP_BRIGHT_MIDDLE:
237 OV2659_write_cmos_sensor(0x3208, 0x00);
238 OV2659_write_cmos_sensor(0x3a0f, 0x38);
239 OV2659_write_cmos_sensor(0x3a10, 0x30);
240 OV2659_write_cmos_sensor(0x3a11, 0x70);
241 OV2659_write_cmos_sensor(0x3a1b, 0x38);
242 OV2659_write_cmos_sensor(0x3a1e, 0x30);
243 OV2659_write_cmos_sensor(0x3a1f, 0x18);
244 OV2659_write_cmos_sensor(0x3208, 0x10);
245 OV2659_write_cmos_sensor(0x3208, 0xa0);
246 break;
247 case ISP_BRIGHT_LOW:
248 OV2659_write_cmos_sensor(0x3208, 0x00);
249 OV2659_write_cmos_sensor(0x3a0f, 0x20);
250 OV2659_write_cmos_sensor(0x3a10, 0x18);
251 OV2659_write_cmos_sensor(0x3a11, 0x40);
252 OV2659_write_cmos_sensor(0x3a1b, 0x20);
253 OV2659_write_cmos_sensor(0x3a1e, 0x18);
254 OV2659_write_cmos_sensor(0x3a1f, 0x0c);
255 OV2659_write_cmos_sensor(0x3208, 0x10);
256 OV2659_write_cmos_sensor(0x3208, 0xa0);
257 break;
258 default:
259 break;
260 }
261}
262
263
264
265void OV2659_set_saturation(UINT16 para)
266{
267 OV2659SENSORDB("[OV5645MIPI_set_saturation]para=%d\n", para);
268
269 switch (para)
270 {
271 case ISP_SAT_HIGH:
272 OV2659_write_cmos_sensor(0x3208, 0x00);
273 OV2659_write_cmos_sensor(0x5073, 0x1B);
274 OV2659_write_cmos_sensor(0x5074, 0xd6);
275 OV2659_write_cmos_sensor(0x5075, 0xf2);
276 OV2659_write_cmos_sensor(0x5076, 0xf2);
277 OV2659_write_cmos_sensor(0x5077, 0xe7);
278 OV2659_write_cmos_sensor(0x5078, 0x0a);
279 OV2659_write_cmos_sensor(0x3208, 0x10);
280 OV2659_write_cmos_sensor(0x3208, 0xa0);
281 break;
282 case ISP_SAT_MIDDLE:
283 OV2659_write_cmos_sensor(0x3208, 0x00);
284 OV2659_write_cmos_sensor(0x5073, 0x17);
285 OV2659_write_cmos_sensor(0x5074, 0xb3);
286 OV2659_write_cmos_sensor(0x5075, 0xca);
287 OV2659_write_cmos_sensor(0x5076, 0xca);
288 OV2659_write_cmos_sensor(0x5077, 0xc1);
289 OV2659_write_cmos_sensor(0x5078, 0x09);
290 OV2659_write_cmos_sensor(0x3208, 0x10);
291 OV2659_write_cmos_sensor(0x3208, 0xa0);
292 break;
293 case ISP_SAT_LOW:
294 OV2659_write_cmos_sensor(0x3208, 0x00);
295 OV2659_write_cmos_sensor(0x5073, 0x12);
296 OV2659_write_cmos_sensor(0x5074, 0x8f);
297 OV2659_write_cmos_sensor(0x5075, 0xa1);
298 OV2659_write_cmos_sensor(0x5076, 0xa1);
299 OV2659_write_cmos_sensor(0x5077, 0x9a);
300 OV2659_write_cmos_sensor(0x5078, 0x07);
301 OV2659_write_cmos_sensor(0x3208, 0x10);
302 OV2659_write_cmos_sensor(0x3208, 0xa0);
303 break;
304 default:
305 break;
306 }
307}
308
309
310
311void OV2659_set_iso(UINT16 para)
312{
313 OV2659SENSORDB("[OV5645MIPI_set_iso]para=%d\n", para);
314
315 spin_lock(&ov2659_drv_lock);
316 OV2659Sensor.isoSpeed = para;
317 spin_unlock(&ov2659_drv_lock);
318
319 switch (para)
320 {
321 case AE_ISO_AUTO:
322 OV2659_write_cmos_sensor(0x3a19, 0x38);
323 break;
324 case AE_ISO_100:
325 OV2659_write_cmos_sensor(0x3a19, 0x18);
326 break;
327 case AE_ISO_200:
328 OV2659_write_cmos_sensor(0x3a19, 0x38);
329 break;
330 case AE_ISO_400:
331 OV2659_write_cmos_sensor(0x3a19, 0x58);
332 break;
333 default:
334 break;
335 }
336}
337
338
339
340BOOL OV2659_set_param_exposure_for_HDR(UINT16 para)
341{
342 kal_uint32 gain = 0, shutter = 0;
343
344 OV2659SENSORDB("[OV2659_set_param_exposure_for_HDR]para=%d\n", para);
345
346 OV2659_set_AE_mode(KAL_FALSE);
347
348 gain = OV2659Sensor.SensorGain;
349 shutter = OV2659Sensor.SensorShutter;
350
351 switch (para)
352 {
353 case AE_EV_COMP_20:
354 case AE_EV_COMP_10:
355 gain =gain<<1;
356 shutter = shutter<<1;
357 break;
358 case AE_EV_COMP_00:
359 break;
360 case AE_EV_COMP_n10:
361 case AE_EV_COMP_n20:
362 gain = gain >> 1;
363 shutter = shutter >> 1;
364 break;
365 default:
366 break;
367 }
368
369 OV2659WriteSensorGain(gain);
370 OV2659WriteShutter(shutter);
371
372 return TRUE;
373}
374
375
376
377void OV2659_set_scene_mode(UINT16 para)
378{
379 OV2659SENSORDB("[OV2659_set_scene_mode]para=%d\n", para);
380
381 spin_lock(&ov2659_drv_lock);
382 OV2659Sensor.sceneMode=para;
383 spin_unlock(&ov2659_drv_lock);
384
385 switch (para)
386 {
387 case SCENE_MODE_NIGHTSCENE:
388 OV2659_night_mode(KAL_TRUE);
389 break;
390 case SCENE_MODE_PORTRAIT:
391 case SCENE_MODE_LANDSCAPE:
392 case SCENE_MODE_SUNSET:
393 case SCENE_MODE_SPORTS:
394 case SCENE_MODE_HDR:
395 break;
396 case SCENE_MODE_OFF:
397 OV2659_night_mode(KAL_FALSE);
398 break;
399 default:
400 break;
401 }
402}
403
404
405
406static void OV2659SetDummy(kal_uint32 dummy_pixels, kal_uint32 dummy_lines)
407{
408 kal_uint32 temp_reg, temp_reg1, temp_reg2;
409
410 OV2659SENSORDB("[OV2659SetDummy] dummy_pixels=%d, dummy_lines=%d\n", dummy_pixels, dummy_lines);
411
412 if (dummy_pixels > 0)
413 {
414 temp_reg1 = OV2659_read_cmos_sensor(0x380D);
415 temp_reg2 = OV2659_read_cmos_sensor(0x380C);
416
417 temp_reg = (temp_reg1 & 0xFF) | (temp_reg2 << 8);
418 temp_reg += dummy_pixels;
419
420 OV2659_write_cmos_sensor(0x380D, (temp_reg & 0xFF));
421 OV2659_write_cmos_sensor(0x380C, ((temp_reg & 0xFF00) >> 8));
422 }
423
424 if (dummy_lines > 0)
425 {
426 temp_reg1 = OV2659_read_cmos_sensor(0x380F);
427 temp_reg2 = OV2659_read_cmos_sensor(0x380E);
428
429 temp_reg = (temp_reg1 & 0xFF) | (temp_reg2 << 8);
430 temp_reg += dummy_lines;
431
432 OV2659_write_cmos_sensor(0x380F, (temp_reg & 0xFF));
433 OV2659_write_cmos_sensor(0x380E, ((temp_reg & 0xFF00) >> 8));
434 }
435}
436
437
438
439static kal_uint32 OV2659ReadShutter(void)
440{
441 kal_uint16 temp_reg1, temp_reg2 ,temp_reg3;
442
443 temp_reg1 = OV2659_read_cmos_sensor(0x3500);
444 temp_reg2 = OV2659_read_cmos_sensor(0x3501);
445 temp_reg3 = OV2659_read_cmos_sensor(0x3502);
446
447 spin_lock(&ov2659_drv_lock);
448 OV2659Sensor.PreviewShutter = (temp_reg1 << 12)| (temp_reg2 << 4)|(temp_reg3 >> 4);
449 spin_unlock(&ov2659_drv_lock);
450
451 OV2659SENSORDB("[OV2659ReadShutter] shutter=%d\n", OV2659Sensor.PreviewShutter);
452
453 return OV2659Sensor.PreviewShutter;
454}
455
456
457
458static kal_uint32 OV2659ReadSensorGain(void)
459{
460 kal_uint32 sensor_gain = 0;
461
462 sensor_gain=(OV2659_read_cmos_sensor(0x350B) & 0xFF);
463
464 OV2659SENSORDB("[OV2659ReadSensorGain] gain_350B=%d\n", sensor_gain);
465
466 return sensor_gain;
467}
468
469
470
471
472static void OV2659_set_AWB_mode(kal_bool AWB_enable)
473{
474 kal_uint8 AwbTemp;
475
476 AwbTemp = OV2659_read_cmos_sensor(0x3406);
477
478 if (AWB_enable == KAL_TRUE)
479 {
480 OV2659SENSORDB("[OV2659_set_AWB_mode] enable\n");
481 OV2659_write_cmos_sensor(0x3406, AwbTemp & 0xFE);
482 }
483 else
484 {
485 OV2659SENSORDB("[OV2659_set_AWB_mode] disable\n");
486 OV2659_write_cmos_sensor(0x3406, AwbTemp | 0x01);
487 }
488
489}
490
491
492
493BOOL OV2659_set_param_wb(UINT16 para)
494{
495 OV2659SENSORDB("[OV2659_set_param_wb]para=%d\n", para);
496
497 switch (para)
498 {
499 case AWB_MODE_OFF:
500 OV2659_set_AWB_mode(KAL_FALSE);
501 break;
502 case AWB_MODE_AUTO:
503 OV2659_set_AWB_mode(KAL_TRUE);
504 break;
505 case AWB_MODE_CLOUDY_DAYLIGHT:
506 OV2659_set_AWB_mode(KAL_FALSE);
507 OV2659_write_cmos_sensor(0x3208, 0x00);
508 OV2659_write_cmos_sensor(0x3400, 0x06);
509 OV2659_write_cmos_sensor(0x3401, 0x30);
510 OV2659_write_cmos_sensor(0x3402, 0x04);
511 OV2659_write_cmos_sensor(0x3403, 0x00);
512 OV2659_write_cmos_sensor(0x3404, 0x04);
513 OV2659_write_cmos_sensor(0x3405, 0x30);
514 OV2659_write_cmos_sensor(0x3208, 0x10);
515 OV2659_write_cmos_sensor(0x3208, 0xa0);
516 break;
517 case AWB_MODE_DAYLIGHT:
518 OV2659_set_AWB_mode(KAL_FALSE);
519 OV2659_write_cmos_sensor(0x3208, 0x00);
520 OV2659_write_cmos_sensor(0x3400, 0x06);
521 OV2659_write_cmos_sensor(0x3401, 0x10);
522 OV2659_write_cmos_sensor(0x3402, 0x04);
523 OV2659_write_cmos_sensor(0x3403, 0x00);
524 OV2659_write_cmos_sensor(0x3404, 0x04);
525 OV2659_write_cmos_sensor(0x3405, 0x48);
526 OV2659_write_cmos_sensor(0x3208, 0x10);
527 OV2659_write_cmos_sensor(0x3208, 0xa0);
528 break;
529 case AWB_MODE_INCANDESCENT:
530 OV2659_set_AWB_mode(KAL_FALSE);
531 OV2659_write_cmos_sensor(0x3208, 0x00);
532 OV2659_write_cmos_sensor(0x3400, 0x04);
533 OV2659_write_cmos_sensor(0x3401, 0xe0);
534 OV2659_write_cmos_sensor(0x3402, 0x04);
535 OV2659_write_cmos_sensor(0x3403, 0x00);
536 OV2659_write_cmos_sensor(0x3404, 0x05);
537 OV2659_write_cmos_sensor(0x3405, 0xa0);
538 OV2659_write_cmos_sensor(0x3208, 0x10);
539 OV2659_write_cmos_sensor(0x3208, 0xa0);
540 break;
541 case AWB_MODE_TUNGSTEN:
542 OV2659_set_AWB_mode(KAL_FALSE);
543 OV2659_write_cmos_sensor(0x3208, 0x00);
544 OV2659_write_cmos_sensor(0x3400, 0x05);
545 OV2659_write_cmos_sensor(0x3401, 0x48);
546 OV2659_write_cmos_sensor(0x3402, 0x04);
547 OV2659_write_cmos_sensor(0x3403, 0x00);
548 OV2659_write_cmos_sensor(0x3404, 0x05);
549 OV2659_write_cmos_sensor(0x3405, 0xe0);
550 OV2659_write_cmos_sensor(0x3208, 0x10);
551 OV2659_write_cmos_sensor(0x3208, 0xa0);
552 break;
553 case AWB_MODE_FLUORESCENT:
554 OV2659_set_AWB_mode(KAL_FALSE);
555 OV2659_write_cmos_sensor(0x3208, 0x00);
556 OV2659_write_cmos_sensor(0x3400, 0x04);
557 OV2659_write_cmos_sensor(0x3401, 0x00);
558 OV2659_write_cmos_sensor(0x3402, 0x04);
559 OV2659_write_cmos_sensor(0x3403, 0x00);
560 OV2659_write_cmos_sensor(0x3404, 0x06);
561 OV2659_write_cmos_sensor(0x3405, 0x50);
562 OV2659_write_cmos_sensor(0x3208, 0x10);
563 OV2659_write_cmos_sensor(0x3208, 0xa0);
564 break;
565 default:
566 return FALSE;
567 }
568
569 spin_lock(&ov2659_drv_lock);
570 WBcount= para;
571 spin_unlock(&ov2659_drv_lock);
572
573 return TRUE;
574}
575
576
577
578static kal_uint32 OV2659_GetSensorID(kal_uint32 *sensorID)
579{
580 volatile signed char i;
581 kal_uint32 sensor_id=0;
582
583 OV2659_write_cmos_sensor(0x0103, 0x01);
584 mDELAY(10);
585
586 for(i=0;i<3;i++)
587 {
588 sensor_id = (OV2659_read_cmos_sensor(0x300A) << 8) | OV2659_read_cmos_sensor(0x300B);
589
590 OV2659SENSORDB("[OV2659_GetSensorID] sensorID=%x\n", sensor_id);
591
592 if(sensor_id != OV2659_SENSOR_ID)
593 {
594 *sensorID =0xffffffff;
595
596 return ERROR_SENSOR_CONNECT_FAIL;
597 }
598 }
599
600 *sensorID = sensor_id;
601
602 return ERROR_NONE;
603}
604
605
606
607static void OV2659InitialSetting(void)
608{
609 OV2659SENSORDB("[OV2659InitialSetting]\n");
610
611 OV2659_write_cmos_sensor(0x3000, 0x0f);
612 OV2659_write_cmos_sensor(0x3001, 0xff);
613 OV2659_write_cmos_sensor(0x3002, 0xff);
614 OV2659_write_cmos_sensor(0x0100, 0x01);
615 OV2659_write_cmos_sensor(0x3633, 0x3d);
616 OV2659_write_cmos_sensor(0x3620, 0x02);
617 OV2659_write_cmos_sensor(0x3631, 0x11);
618 OV2659_write_cmos_sensor(0x3612, 0x04);
619 OV2659_write_cmos_sensor(0x3630, 0x20);
620 OV2659_write_cmos_sensor(0x4702, 0x02);
621 OV2659_write_cmos_sensor(0x370c, 0x34);
622 OV2659_write_cmos_sensor(0x4003, 0x88);
623 OV2659_write_cmos_sensor(0x3800, 0x00);
624 OV2659_write_cmos_sensor(0x3801, 0x00);
625 OV2659_write_cmos_sensor(0x3802, 0x00);
626 OV2659_write_cmos_sensor(0x3803, 0x00);
627 OV2659_write_cmos_sensor(0x3804, 0x06);
628 OV2659_write_cmos_sensor(0x3805, 0x5f);
629 OV2659_write_cmos_sensor(0x3806, 0x04);
630 OV2659_write_cmos_sensor(0x3807, 0xb7);
631 OV2659_write_cmos_sensor(0x3808, 0x03);
632 OV2659_write_cmos_sensor(0x3809, 0x20);
633 OV2659_write_cmos_sensor(0x380a, 0x02);
634 OV2659_write_cmos_sensor(0x380b, 0x58);
635 OV2659_write_cmos_sensor(0x3811, 0x08);
636 OV2659_write_cmos_sensor(0x3813, 0x02);
637 OV2659_write_cmos_sensor(0x3814, 0x31);
638 OV2659_write_cmos_sensor(0x3815, 0x31);
639 OV2659_write_cmos_sensor(0x3820, 0x81);
640 OV2659_write_cmos_sensor(0x3821, 0x01);
641 OV2659_write_cmos_sensor(0x5002, 0x10);
642 OV2659_write_cmos_sensor(0x4608, 0x00);
643 OV2659_write_cmos_sensor(0x4609, 0xa0);
644 OV2659_write_cmos_sensor(0x3623, 0x00);
645 OV2659_write_cmos_sensor(0x3634, 0x76);
646 OV2659_write_cmos_sensor(0x3701, 0x44);
647 OV2659_write_cmos_sensor(0x3208, 0x01);
648 OV2659_write_cmos_sensor(0x3702, 0x18);
649 OV2659_write_cmos_sensor(0x3703, 0x24);
650 OV2659_write_cmos_sensor(0x3704, 0x24);
651 OV2659_write_cmos_sensor(0x3208, 0x11);
652 OV2659_write_cmos_sensor(0x3208, 0x02);
653 OV2659_write_cmos_sensor(0x3702, 0x30);
654 OV2659_write_cmos_sensor(0x3703, 0x48);
655 OV2659_write_cmos_sensor(0x3704, 0x48);
656 OV2659_write_cmos_sensor(0x3208, 0x12);
657 OV2659_write_cmos_sensor(0x3705, 0x0c);
658 OV2659_write_cmos_sensor(0x370a, 0x52);
659 OV2659_write_cmos_sensor(0x3003, 0x80);//3
660 OV2659_write_cmos_sensor(0x3004, 0x10);
661 OV2659_write_cmos_sensor(0x3005, 0x16);
662 OV2659_write_cmos_sensor(0x3006, 0x0d);
663 OV2659_write_cmos_sensor(0x380c, 0x05);
664 OV2659_write_cmos_sensor(0x380d, 0x14);
665 OV2659_write_cmos_sensor(0x380e, 0x02);
666 OV2659_write_cmos_sensor(0x380f, 0xe3);
667 OV2659_write_cmos_sensor(0x3a05, 0x30);
668 OV2659_write_cmos_sensor(0x3a08, 0x00);
669 OV2659_write_cmos_sensor(0x3a09, 0xb9);
670 OV2659_write_cmos_sensor(0x3a0e, 0x04);
671 OV2659_write_cmos_sensor(0x3a0a, 0x00);
672 OV2659_write_cmos_sensor(0x3a0b, 0x9a);
673 OV2659_write_cmos_sensor(0x3a0d, 0x04);
674 OV2659_write_cmos_sensor(0x3a00, 0x3c);
675 OV2659_write_cmos_sensor(0x3a02, 0x05);
676 OV2659_write_cmos_sensor(0x3a03, 0xc6);
677 OV2659_write_cmos_sensor(0x3a14, 0x05);
678 OV2659_write_cmos_sensor(0x3a15, 0xc6);
679 OV2659_write_cmos_sensor(0x350c, 0x00);
680 OV2659_write_cmos_sensor(0x350d, 0x00);
681 OV2659_write_cmos_sensor(0x4300, 0x31);
682 OV2659_write_cmos_sensor(0x5086, 0x02);
683 OV2659_write_cmos_sensor(0x5000, 0xff);
684 OV2659_write_cmos_sensor(0x5001, 0x1f);
685 OV2659_write_cmos_sensor(0x507e, 0x3a);
686 OV2659_write_cmos_sensor(0x507f, 0x10);
687 OV2659_write_cmos_sensor(0x507c, 0x80);
688 OV2659_write_cmos_sensor(0x507d, 0x00);
689 OV2659_write_cmos_sensor(0x507b, 0x06);
690 OV2659_write_cmos_sensor(0x5025, 0x06);
691 OV2659_write_cmos_sensor(0x5026, 0x0c);
692 OV2659_write_cmos_sensor(0x5027, 0x1c);
693 OV2659_write_cmos_sensor(0x5028, 0x36);
694 OV2659_write_cmos_sensor(0x5029, 0x4e);
695 OV2659_write_cmos_sensor(0x502a, 0x5f);
696 OV2659_write_cmos_sensor(0x502b, 0x6d);
697 OV2659_write_cmos_sensor(0x502c, 0x78);
698 OV2659_write_cmos_sensor(0x502d, 0x84);
699 OV2659_write_cmos_sensor(0x502e, 0x95);
700 OV2659_write_cmos_sensor(0x502f, 0xa5);
701 OV2659_write_cmos_sensor(0x5030, 0xb4);
702 OV2659_write_cmos_sensor(0x5031, 0xc8);
703 OV2659_write_cmos_sensor(0x5032, 0xde);
704 OV2659_write_cmos_sensor(0x5033, 0xf0);
705 OV2659_write_cmos_sensor(0x5034, 0x15);
706 OV2659_write_cmos_sensor(0x5070, 0x28);
707 OV2659_write_cmos_sensor(0x5071, 0x48);
708 OV2659_write_cmos_sensor(0x5072, 0x10);
709 OV2659_write_cmos_sensor(0x5073, 0x17);
710 OV2659_write_cmos_sensor(0x5074, 0xb3);
711 OV2659_write_cmos_sensor(0x5075, 0xca);
712 OV2659_write_cmos_sensor(0x5076, 0xca);
713 OV2659_write_cmos_sensor(0x5077, 0xc1);
714 OV2659_write_cmos_sensor(0x5078, 0x09);
715 OV2659_write_cmos_sensor(0x5079, 0x98);
716 OV2659_write_cmos_sensor(0x507a, 0x01);
717 OV2659_write_cmos_sensor(0x5035, 0x6a);
718 OV2659_write_cmos_sensor(0x5036, 0x11);
719 OV2659_write_cmos_sensor(0x5037, 0x92);
720 OV2659_write_cmos_sensor(0x5038, 0x21);
721 OV2659_write_cmos_sensor(0x5039, 0xe1);
722 OV2659_write_cmos_sensor(0x503a, 0x01);
723 OV2659_write_cmos_sensor(0x503c, 0x10);
724 OV2659_write_cmos_sensor(0x503d, 0x10);
725 OV2659_write_cmos_sensor(0x503e, 0x10);
726 OV2659_write_cmos_sensor(0x503f, 0x65);
727 OV2659_write_cmos_sensor(0x5040, 0x62);
728 OV2659_write_cmos_sensor(0x5041, 0x0e);
729 OV2659_write_cmos_sensor(0x5042, 0x9c);
730 OV2659_write_cmos_sensor(0x5043, 0x20);
731 OV2659_write_cmos_sensor(0x5044, 0x28);
732 OV2659_write_cmos_sensor(0x5045, 0x22);
733 OV2659_write_cmos_sensor(0x5046, 0x5c);
734 OV2659_write_cmos_sensor(0x5047, 0xf8);
735 OV2659_write_cmos_sensor(0x5048, 0x08);
736 OV2659_write_cmos_sensor(0x5049, 0x70);
737 OV2659_write_cmos_sensor(0x504a, 0xf0);
738 OV2659_write_cmos_sensor(0x504b, 0xf0);
739 OV2659_write_cmos_sensor(0x500c, 0x03);
740 OV2659_write_cmos_sensor(0x500d, 0x26);
741 OV2659_write_cmos_sensor(0x500e, 0x02);
742 OV2659_write_cmos_sensor(0x500f, 0x64);
743 OV2659_write_cmos_sensor(0x5010, 0x6a);
744 OV2659_write_cmos_sensor(0x5011, 0x00);
745 OV2659_write_cmos_sensor(0x5012, 0x66);
746 OV2659_write_cmos_sensor(0x5013, 0x03);
747 OV2659_write_cmos_sensor(0x5014, 0x24);
748 OV2659_write_cmos_sensor(0x5015, 0x02);
749 OV2659_write_cmos_sensor(0x5016, 0x74);
750 OV2659_write_cmos_sensor(0x5017, 0x62);
751 OV2659_write_cmos_sensor(0x5018, 0x00);
752 OV2659_write_cmos_sensor(0x5019, 0x66);
753 OV2659_write_cmos_sensor(0x501a, 0x03);
754 OV2659_write_cmos_sensor(0x501b, 0x16);
755 OV2659_write_cmos_sensor(0x501c, 0x02);
756 OV2659_write_cmos_sensor(0x501d, 0x76);
757 OV2659_write_cmos_sensor(0x501e, 0x5d);
758 OV2659_write_cmos_sensor(0x501f, 0x00);
759 OV2659_write_cmos_sensor(0x5020, 0x66);
760 OV2659_write_cmos_sensor(0x506e, 0x44);
761 OV2659_write_cmos_sensor(0x5064, 0x08);
762 OV2659_write_cmos_sensor(0x5065, 0x10);
763 OV2659_write_cmos_sensor(0x5066, 0x16);
764 OV2659_write_cmos_sensor(0x5067, 0x10);
765 OV2659_write_cmos_sensor(0x506c, 0x08);
766 OV2659_write_cmos_sensor(0x506d, 0x10);
767 OV2659_write_cmos_sensor(0x506f, 0xa6);
768 OV2659_write_cmos_sensor(0x5068, 0x08);
769 OV2659_write_cmos_sensor(0x5069, 0x10);
770 OV2659_write_cmos_sensor(0x506a, 0x18);
771 OV2659_write_cmos_sensor(0x506b, 0x28);
772 OV2659_write_cmos_sensor(0x5084, 0x0c);
773 OV2659_write_cmos_sensor(0x5085, 0x3c);//3
774 OV2659_write_cmos_sensor(0x5005, 0x80);
775 OV2659_write_cmos_sensor(0x5051, 0x40);
776 OV2659_write_cmos_sensor(0x5052, 0x40);
777 OV2659_write_cmos_sensor(0x5053, 0x40);
778 OV2659_write_cmos_sensor(0x3a0f, 0x38); //4
779 OV2659_write_cmos_sensor(0x3a10, 0x30); //3
780 OV2659_write_cmos_sensor(0x3a11, 0x70);
781 OV2659_write_cmos_sensor(0x3a1b, 0x38); //4
782 OV2659_write_cmos_sensor(0x3a1e, 0x30); //3
783 OV2659_write_cmos_sensor(0x3a1f, 0x20);
784 OV2659_write_cmos_sensor(0x5060, 0x69);
785 OV2659_write_cmos_sensor(0x5061, 0xbe);
786 OV2659_write_cmos_sensor(0x5062, 0xbe);
787 OV2659_write_cmos_sensor(0x5063, 0x69);
788 OV2659_write_cmos_sensor(0x3a18, 0x00);
789 OV2659_write_cmos_sensor(0x3a19, 0x38);
790 OV2659_write_cmos_sensor(0x4009, 0x02);
791 OV2659_write_cmos_sensor(0x3503, 0x00);
792 OV2659_write_cmos_sensor(0x3011, 0xC2 /*0x82*/); // Increase IO driving current
793
794 spin_lock(&ov2659_drv_lock);
795 OV2659Sensor.IsPVmode = 1;
796 OV2659Sensor.PreviewDummyPixels = 0;
797 OV2659Sensor.PreviewDummyLines = 0;
798 OV2659Sensor.PreviewPclk = 480;
799 OV2659Sensor.CapturePclk = 480;
800 OV2659Sensor.SensorGain = 0x10;
801 WBcount = AWB_MODE_AUTO;
802 spin_unlock(&ov2659_drv_lock);
803}
804
805
806
807static void OV2659PreviewSetting(void)
808{
809 OV2659SENSORDB("[OV2659PreviewSetting]\n");
810
811 OV2659_write_cmos_sensor(0X0100, 0X00);
812 OV2659_write_cmos_sensor(0x3503, OV2659_read_cmos_sensor(0x3503) | 0x07);
813 OV2659_write_cmos_sensor(0x3500, ((OV2659Sensor.PreviewShutter * 16) >> 16) & 0xff);
814 OV2659_write_cmos_sensor(0x3501, ((OV2659Sensor.PreviewShutter * 16) >> 8) & 0xff);
815 OV2659_write_cmos_sensor(0x3502, (OV2659Sensor.PreviewShutter * 16) & 0xff);
816 OV2659_write_cmos_sensor(0x350B, OV2659Sensor.SensorGain);
817 OV2659_write_cmos_sensor(0x3a00, OV2659_read_cmos_sensor(0x3a00) | 0x04);
818 OV2659_write_cmos_sensor(0x3503, OV2659_read_cmos_sensor(0x3503) & 0xf8);
819 OV2659_write_cmos_sensor(0x5066, 0x28);
820 OV2659_write_cmos_sensor(0x5067, 0x10);
821 OV2659_write_cmos_sensor(0x506a, 0x0c);
822 OV2659_write_cmos_sensor(0x506b, 0x1c);
823 OV2659_write_cmos_sensor(0x3800, 0x00);
824 OV2659_write_cmos_sensor(0x3801, 0x00);
825 OV2659_write_cmos_sensor(0x3802, 0x00);
826 OV2659_write_cmos_sensor(0x3803, 0x00);
827 OV2659_write_cmos_sensor(0x3804, 0x06);
828 OV2659_write_cmos_sensor(0x3805, 0x5f);
829 OV2659_write_cmos_sensor(0x3806, 0x04);
830 OV2659_write_cmos_sensor(0x3807, 0xb7);
831 OV2659_write_cmos_sensor(0x3808, 0x03);
832 OV2659_write_cmos_sensor(0x3809, 0x20);
833 OV2659_write_cmos_sensor(0x380a, 0x02);
834 OV2659_write_cmos_sensor(0x380b, 0x58);
835 OV2659_write_cmos_sensor(0x3811, 0x08);
836 OV2659_write_cmos_sensor(0x3813, 0x02);
837 OV2659_write_cmos_sensor(0x3814, 0x31);
838 OV2659_write_cmos_sensor(0x3815, 0x31);
839 OV2659_write_cmos_sensor(0x3820, 0x81);
840 OV2659_write_cmos_sensor(0x3821, 0x01);
841 OV2659_write_cmos_sensor(0x3623, 0x00);
842 OV2659_write_cmos_sensor(0x3634, 0x76);
843 OV2659_write_cmos_sensor(0x3701, 0x44);
844 OV2659_write_cmos_sensor(0x3208, 0xa1);
845 OV2659_write_cmos_sensor(0x3705, 0x0c);
846 OV2659_write_cmos_sensor(0x370a, 0x52);
847 OV2659_write_cmos_sensor(0x4608, 0x00);
848 OV2659_write_cmos_sensor(0x4609, 0x80);
849 OV2659_write_cmos_sensor(0x5002, 0x10);
850 OV2659_write_cmos_sensor(0x3003, 0x80);//30fps 26mclk
851 OV2659_write_cmos_sensor(0x3004, 0x10);
852 OV2659_write_cmos_sensor(0x3005, 0x16);
853 OV2659_write_cmos_sensor(0x3006, 0x0d);
854 OV2659_write_cmos_sensor(0x380c, 0x05);
855 OV2659_write_cmos_sensor(0x380d, 0x14);
856 OV2659_write_cmos_sensor(0x380e, 0x02);
857 OV2659_write_cmos_sensor(0x380f, 0x68);
858 OV2659_write_cmos_sensor(0x3a08, 0x00);
859 OV2659_write_cmos_sensor(0x3a09, 0xb9);
860 OV2659_write_cmos_sensor(0x3a0e, 0x03);
861 OV2659_write_cmos_sensor(0x3a0a, 0x00);
862 OV2659_write_cmos_sensor(0x3a0b, 0x9a);
863 OV2659_write_cmos_sensor(0x3a0d, 0x04);
864 OV2659_write_cmos_sensor(0X0100, 0X01);
865 OV2659_write_cmos_sensor(0X301d, 0X08);
866 mDELAY(10);
867 OV2659_write_cmos_sensor(0X301d, 0X00);
868
869 spin_lock(&ov2659_drv_lock);
870 OV2659Sensor.IsPVmode = KAL_TRUE;
871 OV2659Sensor.PreviewPclk = 480;
872 OV2659Sensor.SensorMode = SENSOR_MODE_PREVIEW;
873 spin_unlock(&ov2659_drv_lock);
874}
875
876
877
878static void OV2659FullSizeCaptureSetting(void)
879{
880 OV2659SENSORDB("[OV2659FullSizeCaptureSetting]\n");
881
882 OV2659_write_cmos_sensor(0X0100, 0X00);
883 OV2659_write_cmos_sensor(0x3a00, OV2659_read_cmos_sensor(0x3a00) & 0xfb);
884 OV2659_write_cmos_sensor(0x3503, OV2659_read_cmos_sensor(0x3503) | 0x07);
885 OV2659_write_cmos_sensor(0x5066, 0x28);
886 OV2659_write_cmos_sensor(0x5067, 0x18);
887 OV2659_write_cmos_sensor(0x506a, 0x06);
888 OV2659_write_cmos_sensor(0x506b, 0x16);
889 OV2659_write_cmos_sensor(0x3800, 0x00);
890 OV2659_write_cmos_sensor(0x3801, 0x00);
891 OV2659_write_cmos_sensor(0x3802, 0x00);
892 OV2659_write_cmos_sensor(0x3803, 0x00);
893 OV2659_write_cmos_sensor(0x3804, 0x06);
894 OV2659_write_cmos_sensor(0x3805, 0x5f);
895 OV2659_write_cmos_sensor(0x3806, 0x04);
896 OV2659_write_cmos_sensor(0x3807, 0xbb);
897 OV2659_write_cmos_sensor(0x3808, 0x06);
898 OV2659_write_cmos_sensor(0x3809, 0x40);
899 OV2659_write_cmos_sensor(0x380a, 0x04);
900 OV2659_write_cmos_sensor(0x380b, 0xb0);
901 OV2659_write_cmos_sensor(0x3811, 0x10);
902 OV2659_write_cmos_sensor(0x3813, 0x06);
903 OV2659_write_cmos_sensor(0x3814, 0x11);
904 OV2659_write_cmos_sensor(0x3815, 0x11);
905 OV2659_write_cmos_sensor(0x3623, 0x00);
906 OV2659_write_cmos_sensor(0x3634, 0x44);
907 OV2659_write_cmos_sensor(0x3701, 0x44);
908 OV2659_write_cmos_sensor(0x3208, 0xa2);
909 OV2659_write_cmos_sensor(0x3705, 0x18);
910 OV2659_write_cmos_sensor(0x3820, OV2659_read_cmos_sensor(0x3820) & 0xfe);
911 OV2659_write_cmos_sensor(0x3821, OV2659_read_cmos_sensor(0x3821) & 0xfe);
912 OV2659_write_cmos_sensor(0x370a, 0x12);
913 OV2659_write_cmos_sensor(0x4608, 0x00);
914 OV2659_write_cmos_sensor(0x4609, 0x80);
915 OV2659_write_cmos_sensor(0x5002, 0x00);
916 OV2659_write_cmos_sensor(0x3003, 0x80);//15fps
917 OV2659_write_cmos_sensor(0x3004, 0x10);
918 OV2659_write_cmos_sensor(0x3005, 0x21);
919 OV2659_write_cmos_sensor(0x3006, 0x0d);
920 OV2659_write_cmos_sensor(0x380c, 0x07);
921 OV2659_write_cmos_sensor(0x380d, 0x9f);
922 OV2659_write_cmos_sensor(0x380e, 0x04);
923 OV2659_write_cmos_sensor(0x380f, 0xd0);
924 OV2659_write_cmos_sensor(0x3a08, 0x00);
925 OV2659_write_cmos_sensor(0x3a09, 0xb9);
926 OV2659_write_cmos_sensor(0x3a0e, 0x06);
927 OV2659_write_cmos_sensor(0x3a0a, 0x00);
928 OV2659_write_cmos_sensor(0x3a0b, 0x9a);
929 OV2659_write_cmos_sensor(0x3a0d, 0x08);
930 OV2659_write_cmos_sensor(0x4003, 0x88);
931 OV2659_write_cmos_sensor(0X0100, 0X01);
932
933 spin_lock(&ov2659_drv_lock);
934 OV2659Sensor.IsPVmode = KAL_FALSE;
935 OV2659Sensor.CapturePclk = 585;
936 spin_unlock(&ov2659_drv_lock);
937}
938
939
940
941static void OV2659SetHVMirror(kal_uint8 Mirror)
942{
943 kal_uint8 mirror = 0, flip = 0;
944
945 OV2659SENSORDB("[OV2659SetHVMirror]mirror=%d\n", Mirror);
946
947 Mirror = IMAGE_HV_MIRROR;
948
949 flip = OV2659_read_cmos_sensor(0x3820);
950 mirror = OV2659_read_cmos_sensor(0x3821);
951
952 switch (Mirror)
953 {
954 //for tablet PC sub only
955 case IMAGE_NORMAL:
956 OV2659_write_cmos_sensor(0x3820, flip | 0x06);
957 OV2659_write_cmos_sensor(0x3821, mirror | 0x06);
958 break;
959 case IMAGE_H_MIRROR:
960 OV2659_write_cmos_sensor(0x3820, flip | 0x06);
961 OV2659_write_cmos_sensor(0x3821, mirror & 0xf9);
962 break;
963 case IMAGE_V_MIRROR:
964 OV2659_write_cmos_sensor(0x3820, flip & 0xf9);
965 OV2659_write_cmos_sensor(0x3821, mirror | 0x06);
966 break;
967 case IMAGE_HV_MIRROR:
968 OV2659_write_cmos_sensor(0x3820, flip & 0xf9);
969 OV2659_write_cmos_sensor(0x3821, mirror & 0xf9);
970 break;
971 default:
972 break;
973 }
974}
975
976
977
978UINT32 OV2659Open(void)
979{
980 volatile signed int i;
981 kal_uint16 sensor_id = 0;
982
983 OV2659SENSORDB("[OV2659Open]\n");
984
985 OV2659_write_cmos_sensor(0x0103, 0x01);
986 mDELAY(10);
987
988 for(i = 0; i < 3; i++)
989 {
990 sensor_id = (OV2659_read_cmos_sensor(0x300A) << 8) | OV2659_read_cmos_sensor(0x300B);
991
992 OV2659SENSORDB("[OV2659Open]SensorId=%x\n", sensor_id);
993
994 if(sensor_id != OV2659_SENSOR_ID)
995 {
996 return ERROR_SENSOR_CONNECT_FAIL;
997 }
998 }
999
1000 spin_lock(&ov2659_drv_lock);
1001 OV2659Sensor.CaptureDummyPixels = 0;
1002 OV2659Sensor.CaptureDummyLines = 0;
1003 OV2659Sensor.PreviewDummyPixels = 0;
1004 OV2659Sensor.PreviewDummyLines = 0;
1005 OV2659Sensor.SensorMode = SENSOR_MODE_INIT;
1006 OV2659Sensor.isoSpeed = 100;
1007 spin_unlock(&ov2659_drv_lock);
1008
1009 OV2659InitialSetting();
1010
1011 return ERROR_NONE;
1012}
1013
1014
1015
1016UINT32 OV2659Close(void)
1017{
1018 OV2659SENSORDB("[OV2659Close]\n");
1019
1020 return ERROR_NONE;
1021}
1022
1023
1024
1025UINT32 OV2659Preview(MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *image_window,
1026 MSDK_SENSOR_CONFIG_STRUCT *sensor_config_data)
1027{
1028 OV2659SENSORDB("[OV2659Preview]enter\n");
1029
1030 OV2659PreviewSetting();
1031 mDELAY(300);
1032 OV2659_set_AE_mode(KAL_TRUE);
1033 OV2659_set_AWB_mode(KAL_TRUE);
1034 OV2659SetHVMirror(sensor_config_data->SensorImageMirror);
1035
1036 OV2659SENSORDB("[OV2659Preview]exit\n");
1037
1038 return TRUE ;
1039}
1040
1041
1042
1043UINT32 OV2659Capture(MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *image_window,
1044 MSDK_SENSOR_CONFIG_STRUCT *sensor_config_data)
1045{
1046 kal_uint32 shutter = 0, temp = 0;
1047
1048 OV2659SENSORDB("[OV2659Capture]enter\n");
1049
1050 if(SENSOR_MODE_PREVIEW == OV2659Sensor.SensorMode)
1051 {
1052 OV2659SENSORDB("[OV2659Capture]Normal Capture\n ");
1053
1054 OV2659_set_AWB_mode(KAL_FALSE);
1055
1056 OV2659_write_cmos_sensor(0x3a00, OV2659_read_cmos_sensor(0x3a00)&0xfb);
1057 OV2659_write_cmos_sensor(0x3503, OV2659_read_cmos_sensor(0x3503)|0x07);
1058
1059 shutter=OV2659ReadShutter();
1060 temp =OV2659ReadSensorGain();
1061
1062 mDELAY(30);
1063 OV2659FullSizeCaptureSetting();
1064 OV2659SetHVMirror(sensor_config_data->SensorImageMirror);//tablet pc sub sensor use only
1065 spin_lock(&ov2659_drv_lock);
1066 OV2659Sensor.SensorMode= SENSOR_MODE_CAPTURE;
1067 OV2659Sensor.CaptureDummyPixels = 0;
1068 OV2659Sensor.CaptureDummyLines = 0;
1069 spin_unlock(&ov2659_drv_lock);
1070
1071 shutter = shutter * 2;
1072
1073 OV2659WriteShutter(shutter);
1074 mDELAY(300);
1075
1076 spin_lock(&ov2659_drv_lock);
1077 OV2659Sensor.SensorGain = temp;
1078 OV2659Sensor.SensorShutter = shutter;
1079 spin_unlock(&ov2659_drv_lock);
1080 }
1081 else if(SENSOR_MODE_ZSD == OV2659Sensor.SensorMode)
1082 {
1083 //for zsd hdr use
1084 shutter = OV2659ReadShutter();
1085 temp = OV2659ReadSensorGain();
1086
1087 spin_lock(&ov2659_drv_lock);
1088 OV2659Sensor.SensorGain = temp;
1089 OV2659Sensor.SensorShutter = shutter;
1090 spin_unlock(&ov2659_drv_lock);
1091 }
1092
1093 OV2659SENSORDB("[OV2659Capture]exit\n");
1094
1095 return ERROR_NONE;
1096}
1097
1098
1099
1100UINT32 OV2659ZSDPreview(MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *image_window,
1101 MSDK_SENSOR_CONFIG_STRUCT *sensor_config_data)
1102{
1103 OV2659SENSORDB("[OV2659ZSDPreview]enter\n");
1104
1105 if(SENSOR_MODE_PREVIEW == OV2659Sensor.SensorMode || OV2659Sensor.SensorMode == SENSOR_MODE_INIT)
1106 {
1107 OV2659FullSizeCaptureSetting();
1108 OV2659SetHVMirror(sensor_config_data->SensorImageMirror);//tablet PC sub sensor use
1109 }
1110
1111 spin_lock(&ov2659_drv_lock);
1112 OV2659Sensor.SensorMode = SENSOR_MODE_ZSD;
1113 spin_unlock(&ov2659_drv_lock);
1114
1115 OV2659_set_AE_mode(KAL_TRUE);
1116 OV2659_set_AWB_mode(KAL_TRUE);
1117
1118 OV2659SENSORDB("[OV2659ZSDPreview]exit\n");
1119
1120 return ERROR_NONE;
1121}
1122
1123
1124
1125UINT32 OV2659GetResolution(MSDK_SENSOR_RESOLUTION_INFO_STRUCT *pSensorResolution)
1126{
1127 OV2659SENSORDB("[OV2659GetResolution]\n");
1128
1129 pSensorResolution->SensorPreviewWidth = OV2659_IMAGE_SENSOR_SVGA_WIDTH - 1 * 8;
1130 pSensorResolution->SensorPreviewHeight = OV2659_IMAGE_SENSOR_SVGA_HEIGHT - 1 * 8;
1131 pSensorResolution->SensorFullWidth = OV2659_IMAGE_SENSOR_UVGA_WITDH - 2 * 8;
1132 pSensorResolution->SensorFullHeight = OV2659_IMAGE_SENSOR_UVGA_HEIGHT - 2 * 8;
1133 pSensorResolution->SensorVideoWidth = OV2659_IMAGE_SENSOR_SVGA_WIDTH - 1 * 8;
1134 pSensorResolution->SensorVideoHeight = OV2659_IMAGE_SENSOR_SVGA_HEIGHT - 1 * 8;
1135
1136 return ERROR_NONE;
1137}
1138
1139
1140
1141UINT32 OV2659GetInfo(MSDK_SCENARIO_ID_ENUM ScenarioId,
1142 MSDK_SENSOR_INFO_STRUCT *pSensorInfo,
1143 MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData)
1144{
1145 OV2659SENSORDB("[OV2659GetInfo]\n");
1146
1147 pSensorInfo->SensorPreviewResolutionX = OV2659_IMAGE_SENSOR_SVGA_WIDTH - 1 * 8;
1148 pSensorInfo->SensorPreviewResolutionY = OV2659_IMAGE_SENSOR_SVGA_HEIGHT - 1 * 8;
1149 pSensorInfo->SensorFullResolutionX = OV2659_IMAGE_SENSOR_UVGA_WITDH - 2 * 8;
1150 pSensorInfo->SensorFullResolutionY = OV2659_IMAGE_SENSOR_UVGA_HEIGHT - 2 * 8;
1151 pSensorInfo->SensorCameraPreviewFrameRate = 30;
1152 pSensorInfo->SensorVideoFrameRate = 30;
1153 pSensorInfo->SensorStillCaptureFrameRate = 10;
1154 pSensorInfo->SensorWebCamCaptureFrameRate = 15;
1155 pSensorInfo->SensorResetActiveHigh = FALSE;
1156 pSensorInfo->SensorResetDelayCount = 1;
1157 pSensorInfo->SensorOutputDataFormat = SENSOR_OUTPUT_FORMAT_YUYV;
1158 pSensorInfo->SensorClockPolarity = SENSOR_CLOCK_POLARITY_LOW;
1159 pSensorInfo->SensorClockFallingPolarity = SENSOR_CLOCK_POLARITY_LOW;
1160 pSensorInfo->SensorHsyncPolarity = SENSOR_CLOCK_POLARITY_LOW;
1161 pSensorInfo->SensorVsyncPolarity = SENSOR_CLOCK_POLARITY_LOW;
1162 pSensorInfo->SensorInterruptDelayLines = 1;
1163 pSensorInfo->SensroInterfaceType = SENSOR_INTERFACE_TYPE_PARALLEL;
1164 pSensorInfo->CaptureDelayFrame = 2;
1165 pSensorInfo->PreviewDelayFrame = 4;
1166 pSensorInfo->VideoDelayFrame = 4;
1167 pSensorInfo->SensorMasterClockSwitch = 0;
1168 pSensorInfo->SensorDrivingCurrent = ISP_DRIVING_2MA;
1169
1170 switch (ScenarioId)
1171 {
1172 case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
1173 case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
1174 pSensorInfo->SensorClockFreq = 26;
1175 pSensorInfo->SensorClockDividCount = 3;
1176 pSensorInfo->SensorClockRisingCount = 0;
1177 pSensorInfo->SensorClockFallingCount = 2;
1178 pSensorInfo->SensorPixelClockCount = 3;
1179 pSensorInfo->SensorDataLatchCount = 2;
1180 pSensorInfo->SensorGrabStartX = 2;
1181 pSensorInfo->SensorGrabStartY = 2;
1182 break;
1183 case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
1184 pSensorInfo->SensorClockFreq = 26;
1185 pSensorInfo->SensorClockDividCount = 3;
1186 pSensorInfo->SensorClockRisingCount = 0;
1187 pSensorInfo->SensorClockFallingCount = 2;
1188 pSensorInfo->SensorPixelClockCount = 3;
1189 pSensorInfo->SensorDataLatchCount = 2;
1190 pSensorInfo->SensorGrabStartX = 2;
1191 pSensorInfo->SensorGrabStartY = 2;
1192 break;
1193 default:
1194 pSensorInfo->SensorClockFreq = 26;
1195 pSensorInfo->SensorClockDividCount = 3;
1196 pSensorInfo->SensorClockRisingCount = 0;
1197 pSensorInfo->SensorClockFallingCount = 2;
1198 pSensorInfo->SensorPixelClockCount = 3;
1199 pSensorInfo->SensorDataLatchCount = 2;
1200 pSensorInfo->SensorGrabStartX = 2;
1201 pSensorInfo->SensorGrabStartY = 2;
1202 break;
1203 }
1204
1205 memcpy(pSensorConfigData, &OV2659SensorConfigData, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
1206
1207 return ERROR_NONE;
1208}
1209
1210
1211
1212UINT32 OV2659Control(MSDK_SCENARIO_ID_ENUM ScenarioId, MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *pImageWindow,
1213 MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData)
1214{
1215 OV2659SENSORDB("[OV2659Control]\n");
1216
1217 switch (ScenarioId)
1218 {
1219 case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
1220 case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
1221 OV2659Preview(pImageWindow, pSensorConfigData);
1222 break;
1223 case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
1224 OV2659Capture(pImageWindow, pSensorConfigData);
1225 break;
1226 case MSDK_SCENARIO_ID_CAMERA_ZSD:
1227 OV2659ZSDPreview(pImageWindow, pSensorConfigData);
1228 break;
1229 default:
1230 break;
1231 }
1232
1233 return TRUE;
1234}
1235
1236
1237
1238BOOL OV2659_set_param_effect(UINT16 para)
1239{
1240 OV2659SENSORDB("[OV2659_set_param_effect]para=%d\n", para);
1241 switch (para)
1242 {
1243 case MEFFECT_OFF:
1244 OV2659_write_cmos_sensor(0x3208, 0x00);
1245 OV2659_write_cmos_sensor(0x5001, 0x1f);
1246 OV2659_write_cmos_sensor(0x507B, 0x06);
1247 OV2659_write_cmos_sensor(0x507e, 0x3a);
1248 OV2659_write_cmos_sensor(0x507f, 0x10);
1249 OV2659_write_cmos_sensor(0x3208, 0x10);
1250 OV2659_write_cmos_sensor(0x3208, 0xa0);
1251 break;
1252 case MEFFECT_SEPIA:
1253 OV2659_write_cmos_sensor(0x3208, 0x00);
1254 OV2659_write_cmos_sensor(0x5001, 0x1f);
1255 OV2659_write_cmos_sensor(0x507B, 0x1e);
1256 OV2659_write_cmos_sensor(0x507e, 0x40);
1257 OV2659_write_cmos_sensor(0x507f, 0xa0);
1258 OV2659_write_cmos_sensor(0x3208, 0x10);
1259 OV2659_write_cmos_sensor(0x3208, 0xa0);
1260 break;
1261 case MEFFECT_NEGATIVE:
1262 OV2659_write_cmos_sensor(0x3208, 0x00);
1263 OV2659_write_cmos_sensor(0x5001, 0x1f);
1264 OV2659_write_cmos_sensor(0x507B, 0x46);
1265 OV2659_write_cmos_sensor(0x3208, 0x10);
1266 OV2659_write_cmos_sensor(0x3208, 0xa0);
1267 break;
1268 case MEFFECT_SEPIAGREEN:
1269 OV2659_write_cmos_sensor(0x3208, 0x00);
1270 OV2659_write_cmos_sensor(0x5001, 0x1f);
1271 OV2659_write_cmos_sensor(0x507B, 0x1e);
1272 OV2659_write_cmos_sensor(0x507e, 0x60);
1273 OV2659_write_cmos_sensor(0x507f, 0x60);
1274 OV2659_write_cmos_sensor(0x3208, 0x10);
1275 OV2659_write_cmos_sensor(0x3208, 0xa0);
1276 break;
1277 case MEFFECT_SEPIABLUE:
1278 OV2659_write_cmos_sensor(0x3208, 0x00);
1279 OV2659_write_cmos_sensor(0x5001, 0x1f);
1280 OV2659_write_cmos_sensor(0x507B, 0x1e);
1281 OV2659_write_cmos_sensor(0x507e, 0xa0);
1282 OV2659_write_cmos_sensor(0x507f, 0x40);
1283 OV2659_write_cmos_sensor(0x3208, 0x10);
1284 OV2659_write_cmos_sensor(0x3208, 0xa0);
1285 break;
1286 case MEFFECT_MONO:
1287 OV2659_write_cmos_sensor(0x3208, 0x00);
1288 OV2659_write_cmos_sensor(0x5001, 0x1f);
1289 OV2659_write_cmos_sensor(0x507B, 0x26);
1290 OV2659_write_cmos_sensor(0x3208, 0x10);
1291 OV2659_write_cmos_sensor(0x3208, 0xa0);
1292 break;
1293 default:
1294 return KAL_FALSE;
1295 }
1296
1297 return KAL_TRUE;
1298}
1299
1300
1301
1302BOOL OV2659_set_param_banding(UINT16 para)
1303{
1304 kal_uint8 banding;
1305 kal_uint32 exposure_limitation = 0, line_length = 0, sensor_pixel_clock = 0;
1306
1307 OV2659SENSORDB("[OV2659_set_param_banding]para=%d\n", para);
1308
1309 if (OV2659Sensor.IsPVmode == KAL_TRUE)
1310 {
1311 line_length = OV2659_PV_PERIOD_PIXEL_NUMS + OV2659Sensor.PreviewDummyPixels;
1312 exposure_limitation = OV2659_PV_PERIOD_LINE_NUMS + OV2659Sensor.PreviewDummyLines;
1313 sensor_pixel_clock = OV2659Sensor.PreviewPclk * 100 * 1000;
1314 }
1315 else
1316 {
1317 line_length = OV2659_FULL_PERIOD_PIXEL_NUMS + OV2659Sensor.CaptureDummyPixels;
1318 exposure_limitation = OV2659_FULL_PERIOD_LINE_NUMS + OV2659Sensor.CaptureDummyLines;
1319 sensor_pixel_clock = OV2659Sensor.CapturePclk * 100 * 1000;
1320 }
1321
1322 line_length = line_length * 2;
1323 banding = OV2659_read_cmos_sensor(0x3A05);
1324
1325 switch (para)
1326 {
1327 case AE_FLICKER_MODE_50HZ:
1328 OV2659_write_cmos_sensor(0x3a05, banding & 0x7f);
1329 break;
1330 case AE_FLICKER_MODE_60HZ:
1331 OV2659_write_cmos_sensor(0x3a05, banding | 0x80);
1332 break;
1333 default:
1334 return FALSE;
1335 }
1336
1337 return TRUE;
1338}
1339
1340
1341
1342BOOL OV2659_set_param_exposure(UINT16 para)
1343{
1344 kal_uint8 EvTemp0 = 0x00, EvTemp1 = 0x00, temp_reg= 0x00;
1345
1346 OV2659SENSORDB("[OV2659_set_param_exposure]para=%d\n", para);
1347
1348 if (SCENE_MODE_HDR == OV2659Sensor.sceneMode)
1349 {
1350 OV2659_set_param_exposure_for_HDR(para);
1351
1352 return TRUE;
1353 }
1354
1355 temp_reg=OV2659_read_cmos_sensor(0x5083);
1356 OV2659_write_cmos_sensor(0x507b, OV2659_read_cmos_sensor(0x507b) | 0x04);
1357
1358 switch (para)
1359 {
1360 case AE_EV_COMP_20:
1361 EvTemp0 = 0x20;
1362 EvTemp1 = temp_reg & 0xf7;
1363 break;
1364 case AE_EV_COMP_10:
1365 EvTemp0 = 0x10;
1366 EvTemp1 = temp_reg & 0xf7;
1367 break;
1368 case AE_EV_COMP_00:
1369 EvTemp0 = 0x00;
1370 EvTemp1 = temp_reg & 0xf7;
1371 break;
1372 case AE_EV_COMP_n10:
1373 EvTemp0 = 0x10;
1374 EvTemp1 = temp_reg | 0x08;
1375 break;
1376 case AE_EV_COMP_n20:
1377 EvTemp0 = 0x20;
1378 EvTemp1 = temp_reg | 0x08;
1379 break;
1380 default:
1381 return FALSE;
1382 }
1383
1384 OV2659_write_cmos_sensor(0x3208, 0x00);
1385 OV2659_write_cmos_sensor(0x5082, EvTemp0);
1386 OV2659_write_cmos_sensor(0x5083, EvTemp1);
1387 OV2659_write_cmos_sensor(0x3208, 0x10);
1388 OV2659_write_cmos_sensor(0x3208, 0xa0);
1389
1390 return TRUE;
1391}
1392
1393
1394
1395UINT32 OV2659YUVSensorSetting(FEATURE_ID iCmd, UINT32 iPara)
1396{
1397 OV2659SENSORDB("[OV2659YUVSensorSetting]icmd=%d, ipara=%d\n", iCmd, iPara);
1398
1399 switch (iCmd) {
1400 case FID_SCENE_MODE:
1401 OV2659_set_scene_mode(iPara);
1402 break;
1403 case FID_AWB_MODE:
1404 OV2659_set_param_wb(iPara);
1405 break;
1406 case FID_COLOR_EFFECT:
1407 OV2659_set_param_effect(iPara);
1408 break;
1409 case FID_AE_EV:
1410 OV2659_set_param_exposure(iPara);
1411 break;
1412 case FID_AE_FLICKER:
1413 OV2659_set_param_banding(iPara);
1414 break;
1415 case FID_AE_SCENE_MODE:
1416 if(iPara == AE_MODE_OFF)
1417 OV2659_set_AE_mode(KAL_FALSE);
1418 else
1419 OV2659_set_AE_mode(KAL_TRUE);
1420 break;
1421 case FID_ZOOM_FACTOR:
1422 break;
1423 case FID_ISP_CONTRAST:
1424 OV2659_set_contrast(iPara);
1425 break;
1426 case FID_ISP_BRIGHT:
1427 OV2659_set_brightness(iPara);
1428 break;
1429 case FID_ISP_SAT:
1430 OV2659_set_saturation(iPara);
1431 break;
1432 case FID_AE_ISO:
1433 OV2659_set_iso(iPara);
1434 break;
1435 default:
1436 break;
1437 }
1438 mDELAY(30);
1439 return TRUE;
1440}
1441
1442
1443
1444UINT32 OV2659YUVSetVideoMode(UINT16 u2FrameRate)
1445{
1446 if (u2FrameRate == 30)
1447 {
1448 OV2659_write_cmos_sensor(0x3003, 0x80);//30fps 26mclk
1449 OV2659_write_cmos_sensor(0x3004, 0x10);
1450 OV2659_write_cmos_sensor(0x3005, 0x16);
1451 OV2659_write_cmos_sensor(0x3006, 0x0d);
1452 OV2659_write_cmos_sensor(0x380c, 0x05);
1453 OV2659_write_cmos_sensor(0x380d, 0x14);
1454 OV2659_write_cmos_sensor(0x380e, 0x02);
1455 OV2659_write_cmos_sensor(0x380f, 0x68);
1456 OV2659_write_cmos_sensor(0x3a08, 0x00);
1457 OV2659_write_cmos_sensor(0x3a09, 0xb9);
1458 OV2659_write_cmos_sensor(0x3a0e, 0x03);
1459 OV2659_write_cmos_sensor(0x3a0a, 0x00);
1460 OV2659_write_cmos_sensor(0x3a0b, 0x9a);
1461 OV2659_write_cmos_sensor(0x3a0d, 0x04);
1462 OV2659_write_cmos_sensor(0x3a00, 0x38);
1463 OV2659_write_cmos_sensor(0x3a02, 0x02);
1464 OV2659_write_cmos_sensor(0x3a03, 0x68);
1465 OV2659_write_cmos_sensor(0x3a14, 0x02);
1466 OV2659_write_cmos_sensor(0x3a15, 0x68);
1467 }
1468 else if (u2FrameRate == 15)
1469 {
1470 OV2659_write_cmos_sensor(0x3003, 0x80);//15fps 26mclk
1471 OV2659_write_cmos_sensor(0x3004, 0x20);
1472 OV2659_write_cmos_sensor(0x3005, 0x16);
1473 OV2659_write_cmos_sensor(0x3006, 0x0d);
1474 OV2659_write_cmos_sensor(0x380c, 0x05);
1475 OV2659_write_cmos_sensor(0x380d, 0x14);
1476 OV2659_write_cmos_sensor(0x380e, 0x02);
1477 OV2659_write_cmos_sensor(0x380f, 0x68);
1478 OV2659_write_cmos_sensor(0x3a08, 0x00);
1479 OV2659_write_cmos_sensor(0x3a09, 0x5c);
1480 OV2659_write_cmos_sensor(0x3a0e, 0x06);
1481 OV2659_write_cmos_sensor(0x3a0a, 0x00);
1482 OV2659_write_cmos_sensor(0x3a0b, 0x4d);
1483 OV2659_write_cmos_sensor(0x3a0d, 0x08);
1484 OV2659_write_cmos_sensor(0x3a00, 0x38);
1485 OV2659_write_cmos_sensor(0x3a02, 0x02);
1486 OV2659_write_cmos_sensor(0x3a03, 0x68);
1487 OV2659_write_cmos_sensor(0x3a14, 0x02);
1488 OV2659_write_cmos_sensor(0x3a15, 0x68);
1489 }
1490 else
1491 {
1492 printk("Wrong frame rate setting \n");
1493 }
1494
1495 mDELAY(30);
1496
1497 return TRUE;
1498}
1499
1500
1501
1502UINT32 OV2659SetMaxFramerateByScenario(MSDK_SCENARIO_ID_ENUM scenarioId, MUINT32 frameRate)
1503{
1504 kal_uint32 pclk;
1505 kal_int16 dummyLine, lineLength, frameHeight;
1506
1507 switch (scenarioId)
1508 {
1509 case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
1510 pclk = 480 / 10;
1511 lineLength = OV2659_PV_PERIOD_PIXEL_NUMS;
1512 frameHeight = (10 * pclk) / frameRate / lineLength;
1513 dummyLine = frameHeight - OV2659_PV_PERIOD_LINE_NUMS;
1514 OV2659SENSORDB("[OV2659SetMaxFramerateByScenario][preview]framerate=%d, dummy_line=%d\n",frameRate, dummyLine);
1515 OV2659SetDummy(0, dummyLine);
1516 break;
1517 case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
1518 pclk = 480 / 10;
1519 lineLength = OV2659_PV_PERIOD_PIXEL_NUMS;
1520 frameHeight = (10 * pclk) / frameRate / lineLength;
1521 dummyLine = frameHeight - OV2659_PV_PERIOD_LINE_NUMS;
1522 OV2659SENSORDB("[OV2659SetMaxFramerateByScenario][video]framerate=%d, dummy_line=%d\n",frameRate, dummyLine);
1523 OV2659SetDummy(0, dummyLine);
1524 break;
1525 case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
1526 case MSDK_SCENARIO_ID_CAMERA_ZSD:
1527 pclk = 480 / 10;
1528 lineLength = OV2659_FULL_PERIOD_PIXEL_NUMS;
1529 frameHeight = (10 * pclk) / frameRate / lineLength;
1530 dummyLine = frameHeight - OV2659_FULL_PERIOD_LINE_NUMS;
1531 OV2659SENSORDB("[OV2659SetMaxFramerateByScenario][capture/zsd]framerate=%d, dummy_line=%d\n",frameRate, dummyLine);
1532 OV2659SetDummy(0, dummyLine);
1533 break;
1534 case MSDK_SCENARIO_ID_CAMERA_3D_PREVIEW:
1535 case MSDK_SCENARIO_ID_CAMERA_3D_VIDEO:
1536 case MSDK_SCENARIO_ID_CAMERA_3D_CAPTURE:
1537 break;
1538 default:
1539 break;
1540 }
1541
1542 return ERROR_NONE;
1543}
1544
1545
1546
1547UINT32 OV2659GetDefaultFramerateByScenario(MSDK_SCENARIO_ID_ENUM scenarioId, MUINT32 *pframeRate)
1548{
1549 OV2659SENSORDB("[OV2659GetDefaultFramerateByScenario]\n");
1550
1551 switch (scenarioId)
1552 {
1553 case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
1554 case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
1555 *pframeRate = 300;
1556 break;
1557 case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
1558 case MSDK_SCENARIO_ID_CAMERA_ZSD:
1559 *pframeRate = 300;
1560 break;
1561 case MSDK_SCENARIO_ID_CAMERA_3D_PREVIEW:
1562 case MSDK_SCENARIO_ID_CAMERA_3D_VIDEO:
1563 case MSDK_SCENARIO_ID_CAMERA_3D_CAPTURE:
1564 *pframeRate = 300;
1565 break;
1566 default:
1567 break;
1568 }
1569
1570 return ERROR_NONE;
1571}
1572
1573
1574
1575UINT32 OV2659SetTestPatternMode(kal_bool bEnable)
1576{
1577 OV2659SENSORDB("[OV2659SetTestPatternMode]bEnable=%d\n",bEnable);
1578
1579 if(bEnable)
1580 OV2659_write_cmos_sensor(0x50a0, 0x80);
1581 else
1582 OV2659_write_cmos_sensor(0x50a0, 0x00);
1583 mDELAY(100);
1584
1585 return ERROR_NONE;
1586}
1587
1588
1589
1590void OV2659Set3ACtrl(ACDK_SENSOR_3A_LOCK_ENUM action)
1591{
1592 OV2659SENSORDB("[OV2659Set3ACtrl]action=%d\n",action);
1593
1594 switch (action)
1595 {
1596 case SENSOR_3A_AE_LOCK:
1597 OV2659_set_AE_mode(KAL_FALSE);
1598 break;
1599 case SENSOR_3A_AE_UNLOCK:
1600 OV2659_set_AE_mode(KAL_TRUE);
1601 break;
1602 case SENSOR_3A_AWB_LOCK:
1603 OV2659_set_AWB_mode(KAL_FALSE);
1604 break;
1605 case SENSOR_3A_AWB_UNLOCK:
1606 OV2659_set_AWB_mode(KAL_TRUE);
1607 break;
1608 default:
1609 break;
1610 }
1611
1612 //fix wb mode for capture -> preview,root casue is ap follow .
1613 OV2659_set_param_wb(WBcount);
1614 return;
1615}
1616
1617
1618
1619static void OV2659GetCurAeAwbInfo(UINT32 pSensorAEAWBCurStruct)
1620{
1621 //OV2659SENSORDB("[OV2659GetCurAeAwbInfo]\n");
1622
1623 PSENSOR_AE_AWB_CUR_STRUCT Info = (PSENSOR_AE_AWB_CUR_STRUCT)pSensorAEAWBCurStruct;
1624 Info->SensorAECur.AeCurShutter = OV2659ReadShutter();
1625 Info->SensorAECur.AeCurGain = OV2659ReadSensorGain() * 2;
1626 Info->SensorAwbGainCur.AwbCurRgain = OV2659_read_cmos_sensor(0x504c);
1627 Info->SensorAwbGainCur.AwbCurBgain = OV2659_read_cmos_sensor(0x504e);
1628}
1629
1630
1631
1632void OV2659_get_AEAWB_lock(UINT32 *pAElockRet32, UINT32 *pAWBlockRet32)
1633{
1634 OV2659SENSORDB("[OV2659_get_AEAWB_lock]\n");
1635
1636 *pAElockRet32 = 1;
1637 *pAWBlockRet32 = 1;
1638}
1639
1640
1641
1642void OV2659_GetDelayInfo(UINT32 delayAddr)
1643{
1644 //OV2659SENSORDB("[OV2659_GetDelayInfo]\n");
1645
1646 SENSOR_DELAY_INFO_STRUCT *pDelayInfo=(SENSOR_DELAY_INFO_STRUCT*)delayAddr;
1647 pDelayInfo->InitDelay = 0;
1648 pDelayInfo->EffectDelay = 0;
1649 pDelayInfo->AwbDelay = 0;
1650 pDelayInfo->AFSwitchDelayFrame = 50;
1651}
1652
1653
1654
1655void OV2659GetExifInfo(UINT32 exifAddr)
1656{
1657 //OV2659SENSORDB("[OV2659GetExifInfo]\n");
1658
1659 SENSOR_EXIF_INFO_STRUCT* pExifInfo = (SENSOR_EXIF_INFO_STRUCT*)exifAddr;
1660 pExifInfo->FNumber = 28;
1661 pExifInfo->AEISOSpeed = OV2659Sensor.isoSpeed;
1662 pExifInfo->FlashLightTimeus = 0;
1663 pExifInfo->RealISOValue = OV2659Sensor.isoSpeed;
1664 pExifInfo->AWBMode = WBcount;
1665}
1666
1667
1668
1669UINT32 OV2659FeatureControl(MSDK_SENSOR_FEATURE_ENUM FeatureId,
1670 UINT8 *pFeaturePara,UINT32 *pFeatureParaLen)
1671{
1672 UINT16 *pFeatureReturnPara16=(UINT16 *) pFeaturePara, *pFeatureData16=(UINT16 *) pFeaturePara;
1673 UINT32 *pFeatureReturnPara32=(UINT32 *) pFeaturePara, *pFeatureData32=(UINT32 *) pFeaturePara;
1674 MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData=(MSDK_SENSOR_CONFIG_STRUCT *) pFeaturePara;
1675 MSDK_SENSOR_REG_INFO_STRUCT *pSensorRegData=(MSDK_SENSOR_REG_INFO_STRUCT *) pFeaturePara;
1676
1677 switch (FeatureId)
1678 {
1679 case SENSOR_FEATURE_GET_RESOLUTION:
1680 *pFeatureReturnPara16++=OV2659_IMAGE_SENSOR_UVGA_WITDH;
1681 *pFeatureReturnPara16=OV2659_IMAGE_SENSOR_UVGA_HEIGHT;
1682 *pFeatureParaLen=4;
1683 break;
1684 case SENSOR_FEATURE_GET_PERIOD:
1685 *pFeatureReturnPara16++=OV2659_PV_PERIOD_PIXEL_NUMS + OV2659Sensor.PreviewDummyPixels;
1686 *pFeatureReturnPara16=OV2659_PV_PERIOD_LINE_NUMS + OV2659Sensor.PreviewDummyLines;
1687 *pFeatureParaLen=4;
1688 break;
1689 case SENSOR_FEATURE_GET_PIXEL_CLOCK_FREQ:
1690 *pFeatureReturnPara32 = OV2659Sensor.PreviewPclk * 1000 * 100;
1691 *pFeatureParaLen=4;
1692 break;
1693 case SENSOR_FEATURE_SET_NIGHTMODE:
1694 OV2659_night_mode((BOOL) *pFeatureData16);
1695 break;
1696 case SENSOR_FEATURE_SET_REGISTER:
1697 OV2659_write_cmos_sensor(pSensorRegData->RegAddr, pSensorRegData->RegData);
1698 break;
1699 case SENSOR_FEATURE_GET_REGISTER:
1700 pSensorRegData->RegData = OV2659_read_cmos_sensor(pSensorRegData->RegAddr);
1701 break;
1702 case SENSOR_FEATURE_GET_CONFIG_PARA:
1703 memcpy(pSensorConfigData, &OV2659SensorConfigData, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
1704 *pFeatureParaLen=sizeof(MSDK_SENSOR_CONFIG_STRUCT);
1705 break;
1706 case SENSOR_FEATURE_GET_GROUP_COUNT:
1707 *pFeatureReturnPara32++ = 0;
1708 *pFeatureParaLen = 4;
1709 break;
1710 case SENSOR_FEATURE_GET_LENS_DRIVER_ID:
1711 *pFeatureReturnPara32 = LENS_DRIVER_ID_DO_NOT_CARE;
1712 *pFeatureParaLen = 4;
1713 break;
1714 case SENSOR_FEATURE_CHECK_SENSOR_ID:
1715 OV2659_GetSensorID(pFeatureData32);
1716 break;
1717 case SENSOR_FEATURE_SET_YUV_CMD:
1718 OV2659YUVSensorSetting((FEATURE_ID)*pFeatureData32, *(pFeatureData32 + 1));
1719 break;
1720 case SENSOR_FEATURE_SET_VIDEO_MODE:
1721 OV2659YUVSetVideoMode(*pFeatureData16);
1722 break;
1723 case SENSOR_FEATURE_SET_MAX_FRAME_RATE_BY_SCENARIO:
1724 OV2659SetMaxFramerateByScenario((MSDK_SCENARIO_ID_ENUM)*pFeatureData32, *(pFeatureData32 + 1));
1725 break;
1726 case SENSOR_FEATURE_GET_DEFAULT_FRAME_RATE_BY_SCENARIO:
1727 OV2659GetDefaultFramerateByScenario((MSDK_SCENARIO_ID_ENUM)*pFeatureData32, (MUINT32 *)(*(pFeatureData32 + 1)));
1728 break;
1729 case SENSOR_FEATURE_SET_TEST_PATTERN:
1730 OV2659SetTestPatternMode((BOOL)*pFeatureData16);
1731 break;
1732 case SENSOR_FEATURE_SET_YUV_3A_CMD:
1733 OV2659Set3ACtrl((ACDK_SENSOR_3A_LOCK_ENUM)*pFeatureData32);
1734 break;
1735 case SENSOR_FEATURE_GET_SHUTTER_GAIN_AWB_GAIN:
1736 OV2659GetCurAeAwbInfo(*pFeatureData32);
1737 break;
1738 case SENSOR_FEATURE_GET_AE_AWB_LOCK_INFO:
1739 OV2659_get_AEAWB_lock((UINT32 *)(*pFeatureData32),(UINT32 *) (*(pFeatureData32 + 1)));
1740 break;
1741 case SENSOR_FEATURE_GET_DELAY_INFO:
1742 OV2659_GetDelayInfo(*pFeatureData32);
1743 break;
1744 case SENSOR_FEATURE_GET_EXIF_INFO:
1745 OV2659GetExifInfo(*pFeatureData32);
1746 break;
1747 case SENSOR_FEATURE_GET_TEST_PATTERN_CHECKSUM_VALUE:
1748 *pFeatureReturnPara32= OV2659_TEST_PATTERN_CHECKSUM;
1749 *pFeatureParaLen=4;
1750 break;
1751 case SENSOR_FEATURE_AUTOTEST_CMD:
1752 case SENSOR_FEATURE_SET_GAIN:
1753 case SENSOR_FEATURE_SET_FLASHLIGHT:
1754 case SENSOR_FEATURE_SET_ISP_MASTER_CLOCK_FREQ:
1755 case SENSOR_FEATURE_SET_ESHUTTER:
1756 case SENSOR_FEATURE_SET_CCT_REGISTER:
1757 case SENSOR_FEATURE_GET_CCT_REGISTER:
1758 case SENSOR_FEATURE_SET_ENG_REGISTER:
1759 case SENSOR_FEATURE_GET_ENG_REGISTER:
1760 case SENSOR_FEATURE_GET_REGISTER_DEFAULT:
1761 case SENSOR_FEATURE_CAMERA_PARA_TO_SENSOR:
1762 case SENSOR_FEATURE_SENSOR_TO_CAMERA_PARA:
1763 case SENSOR_FEATURE_GET_GROUP_INFO:
1764 case SENSOR_FEATURE_GET_ITEM_INFO:
1765 case SENSOR_FEATURE_SET_ITEM_INFO:
1766 case SENSOR_FEATURE_GET_ENG_INFO:
1767 break;
1768 default:
1769 break;
1770 }
1771 return ERROR_NONE;
1772}
1773
1774
1775
1776SENSOR_FUNCTION_STRUCT SensorFuncOV2659=
1777{
1778 OV2659Open,
1779 OV2659GetInfo,
1780 OV2659GetResolution,
1781 OV2659FeatureControl,
1782 OV2659Control,
1783 OV2659Close
1784};
1785
1786
1787
1788UINT32 OV2659_YUV_SensorInit(PSENSOR_FUNCTION_STRUCT *pfFunc)
1789{
1790 if (pfFunc!=NULL)
1791 *pfFunc=&SensorFuncOV2659;
1792
1793 return ERROR_NONE;
1794}
1795
1796
kernel source for telekom puls (alcatel/mediatek)