Solaris support for libusb 1.0, see upstream bug https://github.com/libusb/libusb/issues/169

diff -Naur libusb-1.0.20/configure.ac libusb-1.0.20.new/configure.ac

--- libusb-1.0.20/configure.ac	2015-09-05 10:20:40.000000000 -0700

+++ libusb-1.0.20.new/configure.ac	2016-03-10 00:35:25.712129055 -0800

@@ -95,6 +95,12 @@

 	backend="haiku"

 	threads="posix"

 	;;

+*-solaris*)

+	AC_MSG_RESULT([SunOS])

+	backend="sunos"

+	threads="posix"

+	;;

+

 *)

 	AC_MSG_ERROR([unsupported operating system])

 esac

@@ -157,6 +163,16 @@

 	AC_CHECK_HEADERS([poll.h])

 	AC_DEFINE([POLL_NFDS_TYPE],[nfds_t],[type of second poll() argument])

 	;;

+

+sunos)

+	AC_DEFINE(OS_SUNOS, 1, [SunOS backend])

+	AC_SUBST(OS_SUNOS)

+	THREAD_CFLAGS="-pthread"

+	LIBS="-pthread -ldevinfo"

+	AC_CHECK_HEADERS([poll.h])

+	AC_DEFINE([POLL_NFDS_TYPE],[nfds_t],[type of second poll() argument])

+	;;

+

 netbsd)

 	AC_DEFINE(OS_NETBSD, 1, [NetBSD backend])

 	AC_SUBST(OS_NETBSD)

@@ -187,6 +203,7 @@

 AM_CONDITIONAL(OS_LINUX, test "x$backend" = xlinux)

 AM_CONDITIONAL(OS_DARWIN, test "x$backend" = xdarwin)

 AM_CONDITIONAL(OS_OPENBSD, test "x$backend" = xopenbsd)

+AM_CONDITIONAL(OS_SUNOS, test "x$backend" = xsunos)

 AM_CONDITIONAL(OS_NETBSD, test "x$backend" = xnetbsd)

 AM_CONDITIONAL(OS_WINDOWS, test "x$backend" = xwindows)

 AM_CONDITIONAL(OS_HAIKU, test "x$backend" = xhaiku)

diff -Naur libusb-1.0.20/libusb/Makefile.am libusb-1.0.20.new/libusb/Makefile.am

--- libusb-1.0.20/libusb/Makefile.am	2015-09-05 10:20:40.000000000 -0700

+++ libusb-1.0.20.new/libusb/Makefile.am	2016-03-10 00:19:22.549380102 -0800

@@ -9,6 +9,7 @@

 DARWIN_USB_SRC = os/darwin_usb.c

 OPENBSD_USB_SRC = os/openbsd_usb.c

 NETBSD_USB_SRC = os/netbsd_usb.c

+SUNOS_USB_SRC = os/sunos_usb.c os/sunos_usb.h

 WINDOWS_USB_SRC = os/poll_windows.c os/windows_usb.c libusb-1.0.rc libusb-1.0.def

 WINCE_USB_SRC = os/wince_usb.c os/wince_usb.h

@@ -49,6 +50,10 @@

 OS_SRC = $(NETBSD_USB_SRC) $(POSIX_POLL_SRC)

 endif

+if OS_SUNOS

+OS_SRC = $(SUNOS_USB_SRC) $(POSIX_POLL_SRC)

+endif

+

 if OS_HAIKU

 OS_SRC = $(POSIX_POLL_SRC)

 SUBDIRS = os/haiku

diff -Naur libusb-1.0.20/libusb/core.c libusb-1.0.20.new/libusb/core.c

--- libusb-1.0.20/libusb/core.c	2015-09-05 10:30:43.000000000 -0700

+++ libusb-1.0.20.new/libusb/core.c	2016-03-10 00:20:40.154945235 -0800

@@ -58,6 +58,8 @@

 const struct usbi_os_backend * const usbi_backend = &wince_backend;

 #elif defined(OS_HAIKU)

 const struct usbi_os_backend * const usbi_backend = &haiku_usb_raw_backend;

+#elif defined(OS_SUNOS)

+const struct usbi_os_backend * const usbi_backend = &sunos_backend;

 #else

 #error "Unsupported OS"

 #endif

diff -Naur libusb-1.0.20/libusb/libusbi.h libusb-1.0.20.new/libusb/libusbi.h

