image_sensor.c

美光CMOS摄像头驱动

write_cmos_sensor(0x8A, 0xDC0E   );   //LENS_ADJ_HORIZ_RED_0
write_cmos_sensor(0x8B, 0xDCDC   );   //LENS_ADJ_HORIZ_RED_1_2

write_cmos_sensor(0x8C, 0xF7E9   );   //LENS_ADJ_HORIZ_RED_3_4

write_cmos_sensor(0x8D, 0x0005   );   //LENS_ADJ_HORIZ_RED_5
write_cmos_sensor(0x8E, 0xF009   );   //LENS_ADJ_HORIZ_GREEN_0
write_cmos_sensor(0x8F, 0xE9E9   );   //LENS_ADJ_HORIZ_GREEN_1_2
write_cmos_sensor(0x90, 0xF7ED   );   //LENS_ADJ_HORIZ_GREEN_3_4
write_cmos_sensor(0x91, 0x0003   );   //LENS_ADJ_HORIZ_GREEN_5
write_cmos_sensor(0x92, 0xF109   );   //LENS_ADJ_HORIZ_BLUE_0
write_cmos_sensor(0x93, 0xE9E9   );   //LENS_ADJ_HORIZ_BLUE_1_2
write_cmos_sensor(0x94, 0xF9EE   );     //LENS_ADJ_HORIZ_BLUE_3_4
write_cmos_sensor(0x95, 0x0002   );  //LENS_ADJ_HORIZ_BLUE_5
write_cmos_sensor(0xB6, 0x1E11   );  //LENS_ADJ_VERT_RED_5_6
write_cmos_sensor(0xB7, 0x7F2B   );  //LENS_ADJ_VERT_RED_7_8
write_cmos_sensor(0xB8, 0x160F   );  //LENS_ADJ_VERT_GREEN_5_6
write_cmos_sensor(0xB9, 0x7F1C   );  //LENS_ADJ_VERT_GREEN_7_8
write_cmos_sensor(0xBA, 0x170F   );  //LENS_ADJ_VERT_BLUE_5_6
write_cmos_sensor(0xBB, 0x7F14   );  //LENS_ADJ_VERT_BLUE_7_8
write_cmos_sensor(0xBC, 0x1F11   );  //LENS_ADJ_HORIZ_RED_6_7
write_cmos_sensor(0xBD, 0x2626   );  //LENS_ADJ_HORIZ_RED_8_9
write_cmos_sensor(0xBE, 0x001E  );  //LENS_ADJ_HORIZ_RED_10
write_cmos_sensor(0xBF, 0x160F   );  //LENS_ADJ_HORIZ_GREEN_6_7
write_cmos_sensor(0xC0, 0x171B   );//LENS_ADJ_HORIZ_GREEN_8_9
write_cmos_sensor(0xC1, 0x000F   );//LENS_ADJ_HORIZ_GREEN_10
write_cmos_sensor(0xC2, 0x130F   );//LENS_ADJ_HORIZ_BLUE_6_7
write_cmos_sensor(0xC3, 0x1717   );//LENS_ADJ_HORIZ_BLUE_8_9
write_cmos_sensor(0xC4, 0x0005   );//LENS_ADJ_HORIZ_BLUE_10
/*
write_cmos_sensor(0xf0, 0x02);
write_cmos_sensor(0x5E, 0x6753   );
write_cmos_sensor(0x5F, 0x342E   );
write_cmos_sensor(0x22, 0xD960   );//AWB_RED_LIMIT
write_cmos_sensor(0x23, 0xD960   );  //AWB_BLUE_LIMIT
write_cmos_sensor(0x24, 0x7F00   );  //MATRIX_ADJ_LIMITS
write_cmos_sensor(0x28, 0xEA02   );  //AWB_ADVANCED_CONTROL_REG
write_cmos_sensor(0x29, 0x867A   );  //AWB_WIDE_GATES
write_cmos_sensor(0x5E, 0x524C   );  //RATIO_BASE_REG
write_cmos_sensor(0x5F, 0x2024   );  //RATIO_DELTA_REG
write_cmos_sensor(0x60, 0x0002   );  //SIGNS_DELTA_REG
write_cmos_sensor(0x02, 0x00EE   );  //BASE_MATRIX_SIGNS
write_cmos_sensor(0x03, 0x291A   );  //BASE_MATRIX_SCALE_K1_K5 0x3923
write_cmos_sensor(0x04, 0x0724   );  //BASE_MATRIX_SCALE_K6_K9
write_cmos_sensor(0x09, 0x00C0   );  //BASE_MATRIX_COEF_K1
write_cmos_sensor(0x0A, 0x0079   );  //BASE_MATRIX_COEF_K2
write_cmos_sensor(0x0B, 0x0004   );  //BASE_MATRIX_COEF_K3
write_cmos_sensor(0x0C, 0x005C   );  //BASE_MATRIX_COEF_K4
write_cmos_sensor(0x0D, 0x00D9   );  //BASE_MATRIX_COEF_K5
write_cmos_sensor(0x0E, 0x0053   );  //BASE_MATRIX_COEF_K6
write_cmos_sensor(0x0F, 0x0021   );  //BASE_MATRIX_COEF_K7
write_cmos_sensor(0x10, 0x00A4   );  //BASE_MATRIX_COEF_K8
write_cmos_sensor(0x11, 0x00E5   );  //BASE_MATRIX_COEF_K9
write_cmos_sensor(0x15, 0x0000   );    //DELTA_COEFS_SIGNS
write_cmos_sensor(0x16, 0x0000   );  //DELTA_MATRIX_COEF_D1
write_cmos_sensor(0x17, 0x0000   );  //DELTA_MATRIX_COEF_D2
write_cmos_sensor(0x18, 0x0000   );  //DELTA_MATRIX_COEF_D3
write_cmos_sensor(0x19, 0x0000   );  //DELTA_MATRIX_COEF_D4
write_cmos_sensor(0x1A, 0x0000   );  //DELTA_MATRIX_COEF_D5
write_cmos_sensor(0x1B, 0x0000   );  //DELTA_MATRIX_COEF_D6
write_cmos_sensor(0x1C, 0x0000   );  //DELTA_MATRIX_COEF_D7
write_cmos_sensor(0x1D, 0x0000   );  //DELTA_MATRIX_COEF_D8
write_cmos_sensor(0x1E, 0x0000   );  //DELTA_MATRIX_COEF_D9
*/

