/* Function to allocate memory from the SyslinkMemMgr */
Ptr SyslinkMemMgr_SharedMemory_alloc(SyslinkMemMgr_SharedMemory_Object *obj,
        SyslinkMemMgr_AllocParams *allocParams)
{
    Ptr   buf = NULL;
    Error_Block eb;

    Error_init (&eb);

    if (obj != NULL) {
        buf = Memory_alloc(obj->heapHandle, allocParams->size,
                allocParams->align, &eb);
    }

    return (buf);
}
void Event::begin()
{
    Error_Block eb;
    Error_init(&eb);
    
    Event_Params params;
    Event_Params_init(&params);
    
    EventHandle = Event_create(&params, &eb);
    
    if (EventHandle == NULL)
    {
        System_abort("Event create failed");
    }
}
Example #3
0
/*!
 *  ======== InterruptArp32_intRegister ========
 */
Void InterruptArp32_intRegister(UInt16 remoteProcId,
                                 IInterrupt_IntInfo *intInfo,
                                 Fxn func, UArg arg)
{
    UInt        key;
    Hwi_Params  hwiAttrs;
    Error_Block eb;
    InterruptArp32_FxnTable *table;

    Assert_isTrue(remoteProcId < ti_sdo_utils_MultiProc_numProcessors, 
            ti_sdo_ipc_Ipc_A_internal);

    /* Assert that our MultiProc id is set correctly */
    Assert_isTrue((InterruptArp32_arp32ProcId == MultiProc_self()), 
                   ti_sdo_ipc_Ipc_A_internal);

    /* init error block */
    Error_init(&eb);
    
    /* Disable global interrupts */
    key = Hwi_disable();

    table = &(InterruptArp32_module->fxnTable);
    table->func = func;
    table->arg  = arg;

    InterruptArp32_intClear(remoteProcId, intInfo);
    
    /* Make sure the interrupt only gets plugged once */
    InterruptArp32_module->numPlugged++;
    if (InterruptArp32_module->numPlugged == 1) { 
        /* Register interrupt to remote processor */
        Hwi_Params_init(&hwiAttrs);
        hwiAttrs.arg = arg;
        hwiAttrs.vectorNum = intInfo->intVectorId;

        Hwi_create(ARP32INT,
                  (Hwi_FuncPtr)InterruptArp32_intShmStub,
                   &hwiAttrs,
                   &eb);
    }

    /* enable the mailbox and Hwi */
    InterruptArp32_intEnable(remoteProcId, intInfo);
    
    /* Restore global interrupts */
    Hwi_restore(key);
}
Example #4
0
/*!
 *  ======== NotifySetup_attach ========
 *  Initialize interrupt
 */     
Int NotifySetup_attach(UInt16 remoteProcId, Ptr sharedAddr)
{
    NotifyDriverShm_Params notifyShmParams;
    NotifyDriverShm_Handle shmDrvHandle;
    ti_sdo_ipc_Notify_Handle notifyHandle;
    Int status = Notify_S_SUCCESS;
    Error_Block eb;
    
    Error_init(&eb);
    
    NotifyDriverShm_Params_init(&notifyShmParams);
    notifyShmParams.sharedAddr = sharedAddr;
    notifyShmParams.remoteProcId  = remoteProcId;
    
    /* Set the intVectorId if on the DSP */
    if ((MultiProc_self() == NotifySetup_dsp0ProcId) ||
        (MultiProc_self() == NotifySetup_dsp1ProcId)) {
            notifyShmParams.intVectorId = NotifySetup_dspIntVectId;
    }

    /* Set the intVectorId if on the EVE */
    if ((MultiProc_self() == NotifySetup_eve0ProcId) ||
        (MultiProc_self() == NotifySetup_eve1ProcId) ||
        (MultiProc_self() == NotifySetup_eve2ProcId) ||
        (MultiProc_self() == NotifySetup_eve3ProcId)) {
        if (PROCID(remoteProcId) < 4) {
            notifyShmParams.intVectorId = NotifySetup_eveIntVectId_INTC1;
        }
        else {
            notifyShmParams.intVectorId = NotifySetup_eveIntVectId_INTC0;
        }
    }
    
    shmDrvHandle = NotifyDriverShm_create(&notifyShmParams, &eb);
    if (shmDrvHandle == NULL) {
        return (Notify_E_FAIL);
    }
    
    notifyHandle = ti_sdo_ipc_Notify_create(
            NotifyDriverShm_Handle_upCast(shmDrvHandle), remoteProcId, 0, 
            NULL, &eb);
    if (notifyHandle == NULL) {
        NotifyDriverShm_delete(&shmDrvHandle);
        status = Notify_E_FAIL;
    }

    return (status);
}
Example #5
0
/*
 *  ======== Power_registerConstraint ========
 *  Register an operational constraint with Power.
 *
 */