--- libusb-1.0.20/libusb/libusbi.h	2015-09-13 17:36:19.000000000 -0700

+++ libusb-1.0.20.new/libusb/libusbi.h	2016-03-10 00:23:08.647355689 -0800

@@ -493,7 +493,8 @@

 int usbi_clear_event(struct libusb_context *ctx);

 /* Internal abstraction for poll (needs struct usbi_transfer on Windows) */

-#if defined(OS_LINUX) || defined(OS_DARWIN) || defined(OS_OPENBSD) || defined(OS_NETBSD) || defined(OS_HAIKU)

+#if defined(OS_LINUX) || defined(OS_DARWIN) || defined(OS_OPENBSD) || defined(OS_NETBSD) || \

+	defined(OS_HAIKU) || defined(OS_SUNOS)

 #include <unistd.h>

 #include "os/poll_posix.h"

 #elif defined(OS_WINDOWS) || defined(OS_WINCE)

@@ -1091,6 +1092,7 @@

 extern const struct usbi_os_backend windows_backend;

 extern const struct usbi_os_backend wince_backend;

 extern const struct usbi_os_backend haiku_usb_raw_backend;

+extern const struct usbi_os_backend sunos_backend;

 extern struct list_head active_contexts_list;

 extern usbi_mutex_static_t active_contexts_lock;

diff -Naur libusb-1.0.20/libusb/os/sunos_usb.c libusb-1.0.20.new/libusb/os/sunos_usb.c

--- libusb-1.0.20/libusb/os/sunos_usb.c	1969-12-31 16:00:00.000000000 -0800

+++ libusb-1.0.20.new/libusb/os/sunos_usb.c	2016-03-10 00:24:36.641449583 -0800

@@ -0,0 +1,1259 @@

+/*

+ *

+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * This library 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

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include <config.h>

+

+#include <sys/time.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <strings.h>

+#include <errno.h>

+#include <fcntl.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <unistd.h>

+#include <aio.h>

+#include <libdevinfo.h>

+#include <sys/usb/clients/ugen/usb_ugen.h>

+#include <sys/usb/usba.h>

+#include <sys/pci.h>

+

+#include "libusbi.h"

+#include "sunos_usb.h"

+

+/*

+ * Backend functions

+ */

+static int sunos_init(struct libusb_context *);

+static void sunos_exit(void);

+static int sunos_get_device_list(struct libusb_context *,

+    struct discovered_devs **);

+static int sunos_open(struct libusb_device_handle *);

+static void sunos_close(struct libusb_device_handle *);

+static int sunos_get_device_descriptor(struct libusb_device *,

+    uint8_t*, int *);

+static int sunos_get_active_config_descriptor(struct libusb_device *,

+    uint8_t*, size_t, int *);

+static int sunos_get_config_descriptor(struct libusb_device *, uint8_t,

+    uint8_t*, size_t, int *);

+static int sunos_get_configuration(struct libusb_device_handle *, int *);

+static int sunos_set_configuration(struct libusb_device_handle *, int);

+static int sunos_claim_interface(struct libusb_device_handle *, int);

+static int sunos_release_interface(struct libusb_device_handle *, int);

+static int sunos_set_interface_altsetting(struct libusb_device_handle *,

+    int, int);

+static int sunos_clear_halt(struct libusb_device_handle *, uint8_t);

+static int sunos_reset_device(struct libusb_device_handle *);

+static void sunos_destroy_device(struct libusb_device *);

+static int sunos_submit_transfer(struct usbi_transfer *);

+static int sunos_cancel_transfer(struct usbi_transfer *);

+static void sunos_clear_transfer_priv(struct usbi_transfer *);

+static int sunos_handle_transfer_completion(struct usbi_transfer *);

+static int sunos_clock_gettime(int, struct timespec *);

+

+/*

+ * Private functions

+ */

+static int _errno_to_libusb(int);

+static int sunos_usb_get_status(int fd);

+

+static int sunos_init(struct libusb_context *ctx)

+{

+	return (LIBUSB_SUCCESS);

+}

+

+static void sunos_exit(void)

+{

+	usbi_dbg("");

+}

+

+static int

+sunos_fill_in_dev_info(di_node_t node, struct libusb_device *dev)

