Changeset 9504

Timestamp:

08/14/09 21:00:17 (4 years ago)

Author:

ttsou

Message:

works fully through libusb1.0 needs testing

Location:

ossiedev/branches/ttsou/gnuradio/usrp/host/lib

Files:

• fusb_libusb1.cc (modified) (8 diffs)
• fusb_libusb1.h (modified) (5 diffs)
• fusb_sysconfig_libusb1.cc (modified) (2 diffs)

ossiedev/branches/ttsou/gnuradio/usrp/host/lib/fusb_libusb1.cc

@@ -28 +28 @@
 #include <libusb-1.0/libusb.h>
 #include <cstdio>
-
-static const int USB_TIMEOUT = 1000;    // in milliseconds
-
-fusb_devhandle_libusb1::fusb_devhandle_libusb1 (libusb_device_handle *udh)
-  : fusb_devhandle (udh)
-{
-  // that's it
-}
-
-fusb_devhandle_libusb1::~fusb_devhandle_libusb1 ()
-{
-  // nop
+#include <linux/usbdevice_fs.h> // interface to kernel portion of user mode usb driver
+#include <sys/ioctl.h>
+#include <assert.h>
+#include <string.h>
+#include <algorithm>
+#include <errno.h>
+#include <string.h>
+#include <cstdio>
+#include <pthread.h>
+
+#define MINIMIZE_TX_BUFFERING true 
+
+static const int MAX_BLOCK_SIZE = fusb_sysconfig::max_block_size();             // hard limit
+static const int DEFAULT_BLOCK_SIZE = MAX_BLOCK_SIZE;
+static const int DEFAULT_BUFFER_SIZE = 4 * (1L << 20);                          // 4 MB / endpoint
+
+inline static void
+lut_set_ephandle (libusb_transfer *lut, fusb_ephandle_libusb1 *handle)
+{
+  lut->user_data = handle;
+}
+
+inline static fusb_ephandle_libusb1 *
+lut_get_ephandle (libusb_transfer *lut)
+{
+  return (fusb_ephandle_libusb1 *) lut->user_data;
 }
 
@@ -73 +87 @@
 write_callback(struct libusb_transfer *lut)
 {
-  print_transfer_status (lut);
-  libusb_free_transfer (lut);
+  //print_transfer_status (lut);
+  lut_get_ephandle(lut)->completed_list_add(lut);
 } 
 
@@ -80 +94 @@
 read_callback(struct libusb_transfer *lut)
 {
-  libusb_free_transfer (lut);
-}
+  //print_transfer_status(lut);
+  lut_get_ephandle(lut)->completed_list_add(lut);
+}
+// ------------------------------------------------------------------------
+//                      libusb_transfer allocation
+// ------------------------------------------------------------------------
+
+static libusb_transfer*
+alloc_lut (fusb_ephandle_libusb1 *self, int buffer_length, int endpoint,
+           bool input_p, unsigned char *write_buffer,
+           libusb_device_handle *dev_handle)
+{
+  struct libusb_transfer* lut = libusb_alloc_transfer(0);
+
+  endpoint = (endpoint & 0x7f) | (input_p ? 0x80 : 0);
+
+  if (input_p)
+    write_buffer = new unsigned char [buffer_length];
+
+  libusb_fill_bulk_transfer (lut,               // transfer
+                             dev_handle,        // allocate later 
+                             endpoint,          // endpoint
+                             write_buffer,      // buffer
+                             buffer_length,     // length
+                             write_callback,    // callback
+                             self,              // user_data
+                             0);                // timeout
+
+//  urb_set_ephandle(lut, self); 
+
+  return lut;
+}
+
+static void
+free_lut (libusb_transfer *lut)
+{
+  // if this was an input lut, free the buffer
+  if (lut->endpoint & 0x80)
+      delete [] ((unsigned char *) lut->buffer);
+
+  libusb_free_transfer(lut); 
+}
+        
+// ------------------------------------------------------------------------
+//                              device handle
+// ------------------------------------------------------------------------
+
+fusb_devhandle_libusb1::fusb_devhandle_libusb1 (libusb_device_handle *udh)
+  : fusb_devhandle (udh)
+{
+  // that's it
+}
+
+fusb_devhandle_libusb1::~fusb_devhandle_libusb1 ()
+{
+}
+
+
 
 fusb_ephandle *
@@ -92 +162 @@
 
 // ------------------------------------------------------------------------
-//                      libusb_transfer allocation
-// ------------------------------------------------------------------------
-
-#if 0
-static libusb_transfer*
-alloc_libusb_transfer (fusb_ephandle_libusb1 *self, int endpoint,
-                                bool input_p)
-{
-  struct libusb_transfer* lut;
-  lut = libusb_alloc_transfer(0);
-
-  if (input_p)
-    callback = read_callback;
-  else
-    callback = write_callback;
-
-  libusb_fill_bulk_transfer (lut,               // transfer
-                             self->devhandle,   // dev_handle   
-                             endpoint,          // endpoint
-                             write_buffer,      // buffer
-                             block_size,        // length
-                             callback           // callback
-                             NULL,              // user_data
-                             0);                // timeout
-
-  return lut;
-}
-#endif
-
-// ------------------------------------------------------------------------
 //                            end point handle
 // ------------------------------------------------------------------------