Power_Status Power_registerConstraint(Power_Constraint type, UArg value,
    Power_ConstraintHandle *handle)
{
    Power_Status status = Power_SOK;
    Power_ConstraintObj * pConstraint;
    Error_Block eb;

    /* check for NULL handle pointer */
    if (handle == NULL) {
        status = Power_EINVALIDPOINTER;
    }

    /* else, check for invalid constraint type */
    else if ((type < Power_DISALLOWED_CPU_SETPOINT_MASK) ||
             (type > Power_DISALLOWEDSLEEPSTATE_MASK)) {
        status = Power_EINVALIDVALUE;
    }

    /* else, allocate a constraint object */
    else {
        Error_init(&eb);
        pConstraint = Memory_calloc(Power_Object_heap(), 
            sizeof(Power_ConstraintObj), 0, &eb);
        if ((pConstraint == NULL) || Error_check(&eb)) {
            status = Power_EFAIL;
        }

        /* fill in and enqueue the constraint, update aggregate constraints */
        else {

            /* fill in constraint object elements */
            pConstraint->type = type;
            pConstraint->value = value;

            /* place constraint object on the constraints queue */
            Queue_put(Power_Module_State_constraintsQ(), 
                (Queue_Elem*) pConstraint);

            /* update aggregated constraints with the new constraint */
            Power_updateConstraints(type, value);

            /* set out parameters */
            *handle = (UArg *) pConstraint;
        }
    }

    return (status);
}
Example #6
0
void Create_uartHandler() {
	// Create UART task (RS-485)
	Task_Handle UART_taskHandle;
	Task_Params UART_taskParams;
	Error_Block UART_eb;
	Task_Params_init(&UART_taskParams);
	Error_init(&UART_eb);
	UART_taskParams.stackSize = 2048;
	UART_taskParams.priority = 1;
	UART_taskParams.arg0 = 1000;
	UART_taskHandle = Task_create((Task_FuncPtr) uartHandler, &UART_taskParams,
			&UART_eb);
	if (UART_taskHandle == NULL) {
		System_printf("main: Failed to create uartHandler Task\n");
	}
}
Example #7
0
/*
 *  ======== Power_registerNotify ========
 *  Register a function to be called on a specific power event.
 *
 */
