mbgdevio.h

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: mbgdevio.h 1.47 2018/11/22 14:27:05 martin TRASH $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Definitions and prototypes used with Meinberg device driver I/O.
 *
 * -----------------------------------------------------------------------
 *  $Log: mbgdevio.h $
 *  Revision 1.47  2018/11/22 14:27:05  martin
 *  Fixed pointer size problems in a mixed 32/64 bit Linux environment.
 *  Removed obolete preprocessor symbol MBG_USE_KERNEL_DRIVER
 *  and use new global symbol MBG_TGT_USE_IOCTL instead.
 *  Revision 1.46  2018/11/14 12:24:40  martin
 *  Renamed a preprocessor symbol to avoid a name clash.
 *  Revision 1.45  2018/09/21 08:59:17  martin
 *  New version code 0x0308, compatibility version still 0x0210.
 *  Account for a renamed library function.
 *  Updated function prototypes.
 *  Revision 1.44  2018/08/07 15:09:25Z  martin
 *  New version code 0x0370, compatibility version still 0x0210.
 *  Revision 1.43  2018/07/05 08:50:48  martin
 *  Added missing linkage attribute for mbg_open_device().
 *  Reworked handling of IOCTL return codes.
 *  Modified test if cpu_set_t and associated definitions are available.
 *  Use standard errno conversion functions.
 *  Removed usage of obsolete symbol MBGDEVIO_SIMPLE.
 *  Updated function prototypes.
 *  Revision 1.42  2017/07/05 15:20:32  martin
 *  New MBGDEVIO_VERSION 0x0400, compatibility version unchanged.
 *  Account for MBG_ERROR_CODES returned by the ioctl functions.
 *  New type MBG_DEV_FN used for device file names, formerly often
 *  referred to as 'hardware ID'.
 *  New type MBG_DEV_NAME used for unique device names, composed of
 *  device type name and serial number appended after an underscore.
 *  Renamed and reworked list handling for device lists.
 *  Use functions from new module timeutil.
 *  windows.h is now included in mbg_tgt.h.
 *  Check for MBG_TGT_POSIX instead of MBG_TGT_UNIX.
 *  Account for PCPS_HRT_BIN_FRAC_SCALE renamed to MBG_FRAC32_UNITS_PER_SEC.
 *  Fixed macro definition syntax to avoid clang compiler warnings.
 *  Exclude mbg_chk_tstamp64_leap_sec() for BC builds for now.
 *  Lots of new doxygen comments and groups.
 *  Updated function prototypes.
 *  Revision 1.41  2013/09/26 08:54:54  martin
 *  Defined thread function type MBG_THREAD_FNC.
 *  Defined check-if-supported function type MBG_CHK_SUPP_FNC.
 *  Updated function prototypes.
 *  Revision 1.40  2012/10/02 18:40:30Z  martin
 *  There are some g++ versions which fail to compile source code using
 *  the macros provided by Linux to define IOCTL codes. If only the API
 *  functions are called by an application then the IOCTL codes aren't
 *  required anyway, so we just avoid inclusion of mbgioctl.h.
 *  Updated doxygen comments.
 *  Updated function prototypes.
 *  Support on-board event logs.
 *  Fixed a bug which caused a crash when generic I/O calls
 *  were used under Windows.
 *  Changes for QNX.
 *  Workaround to make mbgmon (BC) build under Windows.
 *  Cleaned up CPU set support under Linux.
 *  Moved some macros here so they can be used by other modules.
 *  Support reading CORR_INFO, and reading/writing TR_DISTANCE.
 *  Cleaned up handling of pragma pack().
 *  Cleaned up inclusion of header files.
 *  Moved mutex definitions to new mbgmutex.h.
 *  Renamed mutex stuff to critical sections.
 *  Updated function prototypes to support PTP unicast configuration
 *  Made xhrt leap second check an inline function.
 *  Fixed macro to avoid compiler warning.
 *  Revision 1.39  2009/12/15 15:34:59Z  daniel
 *  Support reading the raw IRIG data bits for firmware versions
 *  which support this feature.
 *  Revision 1.38.1.2  2009/12/10 09:58:53Z  daniel
 *  Revision 1.38.1.1  2009/12/10 09:45:29Z  daniel
 *  Revision 1.38  2009/09/29 15:06:26Z  martin
 *  Updated function prototypes.
 *  Revision 1.37  2009/08/12 14:31:51  daniel
 *  New version code 306, compatibility version still 210.
 *  Revision 1.36  2009/06/19 12:20:31Z  martin
 *  Updated function prototypes.
 *  Revision 1.35  2009/06/09 08:57:09  daniel
 *  New version code 305, compatibility version still 210.
 *  Revision 1.34  2009/06/08 18:20:14Z  daniel
 *  Updated function prototypes.
 *  Fixes for ARM target.
 *  Revision 1.33  2009/03/19 15:36:26  martin
 *  New version code 304, compatibility version still 210.
 *  Moved some inline functions dealing with MBG_PC_CYCLES
 *  from mbgdevio.h to pcpsdev.h.
 *  Include mbg_arch.h here.
 *  Removed unused doxygen comment.
 *  Updated function prototypes.
 *  Revision 1.32  2008/12/17 10:43:30Z  martin
 *  New version code 303, compatibility version still 210.
 *  Increased MBG_MAX_DEVICES from 5 to 8.
 *  Added macros to read the time stamp counter (cycles), and
 *  added an inline rdtscll() call for user space Linux.
 *  Added some inline functions to deal with cycles and timestamps.
 *  Generic support for threads and process/thread affinity controlled
 *  by symbol MBGDEVIO_USE_THREAD_API.
 *  New preprocessor symbol MBGDEVIO_HAVE_THREAD_AFFINITY.
 *  Support extrapolated time stamps controlled
 *  by symbol MBGDEVIO_XHRT_API.
 *  Removed definition of MBG_TGT_SUPP_MMAP.
 *  Updated function prototypes and doxygen comments.
 *  Revision 1.31  2008/02/26 16:57:38Z  martin
 *  Updated function prototypes and doxygen comments.
 *  Revision 1.30  2008/02/04 13:33:15Z  martin
 *  New preprocessor symbol MBG_TGT_SUPP_MMAP.
 *  Revision 1.29  2008/01/31 08:55:39Z  daniel
 *  Renamed functions related to mapped memory support
 *  Revision 1.28  2008/01/31 08:36:22Z  martin
 *  Picked up changes from 1.24.1.1:
 *  Added default preprocessor symbol MBGDEVIO_SIMPLE.
 *  Revision 1.27  2008/01/17 15:56:37Z  daniel
 *  New version code 302, compatibility version still 210.
 *  Added structure MBG_MAPPED_MEM_INFO.
 *  Updated function prototypes.
 *  Revision 1.26  2007/10/16 10:11:42Z  daniel
 *  New version code 301, compatibility version still 210.
 *  Revision 1.25  2007/09/26 14:10:34Z  martin
 *  New version code 300, compatibility version still 210.
 *  Added MBG_MAX_DEVICES.
 *  Added enum SELECTION_MODE.
 *  Added structures MBG_DEVICE_LIST and MBG_DEVICE_NAME_LIST.
 *  Updated function prototypes.
 *  Revision 1.24  2007/03/22 10:14:16Z  martin
 *  New version code 219, compatibility version still 210.
 *  Revision 1.23  2007/03/02 10:18:10Z  martin
 *  Updated function prototypes due to renamed data structures.
 *  Use new definitions of generic handle types.
 *  Preliminary support for *BSD.
 *  Revision 1.22  2006/08/09 13:47:29  martin
 *  New version code 218, compatibility version still 210.
 *  Revision 1.21  2006/06/08 12:30:22Z  martin
 *  New version code 217, compatibility version still 210.
 *  Revision 1.20  2006/05/02 13:14:27Z  martin
 *  New version code 216, compatibility version still 210.
 *  Updated function prototypes.
 *  Revision 1.19  2006/01/11 12:14:53Z  martin
 *  New version code 215, compatibility version still 210.
 *  Revision 1.18  2005/12/15 09:38:39Z  martin
 *  New version 214, compatibility version still 210.
 *  Revision 1.17  2005/06/02 11:54:40Z  martin
 *  Updated function prototypes.
 *  Revision 1.16  2005/02/16 15:13:00Z  martin
 *  New MBGDEVIO_VERSION 0x0212.
 *  Updated function prototypes.
 *  Revision 1.15  2005/01/14 10:22:44Z  martin
 *  Updated function prototypes.
 *  Revision 1.14  2004/12/09 11:24:00Z  martin
 *  Support configuration of on-board frequency synthesizer.
 *  Revision 1.13  2004/11/09 14:13:00Z  martin
 *  Updated function prototypes.
 *  Revision 1.12  2004/08/17 11:13:46Z  martin
 *  Account for renamed symbols.
 *  Revision 1.11  2004/04/14 09:34:23Z  martin
 *  New definition MBGDEVIO_COMPAT_VERSION.
 *  Pack structures 1 byte aligned.
 *  Revision 1.10  2003/12/22 15:35:10Z  martin
 *  New revision 2.03.
 *  Moved some definitions to pcpsdev.h.
 *  New structures to read device time together with associated
 *  PC high resolution timer cycles.
 *  Updated function prototypes.
 *  Revision 1.9  2003/06/19 08:50:05Z  martin
 *  Definition of MBGDEVIO_VERSION number to allow DLL
 *  API version checking.
 *  Replaced some defines by typedefs.
 *  Renamed USE_DOS_TSR to MBG_USE_DOS_TSR.
 *  New preprocessor symbol MBG_USE_KERNEL_DRIVER which
 *  is defined only for targets which use IOCTLs.
 *  Don't include pcps_dos.h here.
 *  Updated function prototypes.
 *  Revision 1.8  2003/05/16 08:44:26  MARTIN
 *  Cleaned up inclusion of headers.
 *  Removed obsolete definitions.
 *  Changes for direct access targets.
 *  Revision 1.7  2003/04/25 10:16:00  martin
 *  Updated inclusion of headers.
 *  Made prototypes available for all targets.
 *  Revision 1.6  2003/04/15 19:38:05Z  martin
 *  Updated function prototypes.
 *  Revision 1.5  2003/04/09 13:44:53Z  martin
 *  Use new common IOCTL codes from mbgioctl.h.
 *  Updated function prototypes.
 *  Revision 1.4  2002/09/06 11:06:35Z  martin
 *  Updated function prototypes for Win32 API..
 *  Win32 compatibility macros to use old APIs with new functions.
 *  Support targets OS/2 and NetWare.
 *  Revision 1.3  2002/02/28 10:08:54Z  MARTIN
 *  Syntax cleanup for Win32.
 *  Revision 1.2  2002/02/26 14:40:47  MARTIN
 *  Source code cleanup.
 *  Changes for DOS with and without TSR.
 *  Revision 1.1  2002/02/19 13:48:21  MARTIN
 *  Initial revision
 *
 **************************************************************************/

