Merge pull request #65 from Hoernchen/master

gain + windows
but need to fix '#define false 1' bugs

firmware/common/max2837.c

@@ -369,6 +369,58 @@ bool max2837_set_lpf_bandwidth(const uint32_t bandwidth_hz) {
 	}
 }
 
+bool max2837_set_lna_gain(const uint32_t gain_db) {
+	uint16_t val;
+	switch(gain_db){
+		case 40:
+			val = MAX2837_LNAgain_MAX;
+			break;
+		case 32:
+			val = MAX2837_LNAgain_M8;
+			break;
+		case 24:
+			val = MAX2837_LNAgain_M16;
+			break;
+		case 16:
+			val = MAX2837_LNAgain_M24;
+			break;
+		case 8:
+			val = MAX2837_LNAgain_M32;
+			break;
+		case 0:
+			val = MAX2837_LNAgain_M40;
+			break;
+		default:
+			return false;
+	}
+	set_MAX2837_LNAgain(val);
+	max2837_reg_commit(1);
+	return true;
+}
+
+bool max2837_set_vga_gain(const uint32_t gain_db) {
+	if( (gain_db & 0x1) || gain_db > 62)/* 0b11111*2 */
+		return false;
+		
+	set_MAX2837_VGA( 31-(gain_db >> 1) );
+	max2837_reg_commit(5);
+	return true;
+}
+
+bool max2837_set_txvga_gain(const uint32_t gain_db) {
+	uint16_t val=0;
+	if(gain_db <16){
+		val = 31-gain_db;
+		val |= (1 << 5); // bit6: 16db
+	} else{
+		val = 31-(gain_db-16);
+	}
+	
+	set_MAX2837_TXVGA_GAIN(val);
+	max2837_reg_commit(29);
+	return true;
+}
+
 #ifdef TEST
 int main(int ac, char **av)
 {

firmware/common/max2837.h

@@ -45,6 +45,9 @@ extern void max2837_stop(void);
  * where order of register writes matters. */
 extern void max2837_set_frequency(uint32_t freq);
 bool max2837_set_lpf_bandwidth(const uint32_t bandwidth_hz);
+bool max2837_set_lna_gain(const uint32_t gain_db);
+bool max2837_set_vga_gain(const uint32_t gain_db);
+bool max2837_set_txvga_gain(const uint32_t gain_db);
 	
 extern void max2837_tx(void);
 extern void max2837_rx(void);

firmware/common/max2837_regs.def

@@ -56,7 +56,7 @@ __MREG__(MAX2837_LNAgain,1,4,3)
 #define MAX2837_LNAgain_M8  0b100
 #define MAX2837_LNAgain_M16 0b010
 #define MAX2837_LNAgain_M24 0b110
-#define MAX2837_LNAgain_M32 0b001
+#define MAX2837_LNAgain_M32 0b011
 #define MAX2837_LNAgain_M40 0b111
 __MREG__(MAX2837_iqerr_trim,1,9,5)
 // 0b00000 = +4.0 degree phase error

firmware/hackrf_usb/hackrf_usb.c

@@ -760,6 +760,45 @@ usb_request_status_t usb_vendor_request_read_partid_serialno(
 	return USB_REQUEST_STATUS_OK;
 }
 
+usb_request_status_t usb_vendor_request_set_lna_gain(
+	usb_endpoint_t* const endpoint,	const usb_transfer_stage_t stage)
+{
+	if( stage == USB_TRANSFER_STAGE_SETUP ) {
+			const uint8_t value = max2837_set_lna_gain(endpoint->setup.index);
+			endpoint->buffer[0] = value;
+			usb_endpoint_schedule(endpoint->in, &endpoint->buffer, 1);
+			usb_endpoint_schedule_ack(endpoint->out);
+			return USB_REQUEST_STATUS_OK;
+	}
+	return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_vga_gain(
+	usb_endpoint_t* const endpoint,	const usb_transfer_stage_t stage)
+{
+	if( stage == USB_TRANSFER_STAGE_SETUP ) {
+			const uint8_t value = max2837_set_vga_gain(endpoint->setup.index);
+			endpoint->buffer[0] = value;
+			usb_endpoint_schedule(endpoint->in, &endpoint->buffer, 1);
+			usb_endpoint_schedule_ack(endpoint->out);
+			return USB_REQUEST_STATUS_OK;
+	}
+	return USB_REQUEST_STATUS_OK;
+}
+
+usb_request_status_t usb_vendor_request_set_txvga_gain(
+	usb_endpoint_t* const endpoint,	const usb_transfer_stage_t stage)
+{
+	if( stage == USB_TRANSFER_STAGE_SETUP ) {
+			const uint8_t value = max2837_set_txvga_gain(endpoint->setup.index);
+			endpoint->buffer[0] = value;
+			usb_endpoint_schedule(endpoint->in, &endpoint->buffer, 1);
+			usb_endpoint_schedule_ack(endpoint->out);
+			return USB_REQUEST_STATUS_OK;
+	}
+	return USB_REQUEST_STATUS_OK;
+}
+
 static const usb_request_handler_fn vendor_request_handler[] = {
 	NULL,
 	usb_vendor_request_set_transceiver_mode,
@@ -779,7 +818,10 @@ static const usb_request_handler_fn vendor_request_handler[] = {
 	usb_vendor_request_read_version_string,
 	usb_vendor_request_set_freq,
 	usb_vendor_request_set_amp_enable,
-	usb_vendor_request_read_partid_serialno
+	usb_vendor_request_read_partid_serialno,
+	usb_vendor_request_set_lna_gain,
+	usb_vendor_request_set_vga_gain,
+	usb_vendor_request_set_txvga_gain
 };
 
 static const uint32_t vendor_request_handler_count =

host/CMakeLists.txt

@@ -0,0 +1,21 @@
+#top dir cmake project for libhackrf + tools
+
+cmake_minimum_required(VERSION 2.8)
+project (hackrf_all)
+
+add_subdirectory(libhackrf)
+add_subdirectory(hackrf-tools)
+
+########################################################################
+# Create uninstall target
+########################################################################
+
+configure_file(
+    ${PROJECT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
+@ONLY)
+
+
+add_custom_target(uninstall
+    ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
+)

host/cmake/modules/FindLIBHACKRF.cmake

@@ -25,7 +25,7 @@ else (LIBHACKRF_INCLUDE_DIR AND LIBHACKRF_LIBRARIES)
   FIND_PATH(LIBHACKRF_INCLUDE_DIR
     NAMES hackrf.h
     HINTS $ENV{LIBHACKRF_DIR}/include ${PC_LIBHACKRF_INCLUDEDIR}
-    PATHS /usr/local/include/libhackrf /usr/local/include
+    PATHS /usr/local/include/libhackrf /usr/include/libhackrf /usr/local/include
     /usr/include ${CMAKE_SOURCE_DIR}/../libhackrf/src
     /opt/local/include/libhackrf
     ${LIBHACKRF_INCLUDE_DIR}

host/cmake/modules/FindThreads.cmake

@@ -0,0 +1,246 @@
+# Updated FindThreads.cmake that supports pthread-win32
+# Downloaded from http://www.vtk.org/Bug/bug_view_advanced_page.php?bug_id=6399
+
+# - This module determines the thread library of the system.
+#
+# The following variables are set
+#  CMAKE_THREAD_LIBS_INIT     - the thread library
+#  CMAKE_USE_SPROC_INIT       - are we using sproc?
+#  CMAKE_USE_WIN32_THREADS_INIT - using WIN32 threads?
+#  CMAKE_USE_PTHREADS_INIT    - are we using pthreads
+#  CMAKE_HP_PTHREADS_INIT     - are we using hp pthreads
+#
+# If use of pthreads-win32 is desired, the following variables
+# can be set.
+#
+#  THREADS_USE_PTHREADS_WIN32 -
+#    Setting this to true searches for the pthreads-win32
+#    port (since CMake 2.8.0)
+#
+#  THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME
+#      C  = no exceptions (default)
+#         (NOTE: This is the default scheme on most POSIX thread
+#          implementations and what you should probably be using)
+#      CE = C++ Exception Handling
+#      SE = Structure Exception Handling (MSVC only)
+#      (NOTE: Changing this option from the default may affect
+#       the portability of your application.  See pthreads-win32
+#       documentation for more details.)
+#
+#======================================================
+# Example usage where threading library
+# is provided by the system:
+#
+#   find_package(Threads REQUIRED)
+#   add_executable(foo foo.cc)
+#   target_link_libraries(foo ${CMAKE_THREAD_LIBS_INIT})
+#
+# Example usage if pthreads-win32 is desired on Windows
+# or a system provided thread library:
+#
+#   set(THREADS_USE_PTHREADS_WIN32 true)
+#   find_package(Threads REQUIRED)
+#   include_directories(${THREADS_PTHREADS_INCLUDE_DIR})
+#
+#   add_executable(foo foo.cc)
+#   target_link_libraries(foo ${CMAKE_THREAD_LIBS_INIT})
+#
+
+INCLUDE (CheckIncludeFiles)
+INCLUDE (CheckLibraryExists)
+SET(Threads_FOUND FALSE)
+
+IF(WIN32 AND NOT CYGWIN AND THREADS_USE_PTHREADS_WIN32)
+  SET(_Threads_ptwin32 true)
+ENDIF()
+
+# Do we have sproc?
+IF(CMAKE_SYSTEM MATCHES IRIX)
+  CHECK_INCLUDE_FILES("sys/types.h;sys/prctl.h"  CMAKE_HAVE_SPROC_H)
+ENDIF()
+
+IF(CMAKE_HAVE_SPROC_H)
+  # We have sproc
+  SET(CMAKE_USE_SPROC_INIT 1)
+
+ELSEIF(_Threads_ptwin32)
+
+  IF(NOT DEFINED THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME)
+    # Assign the default scheme
+    SET(THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME "C")
+  ELSE()
+    # Validate the scheme specified by the user
+    IF(NOT THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME STREQUAL "C" AND
+       NOT THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME STREQUAL "CE" AND
+       NOT THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME STREQUAL "SE")
+         MESSAGE(FATAL_ERROR "See documentation for FindPthreads.cmake, only C, CE, and SE modes are allowed")
+    ENDIF()
+    IF(NOT MSVC AND THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME STREQUAL "SE")
+      MESSAGE(FATAL_ERROR "Structured Exception Handling is only allowed for MSVC")
+    ENDIF(NOT MSVC AND THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME STREQUAL "SE")
+  ENDIF()
+
+  FIND_PATH(THREADS_PTHREADS_INCLUDE_DIR pthread.h)
+
+  # Determine the library filename
+  IF(MSVC)
+    SET(_Threads_pthreads_libname
+        pthreadV${THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME}2)
+  ELSEIF(MINGW)
+    SET(_Threads_pthreads_libname
+        pthreadG${THREADS_PTHREADS_WIN32_EXCEPTION_SCHEME}2)
+  ELSE()
+    MESSAGE(FATAL_ERROR "This should never happen")
+  ENDIF()
+
+  # Use the include path to help find the library if possible
+  SET(_Threads_lib_paths "")
+  IF(THREADS_PTHREADS_INCLUDE_DIR)
+     GET_FILENAME_COMPONENT(_Threads_root_dir
+                            ${THREADS_PTHREADS_INCLUDE_DIR} PATH)
+     SET(_Threads_lib_paths ${_Threads_root_dir}/lib)
+  ENDIF()
+  FIND_LIBRARY(THREADS_PTHREADS_WIN32_LIBRARY
+               NAMES ${_Threads_pthreads_libname}
+               PATHS ${_Threads_lib_paths}
+               DOC "The Portable Threads Library for Win32"
+               NO_SYSTEM_PATH
+               )
+
+  IF(THREADS_PTHREADS_INCLUDE_DIR AND THREADS_PTHREADS_WIN32_LIBRARY)
+    MARK_AS_ADVANCED(THREADS_PTHREADS_INCLUDE_DIR)
+    SET(CMAKE_THREAD_LIBS_INIT ${THREADS_PTHREADS_WIN32_LIBRARY})
+    SET(CMAKE_HAVE_THREADS_LIBRARY 1)
+    SET(Threads_FOUND TRUE)
+  ENDIF()
+
+  MARK_AS_ADVANCED(THREADS_PTHREADS_WIN32_LIBRARY)
+
+ELSE()
+  # Do we have pthreads?
+  CHECK_INCLUDE_FILES("pthread.h" CMAKE_HAVE_PTHREAD_H)
+  IF(CMAKE_HAVE_PTHREAD_H)
+
+    #
+    # We have pthread.h
+    # Let's check for the library now.
+    #
+    SET(CMAKE_HAVE_THREADS_LIBRARY)
+    IF(NOT THREADS_HAVE_PTHREAD_ARG)
+
+      # Do we have -lpthreads
+      CHECK_LIBRARY_EXISTS(pthreads pthread_create "" CMAKE_HAVE_PTHREADS_CREATE)
+      IF(CMAKE_HAVE_PTHREADS_CREATE)
+        SET(CMAKE_THREAD_LIBS_INIT "-lpthreads")
+        SET(CMAKE_HAVE_THREADS_LIBRARY 1)
+        SET(Threads_FOUND TRUE)
+      ENDIF()
+
+      # Ok, how about -lpthread
+      CHECK_LIBRARY_EXISTS(pthread pthread_create "" CMAKE_HAVE_PTHREAD_CREATE)
+      IF(CMAKE_HAVE_PTHREAD_CREATE)
+        SET(CMAKE_THREAD_LIBS_INIT "-lpthread")
+        SET(Threads_FOUND TRUE)
+        SET(CMAKE_HAVE_THREADS_LIBRARY 1)
+      ENDIF()
+
+      IF(CMAKE_SYSTEM MATCHES "SunOS.*")
+        # On sun also check for -lthread
+        CHECK_LIBRARY_EXISTS(thread thr_create "" CMAKE_HAVE_THR_CREATE)
+        IF(CMAKE_HAVE_THR_CREATE)
+          SET(CMAKE_THREAD_LIBS_INIT "-lthread")
+          SET(CMAKE_HAVE_THREADS_LIBRARY 1)
+          SET(Threads_FOUND TRUE)
+        ENDIF()
+      ENDIF(CMAKE_SYSTEM MATCHES "SunOS.*")
+
+    ENDIF(NOT THREADS_HAVE_PTHREAD_ARG)
+
+    IF(NOT CMAKE_HAVE_THREADS_LIBRARY)
+      # If we did not found -lpthread, -lpthread, or -lthread, look for -pthread
+      IF("THREADS_HAVE_PTHREAD_ARG" MATCHES "^THREADS_HAVE_PTHREAD_ARG")
+        MESSAGE(STATUS "Check if compiler accepts -pthread")
+        TRY_RUN(THREADS_PTHREAD_ARG THREADS_HAVE_PTHREAD_ARG
+          ${CMAKE_BINARY_DIR}
+          ${CMAKE_ROOT}/Modules/CheckForPthreads.c
+          CMAKE_FLAGS -DLINK_LIBRARIES:STRING=-pthread
+          COMPILE_OUTPUT_VARIABLE OUTPUT)
+
+        IF(THREADS_HAVE_PTHREAD_ARG)
+          IF(THREADS_PTHREAD_ARG MATCHES "^2$")
+            SET(Threads_FOUND TRUE)
+            MESSAGE(STATUS "Check if compiler accepts -pthread - yes")
+          ELSE()
+            MESSAGE(STATUS "Check if compiler accepts -pthread - no")
+            FILE(APPEND
+              ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+              "Determining if compiler accepts -pthread returned ${THREADS_PTHREAD_ARG} instead of 2. The compiler had the following output:\n${OUTPUT}\n\n")
+          ENDIF()
+        ELSE()
+          MESSAGE(STATUS "Check if compiler accepts -pthread - no")
+          FILE(APPEND
+            ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+            "Determining if compiler accepts -pthread failed with the following output:\n${OUTPUT}\n\n")
+        ENDIF()
+
+      ENDIF("THREADS_HAVE_PTHREAD_ARG" MATCHES "^THREADS_HAVE_PTHREAD_ARG")
+
+      IF(THREADS_HAVE_PTHREAD_ARG)
+        SET(Threads_FOUND TRUE)
+        SET(CMAKE_THREAD_LIBS_INIT "-pthread")
+      ENDIF()
+
+    ENDIF(NOT CMAKE_HAVE_THREADS_LIBRARY)
+  ENDIF(CMAKE_HAVE_PTHREAD_H)
+ENDIF()
+
+IF(CMAKE_THREAD_LIBS_INIT)
+  SET(CMAKE_USE_PTHREADS_INIT 1)
+  SET(Threads_FOUND TRUE)
+ENDIF()
+
+IF(CMAKE_SYSTEM MATCHES "Windows"
+   AND NOT THREADS_USE_PTHREADS_WIN32)
+  SET(CMAKE_USE_WIN32_THREADS_INIT 1)
+  SET(Threads_FOUND TRUE)
+ENDIF()
+
+IF(CMAKE_USE_PTHREADS_INIT)
+  IF(CMAKE_SYSTEM MATCHES "HP-UX-*")
+    # Use libcma if it exists and can be used.  It provides more
+    # symbols than the plain pthread library.  CMA threads
+    # have actually been deprecated:
+    #   http://docs.hp.com/en/B3920-90091/ch12s03.html#d0e11395
+    #   http://docs.hp.com/en/947/d8.html
+    # but we need to maintain compatibility here.
+    # The CMAKE_HP_PTHREADS setting actually indicates whether CMA threads
+    # are available.
+    CHECK_LIBRARY_EXISTS(cma pthread_attr_create "" CMAKE_HAVE_HP_CMA)
+    IF(CMAKE_HAVE_HP_CMA)
+      SET(CMAKE_THREAD_LIBS_INIT "-lcma")
+      SET(CMAKE_HP_PTHREADS_INIT 1)
+      SET(Threads_FOUND TRUE)
+    ENDIF(CMAKE_HAVE_HP_CMA)
+    SET(CMAKE_USE_PTHREADS_INIT 1)
+  ENDIF()
+
+  IF(CMAKE_SYSTEM MATCHES "OSF1-V*")
+    SET(CMAKE_USE_PTHREADS_INIT 0)
+    SET(CMAKE_THREAD_LIBS_INIT )
+  ENDIF()
+
+  IF(CMAKE_SYSTEM MATCHES "CYGWIN_NT*")
+    SET(CMAKE_USE_PTHREADS_INIT 1)
+    SET(Threads_FOUND TRUE)
+    SET(CMAKE_THREAD_LIBS_INIT )
+    SET(CMAKE_USE_WIN32_THREADS_INIT 0)
+  ENDIF()
+ENDIF(CMAKE_USE_PTHREADS_INIT)
+
+INCLUDE(FindPackageHandleStandardArgs)
+IF(_Threads_ptwin32)
+  FIND_PACKAGE_HANDLE_STANDARD_ARGS(Threads DEFAULT_MSG
+    THREADS_PTHREADS_WIN32_LIBRARY THREADS_PTHREADS_INCLUDE_DIR)
+ELSE()
+  FIND_PACKAGE_HANDLE_STANDARD_ARGS(Threads DEFAULT_MSG Threads_FOUND)
+ENDIF()

host/hackrf-tools/CMakeLists.txt

@@ -21,36 +21,43 @@
 
 # Based heavily upon the libftdi cmake setup.
 
-project(hackrf-tools)
+cmake_minimum_required(VERSION 2.8)
+project(hackrf-tools C)
 set(MAJOR_VERSION 0)
 set(MINOR_VERSION 1)
 set(PACKAGE hackrf-tools)
 set(VERSION_STRING ${MAJOR_VERSION}.${MINOR_VERSION})
 set(VERSION ${VERSION_STRING})
-set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}")
+set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/../cmake/modules)
-
-cmake_minimum_required(VERSION 2.8)
 
+if(MSVC)
+include_directories(getopt)
+else()
 add_definitions(-Wall)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu90")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98")
+endif()
-
-find_package(USB1 REQUIRED)
-include_directories(${LIBUSB_INCLUDE_DIR})
 
+if(NOT libhackrf_SOURCE_DIR)
 find_package(LIBHACKRF REQUIRED)
 include_directories(${LIBHACKRF_INCLUDE_DIR})
+else()
+include_directories(${libhackrf_SOURCE_DIR}/src)
+endif()
 
 add_subdirectory(src)
 
 ########################################################################
 # Create uninstall target
 ########################################################################
+
+if(NOT hackrf_all_SOURCE_DIR)
 configure_file(
-    ${CMAKE_SOURCE_DIR}/cmake_uninstall.cmake.in
+    ${PROJECT_SOURCE_DIR}/../cmake/cmake_uninstall.cmake.in
     ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
 @ONLY)
 
+
 add_custom_target(uninstall
     ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
 )
+endif()

host/hackrf-tools/getopt/getopt.h

@@ -0,0 +1,180 @@
+/* Declarations for getopt.
+   Copyright (C) 1989-1994, 1996-1999, 2001 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#ifndef _GETOPT_H
+
+#ifndef __need_getopt
+# define _GETOPT_H 1
+#endif
+
+/* If __GNU_LIBRARY__ is not already defined, either we are being used
+   standalone, or this is the first header included in the source file.
+   If we are being used with glibc, we need to include <features.h>, but
+   that does not exist if we are standalone.  So: if __GNU_LIBRARY__ is
+   not defined, include <ctype.h>, which will pull in <features.h> for us
+   if it's from glibc.  (Why ctype.h?  It's guaranteed to exist and it
+   doesn't flood the namespace with stuff the way some other headers do.)  */
+#if !defined __GNU_LIBRARY__
+# include <ctype.h>
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+extern char *optarg;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `optind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+extern int optind;
+
+/* Callers store zero here to inhibit the error message `getopt' prints
+   for unrecognized options.  */
+
+extern int opterr;
+
+/* Set to an option character which was unrecognized.  */
+
+extern int optopt;
+
+#ifndef __need_getopt
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct option' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument		(or 0) if the option does not take an argument,
+   required_argument	(or 1) if the option requires an argument,
+   optional_argument 	(or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `optarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct option
+{
+# if (defined __STDC__ && __STDC__) || defined __cplusplus
+  const char *name;
+# else
+  char *name;
+# endif
+  /* has_arg can't be an enum because some compilers complain about
+     type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+/* Names for the values of the `has_arg' field of `struct option'.  */
+
+# define no_argument		0
+# define required_argument	1
+# define optional_argument	2
+#endif	/* need getopt */
+
+
+/* Get definitions and prototypes for functions to process the
+   arguments in ARGV (ARGC of them, minus the program name) for
+   options given in OPTS.
+
+   Return the option character from OPTS just read.  Return -1 when
+   there are no more options.  For unrecognized options, or options
+   missing arguments, `optopt' is set to the option letter, and '?' is
+   returned.
+
+   The OPTS string is a list of characters which are recognized option
+   letters, optionally followed by colons, specifying that that letter
+   takes an argument, to be placed in `optarg'.
+
+   If a letter in OPTS is followed by two colons, its argument is
+   optional.  This behavior is specific to the GNU `getopt'.
+
+   The argument `--' causes premature termination of argument
+   scanning, explicitly telling `getopt' that there are no more
+   options.
+
+   If OPTS begins with `--', then non-option arguments are treated as
+   arguments to the option '\0'.  This behavior is specific to the GNU
+   `getopt'.  */
+
+#if (defined __STDC__ && __STDC__) || defined __cplusplus
+# ifdef __GNU_LIBRARY__
+/* Many other libraries have conflicting prototypes for getopt, with
+   differences in the consts, in stdlib.h.  To avoid compilation
+   errors, only prototype getopt for the GNU C library.  */
+extern int getopt (int __argc, char *const *__argv, const char *__shortopts);
+# else /* not __GNU_LIBRARY__ */
+extern int getopt ();
+# endif /* __GNU_LIBRARY__ */
+
+# ifndef __need_getopt
+extern int getopt_long (int __argc, char *const *__argv, const char *__shortopts,
+		        const struct option *__longopts, int *__longind);
+extern int getopt_long_only (int __argc, char *const *__argv,
+			     const char *__shortopts,
+		             const struct option *__longopts, int *__longind);
+
+/* Internal only.  Users should not call this directly.  */
+extern int _getopt_internal (int __argc, char *const *__argv,
+			     const char *__shortopts,
+		             const struct option *__longopts, int *__longind,
+			     int __long_only);
+# endif
+#else /* not __STDC__ */
+extern int getopt ();
+# ifndef __need_getopt
+extern int getopt_long ();
+extern int getopt_long_only ();
+
+extern int _getopt_internal ();
+# endif
+#endif /* __STDC__ */
+
+#ifdef	__cplusplus
+}
+#endif
+
+/* Make sure we later can get all the definitions and declarations.  */
+#undef __need_getopt
+
+#endif /* getopt.h */

host/hackrf-tools/src/CMakeLists.txt

@@ -23,6 +23,12 @@
 
 set(INSTALL_DEFAULT_BINDIR "bin" CACHE STRING "Appended to CMAKE_INSTALL_PREFIX")
 
+if(MSVC)
+add_library(libgetopt_static STATIC
+    ../getopt/getopt.c
+)
+endif()
+
 add_executable(hackrf_max2837 hackrf_max2837.c)
 install(TARGETS hackrf_max2837 RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR})
 
@@ -44,14 +50,22 @@ install(TARGETS hackrf_cpldjtag RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR})
 add_executable(hackrf_info hackrf_info.c)
 install(TARGETS hackrf_info RUNTIME DESTINATION ${INSTALL_DEFAULT_BINDIR})
 
