mbgextio.c

Go to the documentation of this file.

/**************************************************************************
 *
 *  $Id: mbgextio.c 1.20.1.33.1.212 2018/06/07 14:16:55 philipp TRASH $
 *
 *  Copyright (c) Meinberg Funkuhren, Bad Pyrmont, Germany
 *
 *  Description:
 *    Meinberg extended I/O functions for the binary data protocol
 *    via serial communication, network socket I/O, or direct USB I/O.
 *
 *    These functions can *not* be used to access LANTIME NTP servers,
 *    or the modules assembled within a LANTIME since LANTIMEs are using
 *    this kind of communication only internally.
 *
 *    Also, standalone USB devices are usually handled by the driver
 *    accessed in the same way as PCI cards, using the API functions
 *    provided by the mbgdevio library.
 *
 *    These functions can be used, however, with standalone devices
 *    which are accessible either directly via a serial port, or via a
 *    special serial-to-LAN converter like the meinberg LAN_XPT module.
 *
 * -----------------------------------------------------------------------
 *  $Log: mbgextio.c $
 *  Revision 1.20.1.33.1.212  2018/06/07 14:16:55  philipp
 *  Added database command structure send function
 *  Revision 1.20.1.33.1.211  2018/06/05 14:09:14  martin
 *  Doxygen fixes.
 *  Revision 1.20.1.33.1.210  2018/06/05 11:27:55  thomas-b
 *  Added function to check for MBG_XFEATURE_GNSS_MODE
 *  Revision 1.20.1.33.1.209  2018/06/05 11:16:41  thomas-b
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.208  2018/06/05 09:41:55  philipp
 *  Added XFeature database
 *  Revision 1.20.1.33.1.207  2018/06/01 12:27:23  martin
 *  Introduced an optional NACK handler callback function.
 *  Removed mbgextio_get_last_nack_err_code() which is
 *  now obsolete.
 *  Added and fixed some doxygen comments.
 *  Revision 1.20.1.33.1.206  2018/05/29 11:15:32  philipp
 *  Added UFU flash command
 *  Revision 1.20.1.33.1.205  2018/05/29 08:17:49  martin
 *  Unified reception of spurious async binary messages and data bytes.
 *  Use common function to handle NACK messages.
 *  Revision 1.20.1.33.1.204  2018/05/09 08:15:24  thomas-b
 *  Fixed error check in mbgextio_setup_xdevfeat
 *  Revision 1.20.1.33.1.203  2018/04/17 13:29:57  martin
 *  Fixed build without socket I/O.
 *  Revision 1.20.1.33.1.202  2018/04/03 05:49:54  thomas-b
 *  User authentication is only supported via encrypted SSH connection, yet
 *  Revision 1.20.1.33.1.201  2018/03/26 08:04:50  thomas-b
 *  Added fw mngmnt API functions
 *  Revision 1.20.1.33.1.200  2018/03/15 14:03:32  philipp
 *  Added syslog option to monitoring feature
 *  Revision 1.20.1.33.1.199  2018/03/15 11:12:05  martin
 *  New function mbgextio_dev_has_up_conv().
 *  Fixed compiler warning if building without SSH support.
 *  Revision 1.20.1.33.1.198  2018/03/13 07:16:38  thomas-b
 *  Use MBG_INVALID_SOCK_FD instead of INVALID_SOCKET
 *  Revision 1.20.1.33.1.197  2018/03/12 09:32:20  thomas-b
 *  Fixed INVALID_SOCKET check and getaddrinfo usage under Windows
 *  Revision 1.20.1.33.1.196  2018/03/08 13:34:33  philipp
 *  Added mutex to protect libssh's read/write functions
 *  Revision 1.20.1.33.1.195  2018/03/01 10:20:33  martin
 *  Fixed Windows build.
 *  Revision 1.20.1.33.1.194  2018/02/28 16:54:25Z  martin
 *  Doxygen fixes.
 *  Revision 1.20.1.33.1.193  2018/02/27 06:53:55  gregoire.diehl
 *  Add mbgextio_dev_has_clk_res_info and mbgextio_get_clk_res_info calls
 *  Revision 1.20.1.33.1.192  2018/02/15 08:07:32Z  thomas-b
 *  Exchanged gethostbyname call by getaddrinfo to make socket_init thread safe
 *  Revision 1.20.1.33.1.191  2018/02/14 09:11:44  thomas-b
 *  Use XBP_ADDR in mbgextio_xmt_secu_settings
 *  Revision 1.20.1.33.1.190  2018/02/07 10:56:42  thomas-b
 *  fixed deadlock, mutex is acquired in mbgextio_xmt_cmd_u32, already
 *  Revision 1.20.1.33.1.189  2018/02/06 12:39:09  philipp
 *  Added service feature and API
 *  Revision 1.20.1.33.1.188  2018/01/31 16:03:40  daniel
 *  Account for getting SMPTE TLV data from PTP slave module
 *  Revision 1.20.1.33.1.187  2018/01/30 06:38:35  thomas-b
 *  SSH timeout should be long instead of int
 *  Revision 1.20.1.33.1.186  2018/01/26 12:16:53  martin
 *  Moved mbgextio_setup_xdevfeat() out of a conditional code block.
 *  Revision 1.20.1.33.1.185  2018/01/26 09:49:19Z  thomas-b
 *  Renamed setup_extended_device_info to mbgextio_setup_xdevfeat,
 *  added parameter XBP_ADDR and made it non-static.
 *  Revision 1.20.1.33.1.184  2018/01/15 12:47:16  thomas-b
 *  Added permission check to mbgextio_get_corr_info
 *  Revision 1.20.1.33.1.183  2018/01/11 08:16:38  thomas-b
 *  Added permission checks to most read/write functions
 *  Revision 1.20.1.33.1.182  2017/12/21 07:46:33  thomas-b
 *  Added function to check if TLV exec cmd is supported by a device
 *  Revision 1.20.1.33.1.181  2017/12/20 13:40:35  thomas-b
 *  Added function to check if TLV file request is supported by a device
 *  Revision 1.20.1.33.1.180  2017/12/14 14:11:11  martin
 *  Fixed _mbg_mutex_init() call.
 *  Revision 1.20.1.33.1.179  2017/11/23 10:33:00Z  thomas-b
 *  Removed USB_LOCK feature and appropriate structs and functions
 *  Revision 1.20.1.33.1.178  2017/11/21 06:22:38  thomas-b
 *  Added function to check support of TLV rollback command
 *  Revision 1.20.1.33.1.177  2017/11/16 11:12:20  thomas-b
 *  Implemented SSH encryption and user authentication in binary protocol
 *  Added functions for user management
 *  Removed several checks for _PRELIMINARY_CODE, because appropriate code is productive, anyway
 *  Revision 1.20.1.33.1.176  2017/09/19 14:11:37  thomas-b
 *  Request ACK for unregister push command
 *  Revision 1.20.1.33.1.175  2017/09/19 12:47:12  thomas-b
 *  Request ACK for register push command
 *  Revision 1.20.1.33.1.174  2017/08/15 15:27:06  gregoire.diehl
 *  mbgextio_dev_supp_xhe moved to xtiopriv
 *  Revision 1.20.1.33.1.173  2017/08/15 13:45:10Z  gregoire.diehl
 *  Added support for XHE structures
 *  Revision 1.20.1.33.1.172  2017/08/02 10:09:20Z  philipp
 *  Added MBG_MSG_CTL server site related functionality
 *  Revision 1.20.1.33.1.171  2017/08/02 06:55:40  philipp
 *  Added new push messages xfeature
 *  Revision 1.20.1.33.1.170  2017/07/20 06:21:41  philipp
 *  Added tainted config swaP macro
 *  Revision 1.20.1.33.1.169  2017/07/20 06:17:18  philipp
 *  - Refactored monitoring events
 *  - Added xfeature tainted config
 *  - Removed obsolete code
 *  - Added mbglib xmt helper function
 *  Revision 1.20.1.33.1.168  2017/06/19 16:01:14  martin
 *  New functions mbg_chk_dev_is_irig_rx(), mbg_chk_dev_is_irig_rx(),
 *  and mbg_chk_dev_is_irig_rx().
 *  Revision 1.20.1.33.1.167  2017/06/07 12:54:16  thomas-b
 *  Added function to check TLV feature for UFU files
 *  Revision 1.20.1.33.1.166  2017/05/22 12:41:53  thomas-b
 *  Added function to read NTP_REFCLK_STATE_IDX from a device
 *  Revision 1.20.1.33.1.165  2017/05/18 09:29:50  martin
 *  Account for MBG_IO_PORT_SETTINGS::type renamed to port_type.
 *  Doxygen fixes.
 *  Revision 1.20.1.33.1.164  2017/05/17 15:41:06  martin
 *  Doxygen fixes.
 *  Revision 1.20.1.33.1.163  2017/04/25 16:05:34  martin
 *  Fixed build under FreeBSD.
 *  Fixed compiler warning from clang.
 *  Revision 1.20.1.33.1.162  2017/04/20 04:59:57  thomas-b
 *  Use correct swab macros in USB lock functions
 *  Revision 1.20.1.33.1.161  2017/04/20 04:57:27  thomas-b
 *  Added functions to get and set USB lock (LCES) and get USB lock status
 *  Revision 1.20.1.33.1.160  2017/04/12 08:34:53  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.159  2017/04/12 07:34:20  martin
 *  Fixed build with VC6.
 *  Revision 1.20.1.33.1.158  2017/04/11 14:28:26Z  martin
 *  Revision 1.20.1.33.1.157  2017/04/11 14:12:49Z  martin
 *  Fixed DOS build.
 *  Revision 1.20.1.33.1.156  2017/04/11 13:19:41Z  martin
 *  Made mbgextio_setup_receiver_info() more fault tolerant.
 *  Use function call to retrieve RECEIVER_INFO address
 *  from message control block.
 *  Revision 1.20.1.33.1.155  2017/04/10 13:41:55Z  martin
 *  Fixed some compiler warnings.
 *  Revision 1.20.1.33.1.154  2017/04/10 07:49:07Z  martin
 *  Fixed a compiler warning.
 *  Revision 1.20.1.33.1.153  2017/04/05 16:06:38  martin
 *  Added mbgextio_dev_has_bvar_stat().
 *  Revision 1.20.1.33.1.152  2017/03/27 10:38:40  thomas-b
 *  Added functions to read and write PTPv1 common datasets
 *  Revision 1.20.1.33.1.151  2017/03/20 17:11:07  martin
 *  Replaced dummy swab...() macro calls by real macros.
 *  Revision 1.20.1.33.1.150  2017/03/20 10:10:03  martin
 *  Fixed build without _PRELIMINARY_CODE.
 *  Revision 1.20.1.33.1.149  2017/03/07 13:45:55  thomas-b
 *  Added functions to get and set ignore lock
 *  Revision 1.20.1.33.1.148  2017/03/03 06:46:04  thomas-b
 *  Added functions to read/write NTP key, server, refclock and orphan mode settings
 *  Revision 1.20.1.33.1.147  2017/02/23 14:32:08  thomas-b
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.146  2017/02/22 08:31:13  thomas-b
 *  Added functions to read/write event info and read monitoring status and event status
 *  Revision 1.20.1.33.1.145  2017/02/16 13:01:52  thomas-b
 *  Changed get and set functions for PTPv2 port dataset to use idx structure
 *  Revision 1.20.1.33.1.144  2017/02/16 09:27:59  thomas-b
 *  Fixed doxygen docu
 *  Revision 1.20.1.33.1.143  2017/02/16 09:24:32  thomas-b
 *  Added functions to get and set PTPv2 common datasets
 *  Revision 1.20.1.33.1.142  2017/02/15 16:17:37  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.141  2017/02/08 13:12:36  thomas-b
 *  Added functions to get and set SNMP configuration
 *  Revision 1.20.1.33.1.140  2017/02/07 14:24:52  thomas-b
 *  Added function mbgextio_dev_has_monitoring, which checks if the extended feature MBG_XFEATURE_MONITORING is set
 *  Revision 1.20.1.33.1.139  2017/02/07 14:10:19  daniel
 *  Added calls to check for new License TLV feature types
 *  Revision 1.20.1.33.1.138  2016/12/07 09:33:58  martin
 *  Renamed mbgextio_get_utc_param() to mbgextio_get_utc_parm()
 *  and mbgextio_set_utc_param() to mbgextio_set_utc_parm()
 *  for consisten naming with related functions.
 *  Check if index of received data set matches requested index, and
 *  keep receiving if not. Only in mbgextio_get_xmr_status_idx() for now.
 *  Revision 1.20.1.33.1.137  2016/12/01 10:17:27  thomas-b
 *  Temporarily removed ACK request from GPS_SCU_STAT set command
 *  Revision 1.20.1.33.1.136  2016/11/30 16:12:54  thomas-b
 *  Added functions to get/set SCU_STAT_INFO/SCU_STAT_SETTINGS
 *  Revision 1.20.1.33.1.135  2016/11/24 07:06:34  philipp
 *  Honour big endian system when swapping bytes
 *  Revision 1.20.1.33.1.134  2016/11/22 10:33:15  philipp
 *  Implemented I/O ports
 *  Revision 1.20.1.33.1.133  2016/11/22 10:28:04  gregoire.diehl
 *  chk index added in mbgextio_get_xmr_status_idx
 *  Revision 1.20.1.33.1.132  2016/11/15 15:44:12Z  martin
 *  Account for modified mbgserio functions.
 *  Revision 1.20.1.33.1.131  2016/11/02 12:15:17  thomas-b
 *  Added function to check if a device has MBG_XFEATURE_REQ_TTM and adapted the documentation for mbgextio_get_time
 *  Revision 1.20.1.33.1.130  2016/11/01 07:39:02  thomas-b
 *  Fixed reception of XBP packets, copy std_msg_data from xbp_msg_data
 *  Revision 1.20.1.33.1.129  2016/10/31 09:28:06  martin
 *  Doxygen fixes.
 *  Revision 1.20.1.33.1.128  2016/10/25 09:11:17  thomas-b
 *  Added functions to get CFGH, ALM and IONO structures from a device
 *  Revision 1.20.1.33.1.127  2016/10/24 13:59:42  thomas-b
 *  Removed needless space from comment
 *  Fixed mbgextio_rcv_msg_unlocked for reception of XBP packets
 *  Revision 1.20.1.33.1.126  2016/10/20 14:46:03  thomas-b
 *  Added function to check if XBP is supported
 *  Revision 1.20.1.33.1.125  2016/10/20 11:29:10  martin
 *  Added missing const qualifier in mbgextio_get_utc_param().
 *  Revision 1.20.1.33.1.124  2016/10/20 10:43:34  thomas-b
 *  Added function to check if a device is a bus level device
 *  Revision 1.20.1.33.1.123  2016/10/19 14:33:43  thomas-b
 *  Added functions to read and write ucap via network configuration
 *  Revision 1.20.1.33.1.122  2016/10/14 11:09:40  thomas-b
 *  Added function to check MBG_XFEATURE_UCAP_NET
 *  Revision 1.20.1.33.1.121  2016/10/14 08:18:54  thomas-b
 *  Decreased poll timeout
 *  Revision 1.20.1.33.1.120  2016/10/12 08:13:27  thomas-b
 *  Fixed check_init_winsock to return MBG_SUCCESS if WSAStartup returns 0
 *  Revision 1.20.1.33.1.119  2016/09/30 05:36:53  thomas-b
 *  Increased serial poll timeout
 *  Revision 1.20.1.33.1.118  2016/09/29 14:35:12  thomas-b
 *  Moved new get and set functions for NET_CFG_API stage 2 to mbgextio
 *  Revision 1.20.1.33.1.117  2016/09/29 12:19:57  thomas-b
 *  Added function to check transactions feature
 *  Revision 1.20.1.33.1.116  2016/09/20 14:18:27  martin
 *  Fixed a compiler warning.
 *  Revision 1.20.1.33.1.115  2016/09/20 13:52:38  martin
 *  Moved GPS_REQACK preprocessor handling to the header file.
 *  Revision 1.20.1.33.1.114  2016/09/16 08:00:20  thomas-b
 *  Always try to use high speed baud in mbgextio_open_serial_force_default
 *  Revision 1.20.1.33.1.113  2016/09/15 10:15:12  philipp
 *  Fixed compiler warning (uninitialized variable may be used)
 *  Revision 1.20.1.33.1.112  2016/09/12 15:26:24  martin
 *  Conditionally try to retrieve serial number from very old devices.
 *  Revision 1.20.1.33.1.111  2016/09/12 13:42:35Z  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.110  2016/08/23 15:56:59  martin
 *  Set up default receiver info for very old devices
 *  which don't provide it.
 *  Revision 1.20.1.33.1.109  2016/08/23 11:02:59Z  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.108  2016/08/23 09:25:17  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.107  2016/08/23 08:33:25  udo
 *  renamed some Time Mon functions
 *  Revision 1.20.1.33.1.106  2016/08/22 14:14:47  gregoire.diehl
 *  new call: mbgextio_get_corr_info
 *  Revision 1.20.1.33.1.105  2016/08/15 09:36:23Z  udo
 *  added mbgextio_time_mon_get_target_ext_data_set_idx()
 *  Revision 1.20.1.33.1.104  2016/08/11 10:25:53  martin
 *  Started to support time_mon.
 *  Revision 1.20.1.33.1.103  2016/08/09 16:00:36  martin
 *  Removed obsolete string variable.
 *  Revision 1.20.1.33.1.102  2016/08/09 07:12:26  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.101  2016/08/01 10:32:53  daniel
 *  Add functions to get ptp statistics
 *  Revision 1.20.1.33.1.100  2016/07/07 15:04:11  martin
 *  Renamed functions due to renamed library symbols.
 *  Revision 1.20.1.33.1.99  2016/06/29 11:59:11  philipp
 *  Extended socket API by TCP client
 *  Revision 1.20.1.33.1.98  2016/06/15 10:15:49  thomas-b
 *  Added functions which check if the user capture feature is supported by a device
 *  Revision 1.20.1.33.1.97  2016/06/14 10:33:21  thomas-b
 *  Added functions which check if the event log feature is supported by a device
 *  Revision 1.20.1.33.1.96  2016/06/08 09:55:12  thomas-b
 *  Added function mbgextio_open_serial_force_default
 *  Revision 1.20.1.33.1.95  2016/06/07 14:50:33  udo
 *  Reset Meinberg USB device in case if the open_usb function return MBG_ERR_BUSY
 *  Revision 1.20.1.33.1.94  2016/06/07 07:43:06  philipp
 *  New function to check for Irig Rx feature
 *  Revision 1.20.1.33.1.93  2016/06/03 11:15:49  thomas-b
 *  Fixed Windows compatibility issues in get_sock_error and mbgextio_find_lan_devices
 *  Revision 1.20.1.33.1.92  2016/06/02 10:15:38  philipp
 *  Renaming all MBG_EXT_REV_INFO related stuff to MBG_EXT_SYS_INFO.
 *  Revision 1.20.1.33.1.91  2016/05/30 08:10:44  thomas-b
 *  Added functions to check several builtin features
 *  Revision 1.20.1.33.1.90  2016/05/27 05:18:17  philipp
 *  New functions mbgextio_get_xmr_ext_source_stats_idx and mbgextio_get_xmr_ext_source_metrics_idx
 *  Revision 1.20.1.33.1.89  2016/05/25 09:22:58  philipp
 *  New function mbgextio_get_xmr_ext_source_stats_idx
 *  Revision 1.20.1.33.1.88  2016/05/20 13:37:53  philipp
 *  New function mbgextio_set_gpio_settings_idx
 *  Revision 1.20.1.33.1.87  2016/05/20 09:41:33  thomas-b
 *  Removed functions which check for a specific IMS card
 *  Revision 1.20.1.33.1.86  2016/05/20 08:51:19  thomas-b
 *  Added functions mbgextio_dev_has_time_scale and mbgextio_dev_has_tzcode
 *  Revision 1.20.1.33.1.85  2016/05/20 07:51:32  thomas-b
 *  Added function mbgextio_dev_has_tzdl
 *  Revision 1.20.1.33.1.84  2016/05/20 06:42:06  thomas-b
 *  Added function mbgextio_dev_has_enable_flags
 *  Revision 1.20.1.33.1.83  2016/05/18 13:15:40  philipp
 *  Fixed wrong GPS command in mbgextio_cmd_save_cfg
 *  Revision 1.20.1.33.1.82  2016/05/17 13:29:35  philipp
 *  New function to check whether device is LNO
 *  Revision 1.20.1.33.1.81  2016/05/17 06:33:07  philipp
 *  New function to check whether a device has serial outputs
 *  Revision 1.20.1.33.1.80  2016/05/12 10:41:35  philipp
 *  New functions to check bpe card and IRIG Tx feature
 *  Revision 1.20.1.33.1.79  2016/05/10 06:15:26  philipp
 *  New function to check whether a device has programmable pulses
 *  Revision 1.20.1.33.1.78  2016/05/04 13:04:55  thomas-b
 *  Fixed double mutex acquisition in dns set functions (NULL pointer)
 *  Revision 1.20.1.33.1.77  2016/04/26 06:55:45  thomas-b
 *  Added functions to check if NET_CFG and LAN_IP4 APIs are supported
 *  Revision 1.20.1.33.1.76  2016/04/25 14:47:13  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.75  2016/04/22 10:53:58  philipp
 *  New function to check whether device is LIU
 *  Revision 1.20.1.33.1.74  2016/04/20 13:20:25  thomas-b
 *  Added function to check if a device supports NTP
 *  Revision 1.20.1.33.1.73  2016/04/20 09:26:11  philipp
 *  Moved all HPS-PTP related structures to gpspriv.h and removed related extended feature bit from gpsdefs.h.
 *  Also removed functions from mbgextio and xdevfeat since HPS-PTP handling needs a redesign concerning structures.
 *  Thus, handle everything explicitly for now!
 *  -> Redesing this A.S.A.P.!!!
 *  Revision 1.20.1.33.1.72  2016/04/15 08:17:25  philipp
 *  New feature MBG_XFEATURE_EXT_PTP
 *  Revision 1.20.1.33.1.71  2016/04/13 07:01:20  philipp
 *  New function to check whether device is HPS
 *  Revision 1.20.1.33.1.70  2016/04/12 13:27:40  philipp
 *  Several new functions to check for device models and device features
 *  Revision 1.20.1.33.1.69  2016/04/11 13:56:47  thomas-b
 *  Added function mbgextio_dev_has_xmulti_ref
 *  Revision 1.20.1.33.1.68  2016/04/07 14:08:33  philipp
 *  Added function mbgextio_get_ext_rev_info
 *  Revision 1.20.1.33.1.67  2016/04/07 12:45:43  martin
 *  New function mbgextio_dev_has_ext_rev_info().
 *  Revision 1.20.1.33.1.66  2016/03/24 14:08:50  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.65  2016/03/23 13:49:44  thomas-b
 *  Added case for overflow error after check_transfer
 *  Revision 1.20.1.33.1.64  2016/03/23 10:12:52  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.63  2016/03/23 09:48:51  thomas-b
 *  Stop mbgextio_rcv_msg_unlocked after poll_timeout expires
 *  Several changes in mbgextio_find_lan_devices
 *  Revision 1.20.1.33.1.62  2016/03/22 14:52:37  thomas-b
 *  Shutdown socket before close in mbgextio_find_lan_devices
 *  Revision 1.20.1.33.1.61  2016/03/22 14:24:26  thomas-b
 *  Several fixes in mbgextio_find_lan_devices
 *  Revision 1.20.1.33.1.60  2016/03/22 12:53:30  thomas-b
 *  Added functions to find and free Meinberg LAN devices
 *  Revision 1.20.1.33.1.59  2016/03/22 08:39:42  thomas-b
 *  Removed debug output
 *  Revision 1.20.1.33.1.58  2016/03/22 08:16:16  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.57  2016/03/21 13:27:33  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.56  2016/03/18 11:21:55  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.55  2016/03/18 10:48:32  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.54  2016/03/17 11:33:10  philipp
 *  Added XMR functions
 *  Revision 1.20.1.33.1.53  2016/03/16 15:08:50  martin
 *  Moved some low level functions to new module xtiocomm.c.
 *  Revision 1.20.1.33.1.52  2016/03/14 11:53:15  martin
 *  Moved some low level feature check functions to new
 *  module xdevfeat.c, and use those functions.
 *  Removed function mbgextio_get_xfeature_buffer().
 *  Revision 1.20.1.33.1.51  2016/03/11 11:48:18  thomas-b
 *  Check MBG_SUCCESS with macro mbg_rc_is_success
 *  Revision 1.20.1.33.1.50  2016/03/11 10:29:03  thomas-b
 *  Decreased default serial message timeout
 *  Read more than one byte in each call to serial read
 *  Increase timeout if header has been completely received
 *  Revision 1.20.1.33.1.49  2016/03/11 08:20:13  marvin
 *  Added function to save PTP unicast master settings.
 *  Revision 1.20.1.33.1.48  2016/03/02 16:31:40Z  marvin
 *  Do not close socket if opened successfully.
 *  Revision 1.20.1.33.1.47  2016/02/25 12:02:54Z  udo
 *  used mbgextio_req_data_idx instead of mbgextio_req_data for TIME_MON_TARGET_STATUS_IDX
 *  Revision 1.20.1.33.1.46  2016/02/17 15:03:16  udo
 *  used MBG_TIME_MON_TARGET_STATUS_IDX
 *  Revision 1.20.1.33.1.45  2016/02/15 08:28:29  gregoire
 *  typo fixed
 *  Revision 1.20.1.33.1.44  2016/02/15 08:23:51Z  gregoire
 *  mbgextio_get_xfeature_buffer_addr added
 *  Revision 1.20.1.33.1.43  2016/02/11 10:18:47Z  thomas-b
 *  Added function mbgextio_set_fdm_tdev
 *  Revision 1.20.1.33.1.42  2016/02/03 09:16:48  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.41  2016/02/02 15:58:42  martin
 *  Added mbgextio_get_raw_irig_data().
 *  Revision 1.20.1.33.1.40  2016/01/19 14:13:53  udo
 *  improve time monitor functions
 *  Revision 1.20.1.33.1.39  2016/01/18 08:53:34  udo
 *  added support for PTP Time Monitoring on TSU/HPS100
 *  Revision 1.20.1.33.1.38  2016/01/04 15:55:07  martin
 *  New function mbgextio_open_usb_ldev which takes a libusb_device as parameter.
 *  Revision 1.20.1.33.1.37  2015/12/10 16:30:16  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.36  2015/12/10 11:55:14  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.35  2015/12/10 11:10:39  martin
 *  Don't try to read RECEIVER_INFO etc. from legacy USB devices.
 *  Revision 1.20.1.33.1.34  2015/12/09 17:35:01  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.33  2015/12/09 10:45:34  martin
 *  Revision 1.20.1.33.1.32  2015/12/09 10:21:22Z  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.31  2015/12/07 16:34:54  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.30  2015/12/03 16:00:20  martin
 *  Also mbgextio_xmt_cmd() and mbgextio_xmt_cmd() now wait for ACK or NACK
 *  if the transmitted command code has been or'ed with GPS_REQACK.
 *  Doxygen stuff.
 *  Revision 1.20.1.33.1.29  2015/12/01 11:54:49  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.28  2015/12/01 11:36:01  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.27  2015/11/30 17:00:49  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.26  2015/11/30 08:16:14  philipp
 *  Added (wrapper) functions to test for TLV features
 *  Revision 1.20.1.33.1.25  2015/11/26 16:19:26  martin
 *  Reworked check feature API causing some other API calls to be
 *  simplified/changed since receiver info is now stored inside
 *  the message control block.
 *  Revision 1.20.1.33.1.24  2015/11/26 09:57:10  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.23  2015/11/23 12:55:25  philipp
 *  Removed TLV functions
 *  Revision 1.20.1.33.1.21  2015/11/20 10:47:12  daniel
 *  Removed debug messages
 *  Revision 1.20.1.33.1.20  2015/11/20 08:14:36  philipp
 *  Added id member to struct MBG_TLV_ANNOUNCE
 *  Revision 1.20.1.33.1.19  2015/11/20 07:31:19  philipp
 *  Added _mbg_swab_tlv macro in function mbgextio_send_tlv_chunk
 *  Revision 1.20.1.33.1.18  2015/11/20 07:27:37  philipp
 *  Adjusted functions and prototypes to match new TLV structures from gpsdefs.h
 *  Revision 1.20.1.33.1.17  2015/11/19 16:31:14  daniel
 *  Added debug messages
 *  Revision 1.20.1.33.1.16  2015/11/19 13:15:39  philipp
 *  Added TLV functionality
 *  Revision 1.20.1.33.1.15  2015/11/02 10:12:27  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.14  2015/10/19 16:42:20  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.13  2015/10/19 09:35:10  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.12  2015/10/19 09:16:44  martin
 *  Fixed some spelling.
 *  Revision 1.20.1.33.1.11  2015/10/15 14:00:57  martin
 *  Doxygen comments.
 *  Revision 1.20.1.33.1.10  2015/10/09 11:09:16  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.9  2015/10/06 14:19:06  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.8  2015/10/02 08:57:44  thomas-b
 *  Added several functions to retrieve and set parameter structures of the new FDM API
 *  Revision 1.20.1.33.1.7  2015/10/02 08:18:52  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.6  2015/10/01 09:15:56  philipp
 *  _USE_USB_DIRECT_IO: Return MBG_ERR_TIMEOUT and MBG_ERR_DISCONN if poll times out or holds POLLHUP event after reading data returns
 *  Revision 1.20.1.33.1.5  2015/09/15 13:25:55  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.4  2015/09/14 07:23:32  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.3  2015/09/11 12:06:16  martin
 *  *** empty log message ***
 *  Revision 1.20.1.33.1.2  2015/09/10 14:45:16  martin
 *  Unified timeout handling.
 *  If a NACK is received then accept and return an optional
 *  error code which may have been appended by the device.
 *  Revision 1.20.1.33.1.1  2015/09/09 16:00:08  martin
 *  Debug timing.
 *  Revision 1.20.1.33  2015/09/09 15:26:13  martin
 *  Revision 1.20.1.32  2015/09/09 08:41:01  martin
 *  Revision 1.20.1.31  2015/09/09 08:26:27  martin
 *  Revision 1.20.1.30  2015/09/09 06:57:51  daniel
 *  Revision 1.20.1.29  2015/09/08 15:25:48  martin
 *  Copy received data to destination buffer before
 *  device mutex is release.
 *  Revision 1.20.1.28  2015/09/08 14:22:32  martin
 *  Added some some missing mutex code.
 *  Use new inline functions mbg_rc_is_error() and mbg_rc_is_success().
 *  Revision 1.20.1.27  2015/09/08 12:15:02  martin
 *  Changed xmt_mutex to dev_mutex.
 *  Revision 1.20.1.26  2015/09/08 08:38:22  daniel
 *  Use mutex in mbgextio_req_data()
 *  Revision 1.20.1.25  2015/09/04 09:20:17  daniel
 *  Added fuctions to exchange refclock state and tsu version with TSU
 *  Revision 1.20.1.24  2015/09/02 16:42:20  martin
 *  Preliminary code which is only included if a preprocessor symbol
 *  _PRELIMINARY_CODE is defined in the project Makefile.
 *  Revision 1.20.1.23  2015/08/27 16:21:30  martin
 *  Revision 1.20.1.22  2015/08/25 15:33:56  martin
 *  Use safe string copy function from str_util.c.
 *  Revision 1.20.1.21  2015/08/20 14:50:05  martin
 *  Revision 1.20.1.20  2015/08/12 15:53:57  martin
 *  Revision 1.20.1.19  2015/07/22 16:02:07  martin
 *  Started to support variable USB endpoint numbers.
 *  Revision 1.20.1.18  2015/07/14 15:08:43  martin
 *  Unified parameter naming and updated doxygen comments.
 *  Revision 1.20.1.17  2015/07/14 14:05:55  martin
 *  Support XBP addressing.
 *  Added functions to read/send UTC parameters.
 *  Support for USB_DIRECT_IO
 *  Fixed dealloc_msg_ctl() where not all memory was freed.
 *  Reworked mbgextio_force_conn_serial_ftdi().
 *  Revision 1.20.1.16  2014/10/30 16:03:05  martin
 *  Doxygen fixes.
 *  Revision 1.20.1.15  2014/10/30 14:45:55  martin
 *  Generally return Meinberg error codes only.
 *  Do not use GPS_REQACK for secu_settings.
 *  Added FTDI support functions.
 *  Reworked "force connection" functions, also supporting high speed now.
 *  Updated libusb support.
 *  Many new API functions.
 *  Revision 1.20.1.14  2013/11/28 15:51:45Z  marvin
 *  Added mbgextio_get_ntp_peer_state_idx.
 *  Revision 1.20.1.13  2013/11/26 16:06:43Z  marvin
 *  Added mbgextio_get_ntp_sys_state.
 *  Revision 1.20.1.12  2013/11/21 07:46:44Z  marvin
 *  Added mbgextio_xmt_secu_settings.
 *  Cleanup for socket port.
 *  Revision 1.20.1.11  2013/11/15 12:17:30Z  marvin
 *  Added error return for TGT_LINUX if socket_opt_error detected.
 *  Revision 1.20.1.10  2013/11/15 11:49:12Z  marvin
 *  Fixed: return 0 if non_blocking_socket is OK.
 *  check if received GPS_NACK for encryption mode (socket connection).
 *  Revision 1.20.1.9  2013/11/13 16:30:10Z  martin
 *  Revision 1.20.1.8  2013/11/13 16:13:26  martin
 *  Revision 1.20.1.7  2013/11/13 16:05:52  marvin
 *  Revision 1.20.1.6  2013/11/13 15:14:17Z  martin
 *  Cleaned up socket connection code.
 *  Revision 1.20.1.5  2013/11/12 12:12:02  marvin
 *  Changed calls for NTP info and settings.
 *  Revision 1.20.1.4  2013/11/11 11:30:27Z  marvin
 *  Changed socket connection.
 *  Revision 1.20.1.3  2013/11/05 15:53:11Z  marvin
 *  Changed connecting via socket.
 *  Revision 1.20.1.2  2013/10/14 08:54:19Z  marvin
 *  Added mbgextio_set_ntp_clnt_mode_cfg.
 *  Revision 1.20.1.1  2013/09/25 11:09:53Z  marvin
 *  Added NTP support and new support for PTP.
 *  Revision 1.20  2013/09/10 08:56:35Z  marvin
 *  Changed Doxygen comments.
 *  Revision 1.19  2013/09/05 15:10:39Z  marvin
 *  Added support for LAN interface setup
 *  Added support for PTP state
 *  Added support for XMR.
 *  Revision 1.18  2013/09/02 15:16:48Z  marvin
 *  Added support for XMR (get multi ref info, set multi ref settings)
 *  Revision 1.17  2013/08/28 11:01:41Z  marvin
 *  Added read and set tr_distance and gnss_mode.
 *  Revision 1.16.1.1  2013/06/05 09:17:54Z  marvin
 *  Changed close_connection for socket.
 *  Revision 1.16  2013/04/11 14:18:33Z  Gregoire
 *  new calls for sending havequick rx and tx settings to clock
 *  Revision 1.15  2013/02/14 14:42:13Z  martin
 *  Fixed syntax err due to unintentionally pasted word.
 *  Revision 1.14  2013/02/06 15:43:54  martin
 *  Updated doxygen comments.
 *  Revision 1.13  2013/02/01 15:58:43  martin
 *  In mbgextio_force_connection() for Windows wait until all chars
 *  must have been sent since flushing output buffer doesn't work reliably.
 *  Added a number of new functions.
 *  Added doxygen comments.
 *  Revision 1.12  2012/10/30 16:17:30  martin
 *  Started to migrate to opaque stuctures.
 *  Conditionally let xmt routines request for ACK packet,
 *  though this is by default disabled.
 *  Support receiving NACK status.
 *  Support big endian target platforms.
 *  Merged and adapted Daniel's USB support functions.
 *  Support event log entries.
 *  Syntax workaround which is required until this module becomes a DLL.
 *  Added some new functions.
 *  Updated doxygen comments.
 *  Huge cleanup.
 *  Revision 1.11  2011/04/15 13:17:14  martin
 *  Use common mutex support macros from mbgmutex.h.
 *  Revision 1.10  2011/04/08 11:28:24  martin
 *  Modified mbgextio_get_ucap() to account for different device behaviour.
 *  Added missing braces.
 *  Revision 1.9  2009/10/02 14:19:05  martin
 *  Added a bunch of missing functions.
 *  Revision 1.8  2009/10/01 11:10:51  martin
 *  Added functions to set/retrieve char and msg rcv timeout.
 *  Revision 1.7  2009/09/01 10:44:58  martin
 *  Cleanup for CVI.
 *  Use new portable timeout functions from mbg_tmo.h.
 *  Timeouts are now specified in milliseconds.
 *  Distinguish between character timeout and message timeout.
 *  Only fetch one character at a time to prevent received characters
 *  from being discarded after the end of one message.
 *  Revision 1.6  2009/03/10 17:02:08Z  martin
 *  Added support for configurable time scales.
 *  Added mbgextio_get_time() call.
 *  Fixed some compiler warnings.
 *  Revision 1.5  2008/09/04 14:35:50Z  martin
 *  Fixed opening COM port under CVI.
 *  Moved generic serial I/O stuff to mbgserio.c and mbgserio.h.
 *  Restart reception if received msg does not match expected cmd code.
 *  Fixed timeout value for Windows.
 *  New symbol _MBGEXTIO_DIRECT_RC controls whether the return code of the
 *  mbgextio_set_...() functions is evaluated or returned as-is.
 *  New functions mbgextio_set_time(), mbgextio_set_tzdl().
 *  Added mbgextio_get_ucap(). This may not work with older firmware,
 *  see the comments in mbgextio_get_ucap().
 *  Conditionally support checking of time strings.
 *  Revision 1.4  2007/02/27 10:35:19Z  martin
 *  Added mutex for transmit buffer to make transmission thread-safe.
 *  Fixed timeout handling for serial reception.
 *  Renamed mbgextio_get_data() to mbgextio_rcv_msg().
 *  Added some new functions.
 *  Temp. changes for parameter setting functions.
 *  Added comments on POSIX flags used when opening serial port.
 *  Revision 1.3  2006/12/21 10:56:17  martin
 *  Added function mbgextio_set_port_parm.
 *  Revision 1.2  2006/10/25 12:18:31  martin
 *  Support serial I/O under Windows.
 *  Revision 1.1  2006/08/24 12:40:37Z  martin
 *  Initial revision.
 *
 **************************************************************************/