#ifndef _MBGDEVIO_H
#define _MBGDEVIO_H


/* Other headers to be included */

#include <mbg_tgt.h>
#include <mbg_arch.h>
#include <cfg_hlp.h>
#include <timeutil.h>
#include <mbgmutex.h>
#include <mbgerror.h>
#include <mbggeo.h>
#include <pcpsdev.h>
#include <pci_asic.h>
#include <use_pack.h>

#include <time.h>
#include <stdio.h>
#include <errno.h>


#define MBGDEVIO_VERSION         0x0308

#define MBGDEVIO_COMPAT_VERSION  0x0210


#if defined( MBG_TGT_WIN32 )

  #if !defined( MBGDEVIO_XHRT_API )
    #define MBGDEVIO_XHRT_API  1
  #endif

  #if !defined( MBGDEVIO_USE_THREAD_API )
    #define MBGDEVIO_USE_THREAD_API  1
  #endif

  #if !defined( MBGDEVIO_HAVE_THREAD_AFFINITY )
    #define MBGDEVIO_HAVE_THREAD_AFFINITY  1
  #endif

  #define MBGDEVIO_RET_VAL  DWORD

#elif defined( MBG_TGT_LINUX )

  #if !defined( MBGDEVIO_XHRT_API )
    #define MBGDEVIO_XHRT_API  1
  #endif

  // Thread support under Linux depends strongly on
  // the versions of some libraries, so the symbols
  // MBGDEVIO_USE_THREAD_API and MBGDEVIO_HAVE_THREAD_AFFINITY
  // should be set in the project's Makefile, depending on the
  // target envionment. Otherwise thread support is disabled
  // as per default.

  #include <sys/ioctl.h>
  #include <fcntl.h>
  #include <sched.h>

  #if MBGDEVIO_USE_THREAD_API
    #include <pthread.h>
  #endif

#elif defined( MBG_TGT_BSD )

  #include <sys/ioctl.h>
  #include <fcntl.h>

#elif defined( MBG_TGT_OS2 )

#elif defined( MBG_TGT_QNX_NTO )

  #include <sys/types.h>
  #include <sys/stat.h>
  #include <fcntl.h>

  #include <pcpsdrvr.h>

#elif defined( MBG_TGT_DOS )

  #if !defined( MBG_USE_DOS_TSR )
    #define MBG_USE_DOS_TSR  1
  #endif

  #include <pcpsdrvr.h>

#else // other target OSs which access the hardware directly

  #include <pcpsdrvr.h>

#endif


#if MBG_TGT_USE_IOCTL

  #include <mbgioctl.h>

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

#endif


#if !defined( MBGDEVIO_XHRT_API )
  #define MBGDEVIO_XHRT_API  0
#endif

#if !defined( MBGDEVIO_USE_THREAD_API )
  #define MBGDEVIO_USE_THREAD_API  0
#endif

#if !defined( MBGDEVIO_HAVE_THREAD_AFFINITY )
  #define MBGDEVIO_HAVE_THREAD_AFFINITY  0
#endif

#if ( 0 && defined( DEBUG ) )
  #define DEBUG_IOCTL_CALLS  1
#else
  #define DEBUG_IOCTL_CALLS  0
#endif


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


/* Start of header body */

#if defined( _USE_PACK )
  #pragma pack( 1 )      // set byte alignment
  #define _USING_BYTE_ALIGNMENT
#endif


