Sojus07/hackrf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

windows, pt3

Browse Source
This commit is contained in:
Hoernchen
2013-05-27 14:02:15 +02:00
parent abc3cd1f4f
commit a9c301cfd4
13 changed files with 203 additions and 1379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
host/hackrf-tools/CMakeLists.txt
View File

@ -21,7 +21,7 @@
# Based heavily upon the libftdi cmake setup.
project(hackrf-tools)
project(hackrf-tools C)
set(MAJOR_VERSION 0)
set(MINOR_VERSION 1)
set(PACKAGE hackrf-tools)
@ -31,9 +31,12 @@ set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}")
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_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu90")
endif()
find_package(USB1 REQUIRED)
include_directories(${LIBUSB_INCLUDE_DIR})

16
host/hackrf-tools/src/CMakeLists.txt
View File

@ -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})
@ -54,4 +60,12 @@ target_link_libraries(hackrf_spiflash ${LIBHACKRF_LIBRARIES})
target_link_libraries(hackrf_cpldjtag ${LIBHACKRF_LIBRARIES})
target_link_libraries(hackrf_info ${LIBHACKRF_LIBRARIES})
if(MSVC)
target_link_libraries(hackrf_max2837 libgetopt_static)
target_link_libraries(hackrf_si5351c libgetopt_static)
target_link_libraries(hackrf_transfer libgetopt_static)
target_link_libraries(hackrf_rffc5071 libgetopt_static)
target_link_libraries(hackrf_spiflash libgetopt_static)
target_link_libraries(hackrf_cpldjtag libgetopt_static)
target_link_libraries(hackrf_info libgetopt_static)
endif()

11
host/hackrf-tools/src/hackrf_cpldjtag.c
View File

@ -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;
const long long_value = strtol(s, &s_end, base);
s_end = s;
long_value = strtol(s, &s_end, base);
if ((s != s_end) && (*s_end == 0)) {
*value = long_value;
return HACKRF_SUCCESS;

13
host/hackrf-tools/src/hackrf_max2837.c
View File

@ -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;
const long long_value = strtol(s, &s_end, base);
s_end = s;
long_value = strtol(s, &s_end, base);
if( (s != s_end) && (*s_end == 0) ) {
*value = long_value;
return HACKRF_SUCCESS;
@ -118,21 +121,21 @@ 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 ) {
printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result);
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':

13
host/hackrf-tools/src/hackrf_rffc5071.c
View File

@ -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;
const long long_value = strtol(s, &s_end, base);
s_end = s;
long_value = strtol(s, &s_end, base);
if( (s != s_end) && (*s_end == 0) ) {
*value = long_value;
return HACKRF_SUCCESS;
@ -119,21 +122,21 @@ 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 ) {
printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result);
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':

17
host/hackrf-tools/src/hackrf_si5351c.c
View File

@ -106,7 +106,8 @@ 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++) {
uint_fast8_t reg_number = reg_base + 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,21 +163,21 @@ 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 ) {
printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result);
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':

23
host/hackrf-tools/src/hackrf_spiflash.c
View File

@ -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;
const uint32_t u32_value = strtoul(s, &s_end, base);
s_end = s;
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);

75
host/hackrf-tools/src/hackrf_transfer.c
View File

@ -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
#include <windows.h>
#else
#include <unistd.h>
#ifndef bool
typedef int bool;
#define true 1
#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;
const unsigned long long u64_value = strtoull(s, &s_end, base);
s_end = s;
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;
const unsigned long ulong_value = strtoul(s, &s_end, base);
s_end = s;
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);
@ -306,6 +344,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 )
{
@ -575,16 +615,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);
const float rate = (float)byte_count_now / time_difference;
time_difference = TimevalDiff(&time_now, &time_start);
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 +647,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)

117
host/libhackrf/CMakeLists.txt
View File

@ -1,59 +1,58 @@
# Copyright 2012 Jared Boone
# Copyright 2013 Benjamin Vernoux
#
# This file is part of HackRF.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; see the file COPYING. If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#
# Based heavily upon the libftdi cmake setup.
project(libhackrf)
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}")
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_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++98")
endif()
find_package(USB1 REQUIRED)
include_directories(${LIBUSB_INCLUDE_DIR} ${THREADS_PTHREADS_INCLUDE_DIR})
add_subdirectory(src)
########################################################################
# Create uninstall target
########################################################################
configure_file(
${CMAKE_SOURCE_DIR}/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
)
# Copyright 2012 Jared Boone
# Copyright 2013 Benjamin Vernoux
#
# This file is part of HackRF.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; see the file COPYING. If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#
# Based heavily upon the libftdi cmake setup.
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}")
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=gnu90")
endif()
find_package(USB1 REQUIRED)
include_directories(${LIBUSB_INCLUDE_DIR} ${THREADS_PTHREADS_INCLUDE_DIR})
add_subdirectory(src)
########################################################################
# Create uninstall target
########################################################################
configure_file(
${CMAKE_SOURCE_DIR}/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
)

3
host/libhackrf/src/CMakeLists.txt
View File

@ -26,9 +26,6 @@
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)

1086
host/libhackrf/src/getopt/getopt.c
View File

File diff suppressed because it is too large Load Diff

180
host/libhackrf/src/getopt/getopt.h
View File

@ -1,180 +0,0 @@
/* 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 */

19
host/libhackrf/src/hackrf.c
View File

@ -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 {
@ -153,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 )
@ -195,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;
@ -245,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 )
{
@ -253,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;
@ -276,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 )
{