path: root/ucs2-lib/src/ucs_inic_res.c

/*------------------------------------------------------------------------------------------------*/
/* UNICENS V2.1.0-3491                                                                            */
/* Copyright (c) 2017 Microchip Technology Germany II GmbH & Co. KG.                              */
/*                                                                                                */
/* This program is free software: you can redistribute it and/or modify                           */
/* it under the terms of the GNU General Public License as published by                           */
/* the Free Software Foundation, either version 2 of the License, or                              */
/* (at your option) any later version.                                                            */
/*                                                                                                */
/* This program is distributed in the hope that it will be useful,                                */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of                                 */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                  */
/* GNU General Public License for more details.                                                   */
/*                                                                                                */
/* You should have received a copy of the GNU General Public License                              */
/* along with this program.  If not, see <http://www.gnu.org/licenses/>.                          */
/*                                                                                                */
/* You may also obtain this software under a propriety license from Microchip.                    */
/* Please contact Microchip for further information.                                              */
/*------------------------------------------------------------------------------------------------*/

/*!
 * \file
 * \brief   Implementation of FBlock INIC (resource management parts of INIC management)
 * \details Contains the resource management parts of INIC management
 *
 * \cond UCS_INTERNAL_DOC
 * \addtogroup G_INIC
 * @{
 */

/*------------------------------------------------------------------------------------------------*/
/* Includes                                                                                       */
/*------------------------------------------------------------------------------------------------*/
#include "ucs_misc.h"
#include "ucs_ret_pb.h"
#include "ucs_inic.h"
#include "ucs_base.h"

/*------------------------------------------------------------------------------------------------*/
/* Internal macros                                                                                */
/*------------------------------------------------------------------------------------------------*/
/*! \brief API locking Bitmask for all INIC create methods. */
#define INIC_API_CREATE_CLASS               0x0001U
/*! \brief API locking Bitmask of method Inic_ResourceDestroy(). */
#define INIC_API_RESOURCE_DESTROY           0x0002U
/*! \brief API locking Bitmask of method Inic_ResourceInvalidList_Get(). */
#define INIC_API_RESOURCE_INVAL_LIST        0x0004U
/*! \brief API locking Bitmask of method Inic_Notification_Set(). */
#define INIC_API_NOTIFICATION               0x0008U
/*! \brief API locking Bitmask of method Inic_StreamPortConfig_Get(). */
#define INIC_API_STREAM_PORT_CONFIG         0x0010U
/*! \brief API locking Bitmask of method Inic_SyncMute(). */
#define INIC_API_SYNC_MUTE                  0x0020U
/*! \brief API locking Bitmask of method Inic_SyncDemute(). */
#define INIC_API_SYNC_DEMUTE                0x0040U
/*! \brief API locking Bitmask of method Inic_MostPortEnable(). */
#define INIC_API_MOST_PORT_ENABLE           0x0080U
/*! \brief API locking Bitmask of method Inic_MostPortEnFullStr(). */
#define INIC_API_MOST_PORT_EN_FULL_STR      0x0100U
/*! \brief API locking Bitmask of method Inic_GpioPortPinMode_SetGet(). */
#define INIC_API_GPIO_PIN_MODE              0x0200U
/*! \brief API locking Bitmask of method Inic_GpioPortPinState_SetGet(). */
#define INIC_API_GPIO_PIN_STATE             0x0400U
/*! \brief API locking Bitmask of methods Inic_I2cPortRead_StartResultAck() and Inic_I2cPortWrite_StartResultAck(). */
#define INIC_API_I2C_PORT_WR                0x0800U
/*! \brief Bitmask for API method Inic_DeviceSync() used by API locking manager */
#define INIC_API_DEVICE_SYNC                0x1000U

/*------------------------------------------------------------------------------------------------*/
/* Internal prototypes                                                                            */
/*------------------------------------------------------------------------------------------------*/
static void Inic_HandleResApiTimeout(void *self, void *method_mask_ptr);
static void Inic_ResMsgTxStatusCb(void *self, Msg_MostTel_t *tel_ptr, Ucs_MsgTxStatus_t status);

/*------------------------------------------------------------------------------------------------*/
/* Implementation                                                                                 */
/*------------------------------------------------------------------------------------------------*/
/*! \brief Initialization function of the INIC Resource Management part. Called by Inic_Ctor().
 *  \param self    Instance pointer
 */
void Inic_InitResourceManagement(CInic *self)
{
    Sobs_Ctor(&self->lock.res_observer, self, &Inic_HandleResApiTimeout);
    Al_Ctor(&self->lock.res_api, &self->lock.res_observer, self->base_ptr->ucs_user_ptr);
    Alm_RegisterApi(&self->base_ptr->alm, &self->lock.res_api);

    /* initializes the gpio report time status */
    self->gpio_rt_status.first_report = true;
}

/*! \brief Handles an API timeout
 *  \param self             Instance pointer
 *  \param method_mask_ptr  Bitmask to signal which API method has caused the timeout
 */
static void Inic_HandleResApiTimeout(void *self, void *method_mask_ptr)
{
    CInic *self_ = (CInic *)self;
    Alm_ModuleMask_t method_mask = *((Alm_ModuleMask_t *)method_mask_ptr);
    Inic_StdResult_t res_data;

    res_data.data_info       = NULL;
    res_data.result.code     = UCS_RES_ERR_TIMEOUT;
    res_data.result.info_ptr = NULL;

    switch(method_mask)
    {
        case INIC_API_CREATE_CLASS:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for INIC create method.", 0U));
            break;
        case INIC_API_RESOURCE_DESTROY:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_RESOURCE_DESTROY], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_ResourceDestroy().", 0U));
            break;
        case INIC_API_RESOURCE_INVAL_LIST:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_RESOURCE_INVAL_LIST], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_ResourceInvalidList_Get().", 0U));
            break;
        case INIC_API_NOTIFICATION:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_NOTIFICATION], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_Notification_Get().", 0U));
            break;
        case INIC_API_STREAM_PORT_CONFIG:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_STREAM_PORT_CONFIG], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_StreamPortConfig_Get().", 0U));
            break;
        case INIC_API_SYNC_MUTE:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_SYNC_MUTE], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_SyncMute().", 0U));
            break;
        case INIC_API_SYNC_DEMUTE:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_SYNC_DEMUTE], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_SyncDemute().", 0U));
            break;
        case INIC_API_MOST_PORT_ENABLE:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_MOST_PORT_ENABLE], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_MostPortEnable().", 0U));
            break;
        case INIC_API_MOST_PORT_EN_FULL_STR:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_MOST_PORT_EN_FULL_STR], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_MostPortEnFullStr().", 0U));
            break;
        case INIC_API_GPIO_PIN_MODE:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_GPIO_PIN_MODE], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_GpioPortPinMode_SetGet().", 0U));
            break;
        case INIC_API_GPIO_PIN_STATE:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_GPIO_PIN_STATE], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_GpioPortPinState_SetGet().", 0U));
            break;
        case INIC_API_DEVICE_SYNC:
            Ssub_Notify(&self_->ssubs[INIC_SSUB_DEVICE_SYNC], &res_data, true);
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "API locking timeout occurred for method Inic_DeviceSync_StartResult().", 0U));
            break;
        default:
            TR_ERROR((self_->base_ptr->ucs_user_ptr, "[INIC_RES]", "Unknown API locking bitmask detected. Mask: 0x%02X", 1U, method_mask));
            break;
    }
}

/*! \brief Add an observer to the ResourceMonitor subject
 *  \param self     Instance of CInic
 *  \param obs_ptr  Pointer to observer to be informed
 */
void Inic_AddObsrvResMonitor(CInic *self, CObserver *obs_ptr)
{
    (void)Sub_AddObserver(&self->subs[INIC_SUB_RES_MONITOR], obs_ptr);
}

/*! \brief Delete an observer from the ResourceMonitor subject
 *  \param self     Instance of CInic
 *  \param obs_ptr  Pointer to observer to be informed
 */
void Inic_DelObsrvResMonitor(CInic *self, CObserver *obs_ptr)
{
    (void)Sub_RemoveObserver(&self->subs[INIC_SUB_RES_MONITOR], obs_ptr);
}

/*! \brief Add an observer to the MOSTPortStatus subject
 *  \param self     Instance of CInic
 *  \param obs_ptr  Pointer to observer to be informed
 */
void Inic_AddObsrvMostPortStatus(CInic *self, CObserver *obs_ptr)
{
    if (Sub_AddObserver(&self->subs[INIC_SUB_MOST_PORT_STATUS], obs_ptr) != SUB_UNKNOWN_OBSERVER)
    {
        Sub_Notify(&self->subs[INIC_SUB_MOST_PORT_STATUS], &self->most_port_status);
    }
}

/*! \brief Delete an observer from the MOSTPortStatus subject
 *  \param self     Instance of CInic
 *  \param obs_ptr  Pointer to observer to be informed
 */
void Inic_DelObsrvMostPortStatus(CInic *self, CObserver *obs_ptr)
{
    (void)Sub_RemoveObserver(&self->subs[INIC_SUB_MOST_PORT_STATUS], obs_ptr);
}

/*! \brief Add an observer to the GpioTriggerEvent subject
 *  \param self     Instance of CInic
 *  \param obs_ptr  Pointer to observer to be informed
 */
