ucs2-interface/ucs_lib_interf.c

   1 /*------------------------------------------------------------------------------------------------*/
   2 /* Unicens Integration Helper Component                                                           */
   3 /* Copyright 2017, Microchip Technology Inc. and its subsidiaries.                                */
   4 /*                                                                                                */
   5 /* Redistribution and use in source and binary forms, with or without                             */
   6 /* modification, are permitted provided that the following conditions are met:                    */
   7 /*                                                                                                */
   8 /* 1. Redistributions of source code must retain the above copyright notice, this                 */
   9 /*    list of conditions and the following disclaimer.                                            */
  10 /*                                                                                                */
  11 /* 2. Redistributions in binary form must reproduce the above copyright notice,                   */
  12 /*    this list of conditions and the following disclaimer in the documentation                   */
  13 /*    and/or other materials provided with the distribution.                                      */
  14 /*                                                                                                */
  15 /* 3. Neither the name of the copyright holder nor the names of its                               */
  16 /*    contributors may be used to endorse or promote products derived from                        */
  17 /*    this software without specific prior written permission.                                    */
  18 /*                                                                                                */
  19 /* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"                    */
  20 /* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE                      */
  21 /* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE                 */
  22 /* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE                   */
  23 /* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL                     */
  24 /* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR                     */
  25 /* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER                     */
  26 /* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,                  */
  27 /* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE                  */
  28 /* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                           */
  29 /*------------------------------------------------------------------------------------------------*/
  30 #include <assert.h>
  31 #include <stdio.h>
  32 #include "ucs_interface.h"
  33
  34 /************************************************************************/
  35 /* Private Definitions and variables                                    */
  36 /************************************************************************/
  37 #define MAGIC (0xA144BEAF)
  38
  39 /************************************************************************/
  40 /* Private Function Prototypes                                          */
  41 /************************************************************************/
  42 static bool EnqueueCommand(UCSI_Data_t *my, UnicensCmdEntry_t *cmd);
  43 static void OnCommandExecuted(UCSI_Data_t *my, UnicensCmd_t cmd);
  44 static void RB_Init(RB_t *rb, uint16_t amountOfEntries, uint32_t sizeOfEntry, uint8_t *workingBuffer);
  45 static void *RB_GetReadPtr(RB_t *rb);
  46 static void RB_PopReadPtr(RB_t *rb);
  47 static void *RB_GetWritePtr(RB_t *rb);
  48 static void RB_PopWritePtr(RB_t *rb);
  49 static uint16_t OnUnicensGetTime(void *user_ptr);
  50 static void OnUnicensService( void *user_ptr );
  51 static void OnUnicensError( Ucs_Error_t error_code, void *user_ptr );
  52 static void OnUnicensAppTimer( uint16_t timeout, void *user_ptr );
  53 static void OnUnicensDebugErrorMsg(Msg_MostTel_t *m, void *user_ptr);
  54 static void OnLldCtrlStart( Ucs_Lld_Api_t* api_ptr, void *inst_ptr, void *lld_user_ptr );
  55 static void OnLldCtrlStop( void *lld_user_ptr );
  56 static void OnLldCtrlRxMsgAvailable( void *lld_user_ptr );
  57 static void OnLldCtrlTxTransmitC( Ucs_Lld_TxMsg_t *msg_ptr, void *lld_user_ptr );
  58 static void OnUnicensRoutingResult(Ucs_Rm_Route_t* route_ptr, Ucs_Rm_RouteInfos_t route_infos, void *user_ptr);
  59 static void OnUnicensMostPortStatus(uint16_t most_port_handle,
  60     Ucs_Most_PortAvail_t availability, Ucs_Most_PortAvailInfo_t avail_info,
  61     uint16_t free_streaming_bw, void* user_ptr);
  62 static void OnUnicensDebugXrmResources(Ucs_Xrm_ResourceType_t resource_type,
  63     Ucs_Xrm_ResObject_t *resource_ptr, Ucs_Xrm_ResourceInfos_t resource_infos,
  64     Ucs_Rm_EndPoint_t *endpoint_inst_ptr, void *user_ptr);
  65 static void OnUcsInitResult(Ucs_InitResult_t result, void *user_ptr);
  66 static void OnUcsStopResult(Ucs_StdResult_t result, void *user_ptr);
  67 static void OnUcsGpioPortCreate(uint16_t node_address, uint16_t gpio_port_handle, Ucs_Gpio_Result_t result, void *user_ptr);
  68 static void OnUcsGpioPortWrite(uint16_t node_address, uint16_t gpio_port_handle, uint16_t current_state, uint16_t sticky_state, Ucs_Gpio_Result_t result, void *user_ptr);
  69 static void OnUcsMgrReport(Ucs_MgrReport_t code, uint16_t node_address, Ucs_Rm_Node_t *node_ptr, void *user_ptr);
  70 static void OnUcsNsRun(Ucs_Rm_Node_t * node_ptr, Ucs_Ns_ResultCode_t result, void *ucs_user_ptr);
  71 static void OnUcsAmsRxMsgReceived(void *user_ptr);
  72 static void OnUcsGpioTriggerEventStatus(uint16_t node_address, uint16_t gpio_port_handle,
  73     uint16_t rising_edges, uint16_t falling_edges, uint16_t levels, void * user_ptr);
  74 static void OnUcsI2CWrite(uint16_t node_address, uint16_t i2c_port_handle,
  75     uint8_t i2c_slave_address, uint8_t data_len, Ucs_I2c_Result_t result, void *user_ptr);
  76
  77 /************************************************************************/
  78 /* Public Function Implementations                                      */
  79 /************************************************************************/
  80
  81 void UCSI_Init(UCSI_Data_t *my, void *pTag)
  82 {
  83     Ucs_Return_t result;
  84     assert(NULL != my);
  85     memset(my, 0, sizeof(UCSI_Data_t));
  86     my->magic = MAGIC;
  87     my->tag = pTag;
  88     my->unicens = Ucs_CreateInstance();
  89     if (NULL == my->unicens)
  90     {
  91         UCSI_CB_OnUserMessage(my->tag, true, "Can not instance a new version of UNICENS, "\
  92             "increase UCS_NUM_INSTANCES define", 0);
  93         assert(false);
  94         return;
  95     }
  96     result = Ucs_SetDefaultConfig(&my->uniInitData);
  97     if(UCS_RET_SUCCESS != result)
  98     {
  99         UCSI_CB_OnUserMessage(my->tag, true, "Can not set default values to Unicens config (result=0x%X)", 1, result);
 100         assert(false);
 101         return;
 102     }
 103     my->uniInitData.user_ptr = my;
 104     my->uniInitData.mgr.report_fptr = OnUcsMgrReport;
 105
 106     my->uniInitData.general.inic_watchdog_enabled = ENABLE_INIC_WATCHDOG;
 107     my->uniInitData.general.get_tick_count_fptr = &OnUnicensGetTime;
 108     my->uniInitData.general.request_service_fptr = &OnUnicensService;
 109     my->uniInitData.general.error_fptr = &OnUnicensError;
 110     my->uniInitData.general.set_application_timer_fptr = &OnUnicensAppTimer;
 111     my->uniInitData.general.debug_error_msg_fptr = &OnUnicensDebugErrorMsg;
 112     my->uniInitData.ams.enabled = ENABLE_AMS_LIB;
 113     my->uniInitData.ams.rx.message_received_fptr = &OnUcsAmsRxMsgReceived;
 114
 115     my->uniInitData.lld.lld_user_ptr = my;
 116     my->uniInitData.lld.start_fptr =  &OnLldCtrlStart;
 117     my->uniInitData.lld.stop_fptr = &OnLldCtrlStop;
 118     my->uniInitData.lld.rx_available_fptr = &OnLldCtrlRxMsgAvailable;
 119     my->uniInitData.lld.tx_transmit_fptr = &OnLldCtrlTxTransmitC;
 120
 121     my->uniInitData.rm.report_fptr = &OnUnicensRoutingResult;
 122     my->uniInitData.rm.xrm.most_port_status_fptr = &OnUnicensMostPortStatus;
 123     my->uniInitData.rm.debug_resource_status_fptr = &OnUnicensDebugXrmResources;
 124
 125     my->uniInitData.gpio.trigger_event_status_fptr = &OnUcsGpioTriggerEventStatus;
 126
 127     RB_Init(&my->rb, CMD_QUEUE_LEN, sizeof(UnicensCmdEntry_t), my->rbBuf);
 128 }
 129
 130 bool UCSI_NewConfig(UCSI_Data_t *my, UcsXmlVal_t *ucsConfig) {
 131
 132     UnicensCmdEntry_t *e;
 133     assert(MAGIC == my->magic);
 134     if (my->initialized)
 135     {
 136         e = (UnicensCmdEntry_t *)RB_GetWritePtr(&my->rb);
 137         if (NULL == e) return false;
 138         e->cmd = UnicensCmd_Stop;
 139         RB_PopWritePtr(&my->rb);
 140     }
 141     my->uniInitData.mgr.packet_bw = ucsConfig->packetBw;
 142     my->uniInitData.mgr.routes_list_ptr = ucsConfig->pRoutes;
 143     my->uniInitData.mgr.routes_list_size = ucsConfig->routesSize;
 144     my->uniInitData.mgr.nodes_list_ptr = ucsConfig->pNod;
 145     my->uniInitData.mgr.nodes_list_size = ucsConfig->nodSize;
 146     my->uniInitData.mgr.enabled = true;
 147     e = (UnicensCmdEntry_t *)RB_GetWritePtr(&my->rb);
 148     if (NULL == e) return false;
 149     e->cmd =  UnicensCmd_Init;
 150     e->val.Init.init_ptr = &my->uniInitData;
 151     RB_PopWritePtr(&my->rb);
 152     UCSI_CB_OnServiceRequired(my->tag);
 153     return true;
 154 }
 155
 156 bool UCSI_ProcessRxData(UCSI_Data_t *my,
 157     const uint8_t *pBuffer, uint16_t len)
 158 {
 159     Ucs_Lld_RxMsg_t *msg = NULL;
 160     assert(MAGIC == my->magic);
 161     if (NULL == my->uniLld || NULL == my->uniLldHPtr) return false;
 162     msg = my->uniLld->rx_allocate_fptr(my->uniLldHPtr, len);
 163     if (NULL == msg)
 164     {
 165         /*This may happen by definition, OnLldCtrlRxMsgAvailable()
 166           will be called, once buffers are available again*/
 167         return false;
 168     }
 169     msg->data_size = len;
 170     memcpy(msg->data_ptr, pBuffer, len);
 171     my->uniLld->rx_receive_fptr(my->uniLldHPtr, msg);
 172     return true;
 173 }
 174
 175 void UCSI_Service(UCSI_Data_t *my)
 176 {
 177     Ucs_Return_t ret;
 178     UnicensCmdEntry_t *e;
 179     bool popEntry = true; /*Set to false in specific case, where function will callback asynchrony.*/
 180     assert(MAGIC == my->magic);
 181     if (NULL != my->unicens && my->triggerService) {
 182         my->triggerService = false;
 183         Ucs_Service(my->unicens);
 184     }
 185     if (NULL != my->currentCmd) return;
 186     my->currentCmd = e = (UnicensCmdEntry_t *)RB_GetReadPtr(&my->rb);
 187     if (NULL == e) return;
 188     switch (e->cmd) {
 189         case UnicensCmd_Init:
 190             if (UCS_RET_SUCCESS == Ucs_Init(my->unicens, e->val.Init.init_ptr, OnUcsInitResult))
 191                 popEntry = false;
 192             else
 193                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Init failed", 0);
 194             break;
 195         case UnicensCmd_Stop:
 196             if (UCS_RET_SUCCESS == Ucs_Stop(my->unicens, OnUcsStopResult))
 197                 popEntry = false;
 198             else
 199                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Stop failed", 0);
 200             break;
 201         case UnicensCmd_RmSetRoute:
 202             if (UCS_RET_SUCCESS != Ucs_Rm_SetRouteActive(my->unicens, e->val.RmSetRoute.routePtr, e->val.RmSetRoute.isActive))
 203                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Rm_SetRouteActive failed", 0);
 204             break;
 205         case UnicensCmd_NsRun:
 206             if (UCS_RET_SUCCESS != Ucs_Ns_Run(my->unicens, e->val.NsRun.node_ptr, OnUcsNsRun))
 207                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Ns_Run failed", 0);
 208             break;
 209         case UnicensCmd_GpioCreatePort:
 210             if (UCS_RET_SUCCESS == Ucs_Gpio_CreatePort(my->unicens, e->val.GpioCreatePort.destination, 0, e->val.GpioCreatePort.debounceTime, OnUcsGpioPortCreate))
 211                 popEntry = false;
 212             else
 213                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Gpio_CreatePort failed", 0);
 214             break;
 215         case UnicensCmd_GpioWritePort:
 216             if (UCS_RET_SUCCESS == Ucs_Gpio_WritePort(my->unicens, e->val.GpioWritePort.destination, 0x1D00, e->val.GpioWritePort.mask, e->val.GpioWritePort.data, OnUcsGpioPortWrite))
 217                 popEntry = false;
 218             else
 219                 UCSI_CB_OnUserMessage(my->tag, true, "UnicensCmd_GpioWritePort failed", 0);
 220             break;
 221         case UnicensCmd_I2CWrite:
 222             ret = Ucs_I2c_WritePort(my->unicens, e->val.I2CWrite.destination, 0x0F00,
 223                 (e->val.I2CWrite.isBurst ? UCS_I2C_BURST_MODE : UCS_I2C_DEFAULT_MODE), e->val.I2CWrite.blockCount,
 224                 e->val.I2CWrite.slaveAddr, e->val.I2CWrite.timeout, e->val.I2CWrite.dataLen, e->val.I2CWrite.data, OnUcsI2CWrite);
 225             if (UCS_RET_SUCCESS == ret)
 226                 popEntry = false;
 227             else {
 228                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_I2c_WritePort failed ret=%d", 1, ret);
 229                 assert(e->val.I2CWrite.result_fptr != NULL);
 230                 e->val.I2CWrite.result_fptr(NULL /*processing error*/, e->val.I2CWrite.request_ptr);
 231             }
 232             break;
 233         default:
 234             assert(false);
 235             break;
 236     }
 237     if (popEntry)
 238     {
 239         my->currentCmd = NULL;
 240         RB_PopReadPtr(&my->rb);
 241     }
 242 }
 243
 244 void UCSI_Timeout(UCSI_Data_t *my)
 245 {
 246     assert(MAGIC == my->magic);
 247     if (NULL == my->unicens) return;
 248     Ucs_ReportTimeout(my->unicens);
 249 }
 250
 251 bool UCSI_SendAmsMessage(UCSI_Data_t *my, uint16_t msgId, uint16_t targetAddress, uint8_t *pPayload, uint32_t payloadLen)
 252 {
 253     Ucs_AmsTx_Msg_t *msg;
 254     Ucs_Return_t result;
 255     assert(MAGIC == my->magic);
 256     if (NULL == my->unicens) return false;
 257     msg = Ucs_AmsTx_AllocMsg(my->unicens, payloadLen);
 258     if (NULL == msg) return false;
 259     if (0 != payloadLen)
 260     {
 261         assert(NULL != msg->data_ptr);
 262         memcpy(msg->data_ptr, pPayload, payloadLen);
 263     }
 264     msg->custom_info_ptr = NULL;
 265     msg->data_size = payloadLen;
 266     msg->destination_address = targetAddress;
 267     msg->llrbc = 10;
 268     msg->msg_id = msgId;
 269     result = Ucs_AmsTx_SendMsg(my->unicens, msg, NULL);
 270     if (UCS_RET_SUCCESS != result)
 271         Ucs_AmsTx_FreeUnusedMsg(my->unicens, msg);
 272     return UCS_RET_SUCCESS == result;
 273 }
 274
 275 bool UCSI_GetAmsMessage(UCSI_Data_t *my, uint16_t *pMsgId, uint16_t *pSourceAddress, uint8_t **pPayload, uint32_t *pPayloadLen)
 276 {
 277     Ucs_AmsRx_Msg_t *msg;
 278     assert(MAGIC == my->magic);
 279     if (NULL == my->unicens || NULL == pPayload || NULL == pPayloadLen) return false;
 280     msg = Ucs_AmsRx_PeekMsg(my->unicens);
 281     if (NULL == msg) return false;
 282     *pMsgId = msg->msg_id;
 283     *pSourceAddress = msg->source_address;
 284     *pPayload = msg->data_ptr;
 285     *pPayloadLen = msg->data_size;
 286     return true;
 287 }
 288
 289 void UCSI_ReleaseAmsMessage(UCSI_Data_t *my)
 290 {
 291     assert(MAGIC == my->magic);
 292     if (NULL == my->unicens) return;
 293     Ucs_AmsRx_ReleaseMsg(my->unicens);
 294 }
 295
 296 bool UCSI_SetRouteActive(UCSI_Data_t *my, uint16_t routeId, bool isActive)
 297 {
 298     uint16_t i;
 299     UnicensCmdEntry_t entry;
 300     assert(MAGIC == my->magic);
 301     if (NULL == my || NULL == my->uniInitData.mgr.routes_list_ptr) return false;
 302     for (i = 0; i < my->uniInitData.mgr.routes_list_size; i++)
 303     {
 304         Ucs_Rm_Route_t *route = &my->uniInitData.mgr.routes_list_ptr[i];
 305         if (route->route_id != routeId)
 306             continue;
 307         entry.cmd = UnicensCmd_RmSetRoute;
 308         entry.val.RmSetRoute.routePtr = route;
 309         entry.val.RmSetRoute.isActive = isActive;
 310         return EnqueueCommand(my, &entry);
 311     }
 312     return false;
 313 }
 314
 315 bool UCSI_I2CWrite(UCSI_Data_t *my, uint16_t targetAddress, bool isBurst, uint8_t blockCount,
 316     uint8_t slaveAddr, uint16_t timeout, uint8_t dataLen, uint8_t *pData,
 317     Ucsi_ResultCb_t result_fptr, void *request_ptr)
 318 {
 319     UnicensCmdEntry_t entry;
 320     assert(MAGIC == my->magic);
 321     if (NULL == my || NULL == pData || 0 == dataLen) return false;
 322     if (dataLen > I2C_WRITE_MAX_LEN) return false;
 323     entry.cmd = UnicensCmd_I2CWrite;
 324     entry.val.I2CWrite.destination = targetAddress;
 325     entry.val.I2CWrite.isBurst = isBurst;
 326     entry.val.I2CWrite.blockCount = blockCount;
 327     entry.val.I2CWrite.slaveAddr = slaveAddr;
 328     entry.val.I2CWrite.timeout = timeout;
 329     entry.val.I2CWrite.dataLen = dataLen;
 330     entry.val.I2CWrite.result_fptr = result_fptr;
 331     entry.val.I2CWrite.request_ptr = request_ptr;
 332     memcpy(entry.val.I2CWrite.data, pData, dataLen);
 333     return EnqueueCommand(my, &entry);
 334 }
 335
 336 bool UCSI_SetGpioState(UCSI_Data_t *my, uint16_t targetAddress, uint8_t gpioPinId, bool isHighState)
 337 {
 338     uint16_t mask;
 339     UnicensCmdEntry_t entry;
 340     assert(MAGIC == my->magic);
 341     if (NULL == my) return false;
 342     mask = 1 << gpioPinId;
 343     entry.cmd = UnicensCmd_GpioWritePort;
 344     entry.val.GpioWritePort.destination = targetAddress;
 345     entry.val.GpioWritePort.mask = mask;
 346     entry.val.GpioWritePort.data = isHighState ? mask : 0;
 347     return EnqueueCommand(my, &entry);
 348 }
 349
 350 /************************************************************************/
 351 /* Private Functions                                                    */
 352 /************************************************************************/
 353 static bool EnqueueCommand(UCSI_Data_t *my, UnicensCmdEntry_t *cmd)
 354 {
 355     UnicensCmdEntry_t *e;
 356     if (NULL == my || NULL == cmd)
 357     {
 358         assert(false);
 359         return false;
 360     }
 361     e = RB_GetWritePtr(&my->rb);
 362     if (NULL == e)
 363     {
 364         UCSI_CB_OnUserMessage(my->tag, true, "Could not enqueue command. Increase CMD_QUEUE_LEN define", 0);
 365         return false;
 366     }
 367     memcpy(e, cmd, sizeof(UnicensCmdEntry_t));
 368     RB_PopWritePtr(&my->rb);
 369     UCSI_CB_OnServiceRequired(my->tag);
 370     return true;
 371 }
 372
 373 static void OnCommandExecuted(UCSI_Data_t *my, UnicensCmd_t cmd)
 374 {
 375     if (NULL == my)
 376     {
 377         assert(false);
 378         return;
 379     }
 380     if (NULL == my->currentCmd)
 381     {
 382         UCSI_CB_OnUserMessage(my->tag, true, "OnUniCommandExecuted was called, but no "\
 383             "command is in queue", 0);
 384         assert(false);
 385         return;
 386     }
 387     if (my->currentCmd->cmd != cmd)
 388     {
 389         UCSI_CB_OnUserMessage(my->tag, true, "OnUniCommandExecuted was called with "\
 390             "wrong command (Expected=0x%X, Got=0x%X", 2, my->currentCmd->cmd, cmd);
 391         assert(false);
 392         return;
 393     }
 394     my->currentCmd = NULL;
 395     RB_PopReadPtr(&my->rb);
 396 }
 397
 398 static void RB_Init(RB_t *rb, uint16_t amountOfEntries, uint32_t sizeOfEntry, uint8_t *workingBuffer)
 399 {
 400     assert(NULL != rb);
 401     assert(NULL != workingBuffer);
 402     rb->dataQueue = workingBuffer;
 403     rb->pRx = rb->dataQueue;
 404     rb->pTx = rb->dataQueue;
 405     rb->amountOfEntries = amountOfEntries;
 406     rb->sizeOfEntry = sizeOfEntry;
 407     rb->rxPos = 0;
 408     rb->txPos = 0;
 409 }
 410
 411 static void *RB_GetReadPtr(RB_t *rb)
 412 {
 413     assert(NULL != rb);
 414     assert(0 != rb->dataQueue);
 415     if (rb->txPos - rb->rxPos > 0)
 416     return (void *)rb->pRx;
 417     return NULL;
 418 }
 419
 420 static void RB_PopReadPtr(RB_t *rb)
 421 {
 422     assert(NULL != rb);
 423     assert(0 != rb->dataQueue);
 424
 425     rb->pRx += rb->sizeOfEntry;
 426     if (rb->pRx >= rb->dataQueue + ( rb->amountOfEntries * rb->sizeOfEntry))
 427     rb->pRx = rb->dataQueue;
 428     ++rb->rxPos;
 429     assert(rb->txPos >= rb->rxPos);
 430 }
 431
 432 static void *RB_GetWritePtr(RB_t *rb)
 433 {
 434     assert(NULL != rb);
 435     assert(0 != rb->dataQueue);
 436     if (rb->txPos - rb->rxPos < rb->amountOfEntries)
 437     return (void *)rb->pTx;
 438     return NULL;
 439 }
 440
 441 static void RB_PopWritePtr(RB_t *rb)
 442 {
 443     assert(NULL != rb);
 444     assert(0 != rb->dataQueue);
 445     rb->pTx += rb->sizeOfEntry;
 446     if (rb->pTx >= rb->dataQueue + ( rb->amountOfEntries * rb->sizeOfEntry))
 447     rb->pTx = rb->dataQueue;
 448     ++rb->txPos;
 449     assert(rb->txPos >= rb->rxPos);
 450 }
 451
 452 static uint16_t OnUnicensGetTime(void *user_ptr)
 453 {
 454     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 455     assert(MAGIC == my->magic);
 456     return UCSI_CB_OnGetTime(my->tag);
 457 }
 458
 459 static void OnUnicensService( void *user_ptr )
 460 {
 461     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 462     assert(MAGIC == my->magic);
 463     my->triggerService = true;
 464     UCSI_CB_OnServiceRequired(my->tag);
 465 }
 466
 467 static void OnUnicensError( Ucs_Error_t error_code, void *user_ptr )
 468 {
 469     UnicensCmdEntry_t e;
 470     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 471     error_code = error_code;
 472     assert(MAGIC == my->magic);
 473     UCSI_CB_OnUserMessage(my->tag, true, "Unicens general error, code=0x%X, restarting", 1, error_code);
 474     e.cmd = UnicensCmd_Init;
 475     e.val.Init.init_ptr = &my->uniInitData;
 476     EnqueueCommand(my, &e);
 477 }
 478
 479 static void OnUnicensAppTimer( uint16_t timeout, void *user_ptr )
 480 {
 481     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 482     assert(MAGIC == my->magic);
 483     UCSI_CB_OnSetServiceTimer(my->tag, timeout);
 484 }
 485
 486 static void OnUnicensDebugErrorMsg(Msg_MostTel_t *m, void *user_ptr)
 487 {
 488     char buffer[100];
 489     char val[5];
 490     uint8_t i;
 491     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 492     assert(MAGIC == my->magic);
 493     buffer[0] = '\0';
 494     for (i = 0; NULL != m->tel.tel_data_ptr && i < m->tel.tel_len; i++)
 495     {
 496         snprintf(val, sizeof(val), "%02X ", m->tel.tel_data_ptr[i]);
 497         strcat(buffer, val);
 498     }
 499     UCSI_CB_OnUserMessage(my->tag, true, "Received error message, source=%x, %X.%X.%X.%X, [ %s ]",
 500         6, m->source_addr, m->id.fblock_id, m->id.instance_id,
 501         m->id.function_id, m->id.op_type, buffer);
 502 }
 503
 504 static void OnLldCtrlStart( Ucs_Lld_Api_t* api_ptr, void *inst_ptr, void *lld_user_ptr )
 505 {
 506     UCSI_Data_t *my = (UCSI_Data_t *)lld_user_ptr;
 507     assert(MAGIC == my->magic);
 508     my->uniLld = api_ptr;
 509     my->uniLldHPtr = inst_ptr;
 510 }
 511
 512 static void OnLldCtrlStop( void *lld_user_ptr )
 513 {
 514     UCSI_Data_t *my = (UCSI_Data_t *)lld_user_ptr;
 515     assert(MAGIC == my->magic);
 516     my->uniLld = NULL;
 517     my->uniLldHPtr = NULL;
 518 }
 519
 520 static void OnLldCtrlRxMsgAvailable( void *lld_user_ptr )
 521 {
 522     UCSI_Data_t *my = (UCSI_Data_t *)lld_user_ptr;
 523     assert(MAGIC == my->magic);
 524     UCSI_CB_OnServiceRequired(my->tag);
 525 }
 526
 527 static void OnLldCtrlTxTransmitC( Ucs_Lld_TxMsg_t *msg_ptr, void *lld_user_ptr )
 528 {
 529     UCSI_Data_t *my;
 530     Ucs_Mem_Buffer_t * buf_ptr;
 531     uint8_t buffer[BOARD_PMS_TX_SIZE];
 532     uint32_t bufferPos = 0;
 533     my = (UCSI_Data_t *)lld_user_ptr;
 534     assert(MAGIC == my->magic);
 535     if (NULL == msg_ptr || NULL == my || NULL == my->uniLld || NULL == my->uniLldHPtr)
 536     {
 537         assert(false);
 538         return;
 539     }
 540     for (buf_ptr = msg_ptr->memory_ptr; buf_ptr != NULL; buf_ptr = buf_ptr->next_buffer_ptr)
 541     {
 542         if (buf_ptr->data_size + bufferPos > sizeof(buffer))
 543         {
 544             UCSI_CB_OnUserMessage(my->tag, true, "TX buffer is too small, increase " \
 545                 "BOARD_PMS_TX_SIZE define (%lu > %lu)", 2, buf_ptr->data_size + bufferPos, sizeof(buffer));
 546             my->uniLld->tx_release_fptr(my->uniLldHPtr, msg_ptr);
 547             return;
 548         }
 549         memcpy(&buffer[bufferPos], buf_ptr->data_ptr, buf_ptr->data_size);
 550         bufferPos += buf_ptr->data_size;
 551     }
 552     assert(bufferPos == msg_ptr->memory_ptr->total_size);
 553     my->uniLld->tx_release_fptr(my->uniLldHPtr, msg_ptr);
 554     UCSI_CB_OnTxRequest(my->tag, buffer, bufferPos);
 555 }
 556
 557 static void OnUnicensRoutingResult(Ucs_Rm_Route_t* route_ptr, Ucs_Rm_RouteInfos_t route_infos, void *user_ptr)
 558 {
 559     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 560     assert(MAGIC == my->magic);
 561     UCSI_CB_OnRouteResult(my->tag, route_ptr->route_id, UCS_RM_ROUTE_INFOS_BUILT == route_infos);
 562 }
 563
 564 static void OnUnicensMostPortStatus(uint16_t most_port_handle,
 565     Ucs_Most_PortAvail_t availability, Ucs_Most_PortAvailInfo_t avail_info,
 566     uint16_t free_streaming_bw, void* user_ptr)
 567 {
 568     /*TODO: implement*/
 569     most_port_handle = most_port_handle;
 570     availability = availability;
 571     avail_info = avail_info;
 572     free_streaming_bw = free_streaming_bw;
 573     user_ptr = user_ptr;
 574 }
 575
 576 static void OnUnicensDebugXrmResources(Ucs_Xrm_ResourceType_t resource_type,
 577     Ucs_Xrm_ResObject_t *resource_ptr, Ucs_Xrm_ResourceInfos_t resource_infos,
 578     Ucs_Rm_EndPoint_t *endpoint_inst_ptr, void *user_ptr)
 579 {
 580     char *msg = NULL;
 581     UCSI_Data_t *my;
 582     uint16_t adr = 0xFFFF;
 583 #ifndef DEBUG_XRM
 584     resource_type = resource_type;
 585     resource_ptr = resource_ptr;
 586     resource_infos = resource_infos;
 587     endpoint_inst_ptr = endpoint_inst_ptr;
 588     user_ptr = user_ptr;
 589 #else
 590     endpoint_inst_ptr = endpoint_inst_ptr;
 591     my = (UCSI_Data_t *)user_ptr;
 592     assert(MAGIC == my->magic);
 593     if (NULL == resource_ptr) return;
 594     if (endpoint_inst_ptr && endpoint_inst_ptr->node_obj_ptr &&
 595             endpoint_inst_ptr->node_obj_ptr->signature_ptr)
 596         adr = endpoint_inst_ptr->node_obj_ptr->signature_ptr->node_address;
 597     switch (resource_infos)
 598     {
 599         case UCS_XRM_INFOS_BUILT:
 600         msg = (char *)"has been built";
 601         break;
 602         case UCS_XRM_INFOS_DESTROYED:
 603         msg = (char *)"has been destroyed";
 604         break;
 605         case UCS_XRM_INFOS_ERR_BUILT:
 606         msg = (char *)"cannot be built";
 607         break;
 608         default:
 609         msg = (char *)"cannot be destroyed";
 610         break;
 611     }
 612     switch(resource_type)
 613     {
 614         case UCS_XRM_RC_TYPE_MOST_SOCKET:
 615         {
 616             Ucs_Xrm_MostSocket_t *ms = (Ucs_Xrm_MostSocket_t *)resource_ptr;
 617             assert(ms->resource_type == resource_type);
 618             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): MOST socket %s, handle=%04X, "\
 619                 "direction=%d, type=%d, bandwidth=%d", 6, adr, msg, ms->most_port_handle,
 620                 ms->direction, ms->data_type, ms->bandwidth);
 621             break;
 622         }
 623         case UCS_XRM_RC_TYPE_MLB_PORT:
 624         {
 625             Ucs_Xrm_MlbPort_t *m = (Ucs_Xrm_MlbPort_t *)resource_ptr;
 626             assert(m->resource_type == resource_type);
 627             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): MLB port %s, index=%d, clock=%d", 4,
 628                 adr, msg, m->index, m->clock_config);
 629             break;
 630         }
 631         case UCS_XRM_RC_TYPE_MLB_SOCKET:
 632         {
 633             Ucs_Xrm_MlbSocket_t *m = (Ucs_Xrm_MlbSocket_t *)resource_ptr;
 634             assert(m->resource_type == resource_type);
 635             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): MLB socket %s, direction=%d, type=%d,"\
 636                 " bandwidth=%d, channel=%d", 6, adr, msg, m->direction, m->data_type,
 637                 m->bandwidth, m->channel_address);
 638             break;
 639         }
 640         case UCS_XRM_RC_TYPE_USB_PORT:
 641         {
 642             Ucs_Xrm_UsbPort_t *m = (Ucs_Xrm_UsbPort_t *)resource_ptr;
 643             assert(m->resource_type == resource_type);
 644             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): USB port %s, in-cnt=%d, out-cnt=%d", 4,
 645                 adr, msg, m->streaming_if_ep_in_count, m->streaming_if_ep_out_count);
 646             break;
 647         }
 648         case UCS_XRM_RC_TYPE_USB_SOCKET:
 649         {
 650             Ucs_Xrm_UsbSocket_t *m = (Ucs_Xrm_UsbSocket_t *)resource_ptr;
 651             assert(m->resource_type == resource_type);
 652             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): USB socket %s, direction=%d, type=%d," \
 653                 " ep-addr=%02X, frames=%d", 6, adr, msg, m->direction, m->data_type,
 654                 m->end_point_addr, m->frames_per_transfer);
 655             break;
 656         }
 657         case UCS_XRM_RC_TYPE_STRM_PORT:
 658         {
 659             Ucs_Xrm_StrmPort_t *m = (Ucs_Xrm_StrmPort_t *)resource_ptr;
 660             assert(m->resource_type == resource_type);
 661             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): I2S port %s, index=%d, clock=%d, "\
 662                 "align=%d", 5, adr, msg, m->index, m->clock_config, m->data_alignment);
 663             break;
 664         }
 665         case UCS_XRM_RC_TYPE_STRM_SOCKET:
 666         {
 667             Ucs_Xrm_StrmSocket_t *m = (Ucs_Xrm_StrmSocket_t *)resource_ptr;
 668             assert(m->resource_type == resource_type);
 669             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): I2S socket %s, direction=%d, type=%d"\
 670                 ", bandwidth=%d, pin=%d", 6, adr, msg, m->direction, m->data_type,
 671                 m->bandwidth, m->stream_pin_id);
 672             break;
 673         }
 674         case UCS_XRM_RC_TYPE_SYNC_CON:
 675         {
 676             Ucs_Xrm_SyncCon_t *m = (Ucs_Xrm_SyncCon_t *)resource_ptr;
 677             assert(m->resource_type == resource_type);
 678             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Sync connection %s, mute=%d, "\
 679                 "offset=%d", 4, adr, msg, m->mute_mode, m->offset);
 680             break;
 681         }
 682         case UCS_XRM_RC_TYPE_COMBINER:
 683         {
 684             Ucs_Xrm_Combiner_t *m = (Ucs_Xrm_Combiner_t *)resource_ptr;
 685             assert(m->resource_type == resource_type);
 686             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Combiner %s, bytes per frame=%d",
 687                 3, adr, msg, m->bytes_per_frame);
 688             break;
 689         }
 690         case UCS_XRM_RC_TYPE_SPLITTER:
 691         {
 692             Ucs_Xrm_Splitter_t *m = (Ucs_Xrm_Splitter_t *)resource_ptr;
 693             assert(m->resource_type == resource_type);
 694             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Splitter %s, bytes per frame=%d",
 695                 3, adr, msg, m->bytes_per_frame);
 696             break;
 697         }
 698         case UCS_XRM_RC_TYPE_AVP_CON:
 699         {
 700             Ucs_Xrm_AvpCon_t *m = (Ucs_Xrm_AvpCon_t *)resource_ptr;
 701             assert(m->resource_type == resource_type);
 702             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Isoc-AVP connection %s, packetSize=%d",
 703                 3, adr, msg, m->isoc_packet_size);
 704             break;
 705         }
 706         default:
 707         UCSI_CB_OnUserMessage(my->tag, true, "Xrm-Debug (0x%03X): Unknown type=%d %s", 3 , adr, resource_type, msg);
 708     }
 709 #endif
 710 }
 711
 712 static void OnUcsInitResult(Ucs_InitResult_t result, void *user_ptr)
 713 {
 714     UnicensCmdEntry_t e;
 715     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 716     assert(MAGIC == my->magic);
 717     my->initialized = (UCS_INIT_RES_SUCCESS == result);
 718     OnCommandExecuted(my, UnicensCmd_Init);
 719     if (!my->initialized)
 720     {
 721         UCSI_CB_OnUserMessage(my->tag, true, "UcsInitResult reported error (0x%X), restarting...", 1, result);
 722         e.cmd = UnicensCmd_Init;
 723         e.val.Init.init_ptr = &my->uniInitData;
 724         EnqueueCommand(my, &e);
 725     }
 726 }
 727
 728 static void OnUcsStopResult(Ucs_StdResult_t result, void *user_ptr)
 729 {
 730     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 731     result = result; /*TODO: check error case*/
 732     assert(MAGIC == my->magic);
 733     my->initialized = false;
 734     OnCommandExecuted(my, UnicensCmd_Stop);
 735     UCSI_CB_OnStop(my->tag);
 736 }
 737
 738 static void OnUcsGpioPortCreate(uint16_t node_address, uint16_t gpio_port_handle, Ucs_Gpio_Result_t result, void *user_ptr)
 739 {
 740     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 741     assert(MAGIC == my->magic);
 742     OnCommandExecuted(my, UnicensCmd_GpioCreatePort);
 743 }
 744
 745 static void OnUcsGpioPortWrite(uint16_t node_address, uint16_t gpio_port_handle, uint16_t current_state, uint16_t sticky_state, Ucs_Gpio_Result_t result, void *user_ptr)
 746 {
 747     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 748     assert(MAGIC == my->magic);
 749     OnCommandExecuted(my, UnicensCmd_GpioWritePort);
 750 }
 751
 752 static void OnUcsMgrReport(Ucs_MgrReport_t code, uint16_t node_address, Ucs_Rm_Node_t *node_ptr, void *user_ptr)
 753 {
 754     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 755     assert(MAGIC == my->magic);
 756     switch (code)
 757     {
 758     case UCS_MGR_REP_IGNORED_UNKNOWN:
 759         UCSI_CB_OnUserMessage(my->tag, false, "Node=%X: Ignored, because unknown", 1, node_address);
 760         break;
 761     case UCS_MGR_REP_IGNORED_DUPLICATE:
 762         UCSI_CB_OnUserMessage(my->tag, true, "Node=%X: Ignored, because duplicated", 1, node_address);
 763         break;
 764     case UCS_MGR_REP_AVAILABLE:
 765     {
 766         UnicensCmdEntry_t e;
 767         UCSI_CB_OnUserMessage(my->tag, false, "Node=%X: Available", 1, node_address);
 768         /* Enable usage of remote GPIO ports */
 769         e.cmd = UnicensCmd_GpioCreatePort;
 770         e.val.GpioCreatePort.destination = node_address;
 771         e.val.GpioCreatePort.debounceTime = 20;
 772         EnqueueCommand(my, &e);
 773         /* Execute scripts, if there are any */
 774         if (node_ptr && node_ptr->script_list_ptr && node_ptr->script_list_size)
 775         {
 776             e.cmd = UnicensCmd_NsRun;
 777             e.val.NsRun.node_ptr = node_ptr;
 778             EnqueueCommand(my, &e);
 779         }
 780         break;
 781     }
 782     case UCS_MGR_REP_NOT_AVAILABLE:
 783         UCSI_CB_OnUserMessage(my->tag, false, "Node=%X: Not available", 1, node_address);
 784         break;
 785     default:
 786         UCSI_CB_OnUserMessage(my->tag, true, "Node=%X: unknown code", 1, node_address);
 787         break;
 788     }
 789
 790     UCSI_CB_OnMgrReport(my->tag, code, node_address, node_ptr);
 791 }
 792
 793 static void OnUcsNsRun(Ucs_Rm_Node_t * node_ptr, Ucs_Ns_ResultCode_t result, void *ucs_user_ptr)
 794 {
 795     UCSI_Data_t *my;
 796 #ifndef DEBUG_XRM
 797     node_ptr = node_ptr;
 798     result = result;
 799     ucs_user_ptr;
 800 #else
 801     my = (UCSI_Data_t *)ucs_user_ptr;
 802     assert(MAGIC == my->magic);
 803     UCSI_CB_OnUserMessage(my->tag, false, "OnUcsNsRun (%03X): script executed %s",
 804         2, node_ptr->signature_ptr->node_address,
 805         (UCS_NS_RES_SUCCESS == result ? "succeeded" : "false"));
 806 #endif
 807 }
 808
 809 static void OnUcsAmsRxMsgReceived(void *user_ptr)
 810 {
 811     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 812     assert(MAGIC == my->magic);
 813     UCSI_CB_OnAmsMessageReceived(my->tag);
 814 }
 815
 816 static void OnUcsGpioTriggerEventStatus(uint16_t node_address, uint16_t gpio_port_handle,
 817     uint16_t rising_edges, uint16_t falling_edges, uint16_t levels, void * user_ptr)
 818 {
 819     uint8_t i;
 820     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 821     assert(MAGIC == my->magic);
 822     for (i = 0; i < 16; i++)
 823     {
 824         if (0 != ((rising_edges >> i) & 0x1))
 825             UCSI_CB_OnGpioStateChange(my->tag, node_address, i, true);
 826         if (0 != ((falling_edges >> i) & 0x1))
 827             UCSI_CB_OnGpioStateChange(my->tag, node_address, i, false);
 828     }
 829 }
 830
 831 static void OnUcsI2CWrite(uint16_t node_address, uint16_t i2c_port_handle,
 832     uint8_t i2c_slave_address, uint8_t data_len, Ucs_I2c_Result_t result, void *user_ptr)
 833 {
 834     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 835     assert(MAGIC == my->magic);
 836
 837     if ((my->currentCmd->cmd == UnicensCmd_I2CWrite)
 838         && (my->currentCmd->val.I2CWrite.result_fptr)) {
 839
 840         my->currentCmd->val.I2CWrite.result_fptr(&result.code, my->currentCmd->val.I2CWrite.request_ptr);
 841     }
 842     else {
 843         assert(false);
 844     }
 845
 846     OnCommandExecuted(my, UnicensCmd_I2CWrite);
 847     if (UCS_I2C_RES_SUCCESS != result.code)
 848         UCSI_CB_OnUserMessage(my->tag, true, "Remote I2C Write to node=0x%X failed", 1, node_address);
 849 }
 850
 851 /*----------------------------------------
 852  * Debug Message output from Unicens stack:
 853  *----------------------------------------
 854  */
 855 #if defined(UCS_TR_ERROR) || defined(UCS_TR_INFO)
 856 #include <stdio.h>
 857 #define TRACE_BUFFER_SZ 200
 858 void App_TraceError(void *ucs_user_ptr, const char module_str[], const char entry_str[], uint16_t vargs_cnt, ...)
 859 {
 860     va_list argptr;
 861     char outbuf[TRACE_BUFFER_SZ];
 862     void *tag;
 863     UCSI_Data_t *my = (UCSI_Data_t *)ucs_user_ptr;
 864     if (my)
 865     {
 866         assert(MAGIC == my->magic);
 867         tag = my->tag;
 868     }
 869     va_start(argptr, vargs_cnt);
 870     vsprintf(outbuf, entry_str, argptr);
 871     va_end(argptr);
 872     UCSI_CB_OnUserMessage(tag, true, "Error | %s | %s", 2, module_str, outbuf);
 873 }
 874
 875 void App_TraceInfo(void *ucs_user_ptr, const char module_str[], const char entry_str[], uint16_t vargs_cnt, ...)
 876 {
 877     va_list argptr;
 878     char outbuf[TRACE_BUFFER_SZ];
 879     void *tag;
 880     UCSI_Data_t *my = (UCSI_Data_t *)ucs_user_ptr;
 881     if (my)
 882     {
 883         assert(MAGIC == my->magic);
 884         tag = my->tag;
 885     }
 886     va_start(argptr, vargs_cnt);
 887     vsprintf(outbuf, entry_str, argptr);
 888     va_end(argptr);
 889     UCSI_CB_OnUserMessage(tag, false, "Info | %s | %s", 2, module_str, outbuf);
 890 }
 891 #endif