📄 image_sensor.c
字号:
/*****************************************************************************
* Copyright Statement:
* --------------------
* This software is protected by Copyright and the information contained
* herein is confidential. The software may not be copied and the information
* contained herein may not be used or disclosed except with the written
* permission of MediaTek Inc. (C) 2005
*
* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/
/*****************************************************************************
*------------------------------------------------------------------------------
* Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
*============================================================================
****************************************************************************/
#include "drv_comm.h"
#include "IntrCtrl.h"
#include "reg_base.h"
#include "gpio_sw.h"
#include "sccb.h"
#include "isp_if.h"
#include "image_sensor.h"
#include "camera_para.h"
#include "upll_ctrl.h"
#include "med_api.h"
/* Global Valuable */
// SensorInfo g_CCT_MainSensor=MT9V112_OMNIVISION; // modify by wwz in 2008-11-11
#if defined(SENSOR_ROTATE_0)
kal_uint8 g_CCT_FirstGrabColor=BAYER_R;
#else
kal_uint8 g_CCT_FirstGrabColor=BAYER_Gb;
#endif
kal_uint8 start_grab_x_offset=0, start_grab_y_offset=0;
kal_bool gVGAmode=KAL_TRUE, sensor_night_mode=KAL_FALSE, MPEG4_encode_mode=KAL_FALSE;
kal_uint8 normal_gain=0, night_gain=SENSOR_NIGHT_MODE_GAIN;
kal_uint8 preview_pclk_division=0, capture_pclk_division=0;
kal_uint16 dummy_pixels=0, dummy_lines=0, extra_exposure_lines=0;
kal_uint16 exposure_lines=0;
kal_uint16 sensor_global_gain=BASEGAIN, sensor_gain_base=0x0;
kal_uint16 sensor_gain_array[2][4]={{0x2D, 0x2E, 0x2B, 0x2C},{0, 0, 0, 0}};
/* Debug Message, Don't Care */
kal_uint16 sensor_frame_rate;
/* MAX/MIN Explosure Lines Used By AE Algorithm */
kal_uint16 MAX_EXPOSURE_LINES=(PIXEL_CLK/MIN_FRAME_RATE)/VGA_PERIOD_PIXEL_NUMS;
kal_uint8 MIN_EXPOSURE_LINES=2;
/* Parameter For Engineer mode function */
kal_uint32 FAC_SENSOR_REG;
/* Image Sensor ID */
kal_uint16 sensor_id=0;
kal_bool sensor_cap_state=KAL_FALSE;
#if defined(__MAIN_PCB_SUPPORT_DOUBLE_CAMERA__) // add by hqing
extern kal_uint8 mainCamera;
#endif
void SCCB_send_byte(kal_uint8 send_byte)
{
volatile signed char i;
volatile kal_uint32 j;
for (i=7;i>=0;i--)
{ /* data bit 7~0 */
if (send_byte & (1<<i))
{
SET_SCCB_DATA_HIGH;
}
else
{
SET_SCCB_DATA_LOW;
}
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_HIGH;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_LOW;
for(j=0;j<SENSOR_I2C_DELAY;j++);
}
/* don't care bit, 9th bit */
SET_SCCB_DATA_LOW;
SET_SCCB_DATA_INPUT;
SET_SCCB_CLK_HIGH;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_LOW;
SET_SCCB_DATA_OUTPUT;
} /* SCCB_send_byte() */
kal_uint16 SCCB_get_byte(void)
{
volatile signed char i;
volatile kal_uint32 j;
kal_uint16 get_byte=0;
SET_SCCB_DATA_INPUT;
for (i=15; i>=8; i--)
{ /* data bit 15~8 */
SET_SCCB_CLK_HIGH;
for(j=0;j<SENSOR_I2C_DELAY;j++);
if (GET_SCCB_DATA_BIT)
get_byte |= (1<<i);
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_LOW;
for(j=0;j<SENSOR_I2C_DELAY;j++);
}
SET_SCCB_DATA_OUTPUT;
SET_SCCB_DATA_LOW;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_HIGH;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_LOW;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_DATA_INPUT;
for (i=7; i>=0; i--)
{ /* data bit 7~0 */
SET_SCCB_CLK_HIGH;
for(j=0;j<SENSOR_I2C_DELAY;j++);
if (GET_SCCB_DATA_BIT)
get_byte |= (1<<i);
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_LOW;
for(j=0;j<SENSOR_I2C_DELAY;j++);
}
SET_SCCB_DATA_OUTPUT;
SET_SCCB_DATA_HIGH;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_HIGH;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SET_SCCB_CLK_LOW;
return get_byte;
} /* SCCB_get_byte() */
void write_cmos_sensor(kal_uint32 addr, kal_uint32 para)
{
volatile kal_uint32 j;
#if defined(HW_SCCB)
SET_SCCB_DATA_LENGTH(3);
ENABLE_SCCB;
REG_SCCB_DATA = MT9V11X_WRITE_ID | SCCB_DATA_REG_ID_ADDRESS;
REG_SCCB_DATA = addr;
REG_SCCB_DATA = para;
while (SCCB_IS_WRITTING) {};
#elif defined(SCCB_16BIT)
I2C_START_TRANSMISSION;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SCCB_send_byte(MT9V11X_WRITE_ID);
for(j=0;j<SENSOR_I2C_DELAY;j++);
SCCB_send_byte(addr);
for(j=0;j<SENSOR_I2C_DELAY;j++);
SCCB_send_byte(para>>8);
for(j=0;j<SENSOR_I2C_DELAY;j++);
SCCB_send_byte(para&0xFF);
for(j=0;j<SENSOR_I2C_DELAY;j++);
I2C_STOP_TRANSMISSION;
#endif /* HW_SCCB */
} /* write_cmos_sensor() */
kal_uint32 read_cmos_sensor(kal_uint32 addr)
{
volatile kal_uint32 j;
kal_uint16 get_byte=0;
#if defined(HW_SCCB)
SET_SCCB_DATA_LENGTH(2);
ENABLE_SCCB;
REG_SCCB_DATA = MT9V11X_WRITE_ID | SCCB_DATA_REG_ID_ADDRESS;
REG_SCCB_DATA = addr;
while (SCCB_IS_WRITTING) {};
ENABLE_SCCB;
REG_SCCB_DATA = MT9V11X_READ_ID | SCCB_DATA_REG_ID_ADDRESS;
REG_SCCB_DATA=0;
while (SCCB_IS_READING) {};
get_byte = REG_SCCB_READ_DATA & 0xFF;
#elif defined(SCCB_16BIT)
I2C_START_TRANSMISSION;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SCCB_send_byte(MT9V11X_WRITE_ID);
for(j=0;j<SENSOR_I2C_DELAY;j++);
SCCB_send_byte(addr);
for(j=0;j<SENSOR_I2C_DELAY;j++);
I2C_START_TRANSMISSION;
for(j=0;j<SENSOR_I2C_DELAY;j++);
SCCB_send_byte(MT9V11X_READ_ID);
for(j=0;j<SENSOR_I2C_DELAY;j++);
get_byte=SCCB_get_byte();
for(j=0;j<SENSOR_I2C_DELAY;j++);
I2C_STOP_TRANSMISSION;
#endif
return get_byte;
} /* read_cmos_sensor() */
/* Gain Write for RAW data output*/
void write_MT9V11X_gain(kal_uint16 gain)
{
volatile signed char i;
kal_uint16 temp_reg, temp_gain;
kal_uint16 temp_min_gain = gain;
for(i=0;i<4;i++)
{
temp_gain=(sensor_gain_array[1][i]*gain)/BASEGAIN;
if(temp_gain>=1*BASEGAIN && temp_gain<2*BASEGAIN)
{
temp_reg=(temp_gain*32)/BASEGAIN;
if(temp_gain<=temp_min_gain)
{
sensor_global_gain=temp_gain&(~0x1);
temp_min_gain = temp_gain;
}
}
else if(temp_gain>=2*BASEGAIN && temp_gain<8*BASEGAIN)
{
temp_reg=(temp_gain*16)/BASEGAIN+128;
if(temp_gain<=temp_min_gain)
{
sensor_global_gain=temp_gain&(~0x3);
temp_min_gain = temp_gain;
}
}
else if(temp_gain>=8*BASEGAIN && temp_gain<16*BASEGAIN)
{
temp_reg=(temp_gain*8)/BASEGAIN+384;
if(temp_gain<=temp_min_gain)
{
sensor_global_gain=temp_gain&(~0x7);
temp_min_gain = temp_gain;
}
}
else
{
temp_reg=(15.875*BASEGAIN*8)/BASEGAIN+384;
if(temp_gain<=temp_min_gain)
{
sensor_global_gain=15.875*BASEGAIN;
temp_min_gain = temp_gain;
}
}
write_cmos_sensor(sensor_gain_array[0][i],temp_reg);
}
} /* write_MT9V11X_gain */
/* Gain Read for RAW data output*/
kal_uint16 read_MT9V11X_gain(void)
{
volatile signed char i;
kal_uint16 temp_reg, sensor_gain,temp_reg_base;
for(i=0;i<4;i++)
{
temp_reg_base=camera_para.SENSOR.cct[SENSOR_BASEGAIN].para;
temp_reg=camera_para.SENSOR.cct[PRE_GAIN_R_INDEX+i].para;
if(temp_reg>=0x20 && temp_reg<=0x3F)
sensor_gain_array[1][i]=((((temp_reg*BASEGAIN)/32)*temp_reg_base)/32);
else if(temp_reg>=0xA0 && temp_reg<=0xFF)
sensor_gain_array[1][i]=(((((temp_reg-128)*BASEGAIN)/16)*temp_reg_base)/32);
else if(temp_reg>=0x1C0 && temp_reg<=0x1FF)
sensor_gain_array[1][i]=(((((temp_reg-384)*BASEGAIN)/8)*temp_reg_base)/32);
else
ASSERT(0);
}
sensor_gain=(temp_reg_base*BASEGAIN)/32;
return sensor_gain;
} /* read_MT9V11X_gain */
//qin add begin
void Image_DelayMs(kal_uint16 time)
{
volatile kal_uint32 delay;
while(time)//while(time--)
{
for (delay =0;delay <100;delay++) {} // 1ms
time--;
}
}
//qin add end
/*************************************************************************
* FUNCTION
* init_MT9V11X
*
* DESCRIPTION
* This function initialize the registers of CMOS sensor and ISP control register.
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_int8 init_MT9V11X(void)
{
volatile signed char i;
cis_module_power_on(KAL_TRUE); // Power On CIS Power
kal_sleep_task(2); // To wait for Stable Power
RESET_CMOS_SENSOR_MODE2; // High - normal, Low - reset.
SET_CMOS_CLOCK_POLARITY_LOW;
SET_VSYNC_POLARITY_HIGH;
SET_HSYNC_POLARITY_LOW;
ENABLE_CAMERA_INDATA_FORMAT;
SET_CAMERA_INPUT_TYPE(INPUT_YUV422);
ENABLE_CAMERA_TG_CLK_48M;
UPLL_Enable(UPLL_OWNER_ISP);
set_isp_driving_current(camera_para.SENSOR.reg[CMMCLK_CURRENT_INDEX].para);
write_cmos_sensor(0xF0,0); // Switch to Page0
// Reset Sensor
write_cmos_sensor(0x0D, read_cmos_sensor(0x0D) | 0x01);
kal_sleep_task(2);
write_cmos_sensor(0x0D, read_cmos_sensor(0x0D) | 0x20);
kal_sleep_task(2);
write_cmos_sensor(0x0D, read_cmos_sensor(0x0D) & ~0x21);
kal_sleep_task(2);
for(i=0;i<3;i++)
{
sensor_id=read_cmos_sensor(0x00);
if(sensor_id == MT9V112_SENSOR_ID)
break;
}
if(sensor_id != MT9V112_SENSOR_ID)
{
kal_prompt_trace(MOD_MED, "[#ID] FAIL=%d\n",sensor_id);
return -1;
}
/*
write_cmos_sensor(0x03,0x1E8);//0x1E4
write_cmos_sensor(0x04,0x288);//0x288
write_cmos_sensor(0x2F,0xB4);
write_cmos_sensor(0x2B,0xB4);
write_cmos_sensor(0x2C,0xC4);
write_cmos_sensor(0x2D,0xC8);
write_cmos_sensor(0x2E,0xB4);
write_cmos_sensor(0x61,0x0F);
write_cmos_sensor(0x62,0x09);
write_cmos_sensor(0x63,0x0C);
write_cmos_sensor(0x64,0x0F);
write_cmos_sensor(0xF0,0x02);
write_cmos_sensor(0xC8,0x1F0B);
write_cmos_sensor(0xCC,0x0004);
write_cmos_sensor(0xD2,0x007F);
write_cmos_sensor(0xF0,0x01);
write_cmos_sensor(0x05,0x0005);
write_cmos_sensor(0x25,0x002D);
write_cmos_sensor(0x34,0x0000);
write_cmos_sensor(0x35,0xFF00);
write_cmos_sensor(0xA0,0x0280);
write_cmos_sensor(0xA1,0x0280);
write_cmos_sensor(0xA3,0x01E0);
write_cmos_sensor(0xA4,0x01E0);
write_cmos_sensor(0xA7,0x0280);
write_cmos_sensor(0xAA,0x01E0);
write_cmos_sensor(0xC8,0x1F0B);
*/
//write_cmos_sensor(0xC8,0x9F0B);
/************************************/
write_cmos_sensor(0xF0,0x00);
//write_cmos_sensor(0x0D, 0x0009 ); // RESET_REG
//write_cmos_sensor(0x0D, 0x0029 ); // RESET_REG
//write_cmos_sensor(0x0D, 0x0008 ); // RESET_REG
write_cmos_sensor(0x05, 0x014A); // Context B (full-res) Horizontal Blank
write_cmos_sensor(0x06, 0x0100 ); //0x0100,0x000D// Context B (full-res) Vertical Blank
write_cmos_sensor(0x07, 0x014A ); // Context A (preview) Horizontal Blank
write_cmos_sensor(0x08, 0x000D ); // Context A (preview) Vertical Blank
write_cmos_sensor(0x20, 0x0700 ); // Read Mode Context B
write_cmos_sensor(0x21, 0x0400 ); // Read Mode Context A
write_cmos_sensor(0xF0,0x02 );
write_cmos_sensor(0x39, 0x03D2 ); // AE Line size Context A
write_cmos_sensor(0x3A, 0x03D2 ); // AE Line size Context B
write_cmos_sensor(0x3B, 0x055B ); // AE shutter delay limit Context A
write_cmos_sensor(0x3C, 0x055B ); // AE shutter delay limit Context B
write_cmos_sensor(0x57, 0x0198 ); // Context A Flicker full frame time (60Hz)
write_cmos_sensor(0x58, 0x01EA ); // Context A Flicker full frame time (50Hz)
write_cmos_sensor(0x59, 0x0198 ); // Context B Flicker full frame time (60Hz)
write_cmos_sensor(0x5A, 0x01EA ); // Context B Flicker full frame time (50Hz)
write_cmos_sensor(0x5C, 0x0E0A ); // 60Hz Flicker Search Range
write_cmos_sensor(0x5D, 0x120E ); // 50Hz Flicker Search Range
write_cmos_sensor(0x64, 0x5E1C ); // Flicker parameter
write_cmos_sensor(0xf0, 0x02 );
write_cmos_sensor(0x37, 0x0080 ); // 0x0100
write_cmos_sensor(0x5B, 0x0001 ); // FLICKER_CONTROL 50Hz 0x03--> 60Hz
write_cmos_sensor(0x37, 0x0080 ); // SHUTTER_WIDTH_LIM_AE // 0x0100
write_cmos_sensor(0xC8, 0x1F0B ); // CONTEXT_CONTROL
write_cmos_sensor(0xf0, 0x01 );
write_cmos_sensor(0x80, 0x0007 ); //LENS_CORRECT_CONTROL
write_cmos_sensor(0x81, 0xDD09 ); //LENS_ADJ_VERT_RED_0
write_cmos_sensor(0x82, 0xEAE0 ); //LENS_ADJ_VERT_RED_1_2
write_cmos_sensor(0x83, 0x07F6 ); //LENS_ADJ_VERT_RED_3_4
write_cmos_sensor(0x84, 0xE906 ); //LENS_ADJ_VERT_GREEN_0
write_cmos_sensor(0x85, 0xF1ED ); //LENS_ADJ_VERT_GREEN_1_2
write_cmos_sensor(0x86, 0x06F8 ); //LENS_ADJ_VERT_GREEN_3_4
write_cmos_sensor(0x87, 0xEC05 ); //LENS_ADJ_VERT_BLUE_0
write_cmos_sensor(0x88, 0xF2EC ); //LENS_ADJ_VERT_BLUE_1_2
write_cmos_sensor(0x89, 0x07FA ); //LENS_ADJ_VERT_BLUE_3_4
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -