uhd: C API wrapper

* multi_usrp, multi_usrp_clock, and associated classes accessible through C
* Added Doxygen documentation explaining structure and API
* Simple RX and TX streaming examples
* Unit tests for different parts of C interface and C++ error conversion

22 files changed, 3041 insertions, 20 deletions

diff --git a/host/include/CMakeLists.txt b/host/include/CMakeLists.txt
index 780213918..8b1e6bc05 100644
--- a/host/include/CMakeLists.txt
+++ b/host/include/CMakeLists.txt
@@ -20,4 +20,11 @@ CONFIGURE_FILE(
     ${CMAKE_CURRENT_BINARY_DIR}/config.h
 )
 
+IF(ENABLE_C_API)
+    UHD_INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/uhd.h
+        DESTINATION ${INCLUDE_DIR}
+        COMPONENT headers
+    )
+ENDIF(ENABLE_C_API)
+
 ADD_SUBDIRECTORY(uhd)
diff --git a/host/include/uhd.h b/host/include/uhd.h
new file mode 100644
index 000000000..0ecafa88a
--- /dev/null
+++ b/host/include/uhd.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2015 Ettus Research LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_UHD_H
+#define INCLUDED_UHD_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#include <uhd/types/metadata.h>
+#include <uhd/types/ranges.h>
+#include <uhd/types/sensors.h>
+#include <uhd/types/tune_request.h>
+#include <uhd/types/tune_result.h>
+#include <uhd/types/usrp_info.h>
+
+#include <uhd/usrp/dboard_eeprom.h>
+#include <uhd/usrp/mboard_eeprom.h>
+#include <uhd/usrp/subdev_spec.h>
+#include <uhd/usrp/usrp.h>
+
+#include <uhd/usrp_clock/usrp_clock.h>
+
+#include <uhd/utils/thread_priority.h>
+
+#endif /* INCLUDED_UHD_H */
diff --git a/host/include/uhd/CMakeLists.txt b/host/include/uhd/CMakeLists.txt
index f6123aa90..083ec4951 100644
--- a/host/include/uhd/CMakeLists.txt
+++ b/host/include/uhd/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2010-2011,2013-2014 Ettus Research LLC
+# Copyright 2010-2011,2013-2015 Ettus Research LLC
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -40,3 +40,12 @@ UHD_INSTALL(FILES
     DESTINATION ${INCLUDE_DIR}/uhd
     COMPONENT headers
 )
+
+IF(ENABLE_C_API)
+    UHD_INSTALL(FILES
+        config.h
+        error.h
+        DESTINATION ${INCLUDE_DIR}/uhd
+        COMPONENT headers
+    )
+ENDIF(ENABLE_C_API)
diff --git a/host/include/uhd/config.h b/host/include/uhd/config.h
new file mode 100644
index 000000000..1d6cefcc0
--- /dev/null
+++ b/host/include/uhd/config.h
@@ -0,0 +1,82 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_CONFIG_H
+#define INCLUDED_UHD_CONFIG_H
+
+#ifdef _MSC_VER
+// Bring in "and", "or", and "not"
+#include <iso646.h>
+
+// Define ssize_t
+#include <stddef.h>
+typedef ptrdiff_t ssize_t;
+
+#endif /* _MSC_VER */
+
+// Define cross-platform macros
+#if defined(_MSC_VER)
+    #define UHD_EXPORT         __declspec(dllexport)
+    #define UHD_IMPORT         __declspec(dllimport)
+    #define UHD_INLINE         __forceinline
+    #define UHD_DEPRECATED     __declspec(deprecated)
+    #define UHD_ALIGNED(x)     __declspec(align(x))
+    #define UHD_UNUSED(x)      x
+#elif defined(__MINGW32__)
+    #define UHD_EXPORT         __declspec(dllexport)
+    #define UHD_IMPORT         __declspec(dllimport)
+    #define UHD_INLINE         inline
+    #define UHD_DEPRECATED     __declspec(deprecated)
+    #define UHD_ALIGNED(x)     __declspec(align(x))
+    #define UHD_UNUSED(x)      x __attribute__((unused))
+#elif defined(__GNUG__) && __GNUG__ >= 4
+    #define UHD_EXPORT         __attribute__((visibility("default")))
+    #define UHD_IMPORT         __attribute__((visibility("default")))
+    #define UHD_INLINE         inline __attribute__((always_inline))
+    #define UHD_DEPRECATED     __attribute__((deprecated))
+    #define UHD_ALIGNED(x)     __attribute__((aligned(x)))
+    #define UHD_UNUSED(x)      x __attribute__((unused))
+#else
+    #define UHD_EXPORT
+    #define UHD_IMPORT
+    #define UHD_INLINE         inline
+    #define UHD_DEPRECATED
+    #define UHD_ALIGNED(x)
+    #define UHD_UNUSED(x)      x
+#endif
+
+// API declaration macro
+#ifdef UHD_DLL_EXPORTS
+    #define UHD_API UHD_EXPORT
+#else
+    #define UHD_API UHD_IMPORT
+#endif // UHD_DLL_EXPORTS
+
+// Platform defines for conditional code:
+// Taken from boost/config/select_platform_config.hpp,
+// However, we define macros, not strings, for platforms.
+#if defined(linux) || defined(__linux) || defined(__linux__)
+    #define UHD_PLATFORM_LINUX
+#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
+    #define UHD_PLATFORM_WIN32
+#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)
+    #define UHD_PLATFORM_MACOS
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+    #define UHD_PLATFORM_BSD
+#endif
+
+#endif /* INCLUDED_UHD_CONFIG_H */
diff --git a/host/include/uhd/error.h b/host/include/uhd/error.h
new file mode 100644
index 000000000..845d741dc
--- /dev/null
+++ b/host/include/uhd/error.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2015 Ettus Research LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_UHD_ERROR_H
+#define INCLUDED_UHD_ERROR_H
+
+//! UHD error codes
+/*!
+ * Each error code corresponds to a specific uhd::exception, with
+ * extra codes corresponding to a boost::exception, std::exception,
+ * and a catch-all for everything else. When an internal C++ function
+ * throws an exception, UHD converts it to one of these error codes
+ * to return on the C level.
+ */
+typedef enum {
+
+    //! No error thrown.
+    UHD_ERROR_NONE = 0,
+    //! Invalid device arguments.
+    UHD_ERROR_INVALID_DEVICE = 1,
+
+    //! See uhd::index_error.
+    UHD_ERROR_INDEX = 10,
+    //! See uhd::key_error.
+    UHD_ERROR_KEY = 11,
+
+    //! See uhd::not_implemented_error.
+    UHD_ERROR_NOT_IMPLEMENTED = 20,
+    //! See uhd::usb_error.
+    UHD_ERROR_USB = 21,
+
+    //! See uhd::io_error.
+    UHD_ERROR_IO = 30,
+    //! See uhd::os_error.
+    UHD_ERROR_OS = 31,
+
+    //! See uhd::assertion_error.
+    UHD_ERROR_ASSERTION = 40,
+    //! See uhd::lookup_error.
+    UHD_ERROR_LOOKUP = 41,
+    //! See uhd::type_error.
+    UHD_ERROR_TYPE = 42,
+    //! See uhd::value_error.
+    UHD_ERROR_VALUE = 43,
+    //! See uhd::runtime_error.
+    UHD_ERROR_RUNTIME = 44,
+    //! See uhd::environment_error.
+    UHD_ERROR_ENVIRONMENT = 45,
+    //! See uhd::system_error.
+    UHD_ERROR_SYSTEM = 46,
+    //! See uhd::exception.
+    UHD_ERROR_EXCEPT = 47,
+
+    //! A boost::exception was thrown.
+    UHD_ERROR_BOOSTEXCEPT = 60,
+
+    //! A std::exception was thrown.
+    UHD_ERROR_STDEXCEPT = 70,
+
+    //! An unknown error was thrown.
+    UHD_ERROR_UNKNOWN = 100
+} uhd_error;
+
+#ifdef __cplusplus
+#include <uhd/config.hpp>
+#include <uhd/exception.hpp>
+
+#include <boost/exception/diagnostic_information.hpp>
+
+UHD_API uhd_error error_from_uhd_exception(const uhd::exception* e);
+
+/*!
+ * This macro runs the given C++ code, and if there are any exceptions
+ * thrown, they are caught and converted to the corresponding UHD error
+ * code.
+ */
+#define UHD_SAFE_C(...) \
+    try{ __VA_ARGS__ } \
+    catch (const uhd::exception &e) { \
+        return error_from_uhd_exception(&e); \
+    } \
+    catch (const boost::exception&) { \
+        return UHD_ERROR_BOOSTEXCEPT; \
+    } \
+    catch (const std::exception&) { \
+        return UHD_ERROR_STDEXCEPT; \
+    } \
+    catch (...) { \
+        return UHD_ERROR_UNKNOWN; \
+    } \
+    return UHD_ERROR_NONE;
+
+/*!
+ * This macro runs the given C++ code, and if there are any exceptions
+ * thrown, they are caught and converted to the corresponding UHD error
+ * code. The error message is also saved into the given handle.
+ */
+#define UHD_SAFE_C_SAVE_ERROR(h, ...) \
+    h->last_error.clear(); \
+    try{ __VA_ARGS__ } \
+    catch (const uhd::exception &e) { \
+        h->last_error = e.what(); \
+        return error_from_uhd_exception(&e); \
+    } \
+    catch (const boost::exception &e) { \
+        h->last_error = boost::diagnostic_information(e); \
+        return UHD_ERROR_BOOSTEXCEPT; \
+    } \
+    catch (const std::exception &e) { \
+        h->last_error = e.what(); \
+        return UHD_ERROR_STDEXCEPT; \
+    } \
+    catch (...) { \
+        h->last_error = "Unrecognized exception caught."; \
+        return UHD_ERROR_UNKNOWN; \
+    } \
+    h->last_error = "None"; \
+    return UHD_ERROR_NONE;
+
+#endif
+
+#endif /* INCLUDED_UHD_ERROR_H */
diff --git a/host/include/uhd/types/CMakeLists.txt b/host/include/uhd/types/CMakeLists.txt
index 2a25df35f..140b5c710 100644
--- a/host/include/uhd/types/CMakeLists.txt
+++ b/host/include/uhd/types/CMakeLists.txt
@@ -42,3 +42,16 @@ UHD_INSTALL(FILES
     DESTINATION ${INCLUDE_DIR}/uhd/types
     COMPONENT headers
 )
