image_sensor.c

OV2640.rar

        switch (pSensorConfigData->image_mirror) {
        case IMAGE_NORMAL:
            iStartX = 4;
#ifdef OV_PROCESSING_RAW
            iStartY = 6;
#else
            iStartY = 4;
#endif
            break;

        case IMAGE_HV_MIRROR:
            iStartX = 4;
#ifdef OV_PROCESSING_RAW
            iStartY = 5;
#else
            iStartY = 4;
#endif
        break;

        default:
            ASSERT(0);
        }

        iGrabWidth = IMAGE_SENSOR_FULL_WIDTH;
        iGrabHeight = IMAGE_SENSOR_FULL_HEIGHT;

        iCapture_Column_Pixel = FULL_PERIOD_PIXEL_NUMS + iDummyPixels;
        iCP_PCLK_Div = ((DRV_Reg32(ISP_TG_PHASE_COUNTER_REG) >> 4) & 0x0000000F) + 1;
        iShutter = iShutter * g_iPreview_Column_Pixel / iCapture_Column_Pixel;
        iShutter = iShutter * 2 * g_iPV_PCLK_Divider / iCP_PCLK_Div;    // x2 for SVGA -> UXGA switch
    }

    // 1. To force OV2640 re-calibrate ABLC by chaning global gain
    // 2. Skip at least one frame after chaing global gain
    iTemp = read_cmos_sensor(0x00);
    if (bMetaMode == KAL_FALSE) {   // normal capture mode
        write_cmos_sensor(0x00, iTemp % 2 ? --iTemp : ++iTemp);
    }else { // CCT mode
        // 1. CCT mode needs linearity test, gain must be kept constant
        // 2. CCT mode doesn't care capture speed
        write_cmos_sensor(0x00, iTemp % 2 ? --iTemp : ++iTemp);
        kal_sleep_task(250);    // wait at least one frame
        iTemp = read_cmos_sensor(0x00);
        kal_sleep_task(250);    // wait at least one frame
        write_cmos_sensor(0x00, iTemp % 2 ? --iTemp : ++iTemp);
    }

    //compensate OV2640 ABLC for every frame
    write_cmos_sensor(PAGE_SETTING_REG, 0x01);
    write_cmos_sensor(0x71, 0x96);

    OV2640_SetDummy(iDummyPixels, iDummyLines);
    write_OV2640_shutter(iShutter);

    pImageWindow->grab_start_x = iStartX;
    pImageWindow->grab_start_y = iStartY;
    pImageWindow->exposure_window_width = iGrabWidth;
    pImageWindow->exposure_window_height = iGrabHeight;
}   /*  OV2640_Capture  */

/*************************************************************************
* FUNCTION
*	write_OV2640_reg
*
* DESCRIPTION
*	This function set the register of OV2640.
*
* PARAMETERS
*	addr : the register index of OV2640
*  para : setting parameter of the specified register of OV2640
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void write_OV2640_reg(kal_uint32 iAddr, kal_uint32 iPara)
{
    kal_sleep_task(1);
    page_write_cmos_sensor(iAddr, iPara);
}   /*  write_OV2640_reg()  */

/*************************************************************************
* FUNCTION
*	read_cmos_sensor
*
* DESCRIPTION
*	This function read parameter of specified register from OV2640.
*
* PARAMETERS
*	addr : the register index of OV2640
*
* RETURNS
*	the data that read from OV2640
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint32 read_OV2640_reg(kal_uint32 iAddr)
{
    kal_sleep_task(1);
    return page_read_cmos_sensor(iAddr);
}   /*  read_OV2640_reg()   */

/*************************************************************************
* FUNCTION
*	OV2640_SetShutter
*
* DESCRIPTION
*	This function set e-shutter of OV2640 to change exposure time.
*
* PARAMETERS
*	shutter : exposured lines
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void OV2640_SetShutter(kal_uint16 iShutter)
{
    g_iExpLines = iShutter;
    write_OV2640_shutter(iShutter);
}   /*  OV2640_SetShutter   */

/*************************************************************************
* FUNCTION
*	OV2640_SetGain
*
* DESCRIPTION
*	This function is to set global gain to sensor.
*
* PARAMETERS
*	gain : sensor global gain(base: 0x40)
*
* RETURNS
*	the actually gain set to sensor.
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint16 OV2640_SetGain(kal_uint16 iGain)
{
    const kal_uint16 iBaseGain = Reg2Gain(camera_para.SENSOR.cct[GLOBAL_GAIN_INDEX].para);
    const kal_uint16 iGain2Set = iGain * iBaseGain / BASEGAIN;
    kal_uint8 iReg = Gain2Reg(iGain2Set);

    write_cmos_sensor(PAGE_SETTING_REG, 0x01);
    write_cmos_sensor(0x00, iReg);

    return Reg2Gain(iReg) * BASEGAIN / iBaseGain;

#if 0
	sensor_global_gain=(iGain * sensor_gain_base) / BASEGAIN;
	write_OV2640_gain(sensor_global_gain);
	sensor_global_gain=(sensor_global_gain*BASEGAIN)/sensor_gain_base;

	return sensor_global_gain;
#endif
}   /*  OV2640_SetGain  */

