// ----------------------------------------------------------------------------- //! \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); }