void Inic_AddObsrvGpioTriggerEvent(CInic *self, CObserver *obs_ptr)
{
    (void)Sub_AddObserver(&self->subs[INIC_SUB_GPIO_TRIGGER_EVENT], obs_ptr);
}

/*! \brief Removes an observer from the GpioTriggerEvent subject
 *  \param self     Instance of CInic
 *  \param obs_ptr  Pointer to observer to be informed
 */
void Inic_DelObsrvGpioTriggerEvent(CInic *self, CObserver *obs_ptr)
{
    (void)Sub_RemoveObserver(&self->subs[INIC_SUB_GPIO_TRIGGER_EVENT], obs_ptr);
}

/*! \brief  Destroys the resources associated with the given resource handles
 *  \param  self             Reference to CInic instance
 *  \param  res_handle_list  resource handle list
 *  \param  obs_ptr          Reference to an optional observer. The result must be casted into type
 *                           Inic_StdResult_t.
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 *  \return UCS_RET_ERR_PARAM             Wrong length of resource handle list
 */
Ucs_Return_t Inic_ResourceDestroy(CInic *self,
                                  Inic_ResHandleList_t res_handle_list,
                                  CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;
    uint8_t len;

    if(Al_Lock(&self->lock.res_api, INIC_API_RESOURCE_DESTROY) != false)
    {
        /* sender handle + number of resource handles */
        len = 2U * res_handle_list.num_handles;

        if ((len == 0U)  || ((MAX_INVALID_HANDLES_LIST << 1) < len))
        {
            Al_Release(&self->lock.res_api, INIC_API_RESOURCE_DESTROY);
            result = UCS_RET_ERR_PARAM;
        }
        else
        {
            Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, len);

            if (msg_ptr != NULL)
            {
                uint8_t i;

                msg_ptr->destination_addr  = self->target_address;

                msg_ptr->id.fblock_id   = FB_INIC;
                msg_ptr->id.instance_id = 0U;
                msg_ptr->id.function_id = INIC_FID_RESOURCE_DESTROY;
                msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

                for (i=0U; i < res_handle_list.num_handles; ++i)
                {
                    msg_ptr->tel.tel_data_ptr[2U*i]        = MISC_HB(res_handle_list.res_handles[i]);
                    msg_ptr->tel.tel_data_ptr[1U + (2U*i)] = MISC_LB(res_handle_list.res_handles[i]);
                }

                self->ssubs[INIC_SSUB_RESOURCE_DESTROY].user_mask = INIC_API_RESOURCE_DESTROY;
                msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_RESOURCE_DESTROY];
                Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

                (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_RESOURCE_DESTROY], obs_ptr);
            }
            else
            {
                Al_Release(&self->lock.res_api, INIC_API_RESOURCE_DESTROY);
                result = UCS_RET_ERR_BUFFER_OVERFLOW;
            }
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Retrieves the list of invalid resources
 *  \param  self            Reference to CInic instance
 *  \param  obs_ptr         Reference to an optional observer. The result must be casted into type
 *                          Inic_StdResult_t.
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_ResourceInvalidList_Get(CInic *self, CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_RESOURCE_INVAL_LIST) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 0U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr = self->target_address;
            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_RESOURCE_INVALID_LIST;
            msg_ptr->id.op_type     = UCS_OP_GET;

            self->ssubs[INIC_SSUB_RESOURCE_INVAL_LIST].user_mask = INIC_API_RESOURCE_INVAL_LIST;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_RESOURCE_INVAL_LIST];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);
            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_RESOURCE_INVAL_LIST], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_RESOURCE_INVAL_LIST);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Resets the resource monitor back to its default state.
 *  \param  self            Reference to CInic instance
 *  \param  control         Used to reset the resource monitor
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 */
Ucs_Return_t Inic_ResourceMonitor_Set(CInic *self, Ucs_Resource_MonitorCtrl_t control)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);

    if (msg_ptr != NULL)
    {
        msg_ptr->destination_addr    = self->target_address;
        msg_ptr->id.fblock_id        = FB_INIC;
        msg_ptr->id.instance_id      = 0U;
        msg_ptr->id.function_id      = INIC_FID_RESOURCE_MONITOR;
        msg_ptr->id.op_type          = UCS_OP_SET;
        msg_ptr->tel.tel_data_ptr[0] = (uint8_t)control;
        Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);
    }
    else
    {
        result = UCS_RET_ERR_BUFFER_OVERFLOW;
    }

    return result;
}

/*! \brief  Triggers notification of the given function_id list.
 *  \param  self            Reference to CInic instance
 *  \param  control         control command used
 *  \param  device_id       Id of the sending device (local node address).
 *  \param  fktid_list      function ids list.
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_PARAM             parameter exceeds its admissible range was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 */
Ucs_Return_t Inic_Notification_Set(CInic *self, Ucs_Inic_NotificationCtrl_t control, uint16_t device_id, Inic_FktIdList_t fktid_list)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    /* control + device_id + size of the funcids list */
    uint8_t len = 1U + 2U + (2U * fktid_list.num_fktids);

    if (len > MSG_MAX_SIZE_PAYLOAD)
    {
        result = UCS_RET_ERR_PARAM;
    }
    else
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, len);

        if (msg_ptr != NULL)
        {
            uint8_t i;

            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_NOTIFICATION;
            msg_ptr->id.op_type     = UCS_OP_SET;

            msg_ptr->tel.tel_data_ptr[0] = (uint8_t)control;
            msg_ptr->tel.tel_data_ptr[1] = MISC_HB(device_id);
            msg_ptr->tel.tel_data_ptr[2] = MISC_LB(device_id);

            if ((len > 3U) && (fktid_list.fktids_ptr != NULL) )
            {
                for (i=0U; i < fktid_list.num_fktids; ++i)
                {
                    msg_ptr->tel.tel_data_ptr[3U+(2U*i)] = MISC_HB(fktid_list.fktids_ptr[i]);
                    msg_ptr->tel.tel_data_ptr[4U+(2U*i)] = MISC_LB(fktid_list.fktids_ptr[i]);
                }
            }

            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_NOTIFICATION];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);
        }
        else
        {
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }

    return result;
}

