toolutil.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: toolutil.c 1.10 2019/02/08 10:34:47 martin REL_M $
 *
 *  Description:
 *    Common functions which can be used with Meinberg command line
 *    utility programs.
 *
 * -----------------------------------------------------------------------
 *  $Log: toolutil.c $
 *  Revision 1.10  2019/02/08 10:34:47  martin
 *  Fix for the mingw build environment.
 *  Revision 1.9  2018/12/14 13:13:46  martin
 *  Cleaned up mbg_open_device_by_param(), removed obsolete
 *  parameters, and removed all printing by this function.
 *  New function mbg_open_device_by_param_chk() which actually
 *  calls mbg_open_device_by_param() and prints a message to stderr
 *  if the call failed.
 *  Updated some comments.
 *  Revision 1.8  2018/11/15 12:20:44  martin
 *  Individual MBG_MICRO_VERSION codes are now obsolete.
 *  Revision 1.7  2018/07/03 14:47:31  martin
 *  Print a message if an old card with 20 ms timing bug is detected.
 *  Revision 1.6  2018/06/25 13:45:26  martin
 *  Distinguish between MBG_TGT_HAS_DEV_FN and
 *  MBG_TGT_HAS_DEV_FN_BASE.
 *  Use some predefined string formats.
 *  Check parameters in mbg_open_device_by_param().
 *  Some string print functions now return int rather than
 *  size_t, like standard library functions.
 *  Use snprint_utc_offs() from timeutil.c.
 *  Revision 1.5  2017/07/05 07:32:38  martin
 *  Renamed mbg_check_devices() to mbg_handle_devices() and added
 *  a new parameter which controls if only one or all devices
 *  should be handled if no device has been specified.
 *  New function mbg_open_device_by_param() which can be used e.g. to
 *  check if a parameter string is an device file name (MBG_DEV_FN),
 *  or a device index number, or a device name in MBG_DEV_NAME format,
 *  and calls the appropriate open function to open the device.
 *  Made mbg_snprint_hr_tstamp() more versatile by passing a new
 *  optional UTC offset parameter.
 *  Account for PCPS_HRT_BIN_FRAC_SCALE renamed to MBG_FRAC32_UNITS_PER_SEC.
 *  Account for frac_sec_from_bin() obsoleted by bin_frac_32_to_dec_frac().
 *  Print device options with OS-specific device names.
 *  Print special firmware version info, if appropriate.
 *  Reworked error checking after opening device.
 *  mbg_print_program_info() which is usually called first after program
 *  start now makes stdout unbuffered if output is redirected.
 *  Use safe string functions from str_util.c.
 *  Support Windows and QNX Neutrino targets.
 *  Added doxygen comments.
 *  Revision 1.4  2012/10/15 09:33:48  martin
 *  Use common way to handle version information.
 *  Open device with O_RDWR flag.
 *  Fixed printing delta timestamps.
 *  Added function to print PCPS_TIME.
 *  Added function to show PZF correlation.
 *  Added function mbg_print_hr_time() which optionally prints hex status.
 *  Let the display functions for HR timestamps optionally show
 *  the raw (hex) timestamps.
 *  Revision 1.3  2009/06/19 12:12:14  martin
 *  Added function mbg_print_hr_timestamp().
 *  Revision 1.2  2009/02/18 09:15:55  martin
 *  Support TAI and GPS time scales in mbg_snprint_hr_time().
 *  Revision 1.1  2008/12/17 10:45:13  martin
 *  Initial revision.
 *  Revision 1.1  2008/12/15 08:35:07  martin
 *  Initial revision.
 *
 **************************************************************************/

#define _TOOLUTIL
  #include <toolutil.h>
#undef _TOOLUTIL

// include Meinberg headers
#include <cfg_hlp.h>
#include <pcpsutil.h>
#include <timeutil.h>
#include <str_util.h>

#if defined( MBG_TGT_WIN32 )
  #include <mbgsvctl.h>
#endif

// include system headers
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>



#if defined( MBG_TGT_WIN32 ) && defined( _MSC_VER )
  // Required for MSC, but not for e.g. MinGW.
  // Must be defined *after* stdio has been included.
  #define isatty   _isatty
  #define fileno   _fileno
#endif



