/*------------------------------------------------------------------------------------------------*/
/* 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 = ¬if_res;
res_data.result.code = UCS_RES_SUCCESS;
res_data.result.info_ptr = NULL;
MISC_DECODE_WORD(¬if_res.func_id, &(msg_ptr->tel.tel_data_ptr[0]));
if (msg_ptr->tel.tel_len == 4U)
{
MISC_DECODE_WORD(¬if_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 */
/*------------------------------------------------------------------------------------------------*/
