int
LensSensorDrv::moveMCU(int a_i4FocusPos, unsigned int a_u4CurrSensorDev)
{
//DRV_DBG("moveMCU() - pos = %d \n", a_i4FocusPos);
int err = 0;
ACDK_SENSOR_FEATURECONTROL_STRUCT featureCtrl;
MUINT16 FeaturePara = 0;
MUINT32 FeatureParaLen = 0;
int a_fdMCU=0;
if(a_u4CurrSensorDev==MCU_DEV_MAIN) {a_fdMCU = m_fdMCU_main;}
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2) {a_fdMCU = m_fdMCU_main2;}
else if(a_u4CurrSensorDev==MCU_DEV_SUB) {a_fdMCU = m_fdMCU_sub;}
if (a_fdMCU < 0) {
DRV_ERR("moveMCU() invalid m_fdMCU =%d\n", a_fdMCU);
return MCUDrv::MCU_INVALID_DRIVER;
}
FeaturePara = (MUINT16)a_i4FocusPos;
FeatureParaLen = sizeof(MUINT16);
featureCtrl.FeatureId = SENSOR_FEATURE_MOVE_FOCUS_LENS;
featureCtrl.pFeaturePara = (MUINT8*)&FeaturePara;
featureCtrl.pFeatureParaLen = &FeatureParaLen;
err = ioctl(a_fdMCU, KDIMGSENSORIOC_X_FEATURECONCTROL , &featureCtrl);
if (err < 0) {
DRV_ERR("[moveMCU] ioctl - SENSOR_FEATURE_MOVE_FOCUS_LENS, error %s", strerror(errno));
return err;
}
if(a_u4CurrSensorDev==MCU_DEV_MAIN) {m_i4FocusPos_main=a_i4FocusPos;}
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2) {m_i4FocusPos_main2=a_i4FocusPos;}
else if(a_u4CurrSensorDev==MCU_DEV_SUB) {m_i4FocusPos_sub=a_i4FocusPos;}
return MCUDrv::MCU_NO_ERROR;
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
int FlashlightDrv::setTimeOutTime(int ms)
{
DRV_DBG("setTimeOutTime(ms=%d)", ms);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("setTimeOutTime() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASH_IOC_SET_TIME_OUT_TIME_MS,ms);
if (err < 0)
{
DRV_ERR("setTimeOutTime() err=%d\n", err);
}
return err;
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
int FlashlightDrv::setFlashReg(int shift, unsigned short reg, unsigned short mask)
{
DRV_DBG("setFlashSpReg() shift=%d, reg=%d, mak=0x%x",shift, reg, mask);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("setFlashSpReg() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
DRV_DBG("FlashErr setFlashSpReg() code not ready, line=%d",__LINE__);
if (err < 0)
{
DRV_ERR("setFlashSpReg() err=%d\n", err);
}
return err;
}
//======================================
int FlashlightDrv::setPreOn()
{
DRV_DBG("setPreOn()");
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_ERR("setPreOn() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASH_IOC_PRE_ON,0);
if (err < 0)
{
DRV_DBG("setPreOn() not support =%d\n", err);
}
m_preOnTime=getMs();
return err;
}
//======================================
int FlashlightDrv::getPreOnTimeMs(int* ms)
{
DRV_DBG("getPreOnTimeMs()");
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_ERR("getPreOnTimeMs() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
*ms=0;
err = ioctl(m_fdSTROBE,FLASH_IOC_GET_PRE_ON_TIME_MS, ms);
if (err < 0)
{
DRV_DBG("getPreOnTimeMs() not support ret=%d\n", err);
}
DRV_DBG("getPreOnTimeMs=%d", *ms);
return err;
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
int FlashlightDrv::setDuty(int duty)
{
DRV_DBG("setDuty() duty = %d\n",duty);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("setDuty() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASH_IOC_SET_DUTY,duty);
if (err < 0)
{
DRV_ERR("setDuty() err=%d\n", err);
return err;
}
m_duty = duty;
return err;
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
int FlashlightDrv::setStep(int step)
{
DRV_DBG("setStep() step = %d\n",step);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("setStep() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASH_IOC_SET_STEP,step);
if (err < 0)
{
DRV_ERR("setOnOff() err=%d\n", err);
return err;
}
m_step = step;
return err;
}
int FlashlightDrv::hasLowPowerDetect(int* hasLPD)
{
DRV_DBG("hasLowPowerDetect()");
*hasLPD=0;
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_ERR("hasLowPowerDetect() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASH_IOC_HAS_LOW_POWER_DETECT, hasLPD);
if (err < 0)
{
DRV_DBG("hasLowPowerDetect() not support ret=%d\n", err);
}
DRV_DBG("hasLowPowerDetect=%d", *hasLPD);
return err;
}
int FlashlightDrv::setTimeus(unsigned long a_timeus)
{
DRV_DBG("setTimeus line=%d",__LINE__);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG(" [setTimeus] m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASHLIGHTIOC_T_FLASHTIME,a_timeus);
if (err < 0)
{
DRV_ERR("FLASHLIGHTIOC_T_ENABLE error\n");
return err;
}
return StrobeDrv::STROBE_NO_ERROR;
}
int
LensSensorDrv::getMCUInfo(mcuMotorInfo *a_pMotorInfo, unsigned int a_u4CurrSensorDev)
{
int err = 0;
ACDK_SENSOR_FEATURECONTROL_STRUCT featureCtrl;
MUINT32 FeaturePara = 0;
MUINT32 FeatureParaLen = 4;
int a_fdMCU=0;
unsigned long a_i4FocusPos=0;
if(a_u4CurrSensorDev==MCU_DEV_MAIN) {a_fdMCU = m_fdMCU_main; a_i4FocusPos=m_i4FocusPos_main;}
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2) {a_fdMCU = m_fdMCU_main2; a_i4FocusPos=m_i4FocusPos_main2;}
else if(a_u4CurrSensorDev==MCU_DEV_SUB) {a_fdMCU = m_fdMCU_sub; a_i4FocusPos=m_i4FocusPos_sub;}
if (a_fdMCU < 0) {
DRV_ERR("getMCUInfo() invalid m_fdMCU =%d\n", a_fdMCU);
a_pMotorInfo->bIsMotorOpen = 0;
return MCUDrv::MCU_INVALID_DRIVER;
}
a_pMotorInfo->bIsMotorOpen = 1;
a_pMotorInfo->u4CurrentPosition = a_i4FocusPos;
a_pMotorInfo->bIsSupportSR = 0;
featureCtrl.pFeaturePara = (MUINT8*)&FeaturePara;
featureCtrl.pFeatureParaLen = &FeatureParaLen;
featureCtrl.FeatureId = SENSOR_FEATURE_GET_AF_STATUS;
err = ioctl(a_fdMCU, KDIMGSENSORIOC_X_FEATURECONCTROL , &featureCtrl);
a_pMotorInfo->bIsMotorMoving = (bool)FeaturePara;
featureCtrl.FeatureId = SENSOR_FEATURE_GET_AF_INF;
err = ioctl(a_fdMCU, KDIMGSENSORIOC_X_FEATURECONCTROL , &featureCtrl);
a_pMotorInfo->u4InfPosition = (MUINT32)FeaturePara;
featureCtrl.FeatureId = SENSOR_FEATURE_GET_AF_MACRO;
err = ioctl(a_fdMCU, KDIMGSENSORIOC_X_FEATURECONCTROL , &featureCtrl);
a_pMotorInfo->u4MacroPosition = (MUINT32)FeaturePara;
//DRV_DBG("[ImgSensorDrv] [state]%d, [inf]%d, [macro]%d \n", a_pMotorInfo->bIsMotorMoving, a_pMotorInfo->u4InfPosition, a_pMotorInfo->u4MacroPosition);
return MCUDrv::MCU_NO_ERROR;
}
StrobeDrv::FLASHLIGHT_TYPE_ENUM FlashlightDrv::getFlashlightType() const
{
DRV_DBG("getFlashlightType line=%d",__LINE__);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG(" [getFlashlightType] m_fdSTROBE < 0\n");
return StrobeDrv::FLASHLIGHT_NONE;
}
DRV_DBG("[getFlashlightType] m_flashType=%d\n",m_flashType);
err = ioctl(m_fdSTROBE,FLASHLIGHTIOC_G_FLASHTYPE,&m_flashType);
if (err < 0)
{
DRV_ERR("FLASHLIGHTIOC_G_FLASHTYPE error:%d\n",m_flashType);
return StrobeDrv::FLASHLIGHT_NONE;;
}
return (StrobeDrv::FLASHLIGHT_TYPE_ENUM)m_flashType;
}
int FlashlightDrv::setState(unsigned long a_state)
{
DRV_DBG("setState line=%d",__LINE__);
int err = 0;
unsigned long strobeState = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG(" [setState] m_fdSTROBE < 0\n");
return 0;
}
strobeState = (0 == a_state) ? (unsigned long)FLASHLIGHTDRV_STATE_PREVIEW : (unsigned long)FLASHLIGHTDRV_STATE_STILL;
err = ioctl(m_fdSTROBE,FLASHLIGHTIOC_T_STATE,strobeState);
if (err < 0)
{
DRV_ERR("FLASHLIGHTIOC_T_STATE error\n");
return err;
}
return StrobeDrv::STROBE_NO_ERROR;
}
/*******************************************************************************
Author : Cotta
Functionality : set value of sensor capture delay
********************************************************************************/
int FlashlightDrv::setCaptureDelay(unsigned int value)
{
DRV_DBG("setCaptureDelay line=%d",__LINE__);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG(" [setCaptureDelay] m_fdSTROBE < 0\n");
return 0;
}
DRV_DBG(" [setCaptureDelay] set capture delay : %u\n",value);
err = ioctl(m_fdSTROBE,FLASHLIGHTIOC_T_DELAY,value);
if (err < 0)
{
DRV_ERR("FLASHLIGHTIOC_T_DELAY error : %u\n",value);
return err;
}
return StrobeDrv::STROBE_NO_ERROR;
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
int FlashlightDrv::getFlashReg(int shift, unsigned short* a_reg)
{
DRV_DBG("getFlashReg() shift = %d",shift);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG(" [getFlashReg] m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
/*
if(shift==0)
err = ioctl(m_fdSTROBE,FLASHLIGHT_GET_REG0,a_reg);
else if(shift==1)
err = ioctl(m_fdSTROBE,FLASHLIGHT_GET_REG1,a_reg);
else
err = ioctl(m_fdSTROBE,FLASHLIGHT_GET_REG2,a_reg);
*/
if (err < 0)
{
DRV_ERR("getFlashReg() err=%d\n", err);
}
return err;
}
int FlashlightDrv::lowPowerDetectStart()
{
int hasLPD;
hasLowPowerDetect(&hasLPD);
if(hasLPD==0)
return 0;
DRV_DBG("lowPowerDetectStart()");
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("lowPowerDetectStart() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASH_IOC_LOW_POWER_DETECT_START,0);
if (err < 0)
{
DRV_ERR("lowPowerDetectStart() err=%d\n", err);
return err;
}
return 0;
}
int FlashlightDrv::initTemp(unsigned long sensorDev)
{
DRV_DBG("initTemp line=%d",__LINE__);
int err = 0;
unsigned long flashlightIdx = 0; //default dummy driver
//MHAL_LOG("[halSTROBEInit]: %s \n\n", __TIME__);
DRV_DBG("[initTemp] mUsers = %d\n", mUsers);
Mutex::Autolock lock(mLock);
if (mUsers > 0)
{
int preSensorDev;
preSensorDev = m_sensorDev;
m_sensorDev = sensorDev;
if(preSensorDev==m_sensorDev)
{
}
else
{
uninitNoLock();
}
}
m_sensorDev = sensorDev;
if (mUsers == 0)
{
if(sensorDev==0)
sensorDev=e_CAMERA_MAIN_SENSOR;
if (m_fdSTROBE == -1)
{
int ta;
int tb;
ta = getMs();
m_fdSTROBE = open(STROBE_DEV_NAME, O_RDWR);
tb = getMs();
DRV_DBG("[init] m_fdSTROBE = %d t=%d\n", m_fdSTROBE,tb-ta);
if (m_fdSTROBE < 0)
{
DRV_ERR("error opening %s: %s", STROBE_DEV_NAME, strerror(errno));
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
//set flashlight driver
DRV_DBG("[init] sensorDev = %ld\n", sensorDev);
err = ioctl(m_fdSTROBE,FLASHLIGHTIOC_X_SET_DRIVER,sensorDev);
if (err < 0)
{
DRV_ERR("FLASHLIGHTIOC_X_SET_DRIVER error\n");
return err ;
}
m_isOn=0;
m_duty=0;
m_step=0;
m_preOnTime=-1;
}
android_atomic_inc(&mUsers);
m_bTempInit=1;
}
return StrobeDrv::STROBE_NO_ERROR;
}
int
LensDrv::init(unsigned int a_u4CurrSensorDev )
{
char cBuf[64];
unsigned int a_u4CurrLensIdx;
if(a_u4CurrSensorDev==MCU_DEV_MAIN)
{
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_main;
sprintf(cBuf, "/dev/%s", MCUDrv::m_LensInitFunc_main[a_u4CurrLensIdx].LensDrvName);
DRV_DBG("main lens init() [m_userCnt]%d +\n", m_userCnt_main);
DRV_DBG("[main Lens Driver]%s\n", cBuf);
Mutex::Autolock lock(mLock);
if (m_userCnt_main == 0) {
if (m_fdMCU_main == -1) {
m_fdMCU_main = open(cBuf, O_RDWR);
if (m_fdMCU_main < 0) {
if (a_u4CurrLensIdx == 0) { // no error log for dummy lens
return MCUDrv::MCU_NO_ERROR;
}
else {
DRV_ERR("main Lens error opening %s: %s", cBuf, strerror(errno));
return MCUDrv::MCU_INVALID_DRIVER;
}
}
}
}
m_userCnt_main++;
DRV_DBG("main lens init() [m_userCnt]%d [fdMCU_main]%d - \n", m_userCnt_main,m_fdMCU_main);
}
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2)
{
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_main2;
sprintf(cBuf, "/dev/%s", MCUDrv::m_LensInitFunc_main2[a_u4CurrLensIdx].LensDrvName);
DRV_DBG("main2 lens init() [m_userCnt]%d +\n", m_userCnt_main2);
DRV_DBG("[main2 Lens Driver]%s\n", cBuf);
Mutex::Autolock lock(mLock);
if (m_userCnt_main2 == 0) {
if (m_fdMCU_main2 == -1) {
m_fdMCU_main2 = open(cBuf, O_RDWR);
if (m_fdMCU_main2 < 0) {
if (a_u4CurrLensIdx == 0) { // no error log for dummy lens
return MCUDrv::MCU_NO_ERROR;
}
else {
DRV_ERR("main2 Lens error opening %s: %s", cBuf, strerror(errno));
return MCUDrv::MCU_INVALID_DRIVER;
}
}
}
}
m_userCnt_main2++;
DRV_DBG("main2 lens init() [m_userCnt]%d [fdMCU_main2]%d - \n", m_userCnt_main2,m_fdMCU_main2);
}
else if(a_u4CurrSensorDev==MCU_DEV_SUB)
{
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_sub;
sprintf(cBuf, "/dev/%s", MCUDrv::m_LensInitFunc_sub[a_u4CurrLensIdx].LensDrvName);
DRV_DBG("sub lens init() [m_userCnt]%d +\n", m_userCnt_sub);
DRV_DBG("[Lens Driver]%s\n", cBuf);
Mutex::Autolock lock(mLock);
if (m_userCnt_sub == 0) {
if (m_fdMCU_sub == -1) {
m_fdMCU_sub = open(cBuf, O_RDWR);
if (m_fdMCU_sub < 0) {
if (a_u4CurrLensIdx == 0) { // no error log for dummy lens
return MCUDrv::MCU_NO_ERROR;
}
else {
DRV_ERR("error opening %s: %s", cBuf, strerror(errno));
return MCUDrv::MCU_INVALID_DRIVER;
}
}
}
}
m_userCnt_sub++;
DRV_DBG("sub lens init() [m_userCnt]%d [fdMCU_sub]%d - \n", m_userCnt_sub,m_fdMCU_sub);
}
else
return MCUDrv::MCU_INVALID_DRIVER;
return MCUDrv::MCU_NO_ERROR;
}
int
LensSensorDrv::init(unsigned int a_u4CurrSensorDev)
{
DRV_DBG("[init()]\n");
char cBuf[64];
unsigned int a_u4CurrLensIdx, a_userCnt;
int a_fdMCU=0;
int err = 0;
ACDK_SENSOR_FEATURECONTROL_STRUCT featureCtrl;
MUINT16 FeaturePara = 0;
MUINT32 FeatureParaLen = 0;
if(a_u4CurrSensorDev==MCU_DEV_MAIN)
{
a_fdMCU = m_fdMCU_main;
a_userCnt = m_userCnt_main;
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_main;
sprintf(cBuf, "/dev/%s", MCUDrv::m_LensInitFunc_main[a_u4CurrLensIdx].LensDrvName);
DRV_DBG("[Main Lens Driver]%s\n", cBuf);
}
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2)
{
a_fdMCU = m_fdMCU_main2;
a_userCnt = m_userCnt_main2;
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_main2;
sprintf(cBuf, "/dev/%s", MCUDrv::m_LensInitFunc_main2[a_u4CurrLensIdx].LensDrvName);
DRV_DBG("[Main2 Lens Driver]%s\n", cBuf);
}
else if(a_u4CurrSensorDev==MCU_DEV_SUB)
{
a_fdMCU = m_fdMCU_sub;
a_userCnt = m_userCnt_sub;
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_sub;
sprintf(cBuf, "/dev/%s", MCUDrv::m_LensInitFunc_sub[a_u4CurrLensIdx].LensDrvName);
DRV_DBG("[Sub Lens Driver]%s\n", cBuf);
}
else return MCUDrv::MCU_INVALID_DRIVER;
Mutex::Autolock lock(mLock);
if (a_userCnt <= 0) {
if (a_fdMCU == -1) {
a_fdMCU = open(cBuf, O_RDWR);
if (a_fdMCU < 0)
{
DRV_ERR("error opening %s: %s", cBuf, strerror(errno));
return MCUDrv::MCU_INVALID_DRIVER;
}
featureCtrl.FeatureId = SENSOR_FEATURE_INITIALIZE_AF;
featureCtrl.pFeaturePara = (MUINT8*)&FeaturePara;
featureCtrl.pFeatureParaLen = &FeatureParaLen;
err = ioctl(a_fdMCU, KDIMGSENSORIOC_X_FEATURECONCTROL , &featureCtrl);
if (err < 0) {
DRV_ERR("[initMCU] ioctl - SENSOR_FEATURE_INITIALIZE_AF, error %s", strerror(errno));
}
}
}
a_userCnt++;
if(a_u4CurrSensorDev==MCU_DEV_MAIN) m_userCnt_main = a_userCnt;
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2) m_userCnt_main2 = a_userCnt;
else if(a_u4CurrSensorDev==MCU_DEV_SUB) m_userCnt_sub = a_userCnt;
return err;
}