/*************************************************************************
* FUNCTION
*	OV2640_NightMode
*
* DESCRIPTION
*	This function enable/disable night mode of OV2640.
*
* PARAMETERS
*	none
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void OV2640_NightMode(kal_bool bEnable)
{
    // Night mode and normal mode switch effect is switched by different AE tables now
}   /*  OV2640_NightMode    */

void OV2640_Set_Flashlight(kal_bool bEnable)
{
    flashlight_power_on(bEnable);
}   /*  OV2640_Set_Flashlight   */

/*************************************************************************
* FUNCTION
*	image_sensor_func_OV2640
*
* DESCRIPTION
*	OV2640 Image Sensor functions struct.
*
* PARAMETERS
*	none
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
image_sensor_func_struct image_sensor_func_OV2640=
{
	OV2640_Init,
	OV2640_GetID,
	OV2640_GetSize,
	OV2640_GetPeriod,
	OV2640_Preview,
	OV2640_Capture,
	write_OV2640_reg,
	read_OV2640_reg,
	OV2640_SetShutter,
	OV2640_NightMode,
	OV2640_PowerOff,
	OV2640_SetGain,
	OV2640_Set_Flashlight
};  /*  image_sensor_func_OV2640    */

/*************************************************************************
* FUNCTION
*	image_sensor_func_config
*
* DESCRIPTION
*	This function maps the camera module function API structure.
*
* PARAMETERS
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void image_sensor_func_config(void)
{
    image_sensor_func = &image_sensor_func_OV2640;
}   /*  image_sensor_func_config    */