static __mbg_inline
double delta_timestamps( const PCPS_TIME_STAMP *p_ts, const PCPS_TIME_STAMP *p_prv_ts )
{
  uint64_t ts = pcps_time_stamp_to_uint64( p_ts );
  uint64_t prv_ts = pcps_time_stamp_to_uint64( p_prv_ts );

  // We divide by MBG_FRAC32_UNITS_PER_SEC to get the correct fractions
  // and we multiply by 1E6 to get the result in microseconds.
  return (double) ( (int64_t) ( ts - prv_ts ) ) * 1E6 / MBG_FRAC32_UNITS_PER_SEC;

}  // delta_timestamps



/*HDR*/
int mbg_program_version_str( char *s, size_t max_len )
{
  int n;

  n = snprintf_safe( s, max_len, "%i.%i.%i", MBG_MAJOR_VERSION_CODE,
                     MBG_MINOR_VERSION_CODE, MBG_MICRO_VERSION_CODE );

  return n;

}  // mbg_program_version_str



/*HDR*/
int mbg_program_info_str( char *s, size_t max_len, const char *pname,
                          int first_year, int last_year )
{
  int n = 0;

  if ( last_year == 0 )
    last_year = MBG_CURRENT_COPYRIGHT_YEAR;

  n += snprintf_safe( &s[n], max_len - n, "%s v", pname );

  n += mbg_program_version_str( &s[n], max_len - n );

  n += snprintf_safe( &s[n], max_len - n, " copyright Meinberg " );

  if ( first_year != last_year )
    n += snprintf_safe( &s[n], max_len - n, "%04i-", first_year );

  n += snprintf_safe( &s[n], max_len - n, "%04i", last_year );

  return n;

}  // mbg_program_info_str



/*HDR*/
void mbg_print_program_info( const char *pname, int first_year, int last_year )
{
  char ws[256];

  // If the output has been redirected then make stdout unbuffered,
  // e.g. to see the output immediately even though piped through 'tee'.
  if ( !isatty( fileno( stdout ) ) )
    setvbuf( stdout, NULL, _IONBF, 0 );

  mbg_program_info_str( ws, sizeof( ws ), pname, first_year, last_year );

  printf( "\n%s\n\n", ws );

}  // mbg_print_program_info



/*HDR*/
void mbg_print_usage_intro( const char *pname, const char *info )
{
  printf( "Usage:  %s [[opt] [opt] ...] [[dev] [dev] ...]\n\n", pname );

  if ( info )
    printf( "%s\n\n", info );


}  // mbg_print_usage_intro



/*HDR*/
void mbg_print_opt_info( const char *opt_name, const char *opt_info )
{
  if ( opt_name == NULL )
    opt_name = str_empty;

  if ( opt_info == NULL )
    opt_info = str_empty;

  printf( "  %8s   %s\n", opt_name, opt_info );

}  // mbg_print_opt_info



/*HDR*/
void mbg_print_help_options( void )
{
  puts( "where \"opt\" is one of the options:" );
  mbg_print_opt_info( "-? or -h", "print this usage information" );

}  // mbg_print_help_options



/*HDR*/
void mbg_print_device_options( void )
{
  printf( "\n" );

  puts( "where \"dev\" can be:" );

  #if MBG_TGT_HAS_DEV_FN_BASE
    printf( "    a device file name, e.g. \"%s\" or \"%s\"\n",
            EXAMPLE_DEV_FN_1, EXAMPLE_DEV_FN_2 );
  #endif
    printf( "    a device type name, with or with S/N appended, e.g. \"%s\" or \"%s\"\n",
            EXAMPLE_DEV_NAME_1, EXAMPLE_DEV_NAME_2 );

    printf( "    a device index, e.g. \"0\", \"1\",\"2\", ...\n" );

}  // mbg_print_device_options



/*HDR*/
void mbg_print_default_usage( const char *pname, const char *prog_info )
{
  mbg_print_usage_intro( pname, prog_info );
  mbg_print_help_options();
  mbg_print_device_options();
  puts( "" );

}  // mbg_print_default_usage



