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     UnicensCmdEntry_t *e;
 178     bool popEntry = true; /*Set to false in specific case, where function will callback asynchrony.*/
 179     assert(MAGIC == my->magic);
 180     if (NULL != my->unicens && my->triggerService) {
 181         my->triggerService = false;
 182         Ucs_Service(my->unicens);
 183     }
 184     if (NULL != my->currentCmd) return;
 185     my->currentCmd = e = (UnicensCmdEntry_t *)RB_GetReadPtr(&my->rb);
 186     if (NULL == e) return;
 187     switch (e->cmd) {
 188         case UnicensCmd_Init:
 189             if (UCS_RET_SUCCESS == Ucs_Init(my->unicens, e->val.Init.init_ptr, OnUcsInitResult))
 190                 popEntry = false;
 191             else
 192                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Init failed", 0);
 193             break;
 194         case UnicensCmd_Stop:
 195             if (UCS_RET_SUCCESS == Ucs_Stop(my->unicens, OnUcsStopResult))
 196                 popEntry = false;
 197             else
 198                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Stop failed", 0);
 199             break;
 200         case UnicensCmd_RmSetRoute:
 201             if (UCS_RET_SUCCESS != Ucs_Rm_SetRouteActive(my->unicens, e->val.RmSetRoute.routePtr, e->val.RmSetRoute.isActive))
 202                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Rm_SetRouteActive failed", 0);
 203             break;
 204         case UnicensCmd_NsRun:
 205             if (UCS_RET_SUCCESS != Ucs_Ns_Run(my->unicens, e->val.NsRun.node_ptr, OnUcsNsRun))
 206                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Ns_Run failed", 0);
 207             break;
 208         case UnicensCmd_GpioCreatePort:
 209             if (UCS_RET_SUCCESS == Ucs_Gpio_CreatePort(my->unicens, e->val.GpioCreatePort.destination, 0, e->val.GpioCreatePort.debounceTime, OnUcsGpioPortCreate))
 210                 popEntry = false;
 211             else
 212                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Gpio_CreatePort failed", 0);
 213             break;
 214         case UnicensCmd_GpioWritePort:
 215             if (UCS_RET_SUCCESS == Ucs_Gpio_WritePort(my->unicens, e->val.GpioWritePort.destination, 0x1D00, e->val.GpioWritePort.mask, e->val.GpioWritePort.data, OnUcsGpioPortWrite))
 216                 popEntry = false;
 217             else
 218                 UCSI_CB_OnUserMessage(my->tag, true, "UnicensCmd_GpioWritePort failed", 0);
 219             break;
 220         case UnicensCmd_I2CWrite:
 221             if (UCS_RET_SUCCESS == Ucs_I2c_WritePort(my->unicens, e->val.I2CWrite.destination, 0x0F00,
 222                 (e->val.I2CWrite.isBurst ? UCS_I2C_BURST_MODE : UCS_I2C_DEFAULT_MODE), e->val.I2CWrite.blockCount,
 223                 e->val.I2CWrite.slaveAddr, e->val.I2CWrite.timeout, e->val.I2CWrite.dataLen, e->val.I2CWrite.data, OnUcsI2CWrite))
 224                 popEntry = false;
 225             else
 226                 UCSI_CB_OnUserMessage(my->tag, true, "Ucs_Gpio_CreatePort failed", 0);
 227             break;
 228         default:
 229             assert(false);
 230             break;
 231     }
 232     if (popEntry)
 233     {
 234         my->currentCmd = NULL;
 235         RB_PopReadPtr(&my->rb);
 236     }
 237 }
 238
 239 void UCSI_Timeout(UCSI_Data_t *my)
 240 {
 241     assert(MAGIC == my->magic);
 242     if (NULL == my->unicens) return;
 243     Ucs_ReportTimeout(my->unicens);
 244 }
 245
 246 bool UCSI_SendAmsMessage(UCSI_Data_t *my, uint16_t msgId, uint16_t targetAddress, uint8_t *pPayload, uint32_t payloadLen)
 247 {
 248     Ucs_AmsTx_Msg_t *msg;
 249     Ucs_Return_t result;
 250     assert(MAGIC == my->magic);
 251     if (NULL == my->unicens) return false;
 252     msg = Ucs_AmsTx_AllocMsg(my->unicens, payloadLen);
 253     if (NULL == msg) return false;
 254     if (0 != payloadLen)
 255     {
 256         assert(NULL != msg->data_ptr);
 257         memcpy(msg->data_ptr, pPayload, payloadLen);
 258     }
 259     msg->custom_info_ptr = NULL;
 260     msg->data_size = payloadLen;
 261     msg->destination_address = targetAddress;
 262     msg->llrbc = 10;
 263     msg->msg_id = msgId;
 264     result = Ucs_AmsTx_SendMsg(my->unicens, msg, NULL);
 265     if (UCS_RET_SUCCESS != result)
 266         Ucs_AmsTx_FreeUnusedMsg(my->unicens, msg);
 267     return UCS_RET_SUCCESS == result;
 268 }
 269
 270 bool UCSI_GetAmsMessage(UCSI_Data_t *my, uint16_t *pMsgId, uint16_t *pSourceAddress, uint8_t **pPayload, uint32_t *pPayloadLen)
 271 {
 272     Ucs_AmsRx_Msg_t *msg;
 273     assert(MAGIC == my->magic);
 274     if (NULL == my->unicens || NULL == pPayload || NULL == pPayloadLen) return false;
 275     msg = Ucs_AmsRx_PeekMsg(my->unicens);
 276     if (NULL == msg) return false;
 277     *pMsgId = msg->msg_id;
 278     *pSourceAddress = msg->source_address;
 279     *pPayload = msg->data_ptr;
 280     *pPayloadLen = msg->data_size;
 281     return true;
 282 }
 283
 284 void UCSI_ReleaseAmsMessage(UCSI_Data_t *my)
 285 {
 286     assert(MAGIC == my->magic);
 287     if (NULL == my->unicens) return;
 288     Ucs_AmsRx_ReleaseMsg(my->unicens);
 289 }
 290
 291 bool UCSI_SetRouteActive(UCSI_Data_t *my, uint16_t routeId, bool isActive)
 292 {
 293     uint16_t i;
 294     UnicensCmdEntry_t entry;
 295     assert(MAGIC == my->magic);
 296     if (NULL == my || NULL == my->uniInitData.mgr.routes_list_ptr) return false;
 297     for (i = 0; i < my->uniInitData.mgr.routes_list_size; i++)
 298     {
 299         Ucs_Rm_Route_t *route = &my->uniInitData.mgr.routes_list_ptr[i];
 300         if (route->route_id != routeId)
 301             continue;
 302         entry.cmd = UnicensCmd_RmSetRoute;
 303         entry.val.RmSetRoute.routePtr = route;
 304         entry.val.RmSetRoute.isActive = isActive;
 305         return EnqueueCommand(my, &entry);
 306     }
 307     return false;
 308 }
 309
 310 bool UCSI_I2CWrite(UCSI_Data_t *my, uint16_t targetAddress, bool isBurst, uint8_t blockCount,
 311     uint8_t slaveAddr, uint16_t timeout, uint8_t dataLen, uint8_t *pData)
 312 {
 313     UnicensCmdEntry_t entry;
 314     assert(MAGIC == my->magic);
 315     if (NULL == my || NULL == pData || 0 == dataLen) return false;
 316     if (dataLen > I2C_WRITE_MAX_LEN) return false;
 317     entry.cmd = UnicensCmd_I2CWrite;
 318     entry.val.I2CWrite.destination = targetAddress;
 319     entry.val.I2CWrite.isBurst = isBurst;
 320     entry.val.I2CWrite.blockCount = blockCount;
 321     entry.val.I2CWrite.slaveAddr = slaveAddr;
 322     entry.val.I2CWrite.timeout = timeout;
 323     entry.val.I2CWrite.dataLen = dataLen;
 324     memcpy(entry.val.I2CWrite.data, pData, dataLen);
 325     return EnqueueCommand(my, &entry);
 326 }
 327
 328 bool UCSI_SetGpioState(UCSI_Data_t *my, uint16_t targetAddress, uint8_t gpioPinId, bool isHighState)
 329 {
 330     uint16_t mask;
 331     UnicensCmdEntry_t entry;
 332     assert(MAGIC == my->magic);
 333     if (NULL == my) return false;
 334     mask = 1 << gpioPinId;
 335     entry.cmd = UnicensCmd_GpioWritePort;
 336     entry.val.GpioWritePort.destination = targetAddress;
 337     entry.val.GpioWritePort.mask = mask;
 338     entry.val.GpioWritePort.data = isHighState ? mask : 0;
 339     return EnqueueCommand(my, &entry);
 340 }
 341
 342 /************************************************************************/
 343 /* Private Functions                                                    */
 344 /************************************************************************/
 345 static bool EnqueueCommand(UCSI_Data_t *my, UnicensCmdEntry_t *cmd)
 346 {
 347     UnicensCmdEntry_t *e;
 348     if (NULL == my || NULL == cmd)
 349     {
 350         assert(false);
 351         return false;
 352     }
 353     e = RB_GetWritePtr(&my->rb);
 354     if (NULL == e)
 355     {
 356         UCSI_CB_OnUserMessage(my->tag, true, "Could not enqueue command. Increase CMD_QUEUE_LEN define", 0);
 357         return false;
 358     }
 359     memcpy(e, cmd, sizeof(UnicensCmdEntry_t));
 360     RB_PopWritePtr(&my->rb);
 361     UCSI_CB_OnServiceRequired(my->tag);
 362     return true;
 363 }
 364
 365 static void OnCommandExecuted(UCSI_Data_t *my, UnicensCmd_t cmd)
 366 {
 367     if (NULL == my)
 368     {
 369         assert(false);
 370         return;
 371     }
 372     if (NULL == my->currentCmd)
 373     {
 374         UCSI_CB_OnUserMessage(my->tag, true, "OnUniCommandExecuted was called, but no "\
 375             "command is in queue", 0);
 376         assert(false);
 377         return;
 378     }
 379     if (my->currentCmd->cmd != cmd)
 380     {
 381         UCSI_CB_OnUserMessage(my->tag, true, "OnUniCommandExecuted was called with "\
 382             "wrong command (Expected=0x%X, Got=0x%X", 2, my->currentCmd->cmd, cmd);
 383         assert(false);
 384         return;
 385     }
 386     my->currentCmd = NULL;
 387     RB_PopReadPtr(&my->rb);
 388 }
 389
 390 static void RB_Init(RB_t *rb, uint16_t amountOfEntries, uint32_t sizeOfEntry, uint8_t *workingBuffer)
 391 {
 392     assert(NULL != rb);
 393     assert(NULL != workingBuffer);
 394     rb->dataQueue = workingBuffer;
 395     rb->pRx = rb->dataQueue;
 396     rb->pTx = rb->dataQueue;
 397     rb->amountOfEntries = amountOfEntries;
 398     rb->sizeOfEntry = sizeOfEntry;
 399     rb->rxPos = 0;
 400     rb->txPos = 0;
 401 }
 402
 403 static void *RB_GetReadPtr(RB_t *rb)
 404 {
 405     assert(NULL != rb);
 406     assert(0 != rb->dataQueue);
 407     if (rb->txPos - rb->rxPos > 0)
 408     return (void *)rb->pRx;
 409     return NULL;
 410 }
 411
 412 static void RB_PopReadPtr(RB_t *rb)
 413 {
 414     assert(NULL != rb);
 415     assert(0 != rb->dataQueue);
 416
 417     rb->pRx += rb->sizeOfEntry;
 418     if (rb->pRx >= rb->dataQueue + ( rb->amountOfEntries * rb->sizeOfEntry))
 419     rb->pRx = rb->dataQueue;
 420     ++rb->rxPos;
 421     assert(rb->txPos >= rb->rxPos);
 422 }
 423
 424 static void *RB_GetWritePtr(RB_t *rb)
 425 {
 426     assert(NULL != rb);
 427     assert(0 != rb->dataQueue);
 428     if (rb->txPos - rb->rxPos < rb->amountOfEntries)
 429     return (void *)rb->pTx;
 430     return NULL;
 431 }
 432
 433 static void RB_PopWritePtr(RB_t *rb)
 434 {
 435     assert(NULL != rb);
 436     assert(0 != rb->dataQueue);
 437     rb->pTx += rb->sizeOfEntry;
 438     if (rb->pTx >= rb->dataQueue + ( rb->amountOfEntries * rb->sizeOfEntry))
 439     rb->pTx = rb->dataQueue;
 440     ++rb->txPos;
 441     assert(rb->txPos >= rb->rxPos);
 442 }
 443
 444 static uint16_t OnUnicensGetTime(void *user_ptr)
 445 {
 446     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 447     assert(MAGIC == my->magic);
 448     return UCSI_CB_OnGetTime(my->tag);
 449 }
 450
 451 static void OnUnicensService( void *user_ptr )
 452 {
 453     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 454     assert(MAGIC == my->magic);
 455     my->triggerService = true;
 456     UCSI_CB_OnServiceRequired(my->tag);
 457 }
 458
 459 static void OnUnicensError( Ucs_Error_t error_code, void *user_ptr )
 460 {
 461     UnicensCmdEntry_t e;
 462     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 463     error_code = error_code;
 464     assert(MAGIC == my->magic);
 465     UCSI_CB_OnUserMessage(my->tag, true, "Unicens general error, code=0x%X, restarting", 1, error_code);
 466     e.cmd = UnicensCmd_Init;
 467     e.val.Init.init_ptr = &my->uniInitData;
 468     EnqueueCommand(my, &e);
 469 }
 470
 471 static void OnUnicensAppTimer( uint16_t timeout, void *user_ptr )
 472 {
 473     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 474     assert(MAGIC == my->magic);
 475     UCSI_CB_OnSetServiceTimer(my->tag, timeout);
 476 }
 477
 478 static void OnUnicensDebugErrorMsg(Msg_MostTel_t *m, void *user_ptr)
 479 {
 480     char buffer[100];
 481     char val[5];
 482     uint8_t i;
 483     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 484     assert(MAGIC == my->magic);
 485     buffer[0] = '\0';
 486     for (i = 0; NULL != m->tel.tel_data_ptr && i < m->tel.tel_len; i++)
 487     {
 488         snprintf(val, sizeof(val), "%02X ", m->tel.tel_data_ptr[i]);
 489         strcat(buffer, val);
 490     }
 491     UCSI_CB_OnUserMessage(my->tag, true, "Received error message, source=%x, %X.%X.%X.%X, [ %s ]",
 492         6, m->source_addr, m->id.fblock_id, m->id.instance_id,
 493         m->id.function_id, m->id.op_type, buffer);
 494 }
 495
 496 static void OnLldCtrlStart( Ucs_Lld_Api_t* api_ptr, void *inst_ptr, void *lld_user_ptr )
 497 {
 498     UCSI_Data_t *my = (UCSI_Data_t *)lld_user_ptr;
 499     assert(MAGIC == my->magic);
 500     my->uniLld = api_ptr;
 501     my->uniLldHPtr = inst_ptr;
 502 }
 503
 504 static void OnLldCtrlStop( void *lld_user_ptr )
 505 {
 506     UCSI_Data_t *my = (UCSI_Data_t *)lld_user_ptr;
 507     assert(MAGIC == my->magic);
 508     my->uniLld = NULL;
 509     my->uniLldHPtr = NULL;
 510 }
 511
 512 static void OnLldCtrlRxMsgAvailable( void *lld_user_ptr )
 513 {
 514     UCSI_Data_t *my = (UCSI_Data_t *)lld_user_ptr;
 515     assert(MAGIC == my->magic);
 516     UCSI_CB_OnServiceRequired(my->tag);
 517 }
 518
 519 static void OnLldCtrlTxTransmitC( Ucs_Lld_TxMsg_t *msg_ptr, void *lld_user_ptr )
 520 {
 521     UCSI_Data_t *my;
 522     Ucs_Mem_Buffer_t * buf_ptr;
 523     uint8_t buffer[BOARD_PMS_TX_SIZE];
 524     uint32_t bufferPos = 0;
 525     my = (UCSI_Data_t *)lld_user_ptr;
 526     assert(MAGIC == my->magic);
 527     if (NULL == msg_ptr || NULL == my || NULL == my->uniLld || NULL == my->uniLldHPtr)
 528     {
 529         assert(false);
 530         return;
 531     }
 532     for (buf_ptr = msg_ptr->memory_ptr; buf_ptr != NULL; buf_ptr = buf_ptr->next_buffer_ptr)
 533     {
 534         if (buf_ptr->data_size + bufferPos > sizeof(buffer))
 535         {
 536             UCSI_CB_OnUserMessage(my->tag, true, "TX buffer is too small, increase " \
 537                 "BOARD_PMS_TX_SIZE define (%lu > %lu)", 2, buf_ptr->data_size + bufferPos, sizeof(buffer));
 538             my->uniLld->tx_release_fptr(my->uniLldHPtr, msg_ptr);
 539             return;
 540         }
 541         memcpy(&buffer[bufferPos], buf_ptr->data_ptr, buf_ptr->data_size);
 542         bufferPos += buf_ptr->data_size;
 543     }
 544     assert(bufferPos == msg_ptr->memory_ptr->total_size);
 545     my->uniLld->tx_release_fptr(my->uniLldHPtr, msg_ptr);
 546     UCSI_CB_OnTxRequest(my->tag, buffer, bufferPos);
 547 }
 548
 549 static void OnUnicensRoutingResult(Ucs_Rm_Route_t* route_ptr, Ucs_Rm_RouteInfos_t route_infos, void *user_ptr)
 550 {
 551     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 552     assert(MAGIC == my->magic);
 553     UCSI_CB_OnRouteResult(my->tag, route_ptr->route_id, UCS_RM_ROUTE_INFOS_BUILT == route_infos);
 554 }
 555
 556 static void OnUnicensMostPortStatus(uint16_t most_port_handle,
 557     Ucs_Most_PortAvail_t availability, Ucs_Most_PortAvailInfo_t avail_info,
 558     uint16_t free_streaming_bw, void* user_ptr)
 559 {
 560     /*TODO: implement*/
 561     most_port_handle = most_port_handle;
 562     availability = availability;
 563     avail_info = avail_info;
 564     free_streaming_bw = free_streaming_bw;
 565     user_ptr = user_ptr;
 566 }
 567
 568 static void OnUnicensDebugXrmResources(Ucs_Xrm_ResourceType_t resource_type,
 569     Ucs_Xrm_ResObject_t *resource_ptr, Ucs_Xrm_ResourceInfos_t resource_infos,
 570     Ucs_Rm_EndPoint_t *endpoint_inst_ptr, void *user_ptr)
 571 {
 572     char *msg = NULL;
 573     UCSI_Data_t *my;
 574     uint16_t adr = 0xFFFF;
 575 #ifndef DEBUG_XRM
 576     resource_type = resource_type;
 577     resource_ptr = resource_ptr;
 578     resource_infos = resource_infos;
 579     endpoint_inst_ptr = endpoint_inst_ptr;
 580     user_ptr = user_ptr;
 581 #else
 582     endpoint_inst_ptr = endpoint_inst_ptr;
 583     my = (UCSI_Data_t *)user_ptr;
 584     assert(MAGIC == my->magic);
 585     if (NULL == resource_ptr) return;
 586     if (endpoint_inst_ptr && endpoint_inst_ptr->node_obj_ptr &&
 587             endpoint_inst_ptr->node_obj_ptr->signature_ptr)
 588         adr = endpoint_inst_ptr->node_obj_ptr->signature_ptr->node_address;
 589     switch (resource_infos)
 590     {
 591         case UCS_XRM_INFOS_BUILT:
 592         msg = (char *)"has been built";
 593         break;
 594         case UCS_XRM_INFOS_DESTROYED:
 595         msg = (char *)"has been destroyed";
 596         break;
 597         case UCS_XRM_INFOS_ERR_BUILT:
 598         msg = (char *)"cannot be built";
 599         break;
 600         default:
 601         msg = (char *)"cannot be destroyed";
 602         break;
 603     }
 604     switch(resource_type)
 605     {
 606         case UCS_XRM_RC_TYPE_MOST_SOCKET:
 607         {
 608             Ucs_Xrm_MostSocket_t *ms = (Ucs_Xrm_MostSocket_t *)resource_ptr;
 609             assert(ms->resource_type == resource_type);
 610             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): MOST socket %s, handle=%04X, "\
 611                 "direction=%d, type=%d, bandwidth=%d", 6, adr, msg, ms->most_port_handle,
 612                 ms->direction, ms->data_type, ms->bandwidth);
 613             break;
 614         }
 615         case UCS_XRM_RC_TYPE_MLB_PORT:
 616         {
 617             Ucs_Xrm_MlbPort_t *m = (Ucs_Xrm_MlbPort_t *)resource_ptr;
 618             assert(m->resource_type == resource_type);
 619             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): MLB port %s, index=%d, clock=%d", 4,
 620                 adr, msg, m->index, m->clock_config);
 621             break;
 622         }
 623         case UCS_XRM_RC_TYPE_MLB_SOCKET:
 624         {
 625             Ucs_Xrm_MlbSocket_t *m = (Ucs_Xrm_MlbSocket_t *)resource_ptr;
 626             assert(m->resource_type == resource_type);
 627             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): MLB socket %s, direction=%d, type=%d,"\
 628                 " bandwidth=%d, channel=%d", 6, adr, msg, m->direction, m->data_type,
 629                 m->bandwidth, m->channel_address);
 630             break;
 631         }
 632         case UCS_XRM_RC_TYPE_USB_PORT:
 633         {
 634             Ucs_Xrm_UsbPort_t *m = (Ucs_Xrm_UsbPort_t *)resource_ptr;
 635             assert(m->resource_type == resource_type);
 636             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): USB port %s, in-cnt=%d, out-cnt=%d", 4,
 637                 adr, msg, m->streaming_if_ep_in_count, m->streaming_if_ep_out_count);
 638             break;
 639         }
 640         case UCS_XRM_RC_TYPE_USB_SOCKET:
 641         {
 642             Ucs_Xrm_UsbSocket_t *m = (Ucs_Xrm_UsbSocket_t *)resource_ptr;
 643             assert(m->resource_type == resource_type);
 644             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): USB socket %s, direction=%d, type=%d," \
 645                 " ep-addr=%02X, frames=%d", 6, adr, msg, m->direction, m->data_type,
 646                 m->end_point_addr, m->frames_per_transfer);
 647             break;
 648         }
 649         case UCS_XRM_RC_TYPE_STRM_PORT:
 650         {
 651             Ucs_Xrm_StrmPort_t *m = (Ucs_Xrm_StrmPort_t *)resource_ptr;
 652             assert(m->resource_type == resource_type);
 653             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): I2S port %s, index=%d, clock=%d, "\
 654                 "align=%d", 5, adr, msg, m->index, m->clock_config, m->data_alignment);
 655             break;
 656         }
 657         case UCS_XRM_RC_TYPE_STRM_SOCKET:
 658         {
 659             Ucs_Xrm_StrmSocket_t *m = (Ucs_Xrm_StrmSocket_t *)resource_ptr;
 660             assert(m->resource_type == resource_type);
 661             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): I2S socket %s, direction=%d, type=%d"\
 662                 ", bandwidth=%d, pin=%d", 6, adr, msg, m->direction, m->data_type,
 663                 m->bandwidth, m->stream_pin_id);
 664             break;
 665         }
 666         case UCS_XRM_RC_TYPE_SYNC_CON:
 667         {
 668             Ucs_Xrm_SyncCon_t *m = (Ucs_Xrm_SyncCon_t *)resource_ptr;
 669             assert(m->resource_type == resource_type);
 670             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Sync connection %s, mute=%d, "\
 671                 "offset=%d", 4, adr, msg, m->mute_mode, m->offset);
 672             break;
 673         }
 674         case UCS_XRM_RC_TYPE_COMBINER:
 675         {
 676             Ucs_Xrm_Combiner_t *m = (Ucs_Xrm_Combiner_t *)resource_ptr;
 677             assert(m->resource_type == resource_type);
 678             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Combiner %s, bytes per frame=%d",
 679                 3, adr, msg, m->bytes_per_frame);
 680             break;
 681         }
 682         case UCS_XRM_RC_TYPE_SPLITTER:
 683         {
 684             Ucs_Xrm_Splitter_t *m = (Ucs_Xrm_Splitter_t *)resource_ptr;
 685             assert(m->resource_type == resource_type);
 686             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Splitter %s, bytes per frame=%d",
 687                 3, adr, msg, m->bytes_per_frame);
 688             break;
 689         }
 690         case UCS_XRM_RC_TYPE_AVP_CON:
 691         {
 692             Ucs_Xrm_AvpCon_t *m = (Ucs_Xrm_AvpCon_t *)resource_ptr;
 693             assert(m->resource_type == resource_type);
 694             UCSI_CB_OnUserMessage(my->tag, false, "Xrm-Debug (0x%03X): Isoc-AVP connection %s, packetSize=%d",
 695                 3, adr, msg, m->isoc_packet_size);
 696             break;
 697         }
 698         default:
 699         UCSI_CB_OnUserMessage(my->tag, true, "Xrm-Debug (0x%03X): Unknown type=%d %s", 3 , adr, resource_type, msg);
 700     }
 701 #endif
 702 }
 703
 704 static void OnUcsInitResult(Ucs_InitResult_t result, void *user_ptr)
 705 {
 706     UnicensCmdEntry_t e;
 707     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 708     assert(MAGIC == my->magic);
 709     my->initialized = (UCS_INIT_RES_SUCCESS == result);
 710     OnCommandExecuted(my, UnicensCmd_Init);
 711     if (!my->initialized)
 712     {
 713         UCSI_CB_OnUserMessage(my->tag, true, "UcsInitResult reported error (0x%X), restarting...", 1, result);
 714         e.cmd = UnicensCmd_Init;
 715         e.val.Init.init_ptr = &my->uniInitData;
 716         EnqueueCommand(my, &e);
 717     }
 718 }
 719
 720 static void OnUcsStopResult(Ucs_StdResult_t result, void *user_ptr)
 721 {
 722     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 723     result = result; /*TODO: check error case*/
 724     assert(MAGIC == my->magic);
 725     my->initialized = false;
 726     OnCommandExecuted(my, UnicensCmd_Stop);
 727     UCSI_CB_OnStop(my->tag);
 728 }
 729
 730 static void OnUcsGpioPortCreate(uint16_t node_address, uint16_t gpio_port_handle, Ucs_Gpio_Result_t result, void *user_ptr)
 731 {
 732     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 733     assert(MAGIC == my->magic);
 734     OnCommandExecuted(my, UnicensCmd_GpioCreatePort);
 735 }
 736
 737 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)
 738 {
 739     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 740     assert(MAGIC == my->magic);
 741     OnCommandExecuted(my, UnicensCmd_GpioWritePort);
 742 }
 743
 744 static void OnUcsMgrReport(Ucs_MgrReport_t code, uint16_t node_address, Ucs_Rm_Node_t *node_ptr, void *user_ptr)
 745 {
 746     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 747     assert(MAGIC == my->magic);
 748     switch (code)
 749     {
 750     case UCS_MGR_REP_IGNORED_UNKNOWN:
 751         UCSI_CB_OnUserMessage(my->tag, false, "Node=%X: Ignored, because unknown", 1, node_address);
 752         break;
 753     case UCS_MGR_REP_IGNORED_DUPLICATE:
 754         UCSI_CB_OnUserMessage(my->tag, true, "Node=%X: Ignored, because duplicated", 1, node_address);
 755         break;
 756     case UCS_MGR_REP_AVAILABLE:
 757     {
 758         UnicensCmdEntry_t e;
 759         UCSI_CB_OnUserMessage(my->tag, false, "Node=%X: Available", 1, node_address);
 760         /* Enable usage of remote GPIO ports */
 761         e.cmd = UnicensCmd_GpioCreatePort;
 762         e.val.GpioCreatePort.destination = node_address;
 763         e.val.GpioCreatePort.debounceTime = 20;
 764         EnqueueCommand(my, &e);
 765         /* Execute scripts, if there are any */
 766         if (node_ptr && node_ptr->script_list_ptr && node_ptr->script_list_size)
 767         {
 768             e.cmd = UnicensCmd_NsRun;
 769             e.val.NsRun.node_ptr = node_ptr;
 770             EnqueueCommand(my, &e);
 771         }
 772         break;
 773     }
 774     case UCS_MGR_REP_NOT_AVAILABLE:
 775         UCSI_CB_OnUserMessage(my->tag, false, "Node=%X: Not available", 1, node_address);
 776         break;
 777     default:
 778         UCSI_CB_OnUserMessage(my->tag, true, "Node=%X: unknown code", 1, node_address);
 779         break;
 780     }
 781 }
 782
 783 static void OnUcsNsRun(Ucs_Rm_Node_t * node_ptr, Ucs_Ns_ResultCode_t result, void *ucs_user_ptr)
 784 {
 785     UCSI_Data_t *my;
 786 #ifndef DEBUG_XRM
 787     node_ptr = node_ptr;
 788     result = result;
 789     ucs_user_ptr;
 790 #else
 791     my = (UCSI_Data_t *)ucs_user_ptr;
 792     assert(MAGIC == my->magic);
 793     UCSI_CB_OnUserMessage(my->tag, false, "OnUcsNsRun (%03X): script executed %s",
 794         2, node_ptr->signature_ptr->node_address,
 795         (UCS_NS_RES_SUCCESS == result ? "succeeded" : "false"));
 796 #endif
 797 }
 798
 799 static void OnUcsAmsRxMsgReceived(void *user_ptr)
 800 {
 801     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 802     assert(MAGIC == my->magic);
 803     UCSI_CB_OnAmsMessageReceived(my->tag);
 804 }
 805
 806 static void OnUcsGpioTriggerEventStatus(uint16_t node_address, uint16_t gpio_port_handle,
 807     uint16_t rising_edges, uint16_t falling_edges, uint16_t levels, void * user_ptr)
 808 {
 809     uint8_t i;
 810     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 811     assert(MAGIC == my->magic);
 812     for (i = 0; i < 16; i++)
 813     {
 814         if (0 != ((rising_edges >> i) & 0x1))
 815             UCSI_CB_OnGpioStateChange(my->tag, node_address, i, true);
 816         if (0 != ((falling_edges >> i) & 0x1))
 817             UCSI_CB_OnGpioStateChange(my->tag, node_address, i, false);
 818     }
 819 }
 820
 821 static void OnUcsI2CWrite(uint16_t node_address, uint16_t i2c_port_handle,
 822     uint8_t i2c_slave_address, uint8_t data_len, Ucs_I2c_Result_t result, void *user_ptr)
 823 {
 824     UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
 825     assert(MAGIC == my->magic);
 826     OnCommandExecuted(my, UnicensCmd_I2CWrite);
 827     if (UCS_I2C_RES_SUCCESS != result.code)
 828         UCSI_CB_OnUserMessage(my->tag, true, "Remote I2C Write to node=0x%X failed", 1, node_address);
 829 }
 830
 831 /*----------------------------------------
 832  * Debug Message output from Unicens stack:
 833  *----------------------------------------
 834  */
 835 #if defined(UCS_TR_ERROR) || defined(UCS_TR_INFO)
 836 #include <stdio.h>
 837 #define TRACE_BUFFER_SZ 200
 838 void App_TraceError(void *ucs_user_ptr, const char module_str[], const char entry_str[], uint16_t vargs_cnt, ...)
 839 {
 840     va_list argptr;
 841     char outbuf[TRACE_BUFFER_SZ];
 842     void *tag;
 843     UCSI_Data_t *my = (UCSI_Data_t *)ucs_user_ptr;
 844     if (my)
 845     {
 846         assert(MAGIC == my->magic);
 847         tag = my->tag;
 848     }
 849     va_start(argptr, vargs_cnt);
 850     vsprintf(outbuf, entry_str, argptr);
 851     va_end(argptr);
 852     UCSI_CB_OnUserMessage(tag, true, "Error | %s | %s", 2, module_str, outbuf);
 853 }
 854
 855 void App_TraceInfo(void *ucs_user_ptr, const char module_str[], const char entry_str[], uint16_t vargs_cnt, ...)
 856 {
 857     va_list argptr;
 858     char outbuf[TRACE_BUFFER_SZ];
 859     void *tag;
 860     UCSI_Data_t *my = (UCSI_Data_t *)ucs_user_ptr;
 861     if (my)
 862     {
 863         assert(MAGIC == my->magic);
 864         tag = my->tag;
 865     }
 866     va_start(argptr, vargs_cnt);
 867     vsprintf(outbuf, entry_str, argptr);
 868     va_end(argptr);
 869     UCSI_CB_OnUserMessage(tag, false, "Info | %s | %s", 2, module_str, outbuf);
 870 }
 871 #endif