+{

+	int	proplen;

+	int	n, *addr, *port_prop;

+	char	*phypath;

+	uint8_t	*rdata;

+	struct libusb_device_descriptor	*descr;

+	sunos_dev_priv_t	*dpriv = (sunos_dev_priv_t *)dev->os_priv;

+

+	/* Device descriptors */

+	proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,

+	    "usb-dev-descriptor", &rdata);

+	if (proplen <= 0) {

+

+		return (LIBUSB_ERROR_IO);

+	}

+

+	descr = (struct libusb_device_descriptor *)rdata;

+	bcopy(descr, &dpriv->dev_descr, LIBUSB_DT_DEVICE_SIZE);

+	dpriv->dev_descr.bcdUSB = libusb_cpu_to_le16(descr->bcdUSB);

+	dpriv->dev_descr.idVendor = libusb_cpu_to_le16(descr->idVendor);

+	dpriv->dev_descr.idProduct = libusb_cpu_to_le16(descr->idProduct);

+	dpriv->dev_descr.bcdDevice = libusb_cpu_to_le16(descr->bcdDevice);

+

+	/* Raw configuration descriptors */

+	proplen = di_prop_lookup_bytes(DDI_DEV_T_ANY, node,

+	    "usb-raw-cfg-descriptors", &rdata);

+	if (proplen <= 0) {

+		usbi_dbg("can't find raw config descriptors");

+

+		return (LIBUSB_ERROR_IO);

+	}

+	dpriv->raw_cfgdescr = calloc(1, proplen);

+	if (dpriv->raw_cfgdescr == NULL) {

+		return (LIBUSB_ERROR_NO_MEM);

+	} else {

+		bcopy(rdata, dpriv->raw_cfgdescr, proplen);

+	}

+

+	n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "reg", &port_prop);

+

+	if ((n != 1) || (*port_prop <= 0)) {

+		return (LIBUSB_ERROR_IO);

+	}

+	dev->port_number = *port_prop;

+

+	/* device physical path */

+	phypath = di_devfs_path(node);

+	if (phypath) {

+		dpriv->phypath = strdup(phypath);

+		di_devfs_path_free(phypath);

+	} else {

+		free(dpriv->raw_cfgdescr);

+

+		return (LIBUSB_ERROR_IO);

+	}

+

+	/* address */

+	n = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "assigned-address", &addr);

+	if (n != 1 || *addr == 0) {

+		usbi_dbg("can't get address");

+	} else {

+		dev->device_address = *addr;

+	}

+

+	/* speed */

+	if (di_prop_exists(DDI_DEV_T_ANY, node, "low-speed") == 1) {

+		dev->speed = LIBUSB_SPEED_LOW;

+	} else if (di_prop_exists(DDI_DEV_T_ANY, node, "high-speed") == 1) {

+		dev->speed = LIBUSB_SPEED_HIGH;

+	} else if (di_prop_exists(DDI_DEV_T_ANY, node, "full-speed") == 1) {

+		dev->speed = LIBUSB_SPEED_FULL;

+	} else if (di_prop_exists(DDI_DEV_T_ANY, node, "super-speed") == 1) {

+		dev->speed = LIBUSB_SPEED_SUPER;

+	}

+

+	usbi_dbg("vid=%x pid=%x, path=%s, bus_nmber=0x%x, port_number=%d, "

+	    "speed=%d", dpriv->dev_descr.idVendor, dpriv->dev_descr.idProduct,

+	    dpriv->phypath, dev->bus_number, dev->port_number, dev->speed);

+

+	return (LIBUSB_SUCCESS);

+}

+

+

+static int

+sunos_add_devices(di_devlink_t link, void *arg)

