ucs2-lib/src/ucs_xrm_res.c

   1 /*------------------------------------------------------------------------------------------------*/
   2 /* UNICENS V2.1.0-3491                                                                            */
   3 /* Copyright (c) 2017 Microchip Technology Germany II GmbH & Co. KG.                              */
   4 /*                                                                                                */
   5 /* This program is free software: you can redistribute it and/or modify                           */
   6 /* it under the terms of the GNU General Public License as published by                           */
   7 /* the Free Software Foundation, either version 2 of the License, or                              */
   8 /* (at your option) any later version.                                                            */
   9 /*                                                                                                */
  10 /* This program is distributed in the hope that it will be useful,                                */
  11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of                                 */
  12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                  */
  13 /* GNU General Public License for more details.                                                   */
  14 /*                                                                                                */
  15 /* You should have received a copy of the GNU General Public License                              */
  16 /* along with this program.  If not, see <http://www.gnu.org/licenses/>.                          */
  17 /*                                                                                                */
  18 /* You may also obtain this software under a propriety license from Microchip.                    */
  19 /* Please contact Microchip for further information.                                              */
  20 /*------------------------------------------------------------------------------------------------*/
  21
  22 /*!
  23  * \file
  24  * \brief Implementation of the Extended Resource Manager. This file contains the implementation of
  25  *        the INIC Resource Management functions and result/error handlers.
  26  * \cond UCS_INTERNAL_DOC
  27  * \addtogroup G_UCS_XRM_INT
  28  * @{
  29  */
  30
  31 /*------------------------------------------------------------------------------------------------*/
  32 /* Includes                                                                                       */
  33 /*------------------------------------------------------------------------------------------------*/
  34 #include "ucs_xrm.h"
  35 #include "ucs_xrm_pv.h"
  36 #include "ucs_xrm_cfg.h"
  37 #include "ucs_misc.h"
  38
  39 /*------------------------------------------------------------------------------------------------*/
  40 /* Internal prototypes                                                                            */
  41 /*------------------------------------------------------------------------------------------------*/
  42 static uint16_t Xrm_CreatePortHandle(CExtendedResourceManager *self,
  43                                      Ucs_Xrm_PortType_t port_type,
  44                                      uint8_t index);
  45
  46 /*------------------------------------------------------------------------------------------------*/
  47 /* Implementation of class CExtendedResourceManager (Handling of resource objects)                */
  48 /*------------------------------------------------------------------------------------------------*/
  49 /*! \brief  Creates the corresponding INIC port handle depending on the given port type and the
  50  *          given port instance id.
  51  *  \param  self            Instance pointer
  52  *  \param  port_type       Type of the port
  53  *  \param  index           Port instance id
  54  *  \return Returns the created INIC port handle.
  55  */
  56 static uint16_t Xrm_CreatePortHandle(CExtendedResourceManager *self,
  57                                      Ucs_Xrm_PortType_t port_type,
  58                                      uint8_t index)
  59 {
  60     MISC_UNUSED(self);
  61     return ((uint16_t)((uint16_t)port_type << 8) | (uint16_t)index);
  62 }
  63
  64 /*! \brief  Activates remote synchronization on the current device
  65  *  \param  self            Instance pointer
  66  *  \param  next_set_event  Next event to set once the remote synchronization succeeded
  67  *  \return  Possible return values are shown in the table below.
  68  *           Value                       | Description
  69  *           -------------------------   | ------------------------------------
  70  *           UCS_RET_SUCCESS             | No error
  71  *           UCS_RET_ERR_BUFFER_OVERFLOW | no message buffer available
  72  */
  73 extern Ucs_Return_t Xrm_RemoteDeviceAttach (CExtendedResourceManager *self, Srv_Event_t next_set_event)
  74 {
  75     Ucs_Return_t result;
  76
  77     result = Rsm_SyncDev(self->rsm_ptr, self, &Xrm_RmtDevAttachResultCb);
  78
  79     if(result == UCS_RET_SUCCESS)
  80     {
  81         self->queued_event_mask |= next_set_event;
  82         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start Synchronization of remote device", 0U));
  83     }
  84     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
  85     {
  86         Xrm_WaitForTxMsgObj(self, next_set_event);
  87     }
  88
  89     return result;
  90 }
  91
  92 /*! \brief  Triggers the creation of a MOST socket.
  93  *  \param  self    Instance pointer
  94  */
  95 void Xrm_CreateMostSocket(CExtendedResourceManager *self)
  96 {
  97     UCS_XRM_CONST Ucs_Xrm_MostSocket_t *cfg_ptr = (UCS_XRM_CONST  Ucs_Xrm_MostSocket_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
  98     uint16_t con_label = (cfg_ptr->direction == UCS_SOCKET_DIR_INPUT) ? self->current_job_ptr->most_network_connection_label : 0xFFFFU;
  99     Ucs_Return_t result = Inic_MostSocketCreate(self->inic_ptr,
 100                                                 cfg_ptr->most_port_handle,
 101                                                 cfg_ptr->direction,
 102                                                 cfg_ptr->data_type,
 103                                                 cfg_ptr->bandwidth,
 104                                                 con_label,
 105                                                 &self->obs.std_result_obs);
 106     if(result == UCS_RET_SUCCESS)
 107     {
 108         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating MOST socket", 0U));
 109     }
 110     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 111     {
 112         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 113     }
 114     else
 115     {
 116         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 117         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_MOST_SOCKET;
 118         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 119                                                                                 self->current_job_ptr,
 120                                                                                 self->current_obj_pptr);
 121         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 122         self->report_result.details.int_result = result;
 123         Xrm_HandleError(self);
 124         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating MOST socket failed. Return value: 0x%02X", 1U, result));
 125     }
 126 }
 127
 128 /*! \brief  Triggers the creation of the MediaLB port.
 129  *  \param  self    Instance pointer
 130  */
 131 void Xrm_CreateMlbPort(CExtendedResourceManager *self)
 132 {
 133     UCS_XRM_CONST Ucs_Xrm_MlbPort_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_MlbPort_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 134     Ucs_Return_t result = Inic_MlbPortCreate(self->inic_ptr,
 135                                              cfg_ptr->index,
 136                                              cfg_ptr->clock_config,
 137                                              &self->obs.std_result_obs);
 138     if(result == UCS_RET_SUCCESS)
 139     {
 140         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating MediaLB port", 0U));
 141     }
 142     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 143     {
 144         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 145     }
 146     else
 147     {
 148         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 149         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_MLB_PORT;
 150         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 151                                                                                 self->current_job_ptr,
 152                                                                                 self->current_obj_pptr);
 153         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 154         self->report_result.details.int_result = result;
 155         Xrm_HandleError(self);
 156         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating MediaLB port failed. Return value: 0x%02X", 1U, result));
 157     }
 158 }
 159
 160 /*! \brief  Triggers the creation of a MediaLB socket.
 161  *  \param  self    Instance pointer
 162  */
 163 void Xrm_CreateMlbSocket(CExtendedResourceManager *self)
 164 {
 165     Ucs_Return_t result;
 166     uint16_t mlb_port_handle;
 167     UCS_XRM_CONST Ucs_Xrm_MlbSocket_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_MlbSocket_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 168     if(Xrm_IsDefaultCreatedPort(self, cfg_ptr->mlb_port_obj_ptr) != false)
 169     {
 170         mlb_port_handle = Xrm_CreatePortHandle(self,
 171                                                UCS_XRM_PORT_TYPE_MLB,
 172                                                ((UCS_XRM_CONST Ucs_Xrm_DefaultCreatedPort_t *)(UCS_XRM_CONST void*)(cfg_ptr->mlb_port_obj_ptr))->index);
 173     }
 174     else
 175     {
 176         mlb_port_handle= Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->mlb_port_obj_ptr, NULL);
 177     }
 178     result = Inic_MlbSocketCreate(self->inic_ptr,
 179                                   mlb_port_handle,
 180                                   cfg_ptr->direction,
 181                                   cfg_ptr->data_type,
 182                                   cfg_ptr->bandwidth,
 183                                   cfg_ptr->channel_address,
 184                                   &self->obs.std_result_obs);
 185     if(result == UCS_RET_SUCCESS)
 186     {
 187         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating MediaLB socket", 0U));
 188     }
 189     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 190     {
 191         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 192     }
 193     else
 194     {
 195         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 196         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_MLB_SOCKET;
 197         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 198                                                                                 self->current_job_ptr,
 199                                                                                 self->current_obj_pptr);
 200         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 201         self->report_result.details.int_result = result;
 202         Xrm_HandleError(self);
 203         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating MediaLB socket failed. Return value: 0x%02X", 1U, result));
 204     }
 205 }
 206
 207 /*! \brief  Triggers the creation of the USB port.
 208  *  \param  self    Instance pointer
 209  */
 210 void Xrm_CreateUsbPort(CExtendedResourceManager *self)
 211 {
 212     UCS_XRM_CONST Ucs_Xrm_UsbPort_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_UsbPort_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 213     Ucs_Return_t result = Inic_UsbPortCreate(self->inic_ptr,
 214                                              cfg_ptr->index,
 215                                              cfg_ptr->physical_layer,
 216                                              cfg_ptr->devices_interfaces,
 217                                              cfg_ptr->streaming_if_ep_out_count,
 218                                              cfg_ptr->streaming_if_ep_in_count,
 219                                              &self->obs.std_result_obs);
 220     if(result == UCS_RET_SUCCESS)
 221     {
 222         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating USB port", 0U));
 223     }
 224     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 225     {
 226         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 227     }
 228     else
 229     {
 230         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 231         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_USB_PORT;
 232         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 233                                                                                 self->current_job_ptr,
 234                                                                                 self->current_obj_pptr);
 235         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 236         self->report_result.details.int_result = result;
 237         Xrm_HandleError(self);
 238         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating USB port failed. Return value: 0x%02X", 1U, result));
 239     }
 240 }
 241
 242 /*! \brief  Triggers the creation of a USB socket.
 243  *  \param  self    Instance pointer
 244  */
 245 void Xrm_CreateUsbSocket(CExtendedResourceManager *self)
 246 {
 247     Ucs_Return_t result;
 248     uint16_t usb_port_handle;
 249     UCS_XRM_CONST Ucs_Xrm_UsbSocket_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_UsbSocket_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 250     if(Xrm_IsDefaultCreatedPort(self, cfg_ptr->usb_port_obj_ptr) != false)
 251     {
 252         usb_port_handle = Xrm_CreatePortHandle(self,
 253                                                UCS_XRM_PORT_TYPE_USB,
 254                                                ((UCS_XRM_CONST Ucs_Xrm_DefaultCreatedPort_t *)(UCS_XRM_CONST void*)(cfg_ptr->usb_port_obj_ptr))->index);
 255     }
 256     else
 257     {
 258         usb_port_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->usb_port_obj_ptr, NULL);
 259     }
 260     result = Inic_UsbSocketCreate(self->inic_ptr,
 261                                   usb_port_handle,
 262                                   cfg_ptr->direction,
 263                                   cfg_ptr->data_type,
 264                                   cfg_ptr->end_point_addr,
 265                                   cfg_ptr->frames_per_transfer,
 266                                   &self->obs.std_result_obs);
 267     if(result == UCS_RET_SUCCESS)
 268     {
 269         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating USB socket", 0U));
 270     }
 271     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 272     {
 273         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 274     }
 275     else
 276     {
 277         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 278         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_USB_SOCKET;
 279         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 280                                                                                 self->current_job_ptr,
 281                                                                                 self->current_obj_pptr);
 282         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 283         self->report_result.details.int_result = result;
 284         Xrm_HandleError(self);
 285         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating USB socket failed. Return value: 0x%02X", 1U, result));
 286     }
 287 }
 288
 289 /*! \brief  Triggers the creation of the RMCK port.
 290  *  \param  self    Instance pointer
 291  */
 292 void Xrm_CreateRmckPort(CExtendedResourceManager *self)
 293 {
 294     UCS_XRM_CONST Ucs_Xrm_RmckPort_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_RmckPort_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 295     Ucs_Return_t result = Inic_RmckPortCreate(self->inic_ptr,
 296                                                  cfg_ptr->index,
 297                                                  cfg_ptr->clock_source,
 298                                                  cfg_ptr->divisor,
 299                                                  &self->obs.std_result_obs);
 300     if(result == UCS_RET_SUCCESS)
 301     {
 302         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating RMCK port", 0U));
 303     }
 304     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 305     {
 306         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 307     }
 308     else
 309     {
 310         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 311         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_RMCK_PORT;
 312         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 313                                                                                 self->current_job_ptr,
 314                                                                                 self->current_obj_pptr);
 315         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 316         self->report_result.details.int_result = result;
 317         Xrm_HandleError(self);
 318         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating RMCK port failed. Return value: 0x%02X", 1U, result));
 319     }
 320 }
 321
 322 /*! \brief  Triggers the creation of a streaming port.
 323  *  \param  self    Instance pointer
 324  */
 325 void Xrm_CreateStreamPort(CExtendedResourceManager *self)
 326 {
 327     UCS_XRM_CONST Ucs_Xrm_StrmPort_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_StrmPort_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 328     Ucs_Return_t result = Inic_StreamPortCreate(self->inic_ptr,
 329                                                 cfg_ptr->index,
 330                                                 cfg_ptr->clock_config,
 331                                                 cfg_ptr->data_alignment,
 332                                                 &self->obs.std_result_obs);
 333     if(result == UCS_RET_SUCCESS)
 334     {
 335         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating streaming port", 0U));
 336     }
 337     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 338     {
 339         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 340     }
 341     else
 342     {
 343         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 344         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_STRM_PORT;
 345         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 346                                                                                 self->current_job_ptr,
 347                                                                                 self->current_obj_pptr);
 348         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 349         self->report_result.details.int_result = result;
 350         Xrm_HandleError(self);
 351         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating streaming port failed. Return value: 0x%02X", 1U, result));
 352     }
 353 }
 354
 355 /*! \brief  Triggers the creation of a streaming data socket.
 356  *  \param  self    Instance pointer
 357  */
 358 void Xrm_CreateStreamSocket(CExtendedResourceManager *self)
 359 {
 360     Ucs_Return_t result;
 361     uint16_t stream_port_handle;
 362     UCS_XRM_CONST Ucs_Xrm_StrmSocket_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_StrmSocket_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 363     if(Xrm_IsDefaultCreatedPort(self, cfg_ptr->stream_port_obj_ptr) != false)
 364     {
 365         stream_port_handle = Xrm_CreatePortHandle(self,
 366                                                   UCS_XRM_PORT_TYPE_STRM,
 367                                                   ((UCS_XRM_CONST Ucs_Xrm_DefaultCreatedPort_t *)(UCS_XRM_CONST void*)(cfg_ptr->stream_port_obj_ptr))->index);
 368     }
 369     else
 370     {
 371         stream_port_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->stream_port_obj_ptr, NULL);
 372     }
 373     result = Inic_StreamSocketCreate(self->inic_ptr,
 374                                      stream_port_handle,
 375                                      cfg_ptr->direction,
 376                                      cfg_ptr->data_type,
 377                                      cfg_ptr->bandwidth,
 378                                      cfg_ptr->stream_pin_id,
 379                                      &self->obs.std_result_obs);
 380     if(result == UCS_RET_SUCCESS)
 381     {
 382         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating streaming data socket", 0U));
 383     }
 384     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 385     {
 386         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 387     }
 388     else
 389     {
 390         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 391         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_STRM_SOCKET;
 392         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 393                                                                                 self->current_job_ptr,
 394                                                                                 self->current_obj_pptr);
 395         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 396         self->report_result.details.int_result = result;
 397         Xrm_HandleError(self);
 398         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating streaming data socket failed. Return value: 0x%02X", 1U, result));
 399     }
 400 }
 401
 402 /*! \brief  Triggers the creation of a synchronous data connection.
 403  *  \param  self    Instance pointer
 404  */
 405 void Xrm_CreateSyncCon(CExtendedResourceManager *self)
 406 {
 407     UCS_XRM_CONST Ucs_Xrm_SyncCon_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_SyncCon_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 408     uint16_t in_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_in_obj_ptr, NULL);
 409     uint16_t out_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_out_obj_ptr, NULL);
 410     Ucs_Return_t result = Inic_SyncCreate(self->inic_ptr,
 411                                           in_socket_handle,
 412                                           out_socket_handle,
 413                                           false,
 414                                           cfg_ptr->mute_mode,
 415                                           cfg_ptr->offset,
 416                                           &self->obs.std_result_obs);
 417     if(result == UCS_RET_SUCCESS)
 418     {
 419         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating synchronous data connection", 0U));
 420     }
 421     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 422     {
 423         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 424     }
 425     else
 426     {
 427         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 428         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_SYNC_CON;
 429         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 430                                                                                 self->current_job_ptr,
 431                                                                                 self->current_obj_pptr);
 432         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 433         self->report_result.details.int_result = result;
 434         Xrm_HandleError(self);
 435         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating synchronous data connection failed. Return value: 0x%02X", 1U, result));
 436     }
 437 }
 438
 439 /*! \brief  Triggers the creation of a DiscreteFrame Isochronous streaming phase connection.
 440  *  \param  self    Instance pointer
 441  */
 442 void Xrm_CreateDfiPhaseCon(CExtendedResourceManager *self)
 443 {
 444     UCS_XRM_CONST Ucs_Xrm_DfiPhaseCon_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_DfiPhaseCon_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 445     uint16_t in_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_in_obj_ptr, NULL);
 446     uint16_t out_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_out_obj_ptr, NULL);
 447     Ucs_Return_t result = Inic_DfiPhaseCreate(self->inic_ptr,
 448                                               in_socket_handle,
 449                                               out_socket_handle,
 450                                               &self->obs.std_result_obs);
 451     if(result == UCS_RET_SUCCESS)
 452     {
 453         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating DFIPhase connection", 0U));
 454     }
 455     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 456     {
 457         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 458     }
 459     else
 460     {
 461         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 462         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_DFIPHASE_CON;
 463         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 464                                                                                 self->current_job_ptr,
 465                                                                                 self->current_obj_pptr);
 466         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 467         self->report_result.details.int_result = result;
 468         Xrm_HandleError(self);
 469         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating DFIPhase connection failed. Return value: 0x%02X", 1U, result));
 470     }
 471 }
 472
 473 /*! \brief  Triggers the creation of a combiner resource.
 474  *  \param  self    Instance pointer
 475  */
 476 void Xrm_CreateCombiner(CExtendedResourceManager *self)
 477 {
 478     UCS_XRM_CONST Ucs_Xrm_Combiner_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_Combiner_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 479     uint16_t port_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->port_socket_obj_ptr, NULL);
 480     Ucs_Return_t result = Inic_CombinerCreate(self->inic_ptr,
 481                                               port_socket_handle,
 482                                               cfg_ptr->most_port_handle,
 483                                               cfg_ptr->bytes_per_frame,
 484                                               &self->obs.std_result_obs);
 485     if(result == UCS_RET_SUCCESS)
 486     {
 487         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating combiner resource", 0U));
 488     }
 489     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 490     {
 491         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 492     }
 493     else
 494     {
 495         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 496         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_COMBINER;
 497         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 498                                                                                 self->current_job_ptr,
 499                                                                                 self->current_obj_pptr);
 500         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 501         self->report_result.details.int_result = result;
 502         Xrm_HandleError(self);
 503         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating combiner resource failed. Return value: 0x%02X", 1U, result));
 504     }
 505 }
 506
 507 /*! \brief  Triggers the creation of a splitter resource.
 508  *  \param  self    Instance pointer
 509  */
 510 void Xrm_CreateSplitter(CExtendedResourceManager *self)
 511 {
 512     UCS_XRM_CONST Ucs_Xrm_Splitter_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_Splitter_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 513     uint16_t socket_handle_in = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_in_obj_ptr, NULL);
 514     Ucs_Return_t result = Inic_SplitterCreate(self->inic_ptr,
 515                                               socket_handle_in,
 516                                               cfg_ptr->most_port_handle,
 517                                               cfg_ptr->bytes_per_frame,
 518                                               &self->obs.std_result_obs);
 519     if(result == UCS_RET_SUCCESS)
 520     {
 521         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating splitter resource", 0U));
 522     }
 523     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 524     {
 525         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 526     }
 527     else
 528     {
 529         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 530         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_SPLITTER;
 531         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 532                                                                                 self->current_job_ptr,
 533                                                                                 self->current_obj_pptr);
 534         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 535         self->report_result.details.int_result = result;
 536         Xrm_HandleError(self);
 537         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating splitter resource failed. Return value: 0x%02X", 1U, result));
 538     }
 539 }
 540
 541 /*! \brief  Triggers the creation of a A/V packetized isochronous streaming data connection.
 542  *  \param  self    Instance pointer
 543  */
 544 void Xrm_CreateAvpCon(CExtendedResourceManager *self)
 545 {
 546     UCS_XRM_CONST Ucs_Xrm_AvpCon_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_AvpCon_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 547     uint16_t in_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_in_obj_ptr, NULL);
 548     uint16_t out_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_out_obj_ptr, NULL);
 549     Ucs_Return_t result = Inic_AvpCreate(self->inic_ptr,
 550                                          in_socket_handle,
 551                                          out_socket_handle,
 552                                          cfg_ptr->isoc_packet_size,
 553                                          &self->obs.std_result_obs);
 554     if(result == UCS_RET_SUCCESS)
 555     {
 556         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating A/V packetized isochronous streaming data connection", 0U));
 557     }
 558     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 559     {
 560         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 561     }
 562     else
 563     {
 564         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 565         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_AVP_CON;
 566         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 567                                                                                 self->current_job_ptr,
 568                                                                                 self->current_obj_pptr);
 569         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 570         self->report_result.details.int_result = result;
 571         Xrm_HandleError(self);
 572         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating A/V packetized isochronous streaming data connection failed. Return value: 0x%02X", 1U, result));
 573     }
 574 }
 575
 576 /*! \brief  Triggers the creation of a Quality of Service IP streaming data connection.
 577  *  \param  self    Instance pointer
 578  */
 579 void Xrm_CreateQoSCon(CExtendedResourceManager *self)
 580 {
 581     UCS_XRM_CONST Ucs_Xrm_QoSCon_t *cfg_ptr = (UCS_XRM_CONST Ucs_Xrm_QoSCon_t *)(UCS_XRM_CONST void*)(*self->current_obj_pptr);
 582     uint16_t in_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_in_obj_ptr, NULL);
 583     uint16_t out_socket_handle = Xrm_GetResourceHandle(self, self->current_job_ptr, cfg_ptr->socket_out_obj_ptr, NULL);
 584     Ucs_Return_t result = Inic_QoSCreate(self->inic_ptr,
 585                                          in_socket_handle,
 586                                          out_socket_handle,
 587                                          &self->obs.std_result_obs);
 588     if(result == UCS_RET_SUCCESS)
 589     {
 590         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating QoS IP streaming data connection", 0U));
 591     }
 592     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 593     {
 594         Xrm_WaitForTxMsgObj(self, XRM_EVENT_PROCESS);
 595     }
 596     else
 597     {
 598         self->report_result.code = UCS_XRM_RES_ERR_BUILD;
 599         self->report_result.details.resource_type = UCS_XRM_RC_TYPE_QOS_CON;
 600         self->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self,
 601                                                                                 self->current_job_ptr,
 602                                                                                 self->current_obj_pptr);
 603         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 604         self->report_result.details.int_result = result;
 605         Xrm_HandleError(self);
 606         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start creating QoS IP streaming data connection failed. Return value: 0x%02X", 1U, result));
 607     }
 608 }
 609
 610 /*! \brief  Process the result of the INIC resource monitor.
 611  *  \param  self        Instance pointer
 612  *  \param  result_ptr  Reference to result data. Result must be casted into data type
 613  *                      Inic_StdResult_t.
 614  */
 615 void Xrm_ResourceMonitorCb(void *self, void *result_ptr)
 616 {
 617     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
 618     Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
 619
 620     if((result_ptr_->result.code == UCS_RES_SUCCESS) && (result_ptr_->data_info != NULL))
 621     {
 622         Ucs_Resource_MonitorState_t state = *((Ucs_Resource_MonitorState_t *)result_ptr_->data_info);
 623         if(state == UCS_INIC_RES_MON_STATE_ACT_REQ)
 624         {
 625             Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_REQ_INV_RES_LST);
 626         }
 627         else if((state == UCS_INIC_RES_MON_STATE_OK) && (self_->obs.check_unmute_fptr != NULL))
 628         {
 629             self_->obs.check_unmute_fptr(Inic_GetTargetAddress(self_->inic_ptr), self_->base_ptr->ucs_user_ptr);
 630         }
 631     }
 632 }
 633
 634 /*! \brief  Retrieves the list of invalid resources.
 635  *  \param  self    Instance pointer
 636  */
 637 void Xrm_RequestResourceList(CExtendedResourceManager *self)
 638 {
 639     if(Xrm_IsApiFree(self) != false)
 640     {
 641         Ucs_Return_t result;
 642         result = Inic_ResourceInvalidList_Get(self->inic_ptr,
 643                                                 &self->obs.resource_invalid_list_obs);
 644         if(result == UCS_RET_SUCCESS)
 645         {
 646             Xrm_ApiLocking(self, true);
 647         }
 648         else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 649         {
 650             Xrm_WaitForTxMsgObj(self, XRM_EVENT_REQ_INV_RES_LST);
 651         }
 652         else
 653         {
 654             self->report_result.code = UCS_XRM_RES_ERR_INV_LIST;
 655             self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 656             self->report_result.details.int_result = result;
 657             Srv_SetEvent(&self->xrm_srv, XRM_EVENT_ERROR);
 658             TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start requesting invalid resources failed. Return value: 0x%02X", 1U, result));
 659         }
 660     }
 661     else
 662     {
 663         Srv_SetEvent(&self->xrm_srv, XRM_EVENT_REQ_INV_RES_LST);
 664     }
 665 }
 666
 667 /*! \brief  Process the received list of invalid resources.
 668  *  \param  self        Instance pointer
 669  *  \param  result_ptr  Reference to result data. Result must be casted into data type
 670  *                      Inic_StdResult_t.
 671  */
 672 void Xrm_RequestResourceListResultCb(void *self, void *result_ptr)
 673 {
 674     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
 675     Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
 676
 677     if((result_ptr_->result.code == UCS_RES_SUCCESS) && (result_ptr_->data_info != NULL))
 678     {
 679         Inic_ResHandleList_t resource_handle_list = *((Inic_ResHandleList_t *)result_ptr_->data_info);
 680         if((resource_handle_list.res_handles != NULL) && (resource_handle_list.num_handles > 0U))
 681         {
 682             MISC_MEM_CPY(&self_->inv_resource_handle_list[0],
 683                          &resource_handle_list.res_handles[0],
 684                          (resource_handle_list.num_handles * sizeof(resource_handle_list.res_handles[0])));
 685         }
 686         self_->inv_resource_handle_list_size = resource_handle_list.num_handles;
 687         self_->inv_resource_handle_index     = 0U;
 688
 689         Xrmp_Foreach(self_->xrmp_ptr, &Xrm_SetCurrJobPtr, &resource_handle_list.res_handles[0], NULL, self);
 690         Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_DESTROY_INV_RES);
 691     }
 692     else
 693     {
 694         self_->report_result.code = UCS_XRM_RES_ERR_INV_LIST;
 695         if (result_ptr_->result.code == UCS_RES_ERR_TRANSMISSION)
 696         {
 697             self_->report_result.details.tx_result = *(Ucs_MsgTxStatus_t *)(result_ptr_->data_info);
 698             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TX;
 699         }
 700         else
 701         {
 702             self_->report_result.details.tx_result = UCS_MSG_STAT_OK;
 703             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TGT;
 704         }
 705
 706         self_->report_result.details.inic_result = result_ptr_->result;
 707         Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
 708         TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Request of invalid resources failed. Return value: 0x%02X", 1U, result_ptr_->result.code));
 709         TR_ERROR_INIC_RESULT(self_->base_ptr->ucs_user_ptr, "[XRM]", result_ptr_->result.info_ptr, result_ptr_->result.info_size);
 710     }
 711
 712     Xrm_ApiLocking(self_, false);
 713 }
 714
 715 /*! \brief  Triggers the destruction of INIC resources.
 716  *  \param  self        Instance pointer
 717  *  \param  result_fptr Result callback function pointer
 718  */
 719 void Xrm_DestroyResources(CExtendedResourceManager *self, Sobs_UpdateCb_t result_fptr)
 720 {
 721     Ucs_Return_t result;
 722     Inic_ResHandleList_t list;
 723     list.res_handles = &self->inv_resource_handle_list[self->inv_resource_handle_index];
 724     if (self->inv_resource_handle_list_size > MAX_INVALID_HANDLES_LIST)
 725     {
 726         list.num_handles = MAX_INVALID_HANDLES_LIST;
 727         self->curr_dest_resource_handle_size = list.num_handles;
 728     }
 729     else
 730     {
 731         list.num_handles = self->inv_resource_handle_list_size;
 732         self->curr_dest_resource_handle_size = list.num_handles;
 733         if(self->inv_resource_handle_list[(self->inv_resource_handle_index + self->inv_resource_handle_list_size) - 1U] == XRM_INVALID_RESOURCE_HANDLE)
 734         {
 735             list.num_handles--;
 736         }
 737     }
 738     Sobs_Ctor(&self->obs.resource_destroy_obs, self, result_fptr);
 739     result = Inic_ResourceDestroy(self->inic_ptr,
 740                                   list,
 741                                   &self->obs.resource_destroy_obs);
 742     if(result == UCS_RET_SUCCESS)
 743     {
 744         /* No error */
 745 #ifdef UCS_TR_INFO
 746         uint8_t i;
 747         TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "Destruction of invalid resource handles been successfully started:", 0U));
 748         for(i=0U; i<list.num_handles; i++)
 749         {
 750             TR_INFO((self->base_ptr->ucs_user_ptr, "[XRM]", "--> Handle: 0x%04X", 1U, list.res_handles[i]));
 751         }
 752 #endif
 753     }
 754     else if (result == UCS_RET_ERR_PARAM)
 755     {
 756         /* empty list */
 757         if ((list.num_handles == 0U) && (list.res_handles[0] == XRM_INVALID_RESOURCE_HANDLE))
 758         {
 759             self->inv_resource_handle_list_size = 0U;
 760             Srv_SetEvent(&self->xrm_srv, XRM_EVENT_RESET_RES_MONITOR);
 761         }
 762     }
 763     else if(result == UCS_RET_ERR_BUFFER_OVERFLOW)
 764     {
 765         Xrm_WaitForTxMsgObj(self, XRM_EVENT_DESTROY_INV_RES);
 766     }
 767     else
 768     {
 769         self->inv_resource_handle_list_size = 0U;
 770         self->report_result.code = UCS_XRM_RES_ERR_DESTROY;
 771         self->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 772         self->report_result.details.int_result = result;
 773         Srv_SetEvent(&self->xrm_srv, XRM_EVENT_ERROR);
 774         TR_ERROR((self->base_ptr->ucs_user_ptr, "[XRM]", "Start destroying invalid resources failed. Return value: 0x%02X", 1U, result));
 775     }
 776 }
 777
 778 /*! \brief  Resets the INIC's Resource Monitor.
 779  *  \param  self    Instance pointer
 780  */
 781 void Xrm_ResetResourceMonitor(CExtendedResourceManager *self)
 782 {
 783     Ucs_Return_t result = Inic_ResourceMonitor_Set(self->inic_ptr, UCS_INIC_RES_MON_CTRL_RESET);
 784     if(result == UCS_RET_SUCCESS)
 785     {
 786         Srv_SetEvent(&self->xrm_srv, XRM_EVENT_NOTIFY_AUTO_DEST_RES);
 787     }
 788     else
 789     {
 790         Xrm_WaitForTxMsgObj(self, XRM_EVENT_RESET_RES_MONITOR);
 791     }
 792 }
 793
 794
 795 /*! \brief  Handles the result of resource destructions.
 796  *  \param  self        Instance pointer
 797  *  \param  result_ptr  Reference to result data. Result must be casted into data type
 798  *                      Inic_StdResult_t.
 799  */
 800 void Xrm_DestroyResourcesResultCb(void *self, void *result_ptr)
 801 {
 802     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
 803     Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
 804     if(result_ptr_->result.code == UCS_RES_SUCCESS)
 805     {
 806         (void)Xrm_ReleaseResourceHandles(self_,
 807                                    NULL,
 808                                    &self_->inv_resource_handle_list[self_->inv_resource_handle_index],
 809                                    self_->curr_dest_resource_handle_size,
 810                                    XRM_INVALID_RESOURCE_HANDLE);
 811
 812         if (self_->inv_resource_handle_list_size >= self_->curr_dest_resource_handle_size)
 813         {
 814             self_->inv_resource_handle_list_size -= self_->curr_dest_resource_handle_size;
 815             if (self_->inv_resource_handle_list_size > 0U)
 816             {
 817                 self_->inv_resource_handle_index += self_->curr_dest_resource_handle_size;
 818                 Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_DESTROY_INV_RES);
 819             }
 820             else
 821             {
 822                 if(self_->inv_resource_handle_list[(self_->inv_resource_handle_index + self_->curr_dest_resource_handle_size) - 1U] != XRM_INVALID_RESOURCE_HANDLE)
 823                 {
 824                     Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_REQ_INV_RES_LST);
 825                 }
 826                 else
 827                 {
 828                     Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_RESET_RES_MONITOR);
 829                 }
 830                 TR_INFO((self_->base_ptr->ucs_user_ptr, "[XRM]", "INIC resources been successfully destroyed.", 0U));
 831             }
 832         }
 833         else
 834         {
 835             self_->inv_resource_handle_list_size = 0U;
 836             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 837             self_->report_result.details.tx_result = UCS_MSG_STAT_OK;
 838             self_->report_result.code = UCS_XRM_RES_ERR_DESTROY;
 839             self_->report_result.details.inic_result = result_ptr_->result;
 840             Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
 841             TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Destruction of invalid resources failed. Internal resources handles List is corrupted", 0U));
 842         }
 843     }
 844     else if(result_ptr_->result.code == UCS_RES_ERR_BUSY)
 845     {
 846         uint8_t stop_index;
 847         uint16_t failed_resource_handle;
 848         MISC_DECODE_WORD(&(failed_resource_handle), &(result_ptr_->result.info_ptr[3]));
 849         stop_index = Xrm_ReleaseResourceHandles(self_,
 850                                    NULL,
 851                                    &self_->inv_resource_handle_list[self_->inv_resource_handle_index],
 852                                    self_->curr_dest_resource_handle_size,
 853                                    failed_resource_handle);
 854
 855         if (stop_index > 0U)
 856         {
 857             self_->inv_resource_handle_index = stop_index;
 858             self_->inv_resource_handle_list_size -= stop_index;
 859         }
 860         Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_DESTROY_INV_RES);
 861     }
 862     else
 863     {
 864         self_->inv_resource_handle_list_size = 0U;
 865         if (result_ptr_->result.code == UCS_RES_ERR_TRANSMISSION)
 866         {
 867             self_->report_result.details.tx_result = *(Ucs_MsgTxStatus_t *)(result_ptr_->data_info);
 868             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TX;
 869         }
 870         else
 871         {
 872             self_->report_result.details.tx_result = UCS_MSG_STAT_OK;
 873             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TGT;
 874         }
 875         self_->report_result.code = UCS_XRM_RES_ERR_DESTROY;
 876         self_->report_result.details.inic_result = result_ptr_->result;
 877         Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
 878         TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Destruction of invalid resources failed. Return value: 0x%02X", 1U, result_ptr_->result.code));
 879         TR_ERROR_INIC_RESULT(self_->base_ptr->ucs_user_ptr, "[XRM]", result_ptr_->result.info_ptr, result_ptr_->result.info_size);
 880     }
 881 }
 882
 883 /*! \brief  Handles the result of resource destructions for all resources of a job.
 884  *  \param  self        Instance pointer
 885  *  \param  result_ptr  Reference to result data. Result must be casted into data type
 886  *                      Inic_StdResult_t.
 887  */
 888 void Xrm_DestroyJobResourcesResultCb(void *self, void *result_ptr)
 889 {
 890     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
 891     Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
 892     if(result_ptr_->result.code == UCS_RES_SUCCESS)
 893     {
 894         (void)Xrm_ReleaseResourceHandles(self_,
 895                                    self_->current_job_ptr,
 896                                    &self_->inv_resource_handle_list[self_->inv_resource_handle_index],
 897                                    self_->curr_dest_resource_handle_size,
 898                                    XRM_INVALID_RESOURCE_HANDLE);
 899
 900         if (self_->inv_resource_handle_list_size >= self_->curr_dest_resource_handle_size)
 901         {
 902             self_->inv_resource_handle_list_size -= self_->curr_dest_resource_handle_size;
 903             self_->inv_resource_handle_index = 0U;
 904             Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_RESUME_JOB_DESTRUCT);
 905             TR_INFO((self_->base_ptr->ucs_user_ptr, "[XRM]", "INIC resources been successfully destroyed.", 0U));
 906         }
 907         else
 908         {
 909             self_->inv_resource_handle_list_size = 0U;
 910             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_INT;
 911             self_->report_result.details.tx_result = UCS_MSG_STAT_OK;
 912             self_->report_result.code = UCS_XRM_RES_ERR_DESTROY;
 913             self_->report_result.details.inic_result = result_ptr_->result;
 914             Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
 915             TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Destruction of invalid resources failed. Internal resources handles List is corrupted", 0U));
 916         }
 917     }
 918     else if(result_ptr_->result.code == UCS_RES_ERR_BUSY)
 919     {
 920         uint16_t failed_handle;
 921         MISC_DECODE_WORD(&(failed_handle), &(result_ptr_->result.info_ptr[3]));
 922         (void)Xrm_ReleaseResourceHandles(self_,
 923                                    NULL,
 924                                    &self_->inv_resource_handle_list[self_->inv_resource_handle_index],
 925                                    self_->curr_dest_resource_handle_size,
 926                                    failed_handle);
 927
 928         Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_RESUME_JOB_DESTRUCT);
 929     }
 930     else
 931     {
 932         self_->inv_resource_handle_list_size = 0U;
 933         if (result_ptr_->result.code == UCS_RES_ERR_TRANSMISSION)
 934         {
 935             self_->report_result.details.tx_result = *(Ucs_MsgTxStatus_t *)(result_ptr_->data_info);
 936             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TX;
 937         }
 938         else
 939         {
 940             self_->report_result.details.tx_result = UCS_MSG_STAT_OK;
 941             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TGT;
 942         }
 943
 944         self_->report_result.code = UCS_XRM_RES_ERR_DESTROY;
 945         self_->report_result.details.inic_result = result_ptr_->result;
 946         Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
 947         TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Destruction of invalid resources failed. Return value: 0x%02X", 1U, result_ptr_->result.code));
 948         TR_ERROR_INIC_RESULT(self_->base_ptr->ucs_user_ptr, "[XRM]", result_ptr_->result.info_ptr, result_ptr_->result.info_size);
 949     }
 950 }
 951
 952 /*! \brief  Handles the result of "create port", "create socket" and "create connection" operations.
 953  *  \param  self        Instance pointer
 954  *  \param  result_ptr  Reference to result data. Result must be casted into data type
 955  *                      Inic_StdResult_t.
 956  */
 957 void Xrm_StdResultCb(void *self, void *result_ptr)
 958 {
 959     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
 960     Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
 961
 962     if((result_ptr_->result.code == UCS_RES_SUCCESS) && (result_ptr_->data_info != NULL))
 963     {
 964         uint16_t resource_handle = 0U;
 965         if(*(UCS_XRM_CONST Ucs_Xrm_ResourceType_t *)(UCS_XRM_CONST void*)(*self_->current_obj_pptr) == UCS_XRM_RC_TYPE_MOST_SOCKET)
 966         {
 967             Inic_MostSocketCreate_Result_t res_ack = {0U, 0U};
 968             res_ack = *((Inic_MostSocketCreate_Result_t *)result_ptr_->data_info);
 969             resource_handle = res_ack.most_socket_handle;
 970             self_->current_job_ptr->connection_label = res_ack.conn_label;
 971         }
 972         else
 973         {
 974             resource_handle = *((uint16_t *)result_ptr_->data_info);
 975         }
 976
 977         if(Xrm_StoreResourceHandle(self_, resource_handle, self_->current_job_ptr, *self_->current_obj_pptr) != false)
 978         {
 979             if (self_->res_debugging_fptr != NULL)
 980             {
 981                 self_->res_debugging_fptr(*(UCS_XRM_CONST Ucs_Xrm_ResourceType_t *)(UCS_XRM_CONST void*)(*self_->current_obj_pptr), *self_->current_obj_pptr, UCS_XRM_INFOS_BUILT,
 982                                             self_->current_job_ptr->user_arg, self_->base_ptr->ucs_user_ptr);
 983             }
 984
 985             self_->current_obj_pptr++;
 986             Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_PROCESS);
 987             TR_INFO((self_->base_ptr->ucs_user_ptr, "[XRM]", "Resource has been successfully created. Handle: 0x%04X", 1U, resource_handle));
 988         }
 989         else
 990         {
 991             self_->report_result.code = UCS_XRM_RES_ERR_CONFIG;
 992             Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
 993             TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Misconfiguration. Resource handle list is too small.", 0U));
 994         }
 995     }
 996     else
 997     {
 998         self_->current_job_ptr->valid = false;
 999
1000         if (result_ptr_->result.code == UCS_RES_ERR_TRANSMISSION)
1001         {
1002             self_->report_result.details.tx_result = *(Ucs_MsgTxStatus_t *)(result_ptr_->data_info);
1003             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TX;
1004         }
1005         else
1006         {
1007             self_->report_result.details.tx_result = UCS_MSG_STAT_OK;
1008             self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TGT;
1009         }
1010
1011         self_->report_result.code = UCS_XRM_RES_ERR_BUILD;
1012         self_->report_result.details.resource_type = *(UCS_XRM_CONST Ucs_Xrm_ResourceType_t *)(UCS_XRM_CONST void*)(*self_->current_obj_pptr);
1013         self_->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self_,
1014                                                                                  self_->current_job_ptr,
1015                                                                                  self_->current_obj_pptr);
1016         self_->report_result.details.inic_result = result_ptr_->result;
1017         Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
1018
1019         if (self_->res_debugging_fptr != NULL)
1020         {
1021             self_->res_debugging_fptr(*(UCS_XRM_CONST Ucs_Xrm_ResourceType_t *)(UCS_XRM_CONST void*)(*self_->current_obj_pptr),
1022                                   *self_->current_obj_pptr, UCS_XRM_INFOS_ERR_BUILT, self_->current_job_ptr->user_arg, self_->base_ptr->ucs_user_ptr);
1023         }
1024         TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Creation of resource failed. Result code: 0x%02X", 1U, result_ptr_->result.code));
1025         if (result_ptr_->result.info_ptr != NULL)
1026         {
1027             TR_ERROR_INIC_RESULT(self_->base_ptr->ucs_user_ptr, "[XRM]", result_ptr_->result.info_ptr, result_ptr_->result.info_size);
1028         }
1029     }
1030 }
1031
1032 /*! \brief  Handles the result of "device.sync" operations.
1033  *  \param  self        Instance pointer
1034  *  \param  result      RSM result
1035  */
1036 void Xrm_RmtDevAttachResultCb(void *self, Rsm_Result_t result)
1037 {
1038     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
1039     if (result.code == RSM_RES_SUCCESS)
1040     {
1041         Srv_SetEvent(&self_->xrm_srv, self_->queued_event_mask);
1042         self_->queued_event_mask = 0U;
1043         TR_INFO((self_->base_ptr->ucs_user_ptr, "[XRM]", "Remote device has been successfully synchronized.", 0U));
1044     }
1045     else
1046     {
1047         /* In case of StreamingConfig, simulate an error configuration since there
1048          * is currently no possibility to signal SyncLost
1049          */
1050         if ((self_->queued_event_mask  == XRM_EVENT_STREAMPORT_CONFIG_SET) ||
1051             (self_->queued_event_mask  == XRM_EVENT_STREAMPORT_CONFIG_GET))
1052         {
1053             Inic_StdResult_t sim_inic_res;
1054             sim_inic_res.result.code = result.details.inic_result.code;
1055             sim_inic_res.result.info_ptr = NULL;
1056             sim_inic_res.result.info_size = 0U;
1057             sim_inic_res.data_info = NULL;
1058
1059             self_->queued_event_mask = 0U;
1060             /* Force a Notification of the Streaming observer */
1061             self_->obs.stream_port_config_fptr = self_->current_streamport_config.result_fptr;
1062             self_->obs.stream_port_config_obs.update_fptr(self, &sim_inic_res);
1063         }
1064         else
1065         {
1066             if (result.details.inic_result.code == UCS_RES_ERR_TRANSMISSION)
1067             {
1068                 self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TX;
1069             }
1070             else
1071             {
1072                 self_->report_result.details.result_type = UCS_XRM_RESULT_TYPE_TGT;
1073             }
1074             self_->report_result.code = UCS_XRM_RES_ERR_SYNC;
1075             self_->report_result.details.inic_result.code = result.details.inic_result.code;
1076             self_->report_result.details.inic_result.info_ptr  = result.details.inic_result.info_ptr;
1077             self_->report_result.details.inic_result.info_size = result.details.inic_result.info_size;
1078             self_->report_result.details.resource_type = *(UCS_XRM_CONST Ucs_Xrm_ResourceType_t *)(UCS_XRM_CONST void*)(*self_->current_obj_pptr);
1079             self_->report_result.details.resource_index = Xrm_GetResourceObjectIndex(self_,
1080                                                                                         self_->current_job_ptr,
1081                                                                                         self_->current_obj_pptr);
1082             self_->report_result.details.tx_result = (Ucs_MsgTxStatus_t)result.details.tx_result;
1083
1084             self_->queued_event_mask = 0U;
1085             Srv_SetEvent(&self_->xrm_srv, XRM_EVENT_ERROR);
1086             TR_ERROR((self_->base_ptr->ucs_user_ptr, "[XRM]", "Synchronization to the remote device failed. Result code: 0x%02X", 1U, result));
1087         }
1088     }
1089 }
1090
1091
1092 /*------------------------------------------------------------------------------------------------*/
1093 /* Implementation of class CExtendedResourceManager (INIC Resource Management API)                */
1094 /*------------------------------------------------------------------------------------------------*/
1095 /*! \brief   This function is used to configure a Streaming Port.
1096  *  \param   self               Instance pointer
1097  *  \param   index              Streaming Port instance.
1098  *  \param   op_mode            Operation mode of the Streaming Port.
1099  *  \param   port_option        Direction of the physical pins of the indexed Streaming Port.
1100  *  \param   clock_mode         Configuration of the FSY/SCK signals.
1101  *  \param   clock_data_delay   Configuration of the FSY/SCK signals for Generic Streaming.
1102  *  \param   result_fptr        Required result callback
1103  *  \return  Possible return values are shown in the table below.
1104  *           Value                       | Description
1105  *           --------------------------- | ------------------------------------
1106  *           UCS_RET_SUCCESS             | No error
1107  *           UCS_RET_ERR_PARAM           | Invalid callback pointer
1108  *           UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available
1109  *           UCS_RET_ERR_API_LOCKED      | API is currently locked
1110  */
1111 Ucs_Return_t Xrm_Stream_SetPortConfig(CExtendedResourceManager *self,
1112                                       uint8_t index,
1113                                       Ucs_Stream_PortOpMode_t op_mode,
1114                                       Ucs_Stream_PortOption_t port_option,
1115                                       Ucs_Stream_PortClockMode_t clock_mode,
1116                                       Ucs_Stream_PortClockDataDelay_t clock_data_delay,
1117                                       Ucs_Xrm_Stream_PortCfgResCb_t result_fptr)
1118 {
1119     Ucs_Return_t ret_val = UCS_RET_ERR_API_LOCKED;
1120
1121     if ((self != NULL)  && (result_fptr != NULL) )
1122     {
1123         if(Xrm_IsApiFree(self) != false)
1124         {
1125             Xrm_ApiLocking(self, true);
1126
1127             self->current_streamport_config.index = index;
1128             self->current_streamport_config.op_mode = op_mode;
1129             self->current_streamport_config.port_option = port_option;
1130             self->current_streamport_config.clock_mode = clock_mode;
1131             self->current_streamport_config.clock_data_delay = clock_data_delay;
1132             self->current_streamport_config.result_fptr = result_fptr;
1133
1134             ret_val = Xrm_SetStreamPortConfiguration(self);
1135         }
1136     }
1137     else
1138     {
1139         ret_val = UCS_RET_ERR_PARAM;
1140     }
1141
1142     return ret_val;
1143 }
1144
1145 /*! \brief   This function is used to configure a Streaming Port.
1146  *  \param   self               Instance pointer
1147  *  \return  Possible return values are shown in the table below.
1148  *           Value                       | Description
1149  *           --------------------------- | ------------------------------------
1150  *           UCS_RET_SUCCESS             | No error
1151  *           UCS_RET_ERR_PARAM           | Invalid callback pointer
1152  *           UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available
1153  *           UCS_RET_ERR_API_LOCKED      | API is currently locked
1154  */
1155 Ucs_Return_t Xrm_SetStreamPortConfiguration (CExtendedResourceManager *self)
1156 {
1157     Ucs_Return_t ret_val = UCS_RET_ERR_NOT_INITIALIZED;
1158
1159     if (Xrm_IsCurrDeviceAlreadyAttached(self) == false)
1160     {
1161         ret_val = Xrm_RemoteDeviceAttach(self, XRM_EVENT_STREAMPORT_CONFIG_SET);
1162     }
1163     else
1164     {
1165         ret_val = Inic_StreamPortConfig_SetGet(self->inic_ptr,
1166                                                 self->current_streamport_config.index,
1167                                                 self->current_streamport_config.op_mode,
1168                                                 self->current_streamport_config.port_option,
1169                                                 self->current_streamport_config.clock_mode,
1170                                                 self->current_streamport_config.clock_data_delay,
1171                                                 &self->obs.stream_port_config_obs);
1172         if(ret_val == UCS_RET_SUCCESS)
1173         {
1174             self->obs.stream_port_config_fptr = self->current_streamport_config.result_fptr;
1175         }
1176         else if(ret_val == UCS_RET_ERR_BUFFER_OVERFLOW)
1177         {
1178             Xrm_WaitForTxMsgObj(self, XRM_EVENT_STREAMPORT_CONFIG_SET);
1179         }
1180         else if (ret_val == UCS_RET_ERR_API_LOCKED)
1181         {
1182             Xrm_ApiLocking(self, false);
1183         }
1184     }
1185
1186     return ret_val;
1187 }
1188
1189 /*! \brief   This function requests the configurations of a Streaming Port.
1190  *  \param   self           Instance pointer
1191  *  \param   index          Streaming Port instance.
1192  *  \param   result_fptr    Required result callback
1193  *  \return  Possible return values are shown in the table below.
1194  *           Value                       | Description
1195  *           --------------------------- | ----------------------------------------------
1196  *           UCS_RET_SUCCESS             | No error
1197  *           UCS_RET_ERR_PARAM           | At least one parameter is wrong
1198  *           UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available
1199  *           UCS_RET_ERR_API_LOCKED      | API is currently locked
1200  *           UCS_RET_ERR_NOT_AVAILABLE   | Associated device not found
1201  */
1202 Ucs_Return_t Xrm_Stream_GetPortConfig(CExtendedResourceManager *self,
1203                                       uint8_t index,
1204                                       Ucs_Xrm_Stream_PortCfgResCb_t result_fptr)
1205 {
1206     Ucs_Return_t ret_val = UCS_RET_ERR_API_LOCKED;
1207
1208     if((self != NULL) && (result_fptr != NULL) )
1209     {
1210         if(Xrm_IsApiFree(self) != false)
1211         {
1212             Xrm_ApiLocking(self, true);
1213
1214             self->current_streamport_config.index = index;
1215             self->current_streamport_config.result_fptr = result_fptr;
1216
1217             ret_val = Xrm_GetStreamPortConfiguration(self);
1218             if (ret_val == UCS_RET_ERR_API_LOCKED)
1219             {
1220                 /* from another process locked */
1221                 Xrm_ApiLocking(self, false);
1222             }
1223         }
1224     }
1225     else
1226     {
1227         ret_val = UCS_RET_ERR_PARAM;
1228     }
1229
1230     return ret_val;
1231 }
1232
1233 /*! \brief   This function is used to configure a Streaming Port.
1234  *  \param   self               Instance pointer
1235  *  \return  Possible return values are shown in the table below.
1236  *           Value                       | Description
1237  *           --------------------------- | ------------------------------------
1238  *           UCS_RET_SUCCESS             | No error
1239  *           UCS_RET_ERR_PARAM           | Invalid callback pointer
1240  *           UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available
1241  */
1242 Ucs_Return_t Xrm_GetStreamPortConfiguration (CExtendedResourceManager *self)
1243 {
1244     Ucs_Return_t ret_val = UCS_RET_ERR_NOT_INITIALIZED;
1245
1246     if (Xrm_IsCurrDeviceAlreadyAttached(self) == false)
1247     {
1248         ret_val = Xrm_RemoteDeviceAttach(self, XRM_EVENT_STREAMPORT_CONFIG_GET);
1249     }
1250     else
1251     {
1252         ret_val = Inic_StreamPortConfig_Get(self->inic_ptr,
1253                                             self->current_streamport_config.index,
1254                                             &self->obs.stream_port_config_obs);
1255         if(ret_val == UCS_RET_SUCCESS)
1256         {
1257             self->obs.stream_port_config_fptr = self->current_streamport_config.result_fptr;
1258         }
1259         else if(ret_val == UCS_RET_ERR_BUFFER_OVERFLOW)
1260         {
1261             Xrm_WaitForTxMsgObj(self, XRM_EVENT_STREAMPORT_CONFIG_GET);
1262         }
1263     }
1264
1265     return ret_val;
1266 }
1267
1268 /*! \brief Observer callback for Inic_StreamPortConfig_Get(). Casts the result and invokes
1269  *         the application result callback.
1270  *  \param self         Instance pointer
1271  *  \param result_ptr   Reference to result
1272  */
1273 void Xrm_Stream_PortConfigResult(void *self, void *result_ptr)
1274 {
1275     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
1276     Inic_StreamPortConfigStatus_t status;
1277     Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
1278     Ucs_StdResult_t res = result_ptr_->result;
1279
1280     if(self_->obs.stream_port_config_fptr != NULL)
1281     {
1282         if((result_ptr_->result.code == UCS_RES_SUCCESS) && (result_ptr_->data_info != NULL))
1283         {
1284             status = *((Inic_StreamPortConfigStatus_t *)result_ptr_->data_info);
1285         }
1286         else
1287         {
1288             /* Fill param callback function with default (dummy) values */
1289             status.index            = 0x00U;
1290             status.op_mode          = UCS_STREAM_PORT_OP_MODE_GENERIC;
1291             status.port_option      = UCS_STREAM_PORT_OPT_IN_OUT;
1292             status.clock_mode       = UCS_STREAM_PORT_CLK_MODE_OUTPUT;
1293             status.clock_data_delay = UCS_STREAM_PORT_CLK_DLY_NONE;
1294         }
1295         self_->obs.stream_port_config_fptr(Inic_GetTargetAddress(self_->inic_ptr),
1296                                            status.index,
1297                                            status.op_mode,
1298                                            status.port_option,
1299                                            status.clock_mode,
1300                                            status.clock_data_delay,
1301                                            res,
1302                                            self_->base_ptr->ucs_user_ptr);
1303     }
1304
1305     Xrm_ApiLocking(self_, false);
1306 }
1307
1308 /*! \brief   Enables or disables a specific MOST Network Port.
1309  *  \param   self               Instance pointer
1310  *  \param   most_port_handle   Port resource handle.
1311  *  \param   enabled            State of the MOST Port.
1312  *  \param   result_fptr        Optional result callback.
1313  *  \return  Possible return values are shown in the table below.
1314  *           Value                       | Description
1315  *           --------------------------- | ------------------------------------
1316  *           UCS_RET_SUCCESS             | No error
1317  *           UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available
1318  *           UCS_RET_ERR_API_LOCKED      | API is currently locked
1319  *           UCS_RET_ERR_NOT_INITIALIZED | UNICENS is not initialized
1320  */
1321 Ucs_Return_t Xrm_Most_EnablePort(CExtendedResourceManager *self,
1322                                  uint16_t most_port_handle,
1323                                  bool enabled,
1324                                  Ucs_StdResultCb_t result_fptr)
1325 {
1326     Ucs_Return_t ret_val = UCS_RET_ERR_NOT_INITIALIZED;
1327
1328     if(Xrm_IsApiFree(self) != false)
1329     {
1330         ret_val = Inic_MostPortEnable(self->inic_ptr,
1331                                         most_port_handle,
1332                                         enabled,
1333                                         &self->obs.most_port_enable_obs);
1334         if(ret_val == UCS_RET_SUCCESS)
1335         {
1336             self->obs.most_port_enable_fptr = result_fptr;
1337         }
1338     }
1339
1340     return ret_val;
1341 }
1342
1343 /*! \brief   Enables full streaming for a specific MOST Network Port.
1344  *  \param   self               Instance pointer
1345  *  \param   most_port_handle   Port resource handle.
1346  *  \param   enabled            State of the MOST Port related to full streaming.
1347  *  \param   result_fptr        Optional result callback.
1348  *  \return  Possible return values are shown in the table below.
1349  *           Value                       | Description
1350  *           --------------------------- | ------------------------------------
1351  *           UCS_RET_SUCCESS             | No error
1352  *           UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available
1353  *           UCS_RET_ERR_API_LOCKED      | API is currently locked
1354  *           UCS_RET_ERR_NOT_INITIALIZED | UNICENS is not initialized
1355  */
1356 Ucs_Return_t Xrm_Most_PortEnFullStr(CExtendedResourceManager *self,
1357                                     uint16_t most_port_handle,
1358                                     bool enabled,
1359                                     Ucs_StdResultCb_t result_fptr)
1360 {
1361     Ucs_Return_t ret_val = UCS_RET_ERR_NOT_INITIALIZED;
1362
1363     if(Xrm_IsApiFree(self) != false)
1364     {
1365         ret_val = Inic_MostPortEnFullStr(self->inic_ptr,
1366                                             most_port_handle,
1367                                             enabled,
1368                                             &self->obs.most_port_en_full_str_obs);
1369         if(ret_val == UCS_RET_SUCCESS)
1370         {
1371             self->obs.most_port_en_full_str_fptr = result_fptr;
1372         }
1373     }
1374
1375     return ret_val;
1376 }
1377
1378 /*! \brief Observer callback for Inic_MostPortEnable(). Casts the result and invokes
1379  *         the application result callback.
1380  *  \param self         Instance pointer
1381  *  \param result_ptr   Reference to result
1382  */
1383 void Xrm_Most_PortEnableResult(void *self, void *result_ptr)
1384 {
1385     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
1386     if(self_->obs.most_port_enable_fptr != NULL)
1387     {
1388         Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
1389         self_->obs.most_port_enable_fptr(result_ptr_->result, self_->base_ptr->ucs_user_ptr);
1390     }
1391 }
1392
1393 /*! \brief Observer callback for Inic_MostPortEnFullStr(). Casts the result and invokes
1394  *         the application result callback.
1395  *  \param self         Instance pointer
1396  *  \param result_ptr   Reference to result
1397  */
1398 void Xrm_Most_PortEnFullStrResult(void *self, void *result_ptr)
1399 {
1400     CExtendedResourceManager *self_ = (CExtendedResourceManager *)self;
1401     if(self_->obs.most_port_en_full_str_fptr != NULL)
1402     {
1403         Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr;
1404         self_->obs.most_port_en_full_str_fptr(result_ptr_->result, self_->base_ptr->ucs_user_ptr);
1405     }
1406 }
1407
1408 /*! \brief  Sets the current job pointer of the CExtendedResourceManager instance.
1409  *  \param  resrc_ptr       Reference to the resource handle list to be looked for.
1410  *  \param  resrc_handle    Reference to the resource handle to be found.
1411  *  \param  job_ptr         Reference to the job to be looked for.
1412  *  \param  user_arg        Reference to a user argument.
1413  *  \return \c false to continue the for-each-loop of the resources list table, otherwise \c true
1414  */
1415 bool Xrm_SetCurrJobPtr(void *resrc_ptr, void *resrc_handle, void *job_ptr, void * user_arg)
1416 {
1417     bool ret_val = false;
1418     Xrm_ResourceHandleListItem_t * resrc_ptr_ = (Xrm_ResourceHandleListItem_t *)resrc_ptr;
1419     uint16_t * resrc_handle_ = (uint16_t *)resrc_handle;
1420     CExtendedResourceManager *self = (CExtendedResourceManager *)user_arg;
1421
1422     MISC_UNUSED(job_ptr);
1423
1424     if ((resrc_ptr_->resource_handle == *resrc_handle_) &&
1425         (*resrc_handle_ != XRM_INVALID_RESOURCE_HANDLE) &&
1426         (Dl_IsNodeInList(&self->job_list, &resrc_ptr_->job_ptr->node)))
1427     {
1428         self->current_job_ptr = resrc_ptr_->job_ptr;
1429         ret_val = true;
1430     }
1431
1432     return ret_val;
1433 }
1434
1435 /*!
1436  * @}
1437  * \endcond
1438  */
1439
1440 /*------------------------------------------------------------------------------------------------*/
1441 /* End of file                                                                                    */
1442 /*------------------------------------------------------------------------------------------------*/
1443