Power_Status Power_registerNotify(Power_Event eventType, UInt eventMask,
    Fxn notifyFxn, UArg clientArg, Power_NotifyHandle * notifyHandle,
    Fxn *delayedCompletionFxn)
{
    Power_NotifyObj * pNotify;
    Queue_Handle notifyQ;
    Error_Block eb;

    /* check for out of range event type */
    if ((eventType < 0) || (eventType >= Power_INVALIDEVENT)) {
        return (Power_EINVALIDEVENT);
    }

    /* check for NULL pointers for notifyFxn and out params */
    if ((notifyFxn == NULL) || (notifyHandle == NULL) ||
       (delayedCompletionFxn == NULL)) {
        return (Power_EINVALIDPOINTER);
    }

    /* allocate a notification object */
    Error_init(&eb);
    pNotify = Memory_calloc(Power_Object_heap(), sizeof(Power_NotifyObj), 0, 
        &eb);
    if ((pNotify == NULL) || Error_check(&eb)) {
        return (Power_EFAIL);
    }

    /* fill in notify object elements */
    pNotify->eventType = eventType;
    pNotify->notifyFxn = notifyFxn;
    pNotify->clientArg = clientArg;
    pNotify->eventMask = eventMask;

    /* determine the appropriate notification queue */
    notifyQ = (Queue_Handle)((UInt8 *)(Power_module->notifyQ) +
                (UInt)(eventType * (2 * sizeof(Ptr))));

    /* place notify object on appropriate event queue */
    Queue_put(notifyQ, (Queue_Elem*) pNotify);

    /* set out parameters */
    *notifyHandle = pNotify;
    *delayedCompletionFxn = 
        (Fxn) ti_sysbios_family_c674_Power_delayCompletionFxns[eventType];

    return(Power_SOK);
}
Example #8
0
Int RcmClient_create(String server, const RcmClient_Params *params,
        RcmClient_Handle *handle)
{
    RcmClient_Object *obj;
    Error_Block eb;
    Int status = RcmClient_S_SUCCESS;


    Log_print1(Diags_ENTRY, "--> %s: ()", (IArg)FXNN);

    /* initialize the error block */
    Error_init(&eb);
    *handle = (RcmClient_Handle)NULL;

    /* TODO: add check that params was initialized correctly */

    /* allocate the object */
    obj = (RcmClient_Handle)xdc_runtime_Memory_calloc(RcmClient_Module_heap(),
        sizeof(RcmClient_Object), sizeof(Int), &eb);

    if (NULL == obj) {
        Log_error2(FXNN": out of memory: heap=0x%x, size=%u",
            (IArg)RcmClient_Module_heap(), sizeof(RcmClient_Object));
        status = RcmClient_E_NOMEMORY;
        goto leave;
    }

    Log_print1(Diags_LIFECYCLE, FXNN": instance create: 0x%x", (IArg)obj);

    /* object-specific initialization */
    status = RcmClient_Instance_init(obj, server, params);

    if (status < 0) {
        RcmClient_Instance_finalize(obj);
        xdc_runtime_Memory_free(RcmClient_Module_heap(),
            (Ptr)obj, sizeof(RcmClient_Object));
        goto leave;
    }

    /* success, return opaque pointer */
    *handle = (RcmClient_Handle)obj;


leave:
    Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
    return(status);
}
Example #9
0
//void SWItrigger::begin(uint8_t trigger, void (*functionSWItrigger)(uint8_t))
void SWItrigger::begin(uint8_t trigger, void (*functionSWItrigger)())
{
    Error_Block eb;
    Error_init(&eb);
    
    Swi_Params swiParams;
    Swi_Params_init(&swiParams);
    swiParams.trigger = trigger;
    
//    SWItriggerHandle = Swi_create((Swi_FuncPtr)functionSWItrigger(Swi_getTrigger()), &swiParams, &eb);
    SWItriggerHandle = Swi_create((Swi_FuncPtr)functionSWItrigger, &swiParams, &eb);

    if (SWItriggerHandle == NULL)
    {
        System_abort("SWItrigger create failed");
    }
}
/*
 *  ======== main ========
 */
Int main()
{ 
    Task_Handle task;
    Error_Block eb;

    System_printf("enter main()\n");

    Error_init(&eb);
    task = Task_create(taskMstr, NULL, &eb);
    if (task == NULL) {
        System_printf("Task_create() failed!\n");
        BIOS_exit(0);
    }

    BIOS_start();    /* does not return */
    return(0);
}
Example #11
0
File: os.c Project: ianjuch/ee149
/**
 * \brief create semaphore object
 *
 * Creates a counting semaphore for inter-thread synchronization.
 * The initial semaphore count is specified as an input parameter.
 *
 * \param[in] p_sem_handle      Handle to semaphore control block
 * \param[in] p_name            Name of the semaphore - UNUSED in SYS/BIOS
 * \param[in] count             Initial count of the semaphore
 *
 * \return   e_SUCCESS on success, e_FAILURE on error
 *
 * \sa OS_semaphore_delete, OS_semaphore_put, OS_semaphore_get
 * \note
 *
 * \warning
 */