/*! \brief Gets the device id that has notified the given function_id
 *  \param  self            Reference to CInic instance
 *  \param  fktid           The function id to be looked for
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_Notification_Get(CInic *self, uint16_t fktid, CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_NOTIFICATION) != false)
    {
        Msg_MostTel_t * msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_NOTIFICATION;
            msg_ptr->id.op_type     = UCS_OP_GET;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(fktid);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(fktid);

            self->ssubs[INIC_SSUB_NOTIFICATION].user_mask = INIC_API_NOTIFICATION;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_NOTIFICATION];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_NOTIFICATION], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_NOTIFICATION);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates a synchronous data connection. The connection can be directly associated with
 *          an input and output socket.
 *  \param  self                Reference to CInic instance
 *  \param  resource_handle_in  The ID number of the socket or splitter resource that is the
 *                              starting point of the link.
 *  \param  resource_handle_out The ID number of the socket or splitter resource that is the ending
 *                              point of the link.
 *  \param  default_mute        specifies if the connection is muted by default
 *  \param  mute_mode           Configures how the resource monitor shall handle events that may
 *                              the streamed data invalid.
 *  \param  offset              Denotes the offset from/to where data from/to a socket should be
 *                              routed from/to a splitter/combiner.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_SyncCreate(CInic *self,
                             uint16_t resource_handle_in,
                             uint16_t resource_handle_out,
                             bool default_mute,
                             Ucs_Sync_MuteMode_t mute_mode,
                             uint16_t offset,
                             CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 8U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_SYNC_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(resource_handle_in);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(resource_handle_in);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(resource_handle_out);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(resource_handle_out);
            msg_ptr->tel.tel_data_ptr[4] = (default_mute != false) ? 1U : 0U;
            msg_ptr->tel.tel_data_ptr[5] = (uint8_t)mute_mode;
            msg_ptr->tel.tel_data_ptr[6] = MISC_HB(offset);
            msg_ptr->tel.tel_data_ptr[7] = MISC_LB(offset);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function manually mutes a synchronous data connection.
 *  \param  self             Reference to CInic instance
 *  \param  sync_handle      Resource handle of the synchronous connection
 *  \param  obs_ptr          Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_SyncMute(CInic *self,
                           uint16_t sync_handle,
                           CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_SYNC_MUTE) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_SYNC_MUTE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(sync_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(sync_handle);

            self->ssubs[INIC_SSUB_SYNC_MUTE].user_mask = INIC_API_SYNC_MUTE;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_SYNC_MUTE];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_SYNC_MUTE], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_SYNC_MUTE);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function manually de-mutes a synchronous data connection.
 *  \param  self             Reference to CInic instance
 *  \param  sync_handle      Resource handle of the synchronous connection
 *  \param  obs_ptr          Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_SyncDemute(CInic *self,
                             uint16_t sync_handle,
                             CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_SYNC_DEMUTE) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_SYNC_DEMUTE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(sync_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(sync_handle);

            self->ssubs[INIC_SSUB_SYNC_DEMUTE].user_mask = INIC_API_SYNC_DEMUTE;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_SYNC_DEMUTE];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_SYNC_DEMUTE], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_SYNC_DEMUTE);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates a DiscreteFrame Isochronous streaming phase connection. The connection can be
 *          directly associated with an input and output socket.
 *  \param  self                Reference to CInic instance
 *  \param  resource_handle_in  The ID number of the socket or splitter resource that is the
 *                              starting point of the link.
 *  \param  resource_handle_out The ID number of the socket or splitter resource that is the ending
 *                              point of the link.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_DfiPhaseCreate(CInic *self,
                                 uint16_t resource_handle_in,
                                 uint16_t resource_handle_out,
                                 CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 4U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_DFIPHASE_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(resource_handle_in);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(resource_handle_in);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(resource_handle_out);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(resource_handle_out);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates a combiner resource. A Combiner enables grouping of data from multiple network
 *          sockets into the same port socket.
 *  \param  self                Reference to CInic instance
 *  \param  port_socket_handle  Only supported sockets are Streaming Port, MLB, USB (OS81118) or PCI
 *                              (OS81160) sockets of data type Synchronous. Direction must be OUT.
 *  \param  most_port_handle    When the splitter is created with a MOST socket, the socket must be
 *                              created on the same port indicated by this handle.
 *  \param  bytes_per_frame     Specifies the total number of data bytes that are to be transferred
 *                              each MOST frame.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_CombinerCreate(CInic *self,
                                 uint16_t port_socket_handle,
                                 uint16_t most_port_handle,
                                 uint16_t bytes_per_frame,
                                 CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 6U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_COMBINER_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(port_socket_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(port_socket_handle);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[4] = MISC_HB(bytes_per_frame);
            msg_ptr->tel.tel_data_ptr[5] = MISC_LB(bytes_per_frame);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates a splitter resource. A Splitter enables splitting up the data from a single
 *          channel into multiple channels.
 *  \param  self                Reference to CInic instance
 *  \param  socket_handle_in    All sockets of data type Synchronous are supported, regardless of
 *                              the port the socket is created on. The direction must be IN.
 *  \param  most_port_handle    When the splitter is created with a MOST socket, the socket must be
 *                              created on the same port indicated by this handle.
 *  \param  bytes_per_frame     Specifies the total number of data bytes that are to be transferred
 *                              each MOST frame.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_SplitterCreate(CInic *self,
                                 uint16_t socket_handle_in,
                                 uint16_t most_port_handle,
                                 uint16_t bytes_per_frame,
                                 CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 6U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_SPLITTER_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(socket_handle_in);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(socket_handle_in);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[4] = MISC_HB(bytes_per_frame);
            msg_ptr->tel.tel_data_ptr[5] = MISC_LB(bytes_per_frame);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates an Quality of Service IP Streaming data connection.
 *  \param  self                Reference to CInic instance
 *  \param  socket_in_handle    The ID number of the created socket that is the starting point of
 *                              the link. Must be a socket of type Input.
 *  \param  socket_out_handle   The ID number of the created socket that is the ending point of
 *                              the link. Must be a socket of type Output.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_QoSCreate(CInic *self,
                            uint16_t socket_in_handle,
                            uint16_t socket_out_handle,
                            CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 4U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_QOS_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(socket_in_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(socket_in_handle);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(socket_out_handle);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(socket_out_handle);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates an IPC (Inter-Processor Communication) packet connection.
 *  \param  self                Reference to CInic instance
 *  \param  socket_in_handle    The ID number of the created socket that is the starting point of
 *                              the link. Must be a socket of type Input.
 *  \param  socket_out_handle   The ID number of the created socket that is the ending point of
 *                              the link. Must be a socket of type Output.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_IpcCreate(CInic *self,
                            uint16_t socket_in_handle,
                            uint16_t socket_out_handle,
                            CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 4U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_IPC_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(socket_in_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(socket_in_handle);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(socket_out_handle);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(socket_out_handle);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates an A/V Packetized Isochronous Streaming data connection.
 *  \param  self                Reference to CInic instance
 *  \param  socket_in_handle    The ID number of the created socket that is the starting point of
 *                              the link. Must be a socket of type Input.
 *  \param  socket_out_handle   The ID number of the created socket that is the ending point of
 *                              the link. Must be a socket of type Output.
 *  \param  isoc_packet_size    Specifies the size of data packets that are to be transported over
 *                              the isochronous channel.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_AvpCreate(CInic *self,
                            uint16_t socket_in_handle,
                            uint16_t socket_out_handle,
                            Ucs_Avp_IsocPacketSize_t isoc_packet_size,
                            CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 6U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_AVP_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(socket_in_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(socket_in_handle);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(socket_out_handle);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(socket_out_handle);
            msg_ptr->tel.tel_data_ptr[4] = MISC_HB((uint16_t)isoc_packet_size);
            msg_ptr->tel.tel_data_ptr[5] = MISC_LB((uint16_t)isoc_packet_size);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates a MOST socket bound to the MOST Network Port.
 *  \param  self                Reference to CInic instance
 *  \param  most_port_handle    MOST Network Port resource handle
 *  \param  direction           indicates the direction of the data stream from the perspective of
 *                              the INIC
 *  \param  data_type           Specifies the data type
 *  \param  bandwidth           Required socket bandwidth in bytes. Maximum value depends on current
 *                              free network resources.
 *  \param  connection_label    MOST network connection label. When used as parameter with direction
 *                              Input, the connection label is used to connect to the appropriate MOST
 *                              frame bytes. When used as parameter with direction Output, the
 *                              connection label is not used and must be set to 0xFFFF.
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_MostSocketCreate(CInic *self,
                                   uint16_t most_port_handle,
                                   Ucs_SocketDirection_t direction,
                                   Ucs_Most_SocketDataType_t data_type,
                                   uint16_t bandwidth,
                                   uint16_t connection_label,
                                   CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 8U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_MOST_SOCKET_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[2] = (uint8_t)direction;
            msg_ptr->tel.tel_data_ptr[3] = (uint8_t)data_type;
            msg_ptr->tel.tel_data_ptr[4] = MISC_HB(bandwidth);
            msg_ptr->tel.tel_data_ptr[5] = MISC_LB(bandwidth);
            msg_ptr->tel.tel_data_ptr[6] = MISC_HB(connection_label);
            msg_ptr->tel.tel_data_ptr[7] = MISC_LB(connection_label);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates the MediaLB Port with its associated port instance identifier.
 *  \param  self            Reference to CInic instance
 *  \param  index           MediaLB Port instance
 *  \param  clock_config    Stores the clock speed configuration. The value is a multiple
 *                          of the MOST network frame rate Fs; this means the MediaLB Port
 *                          can only be frequency locked to the network's system clock.
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_MlbPortCreate(CInic *self,
                                uint8_t index,
                                Ucs_Mlb_ClockConfig_t clock_config,
                                CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_MLB_PORT_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = index;
            msg_ptr->tel.tel_data_ptr[1] = (uint8_t)clock_config;

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates a MediaLB socket bound to the MediaLB Port with the associated port instance
 *          identifier. If INIC enters Protected Mode, the MediaLB socket will be automatically
 *          destroyed.
 *  \param  self            Reference to CInic instance
 *  \param  mlb_port_handle MediaLB Port resource handle
 *  \param  direction       Indicates the direction of the data stream from the perspective of
 *                          the INIC
 *  \param  data_type       Specifies the data type
 *  \param  bandwidth       Required socket bandwidth in bytes
 *  \param  channel_address Indicates the MediaLB ChannelAddress where the socket is mapped to.
 *                          If the MediaLB Port is created by default, ChannelAddresses 0x0002
 *                          and 0x0004 are reserved and cannot be used.
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_MlbSocketCreate(CInic *self,
                                  uint16_t mlb_port_handle,
                                  Ucs_SocketDirection_t direction,
                                  Ucs_Mlb_SocketDataType_t data_type,
                                  uint16_t bandwidth,
                                  uint16_t channel_address,
                                  CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 8U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_MLB_SOCKET_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0]  = MISC_HB(mlb_port_handle);
            msg_ptr->tel.tel_data_ptr[1]  = MISC_LB(mlb_port_handle);
            msg_ptr->tel.tel_data_ptr[2]  = (uint8_t)direction;
            msg_ptr->tel.tel_data_ptr[3]  = (uint8_t)data_type;
            msg_ptr->tel.tel_data_ptr[4]  = MISC_HB(bandwidth);
            msg_ptr->tel.tel_data_ptr[5]  = MISC_LB(bandwidth);
            msg_ptr->tel.tel_data_ptr[6]  = MISC_HB(channel_address);
            msg_ptr->tel.tel_data_ptr[7]  = MISC_LB(channel_address);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates the USB Port with its associated port instance identifier. The instance
 *          identifier of an USB Port is always directly bound to a specific hardware port.
 *  \param  self                            Reference to CInic instance
 *  \param  index                           USB Port instance
 *  \param  physical_layer                  USB Port physical layer
 *  \param  devices_interfaces              USB Interfaces supported by the device
 *  \param  streaming_if_ep_out_count       number of USB OUT Endpoints being provided through the USB streaming interface
 *  \param  streaming_if_ep_in_count        number of USB IN Endpoints being provided through the USB Streaming interface
 *  \param  obs_ptr                 Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_UsbPortCreate(CInic *self,
                                uint8_t index,
                                Ucs_Usb_PhysicalLayer_t physical_layer,
                                uint16_t devices_interfaces,
                                uint8_t streaming_if_ep_out_count,
                                uint8_t streaming_if_ep_in_count,
                                CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 6U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_USB_PORT_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = index;
            msg_ptr->tel.tel_data_ptr[1] = (uint8_t)physical_layer;
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(devices_interfaces);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(devices_interfaces);
            msg_ptr->tel.tel_data_ptr[4] = streaming_if_ep_out_count;
            msg_ptr->tel.tel_data_ptr[5] = streaming_if_ep_in_count;

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Creates a USB socket bound to the USB port with its associated port instance identifier.
 *          If INIC enters Protected Mode, the USB socket will be automatically destroyed.
 *  \param  self                 Reference to CInic instance
 *  \param  usb_port_handle      USB Port resource handle
 *  \param  direction            Indicates the direction of the data stream from the perspective of
 *                               the INIC
 *  \param  data_type            Specifies the data type
 *  \param  end_point_addr       Denotes the address of a USB endpoint as per its description in the
 *                               USB 2.0 Specification
 *  \param  frames_per_transfer  Indicates the number of MOST frames per transfer per one USB
 *                               transaction
 *  \param  obs_ptr              Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_UsbSocketCreate(CInic *self,
                                  uint16_t usb_port_handle,
                                  Ucs_SocketDirection_t direction,
                                  Ucs_Usb_SocketDataType_t data_type,
                                  uint8_t end_point_addr,
                                  uint16_t frames_per_transfer,
                                  CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 7U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_USB_SOCKET_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(usb_port_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(usb_port_handle);
            msg_ptr->tel.tel_data_ptr[2] = (uint8_t)direction;
            msg_ptr->tel.tel_data_ptr[3] = (uint8_t)data_type;
            msg_ptr->tel.tel_data_ptr[4] = end_point_addr;
            msg_ptr->tel.tel_data_ptr[5] = MISC_HB(frames_per_transfer);
            msg_ptr->tel.tel_data_ptr[6] = MISC_LB(frames_per_transfer);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function is used to configure the Streaming Ports.
 *  \param  self                Reference to CInic instance
 *  \param  index               Streaming Port instance
 *  \param  op_mode             Streaming Port Operation mode
 *  \param  port_option         Streaming Port Options
 *  \param  clock_mode          Stream Port Clock Mode
 *  \param  clock_data_delay    Stream Port Clock Data Delay
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 */
Ucs_Return_t Inic_StreamPortConfig_SetGet(CInic *self,
                                          uint8_t index,
                                          Ucs_Stream_PortOpMode_t op_mode,
                                          Ucs_Stream_PortOption_t port_option,
                                          Ucs_Stream_PortClockMode_t clock_mode,
                                          Ucs_Stream_PortClockDataDelay_t clock_data_delay,
                                          CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_STREAM_PORT_CONFIG) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 5U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr    = self->target_address;
            msg_ptr->id.fblock_id        = FB_INIC;
            msg_ptr->id.instance_id      = 0U;
            msg_ptr->id.function_id      = INIC_FID_STREAM_PORT_CONFIG;
            msg_ptr->id.op_type          = UCS_OP_SETGET;

            msg_ptr->tel.tel_data_ptr[0] = (uint8_t)index;
            msg_ptr->tel.tel_data_ptr[1] = (uint8_t)op_mode;
            msg_ptr->tel.tel_data_ptr[2] = (uint8_t)port_option;
            msg_ptr->tel.tel_data_ptr[3] = (uint8_t)clock_mode;
            msg_ptr->tel.tel_data_ptr[4] = (uint8_t)clock_data_delay;

            self->ssubs[INIC_SSUB_STREAM_PORT_CONFIG].user_mask = INIC_API_STREAM_PORT_CONFIG;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_STREAM_PORT_CONFIG];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_STREAM_PORT_CONFIG], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_STREAM_PORT_CONFIG);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function is used to request the configurations of the Streaming Ports.
 *  \param  self            Reference to CInic instance
 *  \param  index           Streaming Port Instance ID
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_StreamPortConfig_Get(CInic *self,
                                       uint8_t index,
                                       CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_STREAM_PORT_CONFIG) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr    = self->target_address;

            msg_ptr->id.fblock_id        = FB_INIC;
            msg_ptr->id.instance_id      = 0U;
            msg_ptr->id.function_id      = INIC_FID_STREAM_PORT_CONFIG;
            msg_ptr->id.op_type          = UCS_OP_GET;

            msg_ptr->tel.tel_data_ptr[0] = (uint8_t)index;

            self->ssubs[INIC_SSUB_STREAM_PORT_CONFIG].user_mask = INIC_API_STREAM_PORT_CONFIG;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_STREAM_PORT_CONFIG];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_STREAM_PORT_CONFIG], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_STREAM_PORT_CONFIG);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates the Streaming Port with its associated port instance identifier.
 *  \param  self            Reference to CInic instance
 *  \param  index           Streaming Port instance
 *  \param  clock_config    Clock speed configuration of the  SCK  signal
 *  \param  data_alignment  Defines the alignment of the data bytes within the streaming port frame
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_StreamPortCreate(CInic *self,
                                   uint8_t index,
                                   Ucs_Stream_PortClockConfig_t clock_config,
                                   Ucs_Stream_PortDataAlign_t data_alignment,
                                   CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 3U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_STREAM_PORT_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = index;
            msg_ptr->tel.tel_data_ptr[1] = (uint8_t)clock_config;
            msg_ptr->tel.tel_data_ptr[2] = (uint8_t)data_alignment;

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates a Synchronous or DiscreteFrame Isochronous Streaming data socket
 *          bound to the Streaming Port with the denoted port instance identifier.
 *  \param  self                Reference to CInic instance
 *  \param  stream_port_handle  Streaming Port resource handle
 *  \param  direction           Indicates the direction of the data stream, from the INIC's
 *                              perspective
 *  \param  data_type           Specifies the data type
 *  \param  bandwidth           Required socket bandwidth in bytes
 *  \param  stream_pin_id       ID of the serial interface pin of the addressed Streaming Port
 *                              instance
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_StreamSocketCreate(CInic *self,
                                     uint16_t stream_port_handle,
                                     Ucs_SocketDirection_t direction,
                                     Ucs_Stream_SocketDataType_t data_type,
                                     uint16_t bandwidth,
                                     Ucs_Stream_PortPinId_t stream_pin_id,
                                     CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 7U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_STREAM_SOCKET_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(stream_port_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(stream_port_handle);
            msg_ptr->tel.tel_data_ptr[2] = (uint8_t)direction;
            msg_ptr->tel.tel_data_ptr[3] = (uint8_t)data_type;
            msg_ptr->tel.tel_data_ptr[4] = MISC_HB(bandwidth);
            msg_ptr->tel.tel_data_ptr[5] = MISC_LB(bandwidth);
            msg_ptr->tel.tel_data_ptr[6] = (uint8_t)stream_pin_id;

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates an RMCK Port with its associated port instance identifier.
 *  \param  self            Reference to CInic instance
 *  \param  index           RMCK Port instance
 *  \param  clock_source    Indicates the source of the RMCK clock
 *  \param  divisor         Divisor of the clock source
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_RmckPortCreate(CInic *self,
                                    uint8_t index,
                                    Ucs_Rmck_PortClockSource_t clock_source,
                                    uint16_t divisor,
                                    CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 4U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_RMCK_PORT_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = index;
            msg_ptr->tel.tel_data_ptr[1] = (uint8_t)clock_source;
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(divisor);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(divisor);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates an I2C Port with its associated port instance identifier.
 *  \param  self            Reference to CInic instance
 *  \param  index           I2C Port instance
 *  \param  address         The 7-bit I2C slave address of the peripheral to be read.
 *  \param  mode            The operation mode of the I2C Port
 *  \param  speed           The speed grade of the I2C Port
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_I2cPortCreate(CInic *self,
                                uint8_t index,
                                uint8_t address,
                                uint8_t mode,
                                Ucs_I2c_Speed_t speed,
                                CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 4U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_I2C_PORT_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = index;
            msg_ptr->tel.tel_data_ptr[1] = address;
            msg_ptr->tel.tel_data_ptr[2] = mode;
            msg_ptr->tel.tel_data_ptr[3] = (uint8_t)speed;

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function reads a block of bytes from an I2C device at a specified I2C address.
 *  \param  self            Reference to CInic instance
 *  \param  port_handle     Port resource handle
 *  \param  slave_address   The 7-bit I2C slave address of the peripheral to be read
 *  \param  data_len        Number of bytes to be read from the address
 *  \param  timeout         The timeout for the I2C Port read
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_I2cPortRead(CInic *self,
                              uint16_t port_handle,
                              uint8_t slave_address,
                              uint8_t data_len,
                              uint16_t timeout,
                              CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_I2C_PORT_WR) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 6U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_I2C_PORT_READ;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(port_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(port_handle);
            msg_ptr->tel.tel_data_ptr[2] = slave_address;
            msg_ptr->tel.tel_data_ptr[3] = data_len;
            msg_ptr->tel.tel_data_ptr[4] = MISC_HB(timeout);
            msg_ptr->tel.tel_data_ptr[5] = MISC_LB(timeout);

            self->ssubs[INIC_SSUB_I2C_PORT_WR].user_mask = INIC_API_I2C_PORT_WR;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_I2C_PORT_WR];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_I2C_PORT_WR], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_I2C_PORT_WR);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function writes a block of bytes to an I2C device at a specified I2C address.
 *  \param  self            Reference to CInic instance
 *  \param  port_handle     Port resource handle
 *  \param  mode            The write transfer mode
 *  \param  block_count     The number of blocks to be written to the I2C address.
 *  \param  slave_address   The 7-bit I2C slave address of the peripheral to be read
 *  \param  timeout         The timeout for the I2C Port write
 *  \param  data_len        Number of bytes to be written to the addressed I2C peripheral
 *  \param  data_list       Reference to the data list to be written
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_I2cPortWrite(CInic *self,
                              uint16_t port_handle,
                              Ucs_I2c_TrMode_t mode,
                              uint8_t block_count,
                              uint8_t slave_address,
                              uint16_t timeout,
                              uint8_t data_len,
                              uint8_t data_list[],
                              CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_I2C_PORT_WR) != false)
    {
        uint8_t i;
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, (8U + data_len));

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_I2C_PORT_WRITE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(port_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(port_handle);
            msg_ptr->tel.tel_data_ptr[2] = (uint8_t)mode;
            msg_ptr->tel.tel_data_ptr[3] = block_count;
            msg_ptr->tel.tel_data_ptr[4] = slave_address;
            msg_ptr->tel.tel_data_ptr[5] = (mode == UCS_I2C_BURST_MODE)  ? (data_len/block_count):data_len;
            msg_ptr->tel.tel_data_ptr[6] = MISC_HB(timeout);
            msg_ptr->tel.tel_data_ptr[7] = MISC_LB(timeout);

            if (data_list != NULL)
            {
                for (i = 0U; i < data_len; i++)
                {
                    msg_ptr->tel.tel_data_ptr[8U + i] = data_list[i];
                }
            }

            self->ssubs[INIC_SSUB_I2C_PORT_WR].user_mask = INIC_API_I2C_PORT_WR;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_I2C_PORT_WR];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_I2C_PORT_WR], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_I2C_PORT_WR);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates an PCIe Port with its associated port instance identifier.
 *  \param  self            Reference to CInic instance
 *  \param  index           PCIe Port instance
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_PciPortCreate(CInic *self,
                                uint8_t index,
                                CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_PCI_PORT_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = index;

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates a PCIe socket bound to the PCIe Port with the associated port
 *          instance identifier. If the EHC detaches, the PCIe socket will be automatically
 *          destroyed.
 *  \param  self                 Reference to CInic instance
 *  \param  pci_port_handle      PCIe Port resource handle
 *  \param  direction            Indicates the direction of the data stream from the perspective of
 *                               the INIC
 *  \param  data_type            Specifies the data type
 *  \param  dma_channel          Specifies the DMA channel
 *  \param  obs_ptr              Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_PciSocketCreate(CInic *self,
                                  uint16_t pci_port_handle,
                                  Ucs_SocketDirection_t direction,
                                  Ucs_Pci_SocketDataType_t data_type,
                                  uint8_t dma_channel,
                                  CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 5U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_PCI_SOCKET_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(pci_port_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(pci_port_handle);
            msg_ptr->tel.tel_data_ptr[2] = (uint8_t)direction;
            msg_ptr->tel.tel_data_ptr[3] = (uint8_t)data_type;
            msg_ptr->tel.tel_data_ptr[4] = dma_channel;

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function creates a GPIO Port with its associated port instance identifier.
 *  \param  self            Reference to CInic instance
 *  \param  gpio_port_index GPIO Port instance
 *  \param  debounce_time   Timeout for the GPIO debounce timer
 *  \param  obs_ptr              Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_GpioPortCreate(CInic *self,
                                  uint8_t gpio_port_index,
                                  uint16_t debounce_time,
                                  CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_CREATE_CLASS) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 3U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_GPIO_PORT_CREATE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = gpio_port_index;
            msg_ptr->tel.tel_data_ptr[1] = MISC_HB(debounce_time);
            msg_ptr->tel.tel_data_ptr[2] = MISC_LB(debounce_time);

            self->ssubs[INIC_SSUB_CREATE_CLASS].user_mask = INIC_API_CREATE_CLASS;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_CREATE_CLASS];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_CREATE_CLASS], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_CREATE_CLASS);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function enables or disables a specific MOST Network Port.
 *  \param  self                Reference to CInic instance
 *  \param  most_port_handle    Port resource handle
 *  \param  enabled             Indicates whether a MOST Network Port should be enabled or disabled
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_MostPortEnable(CInic *self,
                                 uint16_t most_port_handle,
                                 bool enabled,
                                 CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_MOST_PORT_ENABLE) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 3U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_MOST_PORT_ENABLE;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(most_port_handle);
            msg_ptr->tel.tel_data_ptr[2] = (enabled != false) ? 1U : 0U;

            self->ssubs[INIC_SSUB_MOST_PORT_ENABLE].user_mask = INIC_API_MOST_PORT_ENABLE;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_MOST_PORT_ENABLE];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_MOST_PORT_ENABLE], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_MOST_PORT_ENABLE);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function retrieves the current pin mode of the given GPIO Port.
 *  \param  self              Reference to CInic instance
 *  \param  gpio_handle       GPIO Port instance
 *  \param  obs_ptr           Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t  Inic_GpioPortPinMode_Get(CInic *self, uint16_t gpio_handle, CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_GPIO_PIN_MODE) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_GPIO_PORT_PIN_MODE;
            msg_ptr->id.op_type     = UCS_OP_GET;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(gpio_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(gpio_handle);

            self->ssubs[INIC_SSUB_GPIO_PIN_MODE].user_mask = INIC_API_GPIO_PIN_MODE;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_GPIO_PIN_MODE];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_GPIO_PIN_MODE], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_GPIO_PIN_MODE);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function sets and retrieves the mode of a pin on the GPIO Port
 *  \param  self              Reference to CInic instance
 *  \param  gpio_handle       GPIO Port instance
 *  \param  pin               The GPIO pin that is to be configured
 *  \param  mode              The mode of the GPIO pin
 *  \param  obs_ptr           Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t  Inic_GpioPortPinMode_SetGet(CInic *self, uint16_t gpio_handle, uint8_t pin, Ucs_Gpio_PinMode_t mode, CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_GPIO_PIN_MODE) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 4U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_GPIO_PORT_PIN_MODE;
            msg_ptr->id.op_type     = UCS_OP_SETGET;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(gpio_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(gpio_handle);
            msg_ptr->tel.tel_data_ptr[2] = pin;
            msg_ptr->tel.tel_data_ptr[3] = (uint8_t)mode;

            self->ssubs[INIC_SSUB_GPIO_PIN_MODE].user_mask = INIC_API_GPIO_PIN_MODE;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_GPIO_PIN_MODE];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_GPIO_PIN_MODE], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_GPIO_PIN_MODE);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function retrieves the pin state of the given GPIO Port.
 *  \param  self              Reference to CInic instance
 *  \param  gpio_handle       GPIO Port instance
 *  \param  obs_ptr           Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t  Inic_GpioPortPinState_Get(CInic *self, uint16_t gpio_handle, CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_GPIO_PIN_STATE) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 2U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_GPIO_PORT_PIN_STATE;
            msg_ptr->id.op_type     = UCS_OP_GET;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(gpio_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(gpio_handle);

            self->ssubs[INIC_SSUB_GPIO_PIN_STATE].user_mask = INIC_API_GPIO_PIN_STATE;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_GPIO_PIN_STATE];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_GPIO_PIN_STATE], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_GPIO_PIN_STATE);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function sets and retrieves the state of a pin on the GPIO Port
 *  \param  self              Reference to CInic instance
 *  \param  gpio_handle       GPIO Port instance
 *  \param  mask              The GPIO pins to be written
 *  \param  data              The state of the GPIO pins to be written
 *  \param  obs_ptr           Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t  Inic_GpioPortPinState_SetGet(CInic *self, uint16_t gpio_handle, uint16_t mask, uint16_t data, CSingleObserver *obs_ptr)
{
    Ucs_Return_t result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_GPIO_PIN_STATE) != false)
    {
        Msg_MostTel_t *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 6U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_GPIO_PORT_PIN_STATE;
            msg_ptr->id.op_type     = UCS_OP_SETGET;

            msg_ptr->tel.tel_data_ptr[0] = MISC_HB(gpio_handle);
            msg_ptr->tel.tel_data_ptr[1] = MISC_LB(gpio_handle);
            msg_ptr->tel.tel_data_ptr[2] = MISC_HB(mask);
            msg_ptr->tel.tel_data_ptr[3] = MISC_LB(mask);
            msg_ptr->tel.tel_data_ptr[4] = MISC_HB(data);
            msg_ptr->tel.tel_data_ptr[5] = MISC_LB(data);

            self->ssubs[INIC_SSUB_GPIO_PIN_STATE].user_mask = INIC_API_GPIO_PIN_STATE;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_GPIO_PIN_STATE];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_GPIO_PIN_STATE], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_GPIO_PIN_STATE);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  This function enables full streaming for a specific MOST Network Port.
 *  \param  self                Reference to CInic instance
 *  \param  most_port_handle    Port resource handle
 *  \param  enabled             Indicates whether full streaming is enabled or disabled
 *  \param  obs_ptr             Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available
 *  \return UCS_RET_ERR_API_LOCKED        Resource API is already used by another command
 */
