Esempi in C++ (Cpp) per TIMM_OSAL_ERR_CREATE

Esempio n. 1

File: timm_osal_semaphores.c Progetto: go2ev-devteam/FrontCameraAnalyzer

TIMM_OSAL_ERRORTYPE TIMM_OSAL_SemaphoreObtain(TIMM_OSAL_PTR pSemaphore, TIMM_OSAL_U32 uTimeOut)
{
    TIMM_OSAL_SEMAPHORE *pHandle = (TIMM_OSAL_SEMAPHORE *)pSemaphore;
    TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
    TIMM_OSAL_U32 timeout;
    Bool status;

    if(pHandle == NULL)
    {
        bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
        goto EXIT;
    }

    if (TIMM_OSAL_SUSPEND == uTimeOut) {
        timeout = BIOS_WAIT_FOREVER;
    }
    else
    {
        timeout = _TIMM_OSAL_GetTicks(uTimeOut);
    }

    status = Semaphore_pend(pHandle->sem, timeout);

    if(status == FALSE)
    {
        bReturnStatus = TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR, TIMM_OSAL_COMP_SEMAPHORES, status);
    }
EXIT:
    return bReturnStatus;
}

Esempio n. 2

File: timm_osal_pipes.c Progetto: mrchapp/audio-omx

TIMM_OSAL_ERRORTYPE TIMM_OSAL_ClearPipe (TIMM_OSAL_PTR pPipe)
{
    TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR;

#if 0
    TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
    STATUS status = NU_SUCCESS;

    TIMM_OSAL_PIPE *pHandle = (TIMM_OSAL_PIPE *)pPipe;

    status = NU_Reset_Pipe (&(pHandle->pipe));

    if (NU_SUCCESS != status) {
        /*TIMM_OSAL_Error ("NU_Reset_Pipe failed!!!");*/
        bReturnStatus = TIMM_OSAL_ERR_CREATE(TIMM_OSAL_ERR, TIMM_OSAL_COMP_PIPES, status);
    }
#endif
    return bReturnStatus;
}

Esempio n. 3

File: timm_osal_task.c Progetto: andreimironenko/omx

TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreateTaskExtn (TIMM_OSAL_PTR *pTask,
                                              TIMM_OSAL_TaskProc pFunc,
                                              TIMM_OSAL_U32 uArgc,
                                              TIMM_OSAL_PTR pArgv,
                                              TIMM_OSAL_U32 uStackSize,
                                              TIMM_OSAL_U32 uPriority,
                                              TIMM_OSAL_S8 *pName,
                                              TIMM_OSAL_PTR hStackHeapHandle)
{
    TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
 
    TIMM_OSAL_TASK *pHandle = TIMM_OSAL_NULL;
    Task_Params  taskParams; 

    *pTask = TIMM_OSAL_NULL;
    
    if((pFunc == NULL)|| (uPriority > 31))
    {
       bReturnStatus = TIMM_OSAL_ERR_PARAMETER;	
	   goto EXIT;
    }
    
    pHandle = (TIMM_OSAL_TASK *) TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_TASK), 
		                                         TIMM_OSAL_TRUE, 0,
                                                 TIMMOSAL_MEM_SEGMENT_EXT);

    if(TIMM_OSAL_NULL == pHandle)
    {
        bReturnStatus = TIMM_OSAL_ERR_ALLOC;
		goto EXIT;
    }

    /* Initial cleaning of the task structure */
    TIMM_OSAL_Memset((TIMM_OSAL_PTR)pHandle, 0, sizeof (TIMM_OSAL_TASK));

    pHandle->isCreated = TIMM_OSAL_FALSE;

	strncpy((TIMM_OSAL_CHAR *)pHandle->name, (TIMM_OSAL_CHAR *)pName, TASK_NAME_SIZE);
    pHandle->name[TASK_NAME_SIZE] = '\000';
    pHandle->stackSize = uStackSize;
    pHandle->priority  = uPriority;

    /* Allocate memory for task stack */
    pHandle->stackPtr = (TIMM_OSAL_PTR *)TIMM_OSAL_MallocExtn(pHandle->stackSize, 
                                                   TIMM_OSAL_TRUE, 0, 
                                                   TIMMOSAL_MEM_SEGMENT_EXT,
                                                   hStackHeapHandle);
    if (TIMM_OSAL_NULL == pHandle->stackPtr) 
	{
        TIMM_OSAL_Error("TIMM_OSAL_Malloc failed during task stack allocation");
        bReturnStatus = TIMM_OSAL_ERR_ALLOC;
        goto EXIT;
    }
    TIMM_OSAL_Memset(pHandle->stackPtr, 0xFE, pHandle->stackSize);

    Task_Params_init(&taskParams);

    taskParams.arg0 = uArgc;
    taskParams.arg1 = (TIMM_OSAL_U32)pArgv;
    taskParams.priority = uPriority;
    taskParams.stack = pHandle->stackPtr;
    taskParams.stackSize = uStackSize;
	taskParams.instance->name = (xdc_String)pHandle->name;
     
    /* Create the task */
    pHandle->task = Task_create((Task_FuncPtr)pFunc, &taskParams, NULL);

    if (pHandle->task == NULL) 
	{
        bReturnStatus = (TIMM_OSAL_ERRORTYPE)TIMM_OSAL_ERR_CREATE
			                      (TIMM_OSAL_ERR, TIMM_OSAL_COMP_TASK, FALSE);
        goto EXIT;
    }

    /* Task was successfully created */
    pHandle->isCreated = TIMM_OSAL_TRUE;
    
    *pTask = (TIMM_OSAL_PTR *)pHandle;

EXIT:
    if((TIMM_OSAL_ERR_NONE != bReturnStatus) && (TIMM_OSAL_NULL != pHandle)) 
	{
		if(TIMM_OSAL_NULL != pHandle->stackPtr) 
            TIMM_OSAL_Free (pHandle->stackPtr);
        TIMM_OSAL_Free (pHandle);
    }
    return bReturnStatus;
}