Changeset 9507

Timestamp:

08/15/09 16:22:01 (4 years ago)

Author:

ttsou

Message:

teardowns cleanly

Location:

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

Files:

• fusb_libusb1.cc (modified) (21 diffs)
• fusb_libusb1.h (modified) (4 diffs)

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

@@ -27 +27 @@
 #include <fusb_libusb1.h>
 #include <libusb-1.0/libusb.h>
+#include <stdexcept>
 #include <cstdio>
 #include <assert.h>
@@ -44 +45 @@
  */
 
-
 inline static fusb_ephandle_libusb1 *
 lut_get_ephandle (libusb_transfer *lut)
@@ -79 +79 @@
 }
 
+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); 
+}
 /*
  * Since libusb1.0 takes care of reaping during the libusb-handle_events
- * call, just add the completed luts directly to the compeleted_list 
+ * call, libusb_transfers are completed at this point. Check status and
+ * move to complted_list 
  */
 
 static void
-write_callback(struct libusb_transfer *lut)
-{
-  //print_transfer_status (lut);
+generic_callback(struct libusb_transfer *lut)
+{
+  // Remove from the pending list
+  // Need a better way to do this
+  fusb_devhandle_libusb1* dev_handle = 
+    lut_get_ephandle(lut)->get_fusb_devhandle_libusb1();
+  
+  dev_handle->pending_remove(lut);
+
+  switch (lut->status) {
+  case LIBUSB_TRANSFER_COMPLETED:
+    // Move to the completed list 
+    break;
+  case LIBUSB_TRANSFER_ERROR:
+    break;
+  case LIBUSB_TRANSFER_TIMED_OUT:
+    break;
+  case LIBUSB_TRANSFER_CANCELLED:
+    // On teardown we need to free the libusb_transfer
+    // otherwise let it go to the completed list
+    if (dev_handle->teardown()) {
+      free_lut (lut);
+      return;
+    }
+    break;
+  case LIBUSB_TRANSFER_STALL:
+    break;
+  case LIBUSB_TRANSFER_NO_DEVICE:
+    break;
+  case LIBUSB_TRANSFER_OVERFLOW:
+    break;
+  }
+
+  // If all is well then move to competed list
   lut_get_ephandle(lut)->completed_list_add(lut);
+
 } 
-
-static void
-read_callback(struct libusb_transfer *lut)
-{
-  //print_transfer_status(lut);
-  lut_get_ephandle(lut)->completed_list_add(lut);
-}
 
 /*
@@ -104 +140 @@
 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)
+           bool input_p, unsigned char *write_buffer)
 {
   struct libusb_transfer* lut = libusb_alloc_transfer(0);
-  void (*callback)(libusb_transfer *) = write_callback;
 
   endpoint = (endpoint & 0x7f) | (input_p ? 0x80 : 0);
@@ -114 +148 @@
   if (input_p) {
     write_buffer = new unsigned char [buffer_length];
-    callback = read_callback;
   }
 
@@ -121 +154 @@
   
   libusb_fill_bulk_transfer (lut,               // transfer
-                             dev_handle,        // dev_handle 
+                             NULL,              // fill device before submit
                              endpoint,          // endpoint
                              write_buffer,      // buffer
                              buffer_length,     // length
-                             callback,          // callback
+                             NULL,              // fill callback before sub.
                              self,              // user_data
                              0);                // timeout
@@ -132 +165 @@
 }
 
-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); 
-}
+
         
 /* 
@@ -147 +172 @@
 
 fusb_devhandle_libusb1::fusb_devhandle_libusb1 (libusb_device_handle *udh)
-  : fusb_devhandle (udh)
+  : fusb_devhandle (udh), d_teardown (0)
 {
   // nop 
@@ -154 +179 @@
 fusb_devhandle_libusb1::~fusb_devhandle_libusb1 ()
 {
-  // nop
-}
-
-
+  std::list<libusb_transfer*>::reverse_iterator it;
+  d_teardown = true;
+
+  for (it = d_pending_rqsts.rbegin (); it != d_pending_rqsts.rend (); it++) {
+    _cancel_lut (*it);
+    // libusb_transfer still active and callback will fire
+    // so delete in callback 
+  }
+}
 
 fusb_ephandle *
@@ -165 +195 @@
   return new fusb_ephandle_libusb1 (this, endpoint, input_p,
                                     block_size, nblocks);
+}
+
+void
+fusb_devhandle_libusb1::_cancel_pending_rqsts (fusb_ephandle_libusb1 *eph)
+{
+  std::list<libusb_transfer*>::reverse_iterator it;
+
+  for (it = d_pending_rqsts.rbegin (); it != d_pending_rqsts.rend (); it++){
+    if (lut_get_ephandle (*it) == eph)
+      _cancel_lut (*it);
+  }
+}
+
+void 
+fusb_devhandle_libusb1::pending_add (libusb_transfer *lut)
+{
+  d_pending_rqsts.push_back (lut);
+}
+
+libusb_transfer *
+fusb_devhandle_libusb1::pending_get ()
+{
+  if (d_pending_rqsts.empty ())
+    return 0;
+
+  libusb_transfer *lut = d_pending_rqsts.front ();
+  d_pending_rqsts.pop_front ();
+  return lut;
+}
+
+bool
+fusb_devhandle_libusb1::pending_remove (libusb_transfer *lut)
+{
+  std::list<libusb_transfer*>::iterator result;
+  result = find (d_pending_rqsts.begin (), d_pending_rqsts.end (), lut);
+
+  if (result == d_pending_rqsts.end ()) {
+    fprintf (stderr, "fusb::pending_remove: failed to find lut in pending_rqsts: %p\n", lut);
+    return false;
+  }
+  d_pending_rqsts.erase (result);
+  return true;
+}
+
+bool
+fusb_devhandle_libusb1::_submit_lut (libusb_transfer *lut)
+{
+  int ret;
+
+  // Fill out device and callback
+  lut->dev_handle = get_usb_dev_handle();
+  lut->callback = generic_callback; 
+
+  ret = libusb_submit_transfer (lut);
+  if (ret < 0) {
+    fprintf(stderr, "fusb::_submit_lut %d", ret);
+    return false;
+  }
+
+  pending_add(lut);
+  return true;
+}
+
+bool
+fusb_devhandle_libusb1::_cancel_lut (libusb_transfer *lut)
+{
+  // call on a transfer that has already completed is undefined
+
+  int ret = libusb_cancel_transfer (lut);
+  if (ret < 0) {
+    fprintf (stderr, "fusb::_cancel_lut");
+    return false;
+  }
+  return true;
+
 }
 
@@ -179 +284 @@
     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 > MAX_BLOCK_SIZE)
+    throw std::out_of_range ("fusb_ephandle_libusb1: block_size");
+
+  if (d_nblocks < 0)
+    throw std::out_of_range ("fusb_ephandle_libusb1: nblocks");
 
   if (d_block_size == 0)
@@ -196 +301 @@
 
   if (0)
-    fprintf(stderr, "fusb_ephandle_linux::ctor: d_block_size = %d  d_nblocks = %d\n",
+    fprintf(stderr, "fusb_ephandle_libusb1::ctor: d_block_size = %d  d_nblocks = %d\n",
             d_block_size, d_nblocks);
 
@@ -202 +307 @@
   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()));
+                                      d_input_p, d_write_buffer));
 }
 
 fusb_ephandle_libusb1::~fusb_ephandle_libusb1 ()
 {
-  // free libusb_transfers 
+  stop ();
+
+  libusb_transfer *lut;
+
+  while ((lut = free_list_get ()) != 0)
+    free_lut (lut);
+
+  while ((lut = completed_list_get ()) != 0)
+    free_lut (lut);
+
+  if (d_write_work_in_progress)
+    free_lut (d_write_work_in_progress);
+
+  delete [] d_write_buffer;
+
+  if (d_read_work_in_progress)
+    free_lut (d_read_work_in_progress);
 }
 
@@ -224 +344 @@
      int nerrors = 0;
      while ((lut = free_list_get ()) !=0 && nerrors < d_nblocks) {
-       if (libusb_submit_transfer (lut))
+       if (!submit_lut (lut))
          nerrors++;
      }
@@ -235 +355 @@
 fusb_ephandle_libusb1::stop ()
 {
+  int ret;
+  if (!d_started)
+    return true;
+
+  if (d_write_work_in_progress){
+    free_list_add (d_write_work_in_progress);
+    d_write_work_in_progress = 0;
+  }
+
+  if (d_read_work_in_progress){
+    free_list_add (d_read_work_in_progress);
+    d_read_work_in_progress = 0;
+    d_read_buffer = 0;
+    d_read_buffer_end = 0;
+  }
+
+  d_devhandle->_cancel_pending_rqsts (this);
+  // Blocking call with libusb1 hardcoded timeout of 2 seconds
+  ret = libusb_handle_events(0);
+  if (ret < 0) {
+    perror ("fusb::libusb_handle_events");
+    return false;
+  }
+
+  while (1){
+    libusb_transfer *lut;
+    while ((lut = completed_list_get ()) != 0)
+      free_list_add (lut);
+
+    if (d_free_list.size () == (unsigned) d_nblocks)
+      break;
+
+    if ((ret = libusb_handle_events(0)) < 0) {
+      perror ("fusb::libusb_handle_events");
+      return false;
+    }
+  }
+
   d_started = false;
   return true;
@@ -272 +430 @@
     src += m;
    
-    if (libusb_submit_transfer(lut) < 0)
+    if (!submit_lut(lut))
       return -1;
 
@@ -307 +465 @@
 
     if (lut->actual_length == lut->length){
-      if (libusb_submit_transfer (lut) < 0)
+      if (!submit_lut (lut))
         return -1;
       d_write_work_in_progress = 0;
@@ -337 +495 @@
     }
 
+    // Blocking call with libusb1 hardcoded timeout of 2 seconds
     libusb_handle_events(NULL);
   }
@@ -406 +565 @@
     d_read_buffer_end = 0;
     lut->actual_length = 0;
-    if (libusb_submit_transfer (lut) < 0)
+    if (!submit_lut (lut))
       return false;
   }
@@ -413 +572 @@
 
     while ((lut = completed_list_get ()) == 0 ) {
+      // Blocking call with libusb1 hardcoded timeout of 2 seconds
       libusb_handle_events(NULL);
     }
@@ -475 +635 @@
 }
 
+bool
+fusb_ephandle_libusb1::submit_lut (libusb_transfer *lut)
+{
+  if (!d_devhandle->_submit_lut (lut)) {
+    fprintf (stderr, "_submit_lut failed\n");
+    free_list_add (lut);
+    return false;
+  }
+  return true;
+}

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

@@ -39 +39 @@
 
   void pending_add (struct libusb_transfer *lut);
-  bool pending_remove (struct libusb_transfer *lut);
+  //bool pending_remove (struct libusb_transfer *lut);
   struct libusb_transfer * pending_get ();
 
+  bool d_teardown;
 
 public:
@@ -51 +52 @@
   virtual fusb_ephandle *make_ephandle (int endpoint, bool input_p,
                                         int block_size = 0, int nblocks = 0);
+  // internal use only
+  bool _submit_lut (libusb_transfer *);
+  bool _cancel_lut (libusb_transfer *);
+  void _cancel_pending_rqsts (fusb_ephandle_libusb1 *eph);
+  void _wait_for_completion ();
 
+  // This needs to be public for the libusb_tranfer callback to work
+  // Find a better way
+  bool pending_remove (struct libusb_transfer *lut);
+  inline bool teardown() { return d_teardown; }
 
+//  static void generic_callback (libusb_transfer *lut);
 };
 
@@ -74 +85 @@
   void reap_complete_writes ();
   bool reload_read_buffer ();
-  
+  bool submit_lut (libusb_transfer *lut); 
+ 
 public:
   // CREATORS
@@ -108 +120 @@
   struct libusb_transfer *free_list_get ();
   struct libusb_transfer *completed_list_get ();
+
+  // ACCESSORS
+  fusb_devhandle_libusb1* get_fusb_devhandle_libusb1 () const {
+    return d_devhandle;
+  }
 };