fusb_linux.cc

这是用python语言写的一个数字广播的信号处理工具包。利用它

/* -*- c++ -*- */
/*
 * Copyright 2003 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_linux.h>
#include <usb.h>		// libusb header
#include <stdexcept>
#ifdef HAVE_LINUX_COMPILER_H
#include <linux/compiler.h>
#endif
#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>

#define MINIMIZE_TX_BUFFERING 1		// must be defined to 0 or 1


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


// Totally evil and fragile extraction of file descriptor from
// guts of libusb.  They don't install usbi.h, which is what we'd need
// to do this nicely.
//
// FIXME if everything breaks someday in the future, look here...

static int
fd_from_usb_dev_handle (usb_dev_handle *udh)
{
  return *((int *) udh);
}

inline static void
urb_set_ephandle (usbdevfs_urb *urb, fusb_ephandle_linux *handle)
{
  urb->usercontext = handle;
}

inline static fusb_ephandle_linux *
urb_get_ephandle (usbdevfs_urb *urb)
{
  return (fusb_ephandle_linux *) urb->usercontext;
}

// ------------------------------------------------------------------------
// 		   USB request block (urb) allocation
// ------------------------------------------------------------------------

static usbdevfs_urb *
alloc_urb (fusb_ephandle_linux *self, int buffer_length, int endpoint,
	   bool input_p, unsigned char *write_buffer)
{
  usbdevfs_urb	*urb = new usbdevfs_urb;
  memset (urb, 0, sizeof (*urb));

  urb->buffer_length = buffer_length;

  // We allocate dedicated memory only for input buffers.
  // For output buffers we reuse the same buffer (the kernel 
  // copies the data at submital time)

  if (input_p)
    urb->buffer = new unsigned char [buffer_length];
  else
    urb->buffer = write_buffer;

  // init common values

  urb->type = USBDEVFS_URB_TYPE_BULK;
  urb->endpoint = (endpoint & 0x7f) | (input_p ? 0x80 : 0);

  // USBDEVFS_URB_QUEUE_BULK goes away in linux 2.5, but is needed if
  // we are using a 2.4 usb-uhci host controller driver.  This is
  // unlikely since we're almost always going to be plugged into a
  // high speed host controller (ehci)
#if 0 && defined (USBDEVFS_URB_QUEUE_BULK)
  urb->flags = USBDEVFS_URB_QUEUE_BULK;
#endif

  urb->signr = 0;
  urb_set_ephandle (urb, self);

  return urb;
}

static void
free_urb (usbdevfs_urb *urb)
{
  // if this was an input urb, free the buffer
  if (urb->endpoint & 0x80)
    delete [] ((unsigned char *) urb->buffer);

  delete urb;
}

// ------------------------------------------------------------------------
// 				device handle
// ------------------------------------------------------------------------

fusb_devhandle_linux::fusb_devhandle_linux (usb_dev_handle *udh)
  : fusb_devhandle (udh)
{
  // that's all
}

fusb_devhandle_linux::~fusb_devhandle_linux ()
{
  // if there are any pending requests, cancel them and free the urbs.
  
  std::list<usbdevfs_urb*>::reverse_iterator it;

  for (it = d_pending_rqsts.rbegin (); it != d_pending_rqsts.rend (); it++){
    _cancel_urb (*it);
    free_urb (*it);
  }
}

fusb_ephandle *
fusb_devhandle_linux::make_ephandle (int endpoint, bool input_p,
				     int block_size, int nblocks)
{
  return new fusb_ephandle_linux (this, endpoint, input_p,
				  block_size, nblocks);
}


// Attempt to cancel all transactions associated with eph.

void
fusb_devhandle_linux::_cancel_pending_rqsts (fusb_ephandle_linux *eph)
{
  std::list<usbdevfs_urb*>::reverse_iterator it;

  for (it = d_pending_rqsts.rbegin (); it != d_pending_rqsts.rend (); it++){
    if (urb_get_ephandle (*it) == eph)
      _cancel_urb (*it);
  }
}

void 
fusb_devhandle_linux::pending_add (usbdevfs_urb *urb)
{
  d_pending_rqsts.push_back (urb);
}

usbdevfs_urb *
fusb_devhandle_linux::pending_get ()
{
  if (d_pending_rqsts.empty ())
    return 0;

  usbdevfs_urb *urb = d_pending_rqsts.front ();
  d_pending_rqsts.pop_front ();
  return urb;
}

bool
fusb_devhandle_linux::pending_remove (usbdevfs_urb *urb)
{
  std::list<usbdevfs_urb*>::iterator	result = find (d_pending_rqsts.begin (),
						       d_pending_rqsts.end (),
						       urb);
  if (result == d_pending_rqsts.end ()){
    fprintf (stderr, "fusb::pending_remove: failed to find urb in pending_rqsts: %p\n", urb);
    return false;
  }
  d_pending_rqsts.erase (result);
  return true;
}

/*
 * Submit the urb to the kernel.
 * iff successful, the urb will be placed on the devhandle's pending list.
 */