e_ret_status OS_semaphore_create(handle p_handle,
                                 const void *const p_name,     //UNUSED
                                 uInt16 count)
{
    Semaphore_Handle sem_handle = NULL;
    Error_Block eb;

    Error_init(&eb);

    sem_handle = Semaphore_create(count, NULL, &eb);
    if (NULL == sem_handle) {
        return e_FAILURE;
    }

    *(Semaphore_Handle *)p_handle = sem_handle;
    return e_SUCCESS;
}
/*****************************************************************************
** Function name:  Task_Init1     
**
** Descriptions: 
**     			   Create a task in a non-running state    
** parameters:     Task *pThis, Task name, Task function, Task Fn Arg, Stack Size, 
				 Task Priority.
** Returned value: None   
**
** Dependencies/Limitations/Side Effects/Design Notes:
**		Task is just created, and it will not run until Task_Start
**                
******************************************************************************/
BOOL Task_Init1(Task *pThis, String sName, pfnTask pfn, VOID *pArg, TaskStack eStacksize, TaskPri ePriority  )
{
	Error_Block eb;

	//pThis->tskattrs = TSK_ATTRS;
	 Task_Params_init(&(pThis->tskattrs));
	 Error_init(&eb);

	//pThis->tskattrs.stacksize = eStacksize;

	pThis->tskattrs.stackSize= eStacksize;
	//Setting of Task name
	if (sName != NULL)
	{
		memcpy(pThis->Name, sName, TASK_NAME_SIZE);
		//pThis->tskattrs.name = (String )&pThis->Name[0];
		pThis->tskattrs.instance->name = (String )&pThis->Name[0];
	}
	else
	{
		//pThis->tskattrs.name = "DUMMY";
		pThis->tskattrs.instance->name ="DUMMY";
	}

	//Setting of Task priority
	pThis->tskattrs.priority = STE_TASK_SUSPEND; // Suspend the priority.
	pThis->hPriority = ePriority;
	//Setting argument
	//pThis->tskattrs.arg0 =*(xdc_UArg*)pArg;
	pThis->tskattrs.arg0 =(xdc_UArg)pArg;
	
	//pThis->Handle = TSK_create((Fxn)pfn, &pThis->tskattrs, pArg);
	pThis->Handle = Task_create((Task_FuncPtr)pfn, &pThis->tskattrs,&eb);

    if (pThis->Handle == NULL)
    {
			printf("TASK: Failed create thread");
			return FALSE;
            ///SYS_abort("Failed create thread");
			//Raise an exception.
    }

	return TRUE;

}
Example #13
0
/*!
 *  ======== InterruptDsp_intRegister ======== 
 */
Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,
                              Fxn func, UArg arg)
{
    UInt        key;
    Hwi_Params  hwiAttrs;
    Error_Block eb;
    InterruptDsp_FxnTable *table;    
   
    Assert_isTrue(intInfo->intVectorId <= 15, ti_sdo_ipc_Ipc_A_internal);

    /* init error block */
    Error_init(&eb);

    /* Disable global interrupts */
    key = Hwi_disable();

    table = &(InterruptDsp_module->fxnTable);
    table->func = func;
    table->arg  = arg;
    
    InterruptDsp_intClear(remoteProcId, intInfo);

    /* Make sure the interrupt only gets plugged once */
    InterruptDsp_module->numPlugged++;
    if (InterruptDsp_module->numPlugged == 1) { 
        /* Register interrupt to remote processor */
        Hwi_Params_init(&hwiAttrs);
        hwiAttrs.arg = arg;
        hwiAttrs.eventId = 90;

        Hwi_create(intInfo->intVectorId,
                   (Hwi_FuncPtr)InterruptDsp_intShmStub,
                   &hwiAttrs,
                   &eb);
        
        /* enable the interrupt vector */
        Hwi_enableInterrupt(intInfo->intVectorId);
    }
    
    /* Enable the mailbox interrupt to the DSP */
    InterruptDsp_intEnable(remoteProcId, intInfo);
    
    /* Restore global interrupts */
    Hwi_restore(key);
}
Example #14
0
    int wc_InitMutex(wolfSSL_Mutex* m)
    {
        Semaphore_Params params;
        Error_Block eb;

        Error_init(&eb);
        Semaphore_Params_init(&params);
        params.mode = Semaphore_Mode_BINARY;

        *m = Semaphore_create(1, &params, &eb);
        if (Error_check(&eb)) {
            Error_raise(&eb, Error_E_generic, "Failed to Create the semaphore.",
                NULL);
            return BAD_MUTEX_E;
        }
        else
            return 0;
    }
Example #15
0
MBX_Handle MBX_create(Uns size, Uns length, MBX_Attrs *attrs)
{
    Mailbox_Params params;
    Error_Block eb;

    if (attrs == NULL) {
        attrs = &MBX_ATTRS;
    }

    Mailbox_Params_init(&params);

    params.instance->name = attrs->name;
    params.heap = MEM_getHandle(attrs->segid);

    Error_init(&eb);

    return ((MBX_Handle)Mailbox_create(size, length, &params, &eb));
}
Example #16
0
/*
 *  ======== ListMP_openByAddr ========
 */
Int ListMP_openByAddr(Ptr sharedAddr, ListMP_Handle *handlePtr)
{
    ti_sdo_ipc_ListMP_Params params;
    ti_sdo_ipc_ListMP_Attrs *attrs;
    Error_Block eb;
    Int status;
    UInt16 id;
    
    Error_init(&eb);
    
    ti_sdo_ipc_ListMP_Params_init(&params);
    
    /* Tell Instance_init() that we're opening */
    params.openFlag = TRUE;
    
    attrs = (ti_sdo_ipc_ListMP_Attrs *)sharedAddr;
    params.sharedAddr = sharedAddr;
    id = SharedRegion_getId(sharedAddr);
    
    if (SharedRegion_isCacheEnabled(id)) {
        Cache_inv(attrs, sizeof(ti_sdo_ipc_ListMP_Attrs), Cache_Type_ALL, TRUE);
    }
    
    if (attrs->status != ti_sdo_ipc_ListMP_CREATED) {
        *handlePtr = NULL;
        status = ListMP_E_NOTFOUND;
    }
    else {
        /* Create the object */
        *handlePtr = (ListMP_Handle)ti_sdo_ipc_ListMP_create(&params, &eb);
        if (*handlePtr == NULL) {
            status = ListMP_E_FAIL;
        }
        else {
            status = ListMP_S_SUCCESS;
        }
    }

    if (SharedRegion_isCacheEnabled(id)) {
        Cache_inv(attrs, sizeof(ti_sdo_ipc_ListMP_Attrs), Cache_Type_ALL, TRUE);
    }

    return (status);
}
Example #17
0
/* Function to create a SyslinkMemMgr instance */
SyslinkMemMgr_TilerMemory_Handle SyslinkMemMgr_TilerMemory_create(Ptr params)
{
    Error_Block eb;

    Error_init (&eb);

    SyslinkMemMgr_TilerMemory_Object * obj = NULL;
    SyslinkMemMgr_TilerMemory_Params *instParams =
            (SyslinkMemMgr_TilerMemory_Params *)params;

    /* Allocate Memory for the object */
    obj = (SyslinkMemMgr_TilerMemory_Object *)Memory_alloc(NULL,
            sizeof(SyslinkMemMgr_TilerMemory_Object), 0, &eb);
    if (obj != NULL) {
        obj->heapHandle = instParams->heapHandle;
    }

    return (obj);
}
/**
 * /fn InitializeLedUserSwitch
 * /brief Initialize led D1 und USR SW1.
 * /return void.
 */
static void InitializeLedUserSwitch() {
	uint32_t strength;
	uint32_t pinType;
	Hwi_Params buttonHWIParams;
	Hwi_Handle buttonHwi;
	Error_Block eb;

	// enable port N
	SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
	// LED2
	GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);

	/* set pin gpio port to output */
	GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
	/*configure pad as standard pin with default output current*/
	GPIOPadConfigGet(GPIO_PORTN_BASE, GPIO_PIN_1, &strength, &pinType);
	GPIOPadConfigSet(GPIO_PORTN_BASE, GPIO_PIN_1, strength, GPIO_PIN_TYPE_STD);

	/* turn off led 1 */
	GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, 0);

	/* configure switch 1 with pull up as input on GPIO_PIN_0 as pull-up pin */
	GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_0);
	GPIOPadConfigGet(GPIO_PORTJ_BASE, GPIO_PIN_0, &strength, &pinType);
	GPIOPadConfigSet(GPIO_PORTJ_BASE, GPIO_PIN_0, strength,
	GPIO_PIN_TYPE_STD_WPU);

	Error_init(&eb);
	Hwi_Params_init(&buttonHWIParams);
	buttonHWIParams.arg = 0;
	buttonHWIParams.enableInt = false;

	buttonHwi = Hwi_create(INT_GPIOJ_TM4C129, ButtonFunction, &buttonHWIParams,
			&eb);

	if (buttonHwi == NULL) {
		System_abort("Button Hardware interrupt create failed.");
	}
	Hwi_enableInterrupt(INT_GPIOJ_TM4C129);
	GPIOIntEnable(GPIO_PORTJ_BASE, GPIO_INT_PIN_0);

}
Example #19
0
File: os.c Project: ianjuch/ee149
/**
 * \brief creates a mutex for inter-thread mutual exclusion for resource protection
 *
 *
 *
 *  \param[in] p_handle     Handle to a mutex control block
 *  \param[in] p_name       Name of mutex
 *
 * \return   e_SUCCESS on success, e_FAILURE on error
 *
 * \sa OS_mutex_delete, OS_mutex_lock, OS_mutex_unlock
 * \note
 *
 * \warning
 */
