Compare commits

...
Sign in to create a new pull request.

6 commits

55 changed files with 425 additions and 635 deletions

11
debian/copyright vendored
View file

@ -60,17 +60,6 @@ License: OpenCores-I2C
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Files: host/cmake/modules/FindLibPThreadsWin32.cmake
Copyright: 2008-2009 Hendrik Sattler
2013-2018 Nuand LLC
License: GPL-2+
Comment: This is file is based off of the FindLibUSB.cmake file written by
Hendrik Sattler, from the OpenOBEX project (licensed GPLv2/LGPL). (If
this is not correct, please contact us so we can attribute the author
appropriately.)
https://github.com/zuckschwerdt/openobex/blob/master/CMakeModules/FindLibUSB.cmake
http://dev.zuckschwerdt.org/openobex/
Files: host/cmake/modules/FindLibUSB.cmake
Copyright: 2008-2009 Hendrik Sattler
2013-2018 Nuand LLC

View file

@ -230,29 +230,6 @@ add_custom_target(uninstall
# Windows-only, Post build: Copy libraries to our build output directory
################################################################################
if(WIN32 AND NOT CMAKE_CROSSCOMPILING)
find_package(LibPThreadsWin32)
if(LIBPTHREADSWIN32_FOUND)
set(WIN_RUNTIME_ITEMS ${WIN_RUNTIME_ITEMS}
"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/licenses/pthreads-win32/COPYING.LIB.txt"
"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/pthreadVC2.dll")
add_custom_command(
OUTPUT "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/licenses/pthreads-win32/COPYING.LIB.txt"
COMMAND ${CMAKE_COMMAND} -E copy_if_different
"${LIBPTHREADSWIN32_LIB_COPYING}"
"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/licenses/pthreads-win32/COPYING.LIB.txt"
COMMENT "Copying pthreads-win32 license to output directory..."
)
add_custom_command(
OUTPUT "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/pthreadVC2.dll"
COMMAND ${CMAKE_COMMAND} -E copy_if_different
"${LIBPTHREADSWIN32_DLL}"
"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/"
COMMENT "Copying pthreadVC2.dll to output directory..."
)
endif(LIBPTHREADSWIN32_FOUND)
if(LIBUSB_FOUND)
set(WIN_RUNTIME_ITEMS ${WIN_RUNTIME_ITEMS}
"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/licenses/libusb/COPYING"

View file

@ -23,9 +23,6 @@ Windows users that wish to use a Cypress driver/library based libbladeRF backend
### CMake ###
[CMake][CMake.org] is used to build the items in this directory. \>= v2.8.5 is required, but the latest available version is recommended.
### pthreads-win32 - Windows-only ###
Windows users will need to get [pthreads-win32], and may (with newer Windows versions) need to build it from scratch.
## Build ##
### Linux and OSX ###
@ -63,7 +60,6 @@ This process was most recently validated on Windows 10 Enterprise with CMake 3.9
- If you run into any failures, check these items, then re-run Configure:
- LIBUSB_PATH (and ENABLE_BACKEND_LIBUSB) - for using libusb
- FX3_SDK_PATH (and ENABLE_BACKEND_CYAPI) - for using the Cypress driver
- LIBPTHREADSWIN32_PATH
- Adjust options as desired and re-run the "Configure" command as needed. Values in red are new, and should be reviewed before running "Configure" again to get the red out.
- Click the CMake GUI's "Generate" button.
- In the ```build``` directory, a Visual Studio solution will now exist. You can click "Open Project" to get there.
@ -71,21 +67,6 @@ This process was most recently validated on Windows 10 Enterprise with CMake 3.9
- Upon building the solution, build artifacts will be present in: ```build\output\<build type>```
- ```<build_type>``` may refer to Debug or Release, for example
#### pthreads-win32 ####
If you are using a newer version of Windows / Visual Studio and are getting ```error C0211: 'timespec': 'struct' type redefinition``` when trying to build bladeRF, you will need to rebuild pthreads-win32. The below process seems to work with pthreads-w32 2.9.1.
- Get full source tree from [pthreads-win32] website, and unpack someplace convenient
- In Visual Studio, open `pthreads-w32-2-9-1-release\pthreads.2\pthread.dsw` (one-way upgrade is OK)
- Right-click the solution, select "Retarget solution", hit OK.
- Change "Solution Configurations" dropdown to "Release" ("Debug" doesn't work, but that's OK)
- Edit pthread.h to add `#define HAVE_STRUCT_TIMESPEC` and `#define PTW32_ARCHx64` near the top, just below the include guard
- Build the solution
- Back over in the bladeRF CMake:
- File -> Delete Cache
- Redo the "Configure" dance as before
- Point `LIBPTHREADSWIN32_PATH` to the `pthreads-w32-2-9-1-release\pthreads.2` directory you were just working in
## CMake Options and Flags ##
Below is a list of useful and project-specific CMake options. Please see the [CMake documentation] for
@ -120,4 +101,3 @@ more information.
[CMake documentation]: http://www.cmake.org/cmake/help/documentation.html (Cmake documentation)
[Cypress FX3 SDK]: http://www.cypress.com/?rID=57990 (Cypress FX3 SDK)
[redhat144967]: https://bugzilla.redhat.com/show_bug.cgi?id=144967 (Red Hat Bugzilla - Bug 144967)
[pthreads-win32]: https://sourceware.org/pthreads-win32/ (POSIX Threads for Win32)

View file

@ -1,113 +0,0 @@
# This is file is based off of the FindLibUSB.cmake file written by Hendrik Sattler,
# from the OpenOBEX project (licensed GPLv2/LGPL). (If this is not correct,
# please contact us so we can attribute the author appropriately.)
#
# https://github.com/zuckschwerdt/openobex/blob/master/CMakeModules/FindLibUSB.cmake
# http://dev.zuckschwerdt.org/openobex/
#
# Find pthreads-win32
#
# This requires the LIBPTHREADSWIN32_PATH variable to be set to the path to the
# a pthreads-win32 release, such as the Pre-built.2 directory from the 2.9.1 release:
# ftp://sourceware.org/pub/pthreads-win32/pthreads-w32-2-9-1-release.zip
#
# The following standard variables get defined:
# LIBPTHREADSWIN32_FOUND: true if LibUSB was found
# LIBPTHREADSWIN32_HEADER_FILE: the location of the C header file
# LIBPTHREADSWIN32_INCLUDE_DIRS: the directories that contain headers
# LIBPTHREADSWIN32_LIBRARIES: the library files
# LIBPTHREADSWIN32_LIB_COPYING: the license associated with the library
# LIBPTHREADSWIN32_DLL: the pthreadVC2.dll file
if(DEFINED __INCLUDED_BLADERF_FINDLIBPTHREADSWIN32_CMAKE)
return()
endif()
set(__INCLUDED_BLADERF_FINDLIBPTHREADSWIN32_CMAKE TRUE)
include ( CheckLibraryExists )
include ( CheckIncludeFile )
set(LIBPTHREADSWIN32_PATH
"C:/Program Files (x86)/pthreads-win32"
CACHE
PATH
"Path to win-pthreads files. (This is generally only needed for Windows users who downloaded binary distributions.)"
)
find_file ( LIBPTHREADSWIN32_HEADER_FILE
NAMES
pthread.h
PATHS
${LIBPTHREADSWIN32_PATH}
PATH_SUFFIXES
include include
)
mark_as_advanced ( LIBPTHREADSWIN32_HEADER_FILE )
get_filename_component ( LIBPTHREADSWIN32_INCLUDE_DIRS "${LIBPTHREADSWIN32_HEADER_FILE}" PATH )
if ( WIN32 )
if ( MSVC )
if ( CMAKE_CL_64 )
set ( LIBPTHREADSWIN32_LIBRARY_PATH_SUFFIX x64 )
else ( CMAKE_CL_64 )
set ( LIBPTHREADSWIN32_LIBRARY_PATH_SUFFIX x86 )
endif ( CMAKE_CL_64 )
elseif ( CMAKE_COMPILER_IS_GNUCC )
if ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
set ( LIBPTHREADSWIN32_LIBRARY_PATH_SUFFIX x64 )
else ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
set ( LIBPTHREADSWIN32_LIBRARY_PATH_SUFFIX x86 )
endif ( CMAKE_SIZEOF_VOID_P EQUAL 8 )
endif ( MSVC )
find_library ( PTHREAD_LIBRARY
NAMES
pthreadVC2
PATHS
${LIBPTHREADSWIN32_PATH}
PATH_SUFFIXES
lib/${LIBPTHREADSWIN32_LIBRARY_PATH_SUFFIX}
)
mark_as_advanced ( PTHREAD_LIBRARY )
if ( PTHREAD_LIBRARY )
set ( LIBPTHREADSWIN32_LIBRARIES ${PTHREAD_LIBRARY} )
endif ( PTHREAD_LIBRARY )
find_file ( PTHREAD_DLL
NAMES
pthreadVC2.dll
PATHS
${LIBPTHREADSWIN32_PATH}
PATH_SUFFIXES
dll/${LIBPTHREADSWIN32_LIBRARY_PATH_SUFFIX}
.
)
mark_as_advanced ( PTHREAD_DLL )
if ( PTHREAD_DLL )
set ( LIBPTHREADSWIN32_DLL ${PTHREAD_DLL} )
endif ( PTHREAD_DLL )
else ( WIN32 )
message(FATAL_ERROR "This file only supports Windows")
endif ( WIN32 )
set ( LIBPTHREADSWIN32_LIB_COPYING
"${LIBPTHREADSWIN32_PATH}/COPYING.LIB" )
if ( NOT EXISTS ${LIBPTHREADSWIN32_LIB_COPYING} )
message(FATAL_ERROR "Unable to find pthread-win32 COPYING.LIB file")
endif ()
if ( LIBPTHREADSWIN32_INCLUDE_DIRS AND LIBPTHREADSWIN32_LIBRARIES AND LIBPTHREADSWIN32_DLL )
set ( LIBPTHREADSWIN32_FOUND true )
endif ( LIBPTHREADSWIN32_INCLUDE_DIRS AND LIBPTHREADSWIN32_LIBRARIES AND LIBPTHREADSWIN32_DLL )
if ( LIBPTHREADSWIN32_FOUND )
set ( CMAKE_REQUIRED_INCLUDES "${LIBPTHREADSWIN32_INCLUDE_DIRS}" )
check_include_file ( "{LIBPTHREADSWIN32_HEADER_FILE}" LIBPTHREADSWIN32_FOUND )
endif ( LIBPTHREADSWIN32_FOUND )
if ( NOT LIBPTHREADSWIN32_FOUND )
message ( FATAL_ERROR "pthreads-win32 not found. If you're using a binary distribution, try setting -DLIBPTHREADSWIN32_PATH=<path_to_win_pthread_files>." )
endif ( NOT LIBPTHREADSWIN32_FOUND )

View file

@ -32,11 +32,30 @@
/* Currently, only pthreads is supported. In the future, native windows threads
* may be used; one of the objectives of this file is to ease that transistion.
*/
#include <pthread.h>
#include "rel_assert.h"
#define MUTEX pthread_mutex_t
#if (defined(_WIN32) || defined(USE_NATIVE_THREADS)) && \
!defined(DO_NOT_USE_PTHREADS)
// Do not use pthreads on Windows
#undef USE_PTHREADS
#else
// Use pthreads on non-Windows platforms
#undef USE_PTHREADS
#define USE_PTHREADS
#endif
#ifdef USE_PTHREADS
/* Use pthreads */
#include <pthread.h>
#include <errno.h>
#include <time.h>
#define CLOCK_REALTIME 0
#define THREAD pthread_t
#define MUTEX pthread_mutex_t
#define COND pthread_cond_t
#ifdef ENABLE_LOCK_CHECKS
# define MUTEX_INIT(m) do { \
int status; \
@ -64,11 +83,103 @@
int status = pthread_mutex_destroy(m); \
assert(status == 0 && "Mutex destroy failure");\
} while (0)
#else
# define MUTEX_INIT(m) pthread_mutex_init(m, NULL)
# define MUTEX_LOCK(m) pthread_mutex_lock(m)
# define MUTEX_UNLOCK(m) pthread_mutex_unlock(m)
# define MUTEX_DESTROY(m) pthread_mutex_destroy(m)
#endif
#else /* ENABLE_LOCK_CHECKS */
#define MUTEX_INIT(m) pthread_mutex_init(m, NULL)
#define MUTEX_LOCK(m) pthread_mutex_lock(m)
#define MUTEX_UNLOCK(m) pthread_mutex_unlock(m)
#define MUTEX_DESTROY(m) pthread_mutex_destroy(m)
#endif /* ENABLE_LOCK_CHECKS */
# define THREAD_CREATE(x,y,z) pthread_create(x, NULL, y, z)
# define THREAD_SUCCESS 0
# define THREAD_TIMEOUT ETIMEDOUT
# define THREAD_CANCEL(m) pthread_cancel(m)
# define THREAD_JOIN(t, s) pthread_join(t, s)
# define THREAD_EXIT(s) pthread_exit(s)
# define COND_INIT(m) pthread_cond_init(m, NULL)
# define COND_SIGNAL(m) pthread_cond_signal(m)
// POSIX implementation as a function
static inline int posix_cond_timedwait(pthread_cond_t *c,
pthread_mutex_t *m,
unsigned int t)
{
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += t / 1000;
ts.tv_nsec += (t % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000) {
ts.tv_sec++;
ts.tv_nsec -= 1000000000;
}
return pthread_cond_timedwait(c, m, &ts) == ETIMEDOUT ? -1 : 0;
}
#define COND_TIMED_WAIT(c, m, t) posix_cond_timedwait(c, m, t)
#define COND_WAIT(c, m) pthread_cond_wait(c, m)
#else /* USE_PTHREADS */
#include <windows.h>
#include <time.h>
/* Use C11 threads */
//#include <threads.h>
#define THREAD HANDLE // For thread handles
#define MUTEX CRITICAL_SECTION // For mutexes
#define COND CONDITION_VARIABLE // For condition variables
#ifdef ENABLE_LOCK_CHECKS
# define MUTEX_INIT(m) do { \
int status; \
status = mtx_init(m, mtx_plain | mtx_recursive); \
assert(status == thrd_success && "Mutex init failure"); \
} while (0)
# define MUTEX_LOCK(m) do { \
int status = mtx_lock(m); \
assert(status == thrd_success && "Mutex lock failure");\
} while (0)
# define MUTEX_UNLOCK(m) do { \
int status = mtx_unlock(m); \
assert(status == thrd_success && "Mutex unlock failure");\
} while (0)
# define MUTEX_DESTROY(m) do { \
mtx_destroy(m); \
} while (0)
#else /* ENABLE_LOCK_CHECKS */
#define MUTEX_INIT(m) InitializeCriticalSection(m)
#define MUTEX_LOCK(m) EnterCriticalSection(m)
#define MUTEX_UNLOCK(m) LeaveCriticalSection(m)
#define MUTEX_DESTROY(m) DeleteCriticalSection(m)
#endif /* ENABLE_LOCK_CHECKS */
# define THREAD_CREATE(handle, func, arg) \
((*(handle) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)(func), \
(LPVOID)(arg), 0, NULL)) == NULL ? GetLastError() : 0)
# define THREAD_SUCCESS 0
# define THREAD_TIMEOUT WAIT_TIMEOUT
# define THREAD_CANCEL(m) TerminateThread(m, 0)
# define THREAD_JOIN(t, s) WaitForSingleObject(t, INFINITE)
# define THREAD_EXIT(s) ExitThread(s)
# define COND_INIT(m) (InitializeConditionVariable(m), 0)
# define COND_SIGNAL(m) WakeConditionVariable(m)
# define COND_TIMED_WAIT(c, m, t) \
(SleepConditionVariableCS(c, m, t) ? 0 : GetLastError())
# define COND_WAIT(c, m) (!SleepConditionVariableCS(c, m, INFINITE))
#endif /* USE_PTHREADS */
#endif