-
 
 fusb_ephandle_libusb1::fusb_ephandle_libusb1 (fusb_devhandle_libusb1 *dh,
@@ -130 +169 @@
                                               int block_size, int nblocks)
   : fusb_ephandle (endpoint, input_p, block_size, nblocks),
-    d_devhandle (dh)
-{
-  // nop 
+    d_devhandle (dh),
+    d_write_work_in_progress (0), d_write_buffer (0),
+    d_read_work_in_progress (0), d_read_buffer (0), d_read_buffer_end (0)
+{
+//  if (d_block_size < 0 || d_block_size > MAX_BLOCK_SIZE)
+//    throw std::out_of_range ("fusb_ephandle_linux: block_size");
+
+//  if (d_nblocks < 0)
+//    throw std::out_of_range ("fusb_ephandle_linux: 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);
+
+   if (!d_input_p)
+     if (!MINIMIZE_TX_BUFFERING)
+       d_write_buffer = new unsigned char [d_block_size];
+
+  if (1)
+    fprintf(stderr, "fusb_ephandle_linux::ctor: d_block_size = %d  d_nblocks = %d\n",
+            d_block_size, d_nblocks);
+
+  // allocate libusb_transfers 
+  
+  for (int i = 0; i < d_nblocks; i++)
+    d_free_list.push_back (alloc_lut (this, d_block_size, d_endpoint,
+                                      d_input_p, d_write_buffer,
+                                      d_devhandle->get_usb_dev_handle()));
 }
 
 fusb_ephandle_libusb1::~fusb_ephandle_libusb1 ()
 {
-  // nop 
+  // free libusb_transfers 
 }
 
@@ -154 +220 @@
 }
 
+// ----------------------------------------------------------------
+//                      routines for writing 
+// ----------------------------------------------------------------
+
+#if (MINIMIZE_TX_BUFFERING)
+
 int
 fusb_ephandle_libusb1::write (const void *buffer, int nbytes)
@@ -163 +235 @@
     return -1;
 
-  libusb_transfer *lut = libusb_alloc_transfer(0);
-  libusb_fill_bulk_transfer (lut,                       // transfer
-                             d_devhandle->get_usb_dev_handle(),
-                             d_endpoint,                // endpoint
-                             (unsigned char*) buffer,   // buffer
-                             nbytes,                    // length
-                             write_callback,            // callback
-                             NULL,                      // user_data
-                             USB_TIMEOUT);              // timeout
- 
-  libusb_submit_transfer(lut);  
-  //libusb_handle_events;
+  assert(nbytes % 512 == 0);
+
+  unsigned char *src = (unsigned char *) buffer;
+
+  int n = 0;
+  while (n < nbytes){
+
+    struct libusb_transfer *lut = get_write_work_in_progress();
+    if (!lut)
+      return -1;
+    assert(lut->actual_length == 0);
+    int m = std::min(nbytes - n, MAX_BLOCK_SIZE);
+    lut->buffer = src;
+    lut->length = m;
+
+    n += m;
+    src += m;
+   
+    if (libusb_submit_transfer(lut) < 0)
+      return -1;
+
+    d_write_work_in_progress = 0;
+  }
+
   return nbytes;
 }
+
+#else
+int
+fusb_ephandle_libusb1::write (const void *buffer, int nbytes)
+{
+  if (!d_started)
+    return -1;
+
+  if (d_input_p)
+    return -1;
+
+  unsigned char *src = (unsigned char *) buffer;
+
+  int n = 0;
+  while (n < nbytes){
+
+    libusb_transfer *lut = get_write_work_in_progress ();
+    if (!lut)
+      return -1;
+    unsigned char *dst = (unsigned char *) lut->buffer;
+    int m = std::min (nbytes - n, lut->length - lut->actual_length);
+
+    memcpy (&dst[lut->actual_length], &src[n], m);
+    lut->actual_length += m;
+    n += m;
+
+    if (lut->actual_length == lut->length){
+      if (libusb_submit_transfer (lut) < 0)
+        return -1;
+      d_write_work_in_progress = 0;
+    }
+  }
+
+  return n;
+}
+
+#endif
+
+
+struct libusb_transfer *
+fusb_ephandle_libusb1::get_write_work_in_progress ()
+{
+  if (d_write_work_in_progress)
+    return d_write_work_in_progress;
+
+  while (1){
+
+    reap_complete_writes ();
+
+    struct libusb_transfer *lut = free_list_get ();
+
+    if (lut != 0){
+      assert (lut->actual_length == 0);
+      d_write_work_in_progress = lut;
+      return lut;
+    }
+
+    libusb_handle_events(NULL);
+//   if (!d_devhandle->_reap (true))
+//      return 0;
+//  }
+  }
+}
+
+void
+fusb_ephandle_libusb1::reap_complete_writes ()
+{
+  libusb_transfer *lut;
+
+  while ((lut = completed_list_get ()) != 0) {
+    if (lut->status != 0){
+      fprintf (stderr, "fusb: (status %d) \n",
+               lut->status );
+    }
+    else if (lut->actual_length != lut->length){
+      fprintf (stderr, "fusb: short write xfer: %d != %d\n",
+               lut->actual_length, lut->length);
+    }
+
+    free_list_add (lut);
+  }
+}
+
+// ----------------------------------------------------------------
+//                     routines for reading
+// ----------------------------------------------------------------
 
 int
@@ -186 +356 @@
   if (!d_input_p)
     return -1;
-
-  libusb_transfer *lut = libusb_alloc_transfer(0);
-  libusb_fill_bulk_transfer (lut,                       // transfer
-                             d_devhandle->get_usb_dev_handle(),
-                             d_endpoint,                // endpoint
-                             (unsigned char*) buffer,   // buffer
-                             nbytes,                    // length
-                             read_callback,             // callback
-                             NULL,                      // user_data
-                             USB_TIMEOUT);              // timeout
- 
-  libusb_submit_transfer(lut);  
-}
-
+}
+
+// ----------------------------------------------------------------
+
+void
+fusb_ephandle_libusb1::free_list_add (libusb_transfer *lut)
+{
+  assert (lut_get_ephandle (lut) == this);
+  lut->actual_length = 0;
+  d_free_list.push_back (lut);
+}
+
+libusb_transfer *
+fusb_ephandle_libusb1::free_list_get ()
+{
+  if (d_free_list.empty ())
+    return 0;
+
+  libusb_transfer *lut = d_free_list.front ();
+  d_free_list.pop_front ();
+  return lut;
+}
+
+void
+fusb_ephandle_libusb1::completed_list_add (libusb_transfer *lut)
+{
+  assert (lut_get_ephandle (lut) == this);
+  d_completed_list.push_back (lut);
+}
+
+libusb_transfer *
+fusb_ephandle_libusb1::completed_list_get ()
+{
+  if (d_completed_list.empty ())
+    return 0;
+
+  libusb_transfer *lut = d_completed_list.front ();
+  d_completed_list.pop_front ();
+  return lut;
+}
+

ossiedev/branches/ttsou/gnuradio/usrp/host/lib/fusb_libusb1.h

@@ -25 +25 @@
 
 #include <fusb.h>
+#include <list>
+
+struct libusb_transfer;
+class fusb_ephandle_libusb1;
 
 /*!
@@ -32 +36 @@
 {
 private:
-  
+  std::list<libusb_transfer*>   d_pending_rqsts;
+
+  void pending_add (struct libusb_transfer *lut);
+  bool pending_remove (struct libusb_transfer *lut);
+  struct libusb_transfer * pending_get ();
+
 
 public:
@@ -42 +51 @@
   virtual fusb_ephandle *make_ephandle (int endpoint, bool input_p,
                                         int block_size = 0, int nblocks = 0);
+
+
 };
 
@@ -51 +62 @@
 {
 private:
-  fusb_devhandle_libusb1        *d_devhandle;
+  fusb_devhandle_libusb1         *d_devhandle;
+  std::list<libusb_transfer*>     d_free_list;
+  std::list<libusb_transfer*>     d_completed_list;
+  libusb_transfer                *d_write_work_in_progress;
+  unsigned char                  *d_write_buffer;
+  libusb_transfer                *d_read_work_in_progress;
+  unsigned char                  *d_read_buffer;
+  unsigned char                  *d_read_buffer_end;
+
+  libusb_transfer *get_write_work_in_progress ();
+  void reap_complete_writes ();
+
   
 public:
@@ -81 +103 @@
    */
   virtual void wait_for_completion () { };
+
+  void free_list_add (struct libusb_transfer *lut);
+  void completed_list_add (struct libusb_transfer *lut);
+  struct libusb_transfer *free_list_get ();
+  struct libusb_transfer *completed_list_get ();
 };
 

ossiedev/branches/ttsou/gnuradio/usrp/host/lib/fusb_sysconfig_libusb1.cc

@@ -25 +25 @@
 
 static const int MAX_BLOCK_SIZE = 16 * 1024;            // hard limit
+static const int DEFAULT_BLOCK_SIZE =   4 * 1024;
 static const int FUSB_BUFFER_SIZE = 2 * (1L << 20);     // 2 MB
 
@@ -40 +41 @@
 int fusb_sysconfig::default_block_size ()
 {
-  return fusb_sysconfig::max_block_size ();
+  return DEFAULT_BLOCK_SIZE;
 }