+{

+	struct devlink_cbarg	*largs = (struct devlink_cbarg *)arg;

+	struct node_args	*nargs;

+	di_node_t		myself, pnode;

+	uint64_t		session_id = 0;

+	uint16_t		bdf = 0;

+	struct libusb_device	*dev;

+	sunos_dev_priv_t	*devpriv;

+	const char		*path, *newpath;

+	int			 n, i;

+	int			*addr_prop;

+	uint8_t			bus_number = 0;

+

+	nargs = (struct node_args *)largs->nargs;

+	myself = largs->myself;

+	if (nargs->last_ugenpath) {

+		/* the same node's links */

+		return (DI_WALK_CONTINUE);

+	}

+

+	/*

+	 * Construct session ID.

+	 * session ID = ...parent hub addr|hub addr|dev addr.

+	 */

+	pnode = myself;

+	i = 0;

+	while (pnode != DI_NODE_NIL) {

+		if (di_prop_exists(DDI_DEV_T_ANY, pnode, "root-hub") == 1) {

+			/* walk to root */

+			uint32_t *regbuf = NULL;

+			uint32_t reg;

+

+			n = di_prop_lookup_ints(DDI_DEV_T_ANY, pnode, "reg",

+			    (int **)&regbuf);

+			reg = regbuf[0];

+			bdf = (PCI_REG_BUS_G(reg) << 8) |

+			    (PCI_REG_DEV_G(reg) << 3) | PCI_REG_FUNC_G(reg);

+			session_id |= (bdf << i * 8);

+

+			/* same as 'unit-address' property */

+			bus_number =

+			    (PCI_REG_DEV_G(reg) << 3) | PCI_REG_FUNC_G(reg);

+

+			usbi_dbg("device bus address=%s:%x",

+			    di_bus_addr(pnode), bus_number);

+

+			break;

+		}

+

+		/* usb_addr */

+		n = di_prop_lookup_ints(DDI_DEV_T_ANY, pnode,

+		    "assigned-address", &addr_prop);

+		if ((n != 1) || (addr_prop[0] == 0)) {

+			usbi_dbg("cannot get valid usb_addr");

+

+			return (DI_WALK_CONTINUE);

+		}

+

+		session_id |= ((addr_prop[0] & 0xff) << i * 8);

+		if (++i > 7)

+			break;

+

+		pnode = di_parent_node(pnode);

+	}

+

+	path = di_devlink_path(link);

+	dev = usbi_get_device_by_session_id(nargs->ctx, session_id);

+	if (dev == NULL) {

+		dev = usbi_alloc_device(nargs->ctx, session_id);

+		if (dev == NULL) {

+			usbi_dbg("can't alloc device");

+

+			return (DI_WALK_TERMINATE);

+		}

+		devpriv = (sunos_dev_priv_t *)dev->os_priv;

+		if ((newpath = strrchr(path, '/')) == NULL) {

+			libusb_unref_device(dev);

+

+			return (DI_WALK_TERMINATE);

+		}

+		devpriv->ugenpath = strndup(path, strlen(path) -

+		    strlen(newpath));

+		dev->bus_number = bus_number;

+

+		if (sunos_fill_in_dev_info(myself, dev) != LIBUSB_SUCCESS) {

+			libusb_unref_device(dev);

+

+			return (DI_WALK_TERMINATE);

+		}

+		if (usbi_sanitize_device(dev) < 0) {

+			libusb_unref_device(dev);

+			usbi_dbg("sanatize failed: ");

+			return (DI_WALK_TERMINATE);

+		}

+	} else {

+		usbi_dbg("Dev %s exists", path);

+	}

+

+	devpriv = (sunos_dev_priv_t *)dev->os_priv;

+	if (nargs->last_ugenpath == NULL) {

+		/* first device */

+		nargs->last_ugenpath = devpriv->ugenpath;

+

+		if (discovered_devs_append(*(nargs->discdevs), dev) == NULL) {

+			usbi_dbg("cannot append device");

+		}

+

+		/*

+		 * we alloc and hence ref this dev. We don't need to ref it

+		 * hereafter. Front end or app should take care of their ref.

+		 */

+		libusb_unref_device(dev);

+	}

+

+	usbi_dbg("Device %s %s id=0x%llx, devcount:%d, bdf=%x",

+	    devpriv->ugenpath, path, (uint64_t)session_id,

+	    (*nargs->discdevs)->len, bdf);

+

+	return (DI_WALK_CONTINUE);

+}

+

+static int

+sunos_walk_minor_node_link(di_node_t node, void *args)

