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