cfg_hlp.h

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: cfg_hlp.h 1.6 2018/09/20 11:22:11 martin REL_M $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Definitions and prototypes for configuration programs.
 *
 *    WARNING: Changing the constants defined here affects the size of
 *    the related structures and arrays, and thus would break compatibility
 *    if used in DLLs / shared object libraries.
 *
 *    Care must be taken that the number of objects supported by
 *    any particular device (which can be only determined at runtime)
 *    does not exceed the max. number of objects specified here
 *    for the configuration programs.
 *
 * -----------------------------------------------------------------------
 *  $Log: cfg_hlp.h $
 *  Revision 1.6  2018/09/20 11:22:11  martin
 *  Renamed some global variables to more common names.
 *  Added string initializer tables and associated macros
 *  for some PTP configuration stuff.
 *  Revision 1.5  2018/07/05 10:37:05Z  martin
 *  Renamed setup_port_info_from_port_settings()
 *  to setup_port_info_from_port_parm().
 *  Initializer for OS targets added by philipp.
 *  Database feature support added by philipp.
 *  I/O helper structures and API refuctored by philipp.
 *  Firmware management wrapper structs added by philipp.
 *  Syslog option added to monitoring feature by philipp.
 *  Service feature and API added by philipp.
 *  Return random UID for TLVs under Windows.
 *  MBG_EVENT stuff integrated with common/general monitoring
 *  stuff by philipp.
 *  Monitoring events refactored and tainted config support
 *  added by philipp.
 *  Exclude some function from build in kernel mode.
 *  Fixed build for NetBSD.
 *  Supporting MBG_TGT_NO_TGT.
 *  Updated function prototypes.
 *  Revision 1.4  2017/07/05 13:22:00  martin
 *  Definitions for TLV, IMS, and GPIO provided by philipp.
 *  Definitions for ALL_XPB_INFO, ALL_NET_CFG_INFO,
 *  ALL_PTP_V2_COMMON_DATASETS, ALL_PTP_V1_COMMON_DATASETS,
 *  ALL_UCAP and associated stuff provided by thomas-b.
 *  Definitions for xmulti_ref and IO PORT, SNMP and MONITORING,
 *  and associated stuff provided by philipp and thomas-b.
 *  New definitions COMP_SIG_MODES and PCPS_TIME_EXT_FLAGS.
 *  New inline functions device_id_is_serial() and
 *  device_id_is_lan().
 *  Moved inline function num_bits_set() and a lot of
 *  global configuration variables here.
 *  Older defines N_SUPP_DEV, PCPS_MAX_DDEVS, and MBG_MAX_DEVICES
 *  have been obsoleted by new defines N_SUPP_DEV_BUS, N_SUPP_DEV_EXT,
 *  and N_SUPP_DEV_TOTAL.
 *  Updated function prototypes.
 *  Revision 1.3  2013/09/25 10:02:15  martin
 *  Added ALL_PTP_CFG_INFO, ALL_GNSS_SAT_INFO_IDX and
 *  related definitions.
 *  Added doxygen comments.
 *  Revision 1.2  2012/10/02 18:16:26  martin
 *  Modified some typedefs to be more compliant with the underlying types.
 *  Revision 1.1  2011/09/21 15:59:59  martin
 *  Initial revision.
 *
 **************************************************************************/

#ifndef _CFG_HLP_H
#define _CFG_HLP_H


/* Other headers to be included */

#include <gpsdefs.h>
#include <mbgklist.h>

#if !defined( MBG_TGT_KERNEL )
  #include <stdlib.h>
  #include <string.h>
#endif

#if defined( _PRELIMINARY_CODE )
  #if defined( MBG_TGT_POSIX )
    #include <sys/stat.h>
    #include <time.h>
  #endif // MBG_TGT_POSIX

  #if defined( MBG_TGT_LINUX )
    #include <sys/sysinfo.h>
  #endif // MBG_TGT_LINUX

#endif // _PRELIMINARY_CODE

#ifdef _CFG_HLP
 #define _ext
 #define _DO_INIT
#else
 #define _ext extern
#endif


/* Start of header body */