write_cmos_sensor(0xf0, 0x0002);
write_cmos_sensor(0x24, 0x4000); //MATRIX_ADJ_LIMITS
write_cmos_sensor(0xF5, 0x0020); //MWB POSITION
write_cmos_sensor(0x5E, 0x4962); //RATIO_BASE_REG
write_cmos_sensor(0x5F, 0x7A58); //RATIO_DELTA_REG
write_cmos_sensor(0x60, 0x0002); //SIGNS_DELTA_REG
write_cmos_sensor(0x02, 0x00EA); //BASE_MATRIX_SIGNS
write_cmos_sensor(0x03, 0x291A); //BASE_MATRIX_SCALE_K1_K5
write_cmos_sensor(0x04, 0x04A4); //BASE_MATRIX_SCALE_K6_K9
write_cmos_sensor(0x09, 0x0097); //BASE_MATRIX_COEF_K1
write_cmos_sensor(0x0A, 0x0072); //BASE_MATRIX_COEF_K2
write_cmos_sensor(0x0B, 0x001E); //BASE_MATRIX_COEF_K3
write_cmos_sensor(0x0C, 0x001D); //BASE_MATRIX_COEF_K4
write_cmos_sensor(0x0D, 0x007E); //BASE_MATRIX_COEF_K5
write_cmos_sensor(0x0E, 0x0072); //BASE_MATRIX_COEF_K6
write_cmos_sensor(0x0F, 0x0011); //BASE_MATRIX_COEF_K7
write_cmos_sensor(0x10, 0x0034); //BASE_MATRIX_COEF_K8
write_cmos_sensor(0x11, 0x0082); //BASE_MATRIX_COEF_K9
write_cmos_sensor(0x15, 0x0111); //DELTA_COEFS_SIGNS
write_cmos_sensor(0x16, 0x003A); //DELTA_MATRIX_COEF_D1
write_cmos_sensor(0x17, 0x003B); //DELTA_MATRIX_COEF_D2
write_cmos_sensor(0x18, 0x0022); //DELTA_MATRIX_COEF_D3
write_cmos_sensor(0x19, 0x0051); //DELTA_MATRIX_COEF_D4
write_cmos_sensor(0x1A, 0x002B); //DELTA_MATRIX_COEF_D5
write_cmos_sensor(0x1B, 0x0032); //DELTA_MATRIX_COEF_D6
write_cmos_sensor(0x1C, 0x0071); //DELTA_MATRIX_COEF_D7
write_cmos_sensor(0x1D, 0x00BB); //DELTA_MATRIX_COEF_D8
write_cmos_sensor(0x1E, 0x00CB); //DELTA_MATRIX_COEF_D9

