xref: /illumos-gate/usr/src/uts/common/io/usb/usba/hubdi.c (revision 7c478bd9)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"


/*
 * USBA: Solaris USB Architecture support for the hub
 * including root hub
 * Most of the code for hubd resides in this file and
 * is shared between the HCD root hub support and hubd
 */
#define	USBA_FRAMEWORK
#include <sys/usb/usba.h>
#include <sys/usb/usba/usba_devdb.h>
#include <sys/sunndi.h>
#include <sys/usb/usba/usba_impl.h>
#include <sys/usb/usba/usba_types.h>
#include <sys/usb/usba/hubdi.h>
#include <sys/usb/usba/hcdi_impl.h>
#include <sys/usb/hubd/hub.h>
#include <sys/usb/hubd/hubdvar.h>
#include <sys/usb/hubd/hubd_impl.h>
#include <sys/kobj.h>
#include <sys/kobj_lex.h>
#include <sys/fs/dv_node.h>

/*
 * Prototypes for static functions
 */
static	int	usba_hubdi_bus_ctl(
			dev_info_t		*dip,
			dev_info_t		*rdip,
			ddi_ctl_enum_t		op,
			void			*arg,
			void			*result);

static int	usba_hubdi_map_fault(
			dev_info_t		*dip,
			dev_info_t		*rdip,
			struct hat		*hat,
			struct seg		*seg,
			caddr_t 		addr,
			struct devpage		*dp,
			pfn_t			pfn,
			uint_t			prot,
			uint_t			lock);

static int hubd_busop_get_eventcookie(dev_info_t *dip,
			dev_info_t *rdip,
			char *eventname,
			ddi_eventcookie_t *cookie);
static int hubd_busop_add_eventcall(dev_info_t *dip,
			dev_info_t *rdip,
			ddi_eventcookie_t cookie,
			void (*callback)(dev_info_t *dip,
				ddi_eventcookie_t cookie, void *arg,
				void *bus_impldata),
			void *arg, ddi_callback_id_t *cb_id);
static int hubd_busop_remove_eventcall(dev_info_t *dip,
			ddi_callback_id_t cb_id);
static int hubd_bus_config(dev_info_t *dip,
			uint_t flag,
			ddi_bus_config_op_t op,
			void *arg,
			dev_info_t **child);
static int hubd_bus_unconfig(dev_info_t *dip,
			uint_t flag,
			ddi_bus_config_op_t op,
			void *arg);
static int hubd_bus_power(dev_info_t *dip, void *impl_arg,
			pm_bus_power_op_t op, void *arg, void *result);

static void hubd_get_ancestry_str(hubd_t *);
static usb_port_t  hubd_get_port_num(hubd_t *, struct devctl_iocdata *);
static dev_info_t *hubd_get_child_dip(hubd_t *, usb_port_t);
static uint_t hubd_cfgadm_state(hubd_t *, usb_port_t);
static int hubd_toggle_port(hubd_t *, usb_port_t);
static void hubd_register_cpr_callback(hubd_t *);
static void hubd_unregister_cpr_callback(hubd_t *);
static hubd_t *hubd_get_soft_state(dev_info_t *dip);

/*
 * Busops vector for USB HUB's
 */
struct bus_ops usba_hubdi_busops =	{
	BUSO_REV,
	nullbusmap,			/* bus_map */
	NULL,				/* bus_get_intrspec */
	NULL,				/* bus_add_intrspec */
	NULL,				/* bus_remove_intrspec */
	usba_hubdi_map_fault,		/* bus_map_fault */
	ddi_dma_map,			/* bus_dma_map */
	ddi_dma_allochdl,
	ddi_dma_freehdl,
	ddi_dma_bindhdl,
	ddi_dma_unbindhdl,
	ddi_dma_flush,
	ddi_dma_win,
	ddi_dma_mctl,			/* bus_dma_ctl */
	usba_hubdi_bus_ctl,		/* bus_ctl */
	ddi_bus_prop_op,		/* bus_prop_op */
	hubd_busop_get_eventcookie,
	hubd_busop_add_eventcall,
	hubd_busop_remove_eventcall,
	NULL,				/* bus_post_event */
	NULL,				/* bus_intr_ctl */
	hubd_bus_config,		/* bus_config */
	hubd_bus_unconfig,		/* bus_unconfig */
	NULL,				/* bus_fm_init */
	NULL,				/* bus_fm_fini */
	NULL,				/* bus_fm_access_enter */
	NULL,				/* bus_fm_access_exit */
	hubd_bus_power			/* bus_power */
};


/*
 * local variables
 */
static kmutex_t	usba_hubdi_mutex;	/* protects USBA HUB data structures */

static usba_list_entry_t	usba_hubdi_list;

usb_log_handle_t	hubdi_log_handle;
uint_t			hubdi_errlevel = USB_LOG_L4;
uint_t			hubdi_errmask = (uint_t)-1;
uint_t			hubdi_min_pm_threshold = 5; /* seconds */

/*
 * initialize private data
 */
void
usba_hubdi_initialization()
{
	hubdi_log_handle = usb_alloc_log_hdl(NULL, "hubdi", &hubdi_errlevel,
				&hubdi_errmask, NULL, 0);

	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
	    "usba_hubdi_initialization");

	mutex_init(&usba_hubdi_mutex, NULL, MUTEX_DRIVER, NULL);

	usba_init_list(&usba_hubdi_list, NULL, NULL);
}


void
usba_hubdi_destroy()
{
	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
	    "usba_hubdi_destroy");

	mutex_destroy(&usba_hubdi_mutex);
	usba_destroy_list(&usba_hubdi_list);

	usb_free_log_hdl(hubdi_log_handle);
}


/*
 * Called by an	HUB to attach an instance of the driver
 *	make this instance known to USBA
 *	the HUB	should initialize usba_hubdi structure prior
 *	to calling this	interface
 */
static int
usba_hubdi_register(dev_info_t	*dip,
		uint_t		flags)
{
	usba_hubdi_t *hubdi = kmem_zalloc(sizeof (usba_hubdi_t), KM_SLEEP);
	usba_device_t *usba_device = usba_get_usba_device(dip);

	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
	    "usba_hubdi_register: %s", ddi_node_name(dip));

	hubdi->hubdi_dip = dip;
	hubdi->hubdi_flags = flags;

	usba_device->usb_hubdi = hubdi;

	/*
	 * add this hubdi instance to the list of known hubdi's
	 */
	usba_init_list(&hubdi->hubdi_list, (usb_opaque_t)hubdi,
	    usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip)->
	    hcdi_iblock_cookie);
	mutex_enter(&usba_hubdi_mutex);
	usba_add_to_list(&usba_hubdi_list, &hubdi->hubdi_list);
	mutex_exit(&usba_hubdi_mutex);

	return (DDI_SUCCESS);
}


/*
 * Called by an	HUB to detach an instance of the driver
 */
static int
usba_hubdi_unregister(dev_info_t *dip)
{
	usba_device_t *usba_device = usba_get_usba_device(dip);
	usba_hubdi_t *hubdi = usba_device->usb_hubdi;

	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
	    "usba_hubdi_unregister: %s", ddi_node_name(dip));

	mutex_enter(&usba_hubdi_mutex);
	(void) usba_rm_from_list(&usba_hubdi_list, &hubdi->hubdi_list);
	mutex_exit(&usba_hubdi_mutex);

	usba_destroy_list(&hubdi->hubdi_list);

	kmem_free(hubdi, sizeof (usba_hubdi_t));

	return (DDI_SUCCESS);
}


/*
 * misc bus routines currently not used
 */
/*ARGSUSED*/
static int
usba_hubdi_map_fault(dev_info_t *dip,
	dev_info_t	*rdip,
	struct hat	*hat,
	struct seg	*seg,
	caddr_t 	addr,
	struct devpage	*dp,
	pfn_t		pfn,
	uint_t		prot,
	uint_t		lock)
{
	return (DDI_FAILURE);
}


/*
 * root hub support. the root hub uses the same devi as the HCD
 */
int
usba_hubdi_bind_root_hub(dev_info_t *dip,
	uchar_t	*root_hub_config_descriptor,
	size_t config_length,
	usb_dev_descr_t *root_hub_device_descriptor)
{
	usba_device_t *usba_device;
	usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(dip);
	hubd_t	*root_hubd;
	usb_pipe_handle_t ph = NULL;
	dev_info_t *child = ddi_get_child(dip);

	if (ndi_prop_create_boolean(DDI_DEV_T_NONE, dip,
	    "root-hub") != NDI_SUCCESS) {

		return (USB_FAILURE);
	}

	root_hubd = kmem_zalloc(sizeof (hubd_t), KM_SLEEP);

	/*
	 * create and initialize a usba_device structure
	 */
	usba_device = usba_alloc_usba_device(dip);

	mutex_enter(&usba_device->usb_mutex);
	usba_device->usb_hcdi_ops = hcdi->hcdi_ops;
	usba_device->usb_cfg = root_hub_config_descriptor;
	usba_device->usb_cfg_length = config_length;
	usba_device->usb_dev_descr = root_hub_device_descriptor;
	usba_device->usb_port = 1;
	usba_device->usb_addr = ROOT_HUB_ADDR;
	usba_device->usb_root_hubd = root_hubd;
	usba_device->usb_cfg_array = kmem_zalloc(sizeof (uchar_t *),
								KM_SLEEP);
	usba_device->usb_cfg_array_length = sizeof (uchar_t *);

	usba_device->usb_cfg_array_len = kmem_zalloc(sizeof (uint16_t),
								KM_SLEEP);
	usba_device->usb_cfg_array_len_length = sizeof (uint16_t);

	usba_device->usb_cfg_array[0] = root_hub_config_descriptor;
	usba_device->usb_cfg_array_len[0] =
				sizeof (root_hub_config_descriptor);

	usba_device->usb_cfg_str_descr = kmem_zalloc(sizeof (uchar_t *),
								KM_SLEEP);
	usba_device->usb_n_cfgs = 1;
	usba_device->usb_n_ifs = 1;
	usba_device->usb_dip = dip;

	usba_device->usb_client_flags = kmem_zalloc(
	    usba_device->usb_n_ifs * USBA_CLIENT_FLAG_SIZE, KM_SLEEP);

	usba_device->usb_client_attach_list = kmem_zalloc(
	    usba_device->usb_n_ifs *
	    sizeof (*usba_device->usb_client_attach_list), KM_SLEEP);

	usba_device->usb_client_ev_cb_list = kmem_zalloc(
	    usba_device->usb_n_ifs *
	    sizeof (*usba_device->usb_client_ev_cb_list), KM_SLEEP);

	/*
	 * The bDeviceProtocol field of root hub device specifies,
	 * whether root hub is a High or Full speed usb device.
	 */
	if (root_hub_device_descriptor->bDeviceProtocol) {
		usba_device->usb_port_status = USBA_HIGH_SPEED_DEV;
	} else {
		usba_device->usb_port_status = USBA_FULL_SPEED_DEV;
	}

	mutex_exit(&usba_device->usb_mutex);

	usba_set_usba_device(dip, usba_device);

	/*
	 * For the root hub the default pipe is not yet open
	 */
	if (usb_pipe_open(dip, NULL, NULL,
	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph) != USB_SUCCESS) {
		goto fail;
	}

	/*
	 * kill off all OBP children, they may not be fully
	 * enumerated
	 */
	while (child) {
		dev_info_t *next = ddi_get_next_sibling(child);
		(void) ddi_remove_child(child, 0);
		child = next;
	}

	/*
	 * "attach" the root hub driver
	 */
	if (usba_hubdi_attach(dip, DDI_ATTACH) != DDI_SUCCESS) {
		goto fail;
	}

	return (USB_SUCCESS);

fail:
	(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "root-hub");

	if (ph) {
		usb_pipe_close(dip, ph,
		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
	}

	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);

	kmem_free(usba_device->usb_cfg_str_descr, sizeof (uchar_t *));

	usba_free_usba_device(usba_device);

	usba_set_usba_device(dip, NULL);
	if (root_hubd) {
		kmem_free(root_hubd, sizeof (hubd_t));
	}

	return (USB_FAILURE);
}


int
usba_hubdi_unbind_root_hub(dev_info_t *dip)
{
	usba_device_t *usba_device;

	/* was root hub attached? */
	if (!(usba_is_root_hub(dip))) {

		/* return success anyway */
		return (USB_SUCCESS);
	}

	/*
	 * usba_hubdi_detach also closes the default pipe
	 * and removes properties so there is no need to
	 * do it here
	 */
	if (usba_hubdi_detach(dip, DDI_DETACH) != DDI_SUCCESS) {

		if (DEVI_IS_ATTACHING(dip)) {
			USB_DPRINTF_L1(DPRINT_MASK_ATTA, hubdi_log_handle,
			    "failure to unbind root hub after attach failure");
		}

		return (USB_FAILURE);
	}

	usba_device = usba_get_usba_device(dip);

	kmem_free(usba_device->usb_root_hubd, sizeof (hubd_t));

	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);

	kmem_free(usba_device->usb_cfg_str_descr, sizeof (uchar_t *));

	usba_free_usba_device(usba_device);

	(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "root-hub");

	return (USB_SUCCESS);
}


/*
 * Actual Hub Driver support code:
 *	shared by root hub and non-root hubs
 */
#include <sys/usb/usba/usbai_version.h>

/* Debugging support */
static uint_t hubd_errlevel	= USB_LOG_L4;
static uint_t hubd_errmask	= (uint_t)DPRINT_MASK_ALL;
static uint_t hubd_instance_debug = (uint_t)-1;
static uint_t hubdi_bus_config_debug = 0;

_NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_errlevel))
_NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_errmask))
_NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_instance_debug))

_NOTE(SCHEME_PROTECTS_DATA("unique", msgb))
_NOTE(SCHEME_PROTECTS_DATA("unique", dev_info))


/*
 * local variables:
 *
 * Amount of time to wait between resetting the port and accessing
 * the device.	The value is in microseconds.
 */
static uint_t hubd_device_delay = 1000000;

/*
 * enumeration retry
 */
#define	HUBD_PORT_RETRY 5
static uint_t hubd_retry_enumerate = HUBD_PORT_RETRY;

/*
 * Stale hotremoved device cleanup delay
 */
#define	HUBD_STALE_DIP_CLEANUP_DELAY	5000000
static uint_t hubd_dip_cleanup_delay = HUBD_STALE_DIP_CLEANUP_DELAY;

/*
 * retries for USB suspend and resume
 */
#define	HUBD_SUS_RES_RETRY	2

void	*hubd_statep;

/*
 * prototypes
 */
static int hubd_cleanup(dev_info_t *dip, hubd_t  *hubd);
static int hubd_check_ports(hubd_t  *hubd);

static void hubd_schedule_cleanup(dev_info_t *);

static int  hubd_open_intr_pipe(hubd_t *hubd);
static void hubd_start_polling(hubd_t *hubd, int always);
static void hubd_stop_polling(hubd_t *hubd);
static void hubd_close_intr_pipe(hubd_t *hubd);

static void hubd_read_cb(usb_pipe_handle_t pipe, usb_intr_req_t *req);
static void hubd_exception_cb(usb_pipe_handle_t pipe,
						usb_intr_req_t *req);
static void hubd_hotplug_thread(void *arg);
static int hubd_create_child(dev_info_t *dip,
		hubd_t		*hubd,
		usba_device_t	*usba_device,
		usb_port_status_t port_status,
		usb_port_t	port,
		int		iteration);

static int hubd_delete_child(hubd_t *hubd, usb_port_t port, uint_t flag,
	boolean_t retry);

static int hubd_get_hub_descriptor(hubd_t *hubd);

static int hubd_reset_port(hubd_t *hubd, usb_port_t port);

static int hubd_get_hub_status(hubd_t *hubd);

static int hubd_handle_port_connect(hubd_t *hubd, usb_port_t port);

static int hubd_disable_port(hubd_t *hubd, usb_port_t port);

static int hubd_enable_port(hubd_t *hubd, usb_port_t port);
static int hubd_recover_disabled_port(hubd_t *hubd, usb_port_t port);

static int hubd_determine_port_status(hubd_t *hubd, usb_port_t port,
	uint16_t *status, uint16_t *change, uint_t ack_flag);

static int hubd_enable_all_port_power(hubd_t *hubd);
static int hubd_disable_all_port_power(hubd_t *hubd);
static int hubd_disable_port_power(hubd_t *hubd, usb_port_t port);
static int hubd_enable_port_power(hubd_t *hubd, usb_port_t port);

static void hubd_free_usba_device(hubd_t *hubd, usba_device_t *usba_device);

static int hubd_can_suspend(hubd_t *hubd);
static void hubd_restore_device_state(dev_info_t *dip, hubd_t *hubd);
static int hubd_setdevaddr(hubd_t *hubd, usb_port_t port);
static void hubd_setdevconfig(hubd_t *hubd, usb_port_t port);

static int hubd_register_events(hubd_t *hubd);
static void hubd_do_callback(hubd_t *hubd, dev_info_t *dip,
	ddi_eventcookie_t cookie);
static void hubd_run_callbacks(hubd_t *hubd, usba_event_t type);
static void hubd_post_event(hubd_t *hubd, usb_port_t port, usba_event_t type);
static void hubd_create_pm_components(dev_info_t *dip, hubd_t *hubd);

static int hubd_disconnect_event_cb(dev_info_t *dip);
static int hubd_reconnect_event_cb(dev_info_t *dip);
static int hubd_pre_suspend_event_cb(dev_info_t *dip);
static int hubd_post_resume_event_cb(dev_info_t *dip);
static int hubd_cpr_suspend(hubd_t *hubd);
static void hubd_cpr_resume(dev_info_t *dip);
static int hubd_restore_state_cb(dev_info_t *dip);

static ndi_event_definition_t hubd_ndi_event_defs[] = {
	{USBA_EVENT_TAG_HOT_REMOVAL, DDI_DEVI_REMOVE_EVENT, EPL_KERNEL,
						NDI_EVENT_POST_TO_ALL},
	{USBA_EVENT_TAG_HOT_INSERTION, DDI_DEVI_INSERT_EVENT, EPL_KERNEL,
						NDI_EVENT_POST_TO_ALL},
	{USBA_EVENT_TAG_POST_RESUME, USBA_POST_RESUME_EVENT, EPL_KERNEL,
						NDI_EVENT_POST_TO_ALL},
	{USBA_EVENT_TAG_PRE_SUSPEND, USBA_PRE_SUSPEND_EVENT, EPL_KERNEL,
						NDI_EVENT_POST_TO_ALL}
};

#define	HUBD_N_NDI_EVENTS \
	(sizeof (hubd_ndi_event_defs) / sizeof (ndi_event_definition_t))

static ndi_event_set_t hubd_ndi_events = {
	NDI_EVENTS_REV1, HUBD_N_NDI_EVENTS, hubd_ndi_event_defs};

/* events received from parent */
static usb_event_t hubd_events = {
	hubd_disconnect_event_cb,
	hubd_reconnect_event_cb,
	hubd_pre_suspend_event_cb,
	hubd_post_resume_event_cb
};


/*
 * hubd_get_soft_state() returns the hubd soft state
 */
static hubd_t *
hubd_get_soft_state(dev_info_t *dip)
{
	if (dip == NULL) {

		return (NULL);
	}

	if (usba_is_root_hub(dip)) {
		usba_device_t *usba_device = usba_get_usba_device(dip);

		return (usba_device->usb_root_hubd);
	} else {
		int instance = ddi_get_instance(dip);

		return (ddi_get_soft_state(hubd_statep, instance));
	}
}


/*
 * PM support functions:
 */
/*ARGSUSED*/
static void
hubd_pm_busy_component(hubd_t *hubd, dev_info_t *dip, int component)
{
	if (hubd->h_hubpm != NULL) {
		hubd->h_hubpm->hubp_busy_pm++;
		mutex_exit(HUBD_MUTEX(hubd));
		if (pm_busy_component(dip, 0) != DDI_SUCCESS) {
			mutex_enter(HUBD_MUTEX(hubd));
			hubd->h_hubpm->hubp_busy_pm--;
			mutex_exit(HUBD_MUTEX(hubd));
		}
		mutex_enter(HUBD_MUTEX(hubd));
		USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
		    "hubd_pm_busy_component: %d", hubd->h_hubpm->hubp_busy_pm);
	}
}


/*ARGSUSED*/
static void
hubd_pm_idle_component(hubd_t *hubd, dev_info_t *dip, int component)
{
	if (hubd->h_hubpm != NULL) {
		mutex_exit(HUBD_MUTEX(hubd));
		if (pm_idle_component(dip, 0) == DDI_SUCCESS) {
			mutex_enter(HUBD_MUTEX(hubd));
			ASSERT(hubd->h_hubpm->hubp_busy_pm > 0);
			hubd->h_hubpm->hubp_busy_pm--;
			mutex_exit(HUBD_MUTEX(hubd));
		}
		mutex_enter(HUBD_MUTEX(hubd));
		USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
		    "hubd_pm_idle_component: %d", hubd->h_hubpm->hubp_busy_pm);
	}
}


/*
 * track power level changes for children of this instance
 */
static void
hubd_set_child_pwrlvl(hubd_t *hubd, usb_port_t port, uint8_t power)
{
	int	old_power, new_power, pwr;
	usb_port_t	portno;
	hub_power_t	*hubpm;

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_set_child_pwrlvl: port=%d power=%d",
	    port, power);

	mutex_enter(HUBD_MUTEX(hubd));
	hubpm = hubd->h_hubpm;

	old_power = 0;
	for (portno = 1; portno <= hubd->h_hub_descr.bNbrPorts; portno++) {
		old_power += hubpm->hubp_child_pwrstate[portno];
	}

	/* assign the port power */
	pwr = hubd->h_hubpm->hubp_child_pwrstate[port];
	hubd->h_hubpm->hubp_child_pwrstate[port] = power;
	new_power = old_power - pwr + power;

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_set_child_pwrlvl: new_power=%d old_power=%d",
	    new_power, old_power);

	if ((new_power > 0) && (old_power == 0)) {
		/* we have the first child coming out of low power */
		(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
	} else if ((new_power == 0) && (old_power > 0)) {
		/* we have the last child going to low power */
		(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
	}
	mutex_exit(HUBD_MUTEX(hubd));
}


/*
 * given a child dip, locate its port number
 */
static usb_port_t
hubd_child_dip2port(hubd_t *hubd, dev_info_t *dip)
{
	usb_port_t	port;

	mutex_enter(HUBD_MUTEX(hubd));
	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		if (hubd->h_children_dips[port] == dip) {

			break;
		}
	}
	ASSERT(port <= hubd->h_hub_descr.bNbrPorts);
	mutex_exit(HUBD_MUTEX(hubd));

	return (port);
}


/*
 * if the hub can be put into low power mode, return success
 * NOTE: suspend here means going to lower power, not CPR suspend.
 */
static int
hubd_can_suspend(hubd_t *hubd)
{
	hub_power_t	*hubpm;
	int		total_power = 0;
	usb_port_t	port;

	hubpm = hubd->h_hubpm;

	if (DEVI_IS_DETACHING(hubd->h_dip)) {

		return (USB_SUCCESS);
	}

	/*
	 * Don't go to lower power if haven't been at full power for enough
	 * time to let hotplug thread kickoff.
	 */
	if (ddi_get_time() < (hubpm->hubp_time_at_full_power +
	    hubpm->hubp_min_pm_threshold)) {

		return (USB_FAILURE);
	}

	for (port = 1; (total_power == 0) &&
	    (port <= hubd->h_hub_descr.bNbrPorts); port++) {
		total_power += hubpm->hubp_child_pwrstate[port];
	}

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
		"hubd_can_suspend: %d", total_power);

	return (total_power ? USB_FAILURE : USB_SUCCESS);
}


/*
 * resume port depending on current device state
 */
static int
hubd_resume_port(hubd_t *hubd, usb_port_t port)
{
	int		rval, retry;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;
	uint16_t	status;
	uint16_t	change;
	int		retval = USB_FAILURE;

	mutex_enter(HUBD_MUTEX(hubd));

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_resume_port: port=%d state=0x%x (%s)", port,
	    hubd->h_dev_state, usb_str_dev_state(hubd->h_dev_state));

	switch (hubd->h_dev_state) {
	case USB_DEV_HUB_CHILD_PWRLVL:
		/*
		 * This could be a bus ctl for a port other than the one
		 * that has a remote wakeup condition. So check.
		 */
		if ((hubd->h_port_state[port] & PORT_STATUS_PSS) == 0) {
			/* the port isn't suspended, so don't resume */
			retval = USB_SUCCESS;

			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
			    "hubd_resume_port: port=%d not suspended", port);

			break;
		}
		/*
		 * Device has initiated a wakeup.
		 * Issue a ClearFeature(PortSuspend)
		 */
		mutex_exit(HUBD_MUTEX(hubd));
		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
		    hubd->h_default_pipe,
		    HANDLE_PORT_FEATURE,
		    USB_REQ_CLEAR_FEATURE,
		    CFS_PORT_SUSPEND,
		    port,
		    0, NULL, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
			    "ClearFeature(PortSuspend) fails "
			    "rval=%d cr=%d cb=0x%x", rval,
			    completion_reason, cb_flags);
		}
		mutex_enter(HUBD_MUTEX(hubd));

		/* either way ack changes on the port */
		(void) hubd_determine_port_status(hubd, port,
			&status, &change, PORT_CHANGE_PSSC);
		retval = USB_SUCCESS;

		break;
	case USB_DEV_HUB_STATE_RECOVER:
		/*
		 * When hubd's connect event callback posts a connect
		 * event to its child, it results in this busctl call
		 * which is valid
		 */
		/* FALLTHRU */
	case USB_DEV_ONLINE:
		if ((hubd->h_port_state[port] &
		    (PORT_STATUS_PSS | PORT_STATUS_CCS)) == 0) {
			/*
			 * the port isn't suspended, or connected
			 * so don't resume
			 */
			retval = USB_SUCCESS;

			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
			    "hubd_resume_port: port=%d not suspended", port);

			break;
		}
		/*
		 * prevent kicking off the hotplug thread
		 */
		hubd->h_hotplug_thread++;
		hubd_stop_polling(hubd);

		/* Now ClearFeature(PortSuspend) */
		for (retry = 0; retry < HUBD_SUS_RES_RETRY; retry++) {
			mutex_exit(HUBD_MUTEX(hubd));
			rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_CLEAR_FEATURE,
			    CFS_PORT_SUSPEND,
			    port,
			    0, NULL, 0,
			    &completion_reason, &cb_flags, 0);
			mutex_enter(HUBD_MUTEX(hubd));
			if (rval != USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PM,
				    hubd->h_log_handle,
				    "ClearFeature(PortSuspend) fails"
				    "rval=%d cr=%d cb=0x%x", rval,
				    completion_reason, cb_flags);
			} else {
				/*
				 * As per spec section 11.9 and 7.1.7.7
				 * hub need to provide at least 20ms of
				 * resume signalling, and s/w provide 10ms of
				 * recovery time before accessing the port.
				 */
				mutex_exit(HUBD_MUTEX(hubd));
				delay(drv_usectohz(40000));
				mutex_enter(HUBD_MUTEX(hubd));
				(void) hubd_determine_port_status(hubd, port,
				    &status, &change, PORT_CHANGE_PSSC);

				if ((status & PORT_STATUS_PSS) == 0) {
					/* the port did finally resume */
					retval = USB_SUCCESS;

					break;
				}
			}
		}

		/* allow hotplug thread again */
		hubd->h_hotplug_thread--;
		hubd_start_polling(hubd, 0);

		break;
	case USB_DEV_DISCONNECTED:
		/* Ignore - NO Operation */
		retval = USB_SUCCESS;

		break;
	case USB_DEV_SUSPENDED:
	case USB_DEV_PWRED_DOWN:
	default:
		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
		    "Improper state for port Resume");

		break;
	}
	mutex_exit(HUBD_MUTEX(hubd));

	return (retval);
}


/*
 * suspend port depending on device state
 */
static int
hubd_suspend_port(hubd_t *hubd, usb_port_t port)
{
	int		rval, retry;
	int		retval = USB_FAILURE;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;
	uint16_t	status;
	uint16_t	change;

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_suspend_port: port=%d", port);

	mutex_enter(HUBD_MUTEX(hubd));

	switch (hubd->h_dev_state) {
	case USB_DEV_HUB_STATE_RECOVER:
		/*
		 * When hubd's connect event callback posts a connect
		 * event to its child, it results in this busctl call
		 * which is valid
		 */
		/* FALLTHRU */
	case USB_DEV_HUB_CHILD_PWRLVL:
		/*
		 * When one child is resuming, the other could timeout
		 * and go to low power mode, which is valid
		 */
		/* FALLTHRU */
	case USB_DEV_ONLINE:
		hubd->h_hotplug_thread++;
		hubd_stop_polling(hubd);

		/*
		 * Some devices start an unprovoked resume.  According to spec,
		 * normal resume time for port is 10ms.  Wait for double that
		 * time, then check to be sure port is really suspended.
		 */
		for (retry = 0; retry < HUBD_SUS_RES_RETRY; retry++) {
			/* Now SetFeature(PortSuspend) */
			mutex_exit(HUBD_MUTEX(hubd));
			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_SET_FEATURE,
			    CFS_PORT_SUSPEND,
			    port,
			    0, NULL, 0,
			    &completion_reason, &cb_flags, 0)) !=
			    USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PM,
				    hubd->h_log_handle,
				    "SetFeature(PortSuspend) fails"
				    "rval=%d cr=%d cb=0x%x",
				    rval, completion_reason, cb_flags);
			}

			/*
			 * some devices start an unprovoked resume
			 * wait and check port status after some time
			 */
			delay(drv_usectohz(20000));

			/* either ways ack changes on the port */
			mutex_enter(HUBD_MUTEX(hubd));
			(void) hubd_determine_port_status(hubd, port,
			    &status, &change, PORT_CHANGE_PSSC);
			if (status & PORT_STATUS_PSS) {
				/* the port is indeed suspended */
				retval = USB_SUCCESS;

				break;
			}
		}

		hubd->h_hotplug_thread--;
		hubd_start_polling(hubd, 0);

		break;

	case USB_DEV_DISCONNECTED:
		/* Ignore - No Operation */
		retval = USB_SUCCESS;

		break;

	case USB_DEV_SUSPENDED:
	case USB_DEV_PWRED_DOWN:
	default:
		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
		    "Improper state for port Suspend");

		break;
	}
	mutex_exit(HUBD_MUTEX(hubd));

	return (retval);
}


/*
 * child post attach/detach notifications
 */
static void
hubd_post_attach(hubd_t *hubd, usb_port_t port, struct attachspec *as)
{
	dev_info_t	*dip;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_post_attach: port=%d result=%d",
	    port, as->result);

	if (as->result == DDI_SUCCESS) {
		/*
		 * Check if the child created wants to be power managed.
		 * If yes, the childs power level gets automatically tracked
		 * by DDI_CTLOPS_POWER busctl.
		 * If no, we set power of the new child by default
		 * to USB_DEV_OS_FULL_PWR. Because we should never suspend.
		 */
		mutex_enter(HUBD_MUTEX(hubd));
		dip = hubd->h_children_dips[port];
		mutex_exit(HUBD_MUTEX(hubd));
		if (DEVI(dip)->devi_pm_info == NULL) {
			hubd_set_child_pwrlvl(hubd, port, USB_DEV_OS_FULL_PWR);
		}
	}
}


static void
hubd_post_detach(hubd_t *hubd, usb_port_t port, struct detachspec *ds)
{
	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_post_detach: port=%d result=%d", port, ds->result);

	/*
	 * if the device is successfully detached and is the
	 * last device to detach, mark component as idle
	 */
	mutex_enter(HUBD_MUTEX(hubd));
	if (ds->result == DDI_SUCCESS) {
		usba_device_t	*usba_device = hubd->h_usba_devices[port];
		mutex_exit(HUBD_MUTEX(hubd));

		/*
		 * We set power of the detached child
		 * to 0, so that we can suspend if all
		 * our children are gone
		 */
		hubd_set_child_pwrlvl(hubd, port, USB_DEV_OS_PWR_OFF);

		/* check for leaks on detaching */
		if ((usba_device) && (ds->cmd == DDI_DETACH)) {
			usba_check_for_leaks(usba_device);
		}
	} else {
		mutex_exit(HUBD_MUTEX(hubd));
	}
}


/*
 * hubd_post_power
 *	After the child's power entry point has been called
 *	we record its power level in our local struct.
 *	If the device has powered off, we suspend port
 */
static int
hubd_post_power(hubd_t *hubd, usb_port_t port, pm_bp_child_pwrchg_t *bpc,
    int result)
{
	int	retval = USB_SUCCESS;

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_post_power: port=%d", port);

	if (result == DDI_SUCCESS) {

		/* record this power in our local struct */
		hubd_set_child_pwrlvl(hubd, port, bpc->bpc_nlevel);

		if (bpc->bpc_nlevel == USB_DEV_OS_PWR_OFF) {

			/* now suspend the port */
			retval = hubd_suspend_port(hubd, port);
		} else if (bpc->bpc_nlevel == USB_DEV_OS_FULL_PWR) {

			/* make sure the port is resumed */
			retval = hubd_resume_port(hubd, port);
		}
	} else {

		/* record old power in our local struct */
		hubd_set_child_pwrlvl(hubd, port, bpc->bpc_olevel);

		if (bpc->bpc_olevel == USB_DEV_OS_PWR_OFF) {

			/*
			 * As this device failed to transition from
			 * power off state, suspend the port again
			 */
			retval = hubd_suspend_port(hubd, port);
		}
	}

	return (retval);
}


/*
 * bus ctl notifications are handled here, the rest goes up to root hub/hcd
 */
static int
usba_hubdi_bus_ctl(dev_info_t *dip,
	dev_info_t	*rdip,
	ddi_ctl_enum_t	op,
	void		*arg,
	void		*result)
{
	usba_device_t *hub_usba_device = usba_get_usba_device(rdip);
	dev_info_t *root_hub_dip = hub_usba_device->usb_root_hub_dip;
	struct attachspec *as;
	struct detachspec *ds;
	hubd_t		*hubd;
	usb_port_t	port;
	int		circ, rval;
	int		retval = DDI_FAILURE;

	hubd = hubd_get_soft_state(dip);

	mutex_enter(HUBD_MUTEX(hubd));

	/* flag that we are currently running bus_ctl */
	hubd->h_bus_ctls++;
	mutex_exit(HUBD_MUTEX(hubd));

	USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
	    "usba_hubdi_bus_ctl:\n\t"
	    "dip=0x%p, rdip=0x%p, op=0x%x, arg=0x%p",
	    dip, rdip, op, arg);

	switch (op) {
	case DDI_CTLOPS_ATTACH:
		as = (struct attachspec *)arg;
		port = hubd_child_dip2port(hubd, rdip);

		/* there is nothing to do at resume time */
		if (as->cmd == DDI_RESUME) {
			break;
		}

		/* serialize access */
		ndi_devi_enter(hubd->h_dip, &circ);

		switch (as->when) {
		case DDI_PRE:
			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
			    "DDI_PRE DDI_CTLOPS_ATTACH: dip=%p, port=%d",
			    rdip, port);

			mutex_enter(HUBD_MUTEX(hubd));
			hubd->h_port_state[port] |= HUBD_CHILD_ATTACHING;

			/* Go busy here.  Matching idle is DDI_POST case. */
			(void) hubd_pm_busy_component(hubd, dip, 0);
			mutex_exit(HUBD_MUTEX(hubd));

			/*
			 * if we suspended the port previously
			 * because child went to low power state, and
			 * someone unloaded the driver, the port would
			 * still be suspended and needs to be resumed
			 */
			rval = hubd_resume_port(hubd, port);
			if (rval == USB_SUCCESS) {
				retval = DDI_SUCCESS;
			}

			break;
		case DDI_POST:
			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
			    "DDI_POST DDI_CTLOPS_ATTACH: dip=%p, port=%d",
			    rdip, port);

			mutex_enter(HUBD_MUTEX(hubd));
			hubd->h_port_state[port] &= ~HUBD_CHILD_ATTACHING;
			mutex_exit(HUBD_MUTEX(hubd));

			hubd_post_attach(hubd, port, (struct attachspec *)arg);
			retval = DDI_SUCCESS;
			mutex_enter(HUBD_MUTEX(hubd));

			/* Matching idle call for DDI_PRE busy call. */
			(void) hubd_pm_idle_component(hubd, dip, 0);
			mutex_exit(HUBD_MUTEX(hubd));
		}
		ndi_devi_exit(hubd->h_dip, circ);

		break;
	case DDI_CTLOPS_DETACH:
		ds = (struct detachspec *)arg;
		port = hubd_child_dip2port(hubd, rdip);

		/* there is nothing to do at suspend time */
		if (ds->cmd == DDI_SUSPEND) {
			break;
		}

		/* serialize access */
		ndi_devi_enter(hubd->h_dip, &circ);

		switch (ds->when) {
		case DDI_PRE:
			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
			    "DDI_PRE DDI_CTLOPS_DETACH: dip=%p port=%d",
			    rdip, port);

			mutex_enter(HUBD_MUTEX(hubd));
			hubd->h_port_state[port] |= HUBD_CHILD_DETACHING;

			/* Go busy here.  Matching idle is DDI_POST case. */
			(void) hubd_pm_busy_component(hubd, dip, 0);

			mutex_exit(HUBD_MUTEX(hubd));
			retval = DDI_SUCCESS;

			break;
		case DDI_POST:
			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
			    "DDI_POST DDI_CTLOPS_DETACH: dip=%p port=%d",
			    rdip, port);

			mutex_enter(HUBD_MUTEX(hubd));
			hubd->h_port_state[port] &= ~HUBD_CHILD_DETACHING;
			mutex_exit(HUBD_MUTEX(hubd));

			/* Matching idle call for DDI_PRE busy call. */
			hubd_post_detach(hubd, port, (struct detachspec *)arg);
			retval = DDI_SUCCESS;
			mutex_enter(HUBD_MUTEX(hubd));
			(void) hubd_pm_idle_component(hubd, dip, 0);
			mutex_exit(HUBD_MUTEX(hubd));

			break;
		}
		ndi_devi_exit(hubd->h_dip, circ);

		break;
	default:
		retval = usba_bus_ctl(root_hub_dip, rdip, op, arg, result);
	}

	/* decrement bus_ctls count */
	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_bus_ctls--;
	ASSERT(hubd->h_bus_ctls >= 0);
	mutex_exit(HUBD_MUTEX(hubd));

	return (retval);
}


/*
 * bus enumeration entry points
 */
static int
hubd_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
    void *arg, dev_info_t **child)
{
	extern int modrootloaded;

	hubd_t	*hubd = hubd_get_soft_state(dip);
	int	rval, circ;

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_bus_config: op=%d", op);

	if (hubdi_bus_config_debug) {
		flag |= NDI_DEVI_DEBUG;
	}

	/*
	 * there must be a smarter way to do this but for
	 * now, a hack for booting USB storage.
	 */
	if (!modrootloaded) {
		delay(drv_usectohz(1000000));
	}
	ndi_devi_enter(hubd->h_dip, &circ);
	rval = ndi_busop_bus_config(dip, flag, op, arg, child, 0);
	ndi_devi_exit(hubd->h_dip, circ);

	return (rval);
}


static int
hubd_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
    void *arg)
{
	hubd_t		*hubd = hubd_get_soft_state(dip);
	dev_info_t	*cdip;
	usb_port_t	port;
	int		circ;
	int		rval;

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_bus_unconfig: op=%d", op);

	if (hubdi_bus_config_debug) {
		flag |= NDI_DEVI_DEBUG;
	}

	if ((op == BUS_UNCONFIG_ALL) && (flag & NDI_AUTODETACH) == 0) {
		flag |= NDI_DEVI_REMOVE;
	}

	/* serialize access */
	ndi_devi_enter(dip, &circ);

	rval = ndi_busop_bus_unconfig(dip, flag, op, arg);

	/* logically zap children's list */
	mutex_enter(HUBD_MUTEX(hubd));
	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		hubd->h_port_state[port] |= HUBD_CHILD_ZAP;
	}
	mutex_exit(HUBD_MUTEX(hubd));

	/* fill in what's left */
	for (cdip = ddi_get_child(dip); cdip;
	    cdip = ddi_get_next_sibling(cdip)) {
		usba_device_t *usba_device = usba_get_usba_device(cdip);

		if (usba_device == NULL) {

			continue;
		}
		mutex_enter(HUBD_MUTEX(hubd));
		port = usba_device->usb_port;
		hubd->h_children_dips[port] = cdip;
		hubd->h_port_state[port] &= ~HUBD_CHILD_ZAP;
		mutex_exit(HUBD_MUTEX(hubd));
	}

	/* physically zap the children we didn't find */
	mutex_enter(HUBD_MUTEX(hubd));
	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		if (hubd->h_port_state[port] &  HUBD_CHILD_ZAP) {
			/* zap the dip and usba_device structure as well */
			hubd_free_usba_device(hubd, hubd->h_usba_devices[port]);
			hubd->h_children_dips[port] = NULL;
			hubd->h_port_state[port] &= ~HUBD_CHILD_ZAP;
		}
	}
	mutex_exit(HUBD_MUTEX(hubd));

	ndi_devi_exit(dip, circ);

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_bus_unconfig: rval=%d", rval);

	return (rval);
}


/* bus_power entry point */
static int
hubd_bus_power(dev_info_t *dip, void *impl_arg, pm_bus_power_op_t op,
    void *arg, void *result)
{
	hubd_t		*hubd;
	int		rval, pwrup_res;
	usb_port_t	port;
	int		retval = DDI_FAILURE;
	pm_bp_child_pwrchg_t	*bpc;
	pm_bp_nexus_pwrup_t	bpn;

	hubd = hubd_get_soft_state(dip);

	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubd->h_log_handle,
	    "hubd_bus_power: dip=%p, impl_arg=%p, power_op=%d, arg=%p, "
	    "result=%d\n", dip, impl_arg, op, arg, *(int *)result);

	bpc = (pm_bp_child_pwrchg_t *)arg;

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_bus_pwr++;
	mutex_exit(HUBD_MUTEX(hubd));

	switch (op) {
	case BUS_POWER_PRE_NOTIFICATION:
		port = hubd_child_dip2port(hubd, bpc->bpc_dip);
		USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
		    "hubd_bus_power: BUS_POWER_PRE_NOTIFICATION, port=%d",
		    port);

		/* go to full power if we are powered down */
		mutex_enter(HUBD_MUTEX(hubd));

		/*
		 * If this case completes normally, idle will be in
		 * hubd_bus_power / BUS_POWER_POST_NOTIFICATION
		 */
		hubd_pm_busy_component(hubd, dip, 0);

		/*
		 * raise power only if we have created the components
		 * and are currently in low power
		 */
		if ((hubd->h_dev_state == USB_DEV_PWRED_DOWN) &&
		    hubd->h_hubpm->hubp_wakeup_enabled) {
			mutex_exit(HUBD_MUTEX(hubd));

			bpn.bpn_comp = 0;
			bpn.bpn_dip = dip;
			bpn.bpn_level = USB_DEV_OS_FULL_PWR;
			bpn.bpn_private = bpc->bpc_private;

			rval = pm_busop_bus_power(dip, impl_arg,
			    BUS_POWER_NEXUS_PWRUP, (void *)&bpn,
			    (void *)&pwrup_res);

			if (rval != DDI_SUCCESS || pwrup_res != DDI_SUCCESS) {
				mutex_enter(HUBD_MUTEX(hubd));
				hubd_pm_idle_component(hubd, dip, 0);
				mutex_exit(HUBD_MUTEX(hubd));

				break;
			}
			mutex_enter(HUBD_MUTEX(hubd));
		}

		/* indicate that child is changing power level */
		hubd->h_port_state[port] |= HUBD_CHILD_PWRLVL_CHNG;
		mutex_exit(HUBD_MUTEX(hubd));

		if ((bpc->bpc_olevel == 0) &&
		    (bpc->bpc_nlevel > bpc->bpc_olevel)) {
			/*
			 * this child is transitioning from power off
			 * to power on state - resume port
			 */
			rval = hubd_resume_port(hubd, port);
			if (rval == USB_SUCCESS) {
				retval = DDI_SUCCESS;
			} else {
				/* reset this flag on failure */
				mutex_enter(HUBD_MUTEX(hubd));
				hubd->h_port_state[port] &=
				    ~HUBD_CHILD_PWRLVL_CHNG;
				hubd_pm_idle_component(hubd, dip, 0);
				mutex_exit(HUBD_MUTEX(hubd));
			}
		} else {
			retval = DDI_SUCCESS;
		}

		break;
	case BUS_POWER_POST_NOTIFICATION:
		port = hubd_child_dip2port(hubd, bpc->bpc_dip);
		USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
		    "hubd_bus_power: BUS_POWER_POST_NOTIFICATION, port=%d",
		    port);

		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_port_state[port] &= ~HUBD_CHILD_PWRLVL_CHNG;
		mutex_exit(HUBD_MUTEX(hubd));

		/* record child's pwr and suspend port if required */
		rval = hubd_post_power(hubd, port, bpc, *(int *)result);
		if (rval == USB_SUCCESS) {

			retval = DDI_SUCCESS;
		}

		mutex_enter(HUBD_MUTEX(hubd));

		/*
		 * Matching idle for the busy in
		 * hubd_bus_power / BUS_POWER_PRE_NOTIFICATION
		 */
		hubd_pm_idle_component(hubd, dip, 0);

		mutex_exit(HUBD_MUTEX(hubd));

		break;
	default:
		retval = pm_busop_bus_power(dip, impl_arg, op, arg, result);

		break;
	}

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_bus_pwr--;
	mutex_exit(HUBD_MUTEX(hubd));

	return (retval);
}


/*
 * functions to handle power transition for OS levels 0 -> 3
 */
static int
hubd_pwrlvl0(hubd_t *hubd)
{
	hub_power_t	*hubpm;

	/* We can't power down if hotplug thread is running */
	if (hubd->h_hotplug_thread || hubd->h_hubpm->hubp_busy_pm ||
	    (hubd_can_suspend(hubd) == USB_FAILURE)) {

		return (USB_FAILURE);
	}

	switch (hubd->h_dev_state) {
	case USB_DEV_ONLINE:
		hubpm = hubd->h_hubpm;

		/*
		 * To avoid race with bus_power pre_notify on check over
		 * dev_state, we need to correctly set the dev state
		 * before the mutex is dropped in stop polling.
		 */
		hubd->h_dev_state = USB_DEV_PWRED_DOWN;
		hubpm->hubp_current_power = USB_DEV_OS_PWR_OFF;

		/*
		 * if we are the root hub, do not stop polling
		 * otherwise, we will never see a resume
		 */
		if (usba_is_root_hub(hubd->h_dip)) {
			/* place holder to implement Global Suspend */
			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
			    "Global Suspend: Not Yet Implemented");
		} else {
			hubd_stop_polling(hubd);
		}

		/* Issue USB D3 command to the device here */
		(void) usb_set_device_pwrlvl3(hubd->h_dip);

		break;
	case USB_DEV_DISCONNECTED:
	case USB_DEV_SUSPENDED:
	case USB_DEV_PWRED_DOWN:
	default:

		break;
	}

	return (USB_SUCCESS);
}


/* ARGSUSED */
static int
hubd_pwrlvl1(hubd_t *hubd)
{
	/* Issue USB D2 command to the device here */
	(void) usb_set_device_pwrlvl2(hubd->h_dip);

	return (USB_FAILURE);
}


/* ARGSUSED */
static int
hubd_pwrlvl2(hubd_t *hubd)
{
	/* Issue USB D1 command to the device here */
	(void) usb_set_device_pwrlvl1(hubd->h_dip);

	return (USB_FAILURE);
}


static int
hubd_pwrlvl3(hubd_t *hubd)
{
	hub_power_t	*hubpm;
	int		rval;

	USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle, "hubd_pwrlvl3");

	hubpm = hubd->h_hubpm;
	switch (hubd->h_dev_state) {
	case USB_DEV_PWRED_DOWN:
		ASSERT(hubpm->hubp_current_power == USB_DEV_OS_PWR_OFF);
		if (usba_is_root_hub(hubd->h_dip)) {
			/* implement global resume here */
			USB_DPRINTF_L2(DPRINT_MASK_PM,
			    hubd->h_log_handle,
			    "Global Resume: Not Yet Implemented");
		}
		/* Issue USB D0 command to the device here */
		rval = usb_set_device_pwrlvl0(hubd->h_dip);
		ASSERT(rval == USB_SUCCESS);
		hubd->h_dev_state = USB_DEV_ONLINE;
		hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
		hubpm->hubp_time_at_full_power = ddi_get_time();
		hubd_start_polling(hubd, 0);

		/* FALLTHRU */
	case USB_DEV_ONLINE:
		/* we are already in full power */

		/* FALLTHRU */
	case USB_DEV_DISCONNECTED:
	case USB_DEV_SUSPENDED:
		/*
		 * PM framework tries to put you in full power
		 * during system shutdown. If we are disconnected
		 * return success. Also, we should not change state
		 * when we are disconnected or suspended or about to
		 * transition to that state
		 */

		return (USB_SUCCESS);
	default:
		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
		    "hubd_pwrlvl3: Illegal dev_state=%d", hubd->h_dev_state);

		return (USB_FAILURE);
	}
}


/* power entry point */
/* ARGSUSED */
int
usba_hubdi_power(dev_info_t *dip, int comp, int level)
{
	hubd_t		*hubd;
	hub_power_t	*hubpm;
	int		retval;
	int		circ;

	hubd = hubd_get_soft_state(dip);
	USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
	    "usba_hubdi_power: level=%d", level);

	ndi_devi_enter(dip, &circ);

	mutex_enter(HUBD_MUTEX(hubd));
	hubpm = hubd->h_hubpm;

	/* check if we are transitioning to a legal power level */
	if (USB_DEV_PWRSTATE_OK(hubpm->hubp_pwr_states, level)) {
		USB_DPRINTF_L2(DPRINT_MASK_HUBDI, hubd->h_log_handle,
		    "usba_hubdi_power: illegal power level=%d "
		    "hubp_pwr_states=0x%x", level, hubpm->hubp_pwr_states);
		mutex_exit(HUBD_MUTEX(hubd));

		ndi_devi_exit(dip, circ);

		return (DDI_FAILURE);
	}

	switch (level) {
	case USB_DEV_OS_PWR_OFF:
		retval = hubd_pwrlvl0(hubd);

		break;
	case USB_DEV_OS_PWR_1:
		retval = hubd_pwrlvl1(hubd);

		break;
	case USB_DEV_OS_PWR_2:
		retval = hubd_pwrlvl2(hubd);

		break;
	case USB_DEV_OS_FULL_PWR:
		retval = hubd_pwrlvl3(hubd);

		break;
	}
	mutex_exit(HUBD_MUTEX(hubd));

	ndi_devi_exit(dip, circ);

	return ((retval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
}


/* power entry point for the root hub */
int
usba_hubdi_root_hub_power(dev_info_t *dip, int comp, int level)
{
	return (usba_hubdi_power(dip, comp, level));
}


/*
 * standard driver entry points support code
 */
int
usba_hubdi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int			instance = ddi_get_instance(dip);
	hubd_t			*hubd = NULL;
	int			i, rval;
	int			minor;
	char			*log_name = NULL;
	const char		*root_hub_drvname;
	usb_ep_data_t		*ep_data;
	usba_device_t		*child_ud = NULL;
	usb_dev_descr_t		*usb_dev_descr;
	usb_port_status_t	parent_port_status, child_port_status;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubdi_log_handle,
		"hubd_attach instance %d, cmd=0x%x", instance, cmd);

	switch (cmd) {
	case DDI_ATTACH:

		break;
	case DDI_RESUME:
		hubd_cpr_resume(dip);

		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}

	/*
	 * Allocate softc information.
	 */
	if (usba_is_root_hub(dip)) {
		/* soft state has already been allocated */
		hubd = hubd_get_soft_state(dip);
		minor = HUBD_IS_ROOT_HUB;

		/* generate readable labels for different root hubs */
		root_hub_drvname = ddi_driver_name(dip);
		if (strcmp(root_hub_drvname, "ehci") == 0) {
			log_name = "eusb";
		} else if (strcmp(root_hub_drvname, "uhci") == 0) {
			log_name = "uusb";
		} else {
			/* std. for ohci */
			log_name = "usb";
		}
	} else {
		rval = ddi_soft_state_zalloc(hubd_statep, instance);
		minor = 0;

		if (rval != DDI_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
			    "cannot allocate soft state (%d)", instance);
			goto fail;
		}

		hubd = hubd_get_soft_state(dip);
		if (hubd == NULL) {
			goto fail;
		}
	}

	hubd->h_log_handle = usb_alloc_log_hdl(dip, log_name, &hubd_errlevel,
				&hubd_errmask, &hubd_instance_debug, 0);

	hubd->h_usba_device	= child_ud = usba_get_usba_device(dip);
	hubd->h_dip		= dip;
	hubd->h_instance	= instance;

	mutex_enter(&child_ud->usb_mutex);
	child_port_status = child_ud->usb_port_status;
	usb_dev_descr = child_ud->usb_dev_descr;
	parent_port_status = (child_ud->usb_hs_hub_usba_dev) ?
	    child_ud->usb_hs_hub_usba_dev->usb_port_status : 0;
	mutex_exit(&child_ud->usb_mutex);

	if ((child_port_status == USBA_FULL_SPEED_DEV) &&
	    (parent_port_status == USBA_HIGH_SPEED_DEV) &&
	    (usb_dev_descr->bcdUSB == 0x100)) {
		USB_DPRINTF_L0(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "Use of a USB1.0 hub behind a high speed port may "
		    "cause unexpected failures");
	}

	hubd->h_pipe_policy.pp_max_async_reqs = 1;

	/* register with USBA as client driver */
	if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "client attach failed");

		goto fail;
	}

	if (usb_get_dev_data(dip, &hubd->h_dev_data,
	    USB_PARSE_LVL_IF, 0) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "cannot get dev_data");

		goto fail;
	}

	if ((ep_data = usb_lookup_ep_data(dip, hubd->h_dev_data,
	    hubd->h_dev_data->dev_curr_if, 0, 0,
	    (uint_t)USB_EP_ATTR_INTR, (uint_t)USB_EP_DIR_IN)) == NULL) {
		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "no interrupt IN endpoint found");

		goto fail;
	}

	hubd->h_ep1_descr = ep_data->ep_descr;
	hubd->h_default_pipe = hubd->h_dev_data->dev_default_ph;

	mutex_init(HUBD_MUTEX(hubd), NULL, MUTEX_DRIVER,
				hubd->h_dev_data->dev_iblock_cookie);
	cv_init(&hubd->h_cv_reset_port, NULL, CV_DRIVER, NULL);

	hubd->h_init_state |= HUBD_LOCKS_DONE;

	usb_free_descr_tree(dip, hubd->h_dev_data);

	/*
	 * register this hub instance with usba
	 */
	rval = usba_hubdi_register(dip, 0);
	if (rval != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "usba_hubdi_register failed");
		goto fail;
	}

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_init_state |= HUBD_HUBDI_REGISTERED;
	hubd->h_dev_state = USB_DEV_ONLINE;
	mutex_exit(HUBD_MUTEX(hubd));

	/* now create components to power manage this device */
	hubd_create_pm_components(dip, hubd);

	/*
	 * Event handling: definition and registration
	 *
	 * first the  definition:
	 * get event handle
	 */
	(void) ndi_event_alloc_hdl(dip, 0, &hubd->h_ndi_event_hdl, NDI_SLEEP);

	/* bind event set to the handle */
	if (ndi_event_bind_set(hubd->h_ndi_event_hdl, &hubd_ndi_events,
	    NDI_SLEEP)) {
		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "binding event set failed");

		goto fail;
	}

	/* event registration */
	if (hubd_register_events(hubd) != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "hubd_register_events failed");

		goto fail;
	}

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_init_state |= HUBD_EVENTS_REGISTERED;

	/* initialize and create children */
	if (hubd_check_ports(hubd) != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "hubd_check_ports failed");
		mutex_exit(HUBD_MUTEX(hubd));

		goto fail;
	}

	/*
	 * create cfgadm nodes
	 */
	hubd->h_ancestry_str = (char *)kmem_zalloc(HUBD_APID_NAMELEN, KM_SLEEP);
	hubd_get_ancestry_str(hubd);

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "#ports=0x%x", hubd->h_hub_descr.bNbrPorts);

	for (i = 1; i <= hubd->h_hub_descr.bNbrPorts; i++) {
		char ap_name[HUBD_APID_NAMELEN];

		(void) snprintf(ap_name, HUBD_APID_NAMELEN, "%s%d",
		    hubd->h_ancestry_str, i);
		USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "ap_name=%s", ap_name);

		if (ddi_create_minor_node(dip, ap_name, S_IFCHR, instance,
		    DDI_NT_USB_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
			USB_DPRINTF_L1(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "cannot create attachment point node (%d)",
			    instance);
			mutex_exit(HUBD_MUTEX(hubd));

			goto fail;
		}
	}
	mutex_exit(HUBD_MUTEX(hubd));

	/* create minor nodes */
	if (ddi_create_minor_node(dip, "hubd", S_IFCHR,
	    instance | minor, DDI_NT_NEXUS, 0) != DDI_SUCCESS) {

		USB_DPRINTF_L1(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "cannot create devctl minor node (%d)", instance);

		goto fail;
	}

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_init_state |= HUBD_MINOR_NODE_CREATED;
	mutex_exit(HUBD_MUTEX(hubd));

	/*
	 * host controller driver has already reported this dev
	 * if we are the root hub
	 */
	if (!usba_is_root_hub(dip)) {
		ddi_report_dev(dip);
	}

	/* enable deathrow thread */
	hubd->h_cleanup_enabled = B_TRUE;
	mutex_enter(HUBD_MUTEX(hubd));
	hubd_pm_idle_component(hubd, dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	return (DDI_SUCCESS);

fail:
	{
		char *pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP);

		USB_DPRINTF_L0(DPRINT_MASK_ATTA, hubdi_log_handle,
		    "cannot attach %s", ddi_pathname(dip, pathname));

		kmem_free(pathname, MAXPATHLEN);
	}

	mutex_enter(HUBD_MUTEX(hubd));
	hubd_pm_idle_component(hubd, dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	if (hubd) {
		rval = hubd_cleanup(dip, hubd);
		if (rval != USB_SUCCESS) {
			USB_DPRINTF_L1(DPRINT_MASK_ATTA, hubdi_log_handle,
			    "failure to complete cleanup after attach failure");
		}
	}

	return (DDI_FAILURE);
}


int
usba_hubdi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	hubd_t	*hubd = hubd_get_soft_state(dip);
	int	rval;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_detach: cmd=0x%x", cmd);

	switch (cmd) {
	case DDI_DETACH:
		rval = hubd_cleanup(dip, hubd);

		return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
	case DDI_SUSPEND:
		rval = hubd_cpr_suspend(hubd);

		return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
	default:
		return (DDI_FAILURE);
	}
}


/*
 * hubd_setdevaddr
 *	set the device addrs on this port
 */
static int
hubd_setdevaddr(hubd_t *hubd, usb_port_t port)
{
	int		rval;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;
	usb_pipe_handle_t ph;
	dev_info_t	*child_dip = NULL;
	uchar_t		address = 0;
	usba_device_t	*usba_device;
	int		retry = 0;
	long		time_delay;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_setdevaddr: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	child_dip = hubd->h_children_dips[port];
	address = hubd->h_usba_devices[port]->usb_addr;
	usba_device = hubd->h_usba_devices[port];

	/* close the default pipe with addr x */
	mutex_exit(HUBD_MUTEX(hubd));
	ph = usba_get_dflt_pipe_handle(child_dip);
	usb_pipe_close(child_dip, ph,
	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
	mutex_enter(HUBD_MUTEX(hubd));

	/*
	 * As this device has been reset, temporarily
	 * assign the default address
	 */
	mutex_enter(&usba_device->usb_mutex);
	address = usba_device->usb_addr;
	usba_device->usb_addr = USBA_DEFAULT_ADDR;
	mutex_exit(&usba_device->usb_mutex);

	mutex_exit(HUBD_MUTEX(hubd));

	time_delay = drv_usectohz(hubd_device_delay / 20);
	for (retry = 0; retry < hubd_retry_enumerate; retry++) {

		/* open child's default pipe with USBA_DEFAULT_ADDR */
		if (usb_pipe_open(child_dip, NULL, NULL,
		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph) !=
		    USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "hubd_setdevaddr: Unable to open default pipe");

			break;
		}

		/* Set the address of the device */
		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
		    USB_DEV_REQ_HOST_TO_DEV,
		    USB_REQ_SET_ADDRESS,	/* bRequest */
		    address,			/* wValue */
		    0,				/* wIndex */
		    0,				/* wLength */
		    NULL, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "hubd_setdevaddr(%d): rval=%d cr=%d cb_fl=0x%x",
			    retry, rval, completion_reason, cb_flags);
		}

		usb_pipe_close(child_dip, ph,
		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);

		if (rval == USB_SUCCESS) {

			break;
		}

		delay(time_delay);
	}

	/* Reset to the old address */
	mutex_enter(&usba_device->usb_mutex);
	usba_device->usb_addr = address;
	mutex_exit(&usba_device->usb_mutex);
	mutex_enter(HUBD_MUTEX(hubd));

	usba_clear_data_toggle(usba_device);

	return (rval);
}


/*
 * hubd_setdevconfig
 *	set the device addrs on this port
 */
static void
hubd_setdevconfig(hubd_t *hubd, usb_port_t port)
{
	int			rval;
	usb_cr_t		completion_reason;
	usb_cb_flags_t		cb_flags;
	usb_pipe_handle_t	ph;
	dev_info_t		*child_dip = NULL;
	usba_device_t		*usba_device = NULL;
	uint16_t		config_value;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_setdevconfig: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	child_dip = hubd->h_children_dips[port];
	usba_device = hubd->h_usba_devices[port];
	config_value = hubd->h_usba_devices[port]->usb_cfg_value;
	mutex_exit(HUBD_MUTEX(hubd));

	/* open the default control pipe */
	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) ==
	    USB_SUCCESS) {

		/* Set the default configuration of the device */
		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
		    USB_DEV_REQ_HOST_TO_DEV,
		    USB_REQ_SET_CFG,		/* bRequest */
		    config_value,		/* wValue */
		    0,				/* wIndex */
		    0,				/* wLength */
		    NULL, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "hubd_setdevconfig: set device config failed: "
			    "cr=%d cb_fl=0x%x rval=%d",
			    completion_reason, cb_flags, rval);
		}
		/*
		 * After setting the configuration, we make this default
		 * control pipe persistent, so that it gets re-opened
		 * on posting a connect event
		 */
		usba_persistent_pipe_close(usba_device);
	} else {
		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "pipe open fails: rval=%d", rval);
	}
	mutex_enter(HUBD_MUTEX(hubd));
}


/*ARGSUSED*/
static int
hubd_check_disconnected_ports(dev_info_t *dip, void *arg)
{
	int circ;
	usb_port_t port;
	hubd_t *hubd;
	major_t hub_major = ddi_name_to_major("hubd");

	/*
	 * make sure dip is a usb hub, major of root hub is HCD
	 * major
	 */
	if (!usba_is_root_hub(dip)) {
		if ((ddi_driver_major(dip) != hub_major) ||
		    (i_ddi_node_state(dip) < DS_ATTACHED)) {

			return (DDI_WALK_PRUNECHILD);
		}
	}

	hubd = hubd_get_soft_state(dip);
	if (hubd == NULL) {

		return (DDI_WALK_PRUNECHILD);
	}

	/* walk child list and remove nodes with flag DEVI_DEVICE_REMOVED */
	ndi_devi_enter(dip, &circ);

	mutex_enter(HUBD_MUTEX(hubd));
	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		dev_info_t *cdip = hubd->h_children_dips[port];

		if (cdip == NULL || DEVI_IS_DEVICE_REMOVED(cdip) == 0) {

			continue;
		}

		(void) hubd_delete_child(hubd, port, NDI_DEVI_REMOVE, B_TRUE);
	}
	mutex_exit(HUBD_MUTEX(hubd));
	ndi_devi_exit(dip, circ);

	/* skip siblings of root hub */
	if (usba_is_root_hub(dip)) {

		return (DDI_WALK_PRUNESIB);
	}

	return (DDI_WALK_CONTINUE);
}


/*
 * this thread will walk all children under the root hub for this
 * USB bus instance and attempt to remove them
 */
static void
hubd_root_hub_cleanup_thread(void *arg)
{
	int circ;
	hubd_t *root_hubd = (hubd_t *)arg;
	dev_info_t *rh_dip = root_hubd->h_dip;
#ifndef __lock_lint
	callb_cpr_t cprinfo;

	CALLB_CPR_INIT(&cprinfo, HUBD_MUTEX(root_hubd), callb_generic_cpr,
	    "USB root hub");
#endif

	for (;;) {
		/* don't race with detach */
		ndi_hold_devi(rh_dip);

		mutex_enter(HUBD_MUTEX(root_hubd));
		root_hubd->h_cleanup_needed = 0;
		mutex_exit(HUBD_MUTEX(root_hubd));

		(void) devfs_clean(rh_dip, NULL, 0);

		ndi_devi_enter(ddi_get_parent(rh_dip), &circ);
		ddi_walk_devs(rh_dip, hubd_check_disconnected_ports,
							NULL);
#ifdef __lock_lint
		(void) hubd_check_disconnected_ports(rh_dip, NULL);
#endif
		ndi_devi_exit(ddi_get_parent(rh_dip), circ);

		/* quit if we are not enabled anymore */
		mutex_enter(HUBD_MUTEX(root_hubd));
		if ((root_hubd->h_cleanup_enabled == B_FALSE) ||
		    (root_hubd->h_cleanup_needed == B_FALSE)) {
			root_hubd->h_cleanup_active = B_FALSE;
			mutex_exit(HUBD_MUTEX(root_hubd));
			ndi_rele_devi(rh_dip);

			break;
		}
		mutex_exit(HUBD_MUTEX(root_hubd));
		ndi_rele_devi(rh_dip);

#ifndef __lock_lint
		mutex_enter(HUBD_MUTEX(root_hubd));
		CALLB_CPR_SAFE_BEGIN(&cprinfo);
		mutex_exit(HUBD_MUTEX(root_hubd));

		delay(drv_usectohz(hubd_dip_cleanup_delay));

		mutex_enter(HUBD_MUTEX(root_hubd));
		CALLB_CPR_SAFE_END(&cprinfo, HUBD_MUTEX(root_hubd));
		mutex_exit(HUBD_MUTEX(root_hubd));
#endif
	}

#ifndef __lock_lint
	mutex_enter(HUBD_MUTEX(root_hubd));
	CALLB_CPR_EXIT(&cprinfo);
#endif
}


static void
hubd_schedule_cleanup(dev_info_t *rh_dip)
{
	hubd_t	*root_hubd = (hubd_t *)hubd_get_soft_state(rh_dip);

	mutex_enter(HUBD_MUTEX(root_hubd));
	root_hubd->h_cleanup_needed = B_TRUE;
	if (root_hubd->h_cleanup_enabled && !(root_hubd->h_cleanup_active)) {
		root_hubd->h_cleanup_active = B_TRUE;
		mutex_exit(HUBD_MUTEX(root_hubd));
		(void) thread_create(NULL, 0,
		    hubd_root_hub_cleanup_thread,
		    (void *)root_hubd, 0, &p0, TS_RUN,
		    minclsyspri);
	} else {
		mutex_exit(HUBD_MUTEX(root_hubd));
	}
}


/*
 * hubd_restore_device_state:
 *	- set config for the hub
 *	- power cycle all the ports
 *	- for each port that was connected
 *		- reset port
 *		- assign addrs to the device on this port
 *	- restart polling
 *	- reset suspend flag
 */
static void
hubd_restore_device_state(dev_info_t *dip, hubd_t *hubd)
{
	int		rval;
	int		retry;
	uint_t		hub_prev_state;
	usb_port_t	port;
	uint16_t	status;
	uint16_t	change;
	dev_info_t	*ch_dip;
	boolean_t	ehci_root_hub;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_restore_device_state:");

	mutex_enter(HUBD_MUTEX(hubd));
	hub_prev_state = hubd->h_dev_state;
	ASSERT(hub_prev_state != USB_DEV_PWRED_DOWN);

	/* First bring the device to full power */
	(void) hubd_pm_busy_component(hubd, dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

	if (!usba_is_root_hub(dip) &&
	    (usb_check_same_device(dip, hubd->h_log_handle, USB_LOG_L0,
	    DPRINT_MASK_HOTPLUG,
	    USB_CHK_BASIC|USB_CHK_CFG, NULL) != USB_SUCCESS)) {

		/* change the device state to disconnected */
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_dev_state = USB_DEV_DISCONNECTED;
		(void) hubd_pm_idle_component(hubd, dip, 0);
		mutex_exit(HUBD_MUTEX(hubd));

		return;
	}

	ehci_root_hub = (strcmp(ddi_driver_name(dip), "ehci") == 0);

	mutex_enter(HUBD_MUTEX(hubd));
	/* First turn off all port power */
	rval = hubd_disable_all_port_power(hubd);
	if (rval != USB_SUCCESS) {
		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "hubd_restore_device_state:"
		    "turning off port power failed");
	}

	/* Settling time before turning on again */
	mutex_exit(HUBD_MUTEX(hubd));
	delay(drv_usectohz(hubd_device_delay / 100));
	mutex_enter(HUBD_MUTEX(hubd));

	/* enable power on all ports so we can see connects */
	if (hubd_enable_all_port_power(hubd) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "hubd_restore_device_state: turn on port power failed");

		/* disable whatever was enabled */
		(void) hubd_disable_all_port_power(hubd);

		(void) hubd_pm_idle_component(hubd, dip, 0);
		mutex_exit(HUBD_MUTEX(hubd));

		return;
	}

	/*
	 * wait at least 3 frames before accessing devices
	 * (note that delay's minimal time is one clock tick which
	 * is 10ms unless hires_tick has been changed)
	 */
	mutex_exit(HUBD_MUTEX(hubd));
	delay(drv_usectohz(10000));
	mutex_enter(HUBD_MUTEX(hubd));

	hubd->h_dev_state = USB_DEV_HUB_STATE_RECOVER;

	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "hubd_restore_device_state: port=%d", port);

		/*
		 * the childen_dips list may have dips that have been
		 * already deallocated. we only get a post_detach notification
		 * but not a destroy notification
		 */
		ch_dip = hubd->h_children_dips[port];
		if (ch_dip) {
			/* get port status */
			(void) hubd_determine_port_status(hubd, port,
			    &status, &change, PORT_CHANGE_CSC);

			/* check if it is truly connected */
			if (status & PORT_STATUS_CCS) {
				/*
				 * Now reset port and assign the device
				 * its original address
				 */
				retry = 0;
				do {
					(void) hubd_reset_port(hubd, port);

					/* required for ppx */
					(void) hubd_enable_port(hubd, port);

					if (retry) {
						mutex_exit(HUBD_MUTEX(hubd));
						delay(drv_usectohz(
							hubd_device_delay/2));
						mutex_enter(HUBD_MUTEX(hubd));
					}

					rval = hubd_setdevaddr(hubd, port);
					retry++;
				} while ((rval != USB_SUCCESS) &&
				    (retry < hubd_retry_enumerate));

				hubd_setdevconfig(hubd, port);

				if (hub_prev_state == USB_DEV_DISCONNECTED) {
					/* post a connect event */
					mutex_exit(HUBD_MUTEX(hubd));
					hubd_post_event(hubd, port,
					    USBA_EVENT_TAG_HOT_INSERTION);
					mutex_enter(HUBD_MUTEX(hubd));
				} else {
					/*
					 * Since we have this device connected
					 * mark it reinserted to prevent
					 * cleanup thread from stepping in.
					 */
					DEVI_SET_DEVICE_REINSERTED(ch_dip);
					mutex_exit(HUBD_MUTEX(hubd));

					/*
					 * reopen pipes for children for
					 * their DDI_RESUME
					 */
					rval = usba_persistent_pipe_open(
					    usba_get_usba_device(ch_dip));
					mutex_enter(HUBD_MUTEX(hubd));
					ASSERT(rval == USB_SUCCESS);
				}
			} else {
				/*
				 * Mark this dip for deletion as the device
				 * is not physically present, and schedule
				 * cleanup thread upon post resume
				 */
				mutex_exit(HUBD_MUTEX(hubd));

				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
				    hubd->h_log_handle,
				    "hubd_restore_device_state: "
				    "dip=%p on port=%d marked for cleanup",
				    ch_dip, port);
				DEVI_SET_DEVICE_REMOVED(ch_dip);

				mutex_enter(HUBD_MUTEX(hubd));
			}
		} else if (ehci_root_hub) {
			/* get port status */
			(void) hubd_determine_port_status(hubd, port,
			    &status, &change, PORT_CHANGE_CSC);

			/* check if it is truly connected */
			if (status & PORT_STATUS_CCS) {
				/*
				 * reset the port to find out if we have
				 * 2.0 device connected or 1.X. A 2.0
				 * device will still be seen as connected,
				 * while a 1.X device will switch over to
				 * the companion controller.
				 */
				(void) hubd_reset_port(hubd, port);

				(void) hubd_determine_port_status(hubd, port,
				    &status, &change, PORT_CHANGE_CSC);

				if (status &
				    (PORT_STATUS_CCS | PORT_STATUS_HSDA)) {
					/*
					 * We have a USB 2.0 device
					 * connected. Power cycle this port
					 * so that hotplug thread can
					 * enumerate this device.
					 */
					(void) hubd_toggle_port(hubd, port);
				} else {
					USB_DPRINTF_L2(DPRINT_MASK_ATTA,
					    hubd->h_log_handle,
					    "hubd_restore_device_state: "
					    "device on port %d switched over",
					    port);
				}
			}

		}
	}


	/* if the device had remote wakeup earlier, enable it again */
	if (hubd->h_hubpm->hubp_wakeup_enabled) {
		mutex_exit(HUBD_MUTEX(hubd));
		(void) usb_handle_remote_wakeup(hubd->h_dip,
		    USB_REMOTE_WAKEUP_ENABLE);
		mutex_enter(HUBD_MUTEX(hubd));
	}

	hubd->h_dev_state = USB_DEV_ONLINE;
	hubd_start_polling(hubd, 0);
	(void) hubd_pm_idle_component(hubd, dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));
}


/*
 * hubd_cleanup:
 *	cleanup hubd and deallocate. this function is called for
 *	handling attach failures and detaching including dynamic
 *	reconfiguration. If called from attaching, it must clean
 *	up the whole thing and return success.
 */
/*ARGSUSED*/
static int
hubd_cleanup(dev_info_t *dip, hubd_t *hubd)
{
	int		circ, rval, old_dev_state;
	hub_power_t	*hubpm;
#ifdef DEBUG
	usb_port_t	port;
#endif

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_cleanup:");

	if ((hubd->h_init_state & HUBD_LOCKS_DONE) == 0) {
		goto done;
	}

	/* ensure we are the only one active */
	ndi_devi_enter(dip, &circ);

	mutex_enter(HUBD_MUTEX(hubd));

	/* Cleanup failure is only allowed if called from detach */
	if (DEVI_IS_DETACHING(dip)) {
		dev_info_t *rh_dip = hubd->h_usba_device->usb_root_hub_dip;

		/*
		 * We are being called from detach.
		 * Fail immediately if the hotplug thread is running
		 * else set the dev_state to disconnected so that
		 * hotplug thread just exits without doing anything.
		 */
		if (hubd->h_bus_ctls || hubd->h_bus_pwr ||
		    hubd->h_hotplug_thread) {
			mutex_exit(HUBD_MUTEX(hubd));
			ndi_devi_exit(dip, circ);

			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "hubd_cleanup: hotplug thread/bus ctl active "
			    "- failing detach");

			return (USB_FAILURE);
		}

		/*
		 * if the deathrow thread is still active or about
		 * to become active, fail detach
		 * the roothup can only be detached if nexus drivers
		 * are unloaded or explicitly offlined
		 */
		if (rh_dip == dip) {
			if (hubd->h_cleanup_needed ||
			    hubd->h_cleanup_active) {
				mutex_exit(HUBD_MUTEX(hubd));
				ndi_devi_exit(dip, circ);

				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
				    hubd->h_log_handle,
				    "hubd_cleanup: deathrow still active?"
				    "- failing detach");

				return (USB_FAILURE);
			}
		}
	}

	old_dev_state = hubd->h_dev_state;
	hubd->h_dev_state = USB_DEV_DISCONNECTED;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_cleanup: stop polling");
	hubd_close_intr_pipe(hubd);

	ASSERT((hubd->h_bus_ctls || hubd->h_bus_pwr ||
	    hubd->h_hotplug_thread) == 0);
	mutex_exit(HUBD_MUTEX(hubd));

	/*
	 * deallocate events, if events are still registered
	 * (ie. children still attached) then we have to fail the detach
	 */
	if (hubd->h_ndi_event_hdl) {

		rval = ndi_event_free_hdl(hubd->h_ndi_event_hdl);
		if (DEVI_IS_ATTACHING(dip)) {

			/* It must return success if attaching. */
			ASSERT(rval == NDI_SUCCESS);

		} else if (rval != NDI_SUCCESS) {

			USB_DPRINTF_L1(DPRINT_MASK_ALL, hubd->h_log_handle,
			    "hubd_cleanup: ndi_event_free_hdl failed");
			ndi_devi_exit(dip, circ);

			return (USB_FAILURE);

		}
	}

	mutex_enter(HUBD_MUTEX(hubd));

#ifdef DEBUG
	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		ASSERT(hubd->h_usba_devices[port] == NULL);
		ASSERT(hubd->h_children_dips[port] == NULL);
	}
#endif
	kmem_free(hubd->h_children_dips, hubd->h_cd_list_length);
	kmem_free(hubd->h_usba_devices, hubd->h_cd_list_length);

	/*
	 * Disable the event callbacks first, after this point, event
	 * callbacks will never get called. Note we shouldn't hold
	 * mutex while unregistering events because there may be a
	 * competing event callback thread. Event callbacks are done
	 * with ndi mutex held and this can cause a potential deadlock.
	 * Note that cleanup can't fail after deregistration of events.
	 */
	if (hubd->h_init_state &  HUBD_EVENTS_REGISTERED) {
		mutex_exit(HUBD_MUTEX(hubd));
		usb_unregister_event_cbs(dip, &hubd_events);
		hubd_unregister_cpr_callback(hubd);
		mutex_enter(HUBD_MUTEX(hubd));
	}

	/* restore the old dev state so that device can be put into low power */
	hubd->h_dev_state = old_dev_state;
	hubpm = hubd->h_hubpm;

	if ((hubpm) && (hubd->h_dev_state != USB_DEV_DISCONNECTED)) {
		(void) hubd_pm_busy_component(hubd, dip, 0);
		mutex_exit(HUBD_MUTEX(hubd));
		if (hubd->h_hubpm->hubp_wakeup_enabled) {
			/*
			 * Bring the hub to full power before
			 * issuing the disable remote wakeup command
			 */
			(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

			if ((rval = usb_handle_remote_wakeup(hubd->h_dip,
			    USB_REMOTE_WAKEUP_DISABLE)) != USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PM,
				    hubd->h_log_handle,
				    "hubd_cleanup: disable remote wakeup "
				    "fails=%d", rval);
			}
		}

		(void) pm_lower_power(hubd->h_dip, 0, USB_DEV_OS_PWR_OFF);

		mutex_enter(HUBD_MUTEX(hubd));
		(void) hubd_pm_idle_component(hubd, dip, 0);
	}

	if (hubpm) {
		if (hubpm->hubp_child_pwrstate) {
			kmem_free(hubpm->hubp_child_pwrstate,
			    MAX_PORTS + 1);
		}
		kmem_free(hubpm, sizeof (hub_power_t));
	}
	mutex_exit(HUBD_MUTEX(hubd));

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_cleanup: freeing space");

	if (hubd->h_init_state & HUBD_HUBDI_REGISTERED) {
		rval = usba_hubdi_unregister(dip);
		ASSERT(rval == USB_SUCCESS);
	}

	if (hubd->h_init_state & HUBD_LOCKS_DONE) {
		mutex_destroy(HUBD_MUTEX(hubd));
		cv_destroy(&hubd->h_cv_reset_port);
	}

	ndi_devi_exit(dip, circ);

	if (hubd->h_init_state & HUBD_MINOR_NODE_CREATED) {
		ddi_remove_minor_node(dip, NULL);
	}

	if (usba_is_root_hub(dip)) {
		usb_pipe_close(dip, hubd->h_default_pipe,
		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
	}

done:
	if (hubd->h_ancestry_str) {
		kmem_free(hubd->h_ancestry_str, HUBD_APID_NAMELEN);
	}

	usb_client_detach(dip, hubd->h_dev_data);

	usb_free_log_hdl(hubd->h_log_handle);

	if (!usba_is_root_hub(dip)) {
		ddi_soft_state_free(hubd_statep, ddi_get_instance(dip));
	}

	ddi_prop_remove_all(dip);

	return (USB_SUCCESS);
}


/*
 * hubd_check_ports:
 *	- get hub descriptor
 *	- check initial port status
 *	- enable power on all ports
 *	- enable polling on ep1
 */
static int
hubd_check_ports(hubd_t  *hubd)
{
	int	rval;

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_check_ports: addr=0x%x", usb_get_addr(hubd->h_dip));

	if ((rval = hubd_get_hub_descriptor(hubd)) != USB_SUCCESS) {

		return (rval);
	}

	/*
	 * First turn off all port power
	 */
	if ((rval = hubd_disable_all_port_power(hubd)) != USB_SUCCESS) {

		/* disable whatever was enabled */
		(void) hubd_disable_all_port_power(hubd);

		return (rval);
	}

	/*
	 * do not switch on immediately (instantly on root hub)
	 * and allow time to settle
	 */
	mutex_exit(HUBD_MUTEX(hubd));
	delay(drv_usectohz(10000));
	mutex_enter(HUBD_MUTEX(hubd));

	/*
	 * enable power on all ports so we can see connects
	 */
	if ((rval = hubd_enable_all_port_power(hubd)) != USB_SUCCESS) {
		/* disable whatever was enabled */
		(void) hubd_disable_all_port_power(hubd);

		return (rval);
	}

	/* wait at least 3 frames before accessing devices */
	mutex_exit(HUBD_MUTEX(hubd));
	delay(drv_usectohz(10000));
	mutex_enter(HUBD_MUTEX(hubd));

	/*
	 * allocate arrays for saving the dips of each child per port
	 *
	 * ports go from 1 - n, allocate 1 more entry
	 */
	hubd->h_cd_list_length =
		(sizeof (dev_info_t **)) * (hubd->h_hub_descr.bNbrPorts + 1);

	hubd->h_children_dips = (dev_info_t **)kmem_zalloc(
			hubd->h_cd_list_length, KM_SLEEP);
	hubd->h_usba_devices = (usba_device_t **)kmem_zalloc(
			hubd->h_cd_list_length, KM_SLEEP);

	if ((rval = hubd_open_intr_pipe(hubd)) == USB_SUCCESS) {
		hubd_start_polling(hubd, 0);
	}

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_check_ports done");

	return (rval);
}


/*
 * hubd_get_hub_descriptor:
 */
static int
hubd_get_hub_descriptor(hubd_t *hubd)
{
	usb_hub_descr_t	*hub_descr = &hubd->h_hub_descr;
	mblk_t		*data = NULL;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;
	uint16_t	length;
	int		rval;

	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
	    "hubd_get_hub_descriptor:");

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
	ASSERT(hubd->h_default_pipe != 0);

	/* get hub descriptor length first by requesting 8 bytes only */
	mutex_exit(HUBD_MUTEX(hubd));

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    HUB_CLASS_REQ,
	    USB_REQ_GET_DESCR,		/* bRequest */
	    USB_DESCR_TYPE_SETUP_HUB,	/* wValue */
	    0,				/* wIndex */
	    8,				/* wLength */
	    &data, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "get hub descriptor failed: cr=%d cb_fl=0x%x rval=%d",
		    completion_reason, cb_flags, rval);
		freemsg(data);
		mutex_enter(HUBD_MUTEX(hubd));

		return (rval);
	}

	length = *(data->b_rptr);

	if (length > 8) {
		freemsg(data);
		data = NULL;

		/* get complete hub descriptor */
		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
		    hubd->h_default_pipe,
		    HUB_CLASS_REQ,
		    USB_REQ_GET_DESCR,		/* bRequest */
		    USB_DESCR_TYPE_SETUP_HUB,	/* wValue */
		    0,				/* wIndex */
		    length,			/* wLength */
		    &data, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "get hub descriptor failed: "
			    "cr=%d cb_fl=0x%x rval=%d",
			    completion_reason, cb_flags, rval);
			freemsg(data);
			mutex_enter(HUBD_MUTEX(hubd));

			return (rval);
		}
	}

	mutex_enter(HUBD_MUTEX(hubd));

	/* parse the hub descriptor */
	/* only 32 ports are supported at present */
	ASSERT(*(data->b_rptr + 2) <= 32);
	if (usb_parse_CV_descr("cccscccccc",
	    data->b_rptr, data->b_wptr - data->b_rptr,
	    (void *)hub_descr, sizeof (usb_hub_descr_t)) == 0) {
		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "parsing hub descriptor failed");

		freemsg(data);

		return (USB_FAILURE);
	}

	freemsg(data);

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "rval = 0x%x bNbrPorts = 0x%x wHubChars = 0x%x "
	    "PwrOn2PwrGood = 0x%x", rval,
	    hub_descr->bNbrPorts, hub_descr->wHubCharacteristics,
	    hub_descr->bPwrOn2PwrGood);

	if (hub_descr->bNbrPorts > MAX_PORTS) {
		USB_DPRINTF_L0(DPRINT_MASK_ATTA, hubd->h_log_handle,
		    "Hub driver supports max of %d ports on hub. "
		    "Hence using the first %d port of %d ports available",
		    MAX_PORTS, MAX_PORTS, hub_descr->bNbrPorts);

		hub_descr->bNbrPorts = MAX_PORTS;
	}

	return (USB_SUCCESS);
}


/*
 * hubd_open_intr_pipe:
 *	we read all descriptors first for curiosity and then simply
 *	open the pipe
 */
static int
hubd_open_intr_pipe(hubd_t	*hubd)
{
	int			rval;

	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
	    "hubd_open_intr_pipe:");

	ASSERT(hubd->h_intr_pipe_state == HUBD_INTR_PIPE_IDLE);

	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_OPENING;
	mutex_exit(HUBD_MUTEX(hubd));

	if ((rval = usb_pipe_open(hubd->h_dip,
	    &hubd->h_ep1_descr, &hubd->h_pipe_policy,
	    0, &hubd->h_ep1_ph)) != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_HUB, hubd->h_log_handle,
		    "open intr pipe failed (%d)", rval);

		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_intr_pipe_state = HUBD_INTR_PIPE_IDLE;

		return (rval);
	}

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_ACTIVE;

	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
	    "open intr pipe succeeded, ph=0x%p", hubd->h_ep1_ph);

	return (USB_SUCCESS);
}


/*
 * hubd_start_polling:
 *	start or restart the polling
 */
static void
hubd_start_polling(hubd_t *hubd, int always)
{
	usb_intr_req_t	*reqp;
	int			rval;
	usb_pipe_state_t	pipe_state;

	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
	    "start polling: always=%d dev_state=%d pipe_state=%d\n\t"
	    "thread=%d ep1_ph=0x%p",
	    always, hubd->h_dev_state, hubd->h_intr_pipe_state,
	    hubd->h_hotplug_thread, hubd->h_ep1_ph);

	/*
	 * start or restart polling on the intr pipe
	 * only if hotplug thread is not running
	 */
	if ((always == HUBD_ALWAYS_START_POLLING) ||
	    ((hubd->h_dev_state == USB_DEV_ONLINE) &&
	    (hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE) &&
	    (hubd->h_hotplug_thread == 0) && hubd->h_ep1_ph)) {
		USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
		    "start polling requested");

		reqp = usb_alloc_intr_req(hubd->h_dip, 0, USB_FLAGS_SLEEP);

		reqp->intr_client_private = (usb_opaque_t)hubd;
		reqp->intr_attributes = USB_ATTRS_SHORT_XFER_OK |
					USB_ATTRS_AUTOCLEARING;
		reqp->intr_len = hubd->h_ep1_descr.wMaxPacketSize;
		reqp->intr_cb = hubd_read_cb;
		reqp->intr_exc_cb = hubd_exception_cb;
		mutex_exit(HUBD_MUTEX(hubd));
		if ((rval = usb_pipe_intr_xfer(hubd->h_ep1_ph, reqp,
		    USB_FLAGS_SLEEP)) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
			    "start polling failed, rval=%d", rval);
			usb_free_intr_req(reqp);
		}

		rval = usb_pipe_get_state(hubd->h_ep1_ph, &pipe_state,
			USB_FLAGS_SLEEP);
		if (pipe_state != USB_PIPE_STATE_ACTIVE) {
			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "intr pipe state=%d, rval=%d", pipe_state, rval);
		}
		USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
		    "start polling request 0x%p", reqp);

		mutex_enter(HUBD_MUTEX(hubd));
	}
}


/*
 * hubd_stop_polling
 *	stop polling but do not close the pipe
 */
static void
hubd_stop_polling(hubd_t *hubd)
{
	int			rval;
	usb_pipe_state_t	pipe_state;

	if (hubd->h_ep1_ph) {
		USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "hubd_stop_polling:");
		hubd->h_intr_pipe_state = HUBD_INTR_PIPE_STOPPED;
		mutex_exit(HUBD_MUTEX(hubd));

		usb_pipe_stop_intr_polling(hubd->h_ep1_ph, USB_FLAGS_SLEEP);
		rval = usb_pipe_get_state(hubd->h_ep1_ph, &pipe_state,
			USB_FLAGS_SLEEP);

		if (pipe_state != USB_PIPE_STATE_IDLE) {
			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "intr pipe state=%d, rval=%d", pipe_state, rval);
		}
		mutex_enter(HUBD_MUTEX(hubd));
		if (hubd->h_intr_pipe_state == HUBD_INTR_PIPE_STOPPED) {
			hubd->h_intr_pipe_state = HUBD_INTR_PIPE_ACTIVE;
		}
	}
}


/*
 * hubd_close_intr_pipe:
 *	close the pipe (which also stops the polling
 *	and wait for the hotplug thread to exit
 */
static void
hubd_close_intr_pipe(hubd_t *hubd)
{
	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
	    "hubd_close_intr_pipe:");

	/*
	 * Now that no async operation is outstanding on pipe,
	 * we can change the state to HUBD_INTR_PIPE_CLOSING
	 */
	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_CLOSING;

	ASSERT(hubd->h_hotplug_thread == 0);

	if (hubd->h_ep1_ph) {
		mutex_exit(HUBD_MUTEX(hubd));
		usb_pipe_close(hubd->h_dip, hubd->h_ep1_ph, USB_FLAGS_SLEEP,
							NULL, NULL);
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_ep1_ph = NULL;
	}

	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_IDLE;
}


/*
 * hubd_exception_cb
 *	interrupt ep1 exception callback function.
 *	this callback executes in taskq thread context and assumes
 *	autoclearing
 */
/*ARGSUSED*/
static void
hubd_exception_cb(usb_pipe_handle_t pipe, usb_intr_req_t *reqp)
{
	hubd_t		*hubd = (hubd_t *)(reqp->intr_client_private);

	USB_DPRINTF_L2(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
	    "hubd_exception_cb: "
	    "req=0x%p cr=%d data=0x%p cb_flags=0x%x", reqp,
	    reqp->intr_completion_reason, reqp->intr_data,
	    reqp->intr_cb_flags);

	ASSERT((reqp->intr_cb_flags & USB_CB_INTR_CONTEXT) == 0);

	mutex_enter(HUBD_MUTEX(hubd));
	(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);

	switch (reqp->intr_completion_reason) {
	case USB_CR_PIPE_RESET:
		/* only restart polling after autoclearing */
		if ((hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE) &&
		    (hubd->h_port_reset_wait == 0)) {
			hubd_start_polling(hubd, 0);
		}

		break;
	case USB_CR_DEV_NOT_RESP:
	case USB_CR_STOPPED_POLLING:
	case USB_CR_PIPE_CLOSING:
	case USB_CR_UNSPECIFIED_ERR:
		/* never restart polling on these conditions */
	default:
		/* for all others, wait for the autoclearing PIPE_RESET cb */

		break;
	}

	usb_free_intr_req(reqp);
	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));
}


/*
 * helper function to convert LE bytes to a portmask
 */
static usb_port_mask_t
hubd_mblk2portmask(mblk_t *data)
{
	int len = min(data->b_wptr - data->b_rptr, sizeof (usb_port_mask_t));
	usb_port_mask_t rval = 0;
	int i;

	for (i = 0; i < len; i++) {
		rval |= data->b_rptr[i] << (i * 8);
	}

	return (rval);
}


/*
 * hubd_read_cb:
 *	interrupt ep1 callback function
 *
 *	the status indicates just a change on the pipe with no indication
 *	of what the change was
 *
 *	known conditions:
 *		- reset port completion
 *		- connect
 *		- disconnect
 *
 *	for handling the hotplugging, create a new thread that can do
 *	synchronous usba calls
 */
static void
hubd_read_cb(usb_pipe_handle_t pipe, usb_intr_req_t *reqp)
{
	hubd_t		*hubd = (hubd_t *)(reqp->intr_client_private);
	size_t		length;
	mblk_t		*data = reqp->intr_data;

	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
	    "hubd_read_cb: ph=0x%p req=0x%p", pipe, reqp);

	ASSERT((reqp->intr_cb_flags & USB_CB_INTR_CONTEXT) == 0);

	/*
	 * At present, we are not handling notification for completion of
	 * asynchronous pipe reset, for which this data ptr could be NULL
	 */

	if (data == NULL) {
		usb_free_intr_req(reqp);

		return;
	}

	mutex_enter(HUBD_MUTEX(hubd));

	if ((hubd->h_dev_state == USB_DEV_SUSPENDED) ||
	    (hubd->h_intr_pipe_state != HUBD_INTR_PIPE_ACTIVE)) {
		mutex_exit(HUBD_MUTEX(hubd));
		usb_free_intr_req(reqp);

		return;
	}

	ASSERT(hubd->h_ep1_ph == pipe);

	length = data->b_wptr - data->b_rptr;

	/*
	 * Only look at the data and startup the hotplug thread if
	 * there actually is data.
	 */
	if (length != 0) {
		usb_port_mask_t port_change = hubd_mblk2portmask(data);

		/*
		 * if a port change was already reported and we are waiting for
		 * reset port completion then wake up the hotplug thread which
		 * should be waiting on reset port completion
		 *
		 * if there is disconnect event instead of reset completion, let
		 * the hotplug thread figure this out
		 */

		/* remove the reset wait bits from the status */
		hubd->h_port_change |= port_change &
						~hubd->h_port_reset_wait;

		USB_DPRINTF_L3(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
		    "port change=0x%x port_reset_wait=0x%x",
		    hubd->h_port_change, hubd->h_port_reset_wait);

		/* there should be only one reset bit active at the time */
		if (hubd->h_port_reset_wait & port_change) {
			hubd->h_port_reset_wait = 0;
			cv_signal(&hubd->h_cv_reset_port);
		}

		/*
		 * kick off the thread only if device is ONLINE and it is not
		 * during attaching or detaching
		 */
		if ((hubd->h_dev_state == USB_DEV_ONLINE) &&
		    (!DEVI_IS_ATTACHING(hubd->h_dip)) &&
		    (!DEVI_IS_DETACHING(hubd->h_dip)) &&
		    (hubd->h_port_change) &&
		    (hubd->h_hotplug_thread == 0)) {
			USB_DPRINTF_L3(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
			    "creating hotplug thread: "
			    "dev_state=%d", hubd->h_dev_state);

			/*
			 * Mark this device as busy. The will be marked idle
			 * if the async req fails or at the exit of  hotplug
			 * thread
			 */
			(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);

			if (usb_async_req(hubd->h_dip,
			    hubd_hotplug_thread,
			    (void *)hubd, 0) == USB_SUCCESS) {
				hubd->h_hotplug_thread++;
			} else {
				/* mark this device as idle */
				(void) hubd_pm_idle_component(hubd,
				    hubd->h_dip, 0);
			}
		}
	}
	mutex_exit(HUBD_MUTEX(hubd));

	usb_free_intr_req(reqp);
}


/*
 * hubd_hotplug_thread:
 *	handles resetting of port, and creating children
 *
 *	the ports to check are indicated in h_port_change bit mask
 * XXX note that one time poll doesn't work on the root hub
 */
static void
hubd_hotplug_thread(void *arg)
{
	hubd_t		*hubd = (hubd_t *)arg;
	usb_port_t	port;
	uint16_t	nports;
	uint16_t	status, change;
	hub_power_t	*hubpm;
	dev_info_t	*hdip = hubd->h_dip;
	dev_info_t	*rh_dip = hubd->h_usba_device->usb_root_hub_dip;
	boolean_t	online_child = B_FALSE;
	boolean_t	offline_child = B_FALSE;
	boolean_t	pwrup_child = B_FALSE;
	int		prh_circ, rh_circ, circ, old_state;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_hotplug_thread:  started");

	/*
	 * if our bus power entry point is active, process the change
	 * on the next notification of interrupt pipe
	 */
	mutex_enter(HUBD_MUTEX(hubd));
	if (hubd->h_bus_pwr || (hubd->h_hotplug_thread > 1)) {
		hubd->h_hotplug_thread--;

		/* mark this device as idle */
		hubd_pm_idle_component(hubd, hubd->h_dip, 0);
		mutex_exit(HUBD_MUTEX(hubd));

		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_hotplug_thread: "
		    "bus_power in progress/hotplugging undesirable - quit");

		return;
	}
	mutex_exit(HUBD_MUTEX(hubd));

	ndi_hold_devi(hdip); /* so we don't race with detach */

	mutex_enter(HUBD_MUTEX(hubd));

	/* is this the root hub? */
	if (hdip == rh_dip) {
		if (hubd->h_dev_state == USB_DEV_PWRED_DOWN) {
			hubpm = hubd->h_hubpm;

			/* mark the root hub as full power */
			hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
			hubpm->hubp_time_at_full_power = ddi_get_time();
			mutex_exit(HUBD_MUTEX(hubd));

			USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "hubd_hotplug_thread: call pm_power_has_changed");

			(void) pm_power_has_changed(hdip, 0,
				USB_DEV_OS_FULL_PWR);

			mutex_enter(HUBD_MUTEX(hubd));
			hubd->h_dev_state = USB_DEV_ONLINE;
		}

	} else {
		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_hotplug_thread: not root hub");
	}

	ASSERT(hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE);

	nports = hubd->h_hub_descr.bNbrPorts;

	hubd_stop_polling(hubd);
	mutex_exit(HUBD_MUTEX(hubd));

	/*
	 * this ensures one hotplug activity per system at a time.
	 * we enter the parent PCI node to have this serialization.
	 * this also excludes ioctls and deathrow thread
	 * (a bit crude but easier to debug)
	 */
	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
	ndi_devi_enter(rh_dip, &rh_circ);

	/* exclude other threads */
	ndi_devi_enter(hdip, &circ);
	mutex_enter(HUBD_MUTEX(hubd));

	while ((hubd->h_dev_state == USB_DEV_ONLINE) &&
	    (hubd->h_port_change)) {
		/*
		 * The 0th bit is the hub status change bit.
		 * handle loss of local power here
		 */
		if (hubd->h_port_change & HUB_CHANGE_STATUS) {
			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "hubd_hotplug_thread: hub status change!");

			/*
			 * This should be handled properly.  For now,
			 * mask off the bit.
			 */
			hubd->h_port_change &= ~HUB_CHANGE_STATUS;

			/*
			 * check and ack hub status
			 * this causes stall conditions
			 * when local power is removed
			 */
			(void) hubd_get_hub_status(hubd);
		}

		for (port = 1; port <= nports; port++) {
			usb_port_mask_t port_mask;
			boolean_t was_connected;

			port_mask = 1 << port;
			was_connected =
				(hubd->h_port_state[port] & PORT_STATUS_CCS) &&
				(hubd->h_children_dips[port]);

			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "hubd_hotplug_thread: "
			    "port %d mask=0x%x change=0x%x connected=0x%x",
			    port, port_mask, hubd->h_port_change,
			    was_connected);

			/*
			 * is this a port connection that changed?
			 */
			if ((hubd->h_port_change & port_mask) == 0) {

				continue;
			}
			hubd->h_port_change &= ~port_mask;

			/* ack all changes */
			(void) hubd_determine_port_status(hubd, port,
			    &status, &change, HUBD_ACK_ALL_CHANGES);

			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "handle port %d:\n\t"
			    "new status=0x%x change=0x%x was_conn=0x%x ",
			    port, status, change, was_connected);

			/* Recover a disabled port */
			if (change & PORT_CHANGE_PESC) {
				USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
					hubd->h_log_handle,
					"port%d Disabled - "
					"status=0x%x, change=0x%x",
					port, status, change);

				/*
				 * if the port was connected and is still
				 * connected, recover the port
				 */
				if (was_connected && (status &
				    PORT_STATUS_CCS)) {
					online_child |=
					    (hubd_recover_disabled_port(hubd,
					    port) == USB_SUCCESS);
				}
			}

			/*
			 * Now check what changed on the port
			 */
			if (change & PORT_CHANGE_CSC) {
				if ((status & PORT_STATUS_CCS) &&
				    (!was_connected)) {
					/* new device plugged in */
					online_child |=
					    (hubd_handle_port_connect(hubd,
					    port) == USB_SUCCESS);

				} else if ((status & PORT_STATUS_CCS) &&
				    was_connected) {
					/*
					 * In this case we can never be sure
					 * if the device indeed got hotplugged
					 * or the hub is falsely reporting the
					 * change.
					 * first post a disconnect event
					 * to the child
					 */
					mutex_exit(HUBD_MUTEX(hubd));
					hubd_post_event(hubd, port,
					    USBA_EVENT_TAG_HOT_REMOVAL);
					mutex_enter(HUBD_MUTEX(hubd));

					/*
					 * then reset the port and recover
					 * the device
					 */
					online_child |=
					    (hubd_handle_port_connect(hubd,
					    port) == USB_SUCCESS);
				} else if (was_connected) {
					/* this is a disconnect */
					mutex_exit(HUBD_MUTEX(hubd));
					hubd_post_event(hubd, port,
					    USBA_EVENT_TAG_HOT_REMOVAL);
					mutex_enter(HUBD_MUTEX(hubd));

					offline_child = B_TRUE;
				}
			}

			/*
			 * Check if any port is coming out of suspend
			 */
			if (change & PORT_CHANGE_PSSC) {
				/* a resuming device could have disconnected */
				if (was_connected &&
				    hubd->h_children_dips[port]) {

					/* device on this port resuming */
					dev_info_t *dip;

					dip = hubd->h_children_dips[port];

					/*
					 * Don't raise power on detaching child
					 */
					if (!DEVI_IS_DETACHING(dip)) {
						/*
						 * As this child is not
						 * detaching, we set this
						 * flag, causing bus_ctls
						 * to stall detach till
						 * pm_raise_power returns
						 * and flag it for a deferred
						 * raise_power.
						 *
						 * pm_raise_power is deferred
						 * because we need to release
						 * the locks first.
						 */
						hubd->h_port_state[port] |=
							HUBD_CHILD_RAISE_POWER;
						pwrup_child = B_TRUE;
						mutex_exit(HUBD_MUTEX(hubd));

						/*
						 * make sure that child
						 * doesn't disappear
						 */
						ndi_hold_devi(dip);

						mutex_enter(HUBD_MUTEX(hubd));
					}
				}
			}
		}
	}

	/* release locks so we can do a devfs_clean */
	mutex_exit(HUBD_MUTEX(hubd));

	/* delete cached dv_node's but drop locks first */
	ndi_devi_exit(hdip, circ);
	ndi_devi_exit(rh_dip, rh_circ);
	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);

	(void) devfs_clean(rh_dip, NULL, 0);

	/* now check if any children need onlining */
	if (online_child) {
		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_hotplug_thread: onlining children");

		(void) ndi_devi_online(hubd->h_dip, 0);
	}

	/* now check if any disconnected devices need to be cleaned up */
	if (offline_child) {
		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_hotplug_thread: scheduling cleanup");

		hubd_schedule_cleanup(hubd->h_usba_device->usb_root_hub_dip);
	}

	mutex_enter(HUBD_MUTEX(hubd));

	/* now raise power on the children that have woken up */
	if (pwrup_child) {
		old_state = hubd->h_dev_state;
		hubd->h_dev_state = USB_DEV_HUB_CHILD_PWRLVL;
		for (port = 1; port <= nports; port++) {
			if (hubd->h_port_state[port] & HUBD_CHILD_RAISE_POWER) {
				dev_info_t *dip = hubd->h_children_dips[port];

				mutex_exit(HUBD_MUTEX(hubd));

				/* Get the device to full power */
				(void) pm_busy_component(dip, 0);
				(void) pm_raise_power(dip, 0,
				    USB_DEV_OS_FULL_PWR);
				(void) pm_idle_component(dip, 0);

				/* release the hold on the child */
				ndi_rele_devi(dip);
				mutex_enter(HUBD_MUTEX(hubd));
				hubd->h_port_state[port] &=
				    ~HUBD_CHILD_RAISE_POWER;
			}
		}
		/*
		 * make sure that we don't accidentally
		 * over write the disconnect state
		 */
		if (hubd->h_dev_state == USB_DEV_HUB_CHILD_PWRLVL) {
			hubd->h_dev_state = old_state;
		}
	}

	/*
	 * start polling can immediately kick off read callback
	 * we need to set the h_hotplug_thread to 0 so that
	 * the callback is not dropped
	 */
	hubd_start_polling(hubd, HUBD_ALWAYS_START_POLLING);

	/*
	 * Earlier we would set the h_hotplug_thread = 0 before
	 * polling was restarted  so that
	 * if there is any root hub status change interrupt, we can still kick
	 * off the hotplug thread. This was valid when this interrupt was
	 * delivered in hardware, and only ONE interrupt would be delivered.
	 * Now that we poll on the root hub looking for status change in
	 * software, this assignment is no longer required.
	 */
	hubd->h_hotplug_thread--;

	/* mark this device as idle */
	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_hotplug_thread: exit");

	mutex_exit(HUBD_MUTEX(hubd));

	ndi_rele_devi(hdip);
}


/*
 * hubd_handle_port_connect:
 *	Transition a port from Disabled to Enabled.  Ensure that the
 *	port is in the correct state before attempting to
 *	access the device.
 */
static int
hubd_handle_port_connect(hubd_t *hubd, usb_port_t port)
{
	int			rval;
	int			retry;
	long			time_delay;
	long			settling_time;
	uint16_t		status;
	uint16_t		change;
	usb_addr_t		hubd_usb_addr;
	usba_device_t		*usba_device;
	usb_port_status_t	port_status = 0;
	usb_port_status_t	hub_port_status = 0;

	/* Get the hub address and port status */
	usba_device = hubd->h_usba_device;
	mutex_enter(&usba_device->usb_mutex);
	hubd_usb_addr = usba_device->usb_addr;
	hub_port_status = usba_device->usb_port_status;
	mutex_exit(&usba_device->usb_mutex);

	/*
	 * If a device is connected, transition the
	 * port from Disabled to the Enabled state.
	 * The device will receive downstream packets
	 * in the Enabled state.
	 *
	 * reset port and wait for the hub to report
	 * completion
	 */
	change = status = 0;

	/*
	 * According to section 9.1.2 of USB 2.0 spec, the host should
	 * wait for atleast 100ms to allow completion of an insertion
	 * process and for power at the device to become stable.
	 * We wait for 200 ms
	 */
	settling_time = drv_usectohz(hubd_device_delay / 5);
	mutex_exit(HUBD_MUTEX(hubd));
	delay(settling_time);
	mutex_enter(HUBD_MUTEX(hubd));

	/* calculate 600 ms delay time */
	time_delay = (6 * drv_usectohz(hubd_device_delay)) / 10;

	for (retry = 0; (hubd->h_dev_state == USB_DEV_ONLINE) &&
	    (retry < hubd_retry_enumerate); retry++) {
		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "resetting port%d, retry=%d", port, retry);

		if ((rval = hubd_reset_port(hubd, port)) != USB_SUCCESS) {
			(void) hubd_determine_port_status(hubd,
			    port, &status, &change, 0);

			/* continue only if port is still connected */
			if (status & PORT_STATUS_CCS) {
				continue;
			}

			/* carry on regardless */
		}

		/*
		 * according to USB 2.0 spec section 11.24.2.7.1.2
		 * at the end of port reset, the hub enables the port.
		 * But for some strange reasons, uhci port remains disabled.
		 * And because the port remains disabled for the settling
		 * time below, the device connected to the port gets wedged
		 * - fails to enumerate (device not responding)
		 * Hence, we enable it here immediately and later again after
		 * the delay
		 */
		(void) hubd_enable_port(hubd, port);

		/* we skip this delay in the first iteration */
		if (retry) {
			/*
			 * delay for device to signal disconnect/connect so
			 * that hub properly recognizes the speed of the device
			 */
			mutex_exit(HUBD_MUTEX(hubd));
			delay(settling_time);
			mutex_enter(HUBD_MUTEX(hubd));

			/*
			 * When a low speed device is connected to any port of
			 * PPX it has to be explicitly enabled
			 * Also, if device intentionally signals
			 * disconnect/connect, it will disable the port.
			 * So enable it again.
			 */
			(void) hubd_enable_port(hubd, port);
		}

		if ((rval = hubd_determine_port_status(hubd, port, &status,
		    &change, 0)) != USB_SUCCESS) {

			USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "getting status failed (%d)", rval);

			(void) hubd_disable_port(hubd, port);

			continue;
		}

		if (status & PORT_STATUS_POCI) {
			USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "port %d overcurrent", port);

			(void) hubd_disable_port(hubd, port);

			/* ack changes */
			(void) hubd_determine_port_status(hubd,
			    port, &status, &change, PORT_CHANGE_OCIC);

			continue;
		}

		/* is status really OK? */
		if ((status & PORT_STATUS_OK) != PORT_STATUS_OK) {
			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "port %d status (0x%x) not OK on retry %d",
			    port, status, retry);

			/* check if we still have the connection */
			if (!(status & PORT_STATUS_CCS)) {
				/* lost connection, set exit condition */
				retry = hubd_retry_enumerate;

				break;
			}
		} else {
			/*
			 * Determine if the device is high or full
			 * or low speed.
			 */
			if (status & PORT_STATUS_LSDA) {
				port_status = USBA_LOW_SPEED_DEV;
			} else if (status & PORT_STATUS_HSDA) {
				port_status = USBA_HIGH_SPEED_DEV;
			} else {
				port_status = USBA_FULL_SPEED_DEV;
			}

			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "creating child port%d, status=0x%x "
			    "port status=0x%x",
			    port, status, port_status);

			/*
			 * if the child already exists, set addrs and config
			 * to the device post connect event to the child
			 */
			if (hubd->h_children_dips[port]) {
				/* set addrs to this device */
				rval = hubd_setdevaddr(hubd, port);

				/*
				 * This delay is important for the CATC hub
				 * to enumerate. But, avoid delay in the first
				 * iteration
				 */
				if (retry) {
					mutex_exit(HUBD_MUTEX(hubd));
					delay(drv_usectohz(
					    hubd_device_delay/100));
					mutex_enter(HUBD_MUTEX(hubd));
				}

				if (rval == USB_SUCCESS) {
					/*
					 * set the default config for
					 * this device
					 */
					hubd_setdevconfig(hubd, port);

					/*
					 * indicate to the child that
					 * it is online again
					 */
					mutex_exit(HUBD_MUTEX(hubd));
					hubd_post_event(hubd, port,
					    USBA_EVENT_TAG_HOT_INSERTION);
					mutex_enter(HUBD_MUTEX(hubd));

					return (USB_SUCCESS);
				}
			} else {
				/*
				 * We need to release access here
				 * so that busctls on other ports can
				 * continue and don't cause a deadlock
				 * when busctl and removal of prom node
				 * takes concurrently. This also ensures
				 * busctls for attach of successfully
				 * enumerated devices on other ports can
				 * continue concurrently with the process
				 * of enumerating the new devices. This
				 * reduces the overall boot time of the system.
				 */
				rval = hubd_create_child(hubd->h_dip,
							hubd,
							hubd->h_usba_device,
							port_status, port,
							retry);
				if (rval == USB_SUCCESS) {
					usba_update_hotplug_stats(hubd->h_dip,
					    USBA_TOTAL_HOTPLUG_SUCCESS|
					    USBA_HOTPLUG_SUCCESS);
					hubd->h_total_hotplug_success++;

					if (retry > 0) {
						USB_DPRINTF_L1(
						    DPRINT_MASK_HOTPLUG,
						    hubd->h_log_handle,
						    "device on port %d "
						    "enumerated after %d %s",
						    port, retry,
						    (retry > 1) ? "retries" :
						    "retry");

					}

					return (USB_SUCCESS);
				}
			}
		}

		/* wait a while until it settles? */
		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "disabling port %d again", port);

		(void) hubd_disable_port(hubd, port);
		if (retry) {
			mutex_exit(HUBD_MUTEX(hubd));
			delay(time_delay);
			mutex_enter(HUBD_MUTEX(hubd));
		}

		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "retrying on port %d", port);
	}

	if (retry >= hubd_retry_enumerate) {
		/*
		 * If it is a High Speed Root Hub and connected device
		 * Is a Low/Full Speed, it will be handled by USB 1.1
		 * Host Controller. In this case, USB 2.0 Host Controller
		 * will transfer the ownership of this port to USB 1.1
		 * Host Controller. So don't display any error message on
		 * the console.
		 */
		if ((hubd_usb_addr == ROOT_HUB_ADDR) &&
		    (hub_port_status == USBA_HIGH_SPEED_DEV) &&
		    (port_status != USBA_HIGH_SPEED_DEV)) {
			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
			    hubd->h_log_handle,
			    "hubd_handle_port_connect: Low/Full speed "
			    "device is connected to High Speed root hub");
		} else {
			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
			    hubd->h_log_handle,
			    "Connecting device on port %d failed", port);
		}

		(void) hubd_disable_port(hubd, port);
		usba_update_hotplug_stats(hubd->h_dip,
		    USBA_TOTAL_HOTPLUG_FAILURE|USBA_HOTPLUG_FAILURE);
		hubd->h_total_hotplug_failure++;

		/*
		 * the port should be automagically
		 * disabled but just in case, we do
		 * it here
		 */
		(void) hubd_disable_port(hubd, port);

		/* ack all changes because we disabled this port */
		(void) hubd_determine_port_status(hubd,
		    port, &status, &change, HUBD_ACK_ALL_CHANGES);

	}

	return (USB_FAILURE);
}


/*
 * hubd_get_hub_status:
 */
static int
hubd_get_hub_status(hubd_t *hubd)
{
	int		rval;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;
	mblk_t		*data = NULL;
	uint16_t	status;
	uint16_t	change;
	usb_cfg_descr_t	cfg_descr;
	size_t		cfg_length;
	uchar_t		*usb_cfg;
	uint8_t		MaxPower;

	mutex_exit(HUBD_MUTEX(hubd));
	if (usb_pipe_sync_ctrl_xfer(hubd->h_dip, hubd->h_default_pipe,
	    HUB_CLASS_REQ,
	    USB_REQ_GET_STATUS,
	    0,
	    0,
	    GET_STATUS_LENGTH,
	    &data, 0,
	    &completion_reason, &cb_flags, 0) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "get hub status failed: cr=%d cb=0x%x",
		    completion_reason, cb_flags);

		if (data) {
			freemsg(data);
		}

		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_FAILURE);
	}

	mutex_enter(HUBD_MUTEX(hubd));

	status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
	change = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);

	if (status || change) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "hub status = 0x%x change = 0x%x", status, change);
	}

	mutex_exit(HUBD_MUTEX(hubd));
	freemsg(data);

	/* Obtain the raw configuration descriptor */
	usb_cfg = usb_get_raw_cfg_data(hubd->h_dip, &cfg_length);

	/* get configuration descriptor */
	rval = usb_parse_cfg_descr(usb_cfg, cfg_length,
				&cfg_descr, USB_CFG_DESCR_SIZE);

	if (rval != USB_CFG_DESCR_SIZE) {

		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "get hub configuration descriptor failed.");

		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_FAILURE);
	} else {
		MaxPower = cfg_descr.bMaxPower;
	}

	/* check if local power status changed. */
	if (change & C_HUB_LOCAL_POWER_STATUS) {

		/*
		 * local power has been lost, check the maximum
		 * power consumption of current configuration.
		 * see USB2.0 spec Table 11-12.
		 */
		if (status & HUB_LOCAL_POWER_STATUS) {

			if (MaxPower == 0) {

				/*
				 * Self-powered only hub. Because it could
				 * not draw any power from USB bus.
				 * It can't work well on this condition.
				 */
				USB_DPRINTF_L1(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "local power has been lost, "
				    "please disconnect hub");
			} else {

				/*
				 * Bus-powered only or self/bus-powered hub.
				 */
				USB_DPRINTF_L1(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "local power has been lost,"
				    "the hub could draw %d"
				    " mA power from the USB bus.",
				    2*MaxPower);
			}

		}

		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "clearing feature C_HUB_LOCAL_POWER ");

		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
		    hubd->h_default_pipe,
		    USB_DEV_REQ_TYPE_CLASS,
		    USB_REQ_CLEAR_FEATURE,
		    CFS_C_HUB_LOCAL_POWER,
		    0,
		    0,
		    NULL, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_PORT,
			    hubd->h_log_handle,
			    "clear feature C_HUB_LOCAL_POWER "
			    "failed (%d 0x%x %d)",
			    rval, completion_reason, cb_flags);
		}

	}

	if (change & C_HUB_OVER_CURRENT) {

		if (status & HUB_OVER_CURRENT) {
			/*
			 * the user must offline this hub in order to recover.
			 * the port power is automatically disabled, so we
			 * won't see disconnects.
			 */
			USB_DPRINTF_L1(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "global over current condition, "
			    "please disconnect hub");
		}

		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "clearing feature C_HUB_OVER_CURRENT");

		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
		    hubd->h_default_pipe,
		    USB_DEV_REQ_TYPE_CLASS,
		    USB_REQ_CLEAR_FEATURE,
		    CFS_C_HUB_OVER_CURRENT,
		    0,
		    0,
		    NULL, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			USB_DPRINTF_L2(DPRINT_MASK_PORT,
			    hubd->h_log_handle,
			    "clear feature C_HUB_OVER_CURRENT "
			    "failed (%d 0x%x %d)",
			    rval, completion_reason, cb_flags);
		}
	}

	mutex_enter(HUBD_MUTEX(hubd));

	return (USB_SUCCESS);
}


/*
 * hubd_reset_port:
 */
static int
hubd_reset_port(hubd_t *hubd, usb_port_t port)
{
	int	rval;
	usb_cr_t completion_reason;
	usb_cb_flags_t cb_flags;
	usb_port_mask_t port_mask = 1 << port;
	mblk_t	*data;
	uint16_t status;
	uint16_t change;
	int	i;
	clock_t	current_time;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_reset_port: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	hubd->h_port_reset_wait |= port_mask;

	mutex_exit(HUBD_MUTEX(hubd));

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    HANDLE_PORT_FEATURE,
	    USB_REQ_SET_FEATURE,
	    CFS_PORT_RESET,
	    port,
	    0,
	    NULL, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "reset port%d failed (%d 0x%x %d)",
		    port, completion_reason, cb_flags, rval);

		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_FAILURE);
	}

	mutex_enter(HUBD_MUTEX(hubd));

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "waiting on cv for reset completion");

	/*
	 * wait for port status change event
	 */
	for (i = 0; i < hubd_retry_enumerate; i++) {
		/*
		 * start polling ep1 for receiving notification on
		 * reset completion
		 */
		hubd_start_polling(hubd, HUBD_ALWAYS_START_POLLING);

		/*
		 * sleep a max of 100ms for reset completion
		 * notification to be received
		 */
		current_time = ddi_get_lbolt();
		if (hubd->h_port_reset_wait & port_mask) {
			rval = cv_timedwait(&hubd->h_cv_reset_port,
				&hubd->h_mutex,
				current_time +
				drv_usectohz(hubd_device_delay / 10));
			if ((rval <= 0) &&
			    (hubd->h_port_reset_wait & port_mask)) {
				/* we got woken up because of a timeout */
				USB_DPRINTF_L2(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "timeout: reset port=%d failed", port);

				hubd->h_port_reset_wait &=  ~port_mask;

				hubd_stop_polling(hubd);

				return (USB_FAILURE);
			}
		}

		USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "reset completion received");

		hubd_stop_polling(hubd);

		data = NULL;

		/* check status to determine whether reset completed */
		mutex_exit(HUBD_MUTEX(hubd));
		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
		    hubd->h_default_pipe,
		    GET_PORT_STATUS,
		    USB_REQ_GET_STATUS,
		    0,
		    port,
		    GET_STATUS_LENGTH,
		    &data, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			USB_DPRINTF_L1(DPRINT_MASK_PORT,
			    hubd->h_log_handle,
			    "get status port%d failed (%d 0x%x %d)",
			    port, completion_reason, cb_flags, rval);

			if (data) {
				freemsg(data);
				data = NULL;
			}
			mutex_enter(HUBD_MUTEX(hubd));

			continue;
		}

		status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
		change = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);

		freemsg(data);

		/* continue only if port is still connected */
		if (!(status & PORT_STATUS_CCS)) {

			/* lost connection, set exit condition */
			i = hubd_retry_enumerate;

			mutex_enter(HUBD_MUTEX(hubd));

			break;
		}

		if (status & PORT_STATUS_PRS) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "port%d reset active", port);
			mutex_enter(HUBD_MUTEX(hubd));

			continue;
		} else {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "port%d reset inactive", port);
		}

		if (change & PORT_CHANGE_PRSC) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "clearing feature CFS_C_PORT_RESET");

			if (usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_CLEAR_FEATURE,
			    CFS_C_PORT_RESET,
			    port,
			    0,
			    NULL, 0,
			    &completion_reason, &cb_flags, 0) != USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "clear feature CFS_C_PORT_RESET"
				    " port%d failed (%d 0x%x %d)",
				    port, completion_reason, cb_flags, rval);
			}
		}
		mutex_enter(HUBD_MUTEX(hubd));

		break;
	}

	if (i >= hubd_retry_enumerate) {
		/* port reset has failed */
		rval = USB_FAILURE;
	}

	return (rval);
}


/*
 * hubd_enable_port:
 *	this may fail if the hub as been disconnected
 */
static int
hubd_enable_port(hubd_t *hubd, usb_port_t port)
{
	int	rval;
	usb_cr_t completion_reason;
	usb_cb_flags_t cb_flags;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_enable_port: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	mutex_exit(HUBD_MUTEX(hubd));

	/* Do not issue a SetFeature(PORT_ENABLE) on external hubs */
	if (!usba_is_root_hub(hubd->h_dip)) {
		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_SUCCESS);
	}

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    HANDLE_PORT_FEATURE,
	    USB_REQ_SET_FEATURE,
	    CFS_PORT_ENABLE,
	    port,
	    0,
	    NULL, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "enable port%d failed (%d 0x%x %d)",
		    port, completion_reason, cb_flags, rval);
	}

	mutex_enter(HUBD_MUTEX(hubd));

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "enabling port done");

	return (rval);
}


/*
 * hubd_disable_port
 */
static int
hubd_disable_port(hubd_t *hubd, usb_port_t port)
{
	int	rval;
	usb_cr_t completion_reason;
	usb_cb_flags_t cb_flags;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_disable_port: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	mutex_exit(HUBD_MUTEX(hubd));

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    HANDLE_PORT_FEATURE,
	    USB_REQ_CLEAR_FEATURE,
	    CFS_PORT_ENABLE,
	    port,
	    0,
	    NULL, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "disable port%d failed (%d 0x%x %d)", port,
		    completion_reason, cb_flags, rval);
		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_FAILURE);
	}

	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "clearing feature CFS_C_PORT_ENABLE");

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    HANDLE_PORT_FEATURE,
	    USB_REQ_CLEAR_FEATURE,
	    CFS_C_PORT_ENABLE,
	    port,
	    0,
	    NULL, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT,
		    hubd->h_log_handle,
		    "clear feature CFS_C_PORT_ENABLE port%d failed "
		    "(%d 0x%x %d)",
		    port, completion_reason, cb_flags, rval);

		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_FAILURE);
	}

	mutex_enter(HUBD_MUTEX(hubd));

	return (USB_SUCCESS);
}


/*
 * hubd_determine_port_status:
 */
static int
hubd_determine_port_status(hubd_t *hubd, usb_port_t port,
		uint16_t *status, uint16_t *change, uint_t ack_flag)
{
	int rval;
	mblk_t	*data = NULL;
	usb_cr_t completion_reason;
	usb_cb_flags_t cb_flags;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_determine_port_status: port=%d, state=0x%x ack=0x%x", port,
	    hubd->h_port_state[port], ack_flag);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	mutex_exit(HUBD_MUTEX(hubd));

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    GET_PORT_STATUS,
	    USB_REQ_GET_STATUS,
	    0,
	    port,
	    GET_STATUS_LENGTH,
	    &data, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port=%d get status failed (%d 0x%x %d)",
		    port, completion_reason, cb_flags, rval);

		if (data) {
			freemsg(data);
		}

		*status = *change = 0;
		mutex_enter(HUBD_MUTEX(hubd));

		return (rval);
	}

	mutex_enter(HUBD_MUTEX(hubd));
	if ((data->b_wptr - data->b_rptr) != GET_STATUS_LENGTH) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port %d: length incorrect %d",
		    port, data->b_wptr - data->b_rptr);
		freemsg(data);
		*status = *change = 0;

		return (rval);
	}


	*status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
	*change = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);

	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "port%d status=0x%x, change=0x%x", port, *status, *change);

	freemsg(data);

	if (*status & PORT_STATUS_CCS) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d connected", port);

		hubd->h_port_state[port] |= (PORT_STATUS_CCS & ack_flag);
	} else {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d disconnected", port);

		hubd->h_port_state[port] &= ~(PORT_STATUS_CCS & ack_flag);
	}

	if (*status & PORT_STATUS_PES) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d enabled", port);

		hubd->h_port_state[port] |= (PORT_STATUS_PES & ack_flag);
	} else {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d disabled", port);

		hubd->h_port_state[port] &= ~(PORT_STATUS_PES & ack_flag);
	}

	if (*status & PORT_STATUS_PSS) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d suspended", port);

		hubd->h_port_state[port] |= (PORT_STATUS_PSS & ack_flag);
	} else {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d not suspended", port);

		hubd->h_port_state[port] &= ~(PORT_STATUS_PSS & ack_flag);
	}

	if (*change & PORT_CHANGE_PRSC) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d reset completed", port);

		hubd->h_port_state[port] |= (PORT_CHANGE_PRSC & ack_flag);
	} else {

		hubd->h_port_state[port] &= ~(PORT_CHANGE_PRSC & ack_flag);
	}

	if (*status & PORT_STATUS_POCI) {
		USB_DPRINTF_L1(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d over current!", port);

		hubd->h_port_state[port] |= (PORT_STATUS_POCI & ack_flag);
	} else {

		hubd->h_port_state[port] &= ~(PORT_STATUS_POCI & ack_flag);
	}

	if (*status & PORT_STATUS_PRS) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d reset active", port);

		hubd->h_port_state[port] |= (PORT_STATUS_PRS & ack_flag);
	} else {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d reset inactive", port);

		hubd->h_port_state[port] &= ~(PORT_STATUS_PRS & ack_flag);
	}
	if (*status & PORT_STATUS_PPS) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d power on", port);

		hubd->h_port_state[port] |= (PORT_STATUS_PPS & ack_flag);
	} else {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d power off", port);

		hubd->h_port_state[port] &= ~(PORT_STATUS_PPS & ack_flag);
	}
	if (*status & PORT_STATUS_LSDA) {
		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "port%d low speed", port);

		hubd->h_port_state[port] |= (PORT_STATUS_LSDA & ack_flag);
	} else {
		hubd->h_port_state[port] &= ~(PORT_STATUS_LSDA & ack_flag);
		if (*status & PORT_STATUS_HSDA) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT,
			    hubd->h_log_handle, "port%d "
			    "high speed", port);

			hubd->h_port_state[port] |=
					(PORT_STATUS_HSDA & ack_flag);
		} else {
			USB_DPRINTF_L3(DPRINT_MASK_PORT,
			    hubd->h_log_handle, "port%d "
			    "full speed", port);

			hubd->h_port_state[port] &=
					~(PORT_STATUS_HSDA & ack_flag);
		}
	}

	/*
	 * Acknowledge connection, enable, reset status
	 */
	if (ack_flag) {
		mutex_exit(HUBD_MUTEX(hubd));
		if (*change & PORT_CHANGE_CSC & ack_flag) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "clearing feature CFS_C_PORT_CONNECTION");
			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_CLEAR_FEATURE,
			    CFS_C_PORT_CONNECTION,
			    port,
			    0, NULL, 0,
			    &completion_reason, &cb_flags, 0)) !=
			    USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "clear feature CFS_C_PORT_CONNECTION"
				    " port%d failed (%d 0x%x %d)",
				    port, completion_reason, cb_flags, rval);
			}
		}
		if (*change & PORT_CHANGE_PESC & ack_flag) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "clearing feature CFS_C_PORT_ENABLE");
			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_CLEAR_FEATURE,
			    CFS_C_PORT_ENABLE,
			    port,
			    0, NULL, 0,
			    &completion_reason, &cb_flags, 0)) !=
			    USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "clear feature CFS_C_PORT_ENABLE"
				    " port%d failed (%d 0x%x %d)",
				    port, completion_reason, cb_flags, rval);
			}
		}
		if (*change & PORT_CHANGE_PSSC & ack_flag) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "clearing feature CFS_C_PORT_SUSPEND");

			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_CLEAR_FEATURE,
			    CFS_C_PORT_SUSPEND,
			    port,
			    0, NULL, 0,
			    &completion_reason, &cb_flags, 0)) !=
			    USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "clear feature CFS_C_PORT_SUSPEND"
				    " port%d failed (%d 0x%x %d)",
				    port, completion_reason, cb_flags, rval);
			}
		}
		if (*change & PORT_CHANGE_OCIC & ack_flag) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "clearing feature CFS_C_PORT_OVER_CURRENT");

			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_CLEAR_FEATURE,
			    CFS_C_PORT_OVER_CURRENT,
			    port,
			    0, NULL, 0,
			    &completion_reason, &cb_flags, 0)) !=
			    USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "clear feature CFS_C_PORT_OVER_CURRENT"
				    " port%d failed (%d 0x%x %d)",
				    port, completion_reason, cb_flags, rval);
			}
		}
		if (*change & PORT_CHANGE_PRSC & ack_flag) {
			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "clearing feature CFS_C_PORT_RESET");
			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
			    hubd->h_default_pipe,
			    HANDLE_PORT_FEATURE,
			    USB_REQ_CLEAR_FEATURE,
			    CFS_C_PORT_RESET,
			    port,
			    0, NULL, 0,
			    &completion_reason, &cb_flags, 0)) !=
			    USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_PORT,
				    hubd->h_log_handle,
				    "clear feature CFS_C_PORT_RESET"
				    " port%d failed (%d 0x%x %d)",
				    port, completion_reason, cb_flags, rval);
			}
		}
		mutex_enter(HUBD_MUTEX(hubd));
	}

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "new port%d state 0x%x", port, hubd->h_port_state[port]);


	return (USB_SUCCESS);
}


/*
 * hubd_recover_disabled_port
 * if the port got disabled because of an error
 * enable it. If hub doesn't suport enable port,
 * reset the port to bring the device to life again
 */
static int
hubd_recover_disabled_port(hubd_t *hubd, usb_port_t port)
{
	uint16_t	status;
	uint16_t	change;
	int		rval = USB_FAILURE;

	/* first try enabling the port */
	(void) hubd_enable_port(hubd, port);

	/* read the port status */
	(void) hubd_determine_port_status(hubd, port, &status, &change,
	    PORT_CHANGE_PESC);

	if (status & PORT_STATUS_PES) {
		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			"Port%d now Enabled", port);
	} else if (status & PORT_STATUS_CCS) {
		/* first post a disconnect event to the child */
		mutex_exit(HUBD_MUTEX(hubd));
		hubd_post_event(hubd, port, USBA_EVENT_TAG_HOT_REMOVAL);
		mutex_enter(HUBD_MUTEX(hubd));

		/* then reset the port and recover the device */
		rval = hubd_handle_port_connect(hubd, port);

		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			"Port%d now Enabled by force", port);
	}

	return (rval);
}


/*
 * hubd_enable_all_port_power:
 */
static int
hubd_enable_all_port_power(hubd_t *hubd)
{
	usb_hub_descr_t	*hub_descr;
	int		wait;
	usb_port_t	port;
	uint_t		retry;
	uint16_t	status;
	uint16_t	change;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_enable_all_port_power");

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	hub_descr = &hubd->h_hub_descr;

	/*
	 * According to section 11.11 of USB, for hubs with no power
	 * switches, bPwrOn2PwrGood is zero. But we wait for some
	 * arbitrary time to enable power to become stable.
	 *
	 * If an hub supports port power switching, we need to wait
	 * at least 20ms before accessing corresponding usb port.
	 */
	if ((hub_descr->wHubCharacteristics &
	    HUB_CHARS_NO_POWER_SWITCHING) || (!hub_descr->bPwrOn2PwrGood)) {
		wait = hubd_device_delay / 10;
	} else {
		wait = max(HUB_DEFAULT_POPG,
		    hub_descr->bPwrOn2PwrGood) * 2 * 1000;
	}

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_enable_all_port_power: popg=%d wait=%d",
	    hub_descr->bPwrOn2PwrGood, wait);

	/*
	 * Enable power per port. we ignore gang power and power mask
	 * and always enable all ports one by one.
	 */
	for (port = 1; port <= hub_descr->bNbrPorts; port++) {
		/*
		 * Transition the port from the Powered Off to the
		 * Disconnected state by supplying power to the port.
		 */
		USB_DPRINTF_L4(DPRINT_MASK_PORT,
		    hubd->h_log_handle,
		    "hubd_enable_all_port_power: power port=%d", port);

		(void) hubd_enable_port_power(hubd, port);
	}

	mutex_exit(HUBD_MUTEX(hubd));
	delay(drv_usectohz(wait));
	mutex_enter(HUBD_MUTEX(hubd));

	/* For retry if any, use some extra delay */
	wait = max(wait, hubd_device_delay / 10);

	/* Check each port power status for a given usb hub */
	for (port = 1; port <= hub_descr->bNbrPorts; port++) {

		/* Get port status */
		(void) hubd_determine_port_status(hubd, port,
		    &status, &change, 0);

		for (retry = 0; ((!(status & PORT_STATUS_PPS)) &&
		    (retry < HUBD_PORT_RETRY)); retry++) {

			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "Retry is in progress %d: port %d status %d",
			    retry, port, status);

			(void) hubd_enable_port_power(hubd, port);

			mutex_exit(HUBD_MUTEX(hubd));
			delay(drv_usectohz(wait));
			mutex_enter(HUBD_MUTEX(hubd));

			/* Get port status */
			(void) hubd_determine_port_status(hubd, port,
			    &status, &change, 0);
		}

		/* Print warning message if port has no power */
		if (!(status & PORT_STATUS_PPS)) {

			USB_DPRINTF_L1(DPRINT_MASK_PORT, hubd->h_log_handle,
			    "hubd_enable_all_port_power: port %d power-on "
			    "failed, port status 0x%x", port, status);
		}
	}

	return (USB_SUCCESS);
}


/*
 * hubd_enable_port_power:
 *	enable individual port power
 */
static int
hubd_enable_port_power(hubd_t *hubd, usb_port_t port)
{
	int		rval;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_enable_port_power: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
	ASSERT(hubd->h_default_pipe != 0);

	mutex_exit(HUBD_MUTEX(hubd));

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    HANDLE_PORT_FEATURE,
	    USB_REQ_SET_FEATURE,
	    CFS_PORT_POWER,
	    port,
	    0, NULL, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "set port power failed (%d 0x%x %d)",
		    completion_reason, cb_flags, rval);
		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_FAILURE);
	} else {
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_port_state[port] |= PORT_STATUS_PPS;

		return (USB_SUCCESS);
	}
}


/*
 * hubd_disable_all_port_power:
 */
static int
hubd_disable_all_port_power(hubd_t *hubd)
{
	usb_port_t port;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_disable_all_port_power");

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	/*
	 * disable power per port, ignore gang power and power mask
	 */
	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		(void) hubd_disable_port_power(hubd, port);
	}

	return (USB_SUCCESS);
}


/*
 * hubd_disable_port_power:
 *	disable individual port power
 */
static int
hubd_disable_port_power(hubd_t *hubd, usb_port_t port)
{
	int		rval;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;

	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_disable_port_power: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	mutex_exit(HUBD_MUTEX(hubd));

	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
	    hubd->h_default_pipe,
	    HANDLE_PORT_FEATURE,
	    USB_REQ_CLEAR_FEATURE,
	    CFS_PORT_POWER,
	    port,
	    0, NULL, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "clearing port%d power failed (%d 0x%x %d)",
		    port, completion_reason, cb_flags, rval);

		mutex_enter(HUBD_MUTEX(hubd));

		return (USB_FAILURE);
	} else {

		mutex_enter(HUBD_MUTEX(hubd));
		ASSERT(completion_reason == 0);
		hubd->h_port_state[port] &= ~PORT_STATUS_PPS;

		return (USB_SUCCESS);
	}
}


/*
 * Search the database of user preferences and find out the preferred
 * configuration for this new device
 */
static int
hubd_select_device_configuration(hubd_t *hubd, usb_port_t port,
	dev_info_t *child_dip, usba_device_t *child_ud)
{
	char		*pathname = NULL;
	char		*tmp_path = NULL;
	int		user_conf;
	int		pathlen;
	usb_dev_descr_t	*usbdev_ptr;
	usba_configrec_t *user_pref;

	mutex_enter(&child_ud->usb_mutex);
	usbdev_ptr = child_ud->usb_dev_descr;
	mutex_exit(&child_ud->usb_mutex);

	/* try to get pathname for this device */
	tmp_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
	(void) ddi_pathname(child_dip, tmp_path);

	pathlen = strlen(tmp_path) + 32;
	pathname = kmem_zalloc(pathlen, KM_SLEEP);

	/*
	 * We haven't initialized the node and it doesn't have an address
	 * yet. Append port number to the physical pathname
	 */
	(void) sprintf(pathname, "%s@%d", tmp_path, port);

	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_select_device_configuration: Device=%s\n\t"
	    "Child path=%s",
	    usba_get_mfg_prod_sn_str(child_dip, tmp_path, MAXPATHLEN),
	    pathname);
	kmem_free(tmp_path, MAXPATHLEN);


	/* database search for user preferences */
	user_pref = usba_devdb_get_user_preferences(usbdev_ptr->idVendor,
	    usbdev_ptr->idProduct, child_ud->usb_serialno_str, pathname);

	if (user_pref) {
		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_select_device_configuration: "
		    "usba_devdb_get_user_preferences "
		    "return user_conf=%d\npreferred driver=%s path=%s",
		    user_pref->cfg_index, user_pref->driver,
		    user_pref->pathname);

		user_conf = user_pref->cfg_index;

		if (user_pref->driver) {
			mutex_enter(&child_ud->usb_mutex);
			child_ud->usb_preferred_driver = user_pref->driver;
			mutex_exit(&child_ud->usb_mutex);
		}
	} else {
		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_select_device_configuration: No match found");

		/* select default configuration for this device */
		user_conf = USBA_DEV_CONFIG_INDEX_UNDEFINED;
	}
	kmem_free(pathname, pathlen);

	/* if the device has just one configuration, set default value */
	if (usbdev_ptr->bNumConfigurations == 1) {
		user_conf = USB_DEV_DEFAULT_CONFIG_INDEX;
	}

	return (user_conf);
}


/*
 * Retrieves config cloud for this configuration
 */
int
hubd_get_this_config_cloud(hubd_t *hubd, dev_info_t *dip,
	usba_device_t *child_ud, uint16_t conf_index)
{
	usb_cfg_descr_t	*confdescr;
	mblk_t		*pdata = NULL;
	int		rval;
	size_t		size;
	char		*tmpbuf;
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;
	usb_pipe_handle_t	def_ph;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_get_this_config_cloud: conf_index=%d", conf_index);


	/* alloc temporary space for config descriptor */
	confdescr = (usb_cfg_descr_t *)kmem_zalloc(USB_CFG_DESCR_SIZE,
	    KM_SLEEP);

	/* alloc temporary space for string descriptor */
	tmpbuf = kmem_zalloc(USB_MAXSTRINGLEN, KM_SLEEP);

	def_ph = usba_get_dflt_pipe_handle(dip);

	if ((rval = usb_pipe_sync_ctrl_xfer(dip, def_ph,
	    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
	    USB_REQ_GET_DESCR,
	    USB_DESCR_TYPE_SETUP_CFG | conf_index,
	    0,
	    USB_CFG_DESCR_SIZE,
	    &pdata,
	    0,
	    &completion_reason,
	    &cb_flags,
	    0)) == USB_SUCCESS) {

		/* this must be true since we didn't allow data underruns */
		ASSERT((pdata->b_wptr - pdata->b_rptr) == USB_CFG_DESCR_SIZE);

		/*
		 * Parse the configuration descriptor
		 */
		size = usb_parse_cfg_descr(pdata->b_rptr,
		    pdata->b_wptr - pdata->b_rptr, confdescr,
		    USB_CFG_DESCR_SIZE);

		/* if parse cfg descr error, it should return failure */
		if (size == USB_PARSE_ERROR) {

			if (pdata->b_rptr[1] != USB_DESCR_TYPE_CFG) {
				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
				    hubd->h_log_handle,
				    "device returned incorrect "
				    "configuration descriptor type.");
			}
			rval = USB_FAILURE;
			goto done;
		}

		if (confdescr->wTotalLength < USB_CFG_DESCR_SIZE) {
			USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
			    hubd->h_log_handle,
			    "device returned incorrect "
			    "configuration descriptor size.");

			rval = USB_FAILURE;
			goto done;
		}

		freemsg(pdata);
		pdata = NULL;

		/* Now fetch the complete config cloud */
		if ((rval = usb_pipe_sync_ctrl_xfer(dip, def_ph,
		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
		    USB_REQ_GET_DESCR,
		    USB_DESCR_TYPE_SETUP_CFG | conf_index,
		    0,
		    confdescr->wTotalLength,
		    &pdata,
		    0,
		    &completion_reason,
		    &cb_flags,
		    0)) == USB_SUCCESS) {

			if ((pdata->b_wptr - pdata->b_rptr) !=
			    confdescr->wTotalLength) {

				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
				    hubd->h_log_handle,
				    "device returned incorrect "
				    "configuration descriptor.");

				rval = USB_FAILURE;
				goto done;
			}

			/*
			 * copy config descriptor into usba_device
			 */
			mutex_enter(&child_ud->usb_mutex);
			child_ud->usb_cfg_array[conf_index] =
			    kmem_alloc(confdescr->wTotalLength, KM_SLEEP);
			child_ud->usb_cfg_array_len[conf_index] =
					confdescr->wTotalLength;
			bcopy((caddr_t)pdata->b_rptr,
			    (caddr_t)child_ud->usb_cfg_array[conf_index],
			    confdescr->wTotalLength);
			mutex_exit(&child_ud->usb_mutex);

			/*
			 * retrieve string descriptor describing this
			 * configuration
			 */
			if (confdescr->iConfiguration) {

				USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
				    hubd->h_log_handle,
				    "Get conf str descr for config_index=%d",
				    conf_index);

				/*
				 * Now fetch the string descriptor describing
				 * this configuration
				 */
				if ((rval = usb_get_string_descr(dip,
				    USB_LANG_ID, confdescr->iConfiguration,
				    tmpbuf, USB_MAXSTRINGLEN)) ==
				    USB_SUCCESS) {
					size = strlen(tmpbuf);
					if (size > 0) {
						child_ud->usb_cfg_str_descr
						    [conf_index] = (char *)
						    kmem_zalloc(size + 1,
						    KM_SLEEP);
						(void) strcpy(
						    child_ud->usb_cfg_str_descr
						    [conf_index], tmpbuf);
					}
				} else {
					USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
					    hubd->h_log_handle,
					    "hubd_get_this_config_cloud: "
					    "getting config string (%d) "
					    "failed",
					    confdescr->iConfiguration);

					/* ignore this error */
					rval = USB_SUCCESS;
				}
			}
		}
	}

done:
	if (rval != USB_SUCCESS) {
		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_get_this_config_cloud: "
		    "error in retrieving config descriptor for "
		    "config index=%d rval=%d cr=%d",
		    conf_index, rval, completion_reason);
	}

	if (pdata) {
		freemsg(pdata);
		pdata = NULL;
	}

	kmem_free(confdescr, USB_CFG_DESCR_SIZE);
	kmem_free(tmpbuf, USB_MAXSTRINGLEN);

	return (rval);
}


/*
 * Retrieves the entire config cloud for all configurations of the device
 */
int
hubd_get_all_device_config_cloud(hubd_t *hubd, dev_info_t *dip,
	usba_device_t *child_ud)
{
	int		rval = USB_SUCCESS;
	int		ncfgs;
	uint16_t	size;
	uint16_t	conf_index;
	uchar_t		**cfg_array;
	uint16_t	*cfg_array_len;
	char		**str_descr;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_get_all_device_config_cloud: Start");

	/* alloc pointer array for conf. descriptors */
	mutex_enter(&child_ud->usb_mutex);
	ncfgs = child_ud->usb_n_cfgs;
	mutex_exit(&child_ud->usb_mutex);

	size = sizeof (uchar_t *) * ncfgs;
	cfg_array = kmem_zalloc(size, KM_SLEEP);
	cfg_array_len = kmem_zalloc(ncfgs * sizeof (uint16_t), KM_SLEEP);
	str_descr = kmem_zalloc(size, KM_SLEEP);

	mutex_enter(&child_ud->usb_mutex);
	child_ud->usb_cfg_array = cfg_array;
	child_ud->usb_cfg_array_len = cfg_array_len;
	child_ud->usb_cfg_array_length = size;
	child_ud->usb_cfg_array_len_length = ncfgs * sizeof (uint16_t);
	child_ud->usb_cfg_str_descr = str_descr;
	mutex_exit(&child_ud->usb_mutex);

	/* Get configuration descriptor for each configuration */
	for (conf_index = 0; (conf_index < ncfgs) &&
	    (rval == USB_SUCCESS); conf_index++) {

		rval = hubd_get_this_config_cloud(hubd, dip, child_ud,
		    conf_index);
	}

	return (rval);
}


/*
 * hubd_ready_device:
 *	Update the usba_device structure
 *	Set the given configuration
 *	Prepares the device node for driver to online. If an existing
 *	OBP node is found, it will switch to the OBP node.
 */
static dev_info_t *
hubd_ready_device(hubd_t *hubd, dev_info_t *child_dip, usba_device_t *child_ud,
    int config_index)
{
	usb_cr_t	completion_reason;
	usb_cb_flags_t	cb_flags;
	size_t		size;
	usb_cfg_descr_t	config_descriptor;
	usb_pipe_handle_t def_ph;
	usba_pipe_handle_data_t	*ph;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_ready_device: dip=0x%p, user_conf_index=%d", child_dip,
	    config_index);

	ASSERT(config_index >= 0);

	size = usb_parse_cfg_descr(
	    child_ud->usb_cfg_array[config_index], USB_CFG_DESCR_SIZE,
	    &config_descriptor, USB_CFG_DESCR_SIZE);
	ASSERT(size == USB_CFG_DESCR_SIZE);

	def_ph = usba_get_dflt_pipe_handle(child_dip);

	/* Set the configuration */
	(void) usb_pipe_sync_ctrl_xfer(child_dip, def_ph,
	    USB_DEV_REQ_HOST_TO_DEV,
	    USB_REQ_SET_CFG,	/* bRequest */
	    config_descriptor.bConfigurationValue,	/* wValue */
	    0,				/* wIndex */
	    0,				/* wLength */
	    NULL,
	    0,
	    &completion_reason,
	    &cb_flags,
	    0);

	mutex_enter(&child_ud->usb_mutex);
	child_ud->usb_active_cfg_ndx	= config_index;
	child_ud->usb_cfg		= child_ud->usb_cfg_array[config_index];
	child_ud->usb_cfg_length	= config_descriptor.wTotalLength;
	child_ud->usb_cfg_value 	= config_descriptor.bConfigurationValue;
	child_ud->usb_n_ifs		= config_descriptor.bNumInterfaces;
	child_ud->usb_dip		= child_dip;

	child_ud->usb_client_flags	= kmem_zalloc(
		child_ud->usb_n_ifs * USBA_CLIENT_FLAG_SIZE, KM_SLEEP);

	child_ud->usb_client_attach_list = kmem_zalloc(
		child_ud->usb_n_ifs *
		sizeof (*child_ud->usb_client_attach_list), KM_SLEEP);

	child_ud->usb_client_ev_cb_list = kmem_zalloc(
		child_ud->usb_n_ifs *
		sizeof (*child_ud->usb_client_ev_cb_list), KM_SLEEP);

	mutex_exit(&child_ud->usb_mutex);

	/* ready the device node */
	child_dip = usba_ready_device_node(child_dip);

	/* set owner of default pipe to child dip */
	ph = usba_get_ph_data(def_ph);
	mutex_enter(&ph->p_mutex);
	mutex_enter(&ph->p_ph_impl->usba_ph_mutex);
	ph->p_ph_impl->usba_ph_dip = ph->p_dip = child_dip;
	mutex_exit(&ph->p_ph_impl->usba_ph_mutex);
	mutex_exit(&ph->p_mutex);

	return (child_dip);
}


/*
 * hubd_create_child
 *	- create child dip
 *	- open default pipe
 *	- get device descriptor
 *	- set the address
 *	- get device string descriptors
 *	- get the entire config cloud (all configurations) of the device
 *	- set user preferred configuration
 *	- close default pipe
 *	- load appropriate driver(s)
 */
static int
hubd_create_child(dev_info_t *dip,
		hubd_t		*hubd,
		usba_device_t	*hubd_ud,
		usb_port_status_t port_status,
		usb_port_t	port,
		int		iteration)
{
	dev_info_t		*child_dip = NULL;
	usb_dev_descr_t	usb_dev_descr;
	int			rval;
	usba_device_t		*child_ud = NULL;
	usba_device_t		*parent_ud = NULL;
	usb_pipe_handle_t	ph = NULL; /* default pipe handle */
	mblk_t			*pdata = NULL;
	usb_cr_t		completion_reason;
	int			user_conf_index, config_index;
	usb_cb_flags_t		cb_flags;
	uchar_t			address = 0;
	uint16_t		length;
	size_t			size;
	usb_addr_t		parent_usb_addr;
	usb_port_t		parent_usb_port;
	usba_device_t		*parent_usba_dev;
	usb_port_status_t	parent_port_status;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_create_child: port=%d", port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
	ASSERT(hubd->h_usba_devices[port] == NULL);

	mutex_exit(HUBD_MUTEX(hubd));

	/*
	 * create a dip which can be used to open the pipe. we set
	 * the name after getting the descriptors from the device
	 */
	rval = usba_create_child_devi(dip,
			"device",		/* driver name */
			hubd_ud->usb_hcdi_ops, /* usba_hcdi ops */
			hubd_ud->usb_root_hub_dip,
			port_status,		/* low speed device */
			child_ud,
			&child_dip);

	if (rval != USB_SUCCESS) {

		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "usb_create_child_devi failed (%d)", rval);

		goto fail_cleanup;
	}

	child_ud = usba_get_usba_device(child_dip);
	ASSERT(child_ud != NULL);

	parent_ud = hubd->h_usba_device;
	mutex_enter(&parent_ud->usb_mutex);
	parent_port_status = parent_ud->usb_port_status;

	/*
	 * To support split transactions, update address and port
	 * of high speed hub to which given device is connected.
	 */
	if (parent_port_status == USBA_HIGH_SPEED_DEV) {
		parent_usba_dev = parent_ud;
		parent_usb_addr = parent_ud->usb_addr;
		parent_usb_port = port;
	} else {
		parent_usba_dev = parent_ud->usb_hs_hub_usba_dev;
		parent_usb_addr = parent_ud->usb_hs_hub_addr;
		parent_usb_port = parent_ud->usb_hs_hub_port;
	}
	mutex_exit(&parent_ud->usb_mutex);

	mutex_enter(&child_ud->usb_mutex);
	address = child_ud->usb_addr;
	child_ud->usb_addr = 0;
	child_ud->usb_dev_descr = kmem_alloc(sizeof (usb_dev_descr_t),
	    KM_SLEEP);
	bzero(&usb_dev_descr, sizeof (usb_dev_descr_t));
	usb_dev_descr.bMaxPacketSize0 =
	    (port_status == USBA_LOW_SPEED_DEV) ? 8 : 64;
	bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
	    sizeof (usb_dev_descr_t));
	child_ud->usb_port = port;
	child_ud->usb_hs_hub_usba_dev = parent_usba_dev;
	child_ud->usb_hs_hub_addr = parent_usb_addr;
	child_ud->usb_hs_hub_port = parent_usb_port;
	mutex_exit(&child_ud->usb_mutex);

	/* Open the default pipe */
	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			"usb_pipe_open failed (%d)", rval);

		goto fail_cleanup;
	}

	/*
	 * get device descriptor
	 */
	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_create_child: get device descriptor: 64 bytes");

	rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
	    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
	    USB_REQ_GET_DESCR,			/* bRequest */
	    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
	    0,					/* wIndex */
	    64,					/* wLength */
	    &pdata, USB_ATTRS_SHORT_XFER_OK,
	    &completion_reason, &cb_flags, 0);

	if ((rval != USB_SUCCESS) &&
	    (!((completion_reason == USB_CR_DATA_OVERRUN) && pdata))) {

		/*
		 * rval != USB_SUCCESS AND
		 * completion_reason != USB_CR_DATA_OVERRUN
		 * pdata could be != NULL.
		 * Free pdata now to prevent memory leak.
		 */
		freemsg(pdata);
		pdata = NULL;

		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_create_child: get device descriptor: 8 bytes");

		rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
		    USB_REQ_GET_DESCR,			/* bRequest */
		    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
		    0,					/* wIndex */
		    8,					/* wLength */
		    &pdata, USB_ATTRS_NONE,
		    &completion_reason, &cb_flags, 0);

		if (rval != USB_SUCCESS) {
			USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "getting device descriptor failed (%s 0x%x %d)",
			    usb_str_cr(completion_reason), cb_flags, rval);
			goto fail_cleanup;
		}
	} else {
		ASSERT(completion_reason == USB_CR_OK);
	}

	ASSERT(pdata != NULL);

	size = usb_parse_dev_descr(
			pdata->b_rptr,
			pdata->b_wptr - pdata->b_rptr,
			&usb_dev_descr,
			sizeof (usb_dev_descr_t));

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "parsing device descriptor returned %lu", size);

	length = *(pdata->b_rptr);
	freemsg(pdata);
	pdata = NULL;
	if (size < 8) {
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "get device descriptor returned %lu bytes", size);

		goto fail_cleanup;
	}

	if (length < 8) {
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "fail enumeration: bLength=%d", length);

		goto fail_cleanup;
	}

	/* Set the address of the device */
	if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
	    USB_DEV_REQ_HOST_TO_DEV,
	    USB_REQ_SET_ADDRESS,	/* bRequest */
	    address,			/* wValue */
	    0,				/* wIndex */
	    0,				/* wLength */
	    NULL, 0,
	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
		char buffer[64];
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "setting address failed (cr=%s cb_flags=%s rval=%d)",
		    usb_str_cr(completion_reason),
		    usb_str_cb_flags(cb_flags, buffer, sizeof (buffer)),
		    rval);

		goto fail_cleanup;
	}

	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "set address 0x%x done", address);

	/* now close the pipe for addr 0 */
	usb_pipe_close(child_dip, ph,
	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);

	/*
	 * This delay is important for the CATC hub to enumerate
	 * But, avoid delay in the first iteration
	 */
	if (iteration) {
		delay(drv_usectohz(hubd_device_delay/100));
	}

	/* assign the address in the usba_device structure */
	mutex_enter(&child_ud->usb_mutex);
	child_ud->usb_addr = address;
	child_ud->usb_no_cpr = 0;
	child_ud->usb_port_status = port_status;
	/* save this device descriptor */
	bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
					sizeof (usb_dev_descr_t));
	child_ud->usb_n_cfgs = usb_dev_descr.bNumConfigurations;
	mutex_exit(&child_ud->usb_mutex);

	/* re-open the pipe for the device with the new address */
	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "usb_pipe_open failed (%d)", rval);

		goto fail_cleanup;
	}

	/*
	 * Get full device descriptor only if we have not received full
	 * device descriptor earlier.
	 */
	if (size < length) {
		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_create_child: get full device descriptor: "
		    "%d bytes", length);

		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
		    USB_REQ_GET_DESCR,			/* bRequest */
		    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
		    0,					/* wIndex */
		    length,				/* wLength */
		    &pdata, 0,
		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
			freemsg(pdata);
			pdata = NULL;

			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
			    hubd->h_log_handle,
			    "hubd_create_child: get full device descriptor: "
			    "64 bytes");

			rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
			    USB_DEV_REQ_DEV_TO_HOST |
			    USB_DEV_REQ_TYPE_STANDARD,
			    USB_REQ_GET_DESCR,		/* bRequest */
			    USB_DESCR_TYPE_SETUP_DEV,	/* wValue */
			    0,				/* wIndex */
			    64,				/* wLength */
			    &pdata, USB_ATTRS_SHORT_XFER_OK,
			    &completion_reason, &cb_flags, 0);

			/* we have to trust the data now */
			if (pdata) {
				int len = *(pdata->b_rptr);

				length = pdata->b_wptr - pdata->b_rptr;
				if (length < len) {

					goto fail_cleanup;
				}
			} else if (rval != USB_SUCCESS) {
				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
				    hubd->h_log_handle,
				    "getting device descriptor failed "
				    "(%d 0x%x %d)",
				completion_reason, cb_flags, rval);

				goto fail_cleanup;
			}
		}

		size = usb_parse_dev_descr(
				pdata->b_rptr,
				pdata->b_wptr - pdata->b_rptr,
				&usb_dev_descr,
				sizeof (usb_dev_descr_t));

		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "parsing device descriptor returned %lu", size);

		/*
		 * For now, free the data
		 * eventually, each configuration may need to be looked at
		 */
		freemsg(pdata);
		pdata = NULL;

		if (size != USB_DEV_DESCR_SIZE) {
			USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "fail enumeration: descriptor size=%lu "
			    "expected size=%u", size, USB_DEV_DESCR_SIZE);

			goto fail_cleanup;
		}

		/*
		 * save the device descriptor in usba_device since it is needed
		 * later on again
		 */
		mutex_enter(&child_ud->usb_mutex);
		bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
			sizeof (usb_dev_descr_t));
		child_ud->usb_n_cfgs = usb_dev_descr.bNumConfigurations;
		mutex_exit(&child_ud->usb_mutex);
	}

	if (usb_dev_descr.bNumConfigurations == 0) {
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "device descriptor:\n\t"
		    "l=0x%x type=0x%x USB=0x%x class=0x%x subclass=0x%x\n\t"
		    "protocol=0x%x maxpktsize=0x%x "
		    "Vid=0x%x Pid=0x%x rel=0x%x\n\t"
		    "Mfg=0x%x P=0x%x sn=0x%x #config=0x%x",
		    usb_dev_descr.bLength, usb_dev_descr.bDescriptorType,
		    usb_dev_descr.bcdUSB, usb_dev_descr.bDeviceClass,
		    usb_dev_descr.bDeviceSubClass,
		    usb_dev_descr.bDeviceProtocol,
		    usb_dev_descr.bMaxPacketSize0,
		    usb_dev_descr.idVendor,
		    usb_dev_descr.idProduct, usb_dev_descr.bcdDevice,
		    usb_dev_descr.iManufacturer, usb_dev_descr.iProduct,
		    usb_dev_descr.iSerialNumber,
		    usb_dev_descr.bNumConfigurations);
		goto fail_cleanup;
	}


	/* get the device string descriptor(s) */
	usba_get_dev_string_descrs(child_dip, child_ud);

	/* retrieve config cloud for all configurations */
	rval = hubd_get_all_device_config_cloud(hubd, child_dip, child_ud);
	if (rval != USB_SUCCESS) {
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "failed to get configuration descriptor(s)");

		goto fail_cleanup;
	}

	/* get the preferred configuration for this device */
	user_conf_index = hubd_select_device_configuration(hubd, port,
	    child_dip, child_ud);

	/* Check if the user selected configuration index is in range */
	if (user_conf_index >= usb_dev_descr.bNumConfigurations) {
		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "Configuration index for device idVendor=%d "
		    "idProduct=%d is=%d, and is out of range[0..%d]",
		    usb_dev_descr.idVendor, usb_dev_descr.idProduct,
		    user_conf_index, usb_dev_descr.bNumConfigurations - 1);

		/* treat this as user didn't specify configuration */
		user_conf_index = USBA_DEV_CONFIG_INDEX_UNDEFINED;
	}


	/*
	 * Warn users of a performance hit if connecting a
	 * High Speed behind a 1.1 hub, which is behind a
	 * 2.0 port.
	 */
	if ((parent_port_status != USBA_HIGH_SPEED_DEV) &&
	    !(usba_is_root_hub(parent_ud->usb_dip)) &&
	    (parent_usb_addr)) {

		/*
		 * Now that we know the root port is a high speed port
		 * and that the parent port is not a high speed port,
		 * let's find out if the device itself is a high speed
		 * device.  If it is a high speed device,
		 * USB_DESCR_TYPE_SETUP_DEV_QLF should return a value,
		 * otherwise the command will fail.
		 */
		rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
		    USB_REQ_GET_DESCR,			/* bRequest */
		    USB_DESCR_TYPE_SETUP_DEV_QLF,	/* wValue */
		    0,					/* wIndex */
		    10,					/* wLength */
		    &pdata, USB_ATTRS_SHORT_XFER_OK,
		    &completion_reason, &cb_flags, 0);

		if (pdata) {
			freemsg(pdata);
			pdata = NULL;
		}

		/*
		 * USB_DESCR_TYPE_SETUP_DEV_QLF query was successful
		 * that means this is a high speed device behind a
		 * high speed root hub, but running at full speed
		 * because there is a full speed hub in the middle.
		 */
		if (rval == USB_SUCCESS) {
		    USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
			hubd->h_log_handle,
			"Connecting a high speed device to a "
			"non high speed hub (port %d) will result "
			"in a loss of performance.  Please connect "
			"the device to a high speed hub to get "
			"the maximum performance.",
			port);
		}
	}

	/*
	 * Now we try to online the device by attaching a driver
	 * The following truth table illustrates the logic:-
	 * Cfgndx	Driver	Action
	 * 0		0	loop all configs for driver with full
	 *			compatible properties.
	 * 0		1	set first configuration,
	 *			compatible prop = drivername.
	 * 1		0	Set config, full compatible prop
	 * 1		1	Set config, compatible prop = drivername.
	 *
	 * Note:
	 *	cfgndx = user_conf_index
	 *	Driver = usb_preferred_driver
	 */
	if (user_conf_index == USBA_DEV_CONFIG_INDEX_UNDEFINED) {
		if (child_ud->usb_preferred_driver) {
			/*
			 * It is the job of the "preferred driver" to put the
			 * device in the desired configuration. Till then
			 * put the device in config index 0.
			 */
			child_dip = hubd_ready_device(hubd, child_dip,
			    child_ud, USB_DEV_DEFAULT_CONFIG_INDEX);

			/*
			 * Assign the dip before onlining to avoid race
			 * with busctl
			 */
			mutex_enter(HUBD_MUTEX(hubd));
			hubd->h_children_dips[port] = child_dip;
			mutex_exit(HUBD_MUTEX(hubd));

			(void) usba_bind_driver(child_dip);
		} else {
			/*
			 * loop through all the configurations to see if we
			 * can find a driver for any one config. If not, set
			 * the device in config_index 0
			 */
			rval = USB_FAILURE;
			for (config_index = 0;
			    (config_index < usb_dev_descr.bNumConfigurations) &&
			    (rval != USB_SUCCESS); config_index++) {

				child_dip = hubd_ready_device(hubd, child_dip,
				    child_ud, config_index);

				/*
				 * Assign the dip before onlining to avoid race
				 * with busctl
				 */
				mutex_enter(HUBD_MUTEX(hubd));
				hubd->h_children_dips[port] = child_dip;
				mutex_exit(HUBD_MUTEX(hubd));

				rval = usba_bind_driver(child_dip);
			}
			if (rval != USB_SUCCESS) {
				child_dip = hubd_ready_device(hubd, child_dip,
				    child_ud, 0);
				mutex_enter(HUBD_MUTEX(hubd));
				hubd->h_children_dips[port] = child_dip;
				mutex_exit(HUBD_MUTEX(hubd));
			}
		} /* end else loop all configs */
	} else {
		child_dip = hubd_ready_device(hubd, child_dip,
		    child_ud, user_conf_index);

		/*
		 * Assign the dip before onlining to avoid race
		 * with busctl
		 */
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_children_dips[port] = child_dip;
		mutex_exit(HUBD_MUTEX(hubd));

		(void) usba_bind_driver(child_dip);
	}

	mutex_enter(HUBD_MUTEX(hubd));
	if (hubd->h_usba_devices[port] == NULL) {
		hubd->h_usba_devices[port] = usba_get_usba_device(child_dip);
	} else {
		ASSERT(hubd->h_usba_devices[port] ==
				usba_get_usba_device(child_dip));
	}

	return (USB_SUCCESS);


fail_cleanup:
	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_create_child: fail_cleanup");

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_children_dips[port] = NULL;
	mutex_exit(HUBD_MUTEX(hubd));

	if (pdata) {
		freemsg(pdata);
	}

	if (ph) {
		usb_pipe_close(child_dip, ph,
		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
	}

	if (child_dip) {
		int rval = usba_destroy_child_devi(child_dip,
		    NDI_DEVI_REMOVE);
		if (rval != USB_SUCCESS) {
			USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "failure to remove child node");
		}
	}

	if (child_ud) {
		/* to make sure we free the address */
		mutex_enter(&child_ud->usb_mutex);
		child_ud->usb_addr = address;
		ASSERT(child_ud->usb_ref_count == 0);
		mutex_exit(&child_ud->usb_mutex);

		mutex_enter(HUBD_MUTEX(hubd));
		if (hubd->h_usba_devices[port] == NULL) {
			mutex_exit(HUBD_MUTEX(hubd));
			usba_free_usba_device(child_ud);
		} else {
			hubd_free_usba_device(hubd, hubd->h_usba_devices[port]);
			mutex_exit(HUBD_MUTEX(hubd));
		}
	}

	mutex_enter(HUBD_MUTEX(hubd));

	return (USB_FAILURE);
}


/*
 * hubd_delete_child:
 *	- free usb address
 *	- lookup child dips, there may be multiple on this port
 *	- offline each child devi
 */
static int
hubd_delete_child(hubd_t *hubd, usb_port_t port, uint_t flag, boolean_t retry)
{
	dev_info_t	*child_dip;
	usba_device_t	*usba_device;
	int		rval = USB_SUCCESS;

	child_dip = hubd->h_children_dips[port];

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_delete_child: port=%d, dip=0x%p usba_device=0x%p",
	    port, child_dip);

	mutex_exit(HUBD_MUTEX(hubd));
	if (child_dip) {
		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_delete_child:\n\t"
		    "dip = 0x%p (%s) at port %d",
		    child_dip, ddi_node_name(child_dip), port);

		rval = usba_destroy_child_devi(child_dip, flag);

		if ((rval == USB_SUCCESS) && (flag & NDI_DEVI_REMOVE)) {
			/*
			 * if the child was still < DS_INITIALIZED
			 * then our bus_unconfig was not called and
			 * we have to zap the child here
			 */
			mutex_enter(HUBD_MUTEX(hubd));
			if (hubd->h_children_dips[port] == child_dip) {
				usba_device_t *ud =
						hubd->h_usba_devices[port];
				hubd->h_children_dips[port] = NULL;
				if (ud) {
					mutex_exit(HUBD_MUTEX(hubd));

					mutex_enter(&ud->usb_mutex);
					ud->usb_ref_count = 0;
					mutex_exit(&ud->usb_mutex);

					usba_free_usba_device(ud);
					mutex_enter(HUBD_MUTEX(hubd));
					hubd->h_usba_devices[port] = NULL;
				}
			}
			mutex_exit(HUBD_MUTEX(hubd));
		}
	}

	if ((rval != USB_SUCCESS) && retry) {
		mutex_enter(HUBD_MUTEX(hubd));
		usba_device = hubd->h_usba_devices[port];
		mutex_exit(HUBD_MUTEX(hubd));

		hubd_schedule_cleanup(usba_device->usb_root_hub_dip);
	}
	mutex_enter(HUBD_MUTEX(hubd));

	return (rval);
}


/*
 * hubd_free_usba_device:
 *	free usb device structure unless it is associated with
 *	the root hub which is handled differently
 */
static void
hubd_free_usba_device(hubd_t *hubd, usba_device_t *usba_device)
{
	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_free_usba_device: hubd=0x%p, usba_device=0x%p",
	    hubd, usba_device);

	if (usba_device && (usba_device->usb_addr != ROOT_HUB_ADDR)) {
		usb_port_t port = usba_device->usb_port;
		dev_info_t *dip = hubd->h_children_dips[port];

#ifdef DEBUG
		if (dip) {
			ASSERT(i_ddi_node_state(dip) < DS_INITIALIZED);
		}
#endif

		port = usba_device->usb_port;
		hubd->h_usba_devices[port] = NULL;

		mutex_exit(HUBD_MUTEX(hubd));
		usba_free_usba_device(usba_device);
		mutex_enter(HUBD_MUTEX(hubd));
	}
}


/*
 * event support
 *
 * busctl event support
 */
static int
hubd_busop_get_eventcookie(dev_info_t *dip,
	dev_info_t	*rdip,
	char		*eventname,
	ddi_eventcookie_t *cookie)
{
	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);

	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_busop_get_eventcookie: dip=0x%p, rdip=0x%p, "
	    "event=%s", (void *)dip, (void *)rdip, eventname);
	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "(dip=%s%d, rdip=%s%d)",
	    ddi_driver_name(dip), ddi_get_instance(dip),
	    ddi_driver_name(rdip), ddi_get_instance(rdip));

	/* return event cookie, iblock cookie, and level */
	return (ndi_event_retrieve_cookie(hubd->h_ndi_event_hdl,
		rdip, eventname, cookie, NDI_EVENT_NOPASS));
}


static int
hubd_busop_add_eventcall(dev_info_t *dip,
	dev_info_t	*rdip,
	ddi_eventcookie_t cookie,
	void		(*callback)(dev_info_t *dip,
			ddi_eventcookie_t cookie, void *arg,
			void *bus_impldata),
	void *arg, ddi_callback_id_t *cb_id)
{
	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
	usb_port_t port = hubd_child_dip2port(hubd, rdip);

	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_busop_add_eventcall: dip=0x%p, rdip=0x%p "
	    "cookie=0x%p, cb=0x%p, arg=0x%p",
	    (void *)dip, (void *)rdip, (void *)cookie, (void *)callback, arg);
	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "(dip=%s%d, rdip=%s%d, event=%s)",
	    ddi_driver_name(dip), ddi_get_instance(dip),
	    ddi_driver_name(rdip), ddi_get_instance(rdip),
	    ndi_event_cookie_to_name(hubd->h_ndi_event_hdl, cookie));

	/* Set flag on children registering events */
	switch (ndi_event_cookie_to_tag(hubd->h_ndi_event_hdl, cookie)) {
	case USBA_EVENT_TAG_HOT_REMOVAL:
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_DISCONNECT;
		mutex_exit(HUBD_MUTEX(hubd));

		break;
	case USBA_EVENT_TAG_PRE_SUSPEND:
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_PRESUSPEND;
		mutex_exit(HUBD_MUTEX(hubd));

		break;
	default:

		break;
	}

	/* add callback to our event set */
	return (ndi_event_add_callback(hubd->h_ndi_event_hdl,
		rdip, cookie, callback, arg, NDI_SLEEP, cb_id));
}


static int
hubd_busop_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
{
	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
	ndi_event_callbacks_t *id = (ndi_event_callbacks_t *)cb_id;

	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_busop_remove_eventcall: dip=0x%p, rdip=0x%p "
	    "cookie=0x%p", (void *)dip, id->ndi_evtcb_dip,
	    id->ndi_evtcb_cookie);
	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "(dip=%s%d, rdip=%s%d, event=%s)",
	    ddi_driver_name(dip), ddi_get_instance(dip),
	    ddi_driver_name(id->ndi_evtcb_dip),
	    ddi_get_instance(id->ndi_evtcb_dip),
	    ndi_event_cookie_to_name(hubd->h_ndi_event_hdl,
	    id->ndi_evtcb_cookie));

	/* remove event registration from our event set */
	return (ndi_event_remove_callback(hubd->h_ndi_event_hdl, cb_id));
}


/*
 * event distribution
 *
 * hubd_do_callback:
 *	Post this event to the specified child
 */
static void
hubd_do_callback(hubd_t *hubd, dev_info_t *cdip, ddi_eventcookie_t cookie)
{
	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_do_callback");

	(void) ndi_event_do_callback(hubd->h_ndi_event_hdl, cdip, cookie, NULL);
}


/*
 * hubd_run_callbacks:
 *	Send this event to all children
 */
static void
hubd_run_callbacks(hubd_t *hubd, usba_event_t type)
{
	usb_port_t	port;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_run_callbacks");

	mutex_enter(HUBD_MUTEX(hubd));
	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
		/*
		 * the childen_dips list may have dips that have been
		 * already deallocated. we only get a post_detach notification
		 * but not a destroy notification
		 */
		if (hubd->h_children_dips[port]) {
			mutex_exit(HUBD_MUTEX(hubd));
			hubd_post_event(hubd, port, type);
			mutex_enter(HUBD_MUTEX(hubd));
		}
	}
	mutex_exit(HUBD_MUTEX(hubd));
}


/*
 * hubd_post_event
 *	post event to a child on the port depending on the type
 */
static void
hubd_post_event(hubd_t *hubd, usb_port_t port, usba_event_t type)
{
	int	rval;
	dev_info_t	*dip;
	usba_device_t	*usba_device;
	ddi_eventcookie_t cookie, rm_cookie, suspend_cookie;

	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_post_event: port=%d event=%s", port,
	    ndi_event_tag_to_name(hubd->h_ndi_event_hdl, type));

	cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl, type);
	rm_cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl,
	    USBA_EVENT_TAG_HOT_REMOVAL);
	suspend_cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl,
	    USBA_EVENT_TAG_PRE_SUSPEND);

	/*
	 * Hotplug daemon may be attaching a driver that may be registering
	 * event callbacks. So it already has got the device tree lock and
	 * event handle mutex. So to prevent a deadlock while posting events,
	 * we grab and release the locks in the same order.
	 */
	mutex_enter(HUBD_MUTEX(hubd));
	dip = hubd->h_children_dips[port];
	usba_device = hubd->h_usba_devices[port];
	mutex_exit(HUBD_MUTEX(hubd));

	switch (type) {
	case USBA_EVENT_TAG_HOT_REMOVAL:
		/* Clear the registered event flag */
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_child_events[port] &= ~HUBD_CHILD_EVENT_DISCONNECT;
		mutex_exit(HUBD_MUTEX(hubd));

		hubd_do_callback(hubd, dip, cookie);
		usba_persistent_pipe_close(usba_device);

		/*
		 * Mark the dip for deletion only after the driver has
		 * seen the disconnect event to prevent cleanup thread
		 * from stepping in between.
		 */
		DEVI_SET_DEVICE_REMOVED(dip);

		break;
	case USBA_EVENT_TAG_PRE_SUSPEND:
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_child_events[port] &= ~HUBD_CHILD_EVENT_PRESUSPEND;
		mutex_exit(HUBD_MUTEX(hubd));

		hubd_do_callback(hubd, dip, cookie);
		/*
		 * persistent pipe close for this event is taken care by the
		 * caller after verfying that all children can suspend
		 */

		break;
	case USBA_EVENT_TAG_HOT_INSERTION:
		/*
		 * Check if this child has missed the disconnect event before
		 * it registered for event callbacks
		 */
		mutex_enter(HUBD_MUTEX(hubd));
		if (hubd->h_child_events[port] & HUBD_CHILD_EVENT_DISCONNECT) {
			/* clear the flag and post disconnect event */
			hubd->h_child_events[port] &=
			    ~HUBD_CHILD_EVENT_DISCONNECT;
			mutex_exit(HUBD_MUTEX(hubd));
			hubd_do_callback(hubd, dip, rm_cookie);
			usba_persistent_pipe_close(usba_device);
			mutex_enter(HUBD_MUTEX(hubd));
		}
		mutex_exit(HUBD_MUTEX(hubd));

		/*
		 * Mark the dip as reinserted to prevent cleanup thread
		 * from stepping in.
		 */
		DEVI_SET_DEVICE_REINSERTED(dip);

		rval = usba_persistent_pipe_open(usba_device);
		if (rval != USB_SUCCESS) {
			USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
			    hubd->h_log_handle,
			    "failed to reopen all pipes on reconnect");
		}

		hubd_do_callback(hubd, dip, cookie);

		/*
		 * We might see a connect event only if hotplug thread for
		 * disconnect event don't run in time.
		 * Set the flag again, so we don't miss posting a
		 * disconnect event.
		 */
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_DISCONNECT;
		mutex_exit(HUBD_MUTEX(hubd));

		break;
	case USBA_EVENT_TAG_POST_RESUME:
		/*
		 * Check if this child has missed the pre-suspend event before
		 * it registered for event callbacks
		 */
		mutex_enter(HUBD_MUTEX(hubd));
		if (hubd->h_child_events[port] & HUBD_CHILD_EVENT_PRESUSPEND) {
			/* clear the flag and post pre_suspend event */
			hubd->h_port_state[port] &=
			    ~HUBD_CHILD_EVENT_PRESUSPEND;
			mutex_exit(HUBD_MUTEX(hubd));
			hubd_do_callback(hubd, dip, suspend_cookie);
			mutex_enter(HUBD_MUTEX(hubd));
		}
		mutex_exit(HUBD_MUTEX(hubd));

		mutex_enter(&usba_device->usb_mutex);
		usba_device->usb_no_cpr = 0;
		mutex_exit(&usba_device->usb_mutex);

		/*
		 * Since the pipe has already been opened by hub
		 * at DDI_RESUME time, there is no need for a
		 * persistent pipe open
		 */
		hubd_do_callback(hubd, dip, cookie);

		/*
		 * Set the flag again, so we don't miss posting a
		 * pre-suspend event. This enforces a tighter
		 * dev_state model.
		 */
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_PRESUSPEND;
		mutex_exit(HUBD_MUTEX(hubd));
		break;
	}
}


/*
 * handling of events coming from above
 */
static int
hubd_disconnect_event_cb(dev_info_t *dip)
{
	hubd_t		*hubd = (hubd_t *)hubd_get_soft_state(dip);
	usb_port_t	port, nports;
	usba_device_t	*usba_dev;
	usba_event_t	tag = USBA_EVENT_TAG_HOT_REMOVAL;
	int		circ;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_disconnect_event_cb: tag=%d", tag);

	ndi_devi_enter(dip, &circ);

	mutex_enter(HUBD_MUTEX(hubd));
	switch (hubd->h_dev_state) {
	case USB_DEV_ONLINE:
	case USB_DEV_PWRED_DOWN:
		hubd->h_dev_state = USB_DEV_DISCONNECTED;
		/* stop polling on the interrupt pipe */
		hubd_stop_polling(hubd);

		/* FALLTHROUGH */
	case USB_DEV_SUSPENDED:
		/* we remain in this state */
		mutex_exit(HUBD_MUTEX(hubd));
		hubd_run_callbacks(hubd, tag);
		mutex_enter(HUBD_MUTEX(hubd));

		/* close all the open pipes of our children */
		nports = hubd->h_hub_descr.bNbrPorts;
		for (port = 1; port <= nports; port++) {
			usba_dev = hubd->h_usba_devices[port];
			if (usba_dev != NULL) {
				mutex_exit(HUBD_MUTEX(hubd));
				usba_persistent_pipe_close(usba_dev);
				mutex_enter(HUBD_MUTEX(hubd));
			}
		}

		break;
	case USB_DEV_DISCONNECTED:
		/* avoid passing multiple disconnects to children */
		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_disconnect_event_cb: Already disconnected");

		break;
	default:
		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_disconnect_event_cb: Illegal devstate=%d",
		    hubd->h_dev_state);

		break;
	}
	mutex_exit(HUBD_MUTEX(hubd));

	ndi_devi_exit(dip, circ);

	return (USB_SUCCESS);
}


static int
hubd_reconnect_event_cb(dev_info_t *dip)
{
	int	rval, circ;

	ndi_devi_enter(dip, &circ);
	rval = hubd_restore_state_cb(dip);
	ndi_devi_exit(dip, circ);

	return (rval);
}


/*
 * hubd_pre_suspend_event_cb
 *	propogate event for binary compatibility of old drivers
 */
static int
hubd_pre_suspend_event_cb(dev_info_t *dip)
{
	int	circ;
	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);

	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
	    "hubd_pre_suspend_event_cb");

	/* disable hotplug thread */
	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_hotplug_thread++;
	hubd_stop_polling(hubd);

	/* keep PM out till we see a cpr resume */
	(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	ndi_devi_enter(dip, &circ);
	hubd_run_callbacks(hubd, USBA_EVENT_TAG_PRE_SUSPEND);
	ndi_devi_exit(dip, circ);

	return (USB_SUCCESS);
}


/*
 * hubd_post_resume_event_cb
 *	propogate event for binary compatibility of old drivers
 */
static int
hubd_post_resume_event_cb(dev_info_t *dip)
{
	int	circ;
	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);

	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
	    "hubd_post_resume_event_cb");

	ndi_devi_enter(dip, &circ);
	hubd_run_callbacks(hubd, USBA_EVENT_TAG_POST_RESUME);
	ndi_devi_exit(dip, circ);

	mutex_enter(HUBD_MUTEX(hubd));

	/* enable PM */
	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);

	/* allow hotplug thread */
	hubd->h_hotplug_thread--;

	/* start polling */
	hubd_start_polling(hubd, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	return (USB_SUCCESS);
}


/*
 * hubd_cpr_suspend
 *	save the current state of the driver/device
 */
static int
hubd_cpr_suspend(hubd_t *hubd)
{
	usb_port_t	port, nports;
	usba_device_t	*usba_dev;
	uchar_t		no_cpr = 0;
	int		rval = USB_FAILURE;

	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_cpr_suspend: Begin");

	/* Make sure device is powered up to save state. */
	mutex_enter(HUBD_MUTEX(hubd));
	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	/* bring the device to full power */
	(void) pm_raise_power(hubd->h_dip, 0, USB_DEV_OS_FULL_PWR);
	mutex_enter(HUBD_MUTEX(hubd));

	switch (hubd->h_dev_state) {
	case USB_DEV_ONLINE:
	case USB_DEV_PWRED_DOWN:
	case USB_DEV_DISCONNECTED:
		/* find out if all our children have been quiesced */
		nports = hubd->h_hub_descr.bNbrPorts;
		for (port = 1; (no_cpr == 0) && (port <= nports); port++) {
			usba_dev = hubd->h_usba_devices[port];
			if (usba_dev != NULL) {
				mutex_enter(&usba_dev->usb_mutex);
				no_cpr += usba_dev->usb_no_cpr;
				mutex_exit(&usba_dev->usb_mutex);
			}
		}
		if (no_cpr > 0) {
			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
			    "Children busy - can't checkpoint");
			/* remain in same state to fail checkpoint */

			break;
		} else {
			/*
			 * do not suspend if our hotplug thread
			 * or the deathrow thread is active
			 */
			if ((hubd->h_hotplug_thread > 1) ||
			    (hubd->h_cleanup_active == B_TRUE)) {
				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
				    hubd->h_log_handle,
				    "hotplug thread active  - can't cpr");
				/* remain in same state to fail checkpoint */

				break;
			}

			/* quiesce ourselves now */
			hubd->h_dev_state = USB_DEV_SUSPENDED;
			hubd_stop_polling(hubd);

			/* close all the open pipes of our children */
			for (port = 1; port <= nports; port++) {
				usba_dev = hubd->h_usba_devices[port];
				if (usba_dev != NULL) {
					mutex_exit(HUBD_MUTEX(hubd));
					usba_persistent_pipe_close(usba_dev);
					mutex_enter(HUBD_MUTEX(hubd));
				}
			}
			/*
			 * turn off power to all the ports so that we
			 * don't see any spurious activity
			 */
			(void) hubd_disable_all_port_power(hubd);

			/*
			 * if we are the root hub, we close our pipes
			 * ourselves.
			 */
			if (usba_is_root_hub(hubd->h_dip)) {
				mutex_exit(HUBD_MUTEX(hubd));
				usba_persistent_pipe_close(
				    usba_get_usba_device(hubd->h_dip));
				mutex_enter(HUBD_MUTEX(hubd));
			}
			rval = USB_SUCCESS;

			break;
		}
	case USB_DEV_SUSPENDED:
	default:
		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
		    "hubd_cpr_suspend: Illegal dev state=%d",
		    hubd->h_dev_state);

		break;
	}

	hubd_pm_idle_component(hubd, hubd->h_dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	return (rval);
}

static void
hubd_cpr_resume(dev_info_t *dip)
{
	int	rval, circ;

	ndi_devi_enter(dip, &circ);
	/*
	 * if we are the root hub, we open our pipes
	 * ourselves.
	 */
	if (usba_is_root_hub(dip)) {
		rval = usba_persistent_pipe_open(
		    usba_get_usba_device(dip));
		ASSERT(rval == USB_SUCCESS);
	}
	(void) hubd_restore_state_cb(dip);
	ndi_devi_exit(dip, circ);
}


/*
 * hubd_restore_state_cb
 *	Event callback to restore device state
 */
static int
hubd_restore_state_cb(dev_info_t *dip)
{
	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);

	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
	    "hubd_restore_state_cb: Begin");

	/* restore the state of this device */
	hubd_restore_device_state(dip, hubd);

	return (USB_SUCCESS);
}


/*
 * registering for events
 */
static int
hubd_register_events(hubd_t *hubd)
{
	int		rval = USB_SUCCESS;

	if (usba_is_root_hub(hubd->h_dip)) {
		hubd_register_cpr_callback(hubd);
	} else {
		rval = usb_register_event_cbs(hubd->h_dip, &hubd_events, 0);
	}

	return (rval);
}


/*
 * hubd cpr callback related functions
 *
 * hubd_cpr_post_user_callb:
 *	This function is called during checkpoint & resume -
 *		1. after user threads are stopped during checkpoint
 *		2. after kernel threads are resumed during resume
 */
/* ARGSUSED */
static boolean_t
hubd_cpr_post_user_callb(void *arg, int code)
{
	hubd_cpr_t	*cpr_cb = (hubd_cpr_t *)arg;
	hubd_t		*hubd = cpr_cb->statep;
	int		retry = 0;

	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
	    "hubd_cpr_post_user_callb");

	switch (code) {
	case CB_CODE_CPR_CHKPT:
		USB_DPRINTF_L3(DPRINT_MASK_EVENTS, hubd->h_log_handle,
		    "hubd_cpr_post_user_callb: CB_CODE_CPR_CHKPT");

		mutex_enter(HUBD_MUTEX(hubd));

		/* turn off deathrow thread */
		hubd->h_cleanup_enabled = B_FALSE;

		/* give up if deathrow thread doesn't exit */
		while ((hubd->h_cleanup_active == B_TRUE) && (retry++ < 3)) {
			mutex_exit(HUBD_MUTEX(hubd));
			delay(drv_usectohz(hubd_dip_cleanup_delay));

			USB_DPRINTF_L2(DPRINT_MASK_EVENTS, hubd->h_log_handle,
			    "hubd_cpr_post_user_callb, waiting for "
			    "deathrow thread to exit");
			mutex_enter(HUBD_MUTEX(hubd));
		}

		mutex_exit(HUBD_MUTEX(hubd));

		/* save the state of the device */
		(void) hubd_pre_suspend_event_cb(hubd->h_dip);

		return (B_TRUE);
	case CB_CODE_CPR_RESUME:
		USB_DPRINTF_L3(DPRINT_MASK_EVENTS, hubd->h_log_handle,
		    "hubd_cpr_post_user_callb: CB_CODE_CPR_RESUME");

		/* restore the state of the device */
		(void) hubd_post_resume_event_cb(hubd->h_dip);

		/* turn on deathrow thread */
		mutex_enter(HUBD_MUTEX(hubd));
		hubd->h_cleanup_enabled = B_TRUE;
		mutex_exit(HUBD_MUTEX(hubd));

		hubd_schedule_cleanup(hubd->h_usba_device->usb_root_hub_dip);

		return (B_TRUE);
	default:

		return (B_FALSE);
	}

}


/* register callback with cpr framework */
void
hubd_register_cpr_callback(hubd_t *hubd)
{
	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
	    "hubd_register_cpr_callback");

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_cpr_cb =
	    (hubd_cpr_t *)kmem_zalloc(sizeof (hubd_cpr_t), KM_SLEEP);
	mutex_exit(HUBD_MUTEX(hubd));
	mutex_init(&hubd->h_cpr_cb->lockp, NULL, MUTEX_DRIVER,
	    hubd->h_dev_data->dev_iblock_cookie);
	hubd->h_cpr_cb->statep = hubd;
	hubd->h_cpr_cb->cpr.cc_lockp = &hubd->h_cpr_cb->lockp;
	hubd->h_cpr_cb->cpr.cc_id = callb_add(hubd_cpr_post_user_callb,
	    (void *)hubd->h_cpr_cb, CB_CL_CPR_POST_USER, "hubd");
}


/* unregister callback with cpr framework */
void
hubd_unregister_cpr_callback(hubd_t *hubd)
{
	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
	    "hubd_unregister_cpr_callback");

	if (hubd->h_cpr_cb) {
		(void) callb_delete(hubd->h_cpr_cb->cpr.cc_id);
		mutex_destroy(&hubd->h_cpr_cb->lockp);
		mutex_enter(HUBD_MUTEX(hubd));
		kmem_free(hubd->h_cpr_cb, sizeof (hubd_cpr_t));
		mutex_exit(HUBD_MUTEX(hubd));
	}
}


/*
 * Power management
 *
 * create the pm components required for power management
 */
static void
hubd_create_pm_components(dev_info_t *dip, hubd_t *hubd)
{
	hub_power_t	*hubpm;

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_create_pm_components: Begin");

	/* Allocate the state structure */
	hubpm = kmem_zalloc(sizeof (hub_power_t), KM_SLEEP);

	hubd->h_hubpm = hubpm;
	hubpm->hubp_hubd = hubd;
	hubpm->hubp_pm_capabilities = 0;
	hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
	hubpm->hubp_time_at_full_power = ddi_get_time();
	hubpm->hubp_min_pm_threshold = hubdi_min_pm_threshold;

	/* alloc memory to save power states of children */
	hubpm->hubp_child_pwrstate = (uint8_t *)
		kmem_zalloc(MAX_PORTS + 1, KM_SLEEP);

	/*
	 * if the enable remote wakeup fails
	 * we still want to enable
	 * parent notification so we can PM the children
	 */
	usb_enable_parent_notification(dip);

	if (usb_handle_remote_wakeup(dip,
	    USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS) {
		uint_t		pwr_states;

		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
		    "hubd_create_pm_components: "
		    "Remote Wakeup Enabled");

		if (usb_create_pm_components(dip, &pwr_states) ==
		    USB_SUCCESS) {
			mutex_enter(HUBD_MUTEX(hubd));
			hubpm->hubp_wakeup_enabled = 1;
			hubpm->hubp_pwr_states = (uint8_t)pwr_states;

			/* we are busy now till end of the attach */
			hubd_pm_busy_component(hubd, dip, 0);
			mutex_exit(HUBD_MUTEX(hubd));

			/* bring the device to full power */
			(void) pm_raise_power(dip, 0,
			    USB_DEV_OS_FULL_PWR);
		}
	}

	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
	    "hubd_create_pm_components: END");
}


/*
 * Attachment point management
 */
/* ARGSUSED */
int
usba_hubdi_open(dev_info_t *dip, dev_t *devp, int flags, int otyp,
	cred_t *credp)
{
	hubd_t *hubd;

	if (otyp != OTYP_CHR)
		return (EINVAL);

	hubd = hubd_get_soft_state(dip);
	if (hubd == NULL) {
		return (ENXIO);
	}

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
	    "hubd_open:");

	mutex_enter(HUBD_MUTEX(hubd));
	if ((flags & FEXCL) && (hubd->h_softstate & HUBD_SS_ISOPEN)) {
		mutex_exit(HUBD_MUTEX(hubd));

		return (EBUSY);
	}

	hubd->h_softstate |= HUBD_SS_ISOPEN;
	mutex_exit(HUBD_MUTEX(hubd));

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "opened");

	return (0);
}


/* ARGSUSED */
int
usba_hubdi_close(dev_info_t *dip, dev_t dev, int flag, int otyp,
	cred_t *credp)
{
	hubd_t *hubd;

	if (otyp != OTYP_CHR) {
		return (EINVAL);
	}

	hubd = hubd_get_soft_state(dip);

	if (hubd == NULL) {
		return (ENXIO);
	}

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "hubd_close:");

	mutex_enter(HUBD_MUTEX(hubd));
	hubd->h_softstate &= ~HUBD_SS_ISOPEN;
	mutex_exit(HUBD_MUTEX(hubd));

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "closed");

	return (0);
}


/*
 * hubd_ioctl: cfgadm controls
 */
/* ARGSUSED */
int
usba_hubdi_ioctl(dev_info_t *self, dev_t dev, int cmd, intptr_t arg,
	int mode, cred_t *credp, int *rvalp)
{
	int			rv = 0;
	char			*msg;	/* for messages */
	hubd_t			*hubd;
	usb_port_t		port = 0;
	dev_info_t		*child_dip = NULL;
	dev_info_t		*rh_dip;
	devctl_ap_state_t	ap_state;
	struct devctl_iocdata	*dcp = NULL;
	usb_pipe_state_t	prev_pipe_state = 0;
	int			circ, rh_circ, prh_circ;

	if ((hubd = hubd_get_soft_state(self)) == NULL) {

		return (ENXIO);
	}

	rh_dip = hubd->h_usba_device->usb_root_hub_dip;

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
	    "usba_hubdi_ioctl: "
	    "cmd=%x, arg=%lx, mode=%x, cred=%p, rval=%p dev=0x%lx",
	    cmd, arg, mode, credp, rvalp, dev);

	/* read devctl ioctl data */
	if ((cmd != DEVCTL_AP_CONTROL) &&
	    (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)) {

		return (EFAULT);
	}

	/*
	 * make sure the hub is connected before trying any
	 * of the following operations:
	 * configure, connect, disconnect
	 */
	mutex_enter(HUBD_MUTEX(hubd));

	switch (cmd) {
	case DEVCTL_AP_DISCONNECT:
	case DEVCTL_AP_UNCONFIGURE:
	case DEVCTL_AP_CONFIGURE:
		if (hubd->h_dev_state == USB_DEV_DISCONNECTED) {
			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "hubd: already gone");
			mutex_exit(HUBD_MUTEX(hubd));
			if (dcp) {
				ndi_dc_freehdl(dcp);
			}

			return (EIO);
		}

		/* FALLTHROUGH */
	case DEVCTL_AP_GETSTATE:
		if ((port = hubd_get_port_num(hubd, dcp)) == 0) {
			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
			    "hubd: bad port");
			mutex_exit(HUBD_MUTEX(hubd));
			if (dcp) {
				ndi_dc_freehdl(dcp);
			}

			return (EINVAL);
		}
		break;

	case DEVCTL_AP_CONTROL:

		break;
	default:
		mutex_exit(HUBD_MUTEX(hubd));
		if (dcp) {
			ndi_dc_freehdl(dcp);
		}

		return (ENOTTY);
	}

	/* should not happen, just in case */
	if (hubd->h_dev_state == USB_DEV_SUSPENDED) {
		mutex_exit(HUBD_MUTEX(hubd));
		if (dcp) {
			ndi_dc_freehdl(dcp);
		}

		return (EIO);
	}

	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	/* go full power */
	(void) pm_raise_power(hubd->h_dip, 0, USB_DEV_OS_FULL_PWR);

	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
	ndi_devi_enter(rh_dip, &rh_circ);
	ndi_devi_enter(hubd->h_dip, &circ);

	mutex_enter(HUBD_MUTEX(hubd));

	/* stop polling iff it was active */
	if (hubd->h_ep1_ph) {
		mutex_exit(HUBD_MUTEX(hubd));
		(void) usb_pipe_get_state(hubd->h_ep1_ph, &prev_pipe_state,
							    USB_FLAGS_SLEEP);
		mutex_enter(HUBD_MUTEX(hubd));

		if (prev_pipe_state == USB_PIPE_STATE_ACTIVE) {
			hubd_stop_polling(hubd);
		}
	}

	hubd->h_hotplug_thread++;

	switch (cmd) {
	case DEVCTL_AP_DISCONNECT:
		if (hubd_delete_child(hubd, port,
		    NDI_DEVI_REMOVE, B_FALSE) != USB_SUCCESS) {
			rv = EIO;
		}

		break;
	case DEVCTL_AP_UNCONFIGURE:
		if (hubd_delete_child(hubd, port,
		    NDI_UNCONFIG, B_FALSE) != USB_SUCCESS) {
			rv = EIO;
		}

		break;
	case DEVCTL_AP_CONFIGURE:
		/* toggle port */
		if (hubd_toggle_port(hubd, port) != USB_SUCCESS) {
			(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
			rv = EIO;

			break;
		}

		(void) hubd_handle_port_connect(hubd, port);
		child_dip = hubd_get_child_dip(hubd, port);
		mutex_exit(HUBD_MUTEX(hubd));

		ndi_devi_exit(hubd->h_dip, circ);
		ndi_devi_exit(rh_dip, rh_circ);
		ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
		if ((child_dip == NULL) ||
		    (ndi_devi_online(child_dip, 0) != NDI_SUCCESS)) {
			rv = EIO;
		}
		ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
		ndi_devi_enter(rh_dip, &rh_circ);
		ndi_devi_enter(hubd->h_dip, &circ);

		mutex_enter(HUBD_MUTEX(hubd));

		break;
	case DEVCTL_AP_GETSTATE:
		switch (hubd_cfgadm_state(hubd, port)) {
		case HUBD_CFGADM_DISCONNECTED:
			/* port previously 'disconnected' by cfgadm */
			ap_state.ap_rstate = AP_RSTATE_DISCONNECTED;
			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
			ap_state.ap_condition = AP_COND_OK;

			break;
		case HUBD_CFGADM_UNCONFIGURED:
			ap_state.ap_rstate = AP_RSTATE_CONNECTED;
			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
			ap_state.ap_condition = AP_COND_OK;

			break;
		case HUBD_CFGADM_CONFIGURED:
			ap_state.ap_rstate = AP_RSTATE_CONNECTED;
			ap_state.ap_ostate = AP_OSTATE_CONFIGURED;
			ap_state.ap_condition = AP_COND_OK;

			break;
		case HUBD_CFGADM_STILL_REFERENCED:
			ap_state.ap_rstate = AP_RSTATE_EMPTY;
			ap_state.ap_ostate = AP_OSTATE_CONFIGURED;
			ap_state.ap_condition = AP_COND_UNUSABLE;

			break;
		case HUBD_CFGADM_EMPTY:
		default:
			ap_state.ap_rstate = AP_RSTATE_EMPTY;
			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
			ap_state.ap_condition = AP_COND_OK;

			break;
		}

		ap_state.ap_last_change = (time_t)-1;
		ap_state.ap_error_code = 0;
		ap_state.ap_in_transition = 0;

		USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
		    "DEVCTL_AP_GETSTATE: "
		    "ostate=0x%x, rstate=0x%x, condition=0x%x",
		    ap_state.ap_ostate,
		    ap_state.ap_rstate, ap_state.ap_condition);

		/* copy the return-AP-state information to the user space */
		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
			rv = EFAULT;
		}

		break;
	case DEVCTL_AP_CONTROL:
	{
		/*
		 * Generic devctl for hardware-specific functionality.
		 * For list of sub-commands see hubd_impl.h
		 */
		hubd_ioctl_data_t	ioc;	/* for 64 byte copies */

		/* copy user ioctl data in first */
#ifdef _MULTI_DATAMODEL
		if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
			hubd_ioctl_data_32_t ioc32;

			if (ddi_copyin((void *)arg, (void *)&ioc32,
				sizeof (ioc32), mode) != 0) {
				rv = EFAULT;

				break;
			}
			ioc.cmd		= (uint_t)ioc32.cmd;
			ioc.port	= (uint_t)ioc32.port;
			ioc.get_size	= (uint_t)ioc32.get_size;
			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;
			ioc.bufsiz	= (uint_t)ioc32.bufsiz;
			ioc.misc_arg	= (uint_t)ioc32.misc_arg;
		} else
#endif /* _MULTI_DATAMODEL */
		if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
		    mode) != 0) {
			rv = EFAULT;

			break;
		}

		USB_DPRINTF_L3(DPRINT_MASK_CBOPS, hubd->h_log_handle,
		    "DEVCTL_AP_CONTROL: ioc: cmd=0x%x port=%d get_size=%d"
		    "\n\tbuf=0x%p, bufsiz=%d,  misc_arg=%d", ioc.cmd,
		    ioc.port, ioc.get_size, ioc.buf, ioc.bufsiz, ioc.misc_arg);

		/*
		 * To avoid BE/LE and 32/64 issues, a get_size always
		 * returns a 32-bit number.
		 */
		if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
			rv = EINVAL;

			break;
		}

		switch (ioc.cmd) {
		case USB_DESCR_TYPE_DEV:
			msg = "DEVCTL_AP_CONTROL: GET_DEVICE_DESC";
			if (ioc.get_size) {
				/* uint32 so this works 32/64 */
				uint32_t size = sizeof (usb_dev_descr_t);

				if (ddi_copyout((void *)&size, ioc.buf,
				    ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: get_size copyout failed", msg);
					rv = EIO;

					break;
				}
			} else {	/* send out the actual descr */
				usb_dev_descr_t *dev_descrp;

				/* check child_dip */
				if ((child_dip = hubd_get_child_dip(hubd,
				    ioc.port)) == NULL) {
					rv = EINVAL;

					break;
				}

				dev_descrp = usb_get_dev_descr(child_dip);
				if (ioc.bufsiz != sizeof (*dev_descrp)) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: bufsize passed (%d) != sizeof "
					    "usba_device_descr_t (%d)", msg,
					    ioc.bufsiz, dev_descrp->bLength);
					rv = EINVAL;

					break;
				}

				if (ddi_copyout((void *)dev_descrp,
				    ioc.buf, ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout failed.", msg);
					rv = EIO;

					break;
				}
			}
			break;
		case USB_DESCR_TYPE_STRING:
		{
			char		*str;
			uint32_t	size;
			usba_device_t	*usba_device;

			msg = "DEVCTL_AP_CONTROL: GET_STRING_DESCR";
			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
			    "%s: string request: %d", msg, ioc.misc_arg);

			/* recheck */
			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
			    NULL) {
				rv = EINVAL;

				break;
			}
			usba_device = usba_get_usba_device(child_dip);

			switch (ioc.misc_arg) {
			case HUBD_MFG_STR:
				str = usba_device->usb_mfg_str;

				break;
			case HUBD_PRODUCT_STR:
				str = usba_device->usb_product_str;

				break;
			case HUBD_SERIALNO_STR:
				str = usba_device->usb_serialno_str;

				break;
			case HUBD_CFG_DESCR_STR:
				mutex_enter(&usba_device->usb_mutex);
				str = usba_device->usb_cfg_str_descr[
					usba_device->usb_active_cfg_ndx];
				mutex_exit(&usba_device->usb_mutex);

				break;
			default:
				USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
				    hubd->h_log_handle,
				    "%s: Invalid string request", msg);
				rv = EINVAL;

				break;
			} /* end of switch */

			if (rv != 0) {

				break;
			}

			size = (str != NULL) ? strlen(str) + 1 : 0;
			if (ioc.get_size) {
				if (ddi_copyout((void *)&size, ioc.buf,
				    ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout of size failed.", msg);
					rv = EIO;

					break;
				}
			} else {
				if (size == 0) {
					USB_DPRINTF_L3(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: String is NULL", msg);
					rv = EINVAL;

					break;
				}

				if (ioc.bufsiz != size) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: string buf size wrong", msg);
					rv = EINVAL;

					break;
				}

				if (ddi_copyout((void *)str, ioc.buf,
				    ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout failed.", msg);
					rv = EIO;

					break;
				}
			}
			break;
		}
		case HUBD_GET_CFGADM_NAME:
		{
			uint32_t   name_len;
			const char *name;

			/* recheck */
			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
			    NULL) {
				rv = EINVAL;

				break;
			}
			name = ddi_node_name(child_dip);
			if (name == NULL) {
				name = "unsupported";
			}
			name_len = strlen(name) + 1;

			msg = "DEVCTL_AP_CONTROL: HUBD_GET_CFGADM_NAME";
			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
			    "%s: name=%s name_len=%d", msg, name, name_len);

			if (ioc.get_size) {
				if (ddi_copyout((void *)&name_len,
				    ioc.buf, ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout of size failed", msg);
					rv = EIO;

					break;
				}
			} else {
				if (ioc.bufsiz != name_len) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: string buf length wrong", msg);
					rv = EINVAL;

					break;
				}

				if (ddi_copyout((void *)name, ioc.buf,
				    ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout failed.", msg);
					rv = EIO;

					break;
				}
			}

			break;
		}

		/*
		 * Return the config index for the currently-configured
		 * configuration.
		 */
		case HUBD_GET_CURRENT_CONFIG:
		{
			uint_t		config_index;
			uint32_t	size = sizeof (config_index);
			usba_device_t	*usba_device;

			msg = "DEVCTL_AP_CONTROL: GET_CURRENT_CONFIG";
			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
			    "%s", msg);

			/*
			 * Return the config index for the configuration
			 * currently in use.
			 * Recheck if child_dip exists
			 */
			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
			    NULL) {
				rv = EINVAL;

				break;
			}

			usba_device = usba_get_usba_device(child_dip);
			mutex_enter(&usba_device->usb_mutex);
			config_index = usba_device->usb_active_cfg_ndx;
			mutex_exit(&usba_device->usb_mutex);

			if (ioc.get_size) {
				if (ddi_copyout((void *)&size,
				    ioc.buf, ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout of size failed.", msg);
					rv = EIO;

					break;
				}
			} else {
				if (ioc.bufsiz != size) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: buffer size wrong", msg);
					rv = EINVAL;

					break;
				}
				if (ddi_copyout((void *)&config_index,
				    ioc.buf, ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout failed", msg);
					rv = EIO;
				}
			}

			break;
		}
		case HUBD_GET_DEVICE_PATH:
		{
			char		*path;
			uint32_t	size;

			msg = "DEVCTL_AP_CONTROL: GET_DEVICE_PATH";
			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
			    "%s", msg);

			/* Recheck if child_dip exists */
			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
			    NULL) {
				rv = EINVAL;

				break;
			}

			/* ddi_pathname doesn't supply /devices, so we do. */
			path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
			(void) strcpy(path, "/devices");
			(void) ddi_pathname(child_dip, path + strlen(path));
			size = strlen(path) + 1;

			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
			    "%s: device path=%s  size=%d", msg, path, size);

			if (ioc.get_size) {
				if (ddi_copyout((void *)&size,
				    ioc.buf, ioc.bufsiz, mode) != 0) {

					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout of size failed.", msg);
					rv = EIO;
				}
			} else {
				if (ioc.bufsiz != size) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: buffer wrong size.", msg);
					rv = EINVAL;
				} else if (ddi_copyout((void *)path,
				    ioc.buf, ioc.bufsiz, mode) != 0) {
					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
					    hubd->h_log_handle,
					    "%s: copyout failed.", msg);
					rv = EIO;
				}
			}
			kmem_free(path, MAXPATHLEN);

			break;
		}
		case HUBD_REFRESH_DEVDB:
			msg = "DEVCTL_AP_CONTROL: HUBD_REFRESH_DEVDB";
			USB_DPRINTF_L3(DPRINT_MASK_CBOPS, hubd->h_log_handle,
			    "%s", msg);

			if ((rv = usba_devdb_refresh()) != USB_SUCCESS) {
				USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
				    hubd->h_log_handle,
				    "%s: Failed: %d", msg, rv);
				rv = EIO;
			}

			break;
		default:
			rv = ENOTSUP;
		}	/* end switch */

		break;
	}

	default:
		rv = ENOTTY;
	}

	if (dcp) {
		ndi_dc_freehdl(dcp);
	}

	/* allow hotplug thread now */
	hubd->h_hotplug_thread--;

	if ((hubd->h_dev_state == USB_DEV_ONLINE) &&
	    hubd->h_ep1_ph && (prev_pipe_state == USB_PIPE_STATE_ACTIVE)) {
		hubd_start_polling(hubd, 0);
	}
	mutex_exit(HUBD_MUTEX(hubd));

	ndi_devi_exit(hubd->h_dip, circ);
	ndi_devi_exit(rh_dip, rh_circ);
	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);

	mutex_enter(HUBD_MUTEX(hubd));
	hubd_pm_idle_component(hubd, hubd->h_dip, 0);
	mutex_exit(HUBD_MUTEX(hubd));

	return (rv);
}


/*
 * Helper func used only to help construct the names for the attachment point
 * minor nodes.  Used only in usba_hubdi_attach.
 * Returns whether it found ancestry or not (USB_SUCCESS if yes).
 * ports between the root hub and the device represented by dip.
 * E.g.,  "2.4.3.1" means this device is
 *	plugged into port 1 of a hub that is
 *	plugged into port 3 of a hub that is
 *	plugged into port 4 of a hub that is
 *	plugged into port 2 of the root hub.
 * NOTE: Max ap_id path len is HUBD_APID_NAMELEN (32 chars), which is
 * more than sufficient (as hubs are a max 6 levels deep, port needs 3
 * chars plus NULL each)
 */
static void
hubd_get_ancestry_str(hubd_t *hubd)
{
	char	dev_path[MAXPATHLEN];
	char	*port_num_pos;
	char	port_list[HUBD_APID_NAMELEN];
	char	*port_list_end = port_list;

	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
	    "hubd_get_ancestry_str: hubd=0x%p", hubd);

	dev_path[0] = '\0';
	(void) ddi_pathname(hubd->h_dip, dev_path);
	port_num_pos = dev_path;

	port_list[0] = NULL;
	while ((port_num_pos = (char *)strstr(port_num_pos, "hub@")) != NULL) {
		/*
		 * Found a non-root hub between the root hub port and device.
		 * Get the number of the port this hub is plugged into,
		 * and append it to the ancestry string.
		 */
		if (port_list_end != port_list) { /* have list already */
			(void) strcat(port_list_end, ".");
			port_list_end++;
		}

		while (!isdigit(*port_num_pos)) {
			if (*port_num_pos++ == '\0') {

				break;
			}
		}

		while (isdigit(*port_num_pos)) {
			*port_list_end++ = *port_num_pos++;
			ASSERT(port_list_end <
			    (port_list + sizeof (port_list)));
			ASSERT(port_num_pos < (dev_path + sizeof (dev_path)));
		}
		*port_list_end = '\0';
	}

	if (port_list_end != port_list) {
		(void) strcpy(hubd->h_ancestry_str, port_list);
		(void) strcat(hubd->h_ancestry_str, ".");
	}
}


/* Get which port to operate on.  */
static usb_port_t
hubd_get_port_num(hubd_t *hubd, struct devctl_iocdata *dcp)
{
	int32_t port;

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	/* Get which port to operate on.  */
	if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
		USB_DPRINTF_L2(DPRINT_MASK_CBOPS, hubd->h_log_handle,
		    "hubd_get_port_num: port lookup failed");
		port = 0;
	}

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
	    "hubd_get_port_num: hubd=0x%p, port=%d", hubd, port);

	return ((usb_port_t)port);
}


/* check if child still exists */
static dev_info_t *
hubd_get_child_dip(hubd_t *hubd, usb_port_t port)
{
	dev_info_t *child_dip = hubd->h_children_dips[port];

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
	    "hubd_get_child_dip: hubd=0x%p, port=%d", hubd, port);

	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));

	return (child_dip);
}


/*
 * hubd_cfgadm_state:
 *
 *	child_dip list		port_state		cfgadm_state
 *	--------------		----------		------------
 *	!= NULL			connected		configured or
 *							unconfigured
 *	!= NULL			not connected		disconnect but
 *							busy/still referenced
 *	NULL			connected		logically disconnected
 *	NULL			not connected		empty
 */
static uint_t
hubd_cfgadm_state(hubd_t *hubd, usb_port_t port)
{
	uint_t		state;
	dev_info_t	*child_dip = hubd_get_child_dip(hubd, port);

	if (child_dip) {
		if (hubd->h_port_state[port] & PORT_STATUS_CCS) {
			/*
			 * connected,  now check if driver exists
			 */
			if (DEVI_IS_DEVICE_OFFLINE(child_dip) ||
			    (i_ddi_node_state(child_dip) < DS_ATTACHED)) {
				state = HUBD_CFGADM_UNCONFIGURED;
			} else {
				state = HUBD_CFGADM_CONFIGURED;
			}
		} else {
			/*
			 * this means that the dip is around for
			 * a device that is still referenced but
			 * has been yanked out. So the cfgadm info
			 * for this state should be EMPTY (port empty)
			 * and CONFIGURED (dip still valid).
			 */
			state = HUBD_CFGADM_STILL_REFERENCED;
		}
	} else {
		/* connected but no child dip */
		if (hubd->h_port_state[port] & PORT_STATUS_CCS) {
			/* logically disconnected */
			state = HUBD_CFGADM_DISCONNECTED;
		} else {
			/* physically disconnected */
			state = HUBD_CFGADM_EMPTY;
		}
	}

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
	    "hubd_cfgadm_state: hubd=0x%p, port=%d state=0x%x",
	    hubd, port, state);

	return (state);
}


/*
 * hubd_toggle_port:
 */
static int
hubd_toggle_port(hubd_t *hubd, usb_port_t port)
{
	usb_hub_descr_t	*hub_descr;
	int		wait;
	uint_t		retry;
	uint16_t	status;
	uint16_t	change;

	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
	    "hubd_toggle_port: hubd=0x%p, port=%d", hubd, port);

	if ((hubd_disable_port_power(hubd, port)) != USB_SUCCESS) {

		return (USB_FAILURE);
	}

	/*
	 * see hubd_enable_all_port_power() which
	 * requires longer delay for hubs.
	 */
	mutex_exit(HUBD_MUTEX(hubd));
	delay(drv_usectohz(hubd_device_delay / 10));
	mutex_enter(HUBD_MUTEX(hubd));

	hub_descr = &hubd->h_hub_descr;

	/*
	 * According to section 11.11 of USB, for hubs with no power
	 * switches, bPwrOn2PwrGood is zero. But we wait for some
	 * arbitrary time to enable power to become stable.
	 *
	 * If an hub supports port power swicthing, we need to wait
	 * at least 20ms before accesing corresonding usb port.
	 */
	if ((hub_descr->wHubCharacteristics &
	    HUB_CHARS_NO_POWER_SWITCHING) || (!hub_descr->bPwrOn2PwrGood)) {
		wait = hubd_device_delay / 10;
	} else {
		wait = max(HUB_DEFAULT_POPG,
		    hub_descr->bPwrOn2PwrGood) * 2 * 1000;
	}

	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
	    "hubd_toggle_port: popg=%d wait=%d",
	    hub_descr->bPwrOn2PwrGood, wait);

	retry = 0;

	do {
		(void) hubd_enable_port_power(hubd, port);

		mutex_exit(HUBD_MUTEX(hubd));
		delay(drv_usectohz(wait));
		mutex_enter(HUBD_MUTEX(hubd));

		/* Get port status */
		(void) hubd_determine_port_status(hubd, port,
		    &status, &change, 0);

		/* For retry if any, use some extra delay */
		wait = max(wait, hubd_device_delay / 10);

		retry++;

	} while ((!(status & PORT_STATUS_PPS)) && (retry < HUBD_PORT_RETRY));

	/* Print warning message if port has no power */
	if (!(status & PORT_STATUS_PPS)) {

		USB_DPRINTF_L1(DPRINT_MASK_PORT, hubd->h_log_handle,
		    "hubd_toggle_port: port %d power-on failed, "
		    "port status 0x%x", port, status);

		return (USB_FAILURE);
	}

	return (USB_SUCCESS);
}