delete [] d_write_buffer;      if (d_read_work_in_progress)      free_urb (d_read_work_in_progress);  }    // ----------------------------------------------------------------    bool  fusb_ephandle_linux::start ()  {    if (d_started)      return true;                // already running      d_started = true;      if (d_input_p){               // fire off all the reads      usbdevfs_urb *urb;        int nerrors = 0;      while ((urb = free_list_get ()) != 0 && nerrors < d_nblocks){        if (!submit_urb (urb))          nerrors++;      }    }      return true;  }    //  // kill all i/o in progress.  // kill any completed but unprocessed transactions.  //  bool  fusb_ephandle_linux::stop ()  {    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);    d_devhandle->_reap (false);      while (1){      usbdevfs_urb *urb;      while ((urb = completed_list_get ()) != 0)        free_list_add (urb);        if (d_free_list.size () == (unsigned) d_nblocks)        break;        if (!d_devhandle->_reap(true))        break;    }      d_started = false;    return true;  }    // ----------------------------------------------------------------  //                      routines for writing   // ----------------------------------------------------------------    #if (MINIMIZE_TX_BUFFERING)    int   fusb_ephandle_linux::write(const void *buffer, int nbytes)  {    if (!d_started)      return -1;        if (d_input_p)      return -1;      assert(nbytes % 512 == 0);      unsigned char *src = (unsigned char *) buffer;      int n = 0;    while (n < nbytes){        usbdevfs_urb *urb = get_write_work_in_progress();      if (!urb)        return -1;      assert(urb->actual_length == 0);      int m = std::min(nbytes - n, MAX_BLOCK_SIZE);      urb->buffer = src;      urb->buffer_length = m;        n += m;      src += m;        if (!submit_urb(urb))        return -1;        d_write_work_in_progress = 0;    }      return n;  }    #else    int   fusb_ephandle_linux::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){        usbdevfs_urb *urb = get_write_work_in_progress ();      if (!urb)        return -1;      unsigned char *dst = (unsigned char *) urb->buffer;      int m = std::min (nbytes - n, urb->buffer_length - urb->actual_length);        memcpy (&dst[urb->actual_length], &src[n], m);      urb->actual_length += m;      n += m;        if (urb->actual_length == urb->buffer_length){        if (!submit_urb (urb))          return -1;        d_write_work_in_progress = 0;      }    }      return n;  }    #endif    usbdevfs_urb *  fusb_ephandle_linux::get_write_work_in_progress ()  {    // if we've already got some work in progress, return it      if (d_write_work_in_progress)      return d_write_work_in_progress;      while (1){        reap_complete_writes ();        usbdevfs_urb *urb = free_list_get ();        if (urb != 0){        assert (urb->actual_length == 0);        d_write_work_in_progress = urb;        return urb;      }        // The free list is empty.  Tell the device handle to reap.      // Anything it reaps for us will end up on our completed list.        if (!d_devhandle->_reap (true))        return 0;    }  }    void  fusb_ephandle_linux::reap_complete_writes ()  {    // take a look at the completed_list and xfer to free list after    // checking for errors.      usbdevfs_urb *urb;        while ((urb = completed_list_get ()) != 0){        // Check for any errors or short writes that were reported in the urb.      // The kernel sets status, actual_length and error_count.      // error_count is only used for ISO xfers.      // status is 0 if successful, else is an errno kind of thing        if (urb->status != 0){        fprintf (stderr, "fusb: (status %d) %s\n", urb->status, strerror (-urb->status));      }      else if (urb->actual_length != urb->buffer_length){        fprintf (stderr, "fusb: short write xfer: %d != %d\n",                 urb->actual_length, urb->buffer_length);      }        free_list_add (urb);    }  }    void  fusb_ephandle_linux::wait_for_completion ()  {    d_devhandle->_wait_for_completion ();  }    // ----------------------------------------------------------------  //                     routines for reading  // ----------------------------------------------------------------    int  fusb_ephandle_linux::read (void *buffer, int nbytes)  {    if (!d_started)      return -1;        if (!d_input_p)      return -1;      unsigned char *dst = (unsigned char *) buffer;      int n = 0;    while (n < nbytes){        if (d_read_buffer >= d_read_buffer_end)        if (!reload_read_buffer ())          return -1;        int m = std::min (nbytes - n, (int) (d_read_buffer_end - d_read_buffer));        memcpy (&dst[n], d_read_buffer, m);      d_read_buffer += m;      n += m;    }      return n;  }    bool  fusb_ephandle_linux::reload_read_buffer ()  {    assert (d_read_buffer >= d_read_buffer_end);      usbdevfs_urb *urb;      if (d_read_work_in_progress){      // We're done with this urb.  Fire off a read to refill it.      urb = d_read_work_in_progress;      d_read_work_in_progress = 0;      d_read_buffer = 0;      d_read_buffer_end = 0;      urb->actual_length = 0;      if (!submit_urb (urb))        return false;    }      while (1){        while ((urb = completed_list_get ()) == 0)        if (!d_devhandle->_reap (true))          return false;        // check result of completed read        if (urb->status != 0){        // We've got a problem. Report it and fail.        fprintf (stderr, "fusb: (rd status %d) %s\n", urb->status, strerror (-urb->status));        urb->actual_length = 0;        free_list_add (urb);        return false;      }        // we've got a happy urb, full of data...        d_read_work_in_progress = urb;      d_read_buffer = (unsigned char *) urb->buffer;      d_read_buffer_end = d_read_buffer + urb->actual_length;        return true;    }  }    // ----------------------------------------------------------------    void  fusb_ephandle_linux::free_list_add (usbdevfs_urb *urb)  {    assert (urb_get_ephandle (urb) == this);    urb->actual_length = 0;    d_free_list.push_back (urb);  }    usbdevfs_urb *  fusb_ephandle_linux::free_list_get ()  {    if (d_free_list.empty ())      return 0;      usbdevfs_urb *urb = d_free_list.front ();    d_free_list.pop_front ();    return urb;  }    void  fusb_ephandle_linux::completed_list_add (usbdevfs_urb *urb)  {    assert (urb_get_ephandle (urb) == this);    d_completed_list.push_back (urb);  }    usbdevfs_urb *  fusb_ephandle_linux::completed_list_get ()  {    if (d_completed_list.empty ())      return 0;      usbdevfs_urb *urb = d_completed_list.front ();    d_completed_list.pop_front ();    return urb;  }    /*   * Submit the urb.  If successful the urb ends up on the devhandle's   * pending list, otherwise, it's back on our free list.   */  bool  fusb_ephandle_linux::submit_urb (usbdevfs_urb *urb)  {    if (!d_devhandle->_submit_urb (urb)){// FIXME record the problem somewhere	fprintf (stderr, "_submit_urb failed\n");      free_list_add (urb);      return false;    }   return true;  }