bool
fusb_devhandle_linux::_submit_urb (usbdevfs_urb *urb)
{
  int	ret;

  ret = ioctl (fd_from_usb_dev_handle (d_udh), USBDEVFS_SUBMITURB, urb);
  if (ret < 0){
    perror ("fusb::_submit_urb");
    return false;
  }
  
  pending_add (urb);
  return true;
}

/*
 * Attempt to cancel the in pending or in-progress urb transaction.
 * Return true iff transaction was sucessfully cancelled.
 *
 * Failure to cancel should not be considered a problem.  This frequently
 * occurs if the transaction has already completed in the kernel but hasn't
 * yet been reaped by the user mode code.
 *
 * urbs which were cancelled have their status field set to -ENOENT when
 * they are reaped.
 */
bool
fusb_devhandle_linux::_cancel_urb (usbdevfs_urb *urb)
{
  int ret = ioctl (fd_from_usb_dev_handle (d_udh), USBDEVFS_DISCARDURB, urb);
  if (ret < 0){
    // perror ("fusb::_cancel_urb");
    return false;
  }
  return true;
}

/*
 * Check with the kernel and see if any of our outstanding requests
 * have completed.  For each completed transaction, remove it from the
 * devhandle's pending list and append it to the completed list for
 * the corresponding endpoint.
 *
 * If any transactions are reaped return true.
 *
 * If ok_to_block_p is true, then this will block until at least one
 * transaction completes.
 */
bool
fusb_devhandle_linux::_reap (bool ok_to_block_p)
{
  int		ret;
  int		nreaped = 0;
  usbdevfs_urb	*urb = 0;

  int	fd = fd_from_usb_dev_handle (d_udh);
  
  // try to reap as many as possible without blocking...

  while ((ret = ioctl (fd, USBDEVFS_REAPURBNDELAY, &urb)) == 0){
    if (urb->status != 0 && urb->status != -ENOENT){
      fprintf (stderr, "_reap: usb->status = %d, actual_length = %5d\n",
	       urb->status, urb->actual_length);
    }
    pending_remove (urb);
    urb_get_ephandle (urb)->completed_list_add (urb);
    nreaped++;
  }

  if (nreaped > 0)		// if we got any, return w/o blocking
    return true;

  if (!ok_to_block_p)
    return false;
  
  ret = ioctl (fd, USBDEVFS_REAPURB, &urb);
  if (ret < 0){
    perror ("fusb::_reap");
    return false;
  }

  pending_remove (urb);
  urb_get_ephandle (urb)->completed_list_add (urb);
  return true;
}

void
fusb_devhandle_linux::_wait_for_completion ()
{
  while (!d_pending_rqsts.empty ())
    _reap (true);
}
// ------------------------------------------------------------------------
// 			     end point handle
// ------------------------------------------------------------------------

fusb_ephandle_linux::fusb_ephandle_linux (fusb_devhandle_linux *devhandle,
					  int endpoint,
					  bool input_p,
					  int block_size, int nblocks)
  : fusb_ephandle (endpoint, input_p, block_size, nblocks),
    d_devhandle (devhandle), 
    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 (0)
    fprintf(stderr, "fusb_ephandle_linux::ctor: d_block_size = %d  d_nblocks = %d\n",
	    d_block_size, d_nblocks);

  // allocate urbs

  for (int i = 0; i < d_nblocks; i++)
    d_free_list.push_back (alloc_urb (this, d_block_size, d_endpoint,
				      d_input_p, d_write_buffer));
}

fusb_ephandle_linux::~fusb_ephandle_linux ()
{
  stop ();

  usbdevfs_urb *urb;

  while ((urb = free_list_get ()) != 0)
    free_urb (urb);