cfg_hlp.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: cfg_hlp.c 1.4 2018/09/19 16:55:08 martin REL_M $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Meinberg device configuration helper functions.
 *
 * -----------------------------------------------------------------------
 *  $Log: cfg_hlp.c $
 *  Revision 1.4  2018/09/19 16:55:08  martin
 *  Account for renamed global variables.
 *  Revision 1.3  2018/07/05 10:28:07Z  martin
 *  Renamed setup_port_info_from_port_settings()
 *  to setup_port_info_from_port_parm().
 *  Added function chk_dev_receiver_info().
 *  Function free_all_firmware_info() added by thomas-b.
 *  Syslog option added to monitoring feature by philipp.
 *  I/O helper structures and API refuctored by philipp.
 *  Service feature and API added by philipp.
 *  Database feature support added by philipp.
 *  Function to free ALL_USER_INFO structure added by thomas-b.
 *  MBG_EVENT stuff integrated with common/general monitoring
 *  stuff by philipp.
 *  Monitoring events refactored and tainted config support
 *  added by philipp.
 *  Account for renamed library symbol NSEC_PER_SEC.
 *  Documented some conversion functions for legacy parameters.
 *  Doxygen fixes.
 *  Revision 1.2  2017/07/05 12:17:38  martin
 *  Support functions for TLV, IMS, GPIO, and
 *  mbg_snprint_revision() provided by philipp.
 *  Support functions for network configuration,
 *  NTP configuration, ALL_UCAP stuff, SNMP and
 *  MONITORING, as well as ALL_PTP_V2_COMMON_DATASETS
 *  and ALL_PTP_V1_COMMON_DATASETS provided by thomas-b.
 *  Support functions for xmulti_ref and IO PORT stuff
 *  provided by philipp and thomas-b.
 *  More common GNSS support.
 *  New functions alloc_dev_hw_id() and chk_free_dev_hw_id().
 *  Tried portable printing of int64_t types.
 *  Account for frac_sec_from_bin() obsoleted by
 *  bin_frac_32_to_dec_frac().
 *  Revision 1.1  2014/04/25 09:14:49  martin
 *  Initial revision.
 *
 **************************************************************************/

#define _CFG_HLP
 #include <cfg_hlp.h>
#undef _CFG_HLP

#include <mbgerror.h>
#include <timeutil.h>
#include <str_util.h>
#include <myutil.h>
#include <mbgtime.h>

#if defined( _PRELIMINARY_CODE )
  #include <mbgmktm.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>



/*HDR*/
int chk_sw_rev_name( SW_REV *p, int verbose )
{
  if ( verbose > 1 )  // more than just verbose
    return 1;         // just return raw string

  trim_whitespace( p->name );

  // Some firmware versions have "CC_STANDARD" in their standard version,
  // which doesn't provide any valuable information.
  // We discard this by default.
  if ( strstr( p->name, "CC_STANDARD" ) )
    p->name[0] = 0;

  if ( verbose )
    return 1;  // calling app should display string, even if empty

  // calling app should display string only if not empty
  return strlen( p->name ) != 0;

}  // chk_sw_rev_name



/*HDR*/
int get_str_idx( const char *search,
                 const char *str_table[],
                 int n_entries )
{
  int i;

  for ( i = 0; i < n_entries; i++ )
    if ( strcmp( search, str_table[i] ) == 0 )
      return i;

  return -1;

}  // get_str_idx



/*HDR*/
int get_baud_rate_idx( BAUD_RATE baud_rate )
{
  int i;

  for ( i = 0; i < N_MBG_BAUD_RATES; i++ )
    if ( baud_rate == mbg_baud_rates[i] )
      return i;

  return -1;

}  // get_baud_rate_idx



/*HDR*/
int get_framing_idx( const char *framing )
{
  return get_str_idx( framing, mbg_framing_strs, N_MBG_FRAMINGS );

}  // get_framing_idx



/*HDR*/
void port_settings_from_port_parm_mode( PORT_SETTINGS *p_ps, uint8_t pp_mode,
                                        int cap_str_idx )
{
  if ( pp_mode >= LGCY_STR_UCAP )
  {
    // If @p pp_mode is ::LGCY_STR_UCAP or greater
    // then the string is a capture string which
    // can have the mode ::STR_AUTO or ::STR_ON_REQ,
    // and the string type is a capture string, which
    // usually has index 1 for legacy devices.
    p_ps->str_type = cap_str_idx;
    p_ps->mode = ( pp_mode == LGCY_STR_UCAP ) ? STR_AUTO : STR_ON_REQ;
  }
  else
  {
    // If @p pp_mode is less than ::LGCY_STR_UCAP
    // then the string is the default time string,
    // the format of which depends on the firmware
    // version if the device is legacy.
    // The mode numbers are compatible in this case.
    p_ps->str_type = 0;
    p_ps->mode = pp_mode;
  }

}  // port_settings_from_port_parm_mode