Ucs_Return_t Inic_MostPortEnFullStr(CInic *self,
                                    uint16_t most_port_handle,
                                    bool enabled,
                                    CSingleObserver *obs_ptr)
{
    MISC_UNUSED(self);
    MISC_UNUSED(most_port_handle);
    MISC_UNUSED(enabled);
    MISC_UNUSED(obs_ptr);

    return UCS_RET_ERR_NOT_SUPPORTED;
}

/*! \brief  Allows remote synchronization of the given device
 *  \param  self            Reference to CInic instance
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created 
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available 
 */
Ucs_Return_t Inic_DeviceSync(CInic *self, CSingleObserver *obs_ptr)
{
    Ucs_Return_t     result = UCS_RET_SUCCESS;

    if(Al_Lock(&self->lock.res_api, INIC_API_DEVICE_SYNC) != false)
    {
        Msg_MostTel_t   *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);

        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_DEVICE_SYNC;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = 0x01U;

            self->ssubs[INIC_SSUB_DEVICE_SYNC].user_mask = INIC_API_DEVICE_SYNC;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_DEVICE_SYNC];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_DEVICE_SYNC], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_DEVICE_SYNC);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*! \brief  Un-synchronizes to the given remote device
 *  \param  self            Reference to CInic instance
 *  \param  obs_ptr         Reference to an optional observer
 *  \return UCS_RET_SUCCESS               message was created 
 *  \return UCS_RET_ERR_BUFFER_OVERFLOW   no message buffer available 
 */