View file

@ -25,7 +25,7 @@
#ifndef WIN_CLOCK_GETTIME_H_
#define WIN_CLOCK_GETTIME_H_
#include <pthread.h>
#include "thread.h"
#ifdef __cplusplus
extern "C" {

View file

@ -25,7 +25,7 @@
#ifndef WIN_GETTIMEOFDAY_H_
#define WIN_GETTIMEOFDAY_H_
#include <pthread.h>
#include "thread.h"
#ifdef __cplusplus
extern "C" {

View file

@ -25,7 +25,7 @@
#ifndef WIN_NANOSLEEP_H_
#define WIN_NANOSLEEP_H_
#include <pthread.h>
#include "thread.h"
#ifdef __cplusplus
extern "C" {

View file

@ -48,9 +48,10 @@
#endif
#include <Windows.h>
#include <time.h>
#include <stdint.h>
#include "host_config.h"
#include "pthread.h"
#include "thread.h"
#ifdef __cplusplus
extern "C" {

View file

@ -94,16 +94,7 @@ target_include_directories(ad936x PUBLIC
if(MSVC)
add_definitions(-DHAVE_STRUCT_TIMESPEC)
target_include_directories(ad936x PUBLIC ${MSVC_C99_INCLUDES})
find_package(LibPThreadsWin32 REQUIRED)
if(LIBPTHREADSWIN32_FOUND)
set(HAVE_THREADS true)
target_include_directories(ad936x PUBLIC ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBAD936X_LIBS
${LIBAD936X_LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else()
set(HAVE_THREADS false)
endif()
set(HAVE_THREADS true)
else(MSVC)
find_package(Threads REQUIRED)
if(Threads_FOUND)

View file

@ -196,16 +196,7 @@ set(LIBBLADERF_INCLUDES
if(MSVC)
set(LIBBLADERF_INCLUDES ${LIBBLADERF_INCLUDES} ${MSVC_C99_INCLUDES})
find_package(LibPThreadsWin32 REQUIRED)
if(LIBPTHREADSWIN32_FOUND)
set(HAVE_THREADS true)
set(LIBBLADERF_INCLUDES
${LIBBLADERF_INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBBLADERF_LIBS
${LIBBLADERF_LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else()
set(HAVE_THREADS false)
endif()
set(HAVE_THREADS true)
else(MSVC)
find_package(Threads REQUIRED)
if(Threads_FOUND)
@ -280,11 +271,6 @@ if(ENABLE_BACKEND_CYAPI)
set(LIBBLADERF_INCLUDES ${LIBBLADERF_INCLUDES} ${CYAPI_INCLUDE_DIRS})
endif(ENABLE_BACKEND_CYAPI)
if(MSVC)
set(LIBBLADERF_INCLUDES ${LIBBLADERF_INCLUDES}
${LIBPTHREADSWIN32_INCLUDE_DIRS})
endif()
if(ENABLE_LIBBLADERF_SYNC_LOG_VERBOSE AND ENABLE_LIBBLADERF_LOGGING)
add_definitions(-DENABLE_LIBBLADERF_SYNC_LOG_VERBOSE)
endif()
@ -437,11 +423,9 @@ add_library(libbladerf_shared SHARED ${LIBBLADERF_SOURCE})
# Build configuration
################################################################################
if(MSVC)
set(LIBBLADERF_LIBS ${LIBBLADERF_LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else()
if(NOT MSVC)
set(LIBBLADERF_LIBS ${LIBBLADERF_LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
if(ENABLE_BACKEND_LIBUSB)
set(LIBBLADERF_LIBS ${LIBBLADERF_LIBS} ${LIBUSB_LIBRARIES})

View file

@ -26,7 +26,7 @@
extern "C" {
#include <stdlib.h>
#include <pthread.h>
#include "thread.h"
#include <errno.h>
#include "bladeRF.h" /* Firmware interface */
@ -707,7 +707,7 @@ static int cyapi_stream(void *driver, struct bladerf_stream *stream,
data->transfers[i].buffer = NULL;
data->transfers[i].handle = NULL;
data->num_avail++;
pthread_cond_signal(&stream->can_submit_buffer);
COND_SIGNAL(&stream->can_submit_buffer);
if (next_buffer == BLADERF_STREAM_SHUTDOWN) {
done = true;
@ -792,20 +792,20 @@ int cyapi_submit_stream_buffer(void *driver, struct bladerf_stream *stream,
return BLADERF_ERR_UNEXPECTED;
}
while (data->num_avail == 0 && status == 0) {
status = pthread_cond_timedwait(&stream->can_submit_buffer,
while (data->num_avail == 0 && status == THREAD_SUCCESS) {
status = COND_TIMED_WAIT(&stream->can_submit_buffer,
&stream->lock,
&timeout_abs);
}
} else {
while (data->num_avail == 0 && status == 0) {
status = pthread_cond_wait(&stream->can_submit_buffer,
while (data->num_avail == 0 && status == THREAD_SUCCESS) {
status = COND_WAIT(&stream->can_submit_buffer,
&stream->lock);
}
}
}
if (status == ETIMEDOUT) {
if (status == THREAD_TIMEOUT) {
return BLADERF_ERR_TIMEOUT;
} else if (status != 0) {
return BLADERF_ERR_UNEXPECTED;

View file

@ -22,7 +22,7 @@
#include "host_config.h"
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include "thread.h"
#include <errno.h>
#include <libusb.h>
#if 1 == BLADERF_OS_FREEBSD
@ -1054,7 +1054,7 @@ static void LIBUSB_CALL lusb_stream_cb(struct libusb_transfer *transfer)
} else {
stream_data->transfer_status[transfer_i] = TRANSFER_AVAIL;
stream_data->num_avail++;
pthread_cond_signal(&stream->can_submit_buffer);
COND_SIGNAL(&stream->can_submit_buffer);
}
/* Check to see if the transfer has been cancelled or errored */
@ -1409,7 +1409,6 @@ int lusb_submit_stream_buffer(void *driver, struct bladerf_stream *stream,
{
int status = 0;
struct lusb_stream_data *stream_data = stream->backend_data;
struct timespec timeout_abs;
if (buffer == BLADERF_STREAM_SHUTDOWN) {
if (stream_data->num_avail == stream_data->num_transfers) {
@ -1430,25 +1429,20 @@ int lusb_submit_stream_buffer(void *driver, struct bladerf_stream *stream,
}
if (timeout_ms != 0) {
status = populate_abs_timeout(&timeout_abs, timeout_ms);
if (status != 0) {
return BLADERF_ERR_UNEXPECTED;
}
while (stream_data->num_avail == 0 && status == 0) {
status = pthread_cond_timedwait(&stream->can_submit_buffer,
while (stream_data->num_avail == 0 && status == THREAD_SUCCESS) {
status = COND_TIMED_WAIT(&stream->can_submit_buffer,
&stream->lock,
&timeout_abs);
timeout_ms);
}
} else {
while (stream_data->num_avail == 0 && status == 0) {
status = pthread_cond_wait(&stream->can_submit_buffer,
while (stream_data->num_avail == 0 && status == THREAD_SUCCESS) {
status = COND_WAIT(&stream->can_submit_buffer,
&stream->lock);
}
}
}
if (status == ETIMEDOUT) {
if (status == THREAD_TIMEOUT) {
log_debug("%s: Timed out waiting for a transfer to become available.\n",
__FUNCTION__);
return BLADERF_ERR_TIMEOUT;

View file

@ -66,12 +66,12 @@ int async_init_stream(struct bladerf_stream **stream,
MUTEX_INIT(&lstream->lock);
if (pthread_cond_init(&lstream->can_submit_buffer, NULL) != 0) {
if (COND_INIT(&lstream->can_submit_buffer) != THREAD_SUCCESS) {
free(lstream);
return BLADERF_ERR_UNEXPECTED;
}
if (pthread_cond_init(&lstream->stream_started, NULL) != 0) {
if (COND_INIT(&lstream->stream_started) != THREAD_SUCCESS) {
free(lstream);
return BLADERF_ERR_UNEXPECTED;
}
@ -203,7 +203,7 @@ int async_run_stream(struct bladerf_stream *stream, bladerf_channel_layout layou
MUTEX_LOCK(&stream->lock);
stream->layout = layout;
stream->state = STREAM_RUNNING;
pthread_cond_signal(&stream->stream_started);
COND_SIGNAL(&stream->stream_started);
MUTEX_UNLOCK(&stream->lock);
status = dev->backend->stream(stream, layout);
@ -218,32 +218,23 @@ int async_submit_stream_buffer(struct bladerf_stream *stream,
bool nonblock)
{
int status = 0;
struct timespec timeout_abs;
MUTEX_LOCK(&stream->lock);
if (buffer != BLADERF_STREAM_SHUTDOWN) {
if (stream->state != STREAM_RUNNING && timeout_ms != 0) {
status = populate_abs_timeout(&timeout_abs, timeout_ms);
if (status != 0) {
log_debug("Failed to populate timeout value\n");
goto error;
}
}
while (stream->state != STREAM_RUNNING) {
log_debug("Buffer submitted while stream's not running. "
"Waiting for stream to start.\n");
if (timeout_ms == 0) {
status = pthread_cond_wait(&stream->stream_started,
status = COND_WAIT(&stream->stream_started,
&stream->lock);
} else {
status = pthread_cond_timedwait(&stream->stream_started,
&stream->lock, &timeout_abs);
status = COND_TIMED_WAIT(&stream->stream_started,
&stream->lock, timeout_ms);
}
if (status == ETIMEDOUT) {
if (status == THREAD_TIMEOUT) {
status = BLADERF_ERR_TIMEOUT;
log_debug("%s: %u ms timeout expired",
__FUNCTION__, timeout_ms);

View file

@ -22,8 +22,6 @@
#ifndef STREAMING_ASYNC_H_
#define STREAMING_ASYNC_H_
#include <pthread.h>
#include <libbladeRF.h>
#include "thread.h"
@ -58,8 +56,8 @@ struct bladerf_stream {
/* The following items must be accessed atomically */
int error_code;
bladerf_stream_state state;
pthread_cond_t can_submit_buffer;
pthread_cond_t stream_started;
COND can_submit_buffer;
COND stream_started;
void *backend_data;
};

View file

@ -237,7 +237,7 @@ int sync_init(struct bladerf_sync *sync,
__FUNCTION__, sync->meta.samples_per_msg);
MUTEX_INIT(&sync->buf_mgmt.lock);
pthread_cond_init(&sync->buf_mgmt.buf_ready, NULL);
COND_INIT(&sync->buf_mgmt.buf_ready);
sync->buf_mgmt.status = (sync_buffer_status*) malloc(num_buffers * sizeof(sync_buffer_status));
if (sync->buf_mgmt.status == NULL) {
@ -332,22 +332,18 @@ static int wait_for_buffer(struct buffer_mgmt *b,
unsigned int dbg_idx)
{
int status;
struct timespec timeout;
if (timeout_ms == 0) {
log_verbose("%s: Infinite wait for buffer[%d] (status: %d).\n",
dbg_name, dbg_idx, b->status[dbg_idx]);
status = pthread_cond_wait(&b->buf_ready, &b->lock);
status = COND_WAIT(&b->buf_ready, &b->lock);
} else {
log_verbose("%s: Timed wait for buffer[%d] (status: %d).\n", dbg_name,
dbg_idx, b->status[dbg_idx]);
status = populate_abs_timeout(&timeout, timeout_ms);
if (status == 0) {
status = pthread_cond_timedwait(&b->buf_ready, &b->lock, &timeout);
}
status = COND_TIMED_WAIT(&b->buf_ready, &b->lock, timeout_ms);
}
if (status == ETIMEDOUT) {
if (status == THREAD_TIMEOUT) {
log_error("%s: Timed out waiting for buf_ready after %d ms\n",
__FUNCTION__, timeout_ms);
status = BLADERF_ERR_TIMEOUT;

View file

@ -23,7 +23,6 @@
#define STREAMING_SYNC_H_
#include <limits.h>
#include <pthread.h>
#include <libbladeRF.h>
@ -88,7 +87,7 @@ struct buffer_mgmt {
MUTEX lock;
pthread_cond_t buf_ready; /**< Buffer produced by RX callback, or
COND buf_ready; /**< Buffer produced by RX callback, or
* buffer emptied by TX callback */
};

View file

@ -83,7 +83,7 @@ static void *rx_callback(struct bladerf *dev,
/* This buffer is now ready for the consumer */
b->status[samples_idx] = SYNC_BUFFER_FULL;
b->actual_lengths[samples_idx] = num_samples;
pthread_cond_signal(&b->buf_ready);
COND_SIGNAL(&b->buf_ready);
/* Update the state of the buffer being submitted next */
next_idx = b->prod_i;
@ -155,7 +155,7 @@ static void *tx_callback(struct bladerf *dev,
completed_idx = sync_buf2idx(b, samples);
assert(b->status[completed_idx] == SYNC_BUFFER_IN_FLIGHT);
b->status[completed_idx] = SYNC_BUFFER_EMPTY;
pthread_cond_signal(&b->buf_ready);
COND_SIGNAL(&b->buf_ready);
/* If the callback is assigned to be the submitter, there are
* buffers pending submission */
@ -230,25 +230,25 @@ int sync_worker_init(struct bladerf_sync *s)
MUTEX_INIT(&s->worker->state_lock);
MUTEX_INIT(&s->worker->request_lock);
status = pthread_cond_init(&s->worker->state_changed, NULL);
if (status != 0) {
log_debug("%s worker: pthread_cond_init(state_changed) failed: %d\n",
status = COND_INIT(&s->worker->state_changed);
if (status != THREAD_SUCCESS) {
log_debug("%s worker: cond_init(state_changed) failed: %d\n",
worker2str(s), status);
status = BLADERF_ERR_UNEXPECTED;
goto worker_init_out;
}
status = pthread_cond_init(&s->worker->requests_pending, NULL);
if (status != 0) {
log_debug("%s worker: pthread_cond_init(requests_pending) failed: %d\n",
status = COND_INIT(&s->worker->requests_pending);
if (status != THREAD_SUCCESS) {
log_debug("%s worker: cond_init(requests_pending) failed: %d\n",
worker2str(s), status);
status = BLADERF_ERR_UNEXPECTED;
goto worker_init_out;
}
status = pthread_create(&s->worker->thread, NULL, sync_worker_task, s);
if (status != 0) {
log_debug("%s worker: pthread_create failed: %d\n", worker2str(s),
status = THREAD_CREATE(&s->worker->thread, sync_worker_task, s);
if (status != THREAD_SUCCESS) {
log_debug("%s worker: create failed: %d\n", worker2str(s),
status);
status = BLADERF_ERR_UNEXPECTED;
goto worker_init_out;
@ -274,7 +274,7 @@ worker_init_out:
}
void sync_worker_deinit(struct sync_worker *w,
pthread_mutex_t *lock, pthread_cond_t *cond)
MUTEX *lock, COND *cond)
{
int status;
@ -289,7 +289,7 @@ void sync_worker_deinit(struct sync_worker *w,
if (lock != NULL && cond != NULL) {
MUTEX_LOCK(lock);
pthread_cond_signal(cond);
COND_SIGNAL(cond);
MUTEX_UNLOCK(lock);
}
@ -297,10 +297,10 @@ void sync_worker_deinit(struct sync_worker *w,
if (status != 0) {
log_warning("Timed out while stopping worker. Canceling thread.\n");
pthread_cancel(w->thread);
THREAD_CANCEL(w->thread);
}
pthread_join(w->thread, NULL);
THREAD_JOIN(w->thread, NULL);
log_verbose("%s: Worker joined.\n", __FUNCTION__);
async_deinit_stream(w->stream);
@ -312,7 +312,7 @@ void sync_worker_submit_request(struct sync_worker *w, unsigned int request)
{
MUTEX_LOCK(&w->request_lock);
w->requests |= request;
pthread_cond_signal(&w->requests_pending);
COND_SIGNAL(&w->requests_pending);
MUTEX_UNLOCK(&w->request_lock);
}
@ -320,31 +320,14 @@ int sync_worker_wait_for_state(struct sync_worker *w, sync_worker_state state,
unsigned int timeout_ms)
{
int status = 0;
struct timespec timeout_abs;
const int nsec_per_sec = 1000 * 1000 * 1000;
if (timeout_ms != 0) {
const unsigned int timeout_sec = timeout_ms / 1000;
status = clock_gettime(CLOCK_REALTIME, &timeout_abs);
if (status != 0) {
return BLADERF_ERR_UNEXPECTED;
}
timeout_abs.tv_sec += timeout_sec;
timeout_abs.tv_nsec += (timeout_ms % 1000) * 1000 * 1000;
if (timeout_abs.tv_nsec >= nsec_per_sec) {
timeout_abs.tv_sec += timeout_abs.tv_nsec / nsec_per_sec;
timeout_abs.tv_nsec %= nsec_per_sec;
}
MUTEX_LOCK(&w->state_lock);
status = 0;
while (w->state != state && status == 0) {
status = pthread_cond_timedwait(&w->state_changed,
while (w->state != state && status == THREAD_SUCCESS) {
status = COND_TIMED_WAIT(&w->state_changed,
&w->state_lock,
&timeout_abs);
timeout_ms);
}
MUTEX_UNLOCK(&w->state_lock);
@ -352,7 +335,7 @@ int sync_worker_wait_for_state(struct sync_worker *w, sync_worker_state state,
MUTEX_LOCK(&w->state_lock);
while (w->state != state) {
log_verbose(": Waiting for state change, current = %d\n", w->state);
status = pthread_cond_wait(&w->state_changed,
status = COND_WAIT(&w->state_changed,
&w->state_lock);
}
MUTEX_UNLOCK(&w->state_lock);
@ -362,7 +345,7 @@ int sync_worker_wait_for_state(struct sync_worker *w, sync_worker_state state,
log_debug("%s: Wait on state change failed: %s\n",
__FUNCTION__, strerror(status));
if (status == ETIMEDOUT) {
if (status == THREAD_TIMEOUT) {
status = BLADERF_ERR_TIMEOUT;
} else {
status = BLADERF_ERR_UNEXPECTED;
@ -392,7 +375,7 @@ static void set_state(struct sync_worker *w, sync_worker_state state)
{
MUTEX_LOCK(&w->state_lock);
w->state = state;
pthread_cond_signal(&w->state_changed);
COND_SIGNAL(&w->state_changed);
MUTEX_UNLOCK(&w->state_lock);
}
@ -408,7 +391,7 @@ static sync_worker_state exec_idle_state(struct bladerf_sync *s)
while (s->worker->requests == 0) {
log_verbose("%s worker: Waiting for pending requests\n", worker2str(s));
pthread_cond_wait(&s->worker->requests_pending,
COND_WAIT(&s->worker->requests_pending,
&s->worker->request_lock);
}
@ -434,7 +417,7 @@ static sync_worker_state exec_idle_state(struct bladerf_sync *s)
}
}
pthread_cond_signal(&s->buf_mgmt.buf_ready);
COND_SIGNAL(&s->buf_mgmt.buf_ready);
} else {
s->buf_mgmt.prod_i = s->stream_config.num_xfers;
@ -477,7 +460,7 @@ static void exec_running_state(struct bladerf_sync *s)
* the stream error code back to the API caller */
if (status != 0) {
MUTEX_LOCK(&s->buf_mgmt.lock);
pthread_cond_signal(&s->buf_mgmt.buf_ready);
COND_SIGNAL(&s->buf_mgmt.buf_ready);
MUTEX_UNLOCK(&s->buf_mgmt.lock);
}
}

View file

@ -22,7 +22,7 @@
#include "host_config.h"
#include "sync.h"
#include <libbladeRF.h>
#include <pthread.h>
#include "thread.h"
#if BLADERF_OS_WINDOWS || BLADERF_OS_OSX
#include "clock_gettime.h"
@ -49,7 +49,7 @@ typedef enum {
} sync_worker_state;
struct sync_worker {
pthread_t thread;
THREAD thread;
struct bladerf_stream *stream;
bladerf_stream_cb cb;
@ -58,7 +58,7 @@ struct sync_worker {
sync_worker_state state;
int err_code;
MUTEX state_lock;
pthread_cond_t state_changed; /* Worker thread uses this to inform a
COND state_changed; /* Worker thread uses this to inform a
* waiting main thread about a state
* change */
@ -66,7 +66,7 @@ struct sync_worker {
* the sync->buf_mgmt.lock
*/
unsigned int requests;
pthread_cond_t requests_pending;
COND requests_pending;
MUTEX request_lock;
};
@ -90,8 +90,8 @@ int sync_worker_init(struct bladerf_sync *s);
* workers.
*/
void sync_worker_deinit(struct sync_worker *w,
pthread_mutex_t *lock,
pthread_cond_t *cond);
MUTEX *lock,
COND *cond);
/**
* Wait for state change with optional timeout

View file

@ -34,21 +34,15 @@ set(SRC
set(TEST_CONFIG_FILE_LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(TEST_CONFIG_FILE_INCLUDES
${TEST_CONFIG_FILE_INCLUDES}
${MSVC_C99_INCLUDES}
${LIBPTHREADSWIN32_INCLUDE_DIRS}
)
set(SRC
${SRC}
${BLADERF_HOST_COMMON_SOURCE_DIR}/windows/clock_gettime.c
${BLADERF_HOST_COMMON_SOURCE_DIR}/windows/mkdtemp.c
)
set(TEST_CONFIG_FILE_LIBS
${TEST_CONFIG_FILE_LIBS}
${LIBPTHREADSWIN32_LIBRARIES}
)
endif()
add_definitions(-DLIBBLADERF_SEARCH_PREFIX="${CMAKE_INSTALL_PREFIX}")

View file

@ -13,14 +13,10 @@ endif()
set(LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
set(SRC
src/main.c

View file

@ -27,15 +27,15 @@
* while concurrently runing full duplex streams via the sync interface */
#include "test_ctrl.h"
#include <pthread.h>
#include "thread.h"
DECLARE_TEST_CASE(threads);
struct sync_task {
struct bladerf *dev;
bladerf_direction direction;
pthread_t thread;
pthread_mutex_t lock;
THREAD thread;
MUTEX lock;
bool launched;
bool run;
int status;
@ -53,7 +53,7 @@ struct thread_state {
struct app_params *p;
failure_count failures;
struct thread_test_case const *tc;
pthread_t thread;
THREAD thread;
};
static const struct thread_test_case tc[] = {
@ -69,9 +69,9 @@ static const struct thread_test_case tc[] = {
static inline void get_sync_task_state(struct sync_task *t, bool *run)
{
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
*run = t->run;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
static void *stream_task(void *arg)
@ -129,9 +129,9 @@ out:
}
free(samples);
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->status = status;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
return NULL;
}
@ -144,15 +144,15 @@ static void init_task(struct sync_task *t,
t->run = true;
t->status = 0;
t->direction = dir;
pthread_mutex_init(&t->lock, NULL);
MUTEX_INIT(&t->lock);
}
static int launch_task(struct sync_task *t)
{
int status;
status = pthread_create(&t->thread, NULL, stream_task, t);
if (0 == status) {
status = THREAD_CREATE(&t->thread, stream_task, t);
if (THREAD_SUCCESS == status) {
t->launched = true;
}
@ -162,10 +162,10 @@ static int launch_task(struct sync_task *t)
static inline int deinit_task(struct sync_task *t)
{
if (t->launched) {
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->run = false;
pthread_mutex_unlock(&t->lock);
pthread_join(t->thread, NULL);
MUTEX_UNLOCK(&t->lock);
THREAD_JOIN(t->thread, NULL);
return t->status;
} else {
return 0;
@ -257,9 +257,9 @@ failure_count test_threads(struct bladerf *dev, struct app_params *p, bool quiet
}
status =
pthread_create(&threads[i].thread, NULL, run_test_fn, &threads[i]);
THREAD_CREATE(&threads[i].thread, run_test_fn, &threads[i]);
if (0 == status) {
if (THREAD_SUCCESS == status) {
PRINT(" Started test_%s thread...\n", threads[i].tc->test->name);
threads[i].launched = true;
} else {
@ -271,7 +271,7 @@ failure_count test_threads(struct bladerf *dev, struct app_params *p, bool quiet
for (i = 0; i < num_threads; i++) {
if (threads[i].launched) {
pthread_join(threads[i].thread, NULL);
THREAD_JOIN(threads[i].thread, NULL);
PRINT("\n Joined test_%s thread.\n", threads[i].tc->test->name);
failures += threads[i].failures;
}

View file

@ -14,14 +14,10 @@ endif()
set(LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
add_definitions(-DLOGGING_ENABLED=1)

View file

@ -29,13 +29,12 @@
#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include "conversions.h"
#include "log.h"
#include "test_common.h"
#include <libbladeRF.h>
#include "async.h"
#include "thread.h"
/******************************************************************************
* Type definitions
@ -453,7 +452,7 @@ int main(int argc, char *argv[])
struct rx_buffer_state rx_state;
struct tx_buffer_state tx_state;
struct bladerf_stream *rx_stream, *tx_stream;
pthread_t rx_thread, tx_thread;
THREAD rx_thread, tx_thread;
bladerf_log_level level;
int status;
bool ok;
@ -716,9 +715,9 @@ int main(int argc, char *argv[])
goto error;
}
status = pthread_create(&tx_thread, NULL, tx_streamer, tx_stream);
if (status < 0) {
log_error("pthread_create(TX): %s\n", strerror(status));
status = THREAD_CREATE(&tx_thread, tx_streamer, tx_stream);
if (status != THREAD_SUCCESS) {
log_error("THREAD_CREATE(TX): %s\n", strerror(status));
goto error;
}
@ -728,16 +727,16 @@ int main(int argc, char *argv[])
goto error;
}
status = pthread_create(&rx_thread, NULL, rx_streamer, rx_stream);
if (status < 0) {
log_error("pthread_create(RX): %s\n", strerror(status));
status = THREAD_CREATE(&rx_thread, rx_streamer, rx_stream);
if (status != THREAD_SUCCESS) {
log_error("THREAD_CREATE(RX): %s\n", strerror(status));
goto error;
}
log_info("Loopback test running. Press Ctrl-C to exit...\n");
pthread_join(tx_thread, NULL);
pthread_join(rx_thread, NULL);
THREAD_JOIN(tx_thread, NULL);
THREAD_JOIN(rx_thread, NULL);
log_info("IQ Matches: %zu / %zu (%.1f%%)\n", good_count,
good_count + bad_count,

View file

@ -11,9 +11,6 @@ set(LIBS libbladerf_shared)
if(MSVC)
set(INCLUDES ${INCLUDES} ${MSVC_C99_INCLUDES})
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
endif()
set(SRC

View file

@ -19,14 +19,10 @@ else()
add_definitions(-DLIBBLADERF_SEARCH_PREFIX="${CMAKE_INSTALL_PREFIX}")
endif()
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
set(SRC
src/main.c

View file

@ -15,9 +15,7 @@ set(SRC
set(LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS} ${MSVC_C99_INCLUDES})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
set(INCLUDES ${INCLUDES} ${MSVC_C99_INCLUDES})
set(SRC ${SRC} ${BLADERF_HOST_COMMON_SOURCE_DIR}/windows/getopt_long.c)
else(MSVC)
find_package(Threads REQUIRED)

View file

@ -32,12 +32,12 @@
#include <string.h>
#include <getopt.h>
#include <limits.h>
#include <pthread.h>
#include <libbladeRF.h>
#include "devcfg.h"
#include "conversions.h"
#include "minmax.h"
#include "thread.h"
#define OPTIONS DEVCFG_OPTIONS_BASE "r:S:"
@ -221,7 +221,7 @@ int main(int argc, char *argv[])
int status = EXIT_FAILURE;
struct option *options = NULL;
struct app_params params;
pthread_t rx_thread, tx_thread;
THREAD rx_thread, tx_thread;
bool rx_launched = false;
bool tx_launched = false;
@ -266,8 +266,8 @@ int main(int argc, char *argv[])
}
if (params.rx) {
status = pthread_create(&rx_thread, NULL, rx_task, &params);
if (status != 0) {
status = THREAD_CREATE(&rx_thread, rx_task, &params);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to launch RX thread: %s\n", strerror(status));
params.rx = false;
} else {
@ -276,8 +276,8 @@ int main(int argc, char *argv[])
}
if (params.tx) {
status = pthread_create(&tx_thread, NULL, tx_task, &params);
if (status != 0) {
status = THREAD_CREATE(&tx_thread, tx_task, &params);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to launch TX thread: %s\n", strerror(status));
params.tx = false;
} else {
@ -286,11 +286,11 @@ int main(int argc, char *argv[])
}
if (rx_launched) {
pthread_join(rx_thread, NULL);
THREAD_JOIN(rx_thread, NULL);
}
if (tx_launched) {
pthread_join(tx_thread, NULL);
THREAD_JOIN(tx_thread, NULL);
}
out:

View file

@ -1,11 +1,9 @@
cmake_minimum_required(VERSION 3.5)
project(libbladeRF_test_repeater C)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
endif(MSVC)
endif(NOT MSVC)
set(TEST_REPEATER_SRC
src/main.c
@ -28,7 +26,6 @@ set(TEST_REPEATER_INCLUDE
if(MSVC)
set(TEST_REPEATER_INCLUDE ${TEST_REPEATER_INCLUDE}
${BLADERF_HOST_COMMON_INCLUDE_DIRS}/windows
${LIBPTHREADSWIN32_INCLUDE_DIRS}
${MSVC_C99_INCLUDES}
)
endif()
@ -41,10 +38,5 @@ set(TEST_REPEATER_LIBS
libbladerf_shared
${CMAKE_THREAD_LIBS_INIT})
if(LIBPTHREADSWIN32_FOUND)
set(TEST_REPEATER_LIBS ${TEST_REPEATER_LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
endif()
target_link_libraries(libbladeRF_test_repeater
${TEST_REPEATER_LIBS})
${TEST_REPEATER_LIBS})

View file

@ -64,10 +64,10 @@
#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include <pthread.h>
#include <libbladeRF.h>
#include "rel_assert.h"
#include "thread.h"
#include "repeater.h"
#include "minmax.h"
@ -152,9 +152,9 @@ static char get_key()
/* Thread-safe wrapper around fprintf(stderr, ...) */
#define print_error(repeater_, ...) do { \
pthread_mutex_lock(&repeater_->stderr_lock); \
MUTEX_LOCK(&repeater_->stderr_lock); \
fprintf(stderr, __VA_ARGS__); \
pthread_mutex_unlock(&repeater_->stderr_lock); \
MUTEX_UNLOCK(&repeater_->stderr_lock); \
} while (0)
#define GAIN_TXVGA1_MIN -35
@ -189,22 +189,22 @@ struct buf_mgmt
size_t num_buffers; /* # of sample buffers */
/* Used to signal the TX thread when a few samplse have been buffered up */
pthread_cond_t samples_available;
COND samples_available;
pthread_mutex_t lock;
MUTEX lock;
};
struct repeater
{
struct bladerf *device;
pthread_t rx_task;
THREAD rx_task;
struct bladerf_stream *rx_stream;
pthread_t tx_task;
THREAD tx_task;
struct bladerf_stream *tx_stream;
pthread_mutex_t stderr_lock;
MUTEX stderr_lock;
struct buf_mgmt buf_mgmt;
@ -247,7 +247,7 @@ static void *tx_stream_callback(struct bladerf *dev,
void *ret;
struct repeater *repeater = (struct repeater *)user_data;
pthread_mutex_lock(&repeater->buf_mgmt.lock);
MUTEX_LOCK(&repeater->buf_mgmt.lock);
if (repeater->buf_mgmt.tx_idx < 0) {
ret = NULL;
@ -271,7 +271,7 @@ static void *tx_stream_callback(struct bladerf *dev,
}
}
pthread_mutex_unlock(&repeater->buf_mgmt.lock);
MUTEX_UNLOCK(&repeater->buf_mgmt.lock);
return ret;
}
@ -284,21 +284,21 @@ void * tx_task_run(void *repeater_)
/* Wait for RX task to buffer up some samples before we begin
* consuming them */
pthread_mutex_lock(&repeater->buf_mgmt.lock);
MUTEX_LOCK(&repeater->buf_mgmt.lock);
while(repeater->buf_mgmt.num_filled < repeater->buf_mgmt.prefill_count &&
repeater->buf_mgmt.tx_idx >= 0) {
status = pthread_cond_wait(&repeater->buf_mgmt.samples_available,
status = COND_WAIT(&repeater->buf_mgmt.samples_available,
&repeater->buf_mgmt.lock);
if (status != 0) {
if (status != THREAD_SUCCESS) {
print_error(repeater, "TX startup wait failed (%d)\n", status);
exit_early = true;
}
}
exit_early |= repeater->buf_mgmt.tx_idx < 0;
pthread_mutex_unlock(&repeater->buf_mgmt.lock);
MUTEX_UNLOCK(&repeater->buf_mgmt.lock);
if (!exit_early) {
/* Call stream */
@ -325,7 +325,7 @@ static void *rx_stream_callback(struct bladerf *dev,
struct repeater *repeater = (struct repeater *)user_data;
void *ret;
pthread_mutex_lock(&repeater->buf_mgmt.lock);
MUTEX_LOCK(&repeater->buf_mgmt.lock);
if (repeater->buf_mgmt.rx_idx < 0) {
ret = NULL;
@ -346,10 +346,10 @@ static void *rx_stream_callback(struct bladerf *dev,
} else {
repeater->buf_mgmt.num_filled++;
}
pthread_cond_signal(&repeater->buf_mgmt.samples_available);
COND_SIGNAL(&repeater->buf_mgmt.samples_available);
}
pthread_mutex_unlock(&repeater->buf_mgmt.lock);
MUTEX_UNLOCK(&repeater->buf_mgmt.lock);
return ret;
}
@ -372,9 +372,9 @@ static inline void repeater_init(struct repeater *repeater,
{
memset(repeater, 0, sizeof(*repeater));
pthread_mutex_init(&repeater->stderr_lock, NULL);
pthread_mutex_init(&repeater->buf_mgmt.lock, NULL);
pthread_cond_init(&repeater->buf_mgmt.samples_available, NULL);
MUTEX_INIT(&repeater->stderr_lock);
MUTEX_INIT(&repeater->buf_mgmt.lock);
COND_INIT(&repeater->buf_mgmt.samples_available);
repeater->buf_mgmt.num_filled = 0;
repeater->buf_mgmt.num_buffers = config->num_buffers;
@ -607,15 +607,15 @@ static int start_tasks(struct repeater *repeater)
{
int status;
status = pthread_create(&repeater->rx_task, NULL, rx_task_run, repeater);
if (status < 0) {
status = THREAD_CREATE(&repeater->rx_task, rx_task_run, repeater);
if (status != THREAD_SUCCESS) {
return -1;
}
status = pthread_create(&repeater->tx_task, NULL, tx_task_run, repeater);
if (status < 0) {
pthread_cancel(repeater->rx_task);
pthread_join(repeater->rx_task, NULL);
status = THREAD_CREATE(&repeater->tx_task, tx_task_run, repeater);
if (status != THREAD_SUCCESS) {
THREAD_CANCEL(repeater->rx_task);
THREAD_JOIN(repeater->rx_task, NULL);
return -1;
}
@ -625,18 +625,18 @@ static int start_tasks(struct repeater *repeater)
static void stop_tasks(struct repeater *repeater)
{
print_error(repeater, "Stoppping RX and tasks...\r\n");
pthread_mutex_lock(&repeater->buf_mgmt.lock);
MUTEX_LOCK(&repeater->buf_mgmt.lock);
repeater->buf_mgmt.tx_idx = -1;
repeater->buf_mgmt.rx_idx = -1;
pthread_mutex_unlock(&repeater->buf_mgmt.lock);
pthread_join(repeater->rx_task, NULL);
MUTEX_UNLOCK(&repeater->buf_mgmt.lock);
THREAD_JOIN(repeater->rx_task, NULL);
/* Fire off the "samples available" signal to the TX thread, in case
* it is still awaiting for the prefill completion */
pthread_mutex_lock(&repeater->buf_mgmt.lock);
pthread_cond_signal(&repeater->buf_mgmt.samples_available);
pthread_mutex_unlock(&repeater->buf_mgmt.lock);
pthread_join(repeater->tx_task, NULL);
MUTEX_LOCK(&repeater->buf_mgmt.lock);
COND_SIGNAL(&repeater->buf_mgmt.samples_available);
MUTEX_UNLOCK(&repeater->buf_mgmt.lock);
THREAD_JOIN(repeater->tx_task, NULL);
}

View file

@ -12,14 +12,10 @@ endif()
set(LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
set(SRC
src/main.c

View file

@ -14,14 +14,10 @@ endif()
set(LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
set(SRC
src/main.c

View file

@ -12,14 +12,10 @@ endif()
set(TEST_SYNC_LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(TEST_SYNC_INCLUDES ${TEST_SYNC_INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(TEST_SYNC_LIBS ${TEST_SYNC_LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
set(TEST_SYNC_LIBS ${TEST_SYNC_LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
add_definitions(-DLOGGING_ENABLED=1)

View file

@ -27,7 +27,7 @@
#include <string.h>
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include "thread.h"
#include <signal.h>
#include <libbladeRF.h>
@ -40,7 +40,7 @@ static struct task_args {
struct bladerf *dev;
struct test_params *p;
pthread_t thread;
THREAD thread;
int status;
bool quit;
} rx_args, tx_args;
@ -365,7 +365,7 @@ int test_run(struct test_params *p)
tx_args.quit = false;
log_debug("Starting TX task\n");
if (pthread_create(&tx_args.thread, NULL, tx_task, &tx_args) != 0) {
if (THREAD_CREATE(&tx_args.thread, tx_task, &tx_args) != THREAD_SUCCESS) {
fclose(p->in_file);
p->in_file = NULL;
}
@ -378,7 +378,7 @@ int test_run(struct test_params *p)
rx_args.quit = false;
log_debug("Starting RX task\n");
if (pthread_create(&rx_args.thread, NULL, rx_task, &rx_args) != 0) {
if (THREAD_CREATE(&rx_args.thread, rx_task, &rx_args) != THREAD_SUCCESS) {
fclose(p->out_file);
p->out_file = NULL;
}
@ -387,12 +387,12 @@ int test_run(struct test_params *p)
log_debug("Running...\n");
if (p->in_file != NULL) {
pthread_join(tx_args.thread, NULL);
THREAD_JOIN(tx_args.thread, NULL);
log_debug("Joined TX task\n");
}
if (p->out_file != NULL) {
pthread_join(rx_args.thread, NULL);
THREAD_JOIN(rx_args.thread, NULL);
log_debug("Joined RX task\n");
}

View file

@ -14,14 +14,10 @@ endif()
set(LIBS libbladerf_shared)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
set(INCLUDES ${INCLUDES} ${LIBPTHREADSWIN32_INCLUDE_DIRS})
set(LIBS ${LIBS} ${LIBPTHREADSWIN32_LIBRARIES})
else()
if(NOT MSVC)
find_package(Threads REQUIRED)
set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT})
endif(MSVC)
endif(NOT MSVC)
set(SRC

View file

@ -284,10 +284,10 @@ void *loopback_burst_rx_task (void *args)
burst_num, bladerf_strerror(status));
} else if (meta.status & BLADERF_META_STATUS_OVERRUN) {
fprintf(stderr, "Error: RX overrun detected.\n");
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
t->rx_ready = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
} else {
/*
printf("Read %-8u samples @ 0x%08"PRIx64" (%-8"PRIu64")\n",
@ -336,9 +336,9 @@ void *loopback_burst_rx_task (void *args)
* rid ourselves of any junk in the RX FIFOs and are
* ready to start the test */
next_state = WAIT_FOR_BURST_START;
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->rx_ready = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
}
break;
@ -443,9 +443,9 @@ void *loopback_burst_rx_task (void *args)
break;
}
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
stop = t->stop;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
if (status < 0) {
@ -459,9 +459,9 @@ void *loopback_burst_rx_task (void *args)
#endif
/* Ensure the TX side is signalled to stop, if it isn't already */
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
return NULL;
}
@ -514,10 +514,10 @@ void *loopback_burst_rx_task_rf (void *args)
burst_num, bladerf_strerror(status));
} else if (meta.status & BLADERF_META_STATUS_OVERRUN) {
fprintf(stderr, "Error: RX overrun detected.\n");
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
t->rx_ready = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
} else {
/*
printf("Read %-8u samples @ 0x%08"PRIx64" (%-8"PRIu64")\n",
@ -565,9 +565,9 @@ void *loopback_burst_rx_task_rf (void *args)
* rid ourselves of any junk in the RX FIFOs and are
* ready to start the test */
next_state = WAIT_FOR_BURST_START;
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->rx_ready = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
}
break;
@ -672,9 +672,9 @@ void *loopback_burst_rx_task_rf (void *args)
break;
}
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
stop = t->stop;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
if (status < 0) {
@ -688,9 +688,9 @@ void *loopback_burst_rx_task_rf (void *args)
#endif
/* Ensure the TX side is signalled to stop, if it isn't already */
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
return NULL;
}

View file

@ -28,8 +28,8 @@
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <pthread.h>
#include <libbladeRF.h>
#include "thread.h"
#define LOOPBACK_TX_MAGNITUDE 2000
#define LOOPBACK_RX_POWER_THRESH (256 * 256)
@ -40,7 +40,7 @@ struct loopback_burst_test {
struct loopback_burst *bursts;
unsigned int num_bursts;
pthread_mutex_t lock;
MUTEX lock;
bool stop;
bool rx_ready;
bladerf_frequency frequency;

View file

@ -32,7 +32,7 @@
#include <stdbool.h>
#include <stdint.h>
#include <limits.h>
#include <pthread.h>
#include "thread.h"
#include <libbladeRF.h>
#include "test_timestamps.h"
@ -77,8 +77,8 @@ static struct async_task
size_t curr_buf_idx;
size_t n_buffers;
pthread_t thread;
pthread_mutex_t lock;
THREAD thread;
MUTEX lock;
} rx_task, tx_task;
void *callback(struct bladerf *dev, struct bladerf_stream *stream,
@ -90,7 +90,7 @@ void *callback(struct bladerf *dev, struct bladerf_stream *stream,
void *ret;
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->curr_buf_idx = (t->curr_buf_idx + 1) % t->n_buffers;
ret = t->buffers[t->curr_buf_idx];
@ -112,7 +112,7 @@ void *callback(struct bladerf *dev, struct bladerf_stream *stream,
ret = BLADERF_STREAM_SHUTDOWN;
}
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
return ret;
}
@ -146,10 +146,10 @@ static void *stream_task(void *arg)
bladerf_deinit_stream(stream);
out:
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->state = TASK_STOPPED;
t->exit_status = status;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
return NULL;
}
@ -217,8 +217,8 @@ static int init_if(struct bladerf *dev, struct app_params *p, bladerf_module m,
t->fmt = fmt;
t->state = state = TASK_UNINITIALIZED;
status = pthread_create(&t->thread, NULL, stream_task, t);
if (status != 0) {
status = THREAD_CREATE(&t->thread, stream_task, t);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to launch %s task\n",
m == BLADERF_MODULE_RX ? "RX" : "TX");
return status;
@ -226,15 +226,15 @@ static int init_if(struct bladerf *dev, struct app_params *p, bladerf_module m,
do {
usleep(25000);
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
state = t->state;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
} while (state == TASK_UNINITIALIZED);
/* This may have already stopped if an invalid configuration was
* detected. */
if (state == TASK_STOPPED) {
pthread_join(t->thread, NULL);
THREAD_JOIN(t->thread, NULL);
if (t->exit_status != exp_status) {
fprintf(stderr,
"Uexpected status when configuring async %s: %s\n",
@ -274,23 +274,23 @@ static int deinit_if(struct bladerf *dev, bladerf_module m, bool sync,
return -1;
}
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
state = t->state;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
while (state != TASK_STOPPED) {
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->state = TASK_SHUTDOWN_REQUESTED;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
usleep(25000);
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
state = t->state;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
pthread_join(t->thread, NULL);
THREAD_JOIN(t->thread, NULL);
if (t->exit_status != exp_status) {
fprintf(stderr,
@ -331,7 +331,7 @@ static void init_task_info(struct bladerf *dev, struct app_params *p,
t->n_buffers = 16;
t->curr_buf_idx = 0;
pthread_mutex_init(&t->lock, NULL);
MUTEX_INIT(&t->lock);
}
int test_fn_format_mismatch(struct bladerf *dev, struct app_params *p)

View file

@ -33,7 +33,6 @@
#include <stdint.h>
#include <limits.h>
#include <inttypes.h>
#include <pthread.h>
#include <libbladeRF.h>
#include "test_timestamps.h"
#include "loopback.h"
@ -88,9 +87,9 @@ static void * tx_task(void *args)
i + 1, samples_left, bladerf_strerror(status));
/* Stop the RX worker */
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
meta.flags &= ~BLADERF_META_FLAG_TX_BURST_START;
@ -109,15 +108,15 @@ static void * tx_task(void *args)
bladerf_strerror(status));
/* Stop the RX worker */
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
}
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
stop = t->stop;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
/* Wait for samples to finish */
@ -195,10 +194,10 @@ int test_fn_loopback_onoff(struct bladerf *dev, struct app_params *p)
{
int status = 0;
struct loopback_burst_test test;
pthread_t tx_thread;
THREAD tx_thread;
bool tx_started = false;
pthread_t rx_thread;
THREAD rx_thread;
bool rx_started = false;
bool rx_ready = false;
@ -208,7 +207,7 @@ int test_fn_loopback_onoff(struct bladerf *dev, struct app_params *p)
test.stop = false;
test.rx_ready = false;
pthread_mutex_init(&test.lock, NULL);
MUTEX_INIT(&test.lock);
test.bursts = (struct loopback_burst *) malloc(test.num_bursts * sizeof(test.bursts[0]));
if (test.bursts == NULL) {
@ -225,8 +224,8 @@ int test_fn_loopback_onoff(struct bladerf *dev, struct app_params *p)
printf("Starting bursts...\n");
status = pthread_create(&rx_thread, NULL, loopback_burst_rx_task, &test);
if (status != 0) {
status = THREAD_CREATE(&rx_thread, loopback_burst_rx_task, &test);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to start RX thread: %s\n", strerror(status));
goto out;
} else {
@ -235,13 +234,13 @@ int test_fn_loopback_onoff(struct bladerf *dev, struct app_params *p)
while (!rx_ready) {
usleep(10000);
pthread_mutex_lock(&test.lock);
MUTEX_LOCK(&test.lock);
rx_ready = test.rx_ready;
pthread_mutex_unlock(&test.lock);
MUTEX_UNLOCK(&test.lock);
}
status = pthread_create(&tx_thread, NULL, tx_task, &test);
if (status != 0) {
status = THREAD_CREATE(&tx_thread, tx_task, &test);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to start TX thread: %s\n", strerror(status));
goto out;
} else {
@ -250,11 +249,11 @@ int test_fn_loopback_onoff(struct bladerf *dev, struct app_params *p)
out:
if (tx_started) {
pthread_join(tx_thread, NULL);
THREAD_JOIN(tx_thread, NULL);
}
if (rx_started) {
pthread_join(rx_thread, NULL);
THREAD_JOIN(rx_thread, NULL);
}
free(test.bursts);

View file

@ -33,7 +33,7 @@
#include <stdint.h>
#include <limits.h>
#include <inttypes.h>
#include <pthread.h>
#include "thread.h"
#include <libbladeRF.h>
#include "test_timestamps.h"
#include "loopback.h"
@ -88,9 +88,9 @@ static void * tx_task(void *args)
i + 1, samples_left, bladerf_strerror(status));
/* Stop the RX worker */
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
meta.flags &= ~BLADERF_META_FLAG_TX_BURST_START;
@ -109,15 +109,15 @@ static void * tx_task(void *args)
bladerf_strerror(status));
/* Stop the RX worker */
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
t->stop = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
}
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
stop = t->stop;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
/* Wait for samples to finish */
@ -199,10 +199,10 @@ int test_fn_loopback_onoff_rf(struct bladerf *dev, struct app_params *p)
return 0;
int status = 0;
struct loopback_burst_test test;
pthread_t tx_thread;
THREAD tx_thread;
bool tx_started = false;
pthread_t rx_thread;
THREAD rx_thread;
bool rx_started = false;
bool rx_ready = false;
@ -213,7 +213,7 @@ int test_fn_loopback_onoff_rf(struct bladerf *dev, struct app_params *p)
test.rx_ready = false;
test.frequency = 100e6;
pthread_mutex_init(&test.lock, NULL);
MUTEX_INIT(&test.lock);
fprintf(stderr, "[WARNING] loopback_onoff_rf under construction\n");
fprintf(stderr, "[WARNING] Failure expected\n");
@ -234,8 +234,8 @@ int test_fn_loopback_onoff_rf(struct bladerf *dev, struct app_params *p)
printf("Starting bursts...\n");
status = pthread_create(&rx_thread, NULL, loopback_burst_rx_task_rf, &test);
if (status != 0) {
status = THREAD_CREATE(&rx_thread, loopback_burst_rx_task_rf, &test);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to start RX thread: %s\n", strerror(status));
goto out;
} else {
@ -244,13 +244,13 @@ int test_fn_loopback_onoff_rf(struct bladerf *dev, struct app_params *p)
while (!rx_ready) {
usleep(10000);
pthread_mutex_lock(&test.lock);
MUTEX_LOCK(&test.lock);
rx_ready = test.rx_ready;
pthread_mutex_unlock(&test.lock);
MUTEX_UNLOCK(&test.lock);
}
status = pthread_create(&tx_thread, NULL, tx_task, &test);
if (status != 0) {
status = THREAD_CREATE(&tx_thread, tx_task, &test);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to start TX thread: %s\n", strerror(status));
goto out;
} else {
@ -259,11 +259,11 @@ int test_fn_loopback_onoff_rf(struct bladerf *dev, struct app_params *p)
out:
if (tx_started) {
pthread_join(tx_thread, NULL);
THREAD_JOIN(tx_thread, NULL);
}
if (rx_started) {
pthread_join(rx_thread, NULL);
THREAD_JOIN(rx_thread, NULL);
}
free(test.bursts);

View file

@ -35,7 +35,7 @@
#include <stdint.h>
#include <limits.h>
#include <inttypes.h>
#include <pthread.h>
#include "thread.h"
#include <assert.h>
#include <libbladeRF.h>
#include "test_timestamps.h"
@ -284,9 +284,9 @@ static void * tx_task(void *args)
status = tx_samples(t, samples, &meta, t->bursts[i].duration, i);
if (status != 0) {
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
stop = t->stop = true;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
} else {
meta.flags = BLADERF_META_FLAG_TX_UPDATE_TIMESTAMP;
@ -296,9 +296,9 @@ static void * tx_task(void *args)
}
pthread_mutex_lock(&t->lock);
MUTEX_LOCK(&t->lock);
stop = t->stop;
pthread_mutex_unlock(&t->lock);
MUTEX_UNLOCK(&t->lock);
}
}
@ -341,10 +341,10 @@ int test_fn_loopback_onoff_zp(struct bladerf *dev, struct app_params *p)
{
int status = 0;
struct loopback_burst_test test;
pthread_t tx_thread;
THREAD tx_thread;
bool tx_started = false;
pthread_t rx_thread;
THREAD rx_thread;
bool rx_started = false;
bool rx_ready = false;
@ -354,7 +354,7 @@ int test_fn_loopback_onoff_zp(struct bladerf *dev, struct app_params *p)
test.stop = false;
test.rx_ready = false;
pthread_mutex_init(&test.lock, NULL);
MUTEX_INIT(&test.lock);
test.bursts = (struct loopback_burst *) malloc(test.num_bursts * sizeof(test.bursts[0]));
if (test.bursts == NULL) {
@ -371,8 +371,8 @@ int test_fn_loopback_onoff_zp(struct bladerf *dev, struct app_params *p)
printf("Starting bursts...\n");
status = pthread_create(&rx_thread, NULL, loopback_burst_rx_task, &test);
if (status != 0) {
status = THREAD_CREATE(&rx_thread, loopback_burst_rx_task, &test);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to start RX thread: %s\n", strerror(status));
goto out;
} else {
@ -381,13 +381,13 @@ int test_fn_loopback_onoff_zp(struct bladerf *dev, struct app_params *p)
while (!rx_ready) {
usleep(10000);
pthread_mutex_lock(&test.lock);
MUTEX_LOCK(&test.lock);
rx_ready = test.rx_ready;
pthread_mutex_unlock(&test.lock);
MUTEX_UNLOCK(&test.lock);
}
status = pthread_create(&tx_thread, NULL, tx_task, &test);
if (status != 0) {
status = THREAD_CREATE(&tx_thread, tx_task, &test);
if (status != THREAD_SUCCESS) {
fprintf(stderr, "Failed to start TX thread: %s\n", strerror(status));
goto out;
} else {
@ -396,11 +396,11 @@ int test_fn_loopback_onoff_zp(struct bladerf *dev, struct app_params *p)
out:
if (tx_started) {
pthread_join(tx_thread, NULL);
THREAD_JOIN(tx_thread, NULL);
}
if (rx_started) {
pthread_join(rx_thread, NULL);
THREAD_JOIN(rx_thread, NULL);
}
free(test.bursts);

View file

@ -31,11 +31,11 @@
#include <inttypes.h>
#include <libbladeRF.h>
#include <getopt.h>
#include <pthread.h>
#include "conversions.h"
#include "test_timestamps.h"
#include "test_txrx_hwloop.h"
#include "minmax.h"
#include "thread.h"
#ifdef _WIN32
#include "gettimeofday.h"
@ -97,8 +97,8 @@ int main(int argc, char *argv[]) {
bladerf_log_level log_level;
/** Threading */
pthread_t thread_rx;
pthread_t thread_loopcompare;
THREAD thread_rx;
THREAD thread_loopcompare;
thread_args args_loopbackcompare;
thread_args args_rx;
@ -231,14 +231,14 @@ int main(int argc, char *argv[]) {
args_rx.is_rx_device = true;
args_rx.dev = dev_rx;
args_rx.tc = &test;
pthread_create(&thread_rx, NULL, rx_task, &args_rx);
THREAD_CREATE(&thread_rx, rx_task, &args_rx);
}
if (test.compare == true) {
args_loopbackcompare.is_rx_device = false;
args_loopbackcompare.dev = dev_tx;
args_loopbackcompare.tc = &test;
pthread_create(&thread_loopcompare, NULL, rx_task, &args_loopbackcompare);
THREAD_CREATE(&thread_loopcompare, rx_task, &args_loopbackcompare);
}
for (i = 0; i < test.iterations && status == 0; i++) {
@ -287,12 +287,12 @@ int main(int argc, char *argv[]) {
printf("TX finished in %.4f seconds\n", time_passed);
out:
if (!test.just_tx) {
pthread_join(thread_rx, NULL);
THREAD_JOIN(thread_rx, NULL);
bladerf_close(dev_rx);
}
if (test.compare)
pthread_join(thread_loopcompare, NULL);
THREAD_JOIN(thread_loopcompare, NULL);
status_out = bladerf_enable_module(dev_tx, BLADERF_MODULE_TX, false);
if (status_out != 0) {

View file

@ -24,6 +24,7 @@
*/
#include <stdio.h>
#include <getopt.h>
#include "thread.h"
#include "log.h"
struct test_case {
@ -326,6 +327,6 @@ void *rx_task(void *args) {
cleanup:
free(samples);
free(file_name);
pthread_exit(NULL);
THREAD_EXIT(NULL);
fclose(file);
}

View file

@ -117,7 +117,7 @@ mkdir %BUILDDIR64%
pushd %BUILDDIR64%
echo ====================== Configuring 64-bit build ======================
cmake -G %CMAKE_GENERATOR_64% -DCMAKE_BUILD_TYPE=%BUILD_TYPE% ^
-DLIBUSB_PATH=%LIBUSB% -DLIBPTHREADSWIN32_PATH=%PTHREADS% ^
-DLIBUSB_PATH=%LIBUSB% ^
..\bladeRF\host ^
|| goto EXIT_FAILURE
@ -138,7 +138,7 @@ echo[
echo[
echo ====================== Configuring 32-bit build ======================
cmake -G %CMAKE_GENERATOR_32% -DCMAKE_BUILD_TYPE=%BUILD_TYPE% ^
-DLIBUSB_PATH=%LIBUSB% -DLIBPTHREADSWIN32_PATH=%PTHREADS% ^
-DLIBUSB_PATH=%LIBUSB% ^
..\bladeRF\host ^
|| goto EXIT_FAILURE

View file

@ -1,4 +1,7 @@
cmake_minimum_required(VERSION 3.5)
add_subdirectory(bladeRF-cli)
add_subdirectory(bladeRF-fsk/c)
if(NOT MSVC)
add_subdirectory(bladeRF-fsk/c)
endif()

View file

@ -28,11 +28,9 @@ configure_file(
find_package(LibTecla)
find_package(LibEdit)
if(MSVC)
find_package(LibPThreadsWin32 REQUIRED)
else(MSVC)
if(NOT MSVC)
find_package(Threads REQUIRED)
endif(MSVC)
endif(NOT MSVC)
find_program(PANDOC_EXECUTABLE pandoc)
find_program(BASH_EXECUTABLE bash)
@ -169,7 +167,6 @@ endif()
if(MSVC)
set(CLI_INCLUDE_DIRS ${CLI_INCLUDE_DIRS}
${BLADERF_HOST_COMMON_INCLUDE_DIRS}/windows
${LIBPTHREADSWIN32_INCLUDE_DIRS}
)
endif()
@ -266,7 +263,7 @@ set(CLI_LINK_LIBRARIES
if(NOT MSVC)
set(CLI_LINK_LIBRARIES ${CLI_LINK_LIBRARIES} m)
endif()
endif(NOT MSVC)
if(ENABLE_LIBTECLA)
set(CLI_LINK_LIBRARIES ${CLI_LINK_LIBRARIES} ${LIBTECLA_LIBRARIES})
@ -280,10 +277,6 @@ elseif(ENABLE_LIBEDIT)
set(CLI_LINK_LIBRARIES ${CLI_LINK_LIBRARIES} ${LIBEDIT_LIBRARIES})
endif(ENABLE_LIBTECLA)
if(LIBPTHREADSWIN32_FOUND)
set(CLI_LINK_LIBRARIES ${CLI_LINK_LIBRARIES} ${LIBPTHREADSWIN32_LIBRARIES})
endif()
if(LIBC_VERSION)
# clock_gettime() was moved from librt -> libc in 2.17
if(${LIBC_VERSION} VERSION_LESS "2.17")

View file

@ -17,7 +17,6 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <errno.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

View file

@ -19,7 +19,6 @@
*/
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
@ -36,6 +35,7 @@
#include "parse.h"
#include "rel_assert.h"
#include "rxtx_impl.h"
#include "thread.h"
#include "doc/cmd_help.h"
int gen_write_fmt_sample(FILE *fp, enum rxtx_fmt fmt, int16_t s_i, int16_t s_q) {

View file

@ -20,7 +20,6 @@
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>

View file

@ -20,7 +20,6 @@
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <pthread.h>
#include <string.h>
#include "host_config.h"
@ -112,7 +111,7 @@ void rxtx_set_state(struct rxtx_data *rxtx, enum rxtx_state state)
{
MUTEX_LOCK(&rxtx->task_mgmt.lock);
rxtx->task_mgmt.state = state;
pthread_cond_signal(&rxtx->task_mgmt.signal_state_change);
COND_SIGNAL(&rxtx->task_mgmt.signal_state_change);
MUTEX_UNLOCK(&rxtx->task_mgmt.lock);
}
@ -158,7 +157,7 @@ void rxtx_submit_request(struct rxtx_data *rxtx, unsigned char req)
{
MUTEX_LOCK(&rxtx->task_mgmt.lock);
rxtx->task_mgmt.req |= req;
pthread_cond_signal(&rxtx->task_mgmt.signal_req);
COND_SIGNAL(&rxtx->task_mgmt.signal_req);
MUTEX_UNLOCK(&rxtx->task_mgmt.lock);
}
@ -415,9 +414,9 @@ struct rxtx_data *rxtx_data_alloc(bladerf_direction dir)
ret->task_mgmt.state = RXTX_STATE_IDLE;
ret->task_mgmt.req = 0;
MUTEX_INIT(&ret->task_mgmt.lock);
pthread_cond_init(&ret->task_mgmt.signal_req, NULL);
pthread_cond_init(&ret->task_mgmt.signal_done, NULL);
pthread_cond_init(&ret->task_mgmt.signal_state_change, NULL);
COND_INIT(&ret->task_mgmt.signal_req);
COND_INIT(&ret->task_mgmt.signal_done);
COND_INIT(&ret->task_mgmt.signal_state_change);
ret->task_mgmt.main_task_waiting = false;
/* Initialize error management */
@ -434,9 +433,9 @@ int rxtx_startup(struct cli_state *s, bladerf_direction dir)
if (rxtx_is_tx(dir)) {
rxtx_set_state(s->tx, RXTX_STATE_INIT);
status = pthread_create(&s->tx->task_mgmt.thread, NULL, tx_task, s);
status = THREAD_CREATE(&s->tx->task_mgmt.thread, tx_task, s);
if (status < 0) {
if (status != THREAD_SUCCESS) {
rxtx_set_state(s->tx, RXTX_STATE_FAIL);
} else {
status = rxtx_wait_for_state(s->tx, RXTX_STATE_IDLE, 0);
@ -446,9 +445,8 @@ int rxtx_startup(struct cli_state *s, bladerf_direction dir)
}
} else {
rxtx_set_state(s->rx, RXTX_STATE_INIT);
status = pthread_create(&s->rx->task_mgmt.thread, NULL, rx_task, s);
if (status < 0) {
status = THREAD_CREATE(&s->rx->task_mgmt.thread, rx_task, s);
if (status != THREAD_SUCCESS) {
rxtx_set_state(s->rx, RXTX_STATE_FAIL);
} else {
status = rxtx_wait_for_state(s->rx, RXTX_STATE_IDLE, 0);
@ -478,7 +476,7 @@ void rxtx_shutdown(struct cli_state *s, struct rxtx_data *rxtx)
if (rxtx->task_mgmt.started && rxtx_get_state(rxtx) != RXTX_STATE_FAIL) {
rxtx_submit_request(rxtx, RXTX_TASK_REQ_SHUTDOWN);
pthread_join(rxtx->task_mgmt.thread, NULL);
THREAD_JOIN(rxtx->task_mgmt.thread, NULL);
}
free(rxtx->file_mgmt.path);
@ -741,7 +739,7 @@ void rxtx_task_exec_idle(struct rxtx_data *rxtx, unsigned char *requests)
/* Wait until we're asked to start or shutdown */
while (!(*requests & (RXTX_TASK_REQ_START | RXTX_TASK_REQ_SHUTDOWN))) {
MUTEX_LOCK(&rxtx->task_mgmt.lock);
pthread_cond_wait(&rxtx->task_mgmt.signal_req, &rxtx->task_mgmt.lock);
COND_WAIT(&rxtx->task_mgmt.signal_req, &rxtx->task_mgmt.lock);
*requests = rxtx->task_mgmt.req;
MUTEX_UNLOCK(&rxtx->task_mgmt.lock);
}
@ -791,7 +789,6 @@ int rxtx_handle_wait(struct cli_state *s,
int status = CLI_RET_UNKNOWN;
bool ok;
unsigned int timeout_ms = 0;
struct timespec timeout_abs;
enum rxtx_state state;
static const struct numeric_suffix times[] = {
@ -825,29 +822,13 @@ int rxtx_handle_wait(struct cli_state *s,
MUTEX_UNLOCK(&s->dev_lock);
if (timeout_ms != 0) {
const unsigned int timeout_sec = timeout_ms / 1000;
status = clock_gettime(CLOCK_REALTIME, &timeout_abs);
if (status != 0) {
goto out;
}
timeout_abs.tv_sec += timeout_sec;
timeout_abs.tv_nsec += (timeout_ms % 1000) * 1000 * 1000;
if (timeout_abs.tv_nsec >= NSEC_PER_SEC) {
timeout_abs.tv_sec += timeout_abs.tv_nsec / NSEC_PER_SEC;
timeout_abs.tv_nsec %= NSEC_PER_SEC;
}
MUTEX_LOCK(&rxtx->task_mgmt.lock);
rxtx->task_mgmt.main_task_waiting = true;
while (rxtx->task_mgmt.main_task_waiting) {
status =
pthread_cond_timedwait(&rxtx->task_mgmt.signal_done,
&rxtx->task_mgmt.lock, &timeout_abs);
status = COND_TIMED_WAIT(&rxtx->task_mgmt.signal_done,
&rxtx->task_mgmt.lock, timeout_ms);
if (status == ETIMEDOUT) {
if (status == THREAD_TIMEOUT) {
rxtx->task_mgmt.main_task_waiting = false;
}
}
@ -857,19 +838,18 @@ int rxtx_handle_wait(struct cli_state *s,
MUTEX_LOCK(&rxtx->task_mgmt.lock);
rxtx->task_mgmt.main_task_waiting = true;
while (rxtx->task_mgmt.main_task_waiting) {
status = pthread_cond_wait(&rxtx->task_mgmt.signal_done,
status = COND_WAIT(&rxtx->task_mgmt.signal_done,
&rxtx->task_mgmt.lock);
}
MUTEX_UNLOCK(&rxtx->task_mgmt.lock);
}
out:
/* Re-acquire the device control lock, as the top-level command handler
* will be unlocking this when it's done */
MUTEX_LOCK(&s->dev_lock);
/* Expected and OK condition */
if (status == ETIMEDOUT) {
if (status == THREAD_TIMEOUT) {
status = 0;
}
@ -887,7 +867,7 @@ bool rxtx_release_wait(struct rxtx_data *rxtx)
MUTEX_LOCK(&rxtx->task_mgmt.lock);
was_waiting = rxtx->task_mgmt.main_task_waiting;
rxtx->task_mgmt.main_task_waiting = false;
pthread_cond_signal(&rxtx->task_mgmt.signal_done);
COND_SIGNAL(&rxtx->task_mgmt.signal_done);
MUTEX_UNLOCK(&rxtx->task_mgmt.lock);
return was_waiting;
@ -898,36 +878,19 @@ int rxtx_wait_for_state(struct rxtx_data *rxtx,
unsigned int timeout_ms)
{
int status = 0;
struct timespec timeout_abs;
if (timeout_ms != 0) {
const unsigned int timeout_sec = timeout_ms / 1000;
status = clock_gettime(CLOCK_REALTIME, &timeout_abs);
if (status != 0) {
return -1;
}
timeout_abs.tv_sec += timeout_sec;
timeout_abs.tv_nsec += (timeout_ms % 1000) * 1000 * 1000;
if (timeout_abs.tv_nsec >= NSEC_PER_SEC) {
timeout_abs.tv_sec += timeout_abs.tv_nsec / NSEC_PER_SEC;
timeout_abs.tv_nsec %= NSEC_PER_SEC;
}
MUTEX_LOCK(&rxtx->task_mgmt.lock);
while (rxtx->task_mgmt.state != req_state && status == 0) {
status =
pthread_cond_timedwait(&rxtx->task_mgmt.signal_state_change,
&rxtx->task_mgmt.lock, &timeout_abs);
while (rxtx->task_mgmt.state != req_state && status == THREAD_SUCCESS) {
status = COND_TIMED_WAIT(&rxtx->task_mgmt.signal_state_change,
&rxtx->task_mgmt.lock, timeout_ms);
}
MUTEX_UNLOCK(&rxtx->task_mgmt.lock);
} else {
MUTEX_LOCK(&rxtx->task_mgmt.lock);
while (rxtx->task_mgmt.state != req_state) {
status = pthread_cond_wait(&rxtx->task_mgmt.signal_state_change,
status = COND_WAIT(&rxtx->task_mgmt.signal_state_change,
&rxtx->task_mgmt.lock);
}
MUTEX_UNLOCK(&rxtx->task_mgmt.lock);

View file

@ -102,16 +102,16 @@ struct file_mgmt {
/* Task and thread management */
struct task_mgmt {
pthread_t thread; /* Handle to thread in which the task runs */
THREAD thread; /* Handle to thread in which the task runs */
bool started; /* Has the thread been started? */
enum rxtx_state state; /* Task state */
uint8_t req; /* Requests for state change. See
* RXTX_TASK_REQ_* bitmasks */
MUTEX lock; /* Must be held to access 'req' or 'state' */
pthread_cond_t signal_req; /* Signal when a request has been made */
pthread_cond_t signal_done; /* Signal when task finishes work */
pthread_cond_t signal_state_change; /* Signal after state change */
COND signal_req; /* Signal when a request has been made */
COND signal_done; /* Signal when task finishes work */
COND signal_state_change; /* Signal after state change */
bool main_task_waiting; /* Main task is blocked waiting */
};

View file

@ -19,7 +19,6 @@
*/
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
@ -31,6 +30,7 @@
#include "minmax.h"
#include "parse.h"
#include "rel_assert.h"
#include "thread.h"
#include "rxtx_impl.h"
/* The DAC range is [-2048, 2047] */

View file

@ -19,7 +19,6 @@
*/
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
@ -31,6 +30,7 @@
#include "cmd/rxtx.h"
#include "input.h"
#include "script.h"
#include "thread.h"
/* There's currently only ever 1 active cli_state */
static struct cli_state *cli_state;
@ -105,7 +105,7 @@ struct cli_state *cli_state_create()
cli_state->dev_info.is_bladerf_x40_x115 = false;
cli_state->dev_info.is_bladerf_micro = false;
pthread_mutex_init(&cli_state->dev_lock, NULL);
MUTEX_INIT(&cli_state->dev_lock);
cli_state->rx = rxtx_data_alloc(BLADERF_RX);
if (!cli_state->rx) {
@ -305,25 +305,25 @@ const char *cli_strerror(int error, int lib_error)
void cli_error_init(struct cli_error *e)
{
pthread_mutex_init(&e->lock, NULL);
MUTEX_INIT(&e->lock);
e->type = ETYPE_CLI;
e->value = 0;
}
void set_last_error(struct cli_error *e, enum error_type type, int error)
{
pthread_mutex_lock(&e->lock);
MUTEX_LOCK(&e->lock);
e->type = type;
e->value = error;
pthread_mutex_unlock(&e->lock);
MUTEX_UNLOCK(&e->lock);
}
void get_last_error(struct cli_error *e, enum error_type *type, int *error)
{
pthread_mutex_lock(&e->lock);
MUTEX_LOCK(&e->lock);
*type = e->type;
*error = e->value;
pthread_mutex_unlock(&e->lock);
MUTEX_UNLOCK(&e->lock);
}
int expand_and_open(const char *filename, const char *mode, FILE **file)

View file

@ -26,7 +26,7 @@
#include "host_config.h"
#include "str_queue.h"
#include <libbladeRF.h>
#include <pthread.h>
#include "thread.h"
#include <stdbool.h>
#include <stdio.h>
@ -88,7 +88,7 @@ enum error_type {
struct cli_error {
int value; /**< Last command error */
enum error_type type; /**< Type/source of last error */
pthread_mutex_t lock;
MUTEX lock;
};
/**
@ -106,7 +106,7 @@ struct cli_dev_info {
struct cli_state {
struct bladerf *dev; /**< Device currently in use */
struct cli_dev_info dev_info; /**< Cached device information */
pthread_mutex_t dev_lock; /**< Should be held when performing
MUTEX dev_lock; /**< Should be held when performing
* any "device conrol" calls */
int last_lib_error; /**< Last libbladeRF error */

View file

@ -23,7 +23,6 @@
#include <getopt.h>
#include <stdbool.h>
#include <errno.h>
#include <pthread.h>
#include <string.h>
#include <libbladeRF.h>
#include "input/input.h"
@ -32,6 +31,7 @@
#include "common.h"
#include "cmd.h"
#include "version.h"
#include "thread.h"
#if BLADERF_OS_WINDOWS
#include "setenv.h"