e_ret_status OS_mutex_create(handle p_handle, const void *const p_name)
{
    GateMutex_Params gateParams;
    GateMutex_Handle mtx_handle = {0};

    Error_Block eb;

    GateMutex_Params_init(&gateParams);
    Error_init(&eb);

    gateParams.instance->name = "Default_Name";

    mtx_handle = GateMutex_create(&gateParams, &eb);
    if (NULL == mtx_handle) {
        return e_FAILURE;
    }

    *(GateMutex_Handle *)p_handle = mtx_handle;
    return e_SUCCESS;
}
/*****************************************************************************
** Function name:  Task_Init      
**
** Descriptions: 
**     			   Create a task in a non-running state    
** parameters:     Task *pThis, Task name, Task function, Task Fn Arg, Stack Size, 
				 Task Priority.
** Returned value: None   
**
** Dependencies/Limitations/Side Effects/Design Notes:
**		Task is just created, and it will not run until Task_Start
**                
******************************************************************************/
BOOL Task_Init(Task *pThis, String sName, pfnTask pfn, VOID *pArg)
{

	//pThis->tskattrs = TSK_ATTRS;
	Error_Block eb;
	 Task_Params_init(&(pThis->tskattrs));
	 Error_init(&eb);

	//Setting of Task name
	if (sName != NULL)
	{
		memcpy(pThis->Name, sName, TASK_NAME_SIZE);
		//pThis->tskattrs.name = (String )&pThis->Name[0];
		pThis->tskattrs.instance->name = (String )&pThis->Name[0];
	}
	else
	{
		//pThis->tskattrs.name = "DUMMY";
		pThis->tskattrs.instance->name ="DUMMY";
	}

	//Setting of Task priority
	pThis->tskattrs.priority = STE_TASK_SUSPEND; // Suspend the priority.
	pThis->hPriority = STE_TASK_DEFAULT_PRI;
//	printf("task stacksize %d\n",pThis->tskattrs.stacksize);
	pThis->tskattrs.stackSize= 4*1024;
	//Setting argument
	//	pThis->tskattrs.arg0 =*(xdc_UArg*)pArg;
	pThis->tskattrs.arg0 =(xdc_UArg)pArg;
	
	//pThis->Handle = TSK_create((Fxn)pfn, &pThis->tskattrs, pArg);
	pThis->Handle = Task_create((Task_FuncPtr)pfn, &pThis->tskattrs,&eb);

    if (pThis->Handle == NULL)
    {
			printf("TASK: Failed create thread");
			return FALSE;
    }

	return TRUE;
}
Example #21
0
File: os.c Project: ianjuch/ee149
/**
 * \brief create and run a new thread
 *
 * creates an application thread that starts execution at the specified task entry function.
 * The stack and priority, are among the attributes specified by the input parameters.
 * In addition, the initial execution state of the thread is set to start running immediately after the thead is created
 *
 *  \param[in] p_handle     Handle to a thread control block
 *  \param[in] p_params     Thread params - Memory to be freed by caller
 *                              stackSize = Size of stack
 *                              priority = Task's priority (Order specific to OS)
 *                              p_entry_function = Task's entry function
 *
 * \return   e_SUCCESS on success, e_FAILURE on error
 *
 * \sa OS_thread_delete, OS_thread_terminate, OS_thread_sleep
 * \note
 *
 * \warning
 */
e_ret_status OS_thread_create(handle p_handle,
                              s_thread_params *p_params)
{
    Task_Handle tsk_handle = NULL;
    Task_Params taskParams;
    Error_Block eb;

    Error_init(&eb);

    Task_Params_init(&taskParams);
    taskParams.stackSize = p_params->stack_size;
    taskParams.priority = p_params->priority;

    tsk_handle = Task_create(p_params->p_entry_function, &taskParams, &eb);
    if (NULL == tsk_handle) {
        return e_FAILURE;
    }

    *(Task_Handle *) p_handle = tsk_handle;
    return e_SUCCESS;
}
Example #22
0
/*
 *  ======== MessageQ_create ========
 */
MessageQ_Handle MessageQ_create(String name, const MessageQ_Params *params)
{
    ti_sdo_ipc_MessageQ_Handle handle;
    ti_sdo_ipc_MessageQ_Params prms;
    Error_Block eb;

    Error_init(&eb);

    if (params != NULL) {
        ti_sdo_ipc_MessageQ_Params_init(&prms);
        
        prms.synchronizer = params->synchronizer;

        handle = ti_sdo_ipc_MessageQ_create(name, &prms, &eb);
    }
    else {
        handle = ti_sdo_ipc_MessageQ_create(name, NULL, &eb);
    }

    return ((MessageQ_Handle)handle);
}
Example #23
0
/*
 *  ======== GIO_addDevice ========
 */
