/*
* ======== Adaptor_Module_startup ========
*/
Int Adaptor_Module_startup(Int phase)
{
Int i;
Queue_Elem *elem;
if (Queue_Module_startupDone() == FALSE) {
return (Startup_NOTDONE);
}
/* If there are control messages, put the packets onto the free msg queue */
if (ServiceMgr_supportControl == TRUE) {
elem = (Queue_Elem *)Adaptor_msgBuf;
for (i = 0; i < ServiceMgr_numIncomingCtrlPacketBufs +
ServiceMgr_numOutgoingCtrlPacketBufs; i++) {
Queue_put(Adaptor_module->freeMsgQ, elem);
elem = (Queue_Elem *)((UInt)elem + ServiceMgr_maxCtrlPacketSize);
}
}
/* Put the packets onto the free event queue */
elem = (Queue_Elem *)Adaptor_eventBuf;
for (i = 0; i < ServiceMgr_numEventPacketBufs; i++) {
Queue_put(Adaptor_module->freeEventQ, elem);
elem = (Queue_Elem *)((UInt)elem + ServiceMgr_maxEventPacketSize);
}
/* Call the transport init function */
if (ServiceMgr_transportFxns.initFxn != NULL) {
ServiceMgr_transportFxns.initFxn();
}
return (Startup_DONE);
}
/*
* ======== Clock_Instance_init ========
*/
Void Clock_Instance_init(Clock_Object *obj, Clock_FuncPtr func, UInt timeout,
const Clock_Params *params)
{
Queue_Handle clockQ;
Assert_isTrue((BIOS_clockEnabled == TRUE), Clock_A_clockDisabled);
Assert_isTrue(((BIOS_getThreadType() != BIOS_ThreadType_Hwi) &&
(BIOS_getThreadType() != BIOS_ThreadType_Swi)),
Clock_A_badThreadType);
Assert_isTrue(!(params->startFlag && (timeout == 0)), (Assert_Id)NULL);
obj->timeout = timeout;
obj->period = params->period;
obj->fxn = func;
obj->arg = params->arg;
obj->active = FALSE;
/*
* Clock object is always placed on Clock work Q
*/
clockQ = Clock_Module_State_clockQ();
Queue_put(clockQ, &obj->elem);
if (params->startFlag) {
Clock_start(obj);
}
}
/*
* ======== Adaptor_sendPacket ========
* Function called by a service to send a packet.
*/
Bool Adaptor_sendPacket(UIAPacket_Hdr *packet)
{
Bool status;
Adaptor_Entry *entry;
/* Set the src fields */
UIAPacket_setSenderAdrs(packet, 0);
/*
* If the call is being made in the context of the transferAgent,
* just call the Adaptor directly.
*/
if ((Adaptor_module->transferAgentHandle == Task_self())) {
status = Adaptor_sendToHost(packet);
}
else {
/* Not in the transfer agent's context. Put it on the outgoing queue */
entry = (Adaptor_Entry *)((UInt)packet - sizeof(Queue_Elem));
Queue_put(Adaptor_module->outgoingQ, (Queue_Elem *)entry);
Event_post(Adaptor_module->event, Event_Id_03);
status = TRUE;
}
return (status);
}
/**
* @brief print char on uart1 non-blocking
* @param c char
* @retval None
*/
void usart_putc_nb(char c) {
#ifdef USE_QUEUE
Queue_put(&txbuf, c);
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
#else
USART_SendData(USART1, c);
#endif
}
/*
* ======== Adaptor_freePacket ========
* Function called by a service to "free" a packet.
*/
Void Adaptor_freePacket(UIAPacket_Hdr *packet)
{
Queue_Elem *elem;
UIAPacket_HdrType type = UIAPacket_getHdrType(packet);
elem = (Queue_Elem *)((UInt)packet - sizeof(Queue_Elem));
/* Determine the type of header to place on the correct queue */
if (type == UIAPacket_HdrType_EventPkt) {
Queue_put(Adaptor_module->freeEventQ, elem);
Semaphore_post(Adaptor_module->freeEventSem);
}
else {
Queue_put(Adaptor_module->freeMsgQ, elem);
Semaphore_post(Adaptor_module->freeMsgSem);
}
}
/*
* ======== Task_exit ========
*/
Void Task_exit()
{
UInt tskKey, hwiKey;
Task_Object *tsk;
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
Int i;
#endif
tsk = Task_self();
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
/*
* Process Task_exit hooks. Should be called outside the Task kernel.
*/
for (i = 0; i < Task_hooks.length; i++) {
if (Task_hooks.elem[i].exitFxn != NULL) {
Task_hooks.elem[i].exitFxn(tsk);
}
}
#endif
Log_write2(Task_LD_exit, (UArg)tsk, (UArg)tsk->fxn);
tskKey = Task_disable();
hwiKey = Hwi_disable();
Task_blockI(tsk);
tsk->mode = Task_Mode_TERMINATED;
Task_processVitalTaskFlag(tsk);
Hwi_restore(hwiKey);
Queue_elemClear((Queue_Elem *)tsk);
/* add to terminated task list if it was dynamically created */
if (Task_deleteTerminatedTasks == TRUE) {
Task_Handle dynTask;
dynTask = Task_Object_first();
while (dynTask) {
if (tsk == dynTask) {
tsk->readyQ = Task_Module_State_terminatedQ();
Queue_put(tsk->readyQ, (Queue_Elem *)tsk);
break;
}
else {
dynTask = Task_Object_next(dynTask);
}
}
}
Task_restore(tskKey);
}
/**
* @brief print char on uart1
* @param c char
* @retval None
*/
void usart_putc(char c) {
#ifdef USE_QUEUE
while( Queue_put(&txbuf, c) == 0 )
;
USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
#else
USART_SendData(USART1, c);
while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
;
#endif
}
/*
* ======== Adaptor_rxTaskFxn ========
* Task that receives incoming messages from the host.
* These messages are then sent to the transfer agent.
*/
Void Adaptor_rxTaskFxn(UArg arg, UArg unused)
{
Int status;
Adaptor_Entry *entry;
UIAPacket_Hdr *packet;
/* Make sure the transport is set to go */
if (ServiceMgr_transportFxns.startFxn != NULL) {
Adaptor_module->transportMsgHandle =
ServiceMgr_transportFxns.startFxn(UIAPacket_HdrType_Msg);
}
/*
* Loop to receive msgs from the instrumentation host
*/
while (TRUE) {
/* Grab a free incomingMsg buffer */
packet = Adaptor_getFreePacket(UIAPacket_HdrType_Msg,
BIOS_WAIT_FOREVER);
/* Receive the packet. */
status = ServiceMgr_transportFxns.recvFxn(
Adaptor_module->transportMsgHandle, &packet,
ServiceMgr_maxCtrlPacketSize);
/* Put onto router's message queue */
if ((status > 0) &&
(UIAPacket_getHdrType(packet) == UIAPacket_HdrType_Msg)) {
/* The Queue elem is just above the packet */
entry = (Adaptor_Entry *)((UInt)packet - sizeof(Queue_Elem));
Queue_put(Adaptor_module->incomingQ, (Queue_Elem *)entry);
Event_post(Adaptor_module->event, Event_Id_01);
}
else {
/* Return the packet */
Adaptor_freePacket(packet);
/* Reset the transport with a stop/start */
if (ServiceMgr_transportFxns.stopFxn != NULL) {
ServiceMgr_transportFxns.stopFxn(
Adaptor_module->transportMsgHandle);
}
if (ServiceMgr_transportFxns.startFxn != NULL) {
Adaptor_module->transportMsgHandle =
ServiceMgr_transportFxns.startFxn(UIAPacket_HdrType_Msg);
}
}
}
}
/*
* ======== Task_postInit ========
* Function to be called during module startup to complete the
* initialization of any statically created or constructed task.
* Initialize stack.
* Build Initial stack image.
* Add task to corresponding ready Queue.
*
* returns (0) and clean 'eb' on success
* returns (0) and 'eb' if Task_SupportProxy_start() fails.
* returns (n) and 'eb' for number of successful createFxn() calls iff
* one of the createFxn() calls fails
*/
Int Task_postInit(Task_Object *tsk, Error_Block *eb)
{
UInt tskKey, hwiKey;
Queue_Handle readyQ;
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
Int i;
#endif
tsk->context = Task_SupportProxy_start(tsk,
(Task_SupportProxy_FuncPtr)Task_enter,
(Task_SupportProxy_FuncPtr)Task_exit,
eb);
if (Error_check(eb)) {
return (0);
}
tsk->mode = Task_Mode_READY;
tsk->pendElem = NULL;
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
for (i = 0; i < Task_hooks.length; i++) {
tsk->hookEnv[i] = (Ptr)0;
if (Task_hooks.elem[i].createFxn != NULL) {
Task_hooks.elem[i].createFxn(tsk, eb);
if (Error_check(eb)) {
return (i);
}
}
}
#endif
if (tsk->priority < 0) {
tsk->mask = 0;
tsk->readyQ = Task_Module_State_inactiveQ();
Queue_put(tsk->readyQ, (Queue_Elem *)tsk);
}
else {
tsk->mask = 1 << tsk->priority;
readyQ = Queue_Object_get(Task_module->readyQ, tsk->priority);
tsk->readyQ = readyQ;
tskKey = Task_disable();
hwiKey = Hwi_disable();
Task_unblock(tsk);
Hwi_restore(hwiKey);
Task_restore(tskKey);
}
return (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);
}
/*
* ======== Clock_addI ========
*/
Void Clock_addI(Clock_Object *obj, Clock_FuncPtr func, UInt32 timeout, UArg arg)
{
Queue_Handle clockQ;
obj->timeout = timeout;
obj->period = 0;
obj->fxn = func;
obj->arg = arg;
obj->active = FALSE;
/*
* Clock object is always placed on Clock work Q
*/
clockQ = Clock_Module_State_clockQ();
Queue_put(clockQ, &obj->elem);
}
/*
* ======== 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);
}
/*********************************************************************
* @fn Util_enqueueMsg
*
* @brief Creates a queue node and puts the node in RTOS queue.
*
* @param msgQueue - queue handle.
* @param sem - thread's event processing semaphore that queue is
* associated with.
* @param pMsg - pointer to message to be queued
*
* @return TRUE if message was queued, FALSE otherwise.
*/
uint8_t Util_enqueueMsg(Queue_Handle msgQueue,
#ifdef ICALL_EVENTS
Event_Handle event,
#else //!ICALL_EVENTS
Semaphore_Handle sem,
#endif //ICALL_EVENTS
uint8_t *pMsg)
{
queueRec_t *pRec;
// Allocated space for queue node.
#ifdef USE_ICALL
if ((pRec = ICall_malloc(sizeof(queueRec_t))))
#else
if ((pRec = (queueRec_t *)malloc(sizeof(queueRec_t))))
#endif
{
pRec->pData = pMsg;
// This is an atomic operation
Queue_put(msgQueue, &pRec->_elem);
// Wake up the application thread event handler.
#ifdef ICALL_EVENTS
if (event)
{
Event_post(event, UTIL_QUEUE_EVENT_ID);
}
#else //!ICALL_EVENTS
if (sem)
{
Semaphore_post(sem);
}
#endif //ICALL_EVENTS
return TRUE;
}
// Free the message.
#ifdef USE_ICALL
ICall_free(pMsg);
#else
free(pMsg);
#endif
return FALSE;
}
/*
* ======== Power_registerNotify ========
* Register a function to be called on a specific power event.
*
*/
Power_Status Power_registerNotify(Power_NotifyObj * pNotifyObj,
UInt32 eventTypes, Fxn notifyFxn, UArg clientArg, UArg arg)
{
/* check for NULL pointers */
if ((pNotifyObj == NULL) || (notifyFxn == NULL)) {
return (Power_EINVALIDPOINTER);
}
/* fill in notify object elements */
pNotifyObj->eventTypes = eventTypes;
pNotifyObj->notifyFxn = notifyFxn;
pNotifyObj->clientArg = clientArg;
/* place notify object on event notification queue */
Queue_put(Power_Module_State_notifyQ(), (Queue_Elem*) pNotifyObj);
return (Power_SOK);
}
/**
* @brief USART1's interrupt handler
* @param None
* @retval None
*/
void USART1_IRQHandler() {
if (USART_GetITStatus(USART1, USART_IT_RXNE)) {
uint8_t data = USART_ReceiveData(USART1);
USART_ClearITPendingBit(USART1, USART_IT_RXNE); // Clear interrupt flag
Queue_put(&rxbuf, data);
if( registered_rx_handler ) registered_rx_handler(data);
}
if (USART_GetITStatus(USART1, USART_IT_TXE)) {
USART_ClearITPendingBit(USART1, USART_IT_TXE); // Clear interrupt flag
uint16_t data = Queue_get(&txbuf);
if (data) {
USART_SendData(USART1, data & 0xFF);
} else {
USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
txrunning = 0;
}
}
}