write_cmos_sensor(0xf0, 0x01  );
//write_cmos_sensor(0x06, 0x740E   );

//DELAY 10MS
Image_DelayMs(10);

write_cmos_sensor(0x34, 0x0010   );  // LUMA_OFFSET  // 0x0000, modify by wwz in 2008-11-17
write_cmos_sensor(0x35, 0xFF00   );  // CLIPPING_LIM_OUT_LUMA
write_cmos_sensor(0xE1, 0x0000   );  // GAMMA_B_Y0
write_cmos_sensor(0xDC, 0x1105   );  // GAMMA_B_Y1_Y2
write_cmos_sensor(0xDD, 0x5830   );  // GAMMA_B_Y3_Y4
write_cmos_sensor(0xDE, 0xB08D   );  // GAMMA_B_Y5_Y6
write_cmos_sensor(0xDF, 0xDFCB   );  // GAMMA_B_Y7_Y8
write_cmos_sensor(0xE0, 0xFFF0   );  // GAMMA_B_Y9_Y10
write_cmos_sensor(0x58, 0x0000   );  // GAMMA_A_Y0
write_cmos_sensor(0x53, 0x1105   );  // GAMMA_A_Y1_Y2
write_cmos_sensor(0x54, 0x5830   );  // GAMMA_A_Y3_Y4
write_cmos_sensor(0x55, 0xB08D   );  // GAMMA_A_Y5_Y6
write_cmos_sensor(0x56, 0xDFCB   );  // GAMMA_A_Y7_Y8
write_cmos_sensor(0x57, 0xFFF0   );  // GAMMA_A_Y9_Y10 

//kong add begin
//[gamma0.60]
write_cmos_sensor(0xF0,0x00);
write_cmos_sensor(0xF9, 0x6000   );  // RESERVED_SENSOR_F9 
write_cmos_sensor(0xF0,0x01);
write_cmos_sensor(0xDC, 0x1206   );  // GAMMA_B_Y1_Y2 
write_cmos_sensor(0xDD, 0x4225   );  // GAMMA_B_Y3_Y4 
write_cmos_sensor(0xDE, 0x9C72   );  // GAMMA_B_Y5_Y6 
write_cmos_sensor(0xDF, 0xD6BC   );  // GAMMA_B_Y7_Y8 
write_cmos_sensor(0xE0, 0xFFEC   );  // GAMMA_B_Y9_Y10 
#if 0
//[gamma0.65]
write_cmos_sensor(0xF0,0x00);
write_cmos_sensor(0xF9, 0x8800   );  // RESERVED_SENSOR_F9 
write_cmos_sensor(0xF0,0x01);
write_cmos_sensor(0xDC, 0x0F05   );  // GAMMA_B_Y1_Y2 
write_cmos_sensor(0xDD, 0x3B20   );  // GAMMA_B_Y3_Y4 
write_cmos_sensor(0xDE, 0x9469   );  // GAMMA_B_Y5_Y6 
write_cmos_sensor(0xDF, 0xD3B6   );  // GAMMA_B_Y7_Y8 
write_cmos_sensor(0xE0, 0xFFEA   );  // GAMMA_B_Y9_Y10 

//[gamma0.50]
write_cmos_sensor(0xF0,0x00);
write_cmos_sensor(0xF9, 0xa800   );  // RESERVED_SENSOR_F9 
write_cmos_sensor(0xF0,0x01);
write_cmos_sensor(0xDC, 0x0401   );  // GAMMA_B_Y1_Y2 
write_cmos_sensor(0xDD, 0x2c03   );  // GAMMA_B_Y3_Y4 
write_cmos_sensor(0xDE, 0x9363   );  // GAMMA_B_Y5_Y6 
write_cmos_sensor(0xDF, 0xd4b7   );  // GAMMA_B_Y7_Y8 
write_cmos_sensor(0xE0, 0xffeb   );  // GAMMA_B_Y9_Y10 
#endif
//kong add end

write_cmos_sensor(0xF0,0x00);
write_cmos_sensor(0x34, 0xc019 );
write_cmos_sensor(0x40, 0x1800 );
write_cmos_sensor(0x76, 0x7358 );
write_cmos_sensor(0x04, 0x0282 );
write_cmos_sensor(0x03, 0x01E2 );