#define _MBGEXTIO
  #include <mbgextio.h>
#undef _MBGEXTIO

#include <xtiocomm.h>
#include <xdevfeat.h>
#include <mbgserio.h>
#include <cfg_hlp.h>
#include <mbg_arch.h>
#include <mbgerror.h>
#include <gpsutils.h>
#include <str_util.h>

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


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

#if _TRY_IDENT_DECODE
  #include <identdec.h>
#endif

#if _USE_SOCKET_IO
  #if defined( MBG_TGT_POSIX )
    #include <ifaddrs.h>
    #include <sys/socket.h>
    #include <netdb.h>     // ### TODO gethostbyname / struct hostent
    #include <arpa/inet.h>
  #elif defined( MBG_TGT_WIN32 )
    #if defined( _MSC_VER ) && ( _MSC_VER <= 1200 )  // at least up to VC6
      #define VS_MISSING_IPHLPAPI
    #endif

    #if !defined( VS_MISSING_IPHLPAPI )
      #include <IPHlpApi.h>
    #endif
  #endif
#endif

#if defined( MBG_TGT_POSIX )
  #include <fcntl.h>
  #include <errno.h>
#endif

#if defined( MBG_TGT_DOS )
  #include <dos.h>
#endif

#if _USE_USB_IO
  #include <mbgusbio.h>
#endif

#if _USE_USB_DIRECT_IO
  #include <poll.h>
#endif

#if defined( DEBUG )
  #define DEBUG_SOCK_IO     1
  #define DEBUG_FORCE_CONN  1
  #define DEBUG_INIT_CONN   1
#else
  #define DEBUG_SOCK_IO     0
  #define DEBUG_FORCE_CONN  0
  #define DEBUG_INIT_CONN   0
#endif

#if defined( MBG_TGT_WIN32 ) && _USE_SOCKET_IO
  #define _USE_WIN32_CONSOLE_CONTROL_HANDLER   1
#else
  #define _USE_WIN32_CONSOLE_CONTROL_HANDLER   0
#endif

// default serial message timeout
#if !defined( MBGEXTIO_MSG_TIMEOUT_SERIAL )
  #define MBGEXTIO_MSG_TIMEOUT_SERIAL          2000  // [ms]
#endif

// default serial single character timeout
#if !defined( MBGEXTIO_POLL_TIMEOUT_SERIAL )
  #define MBGEXTIO_POLL_TIMEOUT_SERIAL         200  // [ms]
#endif


// default USB message timeout
#if !defined( MBGEXTIO_MSG_TIMEOUT_USB )
  #define MBGEXTIO_MSG_TIMEOUT_USB             100  // [ms]
#endif

// default USB character timeout, same as message timeout
#if !defined( MBGEXTIO_POLL_TIMEOUT_USB )
  #define MBGEXTIO_POLL_TIMEOUT_USB            MBGEXTIO_MSG_TIMEOUT_USB
#endif



static const char force_conn_cmd_str[] = MBG_FORCE_CONN_CMD_STR;
static const char force_conn_hs_cmd_str[] = MBG_FORCE_CONN_HS_CMD_STR;



enum MSG_CTL_DEVICE_FLAGS
{
  MSG_CTL_DEVICE_FLAG_LEGACY,   
  N_MSG_CTL_DEVICE_FLAGS
};



enum MSG_CTL_DEVICE_FLAG_MSKS
{
  MSG_CTL_DEVICE_FLAG_MSK_LEGACY = ( 1UL << MSG_CTL_DEVICE_FLAG_LEGACY )  
};



//### TODO proper header / prototype
/*HDR*/
const char *mbgextio_get_cmd_name( GPS_CMD cmd_code )
{
  return xtiocomm_get_cmd_name( cmd_code );

}  // mbgextio_get_cmd_name



#if _USE_WIN32_CONSOLE_CONTROL_HANDLER

static /*HDR*/
BOOL WINAPI mbgextio_on_console_event( DWORD dwCtrlType )
{
  switch ( dwCtrlType )
  {
    case CTRL_BREAK_EVENT:
    case CTRL_C_EVENT:
    case CTRL_CLOSE_EVENT:
    case CTRL_SHUTDOWN_EVENT:
      exit( 0 );

  }  // switch

  return FALSE;

}  // mbgextio_on_console_event



static /*HDR*/
void mbgextio_set_console_control_handler( void )
{
  static int has_been_set;

  if ( !has_been_set )
  {
    SetConsoleCtrlHandler( mbgextio_on_console_event, TRUE );
    has_been_set = 1;
  }

}  // mbgextio_set_console_control_handler

#endif  // _USE_WIN32_CONSOLE_CONTROL_HANDLER



#if _USE_USB_IO

static /*HDR*/
int check_setup_legacy_usb_device( const MBG_USB_DEV_INFO *mdev_info, RECEIVER_INFO *p_ri )
{
  int model_code = GPS_MODEL_UNKNOWN;
  const char *model_name = str_unknown;

  if ( mdev_info->ven_id == USB_VENDOR_MEINBERG )
  {
    switch ( mdev_info->prod_id )
    {
      case USB_DEV_CPC_01:
        model_code = GPS_MODEL_CPC_01;
        model_name = GPS_MODEL_NAME_CPC_01;
        break;

      case USB_DEV_CPC180:
        model_code = GPS_MODEL_CPC180;
        model_name = GPS_MODEL_NAME_CPC180;
        break;

      case USB_DEV_TSU_01:
        model_code = GPS_MODEL_TSU_01;
        model_name = GPS_MODEL_NAME_TSU_01;
        break;

      case USB_DEV_CMC:
        model_code = GPS_MODEL_CMC_01;
        model_name = GPS_MODEL_NAME_CMC_01;
        break;

      case USB_DEV_SCU_USB:
        model_code = GPS_MODEL_SCU_01;
        model_name = GPS_MODEL_NAME_SCU_01;
        break;

      case USB_DEV_FCU_01:
        model_code = GPS_MODEL_FCU_01;
        model_name = GPS_MODEL_NAME_FCU_01;
        break;

    #if 0  //    //### TODO check these device, they probably do support binary
      case USB_DEV_SDI_01:
        model_code = GPS_MODEL_UNKNOWN;
        model_name =  str_unknown;
        break;

      case USB_DEV_MDU300:
        model_code = GPS_MODEL_MDU300;
        model_name =  str_unknown;
        break;
    #endif
    }
  }

  #if DEBUG
    fprintf( stderr, "Checking for legacy USB device %04X:%04X: %s, code %i\n",
             mdev_info->ven_id, mdev_info->ven_id, model_name, model_code );
  #endif

  if ( model_code == GPS_MODEL_UNKNOWN )
    return MBG_ERR_DEV_NOT_SUPP;

  if ( p_ri )
  {
    memset( p_ri, 0, sizeof( *p_ri ) );

    p_ri->model_code = model_code;
    sn_cpy_str_safe( p_ri->model_name, sizeof( p_ri->model_name ), model_name );
    p_ri->ticks_per_sec = DEFAULT_GPS_TICKS_PER_SEC;
  }

  return MBG_SUCCESS;

}  // check_setup_legacy_usb_device

#endif  // _USE_USB_IO



/*HDR*/
_NO_MBG_API_ATTR int _NO_MBG_API mbgextio_setup_xdevfeat( MBG_MSG_CTL *pmctl, XBP_ADDR *addr )
{
  MBG_XDEV_FEATURES *p_xdf = &pmctl->xdev_features;
  int rc;

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

  // Get the receiver info first.
  rc = mbgextio_setup_receiver_info( pmctl, addr, &p_xdf->receiver_info );

  if ( mbg_rc_is_error( rc ) )
    goto out;

  // If the device supports extended features then read the
  // extended feature buffer from the device, else clear extended features.
  if ( p_xdf->receiver_info.features & GPS_HAS_XFEATURE )
  {
    rc = mbgextio_req_data( pmctl, addr, GPS_XFEATURES, &p_xdf->xfeature_buffer, sizeof( p_xdf->xfeature_buffer ) );
    //### TODO use special API call?
  }

  // FIXME TODO
  // Shouldn't the same rc check be used after every API call?
  if ( !mbg_rc_is_success_or_err_perm( rc ) )
    goto out;

  rc = MBG_SUCCESS;

  // If the device supports TLVs then read the TLV info and supported TLV
  // features from the device, else clear the structure.
  if ( mbg_rc_is_success( xdevfeat_has_tlv_api( p_xdf ) ) )
  {
    rc = mbgextio_req_data( pmctl, addr, GPS_TLV_INFO, &p_xdf->tlv_info, sizeof( p_xdf->tlv_info ) );
    //### TODO use special API call?
  }

  if ( !mbg_rc_is_success_or_err_perm( rc ) )
    goto out;

  rc = MBG_SUCCESS;

  // If the device supports user authentification, read the logged in user from the device
  if ( mbg_rc_is_success( mbgextio_dev_has_user_auth( pmctl ) ) )
  {
    rc = mbgextio_req_data( pmctl, addr, GPS_AUTH_USER_INFO, &p_xdf->user_info, sizeof( p_xdf->user_info ) );

    if ( mbg_rc_is_success( rc ) )
      rc = mbgextio_req_data( pmctl, addr, GPS_AUTH_USER_STATUS, &p_xdf->user_status, sizeof( p_xdf->user_status ) );
  }

out:
  return rc;

}  // mbgextio_setup_xdevfeat



static /*HDR*/
//### TODO
int dev_open_finish_setup( MBG_MSG_CTL **ppmctl, MBG_MSG_CTL **caller_ppmctl )
{
  int rc;

  #if _USE_WIN32_CONSOLE_CONTROL_HANDLER
    mbgextio_set_console_control_handler();
  #endif

  #if _USE_MUTEX
    _mbg_mutex_init( &(*ppmctl)->dev_mutex, "dev_mutex" );
  #endif

  rc = mbgextio_setup_xdevfeat( *ppmctl, NULL );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_close( rc, ppmctl, caller_ppmctl );

  return dev_open_finish( rc, *ppmctl, caller_ppmctl );

}  // dev_open_finish_setup



#if _USE_SOCKET_IO

static /*HDR*/
int set_socket_blocking_mode( MBG_SOCK_FD sock_fd, int blocking )
{
  int rc = MBG_ERR_UNSPEC;

  if ( sock_fd == MBG_INVALID_SOCK_FD )
  {
    rc = MBG_ERR_INV_SOCK_FD;
    goto out;
  }

  #if defined( MBG_TGT_WIN32 )
  {
    u_long mode = blocking ? 0 : 1;  // ioctlsocket expects an (u_long *)

    rc = ioctlsocket( sock_fd, FIONBIO, &mode );  // returns 0 on success

    if ( rc != 0 )  // error
    {
      rc = mbg_get_last_socket_error( "ioctlsocket(FIONBIO) failed in set_socket_blocking_mode" );
      goto out;
    }
  }
  #elif defined( MBG_TGT_POSIX )
  {
    int val = fcntl( sock_fd, F_GETFL, 0 );  // returns -1 on error

    if ( val == -1 )
    {
      rc = mbg_get_last_socket_error( "fcntl(F_GETFL) failed in set_socket_blocking_mode" );
      goto out;
    }

    if ( blocking )
      val &= ~O_NONBLOCK;
    else
      val |= O_NONBLOCK;

    rc = fcntl( sock_fd, F_SETFL, val );  // returns -1 on error

    if ( rc == -1 )
    {
      rc = mbg_get_last_socket_error( "fcntl(F_SETFL) failed in set_socket_blocking_mode" );
      goto out;
    }
  }
  #else
  {
    rc = MBG_ERR_NOT_SUPP_ON_OS;
    goto out;
  }
  #endif

  rc = MBG_SUCCESS;

out:
  return rc;

}  // set_socket_blocking_mode



static /*HDR*/
int get_sock_error( MBG_SOCK_FD sock_fd )
{
  int so_err = 0;
  socklen_t so_err_sz = sizeof( so_err );
  int rc = getsockopt( sock_fd, SOL_SOCKET, SO_ERROR, (char *) &so_err, &so_err_sz );  // returns 0 on success

  if ( rc != 0 )  // error
  {
    rc = mbg_get_last_socket_error( "getsockopt SO_ERROR failed in get_sock_error" );
    goto out;
  }

  if ( so_err_sz != sizeof( so_err ) )  // might have been modified by getsockopt()
  {
    fprintf( stderr, "Warning: getsockopt option size changed in get_sock_error: %li -> %li",
             (long) sizeof( so_err ), (long) so_err_sz );
    rc = MBG_ERR_UNSPEC;
    goto out;
  }

  if ( so_err != 0 )  // error
  {
    #if defined( MBG_TGT_WIN32 )
      rc = mbg_win32_wsa_err_to_mbg( so_err, "wait failed in wait_nonblocking_socket_ready" );
    #elif defined( MBG_TGT_POSIX )
      rc = mbg_posix_errno_to_mbg( so_err, "wait failed in wait_nonblocking_socket_ready" );
    #else
      #error This function is not supported for this target.
    #endif
    goto out;
  }

  rc = MBG_SUCCESS;

out:
  return rc;

}  // get_sock_error



