--- /dev/null
+/* -*- c++ -*- */
+/*
+ * Copyright 2003,2005 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * GNU Radio is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3, or (at your option)
+ * any later version.
+ *
+ * GNU Radio 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 GNU Radio; see the file COPYING. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <fusb_win32.h>
+#include <usb.h>
+#include <assert.h>
+#include <stdexcept>
+#include <string.h>
+
+static const int MAX_BLOCK_SIZE = fusb_sysconfig::max_block_size();
+static const int DEFAULT_BLOCK_SIZE = MAX_BLOCK_SIZE;
+static const int DEFAULT_BUFFER_SIZE = 16 * (1L << 20); // 16 MB / endpoint
+
+
+static const int USB_TIMEOUT = 1000; // in milliseconds
+
+
+fusb_devhandle_win32::fusb_devhandle_win32 (usb_dev_handle *udh)
+ : fusb_devhandle (udh)
+{
+ // that's it
+}
+
+fusb_devhandle_win32::~fusb_devhandle_win32 ()
+{
+ // nop
+}
+
+fusb_ephandle *
+fusb_devhandle_win32::make_ephandle (int endpoint, bool input_p,
+ int block_size, int nblocks)
+{
+ return new fusb_ephandle_win32 (this, endpoint, input_p,
+ block_size, nblocks);
+}
+
+// ----------------------------------------------------------------
+
+fusb_ephandle_win32::fusb_ephandle_win32 (fusb_devhandle_win32 *dh,
+ int endpoint, bool input_p,
+ int block_size, int nblocks)
+ : fusb_ephandle (endpoint, input_p, block_size, nblocks),
+ d_devhandle (dh), d_input_leftover(0),d_output_short(0)
+{
+ if (d_block_size < 0 || d_block_size > MAX_BLOCK_SIZE)
+ throw std::out_of_range ("fusb_ephandle_win32: block_size");
+
+ if (d_nblocks < 0)
+ throw std::out_of_range ("fusb_ephandle_win32: nblocks");
+
+ if (d_block_size == 0)
+ d_block_size = DEFAULT_BLOCK_SIZE;
+
+ if (d_nblocks == 0)
+ d_nblocks = std::max (1, DEFAULT_BUFFER_SIZE / d_block_size);
+
+ d_buffer = new char [d_block_size*d_nblocks];
+ d_context = new void * [d_nblocks];
+
+ // allocate contexts
+
+ usb_dev_handle *dev = dh->get_usb_dev_handle ();
+ int i;
+
+ if (d_input_p)
+ endpoint |= USB_ENDPOINT_IN;
+
+ for (i=0; i<d_nblocks; i++)
+ usb_bulk_setup_async(dev, &d_context[i], endpoint);
+}
+
+fusb_ephandle_win32::~fusb_ephandle_win32 ()
+{
+ int i;
+
+ stop ();
+
+ for (i=0; i<d_nblocks; i++)
+ usb_free_async(&d_context[i]);
+
+ delete [] d_buffer;
+ delete [] d_context;
+}
+
+bool
+fusb_ephandle_win32::start ()
+{
+ if (d_started)
+ return true; // already running
+
+ d_started = true;
+
+ d_curr = d_nblocks-1;
+ d_outstanding_write = 0;
+ d_input_leftover =0;
+ d_output_short = 0;
+
+ if (d_input_p){ // fire off all the reads
+ int i;
+
+ for (i=0; i<d_nblocks; i++) {
+ usb_submit_async(d_context[i], (char * ) d_buffer+i*d_block_size,
+ d_block_size);
+ }
+ }
+
+ return true;
+}
+
+bool
+fusb_ephandle_win32::stop ()
+{
+ if (!d_started)
+ return true;
+
+ if (!d_input_p)
+ wait_for_completion ();
+
+ d_started = false;
+ return true;
+}
+
+int
+fusb_ephandle_win32::write (const void *buffer, int nbytes)
+{
+ int retval=0;
+ char *buf;
+
+ if (!d_started) // doesn't matter here, but keeps semantics constant
+ return -1;
+
+ if (d_input_p)
+ return -1;
+
+ int bytes_to_write = nbytes;
+ int a=0;
+
+ if (d_output_short != 0) {
+
+ buf = &d_buffer[d_curr*d_block_size + d_block_size - d_output_short];
+ a = std::min(nbytes, d_output_short);
+ memcpy(buf, buffer, a);
+ bytes_to_write -= a;
+ d_output_short -= a;
+
+ if (d_output_short == 0)
+ usb_submit_async(d_context[d_curr],
+ &d_buffer[d_curr*d_block_size], d_block_size);
+ }
+
+ while (bytes_to_write > 0) {
+ d_curr = (d_curr+1)%d_nblocks;
+ buf = &d_buffer[d_curr*d_block_size];
+
+ if (d_outstanding_write != d_nblocks) {
+ d_outstanding_write++;
+ } else {
+ retval = usb_reap_async(d_context[d_curr], USB_TIMEOUT);
+ if (retval < 0) {
+ fprintf(stderr, "%s: usb_reap_async: %s\n",
+ __FUNCTION__, usb_strerror());
+ return retval;
+ }
+ }
+
+ int ncopy = std::min(bytes_to_write, d_block_size);
+ memcpy(buf, (void *) &(((char*)buffer)[a]), ncopy);
+ bytes_to_write -= ncopy;
+ a += ncopy;
+
+ d_output_short = d_block_size - ncopy;
+ if (d_output_short == 0)
+ usb_submit_async(d_context[d_curr], buf, d_block_size);
+ }
+
+ return retval < 0 ? retval : nbytes;
+}
+
+int
+fusb_ephandle_win32::read (void *buffer, int nbytes)
+{
+ int retval=0;
+ char *buf;
+
+ if (!d_started) // doesn't matter here, but keeps semantics constant
+ return -1;
+
+ if (!d_input_p)
+ return -1;
+
+ int bytes_to_read = nbytes;
+
+ int a=0;
+ if (d_input_leftover != 0) {
+
+ buf = &d_buffer[d_curr*d_block_size + d_block_size - d_input_leftover];
+ a = std::min(nbytes, d_input_leftover);
+ memcpy(buffer, buf, a);
+ bytes_to_read -= a;
+ d_input_leftover -= a;
+
+ if (d_input_leftover == 0)
+ usb_submit_async(d_context[d_curr],
+ &d_buffer[d_curr*d_block_size], d_block_size);
+ }
+
+ while (bytes_to_read > 0) {
+
+ d_curr = (d_curr+1)%d_nblocks;
+ buf = &d_buffer[d_curr*d_block_size];
+
+ retval = usb_reap_async(d_context[d_curr], USB_TIMEOUT);
+ if (retval < 0)
+ fprintf(stderr, "%s: usb_reap_async: %s\n",
+ __FUNCTION__, usb_strerror());
+
+ int ncopy = std::min(bytes_to_read, d_block_size);
+ memcpy((void *) &(((char*)buffer)[a]), buf, ncopy);
+ bytes_to_read -= ncopy;
+ a += ncopy;
+
+ d_input_leftover = d_block_size - ncopy;
+ if (d_input_leftover == 0)
+ usb_submit_async(d_context[d_curr], buf, d_block_size);
+ }
+
+ return retval < 0 ? retval : nbytes;
+}
+
+void
+fusb_ephandle_win32::wait_for_completion ()
+{
+ int i;
+
+ for (i=0; i<d_outstanding_write; i++) {
+ int context_num;
+
+ context_num = (d_curr+d_outstanding_write+i+1)%d_nblocks;
+ usb_reap_async(d_context[context_num], USB_TIMEOUT);
+ }
+
+ d_outstanding_write = 0;
+}
projects / debian / gnuradio / blobdiff