xref: /illumos-gate/usr/src/uts/common/io/usb/usba/usba.c (revision 0d2006e4)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2014 Garrett D'Amore <garrett@damore.org>
 * Copyright 2016 James S. Blachly, MD <james.blachly@gmail.com>
 * Copyright 2019 Joyent, Inc.
 */


/*
 * USBA: Solaris USB Architecture support
 */
#define	USBA_FRAMEWORK
#include <sys/usb/usba/usba_impl.h>
#include <sys/usb/usba/hcdi_impl.h>
#include <sys/usb/hubd/hub.h>
#include <sys/fs/dv_node.h>

/*
 * USBA private variables and tunables
 */
static kmutex_t	usba_mutex;

/* mutex to protect usba_root_hubs */
static kmutex_t usba_hub_mutex;

typedef struct usba_root_hub_ent {
	dev_info_t *dip;
	struct usba_root_hub_ent *next;
}usba_root_hub_ent_t;

static usba_root_hub_ent_t *usba_root_hubs = NULL;

/*
 * ddivs forced binding:
 *
 *    usbc usbc_xhubs usbc_xaddress  node name
 *
 *	0	x	x	class name or "device"
 *
 *	1	0	0	ddivs_usbc
 *	1	0	>1	ddivs_usbc except device
 *				at usbc_xaddress
 *	1	1	0	ddivs_usbc except hubs
 *	1	1	>1	ddivs_usbc except hubs and
 *				device at usbc_xaddress
 */
uint_t usba_ddivs_usbc;
uint_t usba_ddivs_usbc_xhubs;
uint_t usba_ddivs_usbc_xaddress;

uint_t usba_ugen_force_binding;

/*
 * compatible name handling
 */
/*
 * allowing for 15 compat names, plus one force bind name and
 * one possible specified client driver name
 */
#define	USBA_MAX_COMPAT_NAMES		17
#define	USBA_MAX_COMPAT_NAME_LEN	64

/* double linked list for usba_devices */
usba_list_entry_t	usba_device_list;

_NOTE(MUTEX_PROTECTS_DATA(usba_mutex, usba_device_list))

/*
 * modload support
 */

static struct modlmisc modlmisc	= {
	&mod_miscops,	/* Type	of module */
	"USBA: USB Architecture 2.0 1.66"
};

static struct modlinkage modlinkage = {
	MODREV_1, (void	*)&modlmisc, NULL
};


static usb_log_handle_t	usba_log_handle;
uint_t		usba_errlevel = USB_LOG_L4;
uint_t		usba_errmask = (uint_t)-1;

extern usb_log_handle_t	hubdi_log_handle;

int
_init(void)
{
	int rval;

	/*
	 * usbai providing log support needs to be init'ed first
	 * and destroyed last
	 */
	usba_usbai_initialization();
	usba_usba_initialization();
	usba_usbai_register_initialization();
	usba_hcdi_initialization();
	usba_hubdi_initialization();
	usba_devdb_initialization();

	if ((rval = mod_install(&modlinkage)) != 0) {
		usba_devdb_destroy();
		usba_hubdi_destroy();
		usba_hcdi_destroy();
		usba_usbai_register_destroy();
		usba_usba_destroy();
		usba_usbai_destroy();
	}

	return (rval);
}

int
_fini()
{
	int rval;

	if ((rval = mod_remove(&modlinkage)) == 0) {
		usba_devdb_destroy();
		usba_hubdi_destroy();
		usba_hcdi_destroy();
		usba_usbai_register_destroy();
		usba_usba_destroy();
		usba_usbai_destroy();
	}

	return (rval);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

boolean_t
usba_owns_ia(dev_info_t *dip)
{
	int if_count = ddi_prop_get_int(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "interface-count", 0);

	return ((if_count) ? B_TRUE : B_FALSE);
}

/*
 * common bus ctl for hcd, usb_mid, and hubd
 */
int
usba_bus_ctl(dev_info_t	*dip,
	dev_info_t		*rdip,
	ddi_ctl_enum_t		op,
	void			*arg,
	void			*result)
{
	dev_info_t		*child_dip = (dev_info_t *)arg;
	usba_device_t		*usba_device;
	usba_hcdi_t		*usba_hcdi;
	usba_hcdi_ops_t		*usba_hcdi_ops;

	USB_DPRINTF_L4(DPRINT_MASK_USBA, hubdi_log_handle,
	    "usba_bus_ctl: %s%d %s%d op=%d", ddi_node_name(rdip),
	    ddi_get_instance(rdip), ddi_node_name(dip),
	    ddi_get_instance(dip), op);

	switch (op) {

	case DDI_CTLOPS_REPORTDEV:
	{
		char *name, compat_name[64], *speed;
		usba_device_t	*hub_usba_device;
		dev_info_t	*hubdip;

		usba_device = usba_get_usba_device(rdip);

		/* find the parent hub */
		hubdip = ddi_get_parent(rdip);
		while ((strcmp(ddi_driver_name(hubdip), "hubd") != 0) &&
		    !(usba_is_root_hub(hubdip))) {
			hubdip = ddi_get_parent(hubdip);
		}

		hub_usba_device = usba_get_usba_device(hubdip);

		if (usba_device) {
			if (usb_owns_device(rdip)) {
				(void) snprintf(compat_name,
				    sizeof (compat_name),
				    "usb%x,%x",
				    usba_device->usb_dev_descr->idVendor,
				    usba_device->usb_dev_descr->idProduct);
			} else if (usba_owns_ia(rdip)) {
				(void) snprintf(compat_name,
				    sizeof (compat_name),
				    "usbia%x,%x.config%x.%x",
				    usba_device->usb_dev_descr->idVendor,
				    usba_device->usb_dev_descr->idProduct,
				    usba_device->usb_cfg_value,
				    usb_get_if_number(rdip));
			} else {
				(void) snprintf(compat_name,
				    sizeof (compat_name),
				    "usbif%x,%x.config%x.%x",
				    usba_device->usb_dev_descr->idVendor,
				    usba_device->usb_dev_descr->idProduct,
				    usba_device->usb_cfg_value,
				    usb_get_if_number(rdip));
			}
			switch (usba_device->usb_port_status) {
			case USBA_SUPER_SPEED_DEV:
				speed = "super speed (USB 3.x)";
				break;
			case USBA_HIGH_SPEED_DEV:
				speed = "hi speed (USB 2.x)";
				break;
			case USBA_LOW_SPEED_DEV:
				speed = "low speed (USB 1.x)";
				break;
			case USBA_FULL_SPEED_DEV:
			default:
				speed = "full speed (USB 1.x)";
				break;
			}

			cmn_err(CE_CONT,
			    "?USB %x.%x %s (%s) operating at %s on "
			    "USB %x.%x %s hub: "
			    "%s@%s, %s%d at bus address %d\n",
			    (usba_device->usb_dev_descr->bcdUSB & 0xff00) >> 8,
			    usba_device->usb_dev_descr->bcdUSB & 0xff,
			    (usb_owns_device(rdip) ? "device" :
			    ((usba_owns_ia(rdip) ? "interface-association" :
			    "interface"))),
			    compat_name, speed,
			    (hub_usba_device->usb_dev_descr->bcdUSB &
			    0xff00) >> 8,
			    hub_usba_device->usb_dev_descr->bcdUSB & 0xff,
			    usba_is_root_hub(hubdip) ? "root" : "external",
			    ddi_node_name(rdip), ddi_get_name_addr(rdip),
			    ddi_driver_name(rdip),
			    ddi_get_instance(rdip), usba_device->usb_addr);

			name = kmem_alloc(MAXNAMELEN, KM_SLEEP);
			(void) usba_get_mfg_prod_sn_str(rdip, name, MAXNAMELEN);
			if (name[0] != '\0') {
				cmn_err(CE_CONT, "?%s\n", name);
			}
			kmem_free(name, MAXNAMELEN);

		} else { /* harden USBA against this case; if it happens */

			cmn_err(CE_CONT,
			    "?USB-device: %s@%s, %s%d\n",
			    ddi_node_name(rdip), ddi_get_name_addr(rdip),
			    ddi_driver_name(rdip), ddi_get_instance(rdip));
		}

		return (DDI_SUCCESS);
	}

	case DDI_CTLOPS_INITCHILD:
	{
		int			usb_addr;
		uint_t			n;
		char			name[32];
		int			*data;
		int			rval;
		int			len = sizeof (usb_addr);

		usba_hcdi	= usba_hcdi_get_hcdi(dip);
		usba_hcdi_ops	= usba_hcdi->hcdi_ops;
		ASSERT(usba_hcdi_ops != NULL);

		/*
		 * as long as the dip exists, it should have
		 * usba_device structure associated with it
		 */
		usba_device = usba_get_usba_device(child_dip);
		if (usba_device == NULL) {

			USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle,
			    "usba_bus_ctl: DDI_NOT_WELL_FORMED (%s (0x%p))",
			    ddi_node_name(child_dip), (void *)child_dip);

			return (DDI_NOT_WELL_FORMED);
		}

		/* the dip should have an address and reg property */
		if (ddi_prop_op(DDI_DEV_T_NONE, child_dip, PROP_LEN_AND_VAL_BUF,
		    DDI_PROP_DONTPASS |	DDI_PROP_CANSLEEP, "assigned-address",
		    (caddr_t)&usb_addr,	&len) != DDI_SUCCESS) {

			USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle,
			    "usba_bus_ctl:\n\t"
			    "%s%d %s%d op=%d rdip = 0x%p dip = 0x%p",
			    ddi_node_name(rdip), ddi_get_instance(rdip),
			    ddi_node_name(dip), ddi_get_instance(dip), op,
			    (void *)rdip, (void *)dip);

			USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle,
			    "usba_bus_ctl: DDI_NOT_WELL_FORMED (%s (0x%p))",
			    ddi_node_name(child_dip), (void *)child_dip);

			return (DDI_NOT_WELL_FORMED);
		}

		if ((rval = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, child_dip,
		    DDI_PROP_DONTPASS, "reg",
		    &data, &n)) != DDI_SUCCESS) {

			USB_DPRINTF_L2(DPRINT_MASK_USBA, hubdi_log_handle,
			    "usba_bus_ctl: %d, DDI_NOT_WELL_FORMED", rval);

			return (DDI_NOT_WELL_FORMED);
		}


		/*
		 * if the configuration is 1, the unit address is
		 * just the interface number
		 */
		if ((n == 1) || ((n > 1) && (data[1] == 1))) {
			(void) sprintf(name, "%x", data[0]);
		} else {
			(void) sprintf(name, "%x,%x", data[0], data[1]);
		}

		USB_DPRINTF_L3(DPRINT_MASK_USBA,
		    hubdi_log_handle, "usba_bus_ctl: name = %s", name);

		ddi_prop_free(data);
		ddi_set_name_addr(child_dip, name);

		/*
		 * increment the reference count for each child using this
		 * usba_device structure
		 */
		mutex_enter(&usba_device->usb_mutex);
		usba_device->usb_ref_count++;

		USB_DPRINTF_L3(DPRINT_MASK_USBA, hubdi_log_handle,
		    "usba_bus_ctl: init usba_device = 0x%p ref_count = %d",
		    (void *)usba_device, usba_device->usb_ref_count);

		mutex_exit(&usba_device->usb_mutex);

		return (DDI_SUCCESS);
	}

	case DDI_CTLOPS_UNINITCHILD:
	{
		usba_device = usba_get_usba_device(child_dip);

		if (usba_device != NULL) {
			/*
			 * decrement the reference count for each child
			 * using this  usba_device structure
			 */
			mutex_enter(&usba_device->usb_mutex);
			usba_device->usb_ref_count--;

			USB_DPRINTF_L3(DPRINT_MASK_USBA, hubdi_log_handle,
			    "usba_hcdi_bus_ctl: uninit usba_device=0x%p "
			    "ref_count=%d",
			    (void *)usba_device, usba_device->usb_ref_count);

			mutex_exit(&usba_device->usb_mutex);
		}
		ddi_set_name_addr(child_dip, NULL);

		return (DDI_SUCCESS);
	}

	case DDI_CTLOPS_IOMIN:
		/* Do nothing */
		return (DDI_SUCCESS);

	/*
	 * These ops correspond	to functions that "shouldn't" be called
	 * by a	USB client driver.  So	we whine when we're called.
	 */
	case DDI_CTLOPS_DMAPMAPC:
	case DDI_CTLOPS_REPORTINT:
	case DDI_CTLOPS_REGSIZE:
	case DDI_CTLOPS_NREGS:
	case DDI_CTLOPS_SIDDEV:
	case DDI_CTLOPS_SLAVEONLY:
	case DDI_CTLOPS_AFFINITY:
	case DDI_CTLOPS_POKE:
	case DDI_CTLOPS_PEEK:
		cmn_err(CE_CONT, "%s%d:	invalid	op (%d)	from %s%d",
		    ddi_node_name(dip), ddi_get_instance(dip),
		    op, ddi_node_name(rdip), ddi_get_instance(rdip));
		return (DDI_FAILURE);

	/*
	 * Everything else (e.g. PTOB/BTOP/BTOPR requests) we pass up
	 */
	default:
		return (ddi_ctlops(dip,	rdip, op, arg, result));
	}
}


/*
 * initialize and destroy USBA module
 */
void
usba_usba_initialization()
{
	usba_log_handle = usb_alloc_log_hdl(NULL, "usba", &usba_errlevel,
	    &usba_errmask, NULL, 0);

	USB_DPRINTF_L4(DPRINT_MASK_USBA,
	    usba_log_handle, "usba_usba_initialization");

	mutex_init(&usba_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&usba_hub_mutex, NULL, MUTEX_DRIVER, NULL);
	usba_init_list(&usba_device_list, NULL, NULL);
}


void
usba_usba_destroy()
{
	USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle, "usba_usba_destroy");

	mutex_destroy(&usba_hub_mutex);
	mutex_destroy(&usba_mutex);
	usba_destroy_list(&usba_device_list);

	usb_free_log_hdl(usba_log_handle);
}


/*
 * usba_set_usb_address:
 *	set usb address in usba_device structure
 */
int
usba_set_usb_address(usba_device_t *usba_device)
{
	usb_addr_t address;
	uchar_t s = 8;
	usba_hcdi_t *hcdi;
	char *usb_address_in_use;

	mutex_enter(&usba_device->usb_mutex);

	hcdi = usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip);

	mutex_enter(&hcdi->hcdi_mutex);
	usb_address_in_use = hcdi->hcdi_usb_address_in_use;

	for (address = ROOT_HUB_ADDR + 1;
	    address <= USBA_MAX_ADDRESS; address++) {
		if (usb_address_in_use[address/s] & (1 << (address % s))) {
			continue;
		}
		usb_address_in_use[address/s] |= (1 << (address % s));
		hcdi->hcdi_device_count++;
		HCDI_HOTPLUG_STATS_DATA(hcdi)->hcdi_device_count.value.ui64++;
		mutex_exit(&hcdi->hcdi_mutex);

		USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle,
		    "usba_set_usb_address: %d", address);

		usba_device->usb_addr = address;

		mutex_exit(&usba_device->usb_mutex);

		return (USB_SUCCESS);
	}

	usba_device->usb_addr = 0;

	USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
	    "no usb address available");

	mutex_exit(&hcdi->hcdi_mutex);
	mutex_exit(&usba_device->usb_mutex);

	return (USB_FAILURE);
}


/*
 * usba_unset_usb_address:
 *	unset usb_address in usba_device structure
 */
void
usba_unset_usb_address(usba_device_t *usba_device)
{
	usb_addr_t address;
	usba_hcdi_t *hcdi;
	uchar_t s = 8;
	char *usb_address_in_use;

	mutex_enter(&usba_device->usb_mutex);
	address = usba_device->usb_addr;
	hcdi = usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip);

	if (address > ROOT_HUB_ADDR) {
		USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle,
		    "usba_unset_usb_address: address=%d", address);

		mutex_enter(&hcdi->hcdi_mutex);
		usb_address_in_use = hcdi->hcdi_usb_address_in_use;

		ASSERT(usb_address_in_use[address/s] & (1 << (address % s)));

		usb_address_in_use[address/s] &= ~(1 << (address % s));

		hcdi->hcdi_device_count--;
		HCDI_HOTPLUG_STATS_DATA(hcdi)->hcdi_device_count.value.ui64--;

		mutex_exit(&hcdi->hcdi_mutex);

		usba_device->usb_addr = 0;
	}
	mutex_exit(&usba_device->usb_mutex);
}


struct usba_evdata *
usba_get_evdata(dev_info_t *dip)
{
	usba_evdata_t *evdata;
	usba_device_t *usba_device = usba_get_usba_device(dip);

	/* called when dip attaches */
	ASSERT(usba_device != NULL);

	mutex_enter(&usba_device->usb_mutex);
	evdata = usba_device->usb_evdata;
	while (evdata) {
		if (evdata->ev_dip == dip) {
			mutex_exit(&usba_device->usb_mutex);

			return (evdata);
		}
		evdata = evdata->ev_next;
	}

	evdata = kmem_zalloc(sizeof (usba_evdata_t), KM_SLEEP);
	evdata->ev_dip = dip;
	evdata->ev_next = usba_device->usb_evdata;
	usba_device->usb_evdata = evdata;
	mutex_exit(&usba_device->usb_mutex);

	return (evdata);
}


/*
 * allocate a usb device structure and link it in the list
 */
usba_device_t *
usba_alloc_usba_device(dev_info_t *root_hub_dip)
{
	usba_device_t	*usba_device;
	int		ep_idx;
	ddi_iblock_cookie_t iblock_cookie =
	    usba_hcdi_get_hcdi(root_hub_dip)->hcdi_iblock_cookie;

	/*
	 * create a new usba_device structure
	 */
	usba_device = kmem_zalloc(sizeof (usba_device_t), KM_SLEEP);

	/*
	 * initialize usba_device
	 */
	mutex_init(&usba_device->usb_mutex, NULL, MUTEX_DRIVER,
	    iblock_cookie);

	usba_init_list(&usba_device->usb_device_list, (usb_opaque_t)usba_device,
	    iblock_cookie);
	usba_init_list(&usba_device->usb_allocated, (usb_opaque_t)usba_device,
	    iblock_cookie);
	mutex_enter(&usba_device->usb_mutex);
	usba_device->usb_root_hub_dip = root_hub_dip;

	/*
	 * add to list of usba_devices
	 */
	usba_add_to_list(&usba_device_list, &usba_device->usb_device_list);

	/* init mutex in each usba_ph_impl structure */
	for (ep_idx = 0; ep_idx < USBA_N_ENDPOINTS; ep_idx++) {
		mutex_init(&usba_device->usb_ph_list[ep_idx].usba_ph_mutex,
		    NULL, MUTEX_DRIVER, iblock_cookie);
	}

	USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
	    "allocated usba_device 0x%p", (void *)usba_device);

	mutex_exit(&usba_device->usb_mutex);

	return (usba_device);
}


/* free NDI event data associated with usba_device */
void
usba_free_evdata(usba_evdata_t *evdata)
{
	usba_evdata_t *next;

	while (evdata) {
		next = evdata->ev_next;
		kmem_free(evdata, sizeof (usba_evdata_t));
		evdata = next;
	}
}


/*
 * free usb device structure
 */
void
usba_free_usba_device(usba_device_t *usba_device)
{
	int			i, ep_idx;
	usb_pipe_handle_t	def_ph;

	if (usba_device == NULL) {

		return;
	}

	mutex_enter(&usba_device->usb_mutex);
	if (usba_device->usb_ref_count) {
		mutex_exit(&usba_device->usb_mutex);

		return;
	}

	USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_free_usba_device 0x%p, address=0x%x, ref cnt=%d",
	    (void *)usba_device, usba_device->usb_addr,
	    usba_device->usb_ref_count);

	usba_free_evdata(usba_device->usb_evdata);
	mutex_exit(&usba_device->usb_mutex);

	def_ph = usba_usbdev_to_dflt_pipe_handle(usba_device);
	if (def_ph != NULL) {
		usba_pipe_handle_data_t	*ph_data = usba_get_ph_data(def_ph);

		if (ph_data) {
			usb_pipe_close(ph_data->p_dip, def_ph,
			    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED,
			    NULL, NULL);
		}
	}

	/*
	 * Give the HCD a chance to clean up this child device before we finish
	 * tearing things down.
	 */
	if (usba_device->usb_hcdi_ops->usba_hcdi_device_fini != NULL) {
		usba_device->usb_hcdi_ops->usba_hcdi_device_fini(
		    usba_device, usba_device->usb_hcd_private);
		usba_device->usb_hcd_private = NULL;
	}

	mutex_enter(&usba_mutex);

	/* destroy mutex in each usba_ph_impl structure */
	for (ep_idx = 0; ep_idx < USBA_N_ENDPOINTS; ep_idx++) {
		mutex_destroy(&usba_device->usb_ph_list[ep_idx].usba_ph_mutex);
	}

	(void) usba_rm_from_list(&usba_device_list,
	    &usba_device->usb_device_list);

	mutex_exit(&usba_mutex);

	usba_destroy_list(&usba_device->usb_device_list);
	usba_destroy_list(&usba_device->usb_allocated);

	USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
	    "deallocating usba_device = 0x%p, address = 0x%x",
	    (void *)usba_device, usba_device->usb_addr);

	/*
	 * ohci allocates descriptors for root hub so we can't
	 * deallocate these here
	 */

	if (usba_device->usb_addr != ROOT_HUB_ADDR) {
		if (usba_device->usb_cfg_array) {
			USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle,
			    "deallocating usb_config_array: 0x%p",
			    (void *)usba_device->usb_cfg_array);
			mutex_enter(&usba_device->usb_mutex);
			for (i = 0;
			    i < usba_device->usb_dev_descr->bNumConfigurations;
			    i++) {
				if (usba_device->usb_cfg_array[i]) {
					kmem_free(
					    usba_device->usb_cfg_array[i],
					    usba_device->usb_cfg_array_len[i]);
				}
			}

			/* free the array pointers */
			kmem_free(usba_device->usb_cfg_array,
			    usba_device->usb_cfg_array_length);
			kmem_free(usba_device->usb_cfg_array_len,
			    usba_device->usb_cfg_array_len_length);

			mutex_exit(&usba_device->usb_mutex);
		}

		if (usba_device->usb_cfg_str_descr) {
			USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle,
			    "deallocating usb_cfg_str_descr: 0x%p",
			    (void *)usba_device->usb_cfg_str_descr);
			for (i = 0;
			    i < usba_device->usb_dev_descr->bNumConfigurations;
			    i++) {
				if (usba_device->usb_cfg_str_descr[i]) {
					kmem_free(
					    usba_device->usb_cfg_str_descr[i],
					    strlen(usba_device->
					    usb_cfg_str_descr[i]) + 1);
				}
			}
			/* free the array pointers */
			kmem_free(usba_device->usb_cfg_str_descr,
			    sizeof (uchar_t *) * usba_device->usb_n_cfgs);
		}

		if (usba_device->usb_dev_descr) {
			kmem_free(usba_device->usb_dev_descr,
			    sizeof (usb_dev_descr_t));
		}

		if (usba_device->usb_mfg_str) {
			kmem_free(usba_device->usb_mfg_str,
			    strlen(usba_device->usb_mfg_str) + 1);
		}

		if (usba_device->usb_product_str) {
			kmem_free(usba_device->usb_product_str,
			    strlen(usba_device->usb_product_str) + 1);
		}

		if (usba_device->usb_serialno_str) {
			kmem_free(usba_device->usb_serialno_str,
			    strlen(usba_device->usb_serialno_str) + 1);
		}

		usba_free_binary_object_store(usba_device);

		usba_unset_usb_address(usba_device);
	}

#ifndef __lock_lint
	ASSERT(usba_device->usb_client_dev_data_list.cddl_next == NULL);
#endif

	if (usba_device->usb_client_flags) {
#ifndef __lock_lint
		int i;

		for (i = 0; i < usba_device->usb_n_ifs; i++) {
			ASSERT(usba_device->usb_client_flags[i] == 0);
		}
#endif
		kmem_free(usba_device->usb_client_flags,
		    usba_device->usb_n_ifs * USBA_CLIENT_FLAG_SIZE);
	}


	if (usba_device->usb_client_attach_list) {
		kmem_free(usba_device->usb_client_attach_list,
		    usba_device->usb_n_ifs *
		    sizeof (*usba_device->usb_client_attach_list));
	}
	if (usba_device->usb_client_ev_cb_list) {
		kmem_free(usba_device->usb_client_ev_cb_list,
		    usba_device->usb_n_ifs *
		    sizeof (*usba_device->usb_client_ev_cb_list));
	}

	/*
	 * finally ready to destroy the structure
	 */
	mutex_destroy(&usba_device->usb_mutex);

	kmem_free((caddr_t)usba_device, sizeof (usba_device_t));
}


/* clear the data toggle for all endpoints on this device */
void
usba_clear_data_toggle(usba_device_t *usba_device)
{
	int	i;

	if (usba_device != NULL) {
		mutex_enter(&usba_device->usb_mutex);
		for (i = 0; i < USBA_N_ENDPOINTS; i++) {
			usba_device->usb_ph_list[i].usba_ph_flags &=
			    ~USBA_PH_DATA_TOGGLE;
		}
		mutex_exit(&usba_device->usb_mutex);
	}
}


