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