+if(NOT libhackrf_SOURCE_DIR)
 include_directories(${LIBHACKRF_INCLUDE_DIR})
+LIST(APPEND TOOLS_LINK_LIBS ${LIBHACKRF_LIBRARIES})
+else()
+LIST(APPEND TOOLS_LINK_LIBS hackrf)
+endif()
 
-target_link_libraries(hackrf_max2837 ${LIBHACKRF_LIBRARIES})
+if(MSVC)
-target_link_libraries(hackrf_si5351c ${LIBHACKRF_LIBRARIES})
+LIST(APPEND TOOLS_LINK_LIBS libgetopt_static)
-target_link_libraries(hackrf_transfer ${LIBHACKRF_LIBRARIES})
+endif()
-target_link_libraries(hackrf_rffc5071 ${LIBHACKRF_LIBRARIES})
-target_link_libraries(hackrf_spiflash ${LIBHACKRF_LIBRARIES})
-target_link_libraries(hackrf_cpldjtag ${LIBHACKRF_LIBRARIES})
-target_link_libraries(hackrf_info ${LIBHACKRF_LIBRARIES})
 
 
+target_link_libraries(hackrf_max2837 ${TOOLS_LINK_LIBS})
+target_link_libraries(hackrf_si5351c ${TOOLS_LINK_LIBS})
+target_link_libraries(hackrf_transfer ${TOOLS_LINK_LIBS})
+target_link_libraries(hackrf_rffc5071 ${TOOLS_LINK_LIBS})
+target_link_libraries(hackrf_spiflash ${TOOLS_LINK_LIBS})
+target_link_libraries(hackrf_cpldjtag ${TOOLS_LINK_LIBS})
+target_link_libraries(hackrf_info ${TOOLS_LINK_LIBS})