write_cmos_sensor(0xF0,0x01);
write_cmos_sensor(0xa0, 0x0282 );
write_cmos_sensor(0xa3, 0x01E2 );
write_cmos_sensor(0xa6, 0x0282 );
write_cmos_sensor(0xa9, 0x01E2 );

write_cmos_sensor(0xF0,0x02 );
write_cmos_sensor(0x2E, 0x0CC1   );// AE_PRECISION_TARGET // 0x0C44

write_cmos_sensor(0xF0,0x01  );
write_cmos_sensor(0x25, 0x002D   );// AWB_SPEED_SATURATION  // 0x0005

write_cmos_sensor(0xF0,0x01);		//del for color error (yuv order)
write_cmos_sensor(0x9B, 0x0201 );
//write_cmos_sensor(0x3A, 0x0201 );



/************************************/
    //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 */

/*************************************************************************
* FUNCTION
*	get_MT9V11X_period
*
* DESCRIPTION
*	This function return the image width and height of image sensor.
*
* PARAMETERS
*	*pixel_number : address pointer of pixel numbers in one period of HSYNC
*  *line_number : address pointer of line numbers in one period of VSYNC
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void get_MT9V11X_period(kal_uint16 *pixel_number, kal_uint16 *line_number)
{
	*pixel_number=VGA_PERIOD_PIXEL_NUMS;			/* pixel numbers in one period of HSYNC */
	*line_number=VGA_PERIOD_LINE_NUMS;			/* line numbers in one period of VSYNC */
}	/* get_MT9V11X_period */

void MT9V11X_preview(image_sensor_exposure_window_struct *image_window, image_sensor_config_struct *sensor_config_data)
{	
	sensor_cap_state=KAL_FALSE;
	
#if defined(__MAIN_PCB_SUPPORT_DOUBLE_CAMERA__)  // add by hqing
	if ( mainCamera == 0)
		mainCamera_power_on();
	else
		secondCamera_power_on();

#endif

	write_cmos_sensor(0xF0, 0);					// Switch to Page0
	
	if(sensor_config_data->frame_rate==0x0F)		// MPEG4 Encode Mode
	{
		MPEG4_encode_mode=KAL_TRUE;
		
		/* config TG of ISP to match the setting of image sensor*/
		SET_TG_OUTPUT_CLK_DIVIDER(3);
		SET_CMOS_RISING_EDGE(0);
		SET_CMOS_FALLING_EDGE(2);
		ENABLE_CAMERA_PIXEL_CLKIN_ENABLE;
		SET_TG_PIXEL_CLK_DIVIDER(3);
		SET_CMOS_DATA_LATCH(2);

		dummy_pixels=0;
		dummy_lines=0;
	}
	else
	{
		MPEG4_encode_mode=KAL_FALSE;

		#if 0
		/* config TG of ISP to match the setting of image sensor*/
		SET_TG_OUTPUT_CLK_DIVIDER(1);
		SET_CMOS_RISING_EDGE(0);
		SET_CMOS_FALLING_EDGE(1);
		ENABLE_CAMERA_PIXEL_CLKIN_ENABLE;
		SET_TG_PIXEL_CLK_DIVIDER(1);
		SET_CMOS_DATA_LATCH(1);
		#else
		SET_TG_OUTPUT_CLK_DIVIDER(3);
		SET_CMOS_RISING_EDGE(0);
		SET_CMOS_FALLING_EDGE(2);
		ENABLE_CAMERA_PIXEL_CLKIN_ENABLE;
		SET_TG_PIXEL_CLK_DIVIDER(3);
		SET_CMOS_DATA_LATCH(2);
		#endif
		
        	dummy_pixels=0;
        	dummy_lines=0;
	}
	
	preview_pclk_division=((DRV_Reg32(ISP_TG_PHASE_COUNTER_REG)&0xF0)>>4)+1;

	switch (sensor_config_data->image_mirror)
	{
		case IMAGE_NORMAL:
			SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CrYCbY1);
			write_cmos_sensor(0x20,0x700);  // 0x0703, modify by wwz in 2008-11-17
		break;
		case IMAGE_H_MIRROR:
			SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CrYCbY1);
			write_cmos_sensor(0x20,0x701);
		break;
		case IMAGE_V_MIRROR:
			SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CrYCbY1);
			write_cmos_sensor(0x20,0x702);
		break;
		case IMAGE_HV_MIRROR:
			SET_CAMERA_INPUT_ORDER(INPUT_ORDER_CbYCrY1);
			write_cmos_sensor(0x20,0x703);  // 0x0700, modify by wwz in 2008-11-17
		break;
	}

	image_window->grab_start_x=IMAGE_SENSOR_VGA_INSERTED_PIXELS+start_grab_x_offset;
	image_window->grab_start_y=IMAGE_SENSOR_VGA_INSERTED_LINES+dummy_lines+start_grab_y_offset;
	image_window->exposure_window_width=IMAGE_SENSOR_VGA_WIDTH;
	image_window->exposure_window_height=IMAGE_SENSOR_VGA_HEIGHT-IMAGE_HEIGHT_OFFSET;
	
	//write_cmos_sensor(0x05, (IMAGE_SENSOR_VGA_HBLANKING+dummy_pixels));
	//write_cmos_sensor(0x06, (IMAGE_SENSOR_VGA_VBLANKING+dummy_lines));