/*HDR*/
void port_parm_mode_from_port_settings( uint8_t *pp_mode, const PORT_SETTINGS *p_ps,
                                        int cap_str_idx )
{
  if ( p_ps->str_type == cap_str_idx )
  {
    // If the string type is a capture string
    // then convert the mode accordingly.
    *pp_mode = ( p_ps->mode == STR_ON_REQ ) ? LGCY_STR_UCAP_REQ : LGCY_STR_UCAP;
  }
  else
  {
    // Other string modes are compatible, so just copy the mode.
    *pp_mode = p_ps->mode;
  }

}  // port_parm_mode_from_port_settings



/*HDR*/
void port_settings_from_port_parm( PORT_SETTINGS *p_ps, int port_idx,
                                   const PORT_PARM *p_pp, int cap_str_idx )
{
  // The basic serial settings can simply be copied.
  p_ps->parm = p_pp->com[port_idx];

  // The string mode may need to be translated.
  port_settings_from_port_parm_mode( p_ps, p_pp->mode[port_idx],
                                     cap_str_idx );

}  // port_info_from_port_parm



/*HDR*/
void port_parm_from_port_settings( PORT_PARM *p_pp, int port_idx,
                                   const PORT_SETTINGS *p_ps, int cap_str_idx )
{
  // The basic serial settings can simply be copied.
  p_pp->com[port_idx] = p_ps->parm;

  // The string mode may need to be translated.
  port_parm_mode_from_port_settings( &p_pp->mode[port_idx],
                                     p_ps, cap_str_idx );

}  // port_parm_from_port_settings



/*HDR*/
uint32_t check_valid_port_info( const PORT_INFO *p_pi,
                                const STR_TYPE_INFO_IDX str_type_info_idx[],
                                int n_str_type )
{
  const PORT_SETTINGS *p_ps = &p_pi->port_settings;
  int idx;
  uint32_t flags = 0;


  if ( p_pi->supp_baud_rates & ~_mask( N_MBG_BAUD_RATES ) )
    flags |= MBG_PS_MSK_BAUD_RATE_OVR_SW;  // dev. supports more baud rates than driver

  idx = get_baud_rate_idx( p_ps->parm.baud_rate );

  if ( !_inrange( idx, 0, N_MBG_BAUD_RATES ) ||
       !_is_supported( idx, p_pi->supp_baud_rates ) )
    flags |= MBG_PS_MSK_BAUD_RATE;


  if ( p_pi->supp_framings & ~_mask( N_MBG_FRAMINGS ) )
    flags |= MBG_PS_MSK_FRAMING_OVR_SW;    // dev. supports more framings than driver

  idx = get_framing_idx( p_ps->parm.framing );

  if ( !_inrange( idx, 0, N_MBG_FRAMINGS ) ||
       !_is_supported( idx, p_pi->supp_framings ) )
    flags |= MBG_PS_MSK_FRAMING;


  if ( p_ps->parm.handshake >= N_COM_HS )
    flags |= MBG_PS_MSK_HS_OVR_SW;         // handshake index exceeds max.

  if ( p_ps->parm.handshake != HS_NONE )   // currently no device supports any handshake
    flags |= MBG_PS_MSK_HS;                // handshake mode not supp. by dev.


  if ( p_pi->supp_str_types & ~_mask( n_str_type ) )
    flags |= MBG_PS_MSK_STR_TYPE_OVR_SW;   // firmware error: more string types supported than reported

  idx = p_ps->str_type;

  if ( idx >= n_str_type )
    flags |= MBG_PS_MSK_STR_TYPE_OVR_DEV;  // string type index exceeds max.
  else
  {
    if ( !_is_supported( idx, p_pi->supp_str_types ) )
      flags |= MBG_PS_MSK_STR_TYPE;        // string type not supported by this port
    else
    {
      // Use the str_type index to get the supported output mode mask
      // from the string type info table. This is required to check
      // whether the selected mode is supported by the selected
      // string type.
      ulong supp_modes = str_type_info_idx[idx].str_type_info.supp_modes;

      if ( supp_modes & ~_mask( N_STR_MODE ) )
        flags |= MBG_PS_MSK_STR_MODE_OVR_SW;  // dev. supports more string modes than driver

      idx = p_ps->mode;

      if ( idx >= N_STR_MODE )                // mode is always >= 0
        flags |= MBG_PS_MSK_STR_MODE_OVR_SW;  // string mode index exceeds max.
      else
        if ( !_is_supported( idx, supp_modes ) )
          flags |= MBG_PS_MSK_STR_MODE;       // string mode not supp. by this string type and port
    }
  }


  if ( p_ps->flags != 0 )            /* currently always 0 */
    flags |= MBG_PS_MSK_FLAGS_OVR_SW | MBG_PS_MSK_FLAGS;


  return flags;

}  // check_valid_port_info



