309 lines
8.1 KiB
C
309 lines
8.1 KiB
C
/*
|
|
* Copyright 2012 Jared Boone <jared@sharebrained.com>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
#include <getopt.h>
|
|
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
|
|
#include <libusb-1.0/libusb.h>
|
|
|
|
const uint16_t hackrf_usb_vid = 0x1d50;
|
|
const uint16_t hackrf_usb_pid = 0x604b;
|
|
|
|
typedef enum {
|
|
TRANSCEIVER_MODE_RX,
|
|
TRANSCEIVER_MODE_TX,
|
|
} transceiver_mode_t;
|
|
static transceiver_mode_t transceiver_mode = TRANSCEIVER_MODE_RX;
|
|
|
|
static float
|
|
TimevalDiff(const struct timeval *a, const struct timeval *b)
|
|
{
|
|
return (a->tv_sec - b->tv_sec) + 1e-6f * (a->tv_usec - b->tv_usec);
|
|
}
|
|
|
|
int fd = -1;
|
|
struct timeval time_start;
|
|
volatile uint32_t byte_count = 0;
|
|
|
|
void write_callback(struct libusb_transfer* transfer) {
|
|
if( transfer->status == LIBUSB_TRANSFER_COMPLETED ) {
|
|
byte_count += transfer->actual_length;
|
|
if( fd != -1 ) {
|
|
const ssize_t bytes_written = write(fd, transfer->buffer, transfer->actual_length);
|
|
if( bytes_written == transfer->actual_length ) {
|
|
libusb_submit_transfer(transfer);
|
|
} else {
|
|
printf("write failed: errno %d\n", errno);
|
|
close(fd);
|
|
fd = -1;
|
|
}
|
|
}
|
|
} else {
|
|
printf("transfer status was not 'completed'\n");
|
|
}
|
|
}
|
|
|
|
void read_callback(struct libusb_transfer* transfer) {
|
|
if( transfer->status == LIBUSB_TRANSFER_COMPLETED ) {
|
|
byte_count += transfer->actual_length;
|
|
if( fd != -1 ) {
|
|
const ssize_t bytes_read = read(fd, transfer->buffer, transfer->length);
|
|
if( bytes_read == transfer->length ) {
|
|
libusb_submit_transfer(transfer);
|
|
} else {
|
|
printf("read failed: errno %d\n", errno);
|
|
close(fd);
|
|
fd = -1;
|
|
}
|
|
}
|
|
} else {
|
|
printf("transfer status was not 'completed'\n");
|
|
}
|
|
}
|
|
|
|
libusb_device_handle* open_device(libusb_context* const context) {
|
|
int result = libusb_init(NULL);
|
|
if( result != 0 ) {
|
|
printf("libusb_init() failed: %d\n", result);
|
|
return NULL;
|
|
}
|
|
|
|
libusb_device_handle* device = libusb_open_device_with_vid_pid(context, hackrf_usb_vid, hackrf_usb_pid);
|
|
if( device == NULL ) {
|
|
printf("libusb_open_device_with_vid_pid() failed\n");
|
|
return NULL;
|
|
}
|
|
|
|
//int speed = libusb_get_device_speed(device);
|
|
//printf("device speed: %d\n", speed);
|
|
|
|
result = libusb_set_configuration(device, 1);
|
|
if( result != 0 ) {
|
|
libusb_close(device);
|
|
printf("libusb_set_configuration() failed: %d\n", result);
|
|
return NULL;
|
|
}
|
|
|
|
result = libusb_claim_interface(device, 0);
|
|
if( result != 0 ) {
|
|
libusb_close(device);
|
|
printf("libusb_claim_interface() failed: %d\n", result);
|
|
return NULL;
|
|
}
|
|
|
|
return device;
|
|
}
|
|
|
|
void free_transfers(struct libusb_transfer** const transfers, const uint32_t transfer_count) {
|
|
for(uint32_t transfer_index=0; transfer_index<transfer_count; transfer_index++) {
|
|
libusb_free_transfer(transfers[transfer_index]);
|
|
}
|
|
free(transfers);
|
|
}
|
|
|
|
struct libusb_transfer** prepare_transfers(
|
|
libusb_device_handle* const device,
|
|
const uint_fast8_t endpoint_address,
|
|
const uint32_t transfer_count,
|
|
const uint32_t buffer_size,
|
|
libusb_transfer_cb_fn callback
|
|
) {
|
|
struct libusb_transfer** const transfers = calloc(transfer_count, sizeof(struct libusb_transfer));
|
|
if( transfers == NULL ) {
|
|
return NULL;
|
|
}
|
|
|
|
for(uint32_t transfer_index=0; transfer_index<transfer_count; transfer_index++) {
|
|
transfers[transfer_index] = libusb_alloc_transfer(0);
|
|
if( transfers[transfer_index] == NULL ) {
|
|
free_transfers(transfers, transfer_count);
|
|
printf("libusb_alloc_transfer() failed\n");
|
|
return NULL;
|
|
}
|
|
|
|
libusb_fill_bulk_transfer(
|
|
transfers[transfer_index],
|
|
device,
|
|
endpoint_address,
|
|
(unsigned char*)malloc(buffer_size),
|
|
buffer_size,
|
|
callback,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
if( transfers[transfer_index]->buffer == NULL ) {
|
|
free_transfers(transfers, transfer_count);
|
|
printf("malloc() failed\n");
|
|
return NULL;
|
|
}
|
|
|
|
int error = libusb_submit_transfer(transfers[transfer_index]);
|
|
if( error != 0 ) {
|
|
free_transfers(transfers, transfer_count);
|
|
printf("libusb_submit_transfer() failed: %d\n", error);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
return transfers;
|
|
}
|
|
|
|
static void usage() {
|
|
printf("Usage:\n");
|
|
printf("\tGo fish.\n");
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
int opt;
|
|
bool receive = false;
|
|
bool transmit = false;
|
|
const char* path = NULL;
|
|
|
|
while( (opt = getopt(argc, argv, "r:t:")) != EOF ) {
|
|
switch( opt ) {
|
|
case 'r':
|
|
receive = true;
|
|
path = optarg;
|
|
break;
|
|
|
|
case 't':
|
|
transmit = true;
|
|
path = optarg;
|
|
break;
|
|
|
|
default:
|
|
usage();
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if( transmit == receive ) {
|
|
if( transmit == true ) {
|
|
fprintf(stderr, "receive and transmit options are mutually exclusive\n");
|
|
} else {
|
|
fprintf(stderr, "specify either transmit or receive option\n");
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
if( receive ) {
|
|
transceiver_mode = TRANSCEIVER_MODE_RX;
|
|
}
|
|
|
|
if( transmit ) {
|
|
transceiver_mode = TRANSCEIVER_MODE_TX;
|
|
}
|
|
|
|
if( path == NULL ) {
|
|
fprintf(stderr, "specify a path to a file to transmit/receive\n");
|
|
return 1;
|
|
}
|
|
|
|
fd = -1;
|
|
uint_fast8_t endpoint_address = 0;
|
|
libusb_transfer_cb_fn callback = NULL;
|
|
|
|
if( transceiver_mode == TRANSCEIVER_MODE_RX ) {
|
|
fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
|
|
endpoint_address = 0x81;
|
|
callback = &write_callback;
|
|
} else {
|
|
fd = open(path, O_RDONLY, S_IRWXU | S_IRWXG | S_IRWXO);
|
|
endpoint_address = 0x02;
|
|
callback = &read_callback;
|
|
}
|
|
|
|
if( fd == -1 ) {
|
|
printf("Failed to open file: errno %d\n", errno);
|
|
return fd;
|
|
}
|
|
|
|
libusb_context* const context = NULL;
|
|
libusb_device_handle* const device = open_device(context);
|
|
if( device == NULL ) {
|
|
return -3;
|
|
}
|
|
|
|
const uint32_t transfer_count = 1024;
|
|
const uint32_t buffer_size = 16384;
|
|
struct libusb_transfer** const transfers = prepare_transfers(
|
|
device, endpoint_address, transfer_count, buffer_size, callback
|
|
);
|
|
if( transfers == NULL ) {
|
|
return -4;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
struct timeval timeout = { 0, 500000 };
|
|
struct timeval time_now;
|
|
|
|
const double progress_interval = 1.0;
|
|
gettimeofday(&time_start, NULL);
|
|
|
|
uint32_t call_count = 0;
|
|
do {
|
|
int error = libusb_handle_events_timeout(context, &timeout);
|
|
if( error != 0 ) {
|
|
printf("libusb_handle_events_timeout() failed: %d\n", error);
|
|
return -10;
|
|
}
|
|
|
|
if( (call_count & 0xFF) == 0 ) {
|
|
gettimeofday(&time_now, NULL);
|
|
const float time_difference = TimevalDiff(&time_now, &time_start);
|
|
if( time_difference >= progress_interval ) {
|
|
const float rate = (float)byte_count / time_difference;
|
|
printf("%.1f/%.3f = %.1f MiB/second\n",
|
|
byte_count / 1e6f,
|
|
time_difference,
|
|
rate / 1e6f
|
|
);
|
|
time_start = time_now;
|
|
byte_count = 0;
|
|
}
|
|
}
|
|
call_count += 1;
|
|
} while(1);
|
|
|
|
free_transfers(transfers, transfer_count);
|
|
|
|
int result = libusb_release_interface(device, 0);
|
|
if( result != 0 ) {
|
|
printf("libusb_release_interface() failed: %d\n", result);
|
|
return -2000;
|
|
}
|
|
|
|
libusb_close(device);
|
|
|
|
libusb_exit(context);
|
|
|
|
return 0;
|
|
}
|