/*HDR*/
int mbg_get_show_dev_info( MBG_DEV_HANDLE dh, const char *dev_name, PCPS_DEV *p_dev )
{
  RECEIVER_INFO ri;
  unsigned long port;
  int irq_num;
  int rc;

  if ( dev_name )
    printf( "%s:\n", dev_name );

  // get information about the device
  rc = mbg_get_device_info( dh, p_dev );

  if ( mbg_cond_err_msg( rc, "mbg_get_device_info" ) )
    goto out;

  rc = mbg_setup_receiver_info( dh, p_dev, &ri );

  if ( mbg_cond_err_msg( rc, "mbg_setup_receiver_info" ) )
    goto out;


  printf( "%s", _pcps_type_name( p_dev ) );

  if ( strlen( _pcps_sernum( p_dev ) ) &&
       strcmp( _pcps_sernum( p_dev ), "N/A" ) )
    printf( " %s", _pcps_sernum( p_dev ) );

  printf( " (FW " PCPS_FW_STR_FMT,
          _pcps_fw_rev_num_major( _pcps_fw_rev_num( p_dev ) ),
          _pcps_fw_rev_num_minor( _pcps_fw_rev_num( p_dev ) )
        );

  if ( chk_sw_rev_name( &ri.sw_rev, 0 ) )
    printf( " \"%s\"", ri.sw_rev.name );

  if ( _pcps_has_asic_version( p_dev ) )
  {
    PCI_ASIC_VERSION av;
    int rc = mbg_get_asic_version( dh, &av );

    if ( mbg_rc_is_success( rc ) )
    {
      av = _convert_asic_version_number( av );  // TODO Do we need this?

      printf( ", ASIC " PCPS_ASIC_STR_FMT,
              _pcps_asic_version_major( av ),
              _pcps_asic_version_minor( av )
            );
    }
  }

  printf( ")" );

  port = _pcps_short_port_base( p_dev, 0 );

  if ( port )
    printf( " at port 0x%03lX", port );

  port = _pcps_short_port_base( p_dev, 1 );

  if ( port )
    printf( "/0x%03lX", port );

  irq_num = _pcps_irq_num( p_dev );

  if ( irq_num != -1 )
    printf( ", irq %i", irq_num );

  if ( _pcps_fw_has_20ms_bug( p_dev ) )
    printf( "\n** Warning: %s v" PCPS_FW_STR_FMT " has a 20 ms timing bug. Please upgrade the firmware!",
            _pcps_type_name( p_dev ),
            _pcps_fw_rev_num_major( _pcps_fw_rev_num( p_dev ) ),
            _pcps_fw_rev_num_minor( _pcps_fw_rev_num( p_dev ) ) );

  rc = MBG_SUCCESS;

out:
  puts( str_empty );
  return rc;

}  // mbg_get_show_dev_info



/*HDR*/
int mbg_handle_device( MBG_DEV_HANDLE dh, const char *dev_name,
                       MBG_DEV_HANDLER_FNC *fnc )
{
  PCPS_DEV dev;
  int rc;

  rc = mbg_get_show_dev_info( dh, dev_name, &dev );

  if ( mbg_rc_is_success( rc ) )
    if ( fnc )
      rc = fnc( dh, &dev );

  mbg_close_device( &dh );

  puts( "" );

  return rc;

}  // mbg_handle_device



/*HDR*/
int chk_get_num_devices( void )
{
  static int num_devices;
  static bool has_searched_devices;

  if ( !has_searched_devices )
  {
    num_devices = mbg_find_devices();
    has_searched_devices = true;
  }

  return num_devices;

}  // chk_get_num_devices



/*HDR*/
int mbg_open_device_by_param( MBG_DEV_HANDLE *p_dh, const char *dev_param_str, int dev_idx,
                              char *dev_name_buffer, size_t dev_name_buffer_size )
{
  MBG_DEV_HANDLE dh = MBG_INVALID_DEV_HANDLE;
  int devices_found;
  int rc = MBG_ERR_GENERIC;

  if ( dev_name_buffer == NULL || dev_name_buffer_size == 0 )
    return MBG_ERR_INV_PARM;

  dev_name_buffer[0] = 0;    // Make string empty

  if ( dev_param_str )
  {
    // A device parameter string has been specified.
    char *endptr;
    long l;

    #if MBG_TGT_HAS_DEV_FN_BASE
      // Check if the device parameter represents a device file name
      if ( strncmp( dev_param_str, mbg_dev_fn_base, strlen( mbg_dev_fn_base ) ) == 0 )
      {
        snprintf_safe( dev_name_buffer, dev_name_buffer_size, "%s", dev_param_str );
        dh = mbg_open_device_by_dev_fn( dev_param_str );
        goto has_tried_to_open;
      }
    #endif


    // Check if the device parameter string is an index number.
    endptr = NULL;
    l = strtol( dev_param_str, &endptr, 0 );

    // If endptr now points past the string then the
    // whole string has been interpreted as number.
    if ( endptr == &dev_param_str[strlen( dev_param_str )] )
    {
      long l_max = (long) ( ( (unsigned int) -1 ) >> 1 );

      if ( l > l_max )
      {
        // The decoded number exceeds the maximum number
        // that can be passed to ::mbg_open_device.
        rc = MBG_ERR_RANGE;
        goto out;
      }

      // We use the decoded number as device index.
      dev_idx = (int) l;
      goto open_dev_with_idx;
    }


    // Finally assume the device name is a model name, eventually
    // with serial number appended.
    snprintf_safe( dev_name_buffer, dev_name_buffer_size, "%s", dev_param_str );
    dh = mbg_open_device_by_name( dev_param_str, MBG_MATCH_MODEL );
    goto has_tried_to_open;
  }


  // We get here directly if dev_param_str is NULL.

open_dev_with_idx:
  // Try to open the device with the index number which has been derived
  // from dev_param_str, or has been passed directly by the caller.
  // First check if the device index is in a valid range.
  devices_found = chk_get_num_devices();

  if ( devices_found == 0 )       // no device found
    return MBG_ERR_NO_DEV;

  if ( dev_idx >= devices_found )  // device index exceeds max
    return MBG_ERR_NO_DEV;

  mbg_dev_fn_from_dev_idx( dev_name_buffer, (int) dev_name_buffer_size, dev_idx );
  dh = mbg_open_device( dev_idx );


has_tried_to_open:
  // We get here immediately after one of the "open" functions has been called,
  // so retrieve an error code to be returned if that function failed.
  rc = ( dh == MBG_INVALID_DEV_HANDLE ) ? mbg_get_last_error( NULL ) : MBG_SUCCESS;

out:
  // Save the returned handle, which can be MBG_INVALID_DEV_HANDLE.
  *p_dh = dh;

  return rc;

}  // mbg_open_device_by_param



/*HDR*/
int mbg_open_device_by_param_chk( MBG_DEV_HANDLE *p_dh, const char *dev_param_str, int dev_idx,
                                  char *dev_name_buffer, size_t dev_name_buffer_size )
{
  int rc = mbg_open_device_by_param( p_dh, dev_param_str, dev_idx,
                                     dev_name_buffer, dev_name_buffer_size );
  if ( mbg_rc_is_error( rc ) )
  {
    char msg[256];
    int n = 0;
    n = snprintf_safe( msg, sizeof( msg ), "** Failed to open device" );

    if ( dev_name_buffer[0] )  // string not empty
      n += snprintf_safe( &msg[n], sizeof( msg ) - n, " %s", dev_name_buffer );
    else
      if ( dev_param_str )     // parameter string has been specified
        n += snprintf_safe( &msg[n], sizeof( msg ) - n, " %s", dev_param_str );
      else                     // device index number
        n += snprintf_safe( &msg[n], sizeof( msg ) - n, " %i", dev_idx );

    n += snprintf_safe( &msg[n], sizeof( msg ) - n, ": %s", mbg_strerror( rc ) );
    fprintf( stderr, "%s\n\n", msg );
  }

  return rc;

}  // mbg_open_device_by_param_chk



/*HDR*/
int mbg_handle_devices( int argc, char *argv[], int optind,
                        MBG_DEV_HANDLER_FNC *fnc, int chk_dev_flags )
{
  MBG_DEV_FN tmp_dev_fn;
  MBG_DEV_HANDLE dh;
  int devices_specified = argc - optind;
  int devices_found = 0;
  const char *dev_param_str = NULL;
  int rc = MBG_ERR_NO_DEV;
  int i;

  if ( devices_specified )
  {
    // One or more device names have been specified
    // on the command line, so handle each device.
    for ( i = optind; i < argc; i++ )
    {
      dev_param_str = argv[i];

      rc = mbg_open_device_by_param_chk( &dh, dev_param_str, 0,
                                         tmp_dev_fn, sizeof( tmp_dev_fn ) );

      if ( mbg_rc_is_success( rc ) )
        rc = mbg_handle_device( dh, ( devices_specified > 1 ) ? tmp_dev_fn : NULL, fnc );

      // Don't continue if one of the specified devices failed.
      if ( mbg_rc_is_error( rc ) )
        break;
    }

    goto out;
  }


  // No device has been specified on the command line.

  if ( chk_dev_flags & CHK_DEV_WITHOUT_DEV )
  {
    // TODO Check if this branch is useful
    // We have been called without a device to be used.
    // This may be useful e.g. if we just want to print
    // some general usage information.
    if ( fnc )
    {
      dh = MBG_INVALID_DEV_HANDLE;
      rc = fnc( dh, NULL );
    }
    else
    {
      // TODO Should we report an error if we have been called
      // without callback function and without device?
    }
    goto out;
  }


  devices_found = chk_get_num_devices();

  if ( devices_found == 0 )  // no device found
  {
    // Don't continue without any device, unless
    // explicitly requested to do so.
    if ( !( chk_dev_flags & CHK_DEV_WITHOUT_DEV ) )
    {
      printf( "No device found.\n" );  // TODO
      rc = MBG_ERR_NO_DEV;
      goto out;
    }

    // We may continue even if no device is available,
    // but must process the callback loop only once.
    devices_found = 1;
  }

  // Unless explicitly requested to handle all devices
  // we have found, we only handle the first one.
  if ( !( chk_dev_flags & CHK_DEV_ALL_DEVICES ) )
    devices_found = 1;

  for ( i = 0; i < devices_found; i++ )
  {
    rc = mbg_open_device_by_param_chk( &dh, NULL, i, tmp_dev_fn, sizeof( tmp_dev_fn ) );

    if ( mbg_rc_is_success( rc ) )
      rc = mbg_handle_device( dh, ( devices_found > 1 ) ? tmp_dev_fn : NULL, fnc );

    // If one of the unspecified devices failed we continue anyway
    // and don't break here.
  }


out:
  return rc;

}  // mbg_handle_devices



/*HDR*/
int mbg_snprint_date_time( char *s, size_t max_len, const PCPS_TIME *p, int verbose )
{
  size_t n = 0;

  n += snprintf_safe( &s[n], max_len - n, "%04u-%02u-%02u %02u:%02u:%02u.%02u",
                      pcps_exp_year( p->year, mbg_exp_year_limit ), p->month, p->mday,
                      p->hour, p->min, p->sec, p->sec100 );

  if ( verbose > 0 )
    n += snprintf_safe( &s[n], max_len - n, " (UTC%+ih), st: %02Xh",
                        p->offs_utc, p->status );

  if ( verbose > 1 )
    n += snprintf_safe( &s[n], max_len - n, ", sig: %i", p->signal );

  return _int_from_size_t( n );

}  // mbg_snprint_date_time



/*HDR*/
int mbg_snprint_hr_tstamp( char *s, size_t max_len, const PCPS_TIME_STAMP *p,
                           long utc_offs, int show_raw )
{
  long l;
  time_t t;
  struct tm tm = { 0 };
  size_t n = 0;
  int rc;

  if ( show_raw )
    n += snprintf_safe( &s[n], max_len - n, "raw: 0x%08lX.%08lX, ",
                        (ulong) p->sec, (ulong) p->frac );

  // We'll use the standard C library functions to convert the seconds
  // to broken-down calendar date and time.
  l = (long) p->sec + utc_offs;
  t = cvt_to_time_t( l );

  // Our time stamp may be UTC, or have been converted to local time.
  // Anyway, since we don't want to account for the system's time zone
  // settings, we always use the gmtime() function for conversion,
  // or our own wrapper, respectively:
  rc = mbg_gmtime( &tm, &t );

  if ( mbg_rc_is_success( rc ) )
    n += snprintf_safe( &s[n], max_len - n, "%04i-%02i-%02i %02i:%02i:%02i." PCPS_HRT_FRAC_SCALE_FMT,
                        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
                        tm.tm_hour, tm.tm_min, tm.tm_sec,
                        (ulong) bin_frac_32_to_dec_frac( p->frac, PCPS_HRT_FRAC_SCALE ) );
  else
    n += snprint_gmtime_error( &s[n], max_len - n, rc, t, __func__ );

  return _int_from_size_t( n );

}  // mbg_snprint_hr_tstamp