Ucs_Return_t Inic_DeviceUnsync(CInic *self, CSingleObserver *obs_ptr)
{
    Ucs_Return_t     result = UCS_RET_SUCCESS;
    Msg_MostTel_t   *msg_ptr = Trcv_TxAllocateMsg(self->xcvr_ptr, 1U);

    if(Al_Lock(&self->lock.res_api, INIC_API_DEVICE_SYNC) != false)
    {
        if (msg_ptr != NULL)
        {
            msg_ptr->destination_addr  = self->target_address;

            msg_ptr->id.fblock_id   = FB_INIC;
            msg_ptr->id.instance_id = 0U;
            msg_ptr->id.function_id = INIC_FID_DEVICE_SYNC;
            msg_ptr->id.op_type     = UCS_OP_STARTRESULT;

            msg_ptr->tel.tel_data_ptr[0] = 0U;

            self->ssubs[INIC_SSUB_DEVICE_SYNC].user_mask = INIC_API_DEVICE_SYNC;
            msg_ptr->info_ptr = &self->ssubs[INIC_SSUB_DEVICE_SYNC];
            Trcv_TxSendMsgExt(self->xcvr_ptr, msg_ptr, &Inic_ResMsgTxStatusCb, self);

            (void)Ssub_AddObserver(&self->ssubs[INIC_SSUB_DEVICE_SYNC], obs_ptr);
        }
        else
        {
            Al_Release(&self->lock.res_api, INIC_API_DEVICE_SYNC);
            result = UCS_RET_ERR_BUFFER_OVERFLOW;
        }
    }
    else
    {
        result = UCS_RET_ERR_API_LOCKED;
    }

    return result;
}

