state from 2014-09-07 13:30 MESZ

1 files changed, 764 insertions, 0 deletions

diff --git a/spectro/usbio_bsd.c b/spectro/usbio_bsd.c
new file mode 100644
index 0000000..7649caf
--- /dev/null
+++ b/spectro/usbio_bsd.c
@@ -0,0 +1,764 @@
+
+/* General USB I/O support, BSD native implementation. */
+/* This file is conditionaly #included into usbio.c */
+ 
+/* 
+ * Argyll Color Correction System
+ *
+ * Author: Graeme W. Gill
+ * Date:   2006/22/4
+ *
+ * Copyright 2006 - 2013 Graeme W. Gill
+ * All rights reserved.
+ *
+ * This material is licenced under the GNU GENERAL PUBLIC LICENSE Version 2 or later :-
+ * see the License2.txt file for licencing details.
+ */
+
+/*
+	!!!! This driver is incomplete and non-functional !!!!
+
+	BSD uses fd per end point, so simplifies things.
+
+	No clear ep or abort i/o though, so we could try clear halt,
+	or close fd and see if that works in aborting transaction ?
+
+	Posix aio would probably work, but it's not loaded by default :-(
+
+	Could use libusb20 API, but not backwards or cross compatible,
+	and is very likely to be buggy ?
+
+ */
+
+#include <unistd.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <glob.h>
+#include <sys/ioctl.h>
+#if defined(__FreeBSD__)
+# include <dev/usb/usb_ioctl.h>		/* Not sure what's going on with FreeBSD... */
+#else
+# include <dev/usb/usb.h>			/* The usual include for BSD */
+#endif 
+
+/* select() defined, but not poll(), so emulate poll() */
+#if defined(FD_CLR) && !defined(POLLIN)
+#include "pollem.h"
+#define poll_x pollem
+#else
+#include <sys/poll.h>	/* Else assume poll() is native */
+#define poll_x poll
+#endif
+
+/* Add paths to USB connected instruments */
+/* Return an icom error */
+int usb_get_paths(
+icompaths *p 
+) {
+	int i, j;
+	char *paths[] = {
+#if defined(__FreeBSD__)
+	    "/dev/usb/[0-9]*.*.0",		/* FreeBSD >= 8 */
+	    "/dev/ugen[0-9]*",			/* FreeBSD < 8, but no .E */
+#else
+	    "/dev/ugen/[0-9]*.00",		/* NetBSD, OpenBSD */
+#endif
+	    NULL
+	};
+	int vid, pid;
+	int nconfig = 0, nep = 0;
+	char *dpath;
+	instType itype;
+	struct usb_idevice *usbd = NULL;
+
+	a1logd(p->log, 6, "usb_get_paths: about to look through usb devices:\n");
+
+	/* See what device names to look for */
+	for (j = 0; ; j++) {
+		glob_t g;
+		int fd;
+		struct usb_device_info di;
+		int rv, found = 0;
+
+		if (paths[j] == NULL)
+			break;
+
+		memset(&g, 0, sizeof(g));
+
+		if (glob(paths[j], GLOB_NOSORT, NULL, &g) != 0) {
+			continue;
+		}
+
+		/* For all the nodes found by the glob */
+		for (i = 0; i < g.gl_pathc; i++) {
+
+#if defined(__FreeBSD__)
+			/* Skip anything with an end point number */
+			if (j == 1 && strchr(g.gl_pathv[i], '.') != NULL)
+				continue;
+#endif
+			if ((fd = open(g.gl_pathv[i], O_RDONLY)) < 0)
+				continue;
+
+			if (ioctl(fd, USB_GET_DEVICEINFO, &di) < 0)
+				continue;
+
+			vid = di.udi_vendorNo;
+			pid = di.udi_productNo;
+
+			a1logd(p->log, 6, "usb_get_paths: checking vid 0x%04x, pid 0x%04x\n",vid,pid);
+
+			/* Do a preliminary match */
+			if ((itype = inst_usb_match(vid, pid, 0)) == instUnknown) {
+				a1logd(p->log, 6 , "usb_get_paths: instrument not reconized\n");
+				continue;
+			}
+
+			// ~~99 need to check number of end points ~~~
+			// ~~99 and number of configs
+			nconfig = 1;
+ 
+//USB_GET_DEVICEINFO	struct usb_device_info
+//USB_GET_DEVICE_DESC	struct usb_device_descriptor
+
+			/* Allocate an idevice so that we can fill in the end point information */
+			if ((usbd = (struct usb_idevice *) calloc(sizeof(struct usb_idevice), 1)) == NULL) {
+				a1loge(p->log, ICOM_SYS, "icoms: calloc failed!\n");
+				close(fd);
+				globfree(&g);
+				return ICOM_SYS;
+			}
+
+			usbd->nconfig = nconfig;
+			
+			/* Found a known instrument ? */
+			if ((itype = inst_usb_match(vid, pid, nep)) != instUnknown) {
+				char pname[400], *cp;
+		
+				a1logd(p->log, 2, "usb_get_paths: found instrument vid 0x%04x, pid 0x%04x\n",vid,pid);
+		
+				/* Create the base device path */
+				dpath = g.gl_pathv[i];
+#if defined(__FreeBSD__)
+				if (j == 0) {		/* Remove .0 */
+					if ((cp = strrchr(dpath, '.')) != NULL
+					 && cp[1] == '0' && cp[2] == '\000')
+						*cp = '\000';
+				}
+#else
+				/* Remove .00 */
+				if ((cp = strrchr(dpath, '.')) != NULL
+				 && cp[1] == '0' && cp[2] == '0' && cp[3] == '\000')
+					*cp = '\000';
+#endif
+				if ((usbd->dpath = strdup(dpath)) == NULL) {
+					a1loge(p->log, ICOM_SYS, "usb_get_paths: strdup path failed!\n");
+					free(usbd);
+					close(fd);
+					globfree(&g);
+					return ICOM_SYS;
+				}
+
+				/* Create a path/identification */
+				sprintf(pname,"%s (%s)", dpath, inst_name(itype));
+				if ((usbd->dpath = strdup(dpath)) == NULL) {
+					a1loge(p->log, ICOM_SYS, "usb_get_paths: strdup path failed!\n");
+					free(usbd);
+					close(fd);
+					globfree(&g);
+					return ICOM_SYS;
+				}
+		
+				/* Add the path and ep info to the list */
+				if ((rv = p->add_usb(p, pname, vid, pid, nep, usbd, itype)) != ICOM_OK)
+					return rv;
+
+
+			} else {
+				free(usbd);
+			}
+
+			close(fd);
+		}
+		globfree(&g);
+
+		/* Only try one glob string */
+		break;
+	}
+
+	a1logd(p->log, 8, "usb_get_paths: returning %d paths and ICOM_OK\n",p->npaths);
+	return ICOM_OK;
+}
+
+/* Copy usb_idevice contents from icompaths to icom */
+/* return icom error */
+int usb_copy_usb_idevice(icoms *d, icompath *s) {
+	int i;
+	if (s->usbd == NULL) { 
+		d->usbd = NULL;
+		return ICOM_OK;
+	}
+	if ((d->usbd = calloc(sizeof(struct usb_idevice), 1)) == NULL) {
+		a1loge(d->log, ICOM_SYS, "usb_copy_usb_idevice: malloc\n");
+		return ICOM_SYS;
+	}
+	if ((d->usbd->dpath = strdup(s->usbd->dpath)) == NULL) {
+		a1loge(d->log, ICOM_SYS, "usb_copy_usb_idevice: malloc\n");
+		return ICOM_SYS;
+	}
+	/* Copy the ep info */
+	d->nconfig = s->usbd->nconfig;
+	d->nifce = s->usbd->nifce;
+	d->config = s->usbd->config;
+	for (i = 0; i < 32; i++)
+		d->ep[i] = s->usbd->ep[i];		/* Struct copy */
+	return ICOM_OK;
+}
+
+/* Cleanup and then free a usb dev entry */
+void usb_del_usb_idevice(struct usb_idevice *usbd) {
+
+	if (usbd == NULL)
+		return;
+
+	if (usbd->dpath != NULL)
+		free(usbd->dpath);
+	free(usbd);
+}
+
+/* Cleanup any USB specific icoms state */
+void usb_del_usb(icoms *p) {
+
+	usb_del_usb_idevice(p->usbd);
+}
+
+/* Close an open USB port */
+/* If we don't do this, the port and/or the device may be left in an unusable state. */
+void usb_close_port(icoms *p) {
+
+	a1logd(p->log, 6, "usb_close_port: called\n");
+
+#ifdef NEVER    // ~~99
+	if (p->is_open && p->usbd != NULL) {
+		struct usbdevfs_urb urb;
+		unsigned char buf[8+IUSB_DESC_TYPE_DEVICE_SIZE];
+		int iface, rv;
+
+		/* Release all the interfaces */
+		for (iface = 0; iface < p->nifce; iface++)
+			ioctl(p->usbd->fd, USBDEVFS_RELEASEINTERFACE, &iface);
+
+		/* Workaround for some bugs - reset device on close */
+		if (p->uflags & icomuf_reset_before_close) {
+			if ((rv = ioctl(p->usbd->fd, USBDEVFS_RESET, NULL)) != 0) {
+				a1logd(p->log, 1, "usb_close_port: reset returned %d\n",rv);
+			}
+		}
+
+		if (p->usbd->running) {		/* If reaper is still running */
+			unsigned char buf[1] = { 0 };
+
+			a1logd(p->log, 6, "usb_close_port: waking reaper thread to trigger exit\n");
+			p->usbd->shutdown = 1;
+
+			if (write(p->usbd->sd_pipe[1], buf, 1) < 1) {
+				a1logd(p->log, 1, "usb_close_port: writing to sd_pipe failed with '%s'\n", strerror(errno));
+				/* Hmm. We could be in trouble ? */
+			}
+		}
+		a1logd(p->log, 6, "usb_close_port: waiting for reaper thread\n");
+		pthread_join(p->usbd->thread, NULL);	/* Wait for urb reaper thread to exit */
+		close(p->usbd->fd);
+		pthread_mutex_destroy(&p->usbd->lock);
+		close(p->usbd->sd_pipe[0]);
+		close(p->usbd->sd_pipe[1]);
+
+		a1logd(p->log, 6, "usb_close_port: usb port has been released and closed\n");
+	}
+	p->is_open = 0;
+#endif  // ~~99
+
+	/* Find it and delete it from our static cleanup list */
+	usb_delete_from_cleanup_list(p);
+}
+
+static void *urb_reaper(void *context);		/* Declare */
+
+/* Open a USB port for all our uses. */
+/* This always re-opens the port */
+/* return icom error */
+static int usb_open_port(
+icoms *p,
+int    config,		/* Configuration number */
+int    wr_ep,		/* Write end point */
+int    rd_ep,		/* Read end point */
+icomuflags usbflags,/* Any special handling flags */
+int retries,		/* > 0 if we should retry set_configuration (100msec) */ 
+char **pnames		/* List of process names to try and kill before opening */
+) {
+	int rv, tries = 0;
+	a1logd(p->log, 8, "usb_open_port: Make sure USB port is open, tries %d\n",retries);
+
+	if (p->is_open)
+		p->close_port(p);
+
+#ifdef NEVER    // ~~99
+	/* Make sure the port is open */
+	if (!p->is_open) {
+		int rv, i, iface;
+		kkill_nproc_ctx *kpc = NULL;
+
+		if (config != 1) {
+			/* Nothing currently needs it, so we haven't implemented it yet... */
+			a1loge(p->log, ICOM_NOTS, "usb_open_port: native driver cant handle config %d\n",config);
+			return ICOM_NOTS;
+		}
+
+		/* Do open retries */
+		for (tries = 0; retries >= 0; retries--, tries++) {
+
+			a1logd(p->log, 8, "usb_open_port: About to open USB port '%s'\n",p->usbd->dpath);
+
+			if (tries > 0) {
+				//msec_sleep(i_rand(50,100));
+				msec_sleep(77);
+			}
+
+			p->uflags = usbflags;
+
+			/* We should only do a set configuration if the device has more than one */
+			/* possible configuration and it is currently not the desired configuration, */
+			/* but we should avoid doing a set configuration if the OS has already */
+			/* selected the configuration we want, since two set configs seem to */
+			/* mess up the Spyder2, BUT we can't do a get config because this */
+			/* messes up the i1pro-D. */
+
+			/* Linux set_configuration(1) by default, so we don't need to do anything */
+			p->cconfig = 1;
+
+			if (p->cconfig != config) {
+				if ((rv = ioctl(p->usbd->fd, USBDEVFS_SETCONFIGURATION, &config)) != 0) {
+					a1logd(p->log, 1, "icoms_usb_setconfig failed with %d\n",rv);
+					return ICOM_SYS;
+				}
+				p->cconfig = config;
+				a1logd(p->log, 6, "usb_open_port: set config %d OK\n",config);
+			}
+
+			/* We're done */
+			break;
+		}
+
+		if (kpc != NULL)
+			kpc->del(kpc); 
+
+		/* Claim all the interfaces */
+		for (iface = 0; iface < p->nifce; iface++) {
+
+			if ((rv = ioctl(p->usbd->fd, USBDEVFS_CLAIMINTERFACE, &iface)) < 0) {
+				struct usbdevfs_getdriver getd;
+				getd.interface = iface;
+
+				a1logd(p->log, 1, "usb_open_port: Claiming USB port '%s' interface %d initally failed with %d\n",p->usbd->dpath,iface,rv);
+
+				/* Detatch the existing interface if kernel driver is active. */
+				if (p->uflags & icomuf_detach
+				 && ioctl(p->usbd->fd, USBDEVFS_GETDRIVER, &getd) == 0) {
+					struct usbdevfs_ioctl cmd;
+					a1logd(p->log, 1, "usb_open_port: Attempting kernel detach\n");
+					cmd.ifno = iface;
+					cmd.ioctl_code = USBDEVFS_DISCONNECT;
+					cmd.data = NULL;
+				 	ioctl(p->usbd->fd, USBDEVFS_IOCTL, &cmd);
+					if ((rv = ioctl(p->usbd->fd, USBDEVFS_CLAIMINTERFACE, &iface)) < 0) {
+						a1loge(p->log, ICOM_SYS, "usb_open_port: Claiming USB port '%s' interface %d failed after detach with %d\n",p->usbd->dpath,iface,rv);
+						return ICOM_SYS;
+					}
+				} else {
+					a1loge(p->log, ICOM_SYS, "usb_open_port: Claiming USB port '%s' interface %d failed with %d\n",p->usbd->dpath,iface,rv);
+					return ICOM_SYS;
+				}
+			}
+		}
+
+		/* Clear any errors. */
+		/* (Some I/F seem to hang if we do this, some seem to hang if we don't !) */
+		/* The ColorMunki on Linux only starts every second time if we don't do this. */
+		if (!(p->uflags & icomuf_no_open_clear)) {
+			for (i = 0; i < 32; i++) {
+				if (!p->ep[i].valid)
+					continue;
+				p->usb_clearhalt(p, p->ep[i].addr); 
+			}
+		}
+
+		/* Set "serial" coms values */
+		p->wr_ep = wr_ep;
+		p->rd_ep = rd_ep;
+		p->rd_qa = p->EPINFO(rd_ep).packetsize;
+		if (p->rd_qa == 0)
+			p->rd_qa = 8;
+		a1logd(p->log, 8, "usb_open_port: 'serial' read quanta = packet size = %d\n",p->rd_qa);
+
+		/* Start the reaper thread to handle URB completions */
+		if ((rv = pipe(p->usbd->sd_pipe)) < 0) {
+			a1loge(p->log, ICOM_SYS, "usb_open_port: creat pipe failed with %d\n",rv);
+			return ICOM_SYS;
+		}
+		pthread_mutex_init(&p->usbd->lock, NULL);
+		
+		p->usbd->running = 1;
+		if ((rv = pthread_create(&p->usbd->thread, NULL, urb_reaper, (void*)p)) < 0) {
+			p->usbd->running = 0;
+			a1loge(p->log, ICOM_SYS, "usb_open_port: creating urb reaper thread failed with %s\n",rv);
+			return ICOM_SYS;
+		}
+
+		p->is_open = 1;
+		a1logd(p->log, 8, "usb_open_port: USB port is now open\n");
+	}
+
+#endif  // ~~99
+	/* Install the cleanup signal handlers, and add to our cleanup list */
+	usb_install_signal_handlers(p);
+
+	return ICOM_OK;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - */
+/* Our universal USB transfer function */
+static int icoms_usb_transaction(
+	icoms *p,
+	usb_cancelt *cancelt,
+	int *transferred,
+	icom_usb_trantype ttype,	/* transfer type */
+	unsigned char endpoint,		/* 0x80 for control write, 0x00 for control read */
+	unsigned char *buffer,
+	int length,
+	unsigned int timeout		/* In msec */
+) {
+	int type;
+	int remlen;
+	unsigned char *bp;
+	int xlength = 0;
+	int i;
+	int reqrv = ICOM_OK;
+
+#ifdef NEVER    // ~~99
+	in_usb_rw++;
+	a1logd(p->log, 8, "icoms_usb_transaction: req type 0x%x ep 0x%x size %d\n",ttype,endpoint,length);
+
+	if (!p->usbd->running) {
+		in_usb_rw--;
+		a1logv(p->log, 1, "icoms_usb_transaction: reaper thread is not running\n");
+		return ICOM_SYS;
+	}
+
+	/* Translate icoms transfer type of Linux */
+	switch (ttype) {
+		case icom_usb_trantype_command:
+			type = USBDEVFS_URB_TYPE_CONTROL;
+			break;
+		case icom_usb_trantype_interrutpt:
+			type = USBDEVFS_URB_TYPE_INTERRUPT;
+			break;
+		case icom_usb_trantype_bulk:
+			type = USBDEVFS_URB_TYPE_BULK;
+			break;
+	}
+
+	/* Setup the icom req and urbs */
+	req.urbs = NULL;
+	pthread_mutex_init(&req.lock, NULL);
+	pthread_cond_init(&req.cond, NULL);
+
+	/* Linux historically only copes with 16384 length urbs, */
+	/* so break up longer requests into multiple urbs */
+
+	req.cancelled = 0;
+	req.nourbs = req.nurbs = (length + (1 << 14)-1) >> 14;
+	if ((req.urbs = (usbio_urb *)calloc(sizeof(usbio_urb), req.nourbs)) == NULL) {
+		in_usb_rw--;
+		a1loge(p->log, ICOM_SYS, "icoms_usb_transaction: control transfer too big! (%d)\n",length);
+		return ICOM_SYS;
+	}
+
+	bp = buffer;
+	remlen = length;
+	for (i = 0; i < req.nurbs; i++) {
+		req.urbs[i].req = &req;
+		req.urbs[i].urbno = i;
+		/* Setup Linux URB */
+		req.urbs[i].urb.usercontext = &req.urbs[i];
+		req.urbs[i].urb.type = type; 
+		if (type != USBDEVFS_URB_TYPE_CONTROL)
+			req.urbs[i].urb.endpoint = endpoint;
+		if (remlen > 16384)
+			req.urbs[i].urb.buffer_length = 16384;
+		else
+			req.urbs[i].urb.buffer_length = remlen;
+		req.urbs[i].urb.buffer = (void *)bp;
+		remlen -= req.urbs[i].urb.buffer_length;
+		bp += req.urbs[i].urb.buffer_length;
+		req.urbs[i].urb.status = -EINPROGRESS;
+	}
+a1logd(p->log, 8, "icoms_usb_transaction: reset req 0x%p nourbs to %d\n",&req,req.nourbs);
+
+	/* Add our request to the req list so that it can be cancelled on reap failure */
+	pthread_mutex_lock(&p->usbd->lock);
+	req.next = p->usbd->reqs;
+	p->usbd->reqs = &req;
+	pthread_mutex_unlock(&p->usbd->lock);
+
+	/* submit the URBs */
+	for (i = 0; i < req.nurbs; i++) {
+		if ((rv = ioctl(p->usbd->fd, USBDEVFS_SUBMITURB, &req.urbs[i].urb)) < 0) {
+			a1logd(p->log, 1, "coms_usb_transaction: Submitting urb to fd %d failed with %d\n",p->usbd->fd, rv);
+			req.urbs[i].urb.status = ICOM_SYS;	/* Mark it as failed to submit */
+			req.nourbs--;
+		}
+	}
+	
+	if (cancelt != NULL) {
+		amutex_lock(cancelt->cmtx);
+		cancelt->hcancel = (void *)&req;
+		cancelt->state = 1;
+		amutex_unlock(cancelt->cond);		/* Signal any thread waiting for IO start */
+		amutex_unlock(cancelt->cmtx);
+	}
+
+	/* Wait for the reaper to wake us, or for a timeout, */
+	/* or for the reaper to die. */
+	pthread_mutex_lock(&req.lock);
+	if (req.nourbs > 0) {
+		struct timeval tv;
+		struct timespec ts;
+
+		// this is unduly complicated...
+		gettimeofday(&tv, NULL);
+		ts.tv_sec = tv.tv_sec + timeout/1000;
+		ts.tv_nsec = (tv.tv_usec + (timeout % 1000) * 1000) * 1000L;
+		if (ts.tv_nsec > 1000000000L) {
+			ts.tv_nsec -= 1000000000L;
+			ts.tv_sec++;
+		}
+		
+		for(;;) {	/* Ignore spurious wakeups */
+			if ((rv = pthread_cond_timedwait(&req.cond, &req.lock, &ts)) != 0) {
+				if (rv != ETIMEDOUT) {
+					pthread_mutex_unlock(&req.lock);
+					a1logd(p->log, 1, "coms_usb_transaction: pthread_cond_timedwait failed with %d\n",rv);
+					rv = ICOM_SYS;
+					goto done;
+				}
+
+				/* Timed out - cancel the remaining URB's */
+				a1logd(p->log, 8, "coms_usb_transaction: time out - cancel remaining URB's\n");
+				reqrv = ICOM_TO;
+				if (!req.cancelled && (rv = cancel_req(p, &req, -1)) != ICOM_OK) {
+					pthread_mutex_unlock(&req.lock);
+					reqrv = ICOM_SYS;
+					/* Since cancelling failed, we can't wait for them to be reaped */
+					goto done;
+				}
+	
+				/* Wait for the cancelled URB's to be reaped */
+				for (;req.nourbs > 0;) {	/* Ignore spurious wakeups */
+					if ((rv = pthread_cond_wait(&req.cond, &req.lock)) != 0) {
+						pthread_mutex_unlock(&req.lock);
+						a1logd(p->log, 1, "coms_usb_transaction:  pthread_cond_wait failed with %d\n",rv);
+						reqrv = ICOM_SYS;
+						/* Waiting for reap failed, so give up */
+						goto done;
+					}
+				}
+			} else {
+				a1logd(p->log, 8, "coms_usb_transaction: reap - %d left\n",req.nourbs);
+			}
+			if (req.nourbs <= 0)
+				break;				/* All urbs's are done */
+		}
+	}
+	pthread_mutex_unlock(&req.lock);
+
+	/* Compute the overall result by going through the urbs. */
+	for (i = 0; i < req.nurbs; i++) {
+		int stat = req.urbs[i].urb.status;
+		xlength += req.urbs[i].urb.actual_length;
+
+		if (stat == ICOM_SYS) {	/* Submit or cancel failed */
+			reqrv = ICOM_SYS;
+		} else if (reqrv == ICOM_OK && stat < 0 && stat != -ECONNRESET) {	/* Error result */
+			if ((endpoint & IUSB_ENDPOINT_DIR_MASK) == IUSB_ENDPOINT_OUT)
+				reqrv = ICOM_USBW;
+			else
+				reqrv = ICOM_USBR;
+		} else if (reqrv == ICOM_OK && stat == -ECONNRESET) {	/* Cancelled */
+			reqrv = ICOM_CANC;
+		} else if (reqrv == ICOM_OK
+		        && req.urbs[i].urb.actual_length < req.urbs[i].urb.buffer_length) {
+			/* Disregard any following urb's status - they are probably cancelled */
+			break;
+		}
+		/* reqrv == ICOM_TO will ignore urb status */
+	}
+
+	if (ttype == icom_usb_trantype_command)
+		xlength += IUSB_REQ_HEADER_SIZE;		/* Account for header - linux doesn't */
+
+	/* requested size wasn't transferred ? */
+	if (reqrv == ICOM_OK && xlength != length)
+		reqrv = ICOM_SHORT;
+
+	if (transferred != NULL)
+		*transferred = xlength;
+
+done:;
+	if (cancelt != NULL) {
+		amutex_lock(cancelt->cmtx);
+		cancelt->hcancel = (void *)NULL;
+		if (cancelt->state == 0)
+			amutex_unlock(cancelt->cond);
+		cancelt->state = 2;
+		amutex_unlock(cancelt->cmtx);
+	}
+
+	/* Remove our request from the list  */
+	pthread_mutex_lock(&p->usbd->lock);
+	preq = &p->usbd->reqs;
+	while (*preq != &req && *preq != NULL)		/* Find it */
+		preq = &((*preq)->next);
+	if (*preq != NULL)
+		*preq = (*preq)->next;
+	pthread_mutex_unlock(&p->usbd->lock);
+
+	if (req.urbs != NULL)
+		free(req.urbs);
+	pthread_cond_destroy(&req.cond);
+	pthread_mutex_destroy(&req.lock);
+
+	if (in_usb_rw < 0)
+		exit(0);
+
+	in_usb_rw--;
+
+	a1logd(p->log, 8, "coms_usb_transaction: returning err 0x%x and %d bytes\n",reqrv, xlength);
+#endif  // ~~99
+
+	return reqrv;
+}
+
+
+/* Return error icom error code */
+static int icoms_usb_control_msg(
+icoms *p,
+int *transferred,
+int requesttype, int request,
+int value, int index, unsigned char *bytes, int size, 
+int timeout) {
+	int reqrv = ICOM_OK;
+	int dirw = (requesttype & IUSB_REQ_DIR_MASK) == IUSB_REQ_HOST_TO_DEV ? 1 : 0;
+	unsigned char *buf;
+
+	a1logd(p->log, 8, "icoms_usb_control_msg: type 0x%x req 0x%x size %d\n",requesttype,request,size);
+
+#ifdef NEVER    // ~~99
+	/* Allocate a buffer for the ctrl header + payload */
+	if ((buf = calloc(1, IUSB_REQ_HEADER_SIZE + size)) == NULL) {
+		a1loge(p->log, ICOM_SYS, "icoms_usb_control_msg: calloc failed\n");
+		return ICOM_SYS;
+	}
+
+	/* Setup the control header */
+	buf[0] = requesttype;
+	buf[1] = request;
+	short2buf(buf + 2, value);
+	short2buf(buf + 4, index);
+	short2buf(buf + 6, size);
+
+	/* If it's a write, copy the write data into the buffer */
+	if (dirw)
+		memcpy(buf + IUSB_REQ_HEADER_SIZE, bytes, size);
+
+	reqrv = icoms_usb_transaction(p, NULL, transferred, icom_usb_trantype_command,   
+	                  dirw ? 0x80 : 0x00, buf, IUSB_REQ_HEADER_SIZE + size, timeout);  
+
+	/* If read, copy the data back */
+	if (!dirw)
+		memcpy(bytes, buf + IUSB_REQ_HEADER_SIZE, size);
+
+	if (transferred != NULL)	/* Adjust for header size requested */
+		*transferred -= IUSB_REQ_HEADER_SIZE;
+
+	free(buf);
+
+#endif  // ~~99
+	a1logd(p->log, 8, "icoms_usb_control_msg: returning err 0x%x and %d bytes\n",reqrv, *transferred);
+	return reqrv;
+}
+
+/*  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Time out error return value */
+
+#define USBIO_ERROR_TIMEOUT	-ETIMEDOUT
+
+/*  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Cancel i/o in another thread */
+int icoms_usb_cancel_io(
+	icoms *p,
+	usb_cancelt *cancelt
+) {
+	int rv = ICOM_OK;
+#ifdef NEVER    // ~~99
+	a1logd(p->log, 8, "icoms_usb_cancel_io called\n");
+	usb_lock_cancel(cancelt);
+	if (cancelt->hcancel != NULL)
+		rv = cancel_req(p, (usbio_req *)cancelt->hcancel, -1);
+	usb_unlock_cancel(cancelt);
+
+	if (rv != ICOM_OK)	/* Assume this could be because of faulty device */
+		rv = ICOM_USBW;
+#endif  // ~~99
+
+	return rv;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Reset and end point data toggle to 0 */
+int icoms_usb_resetep(
+	icoms *p,
+	int ep					/* End point address */
+) {
+	int rv = ICOM_OK;
+
+#ifdef NEVER    // ~~99
+	if ((rv = ioctl(p->usbd->fd, USBDEVFS_RESETEP, &ep)) != 0) {
+		a1logd(p->log, 1, "icoms_usb_resetep failed with %d\n",rv);
+		rv = ICOM_USBW;
+	}
+#endif  // ~~99
+	return rv;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Clear a halt on an end point */
+int icoms_usb_clearhalt(
+	icoms *p,
+	int ep					/* End point address */
+) {
+	int rv = ICOM_OK;
+
+#ifdef NEVER    // ~~99
+	if ((rv = ioctl(p->usbd->fd, USBDEVFS_CLEAR_HALT, &ep)) != 0) {
+		a1logd(p->log, 1, "icoms_usb_clearhalt failed with %d\n",rv);
+		rv = ICOM_USBW;
+	}
+#endif  // ~~99
+	return rv;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - */
+