// write camera_para to sensor register
void camera_para_to_sensor(void)
{
	kal_uint32	i;
	
	for(i=0; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
	{
		write_OV2640_reg(camera_para.SENSOR.reg[i].addr, camera_para.SENSOR.reg[i].para);
	}
	for(i=FACTORY_START_ADDR; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
	{
		write_OV2640_reg(camera_para.SENSOR.reg[i].addr, camera_para.SENSOR.reg[i].para);
	}
	for(i=0; i<CCT_END_ADDR; i++)
	{
		write_OV2640_reg(camera_para.SENSOR.cct[i].addr, camera_para.SENSOR.cct[i].para);
	}
}

// update camera_para from sensor register
void sensor_to_camera_para(void)
{
	kal_uint32	i;
	
	for(i=0; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
	{
		camera_para.SENSOR.reg[i].para = read_OV2640_reg(camera_para.SENSOR.reg[i].addr);
	}
	for(i=FACTORY_START_ADDR; 0xFFFFFFFF!=camera_para.SENSOR.reg[i].addr; i++)
	{
		camera_para.SENSOR.reg[i].para = read_OV2640_reg(camera_para.SENSOR.reg[i].addr);
	}
	
}

//------------------------Engineer mode---------------------------------

void  get_sensor_group_count(kal_int32* sensor_count_ptr)
{
   *sensor_count_ptr=GROUP_TOTAL_NUMS;
   
	return;
}

void get_sensor_group_info(kal_uint16 group_idx, kal_int8* group_name_ptr, kal_int32* item_count_ptr)
{
   switch (group_idx)
   {
      	case PRE_GAIN:
			sprintf(group_name_ptr, "CCT");
			*item_count_ptr = 3;
		break;
		default:
		   ASSERT(0);
	}
}

void get_sensor_item_info(kal_uint16 group_idx,kal_uint16 item_idx, ENG_sensor_info* info_ptr)
{
	kal_uint8 temp_reg;
	write_cmos_sensor(PAGE_SETTING_REG,0x01);
	switch (group_idx)
	{
		
		case PRE_GAIN:
			switch (item_idx)
			{
				case 0:
				  sprintf(info_ptr->item_name_ptr,"Pregain-R");
				  
				  temp_reg = read_OV2640_reg(camera_para.SENSOR.cct[PRE_GAIN_RB_INDEX].addr);
				  temp_reg &= 0x0C;
				  temp_reg >>= 2; 
				  
				  if(temp_reg==0)
				      info_ptr->item_value=1000;
				  else if(temp_reg==1)
				      info_ptr->item_value=1250;
				  else if(temp_reg==2)
				      info_ptr->item_value=1500;
				  else if(temp_reg==3)
				      info_ptr->item_value=1750;
				  
				  info_ptr->is_true_false=KAL_FALSE;
				  info_ptr->is_read_only=KAL_FALSE;
				  info_ptr->is_need_restart=KAL_FALSE;
				  info_ptr->min=1000;
				  info_ptr->max=1875;
				  
				break; 
				case 1:
				  sprintf(info_ptr->item_name_ptr,"Pregain-Gr");
				  
				  
				  temp_reg = read_OV2640_reg(camera_para.SENSOR.cct[PRE_GAIN_G_INDEX].addr);
				  temp_reg &= 0x03;

				  
				  if(temp_reg==0)
				      info_ptr->item_value=1000;
				  else if(temp_reg==1)
				      info_ptr->item_value=1250;
				  else if(temp_reg==2)
				      info_ptr->item_value=1500;
				  else if(temp_reg==3)
				      info_ptr->item_value=1750;
				      
				  info_ptr->is_true_false=KAL_FALSE;
				  info_ptr->is_read_only=KAL_FALSE;
				  info_ptr->is_need_restart=KAL_FALSE;
				  info_ptr->min=1000;
				  info_ptr->max=1875;
				break;
				case 2:
				  sprintf(info_ptr->item_name_ptr,"SENSOR_BASEGAIN");
				  
//				  temp_reg = read_OV2640_gain();
                  temp_reg = Reg2Gain(camera_para.SENSOR.cct[GLOBAL_GAIN_INDEX].para);
				  
				  info_ptr->item_value=(temp_reg*1000)/BASEGAIN;
				  info_ptr->is_true_false=KAL_FALSE;
				  info_ptr->is_read_only=KAL_FALSE;
				  info_ptr->is_need_restart=KAL_FALSE;
				  info_ptr->min=1000;
				  info_ptr->max=16000;
				break;
				default:
				   ASSERT(0);		
			}
		break;
		
		default:
			ASSERT(0); 
	}
}

kal_bool set_sensor_item_info(kal_uint16 group_idx, kal_uint16 item_idx, kal_int32 item_value)
{
   kal_uint8 temp_reg;
   kal_uint16 temp_gain;
   
   write_cmos_sensor(PAGE_SETTING_REG,0x01);
   
   switch (group_idx)
	{
		case PRE_GAIN:
			switch (item_idx)
			{
				case 0:
				  temp_reg = read_OV2640_reg(camera_para.SENSOR.cct[PRE_GAIN_RB_INDEX].addr);
				  temp_reg &= ~0x0C;
				  
				  if(item_value>=1000 && item_value<=1125)
				      temp_reg |= 0x00;
				  else if(item_value>1125 && item_value<=1375)
				      temp_reg |= 0x04;
				  else if(item_value>1375 && item_value<=1625)
				      temp_reg |= 0x08;
				  else if(item_value>1625 && item_value<=1875)
				      temp_reg |= 0x0C;
				  else
				  		return KAL_FALSE;
				  		
				  camera_para.SENSOR.cct[PRE_GAIN_RB_INDEX].para = temp_reg;
				  write_OV2640_reg(camera_para.SENSOR.cct[PRE_GAIN_RB_INDEX].addr,temp_reg);
				break;
				case 1:
				  temp_reg = read_OV2640_reg(camera_para.SENSOR.cct[PRE_GAIN_G_INDEX].addr);
				  temp_reg &= ~0x03;
				  
				  if(item_value>=1000 && item_value<=1125)
				      temp_reg |= 0x00;
				  else if(item_value>1125 && item_value<=1375)
				      temp_reg |= 0x01;
				  else if(item_value>1375 && item_value<=1625)
				      temp_reg |= 0x02;
				  else if(item_value>1625 && item_value<=1875)
				      temp_reg |= 0x03;
				  else
				  		return KAL_FALSE;
				  
				  camera_para.SENSOR.cct[PRE_GAIN_G_INDEX].para = temp_reg;
				  write_OV2640_reg(camera_para.SENSOR.cct[PRE_GAIN_G_INDEX].addr,temp_reg);
				break;
				case 2:
				  temp_gain = (item_value * BASEGAIN) / 1000;
                  temp_reg = Gain2Reg(temp_gain);				

				  camera_para.SENSOR.cct[GLOBAL_GAIN_INDEX].para = temp_reg;
				  write_OV2640_reg(camera_para.SENSOR.cct[GLOBAL_GAIN_INDEX].addr,temp_reg);
				  break;
				default:
				   ASSERT(0);	
			}
		break;
		
		default:
		   ASSERT(0);
	}
	
	return KAL_TRUE;
}