static /*HDR*/
int wait_nonblocking_socket_ready( MBG_SOCK_FD sock_fd, long timeout_msec )
{
  // At least under Windows a select call can set except_fds if
  // the non-blocking attempt to connect fails.
  // See: http://msdn.microsoft.com/en-us/library/windows/desktop/ms740141(v=vs.85).aspx
  // Linux and FreeBSD suggest to use write_fds only.
  #if ( 1 || defined( MBG_TGT_WIN32 ) )  //### TODO
    #define USE_EXCEPT_FDS_WITH_CONNECT   1
  #else
    #define USE_EXCEPT_FDS_WITH_CONNECT   0
  #endif

  fd_set write_fds;
  #if USE_EXCEPT_FDS_WITH_CONNECT
    fd_set except_fds;
  #endif
  int max_fd;
  struct timeval tv_timeout;
  int rc = MBG_ERR_UNSPEC;

  mbg_msec_to_timeval( timeout_msec, &tv_timeout );

  FD_ZERO( &write_fds );
  FD_SET( sock_fd, &write_fds );

  #if defined( MBG_TGT_WIN32 )
    // Under Windows an fd is a handle which can't simply
    // be converted to an int, but the first argument of
    // select() is ignored under Windows anyway, so we just
    // set max_fd to 0.
    max_fd = 0;
  #else
    max_fd = sock_fd;
  #endif

  #if USE_EXCEPT_FDS_WITH_CONNECT
    FD_ZERO( &except_fds );
    FD_SET( sock_fd, &except_fds );
    rc = select( max_fd + 1, NULL, &write_fds, &except_fds, &tv_timeout );
  #else
    rc = select( max_fd + 1, NULL, &write_fds, NULL, &tv_timeout );
  #endif

  if ( rc == MBG_SOCKET_ERR_RETVAL )  // < 0, error
  {
    rc = mbg_get_last_socket_error( "select failed in wait_nonblocking_socket_ready" );
    goto out;
  }

  if ( rc == 0 )  // timeout
  {
    #if DEBUG_SOCK_IO
      fprintf( stderr, "select timed out in wait_nonblocking_socket_ready" );
    #endif
    rc = MBG_ERR_NBLOCK_WAIT_SLCT;
    goto out;
  }

  #if USE_EXCEPT_FDS_WITH_CONNECT
    // The except_fds might be set if no connection could be
    // established if e.g. the target socket is already busy.
    if ( FD_ISSET( sock_fd, &except_fds ) )
    {
      rc = get_sock_error( sock_fd );
      goto out;
    }
  #endif

  // Usually the write_fds are checked to see if the
  // non-blocking connect() call completed successfully,
  // in which case the associated descriptor is set.
  if ( !FD_ISSET( sock_fd, &write_fds ) )
  {
    #if DEBUG_SOCK_IO
      fprintf( stderr, "write_fd is not set after select in wait_nonblocking_socket_ready" );
    #endif
    rc = MBG_ERR_NBLOCK_WAIT_WR_FD;
    goto out;
  }

  #if defined( MBG_TGT_LINUX )
    // From the connect(2) man page:
    // After select(2) indicates writability, use getsockopt(2) to read
    // the SO_ERROR option at level SOL_SOCKET to determine whether connect()
    // completed successfully (SO_ERROR is zero) or unsuccessfully (SO_ERROR
    // is one of the usual error codes, explaining the reason for the failure).
    rc = get_sock_error( sock_fd );
    goto out;
  #endif

  rc = MBG_SUCCESS;

out:
  return rc;

}  // wait_nonblocking_socket_ready


#if defined( MBG_TGT_WIN32 )

void deinit_winsock( void )
{
  WSACleanup( );
}


int check_init_winsock( void )
{
  static bool wsa_init;
  int rc = MBG_SUCCESS;

  if( !wsa_init )
  {
    WORD wVersionRequested = MAKEWORD( 2, 2 );
    WSADATA wsaData;

    rc = WSAStartup( wVersionRequested, &wsaData );
    if ( rc != 0 )
      rc = mbg_win32_wsa_err_to_mbg( rc , NULL );
    else rc = MBG_SUCCESS;

    if( mbg_rc_is_success( rc ) )
    {
      wsa_init = true;
      atexit( deinit_winsock );
    }

  }

  return rc;
}

