📄 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_MICRON;
#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, g_bMJPEG_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;
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 */
/*************************************************************************
* 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);//Row width
write_cmos_sensor(0x04,0x288);//Column width
write_cmos_sensor(0x2F,0xB4);//Global gain
write_cmos_sensor(0x2B,0xB4);//Gb gain
write_cmos_sensor(0x2C,0xC4);//B gain
write_cmos_sensor(0x2D,0xC8);//R gain
write_cmos_sensor(0x2E,0xB4);//Gr gain
write_cmos_sensor(0x61,0x0F);//resvered
write_cmos_sensor(0x62,0x09);//resvered
write_cmos_sensor(0x63,0x0C);//resvered
write_cmos_sensor(0x64,0x0F);//resvered
write_cmos_sensor(0xF0,0x02);//change page to page2
write_cmos_sensor(0xC8,0x1F0B);//context control
write_cmos_sensor(0xCC,0x0004);//resvered
write_cmos_sensor(0xD2,0x007F);//resvered
write_cmos_sensor(0xF0,0x01);//change page to page1
write_cmos_sensor(0x05,0x0005);//Aperture Correction
write_cmos_sensor(0x25,0x002D);//Color saturation control
write_cmos_sensor(0x34,0x0000);//Luma offset
write_cmos_sensor(0x35,0xFF00);//Luma clip
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);
//camera_para_to_sensor(); // switch to preview mode key setting
write_cmos_sensor(0xF0,0); // Switch to Page0
// normal_gain=read_cmos_sensor(0x2F);
// sensor_gain_base=read_MT9V11X_gain();
return 1;
} /* init_cmos_sensor() */
/*************************************************************************
* FUNCTION
* config_MT9V11X_window
*
* DESCRIPTION
* This function config the hardware window of MT9V11X for getting specified
* data of that window.
*
* PARAMETERS
* start_x : start column of the interested window
* start_y : start row of the interested window
* width : column widht of the itnerested window
* height : row depth of the itnerested window
*
* RETURNS
* the data that read from MT9V11X
*
* GLOBALS AFFECTED
*
*************************************************************************/
void config_MT9V11X_window(kal_uint16 startx,kal_uint16 starty,kal_uint16 width, kal_uint16 height)
{
kal_uint16 endx=startx+width;
kal_uint16 endy=starty+height;
// Horizontal
// Vertical
} /* config_MT9V11X_window */
/*************************************************************************
* FUNCTION
* power_off_MT9V11X
*
* DESCRIPTION
* This function is to turn off sensor module power.
*
* PARAMETERS
* None
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void power_off_MT9V11X(void)
{
cis_module_power_on(KAL_FALSE); // Power Off CIS Power
UPLL_Disable(UPLL_OWNER_ISP);
#ifndef HW_SCCB
SET_SCCB_CLK_LOW;
SET_SCCB_DATA_LOW;
#endif
} /* power_off_MT9V11X */
/*************************************************************************
* FUNCTION
* get_MT9V11X_id
*
* DESCRIPTION
* This function return the sensor read/write id of SCCB interface.
*
* PARAMETERS
* *sensor_write_id : address pointer of sensor write id
* *sensor_read_id : address pointer of sensor read id
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void get_MT9V11X_id(kal_uint8 *sensor_write_id, kal_uint8 *sensor_read_id)
{
*sensor_write_id=MT9V11X_WRITE_ID;
*sensor_read_id=MT9V11X_READ_ID;
} /* get_MT9V11X_id */
/*************************************************************************
* FUNCTION
* get_MT9V11X_size
*
* DESCRIPTION
* This function return the image width and height of image sensor.
*
* PARAMETERS
* *sensor_width : address pointer of horizontal effect pixels of image sensor
* *sensor_height : address pointer of vertical effect pixels of image sensor
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void get_MT9V11X_size(kal_uint16 *sensor_width, kal_uint16 *sensor_height)
{
*sensor_width=IMAGE_SENSOR_VGA_WIDTH; /* pixel numbers actually used in one frame */
*sensor_height=IMAGE_SENSOR_VGA_HEIGHT-IMAGE_HEIGHT_OFFSET; /* line numbers actually used in one frame */
} /* get_MT9V11X_size */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -