/*************************************************************************
* FUNCTION
* GC2355MIPI_SetShutter
*
* DESCRIPTION
* This function set e-shutter of GC2355MIPI to change exposure time.
*
* PARAMETERS
* iShutter : exposured lines
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void GC2355MIPI_set_shutter(kal_uint16 iShutter)
{
#if defined(MT6577)||defined(MT6589)
spin_lock(&gc2355mipi_drv_lock);
#endif
GC2355MIPI_sensor.shutter = iShutter;
#if defined(MT6577)||defined(MT6589)
spin_unlock(&gc2355mipi_drv_lock);
#endif
if (!iShutter) iShutter = 1; /* avoid 0 */
#ifdef GC2355MIPI_DRIVER_TRACE
SENSORDB("GC2355MIPI_set_shutter iShutter = %d \n",iShutter);
#endif
if(iShutter < 1) iShutter = 1;
if(iShutter > 16383) iShutter = 16383;//2^14
//Update Shutter
GC2355MIPI_write_cmos_sensor(0x04, (iShutter) & 0xFF);
GC2355MIPI_write_cmos_sensor(0x03, (iShutter >> 8) & 0x3F);
} /* Set_GC2355MIPI_Shutter */
/*************************************************************************
* FUNCTION
* GC2235_SetShutter
*
* DESCRIPTION
* This function set e-shutter of GC2235 to change exposure time.
*
* PARAMETERS
* iShutter : exposured lines
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void GC2235_set_shutter(kal_uint16 iShutter)
{
#if defined(MT6577)||defined(MT6589)
spin_lock(&gc2235_drv_lock);
#endif
GC2235_sensor.shutter = iShutter;
#if defined(MT6577)||defined(MT6589)
spin_unlock(&gc2235_drv_lock);
#endif
if (!iShutter) iShutter = 1; /* avoid 0 */
#ifdef GC2235_DRIVER_TRACE
SENSORDB("GC2235_set_shutter iShutter = %d \n",iShutter);
#endif
if(iShutter < 1) iShutter = 1;
if(iShutter > 8192) iShutter = 8192;//2^13
//Update Shutter
GC2235_write_cmos_sensor(0x04, (iShutter) & 0xFF);
GC2235_write_cmos_sensor(0x03, (iShutter >> 8) & 0x1F);
} /* Set_GC2235_Shutter */
/*************************************************************************
* FUNCTION
* GC2235MIPI_SetGain
*
* DESCRIPTION
* This function is to set global gain to sensor.
*
* PARAMETERS
* iGain : sensor global gain(base: 0x40)
*
* RETURNS
* the actually gain set to sensor.
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint16 GC2235MIPI_SetGain(kal_uint16 iGain)
{
kal_uint16 iReg,temp;
#ifdef GC2235MIPI_DRIVER_TRACE
SENSORDB("GC2235MIPI_SetGain iGain = %d \n",iGain);
#endif
iReg = iGain;
if(256> iReg)
{
//analogic gain
GC2235MIPI_write_cmos_sensor(0xb0, 0x40); // global gain
GC2235MIPI_write_cmos_sensor(0xb1, iReg);//only digital gain 12.13
}
else
{
//analogic gain
temp = 64*iReg/256;
GC2235MIPI_write_cmos_sensor(0xb0, temp); // global gain
GC2235MIPI_write_cmos_sensor(0xb1, 0xff);//only digital gain 12.13
}
return iGain;
}
UINT32 GC2235MIPIControl(MSDK_SCENARIO_ID_ENUM ScenarioId, MSDK_SENSOR_EXPOSURE_WINDOW_STRUCT *pImageWindow,
MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData)
{
#ifdef GC2235_DRIVER_TRACE
SENSORDB("GC2235MIPIControl ScenarioId = %d \n",ScenarioId);
#endif
switch (ScenarioId)
{
case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
GC2235MIPIPreview(pImageWindow, pSensorConfigData);
break;
case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
case MSDK_SCENARIO_ID_CAMERA_ZSD:
GC2235MIPICapture(pImageWindow, pSensorConfigData);
break;
default:
return ERROR_INVALID_SCENARIO_ID;
}
return ERROR_NONE;
} /* GC2235MIPIControl() */
UINT32 HI704YUVSensorSetting(FEATURE_ID iCmd, UINT32 iPara)
{
SENSORDB("[Enter]HI704YUVSensorSetting func:cmd = %d\n",iCmd);
switch (iCmd)
{
case FID_SCENE_MODE: //auto mode or night mode
if (iPara == SCENE_MODE_OFF)//auto mode
{
HI704_night_mode(FALSE);
}
else if (iPara == SCENE_MODE_NIGHTSCENE)//night mode
{
HI704_night_mode(TRUE);
}
break;
case FID_AWB_MODE:
HI704_set_param_wb(iPara);
break;
case FID_COLOR_EFFECT:
HI704_set_param_effect(iPara);
break;
case FID_AE_EV:
HI704_set_param_exposure(iPara);
break;
case FID_AE_FLICKER:
HI704_set_param_banding(iPara);
break;
case FID_ZOOM_FACTOR:
spin_lock(&hi704_yuv_drv_lock);
HI704_zoom_factor = iPara;
spin_unlock(&hi704_yuv_drv_lock);
break;
default:
break;
}
return TRUE;
} /* HI704YUVSensorSetting */
kal_uint16 GC2355MIPI_SetGain(kal_uint16 iGain)
{
kal_uint16 iReg,temp,temp1,luma_value;
#ifdef GC2355MIPI_DRIVER_TRACE
SENSORDB("GC2355MIPI_SetGain iGain = %d \n",iGain);
#endif
GC2355MIPI_write_cmos_sensor(0xb1, 0x01);
GC2355MIPI_write_cmos_sensor(0xb2, 0x00);
iReg = iGain;
if(iReg < 0x40)
iReg = 0x40;
if((ANALOG_GAIN_1<= iReg)&&(iReg < ANALOG_GAIN_2))
{
//analog gain
GC2355MIPI_write_cmos_sensor(0xb6, 0x00);//
temp = iReg;
GC2355MIPI_write_cmos_sensor(0xb1, temp>>6);
GC2355MIPI_write_cmos_sensor(0xb2, (temp<<2)&0xfc);
//SENSORDB("GC2355 analogic gain 1x , add pregain = %d\n",temp);
}
UINT32 GC2235GetInfo(MSDK_SCENARIO_ID_ENUM ScenarioId,
MSDK_SENSOR_INFO_STRUCT *pSensorInfo,
MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData)
{
SENSORDB("GC2235GetInfo\n");
pSensorInfo->SensorPreviewResolutionX=GC2235_IMAGE_SENSOR_PV_WIDTH;
pSensorInfo->SensorPreviewResolutionY=GC2235_IMAGE_SENSOR_PV_HEIGHT;
pSensorInfo->SensorFullResolutionX=GC2235_IMAGE_SENSOR_FULL_WIDTH;
pSensorInfo->SensorFullResolutionY=GC2235_IMAGE_SENSOR_FULL_HEIGHT;
pSensorInfo->SensorCameraPreviewFrameRate=30;
pSensorInfo->SensorVideoFrameRate=30;
pSensorInfo->SensorStillCaptureFrameRate=10;
pSensorInfo->SensorWebCamCaptureFrameRate=15;
pSensorInfo->SensorResetActiveHigh=TRUE; //low active
pSensorInfo->SensorResetDelayCount=5;
pSensorInfo->SensorOutputDataFormat=GC2235_COLOR_FORMAT;
pSensorInfo->SensorClockPolarity=SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorClockFallingPolarity=SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorHsyncPolarity = SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorVsyncPolarity = SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensroInterfaceType=SENSOR_INTERFACE_TYPE_PARALLEL;
pSensorInfo->CaptureDelayFrame = 2;
pSensorInfo->PreviewDelayFrame = 1;
pSensorInfo->VideoDelayFrame = 1;
pSensorInfo->SensorMasterClockSwitch = 0;
pSensorInfo->SensorDrivingCurrent = ISP_DRIVING_8MA;
pSensorInfo->AEShutDelayFrame =0; /* The frame of setting shutter default 0 for TG int */
pSensorInfo->AESensorGainDelayFrame = 0; /* The frame of setting sensor gain */
pSensorInfo->AEISPGainDelayFrame = 4;
switch (ScenarioId)
{
case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
pSensorInfo->SensorClockFreq=24;
pSensorInfo->SensorClockDividCount=3;
pSensorInfo->SensorClockRisingCount= 0;
pSensorInfo->SensorClockFallingCount= 2;
pSensorInfo->SensorPixelClockCount= 3;
pSensorInfo->SensorDataLatchCount= 2;
pSensorInfo->SensorGrabStartX = GC2235_PV_X_START;
pSensorInfo->SensorGrabStartY = GC2235_PV_Y_START;
break;
case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
pSensorInfo->SensorClockFreq=24;
pSensorInfo->SensorClockDividCount=3;
pSensorInfo->SensorClockRisingCount= 0;
pSensorInfo->SensorClockFallingCount= 2;
pSensorInfo->SensorPixelClockCount= 3;
pSensorInfo->SensorDataLatchCount= 2;
pSensorInfo->SensorGrabStartX = GC2235_VIDEO_X_START;
pSensorInfo->SensorGrabStartY = GC2235_VIDEO_Y_START;
break;
case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
case MSDK_SCENARIO_ID_CAMERA_ZSD:
pSensorInfo->SensorClockFreq=24;
pSensorInfo->SensorClockDividCount= 3;
pSensorInfo->SensorClockRisingCount=0;
pSensorInfo->SensorClockFallingCount=2;
pSensorInfo->SensorPixelClockCount=3;
pSensorInfo->SensorDataLatchCount=2;
pSensorInfo->SensorGrabStartX = GC2235_FULL_X_START;
pSensorInfo->SensorGrabStartY = GC2235_FULL_Y_START;
break;
default:
pSensorInfo->SensorClockFreq=24;
pSensorInfo->SensorClockDividCount=3;
pSensorInfo->SensorClockRisingCount=0;
pSensorInfo->SensorClockFallingCount=2;
pSensorInfo->SensorPixelClockCount=3;
pSensorInfo->SensorDataLatchCount=2;
pSensorInfo->SensorGrabStartX = GC2235_PV_X_START;
pSensorInfo->SensorGrabStartY = GC2235_PV_Y_START;
break;
}
memcpy(pSensorConfigData, &GC2235_sensor.cfg_data, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
return ERROR_NONE;
} /* GC2235GetInfo() */
static void HI704_Fix_Video_Frame_Rate(kal_uint16 fix_framerate)
{
kal_uint32 HI704_expfix;
kal_uint32 HI704_expfix_temp;
kal_uint32 HI704_expmax;
kal_uint32 HI704_expbanding;
SENSORDB("[Enter]HI704 Fix_video_frame_rate func: fix_fps=%d\n",fix_framerate);
HI704_sensor.video_current_frame_rate = fix_framerate;
// Fixed Framerate
HI704_write_cmos_sensor(0x01, HI704_read_cmos_sensor(0x01)|0x01); //Sleep: For Write Reg
HI704_write_cmos_sensor(0x03, 0x00);
HI704_write_cmos_sensor(0x11, HI704_read_cmos_sensor(0x11)|0x04);
HI704_write_cmos_sensor(0x03, 0x20);
HI704_write_cmos_sensor(0x10, HI704_read_cmos_sensor(0x10)&0x7f); //Close AE
HI704_write_cmos_sensor(0x11, 0x00);
HI704_write_cmos_sensor(0x18, HI704_read_cmos_sensor(0x18)|0x08); //Reset AE
HI704_write_cmos_sensor(0x2a, 0x00);
HI704_write_cmos_sensor(0x2b, 0x35);
HI704_write_cmos_sensor(0x03, 0x00);
HI704_sensor.pv_dummy_pixels = ((HI704_read_cmos_sensor(0x40)<<8)|HI704_read_cmos_sensor(0x41));
HI704_sensor.pv_line_length = HI704_VGA_DEFAULT_PIXEL_NUMS + HI704_sensor.pv_dummy_pixels ;
HI704_sensor.pv_dummy_lines = ((HI704_read_cmos_sensor(0x42)<<8)|HI704_read_cmos_sensor(0x43));
HI704_expfix_temp = ((HI704_sensor.pv_pclk*10/fix_framerate)-(HI704_sensor.pv_line_length*HI704_sensor.pv_dummy_lines))/8;
HI704_expfix = ((HI704_expfix_temp*8/HI704_sensor.pv_line_length)*HI704_sensor.pv_line_length)/8;
HI704_write_cmos_sensor(0x03, 0x20);
//HI704_write_cmos_sensor(0x83, (HI704_expfix>>16)&0xff);
//HI704_write_cmos_sensor(0x84, (HI704_expfix>>8)&0xff);
//HI704_write_cmos_sensor(0x85, (HI704_expfix>>0)&0xff);
HI704_write_cmos_sensor(0x91, (HI704_expfix>>16)&0xff);
HI704_write_cmos_sensor(0x92, (HI704_expfix>>8)&0xff);
HI704_write_cmos_sensor(0x93, (HI704_expfix>>0)&0xff);
if(HI704_sensor.banding == AE_FLICKER_MODE_50HZ)
{
HI704_expbanding = ((HI704_read_cmos_sensor(0x8b)<<8)|HI704_read_cmos_sensor(0x8c));
}
else if(HI704_sensor.banding == AE_FLICKER_MODE_60HZ)
{
HI704_expbanding = ((HI704_read_cmos_sensor(0x8d)<<8)|HI704_read_cmos_sensor(0x8e));
}
else
{
SENSORDB("[HI704]Wrong Banding Setting!!!...");
}
HI704_expmax = ((HI704_expfix_temp-HI704_expbanding)/HI704_expbanding)*HI704_expbanding;
HI704_write_cmos_sensor(0x03, 0x20);
HI704_write_cmos_sensor(0x88, (HI704_expmax>>16)&0xff);
HI704_write_cmos_sensor(0x89, (HI704_expmax>>8)&0xff);
HI704_write_cmos_sensor(0x8a, (HI704_expmax>>0)&0xff);
HI704_write_cmos_sensor(0x01, HI704_read_cmos_sensor(0x01)&0xfe); //Exit Sleep: For Write Reg
HI704_write_cmos_sensor(0x03, 0x20);
HI704_write_cmos_sensor(0x10, HI704_read_cmos_sensor(0x10)|0x80); //Open AE
HI704_write_cmos_sensor(0x18, HI704_read_cmos_sensor(0x18)&0xf7); //Reset AE
}
UINT32 MT9V114FeatureControl(MSDK_SENSOR_FEATURE_ENUM FeatureId,
UINT8 *pFeaturePara,UINT32 *pFeatureParaLen)
{
//UINT16 u2Temp = 0;
UINT16 *pFeatureReturnPara16=(UINT16 *) pFeaturePara;
UINT16 *pFeatureData16=(UINT16 *) pFeaturePara;
UINT32 *pFeatureReturnPara32=(UINT32 *) pFeaturePara;
UINT32 *pFeatureData32=(UINT32 *) pFeaturePara;
MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData=(MSDK_SENSOR_CONFIG_STRUCT *) pFeaturePara;
MSDK_SENSOR_REG_INFO_STRUCT *pSensorRegData=(MSDK_SENSOR_REG_INFO_STRUCT *) pFeaturePara;
switch (FeatureId)
{
case SENSOR_FEATURE_GET_RESOLUTION:
*pFeatureReturnPara16++=MT9V114_IMAGE_SENSOR_VGA_WIDTH;
*pFeatureReturnPara16=MT9V114_IMAGE_SENSOR_VGA_WIDTH;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_PERIOD:
*pFeatureReturnPara16++=MT9V114_IMAGE_SENSOR_VGA_WIDTH;
*pFeatureReturnPara16=MT9V114_IMAGE_SENSOR_VGA_WIDTH;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_PIXEL_CLOCK_FREQ:
//*pFeatureReturnPara32 = MT9V114_sensor_pclk/10;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_SET_ESHUTTER:
break;
case SENSOR_FEATURE_SET_NIGHTMODE:
MT9V114_night_mode((BOOL) *pFeatureData16);
break;
case SENSOR_FEATURE_SET_GAIN:
break;
case SENSOR_FEATURE_SET_FLASHLIGHT:
break;
case SENSOR_FEATURE_SET_ISP_MASTER_CLOCK_FREQ:
break;
case SENSOR_FEATURE_SET_REGISTER:
MT9V114_write_cmos_sensor(pSensorRegData->RegAddr, pSensorRegData->RegData);
break;
case SENSOR_FEATURE_GET_REGISTER:
pSensorRegData->RegData = MT9V114_read_cmos_sensor(pSensorRegData->RegAddr);
break;
case SENSOR_FEATURE_GET_CONFIG_PARA:
memcpy(pSensorConfigData, &MT9V114SensorConfigData, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
*pFeatureParaLen=sizeof(MSDK_SENSOR_CONFIG_STRUCT);
break;
case SENSOR_FEATURE_SET_CCT_REGISTER:
case SENSOR_FEATURE_GET_CCT_REGISTER:
case SENSOR_FEATURE_SET_ENG_REGISTER:
case SENSOR_FEATURE_GET_ENG_REGISTER:
case SENSOR_FEATURE_GET_REGISTER_DEFAULT:
case SENSOR_FEATURE_CAMERA_PARA_TO_SENSOR:
case SENSOR_FEATURE_SENSOR_TO_CAMERA_PARA:
case SENSOR_FEATURE_GET_GROUP_INFO:
case SENSOR_FEATURE_GET_ITEM_INFO:
case SENSOR_FEATURE_SET_ITEM_INFO:
case SENSOR_FEATURE_GET_ENG_INFO:
break;
case SENSOR_FEATURE_GET_GROUP_COUNT:
// *pFeatureReturnPara32++=0;
//*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_LENS_DRIVER_ID:
// get the lens driver ID from EEPROM or just return LENS_DRIVER_ID_DO_NOT_CARE
// if EEPROM does not exist in camera module.
*pFeatureReturnPara32=LENS_DRIVER_ID_DO_NOT_CARE;
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_SET_YUV_CMD:
MT9V114YUVSensorSetting((FEATURE_ID)*pFeatureData32, *(pFeatureData32+1));
break;
case SENSOR_FEATURE_SET_VIDEO_MODE:
MT9V114YUVSetVideoMode(*pFeatureData16);
break;
case SENSOR_FEATURE_CHECK_SENSOR_ID:
MT9V114GetSensorID(pFeatureReturnPara32);
break;
case SENSOR_FEATURE_GET_AF_MAX_NUM_FOCUS_AREAS:
MT9V114GetAFMaxNumFocusAreas(pFeatureReturnPara32);
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_AE_MAX_NUM_METERING_AREAS:
MT9V114GetAFMaxNumMeteringAreas(pFeatureReturnPara32);
*pFeatureParaLen=4;
break;
case SENSOR_FEATURE_GET_EXIF_INFO:
SENSORDB("SENSOR_FEATURE_GET_EXIF_INFO\n");
SENSORDB("EXIF addr = 0x%x\n",*pFeatureData32);
MT9V114GetExifInfo(*pFeatureData32);
break;
default:
break;
}
return ERROR_NONE;
} /* MT9V114FeatureControl() */
UINT32 MT9V114GetInfo(MSDK_SCENARIO_ID_ENUM ScenarioId,
MSDK_SENSOR_INFO_STRUCT *pSensorInfo,
MSDK_SENSOR_CONFIG_STRUCT *pSensorConfigData)
{
SENSORDB("[Enter]:MT9V114 getInfo func:ScenarioId = %d\n",ScenarioId);
pSensorInfo->SensorPreviewResolutionX=MT9V114_IMAGE_SENSOR_VGA_WIDTH;
pSensorInfo->SensorPreviewResolutionY=MT9V114_IMAGE_SENSOR_VGA_HEIGHT;
pSensorInfo->SensorFullResolutionX=MT9V114_IMAGE_SENSOR_VGA_WIDTH;
pSensorInfo->SensorFullResolutionY=MT9V114_IMAGE_SENSOR_VGA_HEIGHT;
pSensorInfo->SensorCameraPreviewFrameRate=30;
pSensorInfo->SensorVideoFrameRate=30;
pSensorInfo->SensorStillCaptureFrameRate=30;
pSensorInfo->SensorWebCamCaptureFrameRate=15;
pSensorInfo->SensorResetActiveHigh=FALSE;//low is to reset
pSensorInfo->SensorResetDelayCount=4; //4ms
pSensorInfo->SensorOutputDataFormat=SENSOR_OUTPUT_FORMAT_YUYV;
pSensorInfo->SensorClockPolarity=SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorClockFallingPolarity=SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorHsyncPolarity = SENSOR_CLOCK_POLARITY_LOW;
pSensorInfo->SensorVsyncPolarity = SENSOR_CLOCK_POLARITY_HIGH;
pSensorInfo->SensorInterruptDelayLines = 1;
pSensorInfo->SensroInterfaceType=SENSOR_INTERFACE_TYPE_PARALLEL;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_100_MODE].MaxWidth=CAM_SIZE_VGA_WIDTH; //???
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_100_MODE].MaxHeight=CAM_SIZE_VGA_HEIGHT;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_100_MODE].ISOSupported=TRUE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_100_MODE].BinningEnable=FALSE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_200_MODE].MaxWidth=CAM_SIZE_VGA_WIDTH;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_200_MODE].MaxHeight=CAM_SIZE_VGA_HEIGHT;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_200_MODE].ISOSupported=TRUE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_200_MODE].BinningEnable=FALSE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_400_MODE].MaxWidth=CAM_SIZE_VGA_WIDTH;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_400_MODE].MaxHeight=CAM_SIZE_VGA_HEIGHT;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_400_MODE].ISOSupported=TRUE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_400_MODE].BinningEnable=FALSE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_800_MODE].MaxWidth=CAM_SIZE_VGA_WIDTH;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_800_MODE].MaxHeight=CAM_SIZE_VGA_HEIGHT;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_800_MODE].ISOSupported=TRUE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_800_MODE].BinningEnable=TRUE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_1600_MODE].MaxWidth=CAM_SIZE_VGA_WIDTH;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_1600_MODE].MaxHeight=CAM_SIZE_VGA_HEIGHT;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_1600_MODE].ISOSupported=TRUE;
pSensorInfo->SensorISOBinningInfo.ISOBinningInfo[ISO_1600_MODE].BinningEnable=TRUE;
pSensorInfo->CaptureDelayFrame = 4;
pSensorInfo->PreviewDelayFrame = 4;
pSensorInfo->VideoDelayFrame = 4;
pSensorInfo->SensorMasterClockSwitch = 0;
pSensorInfo->SensorDrivingCurrent = ISP_DRIVING_8MA;
switch (ScenarioId)
{
case MSDK_SCENARIO_ID_CAMERA_PREVIEW:
case MSDK_SCENARIO_ID_VIDEO_PREVIEW:
case MSDK_SCENARIO_ID_VIDEO_CAPTURE_MPEG4:
pSensorInfo->SensorClockFreq=24;
pSensorInfo->SensorClockDividCount= 3;
pSensorInfo->SensorClockRisingCount= 0;
pSensorInfo->SensorClockFallingCount= 2;
pSensorInfo->SensorPixelClockCount= 3;
pSensorInfo->SensorDataLatchCount= 2;
pSensorInfo->SensorGrabStartX = 4;
pSensorInfo->SensorGrabStartY =2;
break;
case MSDK_SCENARIO_ID_CAMERA_CAPTURE_JPEG:
case MSDK_SCENARIO_ID_CAMERA_CAPTURE_MEM:
pSensorInfo->SensorClockFreq=24;
pSensorInfo->SensorClockDividCount= 3;
pSensorInfo->SensorClockRisingCount= 0;
pSensorInfo->SensorClockFallingCount= 2;
pSensorInfo->SensorPixelClockCount= 3;
pSensorInfo->SensorDataLatchCount= 2;
pSensorInfo->SensorGrabStartX = 4;
pSensorInfo->SensorGrabStartY = 2;
break;
default:
pSensorInfo->SensorClockFreq=24;
pSensorInfo->SensorClockDividCount=3;
pSensorInfo->SensorClockRisingCount=0;
pSensorInfo->SensorClockFallingCount=2;
pSensorInfo->SensorPixelClockCount=3;
pSensorInfo->SensorDataLatchCount=2;
pSensorInfo->SensorGrabStartX = 4;
pSensorInfo->SensorGrabStartY = 2;
break;
}
// MT9V114_PixelClockDivider=pSensorInfo->SensorPixelClockCount;
memcpy(pSensorConfigData, &MT9V114SensorConfigData, sizeof(MSDK_SENSOR_CONFIG_STRUCT));
SENSORDB("[Exit]:MT9V114 getInfo func\n");
return ERROR_NONE;
} /* MT9V114GetInfo() */
/*************************************************************************
* FUNCTION
* MT9V114_set_param_effect
*
* DESCRIPTION
* effect setting.
*
* PARAMETERS
* none
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
BOOL MT9V114_set_param_effect(UINT16 para)
{
if(MT9V114CurrentStatus.iEffect == para)
return TRUE;
SENSORDB("[Enter]MT9V114 set_param_effect func:para = %d\n",para);
switch (para)
{
case MEFFECT_OFF:
MT9V114_write_cmos_sensor(0x098E, 0xA010);
// MT9V114_write_cmos_sensor(0x8400, 0x0101);
MT9V114_write_cmos_sensor(0xA010, 0x0041);
// MT9V114_write_cmos_sensor(0x8400, 0x0202);
Sleep(10);
break;
case MEFFECT_NEGATIVE:
MT9V114_write_cmos_sensor(0x098E, 0xA010);
// MT9V114_write_cmos_sensor(0x8400, 0x0101);
MT9V114_write_cmos_sensor(0xA010, 0x0341);
MT9V114_write_cmos_sensor(0xA012, 0x3F00);
// MT9V114_write_cmos_sensor(0x8400, 0x0202);
Sleep(10);
break;
case MEFFECT_SEPIA:
MT9V114_write_cmos_sensor(0x098E, 0xA010);
// MT9V114_write_cmos_sensor(0x8400, 0x0101);
MT9V114_write_cmos_sensor(0xA010, 0x0241);
MT9V114_write_cmos_sensor(0xA012, 0x1ED8);
// MT9V114_write_cmos_sensor(0x8400, 0x0202);
Sleep(10);
break;
case MEFFECT_SEPIAGREEN:
MT9V114_write_cmos_sensor(0x098E, 0xA010);
// MT9V114_write_cmos_sensor(0x8400, 0x0101);
MT9V114_write_cmos_sensor(0xA010, 0x0241);
MT9V114_write_cmos_sensor(0xA012, 0xDFC0);
// MT9V114_write_cmos_sensor(0x8400, 0x0202);
Sleep(10);
break;
case MEFFECT_SEPIABLUE:
MT9V114_write_cmos_sensor(0x098E, 0xA010);
// MT9V114_write_cmos_sensor(0x8400, 0x0101);
MT9V114_write_cmos_sensor(0xA010, 0x0241);
MT9V114_write_cmos_sensor(0xA012, 0x003F);
// MT9V114_write_cmos_sensor(0x8400, 0x0202);
Sleep(10);
break;
case MEFFECT_MONO:
MT9V114_write_cmos_sensor(0x098E, 0xA010);
// MT9V114_write_cmos_sensor(0x8400, 0x0101);
MT9V114_write_cmos_sensor(0xA010, 0x0141);
//MT9V114_write_cmos_sensor(0x8400, 0x0202);
Sleep(10);
break;
default:
return FALSE;
}
spin_lock(&mt9v114yuv_drv_lock);
MT9V114CurrentStatus.iEffect = para;
spin_unlock(&mt9v114yuv_drv_lock);
return TRUE;
} /* MT9V114_set_param_effect */
void MT9V114GetAFMaxNumMeteringAreas(UINT32 *pFeatureReturnPara32)
{
*pFeatureReturnPara32 = 0;
SENSORDB(" MT9V114GetAFMaxNumMeteringAreas,*pFeatureReturnPara32 = %d\n", *pFeatureReturnPara32);
}
inline static void GC2235MIPI_get_sensor_item_info(MSDK_SENSOR_ITEM_INFO_STRUCT *para)
{
const static kal_char *cct_item_name[] = {"SENSOR_BASEGAIN", "Pregain-R", "Pregain-Gr", "Pregain-Gb", "Pregain-B"};
const static kal_char *editer_item_name[] = {"REG addr", "REG value"};
#ifdef GC2235MIPI_DRIVER_TRACE
SENSORDB("GC2235MIPI_get_sensor_item_info\n");
#endif
switch (para->GroupIdx)
{
case GC2235MIPI_PRE_GAIN:
switch (para->ItemIdx)
{
case GC2235MIPI_SENSOR_BASEGAIN:
case GC2235MIPI_PRE_GAIN_R_INDEX:
case GC2235MIPI_PRE_GAIN_Gr_INDEX:
case GC2235MIPI_PRE_GAIN_Gb_INDEX:
case GC2235MIPI_PRE_GAIN_B_INDEX:
break;
default:
ASSERT(0);
}
sprintf(para->ItemNamePtr, cct_item_name[para->ItemIdx - GC2235MIPI_SENSOR_BASEGAIN]);
para->ItemValue = GC2235MIPI_sensor.eng.cct[para->ItemIdx].Para * 1000 / BASEGAIN;
para->IsTrueFalse = para->IsReadOnly = para->IsNeedRestart = KAL_FALSE;
para->Min = GC2235MIPI_MIN_ANALOG_GAIN * 1000;
para->Max = GC2235MIPI_MAX_ANALOG_GAIN * 1000;
break;
case GC2235MIPI_CMMCLK_CURRENT:
switch (para->ItemIdx)
{
case 0:
sprintf(para->ItemNamePtr, "Drv Cur[2,4,6,8]mA");
switch (GC2235MIPI_sensor.eng.reg[GC2235MIPI_CMMCLK_CURRENT_INDEX].Para)
{
case ISP_DRIVING_2MA:
para->ItemValue = 2;
break;
case ISP_DRIVING_4MA:
para->ItemValue = 4;
break;
case ISP_DRIVING_6MA:
para->ItemValue = 6;
break;
case ISP_DRIVING_8MA:
para->ItemValue = 8;
break;
default:
ASSERT(0);
}
para->IsTrueFalse = para->IsReadOnly = KAL_FALSE;
para->IsNeedRestart = KAL_TRUE;
para->Min = 2;
para->Max = 8;
break;
default:
ASSERT(0);
}
break;
case GC2235MIPI_FRAME_RATE_LIMITATION:
switch (para->ItemIdx)
{
case 0:
sprintf(para->ItemNamePtr, "Max Exposure Lines");
para->ItemValue = 5998;
break;
case 1:
sprintf(para->ItemNamePtr, "Min Frame Rate");
para->ItemValue = 5;
break;
default:
ASSERT(0);
}
para->IsTrueFalse = para->IsNeedRestart = KAL_FALSE;
para->IsReadOnly = KAL_TRUE;
para->Min = para->Max = 0;
break;
case GC2235MIPI_REGISTER_EDITOR:
switch (para->ItemIdx)
{
case 0:
case 1:
sprintf(para->ItemNamePtr, editer_item_name[para->ItemIdx]);
para->ItemValue = 0;
para->IsTrueFalse = para->IsReadOnly = para->IsNeedRestart = KAL_FALSE;
para->Min = 0;
para->Max = (para->ItemIdx == 0 ? 0xFFFF : 0xFF);
break;
default:
ASSERT(0);
}
break;
default:
ASSERT(0);
}
}
/*************************************************************************
* FUNCTION
* MT9V114_set_param_wb
*
* DESCRIPTION
* wb setting.
*
* PARAMETERS
* none
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
BOOL MT9V114_set_param_wb(UINT16 para)
{
if(MT9V114CurrentStatus.iWB == para)
return TRUE;
//This sensor need more time to balance AWB,
//we suggest higher fps or drop some frame to avoid garbage color when preview initial
SENSORDB("[Enter]MT9V114 set_param_wb func:para = %d\n",para);
switch (para)
{
case AWB_MODE_OFF:
spin_lock(&mt9v114yuv_drv_lock);
MT9V114_AWB_ENABLE = KAL_FALSE;
spin_unlock(&mt9v114yuv_drv_lock);
MT9V114_set_AWB_mode(MT9V114_AWB_ENABLE);
SENSORDB(" AWB_MODE_OFF\n");
break;
case AWB_MODE_AUTO:
spin_lock(&mt9v114yuv_drv_lock);
MT9V114_AWB_ENABLE = KAL_TRUE;
spin_unlock(&mt9v114yuv_drv_lock);
MT9V114_set_AWB_mode(MT9V114_AWB_ENABLE);
SENSORDB(" AWB_MODE_AUTO\n");
MT9V114_write_cmos_sensor(0x098E, 0x9401); // MCU_ADDRESS [AWB_MODE]
MT9V114_write_cmos_sensor(0x9401, 0x0d00); // MCU_DATA_0
MT9V114_write_cmos_sensor(0x9406, 0x007F);
break;
case AWB_MODE_CLOUDY_DAYLIGHT:
MT9V114_write_cmos_sensor(0x098E, 0x9401); // MCU_ADDRESS [AWB_MODE]
MT9V114_write_cmos_sensor(0x9401, 0x0C00); // MCU_DATA_0
MT9V114_write_cmos_sensor(0x9406, 0x7F7F);
//MT9V114_write_cmos_sensor(0x8400, 0x0500); //kevinwang@20100713
MT9V114_write_cmos_sensor(0x9436, 0x3D47);
break;
case AWB_MODE_DAYLIGHT:
MT9V114_write_cmos_sensor(0x098E, 0x9401); // MCU_ADDRESS [AWB_MODE]
MT9V114_write_cmos_sensor(0x9401, 0x0C00); // MCU_DATA_0
MT9V114_write_cmos_sensor(0x9406, 0x7474);
//MT9V114_write_cmos_sensor(0x8400, 0x0500); //kevinwang@20100713
MT9V114_write_cmos_sensor(0x9436, 0x4144);
break;
case AWB_MODE_INCANDESCENT:
MT9V114_write_cmos_sensor(0x098E, 0x9401); // MCU_ADDRESS [AWB_MODE]
MT9V114_write_cmos_sensor(0x9401, 0x0C00); // MCU_DATA_0
MT9V114_write_cmos_sensor(0x9406, 0x1010);
//MT9V114_write_cmos_sensor(0x8400, 0x0500); // kevinwang@20100713
MT9V114_write_cmos_sensor(0x9436, 0x552A);
break;
case AWB_MODE_FLUORESCENT:
MT9V114_write_cmos_sensor(0x098E, 0x9401); // MCU_ADDRESS [AWB_MODE]
MT9V114_write_cmos_sensor(0x9401, 0x0C00); // MCU_DATA_0
MT9V114_write_cmos_sensor(0x9406, 0x3a3a);
//MT9V114_write_cmos_sensor(0x8400, 0x0500); //kevinwang@20100713
MT9V114_write_cmos_sensor(0x9436, 0x4c31);
break;
case AWB_MODE_TUNGSTEN:
MT9V114_write_cmos_sensor(0x098E, 0x9401); // MCU_ADDRESS [AWB_MODE]
MT9V114_write_cmos_sensor(0x9401, 0x0C00); // MCU_DATA_0
MT9V114_write_cmos_sensor(0x9406, 0x4444);
//MT9V114_write_cmos_sensor(0x8400, 0x0500); //kevinwang@20100713
MT9V114_write_cmos_sensor(0x9436, 0x4F33);
break;
default:
return FALSE;
}
spin_lock(&mt9v114yuv_drv_lock);
MT9V114CurrentStatus.iWB = para;
spin_unlock(&mt9v114yuv_drv_lock);
return TRUE;
} /* MT9V114_set_param_wb */
/*************************************************************************
* FUNCTION
* HI704_set_param_wb
*
* DESCRIPTION
* wb setting.
*
* PARAMETERS
* none
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
BOOL HI704_set_param_wb(UINT16 para)
{
//This sensor need more time to balance AWB,
//we suggest higher fps or drop some frame to avoid garbage color when preview initial
SENSORDB("[Enter]HI704 set_param_wb func:para = %d\n",para);
if(HI704_sensor.wb == para) return KAL_TRUE;
spin_lock(&hi704_yuv_drv_lock);
HI704_sensor.wb = para;
spin_unlock(&hi704_yuv_drv_lock);
switch (para)
{
case AWB_MODE_AUTO:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x2e);
//HI704_write_cmos_sensor(0x80, 0x38);
//HI704_write_cmos_sensor(0x82, 0x38);
#ifdef HQ_PROJECT_A61P_HUAWEI
HI704_write_cmos_sensor(0x83, 0x56);
#else
HI704_write_cmos_sensor(0x83, 0x5e);
#endif
HI704_write_cmos_sensor(0x84, 0x15); //0x1e_20120214
#ifdef HQ_PROJECT_A61P_HUAWEI
HI704_write_cmos_sensor(0x85, 0x5e); //0x52_20120214
#else
HI704_write_cmos_sensor(0x85, 0x4f); //0x52_20120214
#endif
HI704_write_cmos_sensor(0x86, 0x1c);
}
break;
case AWB_MODE_CLOUDY_DAYLIGHT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x4a);//71
HI704_write_cmos_sensor(0x82, 0x2a);//2b
HI704_write_cmos_sensor(0x83, 0x4c);//72
HI704_write_cmos_sensor(0x84, 0x4a);//70
HI704_write_cmos_sensor(0x85, 0x2a);//2b
HI704_write_cmos_sensor(0x86, 0x28);
}
break;
case AWB_MODE_DAYLIGHT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x59);
HI704_write_cmos_sensor(0x82, 0x29);
HI704_write_cmos_sensor(0x83, 0x60);
HI704_write_cmos_sensor(0x84, 0x50);
HI704_write_cmos_sensor(0x85, 0x2f);
HI704_write_cmos_sensor(0x86, 0x23);
}
break;
case AWB_MODE_INCANDESCENT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x29);
HI704_write_cmos_sensor(0x82, 0x54);
HI704_write_cmos_sensor(0x83, 0x2e);
HI704_write_cmos_sensor(0x84, 0x23);
HI704_write_cmos_sensor(0x85, 0x58);
HI704_write_cmos_sensor(0x86, 0x4f);
}
break;
case AWB_MODE_FLUORESCENT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x41);
HI704_write_cmos_sensor(0x82, 0x42);
HI704_write_cmos_sensor(0x83, 0x44);
HI704_write_cmos_sensor(0x84, 0x34);
HI704_write_cmos_sensor(0x85, 0x46);
HI704_write_cmos_sensor(0x86, 0x3a);
}
break;
case AWB_MODE_TUNGSTEN:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x80, 0x24);
HI704_write_cmos_sensor(0x81, 0x20);
HI704_write_cmos_sensor(0x82, 0x58);
HI704_write_cmos_sensor(0x83, 0x27);
HI704_write_cmos_sensor(0x84, 0x22);
HI704_write_cmos_sensor(0x85, 0x58);
HI704_write_cmos_sensor(0x86, 0x52);
}
break;
default:
return FALSE;
}
return TRUE;
} /* HI704_set_param_wb */
/*************************************************************************
* FUNCTION
* HI704_set_param_effect
*
* DESCRIPTION
* effect setting.
*
* PARAMETERS
* none
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
BOOL HI704_set_param_effect(UINT16 para)
{
SENSORDB("[Enter]HI704 set_param_effect func:para = %d\n",para);
if(HI704_sensor.effect == para) return KAL_TRUE;
spin_lock(&hi704_yuv_drv_lock);
HI704_sensor.effect = para;
spin_unlock(&hi704_yuv_drv_lock);
switch (para)
{
case MEFFECT_OFF:
{
HI704_write_cmos_sensor(0x03, 0x10);
HI704_write_cmos_sensor(0x11, 0x03);
HI704_write_cmos_sensor(0x12, 0x30);
HI704_write_cmos_sensor(0x13, 0x00);
HI704_write_cmos_sensor(0x44, 0x80);
HI704_write_cmos_sensor(0x45, 0x80);
HI704_write_cmos_sensor(0x47, 0x7f);
HI704_write_cmos_sensor(0x03, 0x13);
HI704_write_cmos_sensor(0x20, 0x07);
HI704_write_cmos_sensor(0x21, 0x07);
}
break;
case MEFFECT_SEPIA:
{
HI704_write_cmos_sensor(0x03, 0x10);
HI704_write_cmos_sensor(0x11, 0x03);
HI704_write_cmos_sensor(0x12, 0x23);
HI704_write_cmos_sensor(0x13, 0x00);
HI704_write_cmos_sensor(0x44, 0x70);
HI704_write_cmos_sensor(0x45, 0x98);
HI704_write_cmos_sensor(0x47, 0x7f);
HI704_write_cmos_sensor(0x03, 0x13);
HI704_write_cmos_sensor(0x20, 0x07);
HI704_write_cmos_sensor(0x21, 0x07);
}
break;
case MEFFECT_NEGATIVE:
{
HI704_write_cmos_sensor(0x03, 0x10);
HI704_write_cmos_sensor(0x11, 0x03);
HI704_write_cmos_sensor(0x12, 0x08);
HI704_write_cmos_sensor(0x13, 0x00);
HI704_write_cmos_sensor(0x14, 0x00);
}
break;
case MEFFECT_SEPIAGREEN:
{
HI704_write_cmos_sensor(0x03, 0x10);
HI704_write_cmos_sensor(0x11, 0x03);
HI704_write_cmos_sensor(0x12, 0x03);
HI704_write_cmos_sensor(0x40, 0x00);
HI704_write_cmos_sensor(0x13, 0x00);
HI704_write_cmos_sensor(0x44, 0x30);
HI704_write_cmos_sensor(0x45, 0x50);
}
break;
case MEFFECT_SEPIABLUE:
{
HI704_write_cmos_sensor(0x03, 0x10);
HI704_write_cmos_sensor(0x11, 0x03);
HI704_write_cmos_sensor(0x12, 0x03);
HI704_write_cmos_sensor(0x40, 0x00);
HI704_write_cmos_sensor(0x13, 0x00);
HI704_write_cmos_sensor(0x44, 0xb0);
HI704_write_cmos_sensor(0x45, 0x40);
}
break;
case MEFFECT_MONO:
{
HI704_write_cmos_sensor(0x03, 0x10);
HI704_write_cmos_sensor(0x11, 0x03);
HI704_write_cmos_sensor(0x12, 0x03);
HI704_write_cmos_sensor(0x40, 0x00);
HI704_write_cmos_sensor(0x44, 0x80);
HI704_write_cmos_sensor(0x45, 0x80);
}
break;
default:
return KAL_FALSE;
}
return KAL_TRUE;
} /* HI704_set_param_effect */
static void GC2235_Sensor_Init(void)
{
/////////////////////////////////////////////////////
////////////////////// SYS //////////////////////
/////////////////////////////////////////////////////
GC2235_write_cmos_sensor(0xfe, 0x80);
GC2235_write_cmos_sensor(0xfe, 0x80);
GC2235_write_cmos_sensor(0xfe, 0x80);
GC2235_write_cmos_sensor(0xf2, 0x00);
GC2235_write_cmos_sensor(0xf6, 0x00);
GC2235_write_cmos_sensor(0xfc, 0x06);
GC2235_write_cmos_sensor(0xf7, 0x15); //pll enable
GC2235_write_cmos_sensor(0xf8, 0x83); //Pll mode 2
GC2235_write_cmos_sensor(0xf9, 0xfe); //[0] pll enable
GC2235_write_cmos_sensor(0xfa, 0x00); //div
GC2235_write_cmos_sensor(0xfe, 0x00);
/////////////////////////////////////////////////////
//////////////// ANALOG & CISCTL ////////////////
/////////////////////////////////////////////////////
GC2235_write_cmos_sensor(0x03, 0x0a);
GC2235_write_cmos_sensor(0x04, 0xec);
GC2235_write_cmos_sensor(0x05, 0x00);
GC2235_write_cmos_sensor(0x06, 0xd0);
GC2235_write_cmos_sensor(0x07, 0x00);
GC2235_write_cmos_sensor(0x08, 0x1a);
GC2235_write_cmos_sensor(0x0a, 0x02);
GC2235_write_cmos_sensor(0x0c, 0x00);
GC2235_write_cmos_sensor(0x0d, 0x04);
GC2235_write_cmos_sensor(0x0e, 0xd0);
GC2235_write_cmos_sensor(0x0f, 0x06);
GC2235_write_cmos_sensor(0x10, 0x50);
GC2235_write_cmos_sensor(0x17, 0x15);//14 //[0]mirror [1]flip
GC2235_write_cmos_sensor(0x18, 0x12); // 0x1e
GC2235_write_cmos_sensor(0x19, 0x06);
GC2235_write_cmos_sensor(0x1a, 0x01);
GC2235_write_cmos_sensor(0x1b, 0x48);
GC2235_write_cmos_sensor(0x1e, 0x88);
GC2235_write_cmos_sensor(0x1f, 0x48);
GC2235_write_cmos_sensor(0x20, 0x03);
GC2235_write_cmos_sensor(0x21, 0x6f);
GC2235_write_cmos_sensor(0x22, 0x80);
GC2235_write_cmos_sensor(0x23, 0xc1);
GC2235_write_cmos_sensor(0x24, 0x2f); //0x2f
GC2235_write_cmos_sensor(0x26, 0x01);
GC2235_write_cmos_sensor(0x27, 0x30);
GC2235_write_cmos_sensor(0x3f, 0x00);
/////////////////////////////////////////////////////
////////////////////// ISP //////////////////////
/////////////////////////////////////////////////////
GC2235_write_cmos_sensor(0x8b, 0xa0);
GC2235_write_cmos_sensor(0x8c, 0x02);
GC2235_write_cmos_sensor(0x90, 0x01);
GC2235_write_cmos_sensor(0x92, 0x02);
GC2235_write_cmos_sensor(0x94, 0x06);
GC2235_write_cmos_sensor(0x95, 0x04);
GC2235_write_cmos_sensor(0x96, 0xb0);
GC2235_write_cmos_sensor(0x97, 0x06);
GC2235_write_cmos_sensor(0x98, 0x40);
/////////////////////////////////////////////////////
////////////////////// BLK //////////////////////
/////////////////////////////////////////////////////
GC2235_write_cmos_sensor(0x40, 0x72); //smooth speed
GC2235_write_cmos_sensor(0x41, 0x04);
GC2235_write_cmos_sensor(0x5e, 0x00);
GC2235_write_cmos_sensor(0x5f, 0x00);
GC2235_write_cmos_sensor(0x60, 0x00);
GC2235_write_cmos_sensor(0x61, 0x00);
GC2235_write_cmos_sensor(0x62, 0x00);
GC2235_write_cmos_sensor(0x63, 0x00);
GC2235_write_cmos_sensor(0x64, 0x00);
GC2235_write_cmos_sensor(0x65, 0x00);
GC2235_write_cmos_sensor(0x66, 0x20);
GC2235_write_cmos_sensor(0x67, 0x20);
GC2235_write_cmos_sensor(0x68, 0x20);
GC2235_write_cmos_sensor(0x69, 0x20);
Sleep(100);
/////////////////////////////////////////////////////
////////////////////// GAIN /////////////////////
/////////////////////////////////////////////////////
GC2235_write_cmos_sensor(0xb2, 0x00);
GC2235_write_cmos_sensor(0xb3, 0x40);
GC2235_write_cmos_sensor(0xb4, 0x40);
GC2235_write_cmos_sensor(0xb5, 0x40);
/////////////////////////////////////////////////////
//////////////////// DARK SUN ///////////////////
/////////////////////////////////////////////////////
GC2235_write_cmos_sensor(0xb8, 0x0f);
GC2235_write_cmos_sensor(0xb9, 0x23);
GC2235_write_cmos_sensor(0xba, 0xff);
GC2235_write_cmos_sensor(0xbc, 0x00);
GC2235_write_cmos_sensor(0xbd, 0x00);
GC2235_write_cmos_sensor(0xbe, 0xff);
GC2235_write_cmos_sensor(0xbf, 0x09);
/////////////////////////////////////////////////////
////////////////////// OUTPUT /////////////////////
/////////////////////////////////////////////////////
GC2235_write_cmos_sensor(0xfe, 0x03);
GC2235_write_cmos_sensor(0x01, 0x00);
GC2235_write_cmos_sensor(0x02, 0x00);
GC2235_write_cmos_sensor(0x03, 0x00);
GC2235_write_cmos_sensor(0x06, 0x00);
GC2235_write_cmos_sensor(0x10, 0x00);
GC2235_write_cmos_sensor(0x15, 0x00);
GC2235_write_cmos_sensor(0xfe, 0x00);
GC2235_write_cmos_sensor(0xf2, 0x0f);
SENSORDB("GC2235_Sensor_Init\n");
} /* GC2235_Sensor_Init */
void HI704GetAEMaxNumMeteringAreas(UINT32 *pFeatureReturnPara32)
{
*pFeatureReturnPara32 = 0;
SENSORDB("HI704GetAEMaxNumMeteringAreas *pFeatureReturnPara32 = %d\n", *pFeatureReturnPara32);
}
void HI704GetAFMaxNumFocusAreas(UINT32 *pFeatureReturnPara32)
{
*pFeatureReturnPara32 = 0;
SENSORDB("HI704GetAFMaxNumFocusAreas *pFeatureReturnPara32 = %d\n", *pFeatureReturnPara32);
}
/*************************************************************************
* FUNCTION
* HI704_set_param_wb
*
* DESCRIPTION
* wb setting.
*
* PARAMETERS
* none
*
* RETURNS
* None
*
* GLOBALS AFFECTED
*
*************************************************************************/
BOOL HI704_set_param_wb(UINT16 para)
{
//This sensor need more time to balance AWB,
//we suggest higher fps or drop some frame to avoid garbage color when preview initial
SENSORDB("[Enter]HI704 set_param_wb func:para = %d\n",para);
if(HI704_sensor.wb == para) return KAL_TRUE;
HI704_sensor.wb = para;
switch (para)
{
case AWB_MODE_AUTO:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x2e);
HI704_write_cmos_sensor(0x80, 0x38);
HI704_write_cmos_sensor(0x82, 0x38);
HI704_write_cmos_sensor(0x83, 0x5e);
HI704_write_cmos_sensor(0x84, 0x24);
HI704_write_cmos_sensor(0x85, 0x59);
HI704_write_cmos_sensor(0x86, 0x24);
}
break;
case AWB_MODE_CLOUDY_DAYLIGHT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x71);
HI704_write_cmos_sensor(0x82, 0x2b);
HI704_write_cmos_sensor(0x83, 0x72);
HI704_write_cmos_sensor(0x84, 0x70);
HI704_write_cmos_sensor(0x85, 0x2b);
HI704_write_cmos_sensor(0x86, 0x28);
}
break;
case AWB_MODE_DAYLIGHT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x59);
HI704_write_cmos_sensor(0x82, 0x29);
HI704_write_cmos_sensor(0x83, 0x60);
HI704_write_cmos_sensor(0x84, 0x50);
HI704_write_cmos_sensor(0x85, 0x2f);
HI704_write_cmos_sensor(0x86, 0x23);
}
break;
case AWB_MODE_INCANDESCENT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x29);
HI704_write_cmos_sensor(0x82, 0x54);
HI704_write_cmos_sensor(0x83, 0x2e);
HI704_write_cmos_sensor(0x84, 0x23);
HI704_write_cmos_sensor(0x85, 0x58);
HI704_write_cmos_sensor(0x86, 0x4f);
}
break;
case AWB_MODE_FLUORESCENT:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x11, 0x28);
HI704_write_cmos_sensor(0x80, 0x41);
HI704_write_cmos_sensor(0x82, 0x42);
HI704_write_cmos_sensor(0x83, 0x44);
HI704_write_cmos_sensor(0x84, 0x34);
HI704_write_cmos_sensor(0x85, 0x46);
HI704_write_cmos_sensor(0x86, 0x3a);
}
break;
case AWB_MODE_TUNGSTEN:
{
HI704_write_cmos_sensor(0x03, 0x22);
HI704_write_cmos_sensor(0x80, 0x24);
HI704_write_cmos_sensor(0x81, 0x20);
HI704_write_cmos_sensor(0x82, 0x58);
HI704_write_cmos_sensor(0x83, 0x27);
HI704_write_cmos_sensor(0x84, 0x22);
HI704_write_cmos_sensor(0x85, 0x58);
HI704_write_cmos_sensor(0x86, 0x52);
}
break;
default:
return FALSE;
}
return TRUE;
} /* HI704_set_param_wb */
inline static kal_bool GC2235MIPI_set_sensor_item_info(MSDK_SENSOR_ITEM_INFO_STRUCT *para)
{
kal_uint16 temp_para;
#ifdef GC2235MIPI_DRIVER_TRACE
SENSORDB("GC2235MIPI_set_sensor_item_info\n");
#endif
switch (para->GroupIdx)
{
case GC2235MIPI_PRE_GAIN:
switch (para->ItemIdx)
{
case GC2235MIPI_SENSOR_BASEGAIN:
case GC2235MIPI_PRE_GAIN_R_INDEX:
case GC2235MIPI_PRE_GAIN_Gr_INDEX:
case GC2235MIPI_PRE_GAIN_Gb_INDEX:
case GC2235MIPI_PRE_GAIN_B_INDEX:
#if defined(MT6577)||defined(MT6589)
spin_lock(&gc2235mipi_drv_lock);
#endif
GC2235MIPI_sensor.eng.cct[para->ItemIdx].Para = para->ItemValue * BASEGAIN / 1000;
#if defined(MT6577)||defined(MT6589)
spin_unlock(&gc2235mipi_drv_lock);
#endif
GC2235MIPI_SetGain(GC2235MIPI_sensor.gain); /* update gain */
break;
default:
ASSERT(0);
}
break;
case GC2235MIPI_CMMCLK_CURRENT:
switch (para->ItemIdx)
{
case 0:
switch (para->ItemValue)
{
case 2:
temp_para = ISP_DRIVING_2MA;
break;
case 3:
case 4:
temp_para = ISP_DRIVING_4MA;
break;
case 5:
case 6:
temp_para = ISP_DRIVING_6MA;
break;
default:
temp_para = ISP_DRIVING_8MA;
break;
}
//GC2235MIPI_set_isp_driving_current(temp_para);
#if defined(MT6577)||defined(MT6589)
spin_lock(&gc2235mipi_drv_lock);
#endif
GC2235MIPI_sensor.eng.reg[GC2235MIPI_CMMCLK_CURRENT_INDEX].Para = temp_para;
#if defined(MT6577)||defined(MT6589)
spin_unlock(&gc2235mipi_drv_lock);
#endif
break;
default:
ASSERT(0);
}
break;
case GC2235MIPI_FRAME_RATE_LIMITATION:
ASSERT(0);
break;
case GC2235MIPI_REGISTER_EDITOR:
switch (para->ItemIdx)
{
static kal_uint32 fac_sensor_reg;
case 0:
if (para->ItemValue < 0 || para->ItemValue > 0xFFFF) return KAL_FALSE;
fac_sensor_reg = para->ItemValue;
break;
case 1:
if (para->ItemValue < 0 || para->ItemValue > 0xFF) return KAL_FALSE;
GC2235MIPI_write_cmos_sensor(fac_sensor_reg, para->ItemValue);
break;
default:
ASSERT(0);
}
break;
default:
ASSERT(0);
}
return KAL_TRUE;
}