/*HDR*/
int valid_port_info( const PORT_INFO *p_pi,
                     const STR_TYPE_INFO_IDX str_type_info_idx[],
                     int n_str_type )
{
  return check_valid_port_info( p_pi, str_type_info_idx, n_str_type ) == 0;

}  // valid_port_info



/*HDR*/
int setup_port_info_from_port_parm( PORT_INFO_IDX pii[], const PORT_PARM *p_pp,
                                    const RECEIVER_INFO *p_ri )
{
  int i;

  for ( i = 0; i < p_ri->n_com_ports; i++ )
  {
    PORT_INFO_IDX *p_pii = &pii[i];
    PORT_INFO *p_pi = &p_pii->port_info;

    p_pii->idx = i;
    port_settings_from_port_parm( &p_pi->port_settings, i, p_pp, 1 );

    p_pi->supp_baud_rates = DEFAULT_GPS_BAUD_RATES_C166;
    p_pi->supp_framings = DEFAULT_GPS_FRAMINGS_C166;
    p_pi->supp_str_types = DEFAULT_SUPP_STR_TYPES_GPS;
  }

  return MBG_SUCCESS;

}  // setup_port_info_from_port_parm



/*HDR*/
int setup_default_str_type_info_idx( STR_TYPE_INFO_IDX stii[], const RECEIVER_INFO *p_ri )
{
  int i;

  for ( i = 0; i < p_ri->n_str_type; i++ )
  {
    STR_TYPE_INFO_IDX *stip = &stii[i];
    stip->idx = i;
    stip->str_type_info = default_str_type_info[i];
  }

  return MBG_SUCCESS;

}  // setup_default_str_type_info_idx



/*HDR*/
int chk_set_n_gnss_supp( ALL_GNSS_INFO *p_agi )
{
  p_agi->n_gnss_supp = num_bits_set( p_agi->gnss_mode_info.supp_gnss_types );

  if ( p_agi->n_gnss_supp > N_GNSS_TYPES )
    return MBG_ERR_N_GNSS_EXCEEDS_SUPP;

  return MBG_SUCCESS;

}  // chk_set_n_gnss_supp



/*HDR*/
void setup_gps_only_sat_info_idx_from_statinfo( ALL_GNSS_INFO *p_agi )
{
  STAT_INFO *p_si = &p_agi->stat_info;
  GNSS_SAT_INFO_IDX *p_gsii = &p_agi->gnss_sat_info_idx[GNSS_TYPE_GPS];
  GNSS_SAT_INFO *p_gsi = &p_gsii->gnss_sat_info;

  memset( p_gsii, 0, sizeof( *p_gsii ) );
  p_gsii->idx = GNSS_TYPE_GPS;

  p_gsi->gnss_type = GNSS_TYPE_GPS;
  p_gsi->svs_in_view = p_si->svs_in_view;
  p_gsi->good_svs = p_si->good_svs;

}  // setup_gps_only_sat_info_idx_from_statinfo



/*HDR*/
int setup_gps_only_gnss_info_from_statinfo( ALL_GNSS_INFO *p_agi )
{
  MBG_GNSS_MODE_INFO *p_gmi = &p_agi->gnss_mode_info;

  memset( p_gmi, 0, sizeof( *p_gmi ) );

  p_gmi->supp_gnss_types = MBG_GNSS_TYPE_MSK_GPS;
  p_gmi->settings.gnss_set = p_gmi->supp_gnss_types;

  memset( p_agi->gnss_sat_info_idx, 0, sizeof( p_agi->gnss_sat_info_idx ) );

  setup_gps_only_sat_info_idx_from_statinfo( p_agi );

  return chk_set_n_gnss_supp( p_agi );

}  // setup_gps_only_gnss_info_from_statinfo



/*HDR*/
void chk_free_dev_hw_id( DEVICE_INFO *p )
{
  if ( p->hw_id )
  {
    free( p->hw_id );
    p->hw_id = NULL;
  }

}  // chk_free_dev_hw_id



/*HDR*/
int alloc_dev_hw_id( DEVICE_INFO *p, size_t len )
{
  if ( p->hw_id )
    return MBG_ERR_ALREADY_ALLOC;


  p->hw_id = (char *) malloc( len );

  if ( p->hw_id == NULL )
    return MBG_ERR_NO_MEM;

  return MBG_SUCCESS;

}  // alloc_dev_hw_id



/*HDR*/
const char *get_fw_id_from_hw_id( const char *hw_id )
{
  int i;

  for ( i = 0; i < N_SUPP_DEV_TOTAL; i++ )
  {
    DEVICE_INFO *p = &device_list[i];

    if ( strlen( p->fw_id ) && p->hw_id )  //### TODO check if this still works as expected
    {
      if ( strcmp( hw_id, p->hw_id ) == 0 )
      {
        if ( strlen( p->fw_id ) > 0 )
          return p->fw_id;

        #if defined( DEBUG )
          fprintf( stderr, "Length of fw_id is 0 in %s for device %i (%s)\n",
                   __func__, i, p->hw_id );
        #endif
      }
    }
  }

  return NULL;

}  // get_fw_id_from_hw_id



