inline static int mt_eis_register_char_driver(void)
{
int ret = 0;
EIS_LOG("[mt_eis_register_char_driver] \n");
if ( (ret = alloc_chrdev_region(&dev_eis, 0, 1, EIS_DEV_NAME)) < 0 ) {
EIS_ERR("alloc_chrdev_region failed, %d \n", ret);
return ret;
}
//Allocate driver
pcdev_eis = cdev_alloc();
if (pcdev_eis == NULL) {
EIS_ERR("cdev_alloc failed\n");
ret = -ENOMEM;
goto mt_eis_register_char_driver_exit;
}
//Attatch file operation.
cdev_init(pcdev_eis, &mt_eis_fops);
pcdev_eis->owner = THIS_MODULE;
//Add to system
if ( (ret = cdev_add(pcdev_eis, dev_eis, 1)) < 0) {
EIS_ERR("Attatch file operation failed, %d \n", ret);
goto mt_eis_register_char_driver_exit;
}
mt_eis_register_char_driver_exit:
if (ret < 0) {
mt_eis_unregister_char_driver();
}
return ret;
}
MINT32 EisHal::destroyMemBuf(MUINT32 bufCnt, IMEM_BUF_INFO *bufInfo)
{
EIS_LOG("Cnt(%d)", bufCnt);
MINT32 err = EIS_RETURN_NO_ERROR;
if(bufCnt > 1) // more than one
{
for(MUINT32 i = 0; i < bufCnt; ++i)
{
if(0 == bufInfo[i].virtAddr)
{
EIS_LOG("Buffer doesn't exist, i(%d)",i);
continue;
}
if(m_pIMemDrv->unmapPhyAddr(&bufInfo[i]) < 0)
{
EIS_ERR("m_pIMemDrv->unmapPhyAddr() error, i(%d)",i);
err = EIS_RETURN_API_FAIL;
}
if (m_pIMemDrv->freeVirtBuf(&bufInfo[i]) < 0)
{
EIS_ERR("m_pIMemDrv->freeVirtBuf() error, i(%d)",i);
err = EIS_RETURN_API_FAIL;
}
}
}
else
{
if(0 == bufInfo->virtAddr)
{
EIS_LOG("Buffer doesn't exist");
}
if(m_pIMemDrv->unmapPhyAddr(bufInfo) < 0)
{
EIS_ERR("m_pIMemDrv->unmapPhyAddr() error");
err = EIS_RETURN_API_FAIL;
}
if (m_pIMemDrv->freeVirtBuf(bufInfo) < 0)
{
EIS_ERR("m_pIMemDrv->freeVirtBuf() error");
err = EIS_RETURN_API_FAIL;
}
}
EIS_LOG("X");
return err;
}
MINT32 EisHal::createMemBuf(MUINT32 &memSize, MUINT32 bufCnt, IMEM_BUF_INFO *bufInfo)
{
MINT32 err = EIS_RETURN_NO_ERROR;
MUINT32 alingSize = (memSize + L1_CACHE_BYTES - 1) & ~(L1_CACHE_BYTES - 1);
EIS_LOG("Cnt(%d),Size(%u),alingSize(%u)",bufCnt, memSize, alingSize);
memSize = alingSize;
if(bufCnt > 1) // more than one
{
for(MUINT32 i = 0; i < bufCnt; ++i)
{
bufInfo[i].size = alingSize;
if(m_pIMemDrv->allocVirtBuf(&bufInfo[i]) < 0)
{
EIS_ERR("m_pIMemDrv->allocVirtBuf() error, i(%d)",i);
err = EIS_RETURN_API_FAIL;
}
if(m_pIMemDrv->mapPhyAddr(&bufInfo[i]) < 0)
{
EIS_ERR("m_pIMemDrv->mapPhyAddr() error, i(%d)",i);
err = EIS_RETURN_API_FAIL;
}
}
}
else
{
bufInfo->size = alingSize;
if(m_pIMemDrv->allocVirtBuf(bufInfo) < 0)
{
EIS_ERR("m_pIMemDrv->allocVirtBuf() error");
err = EIS_RETURN_API_FAIL;
}
if(m_pIMemDrv->mapPhyAddr(bufInfo) < 0)
{
EIS_ERR("m_pIMemDrv->mapPhyAddr() error");
err = EIS_RETURN_API_FAIL;
}
}
EIS_LOG("X");
return err;
}
static int mt_eis_dump_reg(__user mt_eis_reg_t *preg_io)
{
int ret = 0;
mt_eis_reg_t reg;
int i;
spin_lock_irq(&eis_lock);
for (i = 0; i < 11; i++) {
reg.val[i] = ioread32(EIS_BASE + 4 * i);
}
reg.val[11] = CRZ_BASE + 0x10; // CRZ source size
reg.val[12] = ioread32(CRZ_BASE + 0x10);
reg.val[13] = CRZ_BASE + 0x14; // CRZ target size
reg.val[14] = ioread32(CRZ_BASE + 0x14);
reg.val[15] = 0x12345678;
reg.val[16] = 0;
reg.val[17] = 0x12345678;
reg.val[18] = 0;
reg.val[19] = 0x12345678;
reg.val[20] = 0;
if (copy_to_user(preg_io, ®, sizeof(mt_eis_reg_t)) != 0) {
EIS_ERR("copy_to_user failed \n");
ret = -1;
}
spin_unlock_irq(&eis_lock);
return ret;
}
static int mt_eis_probe(struct platform_device *pdev)
{
int ret = 0;
struct resource *pres = NULL;
int i;
EIS_LOG("[mt_eis_probe] enter \n");
// Check platform_device parameters
if (pdev == NULL) {
dev_err(&pdev->dev, "pdev is NULL \n");
return -ENXIO;
}
// Register char driver
if ( (ret = mt_eis_register_char_driver()) ) {
dev_err(&pdev->dev, "register char failed \n");
return ret;
}
// Mapping CAM_REGISTERS
for (i = 0; i < 1; i++) {
pres = platform_get_resource(pdev, IORESOURCE_MEM, i);
if (pres == NULL) {
dev_err(&pdev->dev, "platform_get_resource failed \n");
ret = -ENOMEM;
goto mt_eis_probe_exit;
}
pres = request_mem_region(pres->start, pres->end - pres->start + 1, pdev->name);
if (pres == NULL) {
dev_err(&pdev->dev, "request_mem_region failed \n");
ret = -ENOMEM;
goto mt_eis_probe_exit;
}
}
// Create class register
pclass_eis = class_create(THIS_MODULE, "eisdrv");
if (IS_ERR(pclass_eis)) {
ret = PTR_ERR(pclass_eis);
EIS_ERR("Unable to create class, err = %d\n", ret);
return ret;
}
// FIXME: error handling
device_create(pclass_eis, NULL, dev_eis, NULL, EIS_DEV_NAME);
// Initialize critical section
spin_lock_init(&eis_lock);
mt_eis_probe_exit:
if (ret < 0) {
mt_eis_unregister_char_driver();
}
EIS_LOG("[mt_eis_probe] exit \n");
return ret;
}
static int __init mt_eis_init(void)
{
int ret = 0;
struct proc_dir_entry *prEntry;
//EIS_LOG("[mt_eis_init] \n");
if ((ret = platform_driver_register(&eis_driver)) < 0) {
EIS_ERR("platform_driver_register fail \n");
return ret;
}
prEntry = create_proc_entry("driver/eis_reg", 0, NULL);
if (prEntry) {
prEntry->read_proc = mt_eis_dump_reg_to_proc;
prEntry->write_proc = mt_eis_reg_debug;
}
else {
EIS_ERR("add /proc/driver/eis_reg entry fail \n");
}
return ret;
}
static long mt_eis_ioctl(struct file *file,
unsigned int cmd, unsigned long arg)
{
long ret = 0;
switch (cmd) {
case MT_EIS_IOC_T_DUMP_REG:
ret = mt_eis_dump_reg((__user mt_eis_reg_t *) arg);
break;
case MT_EIS_IOC_T_CLK_ONOFF:
ret = mt_eis_clk_onoff(arg);
break;
default:
EIS_ERR("[mt_eis_ioctl] unknown cmd \n");
ret = -EPERM;
break;
}
return ret;
}
MVOID EisHal::getEISResult(MUINT32 &a_CMV_X_Int,
MUINT32 &a_CMV_X_Flt,
MUINT32 &a_CMV_Y_Int,
MUINT32 &a_CMV_Y_Flt,
MUINT32 &a_TarWidth,
MUINT32 &a_TarHeight)
{
EIS_LOG("mCMV_X(%d),mCMV_Y(%d)",mCMV_X,mCMV_Y);
a_TarWidth = mTarget_W;
a_TarHeight = mTarget_H;
if(mConfigPass == MTRUE)
{
//====== Boundary Checking ======
if(mCMV_X < 0)
{
EIS_ERR("mCMV_X should not be negative(%u), fix to 0",mCMV_X);
mCMV_X = 0;
a_CMV_X_Int = a_CMV_X_Flt = 0;
}
else
{
MFLOAT tempCMV_X = mCMV_X / 256.0;
if((tempCMV_X + (MFLOAT)mTarget_W) > (MFLOAT)mInput_W)
{
EIS_ERR("mCMV_X too large(%u), fix to %u",mCMV_X,(mInput_W - mTarget_W));
mCMV_X = (mInput_W - mTarget_W);
}
a_CMV_X_Int = (mCMV_X & (~0xFF)) >> intPartShift;
a_CMV_X_Flt = (mCMV_X & (0xFF)) << floatPartShift;
}
if(mCMV_Y < 0)
{
EIS_ERR("mCMV_Y should not be negative(%u), fix to 0",mCMV_Y);
mCMV_Y = 0;
a_CMV_Y_Int = a_CMV_Y_Flt = 0;
}
else
{
MFLOAT tempCMV_Y = mCMV_Y / 256.0;
if((tempCMV_Y + (MFLOAT)mTarget_H) > (MFLOAT)mInput_H)
{
EIS_ERR("mCMV_X too large(%u), fix to %u",mCMV_X,(mInput_H - mTarget_H));
mCMV_X = (mInput_H - mTarget_H);
}
a_CMV_Y_Int = (mCMV_Y & (~0xFF)) >> intPartShift;
a_CMV_Y_Flt = (mCMV_Y & (0xFF)) << floatPartShift;
}
EIS_LOG("X_Int(%u),X_Flt(%u),Y_Int(%u),Y_Flt(%u)",a_CMV_X_Int,
a_CMV_X_Flt,
a_CMV_Y_Int,
a_CMV_Y_Flt);
}
else
{
MINT32 EisHal::doEIS()
{
if(mConfigPass == MTRUE)
{
MINT32 err = EIS_RETURN_NO_ERROR;
EIS_SET_PROC_INFO_STRUCT sEIS_AlgSetInfo;
EIS_RESULT_INFO_STRUCT sEIS_Result;
char value[PROPERTY_VALUE_MAX] = {'\0'};
property_get("debug.eis.dump", value, "0");
g_debugDump = atoi(value);
if(g_debugDump >= 1)
{
EIS_LOG("+");
}
//====== Get Statistic from EIS Driver ======
sEIS_AlgSetInfo.eis_image_size_config.InputWidth = mInput_W;
sEIS_AlgSetInfo.eis_image_size_config.InputHeight = mInput_H;
sEIS_AlgSetInfo.eis_image_size_config.TargetWidth = mTarget_W;
sEIS_AlgSetInfo.eis_image_size_config.TargetHeight = mTarget_H;
getEISStatistic(&sEIS_AlgSetInfo.eis_state);
if(g_debugDump >= 1)
{
dumpStatistic(sEIS_AlgSetInfo.eis_state);
}
//====== EIS Algorithm Calculate CMV ======
err = m_pEisAlg->EisFeatureCtrl(EIS_FEATURE_SET_PROC_INFO, &sEIS_AlgSetInfo, NULL);
if(err != S_EIS_OK)
{
EIS_ERR("EisFeatureCtrl(EIS_FEATURE_SET_PROC_INFO) fail(0x%x)",err);
err = EIS_RETURN_API_FAIL;
return err;
}
err = m_pEisAlg->EisMain(&sEIS_Result);
if(err != S_EIS_OK)
{
EIS_ERR("EisMain fail(0x%x)",err);
err = EIS_RETURN_API_FAIL;
return err;
}
//====== Get GMV ======
EIS_GMV_INFO_STRUCT eisGMVInfo;
err = m_pEisAlg->EisFeatureCtrl(EIS_FEATURE_GET_ORI_GMV, NULL, &eisGMVInfo);
if(err != S_EIS_OK)
{
EIS_ERR("EisFeatureCtrl(EIS_FEATURE_GET_ORI_GMV) fail(0x%x)",err);
err = EIS_RETURN_API_FAIL;
return err;
}
//====== Save EIS CMV and GMV =======
mCMV_X = sEIS_Result.CMV_X;
mCMV_Y = sEIS_Result.CMV_Y;
mGMV_X = eisGMVInfo.EIS_GMVx;
mGMV_Y = eisGMVInfo.EIS_GMVy;
//====== Not The First Frame ======
if(mFirstFlag == 0)
{
EIS_LOG("not first frame");
m_pEisDrv->setFirstFrame(MFALSE);
mFirstFlag = 1;
}
//====== Debug ======
if(g_debugDump >= 1 && mFirstFlag < 3)
{
m_pEisDrv->dumpReg();
++mFirstFlag;
}
if(g_debugDump >= 1)
{
EIS_LOG("-");
}
}
else
{
EIS_LOG("EIS config fail, do nothing");
}
return EIS_RETURN_NO_ERROR;
}
MVOID EisHal::configEIS(NSHwScenario::EhwMode a_ehwMode, eisHal_config_t a_sEisConfig)
{
EIS_LOG("HW_Sce(%d)",(MINT32)a_ehwMode);
MINT32 err = 0;
EIS_GET_PROC_INFO_STRUCT eisHWSetting;
EIS_SET_ENV_INFO_STRUCT eisAlgoInit;
EIS_CONFIG_IMAGE_INFO_STRUCT eisImageSize;
//====== Member Variable Setting ======
mConfigPass = MFALSE;
//====== Dynamic Debug ======
char value[PROPERTY_VALUE_MAX] = {'\0'};
property_get("debug.eis.dump", value, "0");
g_debugDump = atoi(value);
//====== EIS Register Setting ======
//member variable setting
mInput_W = a_sEisConfig.imageWidth;
mInput_H = a_sEisConfig.imageHeight;
mTarget_W = (mInput_W / (EIS_FACTOR / 100.0));
mTarget_H = (mInput_H / (EIS_FACTOR / 100.0));
EIS_LOG("mInput_W(%u),mInput_H(%u),mTarget_W(%u),mTarget_H(%u)",mInput_W,mInput_H,mTarget_W,mTarget_H);
if(a_ehwMode == NSHwScenario::eHW_VSS)
{
eisAlgoInit.Eis_Input_Path = EIS_PATH_RAW_DOMAIN;
//RAW domain only setting
m_pEisDrv->setEIS_DB_SEL(1);
m_pEisDrv->setEISRawSel(1);
}
else if(a_ehwMode == NSHwScenario::eHW_ZSD)
{
eisAlgoInit.Eis_Input_Path = EIS_PATH_YUV_DOMAIN;
//YUV domain only setting
m_pEisDrv->setEIS_DB_SEL(0);
m_pEisDrv->setEISRawSel(0);
}
else
{
EIS_LOG("not support right now, use VSS");
eisAlgoInit.Eis_Input_Path = EIS_PATH_RAW_DOMAIN;
//RAW domain only setting
m_pEisDrv->setEIS_DB_SEL(1);
m_pEisDrv->setEISRawSel(1);
}
// get customize setting
getEISCustomize(&eisAlgoInit.eis_tuning_data);
// set image size info
eisImageSize.InputWidth = mInput_W - 4; //@ryan wang: sync eis parameters in middleware and algorithm to avoid "wrong boundry" issue
eisImageSize.InputHeight = mInput_H - 4; //@ryan wang: sync eis parameters in middleware and algorithm to avoid "wrong boundry" issue
eisImageSize.TargetWidth = mTarget_W;
eisImageSize.TargetHeight = mTarget_H;
// init EIS algo
err = m_pEisAlg->EisInit(&eisAlgoInit);
if(err != S_EIS_OK)
{
EIS_ERR("EisInit fail(0x%x)",err);
return;
}
// query setting from EIS algorithm
err = m_pEisAlg->EisFeatureCtrl(EIS_FEATURE_GET_PROC_INFO, &eisImageSize, &eisHWSetting);
if(err != S_EIS_OK)
{
EIS_ERR("EisFeatureCtrl(EIS_FEATURE_GET_PROC_INFO) fail(0x%x)",err);
return;
}
if(g_debugDump >= 1)
{
EIS_LOG("Algo eis_tuning_data");
EIS_LOG("sensitivity(%d)",eisAlgoInit.eis_tuning_data.sensitivity);
EIS_LOG("filter_small_motion(%u)",eisAlgoInit.eis_tuning_data.filter_small_motion);
EIS_LOG("advtuning_data.new_tru_th(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.new_tru_th);
EIS_LOG("advtuning_data.vot_th(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.vot_th);
EIS_LOG("advtuning_data.votb_enlarge_size(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.votb_enlarge_size);
EIS_LOG("advtuning_data.min_s_th(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.min_s_th);
EIS_LOG("advtuning_data.vec_th(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.vec_th);
EIS_LOG("advtuning_data.spr_offset(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.spr_offset);
EIS_LOG("advtuning_data.spr_gain1(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.spr_gain1);
EIS_LOG("advtuning_data.spr_gain2(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.spr_gain2);
EIS_LOG("advtuning_data.vot_his_method(%d)",eisAlgoInit.eis_tuning_data.advtuning_data.vot_his_method);
EIS_LOG("advtuning_data.smooth_his_step(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.smooth_his_step);
EIS_LOG("advtuning_data.eis_debug(%u)",eisAlgoInit.eis_tuning_data.advtuning_data.eis_debug);
for(MINT32 i = 0; i < 4; ++i)
{
EIS_LOG("gmv_pan_array[%d]=%u",i,eisAlgoInit.eis_tuning_data.advtuning_data.gmv_pan_array[i]);
EIS_LOG("gmv_sm_array[%d]=%u",i,eisAlgoInit.eis_tuning_data.advtuning_data.gmv_sm_array[i]);
EIS_LOG("cmv_pan_array[%d]=%u",i,eisAlgoInit.eis_tuning_data.advtuning_data.cmv_pan_array[i]);
EIS_LOG("cmv_sm_array[%d]=%u",i,eisAlgoInit.eis_tuning_data.advtuning_data.cmv_sm_array[i]);
}
EIS_LOG("Algo eisHWSetting");
EIS_LOG("pathCDRZ(0x%x)",eisHWSetting.pathCDRZ);
EIS_LOG("IIR_DS(0x%x)",eisHWSetting.IIR_DS);
EIS_LOG("MBNum_H(0x%x),MBNum_V(0x%x)",eisHWSetting.MBNum_H, eisHWSetting.MBNum_V);
EIS_LOG("RPNum_H(0x%x),RPNum_V(0x%x)",eisHWSetting.RPNum_H,eisHWSetting.RPNum_V);
EIS_LOG("AD_Knee(0x%x),AD_Clip(0x%x)",eisHWSetting.AD_Knee, eisHWSetting.AD_Clip);
EIS_LOG("Gain_H(0x%x),IIR_Gain_H(0x%x),FIR_Gain_H(0x%x)",eisHWSetting.Gain_H, eisHWSetting.IIR_Gain_H, eisHWSetting.FIR_Gain_H);
EIS_LOG("IIR_Gain_V(0x%x)",eisHWSetting.IIR_Gain_V);
EIS_LOG("LMV_TH_X_Cent(0x%x),LMV_TH_X_Surrd(0x%x),LMV_TH_Y_Cent(0x%x),LMV_TH_Y_Surrd(0x%x)",eisHWSetting.LMV_TH_X_Cent,eisHWSetting.LMV_TH_X_Surrd,eisHWSetting.LMV_TH_Y_Cent,eisHWSetting.LMV_TH_Y_Surrd);
EIS_LOG("FL_Offset_H(0x%x),FL_Offset_V(0x%x)",eisHWSetting.FL_Offset_H, eisHWSetting.FL_Offset_V);
EIS_LOG("MB_Offset_H(0x%x),MB_Offset_V(0x%x)",eisHWSetting.MB_Offset_H,eisHWSetting.MB_Offset_V);
EIS_LOG("MB_Intv_H(0x%x),MB_Intv_V(0x%x)",eisHWSetting.MB_Intv_H,eisHWSetting.MB_Intv_V);
}
// HW setting
if(mFirstFlag == 0)
{
EIS_LOG("first frame");
m_pEisDrv->setFirstFrame(MTRUE);
}
m_pEisDrv->enableEIS(MTRUE);
m_pEisDrv->setWRPEnable(MTRUE); // enable write RP function
//m_pEisDrv->setEISSel(eisHWSetting.pathCDRZ); //YUV domain only setting
m_pEisDrv->setEISSel(1); //always after CDRZ. modified for ZSDNCC
m_pEisDrv->setEISImage(mInput_W,mInput_H);
m_pEisDrv->setEISFilterDS(eisHWSetting.IIR_DS);
m_pEisDrv->setMBNum(eisHWSetting.MBNum_H, eisHWSetting.MBNum_V);
m_pEisDrv->setRPNum(eisHWSetting.RPNum_H,eisHWSetting.RPNum_V);
m_pEisDrv->setADKneeClip(eisHWSetting.AD_Knee, eisHWSetting.AD_Clip);
m_pEisDrv->setFilter_H(eisHWSetting.Gain_H, eisHWSetting.IIR_Gain_H, eisHWSetting.FIR_Gain_H);
m_pEisDrv->setFilter_V(eisHWSetting.IIR_Gain_V);
m_pEisDrv->setLMV_TH(eisHWSetting.LMV_TH_X_Cent,eisHWSetting.LMV_TH_X_Surrd,eisHWSetting.LMV_TH_Y_Cent,eisHWSetting.LMV_TH_Y_Surrd);
m_pEisDrv->setFLOffset(eisHWSetting.FL_Offset_H, eisHWSetting.FL_Offset_V);
m_pEisDrv->setMBOffset_H(eisHWSetting.MB_Offset_H);
m_pEisDrv->setMBOffset_V(eisHWSetting.MB_Offset_V);
m_pEisDrv->setMBInterval_H(eisHWSetting.MB_Intv_H);
m_pEisDrv->setMBInterval_V(eisHWSetting.MB_Intv_V);
err = m_pEisDrv->configStatus();
if(err != EIS_RETURN_NO_ERROR)
{
EIS_ERR("EIS_Drv register setting fail(%d)",err);
EIS_LOG("*** Do again ***");
m_pEisDrv->resetConfigStatus();
if(a_ehwMode == NSHwScenario::eHW_VSS)
{
//RAW domain only setting
m_pEisDrv->setEIS_DB_SEL(1);
m_pEisDrv->setEISRawSel(1);
}
else if(a_ehwMode == NSHwScenario::eHW_ZSD)
{
//YUV domain only setting
m_pEisDrv->setEIS_DB_SEL(0);
m_pEisDrv->setEISRawSel(0);
}
else
{
EIS_LOG("not support right now, use VSS");
//RAW domain only setting
m_pEisDrv->setEIS_DB_SEL(1);
m_pEisDrv->setEISRawSel(1);
}
// HW setting
if(mFirstFlag == 0)
{
EIS_LOG("first frame");
m_pEisDrv->setFirstFrame(MTRUE);
}
m_pEisDrv->enableEIS(MTRUE);
m_pEisDrv->setWRPEnable(MTRUE); // enable write RP function
//m_pEisDrv->setEISSel(eisHWSetting.pathCDRZ); //YUV domain only setting
m_pEisDrv->setEISSel(1); //always after CDRZ. modified for ZSDNCC
m_pEisDrv->setEISImage(mInput_W,mInput_H);
m_pEisDrv->setEISFilterDS(eisHWSetting.IIR_DS);
m_pEisDrv->setMBNum(eisHWSetting.MBNum_H, eisHWSetting.MBNum_V);
m_pEisDrv->setRPNum(eisHWSetting.RPNum_H,eisHWSetting.RPNum_V);
m_pEisDrv->setADKneeClip(eisHWSetting.AD_Knee, eisHWSetting.AD_Clip);
m_pEisDrv->setFilter_H(eisHWSetting.Gain_H, eisHWSetting.IIR_Gain_H, eisHWSetting.FIR_Gain_H);
m_pEisDrv->setFilter_V(eisHWSetting.IIR_Gain_V);
m_pEisDrv->setLMV_TH(eisHWSetting.LMV_TH_X_Cent,eisHWSetting.LMV_TH_X_Surrd,eisHWSetting.LMV_TH_Y_Cent,eisHWSetting.LMV_TH_Y_Surrd);
m_pEisDrv->setFLOffset(eisHWSetting.FL_Offset_H, eisHWSetting.FL_Offset_V);
m_pEisDrv->setMBOffset_H(eisHWSetting.MB_Offset_H);
m_pEisDrv->setMBOffset_V(eisHWSetting.MB_Offset_V);
m_pEisDrv->setMBInterval_H(eisHWSetting.MB_Intv_H);
m_pEisDrv->setMBInterval_V(eisHWSetting.MB_Intv_V);
err = m_pEisDrv->configStatus();
if(err != EIS_RETURN_NO_ERROR)
{
mConfigPass = MFALSE;
}
else
{
mConfigPass = MTRUE;
}
}
else
{
mConfigPass = MTRUE;
}
if(g_debugDump >= 1)
{
m_pEisDrv->dumpReg();
}
EIS_LOG("-");
}
MINT32 EisHal::uninit()
{
EIS_LOG("mUsers(%d)", mUsers);
Mutex::Autolock lock(mLock);
//====== Check Reference Count ======
if(mUsers <= 0)
{
EIS_LOG("There is no more user");
return EIS_RETURN_NO_ERROR;
}
//====== Uninitialize ======
android_atomic_dec(&mUsers); //decrease referebce count
if(mUsers == 0) // there is no user
{
MINT32 err = EIS_RETURN_NO_ERROR;
//====== Dynamic Debug ======
char value[PROPERTY_VALUE_MAX] = {'\0'};
property_get("debug.eis.dump", value, "0");
g_debugDump = atoi(value);
if(g_debugDump >= 2)
{
EIS_SET_LOG_BUFFER_STRUCT pEisAlgoLogInfo;
pEisAlgoLogInfo.Eis_Log_Buf_Addr = mEisAlgoIMemBuf.virtAddr;
pEisAlgoLogInfo.Eis_Log_Buf_Size = mEisAlgoIMemBuf.size;
err = m_pEisAlg->EisFeatureCtrl(EIS_FEATURE_SAVE_LOG, &pEisAlgoLogInfo, NULL);
if(err != S_EIS_OK)
{
EIS_ERR("EisFeatureCtrl(EIS_FEATURE_SAVE_LOG) fail(0x%x)",err);
}
}
m_pEisDrv->enableEIS(0);
if(m_pEisDrv != NULL)
{
m_pEisDrv->destroyInstance();
m_pEisDrv = NULL;
}
if(m_pEisAlg != NULL)
{
m_pEisAlg->destroyInstance();
m_pEisAlg = NULL;
}
if(g_debugDump >= 2)
{
//====== Free Memory ======
destroyMemBuf(1,&mEisAlgoIMemBuf);
mEisAlgoIMemBuf.memID = -5;
mEisAlgoIMemBuf.virtAddr = mEisAlgoIMemBuf.phyAddr = mEisAlgoIMemBuf.size = 0;
if(m_pIMemDrv != NULL)
{
m_pIMemDrv->destroyInstance();
m_pIMemDrv = NULL;
}
}
mFirstFlag = 0; // first frmae
mConfigPass = MFALSE;
}
else
{
EIS_LOG("Still %d users", mUsers);
}
EIS_LOG("-");
return EIS_RETURN_NO_ERROR;
}
MINT32 EisHal::init()
{
EIS_LOG("mUsers(%d)", mUsers);
//====== Check Reference Count ======
Mutex::Autolock lock(mLock);
if(mUsers > 0)
{
EIS_LOG("%d has created", mUsers);
android_atomic_inc(&mUsers);
return EIS_RETURN_NO_ERROR;
}
//====== Dynamic Debug ======
char value[PROPERTY_VALUE_MAX] = {'\0'};
property_get("debug.eis.dump", value, "0");
g_debugDump = atoi(value);
//====== Create EIS Driver ======
m_pEisDrv = EisDrvBase::createInstance();
if(m_pEisDrv == NULL)
{
EIS_ERR("EisDrv::createInstance fail");
goto create_fail_exit;
}
//====== Create EIS Algorithm Object ======
m_pEisAlg = MTKEis::createInstance();
if(m_pEisAlg == NULL)
{
EIS_ERR("EisAlg::createInstance fail");
goto create_fail_exit;
}
if(g_debugDump >= 2)
{
//====== EisAlgo Debug Buffer ======
m_pIMemDrv = IMemDrv::createInstance();
if(m_pIMemDrv == NULL)
{
EIS_ERR("Null IMemDrv Obj");
return EIS_RETURN_NULL_OBJ;
}
MUINT32 eisMemSize = EIS_LOG_BUFFER_SIZE;
createMemBuf(eisMemSize,1,&mEisAlgoIMemBuf);
if(mEisAlgoIMemBuf.virtAddr == 0 && mEisAlgoIMemBuf.phyAddr == 0)
{
EIS_ERR("create IMem fail");
return EIS_RETURN_MEMORY_ERROR;
}
EIS_LOG("mEisAlgoIMemBuf : memID(%d),size(%u),virAdd(0x%x),phyAddr(0x%x)",mEisAlgoIMemBuf.memID,
mEisAlgoIMemBuf.size,
mEisAlgoIMemBuf.virtAddr,
mEisAlgoIMemBuf.phyAddr);
}
android_atomic_inc(&mUsers);
EIS_LOG("-");
return EIS_RETURN_NO_ERROR;
create_fail_exit:
if(m_pEisDrv != NULL)
{
m_pEisDrv->destroyInstance();
m_pEisDrv = NULL;
}
if(m_pEisAlg != NULL)
{
m_pEisAlg->destroyInstance();
m_pEisAlg = NULL;
}
EIS_LOG("-");
return EIS_RETURN_INVALID_DRIVER;
}