Int GIO_addDevice(String name, Ptr fxns, GIO_InitFxn initFxn, Int devid, Ptr deviceParams)
{
    DEV_Handle device;
    DEV_Params params;
    Error_Block eb;

    Error_init(&eb);
    DEV_Params_init(&params);
    params.deviceParams = deviceParams;
    params.initFxn = initFxn;
    params.devid = devid;

    device = DEV_create(name, fxns, &params, &eb);

    if (device != NULL) { 
        return (IOM_COMPLETED);
    }
    else {
        return (IOM_EBADIO);
    }
}
/**
 * usage: this method creates the UART task, interacting with the queue,
 * 		  which is filled in the i2c_method
 * @method setup_UART_Task
 * @author: patrik.szabo
 * @param *none*
 * @return 0, if everything succeeded
 */
int setup_UART_Task(void) {
	Task_Params taskUARTParams;
	Task_Handle taskUART;
	Error_Block eb;

	Error_init(&eb);
	Task_Params_init(&taskUARTParams);
	taskUARTParams.stackSize = 1024; // stack in bytes
	taskUARTParams.priority = 14; // 15 is default 16 is highest priority -> see RTOS configuration
	taskUART = Task_create((Task_FuncPtr) uart_method, &taskUARTParams, &eb);
	if (taskUART == NULL) {
		System_abort("TaskUART create failed");
	}

	uartQueue = Queue_create(NULL, NULL);

	// TODO: this should be in external module
	externalModuleQueue = Queue_create(NULL, NULL);

	return (0);
}
Example #25
0
void Clock::begin(void (*ClockFunction)(void), uint32_t ClockTimeOut_ms, uint32_t ClockPeriod_ms)
{
    Error_Block eb;
    Error_init(&eb);

    Clock_Params_init(&ClockParams);
    ClockParams.startFlag = false; // Requires Clock_start

    // ClockParams.period = microsecondsToClockCycles(ClockPeriod_ms); // ms to be translated into ticks
    // ClockHandle = Clock_create( (Clock_FuncPtr)ClockFunction, microsecondsToClockCycles(ClockTimeOut_ms), &ClockParams, &eb);

    // Surprisingly, period already defined in ms for ClockParams.period andClockTimeOut_ms
    ClockParams.period = ClockPeriod_ms;
    ClockHandle = Clock_create( (Clock_FuncPtr)ClockFunction, ClockTimeOut_ms, &ClockParams, &eb);

    if (ClockHandle == NULL)
    {
        // Serial.println("*** Clock create failed");
        System_abort("Clock create failed");
    }
}
Example #26
0
/*
 *  ======== HWI_dispatchPlug ========
 *  Plug the HWI dispatcher table.
 */
Void HWI_dispatchPlug(Int vecid, Fxn fxn, HWI_Attrs *attrs)
{
    Hwi_Params hwiParams;
    Hwi_Handle hwi;
    Error_Block eb;

    if (attrs == NULL) {
        attrs = &HWI_ATTRS;
    }

    Hwi_Params_init(&hwiParams);

    Error_init(&eb);

    if (attrs->ierMask == 1) {
        hwiParams.maskSetting = Hwi_MaskingOption_SELF;
    }
    else {
        hwiParams.maskSetting = Hwi_MaskingOption_BITMASK;
    }
    
    hwiParams.disableMask = hwiParams.restoreMask = attrs->ierMask;

    hwiParams.arg = attrs->arg;
    hwiParams.enableInt = FALSE; 

    /* 
     * Tell the BIOS6 dispatcher not to ACK interrupts because the BIOS5
     * dispatcher doesn't ACK interrupts
     */
    hwiParams.enableAck = FALSE;

    hwi = Hwi_getHandle(vecid);
    if (hwi == NULL) {
        Hwi_create(vecid, (Hwi_FuncPtr)fxn, &hwiParams, &eb);
    }
    else {
        Hwi_reconfig(hwi, (Hwi_FuncPtr)fxn, &hwiParams);
    }
}
Example #27
0
/*
 *  ======== LoggerBuf_setFilterLevel ========
 *  Sets the filter level for the given diags level.
 *
 *  LoggerBuf maintains a separate filter level for every diags category. This
 *  is accomplished by maintaining three masks, one for each of the levels 1 - 
 *  3, wich store the diags categories which are currently at that level. There
 *  is no mask for level4; if the diags category is not found in levels 1-3, it
 *  is  assumed that the filtering level is level4.
 *
 *  This API is an instance function per the IFilterLogger interface, but 
 *  LoggerBuf only maintains module-wide filter levels.
 *
 *  TODO - Should this be conditional on the 'filterByLevel' config?
 */