//	write_cmos_sensor(0x09, exposure_lines);
//	write_cmos_sensor(0xC8, 0x800B);
}	/* MT9V11X_preview */

void MT9V11X_capture(image_sensor_exposure_window_struct *image_window, image_sensor_config_struct *sensor_config_data)
{    
    volatile kal_uint32 shutter=exposure_lines;
 
    
    sensor_cap_state=KAL_TRUE;
	
	if(MPEG4_encode_mode)
	    ASSERT(0);
	
	if(sensor_config_data->enable_shutter_tansfer==KAL_TRUE)
		shutter=sensor_config_data->capture_shutter;
		
	#ifdef OUTPUT_DEBUG_INFO
	sprintf(temp_buffer, "Begin of MT9V11X_capture");
	rmmi_write_to_uart((kal_uint8*) temp_buffer, strlen(temp_buffer), KAL_TRUE);
	sprintf(temp_buffer, "cap_shutter:%d, pre_shut:%d", shutter, exposure_lines);
	rmmi_write_to_uart((kal_uint8*) temp_buffer, strlen(temp_buffer), KAL_TRUE);
	#endif
	
	write_cmos_sensor(0xF0, 0x00);		//swithc to page 0
	shutter = read_cmos_sensor(0x09);
	
    if(sensor_config_data->frame_rate==0xF0)	// If WEBCAM mode.
    {
	SET_TG_OUTPUT_CLK_DIVIDER(1);		// 24Mhz/24MHz, Sync
	SET_CMOS_RISING_EDGE(0);
	SET_CMOS_FALLING_EDGE(1);
	ENABLE_CAMERA_PIXEL_CLKIN_ENABLE;		
	SET_TG_PIXEL_CLK_DIVIDER(1);
	SET_CMOS_DATA_LATCH(1);		
						
//	MAX_EXPOSURE_LINES = (kal_uint16)((PIXEL_CLK/MIN_FRAME_RATE)/(PV_PERIOD_PIXEL_NUMS+PV_dummy_pixels));
//	write_cmos_sensor(0x05, IMAGE_SENSOR_VGA_HBLANKING+dummy_pixels);
//	write_cmos_sensor(0x06, IMAGE_SENSOR_VGA_VBLANKING+dummy_lines);
			
	image_window->grab_start_x=IMAGE_SENSOR_VGA_INSERTED_PIXELS+start_grab_x_offset;
	image_window->grab_start_y=IMAGE_SENSOR_VGA_INSERTED_LINES+start_grab_y_offset;
	image_window->exposure_window_width=IMAGE_SENSOR_VGA_WIDTH-IMAGE_WIDTH_OFFSET;
	image_window->exposure_window_height=IMAGE_SENSOR_VGA_HEIGHT-IMAGE_HEIGHT_OFFSET;		
        
    }
    else if ((image_window->image_target_width<=IMAGE_SENSOR_VGA_WIDTH)&&
	     (image_window->image_target_height<=IMAGE_SENSOR_VGA_HEIGHT))
    {		/* Less than VGA Mode */
		if (image_window->digital_zoom_factor>=(ISP_DIGITAL_ZOOM_INTERVAL<<1))
		{
			SET_TG_OUTPUT_CLK_DIVIDER(3);		// 6/6MHz, Sync
			SET_CMOS_RISING_EDGE(0);