#endif // defined( MBG_TGT_WIN32 )


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_find_lan_devices( MBG_LAN_DEV_LIST **list, uint16_t timeout_ms )
{
#if defined( VS_MISSING_IPHLPAPI )
  return MBG_ERR_NOT_SUPP_ON_OS;
#else
  struct sockaddr_in src_addr = { 0 };
  struct sockaddr_in bcast_addr = { 0 };
  struct sockaddr_in global_bcast_addr = { 0 };
  MBG_LAN_DEV_LIST *list_head = NULL;
  MBG_LAN_DEV_LIST *curr_entry = NULL;
  MBG_LAN_DEV_LIST *tmp_entry;
  const uint32_t query = htonl( MBG_LAN_REQUEST_CONFIG );
  socklen_t addr_len = sizeof ( struct sockaddr_in );
  struct in_addr src_in_addr = { 0 };
  struct in_addr broad_in_addr = { 0 };
  struct timeval select_timeout;
  int opt = 1;
  int rc = MBG_SUCCESS;
  MBG_SOCK_FD sock = MBG_INVALID_SOCK_FD;
  MBG_TMO_TIME t_end;
  MBG_TMO_TIME t_now;
  MBG_LAN_DEV_CFG buf;
  fd_set socks;
  bool found;

#if defined( MBG_TGT_POSIX )

  struct ifaddrs *ifaddr = NULL, *ifa;

#elif defined( MBG_TGT_WIN32 )

  PIP_ADAPTER_ADDRESSES pAdptAddrs, pAdptAddr;
  PIP_ADAPTER_UNICAST_ADDRESS pUnicastAddr;
  ULONG flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
  unsigned long adptAddrsBuflen = sizeof( IP_ADAPTER_ADDRESSES );
  uint8_t prefix;

#endif

  global_bcast_addr.sin_family = AF_INET;
  global_bcast_addr.sin_addr.s_addr = htonl( INADDR_BROADCAST );
  global_bcast_addr.sin_port = htons( MBG_LAN_UDP_BROADCAST_PORT );

  bcast_addr.sin_family = AF_INET;
  bcast_addr.sin_port = htons( MBG_LAN_UDP_BROADCAST_PORT );

#if defined( MBG_TGT_POSIX )

  if ( getifaddrs( &ifaddr ) == 0 )
  {
    for ( ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next )
    {
      if ( ifa->ifa_addr && ( ifa->ifa_addr->sa_family == AF_INET ) )
      {
        src_in_addr.s_addr = ( (struct sockaddr_in *) ifa->ifa_addr )->sin_addr.s_addr;

        if ( ifa->ifa_broadaddr )
          broad_in_addr = ( (struct sockaddr_in *) ifa->ifa_broadaddr )->sin_addr;

#elif defined( MBG_TGT_WIN32 )

  rc = check_init_winsock();
  if( mbg_rc_is_error( rc ) )
    return rc;

  pAdptAddrs = (PIP_ADAPTER_ADDRESSES) malloc( sizeof( IP_ADAPTER_ADDRESSES ) );

  if ( !pAdptAddrs )
    return MBG_ERR_NO_MEM;

  rc = GetAdaptersAddresses( AF_INET, flags, NULL, pAdptAddrs, &adptAddrsBuflen );
  if ( rc == ERROR_BUFFER_OVERFLOW )
  {
    free( pAdptAddrs );
    pAdptAddrs = (PIP_ADAPTER_ADDRESSES) malloc( adptAddrsBuflen );
    if ( !pAdptAddrs )
      return MBG_ERR_NO_MEM;
    rc = GetAdaptersAddresses( AF_INET, flags, NULL, pAdptAddrs, &adptAddrsBuflen );
  }

  if ( rc == NO_ERROR )
  {
    for ( pAdptAddr = pAdptAddrs; pAdptAddr != NULL; pAdptAddr = pAdptAddr->Next )
    {
      if ( pAdptAddr->OperStatus != IfOperStatusUp )
        continue;

      for ( pUnicastAddr = pAdptAddr->FirstUnicastAddress; pUnicastAddr != NULL; pUnicastAddr = pUnicastAddr->Next )
      {
        if ( pUnicastAddr->Address.lpSockaddr->sa_family != AF_INET )
          continue;

        src_in_addr.s_addr = ( (struct sockaddr_in *) pUnicastAddr->Address.lpSockaddr )->sin_addr.s_addr;

        broad_in_addr = src_in_addr;
        for( prefix = pUnicastAddr->OnLinkPrefixLength; prefix < 32; prefix++ )
          broad_in_addr.s_addr |= ( 1UL << prefix );

#endif

        if ( ntohl( src_in_addr.s_addr ) == INADDR_LOOPBACK )
          continue;

        sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );

        if ( sock >= 0 )
        {
          mbg_tmo_get_time( &t_end );
          mbg_tmo_add_ms( &t_end, timeout_ms );

          src_addr.sin_family = AF_INET;
          src_addr.sin_addr.s_addr = src_in_addr.s_addr;

          bcast_addr.sin_addr.s_addr = broad_in_addr.s_addr;

          if ( ( setsockopt( sock, SOL_SOCKET, SO_BROADCAST, (const char*) &opt, sizeof( opt ) ) == 0 ) &&
              ( bind( sock, (const struct sockaddr *) &src_addr, addr_len ) == 0 ) )
          {
            if ( ( sendto( sock, (char *) &query, sizeof( query ), 0, (struct sockaddr *) &global_bcast_addr, addr_len ) == sizeof( query ) ) &&
                 ( sendto( sock, (char *) &query, sizeof( query ), 0, (struct sockaddr *) &bcast_addr, addr_len ) == sizeof( query ) ) )
            {
              while ( 1 )
              {
                FD_ZERO( &socks );
                FD_SET( sock, &socks );

                mbg_tmo_get_time( &t_now );
                if ( mbg_tmo_time_is_after( &t_now, &t_end ) )
                  break;
                mbg_msec_to_timeval( mbg_tmo_time_diff_ms( &t_end, &t_now ), &select_timeout );

                addr_len = sizeof( struct sockaddr_in );

                // The first parameter for select() is always an int, but sock
                // is not an int in Windows, but always in POSIX. Since the parameter
                // is ignored in windows anyway, it's safe to cast it to an int
                // to avoid compiler warnings.
                if( select( (int) ( sock + 1 ), &socks, NULL, NULL, &select_timeout ) > 0 )
                {
                  if( recvfrom( sock, (char *) &buf, sizeof( buf ), 0, (struct sockaddr *) &src_addr, &addr_len ) >= (ssize_t)sizeof( buf ) )
                  {
                    if( ( ntohl( buf.command ) == MBG_LAN_RESPOND_CONFIG ) &&
                      ( ( ntohs( buf.channel_0.own_tcp_port ) == LAN_XPT_PORT ) ||
                        ( buf.channel_0.own_tcp_port == LAN_XPT_PORT ) ||
                        ( ntohs( buf.channel_0.own_tcp_port ) == LAN_SSH_PORT ) ||
                        ( buf.channel_0.own_tcp_port == LAN_SSH_PORT ) ) )
                    {
                      found = false;

                      if ( list_head )
                      {
                        tmp_entry = list_head;
                        while( tmp_entry && !found )
                        {
                          if( tmp_entry->config.ip_address == ntohl( src_addr.sin_addr.s_addr ) )
                            found = true;
                          tmp_entry = tmp_entry->next;
                        }
                      }

                      if ( !found )
                      {
                        if ( curr_entry )
                        {
                          curr_entry->next = (MBG_LAN_DEV_LIST *) malloc( sizeof( *curr_entry->next ) );
                          if ( !curr_entry->next )
                          {
                            rc = MBG_ERR_NO_MEM;
                            goto cleanup_and_return;
                          }
                          curr_entry = curr_entry->next;
                        }
                        else
                        {
                          curr_entry = (MBG_LAN_DEV_LIST *) malloc( sizeof( *curr_entry ) );
                          if( !curr_entry )
                          {
                            rc = MBG_ERR_NO_MEM;
                            goto cleanup_and_return;
                          }
                          list_head = curr_entry;
                        }

                        memset( curr_entry, 0, sizeof( *curr_entry ) );
                        curr_entry->config = buf;
                        curr_entry->config.ip_address = ntohl( src_addr.sin_addr.s_addr );
                        rc++;
                      }
                    }
                  }
                }
                else
                  break;
              }
            }
            else
            {
              rc = MBG_ERR_NBYTES;
              goto cleanup_and_return;
            }
          }
          else
          {
            rc = MBG_ERR_INV_SOCK_FD;
            goto cleanup_and_return;
          }

#if defined( MBG_TGT_POSIX )

          shutdown( sock, SHUT_RDWR );
          close( sock );

#elif defined( MBG_TGT_WIN32 )

          shutdown( sock, SD_BOTH );
          closesocket( sock );

#endif
          sock = -1;
        }
        else
        {
          rc = MBG_ERR_INV_SOCK_FD;
          goto cleanup_and_return;
        }
      }
    }
  }
  else
    rc = MBG_ERR_GENERIC;

cleanup_and_return:

#if defined( MBG_TGT_POSIX )

  if ( ifaddr )
    freeifaddrs( ifaddr );

  if ( sock >= 0 )
  {
    shutdown( sock, SHUT_RDWR );
    close( sock );
  }

#elif defined( MBG_TGT_WIN32 )

  if ( pAdptAddrs )
    free( pAdptAddrs );

  if ( sock >= 0 )
  {
    shutdown( sock, SD_BOTH );
    closesocket( sock );
  }

#endif

  if ( rc <= 0 )
  {
    mbgextio_free_lan_devices( list_head );
    list_head = NULL;
  }

  *list = list_head;

  return rc;
#endif
}


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_free_lan_devices( MBG_LAN_DEV_LIST *list )
{
  if( list )
  {
    MBG_LAN_DEV_LIST *next_entry = list;
    while( next_entry )
    {
      list = next_entry;
      next_entry = list->next;
      free( list );
    }
    return MBG_SUCCESS;
  }
  return MBG_ERR_INV_PARM;
}


static /*HDR*/
int socket_init( MBG_MSG_CTL *pmctl, const char *host )
{
  int rc = MBG_ERR_UNSPEC;
  #if _USE_SSH_ENCRYPTION
    int login_rc = MBG_SUCCESS;
  #endif
  struct addrinfo *pinfo = NULL;

#if defined( MBG_TGT_WIN32 )
  rc = check_init_winsock( );

  if( !mbg_rc_is_success( rc ) )
    goto out;
#endif

  if ( pmctl->st.sockio.use_ssh )
  {
#if _USE_SSH_ENCRYPTION
    long tout = 5000 * 1000;
    int state, port = LAN_SSH_PORT;
    SSH_DATA *ssh_data = ( SSH_DATA* )pmctl->priv_data;

retry:
    ssh_data->session = ssh_new();
    if ( ssh_data->session == NULL )
    {
      rc = MBG_ERR_SOCK_INIT;
      goto out;
    }

    ssh_options_set( ssh_data->session, SSH_OPTIONS_HOST, host );
    ssh_options_set( ssh_data->session, SSH_OPTIONS_PORT, &port );
    ssh_options_set( ssh_data->session, SSH_OPTIONS_TIMEOUT_USEC, &tout );

    if ( ssh_connect( ssh_data->session ) != SSH_OK )
    {
      if( ssh_get_error_code( ssh_data->session ) == SSH_REQUEST_DENIED )
        rc = MBG_ERR_ACCESS;
      else rc = MBG_ERR_DISCONN;
      goto out_close;
    }

    rc = MBG_ERR_ACCESS;
    state = ssh_is_server_known( ssh_data->session );
    switch ( state )
    {
      case SSH_SERVER_KNOWN_OK:
      {
        rc = MBG_SUCCESS;
        break;
      }
      case SSH_SERVER_KNOWN_CHANGED:
      case SSH_SERVER_FOUND_OTHER:
      case SSH_SERVER_FILE_NOT_FOUND:
      case SSH_SERVER_NOT_KNOWN:
      {
        if ( ssh_data->key_prompt )
          rc = ssh_data->key_prompt( ssh_data, state );

        if(mbg_rc_is_error(rc))
          goto out_close;
        break;
      }
      default: goto out_close;
    }

    if ( ssh_data->login_prompt )
    {
      rc = ssh_data->login_prompt( ssh_data, login_rc );
      if ( mbg_rc_is_success( rc ) )
      {
        int32_t tmp;

        ssh_data->channel = ssh_channel_new( ssh_data->session );
        if ( ssh_data->channel == NULL )
        {
          rc = MBG_ERR_SOCK_INIT;
          goto out_close;
        }

        if ( ssh_channel_open_session( ssh_data->channel ) != SSH_OK )
        {
          rc = MBG_ERR_INV_SOCK_FD;
          goto out_close;
        }

        rc = ssh_channel_read( ssh_data->channel, &tmp, sizeof( tmp ), 0 );
        if ( rc > 0 )
          rc = ntohl( tmp );
        else rc = MBG_ERR_TIMEOUT;

        if ( mbg_rc_is_error( rc ) )
        {
          socket_close(pmctl);
          login_rc = rc;
          goto retry;
        }
      }
    }
    else
      rc = MBG_ERR_AUTH;

    if ( mbg_rc_is_error( rc ) )
      goto out_close;

#else
    rc = MBG_ERR_NOT_SUPP_BY_DEV;
#endif
  }
  else
  {
    struct sockaddr_in addr;
    struct addrinfo hints;
    struct sockaddr_in *paddr;
    const struct sockaddr *p;
    int sz;

    if ( inet_pton( AF_INET, host, &addr.sin_addr ) == 1 )
      rc = MBG_SUCCESS;

    if( mbg_rc_is_error( rc ) )
    {
      memset( &hints, 0, sizeof( hints ) );
      hints.ai_family = AF_INET;
      hints.ai_socktype = SOCK_STREAM;
      hints.ai_protocol = IPPROTO_TCP;

      switch ( getaddrinfo( host, NULL, &hints, &pinfo ) )
      {
        case 0:
          rc = MBG_SUCCESS;
          break;

        case EAI_NONAME:
        // At least with some versions of Microsoft Visual Studio
        // EAI_NODATA evaluates to the same number as EAI_NONAME,
        // which caused a "duplicate case" compiler error.
        #if defined( EAI_NODATA ) && ( EAI_NODATA != EAI_NONAME )
          case EAI_NODATA:
        #endif
        #if defined( EAI_ADDRFAMILY )
          case EAI_ADDRFAMILY:
        #endif
        #if defined( EAI_FAMILY )
          case EAI_FAMILY:
        #endif
          rc = MBG_ERR_DEV_NOT_SUPP;
          break;

        case EAI_AGAIN:
          rc = MBG_ERR_BUSY;
          break;

        case EAI_MEMORY:
          rc = MBG_ERR_NO_MEM;
          break;

        default:
          rc = MBG_ERR_UNKNOWN;
          break;
      }

      if ( !pinfo )
      {
        rc = MBG_ERR_GENERIC;
        goto out;
      }

      addr.sin_addr = ( ( struct sockaddr_in* )pinfo->ai_addr )->sin_addr;
    }

    // Create socket on which to send.
    pmctl->st.sockio.sockfd = socket( PF_INET, SOCK_STREAM, 0 );

    if ( pmctl->st.sockio.sockfd == MBG_INVALID_SOCK_FD )
    {
      rc = mbg_get_last_socket_error( "failed to create socket in socket_init" );
      goto out;
    }

    // Set the socket to nonblocking mode to be able to
    // reduce the timeout when connecting to a socket
    // which is offline.
    rc = set_socket_blocking_mode( pmctl->st.sockio.sockfd, 0 );

    if ( mbg_rc_is_error( rc ) )
      goto out_close;


    // Now try to connect to the socket.
    paddr = &pmctl->st.sockio._addr;
    memset( paddr, 0, sizeof( *paddr ) );

    paddr->sin_addr = addr.sin_addr;
    paddr->sin_family = AF_INET;
    paddr->sin_port = htons( LAN_XPT_PORT );

    p = (const struct sockaddr *) paddr;
    sz = sizeof( *paddr );

    rc = connect( pmctl->st.sockio.sockfd, p, sz );  // returns 0 on success on Windows and Linux

    // In nonblocking mode connect() might complete successfully
    // if the destination socket is on the same machine (localhost)
    // However, for remote connections the call usually returns
    // immediately with WSAEWOULDBLOCK on Windows, or EINPROGRESS or
    // EALREADY on POSIX systems. In the latter cases we need to wait
    // and see if the connection can be established successfully.

    if ( rc != 0 )  // eventually not (yet) completed in non-blocking mode
    {
      #if defined( MBG_TGT_WIN32 )
        DWORD wsa_err = WSAGetLastError();

        // WSAEWOULDBLOCK is actually not an error in non-blocking mode
        if ( wsa_err != WSAEWOULDBLOCK )
        {
          rc = mbg_win32_wsa_err_to_mbg( wsa_err, "connect failed in socket_init" );
          goto out_close;
        }
      #else  // POSIX ...
        int posix_errno = errno;

        // EINPROGRESS and EALREADY are actually not errors in non-blocking mode
        if ( ( posix_errno != EINPROGRESS ) && ( posix_errno != EALREADY ) )
        {
          rc = mbg_posix_errno_to_mbg( posix_errno, "connect failed in socket_init" );
          goto out_close;
        }
      #endif

      rc = wait_nonblocking_socket_ready( pmctl->st.sockio.sockfd, 1500 );  //##++++++++++++

      if ( mbg_rc_is_error( rc ) )
        goto out_close;
    }

    // Set the socket back to blocking mode.
    rc = set_socket_blocking_mode( pmctl->st.sockio.sockfd, 1 );

    pmctl->st.sockio.p_addr = &pmctl->st.sockio._addr;
    pmctl->st.sockio.addrlen = sizeof( pmctl->st.sockio._addr );
  }

  if ( mbg_rc_is_success( rc ) )
    goto out;

  // error, fall through and close socket
out_close:
  socket_close( pmctl );

out:
  if ( pinfo )
    freeaddrinfo( pinfo );
  return rc;

}  // socket_init



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_xmt_secu_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                const char *old_passwd, const char *new_passwd )
{
  MBG_MSG_BUFF *pmb;
  SECU_SETTINGS *pss = &pmctl->secu_settings;
  GPS_CMD cmd = GPS_SECU_SETTINGS;  // GPS_REQACK is not supported by LAN_XPT, so never use it
  int rc = MBG_ERR_UNSPEC;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  memset( pss, 0, sizeof *pss );
  strncpy_safe( pss->password, old_passwd, sizeof( pss->password ) );

  set_encryption_mode( pmctl, MBG_XFER_MODE_ENCRYPTED, pss->password );

  if ( new_passwd )
  {
    if ( strlen( new_passwd ) > 0 )
      strncpy_safe( pss->new_password, new_passwd, sizeof( pss->new_password ) );

    pss->flags |= MSK_FLAG_CHANGE_PASSWORD;
  }

  pmb = pmctl->xmt.pmb;
  pmb->u.msg_data.secu_settings = *pss;
  pmb->hdr.cmd = cmd;
  pmb->hdr.len = sizeof( pmb->u.msg_data.secu_settings );

  rc = xmt_tbuff( pmctl, p_addr );    //### TODO Use mbgextio_req_data instead? Is NULL OK?

  if ( mbg_rc_is_error( rc ) )
    goto out;

  rc = mbgextio_rcv_msg_unlocked( pmctl, NULL, cmd, NULL, 0 );    //### TODO Is XBP_ADDR NULL OK?

  // With some devices a timeout may also occur
  // if a wrong password has been used.
  if ( mbg_rc_is_error( rc ) )
    goto out;

  cmd = pmctl->rcv.pmb->hdr.cmd;

  // If we either received a reply with GPS_NACK, or
  // without GPS_ACK, the password was definitely wrong.
  if ( ( cmd & GPS_NACK ) || !( cmd & GPS_ACK ) )
  {
    rc = MBG_ERR_AUTH;
    goto out;
  }

  rc = MBG_SUCCESS;

out:
  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_xmt_secu_settings


/*HDR*/
_NO_MBG_API_ATTR int mbgextio_socket_write_default(MBG_MSG_CTL* pmctl, const void *buf, size_t len)
{
  int rc = sendto( pmctl->st.sockio.sockfd, buf, len, 0,
                   ( const struct sockaddr *)pmctl->st.sockio.p_addr,
                   pmctl->st.sockio.addrlen );

  if ( rc >= 0 )
  {
    if ( (size_t)rc != len )
      rc = MBG_ERR_BYTES_WRITTEN;
  }
  else
    rc = mbg_posix_errno_to_mbg( errno, NULL ) ;

  return rc;
}


/*HDR*/
_NO_MBG_API_ATTR int mbgextio_socket_read_default(MBG_MSG_CTL* pmctl, void *buf, size_t len)
{
  struct timeval tv_timeout;
  fd_set fds;
  int max_fd;
  int rc;

  mbg_msec_to_timeval( pmctl->st.sockio.poll_timeout, &tv_timeout );

  FD_ZERO( &fds );
  FD_SET( pmctl->st.sockio.sockfd, &fds );

  #if defined( MBG_TGT_WIN32 )
    // Under Windows an fd is a handle which can't simply
    // be converted to an int, but the first argument of
    // select() is ignored under Windows anyway, so we just
    // set max_fd to 0.
    max_fd = 0;
  #else
    max_fd = pmctl->st.sockio.sockfd;
  #endif

  rc = select( max_fd + 1, &fds, NULL, NULL, &tv_timeout );

  if ( rc < 0 )
    return rc;

  if ( rc == 0 )
    return MBG_ERR_TIMEOUT;

  // data is available

  return recv( pmctl->st.sockio.sockfd, buf, len, 0 );
}


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_open_socket( const char *host,
                              MBG_MSG_CTL **ppmctl, const char *passwd )
{
  MBG_MSG_CTL *pmctl;
  int rc = alloc_msg_ctl( &pmctl );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_finish( rc, pmctl, ppmctl );

  pmctl->st.sockio.read = mbgextio_socket_read_default;
  pmctl->st.sockio.write = mbgextio_socket_write_default;

  rc = socket_init( pmctl, host );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_free( rc, &pmctl, ppmctl );

  dev_open_init( pmctl, MBG_CONN_TYPE_SOCKET, MBGEXTIO_MSG_TIMEOUT_SOCKET,
                 MBGEXTIO_POLL_TIMEOUT_SOCKET );

  rc = mbgextio_xmt_secu_settings( pmctl, NULL, passwd, NULL );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_close( rc, &pmctl, ppmctl );

  return dev_open_finish_setup( &pmctl, ppmctl );

}  // mbgextio_open_socket


#if _USE_SSH_ENCRYPTION

/*HDR*/
_NO_MBG_API_ATTR int mbgextio_socket_write_ssh( MBG_MSG_CTL* pmctl, const void *buf, size_t len )
{
  int rc;
  SSH_DATA *ssh_data;

  ssh_data = __mbg_get_pmctl_ssh_data( pmctl );

  _mbg_mutex_acquire(&ssh_data->mutex);
  rc = ssh_channel_write( ssh_data->channel, buf, len );
  _mbg_mutex_release(&ssh_data->mutex);

  if ( rc >= 0 )
  {
    if ( (size_t)rc != len )
      rc = MBG_ERR_BYTES_WRITTEN;
  }
  else
    rc = MBG_ERR_IO;

  return rc;
}


/*HDR*/
_NO_MBG_API_ATTR int mbgextio_socket_read_ssh( MBG_MSG_CTL* pmctl, void *buf, size_t len )
{
  SSH_DATA *ssh_data = __mbg_get_pmctl_ssh_data( pmctl );
  struct timeval tv_timeout;
  ssh_channel chans[2];
  int ssh_rc;

  mbg_msec_to_timeval( pmctl->st.sockio.poll_timeout, &tv_timeout );

  chans[0] = ssh_data->channel;
  chans[1] = NULL;

  /*
   * As far as I can tell from libssh's source code there's no need to protect
   * "ssh_channel_select" by the session mutex as no session members are
   * altered in that function. But hey: No guarantee! ;) (Especially not
   * for any future libssh versions!!)
   */
  ssh_rc = ssh_channel_select( chans, NULL, NULL, &tv_timeout );
  if ( ssh_rc == SSH_OK )
  {
    if ( chans[0] != ssh_data->channel )
      return MBG_ERR_TIMEOUT;

    _mbg_mutex_acquire(&ssh_data->mutex);
    ssh_rc = ssh_channel_read_nonblocking( ssh_data->channel, buf, len, 0 );
    _mbg_mutex_release(&ssh_data->mutex);
  }

  if ( ssh_rc > 0 )
    return ssh_rc;

  switch ( ssh_rc )
  {
    case SSH_AGAIN: return MBG_ERR_TIMEOUT;
    case SSH_ERROR:
    case SSH_EOF: return 0;  // 0 evals to disconnected in ::mbgextio_rcv_msg_unlocked
    default: return MBG_ERR_GENERIC;
  }
}


static __mbg_inline SSH_DATA* mbgextio_get_ssh_data( MBG_MSG_CTL *pmctl )
{
  return pmctl->priv_data;
}


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_open_ssh_socket( const char *host,
                              MBG_MSG_CTL **ppmctl, SSH_DATA *ssh_data )
{
  MBG_MSG_CTL *pmctl;
  int rc = alloc_msg_ctl( &pmctl );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_finish( rc, pmctl, ppmctl );

  pmctl->st.sockio.use_ssh = 1;
  pmctl->st.sockio.read = mbgextio_socket_read_ssh;
  pmctl->st.sockio.write = mbgextio_socket_write_ssh;
  pmctl->st.sockio.get_ssh_data = mbgextio_get_ssh_data;
  pmctl->priv_data = ssh_data;
  _mbg_mutex_init( &ssh_data->mutex, "ssh_mutex" );

  rc = socket_init( pmctl, host );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_free( rc, &pmctl, ppmctl );

  dev_open_init( pmctl, MBG_CONN_TYPE_SOCKET, MBGEXTIO_MSG_TIMEOUT_SOCKET,
                 MBGEXTIO_POLL_TIMEOUT_SOCKET );

  return dev_open_finish_setup( &pmctl, ppmctl );
}

#endif

#endif  // _USE_SOCKET_IO



#if _USE_SERIAL_IO

/*HDR*/
int mbgextio_open_serial_raw( const char *dev, MBG_MSG_CTL **ppmctl,
                              uint32_t baud_rate, const char *framing )
{
  MBG_MSG_CTL *pmctl;
  int rc = alloc_msg_ctl( &pmctl );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_finish( rc, pmctl, ppmctl );

  rc = mbgserio_open( &pmctl->st.p_serio, dev );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_free( rc, &pmctl, ppmctl );

  dev_open_init( pmctl, MBG_CONN_TYPE_SERIAL, MBGEXTIO_MSG_TIMEOUT_SERIAL,
                 MBGEXTIO_POLL_TIMEOUT_SERIAL );

  rc = mbgserio_set_parms( pmctl->st.p_serio, baud_rate, framing );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_close( rc, &pmctl, ppmctl );

  return dev_open_finish( rc, pmctl, ppmctl );

}  // mbgextio_open_serial_raw



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_open_serial( const char *dev, MBG_MSG_CTL **ppmctl,
                              uint32_t baud_rate, const char *framing )
{
  MBG_MSG_CTL *pmctl;
  int rc = alloc_msg_ctl( &pmctl );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_finish( rc, pmctl, ppmctl );

  rc = mbgserio_open( &pmctl->st.p_serio, dev );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_free( rc, &pmctl, ppmctl );

  dev_open_init( pmctl, MBG_CONN_TYPE_SERIAL, MBGEXTIO_MSG_TIMEOUT_SERIAL,
                 MBGEXTIO_POLL_TIMEOUT_SERIAL );

  rc = mbgserio_set_parms( pmctl->st.p_serio, baud_rate, framing );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_close( rc, &pmctl, ppmctl );

  return dev_open_finish_setup( &pmctl, ppmctl );

}  // mbgextio_open_serial


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_open_serial_force_default( const char *dev, MBG_MSG_CTL **ppmctl, uint32_t baud_rate, const char *framing )
{
  const char* cmd_str = force_conn_hs_cmd_str;
  int len = (int) strlen( cmd_str );
  MBG_MSG_CTL *pmctl = NULL;
  int rc;
  int high = 1;

  if ( ( baud_rate == MBG_DEFAULT_BAUDRATE_HS ) && ( strcmp( framing, MBG_DEFAULT_FRAMING ) == 0 ) )
    return mbgextio_open_serial( dev, ppmctl, baud_rate, framing );

retry:
  rc = mbgextio_open_serial_raw( dev, &pmctl, baud_rate, framing );

  if ( mbg_rc_is_success( rc ) )
  {
    mbgserio_write( pmctl->st.p_serio, cmd_str, len );

    #ifdef MBG_TGT_WIN32
      // Flushing the output when the serial port is closed doesn't
      // always work correctly under Windows, so we insert a delay
      // here to make sure the string has been set.
      // The required delay depends on the number of characters to
      // send, and on the transmission speed (baud rate).
      Sleep( ( ( 10 * 1000 * len ) / baud_rate ) + 1 );
    #endif

    mbgextio_close_connection( &pmctl );

    // Sleep for 10ms, so the device has time to switch to the new baudrate
    #if defined( MBG_TGT_WIN32 )
      Sleep( 10 );
    #elif defined( MBG_TGT_DOS )
      delay( 10 );
    #else
      usleep( 10000 );
    #endif

    rc = mbgextio_open_serial( dev, &pmctl, high ? MBG_DEFAULT_BAUDRATE_HS : MBG_DEFAULT_BAUDRATE, MBG_DEFAULT_FRAMING );

    if ( mbg_rc_is_error( rc ) && high )
    {
      // If baud_rate is default baudrate and highspeed baud_rate did not work, simply open the port with default baudrate
      if( ( baud_rate == MBG_DEFAULT_BAUDRATE ) && ( strcmp( framing, MBG_DEFAULT_FRAMING ) == 0 ) )
        return mbgextio_open_serial( dev, ppmctl, baud_rate, framing );

      high = 0;
      cmd_str = force_conn_cmd_str;
      len = ( int )strlen( cmd_str );
      goto retry;
    }
  }

  if ( mbg_rc_is_success( rc ) )
    *ppmctl = pmctl;

  return rc;

} // mbgextio_open_serial_force_default

#endif // _USE_SERIAL_IO



#if _USE_SERIAL_IO_FTDI

/*HDR*/
_NO_MBG_API_ATTR FT_HANDLE _MBG_API mbgextio_get_serial_ftdi_port_handle( MBG_MSG_CTL *pmctl )
{
  return pmctl->st.ftdi.port_handle;

}  // mbgextio_get_serial_ftdi_port_handle



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_open_serial_ftdi( int device_num,
                 MBG_MSG_CTL **ppmctl, uint32_t baud_rate, const char *framing )
{
  FT_STATUS status;
  ULONG ft_baud;
  UCHAR ft_data_bits;
  UCHAR ft_stopbits;
  UCHAR ft_parity;
  const char *cp;
  MBG_MSG_CTL *pmctl;
  int rc = alloc_msg_ctl( &pmctl );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_finish( rc, pmctl, ppmctl );

  status = FT_Open( device_num, &pmctl->st.ftdi.port_handle );

  if ( status != FT_OK )
    return dev_open_fail_free( mbg_ftdi_ft_status_to_mbg( status ), &pmctl, ppmctl );

  dev_open_init( pmctl, MBG_CONN_TYPE_SERIAL_FTDI, MBGEXTIO_MSG_TIMEOUT_SERIAL,
                 MBGEXTIO_POLL_TIMEOUT_SERIAL );

  // setup transmission speed
  switch ( baud_rate )
  {
    case 300:    ft_baud = FT_BAUD_300;    break;
    case 600:    ft_baud = FT_BAUD_600;    break;
    case 1200:   ft_baud = FT_BAUD_1200;   break;
    case 2400:   ft_baud = FT_BAUD_2400;   break;
    case 4800:   ft_baud = FT_BAUD_4800;   break;
    case 9600:   ft_baud = FT_BAUD_9600;   break;
    case 14400:  ft_baud = FT_BAUD_14400;  break;
    case 19200:  ft_baud = FT_BAUD_19200;  break;
    case 38400:  ft_baud = FT_BAUD_38400;  break;
    case 57600:  ft_baud = FT_BAUD_57600;  break;
    case 115200: ft_baud = FT_BAUD_115200; break;
    case 230400: ft_baud = FT_BAUD_230400; break;
    case 460800: ft_baud = FT_BAUD_460800; break;
    case 921600: ft_baud = FT_BAUD_921600; break;

    default:
      return dev_open_fail_close( MBG_ERR_INV_PARM, &pmctl, ppmctl );
  }


  // setup framing
  for ( cp = framing; *cp; cp++ )
  {
    char c = toupper( *cp );

    switch ( c )
    {
      case '7':  ft_data_bits = FT_BITS_7;      break;
      case '8':  ft_data_bits = FT_BITS_8;      break;

      case 'N':  ft_parity = FT_PARITY_NONE;    break;
      case 'E':  ft_parity = FT_PARITY_EVEN;    break;
      case 'O':  ft_parity = FT_PARITY_ODD;     break;
      // FT_PARITY_MARK and FT_PARITY_SPACE not supp. by Meinberg API

      case '1':  ft_stopbits = FT_STOP_BITS_1;  break;
      case '2':  ft_stopbits = FT_STOP_BITS_2;  break;

      default:
        return dev_open_fail_close( MBG_ERR_INV_PARM, &pmctl, ppmctl );
    }
  }


  status = FT_SetBaudRate( pmctl->st.ftdi.port_handle, ft_baud );

  if ( status != FT_OK )
    return dev_open_fail_close( mbg_ftdi_ft_status_to_mbg( status ), &pmctl, ppmctl );

  status = FT_SetDataCharacteristics( pmctl->st.ftdi.port_handle,
                              ft_data_bits, ft_stopbits, ft_parity );

  if ( status != FT_OK )
    return dev_open_fail_close( mbg_ftdi_ft_status_to_mbg( status ), &pmctl, ppmctl );

  return dev_open_finish_setup( &pmctl, ppmctl );

}  // mbgextio_open_serial_ftdi

#endif



#if _USE_USB_IO

/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_open_usb( const MBG_USB_DEV_INFO *mdev_info,
                              MBG_MSG_CTL **ppmctl )
{
  MBG_MSG_CTL *pmctl;
  int rc = alloc_msg_ctl( &pmctl );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_finish( rc, pmctl, ppmctl );

  rc = mbgusbio_open( &pmctl->st.usbio, mdev_info );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_free( rc, &pmctl, ppmctl );

  dev_open_init( pmctl, MBG_CONN_TYPE_USB, MBGEXTIO_MSG_TIMEOUT_USB,
                 MBGEXTIO_POLL_TIMEOUT_USB );

  return dev_open_finish_setup( &pmctl, ppmctl );

}  // mbgextio_open_usb



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_reset_usb( const MBG_USB_DEV_INFO *mdev_info )
{
  return mbgusbio_reset( mdev_info );

}  // mbgextio_reset_usb



/*HDR*/
int mbgextio_open_usb_ldev( libusb_device *ldev, MBG_MSG_CTL **ppmctl )
{
  MBG_MSG_CTL *pmctl;
  int rc = alloc_msg_ctl( &pmctl );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_finish( rc, pmctl, ppmctl );

  rc = mbgusbio_open_specific_device( &pmctl->st.usbio, ldev );

  if ( mbg_rc_is_error( rc ) )
    return dev_open_fail_free( rc, &pmctl, ppmctl );

  dev_open_init( pmctl, MBG_CONN_TYPE_USB, MBGEXTIO_MSG_TIMEOUT_USB,
                 MBGEXTIO_POLL_TIMEOUT_USB );

  return dev_open_finish_setup( &pmctl, ppmctl );

}  // mbgextio_open_usb_ldev

#endif



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_close_connection( MBG_MSG_CTL **ppmctl )
{
  MBG_MSG_CTL *pmctl = *ppmctl;
  int rc = MBG_ERR_UNSPEC;

  switch ( pmctl->conn_type )
  {
    #if _USE_SERIAL_IO
      case MBG_CONN_TYPE_SERIAL:
        rc = mbgserio_close( &pmctl->st.p_serio );
        break;
    #endif  // _USE_SERIAL_IO

    #if _USE_SERIAL_IO_FTDI
      case MBG_CONN_TYPE_SERIAL_FTDI:
      {
        FT_STATUS status = FT_Close( pmctl->st.ftdi.port_handle );
        pmctl->st.ftdi.port_handle = NULL;  //### TODO FT_Handle is a PVOID
        rc = mbg_ftdi_ft_status_to_mbg( status );
      } break;
    #endif  // _USE_SERIAL_IO_FTDI

    #if _USE_SOCKET_IO
      case MBG_CONN_TYPE_SOCKET:
        rc = socket_close( pmctl );
        break;
    #endif  // _USE_SOCKET_IO

    #if _USE_USB_IO
      case MBG_CONN_TYPE_USB:
        rc = mbgusbio_close( &pmctl->st.usbio );
        break;
    #endif  // _USE_USB_IO

    default:
      rc = MBG_ERR_CONN_TYPE;

  }  // switch

  #if _USE_MUTEX
    _mbg_mutex_destroy( &pmctl->dev_mutex );
  #endif

  dealloc_msg_ctl( ppmctl );

  return rc;

}  // mbgextio_close_connection



#if _USE_SERIAL_IO

static /*HDR*/
int do_force_conn_serial( const char *dev, int high_speed )
{
  MBG_MSG_CTL *pmctl;
  const char *cmd_str = high_speed ? force_conn_hs_cmd_str : force_conn_cmd_str;
  BAUD_RATE expected_baudrate = high_speed ? MBG_DEFAULT_BAUDRATE_HS : MBG_DEFAULT_BAUDRATE;
  #if DEBUG_FORCE_CONN
    const char *info = high_speed ? " (hs)" : "";
  #endif
  int len = (int) strlen( cmd_str );
  int baud_idx;
  int frame_idx;
  int rc = MBG_ERR_UNSPEC;

  for ( baud_idx = 0; baud_idx < N_MBG_BAUD_RATES; baud_idx++ )
  {
    for ( frame_idx = 0; frame_idx < N_MBG_FRAMINGS; frame_idx++ )
    {
      uint32_t baud_rate = mbg_baud_rates[baud_idx];
      const char *framing = mbg_framing_strs[frame_idx];

      rc = mbgextio_open_serial_raw( dev, &pmctl, baud_rate, framing );

      if ( mbg_rc_is_error( rc ) )
      {
        if ( rc == MBG_ERR_NO_ENTITY )  //### TODO duplicate code
        {
          #if DEBUG_FORCE_CONN
            fprintf( stderr, "force conn%s probing failed to open port %s: %s: aborting\n",
                     info, dev, mbg_strerror( rc ) );
          #endif
          goto out;
        }

        if ( rc == MBG_ERR_IO )  //### TODO duplicate code
        {
          #if DEBUG_FORCE_CONN
            fprintf( stderr, "force conn%s failed for port %s with %li/%s: %s: aborting\n",
                     info, dev, (long) baud_rate, framing, mbg_strerror( rc ) );
          #endif
          goto out;
        }

        #if DEBUG_FORCE_CONN
          fprintf( stderr, "force conn%s failed for port %s with %li/%s: %s: skipping\n",
                   info, dev, (long) baud_rate, framing, mbg_strerror( rc ) );
        #endif
        continue;
      }

      mbgserio_write( pmctl->st.p_serio, cmd_str, len );
      // should we check rc here or just continue?

      #ifdef MBG_TGT_WIN32
        // Flushing the output when the serial port is closed doesn't
        // always work correctly under Windows, so we insert a delay
        // here to make sure the string has been set.
        // The required delay depends on the number of characters to
        // send, and on the transmission speed (baud rate).
        Sleep( ( ( 10 * 1000 * len ) / baud_rate ) + 1 );
      #endif

      mbgextio_close_connection( &pmctl );
    }
  }

  rc = mbgextio_open_serial_raw( dev, &pmctl, expected_baudrate, MBG_DEFAULT_FRAMING );

  if ( mbg_rc_is_error( rc ) )
    goto out;

  rc = mbgextio_get_receiver_info( pmctl, NULL, NULL );

  if ( mbg_rc_is_success( rc ) )
    rc = expected_baudrate;

  mbgextio_close_connection( &pmctl);

out:
  return rc;

}  // do_force_conn_serial



/*HDR*/
_NO_MBG_API_ATTR long _MBG_API mbgextio_force_conn_serial( const char *dev )
{
  long rc = do_force_conn_serial( dev, 1 );

  if ( mbg_rc_is_success( rc ) )
    goto out;

  // If we failed because the specified port is not available
  // then it makes no sense to continue.
  if ( ( rc == MBG_ERR_NO_ENTITY ) || ( rc == MBG_ERR_IO ) )  //### TODO duplicate code
    goto out;

  rc = do_force_conn_serial( dev, 0 );

out:
  return rc;

}  // mbgextio_force_conn_serial

#endif  // _USE_SERIAL_IO



#if _USE_SERIAL_IO_FTDI

static /*HDR*/
int do_force_conn_serial_ftdi( int device_num, const char *cmd_str, BAUD_RATE expected_baudrate )
{
  int i;
  int j;
  MBG_MSG_CTL *pmctl;
  int len = (int) strlen( force_conn_cmd_str );
  long rc = MBG_ERR_UNSPEC;

  for ( i = 0; i < N_MBG_BAUD_RATES; i++ )
  {
    for ( j = 0; j < N_MBG_FRAMINGS; j++ )
    {
      uint32_t baud_rate = mbg_baud_rates[i];
      const char *framing = mbg_framing_strs[j];
      DWORD bytes_written;
      FT_HANDLE port_handle;
      FT_STATUS status;

      rc = mbgextio_open_serial_ftdi( device_num, &pmctl, baud_rate, framing );

      if ( mbg_rc_is_error( rc ) )
        goto out;

      port_handle = pmctl->st.ftdi.port_handle;

      status = FT_Write( port_handle, (LPVOID) force_conn_cmd_str, len, &bytes_written );

    #if 0  //### TODO  we need some error checking here
      if ( status != FT_OK )
      {
        rc = mbg_ftdi_ft_status_to_mbg( status );
        goto out;
      }

      if ( bytes_written != sizeof( len ) )
        goto out_write_failed;
    #endif

      #ifdef MBG_TGT_WIN32
        #if 1
          // TODO Check if this works as expected
          status = FT_Purge( port_handle, FT_PURGE_TX );
        #else

          // Flushing the output when the serial port is closed doesn't
          // always work correctly under Windows, so we insert a delay
          // here to make sure the string has been set.
          // The required delay depends on the number of characters to
          // send, and on the transmission speed (baud rate).
          Sleep( ( ( 10 * 1000 * len ) / baud_rate ) + 1 );
        #endif
      #endif

      mbgextio_close_connection( &pmctl );
    }
  }

  rc = mbgextio_open_serial_ftdi( device_num, &pmctl, expected_baudrate, MBG_DEFAULT_FRAMING );

  if ( mbg_rc_is_error( rc ) )
    goto out;

  rc = mbgextio_get_receiver_info( pmctl, NULL, NULL );

  mbgextio_close_connection( &pmctl );

out:
  return rc;

}  // do_force_conn_serial_ftdi



/*HDR*/
_NO_MBG_API_ATTR long _MBG_API mbgextio_force_conn_serial_ftdi( int device_num )
{
  long rc = do_force_conn_serial_ftdi( device_num, force_conn_hs_cmd_str, MBG_DEFAULT_BAUDRATE_HS );

  if ( mbg_rc_is_success( rc ) )
    return MBG_DEFAULT_BAUDRATE_HS;

  rc = do_force_conn_serial_ftdi( device_num, force_conn_cmd_str, MBG_DEFAULT_BAUDRATE );

  if ( mbg_rc_is_success( rc ) )
    return MBG_DEFAULT_BAUDRATE;

  return rc;

}  // mbgextio_force_conn_serial_ftdi

#endif  // _USE_SERIAL_IO_FTDI



/*HDR*/
_NO_MBG_API_ATTR void _MBG_API mbgextio_register_nack_callback( MBG_MSG_CTL *pmctl,
                                                                MBG_NACK_HANDLER_FNC *fnc )
{
  pmctl->nack_handler_fnc = *fnc;

}  // mbgextio_register_nack_callback



/*HDR*/
_NO_MBG_API_ATTR void _MBG_API mbgextio_register_async_msg_callback( MBG_MSG_CTL *pmctl,
                                                              MBG_ASYNC_MSG_HANDLER_FNC *fnc )
{
  pmctl->async_msg_handler_fnc = *fnc;

}  // mbgextio_register_async_msg_callback



/*HDR*/
_NO_MBG_API_ATTR void _MBG_API mbgextio_register_async_data_callback( MBG_MSG_CTL *pmctl,
                                                              MBG_ASYNC_DATA_HANDLER_FNC *fnc )
{
  pmctl->async_data_handler_fnc = *fnc;

}  // mbgextio_register_async_data_callback



/*HDR*/
_NO_MBG_API_ATTR void _MBG_API mbgextio_register_async_data_reset_callback( MBG_MSG_CTL *pmctl,
                                                              MBG_ASYNC_DATA_RESET_FNC *fnc )
{
  pmctl->async_data_reset_fnc = *fnc;

}  // mbgextio_register_async_data_reset_callback



/*HDR*/
_NO_MBG_API_ATTR RECEIVER_INFO * _MBG_API mbgextio_get_receiver_info_addr( MBG_MSG_CTL *pmctl )
{
  if ( pmctl == NULL )
    return NULL;

  return &pmctl->xdev_features.receiver_info;

}  // mbgextio_get_receiver_info_addr



/*HDR*/
_NO_MBG_API_ATTR MBG_MSG_BUFF * _MBG_API mbgextio_get_rcv_buffer_addr( MBG_MSG_CTL *pmctl )
{
  if ( pmctl == NULL )
    return NULL;

  return pmctl->rcv.pmb;

}  // mbgextio_get_rcv_buffer_addr



/*HDR*/
_NO_MBG_API_ATTR size_t _MBG_API mbgextio_get_rcv_buffer_size( MBG_MSG_CTL *pmctl )
{
  if ( pmctl == NULL )
    return 0;

  return sizeof( *pmctl->rcv.pmb );

}  // mbgextio_get_rcv_buffer_size



/*HDR*/
_NO_MBG_API_ATTR MBG_MSG_BUFF * _MBG_API mbgextio_get_xmt_buffer_addr( MBG_MSG_CTL *pmctl )
{
  if ( pmctl == NULL )
    return NULL;

  return pmctl->xmt.pmb;

}  // mbgextio_get_xmt_buffer_addr



/*HDR*/
_NO_MBG_API_ATTR size_t _MBG_API mbgextio_get_xmt_buffer_size( MBG_MSG_CTL *pmctl )
{
  if ( pmctl == NULL )
    return 0;

  return sizeof( *pmctl->xmt.pmb );

}  // mbgextio_get_xmt_buffer_size



/*HDR*/
_NO_MBG_API_ATTR ulong _MBG_API mbgextio_set_dev_poll_timeout( MBG_MSG_CTL *pmctl, ulong new_timeout )
{
  return xtiocomm_set_dev_poll_timeout( pmctl, new_timeout );

}  // mbgextio_set_dev_poll_timeout



/*HDR*/
_NO_MBG_API_ATTR ulong _MBG_API mbgextio_get_dev_poll_timeout( const MBG_MSG_CTL *pmctl )
{
  return xtiocomm_get_dev_poll_timeout( pmctl );

}  // mbgextio_get_dev_poll_timeout



/*HDR*/
_NO_MBG_API_ATTR void _MBG_API mbgextio_set_msg_rcv_timeout( MBG_MSG_CTL *pmctl, ulong new_timeout )
{
  xtiocomm_set_msg_rcv_timeout( pmctl, new_timeout );

}  // mbgextio_set_msg_rcv_timeout



/*HDR*/
_NO_MBG_API_ATTR ulong _MBG_API mbgextio_get_msg_rcv_timeout( const MBG_MSG_CTL *pmctl )
{
  return xtiocomm_get_msg_rcv_timeout( pmctl );

}  // mbgextio_get_msg_rcv_timeout



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_is_legacy( const MBG_MSG_CTL *pmctl )
{
  return ( pmctl->device_flags & MSG_CTL_DEVICE_FLAG_MSK_LEGACY ) ? MBG_SUCCESS : MBG_ERR_DEV_NOT_SUPP;

}  // mbgextio_dev_is_legacy

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_is_legacy;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_pos_xyz( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_pos_xyz( &pmctl->xdev_features );

}  // mbgextio_dev_has_pos_xyz

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_pos_xyz;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_pos_lla( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_pos_lla( &pmctl->xdev_features );

}  // mbgextio_dev_has_pos_lla

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_pos_lla;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_time_ttm( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_time_ttm( &pmctl->xdev_features );

}  // mbgextio_dev_has_time_ttm

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_time_ttm;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ant_info( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ant_info( &pmctl->xdev_features );

}  // mbgextio_dev_has_ant_info

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ant_info;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ant_cable_length( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ant_cable_length( &pmctl->xdev_features );

}  // mbgextio_dev_has_ant_cable_length

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ant_cable_length;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_io_ports( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_io_ports( &pmctl->xdev_features );

}  // mbgextio_dev_has_io_ports

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_io_ports;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_tainted_cfg( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_tainted_cfg( &pmctl->xdev_features );

}  // mbgextio_dev_has_tainted_cfg

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_tainted_cfg;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_push_msgs( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_push_msgs( &pmctl->xdev_features );

}  // mbgextio_dev_has_push_msgs

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_push_msgs;

/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_clk_res_info( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_clk_res_info( &pmctl->xdev_features );

}  // mbgextio_dev_has_clk_res_info

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_clk_res_info;




/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_gps_stat_info( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_gps_stat_info( &pmctl->xdev_features );

}  // mbgextio_dev_has_gps_stat_info

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_gps_stat_info;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_is_gps( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_is_gps( &pmctl->xdev_features );

}  // mbgextio_dev_is_gps

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_is_gps;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_is_gnss( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_is_gnss( &pmctl->xdev_features );

}  // mbgextio_dev_is_gnss

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_is_gnss;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_is_tcr( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_is_tcr( &pmctl->xdev_features );

}  // mbgextio_dev_is_tcr

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_is_tcr;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_is_dcf( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_is_dcf( &pmctl->xdev_features );

}  // mbgextio_dev_is_dcf

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_is_dcf;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_pzf( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_pzf( &pmctl->xdev_features );

}  // mbgextio_dev_has_pzf

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_pzf;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_is_bus_lvl_dev( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_is_bus_lvl_dev( &pmctl->xdev_features );

}  // mbgextio_dev_is_bus_lvl_dev

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_is_bus_lvl_dev;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_enable_flags( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_enable_flags( &pmctl->xdev_features );

}  // mbgextio_dev_has_enable_flags

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_enable_flags;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_time_scale( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_time_scale( &pmctl->xdev_features );

}  // mbgextio_dev_has_time_scale

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_time_scale;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_tzdl( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_tzdl( &pmctl->xdev_features );

}  // mbgextio_dev_has_tzdl

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_tzdl;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_tzcode( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_tzcode( &pmctl->xdev_features );

}  // mbgextio_dev_has_tzcode

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_tzcode;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ims( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ims( &pmctl->xdev_features );

}  // mbgextio_dev_has_ims

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ims;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_synth( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_synth( &pmctl->xdev_features );

}  // mbgextio_dev_has_synth

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_synth;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_gpio( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_gpio( &pmctl->xdev_features );

}  // mbgextio_dev_has_gpio

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_gpio;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_prog_pulses( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_prog_pulses( &pmctl->xdev_features );

}  // mbgextio_dev_has_prog_pulses

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_prog_pulses;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_irig_tx( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_irig_tx( &pmctl->xdev_features );

}  // mbgextio_dev_has_irig_tx

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_irig_tx;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_irig_rx( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_irig_rx( &pmctl->xdev_features );

}  // mbgextio_dev_has_irig_rx

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_irig_rx;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_serouts( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_serouts( &pmctl->xdev_features );

}  // mbgextio_dev_has_serouts

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_serouts;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_bvar_stat( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_bvar_stat( &pmctl->xdev_features );

}  // mbgextio_dev_has_serouts

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_bvar_stat;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_service( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_service( &pmctl->xdev_features );

}  // mbgextio_dev_has_service

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_service;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_up_conv( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_up_conv( &pmctl->xdev_features );

} // mbgextio_dev_has_up_conv

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_up_conv;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_scu_stat( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_scu_stat( &pmctl->xdev_features );

}  // mbgextio_dev_has_scu_stat

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_scu_stat;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_raw_irig_data( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_raw_irig_data( &pmctl->xdev_features );

}  // mbgextio_dev_has_raw_irig_data

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_raw_irig_data;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_lan_ip4( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_lan_ip4( &pmctl->xdev_features );

}  // mbgextio_dev_has_lan_ip4

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_lan_ip4;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_net_cfg( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_net_cfg( &pmctl->xdev_features );

}  // mbgextio_dev_has_net_cfg

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_net_cfg;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ptp( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ptp( &pmctl->xdev_features );

}  // mbgextio_dev_has_ptp

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ptp;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ntp( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ntp( &pmctl->xdev_features );

} // mbgextio_dev_has_ntp

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ntp;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_fw_mngmnt( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_fw_mngmnt( &pmctl->xdev_features );

} // mbgextio_dev_has_fw_mngmnt

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_fw_mngmnt;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_evt_log( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_evt_log( &pmctl->xdev_features );

} // mbgextio_dev_has_evt_log

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_evt_log;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ucap( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ucap( &pmctl->xdev_features );

} // mbgextio_dev_has_ucap

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ucap;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ucap_net( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ucap_net( &pmctl->xdev_features );

} // mbgextio_dev_has_ucap_net

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ucap_net;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_tlv_api( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_tlv_api( &pmctl->xdev_features );

}  // mbgextio_dev_has_tlv_api

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_tlv_api;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_user_auth( const MBG_MSG_CTL *pmctl )
{
  int rc = MBG_ERR_CONN_TYPE;

  #if _USE_SOCKET_IO
    if( ( pmctl->conn_type == MBG_CONN_TYPE_SOCKET ) &&
        ( pmctl->st.sockio.use_ssh > 0 ) )
      rc = xdevfeat_has_user_auth( &pmctl->xdev_features );
  #endif

  return rc;

}  // mbgextio_dev_has_user_auth

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_user_auth;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_user_mngmnt( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_user_mngmnt( &pmctl->xdev_features );

}  // mbgextio_dev_has_user_mngmnt

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_user_mngmnt;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_file_req( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_file_req( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_file_req

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_file_req;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_exec_cmd( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_exec_cmd( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_exec_cmd

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_exec_cmd;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_fw_rollback( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_fw_rollback( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_fw_rollback

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_fw_rollback;

/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_fw_update( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_fw_update( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_fw_update

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_fw_update;

/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_diag_file( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_diag_file( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_diag_file

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_diag_file;

/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_ptpv2_license( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_ptpv2_license( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_ptpv2_license

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_ptpv2_license;

/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_ptpv1_license( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_ptpv1_license( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_ptpv1_license

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_ptpv1_license;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_ntp_license( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_ntp_license( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_ntp_license

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_ntp_license;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_time_monitor_license( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_time_monitor_license( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_time_monitor_license

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_time_monitor_license;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_supp_tlv_ufu( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_supp_tlv_ufu( &pmctl->xdev_features );

}  // mbgextio_dev_supp_tlv_ufu

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_supp_tlv_ufu;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_cmd_save_cfg( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_cmd_save_cfg( &pmctl->xdev_features );

}  // mbgextio_dev_has_cmd_save_cfg

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_cmd_save_cfg;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_monitoring( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_monitoring( &pmctl->xdev_features );

}  // mbgextio_dev_has_monitoring

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_monitoring;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_led_api( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_led_api( &pmctl->xdev_features );

}  // mbgextio_dev_has_led_api

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_led_api;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_lne_api( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_lne_api( &pmctl->xdev_features );

}  // mbgextio_dev_has_lne_api

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_lne_api;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_pwr_ctl_api( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_pwr_ctl_api( &pmctl->xdev_features );

}  // mbgextio_dev_has_pwr_ctl_api

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_pwr_ctl_api;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_ext_sys_info( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_ext_sys_info( &pmctl->xdev_features );

}  // mbgextio_dev_has_ext_sys_info

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_ext_sys_info;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_transactions( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_transactions( &pmctl->xdev_features );

}  // mbgextio_dev_has_transactions

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_transactions;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_reboot( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_reboot( &pmctl->xdev_features );

}  // mbgextio_dev_has_reboot

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_reboot;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_req_ttm( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_req_ttm( &pmctl->xdev_features );

}  // mbgextio_dev_has_req_ttm

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_req_ttm;


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_xmulti_ref( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_xmulti_ref( &pmctl->xdev_features );

}  // mbgextio_dev_has_xmulti_ref

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_xmulti_ref;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_xbp( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_xbp( &pmctl->xdev_features );

}  // mbgextio_dev_has_xbp

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_xbp;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_database( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_database( &pmctl->xdev_features );

}  // mbgextio_dev_has_database

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_database;



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_dev_has_gnss_mode( const MBG_MSG_CTL *pmctl )
{
  return xdevfeat_has_gnss_mode( &pmctl->xdev_features );

}  // mbgextio_dev_has_gnss_mode

MBGEXTIO_CHK_SUPP_FNC mbgextio_dev_has_gnss_mode;



static /*HDR*/
int msg_return_code( MBG_MSG_CTL *pmctl )
{
  const MBG_MSG_BUFF *pmb = pmctl->rcv.pmb;
  int rc;

  if ( ( pmb->hdr.cmd & GPS_NACK ) == 0 )
    return MBG_SUCCESS;


  // A NACK message has been received from the device.

  if ( pmb->hdr.len == sizeof( pmb->u.msg_data.i16 ) )
  {
    // The device has returned a code to indicate the reason for
    // the NACK. This should be one of the @ref MBG_ERROR_CODES.
    // We'll return this error code by default, if appropriate.
    rc = pmb->u.msg_data.i16;

    // Make sure the returned code is indeed an error code.
    if ( mbg_rc_is_error( rc ) )
    {
      // Call the NACK handler callback function, if one has
      // been registered, and pass the return code from the
      // callback function up to the caller.
      if ( pmctl->nack_handler_fnc )
        rc = pmctl->nack_handler_fnc( pmctl );

      // Return the code received from the device, or
      // the return code from the callback function.
      goto out;
    }

    // The code returned by the device was not an error code,
    // as we'd expected. So we ignore that code and continue
    // the same way as if no specific code had been received
    // from the device.
  }

  rc = MBG_ERR_RCVD_NACK;

out:
  return rc;

}  // msg_return_code



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_rcv_msg_unlocked( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                  GPS_CMD cmd, void *buf, size_t buf_size )
{
  MBG_MSG_RCV_CTL *prctl;
  MBG_MSG_BUFF *pmb;
  char buff[MBGEXTIO_READ_BUFFER_SIZE];
  ssize_t n_bytes = 0;
  int rc = MBG_ERR_UNSPEC;
  int i;
  #if _DEBUG_MSG_TIMING
    MBG_MSG_TIMES *pmt = &pmctl->mt;
  #else
    MBG_MSG_TIMES mt;
    MBG_MSG_TIMES *pmt = &mt;
  #endif

  init_transfer( &pmctl->rcv );
  mbg_tmo_get_time( &pmt->t_start );
  pmt->t_tmo = pmt->t_start;
  mbg_tmo_add_ms( &pmt->t_tmo, pmctl->msg_rcv_timeout );

  for (;;)  // loop until complete msg received
  {
    n_bytes = 0;

    mbg_tmo_get_time( &pmt->t_now );

    if ( mbg_tmo_time_is_after( &pmt->t_now, &pmt->t_tmo ) )
    {
      rc = MBG_ERR_TIMEOUT;
      goto out;
    }

    switch ( pmctl->conn_type )
    {
      #if _USE_SOCKET_IO
        case MBG_CONN_TYPE_SOCKET:
        {
          n_bytes = pmctl->st.sockio.read( pmctl, buff, sizeof( buff ) );

          if ( n_bytes == MBG_ERR_TIMEOUT )
            continue;

          /* 0 bytes mean remote site closed connection on TCP sockets */
          if ( n_bytes == 0 )
          {
            rc = MBG_ERR_DISCONN;
            goto out;
          }

          if ( n_bytes < 0 )
          {
            rc = mbg_get_last_socket_error( "recv failed in mbgextio_rcv_msg_unlocked" );
            goto out;
          }

        } break;
      #endif  // _USE_SOCKET_IO

      #if _USE_SERIAL_IO
        case MBG_CONN_TYPE_SERIAL:
        {
          rc = mbgserio_read_wait( pmctl->st.p_serio, &buff[0], sizeof( buff[0] ) );

          if ( mbg_rc_is_error( rc ) )
          {
            // Do not continue with reception after character timeout
            // if ( rc == MBG_ERR_TIMEOUT )  // just a character timeout
              // continue;                   // continue loop to check message timeout

            goto out;                     // non-timeout error: fatal, quit
          }

          // rc contains number of received bytes
          n_bytes = rc;

        } break;
      #endif  // _USE_SERIAL_IO

      #if _USE_SERIAL_IO_FTDI
        case MBG_CONN_TYPE_SERIAL_FTDI:
        {
          DWORD bytes_read;
          FT_STATUS status;

          //### TODO   pmctl->dev_poll_timeout
          status = FT_Read( pmctl->st.ftdi.port_handle, &buff[0],
                            sizeof( buff[0] ), &bytes_read );

          if ( status != FT_OK )
          {
            rc = mbg_ftdi_ft_status_to_mbg( status );
            goto out;
          }

          n_bytes = bytes_read;

        } break;
      #endif  // _USE_SERIAL_IO_FTDI

      #if _USE_USB_IO
        case MBG_CONN_TYPE_USB:
        {
          rc = mbgusbio_read( &pmctl->st.usbio, (uint8_t *) buff, sizeof( buff ) );

          if ( mbg_rc_is_error( rc ) )
          {
            if ( rc == MBG_ERR_TIMEOUT )  // just a character timeout
              continue;                   // continue loop to check message timeout

            goto out;                     // non-timeout error: fatal, quit
          }

          // rc contains number of received bytes
          n_bytes = rc;

        } break;
      #endif  // _USE_USB_IO

      #if _USE_USB_DIRECT_IO
        case MBG_CONN_TYPE_USB_DIRECT_IO:
        {
          struct pollfd pfd;

          pfd.fd = pmctl->st.usbdio.usbdiofd;
          pfd.events = POLLIN | POLLRDNORM | POLLRDBAND;
          pfd.revents = 0;

          rc = poll( &pfd, 1, pmctl->st.usbdio.poll_timeout );

          if ( rc == 0 )   // timeout
          {
            rc = MBG_ERR_TIMEOUT;
            goto out;
          }

          if ( rc < 0 )    // error
          {
            rc = mbg_get_last_error( "failed to poll direct USB I/O" );
            goto out;
          }

          if ( pfd.revents & POLLHUP )
          {
            rc = MBG_ERR_DISCONN;
            goto out;
          }

          // Other stuff?
          if ( pfd.revents & ( POLLERR | POLLNVAL ) )
          {
            rc = MBG_ERR_UNSPEC;
            goto out;
          }

          // Read data?
          if ( pfd.revents & ( POLLIN | POLLRDNORM | POLLRDBAND ) )
          {
            rc = read( pmctl->st.usbdio.usbdiofd, (void*)buff, sizeof(buff) );

            if ( rc < 0 )
            {
              rc = mbg_get_last_error( "failed to read direct USB I/O" );
              goto out;
            }

            n_bytes = rc;
          }

        } break;
      #endif

      default:
        rc = MBG_ERR_CONN_TYPE;
        goto out;

    }  // switch

    prctl = &pmctl->rcv;
    pmb = prctl->pmb;

    for ( i = 0; i < n_bytes; i++ )
    {
      char c = buff[i];

      // Check if the new char belongs to binary message.
      rc = check_transfer( prctl, c );

      switch ( rc )
      {
        case TR_WAITING:
          // We are waiting for a binary message, but have just received
          // some non-protocol data.
          // If an async data handler callback function has been registered
          // via ::mbgextio_register_async_data_callback then we call that function
          // so it can eventually evaluate this data, otherwise it gets lost.
          if ( pmctl->async_data_handler_fnc )
            pmctl->async_data_handler_fnc( pmctl, c );

          continue;

        case TR_RECEIVING:
          // Data transfer sequence is in progress, keep waiting.
          continue;

        case TR_COMPLETE:
          {
            GPS_CMD rcvd_cmd;

            // A valid binary message has been received.
            // Eventually we want to discard any partial async
            // data that possibly has been received before, and
            // re-initialize async data reception.
            if ( pmctl->async_data_reset_fnc )
              pmctl->async_data_reset_fnc( pmctl );

            rcvd_cmd = pmb->hdr.cmd & ~GPS_CTRL_MSK;

            if ( ( rcvd_cmd == GPS_XBP_PACKET ) && p_addr )
            {
              if ( memcmp( &pmb->u.xbp_msg_data.xbp_addr, p_addr, sizeof( *p_addr ) ) == 0 )
              {
                // This packet is from the expected XBP node.
                mbg_memcpy( pmb, &pmb->u.xbp_msg_data.std_msg, sizeof( pmb->u.xbp_msg_data.std_msg ) );
                rcvd_cmd = pmb->hdr.cmd & ~GPS_CTRL_MSK;
              }
            }

            if ( rcvd_cmd == cmd )
            {
              // The received message is the one we've been waiting for.
              rc = msg_return_code( pmctl );
              goto out;
            }

            #if _USE_ENCRYPTION
              // If an encrypted packet has been received then decrypt it.
              if ( !pmctl->st.sockio.use_ssh && ( rcvd_cmd == GPS_CRYPTED_PACKET ) )
              {
                rc = decrypt_message( pmctl );

                if ( rc < 0 )  /* decryption error */
                  goto out;

                rcvd_cmd = pmb->hdr.cmd & ~GPS_CTRL_MSK;

                if ( ( rcvd_cmd == GPS_XBP_PACKET ) && p_addr )
                {
                  if ( memcmp( &pmb->u.xbp_msg_data.xbp_addr, p_addr, sizeof( *p_addr ) ) == 0 )
                  {
                    // This packet is from the expected XBP node.
                    mbg_memcpy( pmb, &pmb->u.xbp_msg_data.std_msg, sizeof( pmb->u.xbp_msg_data.std_msg ) );
                    rcvd_cmd = pmb->hdr.cmd & ~GPS_CTRL_MSK;
                  }
                }

                if ( rcvd_cmd == cmd )
                {
                  // The received message is the one we've been waiting for.
                  rc = msg_return_code( pmctl );
                  goto out;
                }
              }
            #endif

            // Not waiting for a specific message, so return any message that is complete.
            if ( cmd == GPS_WILDCARD )
            {
              rc = MBG_SUCCESS;
              goto out;
            }

            // We are waiting for a specific message, but have just received
            // a message which does not match the expected code.
            // If an async message handler callback function has been registered
            // via ::mbgextio_register_async_msg_callback then we call that function
            // so it can eventually evaluate the message, and the message doesn't
            // get lost. Otherwise the message is simply dropped.
            // See ::mbgextio_register_async_msg_callback.
            if ( pmctl->async_msg_handler_fnc )
              pmctl->async_msg_handler_fnc( pmctl );

            init_transfer( prctl );   // restart receiving
          }
          break;

        case TR_CSUM_HDR:
          rc = MBG_ERR_HDR_CSUM;
          goto out;

        case TR_CSUM_DATA:
          rc = MBG_ERR_DATA_CSUM;
          goto out;

        case TR_OVERFLOW:
          rc = MBG_ERR_OVERFLOW;
          goto out;

        default:    /* any error condition */
          rc = MBG_ERR_UNSPEC;    //##+++++++++++++++++++++ use detailed rc
          goto out;

      }  /* switch */
    }
  }

out:
  if ( mbg_rc_is_error( rc ) )
    goto out2;   //### TODO

  // Successfully received a binary message. If a destinaton buffer
  // has been specified then we copy the received data to that buffer
  // *before* the device mutex is released, so we can be sure the
  // received data isn't overwritten by a different thread.
  if ( buf )
  {
    MBG_MSG_BUFF *pmb = pmctl->rcv.pmb;

    if ( buf_size != pmb->hdr.len )
    {
      #if defined( DEBUG )
        const char *cp = mbgextio_get_cmd_name( cmd );

        fprintf( stderr, "received data size (%u) doesn't match buffer size (%llu) for cmd: %s\n",
                 pmb->hdr.len, (unsigned long long) buf_size, cp ? cp : "(unknown)" );
      #endif

      rc = MBG_ERR_DATA_SIZE;
      goto out2;
    }

    memcpy( buf, &pmb->u.msg_data, buf_size );
  }

out2:
  return rc;

}  // mbgextio_rcv_msg_unlocked



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_rcv_msg( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                GPS_CMD cmd, void *buf, size_t buf_size )
{
  int rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, cmd, buf, buf_size );   // wait for a message

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_rcv_msg



static /*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_check_ack( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                  GPS_CMD cmd )
{
  int rc = MBG_SUCCESS;

  // Simply return if no acknowledge has been requested
  if ( !( cmd & GPS_REQACK ) )
    goto out;

  rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, (GPS_CMD) ( cmd &  ~GPS_CTRL_MSK ), NULL, 0 );

  if ( mbg_rc_is_error( rc ) )
    goto out;

  if ( pmctl->rcv.pmb->hdr.cmd & GPS_NACK )
  {
    rc = MBG_ERR_RCVD_NACK;
    goto out;
  }

  if ( !( pmctl->rcv.pmb->hdr.cmd & GPS_ACK ) )
    rc = MBG_ERR_RCVD_NO_ACK;

out:
  return rc;

}  // mbgextio_check_ack



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_xmt_msg( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                GPS_CMD cmd, const void *p, uint16_t n_bytes )
{
  MBG_MSG_BUFF *pmb;
  int rc = MBG_ERR_UNSPEC;

  if ( n_bytes > sizeof( pmb->u.msg_data ) )
  {
    rc = MBG_ERR_OVERFLOW;  // bytes to send exceed transmit buffer size

    // If p is not NULL then the transmit mutex has not yet
    // been acquired, and thus we can exit immediately.
    if ( p )
      goto out;

    // Otherwise we have to release the mutex before we exit.
    goto out_release;
  }


  pmb = pmctl->xmt.pmb;

  // If the buffer pointer p is NULL then we assume the transmit buffer
  // has already been set up by the caller, and thus the caller has already
  // acquired the device mutex.
  // However, if a data buffer has been specified (i.e., p != NULL)
  // then we have to acquire the device mutex before we start to
  // set up the transmit buffer.
  if ( p )
  {
    #if _USE_MUTEX
      _mbg_mutex_acquire( &pmctl->dev_mutex );
    #endif
    memcpy( pmb->u.bytes, p, n_bytes );
  }

  pmb->hdr.len = n_bytes;
  pmb->hdr.cmd = cmd;

  rc = xmt_tbuff( pmctl, p_addr );

  if ( mbg_rc_is_success( rc ) )
    rc = mbgextio_check_ack( pmctl, p_addr, cmd );

out_release:
  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

out:
  return rc;

}  // mbgextio_xmt_msg



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_xmt_cmd( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                GPS_CMD cmd )
{
  int rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  rc = xmt_cmd( pmctl, p_addr, cmd );

  // If the call above succeeded then this just means there
  // was no transmission error. It does *not* necessarily mean
  // the command has been received and understood by the device.
  // So if the cmd code has been or'ed with a flag requesting
  // an acknowledge then we wait for an ack msg from the device now.
  if ( mbg_rc_is_success( rc ) )
    rc = mbgextio_check_ack( pmctl, p_addr, cmd );

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_xmt_cmd



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_xmt_cmd_us( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                   GPS_CMD cmd, uint16_t us )
{
  int rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  rc = xmt_cmd_us( pmctl, p_addr, cmd, us );

  if ( mbg_rc_is_success( rc ) )
    rc = mbgextio_check_ack( pmctl, p_addr, cmd );

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_xmt_cmd_us



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_xmt_cmd_u32( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                   GPS_CMD cmd, uint32_t u32 )
{
  int rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  rc = xmt_cmd_u32( pmctl, p_addr, cmd, u32 );

  if ( mbg_rc_is_success( rc ) )
    rc = mbgextio_check_ack( pmctl, p_addr, cmd );

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_xmt_cmd_u32



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_req_data( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                 GPS_CMD cmd, void *buf, size_t buf_size )
{
  int rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  rc = xmt_cmd( pmctl, p_addr, cmd );                         // request data

  if ( mbg_rc_is_success( rc ) )
    rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, cmd, buf, buf_size );   // wait for the reply

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_req_data



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_req_data_idx_unlocked( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                              GPS_CMD cmd, uint16_t idx, void *buf, size_t buf_size )
{
  int rc;

  rc = xmt_cmd_us( pmctl, p_addr, cmd, idx );                 // request data

  if ( mbg_rc_is_success( rc ) )
    rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, cmd, buf, buf_size );   // wait for the reply

  return rc;

}  // mbgextio_req_data_idx_unlocked



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_req_data_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                     GPS_CMD cmd, uint16_t idx, void *buf, size_t buf_size )
{
  int rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  rc = mbgextio_req_data_idx_unlocked( pmctl, p_addr, cmd, idx, buf, buf_size );

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_req_data_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_receiver_info( MBG_MSG_CTL *pmctl,
                                            const XBP_ADDR *p_addr, RECEIVER_INFO *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_RECEIVER_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_receiver_info( p );

  return rc;

}  // mbgextio_get_receiver_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_io_port_limits( MBG_MSG_CTL *pmctl,
                                                           const XBP_ADDR *p_addr,
                                                           MBG_IO_PORT_LIMITS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_IO_PORT_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
    /* There is nothing to swaP */
    _mbg_swab_io_port_limits( p );

  return rc;

}  // mbgextio_get_io_port_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_io_port_settings_idx( MBG_MSG_CTL *pmctl,
                                                                 const XBP_ADDR *p_addr,
                                                                 const MBG_IO_PORT_SETTINGS *p,
                                                                 uint8_t idx )
{
  GPS_CMD cmd = GPS_IO_PORT_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  MBG_IO_PORT_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.iop_settings_idx;
  uint16_t sizes[] = MBG_IO_PORT_SETTINGS_IDX_SIZES;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;

  _mbg_swab_io_port_settings_idx( p_data, 0 );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizes[p->port_type] );
  return rc;

}  // mbgextio_set_io_port_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_io_port_info_idx( MBG_MSG_CTL *pmctl,
                                                             const XBP_ADDR *p_addr,
                                                             MBG_IO_PORT_INFO_IDX *p,
                                                             uint8_t idx )
{
  size_t len;
  MBG_MSG_BUFF *rbuf = mbgextio_get_rcv_buffer_addr(pmctl);
  MBG_IO_PORT_INFO_IDX *iopi_idx = &rbuf->u.msg_data.iop_info_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_IO_PORT_INFO_IDX, idx, NULL, 0 );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  /* Check if at least header part is avail */
  if (rbuf->hdr.len < MBG_IO_PORT_INFO_IDX_MIN_SIZE)
    return MBG_ERR_NBYTES;

  _mbg_swab_io_port_info_idx( iopi_idx, 1 );

  len = sizeof(*p);
  if (len > rbuf->hdr.len)
    len = rbuf->hdr.len;

  memcpy(p, &rbuf->u.msg_data, len);

  return MBG_SUCCESS;

}  // mbgextio_get_io_port_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_io_port_type_info_idx( MBG_MSG_CTL *pmctl,
                                                                  const XBP_ADDR *p_addr,
                                                                  MBG_IO_PORT_TYPE_INFO_IDX *p,
                                                                  uint8_t port_idx, uint8_t port_type_idx)
{
  size_t len;
  uint16_t idx = ((port_idx << 8) | port_type_idx);
  MBG_MSG_BUFF *rbuf = mbgextio_get_rcv_buffer_addr(pmctl);
  MBG_IO_PORT_TYPE_INFO_IDX *iopti_idx = &rbuf->u.msg_data.iop_type_info_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_IO_PORT_TYPE_INFO_IDX, idx, NULL, 0 );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  /* Check if at least header part is avail */
  if (rbuf->hdr.len < MBG_IO_PORT_TYPE_INFO_IDX_MIN_SIZE)
    return MBG_ERR_NBYTES;

  _mbg_swab_io_port_type_info_idx( iopti_idx, 1 );

  len = sizeof(*p);
  if (len > rbuf->hdr.len)
    len = rbuf->hdr.len;

  memcpy(p, &rbuf->u.msg_data, len);

  return MBG_SUCCESS;

}  // mbgextio_get_io_port_type_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_io_port_status_idx( MBG_MSG_CTL *pmctl,
                                                               const XBP_ADDR *p_addr,
                                                               MBG_IO_PORT_STATUS_IDX *p,
                                                               uint8_t idx)
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_IO_PORT_STATUS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_io_port_status_idx( p );

  return rc;

}  // mbgextio_get_io_port_status_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_clk_res_info( MBG_MSG_CTL *pmctl,
                                                         const XBP_ADDR *p_addr,
                                                         MBG_CLK_RES_INFO *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_CLK_RES_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
      _mbg_swab_mbg_clk_res_info( p );

  return rc;

}  // mbgextio_get_clk_res_info




static /*HDR*/
int chk_get_rcvr_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                       RECEIVER_INFO *p )
{
  #if DEBUG_INIT_CONN
    static int cnt;
  #endif

  // Try to read the RECEIVER_INFO structure from the device
  int rc = mbgextio_get_receiver_info( pmctl, p_addr, p );

  #if DEBUG_INIT_CONN
    printf( "get rcvr info %i: %i\n", ++cnt, rc );
  #endif

  if ( mbg_rc_is_success( rc ) )
    pmctl->dev_has_receiver_info = true;

  return rc;

}  // chk_get_rcvr_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_setup_receiver_info( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, RECEIVER_INFO *p )
{
  int rc;

  #if _USE_USB_IO
    // If the device is a legacy USB device then it only supports a
    // proprietary protocol instead of the standard binary protocol.
    // We try to find this out based on the USB vendor and device IDs,
    // and we need to check this *before* we try to read a RECEIVER_INFO
    // structure from the device.
    // See also ::mbgextio_dev_is_legacy
    if ( pmctl->conn_type == MBG_CONN_TYPE_USB )
    {
      RECEIVER_INFO *p_ri = mbgextio_get_receiver_info_addr( pmctl );
      rc = check_setup_legacy_usb_device(&pmctl->st.usbio.mdev_info, p_ri );

      if ( mbg_rc_is_success( rc ) )
      {
        // A legacy device was detected, and an appropriate RECEIVER_INFO
        // for this device has been set up.
        pmctl->device_flags |= MSG_CTL_DEVICE_FLAG_MSK_LEGACY;
        goto out;
      }
    }
  #endif  // _USE_USB_IO

  // Try to read the RECEIVER_INFO structure from the device
  rc = chk_get_rcvr_info( pmctl, p_addr, p );

  if ( mbg_rc_is_success( rc ) )
    goto out;  // RECEIVER_INFO was read successfully

  // Failed, but eventually some synchronization is required,
  // e.g. if the baud rate was just changed, so retry once.
  rc = chk_get_rcvr_info( pmctl, p_addr, p );

  if ( mbg_rc_is_success( rc ) )
    goto out;  // RECEIVER_INFO was read successfully from the device.

  // In all error cases except MBG_ERR_TIMEOUT we return with error anyway.
  if ( rc != MBG_ERR_TIMEOUT )
    goto out;


  // There are a few very old devices which support the binary protocol but
  // don't support reading a RECEIVER_INFO, so we check if we can set up
  // a default structure, depending on a device type.
  //
  // Affected devices, at least:
  //   GPS166    (all versions)
  //   GPS167PC  (all versions)
  //   GPS167PCI < 4.22
  //   GPS167    < 4.17
  //   GPS167SV  < 4.17
  {
    SW_REV sw_rev = { 0 };
    IDENT ident = { { 0 } };

    rc = mbgextio_get_sw_rev( pmctl, p_addr, &sw_rev );

    if ( mbg_rc_is_error( rc ) )  // Failed to read SW revision, so
      goto out;                   // probably no device connected.

    // set up a default receiver info structure
    _setup_default_receiver_info_gps( p );

    // set up some generic device name
    p->model_code = GPS_MODEL_GPS16X;
    sn_cpy_str_safe( p->model_name, sizeof( p->model_name ), GPS_MODEL_NAME_GPS16X );

    // copy the software revision info we have read from the device
    p->sw_rev = sw_rev;
    trim_whitespace( p->sw_rev.name );

    #if _USE_MUTEX
      _mbg_mutex_acquire( &pmctl->dev_mutex );
    #endif

    xmt_cmd( pmctl, p_addr, 0x400 );
    xmt_cmd( pmctl, p_addr, 0x20F );
    xmt_cmd( pmctl, p_addr, 0x001 );
    rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, 0x20F, &ident, sizeof( ident ) );

    #if _USE_MUTEX
      _mbg_mutex_release( &pmctl->dev_mutex );
    #endif

    if ( mbg_rc_is_success( rc ) )
    {
      // Unfortunately there are older devices and firmware versions out there
      // where the serial number is saved word-wise, and others where it is
      // saved byte-wise, so it can be really tricky to get it right.
      // If we want to giver it a try we need to add some other library modules
      #if _TRY_IDENT_DECODE
        mbg_gps_ident_decode( p->sernum, &ident );
      #else
        sn_cpy_str_safe( p->sernum, sizeof( p->sernum ), ident.c );
      #endif
    }

    // Return successful in any case since we could
    // at least read the SW_REV structure.
    rc = MBG_SUCCESS;
  }

out:
  return rc;

}  // mbgextio_setup_receiver_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_sw_rev( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, SW_REV *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_SW_REV, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_sw_rev( p );

  return rc;

}  // mbgextio_get_sw_rev



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ignore_lock( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, IGNORE_LOCK *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_IGNORE_LOCK, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab16( p );

  return rc;

}  // mbgextio_get_ignore_lock



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ignore_lock( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const IGNORE_LOCK *p )
{
  GPS_CMD cmd = GPS_IGNORE_LOCK | OPT_GPS_ACK_CODE;
  IGNORE_LOCK *p_data = &pmctl->xmt.pmb->u.msg_data.ignore_lock;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab16( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ignore_lock



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_bvar_stat( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, BVAR_STAT *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_BVAR_STAT, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_bvar_stat( p );

  return rc;

}  // mbgextio_get_bvar_stat



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_time( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, TTM *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_TIME, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ttm( p );

  return rc;

}  // mbgextio_get_time



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_time( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, const TTM *p )
{
  GPS_CMD cmd = GPS_TIME | OPT_GPS_ACK_CODE;
  TTM *p_data = &pmctl->xmt.pmb->u.msg_data.ttm;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ttm( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_time



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_pos_lla( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, const LLA lla )
{
  GPS_CMD cmd = GPS_POS_LLA | OPT_GPS_ACK_CODE;
  double *p_lla = pmctl->xmt.pmb->u.msg_data.lla;
  int i, rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  for ( i = 0; i < N_LLA; i++ )
  {
    p_lla[i] = lla[i];
    swap_double( &p_lla[i] );
    _mbg_swab_double( &p_lla[i] );
  }

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( LLA ) );
  return rc;

}  // mbgextio_set_pos_lla



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_pos_lla( MBG_MSG_CTL *pmctl,
                                                const XBP_ADDR *p_addr, LLA lla )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_POS_LLA, lla, sizeof( LLA ) );

  if ( mbg_rc_is_success( rc ) && lla )
  {
    int i;

    for ( i = 0; i < N_LLA; i++ )
      swap_double( &lla[i] );
  }

  return rc;

}  // mbgextio_get_pos_lla



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_pos_xyz( MBG_MSG_CTL *pmctl,
                                                 const XBP_ADDR *p_addr, XYZ xyz )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_POS_XYZ, xyz, sizeof( XYZ ) );

  if ( mbg_rc_is_success( rc ) && xyz )
  {
    int i;

    for ( i = 0; i < N_XYZ; i++ )
      swap_double( &xyz[i] );
  }

  return rc;

}  // mbgextio_get_pos_xyz



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_pos( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, POS *p_pos )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_get_pos_xyz( pmctl, p_addr, p_pos->xyz );

  if ( mbg_rc_is_error( rc ) )
    goto out;

  rc = mbgextio_get_pos_lla( pmctl, p_addr, p_pos->lla );

  if ( mbg_rc_is_error( rc ) )
    goto out;

  lla_to_dms( p_pos );

out:
  return rc;

}  // mbgextio_get_pos



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_tzdl( MBG_MSG_CTL *pmctl,
                                                const XBP_ADDR *p_addr, TZDL *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_TZDL, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_tzdl( p );

  return rc;

}  // mbgextio_get_tzdl



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_tzdl( MBG_MSG_CTL *pmctl,
                                       const XBP_ADDR *p_addr, const TZDL *p )
{
  GPS_CMD cmd = GPS_TZDL | OPT_GPS_ACK_CODE;
  TZDL *p_data = &pmctl->xmt.pmb->u.msg_data.tzdl;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_tzdl( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_tzdl



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_port_parm( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, PORT_PARM *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_PORT_PARM, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_port_parm( p );

  return rc;

}  // mbgextio_get_port_parm



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_port_parm( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, const PORT_PARM *p )
{
  GPS_CMD cmd = GPS_PORT_PARM | OPT_GPS_ACK_CODE;
  PORT_PARM *p_data = &pmctl->xmt.pmb->u.msg_data.port_parm;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_port_parm( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_port_parm



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_synth( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, SYNTH *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_SYNTH, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_synth( p );

  return rc;

}  // mbgextio_get_synth



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_synth( MBG_MSG_CTL *pmctl,
                                       const XBP_ADDR *p_addr, const SYNTH *p )
{
  GPS_CMD cmd = GPS_SYNTH | OPT_GPS_ACK_CODE;
  SYNTH *p_data = &pmctl->xmt.pmb->u.msg_data.synth;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_synth( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_synth



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ant_info( MBG_MSG_CTL *pmctl,
                                            const XBP_ADDR *p_addr, ANT_INFO *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_ANT_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ant_info( p );

  return rc;

}  // mbgextio_get_ant_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ucap( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, TTM *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = xmt_cmd( pmctl, p_addr, GPS_UCAP );   /* request a set of data */

  if ( mbg_rc_is_error( rc ) )
    goto out;

  // Attention: Older firmware versions may reply with GPS_TIME
  // messages instead of GPS_UCAP messages, and may not send a reply
  // at all if no capture event is available in the on-board FIFO.
  for (;;)
  {
    rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, -1, NULL, 0 );

    if ( mbg_rc_is_error( rc ) )
      goto out;

    if ( pmctl->rcv.pmb->hdr.cmd == GPS_UCAP )
      break;

    if ( pmctl->rcv.pmb->hdr.cmd == GPS_TIME )
      if ( pmctl->rcv.pmb->hdr.len > 0 )
        if ( pmctl->rcv.pmb->u.msg_data.ttm.channel >= 0 )
          break;

    if ( pmctl->async_msg_handler_fnc )
      pmctl->async_msg_handler_fnc( pmctl );
  }

  if ( p )
  {
    // If the length of the msg header is 0 then the capture buffer
    // is empty. This is indicated with 0xFF in the seconds field of
    // the GPS time structure.
    if ( pmctl->rcv.pmb->hdr.len > 0 )
    {
      *p = pmctl->rcv.pmb->u.msg_data.ttm;
      _mbg_swab_ttm( p );
    }
    else
      _ttm_time_set_unavail( p );  // no capture event available
  }

out:
  return rc;

}  // mbgextio_get_ucap



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ucap_net_glb_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                              MBG_UCAP_NET_GLB_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_UCAP_NET_GLB_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ucap_net_glb_info( p );

  return rc;

} // mbgextio_get_ucap_net_glb_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ucap_net_glb_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                  const MBG_UCAP_NET_GLB_SETTINGS *p )
{
  GPS_CMD cmd = GPS_UCAP_NET_GLB_INFO | OPT_GPS_ACK_CODE;
  MBG_UCAP_NET_GLB_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.ucap_net_glb_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ucap_net_glb_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ucap_net_glb_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ucap_net_recv_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_UCAP_NET_RECV_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_UCAP_NET_RECV_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ucap_net_recv_info_idx( p );

  return rc;

} // mbgextio_get_ucap_net_recv_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ucap_net_recv_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                       const MBG_UCAP_NET_RECV_SETTINGS_IDX *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_UCAP_NET_RECV_INFO_IDX | OPT_GPS_ACK_CODE;
  MBG_UCAP_NET_RECV_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ucap_net_recv_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  p_data->idx = idx;
  _mbg_swab_ucap_net_recv_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ucap_net_recv_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_user_mngmnt_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                             MBG_USER_MNGMNT_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_USERS, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_USER_MNGMNT_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_user_mngmnt_info( p );

  return rc;

} // mbgextio_get_user_mngmnt_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_user_mngmnt_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                 const MBG_USER_MNGMNT_SETTINGS *p )
{
  GPS_CMD cmd = GPS_USER_MNGMNT_INFO | OPT_GPS_ACK_CODE;
  MBG_USER_MNGMNT_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.user_mngmnt_settings;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_USERS, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_user_mngmnt_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_user_mngmnt_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_user_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                          MBG_USER_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_USERS, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_USER_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_user_info_idx( p );

  return rc;

} // mbgextio_get_user_info_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_user_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                              const MBG_USER_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_USER_INFO_IDX | OPT_GPS_ACK_CODE;
  MBG_USER_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.user_settings_idx;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_USERS, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_user_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_user_settings_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_user_level_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                MBG_USER_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_USERS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_USER_LEVEL_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_user_info_idx( p );

  return rc;

} // mbgextio_get_user_level_info_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_user_level_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                    const MBG_USER_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_USER_LEVEL_INFO_IDX | OPT_GPS_ACK_CODE;
  MBG_USER_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.user_settings_idx;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_USERS, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_user_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_user_level_settings_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_user_status_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                            MBG_USER_STATUS_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_USERS, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_USER_STATUS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_user_status_idx( p );

  return rc;

} // mbgextio_get_user_status_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_enable_flags( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, ENABLE_FLAGS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_ENABLE_FLAGS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_enable_flags( p );

  return rc;

}  // mbgextio_get_enable_flags



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_enable_flags( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, const ENABLE_FLAGS *p )
{
  GPS_CMD cmd = GPS_ENABLE_FLAGS | OPT_GPS_ACK_CODE;
  ENABLE_FLAGS *p_data = &pmctl->xmt.pmb->u.msg_data.enable_flags;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_enable_flags( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_enable_flags



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_gps_stat_info( MBG_MSG_CTL *pmctl,
                                              const XBP_ADDR *p_addr, STAT_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_STAT_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_stat_info( p );

  return rc;

}  // mbgextio_get_gps_stat_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ant_cable_len( MBG_MSG_CTL *pmctl,
                                              const XBP_ADDR *p_addr, ANT_CABLE_LEN *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_ANT_CABLE_LENGTH, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ant_cable_len( p );

  return rc;

}  // mbgextio_get_ant_cable_len



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ant_cable_len( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, const ANT_CABLE_LEN *p )
{
  GPS_CMD cmd = GPS_ANT_CABLE_LENGTH | OPT_GPS_ACK_CODE;
  ANT_CABLE_LEN *p_data = &pmctl->xmt.pmb->u.msg_data.ant_cable_len;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ant_cable_len( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ant_cable_len



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_irig_tx_info( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, IRIG_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_IRIG_TX_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_irig_info( p );

  return rc;

}  // mbgextio_get_irig_tx_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_irig_tx_settings( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, const IRIG_SETTINGS *p )
{
  GPS_CMD cmd = GPS_IRIG_TX_SETTINGS | OPT_GPS_ACK_CODE;
  IRIG_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.irig_tx_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_irig_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_irig_tx_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_irig_rx_info( MBG_MSG_CTL *pmctl,
                                                 const XBP_ADDR *p_addr, IRIG_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_IRIG_RX_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_irig_info( p );

  return rc;

}  // mbgextio_get_irig_rx_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_irig_rx_settings( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, const IRIG_SETTINGS *p )
{
  GPS_CMD cmd = GPS_IRIG_RX_SETTINGS | OPT_GPS_ACK_CODE;
  IRIG_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.irig_rx_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_irig_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_irig_rx_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_raw_irig_data( MBG_MSG_CTL *pmctl,
                                                 const XBP_ADDR *p_addr, MBG_RAW_IRIG_DATA *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_RAW_IRIG_DATA, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_raw_irig_data( p );

  return rc;

}  // mbgextio_get_raw_irig_data



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ref_offs( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, MBG_REF_OFFS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_REF_OFFS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ref_offs( p );

  return rc;

}  // mbgextio_get_ref_offs



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ref_offs( MBG_MSG_CTL *pmctl,
                                    const XBP_ADDR *p_addr, const MBG_REF_OFFS *p )
{
  GPS_CMD cmd = GPS_REF_OFFS | OPT_GPS_ACK_CODE;
  MBG_REF_OFFS *p_data = &pmctl->xmt.pmb->u.msg_data.ref_offs;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_mbg_ref_offs( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ref_offs



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_debug_status( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, MBG_DEBUG_STATUS *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_DEBUG_STATUS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_debug_status( p );

  return rc;

}  // mbgextio_get_debug_status



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_opt_info( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, MBG_OPT_INFO *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_OPT_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_opt_info( p );

  return rc;

}  // mbgextio_get_opt_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_opt_settings( MBG_MSG_CTL *pmctl,
                                   const XBP_ADDR *p_addr, const MBG_OPT_SETTINGS *p )
{
  GPS_CMD cmd = GPS_OPT_SETTINGS | OPT_GPS_ACK_CODE;
  MBG_OPT_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.opt_settings;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_mbg_opt_settings( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_opt_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_str_type_info_idx( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, STR_TYPE_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERIAL, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_STR_TYPE_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
  {
    _mbg_swab_str_type_info_idx( p );

  #if 0  //##++ TODO: check if received idx matches requested idx
    if ( pii.idx != i )
    {
      printf( "** Info for port %i requested, but for %i received.\n",
              pii.idx, i );
      rc = ...;
    }
  #endif
  }

  return rc;

}  // mbgextio_get_str_type_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_all_str_type_info( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, STR_TYPE_INFO_IDX stii[] )
{
  RECEIVER_INFO *p_ri = mbgextio_get_receiver_info_addr( pmctl );
  int n_str_type = p_ri->n_str_type;
  uint16_t i;

  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERIAL, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  for ( i = 0; i < n_str_type; i++ )
  {
    rc = mbgextio_get_str_type_info_idx( pmctl, p_addr, &stii[i], i );

    if ( mbg_rc_is_error( rc ) )
      break;
  }

  return rc;

}  // mbgextio_get_all_str_type_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_port_info_idx( MBG_MSG_CTL *pmctl,
                                  const XBP_ADDR *p_addr, PORT_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERIAL, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_PORT_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
  {
    _mbg_swab_port_info_idx( p );

  #if 0  //##++ TODO: check if received idx matches requested idx
    if ( pii.idx != i )
    {
      printf( "** Info for port %i requested, but for %i received.\n",
              pii.idx, i );
      rc = ...;
    }
  #endif
  }

  return rc;

}  // mbgextio_get_port_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_all_port_info( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, PORT_INFO_IDX pii[] )
{
  RECEIVER_INFO *p_ri = mbgextio_get_receiver_info_addr( pmctl );
  int n_com_ports = p_ri->n_com_ports;
  uint16_t i;

  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERIAL, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  for ( i = 0; i < n_com_ports; i++ )
  {
    rc = mbgextio_get_port_info_idx( pmctl, p_addr, &pii[i], i );

    if ( mbg_rc_is_error( rc ) )
      break;
  }

  return rc;

}  // mbgextio_get_all_port_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_port_settings_idx( MBG_MSG_CTL *pmctl,
                             const XBP_ADDR *p_addr, const PORT_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_PORT_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  PORT_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.port_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERIAL, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->port_settings = *p;
  p_data->idx = idx;
  _mbg_swab_port_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_port_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_pout_info_idx( MBG_MSG_CTL *pmctl,
                                const XBP_ADDR *p_addr, POUT_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_POUT_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
  {
    _mbg_swab_pout_info_idx_on_get( p );

  #if 0  //##++ TODO: check if received idx matches requested idx
    if ( pii.idx != i )
    {
      printf( "** Info for port %i requested, but for %i received.\n",
              pii.idx, i );
      rc = ...;
    }
  #endif
  }

  return rc;

}  // mbgextio_get_pout_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_all_pout_info( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, POUT_INFO_IDX *pii )
{
  RECEIVER_INFO *p_ri = mbgextio_get_receiver_info_addr( pmctl );
  int n_prg_out = p_ri->n_prg_out;
  uint16_t i;

  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  memset( pii, 0, n_prg_out * sizeof( *pii ) );

  for ( i = 0; i < n_prg_out; i++ )
  {
    rc = mbgextio_get_pout_info_idx( pmctl, p_addr, &pii[i], i );

    if ( mbg_rc_is_error( rc ) )
      break;
  }

  return rc;

}  // mbgextio_get_all_pout_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_pout_settings_idx( MBG_MSG_CTL *pmctl,
                             const XBP_ADDR *p_addr, const POUT_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_POUT_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  POUT_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.pout_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->pout_settings = *p;
  p_data->idx = idx;
  _mbg_swab_pout_settings_idx_on_set( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_pout_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_gpio_settings_idx( MBG_MSG_CTL *pmctl,
                             const XBP_ADDR *p_addr, const MBG_GPIO_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_GPIO_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  MBG_GPIO_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.gpio_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;

  _mbg_swab_mbg_gpio_settings_idx( p_data, 0 );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_gpio_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_clr_ucap_buff( MBG_MSG_CTL *pmctl,
                                                      const XBP_ADDR *p_addr )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_IOPORTS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_xmt_cmd( pmctl, p_addr, GPS_CLR_UCAP_BUFF );
  return rc;

}  // mbgextio_clr_ucap_buff



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_time_scale_info( MBG_MSG_CTL *pmctl,
                                            const XBP_ADDR *p_addr, MBG_TIME_SCALE_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_TIME_SCALE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_time_scale_info( p );

  return rc;

}  // mbgextio_get_time_scale_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_time_scale_settings( MBG_MSG_CTL *pmctl,
                             const XBP_ADDR *p_addr, const MBG_TIME_SCALE_SETTINGS *p )
{
  GPS_CMD cmd = GPS_TIME_SCALE | OPT_GPS_ACK_CODE;
  MBG_TIME_SCALE_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.time_scale_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_mbg_time_scale_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_time_scale_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_clr_evt_log( MBG_MSG_CTL *pmctl,
                                                    const XBP_ADDR *p_addr )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_xmt_cmd( pmctl, p_addr, GPS_CLR_EVT_LOG );
  return rc;

}  // mbgextio_clr_evt_log



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_num_evt_log_entries( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, MBG_NUM_EVT_LOG_ENTRIES *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NUM_EVT_LOG_ENTRIES, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_num_evt_log_entries( p );

  return rc;

}  // mbgextio_get_num_evt_log_entries



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_first_evt_log_entry( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, MBG_EVT_LOG_ENTRY *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_FIRST_EVT_LOG_ENTRY, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_evt_log_entry( p );

  return rc;

}  // mbgextio_get_first_evt_log_entry



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_next_evt_log_entry( MBG_MSG_CTL *pmctl,
                                                const XBP_ADDR *p_addr, MBG_EVT_LOG_ENTRY *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NEXT_EVT_LOG_ENTRY, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_evt_log_entry( p );

  return rc;

}  // mbgextio_get_next_evt_log_entry



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ims_state( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, MBG_IMS_STATE *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SENSORS, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_IMS_STATE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ims_state( p );

  return rc;

}  // mbgextio_get_ims_state



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ims_sensor_state_idx( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, MBG_IMS_SENSOR_STATE_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SENSORS, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_IMS_SENSOR_STATE_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ims_sensor_state_idx( p );

  return rc;

}  // mbgextio_get_ims_sensor_state_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_holdover_interval( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, const XMR_HOLDOVER_INTV *p )
{
  GPS_CMD cmd = GPS_XMR_HOLDOVER_INTV | OPT_GPS_ACK_CODE;
  XMR_HOLDOVER_INTV *p_data = &pmctl->xmt.pmb->u.msg_data.xmr_holdover_intv;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_xmr_holdover_intv( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_holdover_interval



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_holdover_interval_counter( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, XMR_HOLDOVER_INTV *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_XMR_HOLDOVER_INTV, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_xmr_holdover_intv( p );

  return rc;

}  // mbgextio_get_holdover_interval_counter



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmulti_ref_info_idx( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, XMULTI_REF_INFO_IDX *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_MULTI_REF_INFO, p, sizeof( *p ) );

  if ( ( rc == MBG_SUCCESS ) && p )
    *p = pmctl->rcv.pmb->u.msg_data.xmulti_ref_info_idx;

  return rc;

}  // mbgextio_get_xmulti_ref_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_tzcode( MBG_MSG_CTL *pmctl,
                                              const XBP_ADDR *p_addr, TZCODE *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, PZF_TZCODE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_tzcode( p );

  return rc;

}  // mbgextio_get_tzcode



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_tzcode( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, const TZCODE *p )
{
  GPS_CMD cmd = PZF_TZCODE | OPT_GPS_ACK_CODE;
  TZCODE *p_data = &pmctl->xmt.pmb->u.msg_data.tzcode;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_tzcode( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_tzcode



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_hq_tx_settings( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, const HAVEQUICK_SETTINGS *p )
{
  GPS_CMD cmd = GPS_HAVEQUICK_TX_SETTINGS | OPT_GPS_ACK_CODE;
  HAVEQUICK_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.havequick_settings;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_havequick_settings( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_hq_tx_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_hq_rx_settings( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, const HAVEQUICK_SETTINGS *p )
{
  GPS_CMD cmd = GPS_HAVEQUICK_RX_SETTINGS | OPT_GPS_ACK_CODE;
  HAVEQUICK_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.havequick_settings;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_havequick_settings( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_hq_rx_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_tr_distance( MBG_MSG_CTL *pmctl,
                                            const XBP_ADDR *p_addr, TR_DISTANCE *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, PZF_TR_DISTANCE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_tr_distance( p );

  return rc;

}  // mbgextio_get_tr_distance



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_tr_distance( MBG_MSG_CTL *pmctl,
                                      const XBP_ADDR *p_addr, const TR_DISTANCE *p )
{
  GPS_CMD cmd = PZF_TR_DISTANCE | OPT_GPS_ACK_CODE;
  TR_DISTANCE *p_data = &pmctl->xmt.pmb->u.msg_data.tr_distance;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_tr_distance( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_tr_distance



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_gnss_mode_info( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, MBG_GNSS_MODE_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_GNSS_MODE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_gnss_mode_info( p );

  return rc;

}  // mbgextio_get_gnss_mode_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_gnss_mode_settings( MBG_MSG_CTL *pmctl,
                                    const XBP_ADDR *p_addr, const MBG_GNSS_MODE_SETTINGS *p )
{
  GPS_CMD cmd = GPS_GNSS_MODE | OPT_GPS_ACK_CODE;
  MBG_GNSS_MODE_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.gnss_mode_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_mbg_gnss_mode_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_gnss_mode_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_gnss_sat_info( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, GNSS_SAT_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_GNSS_SAT_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_gnss_sat_info( p );

  return rc;

}  // mbgextio_get_gnss_sat_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_gnss_sat_info_idx( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, GNSS_SAT_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_GNSS_SAT_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
  {
    _mbg_swab_gnss_sat_info_idx( p );

  #if 0  //##++ TODO: check if received idx matches requested idx
    if ( pii.idx != i )
    {
      printf( "** Info for port %i requested, but for %i received.\n",
              pii.idx, i );
      rc = ...;
    }
  #endif
  }

  return rc;

}  // mbgextio_get_gnss_sat_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_all_gnss_sat_info( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, GNSS_SAT_INFO_IDX gsii[],
                              const MBG_GNSS_MODE_INFO *p_mi )
{
  int rc = MBG_SUCCESS;
  int n_supp = num_bits_set( p_mi->supp_gnss_types );
  uint16_t i;

  for ( i = 0; i < n_supp; i++ )
  {
    rc = mbgextio_get_gnss_sat_info_idx( pmctl, p_addr, &gsii[i], i );

    if ( mbg_rc_is_error( rc ) )
      break;
  }

  return rc;

}  // mbgextio_get_all_gnss_sat_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_gnss_sv_status_idx( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, GNSS_SV_STATUS_IDX *p, uint16_t idx )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_GNSS_SV_STATUS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
  {
    _mbg_swab_gnss_sv_status_idx( p );

  #if 0  //##++ TODO: check if received idx matches requested idx
    if ( pii.idx != i )
    {
      printf( "** Info for port %i requested, but for %i received.\n",
              pii.idx, i );
      rc = ...;
    }
  #endif
  }

  return rc;

}  // mbgextio_get_gnss_sv_status_idx



#if 0  

 /*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_all_gnss_sat_info( MBG_MSG_CTL *pmctl,
                              const XBP_ADDR *p_addr, GNSS_SAT_INFO_IDX gsii[],
                              const MBG_GNSS_MODE_INFO *p_mi )
{
  int rc = MBG_SUCCESS;
  int n_supp = num_bits_set( p_mi->supp_gnss_types );
  uint16_t i;

  for ( i = 0; i < n_supp; i++ )
  {
    rc = mbgextio_get_gnss_sat_info_idx( pmctl, p_addr, &gsii[i], i );

    if ( mbg_rc_is_error( rc ) )
      break;
  }

  return rc;

}  // mbgextio_get_all_gnss_sat_info

#endif


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmr_instances( MBG_MSG_CTL *pmctl,
                                                          const XBP_ADDR *p_addr,
                                                          XMULTI_REF_INSTANCES *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_XMR_INSTANCES, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
    _mbg_swab_xmulti_ref_instances( p );

  return rc;

}  // mbgextio_get_xmr_instances



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmr_ext_src_info_idx( MBG_MSG_CTL *pmctl,
                                                                 const XBP_ADDR *p_addr,
                                                                 XMR_EXT_SRC_INFO_IDX *p,
                                                                 uint16_t idx)
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  p->idx = idx;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_XMR_EXT_SRC_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
    _mbg_swab_xmr_ext_src_info_idx( p );

  return rc;

}  // mbgextio_get_xmr_ext_src_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmr_holdover_status( MBG_MSG_CTL *pmctl,
                                                                const XBP_ADDR *p_addr,
                                                                XMR_HOLDOVER_STATUS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_XMR_HOLDOVER_STATUS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
    _mbg_swab_xmr_holdover_status( p );

  return rc;

}  // mbgextio_get_xmr_holdover_status



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmr_info_idx( MBG_MSG_CTL *pmctl,
                                                         const XBP_ADDR *p_addr,
                                                         XMULTI_REF_INFO_IDX *p,
                                                         uint16_t idx)
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  p->idx = idx;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_XMR_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
    _mbg_swab_xmulti_ref_info_idx( p );

  return rc;

}  // mbgextio_get_xmr_info_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmr_status_idx( MBG_MSG_CTL *pmctl,
                                                          const XBP_ADDR *p_addr,
                                                          XMULTI_REF_STATUS_IDX *p,
                                                          uint16_t idx)
{
  int rc = MBG_ERR_UNSPEC;
  GPS_CMD cmd = GPS_XMR_STATUS_IDX;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  //### TODO FIXME  rc = mbgextio_req_data_idx_unlocked( pmctl, p_addr, GPS_XMR_STATUS_IDX, idx, p, sizeof( *p ) );

  rc = xmt_cmd_us( pmctl, p_addr, cmd, idx );                 // request data

  if ( mbg_rc_is_error( rc ) )
    goto out_release;

  for (;;)
  {
    rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, cmd, p, sizeof( *p ) );   // wait for the reply

    if ( mbg_rc_is_error( rc ) )
      break;

    _mbg_swab_xmulti_ref_status_idx( p );

    if ( p->idx == idx )
      break;

    #if defined( DEBUG )
      fprintf( stderr, "GPS_XMR_STATUS_IDX received reply idx %u, expected %u\n", idx, p->idx );
    #endif
  }

out_release:

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  return rc;

}  // mbgextio_get_xmr_status_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmr_ext_source_stats_idx( MBG_MSG_CTL *pmctl,
                                                                     const XBP_ADDR *p_addr,
                                                                     XMR_STATS_IDX *p,
                                                                     uint16_t idx)
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  p->idx = idx;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_XMR_STATS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
    _mbg_swab_xmr_stats_idx( p );

  return rc;

}  // mbgextio_get_xmr_ext_source_stats_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xmr_ext_source_metrics_idx( MBG_MSG_CTL *pmctl,
                                                                       const XBP_ADDR *p_addr,
                                                                       XMR_METRICS_IDX *p,
                                                                       uint16_t idx)
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  p->idx = idx;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_XMR_METRICS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) )
    _mbg_swab_xmr_metrics_idx( p );

  return rc;

}  // mbgextio_get_xmr_ext_source_metrics_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_xmr_settings_idx( MBG_MSG_CTL *pmctl,
                                                             const XBP_ADDR *p_addr,
                                                             const XMULTI_REF_SETTINGS *p,
                                                             uint16_t idx)
{
  GPS_CMD cmd = GPS_XMR_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  XMULTI_REF_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.xmulti_ref_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MRS, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_xmulti_ref_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_xmr_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_lan_if_info( MBG_MSG_CTL *pmctl,
                                                  const XBP_ADDR *p_addr, LAN_IF_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_LAN_IF_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_lan_if_info( p );

  return rc;

}  // mbgextio_get_lan_if_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ip4_settings( MBG_MSG_CTL *pmctl,
                                                 const XBP_ADDR *p_addr, IP4_SETTINGS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_IP4_SETTINGS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ip4_settings( p );

  return rc;

}  // mbgextio_get_ip4_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ip4_settings( MBG_MSG_CTL *pmctl,
                                           const XBP_ADDR *p_addr, const IP4_SETTINGS *p )
{
  GPS_CMD cmd = GPS_IP4_SETTINGS | OPT_GPS_ACK_CODE;
  IP4_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.ip4_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ip4_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ip4_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ip4_state( MBG_MSG_CTL *pmctl,
                                              const XBP_ADDR *p_addr, IP4_SETTINGS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_IP4_STATE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ip4_settings( p );

  return rc;

}  // mbgextio_get_ip4_state



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_state( MBG_MSG_CTL *pmctl,
                                                      const XBP_ADDR *p_addr, PTP_STATE *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_STATE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_state( p );

  return rc;

}  // mbgextio_get_ptp_state



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_cfg_info( MBG_MSG_CTL *pmctl,
                                              const XBP_ADDR *p_addr, PTP_CFG_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_CFG, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_cfg_info( p );

  return rc;

}  // mbgextio_get_ptp_cfg_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_uc_master_cfg_limits( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, PTP_UC_MASTER_CFG_LIMITS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_UC_MASTER_CFG_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_uc_master_cfg_limits( p );

  return rc;

}  // mbgextio_get_ptp_uc_master_cfg_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_all_ptp_uc_master_info( MBG_MSG_CTL *pmctl,
                        const XBP_ADDR *p_addr, PTP_UC_MASTER_INFO_IDX *ptp_uc_master_info_idx,
                        const PTP_UC_MASTER_CFG_LIMITS *ptp_uc_master_cfg_limits )
{
  uint16_t i;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  for ( i = 0; i < ptp_uc_master_cfg_limits->n_supp_master; i++ )
  {
    xmt_cmd_us( pmctl, p_addr, GPS_PTP_UC_MASTER_CFG, i );

    rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, GPS_PTP_UC_MASTER_CFG, NULL, 0 );   //### TODO

    if ( mbg_rc_is_success( rc ) && ptp_uc_master_info_idx )
    {
      PTP_UC_MASTER_INFO_IDX *p = &ptp_uc_master_info_idx[i];
      *p = pmctl->rcv.pmb->u.msg_data.ptp_uc_master_info_idx;
      _mbg_swab_ptp_uc_master_info_idx( p );
    }
    else
      break;
  }

  return rc;

}  // mbgextio_get_all_ptp_uc_master_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_cfg_settings( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, const PTP_CFG_SETTINGS *p )
{
  GPS_CMD cmd = GPS_PTP_CFG | OPT_GPS_ACK_CODE;
  PTP_CFG_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_cfg_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_cfg_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_cfg_settings


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_uc_master_settings_idx( MBG_MSG_CTL *pmctl,
                                     const XBP_ADDR *p_addr, const PTP_UC_MASTER_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_PTP_UC_MASTER_CFG | OPT_GPS_ACK_CODE;
  PTP_UC_MASTER_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_uc_master_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_ptp_uc_master_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_uc_master_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v1_default_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_PTP_V1_DEFAULT_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V1_DEFAULT_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v1_default_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v1_default_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v1_default_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   const MBG_PTP_V1_DEFAULT_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V1_DEFAULT_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V1_DEFAULT_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v1_default_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v1_default_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v1_default_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v1_current_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_PTP_V1_CURRENT_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V1_CURRENT_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v1_current_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v1_current_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v1_current_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   const MBG_PTP_V1_CURRENT_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V1_CURRENT_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V1_CURRENT_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v1_current_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v1_current_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v1_current_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v1_parent_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                  MBG_PTP_V1_PARENT_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V1_PARENT_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v1_parent_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v1_parent_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v1_parent_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   const MBG_PTP_V1_PARENT_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V1_PARENT_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V1_PARENT_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v1_parent_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v1_parent_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v1_parent_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v1_time_properties_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                           MBG_PTP_V1_TIME_PROPERTIES_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V1_TIME_PROP_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v1_time_properties_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v1_time_properties_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v1_time_properties_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                           const MBG_PTP_V1_TIME_PROPERTIES_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V1_TIME_PROP_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V1_TIME_PROPERTIES_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v1_time_properties_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v1_time_properties_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v1_time_properties_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v1_port_dataset_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                    MBG_PTP_V1_PORT_DATASET_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_PTP_V1_PORT_DS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v1_port_dataset_idx( p );

  return rc;

}  // mbgextio_get_ptp_v1_port_dataset_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v1_port_dataset_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                    const MBG_PTP_V1_PORT_DATASET *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_PTP_V1_PORT_DS_IDX | OPT_GPS_ACK_CODE;
  MBG_PTP_V1_PORT_DATASET_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v1_port_dataset_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->port_dataset = *p;
  p_data->idx = idx;
  _mbg_swab_ptp_v1_port_dataset_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v1_port_dataset_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v2_default_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_PTP_V2_DEFAULT_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V2_DEFAULT_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v2_default_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v2_default_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v2_default_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   const MBG_PTP_V2_DEFAULT_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V2_DEFAULT_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V2_DEFAULT_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v2_default_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v2_default_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v2_default_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v2_current_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_PTP_V2_CURRENT_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V2_CURRENT_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v2_current_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v2_current_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v2_current_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   const MBG_PTP_V2_CURRENT_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V2_CURRENT_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V2_CURRENT_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v2_current_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v2_current_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v2_current_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v2_parent_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                  MBG_PTP_V2_PARENT_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V2_PARENT_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v2_parent_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v2_parent_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v2_parent_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   const MBG_PTP_V2_PARENT_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V2_PARENT_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V2_PARENT_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v2_parent_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v2_parent_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v2_parent_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v2_time_properties_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                           MBG_PTP_V2_TIME_PROPERTIES_DATASET *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_V2_TIME_PROP_DS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v2_time_properties_dataset( p );

  return rc;

}  // mbgextio_get_ptp_v2_time_properties_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v2_time_properties_dataset( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                           const MBG_PTP_V2_TIME_PROPERTIES_DATASET *p )
{
  GPS_CMD cmd = GPS_PTP_V2_TIME_PROP_DS | OPT_GPS_ACK_CODE;
  MBG_PTP_V2_TIME_PROPERTIES_DATASET *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v2_time_properties_dataset;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ptp_v2_time_properties_dataset( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v2_time_properties_dataset



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_v2_port_dataset_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                    MBG_PTP_V2_PORT_DATASET_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_PTP_V2_PORT_DS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ptp_v2_port_dataset_idx( p );

  return rc;

}  // mbgextio_get_ptp_v2_port_dataset_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ptp_v2_port_dataset_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                    const MBG_PTP_V2_PORT_DATASET *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_PTP_V2_PORT_DS_IDX | OPT_GPS_ACK_CODE;
  MBG_PTP_V2_PORT_DATASET_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ptp_v2_port_dataset_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_PTP, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->port_dataset = *p;
  p_data->idx = idx;
  _mbg_swab_ptp_v2_port_dataset_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ptp_v2_port_dataset_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ptp_smpte_tlv_state( MBG_MSG_CTL *pmctl,
                                                      const XBP_ADDR *p_addr, PTP_SMPTE_PROFILE_CFG *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_PTP_SMPTE_TLV, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_dummy( p );

  return rc;

}  // mbgextio_get_ptp_smpte_tlv_state



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_monitoring_limits( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                              MBG_MONITORING_LIMITS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_MONITORING_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_monitoring_limits( p );

  return rc;

}  // mbgextio_get_monitoring_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_snmp_glb_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                          MBG_SNMP_GLB_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_SNMP_GLB, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_snmp_glb_info( p );

  return rc;

}  // mbgextio_get_snmp_glb_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_snmp_glb_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                              const MBG_SNMP_GLB_SETTINGS *p )
{
  GPS_CMD cmd = GPS_SNMP_GLB | OPT_GPS_ACK_CODE;
  MBG_SNMP_GLB_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.snmp_glb_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_snmp_glb_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_snmp_glb_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_snmp_v12_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                              MBG_SNMP_V12_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx(pmctl, p_addr, GPS_SNMP_V12_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_snmp_v12_info_idx( p );

  return rc;

}  // mbgextio_get_snmp_v12_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_snmp_v12_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                  const MBG_SNMP_V12_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_SNMP_V12_IDX | OPT_GPS_ACK_CODE;
  MBG_SNMP_V12_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.snmp_v12_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_snmp_v12_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_snmp_v12_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_snmp_v12_trap_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_SNMP_V12_TRAP_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx(pmctl, p_addr, GPS_SNMP_V12_TRAP_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_snmp_v12_trap_info_idx( p );

  return rc;

}  // mbgextio_get_snmp_v12_trap_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_snmp_v12_trap_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                       const MBG_SNMP_V12_TRAP_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_SNMP_V12_TRAP_IDX | OPT_GPS_ACK_CODE;
  MBG_SNMP_V12_TRAP_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.snmp_v12_trap_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_snmp_v12_trap_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_snmp_v12_trap_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_snmp_v3_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                             MBG_SNMP_V3_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx(pmctl, p_addr, GPS_SNMP_V3_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_snmp_v3_info_idx( p );

  return rc;

}  // mbgextio_get_snmp_v3_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_snmp_v3_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                 const MBG_SNMP_V3_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_SNMP_V3_IDX | OPT_GPS_ACK_CODE;
  MBG_SNMP_V3_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.snmp_v3_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_snmp_v3_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_snmp_v3_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_snmp_v3_trap_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                  MBG_SNMP_V3_TRAP_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx(pmctl, p_addr, GPS_SNMP_V3_TRAP_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_snmp_v3_trap_info_idx( p );

  return rc;

}  // mbgextio_get_snmp_v3_trap_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_snmp_v3_trap_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                      const MBG_SNMP_V3_TRAP_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_SNMP_V3_TRAP_IDX | OPT_GPS_ACK_CODE;
  MBG_SNMP_V3_TRAP_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.snmp_v3_trap_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_snmp_v3_trap_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_snmp_v3_trap_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_event_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                           MBG_EVENT_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx(pmctl, p_addr, GPS_EVENT_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_event_info_idx( p );

  return rc;

}  // mbgextio_get_event_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_event_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                               const MBG_EVENT_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_EVENT_IDX | OPT_GPS_ACK_CODE;
  MBG_EVENT_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.event_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_event_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_event_settings_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_event_status_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                             uint8_t vtype, MBG_EVENT_STATUS_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx(pmctl, p_addr, GPS_EVENT_STAT_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_event_status_idx( p, vtype );

  return rc;

}  // mbgextio_get_event_status_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_event_value_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                            uint16_t eidx, uint8_t vtype,
                                                            MBG_EVENT_VALUE_IDX *p, uint16_t vidx )
{
  uint32_t idx = ((eidx << 16) | vidx);
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  rc = xmt_cmd_u32( pmctl, p_addr, GPS_EVENT_VALUE_IDX, idx );
  if ( mbg_rc_is_success( rc ) )
    rc = mbgextio_rcv_msg_unlocked( pmctl, p_addr, GPS_EVENT_VALUE_IDX, p, sizeof( *p ));

  #if _USE_MUTEX
    _mbg_mutex_release( &pmctl->dev_mutex );
  #endif

  if ( mbg_rc_is_error( rc ) )
    return rc;

  _mbg_swab_event_value_idx( p, vtype );

  return MBG_SUCCESS;

}  // mbgextio_get_event_value_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_syslog_glb_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                            MBG_SYSLOG_GLB_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_SYSLOG_GLB_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_syslog_glb_info( p );

  return rc;

}  // mbgextio_get_syslog_glb_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_syslog_glb_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                const MBG_SYSLOG_GLB_SETTINGS *p )
{
  GPS_CMD cmd = GPS_SYSLOG_GLB_INFO | OPT_GPS_ACK_CODE;
  MBG_SYSLOG_GLB_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.syslog_glb_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_syslog_glb_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

  return rc;

}  // mbgextio_set_syslog_glb_settings


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_syslog_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                            MBG_SYSLOG_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_SYSLOG_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_syslog_info_idx( p );

  return rc;

}  // mbgextio_get_syslog_info_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_syslog_settings_idx( MBG_MSG_CTL *pmctl,
                                                                const XBP_ADDR *p_addr,
                                                                const MBG_SYSLOG_SETTINGS *p,
                                                                uint16_t idx )
{
    GPS_CMD cmd = GPS_SYSLOG_INFO_IDX | OPT_GPS_ACK_CODE;
    MBG_SYSLOG_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.syslog_settings_idx;
    int rc;

    rc = mbgextio_chk_user_perm( pmctl, USER_PERM_MONITORING, USER_SCOPE_CONFIG_WRITE_MSK );
    if ( mbg_rc_is_error( rc ) )
      return rc;

    #if _USE_MUTEX
      _mbg_mutex_acquire( &pmctl->dev_mutex );
    #endif

    p_data->settings = *p;
    p_data->idx = idx;

    _mbg_swab_syslog_settings_idx( p_data );

    rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

    return rc;

}  // mbgextio_set_syslog_settings_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_fw_glb_info( MBG_MSG_CTL *pmctl,
                                                        const XBP_ADDR *p_addr,
                                                        MBG_FW_GLB_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FIRMWARE, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_FW_GLB_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_fw_glb_info( p );

  return rc;

}  // mbgextio_get_fw_glb_info


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_fw_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                        MBG_FW_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FIRMWARE, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_FW_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_fw_info_idx( p );

  return rc;

}  // mbgextio_get_fw_info_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_active_fw( MBG_MSG_CTL *pmctl,
                                                      const XBP_ADDR *p_addr,
                                                      uint16_t idx)
{
  GPS_CMD cmd = GPS_FW_ACTIVATE | OPT_GPS_ACK_CODE;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FIRMWARE, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  return mbgextio_xmt_cmd_us( pmctl, p_addr, cmd, idx );

}  // mbgextio_set_active_fw


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_delete_fw( MBG_MSG_CTL *pmctl,
                                                  const XBP_ADDR *p_addr,
                                                  uint16_t idx)
{
  GPS_CMD cmd = GPS_FW_DELETE | OPT_GPS_ACK_CODE;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FIRMWARE, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  return mbgextio_xmt_cmd_us( pmctl, p_addr, cmd, idx );

}  // mbgextio_delete_fw


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_fw_ufu_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                            MBG_FW_UFU_INFO_IDX *p, uint8_t fw_idx, uint8_t ufu_idx )
{
  uint16_t idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FIRMWARE, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  idx = ( ( fw_idx << 8 ) | ufu_idx );
  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_FW_UFU_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_fw_ufu_info_idx( p );

  return rc;

}  // mbgextio_get_fw_ufu_info_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_fw_ufu_flash( MBG_MSG_CTL *pmctl,
                                                     const XBP_ADDR *p_addr,
                                                     const MBG_FW_UFU_FLASH_CMD *p )
{
  int err;
  GPS_CMD cmd = GPS_FW_UFU_FLASH | OPT_GPS_ACK_CODE;
  MBG_FW_UFU_FLASH_CMD *p_data = &pmctl->xmt.pmb->u.msg_data.fw_ufu_flash_cmd;

  err = mbgextio_chk_user_perm( pmctl, USER_PERM_FIRMWARE, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( err ) )
    return err;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;

  _mbg_swab_fw_ufu_flash_cmd( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_fw_ufu_flash



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_database_glb_info( MBG_MSG_CTL *pmctl,
                                                              const XBP_ADDR *p_addr,
                                                              MBG_DATABASE_GLB_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_DATABASE, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_DATABASE_GLB_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_database_glb_info( p );

  return rc;

}  // mbgextio_get_database_glb_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_database_info_idx( MBG_MSG_CTL *pmctl,
                                                              const XBP_ADDR *p_addr,
                                                              MBG_DATABASE_INFO_IDX *p,
                                                              uint8_t idx)
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_DATABASE, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_DATABASE_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_database_info_idx( p );

  return rc;

}  // mbgextio_get_database_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_database_settings_idx( MBG_MSG_CTL *pmctl,
                                                                const XBP_ADDR *p_addr,
                                                                const MBG_DATABASE_SETTINGS *p,
                                                                uint8_t idx )
{
    GPS_CMD cmd = GPS_DATABASE_INFO_IDX | OPT_GPS_ACK_CODE;
    MBG_DATABASE_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.db_settings_idx;
    int rc;

    rc = mbgextio_chk_user_perm( pmctl, USER_PERM_DATABASE, USER_SCOPE_CONFIG_WRITE_MSK );
    if ( mbg_rc_is_error( rc ) )
      return rc;

    #if _USE_MUTEX
      _mbg_mutex_acquire( &pmctl->dev_mutex );
    #endif

    p_data->settings = *p;
    p_data->idx = idx;

    _mbg_swab_database_settings_idx( p_data );

    rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

    return rc;

}  // mbgextio_set_database_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_send_database_cmd( MBG_MSG_CTL *pmctl,
                                                          const XBP_ADDR *p_addr,
                                                          uint32_t cmd,
                                                          const void *payload,
                                                          uint32_t payload_len)
{
  int rc;
  GPS_CMD gps_cmd;
  MBG_DATABASE_CMD *p_data;

  if ( ( !payload && payload_len ) || ( payload && !payload_len ))
    return MBG_ERR_INV_PARM;

  if ( payload_len > sizeof( p_data->payload ) )
    return MBG_ERR_DATA_SIZE;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_DATABASE, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  gps_cmd = GPS_DATABASE_CMD | OPT_GPS_ACK_CODE;
  p_data = &pmctl->xmt.pmb->u.msg_data.db_cmd;
  p_data->cmd = cmd;

  if ( payload && payload_len )
  {
    memcpy( p_data->payload, payload, payload_len );
    p_data->length = payload_len;
  }
  else
  {
    p_data->length = 0;
  }

  _mbg_swab_database_cmd( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, gps_cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_send_database_cmd



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_glb_info( MBG_MSG_CTL *pmctl,
                                                  const XBP_ADDR *p_addr, NTP_GLB_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NTP_GLB_CFG, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_glb_info( p );

  return rc;

}  // mbgextio_get_ntp_glb_info


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_glb_info( MBG_MSG_CTL *pmctl,
                                                         const XBP_ADDR *p_addr,
                                                         const NTP_GLB_SETTINGS *p )
{
  GPS_CMD cmd = GPS_NTP_GLB_CFG | OPT_GPS_ACK_CODE;
  NTP_GLB_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_glb_settings;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ntp_glb_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_glb_info


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_symm_key_limits( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, NTP_SYMM_KEY_LIMITS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NTP_SYMM_KEY_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_symm_key_limits( p );

  return rc;

}  // mbgextio_get_ntp_symm_key_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_symm_key_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                  NTP_SYMM_KEY_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NTP_SYMM_KEY_CFG, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_symm_key_info_idx( p );

  return rc;

}  // mbgextio_get_ntp_symm_key_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_symm_key_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                      const NTP_SYMM_KEY_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NTP_SYMM_KEY_CFG | OPT_GPS_ACK_CODE;
  NTP_SYMM_KEY_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_symm_key_settings_idx;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_ntp_symm_key_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_symm_key_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_trusted_key_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                     NTP_TRUSTED_KEY_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NTP_TRUSTED_KEY_CFG, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_trusted_key_info_idx( p );

  return rc;

}  // mbgextio_get_ntp_trusted_key_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_trusted_key_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                         const NTP_TRUSTED_KEY_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NTP_TRUSTED_KEY_CFG | OPT_GPS_ACK_CODE;
  NTP_TRUSTED_KEY_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_trusted_key_settings_idx;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_ntp_trusted_key_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_trusted_key_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_misc_limits( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, NTP_MISC_LIMITS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NTP_MISC_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_misc_limits( p );

  return rc;

}  // mbgextio_get_ntp_misc_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_misc_orphan_mode_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                      NTP_MISC_ORPHAN_MODE_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NTP_MISC_ORPHAN_MODE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_misc_orphan_mode_info( p );

  return rc;

}  // mbgextio_get_ntp_misc_orphan_mode_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_misc_orphan_mode_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                          const NTP_MISC_ORPHAN_MODE_SETTINGS *p )
{
  GPS_CMD cmd = GPS_NTP_MISC_ORPHAN_MODE | OPT_GPS_ACK_CODE;
  NTP_MISC_ORPHAN_MODE_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_misc_orphan_mode_settings;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ntp_misc_orphan_mode_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_misc_orphan_mode_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_clnt_mode_info( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, NTP_CLNT_MODE_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NTP_CLNT_MODE_CFG, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_clnt_mode_info( p );

  return rc;

}  // mbgextio_get_ntp_clnt_mode_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_clnt_mode_cfg( MBG_MSG_CTL *pmctl,
                                      const XBP_ADDR *p_addr, const NTP_CLNT_MODE_SETTINGS *p )
{
  GPS_CMD cmd = GPS_NTP_CLNT_MODE_CFG | OPT_GPS_ACK_CODE;
  NTP_CLNT_MODE_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_clnt_mode_settings;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ntp_clnt_mode_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_clnt_mode_cfg



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_peer_settings_idx( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, NTP_PEER_SETTINGS_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NTP_PEER_SETTINGS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_peer_settings_idx( p );

  return rc;

}  // mbgextio_get_ntp_peer_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_peer_settings_idx( MBG_MSG_CTL *pmctl,
                                     const XBP_ADDR *p_addr, const NTP_PEER_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NTP_PEER_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  NTP_PEER_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_peer_settings_idx;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->peer_settings = *p;
  p_data->idx = idx;
  _mbg_swab_ntp_peer_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_peer_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_srv_mode_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, NTP_SRV_MODE_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NTP_SRV_MODE_CFG, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_srv_mode_info( p );

  return rc;

}  // mbgextio_get_ntp_srv_mode_info


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_srv_mode_cfg( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const NTP_SRV_MODE_SETTINGS *p )
{
  GPS_CMD cmd = GPS_NTP_SRV_MODE_CFG | OPT_GPS_ACK_CODE;
  NTP_SRV_MODE_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_srv_mode_settings;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_ntp_srv_mode_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_srv_mode_cfg


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_refclk_cfg_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                    NTP_REFCLK_CFG_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NTP_REFCLK_CFG, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_refclk_cfg_info_idx( p );

  return rc;

}  // mbgextio_get_ntp_refclk_cfg_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ntp_refclk_cfg_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                        const NTP_REFCLK_CFG_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NTP_REFCLK_CFG | OPT_GPS_ACK_CODE;
  NTP_REFCLK_CFG_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ntp_refclk_cfg_settings_idx;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_ntp_refclk_cfg_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ntp_refclk_cfg_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_sys_state( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, NTP_SYS_STATE *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NTP_SYS_STATE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_sys_state( p );

  return rc;

}  // mbgextio_get_ntp_sys_state



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_peer_state_idx( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, NTP_PEER_STATE_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NTP_PEER_STATE_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_peer_state_idx( p );

  return rc;

}  // mbgextio_get_ntp_peer_state_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ntp_refclk_state_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                 NTP_REFCLK_STATE_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NTP, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NTP_REFCLK_STATE_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ntp_refclk_state_idx( p );

  return rc;

}  // mbgextio_get_ntp_refclk_state_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_glb_cfg_info( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, MBG_NET_GLB_CFG_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK | USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NET_GLB_CFG, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_glb_cfg_info( p );

  return rc;

}  // mbgextio_get_net_glb_cfg_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_net_glb_cfg_settings( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, const MBG_NET_GLB_CFG_SETTINGS *p )
{
  GPS_CMD cmd = GPS_NET_GLB_CFG | OPT_GPS_ACK_CODE;
  MBG_NET_GLB_CFG_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.net_glb_cfg_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_net_glb_cfg_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_net_glb_cfg_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_dns_srvr_idx( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, MBG_IP_ADDR_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_DNS_SRVR, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ip_addr_idx( p );

  return rc;

}  // mbgextio_get_net_dns_srvr_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_net_dns_srvr_idx( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, const MBG_IP_ADDR *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NET_DNS_SRVR | OPT_GPS_ACK_CODE;
  MBG_IP_ADDR_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.ip_addr_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->addr = *p;
  p_data->idx = idx;
  _mbg_swab_ip_addr_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_net_dns_srvr_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_dns_srch_dom_idx( MBG_MSG_CTL *pmctl,
                                              const XBP_ADDR *p_addr, MBG_NET_NAME_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_DNS_SRCH_DOM, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_name_idx( p );

  return rc;

}  // mbgextio_get_net_dns_srch_dom_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_net_dns_srch_dom_idx( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, const MBG_NET_NAME *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NET_DNS_SRCH_DOM | OPT_GPS_ACK_CODE;
  MBG_NET_NAME_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.net_name_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->net_name = *p;
  p_data->idx = idx;
  _mbg_swab_net_name( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_net_dns_srch_dom_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_stat_dns_srvr_idx( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, MBG_IP_ADDR_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_STAT_DNS_SRVR, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ip_addr_idx( p );

  return rc;

}  // mbgextio_get_net_stat_dns_srvr_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_stat_dns_srch_dom_stat_idx( MBG_MSG_CTL *pmctl,
                                              const XBP_ADDR *p_addr, MBG_NET_NAME_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_STAT_DNS_SRCH_DOM, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_name_idx( p );

  return rc;

}  // mbgextio_get_net_stat_dns_srch_dom_stat_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_intf_link_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_NET_INTF_LINK_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_INTF_LINK_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_intf_link_info_idx( p );

  return rc;

} // mbgextio_get_net_intf_link_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_net_intf_link_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                       const MBG_NET_INTF_LINK_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NET_INTF_LINK_IDX | OPT_GPS_ACK_CODE;
  MBG_NET_INTF_LINK_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.net_intf_link_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_net_intf_link_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_net_intf_link_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_intf_addr_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                   MBG_NET_INTF_ADDR_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_INTF_ADDR_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_intf_addr_info_idx( p );

  return rc;

} // mbgextio_get_net_intf_addr_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_net_intf_addr_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                       const MBG_NET_INTF_ADDR_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NET_INTF_ADDR_IDX | OPT_GPS_ACK_CODE;
  MBG_NET_INTF_ADDR_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.net_intf_addr_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_net_intf_addr_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_net_intf_addr_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_intf_route_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                    MBG_NET_INTF_ROUTE_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_INTF_ROUTE_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_intf_route_info_idx( p );

  return rc;

} // mbgextio_get_net_intf_route_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_net_intf_route_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                        const MBG_NET_INTF_ROUTE_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_NET_INTF_ROUTE_IDX | OPT_GPS_ACK_CODE;
  MBG_NET_INTF_ROUTE_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.net_intf_route_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_net_intf_route_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_net_intf_route_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_stat_glb_cfg_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                  MBG_NET_GLB_CFG_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_NET_STAT_GLB_CFG, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_glb_cfg_info( p );

  return rc;

}  // mbgextio_get_net_stat_glb_cfg_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_stat_intf_link_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                        MBG_NET_INTF_LINK_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_STAT_INTF_LINK_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_intf_link_info_idx( p );

  return rc;

} // mbgextio_get_net_stat_intf_link_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_stat_intf_addr_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                        MBG_NET_INTF_ADDR_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_STAT_INTF_ADDR_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_intf_addr_info_idx( p );

  return rc;

} // mbgextio_get_net_stat_intf_addr_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_net_stat_intf_route_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                                         MBG_NET_INTF_ROUTE_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_NETWORK, USER_SCOPE_STATUS_READ_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_NET_STAT_INTF_ROUTE_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_net_intf_route_info_idx( p );

  return rc;

} // mbgextio_get_net_stat_intf_route_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xbp_limits( MBG_MSG_CTL *pmctl,
                                               const XBP_ADDR *p_addr, XBP_LIMITS *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_XBP_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_xbp_limits( p );

  return rc;

}  // mbgextio_get_xbp_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xbp_node_limits( MBG_MSG_CTL *pmctl,
                                             const XBP_ADDR *p_addr, XBP_NODE_LIMITS *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_XBP_NODE_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_xbp_node_limits( p );

  return rc;

}  // mbgextio_get_xbp_node_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_xbp_node_info_idx( MBG_MSG_CTL *pmctl,
                                         const XBP_ADDR *p_addr, XBP_NODE_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_XBP_NODE_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_xbp_node_info_idx( p );

  return rc;

}  // mbgextio_get_xbp_node_info_idx



static /*HDR*/
void handle_xbp_node( XBP_NODE_INFO *p_ni, long idx )
{
  XBP_ADDR * p_addr = &p_ni->addr;
  RECEIVER_INFO *p_ri = &p_ni->ri;
  int i;

  printf( "Node info %li:", idx );

  printf( " addr %02X:", p_addr->hop_count );

  for ( i = 0; i < MAX_XBP_CASC_LVL; i++ )
    printf( "%02X ", p_addr->addr[i] );

  printf( ", state: %i", p_ni->state );

  printf( ", name: \"%s\"", p_ri->model_name );

  printf( "\n" );

}  // handle_xbp_node



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_setup_xbp_node_list( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr )
{
  static int recursion_count;

  XBP_NODE_LIMITS node_limits;
  int rc = MBG_SUCCESS;
  uint16_t i;

  // This function can be called recursively, so first of all check the recursion level.
  if ( recursion_count > MAX_XBP_CASC_LVL )  //##++++ TODO: or even ">=" ??
  {
    // This should never happen, but we check this anyway.
    rc = MBG_ERR_XBP_CASC_LVL;
    goto out;
  }

  recursion_count++;

  rc = mbgextio_get_xbp_node_limits( pmctl, p_addr, &node_limits );

  if ( mbg_rc_is_error( rc ) )
    goto out_dec;

  for ( i = 0; i < node_limits.node_count; i++ )
  {
    XBP_NODE_INFO_IDX node_info_idx;

    rc = mbgextio_get_xbp_node_info_idx( pmctl, p_addr, &node_info_idx, i );

    if ( mbg_rc_is_error( rc ) )
      break;

    #if 1 && DEBUG
      if ( (ulong) node_info_idx.idx != (ulong) i )
        printf( "** Warning: received XBP index %li for idx %li in %s\n",
                (ulong) node_info_idx.idx, (ulong) i, __func__ );
    #endif

    handle_xbp_node( &node_info_idx.node_info, node_info_idx.idx );
  }

out_dec:
  if ( recursion_count > 0 )
    recursion_count--;
  else
  {
    //### recursion count is unexpectedly 0
  }

out:
  return rc;

}  // mbgextio_setup_xbp_node_list



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_cfgh( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, CFGH *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_CFGH, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_dummy( p );

  return rc;

}  // mbgextio_get_cfgh



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_sv_alm( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, SV_ALM *p, SVNO svno )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_ALM, svno, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_dummy( p );

  return rc;

}  // mbgextio_get_sv_alm



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_iono( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, IONO *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_IONO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_dummy( p );

  return rc;

}  // mbgextio_get_iono



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_utc_parm( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, UTC *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_UTC, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_utc_parm( p );

  return rc;

}  // mbgextio_get_utc_parm



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_utc_parm( MBG_MSG_CTL *pmctl, XBP_ADDR *p_addr, const UTC *p )
{
  GPS_CMD cmd = GPS_UTC | OPT_GPS_ACK_CODE;
  UTC *p_data = &pmctl->xmt.pmb->u.msg_data.utc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_utc_parm( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_utc_parm



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_scu_stat_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, SCU_STAT_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_SCU_STAT, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_scu_stat_info( p );

  return rc;

}  // mbgextio_get_scu_stat_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_scu_stat_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const SCU_STAT_SETTINGS *p )
{
  // TODO: request ACK for SCU_STAT_SETTINGS (at the moment, this is not implemented in RSC/MDU)
  GPS_CMD cmd = GPS_SCU_STAT;
  SCU_STAT_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.scu_stat_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_scu_stat_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_scu_stat_settings



#if _USE_TIME_MON && defined( _PRELIMINARY_CODE )

/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_time_mon_get_inst_info( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, MBG_TIME_MON_INST_INFO *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_TIME_MON_INST_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_time_mon_inst_info( p );

  return rc;

}  // mbgextio_time_mon_get_inst_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_time_mon_send_inst_info( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, const MBG_TIME_MON_INST_INFO *p )
{
  GPS_CMD cmd = GPS_TIME_MON_INST_INFO | OPT_GPS_ACK_CODE;
  MBG_TIME_MON_INST_INFO *p_data = &pmctl->xmt.pmb->u.msg_data.time_mon_inst_info;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_time_mon_inst_info( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_time_mon_send_inst_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_time_mon_send_target_settings( MBG_MSG_CTL *pmctl,
                                        const XBP_ADDR *p_addr, const MBG_TIME_MON_TARGET_SETTINGS *p )
{
  GPS_CMD cmd = GPS_TIME_MON_TARGET_SETTINGS | OPT_GPS_ACK_CODE;
  MBG_TIME_MON_TARGET_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.time_mon_target_settings;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_time_mon_target_settings( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_time_mon_send_target_settings



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_time_mon_get_target_status_idx( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, MBG_TIME_MON_TARGET_STATUS_IDX *p, uint16_t idx  )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_TIME_MON_TARGET_STATUS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_time_mon_target_status_idx( p );

  return rc;

}  // mbgextio_time_mon_get_target_status_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_time_mon_get_target_ext_data_set_idx( MBG_MSG_CTL *pmctl,
                                          const XBP_ADDR *p_addr, MBG_TIME_MON_TARGET_EXT_DATA_SET_IDX *p, uint16_t idx  )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_TIME_MON_TARGET_EXT_DATA_SET_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_time_mon_target_ext_data_set_idx( p );

  return rc;

}  // mbgextio_time_mon_get_target_ext_data_set_idx()

#endif   // _USE_TIME_MON && defined( _PRELIMINARY_CODE )


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_fdm_freq( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_GPIO_FREQ *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_FDM_FREQ, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_gpio_freq( p );

  return rc;

}  // mbgextio_get_fdm_freq


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ims_fdm_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_IMS_FDM_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_FDM_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ims_fdm_info( p );

  return rc;

}  // mbgextio_get_ims_fdm_info


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ims_fdm_limits( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_IMS_FDM_LIMITS *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_FDM_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ims_fdm_limits( p );

  return rc;

}  // mbgextio_get_ims_fdm_limits


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ims_fdm_output_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_IMS_FDM_OUTPUT_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_FDM_OUTPUT_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ims_fdm_output_info_idx( p );

  return rc;

}  // mbgextio_get_ims_fdm_output_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ims_fdm_output_state_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_IMS_FDM_OUTPUT_STATE_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_FDM_OUTPUT_STATE_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ims_fdm_output_state_idx( p );

  return rc;

}  // mbgextio_get_ims_fdm_output_state_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ims_fdm_state( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_IMS_FDM_STATE *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_FDM_STATE, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_ims_fdm_state( p );

  return rc;

}  // mbgextio_get_ims_fdm_state


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ims_fdm_settings( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const MBG_IMS_FDM_SETTINGS *p )
{
  GPS_CMD cmd = GPS_FDM_SETTINGS | OPT_GPS_ACK_CODE;
  MBG_IMS_FDM_SETTINGS *p_data = &pmctl->xmt.pmb->u.msg_data.fdm_settings;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_mbg_ims_fdm_settings( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ims_fdm_settings


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_ims_fdm_output_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                       const MBG_IMS_FDM_OUTPUT_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_FDM_OUTPUT_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  MBG_IMS_FDM_OUTPUT_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.fdm_output_settings_idx;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_mbg_ims_fdm_output_settings_idx( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_ims_fdm_output_settings_idx


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_fdm_tdev( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const NANO_TIME_64 *p )
{
  GPS_CMD cmd = GPS_FDM_SET_TD | OPT_GPS_ACK_CODE;
  NANO_TIME_64 *p_data = &pmctl->xmt.pmb->u.msg_data.nano_time_64;
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_FDM, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_nano_time_64( p_data );

  rc = mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );
  return rc;

}  // mbgextio_set_fdm_tdev


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_cmd_save_cfg( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SYSTEM, USER_SCOPE_CONFIG_WRITE_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_xmt_cmd( pmctl, p_addr, GPS_SAVE_CFG | OPT_GPS_ACK_CODE );
  return rc;
  //### TODO: check if ACK works

}  // mbgextio_cmd_save_cfg



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_lne_limits( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_LNE_LIMITS *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_LNE_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_lne_limits( p );

  return rc;

}  // mbgextio_get_lne_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_lne_port_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_LNE_PORT_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_LNE_PORT_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_lne_port_info_idx( p );

  return rc;

}  // mbgextio_get_lne_port_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_lne_port_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_LNE_PORT_SETTINGS_IDX *p, uint16_t idx )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_LNE_PORT_SETTINGS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_lne_port_settings_idx( p );

  return rc;

}  // mbgextio_get_lne_port_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_lne_port_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const MBG_LNE_PORT_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_LNE_PORT_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  MBG_LNE_PORT_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.lne_port_settings_idx;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_mbg_lne_port_settings_idx( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_lne_port_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_pwr_ctl( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const MBG_PWR_CTL *p )
{
  GPS_CMD cmd = GPS_PWR_CTL | OPT_GPS_ACK_CODE;
  MBG_PWR_CTL *p_data = &pmctl->xmt.pmb->u.msg_data.pwr_ctl;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  *p_data = *p;
  _mbg_swab_mbg_pwr_ctl( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_pwr_ctl



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_pwr_ctl( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_PWR_CTL *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_PWR_CTL, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_pwr_ctl( p );

  return rc;

}  // mbgextio_get_pwr_ctl



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_led_limits( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                       MBG_LED_LIMITS *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_LED_LIMITS, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_led_limits( p );

  return rc;

}  // mbgextio_get_led_limits



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_led_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                         MBG_LED_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_LED_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_led_info_idx( p );

  return rc;

}  // mbgextio_get_led_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_led_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, MBG_LED_SETTINGS_IDX *p, uint16_t idx )
{
  int rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_LED_SETTINGS_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_mbg_led_settings_idx( p );

  return rc;

}  // mbgextio_get_led_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_led_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr, const MBG_LED_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_LED_SETTINGS_IDX | OPT_GPS_ACK_CODE;
  MBG_LED_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.led_settings_idx;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_mbg_led_settings_idx( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_led_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_tainted_cfg( MBG_MSG_CTL *pmctl,
                                                        const XBP_ADDR *p_addr,
                                                        MBG_TAINTED_CFG *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_TAINTED_CFG, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_tainted_cfg( p );

  return rc;

}  // mbgextio_get_tainted_cfg



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_register_push_msg( MBG_MSG_CTL *pmctl,
                                                          const XBP_ADDR *p_addr,
                                                          GPS_CMD cmd)
{
  return mbgextio_xmt_cmd_us( pmctl, p_addr, GPS_REGISTER_PUSH_MSGS | OPT_GPS_ACK_CODE, cmd);

}  // mbgextio_register_push_msg



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_unregister_push_msg( MBG_MSG_CTL *pmctl,
                                                            const XBP_ADDR *p_addr,
                                                            GPS_CMD cmd)
{
  return mbgextio_xmt_cmd_us( pmctl, p_addr, GPS_UNREGISTER_PUSH_MSGS | OPT_GPS_ACK_CODE, cmd);

}  // mbgextio_unregister_push_msg



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_ext_sys_info( MBG_MSG_CTL *pmctl,
                                                         const XBP_ADDR *p_addr,
                                                         MBG_EXT_SYS_INFO *p )
{
  int rc = mbgextio_req_data( pmctl, p_addr, GPS_EXT_SYS_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_ext_sys_info( p );

  return rc;

}  // mbgextio_get_ext_sys_info


/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_corr_info( MBG_MSG_CTL *pmctl,
                                                         const XBP_ADDR *p_addr,
                                                         CORR_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_RECEIVER, USER_SCOPE_STATUS_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, PZF_CORR_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_corr_info( p );

  return rc;

}  // mbgextio_get_core_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_chk_user_perm( MBG_MSG_CTL *pmctl,
                                                      uint16_t perm,
                                                      uint32_t scope_mask )
{
  if ( mbg_rc_is_success( mbgextio_dev_has_user_auth( pmctl ) ) )
  {
    if ( ( scope_mask & USER_SCOPE_STATUS_READ_MSK ) == USER_SCOPE_STATUS_READ_MSK )
    {
      if ( mbg_rc_is_success( _check_user_perm( perm, &pmctl->xdev_features.user_status.stat_read_perm ) ) )
        return MBG_SUCCESS;
    }

    if ( ( scope_mask & USER_SCOPE_CONFIG_READ_MSK ) == USER_SCOPE_CONFIG_READ_MSK )
    {
      if ( mbg_rc_is_success( _check_user_perm( perm, &pmctl->xdev_features.user_status.cfg_read_perm ) ) )
        return MBG_SUCCESS;
    }

    if ( ( scope_mask & USER_SCOPE_CONFIG_WRITE_MSK ) == USER_SCOPE_CONFIG_WRITE_MSK )
    {
      if ( mbg_rc_is_success( _check_user_perm( perm, &pmctl->xdev_features.user_status.cfg_write_perm ) ) )
        return MBG_SUCCESS;
    }

    return MBG_ERR_PERM;
  }

  return MBG_SUCCESS;

}  // mbgextio_chk_usr_perm



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_svc_mgmt_info( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                          MBG_SERVICE_MGMT_INFO *p )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERVICE, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data( pmctl, p_addr, GPS_SVC_MGMT_INFO, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_svc_mgmt_info( p );

  return rc;

} // mbgextio_get_svc_mgmt_info



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_svc_info_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                         MBG_SERVICE_INFO_IDX *p, uint16_t idx )
{
  int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERVICE, USER_SCOPE_STATUS_READ_MSK | USER_SCOPE_CONFIG_READ_MSK );

  if ( mbg_rc_is_error( rc ) )
    return rc;

  rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_SVC_INFO_IDX, idx, p, sizeof( *p ) );

  if ( mbg_rc_is_success( rc ) && p )
    _mbg_swab_svc_info_idx( p );

  return rc;

} // mbgextio_get_svc_info_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_svc_settings_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                             const MBG_SERVICE_SETTINGS *p, uint16_t idx )
{
  GPS_CMD cmd = GPS_SVC_INFO_IDX | OPT_GPS_ACK_CODE;
  MBG_SERVICE_SETTINGS_IDX *p_data = &pmctl->xmt.pmb->u.msg_data.svc_settings_idx;
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERVICE, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  #if _USE_MUTEX
    _mbg_mutex_acquire( &pmctl->dev_mutex );
  #endif

  p_data->settings = *p;
  p_data->idx = idx;
  _mbg_swab_svc_settings_idx( p_data );

  return mbgextio_xmt_msg( pmctl, p_addr, cmd, NULL, sizeof( *p_data ) );

}  // mbgextio_set_svc_settings_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_get_svc_status_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                           MBG_SERVICE_STATUS_IDX *p, uint16_t idx )
{
    int rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERVICE, USER_SCOPE_STATUS_READ_MSK );

    if ( mbg_rc_is_error( rc ) )
      return rc;

    rc = mbgextio_req_data_idx( pmctl, p_addr, GPS_SVC_STATUS_IDX, idx, p, sizeof( *p ) );

    if ( mbg_rc_is_success( rc ) && p )
      _mbg_swab_svc_status_idx( p );

    return rc;

} // mbgextio_get_svc_status_idx



/*HDR*/
_NO_MBG_API_ATTR int _MBG_API mbgextio_set_svc_ctl_idx( MBG_MSG_CTL *pmctl, const XBP_ADDR *p_addr,
                                                        uint16_t idx, uint16_t ctl )
{
  GPS_CMD cmd = GPS_SVC_CTL_IDX | OPT_GPS_ACK_CODE;
  uint32_t u32 = ( ( idx << 16 ) | ctl );
  int rc;

  rc = mbgextio_chk_user_perm( pmctl, USER_PERM_SERVICE, USER_SCOPE_CONFIG_WRITE_MSK );
  if ( mbg_rc_is_error( rc ) )
    return rc;

  return mbgextio_xmt_cmd_u32( pmctl, p_addr, cmd, u32 );

}  // mbgextio_set_svc_ctl_idx