Void LoggerBuf_setFilterLevel(LoggerBuf_Object *obj, Diags_Mask mask, 
                              Diags_EventLevel filterLevel)
{   
    /* 
     * First, remove the bits in 'mask' from all of the current 'level' masks.
     * Use level = (~(mask & level) & level) to remove 'mask' bits from all 
     * 'level's.
     *    1. AND mask and level to get set of bits that appear in both
     *    2. Take the inverse of this set and AND it with 'level' to disable
     *       any bits which appear in 'mask'.
     */
    LoggerBuf_module->level1 = ~(LoggerBuf_module->level1 & mask) & 
                               LoggerBuf_module->level1;
    LoggerBuf_module->level2 = ~(LoggerBuf_module->level2 & mask) & 
                               LoggerBuf_module->level2;    
    LoggerBuf_module->level3 = ~(LoggerBuf_module->level3 & mask) & 
                               LoggerBuf_module->level3;    
    
    /* Enable the bits specified in 'mask' in the appropriate level. */
    switch (filterLevel) {
        case Diags_LEVEL1:
            LoggerBuf_module->level1 |= mask;
            break;
        case Diags_LEVEL2:
            LoggerBuf_module->level2 |= mask;
            break;
        case Diags_LEVEL3:
            LoggerBuf_module->level3 |= mask;
            break;
        case Diags_LEVEL4:
            break;
        default: {
            /* Raise an error that a bad filter level was received. */
            Error_Block eb;
            Error_init(&eb);
            Error_raise(&eb, LoggerBuf_E_badLevel, filterLevel, 0);
            break;
        }
    }
}
Example #28
0
/*
 *  ======== Board_initDMA ========
 */
void Board_initDMA(void)
{
    Error_Block eb;
    Hwi_Params  hwiParams;

    if (!dmaInitialized) {
        Error_init(&eb);
        Hwi_Params_init(&hwiParams);
        Hwi_construct(&(hwiStruct), INT_UDMAERR, Board_errorDMAHwi,
                      &hwiParams, &eb);
        if (Error_check(&eb)) {
            System_abort("Couldn't create DMA error hwi");
        }

        MAP_PRCMPeripheralClkEnable(PRCM_UDMA, PRCM_RUN_MODE_CLK);
        MAP_PRCMPeripheralReset(PRCM_UDMA);
        MAP_uDMAEnable();
        MAP_uDMAControlBaseSet(dmaControlTable);

        dmaInitialized = true;
    }
}
Example #29
0
/*
 *  ======== EK_TM4C123GXL_initDMA ========
 */
void EK_TM4C123GXL_initDMA(void) {
	Error_Block eb;
	Hwi_Params hwiParams;

	if (!DMA_initialized) {

		Error_init(&eb);

		Hwi_Params_init(&hwiParams);
		Hwi_construct(&(hwiStruct), INT_UDMAERR, EK_TM4C123GXL_errorDMAHwi,
				&hwiParams, &eb);
		if (Error_check(&eb)) {
			System_abort("Couldn't create DMA error hwi");
		}

		SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
		uDMAEnable();
		uDMAControlBaseSet(EK_TM4C123GXL_DMAControlTable);

		DMA_initialized = true;
	}
}
Example #30
0
/*
 *  ======== MessageQ_open ========
 */
Int MessageQ_open(String name, MessageQ_QueueId *queueId)
{
    Int         status;
    Error_Block eb;

    Assert_isTrue(name != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);
    Assert_isTrue(queueId != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);

    Error_init(&eb);
    
    /* Search NameServer */
    status = NameServer_getUInt32(
            (NameServer_Handle)MessageQ_module->nameServer, name, queueId, 
            NULL);

    if (status >= 0) {
        return (MessageQ_S_SUCCESS);    /* name found */
    }
    else {
        return (MessageQ_E_NOTFOUND);   /* name not found */
    }
}