STRM_Initialize
streammanager 初始化流程
目录
SensorPlatform::SensorPlatformInit
SensorManager::DetectHandlerThread
SensorManager::ProcessDetectEvent
/**
* STRM_Initialize
*
* @brief Initialize stream manager
* @param initialization parameters
*
* @return CAMERA_SUCCESS if successful;
*/
CamStatus_e STRM_Initialize(const QCarCamInit_t* pInitParams)
{
QCX_LOG(STREAM_MGR, HIGH, "API: %s", __FUNCTION__);
CamStatus_e result = CAMERA_EFAILED;
StreamManager* pStrmManager = NULL;
if (NULL == pInitParams)
{
QCX_LOG(STREAM_MGR, ERROR, "Null pointer passed.");
result = CAMERA_EBADPARAM;
}
else
{
/* Create Stream manager instance. */
pStrmManager = StreamManager::GetInstance();
if (NULL == pStrmManager)
{
QCX_LOG(STREAM_MGR, ERROR, "Stream Manager instance creation failed.");
result = CAMERA_ENOMEMORY;
}
else
{
result = CAMERA_SUCCESS;
}
}
if (CAMERA_SUCCESS == result)
{
QCX_LOG(STREAM_MGR, HIGH, "%s called with init params (flags=%#x, apiVersion=%u)", __FUNCTION__, pInitParams->flags, pInitParams->flags);
result = pStrmManager->Initialize(pInitParams);
if (CAMERA_SUCCESS == result)
{
QCX_LOG(STREAM_MGR, DEBUG, "Stream Manager initialization success.");
}
/* No need to destroy stream manager instance on failure. */
}
return result;
}//解析xml errInjen 配置进行debug log 输出
初始化解串器配置/cameraconfigsa8650.c配置的信息
/**
* @brief
* Function used to initialize.
*
* @param pInitParams [in]
* pointer to init params
*
* @return
* Status as defined in CamStatus_e
*/
CamStatus_e StreamManager::Initialize(const QCarCamInit_t* pInitParams)
{
CamStatus_e result = CAMERA_SUCCESS;
CAM_TRACE_LOG(STREAM_MGR, "StreamManager::Initialize");
/* Check API version */
if (pInitParams->apiVersion >= QCARCAM_VERSION_MINIMUM_COMPATIBLE)
{
QCX_LOG(STREAM_MGR, ERROR, "API version %#x is not supported",
pInitParams->apiVersion);
result = CAMERA_ENOTSUPPORTED;
}
else
{
/* Initialize GPTP
*
* GPTP service might not be available at this time and hence this
* call might fail.
* TODO. Need to try initializing at a later time.
*
* We are not checking the error code here, since it is not a fatal error,
* and we already have the error prints from inside the method */
Gptp::GetInstance()->Init();
/* Initalize dynamic configuration */
//解析xml errInjen 配置进行debug log 输出
//errInjen未配置在xml中
Config::GetInstance()->Init();
/* TODO: Need to move it to SI_Init */
//初始化解串器配置/cameraconfigsa8650.c配置的信息
result = SensorManager::GetInstance()->Init();
if (CAMERA_SUCCESS != result)
{
QCX_LOG(STREAM_MGR, ERROR, "Failed in sensor manager init");
}
else
{
result = SensorManager::GetInstance()->DetectAll();
if (CAMERA_SUCCESS != result)
{
QCX_LOG(STREAM_MGR, ERROR, "Failed in sensor detection");
}
else
{
QCX_LOG(STREAM_MGR, HIGH, "Sensor Manager Init and DetectAll successful");
/* TODO: Need to add init call for CSL */
result = CAMXHAL::GetInstance()->Init();
if (CAMERA_SUCCESS != result)
{
QCX_LOG(STREAM_MGR, ERROR, "CAMX HAL Init failed");
}
else
{
result = CAMXHAL::GetInstance()->InitializeMetatable(&g_QccMetadataTable, g_metadataTableElemCount);
if (CAMERA_SUCCESS != result)
{
m_QccMetadatatable_init = false;
QCX_LOG(STREAM_MGR, ERROR, "Initalizing metadata cached table failed(result = %d)", result);
}
else
{
m_QccMetadatatable_init = true;
QCX_LOG(STREAM_MGR, DEBUG, "Initalizing metadata cached table successed");
}
}
}
}
/*Create the Lock for Global list of input Ids*/
result = OSAL_CriticalSectionCreate(&m_OpenInputIdslock);
if (CAMERA_SUCCESS != result)
{
QCX_LOG(STREAM_MGR, ERROR, "OSAL_CriticalSectionCreate failed, result = %d", result);
}
}
CAM_TRACE_LOG(STREAM_MGR, "StreamManager::Initialize : End");
return result;
}/**
* @brief
* Get singleton instance of gptp.
*/
Gptp* Gptp::GetInstance()
{
static Gptp s_GptpSingleton;
return &s_GptpSingleton;
}
Gptp::Init
//获取GPTP_ENABLE_KEY的value
//GPTP_ENABLE_KEY未进行配置不会初始化gptpInit
/**
* @brief
* Initialize GPTP.
*
* @return
* Status as defined in CamStatus_e
*/
CamStatus_e Gptp::Init(void)
{
CamStatus_e result = CAMERA_EFAILED;
CamStatus_e resultTemp = CAMERA_EFAILED;
//获取GPTP_ENABLE_KEY的value
resultTemp = Config::GetInstance()->GetGptpEnableFromConfig(&mGptpEnable);
if(CAMERA_SUCCESS != resultTemp)
{
QCX_LOG(STREAM_MGR, ERROR, "Failed to read GPTP Enable from config. Disabling GPTP");
mGptpEnable = GPTP_DISABLED;
}
//GPTP_ENABLE_KEY未进行配置不会初始化gptpInit
if(GPTP_ENABLED == mGptpEnable){
bool state;
state = gptpInit();
if (true != state)
{
QCX_LOG(STREAM_MGR, ERROR, "gptp init failed");
}
else
{
QCX_LOG(STREAM_MGR, DEBUG, "gptp init success");
result = CAMERA_SUCCESS;
}
}
return result;
}/**
* @brief
* Read GPTP enable value from config.
*
* @param gptpEn [out]
* pointer to the gptp enable flag.
*
* @return
* Status as defined in CamStatus_e.
*/
CamStatus_e Config::GetGptpEnableFromConfig(uint32_t *pGptpEn)
{
CamStatus_e rc = CAMERA_EFAILED;
rc = GetValFromConfigOverrideSetting(GPTP_ENABLE_KEY, pGptpEn);
if (CAMERA_SUCCESS != rc)
{
QCX_LOG(STREAM_MGR, HIGH, "GPTP Enable config read failed");
}
else
{
QCX_LOG(STREAM_MGR, LOW, "Config read success: GptpEn = %u", *pGptpEn);
}
return rc;
}
*
* @param key [in]
* key of the config.
*
* @param value [out]
* pointer to value of the config.
*
* @return
* Status as defined in CamStatus_e.
*/
CamStatus_e Config::GetValFromConfigOverrideSetting(uint32_t key, uint32_t *pValue)
{
CamStatus_e rc = CAMERA_ENOTFOUND;
const CameraConfigInfo_t* pCamConfig = nullptr;
pCamConfig = PLM_GetCameraConfig();
if (nullptr == pCamConfig)
{
QCX_LOG(STREAM_MGR, ERROR, "Failed to query cameraconfig");
}
else
{
/* Search the config for request queue depth value. */
for (uint32_t idx = 0; idx < CAM_CFG_MAX_NUM_SETTINGS_OVERRIDES; idx++)
{
if (key == pCamConfig->settingsOverrides[idx].key)
{
*pValue = pCamConfig->settingsOverrides[idx].value;
rc = CAMERA_SUCCESS;
break;
}
}
}
return rc;
}
/**************************************************************************************************
@brief
Get camera config
@return
Error const pointer to CameraConfigInfo_t
**************************************************************************************************/
const CameraConfigInfo_t* PLM_GetCameraConfig(void)
{
if (TRUE == g_PlatformCtxt.bInitialized)
{
return g_PlatformCtxt.pCameraConfigInfo;
}
return NULL;
}static int CameraConfigXMLParseFile(CameraConfigInfo_t *boardInfo)
{
int rc = 0;
xmlDocPtr pXmlDoc = NULL;
xmlNodePtr pCur = NULL;
const char* filename = CAMERA_CONFIG_XML_FILE;
uint32_t settingsOverrideIdx = 0;
CAM_MSG(HIGH, "CameraConfig xml file name:%s", filename);
if(access(filename, F_OK))
{
CAM_MSG(HIGH, "CameraConfig file not available. Will use defaults");
rc = -1;
}
if (!rc)
{
pXmlDoc = xmlParseFile(filename);
if (pXmlDoc == NULL)
{
CAM_MSG(ERROR, "CameraConfig file not parsed successfully");
rc = -1;
}
}
if (!rc)
{
pCur = xmlDocGetRootElement(pXmlDoc);
if (pCur == NULL)
{
CAM_MSG(ERROR, "Empty CameraConfig file");
xmlFreeDoc(pXmlDoc);
rc = -1;
}
}
if (!rc)
{
if (xmlStrcmp(pCur->name, (const xmlChar *) "CameraConfig"))
{
CAM_MSG(ERROR, "Wrong CameraConfig file format, root node != CameraConfig");
xmlFreeDoc(pXmlDoc);
rc = -1;
}
else
{
pCur = pCur->xmlChildrenNode;
}
}
//Parse the file
while(pCur != NULL && !rc)
{
if (!(xmlStrcmp(pCur->name, (const xmlChar *) "board")))
{
XML_GET_INT_ATTR(boardInfo->socId, pCur, "socId", 1, uint32_t);
XML_GET_STRING_ATTR(boardInfo->boardName, pCur, "name", 1);
xmlNodePtr pChild = pCur->xmlChildrenNode;
while(pChild != NULL && !rc)
{
if(!(xmlStrcmp(pChild->name, (const xmlChar *) "i2cDevs")))
{
//配置camera sensorlib i2c设备的个数
XML_GET_INT_ATTR(boardInfo->numI2cDevices, pChild, "numI2cDevices", 1, uint32_t);
if(CAM_CFG_MAX_NUM_I2C_DEVICES <= boardInfo->numI2cDevices)
{
CAM_MSG(ERROR, "Number of I2cDevices exceeds max %d", CAM_CFG_MAX_NUM_I2C_DEVICES);
rc = -1;
break;
}
rc = CameraConfigXMLParseI2CDevs(pChild, boardInfo);
}
else if(!(xmlStrcmp(pChild->name, (const xmlChar *) "cameraLibs")))
{
XML_GET_INT_ATTR(boardInfo->numCameraLibs, pChild, "numCameraLibs", 1, uint32_t);
if(CAM_CFG_MAX_NUM_SENSOR_LIBS <= boardInfo->numCameraLibs)
{
CAM_MSG(ERROR, "Number of CameraLibs exceeds max %d", CAM_CFG_MAX_NUM_SENSOR_LIBS);
rc = -1;
break;
}
rc = CameraConfigXMLParseSensorLibs(pChild, boardInfo);
}
else if(!(xmlStrcmp(pChild->name, (const xmlChar *) "settingsOverrides")))
{
uint32_t key = 0;
uint32_t value = 0;
XML_GET_INT_ATTR(key, pChild, "key", 1, uint32_t);
XML_GET_INT_ATTR(value, pChild, "value", 1, uint32_t);
if (CAM_CFG_MAX_NUM_SETTINGS_OVERRIDES <= settingsOverrideIdx)
{
CAM_MSG(ERROR, "Number of engine settings exceeds max %d", CAM_CFG_MAX_NUM_SETTINGS_OVERRIDES);
rc = -1;
break;
}
//获取xml中配置的settingsOverrrides
boardInfo->settingsOverrides[settingsOverrideIdx].key = key;
boardInfo->settingsOverrides[settingsOverrideIdx].value = value;
settingsOverrideIdx++;
}
pChild = pChild->next;
}
}
else if(!(xmlStrcmp(pCur->name, (const xmlChar *) "inputMapping")))
{
XML_GET_INT_ATTR(boardInfo->numInputs, pCur, "numInputs", 1, uint32_t);
//获取xml的input信息
rc = CameraConfigXMLParseInputMapping(pCur, boardInfo);
}
pCur = pCur->next;
}
xmlFreeDoc(pXmlDoc);
return rc;
}static int CameraConfigXMLParseInputMapping(xmlNodePtr pParent, CameraConfigInfo_t *boardInfo)
{
int rc = 0;
xmlNodePtr pCur = pParent->xmlChildrenNode;
uint32_t srcIdx = 0;
while (pCur != NULL && !rc)
{
if (!(xmlStrcmp(pCur->name, (const xmlChar *) "inputMap")))
{
xmlNodePtr pChild;
if(CAM_CFG_MAX_NUM_INPUT_MAPPING <= srcIdx)
{
CAM_MSG(ERROR, "Number of input mapping exceeds max %d", CAM_CFG_MAX_NUM_INPUT_MAPPING);
rc = -1;
break;
}
XML_GET_INT_ATTR(boardInfo->inputs[srcIdx].qcarcamId, pCur, "qcarcamId", 1, uint32_t);
XML_GET_STRING_ATTR(boardInfo->inputs[srcIdx].name, pCur, "name", 1);
pChild = pCur->xmlChildrenNode;
pChild = pChild->next;
if(!(xmlStrcmp(pChild->name, (const xmlChar *) "inputSrc")))
{
XML_GET_INT_ATTR(boardInfo->inputs[srcIdx].sensorLibId, pChild, "sensorLibId", 1, uint32_t);
XML_GET_INT_ATTR(boardInfo->inputs[srcIdx].devId, pChild, "devId", 1, uint32_t);
XML_GET_INT_ATTR(boardInfo->inputs[srcIdx].subdevId, pChild, "subdevId", 1, uint32_t);
}
srcIdx++;
}
pCur = pCur->next;
}
return rc;
}Config::Init
/*
* Initialise config Class.
*
* @return
* Status as defined in CamStatus_e.
*/
void Config::Init()
{
/* TODO: Need to cleanup and implement proper init method.
* Need to initialise all the configs in the init method,
* which will be consumed by clients using getter methods.
* (Now error injection configs are only initalised here.
**/
if(CAMERA_SUCCESS != InitErrInjConfig())
{
QCX_LOG(STREAM_MGR, HIGH, "Error Injection Configs not found");
}
}
* @brief
* Read Error Injection configs from global configs and
* update corresponding config class memeber.
*
* @return
* Status as defined in CamStatus_e.
*/
CamStatus_e Config::InitErrInjConfig()
{
CamStatus_e rc = CAMERA_ENOTFOUND;
uint32_t errInj1 = 0;
uint32_t errInj2 = 0;
uint64_t config = 0;
/* Read and update the error injection configs */
m_errInjConfig.errInjEn = false;
rc = GetValFromConfigOverrideSetting(ERR_INJ_VAL1_KEY, &errInj1);
if (CAMERA_SUCCESS != rc)
{
QCX_LOG(STREAM_MGR, HIGH, "Config not present for ERR_INJ_VAL1_KEY");
}
else
{
rc = GetValFromConfigOverrideSetting(ERR_INJ_VAL2_KEY, &errInj2);
if (CAMERA_SUCCESS != rc)
{
QCX_LOG(STREAM_MGR, HIGH, "Config not present for ERR_INJ_VAL2_KEY");
}
else
{
/* Pack the two 32 bit values to form 64bit value */
config = ((uint64_t)errInj2 << 32) | errInj1;
QCX_LOG(STREAM_MGR, DEBUG, "Config read success: ErrInj Val2 = %x,"
" ErrInj Val1 = %x, config = %lx", errInj2, errInj1, config);
/*
* The 64 bit Config value is divided as
* [15:0] : 16 bits -> Request Id
* [31:16] : 16 bits -> Error Source
* [47:32] : 16 bits -> Error Code
* [59:48] : 12 bits -> Camera Id
* [63:60] : 4 bits -> Error Id
* */
m_errInjConfig.requestId = (config & 0xFFFF);
m_errInjConfig.errorSrc = ((config >> 16) & 0xFFFF);
m_errInjConfig.errorCode = ((config >> 32) & 0xFFFF);
m_errInjConfig.cameraId = ((config >> 48) & 0xFFF);
m_errInjConfig.errorId = ((config >> 60) & 0xF);
QCX_LOG(STREAM_MGR, DEBUG, " Request id = %x, Error Src = %x,"
" Error Code = %x, Camera Id = %d, Error Id = %x",
m_errInjConfig.requestId, m_errInjConfig.errorSrc,
m_errInjConfig.errorCode, m_errInjConfig.cameraId,
m_errInjConfig.errorId);
if (ERROR_CAMERA_CODE_INVALID != m_errInjConfig.errorCode)
{
QCX_LOG(STREAM_MGR, DEBUG, "Valid Error Code: Enabling Error injection");
m_errInjConfig.errInjEn = true;
rc = CAMERA_SUCCESS;
}
}
}
return rc;
}SensorManager::Init
//注册m_SensorPlatformApi函数操作接口
//获取xml中的camera 对应的解串器的i2c num配置
//创建 pDetectHndlr->detectQ
//创建pDetectHndlr->signal 信号量
//创建SensorManager::DetectHandlerThread 处理detectQ中的数据
//初始化pSensorLib 获取boardInfo->cameraLib中的SensorLibConfig
//加载sensorlib
//匹配解串器型号配置 解串器地址mode
//配置devIdx解串器信息
//配置解串器的index rang 0-3
//配置解串器numdevices id
//配置input 信息
/**
* @brief Initialize Sensor Manager
* @return #CamStatus_e
*/
CamStatus_e SensorManager::Init()
{
CamStatus_e result{CAMERA_SUCCESS};
m_pCameraConfigInfo = PLM_GetCameraConfig();
if (nullptr == m_pCameraConfigInfo)
{
QCX_LOG(SENSOR_MGR, ERROR, "Failed to query cameraconfig");
return result;
}
//注册m_SensorPlatformApi函数操作接口
m_SensorPlatformApi.I2CRead = &I2CRead;
m_SensorPlatformApi.I2CWrite = &I2CWrite;
m_SensorPlatformApi.I2CTransact = &I2CTransact;
m_SensorPlatformApi.I2CWriteSync = &I2CWriteSync;
m_SensorPlatformApi.ExecuteGpioAndPowerSequence = &ExecuteGpioAndPowerSequence;
m_SensorPlatformApi.GPIOSetValue = &GPIOSetValue;
m_SensorPlatformApi.GPIOGetValue = &GPIOGetValue;
m_SensorPlatformApi.SetupGpioInterrupt = &SetupGpioInterrupt;
m_SensorPlatformApi.StartCCIFrameSync = &StartCCIFrameSync;
m_SensorPlatformApi.StopCCIFrameSync = &StopCCIFrameSync;
//获取xml中的camera 对应的解串器的i2c num配置
m_numSensorLibs = m_pCameraConfigInfo->numCameraLibs;
char thread_name[64];
const uint64_t nMaxElementSize = sizeof(QCXInputEventMsgType);
m_detectHandlerIsExit = FALSE;
result = QCXCameraCreateSignal(&m_detectSignalDone);
if (result != CAMERA_SUCCESS)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not create Signal");
}
result = OSAL_CriticalSectionCreate(&m_detectMutex);
if (result != CAMERA_SUCCESS)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not create Mutex");
}
for (int i = 0; i < MAX_DETECT_THREAD_IDX; i++)
{
QCXInputDetectHandlerType* pDetectHndlr = &m_detectHandler[i];
//创建 pDetectHndlr->detectQ
result = QCXQueueCreate(nMa xElementSize, CAM_CFG_MAX_NUM_SENSOR_LIBS, FALSE, &pDetectHndlr->detectQ);
if (result != CAMERA_SUCCESS)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not create Queue");
}
//创建pDetectHndlr->signal 信号量
result = QCXCameraCreateSignal(&pDetectHndlr->signal);
if (CAMERA_SUCCESS != result)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not create Signal");
}
UNUSED_VAL(snprintf(thread_name, sizeof(thread_name), "sensormgr_thrd%d", i));
if (CAMERA_SUCCESS == result)
{
//创建SensorManager::DetectHandlerThread 处理detectQ中的数据
result = OSAL_ThreadCreate(QCXThreadDefaultPriority, &SensorManager::DetectHandlerThread, pDetectHndlr,
DETECT_STACK_SIZE, thread_name, &pDetectHndlr->threadId);
if (result != CAMERA_SUCCESS)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not create Thread");
}
}
}
for (uint32_t libIdx = 0U; libIdx < m_numSensorLibs; libIdx++)
{
QcxSensorLib_t* const pSensorLib = &m_sensorLibs[libIdx];
//初始化pSensorLib 获取boardInfo->cameraLib中的SensorLibConfig
pSensorLib->pSensorLibConfig = &m_pCameraConfigInfo->cameraLib[libIdx];
pSensorLib->pSensorPlatform = SensorPlatform::SensorPlatformInit(pSensorLib->pSensorLibConfig);
if (nullptr == pSensorLib->pSensorPlatform)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not load sensorplatform for lib %d",
pSensorLib->pSensorLibConfig->sensorLibId);
continue;
}
//加载sensorlib
result = LoadSensorLib(pSensorLib);
if (CAMERA_SUCCESS != result)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not load sensor lib %d",
pSensorLib->pSensorLibConfig->sensorLibId);
continue;
}
QCX_LOG(SENSOR_MGR, HIGH, "Open sensor lib %d ...",
pSensorLib->pSensorLibConfig->sensorLibId);
//匹配解串器型号配置 解串器地址mode
result = OpenSensorLib(pSensorLib);
if (CAMERA_SUCCESS != result)
{
QCX_LOG(SENSOR_MGR, ERROR, "Could not open sensor lib %d",
pSensorLib->pSensorLibConfig->sensorLibId);
continue;
}
pSensorLib->m_nInputDevices = pSensorLib->pSensorLibConfig->numDevices;
//配置devIdx解串器信息
// Search list of sensor device drivers to determine which ones are
// actually available for use
for (uint32_t devIdx = 0U; devIdx < pSensorLib->m_nInputDevices; devIdx++)
{
QcxInputDevice_t* const pInputDev = &pSensorLib->m_InputDevices[devIdx];
pInputDev->delaySuspendFlag = FALSE;
//配置解串器的index rang 0-3
pInputDev->sensorlibId = libIdx;
//配置解串器numdevices id
pInputDev->devId = devIdx;
pInputDev->pDeviceConfig = &pSensorLib->pSensorLibConfig->devices[devIdx];
}
}
//配置input 信息
for (uint32_t inputmapIdx = 0U; inputmapIdx < m_pCameraConfigInfo->numInputs; inputmapIdx++)
{
QcxInputMapping_t* const pInputMap = &m_InputMappingTable[inputmapIdx];
pInputMap->pInfo = &m_pCameraConfigInfo->inputs[inputmapIdx];
pInputMap->isAvailable = FALSE;
m_nInputMapping++;
}
// return success to keep going with whatever sensor libraries were detected
return CAMERA_SUCCESS;
}//解析xml 获取boardInfo->cameraLib中的SensorLibConfig
static int CameraConfigXMLParseSensorLibs(xmlNodePtr pParent, CameraConfigInfo_t *boardInfo)
{
int rc = 0;
uint32_t cameraLibIdx = 0;
xmlNodePtr pCur = pParent->xmlChildrenNode;
while(pCur != NULL && !rc)
{
if(!(xmlStrcmp(pCur->name, (const xmlChar *) "cameraLib")))
{
xmlNodePtr pChild;
if(cameraLibIdx >= boardInfo->numCameraLibs)
{
CAM_MSG(HIGH, "Number of cameraLibs exceeds max");
return rc;
}
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].sensorLibId, pCur, "sensorLibId", 1, uint32_t);
pChild = pCur->xmlChildrenNode;
while(pChild != NULL && !rc)
{
if(!(xmlStrcmp(pChild->name, (const xmlChar *) "driverInfo")))
{
XML_GET_STRING_ATTR(boardInfo->cameraLib[cameraLibIdx].driverInfo.strSensorLibraryName, pChild, "strSensorLibraryName", 1);
XML_GET_STRING_ATTR(boardInfo->cameraLib[cameraLibIdx].driverInfo.strSensorLibGetInterfFcn, pChild, "strSensorLibGetInterfFcn", 1);
}
else if(!(xmlStrcmp(pChild->name, (const xmlChar *) "inputdevs")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].numDevices, pChild, "numDevices", 1, uint32_t);
uint32_t devId = 0;
xmlNodePtr pSubChild = pChild->xmlChildrenNode;
while(pSubChild != NULL && !rc)
{
if(devId >= boardInfo->cameraLib[cameraLibIdx].numDevices)
{
CAM_MSG(HIGH, "Number of cameraLibs exceeds max");
break;
}
if(!(xmlStrcmp(pSubChild->name, (const xmlChar *) "inputdev")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].deviceId, pSubChild, "deviceId", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].deviceType, pSubChild, "deviceType", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].deviceMode, pSubChild, "deviceMode", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].deviceI2cAddr, pSubChild, "deviceI2cAddr", 1, uint8_t);
xmlNodePtr pSSubChild;
pSSubChild = pSubChild->xmlChildrenNode;
while(pSSubChild != NULL && !rc)
{
if(!(xmlStrcmp(pSSubChild->name, (const xmlChar *) "subdevs")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].numSubdevices, pSSubChild, "numSubdevices", 1, uint8_t);
uint32_t SubDevIdx = 0;
xmlNodePtr pSSubChild1 = pSSubChild->xmlChildrenNode;
while(pSSubChild1 != NULL && !rc)
{
if(SubDevIdx >= boardInfo->cameraLib[cameraLibIdx].devices[devId].numSubdevices)
{
CAM_MSG(HIGH, "Number of cameraLibs exceeds max");
break;
}
if(!(xmlStrcmp(pSSubChild1->name, (const xmlChar *) "subdev")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].subdevId, pSSubChild1, "subdevId", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].type, pSSubChild1, "type", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].serAlias, pSSubChild1, "serAlias", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].snsrAlias, pSSubChild1, "snsrAlias", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].snsrModeId, pSSubChild1, "snsrModeId", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].fsyncMode, pSSubChild1, "fsyncMode", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].fsyncFreq, pSSubChild1, "fsyncFreq", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].subdevices[SubDevIdx].colorSpace, pSSubChild1, "colorSpace", 1, uint8_t);
SubDevIdx++;
}
else if(!xmlNodeIsText(pSSubChild1))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pSSubChild1->name, pSSubChild->name);
rc = -1;
}
pSSubChild1 = pSSubChild1->next;
}
}
else if(!(xmlStrcmp(pSSubChild->name, (const xmlChar *) "csiconn")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].numCsi, pSSubChild, "numCsi", 1, uint8_t);
uint32_t csiIdx = 0;
if(SENSORLIB_MAX_NUM_CSI <= boardInfo->cameraLib[cameraLibIdx].devices[devId].numCsi)
{
CAM_MSG(ERROR, "Number of CSI exceeds max %d", SENSORLIB_MAX_NUM_CSI);
rc =-1;
break;
}
xmlNodePtr pSSubChild1 = pSSubChild->xmlChildrenNode;
while(pSSubChild1 != NULL && !rc)
{
if(csiIdx >= boardInfo->cameraLib[cameraLibIdx].devices[devId].numCsi)
{
CAM_MSG(HIGH, "Number of cameraLibs exceeds max");
break;
}
if(!(xmlStrcmp(pSSubChild1->name, (const xmlChar *) "csiInfo")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].csiInfo[csiIdx].csiId, pSSubChild1, "csiId", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].csiInfo[csiIdx].numLanes, pSSubChild1, "numLanes", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].csiInfo[csiIdx].laneAssign, pSSubChild1, "laneAssign", 1, uint16_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].csiInfo[csiIdx].ifeMap, pSSubChild1, "ifeMap", 1, uint32_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].csiInfo[csiIdx].numIfeMap, pSSubChild1, "numIfeMap", 1, uint8_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].csiInfo[csiIdx].forceHSmode, pSSubChild1, "forceHSmode", 1, uint8_t);
csiIdx++;
}
else if(!xmlNodeIsText(pSSubChild1))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pSSubChild1->name, pSSubChild->name);
rc = -1;
}
pSSubChild1 = pSSubChild1->next;
}
}
else if(!(xmlStrcmp(pSSubChild->name, (const xmlChar *) "i2cinfo")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].numI2cPorts, pSSubChild, "numI2cPorts", 1, uint8_t);
uint32_t I2cIdx = 0;
if(SENSORLIB_MAX_NUM_I2C_PER_DEVICE <= boardInfo->cameraLib[cameraLibIdx].devices[devId].numI2cPorts)
{
CAM_MSG(ERROR, "Number of I2c ports exceeds max %d", SENSORLIB_MAX_NUM_I2C_PER_DEVICE);
rc =-1;
break;
}
xmlNodePtr pSSubChild1 = pSSubChild->xmlChildrenNode;
while(pSSubChild1 != NULL && !rc)
{
if(I2cIdx >= boardInfo->cameraLib[cameraLibIdx].devices[devId].numI2cPorts)
{
CAM_MSG(HIGH, "Number of cameraLibs exceeds max");
break;
}
if(!(xmlStrcmp(pSSubChild1->name, (const xmlChar *) "i2cPort")))
{
boardInfo->cameraLib[cameraLibIdx].devices[devId].i2cPort[I2cIdx].i2ctype = CameraConfigXMLParseI2cType(pSSubChild1);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].i2cPort[I2cIdx].deviceId, pSSubChild1, "deviceId", 1, uint32_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].i2cPort[I2cIdx].portId, pSSubChild1, "portId", 1, uint32_t);
I2cIdx++;
}
else if(!xmlNodeIsText(pSSubChild1))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pSSubChild1->name, pSSubChild->name);
rc = -1;
}
pSSubChild1 = pSSubChild1->next;
}
}
else if(!(xmlStrcmp(pSSubChild->name, (const xmlChar *) "gpioinfo")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].numGpio, pSSubChild, "numGpio", 1, uint8_t);
uint32_t gpioIdx = 0;
if(SENSORLIB_MAX_NUM_GPIO_PER_DEVICE <= boardInfo->cameraLib[cameraLibIdx].devices[devId].numGpio)
{
CAM_MSG(ERROR, "Number of gpio exceeds max %d", SENSORLIB_MAX_NUM_GPIO_PER_DEVICE);
rc =-1;
break;
}
xmlNodePtr pSSubChild1 = pSSubChild->xmlChildrenNode;
while(pSSubChild1 != NULL && !rc)
{
if(gpioIdx >= boardInfo->cameraLib[cameraLibIdx].devices[devId].numGpio)
{
CAM_MSG(HIGH, "Number of cameraLibs exceeds max");
break;
}
if(!(xmlStrcmp(pSSubChild1->name, (const xmlChar *) "gpio")))
{
boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioConfig[gpioIdx].gpioType = CameraConfigXMLParseGpioSignalType(pSSubChild1);
if (CAMERA_GPIO_MAX <= boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioConfig[gpioIdx].gpioType)
{
CAM_MSG(ERROR, "Invalid GPIO type, exceeds %d", CAMERA_GPIO_MAX);
rc = -1;
break;
}
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioConfig[gpioIdx].num, pSSubChild1, "num", 1, uint32_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioConfig[gpioIdx].config, pSSubChild1, "config", 1, uint32_t);
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioConfig[gpioIdx].configMask, pSSubChild1, "configMask", 1, uint32_t);
gpioIdx++;
}
else if(!xmlNodeIsText(pSSubChild1))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pSSubChild1->name, pSSubChild->name);
rc = -1;
}
pSSubChild1 = pSSubChild1->next;
}
}
else if(!(xmlStrcmp(pSSubChild->name, (const xmlChar *) "intrinfo")))
{
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].numGpioIntr, pSSubChild, "numGpioIntr", 1, uint8_t);
uint32_t gpioIntrIdx = 0;
if(SENSORLIB_MAX_NUM_INTR_PER_DEVICE <= boardInfo->cameraLib[cameraLibIdx].devices[devId].numGpioIntr)
{
CAM_MSG(ERROR, "Number of gpio intr exceeds max %d", SENSORLIB_MAX_NUM_INTR_PER_DEVICE);
rc =-1;
break;
}
xmlNodePtr pSSubChild1 = pSSubChild->xmlChildrenNode;
while(pSSubChild1 != NULL && !rc)
{
if(gpioIntrIdx >= boardInfo->cameraLib[cameraLibIdx].devices[devId].numGpioIntr)
{
CAM_MSG(HIGH, "Number of cameraLibs exceeds max");
break;
}
if(!(xmlStrcmp(pSSubChild1->name, (const xmlChar *) "intr")))
{
boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioIntrConfig[gpioIntrIdx].intrType = CameraConfigXMLParseIntrType(pSSubChild1);
if(CAMERA_GPIO_INTR_MAX <= boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioIntrConfig[gpioIntrIdx].intrType)
{
CAM_MSG(ERROR, "Invalid intr type, exceeds %d", CAMERA_GPIO_INTR_MAX);
rc = -1;
break;
}
XML_GET_INT_ATTR(boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioIntrConfig[gpioIntrIdx].gpioPin, pSSubChild1, "gpioPin", 1, uint32_t);
boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioIntrConfig[gpioIntrIdx].triggerType = CameraConfigXMLParsetriggerType(pSSubChild1);
boardInfo->cameraLib[cameraLibIdx].devices[devId].gpioIntrConfig[gpioIntrIdx].intrMode = CameraConfigXMLParseintrMode(pSSubChild1);
gpioIntrIdx++;
}
else if(!xmlNodeIsText(pSSubChild1))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pSSubChild1->name, pSSubChild->name);
rc = -1;
}
pSSubChild1 = pSSubChild1->next;
}
}
else if(!xmlNodeIsText(pSSubChild))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pSSubChild->name, pSubChild->name);
rc = -1;
}
pSSubChild = pSSubChild->next;
}
devId++;
}
else if(!xmlNodeIsText(pSubChild))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pSubChild->name, pChild->name);
rc = -1;
}
pSubChild = pSubChild->next;
}
}
else if(!xmlNodeIsText(pChild))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pChild->name, pCur->name);
rc = -1;
}
pChild = pChild->next;
}
cameraLibIdx++;
}
else if(!xmlNodeIsText(pCur))
{
CAM_MSG(ERROR, "CameraConfig %s inside %s", pCur->name, pParent->name);
rc = -1;
}
pCur = pCur->next;
}
return rc;
}
SensorPlatform::SensorPlatformInit
/* ---------------------------------------------------------------------------
* FUNCTION SensorPlatformInit
* DESCRIPTION Initialize sensor platform with dev id
* DEPENDENCIES None
* PARAMETERS
* RETURN VALUE sensor platform ctxt ptr
* SIDE EFFECTS None
* ------------------------------------------------------------------------ */
SensorPlatform* SensorPlatform::SensorPlatformInit(const CameraConfigSensorLib_t* pDeviceConfig)
{
SensorPlatformCommon* pCtxt = new SensorPlatformCommon(pDeviceConfig);
if (pCtxt)
{
CamStatus_e rc = pCtxt->Init();
if (CAMERA_SUCCESS != rc)
{
delete pCtxt;
pCtxt = NULL;
}
}
return pCtxt;
}
/* --------------------------------------------------------------------------
** Internal Functions
** ----------------------------------------------------------------------- */
SensorPlatformCommon::SensorPlatformCommon(const CameraConfigSensorLib_t* pSensorLibConfig)
{
m_pConfig = pSensorLibConfig;
m_pHndl = NULL;
m_sensorLibId = m_pConfig->sensorLibId;
#if 0
m_i2cMutex = NULL;
memset(m_aInterrupts, 0x0, sizeof(m_aInterrupts));
#endif
}
//初始化SensorLibDeviceConfig_t中解串器GPIO的配置信息
/**
* @brief Initialize SensorPlatform
**/
CamStatus_e SensorPlatformCommon::Init()
{
CamStatus_e rc = CAMERA_SUCCESS;
QCX_LOG(SENSOR_MGR, HIGH, "SensorPlatform init camera id %d", m_sensorLibId);
for (uint32_t devIdx = 0; devIdx < m_pConfig->numDevices && CAMERA_SUCCESS == rc; devIdx++)
{
//初始化SensorLibDeviceConfig_t中解串器GPIO的配置信息
const SensorLibDeviceConfig_t* pDevice = &m_pConfig->devices[devIdx];
for (uint32_t i = 0; i < pDevice->numGpio && CAMERA_SUCCESS == rc; i++)
{
rc = PLM_GpioConfig(pDevice->gpioConfig[i].num, pDevice->gpioConfig[i].config, pDevice->gpioConfig[i].configMask);
if (CAMERA_SUCCESS != rc)
{
QCX_LOG(SENSOR_MGR, ERROR, "Failed to config GPIO %d to 0x%x",
pDevice->gpioConfig[i].num, pDevice->gpioConfig[i].config);
}
else
{
QCX_LOG(SENSOR_MGR, HIGH, "Config GPIO %d to 0x%x",
pDevice->gpioConfig[i].num, pDevice->gpioConfig[i].config);
}
}
}
return rc;
}SensorManager::LoadSensorLib
//加载sensorlib驱动
//调用sensorlib 注册的SensorLibraryAPI_t sg_sensorLibApi 回调函数
/**
* @brief Loads sensor library and its interface
*
* @param pSensorLib pointer to sensor lib struct
*
* @return #CamStatus_e
*/
CamStatus_e SensorManager::LoadSensorLib(QcxSensorLib_t* pSensorLib)
{
CamStatus_e result = CAMERA_SUCCESS;
/* Load sensor library, dlsym getinterface and acquire it */
#ifdef CAM_CFG_BUILD_STATIC_DEVICES
pSensorLib->pfnGetSensorLibInterface = pSensorLib->pSensorLibConfig->driverInfo.pfnSensorLibGetInterf;
pSensorLib->hLibrary = nullptr;
#else
//加载sensorlib驱动
if (nullptr == (pSensorLib->hLibrary = dlopen(pSensorLib->pSensorLibConfig->driverInfo.strSensorLibraryName, RTLD_NOW|RTLD_GLOBAL)))
{
QCX_LOG(SENSOR_MGR, ERROR, "'%s' loading failed '%s'",
pSensorLib->pSensorLibConfig->driverInfo.strSensorLibraryName,
dlerror());
result = CAMERA_EUNABLETOLOAD;
}
else if (NULL == (pSensorLib->pfnGetSensorLibInterface = reinterpret_cast<SensorLibGetInterface>(
dlsym(pSensorLib->hLibrary, pSensorLib->pSensorLibConfig->driverInfo.strSensorLibGetInterfFcn))))
{
QCX_LOG(SENSOR_MGR, ERROR, "'%s' interface not found '%s'",
pSensorLib->pSensorLibConfig->driverInfo.strSensorLibraryName,
dlerror());
result = CAMERA_EUNABLETOLOAD;
}
else
{
//CAMERA_SUCCESS case
}
#endif
if (CAMERA_SUCCESS == result)
{ //调用sensorlib 注册的SensorLibraryAPI_t sg_sensorLibApi 回调函数
if (nullptr == (pSensorLib->pInterface = pSensorLib->pfnGetSensorLibInterface()))
{
QCX_LOG(SENSOR_MGR, ERROR, "'%s' bad init interface",
pSensorLib->pSensorLibConfig->driverInfo.strSensorLibraryName);
result = CAMERA_EUNABLETOLOAD;
}
else if ((pSensorLib->pInterface->size != sizeof(SensorLibraryAPI_t)) ||
(pSensorLib->pInterface->majorVersion != SENSOR_LIB_VERSION_MAJOR) ||
(pSensorLib->pInterface->minorVersion != SENSOR_LIB_VERSION_MINOR) ||
(nullptr == pSensorLib->pInterface->Open) ||
(nullptr == pSensorLib->pInterface->Close) ||
(nullptr == pSensorLib->pInterface->Ioctl) ||
(nullptr == pSensorLib->pInterface->RegisterCallback))
{
QCX_LOG(SENSOR_MGR, ERROR, "'%s' bad interface",
pSensorLib->pSensorLibConfig->driverInfo.strSensorLibraryName);
QCX_LOG(SENSOR_MGR, ERROR, "%d %d %d %p %p %p %p",
pSensorLib->pInterface->size,
pSensorLib->pInterface->majorVersion,
pSensorLib->pInterface->minorVersion,
pSensorLib->pInterface->Open,
pSensorLib->pInterface->Close,
pSensorLib->pInterface->Ioctl,
pSensorLib->pInterface->RegisterCallback);
result = CAMERA_EUNABLETOLOAD;
}
else
{
//CAMERA_SUCCESS case
}
}
return result;
}SensorManager::OpenSensorLib
//调用解串器open函数接口进行初始化
//发送对应的event信号触发SensorManager::DetectHandlerThread 进行detect 操作
/**
* @brief opens instance of sensor library and registers callback
*
* @param pSensorLib pointer to sensor lib struct
*
* @return #CamStatus_e
*/
CamStatus_e SensorManager::OpenSensorLib(QcxSensorLib_t* const pSensorLib)
{
CamStatus_e result = CAMERA_SUCCESS;
SensorLibOpenParams_t openParam = {};
openParam.sensorLibId = pSensorLib->pSensorLibConfig->sensorLibId;
openParam.pPlatformFunc = &m_SensorPlatformApi;
openParam.numDevices = pSensorLib->pSensorLibConfig->numDevices;
openParam.pDevConfig = pSensorLib->pSensorLibConfig->devices;
//调用解串器open函数接口进行初始化
pSensorLib->hSensorLib = pSensorLib->pInterface->Open(&openParam);
if (nullptr == pSensorLib->hSensorLib)
{
QCX_LOG(SENSOR_MGR, ERROR, "Failed to open instance of sensorlibId %d", openParam.sensorLibId);
result = CAMERA_EFAILED;
}
else
{
//register sensor lib handle
pSensorLib->pSensorPlatform->SetSensorLibHandle(pSensorLib->hSensorLib);
SensorRet_e ret = pSensorLib->pInterface->RegisterCallback(pSensorLib->hSensorLib, SensorLibEventCallback, this);
if (SENSOR_RET_SUCCESS != ret)
{
QCX_LOG(SENSOR_MGR, ERROR, "Failed to register callback of sensorlibId %d %d", openParam.sensorLibId, ret);
result = CAMERA_EFAILED;
pSensorLib->pInterface->Close(pSensorLib->hSensorLib);
pSensorLib->hSensorLib = nullptr;
}
}
return result;
}SensorManager::DetectAll
/**
* @brief Detect all sensorlib devices and subdevices
*
*
* @return #CamStatus_e
*/
CamStatus_e SensorManager::DetectAll(void)
{
QCXInputEventMsgType sDetect[m_numSensorLibs] = {};
QCX_LOG(SENSOR_MGR, WARN, "DetectAll %d", m_numSensorLibs);
for (uint32_t sensorlibIdx = 0U; sensorlibIdx < m_numSensorLibs; sensorlibIdx++)
{
sDetect[sensorlibIdx].eventId = INPUT_EVENT_DETECT;
sDetect[sensorlibIdx].devIdx = sensorlibIdx;
QCX_LOG(SENSOR_MGR, LOW, "threadID=%d", m_sensorLibs[sensorlibIdx].pSensorLibConfig->detectThrdId);
uint32_t const detectThrdIdx = m_sensorLibs[sensorlibIdx].pSensorLibConfig->detectThrdId % MAX_DETECT_THREAD_IDX;
//发送对应的event信号触发SensorManager::DetectHandlerThread 进行detect 操作
QueueDetectEvent(&m_detectHandler[detectThrdIdx], &sDetect[sensorlibIdx]);
}
QCXCameraWaitOnSignal(m_detectSignalDone, CAM_SIGNAL_WAIT_NO_TIMEOUT);
return CAMERA_SUCCESS;
}
CamStatus_e SensorManager::QueueDetectEvent(QCXInputDetectHandlerType* const pDetectHndlr, QCXInputEventMsgType* const pMsg)
{
CamStatus_e res = CAMERA_SUCCESS;
res = QCXQueuePush(pDetectHndlr->detectQ, static_cast<void *>(pMsg), static_cast<uint64_t>(sizeof(pMsg)));
if (CAMERA_SUCCESS == res)
{
res = QCXCameraSetSignal(pDetectHndlr->signal);
}
else
{
QCX_LOG(SENSOR_MGR, ERROR, "failed to push to Queue");
}
return res;
}SensorManager::DetectHandlerThread
/**
* @brief Detect Handler Thread
*
* @param pDetectHndlr QCXInputDetectHandlerType
*
* @return #CamStatus_e
*/
int SensorManager::DetectHandlerThread(void* const pArg)
{
QCXInputDetectHandlerType* const pDetectHndlr = (QCXInputDetectHandlerType*)pArg;
SensorManager* const pCtxt = GetInstance();
if (pDetectHndlr)
{
while(!pCtxt->m_detectHandlerIsExit)
{
QCX_LOG(SENSOR_MGR, LOW, "AWAKE THREAD");
pCtxt->ProcessDetectEvent(pDetectHndlr);
QCX_LOG(SENSOR_MGR, LOW, "WAIT");
QCXCameraWaitOnSignal(pDetectHndlr->signal, CAM_SIGNAL_WAIT_NO_TIMEOUT);
}
QCX_LOG(SENSOR_MGR, WARN, "THREAD DONE");
}
return 0;
}
SensorManager::ProcessDetectEvent
/**
* @brief Process the Event for each thread
*
* @param pDetectHndlr QCXInputDetectHandlerType
*
* @return #CamStatus_e
*/
CamStatus_e SensorManager::ProcessDetectEvent(QCXInputDetectHandlerType* const pDetectHndlr)
{
QCXInputEventMsgType msg= {};
uint64_t size;
CamStatus_e ret = CAMERA_SUCCESS;
ret = QCXQueuePop(pDetectHndlr->detectQ, &msg, &size);
if (size == 0 || sizeof(msg) != size || ret != CAMERA_SUCCESS)
{
QCX_LOG(SENSOR_MGR, LOW, "Empty Queue");
}
if (INPUT_EVENT_DETECT == msg.eventId)
{
ret = SensorManager::GetInstance()->DetectInput(msg.devIdx);
if (ret != CAMERA_SUCCESS)
{
QCX_LOG(SENSOR_MGR, WARN, "Detect Fail on %d ", msg.devIdx);
}
}
return ret;
}//使用ioctl 对sensor 进行上电 MAX96712Ioctl
/**
* @brief Detects specific sensor lib devices and subdevices
* @param sensorlibIdx Sensor Library Index
*
* @return #CamStatus_e
*/
CamStatus_e SensorManager::DetectInput(uint32_t sensorlibIdx)
{
CamStatus_e result = CAMERA_SUCCESS;
QcxSensorLib_t* const pSensorLib = &m_sensorLibs[sensorlibIdx];
SensorRet_e ret = SENSOR_RET_SUCCESS;
QCX_LOG(SENSOR_MGR, HIGH, "Detect sensorlibIdx %d", sensorlibIdx);
if (nullptr == pSensorLib->pInterface)
{
QCX_LOG(SENSOR_MGR, ERROR, "No interface for sensorlibIdx %d", sensorlibIdx);
DetectIncrement();
return CAMERA_ENOTFOUND;
}
SensorLibPowerCtrl_t powerCtrl = {};
//配置power cmd
powerCtrl.cmd = SENSORLIB_PWRCMD_POWER_ON;
//使用ioctl 对sensor 进行上电 MAX96712Ioctl
ret = pSensorLib->pInterface->Ioctl(
pSensorLib->hSensorLib,
SENSORLIB_CMD_POWER_CTRL,
&powerCtrl, sizeof(powerCtrl), nullptr, 0);
if (SENSOR_RET_SUCCESS != ret)
{
QCX_LOG(SENSOR_MGR, ERROR, "Failed to power on input device %d rc=%d", sensorlibIdx, ret);
result = CAMERA_EFAILED;
}
else
{
pSensorLib->m_InputDevices[0].state = QCX_INPUT_STATE_ON;
}
if (CAMERA_SUCCESS == result)
{
QCX_KPI_LOG("QCXSERVER Deserailiser Detect Start (%d)", sensorlibIdx);
//max96712_sensor_detect_device & max96712_sensor_detect_device_channels & max96712_sensor_init_setting
ret = pSensorLib->pInterface->Ioctl(pSensorLib->hSensorLib,
SENSORLIB_CMD_DETECT,
nullptr, 0,
nullptr, 0);
QCX_KPI_LOG("QCXSERVER Deserailiser Detect End (%d)", sensorlibIdx);
if (SENSOR_RET_SUCCESS == ret)
{
pSensorLib->m_InputDevices[0].state = QCX_INPUT_STATE_DETECTED;
}
else
{
QCX_LOG(SENSOR_MGR, ERROR, "Failed to detect sensorlibId %d", pSensorLib->pSensorLibConfig->sensorLibId);
result = CAMERA_EFAILED;
}
}
if (CAMERA_SUCCESS == result)
{
SensorLibEnumSubDevices_t* const pEnumSubdevices = &pSensorLib->m_InputDevices[0].enumSubdevices;
pEnumSubdevices->devId = 0U;
//max96712_enum_subdevices
ret = pSensorLib->pInterface->Ioctl(pSensorLib->hSensorLib,
SENSORLIB_CMD_ENUM_SUBDEVICES,
pEnumSubdevices, sizeof(*pEnumSubdevices),
pEnumSubdevices, sizeof(*pEnumSubdevices));
if (SENSOR_RET_SUCCESS == ret)
{
QCX_LOG(SENSOR_MGR, WARN, "Detected sensor lib %d num subdevs %d",
pSensorLib->pSensorLibConfig->sensorLibId, pEnumSubdevices->numSubDevices);
for (uint32_t subdevIdx = 0U; subdevIdx < pEnumSubdevices->numSubDevices; subdevIdx++)
{
SensorLibSubDevice_t* pSubDev = &pEnumSubdevices->subDevices[subdevIdx];
QCX_LOG(SENSOR_MGR, WARN, "%d %d %d %d",
pSensorLib->pSensorLibConfig->sensorLibId, pSubDev->devId, pSubDev->subdevId, pSubDev->state);
for (uint32_t idx = 0U; idx < m_nInputMapping; idx++)
{
QcxInputMapping_t* const pInputMap = &m_InputMappingTable[idx];
if ((pSensorLib->pSensorLibConfig->sensorLibId == pInputMap->pInfo->sensorLibId) &&
(pSubDev->devId == pInputMap->pInfo->devId) &&
(pSubDev->subdevId == pInputMap->pInfo->subdevId))
{
QCX_LOG(SENSOR_MGR, WARN, "Input %u %s available", pInputMap->pInfo->qcarcamId, pInputMap->pInfo->name);
pInputMap->sensorlibIdx = sensorlibIdx;
pInputMap->isAvailable = TRUE;
}
}
}
}
else
{
QCX_LOG(SENSOR_MGR, ERROR, "Failed to enumerate subdevices sensorlibId %d", pSensorLib->pSensorLibConfig->sensorLibId);
result = CAMERA_EFAILED;
}
}
DetectIncrement();
return result;
}
605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