/*
 * usba_create_child_devi():
 *	create a child devinfo node, usba_device, attach properties.
 *	the usba_device structure is shared between all interfaces
 */
int
usba_create_child_devi(dev_info_t	*dip,
		char			*node_name,
		usba_hcdi_ops_t		*usba_hcdi_ops,
		dev_info_t		*usb_root_hub_dip,
		usb_port_status_t	port_status,
		usba_device_t		*usba_device,
		dev_info_t		**child_dip)
{
	int rval = USB_FAILURE;
	int usba_device_allocated = 0;
	usb_addr_t	address;

	USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_create_child_devi: %s usba_device=0x%p "
	    "port status=0x%x", node_name,
	    (void *)usba_device, port_status);

	ndi_devi_alloc_sleep(dip, node_name, (pnode_t)DEVI_SID_NODEID,
	    child_dip);

	USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle,
	    "child dip=0x%p", (void *)*child_dip);

	if (usba_device == NULL) {

		usba_device = usba_alloc_usba_device(usb_root_hub_dip);

		/* grab the mutex to keep warlock happy */
		mutex_enter(&usba_device->usb_mutex);
		usba_device->usb_hcdi_ops	= usba_hcdi_ops;
		usba_device->usb_port_status	= port_status;
		mutex_exit(&usba_device->usb_mutex);

		usba_device_allocated++;
	} else {
		mutex_enter(&usba_device->usb_mutex);
		if (usba_hcdi_ops) {
			ASSERT(usba_device->usb_hcdi_ops == usba_hcdi_ops);
		}
		if (usb_root_hub_dip) {
			ASSERT(usba_device->usb_root_hub_dip ==
			    usb_root_hub_dip);
		}

		usba_device->usb_port_status	= port_status;

		mutex_exit(&usba_device->usb_mutex);
	}

	if (usba_device->usb_addr == 0) {
		if (usba_set_usb_address(usba_device) == USB_FAILURE) {
			address = 0;

			USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
			    "cannot set usb address for dip=0x%p",
			    (void *)*child_dip);

			goto fail;
		}
	}
	address = usba_device->usb_addr;

	/* attach properties */
	rval = ndi_prop_update_int(DDI_DEV_T_NONE, *child_dip,
	    "assigned-address", address);
	if (rval != DDI_PROP_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
		    "cannot set usb address property for dip=0x%p",
		    (void *)*child_dip);
		rval = USB_FAILURE;

		goto fail;
	}

	/*
	 * store the usba_device point in the dip
	 */
	usba_set_usba_device(*child_dip, usba_device);

	USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_create_child_devi: devi=0x%p (%s) ud=0x%p",
	    (void *)*child_dip, ddi_driver_name(*child_dip),
	    (void *)usba_device);

	return (USB_SUCCESS);

fail:
	if (*child_dip) {
		int rval = usba_destroy_child_devi(*child_dip, NDI_DEVI_REMOVE);
		ASSERT(rval == USB_SUCCESS);
		*child_dip = NULL;
	}

	if (usba_device_allocated) {
		usba_free_usba_device(usba_device);
	} else if (address && usba_device) {
		usba_unset_usb_address(usba_device);
	}

	USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_create_child_devi failed: rval=%d", rval);

	return (rval);
}


int
usba_destroy_child_devi(dev_info_t *dip, uint_t flag)
{
	usba_device_t	*usba_device;
	int		rval = NDI_SUCCESS;

	USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_destroy_child_devi: %s%d (0x%p)",
	    ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip);

	usba_device = usba_get_usba_device(dip);

	/*
	 * if the child hasn't been bound yet, we can just
	 * free the dip
	 */
	if (i_ddi_node_state(dip) < DS_INITIALIZED) {
		/*
		 * do not call ndi_devi_free() since it might
		 * deadlock
		 */
		rval = ddi_remove_child(dip, 0);

	} else {
		char *devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP);
		dev_info_t *pdip = ddi_get_parent(dip);

		(void) ddi_deviname(dip, devnm);

		USB_DPRINTF_L3(DPRINT_MASK_USBA, usba_log_handle,
		    "usba_destroy_child_devi:\n\t"
		    "offlining dip 0x%p usba_device=0x%p (%s)", (void *)dip,
		    (void *)usba_device, devnm);

		(void) devfs_clean(pdip, NULL, DV_CLEAN_FORCE);
		rval =	ndi_devi_unconfig_one(pdip, devnm + 1, NULL,
		    flag | NDI_UNCONFIG | NDI_DEVI_OFFLINE);
		if (rval != NDI_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_USBA, usba_log_handle,
			    " ndi_devi_unconfig_one %s%d failed (%d)",
			    ddi_driver_name(dip), ddi_get_instance(dip),
			    rval);
		}
		kmem_free(devnm, MAXNAMELEN + 1);
	}

	USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_destroy_child_devi: rval=%d", rval);

	return (rval == NDI_SUCCESS ? USB_SUCCESS : USB_FAILURE);
}