/*------------------------------------------------------------------------------------------------*/
/* Handler functions                                                                              */
/*------------------------------------------------------------------------------------------------*/
/*! \brief Handle message Tx status, Unlock the API and free the message objects
 *  \param self     The instance
 *  \param tel_ptr  Reference to transmitted message
 *  \param status   Status of the transmitted message
 */
static void Inic_ResMsgTxStatusCb(void *self, Msg_MostTel_t *tel_ptr, Ucs_MsgTxStatus_t status)
{
    CInic *self_ = (CInic *)self;
    CSingleSubject *ssub_ptr = (CSingleSubject *)tel_ptr->info_ptr;

    if ((status != UCS_MSG_STAT_OK) && (tel_ptr->info_ptr != NULL))
    {
        Inic_StdResult_t res_data;

        res_data.data_info        = &status;
        res_data.result.code      = UCS_RES_ERR_TRANSMISSION;
        res_data.result.info_ptr  = NULL;
        res_data.result.info_size = 0U;
        Ssub_Notify(ssub_ptr, &res_data, true);

        if ((ssub_ptr != NULL) && (ssub_ptr->user_mask != 0U))
        {
            Al_Release(&self_->lock.res_api, (Alm_ModuleMask_t)ssub_ptr->user_mask);
        }
    }
    Trcv_TxReleaseMsg(tel_ptr);
    /* Reset user mask of the single subject if available */
    if (ssub_ptr != NULL)
    {
        ssub_ptr->user_mask = 0U;
    }

    /* ICM messages pending? */
    if (Sub_GetNumObservers(&self_->subs[INIC_SUB_TX_MSG_OBJ_AVAIL]) > 0U)
    {
        Sub_Notify(&self_->subs[INIC_SUB_TX_MSG_OBJ_AVAIL], NULL);
    }
}

/*! \brief Handler function for INIC.ResourceDestroy.ErrorAck
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_ResourceDestroy_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_RESOURCE_DESTROY], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_RESOURCE_DESTROY);
}

/*! \brief Handler function for INIC.ResourceDestroy.ResultAck
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_ResourceDestroy_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    MISC_UNUSED(msg_ptr);

    res_data.data_info       = NULL;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_RESOURCE_DESTROY], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_RESOURCE_DESTROY);
}

/*! \brief Handler function for INIC.ResourceInvalidList.Status
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_ResourceInvalidList_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    Inic_ResHandleList_t result;
    uint8_t i;
    uint16_t inv_res_handles[22];   /* Max. ICM message size is 45 -> max. 22 16-bit values */

    res_data.data_info       = &result;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    /* Length of message must be even, since 16-Bit values are transmitted via two 8-bit fields. */
    TR_ASSERT(self_->base_ptr->ucs_user_ptr, "[INIC_RES]", ((msg_ptr->tel.tel_len % 2U) == 0U));

    for(i=0U; (i < (uint8_t)(msg_ptr->tel.tel_len >> 1)); i++)
    {
        MISC_DECODE_WORD(&inv_res_handles[i],
                         &(msg_ptr->tel.tel_data_ptr[(uint8_t)((uint8_t)i << 1)]));
    }
    result.res_handles = &inv_res_handles[0];
    result.num_handles = (uint8_t)((uint8_t)msg_ptr->tel.tel_len >> 1);
    Ssub_Notify(&self_->ssubs[INIC_SSUB_RESOURCE_INVAL_LIST], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_RESOURCE_INVAL_LIST);
}

/*! \brief Handler function for INIC.ResourceInvalidList.Error
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_ResourceInvalidList_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          msg_ptr->tel.tel_len);
    Ssub_Notify(&self_->ssubs[INIC_SSUB_RESOURCE_INVAL_LIST], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_RESOURCE_INVAL_LIST);
}

/*! \brief Handler function for INIC.ResourceMonitor.Status
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_ResourceMonitor_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    Ucs_Resource_MonitorState_t state;

    res_data.data_info       = &state;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    state = (Ucs_Resource_MonitorState_t)msg_ptr->tel.tel_data_ptr[0];
    Sub_Notify(&self_->subs[INIC_SUB_RES_MONITOR], &res_data);
}

/*! \brief Handler function for INIC.ResourceMonitor.Error
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_ResourceMonitor_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          msg_ptr->tel.tel_len);
    Sub_Notify(&self_->subs[INIC_SUB_RES_MONITOR], &res_data);
}

/*! \brief Handler function for INIC.SyncCreate.ErrorAck
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_SyncCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.SyncCreate.ResultAck. res_data.data_info points to the
 *         resource handle of the synchronous connection which was created.
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_SyncCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}


/*! \brief Handler function for INIC.SyncMute.ErrorAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_SyncMute_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info  = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_SYNC_MUTE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_SYNC_MUTE);
}

/*! \brief Handler function for INIC.SyncMute.ResultAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_SyncMute_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    MISC_UNUSED(msg_ptr);

    res_data.data_info       = NULL;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_SYNC_MUTE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_SYNC_MUTE);
}

/*! \brief Handler function for INIC.SyncDemute.ErrorAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_SyncDemute_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info  = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_SYNC_DEMUTE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_SYNC_DEMUTE);
}

/*! \brief Handler function for INIC.SyncDemute.ResultAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_SyncDemute_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    MISC_UNUSED(msg_ptr);

    res_data.data_info       = NULL;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_SYNC_DEMUTE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_SYNC_DEMUTE);
}

/*! \brief Handler function for INIC.DFIPhaseCreate.ErrorAck
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_DfiPhaseCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.DFIPhaseCreate.ResultAck. res_data.data_info points to the
 *         resource handle of the DFIPhase streaming phase connection which was created.
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_DfiPhaseCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.CombinerCreate.ErrorAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_CombinerCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.CombinerCreate.ResultAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_CombinerCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.SplitterCreate.ErrorAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_SplitterCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.SplitterCreate.ResultAck
 * \param  self     reference to INIC object
 * \param  msg_ptr  received message
 */