/*HDR*/
const char *get_hw_id_from_fw_id( const char *fw_id )
{
  int i;

  for ( i = 0; i < N_SUPP_DEV_TOTAL; i++ )
  {
    DEVICE_INFO *p = &device_list[i];

    if ( strlen( p->fw_id ) && p->hw_id )  //### TODO check if this still works as expected
    {
      if ( strcmp( fw_id, p->fw_id ) == 0 )
      {
        if ( strlen( p->hw_id ) > 0 )
          return p->hw_id;

        #if defined( DEBUG )
          fprintf( stderr, "Length of hw_id is 0 in %s for device %i (%s)\n",
                   __func__, i, p->fw_id );
        #endif
      }
    }
  }

  return NULL;

}  // get_hw_id_from_fw_id



/*HDR*/
MBG_IO_PORT_TYPE_INFO* get_io_port_type_info( const MBG_IO_PORT *port,
                                              uint16_t port_type )
{
  unsigned i;
  MBG_IO_PORT_TYPE_INFO *pti;

  if ( !port )
    return NULL;

  for ( i = 0; i < port->p_info.num_types; ++i )
  {
    pti = &port->pt_infos[i];

    if ( pti->port_type == port_type )
    {
      if ( pti->port_type == MBG_IO_PORT_TYPE_GPIO )
      {
        if ( pti->data.gpio_limits.type == port->setts->data.gpio_settings.type )
          return pti;
      }
      else
        return pti;
    }
  }

  return NULL;

}  // get_io_port_type_info



/*HDR*/
void mbg_tlv_announce_init( MBG_TLV_ANNOUNCE *tlv, MBG_TLV_UID uid,
                            MBG_TLV_TYPE tlv_feat_type, uint32_t total_bytes )
{
  memset( tlv, 0, sizeof( *tlv ) );
  tlv->data.uid = uid;
  tlv->data.type = tlv_feat_type;
  tlv->data.total_bytes = total_bytes;
  tlv->data.reserved_1 = 0;
  tlv->reserved_1 = 0;
  tlv->reserved_2 = 0;

}  // mbg_tlv_announce_init



/*HDR*/
void mbg_tlv_init( MBG_TLV *tlv, MBG_TLV_UID uid,
                   MBG_TLV_TYPE tlv_type, uint32_t total_bytes )
{
  memset( tlv, 0, sizeof( *tlv ) );
  tlv->hdr.uid = uid;
  tlv->hdr.tlv_type = tlv_type;
  tlv->hdr.cur_bytes = 0;
  tlv->hdr.trans_bytes = 0;
  tlv->hdr.total_bytes = total_bytes;
  tlv->hdr.reserved_1 = 0;
  tlv->hdr.reserved_2 = 0;
  tlv->hdr.reserved_3 = 0;

}  // mbg_tlv_init



/*HDR*/
void mbg_tlv_rcv_state_init( MBG_TLV_RCV_STATE *state, MBG_TLV_UID uid, uint32_t total_bytes )
{
  state->data.uid = uid;
  state->data.type = 0;
  state->data.total_bytes = total_bytes;
  state->data.reserved_1 = 0;
  state->read_bytes = 0;
  state->reserved_1 = 0;

}  // mbg_tlv_state_init