/*
 * list management
 */
void
usba_init_list(usba_list_entry_t *element, usb_opaque_t private,
	ddi_iblock_cookie_t	iblock_cookie)
{
	mutex_init(&element->list_mutex, NULL, MUTEX_DRIVER,
	    iblock_cookie);
	mutex_enter(&element->list_mutex);
	element->private = private;
	mutex_exit(&element->list_mutex);
}


void
usba_destroy_list(usba_list_entry_t *head)
{
	mutex_enter(&head->list_mutex);
	ASSERT(head->next == NULL);
	ASSERT(head->prev == NULL);
	mutex_exit(&head->list_mutex);

	mutex_destroy(&head->list_mutex);
}


void
usba_add_to_list(usba_list_entry_t *head, usba_list_entry_t *element)
{
	usba_list_entry_t *next;
	int		remaining;

	mutex_enter(&head->list_mutex);
	mutex_enter(&element->list_mutex);

	remaining = head->count;

	/* check if it is not in another list */
	ASSERT(element->next == NULL);
	ASSERT(element->prev == NULL);

#ifdef DEBUG
	/*
	 * only verify the list when not in interrupt context, we
	 * have to trust the HCD
	 */
	if (!servicing_interrupt()) {

		/* check if not already in this list */
		for (next = head->next; (next != NULL);
		    next = next->next) {
			if (next == element) {
				USB_DPRINTF_L0(DPRINT_MASK_USBA,
				    usba_log_handle,
				    "Attempt to corrupt USB list at 0x%p",
				    (void *)head);
				ASSERT(next == element);

				goto done;
			}
			remaining--;

			/*
			 * Detect incorrect circ links or found
			 * unexpected elements.
			 */
			if ((next->next && (remaining == 0)) ||
			    ((next->next == NULL) && remaining)) {
				panic("Corrupted USB list at 0x%p",
				    (void *)head);
				/*NOTREACHED*/
			}
		}
	}
#endif

	if (head->next == NULL) {
		head->prev = head->next = element;
	} else {
		/* add to tail */
		head->prev->next = element;
		element->prev = head->prev;
		head->prev = element;
	}

	head->count++;

	USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_add_to_list: head=0x%p element=0x%p count=%d",
	    (void *)head, (void *)element, head->count);

done:
	mutex_exit(&head->list_mutex);
	mutex_exit(&element->list_mutex);
}


int
usba_rm_from_list(usba_list_entry_t *head, usba_list_entry_t *element)
{
	usba_list_entry_t *e;
	int		found = 0;
	int		remaining;

	/* find the element in the list first */
	mutex_enter(&head->list_mutex);

	USB_DPRINTF_L4(DPRINT_MASK_USBA, usba_log_handle,
	    "usba_rm_from_list: head=0x%p element=0x%p count=%d",
	    (void *)head, (void *)element, head->count);

	remaining = head->count;
	e = head->next;

	while (e) {
		if (e == element) {
			found++;
			break;
		}
		e = e->next;

		remaining--;

		/* Detect incorrect circ links or found unexpected elements. */
		if ((e && (remaining == 0)) ||
		    ((e == NULL) && (remaining))) {
			panic("Corrupted USB list at 0x%p", (void *)head);
			/*NOTREACHED*/
		}
	}

	if (!found) {
		mutex_exit(&head->list_mutex);

		return (USB_FAILURE);
	}

	/* now remove the element */
	mutex_enter(&element->list_mutex);

	if (element->next) {
		element->next->prev = element->prev;
	}
	if (element->prev) {
		element->prev->next = element->next;
	}
	if (head->next == element) {