void Inic_SplitterCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.QoSCreate.ErrorAck
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_QoSCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.QoSCreate.ResultAck.res_data.data_info points to the Resource
 *         handle of the Quality of Service IP Streaming data connection which was created.
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_QoSCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.IPCPacketCreate.ErrorAck
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_IpcCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.IPCPacketCreate.ResultAck.res_data.data_info points to the resource
 *         handle of the Inter-Processor Communication packet connection which was created.
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_IpcCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.AVPCreate.ErrorAck
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_AvpCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.AVPCreate.ResultAck. res_data.data_info points to the Resource
 *         handle of the A/V Packetized Isochronous Streaming connection which was created.
 *  \param self     reference to INIC object
 *  \param msg_ptr  received message
 */
void Inic_AvpCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief Handler function for INIC.MOSTPortStatus.Status
 *  \param self      Reference to CInic instance
 *  \param msg_ptr   Pointer to received message
 */
void Inic_MostPortStatus_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_MostPortStatus_t result;

    MISC_DECODE_WORD(&(result.most_port_handle), &(msg_ptr->tel.tel_data_ptr[0]));
    result.availability          = (Ucs_Most_PortAvail_t)msg_ptr->tel.tel_data_ptr[2];
    result.avail_info            = (Ucs_Most_PortAvailInfo_t)msg_ptr->tel.tel_data_ptr[3];
    result.fullstreaming_enabled = (msg_ptr->tel.tel_data_ptr[4] != 0U) ? true : false;
    MISC_DECODE_WORD(&(result.freestreaming_bw), &(msg_ptr->tel.tel_data_ptr[5]));

    self_->most_port_status = result;

    Sub_Notify(&self_->subs[INIC_SUB_MOST_PORT_STATUS], &result);
}

/*! \brief Handler function for INIC.MOSTPortStatus.Error
 *  \param self      Reference to CInic instance
 *  \param msg_ptr   Pointer to received message
 */
void Inic_MostPortStatus_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          msg_ptr->tel.tel_len);

    Sub_Notify(&self_->subs[INIC_SUB_MOST_PORT_STATUS], &res_data);
}

/*! \brief Handler function for INIC.MOSTSocketCreate.ErrorAck. Result is delivered via the
 *         SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param self     Reference to CInic instance
 *  \param msg_ptr  Pointer to received message
 */
void Inic_MostSocketCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.MOSTSocketCreate.ResultAck
 *  \details Result is delivered via the SingleObserver element ssubs[INIC_SSUB_CREATE_CLASS]. Element
 *           res_data.data_info points to a variable of type Inic_MostSocketCreate_Result_t
 *           which holds the results of the MOSTSocketCreate command.
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MostSocketCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    Inic_MostSocketCreate_Result_t  res;

    MISC_DECODE_WORD(&(res.most_socket_handle), &(msg_ptr->tel.tel_data_ptr[0]));
    MISC_DECODE_WORD(&(res.conn_label),         &(msg_ptr->tel.tel_data_ptr[2]));
    res_data.data_info       = &res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}