/*HDR*/
int mbg_snprint_revision( char *buf, size_t buflen,
                          const char *prefix, const char *suffix,
                          uint32_t rev)
{
  size_t bytes = 0;
  uint32_t major, minor, patch;

  if ( prefix )
    bytes += snprintf_safe( &buf[bytes], buflen, "%s", prefix );

  _mbg_decode_revision( rev, major, minor, patch );
  bytes += snprintf_safe( &buf[bytes], buflen - bytes, "%u.%u.%u",
                          major, minor, patch);

  if ( suffix )
    bytes += snprintf_safe( &buf[bytes], buflen - bytes, "%s", suffix );

  return _int_from_size_t( bytes );

}  // mbg_snprint_revision



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_receiver_info( const RECEIVER_INFO *p )
{
  // Make sure this program supports at least as many serial ports
  // as the current device.
  if ( p->n_com_ports > MAX_PARM_PORT )
    return MBG_ERR_N_COM_EXCEEDS_SUPP;

  // Make sure this program supports at least as many string types
  // as the current device.
  if ( p->n_str_type > MAX_PARM_STR_TYPE )
    return MBG_ERR_N_STR_EXCEEDS_SUPP;

  // Make sure this program supports at least as many programmable
  // outputs as the current device.
  if ( p->n_prg_out > MAX_PARM_POUT )
    return MBG_ERR_N_STR_EXCEEDS_SUPP;

  return MBG_SUCCESS;

}  // chk_dev_receiver_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_xbp_supp_nodes( const ALL_XBP_INFO *info )
{
  if ( info )
  {
    if ( ( info->limits.features & XBP_FEAT_MASK_NODES ) == XBP_FEAT_MASK_NODES )
      return MBG_SUCCESS;

    return MBG_ERR_NOT_SUPP_BY_DEV;
  }

  return MBG_ERR_INV_PARM;

} // chk_dev_xbp_supp_nodes



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_net_cfg_supp_stage_2( const ALL_NET_CFG_INFO *info )
{
  if ( info->glb_cfg_info.feat_flags & MBG_NET_GLB_SUPP_STAGE_2_MASK )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_net_cfg_supp_stage_2



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_ntp_supp_client( const ALL_NTP_CFG_INFO *info )
{
  if ( ( ( info->glb_info.supp_ntp_roles & NTP_MSK_ROLE_CLIENT ) == NTP_MSK_ROLE_CLIENT ) ||
       ( ( info->glb_info.supp_ntp_roles & NTP_MSK_ROLE_CLIENT_SERVER ) == NTP_MSK_ROLE_CLIENT_SERVER ) )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_ntp_supp_client


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_ntp_supp_server( const ALL_NTP_CFG_INFO *info )
{
  if ( ( ( info->glb_info.supp_ntp_roles & NTP_MSK_ROLE_SERVER ) == NTP_MSK_ROLE_SERVER ) ||
       ( ( info->glb_info.supp_ntp_roles & NTP_MSK_ROLE_CLIENT_SERVER ) == NTP_MSK_ROLE_CLIENT_SERVER ) )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_ntp_supp_server


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_mrf_none( const ALL_XMULTI_REF_INFO *info )
{
  if ( ( info->instances.flags & XMRIF_MSK_MRF_NONE_SUPP ) == XMRIF_MSK_MRF_NONE_SUPP )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_xmulti_ref_supp_mrf_none


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_ext_src_info( const ALL_XMULTI_REF_INFO *info )
{
  if ( ( info->instances.flags & XMRIF_MSK_EXT_SRC_INFO_SUPP ) == XMRIF_MSK_EXT_SRC_INFO_SUPP )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_xmulti_ref_supp_ext_src_info


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_holdover_status( const ALL_XMULTI_REF_INFO *info )
{
  if ( ( info->instances.flags & XMRIF_MSK_HOLDOVER_STATUS_SUPP ) == XMRIF_MSK_HOLDOVER_STATUS_SUPP )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_xmulti_ref_supp_holdover_status


/*HDR*/
/*
 * Type is NOT an index of ::XMULTI_REF_INSTANCES::n_xmr_settings,
 * but of ::MULTI_REF_TYPES.
 * Depends on chk_dev_supp_xmulti_ref_ext_src_info.
 * @see chk_dev_supp_xmulti_ref_ext_src_info
 */
_NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_ext_source_stats( const ALL_XMULTI_REF_INFO *info, int type )
{
  if (
       ( type < N_MULTI_REF ) &&
       (( info->ext_src_infos[type].info.feat_flags & XMR_EXT_SRC_FEAT_FLAG_MSK_STATS ) == XMR_EXT_SRC_FEAT_FLAG_MSK_STATS )
     ) return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_xmulti_ref_supp_ext_source_stats


/*HDR*/
/*
 * Type is NOT an index of ::XMULTI_REF_INSTANCES::n_xmr_settings,
 * but of ::MULTI_REF_TYPES.
 * Depends on chk_dev_supp_xmulti_ref_ext_src_info.
 * @see chk_dev_supp_xmulti_ref_ext_src_info
 */
_NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_ext_source_metrics( const ALL_XMULTI_REF_INFO *info, int type )
{
  if (
       ( type < N_MULTI_REF ) &&
       (( info->ext_src_infos[type].info.feat_flags & XMR_EXT_SRC_FEAT_FLAG_MSK_METRICS ) == XMR_EXT_SRC_FEAT_FLAG_MSK_METRICS )
     ) return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_xmulti_ref_supp_ext_source_metrics


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_ims_has_fdm( const ALL_IMS_INFO *info )
{
  if ( ( info->state.flags & MBG_IMS_STATE_FLAG_MSK_HAS_FDM ) == MBG_IMS_STATE_FLAG_MSK_HAS_FDM )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_ims_has_fdm


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_ims_is_volt_out_enabled( const ALL_IMS_STATE *ims_state, unsigned idx )
{
  const MBG_IMS_SENSOR_STATE *sstate = &ims_state->sensor_state_idx[idx].state;

  if (
        ( sstate->type == MBG_IMS_SENSOR_VOLTAGE ) &&
        ( ( sstate->flags & MBG_IMS_SENSOR_VOLTAGE_OUT_ENB ) == MBG_IMS_SENSOR_VOLTAGE_OUT_ENB )
     ) return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_ims_is_volt_out_enabled


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_ims_is_volt_out_overload( const ALL_IMS_STATE *ims_state, unsigned idx )
{
  const MBG_IMS_SENSOR_STATE *sstate = &ims_state->sensor_state_idx[idx].state;

  if (
        ( sstate->type == MBG_IMS_SENSOR_VOLTAGE ) &&
        ( ( sstate->flags & MBG_IMS_SENSOR_VOLTAGE_OUT_OVR ) == MBG_IMS_SENSOR_VOLTAGE_OUT_OVR )
     ) return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_ims_is_volt_out_overload


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_ims_is_pll_locked( const ALL_IMS_STATE *ims_state, unsigned idx )
{
  const MBG_IMS_SENSOR_STATE *sstate = &ims_state->sensor_state_idx[idx].state;

  if (
        ( sstate->type == MBG_IMS_SENSOR_PLL ) &&
        ( ( sstate->flags & MBG_IMS_SENSOR_PLL_LOCKED ) == MBG_IMS_SENSOR_PLL_LOCKED )
     ) return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_ims_is_pll_locked


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_gpio_supp_ass_idx( const ALL_GPIO_INFO *gpio_info, unsigned idx )
{
  const MBG_GPIO_LIMITS *limits = &gpio_info->infos[idx].info.limits;

  if ( ( limits->supp_flags & MSK_MBG_GPIO_DEPENDS_ON_ASS_IO_IDX ) == MSK_MBG_GPIO_DEPENDS_ON_ASS_IO_IDX )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_gpio_supp_ass_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_gpio_dep_on_ass_idx( const ALL_GPIO_INFO *gpio_info, unsigned idx )
{
  const MBG_GPIO_SETTINGS *settings = &gpio_info->infos[idx].info.settings;

  if ( ( settings->flags & MSK_MBG_GPIO_DEPENDS_ON_ASS_IO_IDX ) == MSK_MBG_GPIO_DEPENDS_ON_ASS_IO_IDX )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_gpio_dep_on_ass_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API chk_dev_gpio_has_status( const ALL_GPIO_INFO *info )
{
  if ( ( info->cfg_limits.flags & MBG_GPIO_CFG_LIMIT_FLAG_MASK_STATUS_SUPP ) == MBG_GPIO_CFG_LIMIT_FLAG_MASK_STATUS_SUPP )
    return MBG_SUCCESS;

  return MBG_ERR_NOT_SUPP_BY_DEV;

} // chk_dev_gpio_has_status



/*HDR*/
void free_all_xbp_info ( ALL_XBP_INFO *p )
{
  if ( p )
  {
    if ( p->node_limits )
      free( p->node_limits );

    if ( p->node_infos )
      free( p->node_infos );

    free( p );
  }

} // free_all_xbp_info



/*HDR*/
void free_all_net_cfg_info ( ALL_NET_CFG_INFO *p )
{
  if ( p )
  {
    if ( p->link_infos )
      free( p->link_infos );

    if ( p->addr_infos )
      free( p->addr_infos );

    if ( p->dns_srvrs )
      free( p->dns_srvrs );

    if ( p->dns_srch_doms )
      free( p->dns_srch_doms );

    if ( p->route_infos )
      free( p->route_infos );

    free( p );
  }

} // free_all_net_cfg_info



/*HDR*/
void free_all_net_status_info ( ALL_NET_STATUS_INFO *p )
{
  if ( p )
  {
    if ( p->link_infos )
      free( p->link_infos );

    if ( p->addr_infos )
      free( p->addr_infos );

    if ( p->dns_srvrs )
      free( p->dns_srvrs );

    if ( p->dns_srch_doms )
      free( p->dns_srch_doms );

    if ( p->route_infos )
      free( p->route_infos );

    free( p );
  }

} // free_all_net_status_info



/*HDR*/
void free_all_snmp_info ( ALL_SNMP_INFO *p )
{
  if ( p )
  {
    if ( p->v12_infos )
      free( p->v12_infos );

    if ( p->v12_trap_infos )
      free( p->v12_trap_infos );

    if ( p->v3_infos )
      free( p->v3_infos );

    if ( p->v3_trap_infos )
      free( p->v3_trap_infos );

    free( p );
  }

} // free_all_snmp_info



/*HDR*/
void free_all_syslog_info ( ALL_SYSLOG_INFO *p )
{
  if ( p )
  {
    if ( p->servers )
    {
      unsigned i;
      MBG_SYSLOG_SERVER *srv;

      for (i = 0; i < p->glb_info.settings.num_servers; ++i)
      {
        srv = &p->servers[i];

        if ( srv->release_priv )
          srv->release_priv( srv );
      }

      free( p->servers );
    }

    free( p );
  }

} // free_all_syslog_info



/*HDR*/
void free_all_monitoring_info ( ALL_MONITORING_INFO *p )
{
  if ( p )
  {
    if ( p->all_snmp_info )
      free_all_snmp_info( p->all_snmp_info );

    if ( p->all_events )
      free_all_events( p->all_events );

    if ( p->all_syslog_info )
      free_all_syslog_info( p->all_syslog_info );

    free ( p );
  }
}


/*HDR*/
void free_all_events( ALL_EVENTS *p )
{
  if ( p )
  {
    if ( p->events )
    {
      unsigned i;
      MBG_EVENT *evt;

      for (i = 0; i < p->num_events; ++i)
      {
        evt = &p->events[i];

        if ( evt->release_priv )
          evt->release_priv( evt );

        if ( evt->release_backref )
          evt->release_backref( evt );

        if ( evt->dict_entries )
          free ( evt->dict_entries );
      }

      free( p->events );
    }

    free ( p );
  }
}


/*HDR*/
void free_all_xmulti_ref_info( ALL_XMULTI_REF_INFO *p )
{
  if ( p )
  {
    if ( p->infos )
      free( p->infos );

    if ( p->ext_src_infos )
      free( p->ext_src_infos );

    free ( p );
  }

}  // free_all_xmulti_ref_info



/*HDR*/
void free_all_xmulti_ref_status( ALL_XMULTI_REF_STATUS *p )
{
  if ( p )
  {
    if ( p->status )
      free( p->status );

    if ( p->holdover_status )
      free( p->holdover_status );

    if ( p->stats_idx )
      free( p->stats_idx );

    if ( p->metrics_idx )
      free( p->metrics_idx );

    free( p );
  }

}  // free_all_xmulti_ref_status



/*HDR*/
void free_all_ptp_v1_common_datasets( ALL_PTP_V1_COMMON_DATASETS *p )
{
  if ( p )
  {
    if ( p->port_datasets )
      free( p->port_datasets );

    free( p );
  }

}  // free_all_ptp_v1_common_datasets



/*HDR*/
void free_all_ptp_v2_common_datasets( ALL_PTP_V2_COMMON_DATASETS *p )
{
  if ( p )
  {
    if ( p->port_datasets )
      free( p->port_datasets );

    free( p );
  }

}  // free_all_ptp_v2_common_datasets



/*HDR*/
void free_all_ntp_cfg_info( ALL_NTP_CFG_INFO *p )
{
  if ( p )
  {
    if ( p->symm_key_limits )
      free( p->symm_key_limits );

    if ( p->symm_key_info_idx )
      free( p->symm_key_info_idx );

    if ( p->trusted_key_info_idx )
      free( p->trusted_key_info_idx );

    if ( p->clnt_info )
      free( p->clnt_info );

    if ( p->peer_settings_idx )
      free( p->peer_settings_idx );

    if ( p->srv_info )
      free( p->srv_info );

    if ( p->refclk_info_idx )
      free( p->refclk_info_idx );

    if ( p->misc_limits )
      free( p->misc_limits );

    if ( p->orphan_mode_info )
      free( p->orphan_mode_info );

    free( p );
  }

}  // free_all_ntp_cfg_info



/*HDR*/
void free_all_ntp_status( ALL_NTP_STATUS *p )
{
  if ( p )
  {
    if ( p->refclk_states )
      free( p->refclk_states );

    if ( p->peer_states )
      free( p->peer_states );

    free( p );
  }

}  // free_all_ntp_status



/*HDR*/
void free_all_ims_info( ALL_IMS_INFO *p )
{
  if ( p )
  {
    if ( p->fdm_info )
      free( p->fdm_info );

    if ( p->fdm_limits )
      free( p->fdm_limits );

    if ( p->fdm_outinfo_idx )
      free( p->fdm_outinfo_idx );

    free( p );
  }

}  // free_all_ims_info



/*HDR*/
void free_all_ims_state( ALL_IMS_STATE *p )
{
  if ( p )
  {
    if ( p->sensor_state_idx )
      free( p->sensor_state_idx );

    if ( p->fdm_state )
      free( p->fdm_state );

    if ( p->fdm_output_state_idx )
      free( p->fdm_output_state_idx );

    free( p );
  }

}  // free_all_ims_state



/*HDR*/
void free_all_gpio_info( ALL_GPIO_INFO *p )
{
  if ( p )
  {
    if ( p->infos )
      free( p->infos );

    free( p );
  }

} // free_all_gpio_info



/*HDR*/
void free_all_io_ports( ALL_MBG_IO_PORTS *p )
{
  if ( p )
  {
    if ( p->ports )
    {
      unsigned i;
      MBG_IO_PORT *port;

      for ( i = 0; i < p->num_ports; ++i )
      {
        port = &p->ports[i];

        if ( port->free_priv_data )
          port->free_priv_data( port, port->priv_data );

        if ( port->pt_infos )
            free( port->pt_infos );
      }

      free( p->ports );
    }

    free( p );
  }

} // free_all_io_ports


/*HDR*/
void free_all_gpio_state( ALL_GPIO_STATE *p )
{
  if ( p )
  {
    if ( p->states )
      free( p->states );

    free( p );
  }

} // free_all_gpio_state



/*HDR*/
UCAP_ENTRY* calloc_ucap_entry( void )
{
  UCAP_ENTRY *entry = (UCAP_ENTRY *) calloc( 1, sizeof( *entry ) );

  if ( entry )
    mbg_klist_init( &entry->head );

  return entry;

} // calloc_ucap_entry


/*HDR*/
void free_all_ucap_info( ALL_UCAP_INFO *p )
{
  if ( p )
  {
    UCAP_ENTRY *entry;

    while ( !mbg_klist_is_empty( &p->list ) )
    {
      entry = mbg_klist_first_entry( &p->list, UCAP_ENTRY, head );
      mbg_klist_delete_item( &entry->head );
      free( entry );
    }

    free( p );
  }

} // free_all_ucap_info


/*HDR*/
void free_all_ucap_net_info( ALL_UCAP_NET_INFO *p )
{
  if ( p )
  {
    if ( p->recv_infos )
      free( p->recv_infos );

    free( p );
  }

} // free_all_ucap_net_info



/*HDR*/
void free_all_user_info( ALL_USER_INFO *p )
{
  if ( p )
  {
    if ( p->users )
    {
      unsigned i;
      MBG_USER *usr;

      for ( i = 0; i < p->user_mngmnt_info.settings.num_users; ++i )
      {
        usr = &p->users[i];

        if ( usr->release_priv )
          usr->release_priv( usr );

        if ( usr->release_backref )
          usr->release_backref( usr );
      }

      free( p->users );
    }

    free( p );
  }
}



/*HDR*/
void free_all_svc_info( ALL_SERVICE_INFO *p )
{
  if ( p )
  {
    if ( p->svcs )
    {
      unsigned i;
      MBG_SERVICE *svc;

      for ( i = 0; i < p->mgmt_info.num_services; ++i )
      {
          svc = &p->svcs[i];

        if ( svc->release_priv )
          svc->release_priv( svc );

        if ( svc->release_backref )
          svc->release_backref( svc );
      }

      free( p->svcs );
    }

    free( p );
  }
}


/*HDR*/
void free_all_firmware_info( ALL_FIRMWARE_INFO *p )
{
  if ( p )
  {
    if ( p->firmwares )
    {
      MBG_FIRMWARE_UFU *ufu;
      MBG_FIRMWARE *fw;
      unsigned i, j;

      for ( i = 0; i < p->glb_info.installed_fws; ++i )
      {
        fw = &p->firmwares[i];

        for ( j = 0; j < fw->info.num_ufus; ++j )
        {
          ufu = &fw->ufus[j];

          if ( ufu->release_priv )
            ufu->release_priv( ufu );
        }
        free( fw->ufus );

        if ( fw->release_priv )
          fw->release_priv( fw );
      }

      free( p->firmwares );
    }

    free( p );
  }
}



/*HDR*/
void free_all_database_info( ALL_DATABASE_INFO *p )
{
  if ( !p )
    return;

  if ( p->dbs )
  {
    uint8_t i;
    MBG_DATABASE *db;

    for ( i = 0; i < p->glb_info.num_dbs; ++i )
    {
        db = &p->dbs[i];

        if ( db->release_priv )
            db->release_priv( db );
    }

    free( p->dbs );
  }

  free( p );
}



/*HDR*/
void str_ntp_hex_to_ntp_tstamp( const char *s, NTP_TSTAMP *p )
{
  char *cp = NULL;

  p->seconds = strtoul( s, &cp, 16 );

  if ( *cp == '.' )  // fractions may follow
  {
    cp++;  // skip '.'

    p->fractions = strtoul( cp, NULL, 16 );
  }
  else
    p->fractions = 0;

}  // str_ntp_hex_to_ntp_tstamp



#if !defined( MBG_TGT_MISSING_64_BIT_TYPES )

/*HDR*/
void ntp_tstamp_to_nanotime_64( const NTP_TSTAMP *p_nts, NANO_TIME_64 *p_nt64 )
{
  p_nt64->secs = p_nts->seconds - NTP_SEC_BIAS;
  p_nt64->nano_secs = bin_frac_32_to_dec_frac( p_nts->fractions, NSEC_PER_SEC );

}  // ntp_tstamp_to_nanotime_64



/*HDR*/
void str_ntp_hex_to_nano_time_64( const char *s, NANO_TIME_64 *p )
{
  NTP_TSTAMP nts = { 0 };

  str_ntp_hex_to_ntp_tstamp( s, &nts );
  ntp_tstamp_to_nanotime_64( &nts, p );

}  // str_ntp_hex_to_nano_time_64

#endif  // !defined( MBG_TGT_MISSING_64_BIT_TYPES )