int FlashlightDrv::setLevel(unsigned long a_level)
{
DRV_DBG("setLevel line=%d",__LINE__);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG(" [setLevel] m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
DRV_DBG("[FlashlightDrv] setLevel = %lu\n",a_level);
err = ioctl(m_fdSTROBE,FLASHLIGHTIOC_T_LEVEL,a_level);
DRV_DBG("[FlashlightDrv] setLevel err = %d, line=%d\n",err, __LINE__);
if (err < 0)
{
DRV_ERR("FLASHLIGHTIOC_T_ENABLE error;%ld\n",a_level);
return err;
}
return StrobeDrv::STROBE_NO_ERROR;
}
int FlashlightDrv::uninitNoLock()
{
DRV_DBG("uninitNoLock user=%d",mUsers);
//MHAL_LOG("[halSTROBEUninit] \n");
if (mUsers == 0)
{
DRV_DBG("[uninitNoLock] mUsers = %d\n", mUsers);
}
if (mUsers == 1)
{
if (m_fdSTROBE > 0)
{
close(m_fdSTROBE);
}
m_fdSTROBE = -1;
}
android_atomic_dec(&mUsers);
m_bTempInit=0;
return StrobeDrv::STROBE_NO_ERROR;
}
int FlashlightDrv::mapDutyStep(int peakI, int aveI, int* duty, int* step)
{
DRV_DBG("mapDutyStep()");
DRV_DBG("FlashErr mapDutyStep() code not ready, line=%d",__LINE__);
int err=0;
return err;
}
int FlashlightDrv::hasFlashHw()
{
DRV_DBG("hasFlashHw line=%d",__LINE__);
if (m_fdSTROBE < 0)
{
DRV_DBG(" [getFlashlightType] m_fdSTROBE < 0\n");
return 0;
}
if(e_CAMERA_MAIN_SENSOR==m_sensorDev)
{
#ifdef DUMMY_FLASHLIGHT
return 0;
#else
return 1;
#endif
}
else if(e_CAMERA_SUB_SENSOR==m_sensorDev)
{
if(cust_isSubFlashSupport()==1)
return 1;
else
return 0;
}
else
return 0;
}
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
int FlashlightDrv::unlockSensedV()
{
DRV_DBG("unlockSensedV()");
DRV_DBG("FlashErr unlockSensedV() code not ready, line=%d",__LINE__);
int err=0;
return err;
}
int FlashlightDrv::setFire(unsigned long a_fire)
{
DRV_DBG("setFire line=%d",__LINE__);
int err = 0;
unsigned long fire = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG(" [setFire] m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
DRV_DBG("[FlashlightDrv] setFire = %lu line=%d",a_fire,__LINE__);
fire = (0 == a_fire) ? 0 : 1;
err = ioctl(m_fdSTROBE,FLASHLIGHTIOC_T_ENABLE,fire);
if (err < 0)
{
//DRV_ERR("FLASHLIGHTIOC_T_ENABLE error\n");
DRV_DBG("[FlashlightDrv] setFire ERR line=%d",__LINE__);
return err ;
}
DRV_DBG("[FlashlightDrv] setFire OK line=%d",__LINE__);
return StrobeDrv::STROBE_NO_ERROR;
}
int FlashlightDrv::isOn(int* a_isOn)
{
DRV_DBG("isOn()\n");
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("isOn() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
*a_isOn = m_isOn;
/*
if(a_isOn==1)
err = ioctl(m_fdSTROBE,FLASH_IOC_SET_ONOFF,1);
else if(a_isOn==0)
err = ioctl(m_fdSTROBE,FLASH_IOC_SET_ONOFF,0);
else
err = STROBE_ERR_PARA_INVALID;
if (err < 0)
{
DRV_ERR("isOning() err=%d\n", err);
}*/
return err;
}
int FlashlightDrv::lowPowerDetectEnd(int* isLowPower)
{
int hasLPD;
*isLowPower=0;
hasLowPowerDetect(&hasLPD);
if(hasLPD==0)
{
*isLowPower=0;
return 0;
}
DRV_DBG("lowPowerDetectEnd()");
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_ERR("lowPowerDetectEnd() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
err = ioctl(m_fdSTROBE,FLASH_IOC_LOW_POWER_DETECT_END, isLowPower);
if (err < 0)
{
DRV_DBG("lowPowerDetectEnd() not support ret=%d\n", err);
}
DRV_DBG("isLowPower=%d", *isLowPower);
return 0;
}
int FlashlightDrv::setOnOff(int a_isOn)
{
DRV_DBG("setOnOff() isOn = %d\n",a_isOn);
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("setOnOff() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
if(a_isOn==1)
{
int minPreOnTime;
err = getPreOnTimeMs(&minPreOnTime);
if(err<0)
{
DRV_DBG("no preon");
}
else
{
DRV_DBG("preon support");
if(m_preOnTime==-1)
{
setPreOn();
usleep(minPreOnTime*1000);
}
else
{
int curTime;
int sleepTimeMs;
curTime = getMs();
sleepTimeMs = (minPreOnTime-(curTime-m_preOnTime));
DRV_DBG("preon sleep %d ms", sleepTimeMs);
if(sleepTimeMs>0)
{
usleep( sleepTimeMs*1000);
}
}
}
err = ioctl(m_fdSTROBE,FLASH_IOC_SET_ONOFF,1);
}
else if(a_isOn==0)
{
m_preOnTime=-1;
err = ioctl(m_fdSTROBE,FLASH_IOC_SET_ONOFF,0);
}
else
err = STROBE_ERR_PARA_INVALID;
if (err < 0)
{
DRV_ERR("setOnOff() err=%d\n", err);
}
if(err==0)
m_isOn=a_isOn;
return err;
}
int FlashlightDrv::getCoolDownTime(int* ms)
{
DRV_DBG("getCoolDownTime()");
int err=0;
DRV_DBG("FlashErr setFlashSpReg() code not ready, line=%d",__LINE__);
*ms = 0;
return err;
}
/*******************************************************************************
Author : Cotta
Functionality : get value of strobe watch dog timer
********************************************************************************/
int FlashlightDrv::getStrobeWDTValue(unsigned int *pValue)
{
DRV_DBG("getStrobeWDTValue line=%d",__LINE__);
*pValue = FLASH_LIGHT_WDT_TIMEOUT_MS;
DRV_DBG("[getStrobeWDTValue] WDT value = %u\n",*pValue);
return StrobeDrv::STROBE_NO_ERROR;
}
int FlashlightDrv::getStep(int* step)
{
DRV_DBG("getStep()\n");
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("getStep() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
*step = m_step;
return err;
}
int FlashlightDrv::getDuty(int* duty)
{
DRV_DBG("getDuty()\n");
int err = 0;
if (m_fdSTROBE < 0)
{
DRV_DBG("getDuty() m_fdSTROBE < 0\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
*duty = m_duty;
return err;
}
MCUDrv*
LensSensorDrv::getInstance()
{
DRV_DBG("[ImgSensorDrv] getInstance \n");
static LensSensorDrv singleton;
return &singleton;
}
//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;
}
/*******************************************************************************
Author : Cotta
Functionality : command control
********************************************************************************/
int FlashlightDrv::sendCommand(unsigned int cmd, unsigned int pArg1, unsigned int *pArg2, unsigned int *pArg3)
{
DRV_DBG("sendCommand line=%d",__LINE__);
int err = 0;
switch(cmd)
{
case CMD_STROBE_SET_CAP_DELAY :
err = setCaptureDelay(pArg1); // set capture delay to strobe kernel driver
break;
case CMD_STROBE_GET_WDT_VALUE :
err = getStrobeWDTValue(pArg2); // get WDT value
break;
default :
DRV_ERR("[strobe sendCommand] no commadn support\n");
return StrobeDrv::STROBE_UNKNOWN_ERROR;
}
if (err < 0)
{
DRV_ERR("[strobe sendCommand] Err-ctrlCode(%x)\n",err);
return 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
LensDrv::setMCUParam(int ois_param,unsigned int a_u4CurrSensorDev )
{
int err, a_fdMCU,a_u4CurrLensIdx;
DRV_DBG("setMCUParam() - bOIS_disable = %d \n", (ois_param&1));
DRV_DBG("setMCUParam() - bOIS_movieMode = %d \n", (ois_param&2));
//DRV_DBG("setMCUParam() - u4ois_freq = %d \n", ois_param->u4ois_freq);
//DRV_DBG("setMCUParam() - u4ois_setting1 = %d \n", ois_param->u4ois_setting1);
//DRV_DBG("setMCUParam() - u4ois_setting2 = %d \n", ois_param->u4ois_setting2);
if(a_u4CurrSensorDev==MCU_DEV_MAIN)
{
a_fdMCU=m_fdMCU_main;
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_main;
}
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2)
{
a_fdMCU=m_fdMCU_main2;
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_main2;
}
else if(a_u4CurrSensorDev==MCU_DEV_SUB)
{
a_fdMCU=m_fdMCU_sub;
a_u4CurrLensIdx=MCUDrv::m_u4CurrLensIdx_sub;
}
else
return MCUDrv::MCU_INVALID_DRIVER;
if (a_fdMCU < 0) {
if (a_u4CurrLensIdx == 0) { // no error log for dummy lens
return MCUDrv::MCU_NO_ERROR;
}
else {
DRV_ERR("[setMCUMacroPos] invalid m_fdMCU =%d\n", a_fdMCU);
return MCUDrv::MCU_INVALID_DRIVER;
}
}
err = ioctl(a_fdMCU,mcuIOC_T_SETPARA,ois_param);
if (err < 0) {
DRV_ERR("[setMCUMacroPos] ioctl - mcuIOC_T_SETPARA, error %s", strerror(errno));
return err;
}
return MCUDrv::MCU_NO_ERROR;
}
//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;
}
//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;
}
//======================================
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;
}
int FlashlightDrv::setCaptureFlashlightConf(unsigned long a_strobeWidth)
{
DRV_DBG("setCaptureFlashlightConf line=%d",__LINE__);
int err = StrobeDrv::STROBE_NO_ERROR;
DRV_DBG("[setCaptureFlashlightConf] m_flashType = %d, width=%lu\n",m_flashType,a_strobeWidth);
if (StrobeDrv::FLASHLIGHT_LED_PEAK == m_flashType)
{
DRV_DBG("[setCaptureFlashlightConf] FLASHLIGHT_LED_PEAK\n");
err = FlashlightDrv::setState(1); //still capture state
if (err < 0)
{
DRV_DBG("[setCaptureFlashlightConf] setState fail\n");
}
err = FlashlightDrv::setLevel(a_strobeWidth);
if (err < 0)
{
DRV_DBG("[setCaptureFlashlightConf] setLevel fail\n");
}
}
else if (StrobeDrv::FLASHLIGHT_LED_CONSTANT == m_flashType && 0 != a_strobeWidth )
/*LIB3A_AE_STROBE_MODE_FORCE_ON == m_strobeMode) */
{
err = FlashlightDrv::setState(1); //still capture state
if (err < 0)
{
DRV_DBG("[setCaptureFlashlightConf] setState fail\n");
}
err = FlashlightDrv::setLevel(a_strobeWidth); //set level
if (err < 0)
{
DRV_DBG("[setCaptureFlashlightConf] setLevel fail\n");
}
err = FlashlightDrv::setFire(1);
if (err < 0)
{
DRV_DBG("[setCaptureFlashlightConf] setFire fail\n");
}
}
else
{
DRV_DBG("[setCaptureFlashlightConf] No config\n");
}
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;
}
LensDrv::LensDrv()
: MCUDrv()
, m_fdMCU_main(-1)
, m_fdMCU_main2(-1)
, m_fdMCU_sub(-1)
, m_userCnt_main(0)
, m_userCnt_main2(0)
, m_userCnt_sub(0)
{
DRV_DBG("LensDrv()\n");
}
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
LensSensorDrv::uninit(unsigned int a_u4CurrSensorDev)
{
int a_userCnt;
int a_fdMCU=0;
if(a_u4CurrSensorDev==MCU_DEV_MAIN)
{
a_fdMCU = m_fdMCU_main;
a_userCnt = m_userCnt_main;
DRV_DBG("[Main Lens uninit()]\n");
}
else if(a_u4CurrSensorDev==MCU_DEV_MAIN_2)
{
a_fdMCU = m_fdMCU_main2;
a_userCnt = m_userCnt_main2;
DRV_DBG("[Main2 Lens uninit()]\n");
}
else if(a_u4CurrSensorDev==MCU_DEV_SUB)
{
a_fdMCU = m_fdMCU_sub;
a_userCnt = m_userCnt_sub;
DRV_DBG("[Sub Lens uninit()]\n");
}
else return MCUDrv::MCU_INVALID_DRIVER;
Mutex::Autolock lock(mLock);
if (a_userCnt > 0)
{
if (a_fdMCU > 0) close(a_fdMCU);
a_fdMCU = -1;
}
a_userCnt --;
if (a_userCnt < 0) {a_userCnt = 0;}
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 MCUDrv::MCU_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;
}
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;
}
