/* * This function launches the loading of the flash tuning data */ TuningLoaderMgrError_t CTuningLoaderManager::loadFlashTuningData(const t_flash_info* pFlashInfo) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::loadFlashTuningData", (mTraceObject)); // Check if constructed if(iNmfInstance == NULL) { MSG0("Instance not constructed\n"); OstTraceFiltStatic0(TRACE_ERROR, "Instance not constructed", (mTraceObject)); OUTR(" ",TUNING_LOADER_MGR_NOT_CONSTRUCTED); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadFlashTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_NOT_CONSTRUCTED); return TUNING_LOADER_MGR_NOT_CONSTRUCTED; } // Aguments sanity check if( pFlashInfo == NULL) { MSG1("Bad argument: pFlashInfo=%p\n", pFlashInfo); OstTraceFiltStatic1(TRACE_ERROR, "Bad argument: pFlashInfo=0x%x", (mTraceObject), (t_uint32)pFlashInfo); OUTR(" ",TUNING_LOADER_MGR_BAD_ARGUMENT); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadFlashTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_BAD_ARGUMENT); return TUNING_LOADER_MGR_BAD_ARGUMENT; } // Send command to NMF MSG0("Send 'loadFlashTuning' command to NMF\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Send 'loadFlashTuning' command to NMF", (mTraceObject)); iNmfQueryIntf.loadFlashTuning(*pFlashInfo); OUTR(" ",TUNING_LOADER_MGR_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadFlashTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_OK); return TUNING_LOADER_MGR_OK; }
TuningLoaderMgrError_t CTuningLoaderManager::saveNvmTuningData(const t_camera_info* pCamInfo,unsigned char* pNvm, t_uint32 aSize) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::saveNvmTuningData", (mTraceObject)); // Check if constructed if(iNmfInstance == NULL) { MSG0("Instance not constructed\n"); OstTraceFiltStatic0(TRACE_ERROR, "Instance not constructed", (mTraceObject)); OUTR(" ",TUNING_LOADER_MGR_NOT_CONSTRUCTED); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadNvmTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_NOT_CONSTRUCTED); return TUNING_LOADER_MGR_NOT_CONSTRUCTED; } // Aguments sanity check if( (pCamInfo == NULL) || (pNvm ==NULL) || (aSize == 0)) { MSG1("Bad argument: pCamInfo=%x, pNvm=0x%x, aSize=%x\n", (unsigned int)pCamInfo,(unsigned int)pNvm,(unsigned int)aSize); OstTraceFiltStatic3(TRACE_ERROR, "Bad argument: pCamInfo=0x%x pNvm=0x%x, aSize=%d", (mTraceObject), (t_uint32)pCamInfo,(t_uint32)pNvm,aSize); OUTR(" ",TUNING_LOADER_MGR_BAD_ARGUMENT); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadNvmTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_BAD_ARGUMENT); return TUNING_LOADER_MGR_BAD_ARGUMENT; } // Send command to NMF MSG0("Send 'SaveNvmTuning' command to NMF\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Send 'loadNvmTuning' command to NMF", (mTraceObject)); iNmfQueryIntf.saveNvmTuning(*pCamInfo,(t_uint32)pNvm,aSize); OUTR(" ",TUNING_LOADER_MGR_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::loadNvmTuningData (%d)", (mTraceObject), TUNING_LOADER_MGR_OK); return TUNING_LOADER_MGR_OK; }
OMX_ERRORTYPE JPEGEnc_ArmNmfProcessingComponent::allocateBuffer( OMX_U32 nPortIndex, OMX_U32 nBufferIndex, OMX_U32 nSizeBytes, OMX_U8 **ppData, void **bufferAllocInfo, void **portPrivateInfo) { OstTraceFiltStatic1(TRACE_API, "In JPEGEnc_ArmNmfProcessingComponent : In allocateBuffer <line no %d> ",pProxyComponent,__LINE__); OMX_ERRORTYPE error; if (pProxyComponent->isHVABased) { error = allocateBufferVisual(nPortIndex, nBufferIndex, nSizeBytes, ppData, bufferAllocInfo, portPrivateInfo,OMX_FALSE); } else { error = allocateBufferVisual(nPortIndex, nBufferIndex, nSizeBytes, ppData, bufferAllocInfo, portPrivateInfo,OMX_TRUE); } if (error != OMX_ErrorNone) { OstTraceInt2(TRACE_ERROR, "In JPEGEnc_ArmNmfProcessingComponent : Error While allocating buffer errorType : 0x%x error line no %d\n",error,__LINE__); //jpegenc_armnmf_assert(error,__LINE__, OMX_TRUE); return error; } OstTraceFiltStatic3(TRACE_FLOW, "In JPEGEnc_ArmNmfProcessingComponent : In allocateBuffer nPortIndex : %d nSizeBytes : %d <line no %d> ",pProxyComponent,nPortIndex,nSizeBytes,__LINE__); OstTraceFiltStatic1(TRACE_API, "In JPEGEnc_ArmNmfProcessingComponent : allocateBuffer DONE <line no %d> ",pProxyComponent,__LINE__); return OMX_ErrorNone; }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CDefCorDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CDefCorDamper::ComputeAndQueuePEs", (mTraceObject)); float pDamperValues[DEFCOR_DAMPERS_NUM] = {0.0, 0.0}; t_damper_error_code err = DAMPER_OK; // Evaluate DefCor dampers err = DoEvaluate( pBaseValues, pDamperValues); if(err!=DAMPER_OK) { DBGT_ERROR("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Queue the Page Elements for(int i=0; i<DEFCOR_DAMPERS_NUM; i++) { MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(KDefCorDamperInfo[i].addr), pDamperValues[i]); //OstTraceFiltStatic2(TRACE_DEBUG, "%s = %f", (mTraceObject), CXp70::GetPeName(KDefCorDamperInfo[i].addr), pDamperValues[i]); pIspctlCom->queuePE( KDefCorDamperInfo[i].addr, (t_uint32)pDamperValues[i]); } // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CNoiseFilterDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CNoiseFilterDamper::ComputeAndQueuePEs", (mTraceObject)); float pDampedValues[1] = { 0.0 }; t_damper_error_code err = DAMPER_OK; // Evaluate Noise Filter dampers err = DoEvaluate( pBaseValues, pDampedValues); if(err!=DAMPER_OK) { DBGT_ERROR("Failed to evaluate damper: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Failed to evaluate damper: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseFilterDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Queue the Page Elements float fGaussianWeightDamped = pDampedValues[0]; MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(DusterControl_u8_GaussianWeight_Byte0), fGaussianWeightDamped); OstTraceFiltStatic1(TRACE_DEBUG, "DusterControl_u8_GaussianWeight = %f", (mTraceObject), fGaussianWeightDamped); pIspctlCom->queuePE( DusterControl_u8_GaussianWeight_Byte0, (t_uint32)fGaussianWeightDamped); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseFilterDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
camSharedMemError_t CCamSharedMemory::getChunk(camSharedMemChunk_t *pChunk, camSharedMemChunkId_t chunkId) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::getChunk", (mTraceObject)); if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getChunk (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_STATE); return CAM_SHARED_MEM_ERR_BAD_STATE; } if (chunkId >= CAM_SHARED_MEM_CHUNK_MAX) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getChunk (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PARAMETER); return CAM_SHARED_MEM_ERR_BAD_PARAMETER; } if (abBusyChunks[chunkId]) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getChunk (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PRECONDITION); return CAM_SHARED_MEM_ERR_BAD_PRECONDITION; } abBusyChunks[chunkId] = true; *pChunk = aChunks[chunkId]; OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getChunk (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE); return CAM_SHARED_MEM_ERR_NONE; }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CScorpioDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CScorpioDamper::ComputeAndQueuePEs", (mTraceObject)); float pDampedValues[1] = { 0.0 }; float fCoringLevel = 0.0; t_damper_error_code err = DAMPER_OK; // Evaluate Scorpio dampers err = DoEvaluate( pBaseValues, pDampedValues); if(err!=DAMPER_OK) { DBGT_ERROR("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CScorpioDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Queue the Page Elements list fCoringLevel = pDampedValues[0]; MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(Scorpio_Ctrl_u8_CoringLevel_Ctrl_Byte0), fCoringLevel); OstTraceFiltStatic1(TRACE_DEBUG, "Scorpio_Ctrl_u8_CoringLevel_Ctrl = %f", (mTraceObject), fCoringLevel); pIspctlCom->queuePE( Scorpio_Ctrl_u8_CoringLevel_Ctrl_Byte0, (t_uint32)fCoringLevel); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CScorpioDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/* * This function sets the sharpening damper */ t_damper_error_code CSharpeningDamperLR::SetDamper( const t_sharpening_damper_lr_id aDamperId, const float* pValues, const int aNumRows, const int aNumCols) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CSharpeningDamperLR::SetDamper", (mTraceObject)); t_damper_error_code err = DAMPER_OK; if(aDamperId<0 || aDamperId>=SHARPENING_DAMPERS_LR_NUM) { DBGT_ERROR("Invalid damper Id: %d\n", aDamperId); OstTraceFiltStatic1(TRACE_ERROR, "Invalid damper Id: %d", (mTraceObject), aDamperId); OUTR(" ",DAMPER_INVALID_ARGUMENT); OstTraceFiltStatic1(TRACE_FLOW, "Exit CSharpeningDamperLR::SetDamper (%d)", (mTraceObject), DAMPER_INVALID_ARGUMENT); return DAMPER_INVALID_ARGUMENT; } MSG3("[%s] NumRows=%d, NumCols=%d\n", SHARPENING_DAMPER_LR_NAME(aDamperId), aNumRows, aNumCols); OstTraceFiltStatic3(TRACE_DEBUG, "SHARPENING_DAMPER_LR_NAME(%d) NumRows=%d, NumCols=%d", (mTraceObject), aDamperId, aNumRows, aNumCols); err = DoSetDamper( aDamperId, pValues, aNumRows, aNumCols); if(err!=DAMPER_OK) { DBGT_ERROR("[%s] failed to set damper: err=%d\n", SHARPENING_DAMPER_LR_NAME(aDamperId), err); OstTraceFiltStatic2(TRACE_ERROR, "SHARPENING_DAMPER_LR_NAME(%d) failed to set damper: err=%d", (mTraceObject), aDamperId, err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CSharpeningDamperLR::SetDamper (%d)", (mTraceObject), err); return err; } OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CSharpeningDamperLR::SetDamper (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/* * This function sets the DefCor dampers */ t_damper_error_code CDefCorDamper::SetDamper( const t_defcor_damper_id aDamperId, const float* pValues, const int aNumRows, const int aNumCols) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CDefCorDamper::SetDamper", (mTraceObject)); t_damper_error_code err = DAMPER_OK; if(aDamperId<0 || aDamperId>=DEFCOR_DAMPERS_NUM) { DBGT_ERROR("Invalid damper Id: %d\n", aDamperId); OstTraceFiltStatic1(TRACE_ERROR, "Invalid damper Id: %d", (mTraceObject), aDamperId); OUTR(" ",DAMPER_INVALID_ARGUMENT); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), DAMPER_INVALID_ARGUMENT); return DAMPER_INVALID_ARGUMENT; } MSG3("[%s] NumRows=%d, NumCols=%d\n", KDefCorDamperInfo[aDamperId].name, aNumRows, aNumCols); OstTraceFiltStatic3(TRACE_DEBUG, "[KDefCorDamperInfo[%d].name] NumRows=%d, NumCols=%d", (mTraceObject), aDamperId, aNumRows, aNumCols); err = DoSetDamper( aDamperId, pValues, aNumRows, aNumCols); if(err!=DAMPER_OK) { DBGT_ERROR("[%s] failed to set damper: err=%d\n", KDefCorDamperInfo[aDamperId].name, err); OstTraceFiltStatic2(TRACE_ERROR, "[KDefCorDamperInfo[%d].name] failed to set damper: err=%d", (mTraceObject), aDamperId, err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), err); return err; } OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
SCF_STATE CAM_SM::PowerUp_STC_CheckCoin(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: { ENTRY; MSG0("PowerUp_STC_CheckCoin-SCF_STATE_ENTRY_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_CheckCoin-SCF_STATE_ENTRY_SIG", (&mENSComponent)); // Get coin value pIspctlCom->queuePE(Sensor_Tuning_Status_e_Coin_SubBlock_Status_Byte0,0); pIspctlCom->readQueue(); return 0; } case EVT_ISPCTL_LIST_INFO_SIG: { MSG0("PowerUp_STC_CheckCoin-EVT_ISPCTL_LIST_INFO_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_CheckCoin-EVT_ISPCTL_LIST_INFO_SIG", (&mENSComponent)); if (e->type.ispctlInfo.info_id != ISP_READLIST_DONE) break; //#if defined (OSI_DEBUG) for(t_uint16 i=0; i < e->type.ispctlInfo.number_of_pe; i++) { MSG4(" PE[%d] 0x%X (%s) = 0x%lX\n", i, e->type.ispctlInfo.Listvalue[i].pe_addr, pSensor->GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data ); //OstTraceFiltStatic4(TRACE_DEBUG, " PE[%d] 0x%X (%s) = 0x%lX", (&mENSComponent), i, e->type.ispctlInfo.Listvalue[i].pe_addr, CXp70::GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data ); } //#endif if( (Coin_te)e->type.ispctlInfo.Listvalue[0].pe_data == iStatusCoin) { // Coin state has not changed yet if(iStatusCoinRetriesCount>=10) { MSG0("***** Coin state unchanged, too many attempts *****\n"); OstTraceFiltStatic0(TRACE_DEBUG, "***** Coin state unchanged, too many attempts *****", (&mENSComponent)); DBC_ASSERT(0); return 0; } MSG1(" Coin state unchanged (state=%d) => try again\n", (int)iStatusCoin); OstTraceFiltStatic1(TRACE_DEBUG, "Coin state unchanged (state=%d) => try again", (&mENSComponent), (int)iStatusCoin); iStatusCoinRetriesCount++; pIspctlCom->queuePE(Sensor_Tuning_Status_e_Coin_SubBlock_Status_Byte0,0); pIspctlCom->readQueue(); } else { // Coin state changed => we can read the block ID value iStatusCoin = (Coin_te) e->type.ispctlInfo.Listvalue[0].pe_data; MSG1(" Coin state unchanged (state=%d) => read Block ID value\n", (int)iStatusCoin); OstTraceFiltStatic1(TRACE_DEBUG, "Coin state unchanged (state=%d) => read Block ID value", (&mENSComponent), (int)iStatusCoin); iStatusCoinRetriesCount = 0; SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_ReadId); } return 0; } case SCF_STATE_EXIT_SIG: { EXIT; return 0; } default: break; } return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot); }
/* * NMF callback */ void CTuningLoaderManager::response(t_tuningloader_error aErr) { ASYNC_IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::response", (mTraceObject)); s_scf_event event; if(aErr==TUNING_LOADER_OK) { // NMF operation done: prepare COM_SM event MSG0("NMF operation completed\n"); OstTraceFiltStatic0(TRACE_DEBUG, "NMF operation completed", (mTraceObject)); event.sig = TUNING_LOADER_OPERATION_DONE_SIG; event.type.tuningLoaderEvent.error = TUNING_LOADER_OK; } else { // NMF operation failed: prepare COM_SM event MSG1("NMF operation failed: err=%d\n", aErr); OstTraceFiltStatic1(TRACE_ERROR, "NMF operation failed: err=%d", (mTraceObject), aErr); // Note: here the function iNmfSyncIntf.errorCode2String() cannot be called // as CTuningLoaderManager::response callback is called in the context of the ENS // Wrapper which has no reference to iNmfErrorIntf event.sig = TUNING_LOADER_OPERATION_FAILED_SIG; event.type.tuningLoaderEvent.error = aErr; } iSM->ProcessEvent(&event); ASYNC_OUT0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Exit CTuningLoaderManager::response", (mTraceObject)); }
/* * This function stops NMF */ TuningLoaderMgrError_t CTuningLoaderManager::stop() { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::stop", (mTraceObject)); if(iNmfInstance == NULL) { MSG0("NMF instance not constructed\n"); OstTraceFiltStatic0(TRACE_ERROR, "NMF instance not constructed", (mTraceObject)); OUTR(" ",TUNING_LOADER_MGR_NOT_CONSTRUCTED); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::stop (%d)", (mTraceObject), TUNING_LOADER_MGR_NOT_CONSTRUCTED); return TUNING_LOADER_MGR_NOT_CONSTRUCTED; } MSG0("Stopping NMF component\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Stopping NMF component", (mTraceObject)); iNmfInstance->stop_flush(); OUTR(" ",TUNING_LOADER_MGR_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::stop (%d)", (mTraceObject), TUNING_LOADER_MGR_OK); return TUNING_LOADER_MGR_OK; }
SCF_STATE CAM_SM::PowerUp_STC_ReadId(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: { ENTRY; MSG0("PowerUp_STC_ReadId-SCF_STATE_ENTRY_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_ReadId-SCF_STATE_ENTRY_SIG", (&mENSComponent)); pIspctlCom->queuePE(Sensor_Tuning_Status_u16_CurrentSubBlockIdValue_Byte0,0); pIspctlCom->readQueue(); return 0; } case EVT_ISPCTL_LIST_INFO_SIG: { MSG0("PowerUp_STC_ReadId-EVT_ISPCTL_LIST_INFO_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_ReadId-EVT_ISPCTL_LIST_INFO_SIG", (&mENSComponent)); if (e->type.ispctlInfo.info_id != ISP_READLIST_DONE) break; //#if defined (OSI_DEBUG) for(t_uint16 i=0; i < e->type.ispctlInfo.number_of_pe; i++) { MSG3(" PE[%d] %s = 0x%lX\n", i, pSensor->GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data ); //OstTraceFiltStatic3(TRACE_DEBUG, "PE[%d] %s = 0x%lX", (&mENSComponent), i, CXp70::GetPeName(e->type.ispctlInfo.Listvalue[i].pe_addr), e->type.ispctlInfo.Listvalue[i].pe_data ); } //#endif // Store tuning BlockId value pFwSubBlockId[iCurrentFwSubBlockIndex] = (t_uint16)e->type.ispctlInfo.Listvalue[0].pe_data; MSG2(" FwSubBlockId[%d] = ID%d\n", iCurrentFwSubBlockIndex, pFwSubBlockId[iCurrentFwSubBlockIndex]); OstTraceFiltStatic2(TRACE_DEBUG, "FwSubBlockId[%d] = ID%d", (&mENSComponent), iCurrentFwSubBlockIndex, pFwSubBlockId[iCurrentFwSubBlockIndex]); // Another block to be fetched ? iCurrentFwSubBlockIndex++; if(iCurrentFwSubBlockIndex<iFwSubBlockIdsCount) { // Still some tuning blocks IDs are to be fetched MSG0(" Some blocks ID are to be fetched\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Some blocks ID are to be fetched", (&mENSComponent)); SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_QueryId); } else { // All tuning blocks IDs were fetched MSG1(" All block IDs were fetched: total %d\n", iFwSubBlockIdsCount); OstTraceFiltStatic1(TRACE_DEBUG, "All block IDs were fetched: total %d", (&mENSComponent), iFwSubBlockIdsCount); //#if defined (OSI_DEBUG) for(t_uint16 i=0; i<iFwSubBlockIdsCount; i++) { MSG2(" FwSubBlockId[%d] = ID%d\n", i, pFwSubBlockId[i]); OstTraceFiltStatic2(TRACE_DEBUG, "FwSubBlockId[%d] = ID%d", (&mENSComponent), i, pFwSubBlockId[i]); } //#endif SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_LoadData); } return 0; } case SCF_STATE_EXIT_SIG: { EXIT; return 0; } default: break; } return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot); }
camSharedMemError_t CCamSharedMemory::cacheClean(camSharedMemChunkId_t chunkId) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::cacheClean", (mTraceObject)); if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_STATE); return CAM_SHARED_MEM_ERR_BAD_STATE; } if (chunkId >= CAM_SHARED_MEM_CHUNK_MAX) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PARAMETER); return CAM_SHARED_MEM_ERR_BAD_PARAMETER; } #ifndef CAM_SHARED_MEM_DEBUG /* Exceptionally allow cleaning before the chunk has been requested. For memory debug purpose. */ if (! abBusyChunks[chunkId]) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PRECONDITION); return CAM_SHARED_MEM_ERR_BAD_PRECONDITION; } #endif /* CAM_SHARED_MEM_DEBUG */ OMX_U32 aPhysAddr; // out /* OMX_ERRORTYPE e_ret = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncBeforeReadHwOperation, * After the switch to the 2.6.35 kernel version, MMHwBuffer cache synchronization has changed * (switch from pmem to hwmem driver), with an impact on the API => sync before read AND before write are mandatory. */ OMX_ERRORTYPE e_ret1 = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncBeforeReadHwOperation, (OMX_U32) aChunks[chunkId].armLogicalAddress, aChunks[chunkId].size, aPhysAddr); OMX_ERRORTYPE e_ret2 = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncBeforeWriteHwOperation, (OMX_U32) aChunks[chunkId].armLogicalAddress, aChunks[chunkId].size, aPhysAddr); if ((e_ret1 != OMX_ErrorNone) || (e_ret2 != OMX_ErrorNone)){ MSG2("Problem cleaning data cache (err=%d);%d\n", e_ret1, e_ret2); OstTraceFiltStatic2(TRACE_DEBUG, "Problem cleaning data cache (err=%d);%d", (mTraceObject), e_ret1, e_ret2); OUT0(""); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NO_RESOURCE); return CAM_SHARED_MEM_ERR_NO_RESOURCE; } OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheClean (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE); return CAM_SHARED_MEM_ERR_NONE; }
/** *pBufHnd is written zero in case the memory pool is not cacheable and therefore * does not need to be synchronized. */ camSharedMemError_t CCamSharedMemory::getBufHnd(csm_uint32_t *pBufHnd) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::getBufHnd", (mTraceObject)); if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getBufHnd (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_STATE); return CAM_SHARED_MEM_ERR_BAD_STATE; } if (cacheMode == MMHwBuffer::ENormalCached) { *pBufHnd = (csm_uint32_t) sharedBufferPoolId; } else { *pBufHnd = 0; } OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::getBufHnd (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE); return CAM_SHARED_MEM_ERR_NONE; }
/* * COM_SM Handle setter */ void CTuningLoaderManager::setSM(CScfStateMachine* aSM) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::setSM", (mTraceObject)); iSM = aSM; MSG1("COM_SM Handle = %p\n", iSM); OstTraceFiltStatic1(TRACE_DEBUG, "COM_SM Handle = 0x%x", (mTraceObject), (t_uint32)iSM); OUT0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Exit CTuningLoaderManager::setSM", (mTraceObject)); }
camSharedMemError_t CCamSharedMemory::destroy() { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::destroy", (mTraceObject)); if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::create (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_STATE); return CAM_SHARED_MEM_ERR_BAD_STATE; } for (int i=0; i < CAM_SHARED_MEM_CHUNK_MAX; i++) { if (abBusyChunks[i]) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::create (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PRECONDITION); return CAM_SHARED_MEM_ERR_BAD_PRECONDITION; } } // Reset the T3 xp70 IS space mapping as the buffer is to be freed from the shared memory. if (state == CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) { (void) MMIO_Camera::mapStatisticsMemArea(0); } //Need to reset the trace buffer to finish the trace thread responsible for dumping FW traces. OMX_ERRORTYPE omx_error = MMIO_Camera::resetTraceBuffer(); if ( omx_error != OMX_ErrorNone) { MSG1("Problem resetting trace buffer (err=%d)\n", omx_error); } omx_error = MMHwBuffer::Destroy(sharedBufferPoolId); if (omx_error != OMX_ErrorNone) { MSG1("Problem freeing sharedBufferPoolId (err=%d)\n", omx_error); OstTraceFiltStatic1(TRACE_DEBUG, "Problem freeing sharedBufferPoolId (err=%d)", (mTraceObject), omx_error); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::create (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NO_RESOURCE); return CAM_SHARED_MEM_ERR_NO_RESOURCE; } reset(); state = CCamSharedMemory::CAM_SHARED_MEM_STATE_CLOSED; xp70TraceAddress = 0; xp70TracePhyAddress = 0; OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::create (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE); return CAM_SHARED_MEM_ERR_NONE; }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CNoiseModelDamper::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues, const float aAverageDigitalGain) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CNoiseModelDamper::ComputeAndQueuePEs", (mTraceObject)); float pDampedValues[1] = { 0.0 }; float fUserFrameSigma = 0.0; t_damper_error_code err = DAMPER_OK; // Evaluate Noise Model dampers err = DoEvaluate( pBaseValues, pDampedValues); if(err!=DAMPER_OK) { MSG1("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_DEBUG, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseModelDamper::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Scale the damper output by the reference Shading Correction Gain, Average Digital Gain and pipeline dynamic range // NOTE: the damper output is now the noise sigma at pipeline input, normalized to pipeline dynamic range MSG2("iShadingCorrectionGain=%f, aAverageDigitalGain=%f\n", iShadingCorrectionGain, aAverageDigitalGain); OstTraceFiltStatic2(TRACE_DEBUG, "iShadingCorrectionGain=%f, aAverageDigitalGain=%f", (mTraceObject), iShadingCorrectionGain, aAverageDigitalGain); fUserFrameSigma = pDampedValues[0] * iShadingCorrectionGain * aAverageDigitalGain * 4095.0; // Clip against hardware limit if(fUserFrameSigma >= 1024) { fUserFrameSigma = 1024; } // Queue the Page Elements MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(DusterControl_u16_FrameSigma_Byte0), fUserFrameSigma); OstTraceFiltStatic1(TRACE_DEBUG, "DusterControl_u16_FrameSigma = %f", (mTraceObject), fUserFrameSigma); pIspctlCom->queuePE( DusterControl_u16_FrameSigma_Byte0, (t_uint32)fUserFrameSigma); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseModelDamper::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/* * This function get the config file name of the flash */ TuningLoaderMgrError_t CTuningLoaderManager::getFlashConfigFileName(const char** pFlashCfgFileName) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CTuningLoaderManager::getFlashConfigFileName", (mTraceObject)); // Check if constructed if(iNmfInstance == NULL) { MSG0("Instance not constructed\n"); OstTraceFiltStatic0(TRACE_ERROR, "Instance not constructed", (mTraceObject)); OUTR(" ",TUNING_LOADER_MGR_NOT_CONSTRUCTED); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::getFlashConfigFileName (%d)", (mTraceObject), TUNING_LOADER_MGR_NOT_CONSTRUCTED); return TUNING_LOADER_MGR_NOT_CONSTRUCTED; } // Ask file name to NMF component *pFlashCfgFileName = iNmfSyncIntf.flashConfigFileName(); OUTR(" ",TUNING_LOADER_MGR_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CTuningLoaderManager::getFlashConfigFileName (%d)", (mTraceObject), TUNING_LOADER_MGR_OK); return TUNING_LOADER_MGR_OK; }
camSharedMemError_t CCamSharedMemory::cacheInvalidate(camSharedMemChunkId_t chunkId) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CCamSharedMemory::cacheInvalidate", (mTraceObject)); if (state != CCamSharedMemory::CAM_SHARED_MEM_STATE_OPEN) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_STATE); return CAM_SHARED_MEM_ERR_BAD_STATE; } if (chunkId >= CAM_SHARED_MEM_CHUNK_MAX) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PARAMETER); return CAM_SHARED_MEM_ERR_BAD_PARAMETER; } if (! abBusyChunks[chunkId]) { OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_BAD_PRECONDITION); return CAM_SHARED_MEM_ERR_BAD_PRECONDITION; } // Flush the data that have been written by the ISP FW OMX_U32 aPhysAddr; // out OMX_ERRORTYPE e_ret = sharedBufferPoolId->CacheSync(MMHwBuffer::ESyncAfterWriteHwOperation, (OMX_U32) aChunks[chunkId].armLogicalAddress, aChunks[chunkId].size, aPhysAddr); if (e_ret != OMX_ErrorNone) { MSG1("Problem invalidating data cache (err=%d)\n", e_ret); OstTraceFiltStatic1(TRACE_DEBUG, "Problem invalidating data cache (err=%d)", (mTraceObject), e_ret); OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NO_RESOURCE); return CAM_SHARED_MEM_ERR_NO_RESOURCE; } OUT0("\n"); OstTraceFiltStatic1(TRACE_FLOW, "Exit CCamSharedMemory::cacheInvalidate (%d)", (mTraceObject), CAM_SHARED_MEM_ERR_NONE); return CAM_SHARED_MEM_ERR_NONE; }
/* * This function sets the Coring Level damper */ t_damper_error_code CScorpioDamper::SetCoringLevelDamper( const float* pValues, const int aNumRows, const int aNumCols) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CScorpioDamper::SetCoringLevelDamper", (mTraceObject)); t_damper_error_code err = DAMPER_OK; MSG2("[Coring Level] NumRows=%d, NumCols=%d\n", aNumRows, aNumCols); OstTraceFiltStatic2(TRACE_DEBUG, "[Coring Level] NumRows=%d, NumCols=%d", (mTraceObject), aNumRows, aNumCols); err = DoSetDamper( pValues, aNumRows, aNumCols); if(err!=DAMPER_OK) { DBGT_ERROR("[Coring Level] failed to set damper: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "[Coring Level] failed to set damper: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CScorpioDamper::SetCoringLevelDamper (%d)", (mTraceObject), err); return err; } OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CScorpioDamper::SetCoringLevelDamper (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/* * This function sets the Noise Model damper */ t_damper_error_code CNoiseModelDamper::SetFrameSigmaDamper( const float* pValues, const int aNumRows, const int aNumCols) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CNoiseModelDamper::SetFrameSigmaDamper", (mTraceObject)); t_damper_error_code err = DAMPER_OK; MSG2("[Frame Sigma] NumRows=%d, NumCols=%d\n", aNumRows, aNumCols); OstTraceFiltStatic2(TRACE_DEBUG, "[Frame Sigma] NumRows=%d, NumCols=%d", (mTraceObject), aNumRows, aNumCols); err = DoSetDamper( pValues, aNumRows, aNumCols); if(err!=DAMPER_OK) { MSG1("[Frame Sigma] failed to set damper: err=%d\n", err); OstTraceFiltStatic1(TRACE_DEBUG, "[Frame Sigma] failed to set damper: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseModelDamper::SetFrameSigmaDamper (%d)", (mTraceObject), err); return err; } OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CNoiseModelDamper::SetFrameSigmaDamper (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
/* * This function sets the Gaussian Weight damper */ t_damper_error_code CNoiseFilterDamper::SetDusterGaussianWeightDamper( const float* pValues, const int aNumRows, const int aNumCols) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CNoiseFilterDamper::SetDusterGaussianWeightDamper", (mTraceObject)); t_damper_error_code err = DAMPER_OK; MSG2("[Gaussian Weight] NumRows=%d, NumCols=%d\n", aNumRows, aNumCols); OstTraceFiltStatic2(TRACE_DEBUG, "[Gaussian Weight] NumRows=%d, NumCols=%d", (mTraceObject), aNumRows, aNumCols); err = DoSetDamper( pValues, aNumRows, aNumCols); if(err!=DAMPER_OK) { DBGT_ERROR("[Gaussian Weight] failed to set damper: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "[Gaussian Weight] failed to set damper: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), err); return err; } OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CDefCorDamper::SetDamper (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
void main(void) { // Test All GROUPS OstTraceInt0 (TRACE_ERROR, "ST_OSTTC_TEST2 TRACE_ERROR: OstTraceInt0"); OstTraceInt0 (TRACE_WARNING, "ST_OSTTC_TEST2 TRACE_WARNING: OstTraceInt0"); OstTraceInt0 (TRACE_FLOW, "ST_OSTTC_TEST2 TRACE_FLOW: OstTraceInt0"); OstTraceInt0 (TRACE_DEBUG, "ST_OSTTC_TEST2 TRACE_DEBUG: OstTraceInt0"); OstTraceInt0 (TRACE_API, "ST_OSTTC_TEST2 TRACE_API: OstTraceInt0"); OstTraceInt0 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceInt0"); OstTraceInt0 (TRACE_OMX_BUFFER, "ST_OSTTC_TEST2 TRACE_OMX_BUFFER: OstTraceInt0"); OstTraceInt0 (TRACE_RESERVED, "ST_OSTTC_TEST2 TRACE_OMX_RESERVED: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_0, "ST_OSTTC_TEST2 TRACE_MY_GROUP_0: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_1, "ST_OSTTC_TEST2 TRACE_MY_GROUP_1: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_2, "ST_OSTTC_TEST2 TRACE_MY_GROUP_2: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_3, "ST_OSTTC_TEST2 TRACE_MY_GROUP_3: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_4, "ST_OSTTC_TEST2 TRACE_MY_GROUP_4: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_5, "ST_OSTTC_TEST2 TRACE_MY_GROUP_5: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_6, "ST_OSTTC_TEST2 TRACE_MY_GROUP_6: OstTraceInt0"); OstTraceInt0 (TRACE_MY_GROUP_7, "ST_OSTTC_TEST2 TRACE_MY_GROUP_7: OstTraceInt0"); // Test OstTraceIntx API OstTraceInt1 (TRACE_ERROR, "ST_OSTTC_TEST2 TRACE_ERROR: OstTraceInt1: %d", test); OstTraceInt2 (TRACE_WARNING, "ST_OSTTC_TEST2 TRACE_WARNING: OstTraceInt2: %d %d", test, test); OstTraceInt3 (TRACE_MY_GROUP_6, "ST_OSTTC_TEST2 TRACE_MY_GROUP_6: OstTraceInt3: %d %d %d", test, test, test); OstTraceInt4 (TRACE_MY_GROUP_7, "ST_OSTTC_TEST2 TRACE_MY_GROUP_7: OstTraceInt4: %d %d %d %d", test, test, test, test); // Test OstTraceFiltStaticx API OstTraceFiltInst0 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic0:"); OstTraceFiltInst1 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic1 : %d", test); OstTraceFiltInst2 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic2 : %d %d", test, test); OstTraceFiltInst3 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic3 : %d %d %d", test, test, test); OstTraceFiltInst4 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic4 : %d %d %d %d", test, test, test, test); // Test OstTraceFiltStaticx API OstTraceFiltStatic0 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic0:"); OstTraceFiltStatic1 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic1 : %d", test); OstTraceFiltStatic2 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic2 : %d %d", test, test); OstTraceFiltStatic3 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic3 : %d %d %d", test, test, test); OstTraceFiltStatic4 (TRACE_OMX_API, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltStatic4 : %d %d %d %d", test, test, test, test); // Test trace Buffer API OstTraceArray (TRACE_RESERVED, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceArray %{int8[]}", ptr, size); OstTraceFiltInstData(TRACE_RESERVED, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltInstData %{int8[]}", ptr, size); OstTraceFiltStaticData(TRACE_RESERVED, "ST_OSTTC_TEST2 TRACE_OMX_API: OstTraceFiltInstData %{int8[]}",aInstPtr, ptr, size); // Check Syntax ALL below syntax shall be parsed OstTraceInt0 (TRACE_ERROR, "ST_OSTTC_TEST2 TRACE_ERROR: OstTraceInt0"); OstTraceInt0 ( TRACE_ERROR , "ST_OSTTC_TEST2 TRACE_ERROR: OstTraceInt0"); }
/* * This function computes the dampers and queues the Page Elements */ t_damper_error_code CSharpeningDamperLR::ComputeAndQueuePEs( CIspctlCom* pIspctlCom, const t_damper_base_values* pBaseValues) { IN0("\n"); OstTraceFiltStatic0(TRACE_FLOW, "Entry CSharpeningDamperLR::ComputeAndQueuePEs", (mTraceObject)); float pDamperValues[SHARPENING_DAMPERS_LR_NUM] = { 0.0, 0.0}; t_damper_error_code err = DAMPER_OK; float fAdsocGain = 0.0; float fAdsocCoring = 0.0; float fScaleFactor = 0.0; // Evaluate Sharpening dampers err = DoEvaluate( pBaseValues, pDamperValues); if(err!=DAMPER_OK) { DBGT_ERROR("Evaluation failed: err=%d\n", err); OstTraceFiltStatic1(TRACE_ERROR, "Evaluation failed: err=%d", (mTraceObject), err); OUTR(" ",err); OstTraceFiltStatic1(TRACE_FLOW, "Exit CSharpeningDamperLR::ComputeAndQueuePEs (%d)", (mTraceObject), err); return err; } // Compute and queue Adsoc Gain PE (scale against omx config and clip value) fAdsocGain = pDamperValues[SHARPENING_ADSOC_GAIN_LR]; fScaleFactor = (float)iOmxSharpness * iScaleFactorGain + iScaleFactorOffset; MSG1("Scale Factor = %f\n", fScaleFactor); OstTraceFiltStatic1(TRACE_DEBUG, "Scale Factor = %f", (mTraceObject), fScaleFactor); fAdsocGain *= fScaleFactor; if( fAdsocGain < 0.0) { fAdsocGain = 0.0; } else if ( fAdsocGain > 255.0 ) { fAdsocGain = 255.0; } MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Gain_Byte0), fAdsocGain); OstTraceFiltStatic1(TRACE_DEBUG, "Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Gain = %f", (mTraceObject), fAdsocGain); pIspctlCom->queuePE( Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Gain_Byte0, (t_uint32)fAdsocGain); // Compute and queue Adsoc Coring PE fAdsocCoring = pDamperValues[SHARPENING_ADSOC_CORING_LR]; if( fAdsocCoring < 0.0) { fAdsocCoring = 0.0; } else if ( fAdsocCoring > 31.0 ) { fAdsocCoring = 31.0; } MSG2("%s = %f\n", CIspctlCom::pIspctlSensor->GetPeName(Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Coring_Level_Byte0), fAdsocCoring); OstTraceFiltStatic1(TRACE_DEBUG, "Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Coring_Level = %f", (mTraceObject), fAdsocCoring); pIspctlCom->queuePE( Adsoc_PK_Ctrl_1_u8_Adsoc_PK_Coring_Level_Byte0, (t_uint32)fAdsocCoring); // Done OUTR(" ",DAMPER_OK); OstTraceFiltStatic1(TRACE_FLOW, "Exit CSharpeningDamperLR::ComputeAndQueuePEs (%d)", (mTraceObject), DAMPER_OK); return DAMPER_OK; }
SCF_STATE CAM_SM::CAMERA_LoadingIQSettings(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: ENTRY; return 0; case SCF_STATE_EXIT_SIG: EXIT; return 0; case SCF_STATE_INIT_SIG: INIT; SCF_INIT(&CAM_SM::CAMERA_LoadingIQSettings_OpModeSetup); return 0; case Q_DEFERRED_EVENT_SIG: MSG0("LoadingIQSettings-DEFERRED_EVENT;\n"); OstTraceFiltStatic0(TRACE_DEBUG, "LoadingIQSettings-DEFERRED_EVENT;", (&mENSComponent)); return 0; case SCF_PARENT_SIG:break; default: MSG1("LoadingIQSettings-default %d\n",e->sig); OstTraceFiltStatic1(TRACE_DEBUG, "LoadingIQSettings-default %d", (&mENSComponent),e->sig); break; } return SCF_STATE_PTR(&CAM_SM::OMX_Executing); }
JPEGEnc_ArmNmfProcessingComponent::~JPEGEnc_ArmNmfProcessingComponent() { OstTraceFiltStatic1(TRACE_API, "In JPEGEnc_ArmNmfProcessingComponent : In destructor <line no %d> ",pProxyComponent,__LINE__); if (mParamBufferDesc.nSize) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Freeing memory for mParamBufferDesc <line no %d> ",__LINE__); VFM_Free(arm_vfm_mem_ctxt, (t_uint8*)mParamBufferDesc.nLogicalAddress); mParamBufferDesc.nSize = 0; mParamBufferDesc.nLogicalAddress = 0; mParamBufferDesc.nPhysicalAddress = 0; } if(mHeaderBufferDesc.nSize) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Freeing memory for mHeaderBufferDesc <line no %d> ",__LINE__); VFM_Free(arm_vfm_mem_ctxt, (t_uint8*)mHeaderBufferDesc.nLogicalAddress); mHeaderBufferDesc.nSize = 0; mHeaderBufferDesc.nLogicalAddress = 0; mHeaderBufferDesc.nPhysicalAddress = 0; } if(pProxyComponent->mParam.outputCompressionFormat == OMX_IMAGE_CodingEXIF) { if(mEXIFHeaderBufferDesc.nSize) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Freeing memory for mEXIFHeaderBufferDesc <line no %d> ",__LINE__); VFM_Free(arm_vfm_mem_ctxt, (t_uint8*)mEXIFHeaderBufferDesc.nLogicalAddress); mEXIFHeaderBufferDesc.nSize = 0; mEXIFHeaderBufferDesc.nLogicalAddress = 0; mEXIFHeaderBufferDesc.nPhysicalAddress = 0; } } #ifdef HVA_JPEGENC if (pProxyComponent->isHVABased == OMX_TRUE) { if (mHVATaskDecs.nSize) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Freeing memory for mHVATaskDecs <line no %d> ",__LINE__); VFM_Free(arm_vfm_mem_ctxt, (t_uint8*)mHVATaskDecs.nLogicalAddress); mHVATaskDecs.nSize = 0; mHVATaskDecs.nLogicalAddress = 0; mHVATaskDecs.nPhysicalAddress = 0; } if (mHVAInParamsDecs.nSize) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Freeing memory for mHVAInParamsDecs <line no %d> ",__LINE__); VFM_Free(arm_vfm_mem_ctxt, (t_uint8*)mHVAInParamsDecs.nLogicalAddress); mHVAInParamsDecs.nSize = 0; mHVAInParamsDecs.nLogicalAddress = 0; mHVAInParamsDecs.nPhysicalAddress = 0; } if (mHVAOutParamsDecs.nSize) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Freeing memory for mHVAOutParamsDecs <line no %d> ",__LINE__); VFM_Free(arm_vfm_mem_ctxt, (t_uint8*)mHVAOutParamsDecs.nLogicalAddress); mHVAOutParamsDecs.nSize = 0; mHVAOutParamsDecs.nLogicalAddress = 0; mHVAOutParamsDecs.nPhysicalAddress = 0; } if (mHVAQuantParamsDecs.nSize) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Freeing memory for mHVAQuantParamsDecs <line no %d> ",__LINE__); VFM_Free(arm_vfm_mem_ctxt, (t_uint8*)mHVAQuantParamsDecs.nLogicalAddress); mHVAQuantParamsDecs.nSize = 0; mHVAQuantParamsDecs.nLogicalAddress = 0; mHVAQuantParamsDecs.nPhysicalAddress = 0; } } #endif if(arm_vfm_mem_ctxt) { OstTraceFiltInst1(TRACE_DEBUG, "In JPEGEnc_ArmNmfProcessingComponent : Closing Memory List <line no %d> ",__LINE__); VFM_CloseMemoryList(arm_vfm_mem_ctxt); } arm_vfm_mem_ctxt = 0; OstTraceFiltStatic1(TRACE_API, "In JPEGEnc_ArmNmfProcessingComponent : destruction done <line no %d> ",pProxyComponent,__LINE__); }
SCF_STATE CAM_SM::PowerUp_STC_SendDataToFirmware(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: { ENTRY; MSG0("PowerUp_STC_SendDataToFirmware-SCF_STATE_ENTRY_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_SendDataToFirmware-SCF_STATE_ENTRY_SIG", (&mENSComponent)); CTuningBinData* pFwTuningObj = NULL; // Get the firmware tuning object pFwTuningObj = pTuningDataBase->getObject(TUNING_OBJ_FIRMWARE_DATA); // Check that the firmware tuning data fit into the shared memory chunk if( (csm_uint32_t)pFwTuningObj->getSize() > pFwShmChunk->size) { MSG0("PowerUp_STC_SendDataToFirmware: Tuning data shared chunk too small:\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_SendDataToFirmware: Tuning data shared chunk too small:", (&mENSComponent)); MSG1("PowerUp_STC_SendDataToFirmware: Shared mem size = %ld\n", pFwShmChunk->size); OstTraceFiltStatic1(TRACE_DEBUG, "PowerUp_STC_SendDataToFirmware: Shared mem size = %ld", (&mENSComponent), pFwShmChunk->size); MSG1("PowerUp_STC_SendDataToFirmware: Actual data size = %d\n", pFwTuningObj->getSize()); OstTraceFiltStatic1(TRACE_DEBUG, "PowerUp_STC_SendDataToFirmware: Actual data size = %d", (&mENSComponent), pFwTuningObj->getSize()); DBC_ASSERT(0); return 0; } // Copy the tuning data into the firmware address space MSG3("PowerUp_STC_SendDataToFirmware: Copying data %p, size %d, into firwmare address space %p\n", pFwTuningObj->getAddr(), pFwTuningObj->getSize(), pFwShmChunk->ispLogicalAddress); OstTraceFiltStatic3(TRACE_DEBUG, "PowerUp_STC_SendDataToFirmware: Copying data 0x%x, size %d, into firwmare address space 0x%x", (&mENSComponent), (t_uint32)pFwTuningObj->getAddr(), pFwTuningObj->getSize(), (t_uint32)pFwShmChunk->ispLogicalAddress); if (NULL != pFwTuningObj->getAddr()) { memcpy(pFwShmChunk->armLogicalAddress, pFwTuningObj->getAddr(), pFwTuningObj->getSize()); } else { DBC_ASSERT(0); return 0; } // Flush the memory cache (so that consistent data are read by firmware) camSharedMemError_t shmErr = CAM_SHARED_MEM_ERR_NONE; shmErr = pSharedMemory->cacheClean(CAM_SHARED_MEM_CHUNK_FW_CONFIG); if (shmErr != CAM_SHARED_MEM_ERR_NONE) { DBGT_ERROR("PowerUp_STC_SendDataToFirmware: Failed to flush shared memory chunk, err=%d\n", shmErr); OstTraceFiltStatic1(TRACE_ERROR, "PowerUp_STC_SendDataToFirmware: Failed to flush shared memory chunk, err=%d", (&mENSComponent), shmErr); DBC_ASSERT(0); return 0; } // Send the address (firmware address space) to XP70 pIspctlCom->queuePE(Sensor_Tuning_Control_u32_SubBlock_Data_Address_Byte0, (t_uint32)pFwShmChunk->ispLogicalAddress ); pIspctlCom->processQueue(); return 0; } case SCF_STATE_EXIT_SIG: { EXIT; return 0; } case EVT_ISPCTL_LIST_INFO_SIG: { MSG0("PowerUp_STC_SendDataToFirmware-EVT_ISPCTL_LIST_INFO_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_SendDataToFirmware-EVT_ISPCTL_LIST_INFO_SIG", (&mENSComponent)); if (e->type.ispctlInfo.info_id != ISP_WRITELIST_DONE) break; SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_Done); return 0; } default: break; } return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot); }
SCF_STATE CAM_SM::PowerUp_STC_LoadData(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: { MSG0("PowerUp_STC_LoadData-SCF_STATE_ENTRY_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_LoadData-SCF_STATE_ENTRY_SIG", (&mENSComponent)); TuningLoaderMgrError_t tlmErr = TUNING_LOADER_MGR_OK; t_camera_info camInfo; // Initialisation to remove Coverity Warning camInfo.manufId = 0; camInfo.modelId = 0; camInfo.revNum = 0; camInfo.Fuse_Id[0] = 0; camInfo.Fuse_Id[1] = 0; camInfo.Fuse_Id[2] = 0; camInfo.Fuse_Id4 = 0; camInfo.manufId = pSensor->GetSensorManufacturer(); camInfo.modelId = pSensor->GetSensorModel(); camInfo.revNum = pSensor->GetSensorRevNumber(); t_fw_blocks_info fwBlocks; fwBlocks.subBlockCount = iFwSubBlockIdsCount; fwBlocks.pSubBlockId = pFwSubBlockId; MSG0("PowerUp_STC_LoadData: loading firmware tuning data\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_LoadData: loading firmware tuning data", (&mENSComponent)); tlmErr = pTuningLoaderManager->loadFirmwareTuningData(&camInfo, &fwBlocks); if(tlmErr != TUNING_LOADER_MGR_OK) { DBGT_ERROR("PowerUp_STC_LoadData: firmware tuning data loading failed err=%d (%s)\n", tlmErr, CTuningLoaderManager::errorCode2String(tlmErr)); OstTraceFiltStatic1(TRACE_ERROR, "PowerUp_STC_LoadData: firmware tuning data loading failed err=%d", (&mENSComponent), tlmErr); DBC_ASSERT(0); return 0; } return 0; } case TUNING_LOADER_OPERATION_DONE_SIG: { MSG0("PowerUp_STC_LoadData-TUNING_LOADER_OPERATION_DONE_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_LoadData-TUNING_LOADER_OPERATION_DONE_SIG", (&mENSComponent)); MSG2("Deleting pFwSubBlockId=%p (%d entries)\n", pFwSubBlockId, iFwSubBlockIdsCount); OstTraceFiltStatic2(TRACE_DEBUG, "Deleting pFwSubBlockId=%0x%x (%d entries)", (&mENSComponent), (t_uint32)pFwSubBlockId, iFwSubBlockIdsCount); delete [] pFwSubBlockId; pFwSubBlockId = NULL; SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_SendDataToFirmware); return 0; } case TUNING_LOADER_OPERATION_FAILED_SIG: { MSG0("PowerUp_STC_LoadData-TUNING_LOADER_OPERATION_FAILED_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_LoadData-TUNING_LOADER_OPERATION_FAILED_SIG", (&mENSComponent)); DBGT_ERROR("PowerUp_STC_LoadData: failed to load firmware tuning data err=%ld (%s)\n", e->type.tuningLoaderEvent.error, pTuningLoaderManager->loaderErrorCode2String(e->type.tuningLoaderEvent.error)); OstTraceFiltStatic1(TRACE_ERROR, "PowerUp_STC_LoadData: failed to load firmware tuning data err=%ld", (&mENSComponent), e->type.tuningLoaderEvent.error); DBC_ASSERT(0); return 0; } case SCF_STATE_EXIT_SIG: { EXIT; return 0; } default: break; } return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot); }
SCF_STATE CAM_SM::PowerUp_STC_GetNbBlockIds(s_scf_event const *e) { switch (e->sig) { case SCF_STATE_ENTRY_SIG: { ENTRY; MSG0("PowerUp_STC_GetNbBlockIds-SCF_STATE_ENTRY_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_GetNbBlockIds-SCF_STATE_ENTRY_SIG", (&mENSComponent)); // Ask to firmware how many tuning blocks are supported and get current coin value pIspctlCom->queuePE(Sensor_Tuning_Status_u16_TotalSubBlockIdsCount_Byte0,0); pIspctlCom->queuePE(Sensor_Tuning_Status_e_Coin_SubBlock_Status_Byte0,0); pIspctlCom->readQueue(); return 0; } case EVT_ISPCTL_LIST_INFO_SIG: { MSG0("PowerUp_STC_GetNbBlockIds-EVT_ISPCTL_LIST_INFO_SIG\n"); OstTraceFiltStatic0(TRACE_DEBUG, "PowerUp_STC_GetNbBlockIds-EVT_ISPCTL_LIST_INFO_SIG", (&mENSComponent)); if(e->type.ispctlInfo.info_id != ISP_READLIST_DONE) break; // Store the Firmware tuning info related data iFwSubBlockIdsCount = (t_uint16)e->type.ispctlInfo.Listvalue[0].pe_data; iStatusCoin = (Coin_te) e->type.ispctlInfo.Listvalue[1].pe_data; if(iFwSubBlockIdsCount==0) { // Firmware does not support tuning MSG0(" Tuning not supported by the firmware\n"); OstTraceFiltStatic0(TRACE_DEBUG, "Tuning not supported by the firmware", (&mENSComponent)); pFwSubBlockId = NULL; SCF_TRANSIT_TO(&COM_SM::SHARED_ControlingISPState); return 0; } else { // Firmware supports tuning: retrieve the supported IDs MSG1(" Tuning supported by the firmware: %d FwSubBlocks supported\n", iFwSubBlockIdsCount); OstTraceFiltStatic1(TRACE_DEBUG, "Tuning supported by the firmware: %d FwSubBlocks supported", (&mENSComponent), iFwSubBlockIdsCount); iStatusCoinRetriesCount = 0; iCurrentFwSubBlockIndex = 0; pFwSubBlockId = new t_uint16[iFwSubBlockIdsCount]; if(pFwSubBlockId==NULL) { DBGT_ERROR(" Failed to allocate %d entries for FwSubBlock IDs\n", iFwSubBlockIdsCount); OstTraceFiltStatic1(TRACE_ERROR, "Failed to allocate %d entries for FwSubBlock IDs", (&mENSComponent), iFwSubBlockIdsCount); DBC_ASSERT(0); return 0; } MSG2(" Allocated pFwSubBlockId=%p (%d entries)\n", pFwSubBlockId, iFwSubBlockIdsCount); OstTraceFiltStatic2(TRACE_DEBUG, "Allocated pFwSubBlockId=0x%x (%d entries)", (&mENSComponent), (t_uint32)pFwSubBlockId, iFwSubBlockIdsCount); SCF_TRANSIT_TO(&CAM_SM::PowerUp_STC_QueryId); } return 0; } case SCF_STATE_EXIT_SIG: { EXIT; return 0; } default: break; } return SCF_STATE_PTR(&COM_SM::SHARED_ControlingISPState_Boot); }