+{

+        di_minor_t minor = DI_MINOR_NIL;

+        char *minor_path;

+        struct devlink_cbarg arg;

+	struct node_args *nargs = (struct node_args *)args;

+	di_devlink_handle_t devlink_hdl = nargs->dlink_hdl;

+

+	/* walk each minor to find ugen devices */

+        while ((minor = di_minor_next(node, minor)) != DI_MINOR_NIL) {

+                minor_path = di_devfs_minor_path(minor);

+                arg.nargs = args;

+		arg.myself = node;

+                arg.minor = minor;

+                (void) di_devlink_walk(devlink_hdl,

+		    "^usb/[0-9a-f]+[.][0-9a-f]+", minor_path,

+		    DI_PRIMARY_LINK, (void *)&arg, sunos_add_devices);

+                di_devfs_path_free(minor_path);

+        }

+

+	/* switch to a different node */

+	nargs->last_ugenpath = NULL;

+

+	return (DI_WALK_CONTINUE);

+}

+

+int

+sunos_get_device_list(struct libusb_context * ctx,

+	struct discovered_devs **discdevs)

+{

+	di_node_t root_node;

+	struct node_args args;

+	di_devlink_handle_t devlink_hdl;

+

+	args.ctx = ctx;

+	args.discdevs = discdevs;

+	args.last_ugenpath = NULL;

+	if ((root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {

+		usbi_dbg("di_int() failed: %s", strerror(errno));

+		return (LIBUSB_ERROR_IO);

+	}

+

+	if ((devlink_hdl = di_devlink_init(NULL, 0)) == NULL) {

+		di_fini(root_node);

+		usbi_dbg("di_devlink_init() failed: %s", strerror(errno));

+

+		return (LIBUSB_ERROR_IO);

+	}

+	args.dlink_hdl = devlink_hdl;

+

+	/* walk each node to find USB devices */

+	if (di_walk_node(root_node, DI_WALK_SIBFIRST, &args,

+	    sunos_walk_minor_node_link) == -1) {

+		usbi_dbg("di_walk_node() failed: %s", strerror(errno));

+		di_fini(root_node);

+

+		return (LIBUSB_ERROR_IO);

+	}

+

+	di_fini(root_node);

+	di_devlink_fini(&devlink_hdl);

+

+	usbi_dbg("%d devices", (*discdevs)->len);

+

+	return ((*discdevs)->len);

+}

+

+static int

+sunos_usb_open_ep0(sunos_dev_handle_priv_t *hpriv, sunos_dev_priv_t *dpriv)

+{

+	char filename[PATH_MAX + 1];

+

+	if (hpriv->eps[0].datafd > 0) {

+

+		return (LIBUSB_SUCCESS);

+	}

+	snprintf(filename, PATH_MAX, "%s/cntrl0", dpriv->ugenpath);

+

+	usbi_dbg("opening %s", filename);

+	hpriv->eps[0].datafd = open(filename, O_RDWR);

+	if (hpriv->eps[0].datafd < 0) {

+		return(_errno_to_libusb(errno));

+	}

+

+	snprintf(filename, PATH_MAX, "%s/cntrl0stat", dpriv->ugenpath);

+	hpriv->eps[0].statfd = open(filename, O_RDONLY);

+	if (hpriv->eps[0].statfd < 0) {

+		close(hpriv->eps[0].datafd);

+		hpriv->eps[0].datafd = -1;

+

+		return(_errno_to_libusb(errno));

+	}

+

+	return (LIBUSB_SUCCESS);

+}

+

+static void

+sunos_usb_close_all_eps(sunos_dev_handle_priv_t *hdev)

+{

+	int i;

+

+	/* not close ep0 */

+	for (i = 1; i < USB_MAXENDPOINTS; i++) {

+		if (hdev->eps[i].datafd != -1) {

+			(void) close(hdev->eps[i].datafd);

+			hdev->eps[i].datafd = -1;

+		}

+		if (hdev->eps[i].statfd != -1) {

+			(void) close(hdev->eps[i].statfd);

+			hdev->eps[i].statfd = -1;

+		}

+	}

+}

+

+static void

+sunos_usb_close_ep0(sunos_dev_handle_priv_t *hdev, sunos_dev_priv_t *dpriv)

+{

+	if (hdev->eps[0].datafd >= 0) {

+		close(hdev->eps[0].datafd);

+		close(hdev->eps[0].statfd);

+		hdev->eps[0].datafd = -1;

+		hdev->eps[0].statfd = -1;

+	}

+}

+

+static uchar_t

+sunos_usb_ep_index(uint8_t ep_addr)

+{

+	return ((ep_addr & LIBUSB_ENDPOINT_ADDRESS_MASK) +

+	    ((ep_addr & LIBUSB_ENDPOINT_DIR_MASK) ? 16 : 0));

+}