#ifdef __cplusplus
extern "C" {
#endif


#if 1  // ### TODO cleanup

#define N_SUPP_DEV_BUS   16
#define N_SUPP_DEV_EXT    1

#define N_SUPP_DEV_TOTAL   ( N_SUPP_DEV_BUS + N_SUPP_DEV_EXT )

typedef struct _DEVICE_INFO
{
  char *hw_id;
  char fw_id[100];

} DEVICE_INFO;

_ext DEVICE_INFO device_list[N_SUPP_DEV_TOTAL];

#endif



#define MAX_PARM_PORT        10

#define MAX_PARM_STR_TYPE    20

#define MAX_PARM_POUT        10

#define MAX_PARM_GNSS_SAT  N_GNSS_TYPES

#define MAX_PARM_PTP_UC_MASTER    3

#define MAX_PARM_EXT_NTP_SRVR  20

#define MAX_PARM_GPIO    10

#define MAX_PARM_XMR     10

#define MAX_EXT_NTP_SERVERS  20

#define MAX_MBG_TIME_MON_MODULES 10

#define MAX_MBG_TIME_MON_TARGETS 100



typedef PORT_INFO_IDX ALL_PORT_INFO_IDX[MAX_PARM_PORT];

typedef STR_TYPE_INFO_IDX ALL_STR_TYPE_INFO_IDX[MAX_PARM_STR_TYPE];

typedef struct
{
  ALL_PORT_INFO_IDX pii;       
  ALL_STR_TYPE_INFO_IDX stii;  
  PORT_PARM tmp_pp;            

} RECEIVER_PORT_CFG;



typedef struct
{
  XBP_LIMITS limits;
  XBP_NODE_LIMITS* node_limits;
  XBP_NODE_INFO_IDX* node_infos;
} ALL_XBP_INFO;



typedef POUT_INFO_IDX ALL_POUT_INFO_IDX[MAX_PARM_POUT];



typedef struct
{
  MBG_NET_GLB_CFG_INFO glb_cfg_info;
  MBG_NET_INTF_LINK_INFO_IDX *link_infos;
  MBG_NET_INTF_ADDR_INFO_IDX *addr_infos;
  MBG_IP_ADDR_IDX *dns_srvrs;
  MBG_NET_NAME_IDX *dns_srch_doms;
  MBG_NET_INTF_ROUTE_INFO_IDX *route_infos;
} ALL_NET_CFG_INFO;

typedef ALL_NET_CFG_INFO ALL_NET_STATUS_INFO;



typedef struct
{
  MBG_SNMP_GLB_INFO glb_info;
  MBG_SNMP_V12_INFO_IDX *v12_infos;
  MBG_SNMP_V12_TRAP_INFO_IDX *v12_trap_infos;
  MBG_SNMP_V3_INFO_IDX *v3_infos;
  MBG_SNMP_V3_TRAP_INFO_IDX *v3_trap_infos;

} ALL_SNMP_INFO;



typedef struct mbg_event
{
  unsigned idx;
  MBG_EVENT_INFO info;
  MBG_EVENT_STATUS status;
  MBG_EVENT_VALUE *dict_entries;
  /* Pointer for 3rd party to connect some data */
  void *backref;
  /* Pointer for the mallocer to connect some private data */
  void *priv_data;
  /*
   * Can be used to free/release priv or cookie data (if necessary)
   * or do other stuff before event gets freed. But NEVER use release
   * to free the event itself!! This is done by the API right after calling
   * release.
   */
  void (*release_priv)(struct mbg_event*);
  void (*release_backref)(struct mbg_event*);

} MBG_EVENT;

typedef struct
{
  unsigned num_events;
  MBG_EVENT *events;

} ALL_EVENTS;


typedef struct mbg_syslog_server
{
  unsigned idx;
  MBG_SYSLOG_INFO info;

  /* Pointer for the mallocer to connect some private data */
  void *priv_data;
  /*
   * Can be used to free/release priv or cookie data (if necessary)
   * or do other stuff before event gets freed. But NEVER use release
   * to free the event itself!! This is done by the API right after calling
   * release.
   */
  void (*release_priv)(struct mbg_syslog_server*);

} MBG_SYSLOG_SERVER;

typedef struct
{
  MBG_SYSLOG_GLB_INFO glb_info;
  MBG_SYSLOG_SERVER *servers;

} ALL_SYSLOG_INFO;


typedef struct
{
  MBG_MONITORING_LIMITS limits;
  ALL_SNMP_INFO *all_snmp_info;
  ALL_EVENTS *all_events;
  ALL_SYSLOG_INFO *all_syslog_info;

} ALL_MONITORING_INFO;



typedef PTP_UC_MASTER_INFO_IDX ALL_PTP_UC_MASTER_INFO_IDX[MAX_PARM_PTP_UC_MASTER];

typedef struct
{
  PTP_CFG_INFO ptp_cfg_info;
  PTP_UC_MASTER_CFG_LIMITS ptp_uc_master_cfg_limits;
  ALL_PTP_UC_MASTER_INFO_IDX all_ptp_uc_master_info_idx;

} ALL_PTP_CFG_INFO;



typedef struct
{
  MBG_PTP_V1_DEFAULT_DATASET default_dataset;
  MBG_PTP_V1_CURRENT_DATASET current_dataset;
  MBG_PTP_V1_PARENT_DATASET parent_dataset;
  MBG_PTP_V1_TIME_PROPERTIES_DATASET time_properties_dataset;
  MBG_PTP_V1_PORT_DATASET_IDX *port_datasets;

} ALL_PTP_V1_COMMON_DATASETS;



typedef struct
{
  MBG_PTP_V2_DEFAULT_DATASET default_dataset;
  MBG_PTP_V2_CURRENT_DATASET current_dataset;
  MBG_PTP_V2_PARENT_DATASET parent_dataset;
  MBG_PTP_V2_TIME_PROPERTIES_DATASET time_properties_dataset;
  MBG_PTP_V2_PORT_DATASET_IDX *port_datasets;

} ALL_PTP_V2_COMMON_DATASETS;



typedef GNSS_SAT_INFO_IDX  ALL_GNSS_SAT_INFO_IDX[MAX_PARM_GNSS_SAT];



typedef struct
{
  STAT_INFO stat_info;
  int n_gnss_supp;
  MBG_GNSS_MODE_INFO gnss_mode_info;
  ALL_GNSS_SAT_INFO_IDX gnss_sat_info_idx;

} ALL_GNSS_INFO;



typedef NTP_PEER_SETTINGS ALL_NTP_PEER_SETTINGS[MAX_EXT_NTP_SERVERS];

typedef struct
{
  ALL_NTP_PEER_SETTINGS all_ntp_peer_settings;

} NTP_CLIENT_CFG_PEER_SETTINGS;


typedef struct
{
  NTP_GLB_INFO glb_info;
  NTP_SYMM_KEY_LIMITS *symm_key_limits;
  NTP_SYMM_KEY_INFO_IDX *symm_key_info_idx;
  NTP_TRUSTED_KEY_INFO_IDX *trusted_key_info_idx;

  NTP_CLNT_MODE_INFO *clnt_info;
  NTP_PEER_SETTINGS_IDX *peer_settings_idx;

  NTP_SRV_MODE_INFO *srv_info;
  NTP_REFCLK_CFG_INFO_IDX *refclk_info_idx;
  NTP_MISC_LIMITS *misc_limits;
  NTP_MISC_ORPHAN_MODE_INFO *orphan_mode_info;

} ALL_NTP_CFG_INFO;


typedef struct
{
  NTP_SYS_STATE sys_state;
  NTP_REFCLK_STATE_IDX *refclk_states;
  NTP_PEER_STATE_IDX *peer_states;
} ALL_NTP_STATUS;



typedef MBG_GPIO_INFO_IDX ALL_GPIO_INFO_IDX[MAX_PARM_GPIO];

typedef MBG_GPIO_STATUS_IDX ALL_GPIO_STATUS_IDX[MAX_PARM_GPIO];




typedef XMULTI_REF_STATUS_IDX ALL_XMULTI_REF_STATUS_IDX[MAX_PARM_XMR];

typedef XMULTI_REF_INFO_IDX ALL_XMULTI_REF_INFO_IDX[MAX_PARM_XMR];



typedef struct
{
  XMULTI_REF_INSTANCES instances;
  XMULTI_REF_INFO_IDX *infos;
  XMR_EXT_SRC_INFO_IDX *ext_src_infos;
} ALL_XMULTI_REF_INFO;


typedef struct
{
  XMULTI_REF_STATUS_IDX *status;
  XMR_HOLDOVER_STATUS *holdover_status;
  XMR_STATS_IDX *stats_idx;
  XMR_METRICS_IDX *metrics_idx;
  /* ALL_XMULTI_REF_STATUS related flag if at least one ref type supports stats */
  unsigned char has_stats;
  /* ALL_XMULTI_REF_STATUS related flag if at least one ref type supports metrics */
  unsigned char has_metrics;
} ALL_XMULTI_REF_STATUS;



typedef struct
{
  MBG_IMS_STATE state;
  MBG_IMS_FDM_INFO *fdm_info;
  MBG_IMS_FDM_LIMITS *fdm_limits;
  MBG_IMS_FDM_OUTPUT_INFO_IDX *fdm_outinfo_idx;
} ALL_IMS_INFO;


typedef struct
{
  MBG_IMS_SENSOR_STATE_IDX *sensor_state_idx;
  MBG_IMS_FDM_STATE *fdm_state;
  MBG_IMS_FDM_OUTPUT_STATE_IDX *fdm_output_state_idx;
} ALL_IMS_STATE;



typedef struct
{
  MBG_GPIO_CFG_LIMITS cfg_limits;
  MBG_GPIO_INFO_IDX *infos;
} ALL_GPIO_INFO;


typedef struct
{
  MBG_GPIO_STATUS_IDX *states;
} ALL_GPIO_STATE;


typedef struct mbg_io_port
{
    unsigned idx;
    MBG_IO_PORT_INFO p_info;
    MBG_IO_PORT_STATUS status;
    MBG_IO_PORT_TYPE_INFO *pt_infos;
    /* Shortcut to settings in p_info */
    MBG_IO_PORT_SETTINGS *setts;
    void *priv_data;
    void (*free_priv_data)(const struct mbg_io_port*, void*);
} MBG_IO_PORT;


typedef struct
{
    MBG_IO_PORT_LIMITS limits;
    unsigned num_ports;
    MBG_IO_PORT *ports;
} ALL_MBG_IO_PORTS;


#ifndef MAX_UCAP_ENTRIES
/*
 * According to Andre's GPS firmware this is the maximum
 * number of user captures that are preserved.
 */
#define MAX_UCAP_ENTRIES 585
#endif

typedef struct
{
  struct mbg_klist_head head;
  TTM ttm;
} UCAP_ENTRY;

typedef struct
{
  uint32_t num_ucaps; 
  struct mbg_klist_head list;
} ALL_UCAP_INFO;

// User Captures via Network configuration, see ::MBG_XFEATURE_UCAP_NET
typedef struct
{
  MBG_UCAP_NET_GLB_INFO glb_info;
  MBG_UCAP_NET_RECV_INFO_IDX *recv_infos;
} ALL_UCAP_NET_INFO;


typedef struct mbg_user
{
  unsigned idx;
  MBG_USER_INFO info;
  MBG_USER_STATUS status;

  char salt[3];

  /* Pointer for 3rd party to connect some data */
  void *backref;
  /* Pointer for the mallocer to connect some private data */
  void *priv_data;
  /*
   * Can be used to free/release priv or cookie data (if necessary)
   * or do other stuff before user gets freed. But NEVER use release
   * to free the user itself!! This is done by the API right after calling
   * release.
   */
  void (*release_priv)(struct mbg_user*);
  void (*release_backref)(struct mbg_user*);

} MBG_USER;

typedef struct
{
  MBG_USER_MNGMNT_INFO user_mngmnt_info;
  MBG_USER *users;                          
  MBG_USER *user_levels;                    

} ALL_USER_INFO;


typedef struct mbg_service
{
  unsigned idx;
  MBG_SERVICE_INFO info;
  MBG_SERVICE_STATUS status;

  /* Pointer for 3rd party to connect some data */
  void *backref;
  /* Pointer for the mallocer to connect some private data */
  void *priv_data;
  /*
   * Can be used to free/release priv or cookie data (if necessary)
   * or do other stuff before service gets freed. But NEVER use release
   * to free the service itself!! This is done by the API right after calling
   * release.
   */
  void (*release_priv)(struct mbg_service*);
  void (*release_backref)(struct mbg_service*);

} MBG_SERVICE;

typedef struct
{
  MBG_SERVICE_MGMT_INFO mgmt_info;
  MBG_SERVICE *svcs;

} ALL_SERVICE_INFO;


struct mbg_firmware;
struct mbg_firmware_ufu;


typedef struct mbg_firmware
{
  unsigned idx;
  MBG_FW_INFO info;
  struct mbg_firmware_ufu *ufus;                

  /* Pointer for the mallocer to connect some private data */
  void *priv_data;
  /*
   * Can be used to free/release priv or cookie data (if necessary)
   * or do other stuff before firmware gets freed. But NEVER use release
   * to free the firmware itself!! This is done by the API right after calling
   * release.
   */
  void (*release_priv)(struct mbg_firmware*);

} MBG_FIRMWARE;


typedef struct mbg_firmware_ufu
{
  unsigned idx;
  MBG_FW_UFU_INFO info;
  const struct mbg_firmware *firmware;              

  /* Pointer for the mallocer to connect some private data */
  void *priv_data;
  /*
   * Can be used to free/release priv data (if necessary)
   * or do other stuff before ufu gets freed. But NEVER use release
   * to free the ufu itself!! This is done by the API right after calling
   * release.
   */
  void (*release_priv)(struct mbg_firmware_ufu*);

} MBG_FIRMWARE_UFU;


typedef struct
{
  MBG_FW_GLB_INFO glb_info;
  MBG_FIRMWARE *firmwares;      

} ALL_FIRMWARE_INFO;


typedef struct mbg_database
{
    unsigned idx;
    MBG_DATABASE_INFO info;

    /* Pointer for the mallocer to connect some private data */
    void *priv_data;

    /*
     * Can be used to free/release priv data (if necessary)
     * or do other stuff before ufu gets freed. But NEVER use release
     * to free the ufu itself!! This is done by the API right after calling
     * release.
     */
    void (*release_priv)(struct mbg_database*);

} MBG_DATABASE;


typedef struct
{
  MBG_DATABASE_GLB_INFO glb_info;
  MBG_DATABASE *dbs;

} ALL_DATABASE_INFO;


typedef struct
{
  unsigned codec;
  const char *products;

} MBG_EXT_SYS_INFO_CPU_CODEC;

#define MBG_EXT_SYS_INFO_CPU_CODECS             \
{                                               \
  {HPS_USB_HOST_G1_V0,      "microSYNC HSXXX"}, \
  {HPS_USB_DEVICE_G1_V0,    "HPS100"},          \
  {HPS_USB_DEVICE_G1_V1,    "SSP100"}           \
}


enum COMP_SIG_MODES
{
  COMP_SIG_MODE_NONE,       
  COMP_SIG_MODE_SIGNAL,     
  COMP_SIG_MODE_ANT_CONN,   
  COMP_SIG_MODE_PORT_LINK,  
  N_CONN_SIG_MODES
};


enum PCPS_TIME_EXT_FLAG_BITS
{
  PCPS_TIME_EXT_FLAG_BIT_UTC_VALID,   
  N_PCPS_TIME_EXT_FLAG_BITS
};


enum PCPS_TIME_EXT_FLAGS
{
  PCPS_TIME_EXT_FLAG_UTC_VALID = ( 1UL << PCPS_TIME_EXT_FLAG_BIT_UTC_VALID )  
};



_ext BAUD_RATE mbg_baud_rates[N_MBG_BAUD_RATES]
#ifdef _DO_INIT
 = MBG_BAUD_RATES
#endif
;

_ext const char *mbg_baud_rate_strs[N_MBG_BAUD_RATES]
#ifdef _DO_INIT
 = MBG_BAUD_STRS
#endif
;

_ext const char *mbg_framing_strs[N_MBG_FRAMINGS]
#ifdef _DO_INIT
 = MBG_FRAMING_STRS
#endif
;

_ext const char *str_unknown
#ifdef _DO_INIT
 = "unknown"
#endif
;


_ext const char *str_undefined
#ifdef _DO_INIT
 = "(undefined)"
#endif
;


_ext const char *str_not_spc
#ifdef _DO_INIT
 = "not "
#endif
;



//### TODO
#define DEFAULT_MAX_STR_TYPE    2  // DEFAULT_N_STR_TYPE_GPS ?

_ext STR_TYPE_INFO default_str_type_info[DEFAULT_MAX_STR_TYPE]
#ifdef _DO_INIT
  = {
      { DEFAULT_STR_MODES,      "Default Time String", "Time", 0 },
      { DEFAULT_STR_MODES_UCAP, "Capture String",      "Cap",  0 }
    }
#endif
;



_ext const char *mbg_gpio_type_names[N_MBG_GPIO_TYPES]
#ifdef _DO_INIT
 = DEFAULT_GPIO_TYPES_SHORT_STRS
#endif
;

#define _get_gpio_type_name( _i ) \
  ( ( (_i) < N_MBG_GPIO_TYPES ) ? mbg_gpio_type_names[_i] : str_unknown )



_ext const char *mbg_gpio_port_state_names[N_MBG_GPIO_PORT_STATES]
#ifdef _DO_INIT
 = DEFAULT_GPIO_PORT_STATE_NAMES
#endif
;

#define _get_gpio_port_state_name( _i ) \
  ( ( (_i) < N_MBG_GPIO_PORT_STATES ) ? mbg_gpio_port_state_names[_i] : str_unknown )



_ext const char *mbg_gpio_signal_shape_names[N_MBG_GPIO_SIGNAL_SHAPES]
#ifdef _DO_INIT
 = DEFAULT_GPIO_SIGNAL_SHAPE_NAMES
#endif
;

#define _get_gpio_signal_shape_name( _i ) \
  ( ( (_i) < N_MBG_GPIO_SIGNAL_SHAPES ) ? mbg_gpio_signal_shape_names[_i] : str_unknown )



_ext const char *mbg_gpio_fixed_freq_strs[N_MBG_GPIO_FIXED_FREQ]
#ifdef _DO_INIT
 = MBG_GPIO_FIXED_FREQ_STRS
#endif
;

#define _get_gpio_fixed_freq_str( _i ) \
  ( ( (_i) < N_MBG_GPIO_FIXED_FREQ ) ? mbg_gpio_fixed_freq_strs[_i] : str_unknown )



_ext const char *xmr_holdover_status_mode_names[N_XMR_HOLDOVER_STATUS_MODES]
#ifdef _DO_INIT
 = XMR_HOLDOVER_STATUS_MODE_NAMES
#endif
;

#define _get_xmr_holdover_status_mode_name( _i ) \
  ( ( (_i) < N_XMR_HOLDOVER_STATUS_MODES ) ? xmr_holdover_status_mode_names[_i] : str_unknown )



_ext const char *ptp_role_strs[N_PTP_ROLES]
#ifdef _DO_INIT
 = PTP_ROLE_STRS
#endif
;

#define _get_ptp_role_str_dflt( _i, _dflt ) \
  ( ( (_i) < N_PTP_ROLES ) ? ptp_role_strs[_i] : _dflt )

#define _get_ptp_role_str( _i ) \
  _get_ptp_role_str_dflt( _i, str_unknown )



_ext const char *ptp_nw_protocol_strs[N_PTP_NW_PROT]
#ifdef _DO_INIT
  = PTP_NW_PROT_STRS
#endif
;

#define _get_ptp_nw_protocol_str_dflt( _i, _dflt ) \
  ( ( (_i) < N_PTP_NW_PROT ) ? ptp_nw_protocol_strs[_i] : _dflt )

#define _get_ptp_nw_protocol_str( _i ) \
  _get_ptp_nw_protocol_str_dflt(_i, str_unknown )



_ext const char *ptp_port_state_strs[N_PTP_PORT_STATE]
#ifdef _DO_INIT
  = PTP_PORT_STATE_STRS
#endif
;

#define _get_ptp_port_state_str_dflt( _i, _dflt ) \
  ( ( (_i) < N_PTP_PORT_STATE ) ? ptp_port_state_strs[_i] : _dflt )

#define _get_ptp_port_state_str( _i ) \
  _get_ptp_port_state_str_dflt( _i, str_unknown )



_ext const char *ptp_clock_accuracy_strs[N_PTP_CLOCK_ACCURACY - PTP_CLOCK_ACCURACY_NUM_BIAS]
#ifdef _DO_INIT
  = PTP_CLOCK_ACCURACY_STRS
#endif
;

#define _get_ptp_clock_accuracy_str_dflt( _i, _dflt ) \
  ( ( ( (_i) >= PTP_CLOCK_ACCURACY_NUM_BIAS ) && ( (_i) < N_PTP_CLOCK_ACCURACY ) ) ? \
    ptp_clock_accuracy_strs[(_i) - PTP_CLOCK_ACCURACY_NUM_BIAS] : _dflt )

#define _get_ptp_clock_accuracy_str( _i ) \
  _get_ptp_clock_accuracy_str( _i, str_unknown )



_ext const char *ptp_delay_mechanism_strs[N_PTP_DELAY_MECH]
#ifdef _DO_INIT
  = PTP_DELAY_MECH_NAMES
#endif
;

#define _get_ptp_delay_mechanism_str_dflt( _i, _dflt ) \
  ( ( (_i) < N_PTP_DELAY_MECH ) ? ptp_delay_mechanism_strs[_i] : _dflt )

#define _get_ptp_delay_mechanism_str( _i ) \
  _get_ptp_delay_mechanism_str_dflt( _i, str_unknown )




// Terminated by { 0, NULL }
_ext const PTP_TABLE ptp_time_source_table[]
#ifdef _DO_INIT
  = PTP_TIME_SOURCE_TABLE
#endif
;



static __mbg_inline
int num_bits_set( long val )
{
  int bits_set = 0;
  size_t i;

  for ( i = 0; i < ( 8 * sizeof( val ) ); i++ )
  {
    if ( val & 1 )
      bits_set++;

    val >>= 1;
  }

  return bits_set;

}  // num_bits_set



#if !defined( MBG_TGT_KERNEL )

static __mbg_inline
bool device_id_is_serial( const char *dev_id )
{
  #if defined( MBG_TGT_NO_TGT )
    return false;  //### FIXME
  #elif defined( MBG_TGT_WIN32 )
    //##++++ There may be also serial ports under Windows
    // which don't have "COM" in their name.
    return strstr( dev_id, "COM" ) != NULL;
  #elif defined( MBG_TGT_LINUX )
    return strstr( dev_id, "/dev/ttyS" ) != NULL     // standard serial device
        || strstr( dev_id, "/dev/ttyUSB" ) != NULL;  // serial-to-USB adapter
  #elif defined( MBG_TGT_FREEBSD )
    return strstr( dev_id, "/dev/ttyu" ) != NULL     // dial-in device (standard), FreeBSD 10 and newer
        || strstr( dev_id, "/dev/cuau" ) != NULL     // dial out device, FreeBSD 10 and newer
        || strstr( dev_id, "/dev/ttyd" ) != NULL     // dial-in device (standard), before FreeBSD 10
        || strstr( dev_id, "/dev/cuad" ) != NULL;    // dial-out device, before FreeBSD 10
  #elif defined( MBG_TGT_NETBSD )
    // TODO This is just an ugly hack which identifies
    // some traditional device names as serial ports.
    // There are quite a few other possible names.
    // See "man 4 com" and "man 4 tty".
    return strstr( dev_id, "/dev/tty0" ) != NULL     // traditional dial-in devices
        || strstr( dev_id, "/dev/dty0" ) != NULL;    // traditional dial-out devices
  #elif defined( MBG_TGT_QNX_NTO )
    return strstr( dev_id, "/dev/ser" ) != NULL;
  #elif defined( MBG_TGT_DOS )
    return strstr( dev_id, "COM" ) != NULL;
  #else
    #error device_id_is_serial() needs to be implemented for this platform
  #endif

}  // device_id_is_serial



static __mbg_inline
bool device_id_is_lan( const char *dev_id )
{
  return strstr( dev_id, "LAN" ) != NULL;

}  // device_id_is_lan

#endif  // !defined( MBG_TGT_KERNEL )



#if defined( _PRELIMINARY_CODE )

static __mbg_inline
MBG_TLV_UID mbg_tlv_create_id( void )
{
#if defined( MBG_TGT_LINUX )   
  struct sysinfo info;

  // Linux specific, implement Windows equivalent
  sysinfo( &info );
  return ( (MBG_TLV_UID) ( ( time( NULL ) >> 16 ) | ( info.uptime << 16 ) ) );
#else
  return rand();
#endif
} // mbg_tlv_create_id

#endif  // defined( _PRELIMINARY_CODE )



#if !defined( MBG_TGT_KERNEL )

/* ----- function prototypes begin ----- */

/* This section was generated automatically */
/* by MAKEHDR, do not remove the comments. */

 int chk_sw_rev_name( SW_REV *p, int verbose ) ;

 int get_str_idx( const char *search, const char *str_table[], int n_entries ) ;
 int get_baud_rate_idx( BAUD_RATE baud_rate ) ;
 int get_framing_idx( const char *framing ) ;
 void port_settings_from_port_parm_mode( PORT_SETTINGS *p_ps, uint8_t pp_mode, int cap_str_idx ) ;

 void port_parm_mode_from_port_settings( uint8_t *pp_mode, const PORT_SETTINGS *p_ps, int cap_str_idx ) ;

 void port_settings_from_port_parm( PORT_SETTINGS *p_ps, int port_idx, const PORT_PARM *p_pp, int cap_str_idx ) ;

 void port_parm_from_port_settings( PORT_PARM *p_pp, int port_idx, const PORT_SETTINGS *p_ps, int cap_str_idx ) ;

 uint32_t check_valid_port_info( const PORT_INFO *p_pi, const STR_TYPE_INFO_IDX str_type_info_idx[], int n_str_type ) ;
 int valid_port_info( const PORT_INFO *p_pi, const STR_TYPE_INFO_IDX str_type_info_idx[], int n_str_type ) ;
 int setup_port_info_from_port_parm( PORT_INFO_IDX pii[], const PORT_PARM *p_pp, const RECEIVER_INFO *p_ri ) ;

 int setup_default_str_type_info_idx( STR_TYPE_INFO_IDX stii[], const RECEIVER_INFO *p_ri ) ;
 int chk_set_n_gnss_supp( ALL_GNSS_INFO *p_agi ) ;
 void setup_gps_only_sat_info_idx_from_statinfo( ALL_GNSS_INFO *p_agi ) ;

 int setup_gps_only_gnss_info_from_statinfo( ALL_GNSS_INFO *p_agi ) ;

 void chk_free_dev_hw_id( DEVICE_INFO *p ) ;
 int alloc_dev_hw_id( DEVICE_INFO *p, size_t len ) ;
 const char *get_fw_id_from_hw_id( const char *hw_id ) ;
 const char *get_hw_id_from_fw_id( const char *fw_id ) ;
 MBG_IO_PORT_TYPE_INFO* get_io_port_type_info( const MBG_IO_PORT *port, uint16_t port_type ) ;

 void mbg_tlv_announce_init( MBG_TLV_ANNOUNCE *tlv, MBG_TLV_UID uid, MBG_TLV_TYPE tlv_feat_type, uint32_t total_bytes ) ;

 void mbg_tlv_init( MBG_TLV *tlv, MBG_TLV_UID uid, MBG_TLV_TYPE tlv_type, uint32_t total_bytes ) ;

 void mbg_tlv_rcv_state_init( MBG_TLV_RCV_STATE *state, MBG_TLV_UID uid, uint32_t total_bytes ) ;

 int mbg_snprint_revision( char *buf, size_t buflen, const char *prefix, const char *suffix, uint32_t rev) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_receiver_info( const RECEIVER_INFO *p ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_xbp_supp_nodes( const ALL_XBP_INFO *info ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_net_cfg_supp_stage_2( const ALL_NET_CFG_INFO *info ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_ntp_supp_client( const ALL_NTP_CFG_INFO *info ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_ntp_supp_server( const ALL_NTP_CFG_INFO *info ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_mrf_none( const ALL_XMULTI_REF_INFO *info ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_ext_src_info( const ALL_XMULTI_REF_INFO *info ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_xmulti_ref_supp_holdover_status( const ALL_XMULTI_REF_INFO *info ) ;
 /*
 * 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 ) ;

 /*
 * 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 ) ;

 _NO_MBG_API_ATTR int _MBG_API chk_dev_ims_has_fdm( const ALL_IMS_INFO *info ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_ims_is_volt_out_enabled( const ALL_IMS_STATE *ims_state, unsigned idx ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_ims_is_volt_out_overload( const ALL_IMS_STATE *ims_state, unsigned idx ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_ims_is_pll_locked( const ALL_IMS_STATE *ims_state, unsigned idx ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_gpio_supp_ass_idx( const ALL_GPIO_INFO *gpio_info, unsigned idx ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_gpio_dep_on_ass_idx( const ALL_GPIO_INFO *gpio_info, unsigned idx ) ;
 _NO_MBG_API_ATTR int _MBG_API chk_dev_gpio_has_status( const ALL_GPIO_INFO *info ) ;

 void free_all_xbp_info ( ALL_XBP_INFO *p ) ;

 void free_all_net_cfg_info ( ALL_NET_CFG_INFO *p ) ;

 void free_all_net_status_info ( ALL_NET_STATUS_INFO *p ) ;

 void free_all_snmp_info ( ALL_SNMP_INFO *p ) ;

 void free_all_syslog_info ( ALL_SYSLOG_INFO *p ) ;

 void free_all_monitoring_info ( ALL_MONITORING_INFO *p ) ;

 void free_all_events( ALL_EVENTS *p ) ;

 void free_all_xmulti_ref_info( ALL_XMULTI_REF_INFO *p ) ;

 void free_all_xmulti_ref_status( ALL_XMULTI_REF_STATUS *p ) ;

 void free_all_ptp_v1_common_datasets( ALL_PTP_V1_COMMON_DATASETS *p ) ;

 void free_all_ptp_v2_common_datasets( ALL_PTP_V2_COMMON_DATASETS *p ) ;

 void free_all_ntp_cfg_info( ALL_NTP_CFG_INFO *p ) ;

 void free_all_ntp_status( ALL_NTP_STATUS *p ) ;

 void free_all_ims_info( ALL_IMS_INFO *p ) ;

 void free_all_ims_state( ALL_IMS_STATE *p ) ;

 void free_all_gpio_info( ALL_GPIO_INFO *p ) ;

 void free_all_io_ports( ALL_MBG_IO_PORTS *p ) ;

 void free_all_gpio_state( ALL_GPIO_STATE *p ) ;

 UCAP_ENTRY* calloc_ucap_entry( void ) ;

 void free_all_ucap_info( ALL_UCAP_INFO *p ) ;

 void free_all_ucap_net_info( ALL_UCAP_NET_INFO *p ) ;

 void free_all_user_info( ALL_USER_INFO *p ) ;

 void free_all_svc_info( ALL_SERVICE_INFO *p ) ;

 void free_all_firmware_info( ALL_FIRMWARE_INFO *p ) ;

 void free_all_database_info( ALL_DATABASE_INFO *p ) ;

 void str_ntp_hex_to_ntp_tstamp( const char *s, NTP_TSTAMP *p ) ;

 void ntp_tstamp_to_nanotime_64( const NTP_TSTAMP *p_nts, NANO_TIME_64 *p_nt64 ) ;

 void str_ntp_hex_to_nano_time_64( const char *s, NANO_TIME_64 *p ) ;


/* ----- function prototypes end ----- */

#endif  // !defined( MBG_TGT_KERNEL )

#ifdef __cplusplus
}
#endif


/* End of header body */

#undef _ext
#undef _DO_INIT

#endif  /* _CFG_HLP_H */