host/hackrf-tools/src/hackrf_cpldjtag.c

@@ -28,7 +28,11 @@
 #include <string.h>
 #include <getopt.h>
 #include <sys/types.h>
+#include <stdint.h>
 
+#ifdef _MSC_VER
+typedef int ssize_t;
+#endif
 /* input file shouldn't be any longer than this */
 #define MAX_XSVF_LENGTH 0x10000
 #define PACKET_LEN	4096
@@ -43,6 +47,9 @@ static struct option long_options[] = {
 int parse_int(char* s, uint32_t* const value)
 {
 	uint_fast8_t base = 10;
+	char* s_end;
+	long long_value;
+
 	if (strlen(s) > 2) {
 		if (s[0] == '0')  {
 			if ((s[1] == 'x') || (s[1] == 'X')) {
@@ -55,8 +62,8 @@ int parse_int(char* s, uint32_t* const value)
 		}
 	}
 
-	char* s_end = s;
+	s_end = s;
-	const long long_value = strtol(s, &s_end, base);
+	long_value = strtol(s, &s_end, base);
 	if ((s != s_end) && (*s_end == 0)) {
 		*value = long_value;
 		return HACKRF_SUCCESS;

host/hackrf-tools/src/hackrf_max2837.c

@@ -46,6 +46,9 @@ static struct option long_options[] = {
 
 int parse_int(char* s, uint16_t* const value) {
 	uint_fast8_t base = 10;
+	char* s_end;
+	long long_value;
+
 	if( strlen(s) > 2 ) {
 		if( s[0] == '0' ) {
 			if( (s[1] == 'x') || (s[1] == 'X') ) {
@@ -58,8 +61,8 @@ int parse_int(char* s, uint16_t* const value) {
 		}
 	}
 
-	char* s_end = s;
+	s_end = s;
-	const long long_value = strtol(s, &s_end, base);
+	long_value = strtol(s, &s_end, base);
 	if( (s != s_end) && (*s_end == 0) ) {
 		*value = long_value;
 		return HACKRF_SUCCESS;
@@ -118,6 +121,8 @@ int main(int argc, char** argv) {
 	int opt;
 	uint16_t register_number = REGISTER_INVALID;
 	uint16_t register_value;
+	hackrf_device* device = NULL;
+	int option_index = 0;
 
 	int result = hackrf_init();
 	if( result ) {
@@ -125,14 +130,12 @@ int main(int argc, char** argv) {
 		return -1;
 	}
 	
-	hackrf_device* device = NULL;
 	result = hackrf_open(&device);
 	if( result ) {
 		printf("hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result);
 		return -1;
 	}
 
-	int option_index = 0;
 	while( (opt = getopt_long(argc, argv, "n:rw:", long_options, &option_index)) != EOF ) {
 		switch( opt ) {
 		case 'n':

host/hackrf-tools/src/hackrf_rffc5071.c

@@ -47,6 +47,9 @@ static struct option long_options[] = {
 
 int parse_int(char* s, uint16_t* const value) {
 	uint_fast8_t base = 10;
+	char* s_end;
+	long long_value;
+
 	if( strlen(s) > 2 ) {
 		if( s[0] == '0' ) {
 			if( (s[1] == 'x') || (s[1] == 'X') ) {
@@ -59,8 +62,8 @@ int parse_int(char* s, uint16_t* const value) {
 		}
 	}
 
-	char* s_end = s;
+	s_end = s;
-	const long long_value = strtol(s, &s_end, base);
+	long_value = strtol(s, &s_end, base);
 	if( (s != s_end) && (*s_end == 0) ) {
 		*value = long_value;
 		return HACKRF_SUCCESS;
@@ -119,6 +122,8 @@ int main(int argc, char** argv) {
 	int opt;
 	uint16_t register_number = REGISTER_INVALID;
 	uint16_t register_value;
+	hackrf_device* device = NULL;
+	int option_index = 0;
 
 	int result = hackrf_init();
 	if( result ) {
@@ -126,14 +131,12 @@ int main(int argc, char** argv) {
 		return -1;
 	}
 	
-	hackrf_device* device = NULL;
 	result = hackrf_open(&device);
 	if( result ) {
 		printf("hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result);
 		return -1;
 	}
 
-	int option_index = 0;
 	while( (opt = getopt_long(argc, argv, "n:rw:", long_options, &option_index)) != EOF ) {
 		switch( opt ) {
 		case 'n':

host/hackrf-tools/src/hackrf_si5351c.c

@@ -106,6 +106,7 @@ int dump_multisynth_config(hackrf_device* device, const uint_fast8_t ms_number)
 	uint_fast8_t i;
 	uint_fast8_t reg_base;
 	uint16_t parameters[8];
+	uint32_t p1,p2,p3,r_div;
 
 	reg_base = 42 + (ms_number * 8);
 	for(i=0; i<8; i++) {
@@ -116,22 +117,22 @@ int dump_multisynth_config(hackrf_device* device, const uint_fast8_t ms_number)
 		}
 	}
 	
-	const uint32_t p1 =
+	p1 =
 		  (parameters[2] & 0x03 << 16)
 		| (parameters[3] << 8)
 		| parameters[4]
 		;
-	const uint32_t p2 =
+	p2 =
 		  (parameters[5] & 0x0F << 16)
 		| (parameters[6] << 8)
 		| parameters[7]
 		;
-	const uint32_t p3 =
+	p3 =
 		  (parameters[5] & 0xF0 << 12)
 		| (parameters[0] << 8)
 		|  parameters[1]
 		;
-	const uint32_t r_div =
+	r_div =
 		(parameters[2] >> 4) & 0x7
 		;
 		
@@ -162,6 +163,8 @@ int main(int argc, char** argv) {
 	int opt;
 	uint16_t register_number = REGISTER_INVALID;
 	uint16_t register_value;
+	hackrf_device* device = NULL;
+	int option_index = 0;
 
 	int result = hackrf_init();
 	if( result ) {
@@ -169,14 +172,12 @@ int main(int argc, char** argv) {
 		return -1;
 	}
 	
-	hackrf_device* device = NULL;
 	result = hackrf_open(&device);
 	if( result ) {
 		printf("hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result);
 		return -1;
 	}
 
-	int option_index = 0;
 	while( (opt = getopt_long(argc, argv, "cn:rw:", long_options, &option_index)) != EOF ) {
 		switch( opt ) {
 		case 'n':

host/hackrf-tools/src/hackrf_spiflash.c

@@ -25,11 +25,20 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdbool.h>
 #include <string.h>
 #include <getopt.h>
 #include <sys/types.h>
 
+#ifndef bool
+typedef int bool;
+#define true 1
+#define false 1
+#endif
+
+#ifdef _MSC_VER
+typedef int ssize_t;
+#endif
+
 /* 8 Mbit flash */
 #define MAX_LENGTH 0x100000
 
@@ -43,7 +52,10 @@ static struct option long_options[] = {
 
 int parse_u32(char* s, uint32_t* const value)
 {
+	char* s_end;
 	uint_fast8_t base = 10;
+	uint32_t u32_value;
+
 	if (strlen(s) > 2) {
 		if (s[0] == '0')  {
 			if ((s[1] == 'x') || (s[1] == 'X')) {
@@ -56,8 +68,8 @@ int parse_u32(char* s, uint32_t* const value)
 		}
 	}
 
-	char* s_end = s;
+	s_end = s;
-	const uint32_t u32_value = strtoul(s, &s_end, base);
+	u32_value = strtoul(s, &s_end, base);
 	if ((s != s_end) && (*s_end == 0)) {
 		*value = u32_value;
 		return HACKRF_SUCCESS;
@@ -196,6 +208,7 @@ int main(int argc, char** argv)
 
 	if (read) 
 	{
+		ssize_t bytes_written;
 		tmp_length = length;
 		while (tmp_length) 
 		{
@@ -213,7 +226,7 @@ int main(int argc, char** argv)
 			pdata += xfer_len;
 			tmp_length -= xfer_len;
 		}
-		const ssize_t bytes_written = fwrite(data, 1, length, fd);
+		bytes_written = fwrite(data, 1, length, fd);
 		if (bytes_written != length) {
 			fprintf(stderr, "Failed write to file (wrote %d bytes).\n",
 					(int)bytes_written);
@@ -222,7 +235,7 @@ int main(int argc, char** argv)
 			return EXIT_FAILURE;
 		}
 	} else {
-		const ssize_t bytes_read = fread(data, 1, length, fd);
+		ssize_t bytes_read = fread(data, 1, length, fd);
 		if (bytes_read != length) {
 			fprintf(stderr, "Failed read file (read %d bytes).\n",
 					(int)bytes_read);

host/hackrf-tools/src/hackrf_transfer.c

@@ -24,7 +24,6 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdbool.h>
 #include <string.h>
 #include <getopt.h>
 #include <time.h>
@@ -34,13 +33,44 @@
 #include <fcntl.h>
 #include <errno.h>
 
-#ifdef _WIN32
+#ifndef bool
-#include <windows.h> 
+typedef int bool;
-#else
+#define true 1
-#include <unistd.h>
+#define false 1
 #endif
 
+#ifdef _WIN32
+#include <windows.h>
+
+#ifdef _MSC_VER
+typedef int ssize_t;
+#define strtoull _strtoui64
+#define snprintf _snprintf
+
+int gettimeofday(struct timeval *tv, void* ignored)
+{
+	FILETIME ft;
+	unsigned __int64 tmp = 0;
+	if (NULL != tv) {
+		GetSystemTimeAsFileTime(&ft);
+		tmp |= ft.dwHighDateTime;
+		tmp <<= 32;
+		tmp |= ft.dwLowDateTime;
+		tmp /= 10;
+		tmp -= 11644473600000000Ui64;
+		tv->tv_sec = (long)(tmp / 1000000UL);
+		tv->tv_usec = (long)(tmp % 1000000UL);
+	}
+	return 0;
+}
+
+#endif
+
+#else
+#include <unistd.h>
 #include <sys/time.h>
+#endif
+
 #include <signal.h>
 
 #define FD_BUFFER_SIZE (8*1024)
@@ -141,6 +171,9 @@ TimevalDiff(const struct timeval *a, const struct timeval *b)
 
 int parse_u64(char* s, uint64_t* const value) {
 	uint_fast8_t base = 10;
+	char* s_end;
+	uint64_t u64_value;
+
 	if( strlen(s) > 2 ) {
 		if( s[0] == '0' ) {
 			if( (s[1] == 'x') || (s[1] == 'X') ) {
@@ -153,8 +186,8 @@ int parse_u64(char* s, uint64_t* const value) {
 		}
 	}
 
-	char* s_end = s;
+	s_end = s;
-	const unsigned long long u64_value = strtoull(s, &s_end, base);
+	u64_value = strtoull(s, &s_end, base);
 	if( (s != s_end) && (*s_end == 0) ) {
 		*value = u64_value;
 		return HACKRF_SUCCESS;
@@ -165,6 +198,9 @@ int parse_u64(char* s, uint64_t* const value) {
 
 int parse_u32(char* s, uint32_t* const value) {
 	uint_fast8_t base = 10;
+	char* s_end;
+	uint64_t ulong_value;
+
 	if( strlen(s) > 2 ) {
 		if( s[0] == '0' ) {
 			if( (s[1] == 'x') || (s[1] == 'X') ) {
@@ -177,8 +213,8 @@ int parse_u32(char* s, uint32_t* const value) {
 		}
 	}
 
-	char* s_end = s;
+	s_end = s;
-	const unsigned long ulong_value = strtoul(s, &s_end, base);
+	ulong_value = strtoul(s, &s_end, base);
 	if( (s != s_end) && (*s_end == 0) ) {
 		*value = ulong_value;
 		return HACKRF_SUCCESS;
@@ -220,6 +256,7 @@ int rx_callback(hackrf_transfer* transfer) {
 
 	if( fd != NULL ) 
 	{
+		ssize_t bytes_written;
 		byte_count += transfer->valid_length;
 		bytes_to_write = transfer->valid_length;
 		if (limit_num_samples) {
@@ -228,7 +265,7 @@ int rx_callback(hackrf_transfer* transfer) {
 			}
 			bytes_to_xfer -= bytes_to_write;
 		}
-		const ssize_t bytes_written = fwrite(transfer->buffer, 1, bytes_to_write, fd);
+		bytes_written = fwrite(transfer->buffer, 1, bytes_to_write, fd);
 		if ((bytes_written != bytes_to_write)
 				|| (limit_num_samples && (bytes_to_xfer == 0))) {
 			fclose(fd);
@@ -247,6 +284,7 @@ int tx_callback(hackrf_transfer* transfer) {
 
 	if( fd != NULL )
 	{
+		ssize_t bytes_read;
 		byte_count += transfer->valid_length;
 		bytes_to_read = transfer->valid_length;
 		if (limit_num_samples) {
@@ -259,7 +297,7 @@ int tx_callback(hackrf_transfer* transfer) {
 			}
 			bytes_to_xfer -= bytes_to_read;
 		}
-		const ssize_t bytes_read = fread(transfer->buffer, 1, bytes_to_read, fd);
+		bytes_read = fread(transfer->buffer, 1, bytes_to_read, fd);
 		if ((bytes_read != bytes_to_read)
 				|| (limit_num_samples && (bytes_to_xfer == 0))) {
 			fclose(fd);
@@ -287,11 +325,24 @@ static void usage() {
 
 static hackrf_device* device = NULL;
 
+#ifdef _MSC_VER
+BOOL WINAPI
+sighandler(int signum)
+{
+	if (CTRL_C_EVENT == signum) {
+		fprintf(stdout, "Caught signal %d\n", signum);
+		do_exit = true;
+		return TRUE;
+	}
+	return FALSE;
+}
+#else
 void sigint_callback_handler(int signum) 
 {
 	fprintf(stdout, "Caught signal %d\n", signum);
 	do_exit = true;
 }
+#endif
 
 #define PATH_FILE_MAX_LEN (FILENAME_MAX)
 #define DATE_TIME_MAX_LEN (32)
@@ -306,6 +357,8 @@ int main(int argc, char** argv) {
 	struct tm * timeinfo;
 	long int file_pos;
 	int exit_code = EXIT_SUCCESS;
+	struct timeval t_end;
+	float time_diff;
   
 	while( (opt = getopt(argc, argv, "wr:t:f:a:s:n:b:")) != EOF )
 	{
@@ -511,13 +564,16 @@ int main(int argc, char** argv) {
 		fwrite(&wave_file_hdr, 1, sizeof(t_wav_file_hdr), fd);
 	}
 	
+#ifdef _MSC_VER
+	SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
+#else
 	signal(SIGINT, &sigint_callback_handler);
 	signal(SIGILL, &sigint_callback_handler);
 	signal(SIGFPE, &sigint_callback_handler);
 	signal(SIGSEGV, &sigint_callback_handler);
 	signal(SIGTERM, &sigint_callback_handler);
 	signal(SIGABRT, &sigint_callback_handler);
-
+#endif
 	printf("call hackrf_sample_rate_set(%u Hz/%.03f MHz)\n", sample_rate_hz,((float)sample_rate_hz/(float)FREQ_ONE_MHZ));
 	result = hackrf_sample_rate_set(device, sample_rate_hz);
 	if( result != HACKRF_SUCCESS ) {
@@ -575,16 +631,18 @@ int main(int argc, char** argv) {
 	while( (hackrf_is_streaming(device) == HACKRF_TRUE) &&
 			(do_exit == false) ) 
 	{
+		uint32_t byte_count_now;
+		struct timeval time_now;
+		float time_difference, rate;
 		sleep(1);
 		
-		struct timeval time_now;
 		gettimeofday(&time_now, NULL);
 		
-		uint32_t byte_count_now = byte_count;
+		byte_count_now = byte_count;
 		byte_count = 0;
 		
-		const float time_difference = TimevalDiff(&time_now, &time_start);
+		time_difference = TimevalDiff(&time_now, &time_start);
-		const float rate = (float)byte_count_now / time_difference;
+		rate = (float)byte_count_now / time_difference;
 		printf("%4.1f MiB / %5.3f sec = %4.1f MiB/second\n",
 				(byte_count_now / 1e6f), time_difference, (rate / 1e6f) );
 
@@ -605,9 +663,8 @@ int main(int argc, char** argv) {
 		printf("\nExiting... hackrf_is_streaming() result: %s (%d)\n", hackrf_error_name(result), result);
 	}
 	
-	struct timeval t_end;
 	gettimeofday(&t_end, NULL);
-	const float time_diff = TimevalDiff(&t_end, &t_start);
+	time_diff = TimevalDiff(&t_end, &t_start);
 	printf("Total time: %5.5f s\n", time_diff);
 	
 	if(device != NULL)

host/libhackrf/CMakeLists.txt

@@ -21,33 +21,39 @@
 
 # Based heavily upon the libftdi cmake setup.
 
-project(libhackrf)
+cmake_minimum_required(VERSION 2.8)
+project(libhackrf C)
 set(MAJOR_VERSION 0)
 set(MINOR_VERSION 1)
 set(PACKAGE libhackrf)
 set(VERSION_STRING ${MAJOR_VERSION}.${MINOR_VERSION})
 set(VERSION ${VERSION_STRING})
-set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}")
+set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/../cmake/modules)
-
-cmake_minimum_required(VERSION 2.8)
 
+if(MSVC)
+set(THREADS_USE_PTHREADS_WIN32 true)
+find_package(Threads REQUIRED)
+else()
 add_definitions(-Wall)
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu90")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98")
+endif()
-
 find_package(USB1 REQUIRED)
-include_directories(${LIBUSB_INCLUDE_DIR})
+
+
+include_directories(${LIBUSB_INCLUDE_DIR} ${THREADS_PTHREADS_INCLUDE_DIR})
 
 add_subdirectory(src)
 
 ########################################################################
 # Create uninstall target
 ########################################################################
+if(NOT hackrf_all_SOURCE_DIR)
 configure_file(
-    ${CMAKE_SOURCE_DIR}/cmake_uninstall.cmake.in
+    ${PROJECT_SOURCE_DIR}/../cmake/cmake_uninstall.cmake.in
     ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
 @ONLY)
 
 add_custom_target(uninstall
     ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
 )
+endif()

host/libhackrf/FindUSB1.cmake

@@ -1,38 +0,0 @@
-# - Try to find the freetype library
-# Once done this defines
-#
-#  LIBUSB_FOUND - system has libusb
-#  LIBUSB_INCLUDE_DIR - the libusb include directory
-#  LIBUSB_LIBRARIES - Link these to use libusb
-
-# Copyright (c) 2006, 2008  Laurent Montel, <montel@kde.org>
-#
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-
-if (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-
-  # in cache already
-  set(LIBUSB_FOUND TRUE)
-
-else (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)
-  IF (NOT WIN32)
-    # use pkg-config to get the directories and then use these values
-    # in the FIND_PATH() and FIND_LIBRARY() calls
-    find_package(PkgConfig)
-    pkg_check_modules(PC_LIBUSB libusb-1.0)
-  ENDIF(NOT WIN32)
-
-  FIND_PATH(LIBUSB_INCLUDE_DIR libusb.h
-    PATHS ${PC_LIBUSB_INCLUDEDIR} ${PC_LIBUSB_INCLUDE_DIRS})
-
-  FIND_LIBRARY(LIBUSB_LIBRARIES NAMES usb-1.0
-    PATHS ${PC_LIBUSB_LIBDIR} ${PC_LIBUSB_LIBRARY_DIRS})
-
-  include(FindPackageHandleStandardArgs)
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBUSB DEFAULT_MSG LIBUSB_LIBRARIES LIBUSB_INCLUDE_DIR)
-
-  MARK_AS_ADVANCED(LIBUSB_INCLUDE_DIR LIBUSB_LIBRARIES)
-
-endif (LIBUSB_INCLUDE_DIR AND LIBUSB_LIBRARIES)

host/libhackrf/cmake_uninstall.cmake.in

@@ -1,32 +0,0 @@
-# http://www.vtk.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F
-
-IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
-  MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
-ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
-
-FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
-STRING(REGEX REPLACE "\n" ";" files "${files}")
-FOREACH(file ${files})
-  MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
-  IF(EXISTS "$ENV{DESTDIR}${file}")
-    EXEC_PROGRAM(
-      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
-      OUTPUT_VARIABLE rm_out
-      RETURN_VALUE rm_retval
-      )
-    IF(NOT "${rm_retval}" STREQUAL 0)
-      MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
-    ENDIF(NOT "${rm_retval}" STREQUAL 0)
-  ELSEIF(IS_SYMLINK "$ENV{DESTDIR}${file}")
-    EXEC_PROGRAM(
-      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
-      OUTPUT_VARIABLE rm_out
-      RETURN_VALUE rm_retval
-      )
-    IF(NOT "${rm_retval}" STREQUAL 0)
-      MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
-    ENDIF(NOT "${rm_retval}" STREQUAL 0)
-  ELSE(EXISTS "$ENV{DESTDIR}${file}")
-    MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
-  ENDIF(EXISTS "$ENV{DESTDIR}${file}")
-ENDFOREACH(file)

host/libhackrf/src/CMakeLists.txt

@@ -26,22 +26,23 @@
 set(c_sources ${CMAKE_CURRENT_SOURCE_DIR}/hackrf.c CACHE INTERNAL "List of C sources")
 set(c_headers ${CMAKE_CURRENT_SOURCE_DIR}/hackrf.h CACHE INTERNAL "List of C headers")
 
-set_source_files_properties(hackrf.c PROPERTIES LANGUAGE CXX )
-set_source_files_properties(hackrf.h PROPERTIES LANGUAGE CXX )
-
 # Dynamic library
 add_library(hackrf SHARED ${c_sources})
 set_target_properties(hackrf PROPERTIES VERSION ${MAJOR_VERSION}.${MINOR_VERSION}.0 SOVERSION 0)
 
 # Static library
 add_library(hackrf-static STATIC ${c_sources})
+if(MSVC)
+	set_target_properties(hackrf-static PROPERTIES OUTPUT_NAME "hackrf_static")
+else()
 	set_target_properties(hackrf-static PROPERTIES OUTPUT_NAME "hackrf")
+endif()
 
 set_target_properties(hackrf PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 set_target_properties(hackrf-static PROPERTIES CLEAN_DIRECT_OUTPUT 1)
 
 # Dependencies
-target_link_libraries(hackrf ${LIBUSB_LIBRARIES} pthread)
+target_link_libraries(hackrf ${LIBUSB_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
    
 # For cygwin just force UNIX OFF and WIN32 ON
 if( ${CYGWIN} )

host/libhackrf/src/hackrf.c

@@ -28,6 +28,11 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSI
 #include <libusb.h>
 #include <pthread.h>
 
+#ifndef bool
+typedef int bool;
+#define true 1
+#define false 1
+#endif
 // TODO: Factor this into a shared #include so that firmware can use
 // the same values.
 typedef enum {
@@ -48,7 +53,10 @@ typedef enum {
 	HACKRF_VENDOR_REQUEST_VERSION_STRING_READ = 15,
 	HACKRF_VENDOR_REQUEST_SET_FREQ = 16,
 	HACKRF_VENDOR_REQUEST_AMP_ENABLE = 17,
-	HACKRF_VENDOR_REQUEST_BOARD_PARTID_SERIALNO_READ = 18
+	HACKRF_VENDOR_REQUEST_BOARD_PARTID_SERIALNO_READ = 18,
+	HACKRF_VENDOR_REQUEST_SET_LNA_GAIN = 19,
+	HACKRF_VENDOR_REQUEST_SET_VGA_GAIN = 20,
+	HACKRF_VENDOR_REQUEST_SET_TXVGA_GAIN = 21,
 } hackrf_vendor_request;
 
 typedef enum {
@@ -150,13 +158,14 @@ static int allocate_transfers(hackrf_device* const device)
 {
 	if( device->transfers == NULL )
 	{
-		device->transfers = (libusb_transfer**) calloc(device->transfer_count, sizeof(struct libusb_transfer));
+		uint32_t transfer_index;
+		device->transfers = (struct libusb_transfer**) calloc(device->transfer_count, sizeof(struct libusb_transfer));
 		if( device->transfers == NULL )
 		{
 			return HACKRF_ERROR_NO_MEM;
 		}
 
-		for(uint32_t transfer_index=0; transfer_index<device->transfer_count; transfer_index++)
+		for(transfer_index=0; transfer_index<device->transfer_count; transfer_index++)
 		{
 			device->transfers[transfer_index] = libusb_alloc_transfer(0);
 			if( device->transfers[transfer_index] == NULL )
@@ -192,9 +201,10 @@ static int prepare_transfers(
 	libusb_transfer_cb_fn callback)
 {
 	int error;
+	uint32_t transfer_index;
 	if( device->transfers != NULL )
 	{
-		for(uint32_t transfer_index=0; transfer_index<device->transfer_count; transfer_index++)
+		for(transfer_index=0; transfer_index<device->transfer_count; transfer_index++)
 		{
 			device->transfers[transfer_index]->endpoint = endpoint_address;
 			device->transfers[transfer_index]->callback = callback;
@@ -242,6 +252,8 @@ int ADDCALL hackrf_exit(void)
 int ADDCALL hackrf_open(hackrf_device** device)
 {
 	int result;
+	libusb_device_handle* usb_device;
+	hackrf_device* lib_device;
 	
 	if( device == NULL )
 	{
@@ -250,7 +262,7 @@ int ADDCALL hackrf_open(hackrf_device** device)
 
 	// TODO: Do proper scanning of available devices, searching for
 	// unit serial number (if specified?).
-	libusb_device_handle* usb_device = libusb_open_device_with_vid_pid(g_libusb_context, hackrf_usb_vid, hackrf_usb_pid);
+	usb_device = libusb_open_device_with_vid_pid(g_libusb_context, hackrf_usb_vid, hackrf_usb_pid);
 	if( usb_device == NULL )
 	{
 		return HACKRF_ERROR_NOT_FOUND;
@@ -273,7 +285,7 @@ int ADDCALL hackrf_open(hackrf_device** device)
 		return HACKRF_ERROR_LIBUSB;
 	}
 
-	hackrf_device* lib_device = NULL;
+	lib_device = NULL;
 	lib_device = (hackrf_device*)malloc(sizeof(*lib_device));
 	if( lib_device == NULL )
 	{
@@ -789,6 +801,90 @@ int ADDCALL hackrf_board_partid_serialno_read(hackrf_device* device, read_partid
 	}
 }
 
+int ADDCALL hackrf_set_lna_gain(hackrf_device* device, uint32_t value)
+{
+	int result;
+	
+	if( value > 40 )
+	{
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
+
+	result = libusb_control_transfer(
+		device->usb_device,
+		LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
+		HACKRF_VENDOR_REQUEST_SET_LNA_GAIN,
+		0,
+		value,
+		NULL,
+		0,
+		0
+	);
+
+	if( result != 0 )
+	{
+		return HACKRF_ERROR_INVALID_PARAM;
+	} else {
+		return HACKRF_SUCCESS;
+	}
+}
+
+int ADDCALL hackrf_set_vga_gain(hackrf_device* device, uint32_t value)
+{
+	int result;
+	
+	if( value > 62 )
+	{
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
+
+	result = libusb_control_transfer(
+		device->usb_device,
+		LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
+		HACKRF_VENDOR_REQUEST_SET_VGA_GAIN,
+		0,
+		value,
+		NULL,
+		0,
+		0
+	);
+
+	if( result != 0 )
+	{
+		return HACKRF_ERROR_INVALID_PARAM;
+	} else {
+		return HACKRF_SUCCESS;
+	}
+}
+
+int ADDCALL hackrf_set_txvga_gain(hackrf_device* device, uint32_t value)
+{
+	int result;
+	
+	if( value > 47 )
+	{
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
+
+	result = libusb_control_transfer(
+		device->usb_device,
+		LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
+		HACKRF_VENDOR_REQUEST_SET_TXVGA_GAIN,
+		0,
+		value,
+		NULL,
+		0,
+		0
+	);
+
+	if( result != 0 )
+	{
+		return HACKRF_ERROR_INVALID_PARAM;
+	} else {
+		return HACKRF_SUCCESS;
+	}
+}
+
 static void* transfer_threadproc(void* arg)
 {
 	hackrf_device* device = (hackrf_device*)arg;

host/libhackrf/src/hackrf.h

@@ -25,7 +25,6 @@ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSI
 #define __HACKRF_H__
 
 #include <stdint.h>
-#include <stdbool.h>
 
 #ifdef _WIN32
    #define ADD_EXPORTS
@@ -131,10 +130,20 @@ extern ADDAPI int ADDCALL hackrf_version_string_read(hackrf_device* device, char
 
 extern ADDAPI int ADDCALL hackrf_set_freq(hackrf_device* device, const uint64_t freq_hz);
 
+/* external amp, bool on/off */
 extern ADDAPI int ADDCALL hackrf_set_amp_enable(hackrf_device* device, const uint8_t value);
 
 extern ADDAPI int ADDCALL hackrf_board_partid_serialno_read(hackrf_device* device, read_partid_serialno_t* read_partid_serialno);
 
+/* range 0-40 step 8db */
+extern ADDAPI int ADDCALL hackrf_set_lna_gain(hackrf_device* device, uint32_t value);
+
+/* range 0-62 step 2db */
+extern ADDAPI int ADDCALL hackrf_set_vga_gain(hackrf_device* device, uint32_t value);
+
+/* range 0-47 step 1db */
+extern ADDAPI int ADDCALL hackrf_set_txvga_gain(hackrf_device* device, uint32_t value);
+
 extern ADDAPI const char* ADDCALL hackrf_error_name(enum hackrf_error errcode);
 extern ADDAPI const char* ADDCALL hackrf_board_id_name(enum hackrf_board_id board_id);