Int SystemCfg_detach(SystemCfg_Object *obj)
{
Int status;
Log_print1(Diags_ENTRY,
"--> "FXNN": (remoteProcId=%d)", (IArg)obj->remoteProcId);
/* connect to remote processor */
do {
status = Ipc_detach(obj->remoteProcId);
if (status < 0) {
Task_yield();
}
} while (status < 0); // TODO: status == E_RETRY
if (status < 0) {
Log_error1(FXNN": Ipc_detach() failed, error=%d", (IArg)status);
goto leave;
}
Log_print1(Diags_INFO, FXNN": remoteProcId=%d", (IArg)obj->remoteProcId);
leave:
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
Int SystemCfg_detachHook(UArg userCtx, UInt16 remoteProcId)
{
Int status;
List_Elem * elem = NULL;
SystemCfg_Object * obj = NULL;
IArg key;
/* find object on module list */
key = GateH_enter(Mod_gate);
while ((elem = List_next(Mod_objList, elem)) != NULL) {
obj = (SystemCfg_Object *)elem;
if (obj->remoteProcId == remoteProcId) {
break;
}
obj = NULL;
}
GateH_leave(Mod_gate, key);
if (obj != NULL) {
status = Notify_unregisterEvent(remoteProcId, SystemCfg_NotifyLineId,
SystemCfg_HostDspEvtNum, SystemCfg_notifyCB, (UArg)obj);
if (status < 0) {
Log_error1(FXNN": Notify_unregisterEvent() error %d", (IArg)status);
}
}
return(status);
}
static XDAS_Int32 handleSetupImageDesc(TrikCvHandle* _handle)
{
assert(_handle);
TrikCvPersistentData& pd = getHandlePersistentData(_handle);
XDAS_Int32 res;
if ( _handle->m_params.base.numOutputStreams != 0
&& _handle->m_params.base.numOutputStreams != 1)
{
Log_error1("Invalid number of output stream: %d", _handle->m_params.base.numOutputStreams);
return IALG_EFAIL;
}
TrikCvImageDesc inImageDesc;
TrikCvImageDesc outImageDesc;
inImageDesc.m_format = static_cast<TrikCvImageFormat>(_handle->m_params.base.formatInput);
inImageDesc.m_width = _handle->m_dynamicParams.inputWidth > 0 ? _handle->m_dynamicParams.inputWidth : 0;
inImageDesc.m_height = _handle->m_dynamicParams.inputHeight > 0 ? _handle->m_dynamicParams.inputHeight : 0;
inImageDesc.m_lineLength = _handle->m_dynamicParams.inputLineLength > 0 ? _handle->m_dynamicParams.inputLineLength : 0;
if (_handle->m_params.base.numOutputStreams == 1)
{
outImageDesc.m_format = static_cast<TrikCvImageFormat>(_handle->m_params.base.formatOutput[0]);
outImageDesc.m_width = _handle->m_dynamicParams.base.outputWidth[0] > 0 ? _handle->m_dynamicParams.base.outputWidth[0] : 0;
outImageDesc.m_height = _handle->m_dynamicParams.base.outputHeight[0] > 0 ? _handle->m_dynamicParams.base.outputHeight[0] : 0;
outImageDesc.m_lineLength = _handle->m_dynamicParams.outputLineLength[0] > 0 ? _handle->m_dynamicParams.outputLineLength[0] : 0;
}
else
{
outImageDesc.m_format = TRIK_VIDTRANSCODE_CV_VIDEO_FORMAT_UNKNOWN;
outImageDesc.m_width = 0;
outImageDesc.m_height = 0;
outImageDesc.m_lineLength = 0;
}
if ( (inImageDesc.m_width < 0 || inImageDesc.m_width > _handle->m_params.base.maxWidthInput)
|| (inImageDesc.m_height < 0 || inImageDesc.m_height > _handle->m_params.base.maxHeightInput)
|| (outImageDesc.m_width < 0 || outImageDesc.m_width > _handle->m_params.base.maxWidthOutput[0])
|| (outImageDesc.m_height < 0 || outImageDesc.m_height > _handle->m_params.base.maxHeightOutput[0]))
{
Log_error4("Invalid image dimensions: %dx%d -> %dx%d",
inImageDesc.m_width, inImageDesc.m_height,
outImageDesc.m_width, outImageDesc.m_height);
return IALG_EFAIL;
}
if ((res = handleSetupImageDescCreateCVAlgorithm(_handle, pd, inImageDesc, outImageDesc)) != IALG_EOK)
{
Log_error0("Cannot create CV algorithm");
return res;
}
Log_info0("Image description setup succeed");
return IALG_EOK;
}
/*
* ======== Server_delete ========
*/
Int Server_delete()
{
Int status;
GateMPApp_Msg * msg;
MessageQ_QueueId queId;
Log_print0(Diags_ENTRY, "--> Server_delete:");
/* wait for inbound message */
status = MessageQ_get(Module.slaveQue, (MessageQ_Msg *)&msg,
MessageQ_FOREVER);
if (status < 0) {
goto leave;
}
Log_print0(Diags_ENTRY, "--> Server_delete: got msg");
if (msg->cmd != GATEMPAPP_CMD_SHUTDOWN) {
status = GATEMPAPP_E_UNEXPECTEDMSG;
goto leave;
}
/* send message back to say that GateMP has been cleaned up */
queId = MessageQ_getReplyQueue(msg); /* type-cast not needed */
msg->cmd = GATEMPAPP_CMD_SHUTDOWN_ACK;
MessageQ_put(queId, (MessageQ_Msg)msg);
/* delete the video message queue */
status = MessageQ_delete(&Module.slaveQue);
if (status < 0) {
Log_print0(Diags_ENTRY, "Server_delete: MessageQ_delete failed");
goto leave;
}
Log_print0(Diags_ENTRY, "Server_delete: MessageQ deleted");
/* delete slave GateMP */
status = GateMP_delete(&Module.slaveGateMPHandle);
if (status < 0) {
Log_print0(Diags_ENTRY, "Server_delete: GateMP_delete failed");
goto leave;
}
Log_print0(Diags_ENTRY, "Server_delete: slave GateMP deleted");
leave:
if (status < 0) {
Log_error1("Server_delete: error=0x%x", (IArg)status);
}
/* disable log events */
Log_print1(Diags_EXIT, "<-- Server_delete: %d", (IArg)status);
Diags_setMask(MODULE_NAME"-EXF");
return(status);
}
Int SystemCfg_start(SystemCfg_Handle handle, String filePath)
{
Int status;
/* initialize ipc layer */
status = Ipc_start();
if (status < 0) {
Log_error1(FXNN": Ipc_start() error %d", (IArg)status);
}
return(status);
}
Int SystemCfg_sendEvent(SystemCfg_Object *obj, UInt32 event)
{
Int status;
/* send event to remote core */
status = Notify_sendEvent(obj->remoteProcId, SystemCfg_NotifyLineId,
SystemCfg_HostDspEvtNum, event, TRUE);
if (status < 0) {
Log_error1(FXNN": Notify_sendEvent() error %d", (IArg)status);
}
return(status);
}
Int RcmClient_alloc(RcmClient_Object *obj, UInt32 dataSize,
RcmClient_Message **message)
{
SizeT totalSize;
RcmClient_Packet *packet;
Int status = RcmClient_S_SUCCESS;
Log_print3(Diags_ENTRY,
"--> RcmClient_alloc: obj: 0x%x, dataSize: %d, message: 0x%x",
(IArg)obj, (IArg)dataSize, (IArg)message);
/* ensure minimum size of UInt32[1] */
dataSize = (dataSize < sizeof(UInt32) ? sizeof(UInt32) : dataSize);
/* total memory size (in chars) needed for headers and payload */
totalSize = sizeof(RcmClient_Packet) - sizeof(UInt32) + dataSize;
/* allocate the message */
packet = (RcmClient_Packet*)MessageQ_alloc(obj->heapId, totalSize);
if (NULL == packet) {
Log_error1(FXNN": could not allocate message, size = %u",
(IArg)totalSize);
status = RcmClient_E_MSGALLOCFAILED;
goto leave;
}
/* Log_info() */
Log_print2(Diags_INFO,
FXNN": RcmMessage allocated: addr=0x%x, size=%u (total size)",
(IArg)packet, (IArg)totalSize);
/* initialize the packet structure */
packet->desc = 0;
packet->msgId = RcmClient_genMsgId_P(obj);
packet->message.poolId = RcmClient_DEFAULTPOOLID;
packet->message.jobId = RcmClient_DISCRETEJOBID;
packet->message.fxnIdx = RcmClient_INVALIDFXNIDX;
packet->message.result = 0;
packet->message.dataSize = dataSize;
/* set message pointer to start of the message struct */
*message = (RcmClient_Message *)(&(packet->message));
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
Int SystemCfg_createResources(SystemCfg_Object *obj)
{
Error_Block eb;
Int status = 0;
HeapBuf_Params heapBufP;
IHeap_Handle heapH;
Log_print1(Diags_ENTRY | Diags_INFO, "--> "FXNN": (obj=0x%x)",(IArg)obj);
Error_init(&eb);
/* allocate heap backing store from SR_0 heap */
heapH = (IHeap_Handle)SharedRegion_getHeap(0);
obj->rcmHeapBufSize = 5 * 128;
obj->rcmHeapBufBase = Memory_alloc(heapH, obj->rcmHeapBufSize, 128, &eb);
if (Error_check(&eb)) {
Log_error1(FXNN": out of memory: size=%u", obj->rcmHeapBufSize);
status = -1;
goto leave;
}
/* create heap for messages */
HeapBuf_Params_init(&heapBufP);
heapBufP.blockSize = 128; // header = 52 B, payload = 76 B
heapBufP.numBlocks = 5; // 5 messages, total heap storage = 640 B
heapBufP.align = 128; // align on cache line boundary
heapBufP.buf = obj->rcmHeapBufBase; // heap storage base address
heapBufP.bufSize = obj->rcmHeapBufSize; // heap storage size
obj->rcmHeapH = HeapBuf_create(&heapBufP, &eb);
if (Error_check(&eb)) {
Log_error0(FXNN": HeapBuf_create() failed");
status = -1;
goto leave;
}
/* register this heap with MessageQ */
Log_print2(Diags_INFO,
FXNN": MessageQ_registerHeap: (rcmHeapH: 0x%x, heapId: %d)",
(IArg)(obj->rcmHeapH), (IArg)SystemCfg_RcmMsgHeapId_CompDev);
MessageQ_registerHeap((Ptr)(obj->rcmHeapH), SystemCfg_RcmMsgHeapId_CompDev);
leave:
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
/*
* ======== spi_Read ========
* SimpleLink Host Driver API to receive data from the SPI communication
* interface.
*/
int spi_Read(Fd_t fd, unsigned char *pBuff, int len)
{
WiFiCC3100_Object *object = wifiHandle->object;
SPI_Transaction transaction;
uint32_t msgLength = 0;
Assert_isTrue(object->spiState == WiFiCC3100_SPI_IDLE, NULL);
while (msgLength < len) {
/*
* The DMA can only perform a maximum of DMA_WINDOW_SIZE word transfers
* at a time. Read transactions are split into DMA_WINDOW_SIZE
* transfers until complete.
*/
if (len - msgLength > DMA_WINDOW_SIZE) {
object->spiState = WiFiCC3100_SPI_READ_MSG;
transaction.count = DMA_WINDOW_SIZE;
}
else {
object->spiState = WiFiCC3100_SPI_READ_EOT;
transaction.count = len - msgLength;
}
transaction.rxBuf = (pBuff + msgLength);
transaction.txBuf = NULL;
WiFiCC3100_assertCS();
if (!SPI_transfer(object->spiHandle, &transaction)) {
Log_error1("SPI transfer failed: %d bytes read.", transaction.count);
return (-1);
}
Semaphore_pend((Semaphore_Handle)(&(object->readSemaphore)),
BIOS_WAIT_FOREVER);
WiFiCC3100_deAssertCS();
msgLength += transaction.count;
}
Log_print1(Diags_USER2, "Read transaction complete: %d bytes read.",
transaction.count);
return (msgLength);
}
Int SystemCfg_handshakeEvent(SystemCfg_Object *obj, UInt32 event)
{
Int status;
/* send event to remote core */
status = SystemCfg_sendEvent(obj, event);
if (status < 0) {
Log_error1(FXNN": Notify_sendEvent() error %d", (IArg)status);
goto leave;
}
/* wait for same event */
SystemCfg_waitForEvent(obj, event);
leave:
return(status);
}
/*
* ======== SystemCfg_openResources ========
*/
Int SystemCfg_openResources(SystemCfg_Object *obj)
{
Int status;
/* open rcm heap created on host processor */
status = HeapBufMP_open(SystemCfg_RcmMsgHeapName_CompDev, &(obj->rcmHeapH));
if (status < 0) {
Log_error1("HeapBufMP_open() error %d", (IArg)status);
goto leave;
}
/* register this heap with MessageQ */
MessageQ_registerHeap((Ptr)(obj->rcmHeapH), SystemCfg_RcmMsgHeapId_CompDev);
leave:
return(status);
}
/*
* ======== spi_Open ========
* SimpleLink Host Driver API to open a SPI communication interface.
*/
Fd_t spi_Open(char *ifName, unsigned long flags)
{
WiFiCC3100_Object *object = wifiHandle->object;
SPI_Params spiParams;
SPI_Params_init(&spiParams);
spiParams.bitRate = object->bitRate;
spiParams.transferMode = SPI_MODE_CALLBACK;
spiParams.transferCallbackFxn = WiFiCC3100_spiCallbackFxn;
object->spiHandle = SPI_open(object->spiIndex, &spiParams);
if (object->spiHandle == NULL) {
Log_error1("WiFi SPI (%p) could not be initialized\n", object->spiIndex);
return (-1);
}
object->spiState = WiFiCC3100_SPI_IDLE;
Log_print1(Diags_USER1, "WiFi SPI (%p) open\n", (Fd_t) object->spiHandle);
return ((Fd_t) object->spiHandle);
}
// only in parent
static void inFromChild(evutil_socket_t socket, short eventType, void* vcontext)
{
struct Admin* admin = (struct Admin*) vcontext;
uint8_t buffer[MAX_API_REQUEST_SIZE];
ssize_t amount = read(admin->inFd, buffer, MAX_API_REQUEST_SIZE);
if (amount < 1) {
if (amount == 0 || errno != EAGAIN) {
if (amount < 0) {
Log_error1(admin->logger, "Broken pipe to admin process, errno=%d", errno);
} else {
Log_error(admin->logger, "Connection to admin process closed unexpectedly");
}
event_free(admin->pipeEv);
}
return;
}
if (!admin->initialized) {
if (amount != sizeof(struct sockaddr_storage) + sizeof(int) + 8) {
Log_error(admin->logger, "unexpected length");
} else if (memcmp(buffer, "abcd", 4)) {
Log_error(admin->logger, "bad magic");
} else if (memcmp(&buffer[sizeof(struct sockaddr_storage) + sizeof(int) + 4], "wxyz", 4)) {
Log_error(admin->logger, "bad magic");
} else {
Bits_memcpyConst(&admin->addressLength, &buffer[4], sizeof(int));
Bits_memcpyConst(&admin->address,
&buffer[4 + sizeof(int)],
sizeof(struct sockaddr_storage));
admin->initialized = true;
}
event_base_loopbreak(admin->eventBase);
return;
}
struct Allocator* tempAllocator = admin->allocator->child(admin->allocator);
handleRequestFromChild(admin, buffer, amount, tempAllocator);
tempAllocator->free(tempAllocator);
}
/*
* DataService_GetParameter - Get a DataService parameter.
*
* param - Profile parameter ID
* len - pointer to a variable that contains the maximum length that can be written to *value.
After the call, this value will contain the actual returned length.
* value - pointer to data to write. This is dependent on
* the parameter ID and may be cast to the appropriate
* data type (example: data type of uint16_t will be cast to
* uint16_t pointer).
*/
bStatus_t DataService_GetParameter( uint8_t param, uint16_t *len, void *value )
{
bStatus_t ret = SUCCESS;
switch ( param )
{
case DS_STRING_ID:
*len = MIN(*len, ds_StringValLen);
memcpy(value, ds_StringVal, *len);
Log_info2("GetParameter : %s returning %d bytes", (IArg)"String", (IArg)*len);
break;
case DS_STREAM_ID:
*len = MIN(*len, ds_StreamValLen);
memcpy(value, ds_StreamVal, *len);
Log_info2("GetParameter : %s returning %d bytes", (IArg)"Stream", (IArg)*len);
break;
default:
Log_error1("GetParameter: Parameter #%d not valid.", (IArg)param);
ret = INVALIDPARAMETER;
break;
}
return ret;
}
Int RcmClient_free(RcmClient_Object *obj, RcmClient_Message *msg)
{
Int rval;
MessageQ_Msg msgqMsg;
Int status = RcmClient_S_SUCCESS;
Log_print2(Diags_ENTRY,
"--> "FXNN": (obj=0x%x, msg=0x%x)", (IArg)obj, (IArg)msg);
msgqMsg = (MessageQ_Msg)RcmClient_getPacketAddr_P(msg);
rval = MessageQ_free(msgqMsg);
if (rval < 0) {
Log_error1(FXNN": ipc returned error %d", (IArg)rval);
status = RcmClient_E_IPCERROR;
goto leave;
}
leave:
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
/*
* ======== Hello_exec ========
*/
Int Hello_exec(Void)
{
RcmClient_Params rcmP;
RcmClient_Handle rcmH;
RcmClient_Message * msg;
UInt32 size;
Int status;
/* must initialize the module before using it */
RcmClient_init();
/* create an rcm client instance */
RcmClient_Params_init(&rcmP);
rcmP.heapId = Global_RcmClientHeapId;
/* retry in case the slave is still booting */
do {
status = RcmClient_create(Global_RcmServerName, &rcmP, &rcmH);
} while (status == RcmClient_E_SERVERNOTFOUND);
if (status < 0) {
Log_error0("Hello_exec: RcmClient create failed");
goto leave;
}
/* allocate a remote command message */
size = sizeof(RcmClient_Message) + sizeof(UInt32[32]);
status = RcmClient_alloc(rcmH, size, &msg);
if (status < 0) {
msg = NULL;
Log_error1("Hello_exec: RcmClient_alloc() returned error %d",
(IArg)status);
goto leave;
}
/* fill in the remote command message */
msg->fxnIdx = Global_Hello_idx;
msg->data[0] = (UInt32)0xFFFFFFFF;
System_sprintf((Char *)(&msg->data[1]), "@@@@");
/* execute the remote command message */
status = RcmClient_exec(rcmH, msg, &msg);
if (status < 0) {
Log_error1("Hello_exec: RcmClient_exec() returned error %d",
(IArg)status);
goto leave;
}
/* unmarshal return value */
System_printf("%s\n", (Char *)(&msg->data[1]));
leave:
/* return message to the heap */
if (msg != NULL) {
RcmClient_free(rcmH, msg);
msg = NULL;
}
/* delete the rcm client instance */
if (rcmH != NULL) {
RcmClient_delete(&rcmH);
}
/* finalize the module to support clean shutdown */
RcmClient_exit();
return(status);
}
Int SystemCfg_create(const SystemCfg_Params *params, SystemCfg_Handle *handleP)
{
Int status, bufSize;
Error_Block eb;
SystemCfg_Object * obj;
Semaphore_Params semParams;
Log_print0(Diags_ENTRY, "--> "FXNN": ()");
/* initialize local vars */
status = 0;
Error_init(&eb);
*handleP = (SystemCfg_Handle)NULL;
/* allocate the object */
obj = (SystemCfg_Handle)xdc_runtime_Memory_calloc(NULL,
sizeof(SystemCfg_Object), sizeof(Int), &eb);
if (obj == NULL) {
Log_error1(FXNN": out of memory: size=%u", sizeof(SystemCfg_Object));
status = SystemCfg_E_NOMEMORY;
goto leave;
}
/* object-specific initialization */
obj->remoteProcName = NULL;
obj->remoteProcId = MultiProc_INVALIDID;
obj->semH = NULL;
obj->rcmHeapH = NULL;
/* initialize structures to zero */
memset((Void *)&obj->semObj, 0, sizeof(Semaphore_Struct));
/* store the remote processor name */
bufSize = strlen(params->remoteProcName) + 1;
obj->remoteProcName = (String)xdc_runtime_Memory_calloc(NULL,
bufSize, sizeof(String), &eb);
if (obj == NULL) {
Log_error1(FXNN": out of memory: size=%u", bufSize);
status = SystemCfg_E_NOMEMORY;
goto leave;
}
strcpy(obj->remoteProcName, params->remoteProcName);
/* lookup the remote processor id */
obj->remoteProcId = MultiProc_getId(obj->remoteProcName);
/* create sync object used for synchronizing with remote core */
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_COUNTING;
Semaphore_construct(&obj->semObj, 0, &semParams);
obj->semH = Semaphore_handle(&obj->semObj);
/* add object to module list for register hook */
List_putHead(Mod_objList, &obj->link);
/* success, return opaque pointer */
*handleP = (SystemCfg_Handle)obj;
leave:
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
Int RcmClient_Instance_init(RcmClient_Object *obj, String server,
const RcmClient_Params *params)
{
Error_Block eb;
MessageQ_Params mqParams;
SyncSemThread_Params syncParams;
SemThread_Params semParams;
SemThread_Handle semHndl;
List_Params listP;
Int rval;
Int status = RcmClient_S_SUCCESS;
Log_print2(Diags_ENTRY, "--> %s: (obj=0x%x)", (IArg)FXNN, (IArg)obj);
/* must initialize error block */
Error_init(&eb);
/* initialize instance data */
obj->msgId = 0xFFFF;
obj->sync = NULL;
obj->serverMsgQ = MessageQ_INVALIDMESSAGEQ;
obj->msgQue = NULL;
obj->errorMsgQue = NULL;
obj->mbxLock = NULL;
obj->queueLock = NULL;
obj->recipients = NULL;
obj->newMail = NULL;
/* create the instance gate */
GateThread_construct(&obj->gate, NULL, &eb);
if (Error_check(&eb)) {
Log_error0(FXNN": could not create gate object");
status = RcmClient_E_FAIL;
goto leave;
}
/* create a synchronizer for the message queue */
SyncSemThread_Params_init(&syncParams);
obj->sync = SyncSemThread_create(&syncParams, &eb);
if (Error_check(&eb)) {
status = RcmClient_E_FAIL;
goto leave;
}
/* create the message queue for return messages */
MessageQ_Params_init(&mqParams);
obj->msgQue = MessageQ_create(NULL, &mqParams);
if (obj->msgQue == NULL) {
Log_error0(FXNN": could not create return message queue");
status = RcmClient_E_MSGQCREATEFAILED;
goto leave;
}
/* create the message queue for error messages */
MessageQ_Params_init(&mqParams);
obj->errorMsgQue = MessageQ_create(NULL, &mqParams);
if (NULL == obj->errorMsgQue) {
Log_error0(FXNN": could not create error message queue");
status = RcmClient_E_MSGQCREATEFAILED;
goto leave;
}
/* locate server message queue */
rval = MessageQ_open(server, (MessageQ_QueueId *)(&obj->serverMsgQ));
if (MessageQ_E_NOTFOUND == rval) {
Log_error1(FXNN": given server not found, server=0x%x", (IArg)server);
status = RcmClient_E_SERVERNOTFOUND;
goto leave;
}
else if (status < 0) {
Log_error1(FXNN": could not open server message queue, server=0x%x",
(IArg)server);
status = RcmClient_E_MSGQOPENFAILED;
goto leave;
}
/* create callback server */
if ((obj->cbNotify = params->callbackNotification)) {
/* TODO create callback server thread */
/* make sure to free resources acquired by thread */
Error_raise(&eb, Error_E_generic, "Not Implemented", 0);
goto leave;
}
/* register the heapId used for message allocation */
if ((obj->heapId = params->heapId) == RcmClient_INVALIDHEAPID) {
Log_error0(FXNN": must specify a heap id in create params");
status = RcmClient_E_INVALIDHEAPID;
goto leave;
}
/* create the mailbox lock */
SemThread_Params_init(&semParams);
semHndl = SemThread_create(1, &semParams, &eb);
if (Error_check(&eb)) {
status = RcmClient_E_FAIL;
goto leave;
}
obj->mbxLock = SemThread_Handle_upCast(semHndl);
/* create the message queue lock */
SemThread_Params_init(&semParams);
semHndl = SemThread_create(1, &semParams, &eb);
if (Error_check(&eb)) {
status = RcmClient_E_FAIL;
goto leave;
}
obj->queueLock = SemThread_Handle_upCast(semHndl);
/* create the return message recipient list */
#if defined(RCM_ti_ipc)
List_Params_init(&listP);
obj->recipients = List_create(&listP, &eb);
if (Error_check(&eb)) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#elif defined(RCM_ti_syslink)
List_Params_init(&listP);
obj->recipients = List_create(&listP, NULL);
if (NULL == obj->recipients) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#endif
/* create list of undelivered messages (new mail) */
#if defined(RCM_ti_ipc)
List_Params_init(&listP);
obj->newMail = List_create(&listP, &eb);
if (Error_check(&eb)) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#elif defined(RCM_ti_syslink)
List_Params_init(&listP);
obj->newMail = List_create(&listP, NULL);
if (NULL == obj->newMail) {
Log_error0(FXNN": could not create list object");
status = RcmClient_E_LISTCREATEFAILED;
goto leave;
}
#endif
leave:
Log_print2(Diags_EXIT, "<-- %s: %d", (IArg)FXNN, (IArg)status);
return(status);
}
/*
* ======== Server_finish ========
*
* 1. close remote resources
* 2. handshake close event
* 3. delete shared resoures
* 4. send disconnect event (last event sent)
* 5. wait for disconnect event
* 6. unregister notify callback
* 9. delete semaphore object
*/
Int Server_finish(Void)
{
Int status;
UInt32 event;
/*
* 1. close remote resources
*/
/* delete the RcmServer instance */
status = RcmServer_delete(&Module.rcmServerH);
if (status < 0) {
Log_error1("Server_finish: RcmServer_delete() returned error %d",
(IArg)status);
goto leave;
}
/* unregister rcm heap with MessageQ */
status = MessageQ_unregisterHeap(Global_RcmClientHeapId);
if (status < 0) {
goto leave;
}
/* close the rcm heap */
status = HeapBufMP_close(&Module.heapH);
if (status < 0) {
Log_error1("Server_finish: HeapBufMP_close() returned error %d",
(IArg)status);
goto leave;
}
/*
* 2. handshake close event
*/
status = Notify_sendEvent(Module.hostProcId, Module.lineId,
Module.eventId, App_CMD_CLOSED, TRUE);
if (status < 0) {
goto leave;
}
do {
event = Server_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
goto leave;
}
} while (event != App_CMD_CLOSED);
/*
* 3. delete shared resoures
*/
/*
* 4. send disconnect event (last event sent)
*/
status = Notify_sendEvent(Module.hostProcId, Module.lineId,
Module.eventId, App_CMD_DONE, TRUE);
if (status < 0) {
goto leave;
}
/*
* 5. wait for disconnect event (last event received)
*/
do {
event = Server_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
goto leave;
}
} while (event != App_CMD_DONE);
/*
* 6. unregister notify callback
*/
status = Notify_unregisterEventSingle(Module.hostProcId, Module.lineId,
Module.eventId);
if (status < 0) {
goto leave;
}
/*
* 9. delete semaphore object
*/
Semaphore_destruct(&Module.semS);
Module.semH = NULL;
leave:
return(status);
}
/*
* ======== USBMSCHFatFsTiva_open ========
*/
USBMSCHFatFs_Handle USBMSCHFatFsTiva_open(USBMSCHFatFs_Handle handle,
unsigned char drv,
USBMSCHFatFs_Params *params)
{
unsigned int key;
DRESULT dresult;
FRESULT fresult;
USBMSCHFatFsTiva_Object *object = handle->object;
USBMSCHFatFsTiva_HWAttrs const *hwAttrs = handle->hwAttrs;
union {
Task_Params taskParams;
Semaphore_Params semParams;
GateMutex_Params gateParams;
Hwi_Params hwiParams;
} paramsUnion;
/* Determine if the device was already opened */
key = Hwi_disable();
if (object->driveNumber != DRIVE_NOT_MOUNTED) {
Hwi_restore(key);
return (NULL);
}
/* Mark as being used */
object->driveNumber = drv;
Hwi_restore(key);
/* Store the USBMSCHFatFs parameters */
if (params == NULL) {
/* No params passed in, so use the defaults */
params = (USBMSCHFatFs_Params *) &USBMSCHFatFs_defaultParams;
}
/* Initialize the USB stack for host mode. */
USBStackModeSet(0, eUSBModeHost, NULL);
/* Register host class drivers */
USBHCDRegisterDrivers(0, usbHCDDriverList, numHostClassDrivers);
/* Open an instance of the MSC host driver */
object->MSCInstance = USBHMSCDriveOpen(0, USBMSCHFatFsTiva_cbMSCHandler);
if (!(object->MSCInstance)) {
Log_print0(Diags_USER1,"USBMSCHFatFs: Error initializing the MSC Host");
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
/* Create the Hwi object to service interrupts */
Hwi_Params_init(&(paramsUnion.hwiParams));
paramsUnion.hwiParams.priority = hwAttrs->intPriority;
Hwi_construct(&(object->hwi), hwAttrs->intNum, USBMSCHFatFsTiva_hwiHandler,
&(paramsUnion.hwiParams), NULL);
/* Initialize USB power configuration */
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
/* Enable the USB stack */
USBHCDInit(0, object->memPoolHCD, HCDMEMORYPOOLSIZE);
/* RTOS primitives */
Semaphore_Params_init(&(paramsUnion.semParams));
paramsUnion.semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(object->semUSBConnected), 0, &(paramsUnion.semParams));
GateMutex_Params_init(&(paramsUnion.gateParams));
paramsUnion.gateParams.instance->name = "USB Library Access";
GateMutex_construct(&(object->gateUSBLibAccess), &(paramsUnion.gateParams));
paramsUnion.gateParams.instance->name = "USB Wait";
GateMutex_construct(&(object->gateUSBWait), &(paramsUnion.gateParams));
/*
* Note that serviceUSBHost() should not be run until the USB Stack has been
* initialized!!
*/
Task_Params_init(&(paramsUnion.taskParams));
/*
* If serviceTaskStackPtr is null, then Task_construct performs a
* Memory_alloc - requiring a Heap
*/
paramsUnion.taskParams.stack = params->serviceTaskStackPtr;
/*
* If service priority passed in is higher than what is configured by the
* Task module, then use the highest priority available.
*/
if (Task_numPriorities - 1 < params->servicePriority) {
paramsUnion.taskParams.priority = (Task_numPriorities - 1);
}
else {
paramsUnion.taskParams.priority = params->servicePriority;
}
/* If no stack size is passed in, then use the default task stack size */
if (params->serviceTaskStackSize) {
paramsUnion.taskParams.stackSize = params->serviceTaskStackSize;
}
else {
paramsUnion.taskParams.stackSize = Task_defaultStackSize;
}
Task_construct(&(object->taskHCDMain),USBMSCHFatFsTiva_serviceUSBHost,
&(paramsUnion.taskParams), NULL);
/* Register the new disk_*() functions */
dresult = disk_register(drv,
USBMSCHFatFsTiva_diskInitialize,
USBMSCHFatFsTiva_diskStatus,
USBMSCHFatFsTiva_diskRead,
USBMSCHFatFsTiva_diskWrite,
USBMSCHFatFsTiva_diskIOctl);
/* Check for drive errors */
if (dresult != RES_OK) {
Log_error0("USBMSCHFatFs: disk functions not registered");
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
/* Mount the FatFs (this function does not access the SDCard yet...) */
fresult = f_mount(drv, &(object->filesystem));
if (fresult != FR_OK) {
Log_error1("USBMSCHFatFs: drive %d not mounted", drv);
USBMSCHFatFsTiva_close(handle);
return (NULL);
}
Log_print1(Diags_USER1, "USBMSCHFatFs: drive %d opened", drv);
return (handle);
}
Int RcmClient_getSymbolIndex(RcmClient_Object *obj, String name, UInt32 *index)
{
SizeT len;
RcmClient_Packet *packet;
UInt16 msgId;
MessageQ_Msg msgqMsg;
Int rval;
UInt16 serverStatus;
RcmClient_Message *rcmMsg = NULL;
Int status = RcmClient_S_SUCCESS;
Log_print3(Diags_ENTRY,
"--> "FXNN": (obj=0x%x, name=0x%x, index=0x%x",
(IArg)obj, (IArg)name, (IArg)index);
/* allocate a message */
len = _strlen(name) + 1;
rval = RcmClient_alloc(obj, len, &rcmMsg);
if (rval < 0) {
status = rval;
goto leave;
}
/* copy the function name into the message payload */
rcmMsg->dataSize = len; //TODO this is not proper!
_strcpy((Char *)rcmMsg->data, name);
/* classify this message */
packet = RcmClient_getPacketAddr_P(rcmMsg);
packet->desc |= RcmClient_Desc_SYM_IDX << RcmClient_Desc_TYPE_SHIFT;
msgId = packet->msgId;
/* set the return address to this instance's message queue */
msgqMsg = (MessageQ_Msg)packet;
MessageQ_setReplyQueue(obj->msgQue, msgqMsg);
/* send the message to the server */
rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);
if (rval < 0) {
Log_error0(FXNN": unable to the send message to the server");
status = RcmClient_E_EXECFAILED;
goto leave;
}
/* get the return message from the server */
rval = RcmClient_getReturnMsg_P(obj, msgId, &rcmMsg);
if (rval < 0) {
status = rval;
goto leave;
}
/* check message status for error */
packet = RcmClient_getPacketAddr_P(rcmMsg);
serverStatus = (RcmClient_Desc_TYPE_MASK & packet->desc) >>
RcmClient_Desc_TYPE_SHIFT;
switch (serverStatus) {
case RcmServer_Status_SUCCESS:
break;
case RcmServer_Status_SYMBOL_NOT_FOUND:
Log_error1(FXNN": symbol not found, name=0x%x", (IArg)name);
status = RcmClient_E_SYMBOLNOTFOUND;
goto leave;
default:
Log_error1(FXNN": server returned error %d", (IArg)serverStatus);
status = RcmClient_E_SERVERERROR;
goto leave;
}
/* extract return value */
*index = rcmMsg->data[0];
leave:
if (rcmMsg != NULL) {
RcmClient_free(obj, rcmMsg);
}
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
/*
* ======== Server_exec ========
*/
Int Server_exec()
{
Int status;
GateMPApp_Msg * msg;
MessageQ_QueueId queId;
UInt32 physAddr;
volatile UInt32 * intPtr = 0;
Int num = 0;
Int prevNum = 0;
UInt i = 0;
IArg gateKey = 0;
Log_print0(Diags_ENTRY | Diags_INFO, "--> Server_exec:");
/* wait for inbound message */
status = MessageQ_get(Module.slaveQue, (MessageQ_Msg *)&msg,
MessageQ_FOREVER);
if (status < 0) {
goto leave;
}
if (msg->cmd != GATEMPAPP_CMD_SPTR_ADDR) {
status = GATEMPAPP_E_UNEXPECTEDMSG;
goto leave;
}
/* Get physical address of shared memory */
physAddr = msg->payload;
/* translate the physical address to slave virtual addr */
if (Resource_physToVirt(physAddr, (UInt32 *)&intPtr)) {
Log_error1("Server_exec: Failed to translate phys addr %p to virt addr", physAddr);
goto leave;
}
/* send message back */
queId = MessageQ_getReplyQueue(msg); /* type-cast not needed */
msg->cmd = GATEMPAPP_CMD_SPTR_ADDR_ACK;
MessageQ_put(queId, (MessageQ_Msg)msg);
Log_print0(Diags_INFO,"Server_exec: Modifying shared variable "
"value");
/* open host-created GateMP */
do {
status = GateMP_open(GATEMP_HOST_NAME, &Module.hostGateMPHandle);
} while (status == GateMP_E_NOTFOUND);
if (status < 0) {
Log_error0("Server_exec: Failed to open host-created GateMP");
status = GATEMPAPP_E_FAILURE;
goto leave;
}
Log_print0(Diags_INFO,"Server_exec: Opened GateMP successfully");
Log_print0(Diags_INFO,"Server_exec: Using host-created gate");
for (i = 0;i < LOOP_ITR; i++) {
/* modify the shared variable as long as no one else is currently
* accessing it
*/
/* enter GateMP */
gateKey = GateMP_enter(Module.hostGateMPHandle);
/* read shared variable value */
prevNum = *intPtr;
/* randomly modify the shared variable */
if ( rand() % 2) {
*intPtr -= 1;
}
else {
*intPtr += 1;
}
/* read shared variable value again */
num = *intPtr;
if ((prevNum != num + 1) && (prevNum != num - 1)) {
Log_print0(Diags_INFO, "Server_exec: unexpected variable value." \
"Test failed.");
Log_print2(Diags_INFO, "Server_exec: Previous shared variable "
"value %d, current value=%d", prevNum, num);
status = GATEMPAPP_E_FAILURE;
goto leave;
}
/* leave Gate */
GateMP_leave(Module.hostGateMPHandle, gateKey);
}
/* wait for sync message before we switch gates */
status = MessageQ_get(Module.slaveQue, (MessageQ_Msg *)&msg,
MessageQ_FOREVER);
if (status < 0) {
goto leave;
}
if (msg->cmd != GATEMPAPP_CMD_SYNC) {
status = GATEMPAPP_E_UNEXPECTEDMSG;
goto leave;
}
queId = MessageQ_getReplyQueue(msg);
MessageQ_put(queId, (MessageQ_Msg)msg);
Log_print0(Diags_INFO,"Server_exec: Using slave-created gate");
for (i = 0;i < LOOP_ITR; i++) {
/* modify the shared variable as long as no one else is currently
* accessing it
*/
/* enter GateMP */
gateKey = GateMP_enter(Module.slaveGateMPHandle);
/* read shared variable value */
prevNum = *intPtr;
/* randomly modify the shared variable */
if ( rand() % 2) {
*intPtr -= 1;
}
else {
*intPtr += 1;
}
/* read shared variable value again */
num = *intPtr;
if ((prevNum != num - 1) && (prevNum != num + 1)) {
Log_print0(Diags_INFO, "Server_exec: unexpected variable value." \
"Test failed.");
Log_print2(Diags_INFO, "Server_exec: Previous "
"value=%d, current value=%d", prevNum, num);
status = GATEMPAPP_E_FAILURE;
goto leave;
}
/* leave Gate */
GateMP_leave(Module.slaveGateMPHandle, gateKey);
}
leave:
/* close host GateMP */
if (Module.hostGateMPHandle) {
GateMP_close(&Module.hostGateMPHandle);
}
Log_print0(Diags_ENTRY, "Server_exec: host GateMP closed");
Log_print1(Diags_EXIT, "<-- Server_exec: %d", (IArg)status);
return(status);
}
/*
* ======== Server_setup ========
*
* 1. create semaphore object
* 2. register notify callback
* 3. wait until remote core has also registered notify callback
* 4. create local & shared resources
* 5. send resource ready event
* 6. wait for remote resource ready event
* 7. open remote resources
* 8. handshake the ready event
*/
Int Server_setup(Void)
{
Int status;
UInt32 event;
Semaphore_Params semParams;
RcmServer_Params rcmServerP;
Log_print0(Diags_ENTRY | Diags_INFO, "--> Server_setup:");
/*
* 1. create semaphore object
*/
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_COUNTING;
Semaphore_construct(&Module.semS, 0, &semParams);
Module.semH = Semaphore_handle(&Module.semS);
/*
* 2. register notify callback
*/
status = Notify_registerEventSingle(Module.hostProcId, Module.lineId,
Module.eventId, Server_notifyCB, (UArg)&Module);
if (status < 0) {
goto leave;
}
/*
* 3. wait until remote core has also registered notify callback
*/
do {
status = Notify_sendEvent(Module.hostProcId, Module.lineId,
Module.eventId, App_CMD_NOP, TRUE);
if (status == Notify_E_EVTNOTREGISTERED) {
Task_sleep(200); /* ticks */
}
} while (status == Notify_E_EVTNOTREGISTERED);
if (status < 0) {
goto leave;
}
/*
* 4. create local & shared resources (to be opened by remote processor)
*/
/*
* 5. send resource ready event
*/
status = Notify_sendEvent(Module.hostProcId, Module.lineId, Module.eventId,
App_CMD_RESRDY, TRUE);
if (status < 0) {
goto leave;
}
/*
* 6. wait for remote resource ready event
*/
do {
event = Server_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
goto leave;
}
} while (event != App_CMD_RESRDY);
/*
* 7. open remote resources
*/
/* open the rcm heap */
status = HeapBufMP_open(Global_RcmClientHeapName, &Module.heapH);
if (status < 0) {
Log_error1("Server_setup: HeapBufMP_open() returned error %d",
(IArg)status);
goto leave;
}
/* register the rcm heap with MessageQ */
status = MessageQ_registerHeap((Ptr)(Module.heapH), Global_RcmClientHeapId);
if (status < 0) {
Log_error1("Server_setup: MessageQ_restierHeap() returned error %d",
(IArg)status);
goto leave;
}
/* initialize RcmServer create params */
RcmServer_Params_init(&rcmServerP);
rcmServerP.fxns.length = Server_fxnTab.length;
rcmServerP.fxns.elem = Server_fxnTab.elem;
/* create the RcmServer instance */
status = RcmServer_create(Global_RcmServerName, &rcmServerP,
&Module.rcmServerH);
if (status < 0) {
Log_error1("Server_setup: RcmServer_create() returned error %d",
(IArg)status);
goto leave;
}
/* start the server */
RcmServer_start(Module.rcmServerH);
/*
* 8. handshake the ready event
*/
status = Notify_sendEvent(Module.hostProcId, Module.lineId, Module.eventId,
App_CMD_READY, TRUE);
if (status < 0) {
goto leave;
}
do {
event = Server_waitForEvent();
if (event >= App_E_FAILURE) {
status = -1;
goto leave;
}
} while (event != App_CMD_READY);
leave:
Log_print1(Diags_EXIT, "<-- Server_setup: %d", (IArg)status);
return(status);
}
Int RcmClient_exec(RcmClient_Object *obj,
RcmClient_Message *cmdMsg, RcmClient_Message **returnMsg)
{
RcmClient_Packet *packet;
RcmClient_Message *rtnMsg;
MessageQ_Msg msgqMsg;
UInt16 msgId;
UInt16 serverStatus;
Int rval;
Int status = RcmClient_S_SUCCESS;
Log_print2(Diags_ENTRY,
"--> "FXNN": (cmdMsg=0x%x, rtnMsg=0x%x)", (IArg)obj, (IArg)returnMsg);
/* classify this message */
packet = RcmClient_getPacketAddr_P(cmdMsg);
packet->desc |= RcmClient_Desc_RCM_MSG << RcmClient_Desc_TYPE_SHIFT;
msgId = packet->msgId;
/* set the return address to this instance's message queue */
msgqMsg = (MessageQ_Msg)packet;
MessageQ_setReplyQueue(obj->msgQue, msgqMsg);
/* send the message to the server */
status = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);
if (status < 0) {
Log_error0(FXNN": unable to the send message to the server");
status = RcmClient_E_EXECFAILED;
goto leave;
}
/* get the return message from the server */
rval = RcmClient_getReturnMsg_P(obj, msgId, &rtnMsg);
if (rval < 0) {
*returnMsg = NULL;
status = rval;
goto leave;
}
*returnMsg = rtnMsg;
/* check the server's status stored in the packet header */
packet = RcmClient_getPacketAddr_P(rtnMsg);
serverStatus = (RcmClient_Desc_TYPE_MASK & packet->desc) >>
RcmClient_Desc_TYPE_SHIFT;
switch (serverStatus) {
case RcmServer_Status_SUCCESS:
break;
case RcmServer_Status_INVALID_FXN:
Log_error1(FXNN": invalid function index: 0x%x",
(IArg)rtnMsg->fxnIdx);
status = RcmClient_E_INVALIDFXNIDX;
goto leave;
case RcmServer_Status_MSG_FXN_ERR:
Log_error1(FXNN": message function error %d", (IArg)rtnMsg->result);
status = RcmClient_E_MSGFXNERROR;
goto leave;
default:
Log_error1(FXNN": server returned error %d", (IArg)serverStatus);
status = RcmClient_E_SERVERERROR;
goto leave;
}
leave:
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
Int RcmClient_checkForError(RcmClient_Object *obj, RcmClient_Message **rtnMsg)
{
RcmClient_Message *rcmMsg;
RcmClient_Packet *packet;
MessageQ_Msg msgqMsg;
UInt16 serverStatus;
Int rval;
Int status = RcmClient_S_SUCCESS;
Log_print1(Diags_ENTRY,
"--> "FXNN": (obj=0x%x, rtnMsg=0x%x)", (IArg)rtnMsg);
*rtnMsg = NULL;
/* get error message if available (non-blocking) */
rval = MessageQ_get(obj->errorMsgQue, &msgqMsg, 0);
if ((MessageQ_E_TIMEOUT != rval) && (rval < 0)) {
Log_error1(FXNN": MessageQ_get() returned error %d", (IArg)rval);
status = RcmClient_E_IPCERROR;
goto leave;
}
else if (msgqMsg == NULL) {
goto leave;
}
/* received an error message */
packet = getPacketAddrMsgqMsg(msgqMsg);
rcmMsg = &packet->message;
*rtnMsg = rcmMsg;
/* check the server status stored in the packet header */
serverStatus = (RcmClient_Desc_TYPE_MASK & packet->desc) >>
RcmClient_Desc_TYPE_SHIFT;
switch (serverStatus) {
case RcmServer_Status_JobNotFound:
Log_error1(FXNN": job id=%d not found", (IArg)rcmMsg->jobId);
break;
case RcmServer_Status_PoolNotFound:
Log_error1(FXNN": pool id=0x%x not found", (IArg)rcmMsg->poolId);
break;
case RcmServer_Status_INVALID_FXN:
Log_error1(FXNN": invalid function index: 0x%x",
(IArg)rcmMsg->fxnIdx);
status = RcmClient_E_INVALIDFXNIDX;
break;
case RcmServer_Status_MSG_FXN_ERR:
Log_error1(FXNN": message function error %d", (IArg)rcmMsg->result);
status = RcmClient_E_MSGFXNERROR;
break;
default:
Log_error1(FXNN": server returned error %d", (IArg)serverStatus);
status = RcmClient_E_SERVERERROR;
goto leave;
}
leave:
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
/*
* DataService_SetParameter - Set a DataService parameter.
*
* param - Profile parameter ID
* len - length of data to write
* value - pointer to data to write. This is dependent on
* the parameter ID and may be cast to the appropriate
* data type (example: data type of uint16_t will be cast to
* uint16_t pointer).
*/
bStatus_t DataService_SetParameter( uint8_t param, uint16_t len, void *value )
{
bStatus_t ret = SUCCESS;
uint8_t *pAttrVal;
uint16_t *pValLen;
uint16_t valMinLen;
uint16_t valMaxLen;
uint8_t sendNotiInd = FALSE;
gattCharCfg_t *attrConfig;
uint8_t needAuth;
switch ( param )
{
case DS_STRING_ID:
pAttrVal = ds_StringVal;
pValLen = &ds_StringValLen;
valMinLen = DS_STRING_LEN_MIN;
valMaxLen = DS_STRING_LEN;
Log_info2("SetParameter : %s len: %d", (IArg)"String", (IArg)len);
break;
case DS_STREAM_ID:
pAttrVal = ds_StreamVal;
pValLen = &ds_StreamValLen;
valMinLen = DS_STREAM_LEN_MIN;
valMaxLen = DS_STREAM_LEN;
sendNotiInd = TRUE;
attrConfig = ds_StreamConfig;
needAuth = FALSE; // Change if authenticated link is required for sending.
Log_info2("SetParameter : %s len: %d", (IArg)"Stream", (IArg)len);
break;
default:
Log_error1("SetParameter: Parameter #%d not valid.", (IArg)param);
return INVALIDPARAMETER;
}
// Check bounds, update value and send notification or indication if possible.
if ( len <= valMaxLen && len >= valMinLen )
{
memcpy(pAttrVal, value, len);
*pValLen = len; // Update length for read and get.
if (sendNotiInd)
{
Log_info2("Trying to send noti/ind: connHandle %x, %s",
(IArg)attrConfig[0].connHandle,
(IArg)((attrConfig[0].value==0)?"\x1b[33mNoti/ind disabled\x1b[0m" :
(attrConfig[0].value==1)?"Notification enabled" :
"Indication enabled"));
// Try to send notification.
GATTServApp_ProcessCharCfg( attrConfig, pAttrVal, needAuth,
Data_ServiceAttrTbl, GATT_NUM_ATTRS( Data_ServiceAttrTbl ),
ds_icall_rsp_task_id, Data_Service_ReadAttrCB);
}
}
else
{
Log_error3("Length outside bounds: Len: %d MinLen: %d MaxLen: %d.", (IArg)len, (IArg)valMinLen, (IArg)valMaxLen);
ret = bleInvalidRange;
}
return ret;
}
/*!
* @brief Function for transferring using the SPI interface.
*
* The function will enable the SPI and UDMA modules and disallow
* the device from going into standby.
*
* In ::SPI_MODE_BLOCKING, SPI_transfer will block task execution until the transfer
* has ended.
*
* In ::SPI_MODE_CALLBACK, SPI_transfer does not block task execution, but calls a
* callback function specified by transferCallback when the transfer has ended.
*
* @pre SPICC26XXDMA_open() has to be called first.
* Calling context: Hwi and Swi (only if using ::SPI_MODE_CALLBACK), Task
*
* @param handle A SPI handle returned from SPICC26XXDMA_open()
*
* @param *transaction Pointer to transaction struct
*
* @return True if transfer is successful and false if not
*
* @sa SPICC26XXDMA_open(), SPICC26XXDMA_transferCancel()
*/
bool SPICC26XXDMA_transfer(SPI_Handle handle, SPI_Transaction *transaction)
{
unsigned int key;
SPICC26XX_Object *object;
SPICC26XX_HWAttrs const *hwAttrs;
/* Get the pointer to the object and hwAttr*/
object = handle->object;
hwAttrs = handle->hwAttrs;
/* This is a limitation by the uDMA controller */
Assert_isTrue(transaction->count <= 1024, NULL);
if (transaction->count == 0) {
return (false);
}
/* Make sure that the buffers are aligned properly */
if (object->frameSize == SPICC26XXDMA_16bit) {
Assert_isTrue(!((unsigned long)transaction->txBuf & 0x1), NULL);
Assert_isTrue(!((unsigned long)transaction->rxBuf & 0x1), NULL);
}
/* Disable preemption while checking if a transfer is in progress */
key = Hwi_disable();
if (object->currentTransaction) {
Hwi_restore(key);
Log_error1("SPI:(%p) transaction still in progress",
((SPICC26XX_HWAttrs const *)(handle->hwAttrs))->baseAddr);
/* Flag that the transfer failed to start */
transaction->status = SPI_TRANSFER_FAILED;
/* Transfer is in progress */
return (false);
}
/* Make sure to flag that a transaction is now active */
transaction->status = SPI_TRANSFER_STARTED;
object->currentTransaction = transaction;
Hwi_restore(key);
/* In slave mode, optionally enable callback on CSN de-assert */
if (object->returnPartial) {
PIN_setInterrupt(object->pinHandle, object->csnPin | PIN_IRQ_POSEDGE);
}
/* Enable the SPI module */
SSIEnable(hwAttrs->baseAddr);
/* Setup DMA transfer. */
SPICC26XXDMA_configDMA(handle, transaction);
/* Enable the RX overrun interrupt in the SSI module */
SSIIntEnable(hwAttrs->baseAddr, SSI_RXOR);
/* Set constraints to guarantee transaction */
threadSafeConstraintSet((uint32_t)(transaction->txBuf));
if (object->transferMode == SPI_MODE_BLOCKING) {
Log_print1(Diags_USER1, "SPI:(%p) transfer pending on transferComplete "
"semaphore",
((SPICC26XX_HWAttrs const *)(handle->hwAttrs))->baseAddr);
if (!Semaphore_pend(Semaphore_handle(&(object->transferComplete)), object->transferTimeout)) {
/* Cancel the transfer, if we experience a timeout */
SPICC26XXDMA_transferCancel(handle);
/*
* SPICC26XXDMA_transferCancel peforms a callback which posts a
* transferComplete semaphore. This call consumes this extra post.
*/
Semaphore_pend(Semaphore_handle(&(object->transferComplete)),
BIOS_NO_WAIT);
return (false);
}
}
return (true);
}
/*
* ======== smain ========
*/
Void smain(UArg arg0, UArg arg1)
{
Int status = 0;
Error_Block eb;
SystemCfg_Params systemCfgP;
SystemCfg_Handle systemCfgH = NULL;
ComputeDevice_Cfg compDevCfg;
Log_print0(Diags_ENTRY | Diags_INFO, LOGSTR(2));
Error_init(&eb);
/* initialize modules */
SystemCfg_init();
ComputeDevice_init();
/* start all statically created threads now */
Thread_start(NULL);
/* turn on some trace */
// Diags_setMask("SystemCfg+F;ComputeDevice+F");
Diags_setMask("ComputeDevice+F");
// Diags_setMask("TsrKnl+F1");
/* create a SystemCfg instance for the remote processor */
SystemCfg_Params_init(&systemCfgP);
systemCfgP.remoteProcName = SystemCfg_Host_ProcName;
status = SystemCfg_create(&systemCfgP, &systemCfgH);
if (status < 0) {
goto leave;
}
/* let the host know this processor has started */
status = SystemCfg_startAck(systemCfgH);
if (status < 0) {
Log_error0(LOGSTR(4));
goto leave;
}
/* attach to the remote processor */
status = SystemCfg_attach(systemCfgH);
if (status < 0) {
Log_error0(LOGSTR(5));
goto leave;
}
/* create local resources */
status = SystemCfg_createResources(systemCfgH);
if (status < 0) {
Log_error0(LOGSTR(6));
goto leave;
}
/* wait for handshake before opening remote resources */
SystemCfg_handshakeEvent(systemCfgH, SystemCfg_EvtCreateDone);
/* open shared resources from remote core */
status = SystemCfg_openResources(systemCfgH);
if (status < 0) {
Log_error0(LOGSTR(7));
goto leave;
}
/* start the compute device, start the OpenCL Runtime */
compDevCfg.rcmServerName = SystemCfg_RcmServer_CompDev;
status = ComputeDevice_start((Ptr)(&compDevCfg));
if (status < 0) {
Log_error0(LOGSTR(8));
goto leave;
}
/* send ready event */
SystemCfg_sendEvent(systemCfgH, SystemCfg_EvtReady);
/*
* BEGIN execute phase
*/
/* wait for the shutdown signal */
SystemCfg_waitForEvent(systemCfgH, SystemCfg_EvtShutdown);
/*
* END execute phase
*/
/* stop the compute device */
status = ComputeDevice_stop((Ptr)(&compDevCfg));
if (status < 0) {
Log_error0(LOGSTR(9));
goto leave;
}
/* close shared resources from remote core */
status = SystemCfg_closeResources(systemCfgH);
if (status < 0) {
Log_error0(LOGSTR(10));
goto leave;
}
/* wait for handshake before deleting local resources */
SystemCfg_handshakeEvent(systemCfgH, SystemCfg_EvtCloseDone);
/* delete local resources */
status = SystemCfg_deleteResources(systemCfgH);
if (status < 0) {
Log_error0(LOGSTR(11));
goto leave;
}
/* wait for handshake before terminating */
SystemCfg_handshakeEvent(systemCfgH, SystemCfg_EvtDone);
#if 0 /* SDOCM85206, SDOCM85207 */
/* detach from the remote processor */
status = SystemCfg_detach(systemCfgH);
if (status < 0) {
Log_error1(LOGSTR(12), (IArg)status);
goto leave;
}
/* prepare to be stopped */
SystemCfg_stop(systemCfgH);
#endif
/* delete SystemCfg instance */
if (systemCfgH != NULL) {
SystemCfg_delete(&systemCfgH);
}
/* finalize modules */
ComputeDevice_exit();
SystemCfg_exit();
leave:
Log_print1(Diags_EXIT, LOGSTR(3), (IArg)status);
return;
}
Int RcmClient_acquireJobId(RcmClient_Object *obj, UInt16 *jobIdPtr)
{
RcmClient_Message *msg;
RcmClient_Packet *packet;
MessageQ_Msg msgqMsg;
UInt16 msgId;
Int rval;
UInt16 serverStatus;
Int status = RcmClient_S_SUCCESS;
Log_print2(Diags_ENTRY,
"--> "FXNN": (obj=0x%x, jobIdPtr=0x%x)", (IArg)obj, (IArg)jobIdPtr);
/* allocate a message */
status = RcmClient_alloc(obj, sizeof(UInt16), &msg);
if (status < 0) {
goto leave;
}
/* classify this message */
packet = RcmClient_getPacketAddr_P(msg);
packet->desc |= RcmClient_Desc_JOB_ACQ << RcmClient_Desc_TYPE_SHIFT;
msgId = packet->msgId;
/* set the return address to this instance's message queue */
msgqMsg = (MessageQ_Msg)packet;
MessageQ_setReplyQueue(obj->msgQue, msgqMsg);
/* send the message to the server */
rval = MessageQ_put((MessageQ_QueueId)obj->serverMsgQ, msgqMsg);
if (rval < 0) {
Log_error0(FXNN": unable to the send message to the server");
status = RcmClient_E_FAIL;
goto leave;
}
/* get the return message from the server */
status = RcmClient_getReturnMsg_P(obj, msgId, &msg);
if (status < 0) {
goto leave;
}
/* check message status for error */
packet = RcmClient_getPacketAddr_P(msg);
serverStatus = (RcmClient_Desc_TYPE_MASK & packet->desc) >>
RcmClient_Desc_TYPE_SHIFT;
switch (serverStatus) {
case RcmServer_Status_SUCCESS:
break;
default:
Log_error1(FXNN": server returned error %d", (IArg)serverStatus);
status = RcmClient_E_SERVERERROR;
goto leave;
}
/* extract return value */
*jobIdPtr = (UInt16)(msg->data[0]);
leave:
if (msg != NULL) {
RcmClient_free(obj, msg);
}
Log_print1(Diags_EXIT, "<-- "FXNN": %d", (IArg)status);
return(status);
}