/*HDR*/
int mbg_snprint_hr_time( char *s, size_t max_len, const PCPS_HR_TIME *p, int show_raw )
{
  char ws[80];
  PCPS_TIME_STAMP ts = p->tstamp;
  size_t n;
  const char *time_scale_name;
  const char *cp;

  // If the local time offset is not 0 then add this to the time stamp
  // and set up a string telling the offset.
  if ( p->utc_offs )
  {
    snprint_utc_offs( ws, sizeof( ws ), NULL, p->utc_offs );
    cp = ws;
  }
  else
    cp = "";   // no local time offset


  // Convert the local time stamp to calendar date and time.
  n = mbg_snprint_hr_tstamp( s, max_len, &ts, p->utc_offs, show_raw );

  // By default the time stamp represents UTC plus an optional local time offset.
  time_scale_name = "UTC";

  // However, some cards may be configured to output TAI or GPS time.
  if ( p->status & PCPS_SCALE_TAI )
    time_scale_name = "TAI";      // time stamp represents TAI
  else
    if ( p->status & PCPS_SCALE_GPS )
      time_scale_name = "GPS";    // time stamp represents GPS system time

  n += snprintf_safe( &s[n], max_len - n, " %s%s", time_scale_name, cp );

  return _int_from_size_t( n );

}  // mbg_snprint_hr_time



/*HDR*/
void mbg_print_hr_timestamp( PCPS_TIME_STAMP *p_ts, int32_t hns_latency, PCPS_TIME_STAMP *p_prv_ts,
                             int no_latency, int show_raw )
{
  char ws[80];

  mbg_snprint_hr_tstamp( ws, sizeof( ws ), p_ts, 0, show_raw );
  printf( "HR time %s", ws );

  if ( p_prv_ts )
    printf( " (%+.1f us)", delta_timestamps( p_ts, p_prv_ts ) );

  if ( !no_latency )
    printf( ", latency: %.1f us", ( (double) hns_latency ) / 10 );

  puts( str_empty );

}  // mbg_print_hr_timestamp



/*HDR*/
void mbg_print_hr_time( PCPS_HR_TIME *p_ht, int32_t hns_latency, PCPS_TIME_STAMP *p_prv_ts,
                        int no_latency, int show_raw, int verbose )
{
  char ws[80];

  mbg_snprint_hr_time( ws, sizeof( ws ), p_ht, show_raw );
  printf( "HR time %s", ws );

  if ( p_prv_ts )
    printf( " (%+.1f us)", delta_timestamps( &p_ht->tstamp, p_prv_ts ) );

  if ( !no_latency )
    printf( ", latency: %.1f us", ( (double) hns_latency ) / 10 );

  if ( verbose > 0 )
    printf( ", st: 0x%04lX", (ulong) p_ht->status );

  if ( verbose > 1 )
    printf( ", sig: %i", p_ht->signal );

  puts( "" );

}  // mbg_print_hr_time



/*HDR*/
int mbg_show_pzf_corr_info( MBG_DEV_HANDLE dh, int show_corr_step )
{
  CORR_INFO ci;
  char ws[80];
  const char *cp;

  int rc = mbg_get_corr_info( dh, &ci );

  if ( mbg_cond_err_msg( rc, "mbg_get_corr_info" ) )
    return rc;


  if ( ci.status < N_PZF_CORR_STATE )
    cp = pzf_corr_state_name[ci.status];
  else
  {
    snprintf_safe( ws, sizeof( ws ), "unknown status code: 0x%02X", ci.status );
    cp = ws;
  }

  printf( "%s, PZF correlation: %u%%", cp, ci.val );

  if ( show_corr_step )
    if ( ci.corr_dir != ' ' )
      printf( " Shift: %c", ci.corr_dir );

  return MBG_SUCCESS;

}  // mbg_show_pzf_corr_info



/*HDR*/
int mbg_get_gps_gnss_mode_info_chk( MBG_DEV_HANDLE dh, MBG_GNSS_MODE_INFO *p )
{
  int rc = mbg_get_gps_gnss_mode_info( dh, p );
  mbg_cond_err_msg( rc, "mbg_get_gps_gnss_mode_info" );

  return rc;

}  // mbg_get_gps_gnss_mode_info_chk