// -----------------------------------------------------------------------------
//! \brief Initialize an RTOS queue to hold messages to be processed.
//!
//! \param pQueue - pointer to queue instance structure.
//!
//! \return A queue handle.
// -----------------------------------------------------------------------------
Queue_Handle NPIUtil_constructQueue(Queue_Struct *pQueue)
{
// Construct a Queue instance.
Queue_construct(pQueue, NULL);
return Queue_handle(pQueue);
}
/*
* ======== Event_Instance_init ========
*/
Void Event_Instance_init(Event_Object *event, const Event_Params *params)
{
Queue_Handle pendQ;
event->postedEvents = 0;
pendQ = Event_Instance_State_pendQ(event);
Queue_construct(Queue_struct(pendQ), NULL);
}
/*
* ======== GateMutexPri_Instance_init ========
*/
Void GateMutexPri_Instance_init(GateMutexPri_Object *obj,
const GateMutexPri_Params *params)
{
Queue_Handle pendQ;
pendQ = GateMutexPri_Instance_State_pendQ(obj);
obj->mutexCnt = 1;
obj->owner = NULL;
obj->ownerOrigPri = 0;
Queue_construct(Queue_struct(pendQ), NULL);
}
/*
* ======== Semaphore_Instance_init ========
*/
Void Semaphore_Instance_init(Semaphore_Object *sem, Int count,
const Semaphore_Params *params)
{
Queue_Handle pendQ;
UInt hwiKey;
pendQ = Semaphore_Instance_State_pendQ(sem);
sem->mode = params->mode;
sem->count = count;
/* Make sure that supportsEvents is TRUE if params->event is not null */
Assert_isTrue((Semaphore_supportsEvents == TRUE) ||
((Semaphore_supportsEvents == FALSE) &&
(params->event == NULL)), Semaphore_A_noEvents);
Queue_construct(Queue_struct(pendQ), NULL);
if (Semaphore_supportsEvents && (params->event != NULL)) {
sem->event = params->event;
sem->eventId = params->eventId;
hwiKey = Hwi_disable();
if (count) {
/*
* In the unlikely case that a task is already
* pending on the event object waiting for this
* Semaphore...
*/
Hwi_restore(hwiKey);
Semaphore_eventPost(sem->event, sem->eventId);
}
else {
Semaphore_eventSync(sem->event, sem->eventId, 0);
Hwi_restore(hwiKey);
}
}
else {
sem->event = NULL;
sem->eventId = 1;
}
}
/*
* ======== GIO_Instance_init ========
*/
Int GIO_Instance_init(GIO_Object *obj, String name, UInt mode,
const GIO_Params *params, Error_Block *eb)
{
Int i, status;
Queue_Handle doneList;
Queue_Handle freeList;
DEV_Handle device;
IOM_Packet *packets;
IOM_Fxns *iomFxns;
Ptr devp;
obj->name = name;
obj->numPackets = params->numPackets;
obj->doneCount = 0;
obj->freeCount = 0;
obj->submitCount = 0;
obj->mode = mode;
obj->model = params->model;
obj->timeout = params->timeout;
if (params->sync == NULL) {
obj->userSync = FALSE;
obj->sync = SyncSemThread_Handle_upCast(SyncSemThread_create(NULL, eb));
if (obj->sync == NULL) {
return (1);
}
}
else {
obj->sync = params->sync;
obj->userSync = TRUE;
}
doneList = GIO_Instance_State_doneList(obj);
Queue_construct(Queue_struct(doneList), NULL);
freeList = GIO_Instance_State_freeList(obj);
Queue_construct(Queue_struct(freeList), NULL);
/* allocate packets */
packets = Memory_alloc(NULL, sizeof(IOM_Packet) * (obj->numPackets), 0, eb);
if (packets == NULL) {
return (2);
}
obj->packets = packets;
obj->freeCount = obj->numPackets;
/*
* Split the buffer into packets and add to freeList
*/
for (i = 0; i < obj->numPackets; i++) {
Queue_enqueue(freeList, (Queue_Elem *)&packets[i]);
}
name = DEV_match(name, &device);
if (device == NULL) {
/* The name was not found */
Error_raise(eb, GIO_E_notFound, obj->name, 0);
return (3);
}
obj->fxns = DEV_getFxns(device);
iomFxns = (IOM_Fxns *)obj->fxns;
devp = DEV_getDevp(device);
status = iomFxns->mdCreateChan(&obj->mdChan, devp, name, mode,
params->chanParams, callback, obj);
if (status != IOM_COMPLETED) {
Error_raise(eb, GIO_E_createFailed, status, 0);
return (4);
}
return (0);
}
/*
* ======== pthread_create ========
*/
int pthread_create(pthread_t *newthread, const pthread_attr_t *attr,
void *(*startroutine)(void *), void *arg)
{
Semaphore_Params semParams;
Task_Params taskParams;
pthread_Obj *thread = NULL;
Error_Block eb;
pthread_attr_t *pAttr;
Error_init(&eb);
Task_Params_init(&taskParams);
*newthread = NULL;
thread = (pthread_Obj *)Memory_alloc(Task_Object_heap(),
sizeof(pthread_Obj), 0, &eb);
if (thread == NULL) {
return (ENOMEM);
}
pAttr = (attr == NULL) ? &defaultPthreadAttrs : (pthread_attr_t *)attr;
taskParams.priority = pAttr->priority;
taskParams.stack = pAttr->stack;
taskParams.stackSize = pAttr->stacksize + pAttr->guardsize;
/* Save the function in arg0 for ROV */
taskParams.arg0 = (UArg)startroutine;
taskParams.arg1 = (UArg)thread;
taskParams.env = arg;
taskParams.priority = -1;
thread->detached = (pAttr->detachstate == PTHREAD_CREATE_JOINABLE) ? 0 : 1;
thread->fxn = startroutine;
thread->joinThread = NULL;
thread->cancelState = PTHREAD_CANCEL_ENABLE;
thread->cancelPending = 0;
thread->priority = pAttr->priority;
thread->cleanupList = NULL;
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
thread->blockedMutex = NULL;
Queue_elemClear((Queue_Elem *)thread);
Queue_construct(&(thread->mutexList), NULL);
#endif
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(thread->joinSem), 0, &semParams);
thread->task = Task_create((Task_FuncPtr)_pthread_runStub,
&taskParams, &eb);
if (thread->task == NULL) {
Semaphore_destruct(&(thread->joinSem));
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
Queue_destruct(&(thread->mutexList));
#endif
Memory_free(Task_Object_heap(), thread, sizeof(pthread_Obj));
return (ENOMEM);
}
*newthread = (pthread_t)thread;
Task_setPri(thread->task, pAttr->priority);
return (0);
}