+
+IF(ENABLE_C_API)
+    UHD_INSTALL(FILES
+        metadata.h
+        ranges.h
+        sensors.h
+        tune_request.h
+        tune_result.h
+        usrp_info.h
+        DESTINATION ${INCLUDE_DIR}/uhd/types
+        COMPONENT headers
+    )
+ENDIF(ENABLE_C_API)
diff --git a/host/include/uhd/types/metadata.h b/host/include/uhd/types/metadata.h
new file mode 100644
index 000000000..0cdbc6a72
--- /dev/null
+++ b/host/include/uhd/types/metadata.h
@@ -0,0 +1,364 @@
+/*
+ * Copyright 2015 Ettus Research
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_UHD_TYPES_METADATA_H
+#define INCLUDED_UHD_TYPES_METADATA_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <time.h>
+
+#ifdef __cplusplus
+#include <uhd/types/metadata.hpp>
+#include <string>
+
+struct uhd_rx_metadata_t {
+    uhd::rx_metadata_t rx_metadata_cpp;
+    std::string last_error;
+};
+
+struct uhd_tx_metadata_t {
+    uhd::tx_metadata_t tx_metadata_cpp;
+    std::string last_error;
+};
+
+struct uhd_async_metadata_t {
+    uhd::async_metadata_t async_metadata_cpp;
+    std::string last_error;
+};
+
+extern "C" {
+#else
+struct uhd_rx_metadata_t;
+struct uhd_tx_metadata_t;
+struct uhd_async_metadata_t;
+#endif
+
+//! RX metadata interface for describing sent IF data.
+/*!
+ * See uhd::rx_metadata_t for details.
+ *
+ * NOTE: Using this handle before calling uhd_rx_metadata_make() will
+ * result in undefined behavior.
+ */
+typedef struct uhd_rx_metadata_t*    uhd_rx_metadata_handle;
+
+//! TX metadata interface for describing received IF data.
+/*!
+ * See uhd::tx_metadata_t for details.
+ *
+ * NOTE: Using this handle before calling uhd_tx_metadata_make() will
+ * result in undefined behavior.
+ */
+typedef struct uhd_tx_metadata_t*    uhd_tx_metadata_handle;
+
+//! Interface for describing transmit-related events.
+/*!
+ * See uhd::async_metadata_t for details.
+ *
+ * NOTE: Using this handle before calling uhd_async_metadata_make() will
+ * result in undefined behavior.
+ */
+typedef struct uhd_async_metadata_t* uhd_async_metadata_handle;
+
+//! Error condition on a receive call
+/*!
+ * See uhd::rx_metadata_t::error_code_t for more details.
+ */
+typedef enum {
+    //! No error code associated with this metadata
+    UHD_RX_METADATA_ERROR_CODE_NONE         = 0x0,
+    //! No packet received, implementation timed out
+    UHD_RX_METADATA_ERROR_CODE_TIMEOUT      = 0x1,
+    //! A stream command was issued in the past
+    UHD_RX_METADATA_ERROR_CODE_LATE_COMMAND = 0x2,
+    //! Expected another stream command
+    UHD_RX_METADATA_ERROR_CODE_BROKEN_CHAIN = 0x4,
+    //! Overflow or sequence error
+    UHD_RX_METADATA_ERROR_CODE_OVERFLOW     = 0x8,
+    //! Multi-channel alignment failed
+    UHD_RX_METADATA_ERROR_CODE_ALIGNMENT    = 0xC,
+    //! The packet could not be parsed
+    UHD_RX_METADATA_ERROR_CODE_BAD_PACKET   = 0xF
+} uhd_rx_metadata_error_code_t;
+
+
+//! Create a new RX metadata handle
+UHD_API uhd_error uhd_rx_metadata_make(
+    uhd_rx_metadata_handle* handle
+);
+
+//! Free an RX metadata handle
+/*!
+ * Using a handle after freeing it here will result in a segmentation fault.
+ */
+UHD_API uhd_error uhd_rx_metadata_free(
+    uhd_rx_metadata_handle* handle
+);
+
+//! Has time specification?
+UHD_API uhd_error uhd_rx_metadata_has_time_spec(
+    uhd_rx_metadata_handle h,
+    bool *result_out
+);
+
+//! Time of first sample
+UHD_API uhd_error uhd_rx_metadata_time_spec(
+    uhd_rx_metadata_handle h,
+    time_t *full_secs_out,
+    double *frac_secs_out
+);
+
+//! Fragmentation flag
+UHD_API uhd_error uhd_rx_metadata_more_fragments(
+    uhd_rx_metadata_handle h,
+    bool *result_out
+);
+
+//! Fragmentation offset
+UHD_API uhd_error uhd_rx_metadata_fragment_offset(
+    uhd_rx_metadata_handle h,
+    size_t *fragment_offset_out
+);
+
+//! Start of burst?
+UHD_API uhd_error uhd_rx_metadata_start_of_burst(
+    uhd_rx_metadata_handle h,
+    bool *result_out
+);
+
+//! End of burst?
+UHD_API uhd_error uhd_rx_metadata_end_of_burst(
+    uhd_rx_metadata_handle h,
+    bool *result_out
+);
+
+//! Result out of sequence?
+UHD_API uhd_error uhd_rx_metadata_out_of_sequence(
+    uhd_rx_metadata_handle h,
+    bool *result_out
+);
+
+//! Return a pretty-print representation of this metadata.
+/*!
+ * NOTE: This function will overwrite any string in the given buffer
+ * before inserting the pp_string.
+ *
+ * \param h metadata handle
+ * \param pp_string_out string buffer for pp_string
+ * \param buffer length
+ */
+UHD_API uhd_error uhd_rx_metadata_to_pp_string(
+    uhd_rx_metadata_handle h,
+    char* pp_string_out,
+    size_t strbuffer_len
+);
+
+//! Get the last error state of the RX metadata object.
+UHD_API uhd_error uhd_rx_metadata_error_code(
+    uhd_rx_metadata_handle h,
+    uhd_rx_metadata_error_code_t *error_code_out
+);
+
+//! Get a string representation of the last error state of the RX metadata object.
+/*!
+ * NOTES:
+ * <ul>
+ * <li>This is different from the error that can be retrieved with
+ *     uhd_rx_metadata_last_error. See uhd::rx_metadata_t::strerror() for details.</li>
+ * <li>This function will overwrite any string in the given buffer before
+ *     inserting the error string.</li>
+ * </ul>
+ *
+ * \param h metadata handle
+ * \param strerror_out string buffer for strerror
+ * \param buffer length
+ */
+UHD_API uhd_error uhd_rx_metadata_strerror(
+    uhd_rx_metadata_handle h,
+    char* strerror_out,
+    size_t strbuffer_len
+);
+
+//! Get the last error logged by the RX metadata object.
+/*!
+ * NOTES:
+ * <ul>
+ * <li>This is different from the error that can be retrieved with
+ *     uhd_rx_metadata_strerror(). See <uhd/error.h> for details.</li>
+ * <li>This function will overwrite any string in the given buffer before
+ *     inserting the error string.</li>
+ * </ul>
+ *
+ * \param h metadata handle
+ * \param error_out string buffer for error
+ * \param buffer length
+ */
+UHD_API uhd_error uhd_rx_metadata_last_error(
+    uhd_rx_metadata_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+//! Create a new TX metadata handle
+UHD_API uhd_error uhd_tx_metadata_make(
+    uhd_tx_metadata_handle* handle,
+    bool has_time_spec,
+    time_t full_secs,
+    double frac_secs,
+    bool start_of_burst,
+    bool end_of_burst
+);
+
+
+//! Free an TX metadata handle
+/*!
+ * Using a handle after freeing it here will result in a segmentation fault.
+ */
+UHD_API uhd_error uhd_tx_metadata_free(
+    uhd_tx_metadata_handle* handle
+);
+
+//! Has time specification?
+UHD_API uhd_error uhd_tx_metadata_has_time_spec(
+    uhd_tx_metadata_handle h,
+    bool *result_out
+);
+
+//! Get time specification
+UHD_API uhd_error uhd_tx_metadata_time_spec(
+    uhd_tx_metadata_handle h,
+    time_t *full_secs_out,
+    double *frac_secs_out
+);
+
+//! Start of burst?
+UHD_API uhd_error uhd_tx_metadata_start_of_burst(
+    uhd_tx_metadata_handle h,
+    bool *result_out
+);
+
+//! End of burst?
+UHD_API uhd_error uhd_tx_metadata_end_of_burst(
+    uhd_tx_metadata_handle h,
+    bool *result_out
+);
+
+//! Get the last error logged by the TX metadata object.
+/*!
+ * NOTE: This function will overwrite any string in the given buffer before
+ * inserting the error string.
+ *
+ * \param h metadata handle
+ * \param error_out string buffer for error
+ * \param buffer length
+ */
+UHD_API uhd_error uhd_tx_metadata_last_error(
+    uhd_tx_metadata_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+//! The type of event for a receive async message call.
+/*!
+ * See uhd::async_metadata_t::event_code_t for more details.
+ */
+typedef enum {
+    //! A burst was successfully transmitted.
+    UHD_ASYNC_METADATA_EVENT_CODE_BURST_ACK           = 0x1,
+    //! An internal send buffer has emptied.
+    UHD_ASYNC_METADATA_EVENT_CODE_UNDERFLOW           = 0x2,
+    //! Packet loss error between host and device.
+    UHD_ASYNC_METADATA_EVENT_CODE_SEQ_ERROR           = 0x4,
+    //! Packet had time that was late.
+    UHD_ASYNC_METADATA_EVENT_CODE_TIME_ERROR          = 0x8,
+    //! Underflow occurred inside a packet.
+    UHD_ASYNC_METADATA_EVENT_CODE_UNDERFLOW_IN_PACKET = 0x10,
+    //! Packet loss within a burst.
+    UHD_ASYNC_METADATA_EVENT_CODE_SEQ_ERROR_IN_BURST  = 0x20,
+    //! Some kind of custom user payload.
+    UHD_ASYNC_METADATA_EVENT_CODE_USER_PAYLOAD        = 0x40
+} uhd_async_metadata_event_code_t;
+
+//! Create a new async metadata handle
+UHD_API uhd_error uhd_async_metadata_make(
+    uhd_async_metadata_handle* handle
+);
+
+//! Free an async metadata handle
+/*!
+ * Using a handle after freeing it will result in a segmentation fault.
+ */
+UHD_API uhd_error uhd_async_metadata_free(
+    uhd_async_metadata_handle* handle
+);
+
+//! Channel number in a MIMO configuration
+UHD_API uhd_error uhd_async_metadata_channel(
+    uhd_async_metadata_handle h,
+    size_t *channel_out
+);
+
+//! Has time specification?
+UHD_API uhd_error uhd_async_metadata_has_time_spec(
+    uhd_async_metadata_handle h,
+    bool *result_out
+);
+
+//! Get time specification
+UHD_API uhd_error uhd_async_metadata_time_spec(
+    uhd_async_metadata_handle h,
+    time_t *full_secs_out,
+    double *frac_secs_out
+);
+
+//! Get last event code
+UHD_API uhd_error uhd_async_metadata_event_code(
+    uhd_async_metadata_handle h,
+    uhd_async_metadata_event_code_t *event_code_out
+);
+
+//! Get payload from custom FPGA fabric
+UHD_API uhd_error uhd_async_metadata_user_payload(
+    uhd_async_metadata_handle h,
+    uint32_t user_payload_out[4]
+);
+
+//! Get the last error logged by the async metadata object.
+/*!
+ * NOTE: This function will overwrite any string in the given buffer before
+ * inserting the error string.
+ *
+ * \param h metadata handle
+ * \param error_out string buffer for error
+ * \param buffer length
+ */
+UHD_API uhd_error uhd_async_metadata_last_error(
+    uhd_async_metadata_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_TYPES_METADATA_H */
diff --git a/host/include/uhd/types/ranges.h b/host/include/uhd/types/ranges.h
new file mode 100644
index 000000000..ca80c9141
--- /dev/null
+++ b/host/include/uhd/types/ranges.h
@@ -0,0 +1,154 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_TYPES_RANGES_H
+#define INCLUDED_UHD_TYPES_RANGES_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+//! Range of floating-point values
+typedef struct {
+    //! First value
+    double start;
+    //! Last value
+    double stop;
+    //! Granularity
+    double step;
+} uhd_range_t;
+
+#ifdef __cplusplus
+#include <uhd/types/ranges.hpp>
+#include <string>
+
+struct uhd_meta_range_t {
+    uhd::meta_range_t meta_range_cpp;
+    std::string last_error;
+};
+
+extern "C" {
+#else
+struct uhd_meta_range_t;
+#endif
+
+//! C-level interface for dealing with a list of ranges
+/*!
+ * See uhd::meta_range_t for more details.
+ */
+typedef struct uhd_meta_range_t* uhd_meta_range_handle;
+
+//! Get a string representation of the given range
+UHD_API uhd_error uhd_range_to_pp_string(
+    const uhd_range_t *range,
+    char* pp_string_out,
+    size_t strbuffer_len
+);
+
+//! Create a meta range handle
+/*!
+ * NOTE: Using a uhd_meta_range_handle before passing it into this function will
+ * result in undefined behavior.
+ */
+UHD_API uhd_error uhd_meta_range_make(
+    uhd_meta_range_handle* h
+);
+
+//! Destroy a meta range handle
+/*!
+ * NOTE: Using a uhd_meta_range_handle after passing it into this function will
+ * result in a segmentation fault.
+ */
+UHD_API uhd_error uhd_meta_range_free(
+    uhd_meta_range_handle* h
+);
+
+//! Get the overall start value for the given meta range
+UHD_API uhd_error uhd_meta_range_start(
+    uhd_meta_range_handle h,
+    double *start_out
+);
+
+//! Get the overall stop value for the given meta range
+UHD_API uhd_error uhd_meta_range_stop(
+    uhd_meta_range_handle h,
+    double *stop_out
+);
+
+//! Get the overall step value for the given meta range
+UHD_API uhd_error uhd_meta_range_step(
+    uhd_meta_range_handle h,
+    double *step_out
+);
+
+//! Clip the given value to a possible value in the given range
+UHD_API uhd_error uhd_meta_range_clip(
+    uhd_meta_range_handle h,
+    double value,
+    bool clip_step,
+    double *result_out
+);
+
+//! Get the number of ranges in the given meta range
+UHD_API uhd_error uhd_meta_range_size(
+    uhd_meta_range_handle h,
+    size_t *size_out
+);
+
+//! Add a range to the given meta range
+UHD_API uhd_error uhd_meta_range_push_back(
+    uhd_meta_range_handle h,
+    const uhd_range_t *range
+);
+
+//! Get the range at the given index
+UHD_API uhd_error uhd_meta_range_at(
+    uhd_meta_range_handle h,
+    size_t num,
+    uhd_range_t *range_out
+);
+
+//! Get a string representation of the given meta range
+UHD_API uhd_error uhd_meta_range_to_pp_string(
+    uhd_meta_range_handle h,
+    char* pp_string_out,
+    size_t strbuffer_len
+);
+
+//! Get the last error recorded by the underlying meta range
+UHD_API uhd_error uhd_meta_range_last_error(
+    uhd_meta_range_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+#ifdef __cplusplus
+}
+
+UHD_API uhd::range_t uhd_range_c_to_cpp(
+    const uhd_range_t *range_c
+);
+
+UHD_API void uhd_range_cpp_to_c(
+    const uhd::range_t &range_cpp,
+    uhd_range_t *range_c
+);
+#endif
+
+#endif /* INCLUDED_UHD_TYPES_RANGES_H */
diff --git a/host/include/uhd/types/sensors.h b/host/include/uhd/types/sensors.h
new file mode 100644
index 000000000..c0037c9f6
--- /dev/null
+++ b/host/include/uhd/types/sensors.h
@@ -0,0 +1,231 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_TYPES_SENSORS_H
+#define INCLUDED_UHD_TYPES_SENSORS_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#ifdef __cplusplus
+#include <uhd/types/sensors.hpp>
+#include <string>
+
+struct uhd_sensor_value_t {
+    // No default constructor, so we need a pointer
+    uhd::sensor_value_t* sensor_value_cpp;
+    std::string last_error;
+};
+extern "C" {
+#else
+struct uhd_sensor_value_t;
+#endif
+
+//! C-level interface for a UHD sensor
+/*!
+ * See uhd::sensor_value_t for more details.
+ *
+ * NOTE: Using a handle before calling a make function will result in undefined behavior.
+ */
+typedef struct uhd_sensor_value_t* uhd_sensor_value_handle;
+
+//! Sensor value types
+typedef enum {
+    UHD_SENSOR_VALUE_BOOLEAN = 98,
+    UHD_SENSOR_VALUE_INTEGER = 105,
+    UHD_SENSOR_VALUE_REALNUM = 114,
+    UHD_SENSOR_VALUE_STRING  = 115
+} uhd_sensor_value_data_type_t;
+
+//! Make a UHD sensor from a boolean.
+/*!
+ * \param h the sensor handle in which to place sensor
+ * \param name sensor name
+ * \param value sensor value
+ * \param utrue string representing "true"
+ * \param ufalse string representing "false"
+ * \returns UHD error code
+ */
+UHD_API uhd_error uhd_sensor_value_make_from_bool(
+    uhd_sensor_value_handle* h,
+    const char* name,
+    bool value,
+    const char* utrue,
+    const char* ufalse
+);
+
+//! Make a UHD sensor from an integer.
+/*!
+ * \param h the sensor value in which to place sensor
+ * \param name sensor name
+ * \param value sensor value
+ * \param unit sensor unit
+ * \param formatter printf-style format string for value string
+ * \returns UHD error code
+ */
+UHD_API uhd_error uhd_sensor_value_make_from_int(
+    uhd_sensor_value_handle* h,
+    const char* name,
+    int value,
+    const char* unit,
+    const char* formatter
+);
+
+//! Make a UHD sensor from a real number.
+/*!
+ * \param h the sensor value in which to place sensor
+ * \param name sensor name
+ * \param value sensor value
+ * \param unit sensor unit
+ * \param formatter printf-style format string for value string
+ * \returns UHD error code
+ */
+UHD_API uhd_error uhd_sensor_value_make_from_realnum(
+    uhd_sensor_value_handle* h,
+    const char* name,
+    double value,
+    const char* unit,
+    const char* formatter
+);
+
+//! Make a UHD sensor from a string.
+/*!
+ * \param h the sensor value in which to place sensor
+ * \param name sensor name
+ * \param value sensor value
+ * \param unit sensor unit
+ * \returns UHD error code
+ */
+UHD_API uhd_error uhd_sensor_value_make_from_string(
+    uhd_sensor_value_handle* h,
+    const char* name,
+    const char* value,
+    const char* unit
+);
+
+//! Free the given sensor handle.
+/*!
+ * Attempting to use the handle after calling this handle will
+ * result in a segmentation fault.
+ */
+UHD_API uhd_error uhd_sensor_value_free(
+    uhd_sensor_value_handle* h
+);
+
+//! Get the sensor's value as a boolean.
+UHD_API uhd_error uhd_sensor_value_to_bool(
+    uhd_sensor_value_handle h,
+    bool *value_out
+);
+
+//! Get the sensor's value as an integer.
+UHD_API uhd_error uhd_sensor_value_to_int(
+    uhd_sensor_value_handle h,
+    int *value_out
+);
+
+//! Get the sensor's value as a real number.
+UHD_API uhd_error uhd_sensor_value_to_realnum(
+    uhd_sensor_value_handle h,
+    double *value_out
+);
+
+//! Get the sensor's name.
+/*!
+ * NOTE: This function will overwrite any string in the given
+ * buffer before inserting the sensor name.
+ *
+ * \param h sensor handle
+ * \param name_out string buffer in which to place name
+ * \param strbuffer_len buffer length
+ */
+UHD_API uhd_error uhd_sensor_value_name(
+    uhd_sensor_value_handle h,
+    char* name_out,
+    size_t strbuffer_len
+);
+
+//! Get the sensor's value.
+/*!
+ * NOTE: This function will overwrite any string in the given
+ * buffer before inserting the sensor value.
+ *
+ * \param h sensor handle
+ * \param value_out string buffer in which to place value
+ * \param strbuffer_len buffer length
+ */
+UHD_API uhd_error uhd_sensor_value_value(
+    uhd_sensor_value_handle h,
+    char* value_out,
+    size_t strbuffer_len
+);
+
+//! Get the sensor's unit.
+/*!
+ * NOTE: This function will overwrite any string in the given
+ * buffer before inserting the sensor unit.
+ *
+ * \param h sensor handle
+ * \param unit_out string buffer in which to place unit
+ * \param strbuffer_len buffer length
+ */
+UHD_API uhd_error uhd_sensor_value_unit(
+    uhd_sensor_value_handle h,
+    char* unit_out,
+    size_t strbuffer_len
+);
+
+UHD_API uhd_error uhd_sensor_value_data_type(
+    uhd_sensor_value_handle h,
+    uhd_sensor_value_data_type_t *data_type_out
+);
+
+//! Get a pretty-print representation of the given sensor.
+/*!
+ * NOTE: This function will overwrite any string in the given
+ * buffer before inserting the string.
+ *
+ * \param h sensor handle
+ * \param pp_string_out string buffer in which to place pp_string
+ * \param strbuffer_len buffer length
+ */
+UHD_API uhd_error uhd_sensor_value_to_pp_string(
+    uhd_sensor_value_handle h,
+    char* pp_string_out,
+    size_t strbuffer_len
+);
+
+//! Get the last error logged by the sensor handle.
+/*!
+ * NOTE: This function will overwrite any string in the given
+ * buffer before inserting the error string.
+ *
+ * \param h sensor handle
+ * \param error_out string buffer in which to place error
+ * \param strbuffer_len buffer length
+ */
+UHD_API uhd_error uhd_sensor_value_last_error(
+    uhd_sensor_value_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_TYPES_SENSORS_H */
diff --git a/host/include/uhd/types/stream_cmd.hpp b/host/include/uhd/types/stream_cmd.hpp
index 3c34c9656..c24296bd6 100644
--- a/host/include/uhd/types/stream_cmd.hpp
+++ b/host/include/uhd/types/stream_cmd.hpp
@@ -1,19 +1,19 @@
-//
-// Copyright 2010-2012 Ettus Research LLC
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
+/*
+ * Copyright 2010-2012,2015 Ettus Research LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #ifndef INCLUDED_UHD_TYPES_STREAM_CMD_HPP
 #define INCLUDED_UHD_TYPES_STREAM_CMD_HPP
@@ -59,6 +59,6 @@ namespace uhd{
         stream_cmd_t(const stream_mode_t &stream_mode);
     };
 
-} //namespace uhd
+} /* namespace uhd */
 
 #endif /* INCLUDED_UHD_TYPES_STREAM_CMD_HPP */
diff --git a/host/include/uhd/types/tune_request.h b/host/include/uhd/types/tune_request.h
new file mode 100644
index 000000000..046350643
--- /dev/null
+++ b/host/include/uhd/types/tune_request.h
@@ -0,0 +1,61 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_TYPES_TUNE_REQUEST_H
+#define INCLUDED_UHD_TYPES_TUNE_REQUEST_H
+
+#include <uhd/config.h>
+
+#include <stdlib.h>
+
+//! Policy options for tunable elements in the RF chain.
+typedef enum {
+    //! Do not set this argument, use current setting.
+    UHD_TUNE_REQUEST_POLICY_NONE   = 78,
+    //! Automatically determine the argument's value.
+    UHD_TUNE_REQUEST_POLICY_AUTO   = 65,
+    //! Use the argument's value for the setting.
+    UHD_TUNE_REQUEST_POLICY_MANUAL = 77
+} uhd_tune_request_policy_t;
+
+//! Instructs implementation how to tune the RF chain
+/*!
+ * See uhd::tune_request_t for more details.
+ */
+typedef struct {
+    //! Target frequency for RF chain in Hz
+    double target_freq;
+    //! RF frequency policy
+    uhd_tune_request_policy_t rf_freq_policy;
+    //! RF frequency in Hz
+    double rf_freq;
+    //! DSP frequency policy
+    uhd_tune_request_policy_t dsp_freq_policy;
+    //! DSP frequency in Hz
+    double dsp_freq;
+    //! Key-value pairs delimited by commas
+    char* args;
+} uhd_tune_request_t;
+
+#ifdef __cplusplus
+#include <uhd/types/tune_request.hpp>
+
+UHD_API uhd::tune_request_t uhd_tune_request_c_to_cpp(uhd_tune_request_t *tune_request_c);
+
+#endif
+
+#endif /* INCLUDED_UHD_TYPES_TUNE_REQUEST_H */
diff --git a/host/include/uhd/types/tune_result.h b/host/include/uhd/types/tune_result.h
new file mode 100644
index 000000000..e0d00cd2e
--- /dev/null
+++ b/host/include/uhd/types/tune_result.h
@@ -0,0 +1,60 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_TYPES_TUNE_RESULT_H
+#define INCLUDED_UHD_TYPES_TUNE_RESULT_H
+
+#include <uhd/config.h>
+
+#include <stdlib.h>
+
+//! Stores RF and DSP tuned frequencies.
+/*!
+ * See uhd::tune_result_t for more details.
+ */
+typedef struct {
+    //! Target RF frequency, clipped to be within system range
+    double clipped_rf_freq;
+    //! Target RF frequency, including RF FE offset
+    double target_rf_freq;
+    //! Frequency to which RF LO is actually tuned
+    double actual_rf_freq;
+    //! Frequency the CORDIC must adjust the RF
+    double target_dsp_freq;
+    //! Frequency to which the CORDIC in the DSP actually tuned
+    double actual_dsp_freq;
+} uhd_tune_result_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//! Create a pretty print representation of this tune result.
+UHD_API void uhd_tune_result_to_pp_string(uhd_tune_result_t *tune_result,
+                                          char* pp_string_out, size_t strbuffer_len);
+
+#ifdef __cplusplus
+}
+#include <uhd/types/tune_result.hpp>
+
+UHD_API uhd::tune_result_t uhd_tune_result_c_to_cpp(uhd_tune_result_t *tune_result_c);
+
+UHD_API void uhd_tune_result_cpp_to_c(const uhd::tune_result_t &tune_result_cpp,
+                                      uhd_tune_result_t *tune_result_c);
+#endif
+
+#endif /* INCLUDED_UHD_TYPES_TUNE_RESULT_H */
diff --git a/host/include/uhd/types/usrp_info.h b/host/include/uhd/types/usrp_info.h
new file mode 100644
index 000000000..c118963da
--- /dev/null
+++ b/host/include/uhd/types/usrp_info.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015 Ettus Research LLC
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_UHD_TYPES_USRP_INFO_H
+#define INCLUDED_UHD_TYPES_USRP_INFO_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+//! USRP RX info
+/*!
+ * This struct is populated by uhd_usrp_get_rx_info().
+ */
+typedef struct {
+    //! Motherboard ID
+    char* mboard_id;
+    //! Motherboard name
+    char* mboard_name;
+    //! Motherboard serial
+    char* mboard_serial;
+    //! RX daughterboard ID
+    char* rx_id;
+    //! RX subdev name
+    char* rx_subdev_name;
+    //! RX subdev spec
+    char* rx_subdev_spec;
+    //! RX daughterboard serial
+    char* rx_serial;
+    //! RX daughterboard antenna
+    char* rx_antenna;
+} uhd_usrp_rx_info_t;
+
+//! USRP TX info
+/*!
+ * This struct is populated by uhd_usrp_get_tx_info().
+ */
+typedef struct {
+    //! Motherboard ID
+    char* mboard_id;
+    //! Motherboard name
+    char* mboard_name;
+    //! Motherboard serial
+    char* mboard_serial;
+    //! TX daughterboard ID
+    char* tx_id;
+    //! TX subdev name
+    char* tx_subdev_name;
+    //! TX subdev spec
+    char* tx_subdev_spec;
+    //! TX daughterboard serial
+    char* tx_serial;
+    //! TX daughterboard antenna
+    char* tx_antenna;
+} uhd_usrp_tx_info_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//! Clean up a uhd_usrp_rx_info_t populated by uhd_usrp_get_rx_info().
+/*!
+ * NOTE: If this function is passed a uhd_usrp_rx_info_t that has not
+ * been populated by uhd_usrp_get_rx_info(), it will produce a double-free
+ * error.
+ */
+UHD_API uhd_error uhd_usrp_rx_info_free(uhd_usrp_rx_info_t *rx_info);
+
+//! Clean up a uhd_usrp_tx_info_t populated by uhd_usrp_get_tx_info().
+/*!
+ * NOTE: If this function is passed a uhd_usrp_tx_info_t that has not
+ * been populated by uhd_usrp_get_tx_info(), it will produce a double-free
+ * error.
+ */
+UHD_API uhd_error uhd_usrp_tx_info_free(uhd_usrp_tx_info_t *tx_info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_TYPES_USRP_INFO_H */
diff --git a/host/include/uhd/usrp/CMakeLists.txt b/host/include/uhd/usrp/CMakeLists.txt
index d30a2900a..e974f808d 100644
--- a/host/include/uhd/usrp/CMakeLists.txt
+++ b/host/include/uhd/usrp/CMakeLists.txt
@@ -1,5 +1,5 @@
 #
-# Copyright 2010-2011 Ettus Research LLC
+# Copyright 2010-2011,2015 Ettus Research LLC
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,7 +15,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-
 UHD_INSTALL(FILES
 
     #### dboard headers ###
@@ -36,3 +35,14 @@ UHD_INSTALL(FILES
     DESTINATION ${INCLUDE_DIR}/uhd/usrp
     COMPONENT headers
 )
+
+IF(ENABLE_C_API)
+    UHD_INSTALL(FILES
+        dboard_eeprom.h
+        mboard_eeprom.h
+        subdev_spec.h
+        usrp.h
+        DESTINATION ${INCLUDE_DIR}/uhd/usrp
+        COMPONENT headers
+    )
+ENDIF(ENABLE_C_API)
diff --git a/host/include/uhd/usrp/dboard_eeprom.h b/host/include/uhd/usrp/dboard_eeprom.h
new file mode 100644
index 000000000..6980de0ce
--- /dev/null
+++ b/host/include/uhd/usrp/dboard_eeprom.h
@@ -0,0 +1,110 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_USRP_DBOARD_EEPROM_H
+#define INCLUDED_UHD_USRP_DBOARD_EEPROM_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#ifdef __cplusplus
+#include <uhd/usrp/dboard_eeprom.hpp>
+#include <string>
+
+struct uhd_dboard_eeprom_t {
+    uhd::usrp::dboard_eeprom_t dboard_eeprom_cpp;
+    std::string last_error;
+};
+
+extern "C" {
+#else
+struct uhd_dboard_eeprom_t;
+#endif
+
+//! A C-level interface for interacting with a daughterboard EEPROM
+/*!
+ * See uhd::usrp::dboard_eeprom_t for more details.
+ *
+ * NOTE: Using a handle before passing it into uhd_dboard_eeprom_make() will
+ * result in undefined behavior.
+ */
+typedef struct uhd_dboard_eeprom_t* uhd_dboard_eeprom_handle;
+
+//! Create handle for a USRP daughterboard EEPROM
+UHD_API uhd_error uhd_dboard_eeprom_make(
+    uhd_dboard_eeprom_handle* h
+);
+
+//! Safely destroy the given handle
+/*!
+ * NOTE: Using a handle after passing it into this function will result in
+ * a segmentation fault.
+ */
+UHD_API uhd_error uhd_dboard_eeprom_free(
+    uhd_dboard_eeprom_handle* h
+);
+
+//! Get the ID associated with the given daughterboard as a string hex representation
+UHD_API uhd_error uhd_dboard_eeprom_get_id(
+    uhd_dboard_eeprom_handle h,
+    char* id_out,
+    size_t strbuffer_len
+);
+
+//! Set the daughterboard ID using a string hex representation
+UHD_API uhd_error uhd_dboard_eeprom_set_id(
+    uhd_dboard_eeprom_handle h,
+    const char* id
+);
+
+//! Get the daughterboard's serial
+UHD_API uhd_error uhd_dboard_eeprom_get_serial(
+    uhd_dboard_eeprom_handle h,
+    char* serial_out,
+    size_t strbuffer_len
+);
+
+//! Set the daughterboard's serial
+UHD_API uhd_error uhd_dboard_eeprom_set_serial(
+    uhd_dboard_eeprom_handle h,
+    const char* serial
+);
+
+//! Get the daughterboard's revision (not always present)
+UHD_API uhd_error uhd_dboard_eeprom_get_revision(
+    uhd_dboard_eeprom_handle h,
+    int* revision_out
+);
+
+//! Set the daughterboard's revision
+UHD_API uhd_error uhd_dboard_eeprom_set_revision(
+    uhd_dboard_eeprom_handle h,
+    int revision
+);
+
+//! Get the last error reported by the handle
+UHD_API uhd_error uhd_dboard_eeprom_last_error(
+    uhd_dboard_eeprom_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_USRP_DBOARD_EEPROM_H */
diff --git a/host/include/uhd/usrp/mboard_eeprom.h b/host/include/uhd/usrp/mboard_eeprom.h
new file mode 100644
index 000000000..b4474a26d
--- /dev/null
+++ b/host/include/uhd/usrp/mboard_eeprom.h
@@ -0,0 +1,87 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_USRP_MBOARD_EEPROM_H
+#define INCLUDED_UHD_USRP_MBOARD_EEPROM_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#ifdef __cplusplus
+#include <uhd/usrp/mboard_eeprom.hpp>
+#include <string>
+
+struct uhd_mboard_eeprom_t {
+    uhd::usrp::mboard_eeprom_t mboard_eeprom_cpp;
+    std::string last_error;
+};
+
+extern "C" {
+#else
+struct uhd_mboard_eeprom_t;
+#endif
+
+//! A C-level interface for interacting with a USRP motherboard's EEPROM
+/*!
+ * See uhd::usrp::mboard_eeprom_t for more details.
+ *
+ * NOTE: Using a handle before passing it into uhd_mboard_eeprom_make() will
+ * result in undefined behavior.
+ */
+typedef struct uhd_mboard_eeprom_t* uhd_mboard_eeprom_handle;
+
+//! Create a handle for working with a USRP motherboard EEPROM
+UHD_API uhd_error uhd_mboard_eeprom_make(
+    uhd_mboard_eeprom_handle* h
+);
+
+//! Free a USRP motherboard EEPROM handle
+/*!
+ * NOTE: Using a handle after passing it into this function will result in
+ * a segmentation fault.
+ */
+UHD_API uhd_error uhd_mboard_eeprom_free(
+    uhd_mboard_eeprom_handle* h
+);
+
+//! Get the value associated with the given EEPROM key
+UHD_API uhd_error uhd_mboard_eeprom_get_value(
+    uhd_mboard_eeprom_handle h,
+    const char* key,
+    char* value_out,
+    size_t strbuffer_len
+);
+
+//! Set the value for the given EEPROM key
+UHD_API uhd_error uhd_mboard_eeprom_set_value(
+    uhd_mboard_eeprom_handle h,
+    const char* key,
+    const char* value
+);
+
+//! Get the last error recorded by the handle
+UHD_API uhd_error uhd_mboard_eeprom_last_error(
+    uhd_mboard_eeprom_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_USRP_MBOARD_EEPROM_H */
diff --git a/host/include/uhd/usrp/subdev_spec.h b/host/include/uhd/usrp/subdev_spec.h
new file mode 100644
index 000000000..f847181b7
--- /dev/null
+++ b/host/include/uhd/usrp/subdev_spec.h
@@ -0,0 +1,137 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_USRP_SUBDEV_SPEC_H
+#define INCLUDED_UHD_USRP_SUBDEV_SPEC_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#include <stdbool.h>
+
+//! Subdevice specification
+typedef struct {
+    // Daughterboard slot name
+    char* db_name;
+    //! Subdevice name
+    char* sd_name;
+} uhd_subdev_spec_pair_t;
+
+#ifdef __cplusplus
+#include <uhd/usrp/subdev_spec.hpp>
+#include <string>
+
+struct uhd_subdev_spec_t {
+    uhd::usrp::subdev_spec_t subdev_spec_cpp;
+    std::string last_error;
+};
+
+extern "C" {
+#else
+struct uhd_subdev_spec_t;
+#endif
+
+//! A C-level interface for working with a list of subdevice specifications
+/*!
+ * See uhd::usrp::subdev_spec_t for more details.
+ *
+ * NOTE: Using a handle before passing it into uhd_subdev_spec_make() will result in
+ * undefined behavior.
+ */
+typedef struct uhd_subdev_spec_t* uhd_subdev_spec_handle;
+
+//! Safely destroy any memory created in the generation of a uhd_subdev_spec_pair_t
+UHD_API uhd_error uhd_subdev_spec_pair_free(
+    uhd_subdev_spec_pair_t *subdev_spec_pair
+);
+
+//! Check to see if two subdevice specifications are equal
+UHD_API uhd_error uhd_subdev_spec_pairs_equal(
+    const uhd_subdev_spec_pair_t* first,
+    const uhd_subdev_spec_pair_t* second,
+    bool *result_out
+);
+
+//! Create a handle for a list of subdevice specifications
+UHD_API uhd_error uhd_subdev_spec_make(
+    uhd_subdev_spec_handle* h,
+    const char* markup
+);
+
+//! Safely destroy a subdevice specification handle
+/*!
+ * NOTE: Using a handle after passing it into this function will result in
+ * a segmentation fault.
+ */
+UHD_API uhd_error uhd_subdev_spec_free(
+    uhd_subdev_spec_handle* h
+);
+
+//! Check how many subdevice specifications are in this list
+UHD_API uhd_error uhd_subdev_spec_size(
+    uhd_subdev_spec_handle h,
+    size_t *size_out
+);
+
+//! Add a subdevice specification to this list
+UHD_API uhd_error uhd_subdev_spec_push_back(
+    uhd_subdev_spec_handle h,
+    const char* markup
+);
+
+//! Get the subdevice specification at the given index
+UHD_API uhd_error uhd_subdev_spec_at(
+    uhd_subdev_spec_handle h,
+    size_t num,
+    uhd_subdev_spec_pair_t *subdev_spec_pair_out
+);
+
+//! Get a string representation of the given list
+UHD_API uhd_error uhd_subdev_spec_to_pp_string(
+    uhd_subdev_spec_handle h,
+    char* pp_string_out,
+    size_t strbuffer_len
+);
+
+//! Get a markup string representation of the given list
+UHD_API uhd_error uhd_subdev_spec_to_string(
+    uhd_subdev_spec_handle h,
+    char* string_out,
+    size_t strbuffer_len
+);
+
+//! Get the last error recorded by the given handle
+UHD_API uhd_error uhd_subdev_spec_last_error(
+    uhd_subdev_spec_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+#ifdef __cplusplus
+}
+
+UHD_API uhd::usrp::subdev_spec_pair_t uhd_subdev_spec_pair_c_to_cpp(
+    const uhd_subdev_spec_pair_t* subdev_spec_pair_c
+);
+
+UHD_API void uhd_subdev_spec_pair_cpp_to_c(
+    const uhd::usrp::subdev_spec_pair_t &subdev_spec_pair_cpp,
+    uhd_subdev_spec_pair_t *subdev_spec_pair_c
+);
+#endif
+
+#endif /* INCLUDED_UHD_USRP_SUBDEV_SPEC_H */
diff --git a/host/include/uhd/usrp/usrp.h b/host/include/uhd/usrp/usrp.h
new file mode 100644
index 000000000..e828628c7
--- /dev/null
+++ b/host/include/uhd/usrp/usrp.h
@@ -0,0 +1,1242 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_USRP_H
+#define INCLUDED_UHD_USRP_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+#include <uhd/types/metadata.h>
+#include <uhd/types/ranges.h>
+#include <uhd/types/sensors.h>
+#include <uhd/types/tune_request.h>
+#include <uhd/types/tune_result.h>
+#include <uhd/types/usrp_info.h>
+#include <uhd/usrp/mboard_eeprom.h>
+#include <uhd/usrp/dboard_eeprom.h>
+#include <uhd/usrp/subdev_spec.h>
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <time.h>
+
+/*
+ * Streamers
+ */
+
+//! A struct of parameters to construct a stream.
+/*!
+ * See uhd::stream_args_t for more details.
+ */
+typedef struct {
+    //! Format of host memory
+    char* cpu_format;
+    //! Over-the-wire format
+    char* otw_format;
+    //! Other stream args
+    char* args;
+    //! Array that lists channels
+    size_t* channel_list;
+    //! Number of channels
+    int n_channels;
+} uhd_stream_args_t;
+
+//! How streaming is issued to the device
+/*!
+ * See uhd::stream_cmd_t for more details.
+ */
+typedef enum {
+    //! Stream samples indefinitely
+    UHD_STREAM_MODE_START_CONTINUOUS   = 97,
+    //! End continuous streaming
+    UHD_STREAM_MODE_STOP_CONTINUOUS    = 111,
+    //! Stream some number of samples and finish
+    UHD_STREAM_MODE_NUM_SAMPS_AND_DONE = 100,
+    //! Stream some number of samples but expect more
+    UHD_STREAM_MODE_NUM_SAMPS_AND_MORE = 109
+} uhd_stream_mode_t;
+
+//! Define how device streams to host
+/*!
+ * See uhd::stream_cmd_t for more details.
+ */
+typedef struct {
+    //! How streaming is issued to the device
+    uhd_stream_mode_t stream_mode;
+    //! Number of samples
+    size_t num_samps;
+    //! Stream now?
+    bool stream_now;
+    //! If not now, then full seconds into future to stream
+    time_t time_spec_full_secs;
+    //! If not now, then fractional seconds into future to stream
+    double time_spec_frac_secs;
+} uhd_stream_cmd_t;
+
+struct uhd_rx_streamer;
+struct uhd_tx_streamer;
+
+//! C-level interface for working with an RX streamer
+/*!
+ * See uhd::rx_streamer for more details.
+ */
+typedef struct uhd_rx_streamer* uhd_rx_streamer_handle;
+
+//! C-level interface for working with a TX streamer
+/*!
+ * See uhd::tx_streamer for more details.
+ */
+typedef struct uhd_tx_streamer* uhd_tx_streamer_handle;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * RX Streamer
+ */
+
+//! Create an RX streamer handle.
+/*!
+ * NOTE: Using this streamer before passing it into uhd_usrp_get_rx_stream()
+ * will result in undefined behavior.
+ */
+UHD_API uhd_error uhd_rx_streamer_make(
+    uhd_rx_streamer_handle *h
+);
+
+//! Free an RX streamer handle.
+/*!
+ * NOTE: Using a streamer after passing it into this function will result
+ * in a segmentation fault.
+ */
+UHD_API uhd_error uhd_rx_streamer_free(
+    uhd_rx_streamer_handle *h
+);
+
+//! Get the number of channels associated with this streamer
+UHD_API uhd_error uhd_rx_streamer_num_channels(
+    uhd_rx_streamer_handle h,
+    size_t *num_channels_out
+);
+
+//! Get the max number of samples per buffer per packet
+UHD_API uhd_error uhd_rx_streamer_max_num_samps(
+    uhd_rx_streamer_handle h,
+    size_t *max_num_samps_out
+);
+
+//! Receive buffers containing samples into the given RX streamer
+/*!
+ * See uhd::rx_streamer::recv() for more details.
+ *
+ * \param h RX streamer handle
+ * \param buffs pointer to buffers in which to receive samples
+ * \param samps_per_buffer max number of samples per buffer
+ * \param md handle to RX metadata in which to receive results
+ * \param timeout timeout in seconds to wait for a packet
+ * \param one_packet send a single packet
+ * \param items_recvd pointer to output variable for number of samples received
+ */
+UHD_API uhd_error uhd_rx_streamer_recv(
+    uhd_rx_streamer_handle h,
+    void** buffs,
+    size_t samps_per_buff,
+    uhd_rx_metadata_handle md,
+    double timeout,
+    bool one_packet,
+    size_t *items_recvd
+);
+
+//! Issue the given stream command
+/*!
+ * See uhd::rx_streamer::issue_stream_cmd() for more details.
+ */
+UHD_API uhd_error uhd_rx_streamer_issue_stream_cmd(
+    uhd_rx_streamer_handle h,
+    const uhd_stream_cmd_t *stream_cmd
+);
+
+//! Get the last error reported by the RX streamer
+/*!
+ * NOTE: This will overwrite the string currently in error_out before
+ * using it to return its error.
+ *
+ * \param h RX streamer handle
+ * \param error_out string buffer in which to place error
+ * \param strbuffer_len buffer size
+ */
+UHD_API uhd_error uhd_rx_streamer_last_error(
+    uhd_rx_streamer_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+/*
+ * TX Streamer
+ */
+
+//! Create an TX streamer handle.
+/*!
+ * NOTE: Using this streamer before passing it into uhd_usrp_get_tx_stream()
+ * will result in undefined behavior.
+ */
+UHD_API uhd_error uhd_tx_streamer_make(
+    uhd_tx_streamer_handle *h
+);
+
+//! Free an TX streamer handle.
+/*!
+ * NOTE: Using a streamer after passing it into this function will result
+ * in a segmentation fault.
+ */
+UHD_API uhd_error uhd_tx_streamer_free(
+    uhd_tx_streamer_handle *h
+);
+
+//! Get the number of channels associated with this streamer
+UHD_API uhd_error uhd_tx_streamer_num_channels(
+    uhd_tx_streamer_handle h,
+    size_t *num_channels_out
+);
+
+//! Get the max number of samples per buffer per packet
+UHD_API uhd_error uhd_tx_streamer_max_num_samps(
+    uhd_tx_streamer_handle h,
+    size_t *max_num_samps_out
+);
+
+//! Send buffers containing samples described by the metadata
+/*!
+ * See uhd::tx_streamer::send() for more details.
+ *
+ * \param h TX streamer handle
+ * \param buffs pointer to buffers containing samples to send
+ * \param samps_per_buffer max number of samples per buffer
+ * \param md handle to TX metadata
+ * \param timeout timeout in seconds to wait for a packet
+ * \param items_sent pointer to output variable for number of samples send
+ */
+UHD_API uhd_error uhd_tx_streamer_send(
+    uhd_tx_streamer_handle h,
+    const void **buffs,
+    size_t samps_per_buff,
+    uhd_tx_metadata_handle md,
+    double timeout,
+    size_t *items_sent
+);
+
+//! Receive an asynchronous message from this streamer
+/*!
+ * See uhd::tx_streamer::recv_async_msg() for more details.
+ */
+UHD_API uhd_error uhd_tx_streamer_recv_async_msg(
+    uhd_tx_streamer_handle h,
+    uhd_async_metadata_handle md,
+    double timeout,
+    bool *valid
+);
+
+//! Get the last error reported by the TX streamer
+/*!
+ * NOTE: This will overwrite the string currently in error_out before
+ * using it to return its error.
+ *
+ * \param h TX streamer handle
+ * \param error_out string buffer in which to place error
+ * \param strbuffer_len buffer size
+ */
+UHD_API uhd_error uhd_tx_streamer_last_error(
+    uhd_tx_streamer_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+/****************************************************************************
+ * Public Datatypes for USRP / streamer handling.
+ ***************************************************************************/
+struct uhd_usrp;
+
+//! C-level interface for working with a USRP device
+/*
+ * See uhd::usrp::multi_usrp for more details.
+ *
+ * NOTE: You must pass this handle into uhd_usrp_make before using it.
+ */
+typedef struct uhd_usrp* uhd_usrp_handle;
+
+/****************************************************************************
+ * USRP Make / Free API calls
+ ***************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//! Create a USRP handle.
+/*!
+ * \param h the handle
+ * \param args device args (e.g. "type=x300")
+ */
+UHD_API uhd_error uhd_usrp_make(
+    uhd_usrp_handle *h,
+    const char *args
+);
+
+//! Safely destroy the USRP object underlying the handle.
+/*!
+ * NOTE: Attempting to use a USRP handle after passing it into this function
+ * will result in a segmentation fault.
+ */
+UHD_API uhd_error uhd_usrp_free(
+    uhd_usrp_handle *h
+);
+
+//! Get the last error reported by the USRP handle
+UHD_API uhd_error uhd_usrp_last_error(
+    uhd_usrp_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+//! Create RX streamer from a USRP handle and given stream args
+UHD_API uhd_error uhd_usrp_get_rx_stream(
+    uhd_usrp_handle h,
+    uhd_stream_args_t *stream_args,
+    uhd_rx_streamer_handle h_out
+);
+
+//! Create TX streamer from a USRP handle and given stream args
+UHD_API uhd_error uhd_usrp_get_tx_stream(
+    uhd_usrp_handle h,
+    uhd_stream_args_t *stream_args,
+    uhd_tx_streamer_handle h_out
+);
+
+/****************************************************************************
+ * multi_usrp API calls
+ ***************************************************************************/
+
+//! Get RX info from the USRP device
+/*!
+ * NOTE: After calling this function, uhd_usrp_rx_info_free() must be called on info_out.
+ */
+UHD_API uhd_error uhd_usrp_get_rx_info(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_usrp_rx_info_t *info_out
+);
+
+//! Get TX info from the USRP device
+/*!
+ * NOTE: After calling this function, uhd_usrp_tx_info_free() must be called on info_out.
+ */
+UHD_API uhd_error uhd_usrp_get_tx_info(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_usrp_tx_info_t *info_out
+);
+
+/****************************************************************************
+ * Motherboard methods
+ ***************************************************************************/
+
+//! Set the master clock rate.
+/*!
+ * See uhd::usrp::multi_usrp::set_master_clock_rate() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_master_clock_rate(
+    uhd_usrp_handle h,
+    double rate,
+    size_t mboard
+);
+
+//! Get the master clock rate.
+/*!
+ * See uhd::usrp::multi_usrp::get_master_clock_rate() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_master_clock_rate(
+    uhd_usrp_handle h,
+    size_t mboard,
+    double *clock_rate_out
+);
+
+//! Get a pretty-print representation of the USRP device.
+/*!
+ * See uhd::usrp::multi_usrp::get_pp_string() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_pp_string(
+    uhd_usrp_handle h,
+    char* pp_string_out,
+    size_t strbuffer_len
+);
+
+//! Get the motherboard name for the given device
+/*!
+ * See uhd::usrp::multi_usrp::get_mboard_name() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_mboard_name(
+    uhd_usrp_handle h,
+    size_t mboard,
+    char* mboard_name_out,
+    size_t strbuffer_len
+);
+
+//! Get the USRP device's current internal time
+/*!
+ * See uhd::usrp::multi_usrp::get_time_now() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_time_now(
+    uhd_usrp_handle h,
+    size_t mboard,
+    time_t *full_secs_out,
+    double *frac_secs_out
+);
+
+//! Get the time when this device's last PPS pulse occurred
+/*!
+ * See uhd::usrp::multi_usrp::get_time_last_pps() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_time_last_pps(
+    uhd_usrp_handle h,
+    size_t mboard,
+    time_t *full_secs_out,
+    double *frac_secs_out
+);
+
+//! Set the USRP device's time
+/*!
+ * See uhd::usrp::multi_usrp::set_time_now() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_time_now(
+    uhd_usrp_handle h,
+    time_t full_secs,
+    double frac_secs,
+    size_t mboard
+);
+
+//! Set the USRP device's time to the given value upon the next PPS detection
+/*!
+ * See uhd::usrp::multi_usrp::set_time_next_pps() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_time_next_pps(
+    uhd_usrp_handle h,
+    time_t full_secs,
+    double frac_secs,
+    size_t mboard
+);
+
+//! Synchronize the time across all motherboards
+/*!
+ * See uhd::usrp::multi_usrp::set_time_unknown_pps() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_time_unknown_pps(
+    uhd_usrp_handle h,
+    time_t full_secs,
+    double frac_secs
+);
+
+//! Are all motherboard times synchronized?
+UHD_API uhd_error uhd_usrp_get_time_synchronized(
+    uhd_usrp_handle h,
+    bool *result_out
+);
+
+//! Set the time at which timed commands will take place
+/*!
+ * See uhd::usrp::multi_usrp::set_command_time() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_command_time(
+    uhd_usrp_handle h,
+    time_t full_secs,
+    double frac_secs,
+    size_t mboard
+);
+
+//! Clear the command time so that commands are sent ASAP
+UHD_API uhd_error uhd_usrp_clear_command_time(
+    uhd_usrp_handle h,
+    size_t mboard
+);
+
+//! Issue a stream command to tell the device to send samples to the host
+/*!
+ * See uhd::usrp::multi_usrp::issue_stream_command() for more details.
+ */
+UHD_API uhd_error uhd_usrp_issue_stream_cmd(
+    uhd_usrp_handle h,
+    uhd_stream_cmd_t *stream_cmd,
+    size_t chan
+);
+
+//! Set the time source for the given device
+/*!
+ * See uhd::usrp::multi_usrp::set_time_source() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_time_source(
+    uhd_usrp_handle h,
+    const char* time_source,
+    size_t mboard
+);
+
+//! Get the time source for the given device
+/*!
+ * See uhd::usrp::multi_usrp::get_time_source() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_time_source(
+    uhd_usrp_handle h,
+    size_t mboard,
+    char* time_source_out,
+    size_t strbuffer_len
+);
+
+//! Get a list of time sources for the given device
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of time sources.
+ *
+ * \param h USRP handle
+ * \param mboard which motherboard to use
+ * \param time_sources_out string buffer in which to place time sources
+ * \param strbuffer_len buffer length
+ * \param num_time_sources_out variable in which to place number of time sources
+ */
+UHD_API uhd_error uhd_usrp_get_time_sources(
+    uhd_usrp_handle h,
+    size_t mboard,
+    char* time_sources_out,
+    size_t strbuffer_len,
+    size_t *num_time_sources_out
+);
+
+//! Set the given device's clock source
+/*!
+ * See uhd::usrp::multi_usrp::set_clock_source() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_clock_source(
+    uhd_usrp_handle h,
+    const char* clock_source,
+    size_t mboard
+);
+
+//! Get the given device's clock source
+/*!
+ * See uhd::usrp::multi_usrp::get_clock_source() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_clock_source(
+    uhd_usrp_handle h,
+    size_t mboard,
+    char* clock_source_out,
+    size_t strbuffer_len
+);
+
+//! Get a list of clock sources for the given device
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of clock sources.
+ *
+ * \param h USRP handle
+ * \param mboard which motherboard to use
+ * \param clock_sources_out string buffer in which to place clock sources
+ * \param strbuffer_len buffer length
+ * \param num_clock_sources_out variable in which to place number of clock sources
+ */
+UHD_API uhd_error uhd_usrp_get_clock_sources(
+    uhd_usrp_handle h,
+    size_t mboard,
+    char* clock_sources_out,
+    size_t strbuffer_len,
+    size_t *num_clock_sources_out
+);
+
+//! Enable or disable sending the clock source to an output connector
+/*!
+ * See uhd::usrp::set_clock_source_out() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_clock_source_out(
+    uhd_usrp_handle h,
+    bool enb,
+    size_t mboard
+);
+
+//! Enable or disable sending the time source to an output connector
+/*!
+ * See uhd::usrp::set_time_source_out() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_time_source_out(
+    uhd_usrp_handle h,
+    bool enb,
+    size_t mboard
+);
+
+//! Get the number of devices associated with the given USRP handle
+UHD_API uhd_error uhd_usrp_get_num_mboards(
+    uhd_usrp_handle h,
+    size_t *num_mboards_out
+);
+
+//! Get the value associated with the given sensor name
+UHD_API uhd_error uhd_usrp_get_mboard_sensor(
+    uhd_usrp_handle h,
+    const char* name,
+    size_t mboard,
+    uhd_sensor_value_handle sensor_value_out
+);
+
+//! Get a list of motherboard sensors for the given device
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of motherboard sensors.
+ *
+ * \param h USRP handle
+ * \param mboard which motherboard to use
+ * \param mboard_sensors_out string buffer in which to place motherboard sensors
+ * \param strbuffer_len buffer length
+ * \param num_mboard_sensors_out variable in which to place number of motherboard sensors
+ */
+UHD_API uhd_error uhd_usrp_get_mboard_sensor_names(
+    uhd_usrp_handle h,
+    size_t mboard,
+    char* mboard_sensor_names_out,
+    size_t strbuffer_len,
+    size_t *num_mboard_sensors_out
+);
+
+//! Perform a write on a user configuration register bus
+/*!
+ * See uhd::usrp::multi_usrp::set_user_register() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_user_register(
+    uhd_usrp_handle h,
+    uint8_t addr,
+    uint32_t data,
+    size_t mboard
+);
+
+/****************************************************************************
+ * EEPROM access methods
+ ***************************************************************************/
+
+//! Get a handle for the given motherboard's EEPROM
+UHD_API uhd_error uhd_usrp_get_mboard_eeprom(
+    uhd_usrp_handle h,
+    uhd_mboard_eeprom_handle mb_eeprom,
+    size_t mboard
+);
+
+//! Set values in the given motherboard's EEPROM
+UHD_API uhd_error uhd_usrp_set_mboard_eeprom(
+    uhd_usrp_handle h,
+    uhd_mboard_eeprom_handle mb_eeprom,
+    size_t mboard
+);
+
+//! Get a handle for the given device's daughterboard EEPROM
+UHD_API uhd_error uhd_usrp_get_dboard_eeprom(
+    uhd_usrp_handle h,
+    uhd_dboard_eeprom_handle db_eeprom,
+    const char* unit,
+    const char* slot,
+    size_t mboard
+);
+
+//! Set values in the given daughterboard's EEPROM
+UHD_API uhd_error uhd_usrp_set_dboard_eeprom(
+    uhd_usrp_handle h,
+    uhd_dboard_eeprom_handle db_eeprom,
+    const char* unit,
+    const char* slot,
+    size_t mboard
+);
+
+/****************************************************************************
+ * RX methods
+ ***************************************************************************/
+
+//! Map the given device's RX frontend to a channel
+/*!
+ * See uhd::usrp::multi_usrp::set_rx_subdev_spec() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_rx_subdev_spec(
+    uhd_usrp_handle h,
+    uhd_subdev_spec_handle subdev_spec,
+    size_t mboard
+);
+
+//! Get the RX frontend specfication for the given device
+UHD_API uhd_error uhd_usrp_get_rx_subdev_spec(
+    uhd_usrp_handle h,
+    size_t mboard,
+    uhd_subdev_spec_handle subdev_spec_out
+);
+
+//! Get the number of RX channels for the given handle
+UHD_API uhd_error uhd_usrp_get_rx_num_channels(
+    uhd_usrp_handle h,
+    size_t *num_channels_out
+);
+
+//! Get the name for the RX frontend
+UHD_API uhd_error uhd_usrp_get_rx_subdev_name(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* rx_subdev_name_out,
+    size_t strbuffer_len
+);
+
+//! Set the given RX channel's sample rate (in Sps)
+UHD_API uhd_error uhd_usrp_set_rx_rate(
+    uhd_usrp_handle h,
+    double rate,
+    size_t chan
+);
+
+//! Get the given RX channel's sample rate (in Sps)
+UHD_API uhd_error uhd_usrp_get_rx_rate(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *rate_out
+);
+
+//! Get a range of possible RX rates for the given channel
+UHD_API uhd_error uhd_usrp_get_rx_rates(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle rates_out
+);
+
+//! Set the given channel's center RX frequency
+UHD_API uhd_error uhd_usrp_set_rx_freq(
+    uhd_usrp_handle h,
+    uhd_tune_request_t *tune_request,
+    size_t chan,
+    uhd_tune_result_t *tune_result
+);
+
+//! Get the given channel's center RX frequency
+UHD_API uhd_error uhd_usrp_get_rx_freq(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *freq_out
+);
+
+//! Get all possible center frequency ranges for the given channel
+/*!
+ * See uhd::usrp::multi_usrp::get_rx_freq_range() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_rx_freq_range(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle freq_range_out
+);
+
+//! Get all possible RF frequency ranges for the given channel's RX RF frontend
+UHD_API uhd_error uhd_usrp_get_fe_rx_freq_range(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle freq_range_out
+);
+
+//! Set the RX gain for the given channel and name
+UHD_API uhd_error uhd_usrp_set_rx_gain(
+    uhd_usrp_handle h,
+    double gain,
+    size_t chan,
+    const char *gain_name
+);
+
+//! Set the normalized RX gain [0.0, 1.0] for the given channel
+/*!
+ * See uhd::usrp::multi_usrp::set_normalized_rx_gain() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_normalized_rx_gain(
+    uhd_usrp_handle h,
+    double gain,
+    size_t chan
+);
+
+//! Enable or disable the given channel's RX AGC module
+/*!
+ * See uhd::usrp::multi_usrp::set_rx_agc() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_rx_agc(
+    uhd_usrp_handle h,
+    bool enable,
+    size_t chan
+);
+
+//! Get the given channel's RX gain
+UHD_API uhd_error uhd_usrp_get_rx_gain(
+    uhd_usrp_handle h,
+    size_t chan,
+    const char *gain_name,
+    double *gain_out
+);
+
+//! Get the given channel's normalized RX gain [0.0, 1.0]
+/*!
+ * See uhd::usrp::multi_usrp::get_normalized_rx_gain() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_normalized_rx_gain(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *gain_out
+);
+
+//! Get all possible gain ranges for the given channel and name
+UHD_API uhd_error uhd_usrp_get_rx_gain_range(
+    uhd_usrp_handle h,
+    const char* name,
+    size_t chan,
+    uhd_meta_range_handle gain_range_out
+);
+
+//! Get a list of RX gain names for the given channel
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of RX gain names.
+ *
+ * \param h USRP handle
+ * \param channel which channel to use
+ * \param rx_gain_names_out string buffer in which to place RX gain names
+ * \param strbuffer_len buffer length
+ * \param num_rx_gain_names_out variable in which to place number of RX gain names
+ */
+UHD_API uhd_error uhd_usrp_get_rx_gain_names(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* gain_names_out,
+    size_t strbuffer_len,
+    size_t *num_rx_gain_names_out
+);
+
+//! Set the RX antenna for the given channel
+UHD_API uhd_error uhd_usrp_set_rx_antenna(
+    uhd_usrp_handle h,
+    const char* ant,
+    size_t chan
+);
+
+//! Get the RX antenna for the given channel
+UHD_API uhd_error uhd_usrp_get_rx_antenna(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* ant_out,
+    size_t strbuffer_len
+);
+
+//! Get a list of RX antennas associated with the given channels
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of RX gain names.
+ *
+ * \param h USRP handle
+ * \param channel which channel to use
+ * \param rx_antennas_out string buffer in which to place RX antennas
+ * \param strbuffer_len buffer length
+ * \param num_rx_antennas_out variable in which to place number of RX gain names
+ */
+UHD_API uhd_error uhd_usrp_get_rx_antennas(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* antennas_out,
+    size_t strbuffer_len,
+    size_t *num_rx_antennas_out
+);
+
+//! Get a list of RX sensors associated with the given channels
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of RX gain names.
+ *
+ * \param h USRP handle
+ * \param channel which channel to use
+ * \param sensor_names_out string buffer in which to place RX sensor names
+ * \param strbuffer_len buffer length
+ * \param num_rx_sensors_out variable in which to place number of RX sensor names
+ */
+UHD_API uhd_error uhd_usrp_get_rx_sensor_names(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* sensor_names_out,
+    size_t strbuffer_len,
+    size_t *num_rx_sensors_out
+);
+
+//! Set the bandwidth for the given channel's RX frontend
+UHD_API uhd_error uhd_usrp_set_rx_bandwidth(
+    uhd_usrp_handle h,
+    double bandwidth,
+    size_t chan
+);
+
+//! Get the bandwidth for the given channel's RX frontend
+UHD_API uhd_error uhd_usrp_get_rx_bandwidth(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *bandwidth_out
+);
+
+//! Get all possible bandwidth ranges for the given channel's RX frontend
+UHD_API uhd_error uhd_usrp_get_rx_bandwidth_range(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle bandwidth_range_out
+);
+
+//! Get the value for the given RX sensor
+UHD_API uhd_error uhd_usrp_get_rx_sensor(
+    uhd_usrp_handle h,
+    const char* name,
+    size_t chan,
+    uhd_sensor_value_handle sensor_value_out
+);
+
+//! Enable or disable RX DC offset correction for the given channel
+/*!
+ * See uhd::usrp::multi_usrp::set_rx_dc_offset() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_rx_dc_offset_enabled(
+    uhd_usrp_handle h,
+    bool enb,
+    size_t chan
+);
+
+//! Enable or disable RX IQ imbalance correction for the given channel
+UHD_API uhd_error uhd_usrp_set_rx_iq_balance_enabled(
+    uhd_usrp_handle h,
+    bool enb,
+    size_t chan
+);
+
+/****************************************************************************
+ * TX methods
+ ***************************************************************************/
+
+//! Map the given device's TX frontend to a channel
+/*!
+ * See uhd::usrp::multi_usrp::set_tx_subdev_spec() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_tx_subdev_spec(
+    uhd_usrp_handle h,
+    uhd_subdev_spec_handle subdev_spec,
+    size_t mboard
+);
+
+//! Get the TX frontend specfication for the given device
+UHD_API uhd_error uhd_usrp_get_tx_subdev_spec(
+    uhd_usrp_handle h,
+    size_t mboard,
+    uhd_subdev_spec_handle subdev_spec_out
+);
+
+//! Get the number of TX channels for the given handle
+UHD_API uhd_error uhd_usrp_get_tx_num_channels(
+    uhd_usrp_handle h,
+    size_t *num_channels_out
+);
+
+//! Get the name for the RX frontend
+UHD_API uhd_error uhd_usrp_get_tx_subdev_name(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* tx_subdev_name_out,
+    size_t strbuffer_len
+);
+
+//! Set the given RX channel's sample rate (in Sps)
+UHD_API uhd_error uhd_usrp_set_tx_rate(
+    uhd_usrp_handle h,
+    double rate,
+    size_t chan
+);
+
+//! Get the given RX channel's sample rate (in Sps)
+UHD_API uhd_error uhd_usrp_get_tx_rate(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *rate_out
+);
+
+//! Get a range of possible RX rates for the given channel
+UHD_API uhd_error uhd_usrp_get_tx_rates(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle rates_out
+);
+
+//! Set the given channel's center TX frequency
+UHD_API uhd_error uhd_usrp_set_tx_freq(
+    uhd_usrp_handle h,
+    uhd_tune_request_t *tune_request,
+    size_t chan,
+    uhd_tune_result_t *tune_result
+);
+
+//! Get the given channel's center TX frequency
+UHD_API uhd_error uhd_usrp_get_tx_freq(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *freq_out
+);
+
+//! Get all possible center frequency ranges for the given channel
+/*!
+ * See uhd::usrp::multi_usrp::get_rx_freq_range() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_tx_freq_range(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle freq_range_out
+);
+
+//! Get all possible RF frequency ranges for the given channel's TX RF frontend
+UHD_API uhd_error uhd_usrp_get_fe_tx_freq_range(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle freq_range_out
+);
+
+//! Set the TX gain for the given channel and name
+UHD_API uhd_error uhd_usrp_set_tx_gain(
+    uhd_usrp_handle h,
+    double gain,
+    size_t chan,
+    const char *gain_name
+);
+
+//! Set the normalized TX gain [0.0, 1.0] for the given channel
+/*!
+ * See uhd::usrp::multi_usrp::set_normalized_tx_gain() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_normalized_tx_gain(
+    uhd_usrp_handle h,
+    double gain,
+    size_t chan
+);
+
+//! Get all possible gain ranges for the given channel and name
+UHD_API uhd_error uhd_usrp_get_tx_gain_range(
+    uhd_usrp_handle h,
+    const char* name,
+    size_t chan,
+    uhd_meta_range_handle gain_range_out
+);
+
+//! Get the given channel's RX gain
+UHD_API uhd_error uhd_usrp_get_tx_gain(
+    uhd_usrp_handle h,
+    size_t chan,
+    const char *gain_name,
+    double *gain_out
+);
+
+//! Get the given channel's normalized TX gain [0.0, 1.0]
+/*!
+ * See uhd::usrp::multi_usrp::get_normalized_tx_gain() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_normalized_tx_gain(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *gain_out
+);
+
+//! Get a list of TX gain names for the given channel
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of TX gain names.
+ *
+ * \param h USRP handle
+ * \param channel which channel to use
+ * \param tx_gain_names_out string buffer in which to place TX gain names
+ * \param strbuffer_len buffer length
+ * \param num_tx_gain_names_out variable in which to place number of TX gain names
+ */
+UHD_API uhd_error uhd_usrp_get_tx_gain_names(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* gain_names_out,
+    size_t strbuffer_len,
+    size_t *num_tx_gain_names_out
+);
+
+//! Set the TX antenna for the given channel
+UHD_API uhd_error uhd_usrp_set_tx_antenna(
+    uhd_usrp_handle h,
+    const char* ant,
+    size_t chan
+);
+
+//! Get the TX antenna for the given channel
+UHD_API uhd_error uhd_usrp_get_tx_antenna(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* ant_out,
+    size_t strbuffer_len
+);
+
+//! Get a list of tx antennas associated with the given channels
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of tx gain names.
+ *
+ * \param h USRP handle
+ * \param channel which channel to use
+ * \param tx_antennas_out string buffer in which to place TX antennas
+ * \param strbuffer_len buffer length
+ * \param num_tx_antennas_out variable in which to place number of TX gain names
+ */
+UHD_API uhd_error uhd_usrp_get_tx_antennas(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* antennas_out,
+    size_t strbuffer_len,
+    size_t *num_tx_antennas_out
+);
+
+//! Set the bandwidth for the given channel's TX frontend
+UHD_API uhd_error uhd_usrp_set_tx_bandwidth(
+    uhd_usrp_handle h,
+    double bandwidth,
+    size_t chan
+);
+
+//! Get the bandwidth for the given channel's TX frontend
+UHD_API uhd_error uhd_usrp_get_tx_bandwidth(
+    uhd_usrp_handle h,
+    size_t chan,
+    double *bandwidth_out
+);
+
+//! Get all possible bandwidth ranges for the given channel's TX frontend
+UHD_API uhd_error uhd_usrp_get_tx_bandwidth_range(
+    uhd_usrp_handle h,
+    size_t chan,
+    uhd_meta_range_handle bandwidth_range_out
+);
+
+//! Get the value for the given TX sensor
+UHD_API uhd_error uhd_usrp_get_tx_sensor(
+    uhd_usrp_handle h,
+    const char* name,
+    size_t chan,
+    uhd_sensor_value_handle sensor_value_out
+);
+
+//! Get a list of TX sensors associated with the given channels
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of TX gain names.
+ *
+ * \param h USRP handle
+ * \param channel which channel to use
+ * \param sensor_names_out string buffer in which to place TX sensor names
+ * \param strbuffer_len buffer length
+ * \param num_tx_sensors_out variable in which to place number of TX sensor names
+ */
+UHD_API uhd_error uhd_usrp_get_tx_sensor_names(
+    uhd_usrp_handle h,
+    size_t chan,
+    char* sensor_names_out,
+    size_t strbuffer_len,
+    size_t *num_tx_sensors_out
+);
+
+//! Enable or disable TX DC offset correction for the given channel
+/*!
+ * See uhd::usrp::multi_usrp::set_tx_dc_offset() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_tx_dc_offset_enabled(
+    uhd_usrp_handle h,
+    bool enb,
+    size_t chan
+);
+
+//! Enable or disable TX IQ imbalance correction for the given channel
+UHD_API uhd_error uhd_usrp_set_tx_iq_balance_enabled(
+    uhd_usrp_handle h,
+    bool enb,
+    size_t chan
+);
+
+/****************************************************************************
+ * GPIO methods
+ ***************************************************************************/
+
+//! Get a list of GPIO banks associated with the given channels
+/*!
+ * The list will be returned as a comma-delimited list that can
+ * be parsed with strtok(). The function will also return the number
+ * of TX gain names.
+ *
+ * \param h USRP handle
+ * \param channel which channel to use
+ * \param gpio_banks_out string buffer in which to place GPIO banks
+ * \param strbuffer_len buffer length
+ * \param num_gpio_banks_out variable in which to place number of GPIO banks
+ */
+UHD_API uhd_error uhd_usrp_get_gpio_banks(
+    uhd_usrp_handle h,
+    size_t mboard,
+    char* gpio_banks_out,
+    size_t strbuffer_len,
+    size_t *num_gpio_banks_out
+);
+
+//! Set a GPIO attribute for a given GPIO bank
+/*!
+ * See uhd::usrp::multi_usrp::set_gpio_attr() for more details.
+ */
+UHD_API uhd_error uhd_usrp_set_gpio_attr(
+    uhd_usrp_handle h,
+    const char* bank,
+    const char* attr,
+    uint32_t value,
+    uint32_t mask,
+    size_t mboard
+);
+
+//! Get a GPIO attribute on a particular GPIO bank
+/*!
+ * See uhd::usrp::multi_usrp::get_gpio_attr() for more details.
+ */
+UHD_API uhd_error uhd_usrp_get_gpio_attr(
+    uhd_usrp_handle h,
+    const char* bank,
+    const char* attr,
+    size_t mboard,
+    uint32_t *attr_out
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_USRP_H */
diff --git a/host/include/uhd/usrp_clock/CMakeLists.txt b/host/include/uhd/usrp_clock/CMakeLists.txt
index a116e4982..518cb7737 100644
--- a/host/include/uhd/usrp_clock/CMakeLists.txt
+++ b/host/include/uhd/usrp_clock/CMakeLists.txt
@@ -21,3 +21,9 @@ UHD_INSTALL(FILES
     DESTINATION ${INCLUDE_DIR}/uhd/usrp_clock
     COMPONENT headers
 )
+
+IF(ENABLE_C_API)
+    UHD_INSTALL(FILES
+        usrp_clock.h
+    )
+ENDIF(ENABLE_C_API)
diff --git a/host/include/uhd/usrp_clock/usrp_clock.h b/host/include/uhd/usrp_clock/usrp_clock.h
new file mode 100644
index 000000000..2f5a1db29
--- /dev/null
+++ b/host/include/uhd/usrp_clock/usrp_clock.h
@@ -0,0 +1,117 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_USRP_CLOCK_H
+#define INCLUDED_UHD_USRP_CLOCK_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+#include <uhd/types/sensors.h>
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <time.h>
+
+/****************************************************************************
+ * Public Datatypes for USRP clock
+ ***************************************************************************/
+struct uhd_usrp_clock;
+
+//! A C-level interface for interacting with an Ettus Research clock device
+/*!
+ * See uhd::usrp_clock::multi_usrp_clock for more details.
+ *
+ * NOTE: Attempting to use a handle before passing it into uhd_usrp_clock_make()
+ * will result in undefined behavior.
+ */
+typedef struct uhd_usrp_clock* uhd_usrp_clock_handle;
+
+/****************************************************************************
+ * Make / Free API calls
+ ***************************************************************************/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*! Create a USRP Clock handle.
+ *
+ * \param h The handle
+ * \param args Device args (e.g. "addr=192.168.10.3")
+ */
+UHD_API uhd_error uhd_usrp_clock_make(
+    uhd_usrp_clock_handle *h,
+    const char *args
+);
+
+/*! Safely destroy the USRP_CLOCK object underlying the handle.
+ *
+ * Note: After calling this, usage of h may cause segmentation faults.
+ * However, multiple calling of uhd_usrp_free() is safe.
+ */
+UHD_API uhd_error uhd_usrp_clock_free(
+    uhd_usrp_clock_handle *h
+);
+
+//! Get last error
+UHD_API uhd_error uhd_usrp_clock_last_error(
+    uhd_usrp_clock_handle h,
+    char* error_out,
+    size_t strbuffer_len
+);
+
+//! Get board information in a nice output
+UHD_API uhd_error uhd_usrp_clock_get_pp_string(
+    uhd_usrp_clock_handle h,
+    char* pp_string_out,
+    size_t strbuffer_len
+);
+
+//! Get number of boards
+UHD_API uhd_error uhd_usrp_clock_get_num_boards(
+    uhd_usrp_clock_handle h,
+    size_t *num_boards_out
+);
+
+//! Get time
+UHD_API uhd_error uhd_usrp_clock_get_time(
+    uhd_usrp_clock_handle h,
+    size_t board,
+    uint32_t *clock_time_out
+);
+
+//! Get sensor
+UHD_API uhd_error uhd_usrp_clock_get_sensor(
+    uhd_usrp_clock_handle h,
+    const char* name,
+    size_t board,
+    uhd_sensor_value_handle sensor_value_out
+);
+
+//! Get sensor names
+UHD_API uhd_error uhd_usrp_clock_get_sensor_names(
+    uhd_usrp_clock_handle h,
+    size_t board,
+    char *sensor_names_out,
+    size_t strbuffer_len,
+    size_t *num_sensors_out
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_USRP_CLOCK_H */
diff --git a/host/include/uhd/utils/CMakeLists.txt b/host/include/uhd/utils/CMakeLists.txt
index 6b3d5a581..af6d3ee47 100644
--- a/host/include/uhd/utils/CMakeLists.txt
+++ b/host/include/uhd/utils/CMakeLists.txt
@@ -42,3 +42,11 @@ UHD_INSTALL(FILES
     DESTINATION ${INCLUDE_DIR}/uhd/utils
     COMPONENT headers
 )
+
+IF(ENABLE_C_API)
+    UHD_INSTALL(FILES
+        thread_priority.h
+        DESTINATION ${INCLUDE_DIR}/uhd/utils
+        COMPONENT headers
+    )
+ENDIF(ENABLE_C_API)
diff --git a/host/include/uhd/utils/thread_priority.h b/host/include/uhd/utils/thread_priority.h
new file mode 100644
index 000000000..217d7a1cc
--- /dev/null
+++ b/host/include/uhd/utils/thread_priority.h
@@ -0,0 +1,53 @@
+//
+// Copyright 2015 Ettus Research LLC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+#ifndef INCLUDED_UHD_UTILS_THREAD_PRIORITY_H
+#define INCLUDED_UHD_UTILS_THREAD_PRIORITY_H
+
+#include <uhd/config.h>
+#include <uhd/error.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static const float uhd_default_thread_priority = 0.5;
+
+/*!
+ * Set the scheduling priority on the current thread.
+ *
+ * A new thread or calling process should make this call
+ * with the defailts this to enable realtime scheduling.
+ *
+ * A priority of zero corresponds to normal priority.
+ * Positive priority values are higher than normal.
+ * Negative priority values are lower than normal.
+ *
+ * \param priority a value between -1 and 1
+ * \param realtime true to use realtime mode
+ * \return UHD error code
+ */
+UHD_API uhd_error uhd_set_thread_priority(
+    float priority,
+    bool realtime
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_UHD_UTILS_THREAD_PRIORITY_H */