/*! \brief   Handler function for INIC.MLBPortCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MlbPortCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info      = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.MLBPortCreate.ResultAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *           Element res_data.data_info points to the variable mlb_port_handle which holds the
 *           MediaLB Port resource handle.
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MlbPortCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t mlb_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&mlb_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &mlb_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.MLBSocketCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MlbSocketCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.MLBSocketCreate.ResultAck
 *  \details Element res_data.data_info points to the variable mlb_socket_handle which holds the
 *           MediaLB Socket resource handle of the created socket. Result is delivered via the
 *           SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MlbSocketCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t mlb_socket_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&mlb_socket_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &mlb_socket_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.USBPortCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_UsbPortCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.USBPortCreate.ResultAck
 *  \details Element res_data.data_info points to the variable usb_port_handle which holds the USB
 *           Port resource handle.
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_UsbPortCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t usb_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&usb_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &usb_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.USBSocketCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_UsbSocketCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.USBSocketCreate.ResultAck
 *  \details Element res_data.data_info points to the variable usb_socket_handle which holds the
 *           Socket resource handle of the created socket. Result is delivered via the
 *           SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_UsbSocketCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t usb_socket_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&usb_socket_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &usb_socket_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.StreamPortConfiguration.Status
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_STREAM_PORT_CONFIG].
 *           Element res_data.data_info points to a variable of type Inic_StreamPortConfigStatus_t
 *           which holds the results of the INIC.StreamPortConfiguration.Get command.
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_StreamPortConfig_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StreamPortConfigStatus_t res;
    Inic_StdResult_t res_data;

    res_data.data_info       = &res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    res.index            = msg_ptr->tel.tel_data_ptr[0];
    res.op_mode          = (Ucs_Stream_PortOpMode_t)msg_ptr->tel.tel_data_ptr[1];
    res.port_option      = (Ucs_Stream_PortOption_t)msg_ptr->tel.tel_data_ptr[2];
    res.clock_mode       = (Ucs_Stream_PortClockMode_t)msg_ptr->tel.tel_data_ptr[3];
    res.clock_data_delay = (Ucs_Stream_PortClockDataDelay_t)msg_ptr->tel.tel_data_ptr[4];

    Ssub_Notify(&self_->ssubs[INIC_SSUB_STREAM_PORT_CONFIG], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_STREAM_PORT_CONFIG);
}

/*! \brief   Handler function for INIC.StreamPortConfiguration.Error
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_STREAM_PORT_CONFIG].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_StreamPortConfig_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          msg_ptr->tel.tel_len);
    Ssub_Notify(&self_->ssubs[INIC_SSUB_STREAM_PORT_CONFIG], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_STREAM_PORT_CONFIG);
}

/*! \brief   Handler function for INIC.StreamPortCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_StreamPortCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.StreamPortCreate.ResultAck
 *  \details Element res_data.data_info points to the variable stream_port_handle which holds the
 *           Streaming Port resource handle. Result is delivered via the SingleObserver object
 *           ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_StreamPortCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t stream_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&stream_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &stream_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.StreamSocketCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_StreamSocketCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.StreamSocketCreate.ResultAck
 *  \details Element res_data.data_info points to the variable stream_socket_handle which holds
 *           the Socket resource handle of the created socket. Result is delivered via the
 *           SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_StreamSocketCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t stream_socket_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&stream_socket_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &stream_socket_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.RMCKOutPortCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_RmckPortCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.RMCKOutPortCreate.ResultAck
 *  \details Element res_data.data_info points to the variable rmck_port_handle which holds the
 *           RMCK Port resource handle. Result is delivered via the SingleObserver object
 *           ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_RmckPortCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t rmck_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&rmck_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &rmck_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.I2CPortCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_I2cPortCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.I2CPortCreate.ResultAck
 *  \details Element res_data.data_info points to the variable i2c_port_handle which holds the
 *           I2C Port resource handle. Result is delivered via the SingleObserver object
 *           ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_I2cPortCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t i2c_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&i2c_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &i2c_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.I2CPortRead.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_I2C_PORT_WR].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_I2cPortRead_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_I2C_PORT_WR], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_I2C_PORT_WR);
}

/*! \brief   Handler function for INIC.I2CPortRead.ResultAck
 *  \details Element res_data.data_info points to a variable of type Inic_I2cReadResStatus_t which holds the
 *          the results of the INIC.I2CPortRead.StartResultAck command.
 *          Result is delivered via the SingleObserver object ssubs[INIC_SSUB_I2C_PORT_WR].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_I2cPortRead_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_I2cReadResStatus_t i2c_read_res;
    Inic_StdResult_t res_data;

    res_data.data_info       = &i2c_read_res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    MISC_DECODE_WORD(&i2c_read_res.port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    i2c_read_res.slave_address = msg_ptr->tel.tel_data_ptr[2];
    i2c_read_res.data_len      = msg_ptr->tel.tel_data_ptr[3];
    i2c_read_res.data_ptr      = &msg_ptr->tel.tel_data_ptr[4];

    Ssub_Notify(&self_->ssubs[INIC_SSUB_I2C_PORT_WR], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_I2C_PORT_WR);
}

/*! \brief   Handler function for INIC.I2CPortWrite.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_I2C_PORT_WR].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_I2cPortWrite_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_I2C_PORT_WR], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_I2C_PORT_WR);
}

/*! \brief   Handler function for INIC.I2CPortWrite.ResultAck
 *  \details Element res_data.data_info points to a variable of type Inic_I2cWriteResStatus_t which holds the
 *          the results of the INIC.I2CPortWrite.StartResultAck command.
 *          Result is delivered via the SingleObserver object ssubs[INIC_SSUB_I2C_PORT_WR].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_I2cPortWrite_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_I2cWriteResStatus_t i2c_write_res;
    Inic_StdResult_t res_data;

    res_data.data_info       = &i2c_write_res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    MISC_DECODE_WORD(&i2c_write_res.port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    i2c_write_res.slave_address = msg_ptr->tel.tel_data_ptr[2];
    i2c_write_res.data_len      = msg_ptr->tel.tel_data_ptr[3];

    Ssub_Notify(&self_->ssubs[INIC_SSUB_I2C_PORT_WR], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_I2C_PORT_WR);
}

/*! \brief   Handler function for INIC.PCIPortCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_PciPortCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.PCIPortCreate.ResultAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_PciPortCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t pci_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&pci_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &pci_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.PCISocketCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_PciSocketCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.PCISocketCreate.ResultAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_PciSocketCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t pci_socket_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&pci_socket_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &pci_socket_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.GPIOPortCreate.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortCreate_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.GPIOPortCreate.ResultAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_CREATE_CLASS].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortCreate_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    uint16_t gpio_port_handle;
    Inic_StdResult_t res_data;

    MISC_DECODE_WORD(&gpio_port_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    res_data.data_info       = &gpio_port_handle;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_CREATE_CLASS], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_CREATE_CLASS);
}

/*! \brief   Handler function for INIC.MOSTPortEnable.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_MOST_PORT_ENABLE].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MostPortEnable_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_MOST_PORT_ENABLE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_MOST_PORT_ENABLE);
}

/*! \brief   Handler function for INIC.MOSTPortEnable.ResultAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_MOST_PORT_ENABLE].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MostPortEnable_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    MISC_UNUSED(msg_ptr);

    res_data.data_info       = NULL;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_MOST_PORT_ENABLE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_MOST_PORT_ENABLE);
}

/*! \brief   Handler function for INIC.GPIOPortPinMode.Status
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_GPIO_PIN_MODE].
 *           Element res_data.data_info points to a variable of type Inic_GpioPortPinModeStatus_t
 *           which holds the results of the INIC.GPIOPortPinMode.Get command.
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortPinMode_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_GpioPortPinModeStatus_t res;
    Inic_StdResult_t res_data;
    uint8_t i = 2U, j = 0U;
    Ucs_Gpio_PinConfiguration_t pin_ls[16U];

    res.cfg_list             = &pin_ls[0];
    res.len                  = (msg_ptr->tel.tel_len - 2U) >> 1U;
    res_data.data_info       = &res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    MISC_DECODE_WORD(&res.gpio_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    for (; (i < msg_ptr->tel.tel_len) && (j < 16U); i=i+2U)
    {
        pin_ls[j].pin  = msg_ptr->tel.tel_data_ptr[i];
        pin_ls[j].mode = (Ucs_Gpio_PinMode_t)msg_ptr->tel.tel_data_ptr[i+1U];
        j++;
    }

    Ssub_Notify(&self_->ssubs[INIC_SSUB_GPIO_PIN_MODE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_GPIO_PIN_MODE);
}

/*! \brief   Handler function for INIC.GPIOPortPinMode.Error
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_GPIO_PIN_MODE].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortPinMode_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          msg_ptr->tel.tel_len);
    Ssub_Notify(&self_->ssubs[INIC_SSUB_GPIO_PIN_MODE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_GPIO_PIN_MODE);
}

/*! \brief   Handler function for INIC.GPIOPortPinState.Status
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_GPIO_PIN_STATE].
 *           Element res_data.data_info points to a variable of type Inic_GpioPortPinStateStatus_t
 *           which holds the results of the INIC.GPIOPortPinState.Get command.
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortPinState_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_GpioPortPinStateStatus_t res;
    Inic_StdResult_t res_data;

    res_data.data_info       = &res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    MISC_DECODE_WORD(&res.gpio_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    MISC_DECODE_WORD(&res.current_state, &(msg_ptr->tel.tel_data_ptr[2]));
    MISC_DECODE_WORD(&res.sticky_state, &(msg_ptr->tel.tel_data_ptr[4]));

    Ssub_Notify(&self_->ssubs[INIC_SSUB_GPIO_PIN_STATE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_GPIO_PIN_STATE);
}

/*! \brief   Handler function for INIC.GPIOPortPinState.Error
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_GPIO_PIN_STATE].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortPinState_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          msg_ptr->tel.tel_len);
    Ssub_Notify(&self_->ssubs[INIC_SSUB_GPIO_PIN_STATE], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_GPIO_PIN_STATE);
}

/*! \brief   Handler function for INIC.GPIOPortTriggerEvent.Status
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_GPIO_TRIGGER_EVENT].
 *           Element res_data.data_info points to a variable of type Inic_GpioTriggerEventStatus_t
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortTrigger_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_GpioTriggerEventStatus_t res;
    Inic_StdResult_t res_data;

    res_data.data_info       = &res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    MISC_DECODE_WORD(&res.gpio_handle, &(msg_ptr->tel.tel_data_ptr[0]));
    MISC_DECODE_WORD(&res.rising_edges, &(msg_ptr->tel.tel_data_ptr[2]));
    MISC_DECODE_WORD(&res.falling_edges, &(msg_ptr->tel.tel_data_ptr[4]));
    MISC_DECODE_WORD(&res.levels, &(msg_ptr->tel.tel_data_ptr[6]));
    res.is_first_report = self_->gpio_rt_status.first_report;
    if (self_->gpio_rt_status.first_report)
    {
        self_->gpio_rt_status.first_report = false;
    }

    Sub_Notify(&self_->subs[INIC_SUB_GPIO_TRIGGER_EVENT], &res_data);
}

/*! \brief   Handler function for INIC.GPIOPortTriggerEvent.Error
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_GPIO_TRIGGER_EVENT].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_GpioPortTrigger_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          msg_ptr->tel.tel_len);
    Sub_Notify(&self_->subs[INIC_SUB_GPIO_TRIGGER_EVENT], &res_data);
}

/*! \brief   Handler function for INIC.MOSTPortEnableFullStreaming.ErrorAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_MOST_PORT_EN_FULL_STR].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MostPortEnFullStr_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));
    Ssub_Notify(&self_->ssubs[INIC_SSUB_MOST_PORT_EN_FULL_STR], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_MOST_PORT_EN_FULL_STR);
}

/*! \brief   Handler function for INIC.MOSTPortEnableFullStreaming.ResultAck
 *  \details Result is delivered via the SingleObserver object ssubs[INIC_SSUB_MOST_PORT_EN_FULL_STR].
 *  \param   self      Reference to CInic instance
 *  \param   msg_ptr   Pointer to received message
 */
void Inic_MostPortEnFullStr_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    MISC_UNUSED(msg_ptr);

    res_data.data_info       = NULL;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;
    Ssub_Notify(&self_->ssubs[INIC_SSUB_MOST_PORT_EN_FULL_STR], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_MOST_PORT_EN_FULL_STR);
}

/*! \brief Handler function for INIC.Notification.Error
 *  \param  self     reference to INIC object
 *  \param  msg_ptr  received message
 */
void Inic_Notification_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    res_data.data_info  = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0],
                                          (msg_ptr->tel.tel_len));

    Ssub_Notify(&self_->ssubs[INIC_SSUB_NOTIFICATION], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_NOTIFICATION);
}

/*! \brief Handler function for INIC.Notification.ResultAck
 *  \param  self     reference to INIC object
 *  \param  msg_ptr  received message
 */
void Inic_Notification_Status(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
    Inic_NotificationResult_t notif_res;

    res_data.data_info       = &notif_res;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    MISC_DECODE_WORD(&notif_res.func_id, &(msg_ptr->tel.tel_data_ptr[0]));
    if (msg_ptr->tel.tel_len == 4U)
    {
        MISC_DECODE_WORD(&notif_res.device_id, &(msg_ptr->tel.tel_data_ptr[2]));
    }
    else
    {
        notif_res.device_id = 0U;
    }

    Ssub_Notify(&self_->ssubs[INIC_SSUB_NOTIFICATION], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_NOTIFICATION);
}

/*! \brief Handler  function for INIC.DeviceSync.Error
 *  \param  self    reference to INIC object
 *  \param  msg_ptr received message
 */
void Inic_DeviceSync_Error(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;
 
    res_data.data_info  = NULL;
    res_data.result = Inic_TranslateError(self_,
                                          &msg_ptr->tel.tel_data_ptr[0], 
                                          (msg_ptr->tel.tel_len));

    Ssub_Notify(&self_->ssubs[INIC_SSUB_DEVICE_SYNC], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_DEVICE_SYNC);
}

/*! \brief Handler  function for INIC.DeviceSync.Result
 *  \param  self    reference to INIC object
 *  \param  msg_ptr received message
 */
void Inic_DeviceSync_Result(void *self, Msg_MostTel_t *msg_ptr)
{
    CInic *self_ = (CInic *)self;
    Inic_StdResult_t res_data;

    MISC_UNUSED(msg_ptr);

    res_data.data_info       = NULL;
    res_data.result.code     = UCS_RES_SUCCESS;
    res_data.result.info_ptr = NULL;

    Ssub_Notify(&self_->ssubs[INIC_SSUB_DEVICE_SYNC], &res_data, true);
    Al_Release(&self_->lock.res_api, INIC_API_DEVICE_SYNC);
}

/*!
 * @}
 * \endcond
 */

/*------------------------------------------------------------------------------------------------*/
/* End of file                                                                                    */
/*------------------------------------------------------------------------------------------------*/