#ifdef __cplusplus
extern "C" {
#endif

#if MBG_TGT_USE_IOCTL   // TODO should we use a different symbol to control this?

  typedef MBG_HANDLE MBG_DEV_HANDLE;

  #define MBG_INVALID_DEV_HANDLE  MBG_INVALID_HANDLE

#else // other target OSs which access the hardware directly

  typedef PCPS_DDEV *MBG_DEV_HANDLE;

  #define MBG_INVALID_DEV_HANDLE  NULL

#endif


#if !defined( MBGDEVIO_RET_VAL )
  #define MBGDEVIO_RET_VAL   int
#endif


#if !defined( _mbgdevio_cnv_ret_val )
  #define _mbgdevio_cnv_ret_val( _v )  (_v)
#endif


typedef char MBG_DEV_FN[260];   // Conforming to MAX_PATH in Windows


#if MBG_TGT_HAS_DEV_FN_BASE

#define MBGCLOCK_DEV_FN_BASE  "/dev/mbgclock"
#define MBGCLOCK_DEV_FN_FMT   MBGCLOCK_DEV_FN_BASE "%i"

_ext const char mbg_dev_fn_base[]
#ifdef _DO_INIT
  = MBGCLOCK_DEV_FN_BASE
#endif
;

_ext const char mbg_dev_fn_fmt[]
#ifdef _DO_INIT
  = MBGCLOCK_DEV_FN_FMT
#endif
;

#endif



// Definitions specific to the target OS

#if defined( MBG_TGT_LINUX )

  #define MBG_PROCESS_ID              pid_t
  #define _mbg_get_current_process()  0

  // __cpu_set_t_defined used to be defined by GNU's glibc.
  // However, at least with glibc-2.26 this doesn't seem to be
  // the case anymore, so we test alternatively if CPU_SETSIZE
  // is defined.
  #if defined( __cpu_set_t_defined ) || defined( CPU_SETSIZE )
    #define MBG_CPU_SET               cpu_set_t
    #define MBG_CPU_SET_SIZE          CPU_SETSIZE
    #define _mbg_cpu_clear( _ps )     CPU_ZERO( (_ps) )
    #define _mbg_cpu_set( _i, _ps )   CPU_SET( (_i), (_ps) )
    #define _mbg_cpu_isset( _i, _ps ) CPU_ISSET( (_i), (_ps) )
  #endif

  #if MBGDEVIO_USE_THREAD_API
    #define MBG_THREAD_ID             pthread_t
    #define _mbg_get_current_thread() 0
    #define MBG_THREAD_FNC_ATTR       // empty
    #define MBG_THREAD_FNC_RET_VAL    void *
    #define _mbg_thread_exit( _v )    return (void *) (_v)
  #endif

#elif defined( MBG_TGT_WIN32 )

  #define MBG_PROCESS_ID              HANDLE
  #define _mbg_get_current_process()  GetCurrentProcess()

  #define MBG_CPU_SET                 DWORD_PTR  // Attention: this is not used as pointer!
  #define MBG_CPU_SET_SIZE            ( sizeof( MBG_CPU_SET ) * 8 )

  #define MBG_THREAD_ID               HANDLE
  #define _mbg_get_current_thread()   GetCurrentThread()
  #define MBG_THREAD_FNC_ATTR         WINAPI
  #define MBG_THREAD_FNC_RET_VAL      DWORD
  #define _mbg_thread_exit( _v )      ExitThread( _v ); return (_v)

#endif  // target specific


#if !defined( MBG_TGT_WIN32 )
  #define FILETIME    int  // just a dummy to avoid build errors
#endif

#if !defined( MBG_PROCESS_ID )
  #define MBG_PROCESS_ID              int
#endif

#if !defined( _mbg_get_current_process )
  #define _mbg_get_current_process()  0
#endif

#if !defined( MBG_CPU_SET )
  #define MBG_CPU_SET                 int
#endif

#if !defined( MBG_CPU_SET_SIZE )
  #define MBG_CPU_SET_SIZE            ( sizeof( MBG_CPU_SET ) * 8 )
#endif

#if !defined( _mbg_cpu_clear )
  #define _mbg_cpu_clear( _ps )       ( *(_ps) = 0 )
#endif

#if !defined( _mbg_cpu_set )
  #define _mbg_cpu_set( _i, _ps )     ( *(_ps) |= ( (MBG_CPU_SET) 1UL << (_i) ) )
#endif

#if !defined( _mbg_cpu_isset )
  #define _mbg_cpu_isset( _i, _ps )   ( *(_ps) & ( 1UL << (_i) ) )
#endif


#if !defined( MBG_THREAD_ID )
  #define MBG_THREAD_ID               int
#endif

#if !defined( _mbg_get_current_thread )
  #define _mbg_get_current_thread()   0
#endif

#if !defined( MBG_THREAD_FNC_ATTR )
  #define MBG_THREAD_FNC_ATTR         // empty
#endif

#if !defined( MBG_THREAD_FNC_RET_VAL )
  #define MBG_THREAD_FNC_RET_VAL      void
#endif

#if !defined( _mbg_thread_exit )
  #define _mbg_thread_exit( _v )      _nop_macro_fnc()
#endif



typedef struct
{
  MBG_THREAD_ID thread_id;
  #if defined( MBG_TGT_WIN32 )
    HANDLE exit_request;
  #endif

} MBG_THREAD_INFO;



typedef MBG_THREAD_FNC_RET_VAL MBG_THREAD_FNC_ATTR MBG_THREAD_FNC( void * );



typedef struct
{
  PCPS_HR_TIME_CYCLES htc;    
  uint64_t pcps_hr_tstamp64;  

} MBG_XHRT_VARS;



typedef struct
{
  MBG_XHRT_VARS vars;
  MBG_XHRT_VARS prv_vars;
  MBG_PC_CYCLES_FREQUENCY freq_hz;
  int ioctl_status;
  int sleep_ms;
  MBG_CRIT_SECT crit_sect;
  MBG_DEV_HANDLE dh;

} MBG_XHRT_INFO;



typedef struct
{
  MBG_XHRT_INFO xhrt_info;
  MBG_THREAD_INFO ti;

} MBG_POLL_THREAD_INFO;



enum MBG_MATCH_MODES
{
  MBG_MATCH_ANY,      
  MBG_MATCH_MODEL,    
  MBG_MATCH_EXACTLY,  
  N_MBG_MATCH_MODES   
};



typedef struct _MBG_DEV_FN_LIST_ENTRY MBG_DEV_FN_LIST_ENTRY;


struct _MBG_DEV_FN_LIST_ENTRY
{
  char *dev_fn_ptr;  
  MBG_DEV_FN_LIST_ENTRY *next;
};



typedef struct _MBG_DEV_NAME_LIST_ENTRY MBG_DEV_NAME_LIST_ENTRY;


struct _MBG_DEV_NAME_LIST_ENTRY
{
  char dev_name[40];      
  MBG_DEV_NAME_LIST_ENTRY *next;
};



typedef int _MBG_API MBG_CHK_SUPP_FNC( MBG_DEV_HANDLE dh );




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

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

 _MBG_API_ATTR int _MBG_API mbgdevio_get_version( void ) ;

 _MBG_API_ATTR int _MBG_API mbgdevio_check_version( int header_version ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_receiver_info( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_gps_data( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_generic_io( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_asic_version( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_asic_features( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_xmr( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_isa( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_mca( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_pci( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_pci_express( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_usb( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_gnss( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_gps( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_dcf( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_pzf( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_msf( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_wwvb( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_jjy( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_lwr( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_is_tcr( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_lan_intf( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_ptp( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_ptp_unicast( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_hr_time( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_fast_hr_timestamp( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_time_scale( MBG_DEV_HANDLE dh ) ;

 /* (Intentionally excluded from Doxygen)
 * @brief Check if a device supports setting an event time
 *
 * This feature is only supported by some special custom firmware
 * to preset a %UTC time at which the clock is to generate an output signal.
 *
 * @note This function should be preferred over ::mbg_dev_has_event_time,
 * which has been deprecated.
 *
 * @param[in]  dh  Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 *
 * @return ::MBG_SUCCESS if the requested feature is supported, ::MBG_ERR_NOT_SUPP_BY_DEV
 *         if not supported, or one of the other @ref MBG_ERROR_CODES
 *
 * @ingroup mbgdevio_chk_supp_fncs
 * @see ::mbg_set_event_time
 */
 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_event_time( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_ucap( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_can_clr_ucap_buff( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_tzdl( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_pcps_tzdl( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_tzcode( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_tz( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_irig( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_irig_tx( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_irig_ctrl_bits( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_raw_irig_data( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_irig_time( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_signal( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_mod( MBG_DEV_HANDLE dh ) ;

 /* (Intentionally excluded from Doxygen)
 * @brief Check if a device supports higher baud rates than usual
 *
 * Check if a device provides a serial output that supports
 * higher baud rates than older cards, i.e. ::DEFAULT_BAUD_RATES_DCF_HS
 * rather than ::DEFAULT_BAUD_RATES_DCF.
 *
 * The call ::mbg_get_serial_settings takes care of this, so applications
 * which use that call as suggested don't need to use this call directly.
 *
 * @note This function should be preferred over ::mbg_dev_has_serial_hs,
 * which has been deprecated.
 *
 * @param[in]  dh  Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 *
 * @return ::MBG_SUCCESS if the requested feature is supported, ::MBG_ERR_NOT_SUPP_BY_DEV
 *         if not supported, or one of the other @ref MBG_ERROR_CODES
 *
 * @ingroup mbgdevio_chk_supp_fncs
 * @see ::mbg_get_serial_settings
 */
 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_serial_hs( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_synth( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_gpio( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_cab_len( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_ref_offs( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_opt_flags( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_utc_parm( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_corr_info( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_tr_distance( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_debug_status( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_evt_log( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_chk_dev_has_dac_ctrl( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_receiver_info" ) _MBG_API mbg_dev_has_receiver_info( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_gps_data" ) _MBG_API mbg_dev_has_gps_data( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_generic_io" ) _MBG_API mbg_dev_has_generic_io( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_asic_version" ) _MBG_API mbg_dev_has_asic_version( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_asic_features" ) _MBG_API mbg_dev_has_asic_features( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_xmr" ) _MBG_API mbg_dev_has_xmr( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_is_gnss" ) _MBG_API mbg_dev_is_gnss( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_is_gps" ) _MBG_API mbg_dev_is_gps( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_is_dcf" ) _MBG_API mbg_dev_is_dcf( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_pzf" ) _MBG_API mbg_dev_has_pzf( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_is_msf" ) _MBG_API mbg_dev_is_msf( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_is_wwvb" ) _MBG_API mbg_dev_is_wwvb( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_is_lwr" ) _MBG_API mbg_dev_is_lwr( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_is_tcr" ) _MBG_API mbg_dev_is_irig_rx( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_lan_intf" ) _MBG_API mbg_dev_has_lan_intf( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_ptp" ) _MBG_API mbg_dev_has_ptp( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_ptp_unicast" ) _MBG_API mbg_dev_has_ptp_unicast( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_hr_time" ) _MBG_API mbg_dev_has_hr_time( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_fast_hr_timestamp" ) _MBG_API mbg_dev_has_fast_hr_timestamp( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_time_scale" ) _MBG_API mbg_dev_has_time_scale( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_event_time" ) _MBG_API mbg_dev_has_event_time( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_ucap" ) _MBG_API mbg_dev_has_ucap( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_can_clr_ucap_buff" ) _MBG_API mbg_dev_can_clr_ucap_buff( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_tzdl" ) _MBG_API mbg_dev_has_tzdl( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_pcps_tzdl" ) _MBG_API mbg_dev_has_pcps_tzdl( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_tzcode" ) _MBG_API mbg_dev_has_tzcode( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_tz" ) _MBG_API mbg_dev_has_tz( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_irig" ) _MBG_API mbg_dev_has_irig( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_irig_tx" ) _MBG_API mbg_dev_has_irig_tx( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_irig_ctrl_bits" ) _MBG_API mbg_dev_has_irig_ctrl_bits( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_raw_irig_data" ) _MBG_API mbg_dev_has_raw_irig_data( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_irig_time" ) _MBG_API mbg_dev_has_irig_time( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_signal" ) _MBG_API mbg_dev_has_signal( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_mod" ) _MBG_API mbg_dev_has_mod( MBG_DEV_HANDLE dh, int *p ) ;

 /* (Intentionally excluded from Doxygen)
 * @brief Check if a device supports higher baud rates than usual
 *
 * Check if a device provides a serial output that supports
 * higher baud rates than older cards, i.e. ::DEFAULT_BAUD_RATES_DCF_HS
 * rather than ::DEFAULT_BAUD_RATES_DCF.
 *
 * @deprecated This function is deprecated, use ::mbg_chk_dev_has_serial_hs preferably.
 *
 * @param[in]  dh  Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 * @param[out] p   Pointer to an int which is updated if the API call succeeds.
 *                 The flag is set != 0 if the requested feature is supported, else 0.
 *
 * @return ::MBG_SUCCESS on success, if *p has been updated, else one of the @ref MBG_ERROR_CODES
 *
 * @ingroup mbgdevio_chk_supp_fncs_deprecated
 * @see ::mbg_chk_dev_has_serial_hs
 */
 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_serial_hs" ) _MBG_API mbg_dev_has_serial_hs( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_synth" ) _MBG_API mbg_dev_has_synth( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_gpio" ) _MBG_API mbg_dev_has_gpio( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_cab_len" ) _MBG_API mbg_dev_has_cab_len( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_ref_offs" ) _MBG_API mbg_dev_has_ref_offs( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_opt_flags" ) _MBG_API mbg_dev_has_opt_flags( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_utc_parm" ) _MBG_API mbg_dev_has_utc_parm( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_corr_info" ) _MBG_API mbg_dev_has_corr_info( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_tr_distance" ) _MBG_API mbg_dev_has_tr_distance( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_debug_status" ) _MBG_API mbg_dev_has_debug_status( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _DEPRECATED_BY( "mbg_chk_dev_has_evt_log" ) _MBG_API mbg_dev_has_evt_log( MBG_DEV_HANDLE dh, int *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_dev_fn_from_dev_idx( char *s, int max_len, int dev_idx ) ;

 _MBG_API_ATTR MBG_DEV_HANDLE _MBG_API mbg_open_device( int dev_idx ) ;

 _MBG_API_ATTR MBG_DEV_HANDLE _MBG_API mbg_open_device_by_dev_fn( const char *dev_fn ) ;

 _MBG_API_ATTR MBG_DEV_HANDLE _DEPRECATED_BY( "mbg_open_device_by_dev_fn" ) _MBG_API mbg_open_device_by_hw_id( const char *dev_fn ) ;

 _MBG_API_ATTR int _MBG_API mbg_find_devices( void ) ;

 _MBG_API_ATTR int _MBG_API mbg_find_devices_with_names( MBG_DEV_NAME_LIST_ENTRY **p_list, int max_devices ) ;

 _MBG_API_ATTR void _MBG_API mbg_free_device_name_list( MBG_DEV_NAME_LIST_ENTRY *list ) ;

 _MBG_API_ATTR void _MBG_API mbg_split_dev_name( const MBG_DEV_NAME dev_name, char *type_name, size_t type_name_size, char *sernum, size_t sernum_size ) ;

 _MBG_API_ATTR MBG_DEV_HANDLE _MBG_API mbg_open_device_by_name( const MBG_DEV_NAME srch_name, int selection_mode ) ;

 _MBG_API_ATTR void _MBG_API mbg_close_device( MBG_DEV_HANDLE *dev_handle ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_drvr_info( MBG_DEV_HANDLE dh, PCPS_DRVR_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_device_info( MBG_DEV_HANDLE dh, PCPS_DEV *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_status_port( MBG_DEV_HANDLE dh, PCPS_STATUS_PORT *p ) ;

 /* (Intentionally excluded from Doxygen)
 * Generic read function which writes a command code to a device
 * and reads a number of replied data to a generic buffer.
 *
 * <b>Warning</b>: This is for debugging purposes only!
 * The specialized API calls should be used preferably.
 * Not all devices support each of the ::PC_GPS_COMMANDS.
 *
 * @param[in]   dh   Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 * @param[in]   cmd  Can be any @ref PCPS_CMD_CODES "command code" supported by the device
 * @param[out]  p    Pointer to a buffer to be filled up
 * @param[in]   size Size of the output buffer
 *
 * @return ::MBG_SUCCESS on success, else one of the @ref MBG_ERROR_CODES
 *
 * @see ::mbg_generic_write
 * @see ::mbg_generic_read_gps
 * @see ::mbg_generic_write_gps
 * @see ::mbg_generic_io
 */
 _MBG_API_ATTR int _MBG_API mbg_generic_read( MBG_DEV_HANDLE dh, int cmd, void *p, int size ) ;

 /* (Intentionally excluded from Doxygen)
 * Generic read function which writes a GPS command code to a device
 * and reads a number of data bytes back into a generic buffer.
 * The function ::mbg_chk_dev_has_gps_data can be used to check
 * whether this call is supported by a device.
 *
 * <b>Warning</b>: This is for debugging purposes only!
 * The specialized API calls should be used preferably.
 * Not all devices support each of the ::PC_GPS_COMMANDS.
 *
 * @param[in]   dh    Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 * @param[in]   cmd   One of the ::PCPS_CMD_CODES supported by the device.
 * @param[out]  p     Pointer to a buffer to be filled up
 * @param[in]   size  Size of the buffer, has to match the expected data size associated with cmd
 *
 * @return ::MBG_SUCCESS on success, else one of the @ref MBG_ERROR_CODES
 *
 * @see ::mbg_chk_dev_has_gps_data
 * @see ::mbg_generic_write_gps
 * @see ::mbg_generic_read
 * @see ::mbg_generic_write
 * @see ::mbg_generic_io
 */
 _MBG_API_ATTR int _MBG_API mbg_generic_read_gps( MBG_DEV_HANDLE dh, int cmd, void *p, int size ) ;

 /* (Intentionally excluded from Doxygen)
 * Generic write function which writes a command code plus an
 * associated number of data bytes to a device.
 *
 * <b>Warning</b>: This is for debugging purposes only!
 * The specialized API calls should be used preferably.
 * Not all devices support each of the ::PC_GPS_COMMANDS.
 *
 * @param[in]  dh    Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 * @param[in]  cmd   One of the ::PCPS_CMD_CODES supported by the device.
 * @param[in]  p     Pointer to a buffer of data to be written
 * @param[in]  size  Size of the buffer, has to match the expected data size associated with cmd
 *
 * @return ::MBG_SUCCESS on success, else one of the @ref MBG_ERROR_CODES
 *
 * @see ::mbg_generic_read
 * @see ::mbg_generic_read_gps
 * @see ::mbg_generic_write_gps
 * @see ::mbg_generic_io
 */
 _MBG_API_ATTR int _MBG_API mbg_generic_write( MBG_DEV_HANDLE dh, int cmd, const void *p, int size ) ;

 /* (Intentionally excluded from Doxygen)
 * Generic write function which writes a GPS command code plus an
 * associated number of data bytes to a device.
 * The function ::mbg_chk_dev_has_gps_data can be used to check
 * whether this call is supported by a device.
 *
 * <b>Warning</b>: This is for debugging purposes only!
 * The specialized API calls should be used preferably.
 * Not all devices support each of the ::PC_GPS_COMMANDS.
 *
 * @param[in]  dh    Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 * @param[in]  cmd   One of the ::PCPS_CMD_CODES supported by the device.
 * @param[in]  p     Pointer to a buffer of data to be written
 * @param[in]  size  Size of the buffer, has to match the expected data size associated with cmd
 *
 * @return ::MBG_SUCCESS on success, else one of the @ref MBG_ERROR_CODES
 *
 * @see ::mbg_chk_dev_has_gps_data
 * @see ::mbg_generic_read_gps
 * @see ::mbg_generic_read
 * @see ::mbg_generic_write
 * @see ::mbg_generic_io
 */
 _MBG_API_ATTR int _MBG_API mbg_generic_write_gps( MBG_DEV_HANDLE dh, int cmd, const void *p, int size ) ;

 /* (Intentionally excluded from Doxygen)
 * Write and/or read generic data to/from a device.
 * The function ::mbg_chk_dev_has_generic_io checks
 * whether this call is supported by a device.
 *
 * <b>Warning</b>: This call is for debugging purposes and internal use only!
 *
 * @return ::MBG_SUCCESS on success, else one of the @ref MBG_ERROR_CODES
 *
 * @see ::mbg_chk_dev_has_generic_io
 * @see ::mbg_generic_read
 * @see ::mbg_generic_write
 * @see ::mbg_generic_read_gps
 * @see ::mbg_generic_write_gps
 */
 _MBG_API_ATTR int _MBG_API mbg_generic_io( MBG_DEV_HANDLE dh, int type, const void *in_p, int in_sz, void *out_p, int out_sz ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_time( MBG_DEV_HANDLE dh, PCPS_TIME *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_time( MBG_DEV_HANDLE dh, const PCPS_STIME *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_sync_time( MBG_DEV_HANDLE dh, PCPS_TIME *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_time_sec_change( MBG_DEV_HANDLE dh, PCPS_TIME *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_hr_time( MBG_DEV_HANDLE dh, PCPS_HR_TIME *p ) ;

 /* (Intentionally excluded from Doxygen )
 * Write a high resolution time stamp ::PCPS_TIME_STAMP to a device
 * to configure a %UTC time when the clock shall generate an event.
 * The API call ::mbg_chk_dev_has_event_time checks whether
 * this call is supported by a device.
 *
 * <b>Note:</b> This is only supported by some special firmware.
 *
 * @param[in]  dh  Valid ::MBG_DEV_HANDLE handle to a Meinberg device.
 * @param[in]  p   Pointer to a ::PCPS_TIME_STAMP structure to be written.
 *
 * @return ::MBG_SUCCESS on success, else one of the @ref MBG_ERROR_CODES
 *
 * @see ::mbg_chk_dev_has_event_time
 */
 _MBG_API_ATTR int _MBG_API mbg_set_event_time( MBG_DEV_HANDLE dh, const PCPS_TIME_STAMP *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_serial( MBG_DEV_HANDLE dh, PCPS_SERIAL *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_serial( MBG_DEV_HANDLE dh, const PCPS_SERIAL *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_tzcode( MBG_DEV_HANDLE dh, PCPS_TZCODE *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_tzcode( MBG_DEV_HANDLE dh, const PCPS_TZCODE *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_pcps_tzdl( MBG_DEV_HANDLE dh, PCPS_TZDL *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_pcps_tzdl( MBG_DEV_HANDLE dh, const PCPS_TZDL *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ref_offs( MBG_DEV_HANDLE dh, MBG_REF_OFFS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_ref_offs( MBG_DEV_HANDLE dh, const MBG_REF_OFFS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_opt_info( MBG_DEV_HANDLE dh, MBG_OPT_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_opt_settings( MBG_DEV_HANDLE dh, const MBG_OPT_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_irig_rx_info( MBG_DEV_HANDLE dh, IRIG_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_irig_rx_settings( MBG_DEV_HANDLE dh, const IRIG_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_all_irig_rx_info( MBG_DEV_HANDLE dh, const PCPS_DEV *pdev, IRIG_INFO *p_irig_info, MBG_REF_OFFS *p_ref_offs, MBG_OPT_INFO *p_opt_info ) ;

 _MBG_API_ATTR int _MBG_API mbg_save_all_irig_rx_settings( MBG_DEV_HANDLE dh, const PCPS_DEV *pdev, const IRIG_SETTINGS *p_irig_settings, const MBG_REF_OFFS *p_ref_offs, const MBG_OPT_SETTINGS *p_opt_settings ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_irig_ctrl_bits( MBG_DEV_HANDLE dh, MBG_IRIG_CTRL_BITS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_raw_irig_data( MBG_DEV_HANDLE dh, MBG_RAW_IRIG_DATA *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_raw_irig_data_on_sec_change( MBG_DEV_HANDLE dh, MBG_RAW_IRIG_DATA *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_irig_time( MBG_DEV_HANDLE dh, PCPS_IRIG_TIME *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_clr_ucap_buff( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ucap_entries( MBG_DEV_HANDLE dh, PCPS_UCAP_ENTRIES *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ucap_event( MBG_DEV_HANDLE dh, PCPS_HR_TIME *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_tzdl( MBG_DEV_HANDLE dh, TZDL *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_tzdl( MBG_DEV_HANDLE dh, const TZDL *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_sw_rev( MBG_DEV_HANDLE dh, SW_REV *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_bvar_stat( MBG_DEV_HANDLE dh, BVAR_STAT *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_time( MBG_DEV_HANDLE dh, TTM *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_time( MBG_DEV_HANDLE dh, const TTM *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_port_parm( MBG_DEV_HANDLE dh, PORT_PARM *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_port_parm( MBG_DEV_HANDLE dh, const PORT_PARM *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_ant_info( MBG_DEV_HANDLE dh, ANT_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_ucap( MBG_DEV_HANDLE dh, TTM *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_enable_flags( MBG_DEV_HANDLE dh, ENABLE_FLAGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_enable_flags( MBG_DEV_HANDLE dh, const ENABLE_FLAGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_stat_info( MBG_DEV_HANDLE dh, STAT_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_cmd( MBG_DEV_HANDLE dh, const GPS_CMD *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_pos( MBG_DEV_HANDLE dh, POS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_pos_xyz( MBG_DEV_HANDLE dh, const XYZ p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_pos_lla( MBG_DEV_HANDLE dh, const LLA p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_ant_cable_len( MBG_DEV_HANDLE dh, ANT_CABLE_LEN *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_ant_cable_len( MBG_DEV_HANDLE dh, const ANT_CABLE_LEN *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_receiver_info( MBG_DEV_HANDLE dh, RECEIVER_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_str_type_info( MBG_DEV_HANDLE dh, STR_TYPE_INFO_IDX stii[], const RECEIVER_INFO *p_ri ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_port_info( MBG_DEV_HANDLE dh, PORT_INFO_IDX pii[], const RECEIVER_INFO *p_ri ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_port_settings_idx( MBG_DEV_HANDLE dh, const PORT_SETTINGS_IDX *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_port_settings( MBG_DEV_HANDLE dh, const PORT_SETTINGS *p, int idx ) ;

 _MBG_API_ATTR int _MBG_API mbg_setup_receiver_info( MBG_DEV_HANDLE dh, const PCPS_DEV *p_dev, RECEIVER_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_asic_version( MBG_DEV_HANDLE dh, PCI_ASIC_VERSION *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_asic_features( MBG_DEV_HANDLE dh, PCI_ASIC_FEATURES *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_time_scale_info( MBG_DEV_HANDLE dh, MBG_TIME_SCALE_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_time_scale_settings( MBG_DEV_HANDLE dh, const MBG_TIME_SCALE_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_utc_parm( MBG_DEV_HANDLE dh, UTC *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_utc_parm( MBG_DEV_HANDLE dh, const UTC *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_time_cycles( MBG_DEV_HANDLE dh, PCPS_TIME_CYCLES *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_hr_time_cycles( MBG_DEV_HANDLE dh, PCPS_HR_TIME_CYCLES *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_hr_time_comp( MBG_DEV_HANDLE dh, PCPS_HR_TIME *p, int32_t *hns_latency ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_irig_tx_info( MBG_DEV_HANDLE dh, IRIG_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_irig_tx_settings( MBG_DEV_HANDLE dh, const IRIG_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_synth( MBG_DEV_HANDLE dh, SYNTH *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_synth( MBG_DEV_HANDLE dh, const SYNTH *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_synth_state( MBG_DEV_HANDLE dh, SYNTH_STATE *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_fast_hr_timestamp_cycles( MBG_DEV_HANDLE dh, PCPS_TIME_STAMP_CYCLES *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_fast_hr_timestamp_comp( MBG_DEV_HANDLE dh, PCPS_TIME_STAMP *p, int32_t *hns_latency ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_fast_hr_timestamp( MBG_DEV_HANDLE dh, PCPS_TIME_STAMP *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_pout_info( MBG_DEV_HANDLE dh, POUT_INFO_IDX pii[], const RECEIVER_INFO *p_ri ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_pout_settings_idx( MBG_DEV_HANDLE dh, const POUT_SETTINGS_IDX *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_pout_settings( MBG_DEV_HANDLE dh, const POUT_SETTINGS *p, int idx ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_irq_stat_info( MBG_DEV_HANDLE dh, PCPS_IRQ_STAT_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_lan_if_info( MBG_DEV_HANDLE dh, LAN_IF_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ip4_state( MBG_DEV_HANDLE dh, IP4_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ip4_settings( MBG_DEV_HANDLE dh, IP4_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_ip4_settings( MBG_DEV_HANDLE dh, const IP4_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ptp_state( MBG_DEV_HANDLE dh, PTP_STATE *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ptp_cfg_info( MBG_DEV_HANDLE dh, PTP_CFG_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_ptp_cfg_settings( MBG_DEV_HANDLE dh, const PTP_CFG_SETTINGS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_ptp_uc_master_cfg_limits( MBG_DEV_HANDLE dh, PTP_UC_MASTER_CFG_LIMITS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_all_ptp_uc_master_info( MBG_DEV_HANDLE dh, PTP_UC_MASTER_INFO_IDX pii[], const PTP_UC_MASTER_CFG_LIMITS *p_umsl ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_ptp_uc_master_settings_idx( MBG_DEV_HANDLE dh, const PTP_UC_MASTER_SETTINGS_IDX *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_time_info_hrt( MBG_DEV_HANDLE dh, MBG_TIME_INFO_HRT *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_time_info_tstamp( MBG_DEV_HANDLE dh, MBG_TIME_INFO_TSTAMP *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_corr_info( MBG_DEV_HANDLE dh, CORR_INFO *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_tr_distance( MBG_DEV_HANDLE dh, TR_DISTANCE *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_tr_distance( MBG_DEV_HANDLE dh, const TR_DISTANCE *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_debug_status( MBG_DEV_HANDLE dh, MBG_DEBUG_STATUS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_clr_evt_log( MBG_DEV_HANDLE dh ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_num_evt_log_entries( MBG_DEV_HANDLE dh, MBG_NUM_EVT_LOG_ENTRIES *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_first_evt_log_entry( MBG_DEV_HANDLE dh, MBG_EVT_LOG_ENTRY *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_next_evt_log_entry( MBG_DEV_HANDLE dh, MBG_EVT_LOG_ENTRY *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_gnss_mode_info( MBG_DEV_HANDLE dh, MBG_GNSS_MODE_INFO *p_mi ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_gnss_mode_settings( MBG_DEV_HANDLE dh, const MBG_GNSS_MODE_SETTINGS *p_ms ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_gnss_sat_info( MBG_DEV_HANDLE dh, GNSS_SAT_INFO_IDX gsii[], const MBG_GNSS_MODE_INFO *p_mi ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gpio_cfg_limits( MBG_DEV_HANDLE dh, MBG_GPIO_CFG_LIMITS *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_gpio_info( MBG_DEV_HANDLE dh, MBG_GPIO_INFO_IDX gii[], const MBG_GPIO_CFG_LIMITS *p_gcl ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_gpio_settings_idx( MBG_DEV_HANDLE dh, const MBG_GPIO_SETTINGS_IDX *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_gpio_status( MBG_DEV_HANDLE dh, MBG_GPIO_STATUS_IDX gsi[], const MBG_GPIO_CFG_LIMITS *p_gcl ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_xmr_instances( MBG_DEV_HANDLE dh, XMULTI_REF_INSTANCES *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_xmr_status( MBG_DEV_HANDLE dh, XMULTI_REF_STATUS_IDX xmrsi[], const XMULTI_REF_INSTANCES *p_xmri ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_gps_all_xmr_info( MBG_DEV_HANDLE dh, XMULTI_REF_INFO_IDX xmrii[], const XMULTI_REF_INSTANCES *p_xmri ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_gps_xmr_settings_idx( MBG_DEV_HANDLE dh, const XMULTI_REF_SETTINGS_IDX *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_xmr_holdover_status( MBG_DEV_HANDLE dh, XMR_HOLDOVER_STATUS *p, const XMULTI_REF_INSTANCES *p_xmri ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_process_affinity( MBG_PROCESS_ID pid, MBG_CPU_SET *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_process_affinity( MBG_PROCESS_ID pid, MBG_CPU_SET *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_set_current_process_affinity_to_cpu( int cpu_num ) ;

 _MBG_API_ATTR int _MBG_API mbg_thread_create( MBG_THREAD_INFO *p_ti, MBG_THREAD_FNC fnc, void *arg ) ;

 _MBG_API_ATTR int _MBG_API mbg_thread_stop( MBG_THREAD_INFO *p_ti ) ;

 _MBG_API_ATTR int _MBG_API mbg_thread_sleep_interruptible( MBG_THREAD_INFO *p_ti, ulong sleep_ms ) ;

 _MBG_API_ATTR int _MBG_API mbg_thread_set_affinity( MBG_THREAD_INFO *p_ti, MBG_CPU_SET *p ) ;

 _MBG_API_ATTR int _MBG_API mbg_xhrt_poll_thread_create( MBG_POLL_THREAD_INFO *p_pti, MBG_DEV_HANDLE dh, MBG_PC_CYCLES_FREQUENCY freq_hz, int sleep_ms ) ;

 _MBG_API_ATTR int _MBG_API mbg_xhrt_poll_thread_stop( MBG_POLL_THREAD_INFO *p_pti ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_xhrt_time_as_pcps_hr_time( MBG_XHRT_INFO *p, PCPS_HR_TIME *p_hrt ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_xhrt_time_as_filetime( MBG_XHRT_INFO *p, FILETIME *p_ft ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_xhrt_cycles_frequency( MBG_XHRT_INFO *p, MBG_PC_CYCLES_FREQUENCY *p_freq_hz ) ;

 _MBG_API_ATTR int _MBG_API mbg_get_default_cycles_frequency_from_dev( MBG_DEV_HANDLE dh, MBG_PC_CYCLES_FREQUENCY *p ) ;

 _MBG_API_ATTR MBG_PC_CYCLES_FREQUENCY _MBG_API mbg_get_default_cycles_frequency( void ) ;


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


#if defined( MBG_TGT_WIN32 )

static __mbg_inline
MBGDEVIO_RET_VAL do_mbg_ioctl( MBG_DEV_HANDLE dh, int ioctl_code,
                               const void *in_p, int in_sz, void *out_p, int out_sz )
{
  DWORD ReturnedLength = 0;

  if ( !DeviceIoControl( dh, ioctl_code,
                         (LPVOID) in_p, in_sz, out_p, out_sz,
                         &ReturnedLength,
                         NULL
                       ) )
  {
    DWORD last_error = GetLastError();
    int rc = mbg_win32_sys_err_to_mbg( last_error, NULL );

    #if 0  //### TODO FIXME
      // We can't call mbgsvctl_log_mbgdevio_error() here (for now).
      // Is is defined in mbgsvctl.h, and including mbgsvctl.h here,
      // or copying the prototype here results in DLL import/export
      // mismatch errors.

      // do not report a USB device timeout error
      if ( rc != MBG_ERR_USB_ACCESS )
        mbgsvctl_log_mbgdevio_error( ioctl_code, rc );
    #endif

    return rc;
  }

  return MBG_SUCCESS;

}  // do_mbg_ioctl

  #define _do_mbg_ioctl( _dh, _ioctl, _p, _in_sz, _out_sz ) \
    do_mbg_ioctl( _dh, _ioctl, (LPVOID) _p, _in_sz, (LPVOID) _p, _out_sz )

#elif defined( MBG_HAS_POSIX_IOCTL )

  // In case of an error ioctl returns -1, and errno has been set
  // to a *positive* POSIX error code.

  static __mbg_inline
  MBGDEVIO_RET_VAL do_mbg_ioctl( MBG_DEV_HANDLE dh, unsigned long ioctl_code, const void *p )
  {
    int sys_rc = ioctl( dh, ioctl_code, (void *) p );

    if ( sys_rc == -1 )  // error
    {
      int sys_errno = errno;
      int rc = mbg_posix_errno_to_mbg( sys_errno, NULL );

      #if DEBUG_IOCTL_CALLS
        fprintf( stderr, "IOCTL %s (0x%08lX) error: %s (errno: %i) --> %s (rc: %i)\n",
                 mbgioctl_get_name( ioctl_code ), (ulong) ioctl_code,
                 strerror( sys_errno ), sys_errno,
                 mbg_strerror( rc ), rc );
      #endif

      return rc;
    }

    return MBG_SUCCESS;
  }

  #define _do_mbg_ioctl( _dh, _ioctl, _p, _in_sz, _out_sz ) \
    do_mbg_ioctl( _dh, _ioctl, _p )

#endif



// The code below depends on whether the target device is accessed via
// IOCTLs to a device driver, or the hardware is accessed directly.

#if MBG_TGT_USE_IOCTL

  static __mbg_inline
  int mbgdevio_do_gen_io( MBG_DEV_HANDLE dh, int info, unsigned int ioctl_code,
                          const void *in_p, int in_sz,
                          void *out_p, int out_sz )
  {
    MBGDEVIO_RET_VAL rc;

    // Generic IOCTL calls always need to pass some info beside
    // the I/O buffers down to the driver, which usually is
    // the command code for the device.
    // Thus we must always use one of the control structures
    // IOCTL_GENERIC_REQ or IOCTL_GENERIC_BUFFER, whichever
    // is appropriate for the target OS.

    #if USE_IOCTL_GENERIC_REQ

      IOCTL_GENERIC_REQ req = { 0 };

      req.in_p = (uintptr_t) in_p;
      req.out_p = (uintptr_t) out_p;
      req.in_sz = in_sz;
      req.out_sz = out_sz;
      req.info = info;

      #if DEBUG_IOCTL_CALLS
        printf( "inp:  %p --> 0x%" PRIx64 " (%lu)\n", in_p, req.in_p, (ulong) req.in_sz );
        printf( "outp: %p --> 0x%" PRIx64 " (%lu)\n", out_p, req.out_p, (ulong) req.out_sz );
      #endif

      rc = _do_mbg_ioctl( dh, ioctl_code, &req, sizeof( req ), 0 );

    #else

      IOCTL_GENERIC_BUFFER *p_buff;
      int buff_size = sizeof( p_buff->ctl )
                    + ( ( in_sz > out_sz ) ? in_sz : out_sz );

      p_buff = (IOCTL_GENERIC_BUFFER *) malloc( buff_size );

      if ( p_buff == NULL )
        return MBG_ERR_NO_MEM;

      p_buff->ctl.info = info;
      p_buff->ctl.data_size_in = in_sz;
      p_buff->ctl.data_size_out = out_sz;

      if ( in_p )
        memcpy( p_buff->data, in_p, in_sz );

      rc = _do_mbg_ioctl( dh, ioctl_code, p_buff,
                          sizeof( IOCTL_GENERIC_CTL ) + in_sz,
                          sizeof( IOCTL_GENERIC_CTL ) + out_sz );

      if ( out_p && ( rc == MBG_SUCCESS ) )
        memcpy( out_p, p_buff->data, out_sz );

      free( p_buff );

    #endif

    return _mbgdevio_cnv_ret_val( rc );

  }  // mbgdevio_do_gen_io



  #define _do_mbgdevio_read( _dh, _cmd, _ioctl, _p, _sz ) \
    _do_mbg_ioctl( _dh, _ioctl, _p, 0, _sz )

  #define _do_mbgdevio_write( _dh, _cmd, _ioctl, _p, _sz ) \
    _do_mbg_ioctl( _dh, _ioctl, _p, _sz, 0 )

  #define _do_mbgdevio_read_gps      _do_mbgdevio_read

  #define _do_mbgdevio_write_gps     _do_mbgdevio_write



  #define _mbgdevio_read_var( _dh, _cmd, _ioctl, _p ) \
    _do_mbgdevio_read( _dh, _cmd, _ioctl, _p, sizeof( *(_p) ) )

  #define _mbgdevio_write_var( _dh, _cmd, _ioctl, _p ) \
    _do_mbgdevio_write( _dh, _cmd, _ioctl, _p, sizeof( *(_p) ) )

  #define _mbgdevio_write_cmd( _dh, _cmd, _ioctl ) \
    _do_mbgdevio_write( _dh, _cmd, _ioctl, NULL, 0 )

  #define _mbgdevio_read_gps        _do_mbgdevio_read
  #define _mbgdevio_read_gps_var    _mbgdevio_read_var

  #define _mbgdevio_write_gps       _do_mbgdevio_write
  #define _mbgdevio_write_gps_var   _mbgdevio_write_var


  #define _mbgdevio_gen_read( _dh, _cmd, _p, _sz ) \
    mbgdevio_do_gen_io( _dh, _cmd, IOCTL_PCPS_GENERIC_READ, NULL, 0, _p, _sz )

  #define _mbgdevio_gen_write( _dh, _cmd, _p, _sz ) \
    mbgdevio_do_gen_io( _dh, _cmd, IOCTL_PCPS_GENERIC_WRITE, _p, _sz, NULL, 0 )

  #define _mbgdevio_gen_io( _dh, _type, _in_p, _in_sz, _out_p, _out_sz ) \
    mbgdevio_do_gen_io( _dh, _type, IOCTL_PCPS_GENERIC_IO, _in_p, _in_sz, _out_p, _out_sz )

  #define _mbgdevio_gen_read_gps( _dh, _cmd, _p, _sz ) \
    mbgdevio_do_gen_io( _dh, _cmd, IOCTL_PCPS_GENERIC_READ_GPS, NULL, 0, _p, _sz )

  #define _mbgdevio_gen_write_gps( _dh, _cmd, _p, _sz ) \
    mbgdevio_do_gen_io( _dh, _cmd, IOCTL_PCPS_GENERIC_WRITE_GPS, _p, _sz, NULL, 0 )


#else  // !MBG_TGT_USE_IOCTL, accessing hardware device directly

  #define _mbgdevio_chk_cond( _cond )  \
  {                                    \
    if ( !(_cond) )                    \
      return MBG_ERR_NOT_SUPP_BY_DEV;  \
  }

  #define _mbgdevio_read( _dh, _cmd, _ioctl, _p, _sz ) \
    pcps_read_safe( _dh, _cmd, _p, _sz )

  #define _mbgdevio_write( _dh, _cmd, _ioctl, _p, _sz ) \
    pcps_write_safe( _dh, _cmd, _p, _sz )

  #define _do_mbgdevio_read_gps( _dh, _cmd, _ioctl, _p, _sz ) \
    pcps_read_gps_safe( _dh, _cmd, _p, _sz )

  #define _mbgdevio_write_gps( _dh, _cmd, _ioctl, _p, _sz ) \
    pcps_write_gps_safe( _dh, _cmd, _p, _sz )



//##+++++++++++++++++++
  #define _mbgdevio_read_var( _dh, _cmd, _ioctl, _p ) \
    _pcps_read_var_safe( _dh, _cmd, *(_p) )

  #define _mbgdevio_write_var( _dh, _cmd, _ioctl, _p ) \
    _pcps_write_var_safe( _dh, _cmd, *(_p) )

  #define _mbgdevio_write_cmd( _dh, _cmd, _ioctl ) \
    _pcps_write_byte_safe( _dh, _cmd );

  #define _mbgdevio_read_gps_var( _dh, _cmd, _ioctl, _p ) \
    _pcps_read_gps_var_safe( _dh, _cmd, *(_p) )

  #define _mbgdevio_write_gps_var( _dh, _cmd, _ioctl, _p ) \
    _pcps_write_gps_var_safe( _dh, _cmd, *(_p) )


  #define _mbgdevio_gen_read( _dh, _cmd, _p, _sz ) \
    _mbgdevio_read( _dh, _cmd, -1, _p, _sz )

  #define _mbgdevio_gen_write( _dh, _cmd, _p, _sz ) \
    _mbgdevio_write( _dh, _cmd, -1, _p, _sz )

  #define _mbgdevio_gen_io( _dh, _type, _in_p, _in_sz, _out_p, _out_sz ) \
    pcps_generic_io( _dh, _type, _in_p, _in_sz, _out_p, _out_sz );

  #define _mbgdevio_gen_read_gps( _dh, _cmd, _p, _sz ) \
    _do_mbgdevio_read_gps( _dh, _cmd, -1, _p, _sz )

  #define _mbgdevio_gen_write_gps( _dh, _cmd, _p, _sz ) \
    _mbgdevio_write_gps( _dh, _cmd, -1, _p, _sz )

#endif  // !MBG_TGT_USE_IOCTL



#define _mbg_generic_read_var( _dh, _cmd, _s )  \
  mbg_generic_read( _dh, _cmd, &(_s), sizeof( (_s) ) )

#define _mbg_generic_write_var( _dh, _cmd, _s )  \
  mbg_generic_write( _dh, _cmd, &(_s), sizeof( (_s) ) )

#define _mbg_generic_read_gps_var( _dh, _cmd, _s )  \
  mbg_generic_read_gps( _dh, _cmd, &(_s), sizeof( (_s) ) )

#define _mbg_generic_write_gps_var( _dh, _cmd, _s )  \
  mbg_generic_write_gps( _dh, _cmd, &(_s), sizeof( (_s) ) )



#define _mbgdevio_gen_read_var( _dh, _cmd, _s ) \
  _mbgdevio_gen_read( _dh, _cmd, &(_s), sizeof( (_s) ) )

#define _mbgdevio_gen_write_var( _dh, _cmd, _s ) \
  _mbgdevio_gen_write( _dh, _cmd, &(_s), sizeof( (_s) ) )

#define _mbgdevio_gen_read_gps_var( _dh, _cmd, _s ) \
  _mbgdevio_gen_read_gps( _dh, _cmd, &(_s), sizeof( (_s) ) )

#define _mbgdevio_gen_write_gps_var( _dh, _cmd, _s ) \
  _mbgdevio_gen_write_gps( _dh, _cmd, &(_s), sizeof( (_s) ) )



#if defined( MBG_TGT_WIN32 ) || defined( MBG_TGT_POSIX )

// NOTE
// For some reason the code below causes an internal compiler error
// with Borland C++Builder 5.0 release builds. Since we don't need
// this function in the BC5 projects anyway we simply exclude it
// from build.

#if !defined( __BORLANDC__ )

static __mbg_inline
void mbg_chk_tstamp64_leap_sec( uint64_t *tstamp64, PCPS_TIME_STATUS_X *status )
{
  if ( *status & ( PCPS_LS_ANN | PCPS_LS_ENB ) )
  {
    struct tm tm = { 0 };
    time_t t = cvt_to_time_t( (uint32_t) ( (*tstamp64) >> 32 ) );
    int rc = mbg_gmtime( &tm, &t );

    if ( mbg_rc_is_success( rc ) )
    {
      // Handle leap second and status
      if ( tm.tm_hour == 0 && tm.tm_min == 0 && tm.tm_sec == 0 )
      {
        if ( *status & PCPS_LS_ANN )
        {
          // Set leap second enabled flag on rollover to the leap second and clear announce flag
          *status &= ~PCPS_LS_ANN;
          *status |= PCPS_LS_ENB;

          // Decrement interpolated second to avoid automated overflow during the leap second.
          // Second 59 appears for the second time.
          *tstamp64 -= MBG_FRAC32_UNITS_PER_SEC;
        }
        else
          if ( *status & PCPS_LS_ENB ) // Clear bits when leap second expires and 0:00:00 UTC is reached
            *status &= ~( PCPS_LS_ANN | PCPS_LS_ENB );
      }
    }
  }

}  // mbg_chk_tstamp64_leap_sec

#endif  // !defined( __BORLANDC__ )

#endif  // defined( MBG_TGT_WIN32 ) || defined( MBG_TGT_POSIX )



static __mbg_inline
void mbg_init_pc_cycles_frequency( MBG_DEV_HANDLE dh, MBG_PC_CYCLES_FREQUENCY *p )
{
  if ( *p == 0 )
    mbg_get_default_cycles_frequency_from_dev( dh, p );

}  // mbg_init_pc_cycles_frequency



#if MBG_TGT_HAS_64BIT_TYPES

static __mbg_inline
uint64_t pcps_time_stamp_to_uint64( const PCPS_TIME_STAMP *ts )
{
  return ( ( (uint64_t) ts->sec ) << 32 ) + ts->frac;

}  // pcps_time_stamp_to_uint64



static __mbg_inline
void uint64_to_pcps_time_stamp( PCPS_TIME_STAMP *ts, uint64_t n )
{
  ts->sec = (uint32_t) ( n >> 32 );
  ts->frac = (uint32_t) ( n & 0xFFFFFFFFUL );

}  // uint64_to_pcps_time_stamp

#endif


#ifdef __cplusplus
}
#endif

#if defined( _USING_BYTE_ALIGNMENT )
  #pragma pack()      // set default alignment
  #undef _USING_BYTE_ALIGNMENT
#endif

/* End of header body */


#undef _ext
#undef _DO_INIT

#endif  /* _MBGDEVIO_H */