xref: /illumos-gate/usr/src/uts/common/io/usb/usba/hubdi.c (revision f5b8369c)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5fef1e07eSsl  * Common Development and Distribution License (the "License").
6fef1e07eSsl  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
22*f5b8369cSRaymond Chen  * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
237c478bd9Sstevel@tonic-gate  */
247c478bd9Sstevel@tonic-gate 
257c478bd9Sstevel@tonic-gate /*
267c478bd9Sstevel@tonic-gate  * USBA: Solaris USB Architecture support for the hub
277c478bd9Sstevel@tonic-gate  * including root hub
287c478bd9Sstevel@tonic-gate  * Most of the code for hubd resides in this file and
297c478bd9Sstevel@tonic-gate  * is shared between the HCD root hub support and hubd
307c478bd9Sstevel@tonic-gate  */
317c478bd9Sstevel@tonic-gate #define	USBA_FRAMEWORK
327c478bd9Sstevel@tonic-gate #include <sys/usb/usba.h>
337c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usba_devdb.h>
347c478bd9Sstevel@tonic-gate #include <sys/sunndi.h>
357c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usba_impl.h>
367c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usba_types.h>
377c478bd9Sstevel@tonic-gate #include <sys/usb/usba/hubdi.h>
387c478bd9Sstevel@tonic-gate #include <sys/usb/usba/hcdi_impl.h>
397c478bd9Sstevel@tonic-gate #include <sys/usb/hubd/hub.h>
407c478bd9Sstevel@tonic-gate #include <sys/usb/hubd/hubdvar.h>
417c478bd9Sstevel@tonic-gate #include <sys/usb/hubd/hubd_impl.h>
427c478bd9Sstevel@tonic-gate #include <sys/kobj.h>
437c478bd9Sstevel@tonic-gate #include <sys/kobj_lex.h>
447c478bd9Sstevel@tonic-gate #include <sys/fs/dv_node.h>
45d29f5a71Szhigang lu - Sun Microsystems - Beijing China #include <sys/strsun.h>
467c478bd9Sstevel@tonic-gate 
4740482326SVincent Wang /*
4840482326SVincent Wang  * External functions
4940482326SVincent Wang  */
5040482326SVincent Wang extern boolean_t consconfig_console_is_ready(void);
5140482326SVincent Wang 
527c478bd9Sstevel@tonic-gate /*
537c478bd9Sstevel@tonic-gate  * Prototypes for static functions
547c478bd9Sstevel@tonic-gate  */
557c478bd9Sstevel@tonic-gate static	int	usba_hubdi_bus_ctl(
567c478bd9Sstevel@tonic-gate 			dev_info_t		*dip,
577c478bd9Sstevel@tonic-gate 			dev_info_t		*rdip,
587c478bd9Sstevel@tonic-gate 			ddi_ctl_enum_t		op,
597c478bd9Sstevel@tonic-gate 			void			*arg,
607c478bd9Sstevel@tonic-gate 			void			*result);
617c478bd9Sstevel@tonic-gate 
627c478bd9Sstevel@tonic-gate static int	usba_hubdi_map_fault(
637c478bd9Sstevel@tonic-gate 			dev_info_t		*dip,
647c478bd9Sstevel@tonic-gate 			dev_info_t		*rdip,
657c478bd9Sstevel@tonic-gate 			struct hat		*hat,
667c478bd9Sstevel@tonic-gate 			struct seg		*seg,
677c478bd9Sstevel@tonic-gate 			caddr_t 		addr,
687c478bd9Sstevel@tonic-gate 			struct devpage		*dp,
697c478bd9Sstevel@tonic-gate 			pfn_t			pfn,
707c478bd9Sstevel@tonic-gate 			uint_t			prot,
717c478bd9Sstevel@tonic-gate 			uint_t			lock);
727c478bd9Sstevel@tonic-gate 
737c478bd9Sstevel@tonic-gate static int hubd_busop_get_eventcookie(dev_info_t *dip,
747c478bd9Sstevel@tonic-gate 			dev_info_t *rdip,
757c478bd9Sstevel@tonic-gate 			char *eventname,
767c478bd9Sstevel@tonic-gate 			ddi_eventcookie_t *cookie);
777c478bd9Sstevel@tonic-gate static int hubd_busop_add_eventcall(dev_info_t *dip,
787c478bd9Sstevel@tonic-gate 			dev_info_t *rdip,
797c478bd9Sstevel@tonic-gate 			ddi_eventcookie_t cookie,
807c478bd9Sstevel@tonic-gate 			void (*callback)(dev_info_t *dip,
817c478bd9Sstevel@tonic-gate 				ddi_eventcookie_t cookie, void *arg,
827c478bd9Sstevel@tonic-gate 				void *bus_impldata),
837c478bd9Sstevel@tonic-gate 			void *arg, ddi_callback_id_t *cb_id);
847c478bd9Sstevel@tonic-gate static int hubd_busop_remove_eventcall(dev_info_t *dip,
857c478bd9Sstevel@tonic-gate 			ddi_callback_id_t cb_id);
867c478bd9Sstevel@tonic-gate static int hubd_bus_config(dev_info_t *dip,
877c478bd9Sstevel@tonic-gate 			uint_t flag,
887c478bd9Sstevel@tonic-gate 			ddi_bus_config_op_t op,
897c478bd9Sstevel@tonic-gate 			void *arg,
907c478bd9Sstevel@tonic-gate 			dev_info_t **child);
917c478bd9Sstevel@tonic-gate static int hubd_bus_unconfig(dev_info_t *dip,
927c478bd9Sstevel@tonic-gate 			uint_t flag,
937c478bd9Sstevel@tonic-gate 			ddi_bus_config_op_t op,
947c478bd9Sstevel@tonic-gate 			void *arg);
957c478bd9Sstevel@tonic-gate static int hubd_bus_power(dev_info_t *dip, void *impl_arg,
967c478bd9Sstevel@tonic-gate 			pm_bus_power_op_t op, void *arg, void *result);
977c478bd9Sstevel@tonic-gate 
987c478bd9Sstevel@tonic-gate static usb_port_t  hubd_get_port_num(hubd_t *, struct devctl_iocdata *);
997c478bd9Sstevel@tonic-gate static dev_info_t *hubd_get_child_dip(hubd_t *, usb_port_t);
1007c478bd9Sstevel@tonic-gate static uint_t hubd_cfgadm_state(hubd_t *, usb_port_t);
1017c478bd9Sstevel@tonic-gate static int hubd_toggle_port(hubd_t *, usb_port_t);
1027c478bd9Sstevel@tonic-gate static void hubd_register_cpr_callback(hubd_t *);
1037c478bd9Sstevel@tonic-gate static void hubd_unregister_cpr_callback(hubd_t *);
1047c478bd9Sstevel@tonic-gate 
1057c478bd9Sstevel@tonic-gate /*
1067c478bd9Sstevel@tonic-gate  * Busops vector for USB HUB's
1077c478bd9Sstevel@tonic-gate  */
1087c478bd9Sstevel@tonic-gate struct bus_ops usba_hubdi_busops =	{
1097c478bd9Sstevel@tonic-gate 	BUSO_REV,
1107c478bd9Sstevel@tonic-gate 	nullbusmap,			/* bus_map */
1117c478bd9Sstevel@tonic-gate 	NULL,				/* bus_get_intrspec */
1127c478bd9Sstevel@tonic-gate 	NULL,				/* bus_add_intrspec */
1137c478bd9Sstevel@tonic-gate 	NULL,				/* bus_remove_intrspec */
1147c478bd9Sstevel@tonic-gate 	usba_hubdi_map_fault,		/* bus_map_fault */
1157c478bd9Sstevel@tonic-gate 	ddi_dma_map,			/* bus_dma_map */
1167c478bd9Sstevel@tonic-gate 	ddi_dma_allochdl,
1177c478bd9Sstevel@tonic-gate 	ddi_dma_freehdl,
1187c478bd9Sstevel@tonic-gate 	ddi_dma_bindhdl,
1197c478bd9Sstevel@tonic-gate 	ddi_dma_unbindhdl,
1207c478bd9Sstevel@tonic-gate 	ddi_dma_flush,
1217c478bd9Sstevel@tonic-gate 	ddi_dma_win,
1227c478bd9Sstevel@tonic-gate 	ddi_dma_mctl,			/* bus_dma_ctl */
1237c478bd9Sstevel@tonic-gate 	usba_hubdi_bus_ctl,		/* bus_ctl */
1247c478bd9Sstevel@tonic-gate 	ddi_bus_prop_op,		/* bus_prop_op */
1257c478bd9Sstevel@tonic-gate 	hubd_busop_get_eventcookie,
1267c478bd9Sstevel@tonic-gate 	hubd_busop_add_eventcall,
1277c478bd9Sstevel@tonic-gate 	hubd_busop_remove_eventcall,
1287c478bd9Sstevel@tonic-gate 	NULL,				/* bus_post_event */
1297c478bd9Sstevel@tonic-gate 	NULL,				/* bus_intr_ctl */
1307c478bd9Sstevel@tonic-gate 	hubd_bus_config,		/* bus_config */
1317c478bd9Sstevel@tonic-gate 	hubd_bus_unconfig,		/* bus_unconfig */
1327c478bd9Sstevel@tonic-gate 	NULL,				/* bus_fm_init */
1337c478bd9Sstevel@tonic-gate 	NULL,				/* bus_fm_fini */
1347c478bd9Sstevel@tonic-gate 	NULL,				/* bus_fm_access_enter */
1357c478bd9Sstevel@tonic-gate 	NULL,				/* bus_fm_access_exit */
1367c478bd9Sstevel@tonic-gate 	hubd_bus_power			/* bus_power */
1377c478bd9Sstevel@tonic-gate };
1387c478bd9Sstevel@tonic-gate 
139*f5b8369cSRaymond Chen #define	USB_HUB_INTEL_VID	0x8087
140*f5b8369cSRaymond Chen #define	USB_HUB_INTEL_PID	0x0020
1417c478bd9Sstevel@tonic-gate 
1427c478bd9Sstevel@tonic-gate /*
1437c478bd9Sstevel@tonic-gate  * local variables
1447c478bd9Sstevel@tonic-gate  */
1457c478bd9Sstevel@tonic-gate static kmutex_t	usba_hubdi_mutex;	/* protects USBA HUB data structures */
1467c478bd9Sstevel@tonic-gate 
1477c478bd9Sstevel@tonic-gate static usba_list_entry_t	usba_hubdi_list;
1487c478bd9Sstevel@tonic-gate 
1497c478bd9Sstevel@tonic-gate usb_log_handle_t	hubdi_log_handle;
1507c478bd9Sstevel@tonic-gate uint_t			hubdi_errlevel = USB_LOG_L4;
1517c478bd9Sstevel@tonic-gate uint_t			hubdi_errmask = (uint_t)-1;
152d29f5a71Szhigang lu - Sun Microsystems - Beijing China uint8_t			hubdi_min_pm_threshold = 5; /* seconds */
153aa041649SRaymond Chen uint8_t			hubdi_reset_delay = 20; /* seconds */
1548e1b7aa1Sfei feng - Sun Microsystems - Beijing China extern int modrootloaded;
1557c478bd9Sstevel@tonic-gate 
1567c478bd9Sstevel@tonic-gate /*
1577c478bd9Sstevel@tonic-gate  * initialize private data
1587c478bd9Sstevel@tonic-gate  */
1597c478bd9Sstevel@tonic-gate void
1607c478bd9Sstevel@tonic-gate usba_hubdi_initialization()
1617c478bd9Sstevel@tonic-gate {
1627c478bd9Sstevel@tonic-gate 	hubdi_log_handle = usb_alloc_log_hdl(NULL, "hubdi", &hubdi_errlevel,
163c0f24e5bSlg 	    &hubdi_errmask, NULL, 0);
1647c478bd9Sstevel@tonic-gate 
1657c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
1667c478bd9Sstevel@tonic-gate 	    "usba_hubdi_initialization");
1677c478bd9Sstevel@tonic-gate 
1687c478bd9Sstevel@tonic-gate 	mutex_init(&usba_hubdi_mutex, NULL, MUTEX_DRIVER, NULL);
1697c478bd9Sstevel@tonic-gate 
1707c478bd9Sstevel@tonic-gate 	usba_init_list(&usba_hubdi_list, NULL, NULL);
1717c478bd9Sstevel@tonic-gate }
1727c478bd9Sstevel@tonic-gate 
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate void
1757c478bd9Sstevel@tonic-gate usba_hubdi_destroy()
1767c478bd9Sstevel@tonic-gate {
1777c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
1787c478bd9Sstevel@tonic-gate 	    "usba_hubdi_destroy");
1797c478bd9Sstevel@tonic-gate 
1807c478bd9Sstevel@tonic-gate 	mutex_destroy(&usba_hubdi_mutex);
1817c478bd9Sstevel@tonic-gate 	usba_destroy_list(&usba_hubdi_list);
1827c478bd9Sstevel@tonic-gate 
1837c478bd9Sstevel@tonic-gate 	usb_free_log_hdl(hubdi_log_handle);
1847c478bd9Sstevel@tonic-gate }
1857c478bd9Sstevel@tonic-gate 
1867c478bd9Sstevel@tonic-gate 
1877c478bd9Sstevel@tonic-gate /*
1887c478bd9Sstevel@tonic-gate  * Called by an	HUB to attach an instance of the driver
1897c478bd9Sstevel@tonic-gate  *	make this instance known to USBA
1907c478bd9Sstevel@tonic-gate  *	the HUB	should initialize usba_hubdi structure prior
1917c478bd9Sstevel@tonic-gate  *	to calling this	interface
1927c478bd9Sstevel@tonic-gate  */
193ff0e937bSRaymond Chen int
1947c478bd9Sstevel@tonic-gate usba_hubdi_register(dev_info_t	*dip,
1957c478bd9Sstevel@tonic-gate 		uint_t		flags)
1967c478bd9Sstevel@tonic-gate {
1977c478bd9Sstevel@tonic-gate 	usba_hubdi_t *hubdi = kmem_zalloc(sizeof (usba_hubdi_t), KM_SLEEP);
1987c478bd9Sstevel@tonic-gate 	usba_device_t *usba_device = usba_get_usba_device(dip);
1997c478bd9Sstevel@tonic-gate 
2007c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
2017c478bd9Sstevel@tonic-gate 	    "usba_hubdi_register: %s", ddi_node_name(dip));
2027c478bd9Sstevel@tonic-gate 
2037c478bd9Sstevel@tonic-gate 	hubdi->hubdi_dip = dip;
2047c478bd9Sstevel@tonic-gate 	hubdi->hubdi_flags = flags;
2057c478bd9Sstevel@tonic-gate 
2067c478bd9Sstevel@tonic-gate 	usba_device->usb_hubdi = hubdi;
2077c478bd9Sstevel@tonic-gate 
2087c478bd9Sstevel@tonic-gate 	/*
2097c478bd9Sstevel@tonic-gate 	 * add this hubdi instance to the list of known hubdi's
2107c478bd9Sstevel@tonic-gate 	 */
2117c478bd9Sstevel@tonic-gate 	usba_init_list(&hubdi->hubdi_list, (usb_opaque_t)hubdi,
2127c478bd9Sstevel@tonic-gate 	    usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip)->
2137c478bd9Sstevel@tonic-gate 	    hcdi_iblock_cookie);
2147c478bd9Sstevel@tonic-gate 	mutex_enter(&usba_hubdi_mutex);
2157c478bd9Sstevel@tonic-gate 	usba_add_to_list(&usba_hubdi_list, &hubdi->hubdi_list);
2167c478bd9Sstevel@tonic-gate 	mutex_exit(&usba_hubdi_mutex);
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate 	return (DDI_SUCCESS);
2197c478bd9Sstevel@tonic-gate }
2207c478bd9Sstevel@tonic-gate 
2217c478bd9Sstevel@tonic-gate 
2227c478bd9Sstevel@tonic-gate /*
2237c478bd9Sstevel@tonic-gate  * Called by an	HUB to detach an instance of the driver
2247c478bd9Sstevel@tonic-gate  */
225ff0e937bSRaymond Chen int
2267c478bd9Sstevel@tonic-gate usba_hubdi_unregister(dev_info_t *dip)
2277c478bd9Sstevel@tonic-gate {
2287c478bd9Sstevel@tonic-gate 	usba_device_t *usba_device = usba_get_usba_device(dip);
2297c478bd9Sstevel@tonic-gate 	usba_hubdi_t *hubdi = usba_device->usb_hubdi;
2307c478bd9Sstevel@tonic-gate 
2317c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
2327c478bd9Sstevel@tonic-gate 	    "usba_hubdi_unregister: %s", ddi_node_name(dip));
2337c478bd9Sstevel@tonic-gate 
2347c478bd9Sstevel@tonic-gate 	mutex_enter(&usba_hubdi_mutex);
2357c478bd9Sstevel@tonic-gate 	(void) usba_rm_from_list(&usba_hubdi_list, &hubdi->hubdi_list);
2367c478bd9Sstevel@tonic-gate 	mutex_exit(&usba_hubdi_mutex);
2377c478bd9Sstevel@tonic-gate 
2387c478bd9Sstevel@tonic-gate 	usba_destroy_list(&hubdi->hubdi_list);
2397c478bd9Sstevel@tonic-gate 
2407c478bd9Sstevel@tonic-gate 	kmem_free(hubdi, sizeof (usba_hubdi_t));
2417c478bd9Sstevel@tonic-gate 
2427c478bd9Sstevel@tonic-gate 	return (DDI_SUCCESS);
2437c478bd9Sstevel@tonic-gate }
2447c478bd9Sstevel@tonic-gate 
2457c478bd9Sstevel@tonic-gate 
2467c478bd9Sstevel@tonic-gate /*
2477c478bd9Sstevel@tonic-gate  * misc bus routines currently not used
2487c478bd9Sstevel@tonic-gate  */
2497c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2507c478bd9Sstevel@tonic-gate static int
2517c478bd9Sstevel@tonic-gate usba_hubdi_map_fault(dev_info_t *dip,
2527c478bd9Sstevel@tonic-gate 	dev_info_t	*rdip,
2537c478bd9Sstevel@tonic-gate 	struct hat	*hat,
2547c478bd9Sstevel@tonic-gate 	struct seg	*seg,
2557c478bd9Sstevel@tonic-gate 	caddr_t 	addr,
2567c478bd9Sstevel@tonic-gate 	struct devpage	*dp,
2577c478bd9Sstevel@tonic-gate 	pfn_t		pfn,
2587c478bd9Sstevel@tonic-gate 	uint_t		prot,
2597c478bd9Sstevel@tonic-gate 	uint_t		lock)
2607c478bd9Sstevel@tonic-gate {
2617c478bd9Sstevel@tonic-gate 	return (DDI_FAILURE);
2627c478bd9Sstevel@tonic-gate }
2637c478bd9Sstevel@tonic-gate 
2647c478bd9Sstevel@tonic-gate 
2657c478bd9Sstevel@tonic-gate /*
2667c478bd9Sstevel@tonic-gate  * root hub support. the root hub uses the same devi as the HCD
2677c478bd9Sstevel@tonic-gate  */
2687c478bd9Sstevel@tonic-gate int
2697c478bd9Sstevel@tonic-gate usba_hubdi_bind_root_hub(dev_info_t *dip,
2707c478bd9Sstevel@tonic-gate 	uchar_t	*root_hub_config_descriptor,
2717c478bd9Sstevel@tonic-gate 	size_t config_length,
2727c478bd9Sstevel@tonic-gate 	usb_dev_descr_t *root_hub_device_descriptor)
2737c478bd9Sstevel@tonic-gate {
2747c478bd9Sstevel@tonic-gate 	usba_device_t *usba_device;
2757c478bd9Sstevel@tonic-gate 	usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(dip);
2767c478bd9Sstevel@tonic-gate 	hubd_t	*root_hubd;
2777c478bd9Sstevel@tonic-gate 	usb_pipe_handle_t ph = NULL;
2787c478bd9Sstevel@tonic-gate 	dev_info_t *child = ddi_get_child(dip);
2797c478bd9Sstevel@tonic-gate 
2807c478bd9Sstevel@tonic-gate 	if (ndi_prop_create_boolean(DDI_DEV_T_NONE, dip,
2817c478bd9Sstevel@tonic-gate 	    "root-hub") != NDI_SUCCESS) {
2827c478bd9Sstevel@tonic-gate 
2837c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
2847c478bd9Sstevel@tonic-gate 	}
2857c478bd9Sstevel@tonic-gate 
286de6f998eSrui wang - Sun Microsystems - Beijing China 	usba_add_root_hub(dip);
287de6f998eSrui wang - Sun Microsystems - Beijing China 
2887c478bd9Sstevel@tonic-gate 	root_hubd = kmem_zalloc(sizeof (hubd_t), KM_SLEEP);
2897c478bd9Sstevel@tonic-gate 
2907c478bd9Sstevel@tonic-gate 	/*
2917c478bd9Sstevel@tonic-gate 	 * create and initialize a usba_device structure
2927c478bd9Sstevel@tonic-gate 	 */
2937c478bd9Sstevel@tonic-gate 	usba_device = usba_alloc_usba_device(dip);
2947c478bd9Sstevel@tonic-gate 
2957c478bd9Sstevel@tonic-gate 	mutex_enter(&usba_device->usb_mutex);
2967c478bd9Sstevel@tonic-gate 	usba_device->usb_hcdi_ops = hcdi->hcdi_ops;
2977c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg = root_hub_config_descriptor;
2987c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_length = config_length;
2997c478bd9Sstevel@tonic-gate 	usba_device->usb_dev_descr = root_hub_device_descriptor;
3007c478bd9Sstevel@tonic-gate 	usba_device->usb_port = 1;
3017c478bd9Sstevel@tonic-gate 	usba_device->usb_addr = ROOT_HUB_ADDR;
3027c478bd9Sstevel@tonic-gate 	usba_device->usb_root_hubd = root_hubd;
3037c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_array = kmem_zalloc(sizeof (uchar_t *),
304c0f24e5bSlg 	    KM_SLEEP);
3057c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_array_length = sizeof (uchar_t *);
3067c478bd9Sstevel@tonic-gate 
3077c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_array_len = kmem_zalloc(sizeof (uint16_t),
308c0f24e5bSlg 	    KM_SLEEP);
3097c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_array_len_length = sizeof (uint16_t);
3107c478bd9Sstevel@tonic-gate 
3117c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_array[0] = root_hub_config_descriptor;
3127c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_array_len[0] =
313c0f24e5bSlg 	    sizeof (root_hub_config_descriptor);
3147c478bd9Sstevel@tonic-gate 
3157c478bd9Sstevel@tonic-gate 	usba_device->usb_cfg_str_descr = kmem_zalloc(sizeof (uchar_t *),
316c0f24e5bSlg 	    KM_SLEEP);
3177c478bd9Sstevel@tonic-gate 	usba_device->usb_n_cfgs = 1;
3187c478bd9Sstevel@tonic-gate 	usba_device->usb_n_ifs = 1;
3197c478bd9Sstevel@tonic-gate 	usba_device->usb_dip = dip;
3207c478bd9Sstevel@tonic-gate 
3217c478bd9Sstevel@tonic-gate 	usba_device->usb_client_flags = kmem_zalloc(
3227c478bd9Sstevel@tonic-gate 	    usba_device->usb_n_ifs * USBA_CLIENT_FLAG_SIZE, KM_SLEEP);
3237c478bd9Sstevel@tonic-gate 
3247c478bd9Sstevel@tonic-gate 	usba_device->usb_client_attach_list = kmem_zalloc(
3257c478bd9Sstevel@tonic-gate 	    usba_device->usb_n_ifs *
3267c478bd9Sstevel@tonic-gate 	    sizeof (*usba_device->usb_client_attach_list), KM_SLEEP);
3277c478bd9Sstevel@tonic-gate 
3287c478bd9Sstevel@tonic-gate 	usba_device->usb_client_ev_cb_list = kmem_zalloc(
3297c478bd9Sstevel@tonic-gate 	    usba_device->usb_n_ifs *
3307c478bd9Sstevel@tonic-gate 	    sizeof (*usba_device->usb_client_ev_cb_list), KM_SLEEP);
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate 	/*
3337c478bd9Sstevel@tonic-gate 	 * The bDeviceProtocol field of root hub device specifies,
3347c478bd9Sstevel@tonic-gate 	 * whether root hub is a High or Full speed usb device.
3357c478bd9Sstevel@tonic-gate 	 */
3367c478bd9Sstevel@tonic-gate 	if (root_hub_device_descriptor->bDeviceProtocol) {
3377c478bd9Sstevel@tonic-gate 		usba_device->usb_port_status = USBA_HIGH_SPEED_DEV;
3387c478bd9Sstevel@tonic-gate 	} else {
3397c478bd9Sstevel@tonic-gate 		usba_device->usb_port_status = USBA_FULL_SPEED_DEV;
3407c478bd9Sstevel@tonic-gate 	}
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate 	mutex_exit(&usba_device->usb_mutex);
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate 	usba_set_usba_device(dip, usba_device);
3457c478bd9Sstevel@tonic-gate 
3467c478bd9Sstevel@tonic-gate 	/*
3477c478bd9Sstevel@tonic-gate 	 * For the root hub the default pipe is not yet open
3487c478bd9Sstevel@tonic-gate 	 */
3497c478bd9Sstevel@tonic-gate 	if (usb_pipe_open(dip, NULL, NULL,
3507c478bd9Sstevel@tonic-gate 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph) != USB_SUCCESS) {
3517c478bd9Sstevel@tonic-gate 		goto fail;
3527c478bd9Sstevel@tonic-gate 	}
3537c478bd9Sstevel@tonic-gate 
3547c478bd9Sstevel@tonic-gate 	/*
3557c478bd9Sstevel@tonic-gate 	 * kill off all OBP children, they may not be fully
3567c478bd9Sstevel@tonic-gate 	 * enumerated
3577c478bd9Sstevel@tonic-gate 	 */
3587c478bd9Sstevel@tonic-gate 	while (child) {
3597c478bd9Sstevel@tonic-gate 		dev_info_t *next = ddi_get_next_sibling(child);
3607c478bd9Sstevel@tonic-gate 		(void) ddi_remove_child(child, 0);
3617c478bd9Sstevel@tonic-gate 		child = next;
3627c478bd9Sstevel@tonic-gate 	}
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 	/*
3657c478bd9Sstevel@tonic-gate 	 * "attach" the root hub driver
3667c478bd9Sstevel@tonic-gate 	 */
3677c478bd9Sstevel@tonic-gate 	if (usba_hubdi_attach(dip, DDI_ATTACH) != DDI_SUCCESS) {
3687c478bd9Sstevel@tonic-gate 		goto fail;
3697c478bd9Sstevel@tonic-gate 	}
3707c478bd9Sstevel@tonic-gate 
3717c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
3727c478bd9Sstevel@tonic-gate 
3737c478bd9Sstevel@tonic-gate fail:
3747c478bd9Sstevel@tonic-gate 	(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "root-hub");
3757c478bd9Sstevel@tonic-gate 
376de6f998eSrui wang - Sun Microsystems - Beijing China 	usba_rem_root_hub(dip);
377de6f998eSrui wang - Sun Microsystems - Beijing China 
3787c478bd9Sstevel@tonic-gate 	if (ph) {
3797c478bd9Sstevel@tonic-gate 		usb_pipe_close(dip, ph,
3807c478bd9Sstevel@tonic-gate 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
3817c478bd9Sstevel@tonic-gate 	}
3827c478bd9Sstevel@tonic-gate 
3837c478bd9Sstevel@tonic-gate 	kmem_free(usba_device->usb_cfg_array,
384c0f24e5bSlg 	    usba_device->usb_cfg_array_length);
3857c478bd9Sstevel@tonic-gate 	kmem_free(usba_device->usb_cfg_array_len,
386c0f24e5bSlg 	    usba_device->usb_cfg_array_len_length);
3877c478bd9Sstevel@tonic-gate 
3887c478bd9Sstevel@tonic-gate 	kmem_free(usba_device->usb_cfg_str_descr, sizeof (uchar_t *));
3897c478bd9Sstevel@tonic-gate 
3907c478bd9Sstevel@tonic-gate 	usba_free_usba_device(usba_device);
3917c478bd9Sstevel@tonic-gate 
3927c478bd9Sstevel@tonic-gate 	usba_set_usba_device(dip, NULL);
3937c478bd9Sstevel@tonic-gate 	if (root_hubd) {
3947c478bd9Sstevel@tonic-gate 		kmem_free(root_hubd, sizeof (hubd_t));
3957c478bd9Sstevel@tonic-gate 	}
3967c478bd9Sstevel@tonic-gate 
3977c478bd9Sstevel@tonic-gate 	return (USB_FAILURE);
3987c478bd9Sstevel@tonic-gate }
3997c478bd9Sstevel@tonic-gate 
4007c478bd9Sstevel@tonic-gate 
4017c478bd9Sstevel@tonic-gate int
4027c478bd9Sstevel@tonic-gate usba_hubdi_unbind_root_hub(dev_info_t *dip)
4037c478bd9Sstevel@tonic-gate {
4047c478bd9Sstevel@tonic-gate 	usba_device_t *usba_device;
4057c478bd9Sstevel@tonic-gate 
4067c478bd9Sstevel@tonic-gate 	/* was root hub attached? */
4077c478bd9Sstevel@tonic-gate 	if (!(usba_is_root_hub(dip))) {
4087c478bd9Sstevel@tonic-gate 
4097c478bd9Sstevel@tonic-gate 		/* return success anyway */
4107c478bd9Sstevel@tonic-gate 		return (USB_SUCCESS);
4117c478bd9Sstevel@tonic-gate 	}
4127c478bd9Sstevel@tonic-gate 
4137c478bd9Sstevel@tonic-gate 	/*
4147c478bd9Sstevel@tonic-gate 	 * usba_hubdi_detach also closes the default pipe
4157c478bd9Sstevel@tonic-gate 	 * and removes properties so there is no need to
4167c478bd9Sstevel@tonic-gate 	 * do it here
4177c478bd9Sstevel@tonic-gate 	 */
4187c478bd9Sstevel@tonic-gate 	if (usba_hubdi_detach(dip, DDI_DETACH) != DDI_SUCCESS) {
4197c478bd9Sstevel@tonic-gate 
4207c478bd9Sstevel@tonic-gate 		if (DEVI_IS_ATTACHING(dip)) {
421d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
4227c478bd9Sstevel@tonic-gate 			    "failure to unbind root hub after attach failure");
4237c478bd9Sstevel@tonic-gate 		}
4247c478bd9Sstevel@tonic-gate 
4257c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
4267c478bd9Sstevel@tonic-gate 	}
4277c478bd9Sstevel@tonic-gate 
4287c478bd9Sstevel@tonic-gate 	usba_device = usba_get_usba_device(dip);
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate 	kmem_free(usba_device->usb_root_hubd, sizeof (hubd_t));
4317c478bd9Sstevel@tonic-gate 
4327c478bd9Sstevel@tonic-gate 	kmem_free(usba_device->usb_cfg_array,
433c0f24e5bSlg 	    usba_device->usb_cfg_array_length);
4347c478bd9Sstevel@tonic-gate 	kmem_free(usba_device->usb_cfg_array_len,
435c0f24e5bSlg 	    usba_device->usb_cfg_array_len_length);
4367c478bd9Sstevel@tonic-gate 
4377c478bd9Sstevel@tonic-gate 	kmem_free(usba_device->usb_cfg_str_descr, sizeof (uchar_t *));
4387c478bd9Sstevel@tonic-gate 
4397c478bd9Sstevel@tonic-gate 	usba_free_usba_device(usba_device);
4407c478bd9Sstevel@tonic-gate 
441de6f998eSrui wang - Sun Microsystems - Beijing China 	usba_rem_root_hub(dip);
442de6f998eSrui wang - Sun Microsystems - Beijing China 
4437c478bd9Sstevel@tonic-gate 	(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "root-hub");
4447c478bd9Sstevel@tonic-gate 
4457c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
4467c478bd9Sstevel@tonic-gate }
4477c478bd9Sstevel@tonic-gate 
4487c478bd9Sstevel@tonic-gate 
4497c478bd9Sstevel@tonic-gate /*
4507c478bd9Sstevel@tonic-gate  * Actual Hub Driver support code:
4517c478bd9Sstevel@tonic-gate  *	shared by root hub and non-root hubs
4527c478bd9Sstevel@tonic-gate  */
4537c478bd9Sstevel@tonic-gate #include <sys/usb/usba/usbai_version.h>
4547c478bd9Sstevel@tonic-gate 
4557c478bd9Sstevel@tonic-gate /* Debugging support */
456ff0e937bSRaymond Chen uint_t hubd_errlevel	= USB_LOG_L4;
457ff0e937bSRaymond Chen uint_t hubd_errmask	= (uint_t)DPRINT_MASK_ALL;
458ff0e937bSRaymond Chen uint_t hubd_instance_debug = (uint_t)-1;
4597c478bd9Sstevel@tonic-gate static uint_t hubdi_bus_config_debug = 0;
4607c478bd9Sstevel@tonic-gate 
4617c478bd9Sstevel@tonic-gate _NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_errlevel))
4627c478bd9Sstevel@tonic-gate _NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_errmask))
4637c478bd9Sstevel@tonic-gate _NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_instance_debug))
4647c478bd9Sstevel@tonic-gate 
4657c478bd9Sstevel@tonic-gate _NOTE(SCHEME_PROTECTS_DATA("unique", msgb))
4667c478bd9Sstevel@tonic-gate _NOTE(SCHEME_PROTECTS_DATA("unique", dev_info))
4677c478bd9Sstevel@tonic-gate 
4687c478bd9Sstevel@tonic-gate 
4697c478bd9Sstevel@tonic-gate /*
4707c478bd9Sstevel@tonic-gate  * local variables:
4717c478bd9Sstevel@tonic-gate  *
4727c478bd9Sstevel@tonic-gate  * Amount of time to wait between resetting the port and accessing
4737c478bd9Sstevel@tonic-gate  * the device.	The value is in microseconds.
4747c478bd9Sstevel@tonic-gate  */
4757c478bd9Sstevel@tonic-gate static uint_t hubd_device_delay = 1000000;
4767c478bd9Sstevel@tonic-gate 
4777c478bd9Sstevel@tonic-gate /*
4787c478bd9Sstevel@tonic-gate  * enumeration retry
4797c478bd9Sstevel@tonic-gate  */
4807c478bd9Sstevel@tonic-gate #define	HUBD_PORT_RETRY 5
4817c478bd9Sstevel@tonic-gate static uint_t hubd_retry_enumerate = HUBD_PORT_RETRY;
4827c478bd9Sstevel@tonic-gate 
4837c478bd9Sstevel@tonic-gate /*
4847c478bd9Sstevel@tonic-gate  * Stale hotremoved device cleanup delay
4857c478bd9Sstevel@tonic-gate  */
4867c478bd9Sstevel@tonic-gate #define	HUBD_STALE_DIP_CLEANUP_DELAY	5000000
4877c478bd9Sstevel@tonic-gate static uint_t hubd_dip_cleanup_delay = HUBD_STALE_DIP_CLEANUP_DELAY;
4887c478bd9Sstevel@tonic-gate 
4897c478bd9Sstevel@tonic-gate /*
4907c478bd9Sstevel@tonic-gate  * retries for USB suspend and resume
4917c478bd9Sstevel@tonic-gate  */
4927c478bd9Sstevel@tonic-gate #define	HUBD_SUS_RES_RETRY	2
4937c478bd9Sstevel@tonic-gate 
4947c478bd9Sstevel@tonic-gate void	*hubd_statep;
4957c478bd9Sstevel@tonic-gate 
4967c478bd9Sstevel@tonic-gate /*
4977c478bd9Sstevel@tonic-gate  * prototypes
4987c478bd9Sstevel@tonic-gate  */
4997c478bd9Sstevel@tonic-gate static int hubd_cleanup(dev_info_t *dip, hubd_t  *hubd);
5007c478bd9Sstevel@tonic-gate static int hubd_check_ports(hubd_t  *hubd);
5017c478bd9Sstevel@tonic-gate 
5027c478bd9Sstevel@tonic-gate static int  hubd_open_intr_pipe(hubd_t *hubd);
5037c478bd9Sstevel@tonic-gate static void hubd_start_polling(hubd_t *hubd, int always);
5047c478bd9Sstevel@tonic-gate static void hubd_stop_polling(hubd_t *hubd);
5057c478bd9Sstevel@tonic-gate static void hubd_close_intr_pipe(hubd_t *hubd);
5067c478bd9Sstevel@tonic-gate 
5077c478bd9Sstevel@tonic-gate static void hubd_read_cb(usb_pipe_handle_t pipe, usb_intr_req_t *req);
5087c478bd9Sstevel@tonic-gate static void hubd_exception_cb(usb_pipe_handle_t pipe,
5097c478bd9Sstevel@tonic-gate 						usb_intr_req_t *req);
5107c478bd9Sstevel@tonic-gate static void hubd_hotplug_thread(void *arg);
511ffcd51f3Slg static void hubd_reset_thread(void *arg);
5127c478bd9Sstevel@tonic-gate static int hubd_create_child(dev_info_t *dip,
5137c478bd9Sstevel@tonic-gate 		hubd_t		*hubd,
5147c478bd9Sstevel@tonic-gate 		usba_device_t	*usba_device,
5157c478bd9Sstevel@tonic-gate 		usb_port_status_t port_status,
5167c478bd9Sstevel@tonic-gate 		usb_port_t	port,
5177c478bd9Sstevel@tonic-gate 		int		iteration);
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate static int hubd_delete_child(hubd_t *hubd, usb_port_t port, uint_t flag,
5207c478bd9Sstevel@tonic-gate 	boolean_t retry);
5217c478bd9Sstevel@tonic-gate 
5227c478bd9Sstevel@tonic-gate static int hubd_get_hub_descriptor(hubd_t *hubd);
5237c478bd9Sstevel@tonic-gate 
52435f36846Ssl static int hubd_get_hub_status_words(hubd_t *hubd, uint16_t *status);
52535f36846Ssl 
5267c478bd9Sstevel@tonic-gate static int hubd_reset_port(hubd_t *hubd, usb_port_t port);
5277c478bd9Sstevel@tonic-gate 
5287c478bd9Sstevel@tonic-gate static int hubd_get_hub_status(hubd_t *hubd);
5297c478bd9Sstevel@tonic-gate 
5307c478bd9Sstevel@tonic-gate static int hubd_handle_port_connect(hubd_t *hubd, usb_port_t port);
5317c478bd9Sstevel@tonic-gate 
5327c478bd9Sstevel@tonic-gate static int hubd_disable_port(hubd_t *hubd, usb_port_t port);
5337c478bd9Sstevel@tonic-gate 
5347c478bd9Sstevel@tonic-gate static int hubd_enable_port(hubd_t *hubd, usb_port_t port);
5357c478bd9Sstevel@tonic-gate static int hubd_recover_disabled_port(hubd_t *hubd, usb_port_t port);
5367c478bd9Sstevel@tonic-gate 
5377c478bd9Sstevel@tonic-gate static int hubd_determine_port_status(hubd_t *hubd, usb_port_t port,
5387c478bd9Sstevel@tonic-gate 	uint16_t *status, uint16_t *change, uint_t ack_flag);
5397c478bd9Sstevel@tonic-gate 
5407c478bd9Sstevel@tonic-gate static int hubd_enable_all_port_power(hubd_t *hubd);
5417c478bd9Sstevel@tonic-gate static int hubd_disable_all_port_power(hubd_t *hubd);
5427c478bd9Sstevel@tonic-gate static int hubd_disable_port_power(hubd_t *hubd, usb_port_t port);
5437c478bd9Sstevel@tonic-gate static int hubd_enable_port_power(hubd_t *hubd, usb_port_t port);
5447c478bd9Sstevel@tonic-gate 
5457c478bd9Sstevel@tonic-gate static void hubd_free_usba_device(hubd_t *hubd, usba_device_t *usba_device);
5467c478bd9Sstevel@tonic-gate 
5477c478bd9Sstevel@tonic-gate static int hubd_can_suspend(hubd_t *hubd);
5487c478bd9Sstevel@tonic-gate static void hubd_restore_device_state(dev_info_t *dip, hubd_t *hubd);
5497c478bd9Sstevel@tonic-gate static int hubd_setdevaddr(hubd_t *hubd, usb_port_t port);
5507c478bd9Sstevel@tonic-gate static void hubd_setdevconfig(hubd_t *hubd, usb_port_t port);
5517c478bd9Sstevel@tonic-gate 
5527c478bd9Sstevel@tonic-gate static int hubd_register_events(hubd_t *hubd);
5537c478bd9Sstevel@tonic-gate static void hubd_do_callback(hubd_t *hubd, dev_info_t *dip,
5547c478bd9Sstevel@tonic-gate 	ddi_eventcookie_t cookie);
5557c478bd9Sstevel@tonic-gate static void hubd_run_callbacks(hubd_t *hubd, usba_event_t type);
5567c478bd9Sstevel@tonic-gate static void hubd_post_event(hubd_t *hubd, usb_port_t port, usba_event_t type);
5577c478bd9Sstevel@tonic-gate static void hubd_create_pm_components(dev_info_t *dip, hubd_t *hubd);
5587c478bd9Sstevel@tonic-gate 
5597c478bd9Sstevel@tonic-gate static int hubd_disconnect_event_cb(dev_info_t *dip);
5607c478bd9Sstevel@tonic-gate static int hubd_reconnect_event_cb(dev_info_t *dip);
5617c478bd9Sstevel@tonic-gate static int hubd_pre_suspend_event_cb(dev_info_t *dip);
5627c478bd9Sstevel@tonic-gate static int hubd_post_resume_event_cb(dev_info_t *dip);
5637c478bd9Sstevel@tonic-gate static int hubd_cpr_suspend(hubd_t *hubd);
5647c478bd9Sstevel@tonic-gate static void hubd_cpr_resume(dev_info_t *dip);
5657c478bd9Sstevel@tonic-gate static int hubd_restore_state_cb(dev_info_t *dip);
566ffcd51f3Slg static int hubd_check_same_device(hubd_t *hubd, usb_port_t port);
5677c478bd9Sstevel@tonic-gate 
56835f36846Ssl static int hubd_init_power_budget(hubd_t *hubd);
56935f36846Ssl 
5707c478bd9Sstevel@tonic-gate static ndi_event_definition_t hubd_ndi_event_defs[] = {
5717c478bd9Sstevel@tonic-gate 	{USBA_EVENT_TAG_HOT_REMOVAL, DDI_DEVI_REMOVE_EVENT, EPL_KERNEL,
5727c478bd9Sstevel@tonic-gate 						NDI_EVENT_POST_TO_ALL},
5737c478bd9Sstevel@tonic-gate 	{USBA_EVENT_TAG_HOT_INSERTION, DDI_DEVI_INSERT_EVENT, EPL_KERNEL,
5747c478bd9Sstevel@tonic-gate 						NDI_EVENT_POST_TO_ALL},
5757c478bd9Sstevel@tonic-gate 	{USBA_EVENT_TAG_POST_RESUME, USBA_POST_RESUME_EVENT, EPL_KERNEL,
5767c478bd9Sstevel@tonic-gate 						NDI_EVENT_POST_TO_ALL},
5777c478bd9Sstevel@tonic-gate 	{USBA_EVENT_TAG_PRE_SUSPEND, USBA_PRE_SUSPEND_EVENT, EPL_KERNEL,
5787c478bd9Sstevel@tonic-gate 						NDI_EVENT_POST_TO_ALL}
5797c478bd9Sstevel@tonic-gate };
5807c478bd9Sstevel@tonic-gate 
5817c478bd9Sstevel@tonic-gate #define	HUBD_N_NDI_EVENTS \
5827c478bd9Sstevel@tonic-gate 	(sizeof (hubd_ndi_event_defs) / sizeof (ndi_event_definition_t))
5837c478bd9Sstevel@tonic-gate 
5847c478bd9Sstevel@tonic-gate static ndi_event_set_t hubd_ndi_events = {
5857c478bd9Sstevel@tonic-gate 	NDI_EVENTS_REV1, HUBD_N_NDI_EVENTS, hubd_ndi_event_defs};
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate /* events received from parent */
5887c478bd9Sstevel@tonic-gate static usb_event_t hubd_events = {
5897c478bd9Sstevel@tonic-gate 	hubd_disconnect_event_cb,
5907c478bd9Sstevel@tonic-gate 	hubd_reconnect_event_cb,
5917c478bd9Sstevel@tonic-gate 	hubd_pre_suspend_event_cb,
5927c478bd9Sstevel@tonic-gate 	hubd_post_resume_event_cb
5937c478bd9Sstevel@tonic-gate };
5947c478bd9Sstevel@tonic-gate 
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate /*
5977c478bd9Sstevel@tonic-gate  * hubd_get_soft_state() returns the hubd soft state
598ff0e937bSRaymond Chen  *
599ff0e937bSRaymond Chen  * WUSB support extends this function to support wire adapter class
600ff0e937bSRaymond Chen  * devices. The hubd soft state for the wire adapter class device
601ff0e937bSRaymond Chen  * would be stored in usb_root_hubd field of the usba_device structure,
602ff0e937bSRaymond Chen  * just as the USB host controller drivers do.
6037c478bd9Sstevel@tonic-gate  */
604ff0e937bSRaymond Chen hubd_t *
6057c478bd9Sstevel@tonic-gate hubd_get_soft_state(dev_info_t *dip)
6067c478bd9Sstevel@tonic-gate {
6077c478bd9Sstevel@tonic-gate 	if (dip == NULL) {
6087c478bd9Sstevel@tonic-gate 
6097c478bd9Sstevel@tonic-gate 		return (NULL);
6107c478bd9Sstevel@tonic-gate 	}
6117c478bd9Sstevel@tonic-gate 
612ff0e937bSRaymond Chen 	if (usba_is_root_hub(dip) || usba_is_wa(dip)) {
6137c478bd9Sstevel@tonic-gate 		usba_device_t *usba_device = usba_get_usba_device(dip);
6147c478bd9Sstevel@tonic-gate 
6157c478bd9Sstevel@tonic-gate 		return (usba_device->usb_root_hubd);
6167c478bd9Sstevel@tonic-gate 	} else {
6177c478bd9Sstevel@tonic-gate 		int instance = ddi_get_instance(dip);
6187c478bd9Sstevel@tonic-gate 
6197c478bd9Sstevel@tonic-gate 		return (ddi_get_soft_state(hubd_statep, instance));
6207c478bd9Sstevel@tonic-gate 	}
6217c478bd9Sstevel@tonic-gate }
6227c478bd9Sstevel@tonic-gate 
6237c478bd9Sstevel@tonic-gate 
6247c478bd9Sstevel@tonic-gate /*
6257c478bd9Sstevel@tonic-gate  * PM support functions:
6267c478bd9Sstevel@tonic-gate  */
6277c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6287c478bd9Sstevel@tonic-gate static void
6297c478bd9Sstevel@tonic-gate hubd_pm_busy_component(hubd_t *hubd, dev_info_t *dip, int component)
6307c478bd9Sstevel@tonic-gate {
6317c478bd9Sstevel@tonic-gate 	if (hubd->h_hubpm != NULL) {
6327c478bd9Sstevel@tonic-gate 		hubd->h_hubpm->hubp_busy_pm++;
6337c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
6347c478bd9Sstevel@tonic-gate 		if (pm_busy_component(dip, 0) != DDI_SUCCESS) {
6357c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
6367c478bd9Sstevel@tonic-gate 			hubd->h_hubpm->hubp_busy_pm--;
6377c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
6387c478bd9Sstevel@tonic-gate 		}
6397c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
6407c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
6417c478bd9Sstevel@tonic-gate 		    "hubd_pm_busy_component: %d", hubd->h_hubpm->hubp_busy_pm);
6427c478bd9Sstevel@tonic-gate 	}
6437c478bd9Sstevel@tonic-gate }
6447c478bd9Sstevel@tonic-gate 
6457c478bd9Sstevel@tonic-gate 
6467c478bd9Sstevel@tonic-gate /*ARGSUSED*/
6477c478bd9Sstevel@tonic-gate static void
6487c478bd9Sstevel@tonic-gate hubd_pm_idle_component(hubd_t *hubd, dev_info_t *dip, int component)
6497c478bd9Sstevel@tonic-gate {
6507c478bd9Sstevel@tonic-gate 	if (hubd->h_hubpm != NULL) {
6517c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
6527c478bd9Sstevel@tonic-gate 		if (pm_idle_component(dip, 0) == DDI_SUCCESS) {
6537c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
6547c478bd9Sstevel@tonic-gate 			ASSERT(hubd->h_hubpm->hubp_busy_pm > 0);
6557c478bd9Sstevel@tonic-gate 			hubd->h_hubpm->hubp_busy_pm--;
6567c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
6577c478bd9Sstevel@tonic-gate 		}
6587c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
6597c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
6607c478bd9Sstevel@tonic-gate 		    "hubd_pm_idle_component: %d", hubd->h_hubpm->hubp_busy_pm);
6617c478bd9Sstevel@tonic-gate 	}
6627c478bd9Sstevel@tonic-gate }
6637c478bd9Sstevel@tonic-gate 
6647c478bd9Sstevel@tonic-gate 
6657c478bd9Sstevel@tonic-gate /*
6667c478bd9Sstevel@tonic-gate  * track power level changes for children of this instance
6677c478bd9Sstevel@tonic-gate  */
6687c478bd9Sstevel@tonic-gate static void
6697c478bd9Sstevel@tonic-gate hubd_set_child_pwrlvl(hubd_t *hubd, usb_port_t port, uint8_t power)
6707c478bd9Sstevel@tonic-gate {
6717c478bd9Sstevel@tonic-gate 	int	old_power, new_power, pwr;
6727c478bd9Sstevel@tonic-gate 	usb_port_t	portno;
6737c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
6747c478bd9Sstevel@tonic-gate 
6757c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
6767c478bd9Sstevel@tonic-gate 	    "hubd_set_child_pwrlvl: port=%d power=%d",
6777c478bd9Sstevel@tonic-gate 	    port, power);
6787c478bd9Sstevel@tonic-gate 
6797c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
6807c478bd9Sstevel@tonic-gate 	hubpm = hubd->h_hubpm;
6817c478bd9Sstevel@tonic-gate 
6827c478bd9Sstevel@tonic-gate 	old_power = 0;
6837c478bd9Sstevel@tonic-gate 	for (portno = 1; portno <= hubd->h_hub_descr.bNbrPorts; portno++) {
6847c478bd9Sstevel@tonic-gate 		old_power += hubpm->hubp_child_pwrstate[portno];
6857c478bd9Sstevel@tonic-gate 	}
6867c478bd9Sstevel@tonic-gate 
6877c478bd9Sstevel@tonic-gate 	/* assign the port power */
6887c478bd9Sstevel@tonic-gate 	pwr = hubd->h_hubpm->hubp_child_pwrstate[port];
6897c478bd9Sstevel@tonic-gate 	hubd->h_hubpm->hubp_child_pwrstate[port] = power;
6907c478bd9Sstevel@tonic-gate 	new_power = old_power - pwr + power;
6917c478bd9Sstevel@tonic-gate 
6927c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
6937c478bd9Sstevel@tonic-gate 	    "hubd_set_child_pwrlvl: new_power=%d old_power=%d",
6947c478bd9Sstevel@tonic-gate 	    new_power, old_power);
6957c478bd9Sstevel@tonic-gate 
6967c478bd9Sstevel@tonic-gate 	if ((new_power > 0) && (old_power == 0)) {
6977c478bd9Sstevel@tonic-gate 		/* we have the first child coming out of low power */
6987c478bd9Sstevel@tonic-gate 		(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
6997c478bd9Sstevel@tonic-gate 	} else if ((new_power == 0) && (old_power > 0)) {
7007c478bd9Sstevel@tonic-gate 		/* we have the last child going to low power */
7017c478bd9Sstevel@tonic-gate 		(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
7027c478bd9Sstevel@tonic-gate 	}
7037c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
7047c478bd9Sstevel@tonic-gate }
7057c478bd9Sstevel@tonic-gate 
7067c478bd9Sstevel@tonic-gate 
7077c478bd9Sstevel@tonic-gate /*
7087c478bd9Sstevel@tonic-gate  * given a child dip, locate its port number
7097c478bd9Sstevel@tonic-gate  */
7107c478bd9Sstevel@tonic-gate static usb_port_t
7117c478bd9Sstevel@tonic-gate hubd_child_dip2port(hubd_t *hubd, dev_info_t *dip)
7127c478bd9Sstevel@tonic-gate {
7137c478bd9Sstevel@tonic-gate 	usb_port_t	port;
7147c478bd9Sstevel@tonic-gate 
7157c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
7167c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
7177c478bd9Sstevel@tonic-gate 		if (hubd->h_children_dips[port] == dip) {
7187c478bd9Sstevel@tonic-gate 
7197c478bd9Sstevel@tonic-gate 			break;
7207c478bd9Sstevel@tonic-gate 		}
7217c478bd9Sstevel@tonic-gate 	}
7227c478bd9Sstevel@tonic-gate 	ASSERT(port <= hubd->h_hub_descr.bNbrPorts);
7237c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
7247c478bd9Sstevel@tonic-gate 
7257c478bd9Sstevel@tonic-gate 	return (port);
7267c478bd9Sstevel@tonic-gate }
7277c478bd9Sstevel@tonic-gate 
7287c478bd9Sstevel@tonic-gate 
7297c478bd9Sstevel@tonic-gate /*
7307c478bd9Sstevel@tonic-gate  * if the hub can be put into low power mode, return success
7317c478bd9Sstevel@tonic-gate  * NOTE: suspend here means going to lower power, not CPR suspend.
7327c478bd9Sstevel@tonic-gate  */
7337c478bd9Sstevel@tonic-gate static int
7347c478bd9Sstevel@tonic-gate hubd_can_suspend(hubd_t *hubd)
7357c478bd9Sstevel@tonic-gate {
7367c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
7377c478bd9Sstevel@tonic-gate 	int		total_power = 0;
7387c478bd9Sstevel@tonic-gate 	usb_port_t	port;
7397c478bd9Sstevel@tonic-gate 
7407c478bd9Sstevel@tonic-gate 	hubpm = hubd->h_hubpm;
7417c478bd9Sstevel@tonic-gate 
7427c478bd9Sstevel@tonic-gate 	if (DEVI_IS_DETACHING(hubd->h_dip)) {
7437c478bd9Sstevel@tonic-gate 
7447c478bd9Sstevel@tonic-gate 		return (USB_SUCCESS);
7457c478bd9Sstevel@tonic-gate 	}
7467c478bd9Sstevel@tonic-gate 
7477c478bd9Sstevel@tonic-gate 	/*
7487c478bd9Sstevel@tonic-gate 	 * Don't go to lower power if haven't been at full power for enough
7497c478bd9Sstevel@tonic-gate 	 * time to let hotplug thread kickoff.
7507c478bd9Sstevel@tonic-gate 	 */
7517c478bd9Sstevel@tonic-gate 	if (ddi_get_time() < (hubpm->hubp_time_at_full_power +
7527c478bd9Sstevel@tonic-gate 	    hubpm->hubp_min_pm_threshold)) {
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
7557c478bd9Sstevel@tonic-gate 	}
7567c478bd9Sstevel@tonic-gate 
7577c478bd9Sstevel@tonic-gate 	for (port = 1; (total_power == 0) &&
7587c478bd9Sstevel@tonic-gate 	    (port <= hubd->h_hub_descr.bNbrPorts); port++) {
7597c478bd9Sstevel@tonic-gate 		total_power += hubpm->hubp_child_pwrstate[port];
7607c478bd9Sstevel@tonic-gate 	}
7617c478bd9Sstevel@tonic-gate 
7627c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
763c0f24e5bSlg 	    "hubd_can_suspend: %d", total_power);
7647c478bd9Sstevel@tonic-gate 
7657c478bd9Sstevel@tonic-gate 	return (total_power ? USB_FAILURE : USB_SUCCESS);
7667c478bd9Sstevel@tonic-gate }
7677c478bd9Sstevel@tonic-gate 
7687c478bd9Sstevel@tonic-gate 
7697c478bd9Sstevel@tonic-gate /*
7707c478bd9Sstevel@tonic-gate  * resume port depending on current device state
7717c478bd9Sstevel@tonic-gate  */
7727c478bd9Sstevel@tonic-gate static int
7737c478bd9Sstevel@tonic-gate hubd_resume_port(hubd_t *hubd, usb_port_t port)
7747c478bd9Sstevel@tonic-gate {
7757c478bd9Sstevel@tonic-gate 	int		rval, retry;
7767c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
7777c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
7787c478bd9Sstevel@tonic-gate 	uint16_t	status;
7797c478bd9Sstevel@tonic-gate 	uint16_t	change;
7807c478bd9Sstevel@tonic-gate 	int		retval = USB_FAILURE;
7817c478bd9Sstevel@tonic-gate 
7827c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
7837c478bd9Sstevel@tonic-gate 
7847c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
7857c478bd9Sstevel@tonic-gate 	    "hubd_resume_port: port=%d state=0x%x (%s)", port,
7867c478bd9Sstevel@tonic-gate 	    hubd->h_dev_state, usb_str_dev_state(hubd->h_dev_state));
7877c478bd9Sstevel@tonic-gate 
7887c478bd9Sstevel@tonic-gate 	switch (hubd->h_dev_state) {
7897c478bd9Sstevel@tonic-gate 	case USB_DEV_HUB_CHILD_PWRLVL:
7907c478bd9Sstevel@tonic-gate 		/*
7917c478bd9Sstevel@tonic-gate 		 * This could be a bus ctl for a port other than the one
7927c478bd9Sstevel@tonic-gate 		 * that has a remote wakeup condition. So check.
7937c478bd9Sstevel@tonic-gate 		 */
7947c478bd9Sstevel@tonic-gate 		if ((hubd->h_port_state[port] & PORT_STATUS_PSS) == 0) {
7957c478bd9Sstevel@tonic-gate 			/* the port isn't suspended, so don't resume */
7967c478bd9Sstevel@tonic-gate 			retval = USB_SUCCESS;
7977c478bd9Sstevel@tonic-gate 
7987c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
7997c478bd9Sstevel@tonic-gate 			    "hubd_resume_port: port=%d not suspended", port);
8007c478bd9Sstevel@tonic-gate 
8017c478bd9Sstevel@tonic-gate 			break;
8027c478bd9Sstevel@tonic-gate 		}
8037c478bd9Sstevel@tonic-gate 		/*
8047c478bd9Sstevel@tonic-gate 		 * Device has initiated a wakeup.
8057c478bd9Sstevel@tonic-gate 		 * Issue a ClearFeature(PortSuspend)
8067c478bd9Sstevel@tonic-gate 		 */
8077c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
8087c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
8097c478bd9Sstevel@tonic-gate 		    hubd->h_default_pipe,
81035f36846Ssl 		    HUB_HANDLE_PORT_FEATURE_TYPE,
8117c478bd9Sstevel@tonic-gate 		    USB_REQ_CLEAR_FEATURE,
8127c478bd9Sstevel@tonic-gate 		    CFS_PORT_SUSPEND,
8137c478bd9Sstevel@tonic-gate 		    port,
8147c478bd9Sstevel@tonic-gate 		    0, NULL, 0,
8157c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
8167c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
8177c478bd9Sstevel@tonic-gate 			    "ClearFeature(PortSuspend) fails "
8187c478bd9Sstevel@tonic-gate 			    "rval=%d cr=%d cb=0x%x", rval,
8197c478bd9Sstevel@tonic-gate 			    completion_reason, cb_flags);
8207c478bd9Sstevel@tonic-gate 		}
8217c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
8227c478bd9Sstevel@tonic-gate 
8237c478bd9Sstevel@tonic-gate 		/* either way ack changes on the port */
8247c478bd9Sstevel@tonic-gate 		(void) hubd_determine_port_status(hubd, port,
825c0f24e5bSlg 		    &status, &change, PORT_CHANGE_PSSC);
8267c478bd9Sstevel@tonic-gate 		retval = USB_SUCCESS;
8277c478bd9Sstevel@tonic-gate 
8287c478bd9Sstevel@tonic-gate 		break;
8297c478bd9Sstevel@tonic-gate 	case USB_DEV_HUB_STATE_RECOVER:
8307c478bd9Sstevel@tonic-gate 		/*
8317c478bd9Sstevel@tonic-gate 		 * When hubd's connect event callback posts a connect
8327c478bd9Sstevel@tonic-gate 		 * event to its child, it results in this busctl call
8337c478bd9Sstevel@tonic-gate 		 * which is valid
8347c478bd9Sstevel@tonic-gate 		 */
8357c478bd9Sstevel@tonic-gate 		/* FALLTHRU */
8367c478bd9Sstevel@tonic-gate 	case USB_DEV_ONLINE:
8376c7181fcSsl 		if (((hubd->h_port_state[port] & PORT_STATUS_CCS) == 0) ||
8386c7181fcSsl 		    ((hubd->h_port_state[port] & PORT_STATUS_PSS) == 0)) {
8397c478bd9Sstevel@tonic-gate 			/*
8407c478bd9Sstevel@tonic-gate 			 * the port isn't suspended, or connected
8417c478bd9Sstevel@tonic-gate 			 * so don't resume
8427c478bd9Sstevel@tonic-gate 			 */
8437c478bd9Sstevel@tonic-gate 			retval = USB_SUCCESS;
8447c478bd9Sstevel@tonic-gate 
8457c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
8467c478bd9Sstevel@tonic-gate 			    "hubd_resume_port: port=%d not suspended", port);
8477c478bd9Sstevel@tonic-gate 
8487c478bd9Sstevel@tonic-gate 			break;
8497c478bd9Sstevel@tonic-gate 		}
8507c478bd9Sstevel@tonic-gate 		/*
8517c478bd9Sstevel@tonic-gate 		 * prevent kicking off the hotplug thread
8527c478bd9Sstevel@tonic-gate 		 */
8537c478bd9Sstevel@tonic-gate 		hubd->h_hotplug_thread++;
8547c478bd9Sstevel@tonic-gate 		hubd_stop_polling(hubd);
8557c478bd9Sstevel@tonic-gate 
8567c478bd9Sstevel@tonic-gate 		/* Now ClearFeature(PortSuspend) */
8577c478bd9Sstevel@tonic-gate 		for (retry = 0; retry < HUBD_SUS_RES_RETRY; retry++) {
8587c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
8597c478bd9Sstevel@tonic-gate 			rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
8607c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
86135f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
8627c478bd9Sstevel@tonic-gate 			    USB_REQ_CLEAR_FEATURE,
8637c478bd9Sstevel@tonic-gate 			    CFS_PORT_SUSPEND,
8647c478bd9Sstevel@tonic-gate 			    port,
8657c478bd9Sstevel@tonic-gate 			    0, NULL, 0,
8667c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0);
8677c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
8687c478bd9Sstevel@tonic-gate 			if (rval != USB_SUCCESS) {
8697c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PM,
8707c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
8717c478bd9Sstevel@tonic-gate 				    "ClearFeature(PortSuspend) fails"
8727c478bd9Sstevel@tonic-gate 				    "rval=%d cr=%d cb=0x%x", rval,
8737c478bd9Sstevel@tonic-gate 				    completion_reason, cb_flags);
8747c478bd9Sstevel@tonic-gate 			} else {
8757c478bd9Sstevel@tonic-gate 				/*
8767c478bd9Sstevel@tonic-gate 				 * As per spec section 11.9 and 7.1.7.7
8777c478bd9Sstevel@tonic-gate 				 * hub need to provide at least 20ms of
8787c478bd9Sstevel@tonic-gate 				 * resume signalling, and s/w provide 10ms of
8797c478bd9Sstevel@tonic-gate 				 * recovery time before accessing the port.
8807c478bd9Sstevel@tonic-gate 				 */
8817c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
8827c478bd9Sstevel@tonic-gate 				delay(drv_usectohz(40000));
8837c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
8847c478bd9Sstevel@tonic-gate 				(void) hubd_determine_port_status(hubd, port,
8857c478bd9Sstevel@tonic-gate 				    &status, &change, PORT_CHANGE_PSSC);
8867c478bd9Sstevel@tonic-gate 
8877c478bd9Sstevel@tonic-gate 				if ((status & PORT_STATUS_PSS) == 0) {
8887c478bd9Sstevel@tonic-gate 					/* the port did finally resume */
8897c478bd9Sstevel@tonic-gate 					retval = USB_SUCCESS;
8907c478bd9Sstevel@tonic-gate 
8917c478bd9Sstevel@tonic-gate 					break;
8927c478bd9Sstevel@tonic-gate 				}
8937c478bd9Sstevel@tonic-gate 			}
8947c478bd9Sstevel@tonic-gate 		}
8957c478bd9Sstevel@tonic-gate 
8967c478bd9Sstevel@tonic-gate 		/* allow hotplug thread again */
8977c478bd9Sstevel@tonic-gate 		hubd->h_hotplug_thread--;
8987c478bd9Sstevel@tonic-gate 		hubd_start_polling(hubd, 0);
8997c478bd9Sstevel@tonic-gate 
9007c478bd9Sstevel@tonic-gate 		break;
9017c478bd9Sstevel@tonic-gate 	case USB_DEV_DISCONNECTED:
9027c478bd9Sstevel@tonic-gate 		/* Ignore - NO Operation */
9037c478bd9Sstevel@tonic-gate 		retval = USB_SUCCESS;
9047c478bd9Sstevel@tonic-gate 
9057c478bd9Sstevel@tonic-gate 		break;
9067c478bd9Sstevel@tonic-gate 	case USB_DEV_SUSPENDED:
9077c478bd9Sstevel@tonic-gate 	case USB_DEV_PWRED_DOWN:
9087c478bd9Sstevel@tonic-gate 	default:
9097c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
9107c478bd9Sstevel@tonic-gate 		    "Improper state for port Resume");
9117c478bd9Sstevel@tonic-gate 
9127c478bd9Sstevel@tonic-gate 		break;
9137c478bd9Sstevel@tonic-gate 	}
9147c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
9157c478bd9Sstevel@tonic-gate 
9167c478bd9Sstevel@tonic-gate 	return (retval);
9177c478bd9Sstevel@tonic-gate }
9187c478bd9Sstevel@tonic-gate 
9197c478bd9Sstevel@tonic-gate 
9207c478bd9Sstevel@tonic-gate /*
9217c478bd9Sstevel@tonic-gate  * suspend port depending on device state
9227c478bd9Sstevel@tonic-gate  */
9237c478bd9Sstevel@tonic-gate static int
9247c478bd9Sstevel@tonic-gate hubd_suspend_port(hubd_t *hubd, usb_port_t port)
9257c478bd9Sstevel@tonic-gate {
9267c478bd9Sstevel@tonic-gate 	int		rval, retry;
9277c478bd9Sstevel@tonic-gate 	int		retval = USB_FAILURE;
9287c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
9297c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
9307c478bd9Sstevel@tonic-gate 	uint16_t	status;
9317c478bd9Sstevel@tonic-gate 	uint16_t	change;
9327c478bd9Sstevel@tonic-gate 
9337c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
9347c478bd9Sstevel@tonic-gate 	    "hubd_suspend_port: port=%d", port);
9357c478bd9Sstevel@tonic-gate 
9367c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
9377c478bd9Sstevel@tonic-gate 
9387c478bd9Sstevel@tonic-gate 	switch (hubd->h_dev_state) {
9397c478bd9Sstevel@tonic-gate 	case USB_DEV_HUB_STATE_RECOVER:
9407c478bd9Sstevel@tonic-gate 		/*
9417c478bd9Sstevel@tonic-gate 		 * When hubd's connect event callback posts a connect
9427c478bd9Sstevel@tonic-gate 		 * event to its child, it results in this busctl call
9437c478bd9Sstevel@tonic-gate 		 * which is valid
9447c478bd9Sstevel@tonic-gate 		 */
9457c478bd9Sstevel@tonic-gate 		/* FALLTHRU */
9467c478bd9Sstevel@tonic-gate 	case USB_DEV_HUB_CHILD_PWRLVL:
9477c478bd9Sstevel@tonic-gate 		/*
9487c478bd9Sstevel@tonic-gate 		 * When one child is resuming, the other could timeout
9497c478bd9Sstevel@tonic-gate 		 * and go to low power mode, which is valid
9507c478bd9Sstevel@tonic-gate 		 */
9517c478bd9Sstevel@tonic-gate 		/* FALLTHRU */
9527c478bd9Sstevel@tonic-gate 	case USB_DEV_ONLINE:
9537c478bd9Sstevel@tonic-gate 		hubd->h_hotplug_thread++;
9547c478bd9Sstevel@tonic-gate 		hubd_stop_polling(hubd);
9557c478bd9Sstevel@tonic-gate 
9567c478bd9Sstevel@tonic-gate 		/*
9577c478bd9Sstevel@tonic-gate 		 * Some devices start an unprovoked resume.  According to spec,
9587c478bd9Sstevel@tonic-gate 		 * normal resume time for port is 10ms.  Wait for double that
9597c478bd9Sstevel@tonic-gate 		 * time, then check to be sure port is really suspended.
9607c478bd9Sstevel@tonic-gate 		 */
9617c478bd9Sstevel@tonic-gate 		for (retry = 0; retry < HUBD_SUS_RES_RETRY; retry++) {
9627c478bd9Sstevel@tonic-gate 			/* Now SetFeature(PortSuspend) */
9637c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
9647c478bd9Sstevel@tonic-gate 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
9657c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
96635f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
9677c478bd9Sstevel@tonic-gate 			    USB_REQ_SET_FEATURE,
9687c478bd9Sstevel@tonic-gate 			    CFS_PORT_SUSPEND,
9697c478bd9Sstevel@tonic-gate 			    port,
9707c478bd9Sstevel@tonic-gate 			    0, NULL, 0,
9717c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0)) !=
9727c478bd9Sstevel@tonic-gate 			    USB_SUCCESS) {
9737c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PM,
9747c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
9757c478bd9Sstevel@tonic-gate 				    "SetFeature(PortSuspend) fails"
9767c478bd9Sstevel@tonic-gate 				    "rval=%d cr=%d cb=0x%x",
9777c478bd9Sstevel@tonic-gate 				    rval, completion_reason, cb_flags);
9787c478bd9Sstevel@tonic-gate 			}
9797c478bd9Sstevel@tonic-gate 
9807c478bd9Sstevel@tonic-gate 			/*
9817c478bd9Sstevel@tonic-gate 			 * some devices start an unprovoked resume
9827c478bd9Sstevel@tonic-gate 			 * wait and check port status after some time
9837c478bd9Sstevel@tonic-gate 			 */
9847c478bd9Sstevel@tonic-gate 			delay(drv_usectohz(20000));
9857c478bd9Sstevel@tonic-gate 
9867c478bd9Sstevel@tonic-gate 			/* either ways ack changes on the port */
9877c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
9887c478bd9Sstevel@tonic-gate 			(void) hubd_determine_port_status(hubd, port,
9897c478bd9Sstevel@tonic-gate 			    &status, &change, PORT_CHANGE_PSSC);
9907c478bd9Sstevel@tonic-gate 			if (status & PORT_STATUS_PSS) {
9917c478bd9Sstevel@tonic-gate 				/* the port is indeed suspended */
9927c478bd9Sstevel@tonic-gate 				retval = USB_SUCCESS;
9937c478bd9Sstevel@tonic-gate 
9947c478bd9Sstevel@tonic-gate 				break;
9957c478bd9Sstevel@tonic-gate 			}
9967c478bd9Sstevel@tonic-gate 		}
9977c478bd9Sstevel@tonic-gate 
9987c478bd9Sstevel@tonic-gate 		hubd->h_hotplug_thread--;
9997c478bd9Sstevel@tonic-gate 		hubd_start_polling(hubd, 0);
10007c478bd9Sstevel@tonic-gate 
10017c478bd9Sstevel@tonic-gate 		break;
10027c478bd9Sstevel@tonic-gate 
10037c478bd9Sstevel@tonic-gate 	case USB_DEV_DISCONNECTED:
10047c478bd9Sstevel@tonic-gate 		/* Ignore - No Operation */
10057c478bd9Sstevel@tonic-gate 		retval = USB_SUCCESS;
10067c478bd9Sstevel@tonic-gate 
10077c478bd9Sstevel@tonic-gate 		break;
10087c478bd9Sstevel@tonic-gate 
10097c478bd9Sstevel@tonic-gate 	case USB_DEV_SUSPENDED:
10107c478bd9Sstevel@tonic-gate 	case USB_DEV_PWRED_DOWN:
10117c478bd9Sstevel@tonic-gate 	default:
10127c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
10137c478bd9Sstevel@tonic-gate 		    "Improper state for port Suspend");
10147c478bd9Sstevel@tonic-gate 
10157c478bd9Sstevel@tonic-gate 		break;
10167c478bd9Sstevel@tonic-gate 	}
10177c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
10187c478bd9Sstevel@tonic-gate 
10197c478bd9Sstevel@tonic-gate 	return (retval);
10207c478bd9Sstevel@tonic-gate }
10217c478bd9Sstevel@tonic-gate 
10227c478bd9Sstevel@tonic-gate 
10237c478bd9Sstevel@tonic-gate /*
10247c478bd9Sstevel@tonic-gate  * child post attach/detach notifications
10257c478bd9Sstevel@tonic-gate  */
10267c478bd9Sstevel@tonic-gate static void
10277c478bd9Sstevel@tonic-gate hubd_post_attach(hubd_t *hubd, usb_port_t port, struct attachspec *as)
10287c478bd9Sstevel@tonic-gate {
10297c478bd9Sstevel@tonic-gate 	dev_info_t	*dip;
10307c478bd9Sstevel@tonic-gate 
10317c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
10327c478bd9Sstevel@tonic-gate 	    "hubd_post_attach: port=%d result=%d",
10337c478bd9Sstevel@tonic-gate 	    port, as->result);
10347c478bd9Sstevel@tonic-gate 
10357c478bd9Sstevel@tonic-gate 	if (as->result == DDI_SUCCESS) {
10367c478bd9Sstevel@tonic-gate 		/*
10377c478bd9Sstevel@tonic-gate 		 * Check if the child created wants to be power managed.
10387c478bd9Sstevel@tonic-gate 		 * If yes, the childs power level gets automatically tracked
10397c478bd9Sstevel@tonic-gate 		 * by DDI_CTLOPS_POWER busctl.
10407c478bd9Sstevel@tonic-gate 		 * If no, we set power of the new child by default
10417c478bd9Sstevel@tonic-gate 		 * to USB_DEV_OS_FULL_PWR. Because we should never suspend.
10427c478bd9Sstevel@tonic-gate 		 */
10437c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
10447c478bd9Sstevel@tonic-gate 		dip = hubd->h_children_dips[port];
10457c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
10467c478bd9Sstevel@tonic-gate 		if (DEVI(dip)->devi_pm_info == NULL) {
10477c478bd9Sstevel@tonic-gate 			hubd_set_child_pwrlvl(hubd, port, USB_DEV_OS_FULL_PWR);
10487c478bd9Sstevel@tonic-gate 		}
10497c478bd9Sstevel@tonic-gate 	}
10507c478bd9Sstevel@tonic-gate }
10517c478bd9Sstevel@tonic-gate 
10527c478bd9Sstevel@tonic-gate 
10537c478bd9Sstevel@tonic-gate static void
10547c478bd9Sstevel@tonic-gate hubd_post_detach(hubd_t *hubd, usb_port_t port, struct detachspec *ds)
10557c478bd9Sstevel@tonic-gate {
10567c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
10577c478bd9Sstevel@tonic-gate 	    "hubd_post_detach: port=%d result=%d", port, ds->result);
10587c478bd9Sstevel@tonic-gate 
10597c478bd9Sstevel@tonic-gate 	/*
10607c478bd9Sstevel@tonic-gate 	 * if the device is successfully detached and is the
10617c478bd9Sstevel@tonic-gate 	 * last device to detach, mark component as idle
10627c478bd9Sstevel@tonic-gate 	 */
10637c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
10647c478bd9Sstevel@tonic-gate 	if (ds->result == DDI_SUCCESS) {
10657c478bd9Sstevel@tonic-gate 		usba_device_t	*usba_device = hubd->h_usba_devices[port];
106635f36846Ssl 		dev_info_t	*pdip = hubd->h_dip;
10677c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
10687c478bd9Sstevel@tonic-gate 
106935f36846Ssl 		usba_hubdi_incr_power_budget(pdip, usba_device);
107035f36846Ssl 
10717c478bd9Sstevel@tonic-gate 		/*
10727c478bd9Sstevel@tonic-gate 		 * We set power of the detached child
10737c478bd9Sstevel@tonic-gate 		 * to 0, so that we can suspend if all
10747c478bd9Sstevel@tonic-gate 		 * our children are gone
10757c478bd9Sstevel@tonic-gate 		 */
10767c478bd9Sstevel@tonic-gate 		hubd_set_child_pwrlvl(hubd, port, USB_DEV_OS_PWR_OFF);
10777c478bd9Sstevel@tonic-gate 
10787c478bd9Sstevel@tonic-gate 		/* check for leaks on detaching */
10797c478bd9Sstevel@tonic-gate 		if ((usba_device) && (ds->cmd == DDI_DETACH)) {
10807c478bd9Sstevel@tonic-gate 			usba_check_for_leaks(usba_device);
10817c478bd9Sstevel@tonic-gate 		}
10827c478bd9Sstevel@tonic-gate 	} else {
10837c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
10847c478bd9Sstevel@tonic-gate 	}
10857c478bd9Sstevel@tonic-gate }
10867c478bd9Sstevel@tonic-gate 
10877c478bd9Sstevel@tonic-gate 
10887c478bd9Sstevel@tonic-gate /*
10897c478bd9Sstevel@tonic-gate  * hubd_post_power
10907c478bd9Sstevel@tonic-gate  *	After the child's power entry point has been called
10917c478bd9Sstevel@tonic-gate  *	we record its power level in our local struct.
10927c478bd9Sstevel@tonic-gate  *	If the device has powered off, we suspend port
10937c478bd9Sstevel@tonic-gate  */
10947c478bd9Sstevel@tonic-gate static int
10957c478bd9Sstevel@tonic-gate hubd_post_power(hubd_t *hubd, usb_port_t port, pm_bp_child_pwrchg_t *bpc,
10967c478bd9Sstevel@tonic-gate     int result)
10977c478bd9Sstevel@tonic-gate {
10987c478bd9Sstevel@tonic-gate 	int	retval = USB_SUCCESS;
10997c478bd9Sstevel@tonic-gate 
11007c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
11017c478bd9Sstevel@tonic-gate 	    "hubd_post_power: port=%d", port);
11027c478bd9Sstevel@tonic-gate 
11037c478bd9Sstevel@tonic-gate 	if (result == DDI_SUCCESS) {
11047c478bd9Sstevel@tonic-gate 
11057c478bd9Sstevel@tonic-gate 		/* record this power in our local struct */
11067c478bd9Sstevel@tonic-gate 		hubd_set_child_pwrlvl(hubd, port, bpc->bpc_nlevel);
11077c478bd9Sstevel@tonic-gate 
11087c478bd9Sstevel@tonic-gate 		if (bpc->bpc_nlevel == USB_DEV_OS_PWR_OFF) {
11097c478bd9Sstevel@tonic-gate 
11107c478bd9Sstevel@tonic-gate 			/* now suspend the port */
11117c478bd9Sstevel@tonic-gate 			retval = hubd_suspend_port(hubd, port);
11127c478bd9Sstevel@tonic-gate 		} else if (bpc->bpc_nlevel == USB_DEV_OS_FULL_PWR) {
11137c478bd9Sstevel@tonic-gate 
11147c478bd9Sstevel@tonic-gate 			/* make sure the port is resumed */
11157c478bd9Sstevel@tonic-gate 			retval = hubd_resume_port(hubd, port);
11167c478bd9Sstevel@tonic-gate 		}
11177c478bd9Sstevel@tonic-gate 	} else {
11187c478bd9Sstevel@tonic-gate 
11197c478bd9Sstevel@tonic-gate 		/* record old power in our local struct */
11207c478bd9Sstevel@tonic-gate 		hubd_set_child_pwrlvl(hubd, port, bpc->bpc_olevel);
11217c478bd9Sstevel@tonic-gate 
11227c478bd9Sstevel@tonic-gate 		if (bpc->bpc_olevel == USB_DEV_OS_PWR_OFF) {
11237c478bd9Sstevel@tonic-gate 
11247c478bd9Sstevel@tonic-gate 			/*
11257c478bd9Sstevel@tonic-gate 			 * As this device failed to transition from
11267c478bd9Sstevel@tonic-gate 			 * power off state, suspend the port again
11277c478bd9Sstevel@tonic-gate 			 */
11287c478bd9Sstevel@tonic-gate 			retval = hubd_suspend_port(hubd, port);
11297c478bd9Sstevel@tonic-gate 		}
11307c478bd9Sstevel@tonic-gate 	}
11317c478bd9Sstevel@tonic-gate 
11327c478bd9Sstevel@tonic-gate 	return (retval);
11337c478bd9Sstevel@tonic-gate }
11347c478bd9Sstevel@tonic-gate 
11357c478bd9Sstevel@tonic-gate 
11367c478bd9Sstevel@tonic-gate /*
11377c478bd9Sstevel@tonic-gate  * bus ctl notifications are handled here, the rest goes up to root hub/hcd
11387c478bd9Sstevel@tonic-gate  */
11397c478bd9Sstevel@tonic-gate static int
11407c478bd9Sstevel@tonic-gate usba_hubdi_bus_ctl(dev_info_t *dip,
11417c478bd9Sstevel@tonic-gate 	dev_info_t	*rdip,
11427c478bd9Sstevel@tonic-gate 	ddi_ctl_enum_t	op,
11437c478bd9Sstevel@tonic-gate 	void		*arg,
11447c478bd9Sstevel@tonic-gate 	void		*result)
11457c478bd9Sstevel@tonic-gate {
11467c478bd9Sstevel@tonic-gate 	usba_device_t *hub_usba_device = usba_get_usba_device(rdip);
11477c478bd9Sstevel@tonic-gate 	dev_info_t *root_hub_dip = hub_usba_device->usb_root_hub_dip;
11487c478bd9Sstevel@tonic-gate 	struct attachspec *as;
11497c478bd9Sstevel@tonic-gate 	struct detachspec *ds;
11507c478bd9Sstevel@tonic-gate 	hubd_t		*hubd;
11517c478bd9Sstevel@tonic-gate 	usb_port_t	port;
11527c478bd9Sstevel@tonic-gate 	int		circ, rval;
11537c478bd9Sstevel@tonic-gate 	int		retval = DDI_FAILURE;
11547c478bd9Sstevel@tonic-gate 
11557c478bd9Sstevel@tonic-gate 	hubd = hubd_get_soft_state(dip);
11567c478bd9Sstevel@tonic-gate 
11577c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
11587c478bd9Sstevel@tonic-gate 
11597c478bd9Sstevel@tonic-gate 	/* flag that we are currently running bus_ctl */
11607c478bd9Sstevel@tonic-gate 	hubd->h_bus_ctls++;
11617c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
11627c478bd9Sstevel@tonic-gate 
11637c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
11647c478bd9Sstevel@tonic-gate 	    "usba_hubdi_bus_ctl:\n\t"
11657c478bd9Sstevel@tonic-gate 	    "dip=0x%p, rdip=0x%p, op=0x%x, arg=0x%p",
1166112116d8Sfb 	    (void *)dip, (void *)rdip, op, arg);
11677c478bd9Sstevel@tonic-gate 
11687c478bd9Sstevel@tonic-gate 	switch (op) {
11697c478bd9Sstevel@tonic-gate 	case DDI_CTLOPS_ATTACH:
11707c478bd9Sstevel@tonic-gate 		as = (struct attachspec *)arg;
11717c478bd9Sstevel@tonic-gate 		port = hubd_child_dip2port(hubd, rdip);
11727c478bd9Sstevel@tonic-gate 
11737c478bd9Sstevel@tonic-gate 		/* there is nothing to do at resume time */
11747c478bd9Sstevel@tonic-gate 		if (as->cmd == DDI_RESUME) {
11757c478bd9Sstevel@tonic-gate 			break;
11767c478bd9Sstevel@tonic-gate 		}
11777c478bd9Sstevel@tonic-gate 
11787c478bd9Sstevel@tonic-gate 		/* serialize access */
11797c478bd9Sstevel@tonic-gate 		ndi_devi_enter(hubd->h_dip, &circ);
11807c478bd9Sstevel@tonic-gate 
11817c478bd9Sstevel@tonic-gate 		switch (as->when) {
11827c478bd9Sstevel@tonic-gate 		case DDI_PRE:
11837c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
11847c478bd9Sstevel@tonic-gate 			    "DDI_PRE DDI_CTLOPS_ATTACH: dip=%p, port=%d",
1185112116d8Sfb 			    (void *)rdip, port);
11867c478bd9Sstevel@tonic-gate 
11877c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
11887c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] |= HUBD_CHILD_ATTACHING;
11897c478bd9Sstevel@tonic-gate 
11907c478bd9Sstevel@tonic-gate 			/* Go busy here.  Matching idle is DDI_POST case. */
11917c478bd9Sstevel@tonic-gate 			(void) hubd_pm_busy_component(hubd, dip, 0);
11927c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
11937c478bd9Sstevel@tonic-gate 
11947c478bd9Sstevel@tonic-gate 			/*
11957c478bd9Sstevel@tonic-gate 			 * if we suspended the port previously
11967c478bd9Sstevel@tonic-gate 			 * because child went to low power state, and
11977c478bd9Sstevel@tonic-gate 			 * someone unloaded the driver, the port would
11987c478bd9Sstevel@tonic-gate 			 * still be suspended and needs to be resumed
11997c478bd9Sstevel@tonic-gate 			 */
12007c478bd9Sstevel@tonic-gate 			rval = hubd_resume_port(hubd, port);
12017c478bd9Sstevel@tonic-gate 			if (rval == USB_SUCCESS) {
12027c478bd9Sstevel@tonic-gate 				retval = DDI_SUCCESS;
12037c478bd9Sstevel@tonic-gate 			}
12047c478bd9Sstevel@tonic-gate 
12057c478bd9Sstevel@tonic-gate 			break;
12067c478bd9Sstevel@tonic-gate 		case DDI_POST:
12077c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
12087c478bd9Sstevel@tonic-gate 			    "DDI_POST DDI_CTLOPS_ATTACH: dip=%p, port=%d",
1209112116d8Sfb 			    (void *)rdip, port);
12107c478bd9Sstevel@tonic-gate 
12117c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
12127c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] &= ~HUBD_CHILD_ATTACHING;
12137c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
12147c478bd9Sstevel@tonic-gate 
12157c478bd9Sstevel@tonic-gate 			hubd_post_attach(hubd, port, (struct attachspec *)arg);
12167c478bd9Sstevel@tonic-gate 			retval = DDI_SUCCESS;
12177c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
12187c478bd9Sstevel@tonic-gate 
12197c478bd9Sstevel@tonic-gate 			/* Matching idle call for DDI_PRE busy call. */
12207c478bd9Sstevel@tonic-gate 			(void) hubd_pm_idle_component(hubd, dip, 0);
12217c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
12227c478bd9Sstevel@tonic-gate 		}
12237c478bd9Sstevel@tonic-gate 		ndi_devi_exit(hubd->h_dip, circ);
12247c478bd9Sstevel@tonic-gate 
12257c478bd9Sstevel@tonic-gate 		break;
12267c478bd9Sstevel@tonic-gate 	case DDI_CTLOPS_DETACH:
12277c478bd9Sstevel@tonic-gate 		ds = (struct detachspec *)arg;
12287c478bd9Sstevel@tonic-gate 		port = hubd_child_dip2port(hubd, rdip);
12297c478bd9Sstevel@tonic-gate 
12307c478bd9Sstevel@tonic-gate 		/* there is nothing to do at suspend time */
12317c478bd9Sstevel@tonic-gate 		if (ds->cmd == DDI_SUSPEND) {
12327c478bd9Sstevel@tonic-gate 			break;
12337c478bd9Sstevel@tonic-gate 		}
12347c478bd9Sstevel@tonic-gate 
12357c478bd9Sstevel@tonic-gate 		/* serialize access */
12367c478bd9Sstevel@tonic-gate 		ndi_devi_enter(hubd->h_dip, &circ);
12377c478bd9Sstevel@tonic-gate 
12387c478bd9Sstevel@tonic-gate 		switch (ds->when) {
12397c478bd9Sstevel@tonic-gate 		case DDI_PRE:
12407c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
12417c478bd9Sstevel@tonic-gate 			    "DDI_PRE DDI_CTLOPS_DETACH: dip=%p port=%d",
1242112116d8Sfb 			    (void *)rdip, port);
12437c478bd9Sstevel@tonic-gate 
12447c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
12457c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] |= HUBD_CHILD_DETACHING;
12467c478bd9Sstevel@tonic-gate 
12477c478bd9Sstevel@tonic-gate 			/* Go busy here.  Matching idle is DDI_POST case. */
12487c478bd9Sstevel@tonic-gate 			(void) hubd_pm_busy_component(hubd, dip, 0);
12497c478bd9Sstevel@tonic-gate 
12507c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
12517c478bd9Sstevel@tonic-gate 			retval = DDI_SUCCESS;
12527c478bd9Sstevel@tonic-gate 
12537c478bd9Sstevel@tonic-gate 			break;
12547c478bd9Sstevel@tonic-gate 		case DDI_POST:
12557c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
12567c478bd9Sstevel@tonic-gate 			    "DDI_POST DDI_CTLOPS_DETACH: dip=%p port=%d",
1257112116d8Sfb 			    (void *)rdip, port);
12587c478bd9Sstevel@tonic-gate 
12597c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
12607c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] &= ~HUBD_CHILD_DETACHING;
12617c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
12627c478bd9Sstevel@tonic-gate 
12637c478bd9Sstevel@tonic-gate 			/* Matching idle call for DDI_PRE busy call. */
12647c478bd9Sstevel@tonic-gate 			hubd_post_detach(hubd, port, (struct detachspec *)arg);
12657c478bd9Sstevel@tonic-gate 			retval = DDI_SUCCESS;
12667c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
12677c478bd9Sstevel@tonic-gate 			(void) hubd_pm_idle_component(hubd, dip, 0);
12687c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
12697c478bd9Sstevel@tonic-gate 
12707c478bd9Sstevel@tonic-gate 			break;
12717c478bd9Sstevel@tonic-gate 		}
12727c478bd9Sstevel@tonic-gate 		ndi_devi_exit(hubd->h_dip, circ);
12737c478bd9Sstevel@tonic-gate 
12747c478bd9Sstevel@tonic-gate 		break;
12757c478bd9Sstevel@tonic-gate 	default:
12767c478bd9Sstevel@tonic-gate 		retval = usba_bus_ctl(root_hub_dip, rdip, op, arg, result);
12777c478bd9Sstevel@tonic-gate 	}
12787c478bd9Sstevel@tonic-gate 
12797c478bd9Sstevel@tonic-gate 	/* decrement bus_ctls count */
12807c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
12817c478bd9Sstevel@tonic-gate 	hubd->h_bus_ctls--;
12827c478bd9Sstevel@tonic-gate 	ASSERT(hubd->h_bus_ctls >= 0);
12837c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
12847c478bd9Sstevel@tonic-gate 
12857c478bd9Sstevel@tonic-gate 	return (retval);
12867c478bd9Sstevel@tonic-gate }
12877c478bd9Sstevel@tonic-gate 
128840482326SVincent Wang /*
128940482326SVincent Wang  * hubd_config_one:
129040482326SVincent Wang  * 	enumerate one child according to 'port'
129140482326SVincent Wang  */
129240482326SVincent Wang 
129340482326SVincent Wang static boolean_t
129440482326SVincent Wang hubd_config_one(hubd_t *hubd, int port)
129540482326SVincent Wang {
129640482326SVincent Wang 	uint16_t	status, change;
129740482326SVincent Wang 	dev_info_t	*hdip = hubd->h_dip;
129840482326SVincent Wang 	dev_info_t	*rh_dip = hubd->h_usba_device->usb_root_hub_dip;
129940482326SVincent Wang 	boolean_t	online_child = B_FALSE, found = B_FALSE;
130040482326SVincent Wang 	int		prh_circ, rh_circ, circ;
130140482326SVincent Wang 
130240482326SVincent Wang 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
130340482326SVincent Wang 	    "hubd_config_one:  started, hubd_reset_port = 0x%x", port);
130440482326SVincent Wang 
130540482326SVincent Wang 	ndi_hold_devi(hdip); /* so we don't race with detach */
130640482326SVincent Wang 
130740482326SVincent Wang 	/*
130840482326SVincent Wang 	 * this ensures one config activity per system at a time.
130940482326SVincent Wang 	 * we enter the parent PCI node to have this serialization.
131040482326SVincent Wang 	 * this also excludes ioctls and deathrow thread
131140482326SVincent Wang 	 */
131240482326SVincent Wang 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
131340482326SVincent Wang 	ndi_devi_enter(rh_dip, &rh_circ);
131440482326SVincent Wang 
131540482326SVincent Wang 	/* exclude other threads */
131640482326SVincent Wang 	ndi_devi_enter(hdip, &circ);
131740482326SVincent Wang 	mutex_enter(HUBD_MUTEX(hubd));
131840482326SVincent Wang 
1319e4c316c4SVincent Wang 	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
1320e4c316c4SVincent Wang 
132140482326SVincent Wang 	if (!hubd->h_children_dips[port]) {
132240482326SVincent Wang 
132340482326SVincent Wang 		(void) hubd_determine_port_status(hubd, port,
132440482326SVincent Wang 		    &status, &change, HUBD_ACK_ALL_CHANGES);
132540482326SVincent Wang 
132640482326SVincent Wang 		if (status & PORT_STATUS_CCS) {
132740482326SVincent Wang 			online_child |=	(hubd_handle_port_connect(hubd,
132840482326SVincent Wang 			    port) == USB_SUCCESS);
132940482326SVincent Wang 			found = online_child;
133040482326SVincent Wang 		}
133140482326SVincent Wang 	} else {
133240482326SVincent Wang 		found = B_TRUE;
133340482326SVincent Wang 	}
133440482326SVincent Wang 
133540482326SVincent Wang 	mutex_exit(HUBD_MUTEX(hubd));
133640482326SVincent Wang 
133740482326SVincent Wang 	ndi_devi_exit(hdip, circ);
133840482326SVincent Wang 	ndi_devi_exit(rh_dip, rh_circ);
133940482326SVincent Wang 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
134040482326SVincent Wang 
134140482326SVincent Wang 	if (online_child) {
134240482326SVincent Wang 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
134340482326SVincent Wang 		    "hubd_config_one: onlining child");
134440482326SVincent Wang 
134540482326SVincent Wang 		(void) ndi_devi_online(hubd->h_dip, 0);
134640482326SVincent Wang 	}
134740482326SVincent Wang 
134840482326SVincent Wang 	mutex_enter(HUBD_MUTEX(hubd));
134940482326SVincent Wang 
135040482326SVincent Wang 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
135140482326SVincent Wang 
135240482326SVincent Wang 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
135340482326SVincent Wang 	    "hubd_config_one: exit");
135440482326SVincent Wang 
135540482326SVincent Wang 	mutex_exit(HUBD_MUTEX(hubd));
135640482326SVincent Wang 
135740482326SVincent Wang 	ndi_rele_devi(hdip);
135840482326SVincent Wang 
135940482326SVincent Wang 	return (found);
136040482326SVincent Wang }
13617c478bd9Sstevel@tonic-gate 
13627c478bd9Sstevel@tonic-gate /*
13637c478bd9Sstevel@tonic-gate  * bus enumeration entry points
13647c478bd9Sstevel@tonic-gate  */
13657c478bd9Sstevel@tonic-gate static int
13667c478bd9Sstevel@tonic-gate hubd_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
13677c478bd9Sstevel@tonic-gate     void *arg, dev_info_t **child)
13687c478bd9Sstevel@tonic-gate {
13697c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = hubd_get_soft_state(dip);
13707c478bd9Sstevel@tonic-gate 	int	rval, circ;
137140482326SVincent Wang 	long port;
13727c478bd9Sstevel@tonic-gate 
13737c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
13747c478bd9Sstevel@tonic-gate 	    "hubd_bus_config: op=%d", op);
13757c478bd9Sstevel@tonic-gate 
13767c478bd9Sstevel@tonic-gate 	if (hubdi_bus_config_debug) {
13777c478bd9Sstevel@tonic-gate 		flag |= NDI_DEVI_DEBUG;
13787c478bd9Sstevel@tonic-gate 	}
13797c478bd9Sstevel@tonic-gate 
138040482326SVincent Wang 	if (op == BUS_CONFIG_ONE) {
138140482326SVincent Wang 		boolean_t found;
1382d724deadSguoqing zhu - Sun Microsystems - Beijing China 		char cname[80];
1383d724deadSguoqing zhu - Sun Microsystems - Beijing China 		char *name, *addr;
1384d724deadSguoqing zhu - Sun Microsystems - Beijing China 
1385d724deadSguoqing zhu - Sun Microsystems - Beijing China 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
1386d724deadSguoqing zhu - Sun Microsystems - Beijing China 		    "hubd_bus_config: op=%d (BUS_CONFIG_ONE)", op);
1387d724deadSguoqing zhu - Sun Microsystems - Beijing China 
138840482326SVincent Wang 		(void) snprintf(cname, 80, "%s", (char *)arg);
138940482326SVincent Wang 		/* split name into "name@addr" parts */
139040482326SVincent Wang 		i_ddi_parse_name(cname, &name, &addr, NULL);
139140482326SVincent Wang 		if (addr && *addr) {
139240482326SVincent Wang 			(void) ddi_strtol(addr, NULL, 16, &port);
139340482326SVincent Wang 		} else {
139440482326SVincent Wang 			return (NDI_FAILURE);
139540482326SVincent Wang 		}
1396d724deadSguoqing zhu - Sun Microsystems - Beijing China 
139740482326SVincent Wang 		found = hubd_config_one(hubd, port);
13985321cfb7Spengcheng chen - Sun Microsystems - Beijing China 
1399d724deadSguoqing zhu - Sun Microsystems - Beijing China 		if (found == 0) {
1400d724deadSguoqing zhu - Sun Microsystems - Beijing China 			return (NDI_FAILURE);
1401d724deadSguoqing zhu - Sun Microsystems - Beijing China 		}
1402d724deadSguoqing zhu - Sun Microsystems - Beijing China 
14037c478bd9Sstevel@tonic-gate 	}
14047c478bd9Sstevel@tonic-gate 	ndi_devi_enter(hubd->h_dip, &circ);
14057c478bd9Sstevel@tonic-gate 	rval = ndi_busop_bus_config(dip, flag, op, arg, child, 0);
14067c478bd9Sstevel@tonic-gate 	ndi_devi_exit(hubd->h_dip, circ);
14077c478bd9Sstevel@tonic-gate 
14087c478bd9Sstevel@tonic-gate 	return (rval);
14097c478bd9Sstevel@tonic-gate }
14107c478bd9Sstevel@tonic-gate 
14117c478bd9Sstevel@tonic-gate 
14127c478bd9Sstevel@tonic-gate static int
14137c478bd9Sstevel@tonic-gate hubd_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
14147c478bd9Sstevel@tonic-gate     void *arg)
14157c478bd9Sstevel@tonic-gate {
14167c478bd9Sstevel@tonic-gate 	hubd_t		*hubd = hubd_get_soft_state(dip);
14177c478bd9Sstevel@tonic-gate 	dev_info_t	*cdip;
14187c478bd9Sstevel@tonic-gate 	usb_port_t	port;
14197c478bd9Sstevel@tonic-gate 	int		circ;
14207c478bd9Sstevel@tonic-gate 	int		rval;
14217c478bd9Sstevel@tonic-gate 
14227c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
14237c478bd9Sstevel@tonic-gate 	    "hubd_bus_unconfig: op=%d", op);
14247c478bd9Sstevel@tonic-gate 
14257c478bd9Sstevel@tonic-gate 	if (hubdi_bus_config_debug) {
14267c478bd9Sstevel@tonic-gate 		flag |= NDI_DEVI_DEBUG;
14277c478bd9Sstevel@tonic-gate 	}
14287c478bd9Sstevel@tonic-gate 
14297c478bd9Sstevel@tonic-gate 	if ((op == BUS_UNCONFIG_ALL) && (flag & NDI_AUTODETACH) == 0) {
14307c478bd9Sstevel@tonic-gate 		flag |= NDI_DEVI_REMOVE;
14317c478bd9Sstevel@tonic-gate 	}
14327c478bd9Sstevel@tonic-gate 
14337c478bd9Sstevel@tonic-gate 	/* serialize access */
14347c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
14357c478bd9Sstevel@tonic-gate 
14367c478bd9Sstevel@tonic-gate 	rval = ndi_busop_bus_unconfig(dip, flag, op, arg);
14377c478bd9Sstevel@tonic-gate 
14387c478bd9Sstevel@tonic-gate 	/* logically zap children's list */
14397c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
14407c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
14417c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= HUBD_CHILD_ZAP;
14427c478bd9Sstevel@tonic-gate 	}
14437c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
14447c478bd9Sstevel@tonic-gate 
14457c478bd9Sstevel@tonic-gate 	/* fill in what's left */
14467c478bd9Sstevel@tonic-gate 	for (cdip = ddi_get_child(dip); cdip;
14477c478bd9Sstevel@tonic-gate 	    cdip = ddi_get_next_sibling(cdip)) {
14487c478bd9Sstevel@tonic-gate 		usba_device_t *usba_device = usba_get_usba_device(cdip);
14497c478bd9Sstevel@tonic-gate 
14507c478bd9Sstevel@tonic-gate 		if (usba_device == NULL) {
14517c478bd9Sstevel@tonic-gate 
14527c478bd9Sstevel@tonic-gate 			continue;
14537c478bd9Sstevel@tonic-gate 		}
14547c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
14557c478bd9Sstevel@tonic-gate 		port = usba_device->usb_port;
14567c478bd9Sstevel@tonic-gate 		hubd->h_children_dips[port] = cdip;
14577c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~HUBD_CHILD_ZAP;
14587c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
14597c478bd9Sstevel@tonic-gate 	}
14607c478bd9Sstevel@tonic-gate 
14617c478bd9Sstevel@tonic-gate 	/* physically zap the children we didn't find */
14627c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
14637c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
1464112cd14aSqz 		if (hubd->h_port_state[port] &	HUBD_CHILD_ZAP) {
14657c478bd9Sstevel@tonic-gate 			/* zap the dip and usba_device structure as well */
14667c478bd9Sstevel@tonic-gate 			hubd_free_usba_device(hubd, hubd->h_usba_devices[port]);
14677c478bd9Sstevel@tonic-gate 			hubd->h_children_dips[port] = NULL;
14687c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] &= ~HUBD_CHILD_ZAP;
14697c478bd9Sstevel@tonic-gate 		}
14707c478bd9Sstevel@tonic-gate 	}
14717c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
14727c478bd9Sstevel@tonic-gate 
14737c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
14747c478bd9Sstevel@tonic-gate 
14757c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
14767c478bd9Sstevel@tonic-gate 	    "hubd_bus_unconfig: rval=%d", rval);
14777c478bd9Sstevel@tonic-gate 
14787c478bd9Sstevel@tonic-gate 	return (rval);
14797c478bd9Sstevel@tonic-gate }
14807c478bd9Sstevel@tonic-gate 
14817c478bd9Sstevel@tonic-gate 
14827c478bd9Sstevel@tonic-gate /* bus_power entry point */
14837c478bd9Sstevel@tonic-gate static int
14847c478bd9Sstevel@tonic-gate hubd_bus_power(dev_info_t *dip, void *impl_arg, pm_bus_power_op_t op,
14857c478bd9Sstevel@tonic-gate     void *arg, void *result)
14867c478bd9Sstevel@tonic-gate {
14877c478bd9Sstevel@tonic-gate 	hubd_t		*hubd;
14887c478bd9Sstevel@tonic-gate 	int		rval, pwrup_res;
14897c478bd9Sstevel@tonic-gate 	usb_port_t	port;
14907c478bd9Sstevel@tonic-gate 	int		retval = DDI_FAILURE;
14917c478bd9Sstevel@tonic-gate 	pm_bp_child_pwrchg_t	*bpc;
14927c478bd9Sstevel@tonic-gate 	pm_bp_nexus_pwrup_t	bpn;
14937c478bd9Sstevel@tonic-gate 
14947c478bd9Sstevel@tonic-gate 	hubd = hubd_get_soft_state(dip);
14957c478bd9Sstevel@tonic-gate 
14967c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubd->h_log_handle,
14977c478bd9Sstevel@tonic-gate 	    "hubd_bus_power: dip=%p, impl_arg=%p, power_op=%d, arg=%p, "
1498112116d8Sfb 	    "result=%d\n", (void *)dip, impl_arg, op, arg, *(int *)result);
14997c478bd9Sstevel@tonic-gate 
15007c478bd9Sstevel@tonic-gate 	bpc = (pm_bp_child_pwrchg_t *)arg;
15017c478bd9Sstevel@tonic-gate 
15027c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
15037c478bd9Sstevel@tonic-gate 	hubd->h_bus_pwr++;
15047c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate 	switch (op) {
15077c478bd9Sstevel@tonic-gate 	case BUS_POWER_PRE_NOTIFICATION:
15087c478bd9Sstevel@tonic-gate 		port = hubd_child_dip2port(hubd, bpc->bpc_dip);
15097c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
15107c478bd9Sstevel@tonic-gate 		    "hubd_bus_power: BUS_POWER_PRE_NOTIFICATION, port=%d",
15117c478bd9Sstevel@tonic-gate 		    port);
15127c478bd9Sstevel@tonic-gate 
15137c478bd9Sstevel@tonic-gate 		/* go to full power if we are powered down */
15147c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
15157c478bd9Sstevel@tonic-gate 
15167c478bd9Sstevel@tonic-gate 		/*
15177c478bd9Sstevel@tonic-gate 		 * If this case completes normally, idle will be in
15187c478bd9Sstevel@tonic-gate 		 * hubd_bus_power / BUS_POWER_POST_NOTIFICATION
15197c478bd9Sstevel@tonic-gate 		 */
15207c478bd9Sstevel@tonic-gate 		hubd_pm_busy_component(hubd, dip, 0);
15217c478bd9Sstevel@tonic-gate 
15227c478bd9Sstevel@tonic-gate 		/*
15237c478bd9Sstevel@tonic-gate 		 * raise power only if we have created the components
15247c478bd9Sstevel@tonic-gate 		 * and are currently in low power
15257c478bd9Sstevel@tonic-gate 		 */
15267c478bd9Sstevel@tonic-gate 		if ((hubd->h_dev_state == USB_DEV_PWRED_DOWN) &&
15277c478bd9Sstevel@tonic-gate 		    hubd->h_hubpm->hubp_wakeup_enabled) {
15287c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
15297c478bd9Sstevel@tonic-gate 
15307c478bd9Sstevel@tonic-gate 			bpn.bpn_comp = 0;
15317c478bd9Sstevel@tonic-gate 			bpn.bpn_dip = dip;
15327c478bd9Sstevel@tonic-gate 			bpn.bpn_level = USB_DEV_OS_FULL_PWR;
15337c478bd9Sstevel@tonic-gate 			bpn.bpn_private = bpc->bpc_private;
15347c478bd9Sstevel@tonic-gate 
15357c478bd9Sstevel@tonic-gate 			rval = pm_busop_bus_power(dip, impl_arg,
15367c478bd9Sstevel@tonic-gate 			    BUS_POWER_NEXUS_PWRUP, (void *)&bpn,
15377c478bd9Sstevel@tonic-gate 			    (void *)&pwrup_res);
15387c478bd9Sstevel@tonic-gate 
15397c478bd9Sstevel@tonic-gate 			if (rval != DDI_SUCCESS || pwrup_res != DDI_SUCCESS) {
15407c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
15417c478bd9Sstevel@tonic-gate 				hubd_pm_idle_component(hubd, dip, 0);
15427c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
15437c478bd9Sstevel@tonic-gate 
15447c478bd9Sstevel@tonic-gate 				break;
15457c478bd9Sstevel@tonic-gate 			}
15467c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
15477c478bd9Sstevel@tonic-gate 		}
15487c478bd9Sstevel@tonic-gate 
15497c478bd9Sstevel@tonic-gate 		/* indicate that child is changing power level */
15507c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= HUBD_CHILD_PWRLVL_CHNG;
15517c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
15527c478bd9Sstevel@tonic-gate 
15537c478bd9Sstevel@tonic-gate 		if ((bpc->bpc_olevel == 0) &&
15547c478bd9Sstevel@tonic-gate 		    (bpc->bpc_nlevel > bpc->bpc_olevel)) {
15557c478bd9Sstevel@tonic-gate 			/*
15567c478bd9Sstevel@tonic-gate 			 * this child is transitioning from power off
15577c478bd9Sstevel@tonic-gate 			 * to power on state - resume port
15587c478bd9Sstevel@tonic-gate 			 */
15597c478bd9Sstevel@tonic-gate 			rval = hubd_resume_port(hubd, port);
15607c478bd9Sstevel@tonic-gate 			if (rval == USB_SUCCESS) {
15617c478bd9Sstevel@tonic-gate 				retval = DDI_SUCCESS;
15627c478bd9Sstevel@tonic-gate 			} else {
15637c478bd9Sstevel@tonic-gate 				/* reset this flag on failure */
15647c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
15657c478bd9Sstevel@tonic-gate 				hubd->h_port_state[port] &=
15667c478bd9Sstevel@tonic-gate 				    ~HUBD_CHILD_PWRLVL_CHNG;
15677c478bd9Sstevel@tonic-gate 				hubd_pm_idle_component(hubd, dip, 0);
15687c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
15697c478bd9Sstevel@tonic-gate 			}
15707c478bd9Sstevel@tonic-gate 		} else {
15717c478bd9Sstevel@tonic-gate 			retval = DDI_SUCCESS;
15727c478bd9Sstevel@tonic-gate 		}
15737c478bd9Sstevel@tonic-gate 
15747c478bd9Sstevel@tonic-gate 		break;
15757c478bd9Sstevel@tonic-gate 	case BUS_POWER_POST_NOTIFICATION:
15767c478bd9Sstevel@tonic-gate 		port = hubd_child_dip2port(hubd, bpc->bpc_dip);
15777c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
15787c478bd9Sstevel@tonic-gate 		    "hubd_bus_power: BUS_POWER_POST_NOTIFICATION, port=%d",
15797c478bd9Sstevel@tonic-gate 		    port);
15807c478bd9Sstevel@tonic-gate 
15817c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
15827c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~HUBD_CHILD_PWRLVL_CHNG;
15837c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
15847c478bd9Sstevel@tonic-gate 
15857c478bd9Sstevel@tonic-gate 		/* record child's pwr and suspend port if required */
15867c478bd9Sstevel@tonic-gate 		rval = hubd_post_power(hubd, port, bpc, *(int *)result);
15877c478bd9Sstevel@tonic-gate 		if (rval == USB_SUCCESS) {
15887c478bd9Sstevel@tonic-gate 
15897c478bd9Sstevel@tonic-gate 			retval = DDI_SUCCESS;
15907c478bd9Sstevel@tonic-gate 		}
15917c478bd9Sstevel@tonic-gate 
15927c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
15937c478bd9Sstevel@tonic-gate 
15947c478bd9Sstevel@tonic-gate 		/*
15957c478bd9Sstevel@tonic-gate 		 * Matching idle for the busy in
15967c478bd9Sstevel@tonic-gate 		 * hubd_bus_power / BUS_POWER_PRE_NOTIFICATION
15977c478bd9Sstevel@tonic-gate 		 */
15987c478bd9Sstevel@tonic-gate 		hubd_pm_idle_component(hubd, dip, 0);
15997c478bd9Sstevel@tonic-gate 
16007c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
16017c478bd9Sstevel@tonic-gate 
16027c478bd9Sstevel@tonic-gate 		break;
16037c478bd9Sstevel@tonic-gate 	default:
16047c478bd9Sstevel@tonic-gate 		retval = pm_busop_bus_power(dip, impl_arg, op, arg, result);
16057c478bd9Sstevel@tonic-gate 
16067c478bd9Sstevel@tonic-gate 		break;
16077c478bd9Sstevel@tonic-gate 	}
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
16107c478bd9Sstevel@tonic-gate 	hubd->h_bus_pwr--;
16117c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
16127c478bd9Sstevel@tonic-gate 
16137c478bd9Sstevel@tonic-gate 	return (retval);
16147c478bd9Sstevel@tonic-gate }
16157c478bd9Sstevel@tonic-gate 
16167c478bd9Sstevel@tonic-gate 
16177c478bd9Sstevel@tonic-gate /*
16187c478bd9Sstevel@tonic-gate  * functions to handle power transition for OS levels 0 -> 3
16197c478bd9Sstevel@tonic-gate  */
16207c478bd9Sstevel@tonic-gate static int
16217c478bd9Sstevel@tonic-gate hubd_pwrlvl0(hubd_t *hubd)
16227c478bd9Sstevel@tonic-gate {
16237c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
16247c478bd9Sstevel@tonic-gate 
16257c478bd9Sstevel@tonic-gate 	/* We can't power down if hotplug thread is running */
16267c478bd9Sstevel@tonic-gate 	if (hubd->h_hotplug_thread || hubd->h_hubpm->hubp_busy_pm ||
16277c478bd9Sstevel@tonic-gate 	    (hubd_can_suspend(hubd) == USB_FAILURE)) {
16287c478bd9Sstevel@tonic-gate 
16297c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
16307c478bd9Sstevel@tonic-gate 	}
16317c478bd9Sstevel@tonic-gate 
16327c478bd9Sstevel@tonic-gate 	switch (hubd->h_dev_state) {
16337c478bd9Sstevel@tonic-gate 	case USB_DEV_ONLINE:
16347c478bd9Sstevel@tonic-gate 		hubpm = hubd->h_hubpm;
16357c478bd9Sstevel@tonic-gate 
16367c478bd9Sstevel@tonic-gate 		/*
16377c478bd9Sstevel@tonic-gate 		 * To avoid race with bus_power pre_notify on check over
16387c478bd9Sstevel@tonic-gate 		 * dev_state, we need to correctly set the dev state
16397c478bd9Sstevel@tonic-gate 		 * before the mutex is dropped in stop polling.
16407c478bd9Sstevel@tonic-gate 		 */
16417c478bd9Sstevel@tonic-gate 		hubd->h_dev_state = USB_DEV_PWRED_DOWN;
16427c478bd9Sstevel@tonic-gate 		hubpm->hubp_current_power = USB_DEV_OS_PWR_OFF;
16437c478bd9Sstevel@tonic-gate 
16447c478bd9Sstevel@tonic-gate 		/*
16457c478bd9Sstevel@tonic-gate 		 * if we are the root hub, do not stop polling
16467c478bd9Sstevel@tonic-gate 		 * otherwise, we will never see a resume
16477c478bd9Sstevel@tonic-gate 		 */
16487c478bd9Sstevel@tonic-gate 		if (usba_is_root_hub(hubd->h_dip)) {
16497c478bd9Sstevel@tonic-gate 			/* place holder to implement Global Suspend */
16507c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
16517c478bd9Sstevel@tonic-gate 			    "Global Suspend: Not Yet Implemented");
16527c478bd9Sstevel@tonic-gate 		} else {
16537c478bd9Sstevel@tonic-gate 			hubd_stop_polling(hubd);
16547c478bd9Sstevel@tonic-gate 		}
16557c478bd9Sstevel@tonic-gate 
16567c478bd9Sstevel@tonic-gate 		/* Issue USB D3 command to the device here */
16577c478bd9Sstevel@tonic-gate 		(void) usb_set_device_pwrlvl3(hubd->h_dip);
16587c478bd9Sstevel@tonic-gate 
16597c478bd9Sstevel@tonic-gate 		break;
16607c478bd9Sstevel@tonic-gate 	case USB_DEV_DISCONNECTED:
16617c478bd9Sstevel@tonic-gate 	case USB_DEV_SUSPENDED:
16627c478bd9Sstevel@tonic-gate 	case USB_DEV_PWRED_DOWN:
16637c478bd9Sstevel@tonic-gate 	default:
16647c478bd9Sstevel@tonic-gate 
16657c478bd9Sstevel@tonic-gate 		break;
16667c478bd9Sstevel@tonic-gate 	}
16677c478bd9Sstevel@tonic-gate 
16687c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
16697c478bd9Sstevel@tonic-gate }
16707c478bd9Sstevel@tonic-gate 
16717c478bd9Sstevel@tonic-gate 
16727c478bd9Sstevel@tonic-gate /* ARGSUSED */
16737c478bd9Sstevel@tonic-gate static int
16747c478bd9Sstevel@tonic-gate hubd_pwrlvl1(hubd_t *hubd)
16757c478bd9Sstevel@tonic-gate {
16767c478bd9Sstevel@tonic-gate 	/* Issue USB D2 command to the device here */
16777c478bd9Sstevel@tonic-gate 	(void) usb_set_device_pwrlvl2(hubd->h_dip);
16787c478bd9Sstevel@tonic-gate 
16797c478bd9Sstevel@tonic-gate 	return (USB_FAILURE);
16807c478bd9Sstevel@tonic-gate }
16817c478bd9Sstevel@tonic-gate 
16827c478bd9Sstevel@tonic-gate 
16837c478bd9Sstevel@tonic-gate /* ARGSUSED */
16847c478bd9Sstevel@tonic-gate static int
16857c478bd9Sstevel@tonic-gate hubd_pwrlvl2(hubd_t *hubd)
16867c478bd9Sstevel@tonic-gate {
16877c478bd9Sstevel@tonic-gate 	/* Issue USB D1 command to the device here */
16887c478bd9Sstevel@tonic-gate 	(void) usb_set_device_pwrlvl1(hubd->h_dip);
16897c478bd9Sstevel@tonic-gate 
16907c478bd9Sstevel@tonic-gate 	return (USB_FAILURE);
16917c478bd9Sstevel@tonic-gate }
16927c478bd9Sstevel@tonic-gate 
16937c478bd9Sstevel@tonic-gate 
16947c478bd9Sstevel@tonic-gate static int
16957c478bd9Sstevel@tonic-gate hubd_pwrlvl3(hubd_t *hubd)
16967c478bd9Sstevel@tonic-gate {
16977c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
16987c478bd9Sstevel@tonic-gate 	int		rval;
16997c478bd9Sstevel@tonic-gate 
17007c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle, "hubd_pwrlvl3");
17017c478bd9Sstevel@tonic-gate 
17027c478bd9Sstevel@tonic-gate 	hubpm = hubd->h_hubpm;
17037c478bd9Sstevel@tonic-gate 	switch (hubd->h_dev_state) {
17047c478bd9Sstevel@tonic-gate 	case USB_DEV_PWRED_DOWN:
17057c478bd9Sstevel@tonic-gate 		ASSERT(hubpm->hubp_current_power == USB_DEV_OS_PWR_OFF);
17067c478bd9Sstevel@tonic-gate 		if (usba_is_root_hub(hubd->h_dip)) {
17077c478bd9Sstevel@tonic-gate 			/* implement global resume here */
17087c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PM,
17097c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
17107c478bd9Sstevel@tonic-gate 			    "Global Resume: Not Yet Implemented");
17117c478bd9Sstevel@tonic-gate 		}
17127c478bd9Sstevel@tonic-gate 		/* Issue USB D0 command to the device here */
17137c478bd9Sstevel@tonic-gate 		rval = usb_set_device_pwrlvl0(hubd->h_dip);
17147c478bd9Sstevel@tonic-gate 		ASSERT(rval == USB_SUCCESS);
17157c478bd9Sstevel@tonic-gate 		hubd->h_dev_state = USB_DEV_ONLINE;
17167c478bd9Sstevel@tonic-gate 		hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
17177c478bd9Sstevel@tonic-gate 		hubpm->hubp_time_at_full_power = ddi_get_time();
17187c478bd9Sstevel@tonic-gate 		hubd_start_polling(hubd, 0);
17197c478bd9Sstevel@tonic-gate 
17207c478bd9Sstevel@tonic-gate 		/* FALLTHRU */
17217c478bd9Sstevel@tonic-gate 	case USB_DEV_ONLINE:
17227c478bd9Sstevel@tonic-gate 		/* we are already in full power */
17237c478bd9Sstevel@tonic-gate 
17247c478bd9Sstevel@tonic-gate 		/* FALLTHRU */
17257c478bd9Sstevel@tonic-gate 	case USB_DEV_DISCONNECTED:
17267c478bd9Sstevel@tonic-gate 	case USB_DEV_SUSPENDED:
17277c478bd9Sstevel@tonic-gate 		/*
17287c478bd9Sstevel@tonic-gate 		 * PM framework tries to put you in full power
17297c478bd9Sstevel@tonic-gate 		 * during system shutdown. If we are disconnected
17307c478bd9Sstevel@tonic-gate 		 * return success. Also, we should not change state
17317c478bd9Sstevel@tonic-gate 		 * when we are disconnected or suspended or about to
17327c478bd9Sstevel@tonic-gate 		 * transition to that state
17337c478bd9Sstevel@tonic-gate 		 */
17347c478bd9Sstevel@tonic-gate 
17357c478bd9Sstevel@tonic-gate 		return (USB_SUCCESS);
17367c478bd9Sstevel@tonic-gate 	default:
17377c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
17387c478bd9Sstevel@tonic-gate 		    "hubd_pwrlvl3: Illegal dev_state=%d", hubd->h_dev_state);
17397c478bd9Sstevel@tonic-gate 
17407c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
17417c478bd9Sstevel@tonic-gate 	}
17427c478bd9Sstevel@tonic-gate }
17437c478bd9Sstevel@tonic-gate 
17447c478bd9Sstevel@tonic-gate 
17457c478bd9Sstevel@tonic-gate /* power entry point */
17467c478bd9Sstevel@tonic-gate /* ARGSUSED */
17477c478bd9Sstevel@tonic-gate int
17487c478bd9Sstevel@tonic-gate usba_hubdi_power(dev_info_t *dip, int comp, int level)
17497c478bd9Sstevel@tonic-gate {
17507c478bd9Sstevel@tonic-gate 	hubd_t		*hubd;
17517c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
17527c478bd9Sstevel@tonic-gate 	int		retval;
17537c478bd9Sstevel@tonic-gate 	int		circ;
17547c478bd9Sstevel@tonic-gate 
17557c478bd9Sstevel@tonic-gate 	hubd = hubd_get_soft_state(dip);
17567c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
17577c478bd9Sstevel@tonic-gate 	    "usba_hubdi_power: level=%d", level);
17587c478bd9Sstevel@tonic-gate 
17597c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
17607c478bd9Sstevel@tonic-gate 
17617c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
17627c478bd9Sstevel@tonic-gate 	hubpm = hubd->h_hubpm;
17637c478bd9Sstevel@tonic-gate 
17647c478bd9Sstevel@tonic-gate 	/* check if we are transitioning to a legal power level */
17657c478bd9Sstevel@tonic-gate 	if (USB_DEV_PWRSTATE_OK(hubpm->hubp_pwr_states, level)) {
17667c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HUBDI, hubd->h_log_handle,
17677c478bd9Sstevel@tonic-gate 		    "usba_hubdi_power: illegal power level=%d "
17687c478bd9Sstevel@tonic-gate 		    "hubp_pwr_states=0x%x", level, hubpm->hubp_pwr_states);
17697c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 		ndi_devi_exit(dip, circ);
17727c478bd9Sstevel@tonic-gate 
17737c478bd9Sstevel@tonic-gate 		return (DDI_FAILURE);
17747c478bd9Sstevel@tonic-gate 	}
17757c478bd9Sstevel@tonic-gate 
17767c478bd9Sstevel@tonic-gate 	switch (level) {
17777c478bd9Sstevel@tonic-gate 	case USB_DEV_OS_PWR_OFF:
17787c478bd9Sstevel@tonic-gate 		retval = hubd_pwrlvl0(hubd);
17797c478bd9Sstevel@tonic-gate 
17807c478bd9Sstevel@tonic-gate 		break;
17817c478bd9Sstevel@tonic-gate 	case USB_DEV_OS_PWR_1:
17827c478bd9Sstevel@tonic-gate 		retval = hubd_pwrlvl1(hubd);
17837c478bd9Sstevel@tonic-gate 
17847c478bd9Sstevel@tonic-gate 		break;
17857c478bd9Sstevel@tonic-gate 	case USB_DEV_OS_PWR_2:
17867c478bd9Sstevel@tonic-gate 		retval = hubd_pwrlvl2(hubd);
17877c478bd9Sstevel@tonic-gate 
17887c478bd9Sstevel@tonic-gate 		break;
17897c478bd9Sstevel@tonic-gate 	case USB_DEV_OS_FULL_PWR:
17907c478bd9Sstevel@tonic-gate 		retval = hubd_pwrlvl3(hubd);
17917c478bd9Sstevel@tonic-gate 
17927c478bd9Sstevel@tonic-gate 		break;
17937c478bd9Sstevel@tonic-gate 	}
17947c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
17957c478bd9Sstevel@tonic-gate 
17967c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
17977c478bd9Sstevel@tonic-gate 
17987c478bd9Sstevel@tonic-gate 	return ((retval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
17997c478bd9Sstevel@tonic-gate }
18007c478bd9Sstevel@tonic-gate 
18017c478bd9Sstevel@tonic-gate 
18027c478bd9Sstevel@tonic-gate /* power entry point for the root hub */
18037c478bd9Sstevel@tonic-gate int
18047c478bd9Sstevel@tonic-gate usba_hubdi_root_hub_power(dev_info_t *dip, int comp, int level)
18057c478bd9Sstevel@tonic-gate {
18067c478bd9Sstevel@tonic-gate 	return (usba_hubdi_power(dip, comp, level));
18077c478bd9Sstevel@tonic-gate }
18087c478bd9Sstevel@tonic-gate 
18097c478bd9Sstevel@tonic-gate 
18107c478bd9Sstevel@tonic-gate /*
18117c478bd9Sstevel@tonic-gate  * standard driver entry points support code
18127c478bd9Sstevel@tonic-gate  */
18137c478bd9Sstevel@tonic-gate int
18147c478bd9Sstevel@tonic-gate usba_hubdi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
18157c478bd9Sstevel@tonic-gate {
18167c478bd9Sstevel@tonic-gate 	int			instance = ddi_get_instance(dip);
18177c478bd9Sstevel@tonic-gate 	hubd_t			*hubd = NULL;
18187c478bd9Sstevel@tonic-gate 	int			i, rval;
18197c478bd9Sstevel@tonic-gate 	int			minor;
1820112cd14aSqz 	uint8_t			ports_count;
18217c478bd9Sstevel@tonic-gate 	char			*log_name = NULL;
18227c478bd9Sstevel@tonic-gate 	const char		*root_hub_drvname;
18237c478bd9Sstevel@tonic-gate 	usb_ep_data_t		*ep_data;
18247c478bd9Sstevel@tonic-gate 	usba_device_t		*child_ud = NULL;
18257c478bd9Sstevel@tonic-gate 	usb_dev_descr_t		*usb_dev_descr;
18267c478bd9Sstevel@tonic-gate 	usb_port_status_t	parent_port_status, child_port_status;
18277c478bd9Sstevel@tonic-gate 
18287c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubdi_log_handle,
1829c0f24e5bSlg 	    "hubd_attach instance %d, cmd=0x%x", instance, cmd);
18307c478bd9Sstevel@tonic-gate 
18317c478bd9Sstevel@tonic-gate 	switch (cmd) {
18327c478bd9Sstevel@tonic-gate 	case DDI_ATTACH:
18337c478bd9Sstevel@tonic-gate 
18347c478bd9Sstevel@tonic-gate 		break;
18357c478bd9Sstevel@tonic-gate 	case DDI_RESUME:
18367c478bd9Sstevel@tonic-gate 		hubd_cpr_resume(dip);
18377c478bd9Sstevel@tonic-gate 
18387c478bd9Sstevel@tonic-gate 		return (DDI_SUCCESS);
18397c478bd9Sstevel@tonic-gate 	default:
18407c478bd9Sstevel@tonic-gate 		return (DDI_FAILURE);
18417c478bd9Sstevel@tonic-gate 	}
18427c478bd9Sstevel@tonic-gate 
18437c478bd9Sstevel@tonic-gate 	/*
18447c478bd9Sstevel@tonic-gate 	 * Allocate softc information.
18457c478bd9Sstevel@tonic-gate 	 */
18467c478bd9Sstevel@tonic-gate 	if (usba_is_root_hub(dip)) {
18477c478bd9Sstevel@tonic-gate 		/* soft state has already been allocated */
18487c478bd9Sstevel@tonic-gate 		hubd = hubd_get_soft_state(dip);
18497c478bd9Sstevel@tonic-gate 		minor = HUBD_IS_ROOT_HUB;
18507c478bd9Sstevel@tonic-gate 
18517c478bd9Sstevel@tonic-gate 		/* generate readable labels for different root hubs */
18527c478bd9Sstevel@tonic-gate 		root_hub_drvname = ddi_driver_name(dip);
18537c478bd9Sstevel@tonic-gate 		if (strcmp(root_hub_drvname, "ehci") == 0) {
18547c478bd9Sstevel@tonic-gate 			log_name = "eusb";
18557c478bd9Sstevel@tonic-gate 		} else if (strcmp(root_hub_drvname, "uhci") == 0) {
18567c478bd9Sstevel@tonic-gate 			log_name = "uusb";
18577c478bd9Sstevel@tonic-gate 		} else {
18587c478bd9Sstevel@tonic-gate 			/* std. for ohci */
18597c478bd9Sstevel@tonic-gate 			log_name = "usb";
18607c478bd9Sstevel@tonic-gate 		}
18617c478bd9Sstevel@tonic-gate 	} else {
18627c478bd9Sstevel@tonic-gate 		rval = ddi_soft_state_zalloc(hubd_statep, instance);
18637c478bd9Sstevel@tonic-gate 		minor = 0;
18647c478bd9Sstevel@tonic-gate 
18657c478bd9Sstevel@tonic-gate 		if (rval != DDI_SUCCESS) {
18667c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
18677c478bd9Sstevel@tonic-gate 			    "cannot allocate soft state (%d)", instance);
18687c478bd9Sstevel@tonic-gate 			goto fail;
18697c478bd9Sstevel@tonic-gate 		}
18707c478bd9Sstevel@tonic-gate 
18717c478bd9Sstevel@tonic-gate 		hubd = hubd_get_soft_state(dip);
18727c478bd9Sstevel@tonic-gate 		if (hubd == NULL) {
18737c478bd9Sstevel@tonic-gate 			goto fail;
18747c478bd9Sstevel@tonic-gate 		}
18757c478bd9Sstevel@tonic-gate 	}
18767c478bd9Sstevel@tonic-gate 
18777c478bd9Sstevel@tonic-gate 	hubd->h_log_handle = usb_alloc_log_hdl(dip, log_name, &hubd_errlevel,
1878c0f24e5bSlg 	    &hubd_errmask, &hubd_instance_debug, 0);
18797c478bd9Sstevel@tonic-gate 
18807c478bd9Sstevel@tonic-gate 	hubd->h_usba_device	= child_ud = usba_get_usba_device(dip);
18817c478bd9Sstevel@tonic-gate 	hubd->h_dip		= dip;
18827c478bd9Sstevel@tonic-gate 	hubd->h_instance	= instance;
18837c478bd9Sstevel@tonic-gate 
18847c478bd9Sstevel@tonic-gate 	mutex_enter(&child_ud->usb_mutex);
18857c478bd9Sstevel@tonic-gate 	child_port_status = child_ud->usb_port_status;
18867c478bd9Sstevel@tonic-gate 	usb_dev_descr = child_ud->usb_dev_descr;
18877c478bd9Sstevel@tonic-gate 	parent_port_status = (child_ud->usb_hs_hub_usba_dev) ?
18887c478bd9Sstevel@tonic-gate 	    child_ud->usb_hs_hub_usba_dev->usb_port_status : 0;
18897c478bd9Sstevel@tonic-gate 	mutex_exit(&child_ud->usb_mutex);
18907c478bd9Sstevel@tonic-gate 
18917c478bd9Sstevel@tonic-gate 	if ((child_port_status == USBA_FULL_SPEED_DEV) &&
18927c478bd9Sstevel@tonic-gate 	    (parent_port_status == USBA_HIGH_SPEED_DEV) &&
18937c478bd9Sstevel@tonic-gate 	    (usb_dev_descr->bcdUSB == 0x100)) {
18947c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L0(DPRINT_MASK_ATTA, hubd->h_log_handle,
18957c478bd9Sstevel@tonic-gate 		    "Use of a USB1.0 hub behind a high speed port may "
18967c478bd9Sstevel@tonic-gate 		    "cause unexpected failures");
18977c478bd9Sstevel@tonic-gate 	}
18987c478bd9Sstevel@tonic-gate 
18997c478bd9Sstevel@tonic-gate 	hubd->h_pipe_policy.pp_max_async_reqs = 1;
19007c478bd9Sstevel@tonic-gate 
19017c478bd9Sstevel@tonic-gate 	/* register with USBA as client driver */
19027c478bd9Sstevel@tonic-gate 	if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) {
19037c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
19047c478bd9Sstevel@tonic-gate 		    "client attach failed");
19057c478bd9Sstevel@tonic-gate 
19067c478bd9Sstevel@tonic-gate 		goto fail;
19077c478bd9Sstevel@tonic-gate 	}
19087c478bd9Sstevel@tonic-gate 
19097c478bd9Sstevel@tonic-gate 	if (usb_get_dev_data(dip, &hubd->h_dev_data,
19107c478bd9Sstevel@tonic-gate 	    USB_PARSE_LVL_IF, 0) != USB_SUCCESS) {
19117c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
19127c478bd9Sstevel@tonic-gate 		    "cannot get dev_data");
19137c478bd9Sstevel@tonic-gate 
19147c478bd9Sstevel@tonic-gate 		goto fail;
19157c478bd9Sstevel@tonic-gate 	}
19167c478bd9Sstevel@tonic-gate 
19177c478bd9Sstevel@tonic-gate 	if ((ep_data = usb_lookup_ep_data(dip, hubd->h_dev_data,
19187c478bd9Sstevel@tonic-gate 	    hubd->h_dev_data->dev_curr_if, 0, 0,
19197c478bd9Sstevel@tonic-gate 	    (uint_t)USB_EP_ATTR_INTR, (uint_t)USB_EP_DIR_IN)) == NULL) {
19207c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
19217c478bd9Sstevel@tonic-gate 		    "no interrupt IN endpoint found");
19227c478bd9Sstevel@tonic-gate 
19237c478bd9Sstevel@tonic-gate 		goto fail;
19247c478bd9Sstevel@tonic-gate 	}
19257c478bd9Sstevel@tonic-gate 
19267c478bd9Sstevel@tonic-gate 	hubd->h_ep1_descr = ep_data->ep_descr;
19277c478bd9Sstevel@tonic-gate 	hubd->h_default_pipe = hubd->h_dev_data->dev_default_ph;
19287c478bd9Sstevel@tonic-gate 
19297c478bd9Sstevel@tonic-gate 	mutex_init(HUBD_MUTEX(hubd), NULL, MUTEX_DRIVER,
1930c0f24e5bSlg 	    hubd->h_dev_data->dev_iblock_cookie);
19317c478bd9Sstevel@tonic-gate 	cv_init(&hubd->h_cv_reset_port, NULL, CV_DRIVER, NULL);
1932ffcd51f3Slg 	cv_init(&hubd->h_cv_hotplug_dev, NULL, CV_DRIVER, NULL);
19337c478bd9Sstevel@tonic-gate 
19347c478bd9Sstevel@tonic-gate 	hubd->h_init_state |= HUBD_LOCKS_DONE;
19357c478bd9Sstevel@tonic-gate 
19367c478bd9Sstevel@tonic-gate 	usb_free_descr_tree(dip, hubd->h_dev_data);
19377c478bd9Sstevel@tonic-gate 
19387c478bd9Sstevel@tonic-gate 	/*
19397c478bd9Sstevel@tonic-gate 	 * register this hub instance with usba
19407c478bd9Sstevel@tonic-gate 	 */
19417c478bd9Sstevel@tonic-gate 	rval = usba_hubdi_register(dip, 0);
19427c478bd9Sstevel@tonic-gate 	if (rval != USB_SUCCESS) {
1943d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
19447c478bd9Sstevel@tonic-gate 		    "usba_hubdi_register failed");
19457c478bd9Sstevel@tonic-gate 		goto fail;
19467c478bd9Sstevel@tonic-gate 	}
19477c478bd9Sstevel@tonic-gate 
19487c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
19497c478bd9Sstevel@tonic-gate 	hubd->h_init_state |= HUBD_HUBDI_REGISTERED;
19507c478bd9Sstevel@tonic-gate 	hubd->h_dev_state = USB_DEV_ONLINE;
19517c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
19527c478bd9Sstevel@tonic-gate 
19537c478bd9Sstevel@tonic-gate 	/* now create components to power manage this device */
19547c478bd9Sstevel@tonic-gate 	hubd_create_pm_components(dip, hubd);
19557c478bd9Sstevel@tonic-gate 
19567c478bd9Sstevel@tonic-gate 	/*
19577c478bd9Sstevel@tonic-gate 	 * Event handling: definition and registration
19587c478bd9Sstevel@tonic-gate 	 *
19597c478bd9Sstevel@tonic-gate 	 * first the  definition:
19607c478bd9Sstevel@tonic-gate 	 * get event handle
19617c478bd9Sstevel@tonic-gate 	 */
19627c478bd9Sstevel@tonic-gate 	(void) ndi_event_alloc_hdl(dip, 0, &hubd->h_ndi_event_hdl, NDI_SLEEP);
19637c478bd9Sstevel@tonic-gate 
19647c478bd9Sstevel@tonic-gate 	/* bind event set to the handle */
19657c478bd9Sstevel@tonic-gate 	if (ndi_event_bind_set(hubd->h_ndi_event_hdl, &hubd_ndi_events,
19667c478bd9Sstevel@tonic-gate 	    NDI_SLEEP)) {
19677c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
19687c478bd9Sstevel@tonic-gate 		    "binding event set failed");
19697c478bd9Sstevel@tonic-gate 
19707c478bd9Sstevel@tonic-gate 		goto fail;
19717c478bd9Sstevel@tonic-gate 	}
19727c478bd9Sstevel@tonic-gate 
19737c478bd9Sstevel@tonic-gate 	/* event registration */
19747c478bd9Sstevel@tonic-gate 	if (hubd_register_events(hubd) != USB_SUCCESS) {
1975d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
19767c478bd9Sstevel@tonic-gate 		    "hubd_register_events failed");
19777c478bd9Sstevel@tonic-gate 
19787c478bd9Sstevel@tonic-gate 		goto fail;
19797c478bd9Sstevel@tonic-gate 	}
19807c478bd9Sstevel@tonic-gate 
19817c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
19827c478bd9Sstevel@tonic-gate 	hubd->h_init_state |= HUBD_EVENTS_REGISTERED;
19837c478bd9Sstevel@tonic-gate 
198435f36846Ssl 	if ((hubd_get_hub_descriptor(hubd)) != USB_SUCCESS) {
198535f36846Ssl 		mutex_exit(HUBD_MUTEX(hubd));
198635f36846Ssl 
198735f36846Ssl 		goto fail;
198835f36846Ssl 	}
198935f36846Ssl 
199035f36846Ssl 	if (ddi_prop_exists(DDI_DEV_T_ANY, dip,
199135f36846Ssl 	    (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
199235f36846Ssl 	    "hub-ignore-power-budget") == 1) {
199335f36846Ssl 		hubd->h_ignore_pwr_budget = B_TRUE;
199435f36846Ssl 	} else {
199535f36846Ssl 		hubd->h_ignore_pwr_budget = B_FALSE;
199635f36846Ssl 
199735f36846Ssl 		/* initialize hub power budget variables */
199835f36846Ssl 		if (hubd_init_power_budget(hubd) != USB_SUCCESS) {
199935f36846Ssl 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
200035f36846Ssl 			    "hubd_init_power_budget failed");
200135f36846Ssl 			mutex_exit(HUBD_MUTEX(hubd));
200235f36846Ssl 
200335f36846Ssl 			goto fail;
200435f36846Ssl 		}
200535f36846Ssl 	}
200635f36846Ssl 
20077c478bd9Sstevel@tonic-gate 	/* initialize and create children */
20087c478bd9Sstevel@tonic-gate 	if (hubd_check_ports(hubd) != USB_SUCCESS) {
2009d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
20107c478bd9Sstevel@tonic-gate 		    "hubd_check_ports failed");
20117c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
20127c478bd9Sstevel@tonic-gate 
20137c478bd9Sstevel@tonic-gate 		goto fail;
20147c478bd9Sstevel@tonic-gate 	}
20157c478bd9Sstevel@tonic-gate 
20167c478bd9Sstevel@tonic-gate 	/*
20177c478bd9Sstevel@tonic-gate 	 * create cfgadm nodes
20187c478bd9Sstevel@tonic-gate 	 */
20197c478bd9Sstevel@tonic-gate 	hubd->h_ancestry_str = (char *)kmem_zalloc(HUBD_APID_NAMELEN, KM_SLEEP);
20207c478bd9Sstevel@tonic-gate 	hubd_get_ancestry_str(hubd);
20217c478bd9Sstevel@tonic-gate 
20227c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
20237c478bd9Sstevel@tonic-gate 	    "#ports=0x%x", hubd->h_hub_descr.bNbrPorts);
20247c478bd9Sstevel@tonic-gate 
20257c478bd9Sstevel@tonic-gate 	for (i = 1; i <= hubd->h_hub_descr.bNbrPorts; i++) {
20267c478bd9Sstevel@tonic-gate 		char ap_name[HUBD_APID_NAMELEN];
20277c478bd9Sstevel@tonic-gate 
20287c478bd9Sstevel@tonic-gate 		(void) snprintf(ap_name, HUBD_APID_NAMELEN, "%s%d",
20297c478bd9Sstevel@tonic-gate 		    hubd->h_ancestry_str, i);
20307c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
20317c478bd9Sstevel@tonic-gate 		    "ap_name=%s", ap_name);
20327c478bd9Sstevel@tonic-gate 
20337c478bd9Sstevel@tonic-gate 		if (ddi_create_minor_node(dip, ap_name, S_IFCHR, instance,
20347c478bd9Sstevel@tonic-gate 		    DDI_NT_USB_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
2035d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
20367c478bd9Sstevel@tonic-gate 			    "cannot create attachment point node (%d)",
20377c478bd9Sstevel@tonic-gate 			    instance);
20387c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
20397c478bd9Sstevel@tonic-gate 
20407c478bd9Sstevel@tonic-gate 			goto fail;
20417c478bd9Sstevel@tonic-gate 		}
20427c478bd9Sstevel@tonic-gate 	}
2043112cd14aSqz 
2044112cd14aSqz 	ports_count = hubd->h_hub_descr.bNbrPorts;
20457c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
20467c478bd9Sstevel@tonic-gate 
20477c478bd9Sstevel@tonic-gate 	/* create minor nodes */
20487c478bd9Sstevel@tonic-gate 	if (ddi_create_minor_node(dip, "hubd", S_IFCHR,
20497c478bd9Sstevel@tonic-gate 	    instance | minor, DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
20507c478bd9Sstevel@tonic-gate 
2051d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
20527c478bd9Sstevel@tonic-gate 		    "cannot create devctl minor node (%d)", instance);
20537c478bd9Sstevel@tonic-gate 
20547c478bd9Sstevel@tonic-gate 		goto fail;
20557c478bd9Sstevel@tonic-gate 	}
20567c478bd9Sstevel@tonic-gate 
20577c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
20587c478bd9Sstevel@tonic-gate 	hubd->h_init_state |= HUBD_MINOR_NODE_CREATED;
20597c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
20607c478bd9Sstevel@tonic-gate 
2061112cd14aSqz 	if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
2062112cd14aSqz 	    "usb-port-count", ports_count) != DDI_PROP_SUCCESS) {
2063112cd14aSqz 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2064ff0e937bSRaymond Chen 		    "usb-port-count update failed");
2065112cd14aSqz 	}
2066112cd14aSqz 
20677c478bd9Sstevel@tonic-gate 	/*
20687c478bd9Sstevel@tonic-gate 	 * host controller driver has already reported this dev
20697c478bd9Sstevel@tonic-gate 	 * if we are the root hub
20707c478bd9Sstevel@tonic-gate 	 */
20717c478bd9Sstevel@tonic-gate 	if (!usba_is_root_hub(dip)) {
20727c478bd9Sstevel@tonic-gate 		ddi_report_dev(dip);
20737c478bd9Sstevel@tonic-gate 	}
20747c478bd9Sstevel@tonic-gate 
20757c478bd9Sstevel@tonic-gate 	/* enable deathrow thread */
20767c478bd9Sstevel@tonic-gate 	hubd->h_cleanup_enabled = B_TRUE;
20777c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
20787c478bd9Sstevel@tonic-gate 	hubd_pm_idle_component(hubd, dip, 0);
20797c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
20807c478bd9Sstevel@tonic-gate 
20817c478bd9Sstevel@tonic-gate 	return (DDI_SUCCESS);
20827c478bd9Sstevel@tonic-gate 
20837c478bd9Sstevel@tonic-gate fail:
20847c478bd9Sstevel@tonic-gate 	{
20857c478bd9Sstevel@tonic-gate 		char *pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
20867c478bd9Sstevel@tonic-gate 
20878668df41Slg 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
20887c478bd9Sstevel@tonic-gate 		    "cannot attach %s", ddi_pathname(dip, pathname));
20897c478bd9Sstevel@tonic-gate 
20907c478bd9Sstevel@tonic-gate 		kmem_free(pathname, MAXPATHLEN);
20917c478bd9Sstevel@tonic-gate 	}
20927c478bd9Sstevel@tonic-gate 
20937c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
20947c478bd9Sstevel@tonic-gate 	hubd_pm_idle_component(hubd, dip, 0);
20957c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
20967c478bd9Sstevel@tonic-gate 
20977c478bd9Sstevel@tonic-gate 	if (hubd) {
20987c478bd9Sstevel@tonic-gate 		rval = hubd_cleanup(dip, hubd);
20997c478bd9Sstevel@tonic-gate 		if (rval != USB_SUCCESS) {
2100d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
21017c478bd9Sstevel@tonic-gate 			    "failure to complete cleanup after attach failure");
21027c478bd9Sstevel@tonic-gate 		}
21037c478bd9Sstevel@tonic-gate 	}
21047c478bd9Sstevel@tonic-gate 
21057c478bd9Sstevel@tonic-gate 	return (DDI_FAILURE);
21067c478bd9Sstevel@tonic-gate }
21077c478bd9Sstevel@tonic-gate 
21087c478bd9Sstevel@tonic-gate 
21097c478bd9Sstevel@tonic-gate int
21107c478bd9Sstevel@tonic-gate usba_hubdi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
21117c478bd9Sstevel@tonic-gate {
21127c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = hubd_get_soft_state(dip);
21137c478bd9Sstevel@tonic-gate 	int	rval;
21147c478bd9Sstevel@tonic-gate 
21157c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
21167c478bd9Sstevel@tonic-gate 	    "hubd_detach: cmd=0x%x", cmd);
21177c478bd9Sstevel@tonic-gate 
21187c478bd9Sstevel@tonic-gate 	switch (cmd) {
21197c478bd9Sstevel@tonic-gate 	case DDI_DETACH:
21207c478bd9Sstevel@tonic-gate 		rval = hubd_cleanup(dip, hubd);
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 		return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
21237c478bd9Sstevel@tonic-gate 	case DDI_SUSPEND:
21247c478bd9Sstevel@tonic-gate 		rval = hubd_cpr_suspend(hubd);
21257c478bd9Sstevel@tonic-gate 
21267c478bd9Sstevel@tonic-gate 		return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
21277c478bd9Sstevel@tonic-gate 	default:
21287c478bd9Sstevel@tonic-gate 		return (DDI_FAILURE);
21297c478bd9Sstevel@tonic-gate 	}
21307c478bd9Sstevel@tonic-gate }
21317c478bd9Sstevel@tonic-gate 
21327c478bd9Sstevel@tonic-gate 
21337c478bd9Sstevel@tonic-gate /*
21347c478bd9Sstevel@tonic-gate  * hubd_setdevaddr
21357c478bd9Sstevel@tonic-gate  *	set the device addrs on this port
21367c478bd9Sstevel@tonic-gate  */
21377c478bd9Sstevel@tonic-gate static int
21387c478bd9Sstevel@tonic-gate hubd_setdevaddr(hubd_t *hubd, usb_port_t port)
21397c478bd9Sstevel@tonic-gate {
21407c478bd9Sstevel@tonic-gate 	int		rval;
21417c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
21427c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
21437c478bd9Sstevel@tonic-gate 	usb_pipe_handle_t ph;
21447c478bd9Sstevel@tonic-gate 	dev_info_t	*child_dip = NULL;
21457c478bd9Sstevel@tonic-gate 	uchar_t		address = 0;
21467c478bd9Sstevel@tonic-gate 	usba_device_t	*usba_device;
21477c478bd9Sstevel@tonic-gate 	int		retry = 0;
21487c478bd9Sstevel@tonic-gate 	long		time_delay;
21497c478bd9Sstevel@tonic-gate 
21507c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
21517c478bd9Sstevel@tonic-gate 	    "hubd_setdevaddr: port=%d", port);
21527c478bd9Sstevel@tonic-gate 
21537c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 	child_dip = hubd->h_children_dips[port];
21567c478bd9Sstevel@tonic-gate 	address = hubd->h_usba_devices[port]->usb_addr;
21577c478bd9Sstevel@tonic-gate 	usba_device = hubd->h_usba_devices[port];
21587c478bd9Sstevel@tonic-gate 
21597c478bd9Sstevel@tonic-gate 	/* close the default pipe with addr x */
21607c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
21617c478bd9Sstevel@tonic-gate 	ph = usba_get_dflt_pipe_handle(child_dip);
21627c478bd9Sstevel@tonic-gate 	usb_pipe_close(child_dip, ph,
21637c478bd9Sstevel@tonic-gate 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
21647c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
21657c478bd9Sstevel@tonic-gate 
21667c478bd9Sstevel@tonic-gate 	/*
21677c478bd9Sstevel@tonic-gate 	 * As this device has been reset, temporarily
21687c478bd9Sstevel@tonic-gate 	 * assign the default address
21697c478bd9Sstevel@tonic-gate 	 */
21707c478bd9Sstevel@tonic-gate 	mutex_enter(&usba_device->usb_mutex);
21717c478bd9Sstevel@tonic-gate 	address = usba_device->usb_addr;
21727c478bd9Sstevel@tonic-gate 	usba_device->usb_addr = USBA_DEFAULT_ADDR;
21737c478bd9Sstevel@tonic-gate 	mutex_exit(&usba_device->usb_mutex);
21747c478bd9Sstevel@tonic-gate 
21757c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
21767c478bd9Sstevel@tonic-gate 
21777c478bd9Sstevel@tonic-gate 	time_delay = drv_usectohz(hubd_device_delay / 20);
21787c478bd9Sstevel@tonic-gate 	for (retry = 0; retry < hubd_retry_enumerate; retry++) {
21797c478bd9Sstevel@tonic-gate 
21807c478bd9Sstevel@tonic-gate 		/* open child's default pipe with USBA_DEFAULT_ADDR */
21817c478bd9Sstevel@tonic-gate 		if (usb_pipe_open(child_dip, NULL, NULL,
21827c478bd9Sstevel@tonic-gate 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph) !=
21837c478bd9Sstevel@tonic-gate 		    USB_SUCCESS) {
21847c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
21857c478bd9Sstevel@tonic-gate 			    "hubd_setdevaddr: Unable to open default pipe");
21867c478bd9Sstevel@tonic-gate 
21877c478bd9Sstevel@tonic-gate 			break;
21887c478bd9Sstevel@tonic-gate 		}
21897c478bd9Sstevel@tonic-gate 
21907c478bd9Sstevel@tonic-gate 		/* Set the address of the device */
21917c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
21927c478bd9Sstevel@tonic-gate 		    USB_DEV_REQ_HOST_TO_DEV,
21937c478bd9Sstevel@tonic-gate 		    USB_REQ_SET_ADDRESS,	/* bRequest */
21947c478bd9Sstevel@tonic-gate 		    address,			/* wValue */
21957c478bd9Sstevel@tonic-gate 		    0,				/* wIndex */
21967c478bd9Sstevel@tonic-gate 		    0,				/* wLength */
21977c478bd9Sstevel@tonic-gate 		    NULL, 0,
21987c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
21997c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
22007c478bd9Sstevel@tonic-gate 			    "hubd_setdevaddr(%d): rval=%d cr=%d cb_fl=0x%x",
22017c478bd9Sstevel@tonic-gate 			    retry, rval, completion_reason, cb_flags);
22027c478bd9Sstevel@tonic-gate 		}
22037c478bd9Sstevel@tonic-gate 
22047c478bd9Sstevel@tonic-gate 		usb_pipe_close(child_dip, ph,
22057c478bd9Sstevel@tonic-gate 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
22067c478bd9Sstevel@tonic-gate 
22077c478bd9Sstevel@tonic-gate 		if (rval == USB_SUCCESS) {
22087c478bd9Sstevel@tonic-gate 
22097c478bd9Sstevel@tonic-gate 			break;
22107c478bd9Sstevel@tonic-gate 		}
22117c478bd9Sstevel@tonic-gate 
22127c478bd9Sstevel@tonic-gate 		delay(time_delay);
22137c478bd9Sstevel@tonic-gate 	}
22147c478bd9Sstevel@tonic-gate 
22157c478bd9Sstevel@tonic-gate 	/* Reset to the old address */
22167c478bd9Sstevel@tonic-gate 	mutex_enter(&usba_device->usb_mutex);
22177c478bd9Sstevel@tonic-gate 	usba_device->usb_addr = address;
22187c478bd9Sstevel@tonic-gate 	mutex_exit(&usba_device->usb_mutex);
22197c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
22207c478bd9Sstevel@tonic-gate 
22217c478bd9Sstevel@tonic-gate 	usba_clear_data_toggle(usba_device);
22227c478bd9Sstevel@tonic-gate 
22237c478bd9Sstevel@tonic-gate 	return (rval);
22247c478bd9Sstevel@tonic-gate }
22257c478bd9Sstevel@tonic-gate 
22267c478bd9Sstevel@tonic-gate 
22277c478bd9Sstevel@tonic-gate /*
22287c478bd9Sstevel@tonic-gate  * hubd_setdevconfig
22297c478bd9Sstevel@tonic-gate  *	set the device addrs on this port
22307c478bd9Sstevel@tonic-gate  */
22317c478bd9Sstevel@tonic-gate static void
22327c478bd9Sstevel@tonic-gate hubd_setdevconfig(hubd_t *hubd, usb_port_t port)
22337c478bd9Sstevel@tonic-gate {
22347c478bd9Sstevel@tonic-gate 	int			rval;
22357c478bd9Sstevel@tonic-gate 	usb_cr_t		completion_reason;
22367c478bd9Sstevel@tonic-gate 	usb_cb_flags_t		cb_flags;
22377c478bd9Sstevel@tonic-gate 	usb_pipe_handle_t	ph;
22387c478bd9Sstevel@tonic-gate 	dev_info_t		*child_dip = NULL;
22397c478bd9Sstevel@tonic-gate 	usba_device_t		*usba_device = NULL;
22407c478bd9Sstevel@tonic-gate 	uint16_t		config_value;
22417c478bd9Sstevel@tonic-gate 
22427c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
22437c478bd9Sstevel@tonic-gate 	    "hubd_setdevconfig: port=%d", port);
22447c478bd9Sstevel@tonic-gate 
22457c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
22467c478bd9Sstevel@tonic-gate 
22477c478bd9Sstevel@tonic-gate 	child_dip = hubd->h_children_dips[port];
22487c478bd9Sstevel@tonic-gate 	usba_device = hubd->h_usba_devices[port];
22497c478bd9Sstevel@tonic-gate 	config_value = hubd->h_usba_devices[port]->usb_cfg_value;
22507c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
22517c478bd9Sstevel@tonic-gate 
22527c478bd9Sstevel@tonic-gate 	/* open the default control pipe */
22537c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
22547c478bd9Sstevel@tonic-gate 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) ==
22557c478bd9Sstevel@tonic-gate 	    USB_SUCCESS) {
22567c478bd9Sstevel@tonic-gate 
22577c478bd9Sstevel@tonic-gate 		/* Set the default configuration of the device */
22587c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
22597c478bd9Sstevel@tonic-gate 		    USB_DEV_REQ_HOST_TO_DEV,
22607c478bd9Sstevel@tonic-gate 		    USB_REQ_SET_CFG,		/* bRequest */
22617c478bd9Sstevel@tonic-gate 		    config_value,		/* wValue */
22627c478bd9Sstevel@tonic-gate 		    0,				/* wIndex */
22637c478bd9Sstevel@tonic-gate 		    0,				/* wLength */
22647c478bd9Sstevel@tonic-gate 		    NULL, 0,
22657c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
22667c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
22677c478bd9Sstevel@tonic-gate 			    "hubd_setdevconfig: set device config failed: "
22687c478bd9Sstevel@tonic-gate 			    "cr=%d cb_fl=0x%x rval=%d",
22697c478bd9Sstevel@tonic-gate 			    completion_reason, cb_flags, rval);
22707c478bd9Sstevel@tonic-gate 		}
22717c478bd9Sstevel@tonic-gate 		/*
22727c478bd9Sstevel@tonic-gate 		 * After setting the configuration, we make this default
22737c478bd9Sstevel@tonic-gate 		 * control pipe persistent, so that it gets re-opened
22747c478bd9Sstevel@tonic-gate 		 * on posting a connect event
22757c478bd9Sstevel@tonic-gate 		 */
22767c478bd9Sstevel@tonic-gate 		usba_persistent_pipe_close(usba_device);
22777c478bd9Sstevel@tonic-gate 	} else {
22787c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
22797c478bd9Sstevel@tonic-gate 		    "pipe open fails: rval=%d", rval);
22807c478bd9Sstevel@tonic-gate 	}
22817c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
22827c478bd9Sstevel@tonic-gate }
22837c478bd9Sstevel@tonic-gate 
22847c478bd9Sstevel@tonic-gate 
22857c478bd9Sstevel@tonic-gate /*ARGSUSED*/
22867c478bd9Sstevel@tonic-gate static int
22877c478bd9Sstevel@tonic-gate hubd_check_disconnected_ports(dev_info_t *dip, void *arg)
22887c478bd9Sstevel@tonic-gate {
22897c478bd9Sstevel@tonic-gate 	int circ;
22907c478bd9Sstevel@tonic-gate 	usb_port_t port;
22917c478bd9Sstevel@tonic-gate 	hubd_t *hubd;
22927c478bd9Sstevel@tonic-gate 	major_t hub_major = ddi_name_to_major("hubd");
2293ff0e937bSRaymond Chen 	major_t hwahc_major = ddi_name_to_major("hwahc");
2294ff0e937bSRaymond Chen 	major_t usbmid_major = ddi_name_to_major("usb_mid");
22957c478bd9Sstevel@tonic-gate 
22967c478bd9Sstevel@tonic-gate 	/*
22977c478bd9Sstevel@tonic-gate 	 * make sure dip is a usb hub, major of root hub is HCD
22987c478bd9Sstevel@tonic-gate 	 * major
22997c478bd9Sstevel@tonic-gate 	 */
23007c478bd9Sstevel@tonic-gate 	if (!usba_is_root_hub(dip)) {
2301ff0e937bSRaymond Chen 		if (ddi_driver_major(dip) == usbmid_major) {
2302ff0e937bSRaymond Chen 			/*
2303ff0e937bSRaymond Chen 			 * need to walk the children since it might be a
2304ff0e937bSRaymond Chen 			 * HWA device
2305ff0e937bSRaymond Chen 			 */
2306ff0e937bSRaymond Chen 
2307ff0e937bSRaymond Chen 			return (DDI_WALK_CONTINUE);
2308ff0e937bSRaymond Chen 		}
2309ff0e937bSRaymond Chen 
2310ff0e937bSRaymond Chen 		/* TODO: DWA device may also need special handling */
2311ff0e937bSRaymond Chen 
2312ff0e937bSRaymond Chen 		if (((ddi_driver_major(dip) != hub_major) &&
2313ff0e937bSRaymond Chen 		    (ddi_driver_major(dip) != hwahc_major)) ||
2314737d277aScth 		    !i_ddi_devi_attached(dip)) {
23157c478bd9Sstevel@tonic-gate 
23167c478bd9Sstevel@tonic-gate 			return (DDI_WALK_PRUNECHILD);
23177c478bd9Sstevel@tonic-gate 		}
23187c478bd9Sstevel@tonic-gate 	}
23197c478bd9Sstevel@tonic-gate 
23207c478bd9Sstevel@tonic-gate 	hubd = hubd_get_soft_state(dip);
23217c478bd9Sstevel@tonic-gate 	if (hubd == NULL) {
23227c478bd9Sstevel@tonic-gate 
23237c478bd9Sstevel@tonic-gate 		return (DDI_WALK_PRUNECHILD);
23247c478bd9Sstevel@tonic-gate 	}
23257c478bd9Sstevel@tonic-gate 
23267c478bd9Sstevel@tonic-gate 	/* walk child list and remove nodes with flag DEVI_DEVICE_REMOVED */
23277c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
23287c478bd9Sstevel@tonic-gate 
2329ff0e937bSRaymond Chen 	if (ddi_driver_major(dip) != hwahc_major) {
2330ff0e937bSRaymond Chen 		/* for normal usb hub or root hub */
2331ff0e937bSRaymond Chen 		mutex_enter(HUBD_MUTEX(hubd));
2332ff0e937bSRaymond Chen 		for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
2333ff0e937bSRaymond Chen 			dev_info_t *cdip = hubd->h_children_dips[port];
23347c478bd9Sstevel@tonic-gate 
2335ff0e937bSRaymond Chen 			if (cdip == NULL || DEVI_IS_DEVICE_REMOVED(cdip) == 0) {
23367c478bd9Sstevel@tonic-gate 
2337ff0e937bSRaymond Chen 				continue;
2338ff0e937bSRaymond Chen 			}
2339ff0e937bSRaymond Chen 
2340ff0e937bSRaymond Chen 			(void) hubd_delete_child(hubd, port, NDI_DEVI_REMOVE,
2341ff0e937bSRaymond Chen 			    B_TRUE);
23427c478bd9Sstevel@tonic-gate 		}
2343ff0e937bSRaymond Chen 		mutex_exit(HUBD_MUTEX(hubd));
2344ff0e937bSRaymond Chen 	} else {
2345ff0e937bSRaymond Chen 		/* for HWA */
2346ff0e937bSRaymond Chen 		if (hubd->h_cleanup_child != NULL) {
2347ff0e937bSRaymond Chen 			if (hubd->h_cleanup_child(dip) != USB_SUCCESS) {
2348ff0e937bSRaymond Chen 				ndi_devi_exit(dip, circ);
2349ff0e937bSRaymond Chen 
2350ff0e937bSRaymond Chen 				return (DDI_WALK_PRUNECHILD);
2351ff0e937bSRaymond Chen 			}
2352ff0e937bSRaymond Chen 		} else {
2353ff0e937bSRaymond Chen 			ndi_devi_exit(dip, circ);
23547c478bd9Sstevel@tonic-gate 
2355ff0e937bSRaymond Chen 			return (DDI_WALK_PRUNECHILD);
2356ff0e937bSRaymond Chen 		}
23577c478bd9Sstevel@tonic-gate 	}
2358ff0e937bSRaymond Chen 
23597c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
23607c478bd9Sstevel@tonic-gate 
23617c478bd9Sstevel@tonic-gate 	/* skip siblings of root hub */
23627c478bd9Sstevel@tonic-gate 	if (usba_is_root_hub(dip)) {
23637c478bd9Sstevel@tonic-gate 
23647c478bd9Sstevel@tonic-gate 		return (DDI_WALK_PRUNESIB);
23657c478bd9Sstevel@tonic-gate 	}
23667c478bd9Sstevel@tonic-gate 
23677c478bd9Sstevel@tonic-gate 	return (DDI_WALK_CONTINUE);
23687c478bd9Sstevel@tonic-gate }
23697c478bd9Sstevel@tonic-gate 
23707c478bd9Sstevel@tonic-gate 
23717c478bd9Sstevel@tonic-gate /*
23727c478bd9Sstevel@tonic-gate  * this thread will walk all children under the root hub for this
23737c478bd9Sstevel@tonic-gate  * USB bus instance and attempt to remove them
23747c478bd9Sstevel@tonic-gate  */
23757c478bd9Sstevel@tonic-gate static void
23767c478bd9Sstevel@tonic-gate hubd_root_hub_cleanup_thread(void *arg)
23777c478bd9Sstevel@tonic-gate {
23787c478bd9Sstevel@tonic-gate 	int circ;
23797c478bd9Sstevel@tonic-gate 	hubd_t *root_hubd = (hubd_t *)arg;
23807c478bd9Sstevel@tonic-gate 	dev_info_t *rh_dip = root_hubd->h_dip;
23817c478bd9Sstevel@tonic-gate #ifndef __lock_lint
23827c478bd9Sstevel@tonic-gate 	callb_cpr_t cprinfo;
23837c478bd9Sstevel@tonic-gate 
23847c478bd9Sstevel@tonic-gate 	CALLB_CPR_INIT(&cprinfo, HUBD_MUTEX(root_hubd), callb_generic_cpr,
23857c478bd9Sstevel@tonic-gate 	    "USB root hub");
23867c478bd9Sstevel@tonic-gate #endif
23877c478bd9Sstevel@tonic-gate 
23887c478bd9Sstevel@tonic-gate 	for (;;) {
23897c478bd9Sstevel@tonic-gate 		/* don't race with detach */
23907c478bd9Sstevel@tonic-gate 		ndi_hold_devi(rh_dip);
23917c478bd9Sstevel@tonic-gate 
23927c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(root_hubd));
23937c478bd9Sstevel@tonic-gate 		root_hubd->h_cleanup_needed = 0;
23947c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(root_hubd));
23957c478bd9Sstevel@tonic-gate 
23967c478bd9Sstevel@tonic-gate 		(void) devfs_clean(rh_dip, NULL, 0);
23977c478bd9Sstevel@tonic-gate 
23987c478bd9Sstevel@tonic-gate 		ndi_devi_enter(ddi_get_parent(rh_dip), &circ);
23997c478bd9Sstevel@tonic-gate 		ddi_walk_devs(rh_dip, hubd_check_disconnected_ports,
2400c0f24e5bSlg 		    NULL);
24017c478bd9Sstevel@tonic-gate #ifdef __lock_lint
24027c478bd9Sstevel@tonic-gate 		(void) hubd_check_disconnected_ports(rh_dip, NULL);
24037c478bd9Sstevel@tonic-gate #endif
24047c478bd9Sstevel@tonic-gate 		ndi_devi_exit(ddi_get_parent(rh_dip), circ);
24057c478bd9Sstevel@tonic-gate 
24067c478bd9Sstevel@tonic-gate 		/* quit if we are not enabled anymore */
24077c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(root_hubd));
24087c478bd9Sstevel@tonic-gate 		if ((root_hubd->h_cleanup_enabled == B_FALSE) ||
24097c478bd9Sstevel@tonic-gate 		    (root_hubd->h_cleanup_needed == B_FALSE)) {
24107c478bd9Sstevel@tonic-gate 			root_hubd->h_cleanup_active = B_FALSE;
24117c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(root_hubd));
24127c478bd9Sstevel@tonic-gate 			ndi_rele_devi(rh_dip);
24137c478bd9Sstevel@tonic-gate 
24147c478bd9Sstevel@tonic-gate 			break;
24157c478bd9Sstevel@tonic-gate 		}
24167c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(root_hubd));
24177c478bd9Sstevel@tonic-gate 		ndi_rele_devi(rh_dip);
24187c478bd9Sstevel@tonic-gate 
24197c478bd9Sstevel@tonic-gate #ifndef __lock_lint
24207c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(root_hubd));
24217c478bd9Sstevel@tonic-gate 		CALLB_CPR_SAFE_BEGIN(&cprinfo);
24227c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(root_hubd));
24237c478bd9Sstevel@tonic-gate 
24247c478bd9Sstevel@tonic-gate 		delay(drv_usectohz(hubd_dip_cleanup_delay));
24257c478bd9Sstevel@tonic-gate 
24267c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(root_hubd));
24277c478bd9Sstevel@tonic-gate 		CALLB_CPR_SAFE_END(&cprinfo, HUBD_MUTEX(root_hubd));
24287c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(root_hubd));
24297c478bd9Sstevel@tonic-gate #endif
24307c478bd9Sstevel@tonic-gate 	}
24317c478bd9Sstevel@tonic-gate 
24327c478bd9Sstevel@tonic-gate #ifndef __lock_lint
24337c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(root_hubd));
24347c478bd9Sstevel@tonic-gate 	CALLB_CPR_EXIT(&cprinfo);
24357c478bd9Sstevel@tonic-gate #endif
24367c478bd9Sstevel@tonic-gate }
24377c478bd9Sstevel@tonic-gate 
24387c478bd9Sstevel@tonic-gate 
2439ff0e937bSRaymond Chen void
24407c478bd9Sstevel@tonic-gate hubd_schedule_cleanup(dev_info_t *rh_dip)
24417c478bd9Sstevel@tonic-gate {
2442ff0e937bSRaymond Chen 	hubd_t	*root_hubd;
2443ff0e937bSRaymond Chen 
2444ff0e937bSRaymond Chen 	/*
2445ff0e937bSRaymond Chen 	 * The usb_root_hub_dip pointer for the child hub of the WUSB
2446ff0e937bSRaymond Chen 	 * wire adapter class device points to the wire adapter, not
2447ff0e937bSRaymond Chen 	 * the root hub. Need to find the real root hub dip so that
2448ff0e937bSRaymond Chen 	 * the cleanup thread only starts from the root hub.
2449ff0e937bSRaymond Chen 	 */
2450ff0e937bSRaymond Chen 	while (!usba_is_root_hub(rh_dip)) {
2451ff0e937bSRaymond Chen 		root_hubd = hubd_get_soft_state(rh_dip);
2452ff0e937bSRaymond Chen 		if (root_hubd != NULL) {
2453ff0e937bSRaymond Chen 			rh_dip = root_hubd->h_usba_device->usb_root_hub_dip;
2454ff0e937bSRaymond Chen 			if (rh_dip == NULL) {
2455ff0e937bSRaymond Chen 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
2456ff0e937bSRaymond Chen 				    root_hubd->h_log_handle,
2457ff0e937bSRaymond Chen 				    "hubd_schedule_cleanup: null rh dip");
2458ff0e937bSRaymond Chen 
2459ff0e937bSRaymond Chen 				return;
2460ff0e937bSRaymond Chen 			}
2461ff0e937bSRaymond Chen 		} else {
2462ff0e937bSRaymond Chen 			USB_DPRINTF_L2(DPRINT_MASK_ATTA,
2463ff0e937bSRaymond Chen 			    root_hubd->h_log_handle,
2464ff0e937bSRaymond Chen 			    "hubd_schedule_cleanup: cannot find root hub");
2465ff0e937bSRaymond Chen 
2466ff0e937bSRaymond Chen 			return;
2467ff0e937bSRaymond Chen 		}
2468ff0e937bSRaymond Chen 	}
2469ff0e937bSRaymond Chen 	root_hubd = hubd_get_soft_state(rh_dip);
24707c478bd9Sstevel@tonic-gate 
24717c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(root_hubd));
24727c478bd9Sstevel@tonic-gate 	root_hubd->h_cleanup_needed = B_TRUE;
24737c478bd9Sstevel@tonic-gate 	if (root_hubd->h_cleanup_enabled && !(root_hubd->h_cleanup_active)) {
24747c478bd9Sstevel@tonic-gate 		root_hubd->h_cleanup_active = B_TRUE;
24757c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(root_hubd));
24767c478bd9Sstevel@tonic-gate 		(void) thread_create(NULL, 0,
24777c478bd9Sstevel@tonic-gate 		    hubd_root_hub_cleanup_thread,
24787c478bd9Sstevel@tonic-gate 		    (void *)root_hubd, 0, &p0, TS_RUN,
24797c478bd9Sstevel@tonic-gate 		    minclsyspri);
24807c478bd9Sstevel@tonic-gate 	} else {
24817c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(root_hubd));
24827c478bd9Sstevel@tonic-gate 	}
24837c478bd9Sstevel@tonic-gate }
24847c478bd9Sstevel@tonic-gate 
24857c478bd9Sstevel@tonic-gate 
24867c478bd9Sstevel@tonic-gate /*
24877c478bd9Sstevel@tonic-gate  * hubd_restore_device_state:
24887c478bd9Sstevel@tonic-gate  *	- set config for the hub
24897c478bd9Sstevel@tonic-gate  *	- power cycle all the ports
24907c478bd9Sstevel@tonic-gate  *	- for each port that was connected
24917c478bd9Sstevel@tonic-gate  *		- reset port
24927c478bd9Sstevel@tonic-gate  *		- assign addrs to the device on this port
24937c478bd9Sstevel@tonic-gate  *	- restart polling
24947c478bd9Sstevel@tonic-gate  *	- reset suspend flag
24957c478bd9Sstevel@tonic-gate  */
24967c478bd9Sstevel@tonic-gate static void
24977c478bd9Sstevel@tonic-gate hubd_restore_device_state(dev_info_t *dip, hubd_t *hubd)
24987c478bd9Sstevel@tonic-gate {
24997c478bd9Sstevel@tonic-gate 	int		rval;
25007c478bd9Sstevel@tonic-gate 	int		retry;
25017c478bd9Sstevel@tonic-gate 	uint_t		hub_prev_state;
25027c478bd9Sstevel@tonic-gate 	usb_port_t	port;
25037c478bd9Sstevel@tonic-gate 	uint16_t	status;
25047c478bd9Sstevel@tonic-gate 	uint16_t	change;
25057c478bd9Sstevel@tonic-gate 	dev_info_t	*ch_dip;
25067c478bd9Sstevel@tonic-gate 	boolean_t	ehci_root_hub;
25077c478bd9Sstevel@tonic-gate 
25087c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
25097c478bd9Sstevel@tonic-gate 	    "hubd_restore_device_state:");
25107c478bd9Sstevel@tonic-gate 
25117c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
25127c478bd9Sstevel@tonic-gate 	hub_prev_state = hubd->h_dev_state;
25137c478bd9Sstevel@tonic-gate 	ASSERT(hub_prev_state != USB_DEV_PWRED_DOWN);
25147c478bd9Sstevel@tonic-gate 
25157c478bd9Sstevel@tonic-gate 	/* First bring the device to full power */
25167c478bd9Sstevel@tonic-gate 	(void) hubd_pm_busy_component(hubd, dip, 0);
25177c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
25187c478bd9Sstevel@tonic-gate 
25197c478bd9Sstevel@tonic-gate 	(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
25207c478bd9Sstevel@tonic-gate 
25217c478bd9Sstevel@tonic-gate 	if (!usba_is_root_hub(dip) &&
25227c478bd9Sstevel@tonic-gate 	    (usb_check_same_device(dip, hubd->h_log_handle, USB_LOG_L0,
25237c478bd9Sstevel@tonic-gate 	    DPRINT_MASK_HOTPLUG,
25247c478bd9Sstevel@tonic-gate 	    USB_CHK_BASIC|USB_CHK_CFG, NULL) != USB_SUCCESS)) {
25257c478bd9Sstevel@tonic-gate 
25267c478bd9Sstevel@tonic-gate 		/* change the device state to disconnected */
25277c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
25287c478bd9Sstevel@tonic-gate 		hubd->h_dev_state = USB_DEV_DISCONNECTED;
25297c478bd9Sstevel@tonic-gate 		(void) hubd_pm_idle_component(hubd, dip, 0);
25307c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
25317c478bd9Sstevel@tonic-gate 
25327c478bd9Sstevel@tonic-gate 		return;
25337c478bd9Sstevel@tonic-gate 	}
25347c478bd9Sstevel@tonic-gate 
25357c478bd9Sstevel@tonic-gate 	ehci_root_hub = (strcmp(ddi_driver_name(dip), "ehci") == 0);
25367c478bd9Sstevel@tonic-gate 
25377c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
25387c478bd9Sstevel@tonic-gate 	/* First turn off all port power */
25397c478bd9Sstevel@tonic-gate 	rval = hubd_disable_all_port_power(hubd);
25407c478bd9Sstevel@tonic-gate 	if (rval != USB_SUCCESS) {
25417c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
25427c478bd9Sstevel@tonic-gate 		    "hubd_restore_device_state:"
25437c478bd9Sstevel@tonic-gate 		    "turning off port power failed");
25447c478bd9Sstevel@tonic-gate 	}
25457c478bd9Sstevel@tonic-gate 
25467c478bd9Sstevel@tonic-gate 	/* Settling time before turning on again */
25477c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
25487c478bd9Sstevel@tonic-gate 	delay(drv_usectohz(hubd_device_delay / 100));
25497c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
25507c478bd9Sstevel@tonic-gate 
25517c478bd9Sstevel@tonic-gate 	/* enable power on all ports so we can see connects */
25527c478bd9Sstevel@tonic-gate 	if (hubd_enable_all_port_power(hubd) != USB_SUCCESS) {
25537c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
25547c478bd9Sstevel@tonic-gate 		    "hubd_restore_device_state: turn on port power failed");
25557c478bd9Sstevel@tonic-gate 
25567c478bd9Sstevel@tonic-gate 		/* disable whatever was enabled */
25577c478bd9Sstevel@tonic-gate 		(void) hubd_disable_all_port_power(hubd);
25587c478bd9Sstevel@tonic-gate 
25597c478bd9Sstevel@tonic-gate 		(void) hubd_pm_idle_component(hubd, dip, 0);
25607c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
25617c478bd9Sstevel@tonic-gate 
25627c478bd9Sstevel@tonic-gate 		return;
25637c478bd9Sstevel@tonic-gate 	}
25647c478bd9Sstevel@tonic-gate 
25657c478bd9Sstevel@tonic-gate 	/*
25667c478bd9Sstevel@tonic-gate 	 * wait at least 3 frames before accessing devices
25677c478bd9Sstevel@tonic-gate 	 * (note that delay's minimal time is one clock tick which
25687c478bd9Sstevel@tonic-gate 	 * is 10ms unless hires_tick has been changed)
25697c478bd9Sstevel@tonic-gate 	 */
25707c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
25717c478bd9Sstevel@tonic-gate 	delay(drv_usectohz(10000));
25727c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
25737c478bd9Sstevel@tonic-gate 
25747c478bd9Sstevel@tonic-gate 	hubd->h_dev_state = USB_DEV_HUB_STATE_RECOVER;
25757c478bd9Sstevel@tonic-gate 
25767c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
25777c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
25787c478bd9Sstevel@tonic-gate 		    "hubd_restore_device_state: port=%d", port);
25797c478bd9Sstevel@tonic-gate 
25807c478bd9Sstevel@tonic-gate 		/*
25817c478bd9Sstevel@tonic-gate 		 * the childen_dips list may have dips that have been
25827c478bd9Sstevel@tonic-gate 		 * already deallocated. we only get a post_detach notification
25837c478bd9Sstevel@tonic-gate 		 * but not a destroy notification
25847c478bd9Sstevel@tonic-gate 		 */
25857c478bd9Sstevel@tonic-gate 		ch_dip = hubd->h_children_dips[port];
25867c478bd9Sstevel@tonic-gate 		if (ch_dip) {
25877c478bd9Sstevel@tonic-gate 			/* get port status */
25887c478bd9Sstevel@tonic-gate 			(void) hubd_determine_port_status(hubd, port,
25897c478bd9Sstevel@tonic-gate 			    &status, &change, PORT_CHANGE_CSC);
25907c478bd9Sstevel@tonic-gate 
25917c478bd9Sstevel@tonic-gate 			/* check if it is truly connected */
25927c478bd9Sstevel@tonic-gate 			if (status & PORT_STATUS_CCS) {
25937c478bd9Sstevel@tonic-gate 				/*
25947c478bd9Sstevel@tonic-gate 				 * Now reset port and assign the device
25957c478bd9Sstevel@tonic-gate 				 * its original address
25967c478bd9Sstevel@tonic-gate 				 */
25977c478bd9Sstevel@tonic-gate 				retry = 0;
25987c478bd9Sstevel@tonic-gate 				do {
25997c478bd9Sstevel@tonic-gate 					(void) hubd_reset_port(hubd, port);
26007c478bd9Sstevel@tonic-gate 
26017c478bd9Sstevel@tonic-gate 					/* required for ppx */
26027c478bd9Sstevel@tonic-gate 					(void) hubd_enable_port(hubd, port);
26037c478bd9Sstevel@tonic-gate 
26047c478bd9Sstevel@tonic-gate 					if (retry) {
26057c478bd9Sstevel@tonic-gate 						mutex_exit(HUBD_MUTEX(hubd));
26067c478bd9Sstevel@tonic-gate 						delay(drv_usectohz(
2607c0f24e5bSlg 						    hubd_device_delay/2));
26087c478bd9Sstevel@tonic-gate 						mutex_enter(HUBD_MUTEX(hubd));
26097c478bd9Sstevel@tonic-gate 					}
26107c478bd9Sstevel@tonic-gate 
26117c478bd9Sstevel@tonic-gate 					rval = hubd_setdevaddr(hubd, port);
26127c478bd9Sstevel@tonic-gate 					retry++;
26137c478bd9Sstevel@tonic-gate 				} while ((rval != USB_SUCCESS) &&
26147c478bd9Sstevel@tonic-gate 				    (retry < hubd_retry_enumerate));
26157c478bd9Sstevel@tonic-gate 
26167c478bd9Sstevel@tonic-gate 				hubd_setdevconfig(hubd, port);
26177c478bd9Sstevel@tonic-gate 
26187c478bd9Sstevel@tonic-gate 				if (hub_prev_state == USB_DEV_DISCONNECTED) {
26197c478bd9Sstevel@tonic-gate 					/* post a connect event */
26207c478bd9Sstevel@tonic-gate 					mutex_exit(HUBD_MUTEX(hubd));
26217c478bd9Sstevel@tonic-gate 					hubd_post_event(hubd, port,
26227c478bd9Sstevel@tonic-gate 					    USBA_EVENT_TAG_HOT_INSERTION);
26237c478bd9Sstevel@tonic-gate 					mutex_enter(HUBD_MUTEX(hubd));
26247c478bd9Sstevel@tonic-gate 				} else {
26257c478bd9Sstevel@tonic-gate 					/*
26267c478bd9Sstevel@tonic-gate 					 * Since we have this device connected
26277c478bd9Sstevel@tonic-gate 					 * mark it reinserted to prevent
26287c478bd9Sstevel@tonic-gate 					 * cleanup thread from stepping in.
26297c478bd9Sstevel@tonic-gate 					 */
26307c478bd9Sstevel@tonic-gate 					mutex_exit(HUBD_MUTEX(hubd));
263116747f41Scth 					mutex_enter(&(DEVI(ch_dip)->devi_lock));
263216747f41Scth 					DEVI_SET_DEVICE_REINSERTED(ch_dip);
263316747f41Scth 					mutex_exit(&(DEVI(ch_dip)->devi_lock));
26347c478bd9Sstevel@tonic-gate 
26357c478bd9Sstevel@tonic-gate 					/*
26367c478bd9Sstevel@tonic-gate 					 * reopen pipes for children for
26377c478bd9Sstevel@tonic-gate 					 * their DDI_RESUME
26387c478bd9Sstevel@tonic-gate 					 */
26397c478bd9Sstevel@tonic-gate 					rval = usba_persistent_pipe_open(
26407c478bd9Sstevel@tonic-gate 					    usba_get_usba_device(ch_dip));
26417c478bd9Sstevel@tonic-gate 					mutex_enter(HUBD_MUTEX(hubd));
26427c478bd9Sstevel@tonic-gate 					ASSERT(rval == USB_SUCCESS);
26437c478bd9Sstevel@tonic-gate 				}
26447c478bd9Sstevel@tonic-gate 			} else {
26457c478bd9Sstevel@tonic-gate 				/*
26467c478bd9Sstevel@tonic-gate 				 * Mark this dip for deletion as the device
26477c478bd9Sstevel@tonic-gate 				 * is not physically present, and schedule
26487c478bd9Sstevel@tonic-gate 				 * cleanup thread upon post resume
26497c478bd9Sstevel@tonic-gate 				 */
26507c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
26517c478bd9Sstevel@tonic-gate 
26527c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
26537c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
26547c478bd9Sstevel@tonic-gate 				    "hubd_restore_device_state: "
26557c478bd9Sstevel@tonic-gate 				    "dip=%p on port=%d marked for cleanup",
2656112116d8Sfb 				    (void *)ch_dip, port);
265716747f41Scth 				mutex_enter(&(DEVI(ch_dip)->devi_lock));
26587c478bd9Sstevel@tonic-gate 				DEVI_SET_DEVICE_REMOVED(ch_dip);
265916747f41Scth 				mutex_exit(&(DEVI(ch_dip)->devi_lock));
26607c478bd9Sstevel@tonic-gate 
26617c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
26627c478bd9Sstevel@tonic-gate 			}
26637c478bd9Sstevel@tonic-gate 		} else if (ehci_root_hub) {
26647c478bd9Sstevel@tonic-gate 			/* get port status */
26657c478bd9Sstevel@tonic-gate 			(void) hubd_determine_port_status(hubd, port,
26667c478bd9Sstevel@tonic-gate 			    &status, &change, PORT_CHANGE_CSC);
26677c478bd9Sstevel@tonic-gate 
26687c478bd9Sstevel@tonic-gate 			/* check if it is truly connected */
26697c478bd9Sstevel@tonic-gate 			if (status & PORT_STATUS_CCS) {
26707c478bd9Sstevel@tonic-gate 				/*
26717c478bd9Sstevel@tonic-gate 				 * reset the port to find out if we have
26727c478bd9Sstevel@tonic-gate 				 * 2.0 device connected or 1.X. A 2.0
26737c478bd9Sstevel@tonic-gate 				 * device will still be seen as connected,
26747c478bd9Sstevel@tonic-gate 				 * while a 1.X device will switch over to
26757c478bd9Sstevel@tonic-gate 				 * the companion controller.
26767c478bd9Sstevel@tonic-gate 				 */
26777c478bd9Sstevel@tonic-gate 				(void) hubd_reset_port(hubd, port);
26787c478bd9Sstevel@tonic-gate 
26797c478bd9Sstevel@tonic-gate 				(void) hubd_determine_port_status(hubd, port,
26807c478bd9Sstevel@tonic-gate 				    &status, &change, PORT_CHANGE_CSC);
26817c478bd9Sstevel@tonic-gate 
26827c478bd9Sstevel@tonic-gate 				if (status &
26837c478bd9Sstevel@tonic-gate 				    (PORT_STATUS_CCS | PORT_STATUS_HSDA)) {
26847c478bd9Sstevel@tonic-gate 					/*
26857c478bd9Sstevel@tonic-gate 					 * We have a USB 2.0 device
26867c478bd9Sstevel@tonic-gate 					 * connected. Power cycle this port
26877c478bd9Sstevel@tonic-gate 					 * so that hotplug thread can
26887c478bd9Sstevel@tonic-gate 					 * enumerate this device.
26897c478bd9Sstevel@tonic-gate 					 */
26907c478bd9Sstevel@tonic-gate 					(void) hubd_toggle_port(hubd, port);
26917c478bd9Sstevel@tonic-gate 				} else {
26927c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_ATTA,
26937c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
26947c478bd9Sstevel@tonic-gate 					    "hubd_restore_device_state: "
26957c478bd9Sstevel@tonic-gate 					    "device on port %d switched over",
26967c478bd9Sstevel@tonic-gate 					    port);
26977c478bd9Sstevel@tonic-gate 				}
26987c478bd9Sstevel@tonic-gate 			}
26997c478bd9Sstevel@tonic-gate 
27007c478bd9Sstevel@tonic-gate 		}
27017c478bd9Sstevel@tonic-gate 	}
27027c478bd9Sstevel@tonic-gate 
27037c478bd9Sstevel@tonic-gate 
27047c478bd9Sstevel@tonic-gate 	/* if the device had remote wakeup earlier, enable it again */
27057c478bd9Sstevel@tonic-gate 	if (hubd->h_hubpm->hubp_wakeup_enabled) {
27067c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
27077c478bd9Sstevel@tonic-gate 		(void) usb_handle_remote_wakeup(hubd->h_dip,
27087c478bd9Sstevel@tonic-gate 		    USB_REMOTE_WAKEUP_ENABLE);
27097c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
27107c478bd9Sstevel@tonic-gate 	}
27117c478bd9Sstevel@tonic-gate 
27127c478bd9Sstevel@tonic-gate 	hubd->h_dev_state = USB_DEV_ONLINE;
27137c478bd9Sstevel@tonic-gate 	hubd_start_polling(hubd, 0);
27147c478bd9Sstevel@tonic-gate 	(void) hubd_pm_idle_component(hubd, dip, 0);
27157c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
27167c478bd9Sstevel@tonic-gate }
27177c478bd9Sstevel@tonic-gate 
27187c478bd9Sstevel@tonic-gate 
27197c478bd9Sstevel@tonic-gate /*
27207c478bd9Sstevel@tonic-gate  * hubd_cleanup:
27217c478bd9Sstevel@tonic-gate  *	cleanup hubd and deallocate. this function is called for
27227c478bd9Sstevel@tonic-gate  *	handling attach failures and detaching including dynamic
27237c478bd9Sstevel@tonic-gate  *	reconfiguration. If called from attaching, it must clean
27247c478bd9Sstevel@tonic-gate  *	up the whole thing and return success.
27257c478bd9Sstevel@tonic-gate  */
27267c478bd9Sstevel@tonic-gate /*ARGSUSED*/
27277c478bd9Sstevel@tonic-gate static int
27287c478bd9Sstevel@tonic-gate hubd_cleanup(dev_info_t *dip, hubd_t *hubd)
27297c478bd9Sstevel@tonic-gate {
27307c478bd9Sstevel@tonic-gate 	int		circ, rval, old_dev_state;
27317c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
27327c478bd9Sstevel@tonic-gate #ifdef DEBUG
27337c478bd9Sstevel@tonic-gate 	usb_port_t	port;
27347c478bd9Sstevel@tonic-gate #endif
27357c478bd9Sstevel@tonic-gate 
27367c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
27377c478bd9Sstevel@tonic-gate 	    "hubd_cleanup:");
27387c478bd9Sstevel@tonic-gate 
27397c478bd9Sstevel@tonic-gate 	if ((hubd->h_init_state & HUBD_LOCKS_DONE) == 0) {
27407c478bd9Sstevel@tonic-gate 		goto done;
27417c478bd9Sstevel@tonic-gate 	}
27427c478bd9Sstevel@tonic-gate 
27437c478bd9Sstevel@tonic-gate 	/* ensure we are the only one active */
27447c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
27457c478bd9Sstevel@tonic-gate 
27467c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
27477c478bd9Sstevel@tonic-gate 
27487c478bd9Sstevel@tonic-gate 	/* Cleanup failure is only allowed if called from detach */
27497c478bd9Sstevel@tonic-gate 	if (DEVI_IS_DETACHING(dip)) {
27507c478bd9Sstevel@tonic-gate 		dev_info_t *rh_dip = hubd->h_usba_device->usb_root_hub_dip;
27517c478bd9Sstevel@tonic-gate 
27527c478bd9Sstevel@tonic-gate 		/*
27537c478bd9Sstevel@tonic-gate 		 * We are being called from detach.
27547c478bd9Sstevel@tonic-gate 		 * Fail immediately if the hotplug thread is running
27557c478bd9Sstevel@tonic-gate 		 * else set the dev_state to disconnected so that
27567c478bd9Sstevel@tonic-gate 		 * hotplug thread just exits without doing anything.
27577c478bd9Sstevel@tonic-gate 		 */
27587c478bd9Sstevel@tonic-gate 		if (hubd->h_bus_ctls || hubd->h_bus_pwr ||
27597c478bd9Sstevel@tonic-gate 		    hubd->h_hotplug_thread) {
27607c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
27617c478bd9Sstevel@tonic-gate 			ndi_devi_exit(dip, circ);
27627c478bd9Sstevel@tonic-gate 
27637c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
27647c478bd9Sstevel@tonic-gate 			    "hubd_cleanup: hotplug thread/bus ctl active "
27657c478bd9Sstevel@tonic-gate 			    "- failing detach");
27667c478bd9Sstevel@tonic-gate 
27677c478bd9Sstevel@tonic-gate 			return (USB_FAILURE);
27687c478bd9Sstevel@tonic-gate 		}
27697c478bd9Sstevel@tonic-gate 
27707c478bd9Sstevel@tonic-gate 		/*
27717c478bd9Sstevel@tonic-gate 		 * if the deathrow thread is still active or about
27727c478bd9Sstevel@tonic-gate 		 * to become active, fail detach
27737c478bd9Sstevel@tonic-gate 		 * the roothup can only be detached if nexus drivers
27747c478bd9Sstevel@tonic-gate 		 * are unloaded or explicitly offlined
27757c478bd9Sstevel@tonic-gate 		 */
27767c478bd9Sstevel@tonic-gate 		if (rh_dip == dip) {
27777c478bd9Sstevel@tonic-gate 			if (hubd->h_cleanup_needed ||
27787c478bd9Sstevel@tonic-gate 			    hubd->h_cleanup_active) {
27797c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
27807c478bd9Sstevel@tonic-gate 				ndi_devi_exit(dip, circ);
27817c478bd9Sstevel@tonic-gate 
27827c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
27837c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
27847c478bd9Sstevel@tonic-gate 				    "hubd_cleanup: deathrow still active?"
27857c478bd9Sstevel@tonic-gate 				    "- failing detach");
27867c478bd9Sstevel@tonic-gate 
27877c478bd9Sstevel@tonic-gate 				return (USB_FAILURE);
27887c478bd9Sstevel@tonic-gate 			}
27897c478bd9Sstevel@tonic-gate 		}
27907c478bd9Sstevel@tonic-gate 	}
27917c478bd9Sstevel@tonic-gate 
27927c478bd9Sstevel@tonic-gate 	old_dev_state = hubd->h_dev_state;
27937c478bd9Sstevel@tonic-gate 	hubd->h_dev_state = USB_DEV_DISCONNECTED;
27947c478bd9Sstevel@tonic-gate 
27957c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
27967c478bd9Sstevel@tonic-gate 	    "hubd_cleanup: stop polling");
27977c478bd9Sstevel@tonic-gate 	hubd_close_intr_pipe(hubd);
27987c478bd9Sstevel@tonic-gate 
27997c478bd9Sstevel@tonic-gate 	ASSERT((hubd->h_bus_ctls || hubd->h_bus_pwr ||
28007c478bd9Sstevel@tonic-gate 	    hubd->h_hotplug_thread) == 0);
28017c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
28027c478bd9Sstevel@tonic-gate 
28037c478bd9Sstevel@tonic-gate 	/*
28047c478bd9Sstevel@tonic-gate 	 * deallocate events, if events are still registered
28057c478bd9Sstevel@tonic-gate 	 * (ie. children still attached) then we have to fail the detach
28067c478bd9Sstevel@tonic-gate 	 */
28077c478bd9Sstevel@tonic-gate 	if (hubd->h_ndi_event_hdl) {
28087c478bd9Sstevel@tonic-gate 
28097c478bd9Sstevel@tonic-gate 		rval = ndi_event_free_hdl(hubd->h_ndi_event_hdl);
28107c478bd9Sstevel@tonic-gate 		if (DEVI_IS_ATTACHING(dip)) {
28117c478bd9Sstevel@tonic-gate 
28127c478bd9Sstevel@tonic-gate 			/* It must return success if attaching. */
28137c478bd9Sstevel@tonic-gate 			ASSERT(rval == NDI_SUCCESS);
28147c478bd9Sstevel@tonic-gate 
28157c478bd9Sstevel@tonic-gate 		} else if (rval != NDI_SUCCESS) {
28167c478bd9Sstevel@tonic-gate 
2817d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_ALL, hubd->h_log_handle,
28187c478bd9Sstevel@tonic-gate 			    "hubd_cleanup: ndi_event_free_hdl failed");
28197c478bd9Sstevel@tonic-gate 			ndi_devi_exit(dip, circ);
28207c478bd9Sstevel@tonic-gate 
28217c478bd9Sstevel@tonic-gate 			return (USB_FAILURE);
28227c478bd9Sstevel@tonic-gate 
28237c478bd9Sstevel@tonic-gate 		}
28247c478bd9Sstevel@tonic-gate 	}
28257c478bd9Sstevel@tonic-gate 
28267c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
28277c478bd9Sstevel@tonic-gate 
282835f36846Ssl 	if (hubd->h_init_state & HUBD_CHILDREN_CREATED) {
28297c478bd9Sstevel@tonic-gate #ifdef DEBUG
283035f36846Ssl 		for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
283135f36846Ssl 			ASSERT(hubd->h_usba_devices[port] == NULL);
283235f36846Ssl 			ASSERT(hubd->h_children_dips[port] == NULL);
283335f36846Ssl 		}
28347c478bd9Sstevel@tonic-gate #endif
283535f36846Ssl 		kmem_free(hubd->h_children_dips, hubd->h_cd_list_length);
283635f36846Ssl 		kmem_free(hubd->h_usba_devices, hubd->h_cd_list_length);
283735f36846Ssl 	}
28387c478bd9Sstevel@tonic-gate 
28397c478bd9Sstevel@tonic-gate 	/*
28407c478bd9Sstevel@tonic-gate 	 * Disable the event callbacks first, after this point, event
28417c478bd9Sstevel@tonic-gate 	 * callbacks will never get called. Note we shouldn't hold
28427c478bd9Sstevel@tonic-gate 	 * mutex while unregistering events because there may be a
28437c478bd9Sstevel@tonic-gate 	 * competing event callback thread. Event callbacks are done
28447c478bd9Sstevel@tonic-gate 	 * with ndi mutex held and this can cause a potential deadlock.
28457c478bd9Sstevel@tonic-gate 	 * Note that cleanup can't fail after deregistration of events.
28467c478bd9Sstevel@tonic-gate 	 */
28477c478bd9Sstevel@tonic-gate 	if (hubd->h_init_state &  HUBD_EVENTS_REGISTERED) {
28487c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
28497c478bd9Sstevel@tonic-gate 		usb_unregister_event_cbs(dip, &hubd_events);
28507c478bd9Sstevel@tonic-gate 		hubd_unregister_cpr_callback(hubd);
28517c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
28527c478bd9Sstevel@tonic-gate 	}
28537c478bd9Sstevel@tonic-gate 
28547c478bd9Sstevel@tonic-gate 	/* restore the old dev state so that device can be put into low power */
28557c478bd9Sstevel@tonic-gate 	hubd->h_dev_state = old_dev_state;
28567c478bd9Sstevel@tonic-gate 	hubpm = hubd->h_hubpm;
28577c478bd9Sstevel@tonic-gate 
28587c478bd9Sstevel@tonic-gate 	if ((hubpm) && (hubd->h_dev_state != USB_DEV_DISCONNECTED)) {
28597c478bd9Sstevel@tonic-gate 		(void) hubd_pm_busy_component(hubd, dip, 0);
28607c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
28617c478bd9Sstevel@tonic-gate 		if (hubd->h_hubpm->hubp_wakeup_enabled) {
28627c478bd9Sstevel@tonic-gate 			/*
28637c478bd9Sstevel@tonic-gate 			 * Bring the hub to full power before
28647c478bd9Sstevel@tonic-gate 			 * issuing the disable remote wakeup command
28657c478bd9Sstevel@tonic-gate 			 */
28667c478bd9Sstevel@tonic-gate 			(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
28677c478bd9Sstevel@tonic-gate 
28687c478bd9Sstevel@tonic-gate 			if ((rval = usb_handle_remote_wakeup(hubd->h_dip,
28697c478bd9Sstevel@tonic-gate 			    USB_REMOTE_WAKEUP_DISABLE)) != USB_SUCCESS) {
28707c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PM,
28717c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
28727c478bd9Sstevel@tonic-gate 				    "hubd_cleanup: disable remote wakeup "
28737c478bd9Sstevel@tonic-gate 				    "fails=%d", rval);
28747c478bd9Sstevel@tonic-gate 			}
28757c478bd9Sstevel@tonic-gate 		}
28767c478bd9Sstevel@tonic-gate 
28777c478bd9Sstevel@tonic-gate 		(void) pm_lower_power(hubd->h_dip, 0, USB_DEV_OS_PWR_OFF);
28787c478bd9Sstevel@tonic-gate 
28797c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
28807c478bd9Sstevel@tonic-gate 		(void) hubd_pm_idle_component(hubd, dip, 0);
28817c478bd9Sstevel@tonic-gate 	}
28827c478bd9Sstevel@tonic-gate 
28837c478bd9Sstevel@tonic-gate 	if (hubpm) {
28847c478bd9Sstevel@tonic-gate 		if (hubpm->hubp_child_pwrstate) {
28857c478bd9Sstevel@tonic-gate 			kmem_free(hubpm->hubp_child_pwrstate,
28867c478bd9Sstevel@tonic-gate 			    MAX_PORTS + 1);
28877c478bd9Sstevel@tonic-gate 		}
28887c478bd9Sstevel@tonic-gate 		kmem_free(hubpm, sizeof (hub_power_t));
28897c478bd9Sstevel@tonic-gate 	}
28907c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
28917c478bd9Sstevel@tonic-gate 
28927c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
28937c478bd9Sstevel@tonic-gate 	    "hubd_cleanup: freeing space");
28947c478bd9Sstevel@tonic-gate 
28957c478bd9Sstevel@tonic-gate 	if (hubd->h_init_state & HUBD_HUBDI_REGISTERED) {
28967c478bd9Sstevel@tonic-gate 		rval = usba_hubdi_unregister(dip);
28977c478bd9Sstevel@tonic-gate 		ASSERT(rval == USB_SUCCESS);
28987c478bd9Sstevel@tonic-gate 	}
28997c478bd9Sstevel@tonic-gate 
29007c478bd9Sstevel@tonic-gate 	if (hubd->h_init_state & HUBD_LOCKS_DONE) {
29017c478bd9Sstevel@tonic-gate 		mutex_destroy(HUBD_MUTEX(hubd));
29027c478bd9Sstevel@tonic-gate 		cv_destroy(&hubd->h_cv_reset_port);
2903ffcd51f3Slg 		cv_destroy(&hubd->h_cv_hotplug_dev);
29047c478bd9Sstevel@tonic-gate 	}
29057c478bd9Sstevel@tonic-gate 
29067c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
29077c478bd9Sstevel@tonic-gate 
29087c478bd9Sstevel@tonic-gate 	if (hubd->h_init_state & HUBD_MINOR_NODE_CREATED) {
29097c478bd9Sstevel@tonic-gate 		ddi_remove_minor_node(dip, NULL);
29107c478bd9Sstevel@tonic-gate 	}
29117c478bd9Sstevel@tonic-gate 
29127c478bd9Sstevel@tonic-gate 	if (usba_is_root_hub(dip)) {
29137c478bd9Sstevel@tonic-gate 		usb_pipe_close(dip, hubd->h_default_pipe,
29147c478bd9Sstevel@tonic-gate 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
29157c478bd9Sstevel@tonic-gate 	}
29167c478bd9Sstevel@tonic-gate 
29177c478bd9Sstevel@tonic-gate done:
29187c478bd9Sstevel@tonic-gate 	if (hubd->h_ancestry_str) {
29197c478bd9Sstevel@tonic-gate 		kmem_free(hubd->h_ancestry_str, HUBD_APID_NAMELEN);
29207c478bd9Sstevel@tonic-gate 	}
29217c478bd9Sstevel@tonic-gate 
29227c478bd9Sstevel@tonic-gate 	usb_client_detach(dip, hubd->h_dev_data);
29237c478bd9Sstevel@tonic-gate 
29247c478bd9Sstevel@tonic-gate 	usb_free_log_hdl(hubd->h_log_handle);
29257c478bd9Sstevel@tonic-gate 
29267c478bd9Sstevel@tonic-gate 	if (!usba_is_root_hub(dip)) {
29277c478bd9Sstevel@tonic-gate 		ddi_soft_state_free(hubd_statep, ddi_get_instance(dip));
29287c478bd9Sstevel@tonic-gate 	}
29297c478bd9Sstevel@tonic-gate 
29307c478bd9Sstevel@tonic-gate 	ddi_prop_remove_all(dip);
29317c478bd9Sstevel@tonic-gate 
29327c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
29337c478bd9Sstevel@tonic-gate }
29347c478bd9Sstevel@tonic-gate 
29357c478bd9Sstevel@tonic-gate 
29366c7181fcSsl /*
29376c7181fcSsl  * hubd_determine_port_connection:
29386c7181fcSsl  *	Determine which port is in connect status but does not
29396c7181fcSsl  *	have connect status change bit set, and mark port change
29406c7181fcSsl  *	bit accordingly.
29416c7181fcSsl  *	This function is applied during hub attach time.
29426c7181fcSsl  */
29436c7181fcSsl static usb_port_mask_t
29446c7181fcSsl hubd_determine_port_connection(hubd_t	*hubd)
29456c7181fcSsl {
29466c7181fcSsl 	usb_port_t	port;
29476c7181fcSsl 	usb_hub_descr_t	*hub_descr;
29486c7181fcSsl 	uint16_t	status;
29496c7181fcSsl 	uint16_t	change;
29506c7181fcSsl 	usb_port_mask_t	port_change = 0;
29516c7181fcSsl 
29526c7181fcSsl 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
29536c7181fcSsl 
29546c7181fcSsl 	hub_descr = &hubd->h_hub_descr;
29556c7181fcSsl 
29566c7181fcSsl 	for (port = 1; port <= hub_descr->bNbrPorts; port++) {
29576c7181fcSsl 
29586c7181fcSsl 		(void) hubd_determine_port_status(hubd, port, &status,
29596c7181fcSsl 		    &change, 0);
29606c7181fcSsl 
29616c7181fcSsl 		/* Check if port is in connect status */
29626c7181fcSsl 		if (!(status & PORT_STATUS_CCS)) {
29636c7181fcSsl 
29646c7181fcSsl 			continue;
29656c7181fcSsl 		}
29666c7181fcSsl 
29676c7181fcSsl 		/*
29686c7181fcSsl 		 * Check if port Connect Status Change bit has been set.
29696c7181fcSsl 		 * If already set, the connection will be handled by
29706c7181fcSsl 		 * intr polling callback, not during attach.
29716c7181fcSsl 		 */
29726c7181fcSsl 		if (change & PORT_CHANGE_CSC) {
29736c7181fcSsl 
29746c7181fcSsl 			continue;
29756c7181fcSsl 		}
29766c7181fcSsl 
29776c7181fcSsl 		port_change |= 1 << port;
29786c7181fcSsl 	}
29796c7181fcSsl 
29806c7181fcSsl 	return (port_change);
29816c7181fcSsl }
29826c7181fcSsl 
29836c7181fcSsl 
29847c478bd9Sstevel@tonic-gate /*
29857c478bd9Sstevel@tonic-gate  * hubd_check_ports:
29867c478bd9Sstevel@tonic-gate  *	- get hub descriptor
29877c478bd9Sstevel@tonic-gate  *	- check initial port status
29887c478bd9Sstevel@tonic-gate  *	- enable power on all ports
29897c478bd9Sstevel@tonic-gate  *	- enable polling on ep1
29907c478bd9Sstevel@tonic-gate  */
29917c478bd9Sstevel@tonic-gate static int
29927c478bd9Sstevel@tonic-gate hubd_check_ports(hubd_t  *hubd)
29937c478bd9Sstevel@tonic-gate {
29946c7181fcSsl 	int			rval;
29956c7181fcSsl 	usb_port_mask_t		port_change = 0;
29966c7181fcSsl 	hubd_hotplug_arg_t	*arg;
29977c478bd9Sstevel@tonic-gate 
29987c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
29997c478bd9Sstevel@tonic-gate 
30007c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
30017c478bd9Sstevel@tonic-gate 	    "hubd_check_ports: addr=0x%x", usb_get_addr(hubd->h_dip));
30027c478bd9Sstevel@tonic-gate 
30037c478bd9Sstevel@tonic-gate 	/*
30047c478bd9Sstevel@tonic-gate 	 * First turn off all port power
30057c478bd9Sstevel@tonic-gate 	 */
30067c478bd9Sstevel@tonic-gate 	if ((rval = hubd_disable_all_port_power(hubd)) != USB_SUCCESS) {
30077c478bd9Sstevel@tonic-gate 
30087c478bd9Sstevel@tonic-gate 		/* disable whatever was enabled */
30097c478bd9Sstevel@tonic-gate 		(void) hubd_disable_all_port_power(hubd);
30107c478bd9Sstevel@tonic-gate 
30117c478bd9Sstevel@tonic-gate 		return (rval);
30127c478bd9Sstevel@tonic-gate 	}
30137c478bd9Sstevel@tonic-gate 
30147c478bd9Sstevel@tonic-gate 	/*
30157c478bd9Sstevel@tonic-gate 	 * do not switch on immediately (instantly on root hub)
30167c478bd9Sstevel@tonic-gate 	 * and allow time to settle
30177c478bd9Sstevel@tonic-gate 	 */
30187c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
30197c478bd9Sstevel@tonic-gate 	delay(drv_usectohz(10000));
30207c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
30217c478bd9Sstevel@tonic-gate 
30227c478bd9Sstevel@tonic-gate 	/*
30237c478bd9Sstevel@tonic-gate 	 * enable power on all ports so we can see connects
30247c478bd9Sstevel@tonic-gate 	 */
30257c478bd9Sstevel@tonic-gate 	if ((rval = hubd_enable_all_port_power(hubd)) != USB_SUCCESS) {
30267c478bd9Sstevel@tonic-gate 		/* disable whatever was enabled */
30277c478bd9Sstevel@tonic-gate 		(void) hubd_disable_all_port_power(hubd);
30287c478bd9Sstevel@tonic-gate 
30297c478bd9Sstevel@tonic-gate 		return (rval);
30307c478bd9Sstevel@tonic-gate 	}
30317c478bd9Sstevel@tonic-gate 
30327c478bd9Sstevel@tonic-gate 	/* wait at least 3 frames before accessing devices */
30337c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
30347c478bd9Sstevel@tonic-gate 	delay(drv_usectohz(10000));
30357c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
30367c478bd9Sstevel@tonic-gate 
30377c478bd9Sstevel@tonic-gate 	/*
30387c478bd9Sstevel@tonic-gate 	 * allocate arrays for saving the dips of each child per port
30397c478bd9Sstevel@tonic-gate 	 *
30407c478bd9Sstevel@tonic-gate 	 * ports go from 1 - n, allocate 1 more entry
30417c478bd9Sstevel@tonic-gate 	 */
30427c478bd9Sstevel@tonic-gate 	hubd->h_cd_list_length =
3043c0f24e5bSlg 	    (sizeof (dev_info_t **)) * (hubd->h_hub_descr.bNbrPorts + 1);
30447c478bd9Sstevel@tonic-gate 
30457c478bd9Sstevel@tonic-gate 	hubd->h_children_dips = (dev_info_t **)kmem_zalloc(
3046c0f24e5bSlg 	    hubd->h_cd_list_length, KM_SLEEP);
30477c478bd9Sstevel@tonic-gate 	hubd->h_usba_devices = (usba_device_t **)kmem_zalloc(
3048c0f24e5bSlg 	    hubd->h_cd_list_length, KM_SLEEP);
30497c478bd9Sstevel@tonic-gate 
305035f36846Ssl 	hubd->h_init_state |= HUBD_CHILDREN_CREATED;
305135f36846Ssl 
30526c7181fcSsl 	mutex_exit(HUBD_MUTEX(hubd));
30536c7181fcSsl 	arg = (hubd_hotplug_arg_t *)kmem_zalloc(
30546c7181fcSsl 	    sizeof (hubd_hotplug_arg_t), KM_SLEEP);
30556c7181fcSsl 	mutex_enter(HUBD_MUTEX(hubd));
30566c7181fcSsl 
30576c7181fcSsl 	if ((rval = hubd_open_intr_pipe(hubd)) != USB_SUCCESS) {
30586c7181fcSsl 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
30596c7181fcSsl 
30606c7181fcSsl 		return (rval);
30616c7181fcSsl 	}
30626c7181fcSsl 
30636c7181fcSsl 	hubd_start_polling(hubd, 0);
30646c7181fcSsl 
30656c7181fcSsl 	/*
30666c7181fcSsl 	 * Some hub devices, like the embedded hub in the CKS ErgoMagic
30676c7181fcSsl 	 * keyboard, may only have connection status bit set, but not
30686c7181fcSsl 	 * have connect status change bit set when a device has been
30696c7181fcSsl 	 * connected to its downstream port before the hub is enumerated.
30706c7181fcSsl 	 * Then when the hub is in enumeration, the devices connected to
30716c7181fcSsl 	 * it cannot be detected by the intr pipe and won't be enumerated.
30726c7181fcSsl 	 * We need to check such situation here and enumerate the downstream
30736c7181fcSsl 	 * devices for such hubs.
30746c7181fcSsl 	 */
30756c7181fcSsl 	port_change = hubd_determine_port_connection(hubd);
30766c7181fcSsl 
30776c7181fcSsl 	if (port_change) {
30786c7181fcSsl 		hubd_pm_busy_component(hubd, hubd->h_dip, 0);
30796c7181fcSsl 
30806c7181fcSsl 		arg->hubd = hubd;
30816c7181fcSsl 		arg->hotplug_during_attach = B_TRUE;
30826c7181fcSsl 		hubd->h_port_change |= port_change;
30836c7181fcSsl 
30846c7181fcSsl 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
30856c7181fcSsl 		    "hubd_check_ports: port change=0x%x, need to connect",
30866c7181fcSsl 		    hubd->h_port_change);
30876c7181fcSsl 
30886c7181fcSsl 		if (usb_async_req(hubd->h_dip, hubd_hotplug_thread,
30896c7181fcSsl 		    (void *)arg, 0) == USB_SUCCESS) {
30906c7181fcSsl 			hubd->h_hotplug_thread++;
30916c7181fcSsl 		} else {
30926c7181fcSsl 			/* mark this device as idle */
30936c7181fcSsl 			hubd_pm_idle_component(hubd, hubd->h_dip, 0);
30946c7181fcSsl 			kmem_free(arg, sizeof (hubd_hotplug_arg_t));
30956c7181fcSsl 		}
30966c7181fcSsl 	} else {
30976c7181fcSsl 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
30987c478bd9Sstevel@tonic-gate 	}
30997c478bd9Sstevel@tonic-gate 
31007c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
31017c478bd9Sstevel@tonic-gate 	    "hubd_check_ports done");
31027c478bd9Sstevel@tonic-gate 
31036c7181fcSsl 	return (USB_SUCCESS);
31047c478bd9Sstevel@tonic-gate }
31057c478bd9Sstevel@tonic-gate 
31067c478bd9Sstevel@tonic-gate 
31077c478bd9Sstevel@tonic-gate /*
31087c478bd9Sstevel@tonic-gate  * hubd_get_hub_descriptor:
31097c478bd9Sstevel@tonic-gate  */
31107c478bd9Sstevel@tonic-gate static int
31117c478bd9Sstevel@tonic-gate hubd_get_hub_descriptor(hubd_t *hubd)
31127c478bd9Sstevel@tonic-gate {
31137c478bd9Sstevel@tonic-gate 	usb_hub_descr_t	*hub_descr = &hubd->h_hub_descr;
31147c478bd9Sstevel@tonic-gate 	mblk_t		*data = NULL;
31157c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
31167c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
31177c478bd9Sstevel@tonic-gate 	uint16_t	length;
31187c478bd9Sstevel@tonic-gate 	int		rval;
3119*f5b8369cSRaymond Chen 	usb_req_attrs_t attr = 0;
31207c478bd9Sstevel@tonic-gate 
31217c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
31227c478bd9Sstevel@tonic-gate 	    "hubd_get_hub_descriptor:");
31237c478bd9Sstevel@tonic-gate 
3124*f5b8369cSRaymond Chen 	if ((hubd->h_dev_data->dev_descr->idVendor == USB_HUB_INTEL_VID) &&
3125*f5b8369cSRaymond Chen 	    (hubd->h_dev_data->dev_descr->idProduct == USB_HUB_INTEL_PID)) {
3126*f5b8369cSRaymond Chen 		attr = USB_ATTRS_SHORT_XFER_OK;
3127*f5b8369cSRaymond Chen 	}
3128*f5b8369cSRaymond Chen 
31297c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
31307c478bd9Sstevel@tonic-gate 	ASSERT(hubd->h_default_pipe != 0);
31317c478bd9Sstevel@tonic-gate 
31327c478bd9Sstevel@tonic-gate 	/* get hub descriptor length first by requesting 8 bytes only */
31337c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
31347c478bd9Sstevel@tonic-gate 
31357c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
31367c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
313735f36846Ssl 	    HUB_CLASS_REQ_TYPE,
31387c478bd9Sstevel@tonic-gate 	    USB_REQ_GET_DESCR,		/* bRequest */
31397c478bd9Sstevel@tonic-gate 	    USB_DESCR_TYPE_SETUP_HUB,	/* wValue */
31407c478bd9Sstevel@tonic-gate 	    0,				/* wIndex */
31417c478bd9Sstevel@tonic-gate 	    8,				/* wLength */
31427c478bd9Sstevel@tonic-gate 	    &data, 0,
31437c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
31447c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
31457c478bd9Sstevel@tonic-gate 		    "get hub descriptor failed: cr=%d cb_fl=0x%x rval=%d",
31467c478bd9Sstevel@tonic-gate 		    completion_reason, cb_flags, rval);
31477c478bd9Sstevel@tonic-gate 		freemsg(data);
31487c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
31497c478bd9Sstevel@tonic-gate 
31507c478bd9Sstevel@tonic-gate 		return (rval);
31517c478bd9Sstevel@tonic-gate 	}
31527c478bd9Sstevel@tonic-gate 
31537c478bd9Sstevel@tonic-gate 	length = *(data->b_rptr);
31547c478bd9Sstevel@tonic-gate 
31557c478bd9Sstevel@tonic-gate 	if (length > 8) {
31567c478bd9Sstevel@tonic-gate 		freemsg(data);
31577c478bd9Sstevel@tonic-gate 		data = NULL;
31587c478bd9Sstevel@tonic-gate 
31597c478bd9Sstevel@tonic-gate 		/* get complete hub descriptor */
3160*f5b8369cSRaymond Chen 		rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
31617c478bd9Sstevel@tonic-gate 		    hubd->h_default_pipe,
316235f36846Ssl 		    HUB_CLASS_REQ_TYPE,
31637c478bd9Sstevel@tonic-gate 		    USB_REQ_GET_DESCR,		/* bRequest */
31647c478bd9Sstevel@tonic-gate 		    USB_DESCR_TYPE_SETUP_HUB,	/* wValue */
31657c478bd9Sstevel@tonic-gate 		    0,				/* wIndex */
31667c478bd9Sstevel@tonic-gate 		    length,			/* wLength */
3167*f5b8369cSRaymond Chen 		    &data, attr,
3168*f5b8369cSRaymond Chen 		    &completion_reason, &cb_flags, 0);
3169*f5b8369cSRaymond Chen 
3170*f5b8369cSRaymond Chen 		/*
3171*f5b8369cSRaymond Chen 		 * Hub descriptor data less than 9 bytes is not valid and
3172*f5b8369cSRaymond Chen 		 * may cause trouble if we use it. See USB2.0 Tab11-13.
3173*f5b8369cSRaymond Chen 		 */
3174*f5b8369cSRaymond Chen 		if ((rval != USB_SUCCESS) || (MBLKL(data) <= 8)) {
31757c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
31767c478bd9Sstevel@tonic-gate 			    "get hub descriptor failed: "
3177*f5b8369cSRaymond Chen 			    "cr=%d cb_fl=0x%x rval=%d, len=%ld",
3178*f5b8369cSRaymond Chen 			    completion_reason, cb_flags, rval,
3179*f5b8369cSRaymond Chen 			    (data)?MBLKL(data):0);
31807c478bd9Sstevel@tonic-gate 			freemsg(data);
31817c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
31827c478bd9Sstevel@tonic-gate 
31837c478bd9Sstevel@tonic-gate 			return (rval);
31847c478bd9Sstevel@tonic-gate 		}
31857c478bd9Sstevel@tonic-gate 	}
31867c478bd9Sstevel@tonic-gate 
31877c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
31887c478bd9Sstevel@tonic-gate 
31897c478bd9Sstevel@tonic-gate 	/* parse the hub descriptor */
31907c478bd9Sstevel@tonic-gate 	/* only 32 ports are supported at present */
31917c478bd9Sstevel@tonic-gate 	ASSERT(*(data->b_rptr + 2) <= 32);
31927c478bd9Sstevel@tonic-gate 	if (usb_parse_CV_descr("cccscccccc",
3193d29f5a71Szhigang lu - Sun Microsystems - Beijing China 	    data->b_rptr, MBLKL(data),
31947c478bd9Sstevel@tonic-gate 	    (void *)hub_descr, sizeof (usb_hub_descr_t)) == 0) {
31957c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
31967c478bd9Sstevel@tonic-gate 		    "parsing hub descriptor failed");
31977c478bd9Sstevel@tonic-gate 
31987c478bd9Sstevel@tonic-gate 		freemsg(data);
31997c478bd9Sstevel@tonic-gate 
32007c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
32017c478bd9Sstevel@tonic-gate 	}
32027c478bd9Sstevel@tonic-gate 
32037c478bd9Sstevel@tonic-gate 	freemsg(data);
32047c478bd9Sstevel@tonic-gate 
32057c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
320635f36846Ssl 	    "rval=0x%x bNbrPorts=0x%x wHubChars=0x%x "
320735f36846Ssl 	    "PwrOn2PwrGood=0x%x HubContrCurrent=%dmA", rval,
32087c478bd9Sstevel@tonic-gate 	    hub_descr->bNbrPorts, hub_descr->wHubCharacteristics,
320935f36846Ssl 	    hub_descr->bPwrOn2PwrGood, hub_descr->bHubContrCurrent);
32107c478bd9Sstevel@tonic-gate 
32117c478bd9Sstevel@tonic-gate 	if (hub_descr->bNbrPorts > MAX_PORTS) {
32127c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L0(DPRINT_MASK_ATTA, hubd->h_log_handle,
32137c478bd9Sstevel@tonic-gate 		    "Hub driver supports max of %d ports on hub. "
32147c478bd9Sstevel@tonic-gate 		    "Hence using the first %d port of %d ports available",
32157c478bd9Sstevel@tonic-gate 		    MAX_PORTS, MAX_PORTS, hub_descr->bNbrPorts);
32167c478bd9Sstevel@tonic-gate 
32177c478bd9Sstevel@tonic-gate 		hub_descr->bNbrPorts = MAX_PORTS;
32187c478bd9Sstevel@tonic-gate 	}
32197c478bd9Sstevel@tonic-gate 
32207c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
32217c478bd9Sstevel@tonic-gate }
32227c478bd9Sstevel@tonic-gate 
32237c478bd9Sstevel@tonic-gate 
322435f36846Ssl /*
322535f36846Ssl  * hubd_get_hub_status_words:
322635f36846Ssl  */
322735f36846Ssl static int
322835f36846Ssl hubd_get_hub_status_words(hubd_t *hubd, uint16_t *status)
322935f36846Ssl {
323035f36846Ssl 	usb_cr_t	completion_reason;
323135f36846Ssl 	usb_cb_flags_t	cb_flags;
323235f36846Ssl 	mblk_t		*data = NULL;
323335f36846Ssl 
323435f36846Ssl 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
323535f36846Ssl 
323635f36846Ssl 	mutex_exit(HUBD_MUTEX(hubd));
323735f36846Ssl 
323835f36846Ssl 	if (usb_pipe_sync_ctrl_xfer(hubd->h_dip, hubd->h_default_pipe,
323935f36846Ssl 	    HUB_CLASS_REQ_TYPE,
324035f36846Ssl 	    USB_REQ_GET_STATUS,
324135f36846Ssl 	    0,
324235f36846Ssl 	    0,
324335f36846Ssl 	    GET_STATUS_LENGTH,
324435f36846Ssl 	    &data, 0,
324535f36846Ssl 	    &completion_reason, &cb_flags, 0) != USB_SUCCESS) {
324635f36846Ssl 		USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
324735f36846Ssl 		    "get hub status failed: cr=%d cb=0x%x",
324835f36846Ssl 		    completion_reason, cb_flags);
324935f36846Ssl 
325035f36846Ssl 		if (data) {
325135f36846Ssl 			freemsg(data);
325235f36846Ssl 		}
325335f36846Ssl 
325435f36846Ssl 		mutex_enter(HUBD_MUTEX(hubd));
325535f36846Ssl 
325635f36846Ssl 		return (USB_FAILURE);
325735f36846Ssl 	}
325835f36846Ssl 
325935f36846Ssl 	mutex_enter(HUBD_MUTEX(hubd));
326035f36846Ssl 
326135f36846Ssl 	status[0] = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
326235f36846Ssl 	status[1] = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);
326335f36846Ssl 
326435f36846Ssl 	USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
326535f36846Ssl 	    "hub status=0x%x change=0x%x", status[0], status[1]);
326635f36846Ssl 
326735f36846Ssl 	freemsg(data);
326835f36846Ssl 
326935f36846Ssl 	return (USB_SUCCESS);
327035f36846Ssl }
327135f36846Ssl 
327235f36846Ssl 
32737c478bd9Sstevel@tonic-gate /*
32747c478bd9Sstevel@tonic-gate  * hubd_open_intr_pipe:
32757c478bd9Sstevel@tonic-gate  *	we read all descriptors first for curiosity and then simply
32767c478bd9Sstevel@tonic-gate  *	open the pipe
32777c478bd9Sstevel@tonic-gate  */
32787c478bd9Sstevel@tonic-gate static int
32797c478bd9Sstevel@tonic-gate hubd_open_intr_pipe(hubd_t	*hubd)
32807c478bd9Sstevel@tonic-gate {
32817c478bd9Sstevel@tonic-gate 	int			rval;
32827c478bd9Sstevel@tonic-gate 
32837c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
32847c478bd9Sstevel@tonic-gate 	    "hubd_open_intr_pipe:");
32857c478bd9Sstevel@tonic-gate 
32867c478bd9Sstevel@tonic-gate 	ASSERT(hubd->h_intr_pipe_state == HUBD_INTR_PIPE_IDLE);
32877c478bd9Sstevel@tonic-gate 
32887c478bd9Sstevel@tonic-gate 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_OPENING;
32897c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
32907c478bd9Sstevel@tonic-gate 
32917c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_open(hubd->h_dip,
32927c478bd9Sstevel@tonic-gate 	    &hubd->h_ep1_descr, &hubd->h_pipe_policy,
32937c478bd9Sstevel@tonic-gate 	    0, &hubd->h_ep1_ph)) != USB_SUCCESS) {
3294d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
32957c478bd9Sstevel@tonic-gate 		    "open intr pipe failed (%d)", rval);
32967c478bd9Sstevel@tonic-gate 
32977c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
32987c478bd9Sstevel@tonic-gate 		hubd->h_intr_pipe_state = HUBD_INTR_PIPE_IDLE;
32997c478bd9Sstevel@tonic-gate 
33007c478bd9Sstevel@tonic-gate 		return (rval);
33017c478bd9Sstevel@tonic-gate 	}
33027c478bd9Sstevel@tonic-gate 
33037c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
33047c478bd9Sstevel@tonic-gate 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_ACTIVE;
33057c478bd9Sstevel@tonic-gate 
33067c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3307112116d8Sfb 	    "open intr pipe succeeded, ph=0x%p", (void *)hubd->h_ep1_ph);
33087c478bd9Sstevel@tonic-gate 
33097c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
33107c478bd9Sstevel@tonic-gate }
33117c478bd9Sstevel@tonic-gate 
33127c478bd9Sstevel@tonic-gate 
33137c478bd9Sstevel@tonic-gate /*
33147c478bd9Sstevel@tonic-gate  * hubd_start_polling:
33157c478bd9Sstevel@tonic-gate  *	start or restart the polling
33167c478bd9Sstevel@tonic-gate  */
33177c478bd9Sstevel@tonic-gate static void
33187c478bd9Sstevel@tonic-gate hubd_start_polling(hubd_t *hubd, int always)
33197c478bd9Sstevel@tonic-gate {
33207c478bd9Sstevel@tonic-gate 	usb_intr_req_t	*reqp;
33217c478bd9Sstevel@tonic-gate 	int			rval;
33227c478bd9Sstevel@tonic-gate 	usb_pipe_state_t	pipe_state;
33237c478bd9Sstevel@tonic-gate 
33247c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
33257c478bd9Sstevel@tonic-gate 	    "start polling: always=%d dev_state=%d pipe_state=%d\n\t"
33267c478bd9Sstevel@tonic-gate 	    "thread=%d ep1_ph=0x%p",
33277c478bd9Sstevel@tonic-gate 	    always, hubd->h_dev_state, hubd->h_intr_pipe_state,
3328112116d8Sfb 	    hubd->h_hotplug_thread, (void *)hubd->h_ep1_ph);
33297c478bd9Sstevel@tonic-gate 
33307c478bd9Sstevel@tonic-gate 	/*
33317c478bd9Sstevel@tonic-gate 	 * start or restart polling on the intr pipe
33327c478bd9Sstevel@tonic-gate 	 * only if hotplug thread is not running
33337c478bd9Sstevel@tonic-gate 	 */
33347c478bd9Sstevel@tonic-gate 	if ((always == HUBD_ALWAYS_START_POLLING) ||
33357c478bd9Sstevel@tonic-gate 	    ((hubd->h_dev_state == USB_DEV_ONLINE) &&
33367c478bd9Sstevel@tonic-gate 	    (hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE) &&
33377c478bd9Sstevel@tonic-gate 	    (hubd->h_hotplug_thread == 0) && hubd->h_ep1_ph)) {
33387c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
33397c478bd9Sstevel@tonic-gate 		    "start polling requested");
33407c478bd9Sstevel@tonic-gate 
33417c478bd9Sstevel@tonic-gate 		reqp = usb_alloc_intr_req(hubd->h_dip, 0, USB_FLAGS_SLEEP);
33427c478bd9Sstevel@tonic-gate 
33437c478bd9Sstevel@tonic-gate 		reqp->intr_client_private = (usb_opaque_t)hubd;
33447c478bd9Sstevel@tonic-gate 		reqp->intr_attributes = USB_ATTRS_SHORT_XFER_OK |
3345c0f24e5bSlg 		    USB_ATTRS_AUTOCLEARING;
33467c478bd9Sstevel@tonic-gate 		reqp->intr_len = hubd->h_ep1_descr.wMaxPacketSize;
33477c478bd9Sstevel@tonic-gate 		reqp->intr_cb = hubd_read_cb;
33487c478bd9Sstevel@tonic-gate 		reqp->intr_exc_cb = hubd_exception_cb;
33497c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
33507c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_intr_xfer(hubd->h_ep1_ph, reqp,
33517c478bd9Sstevel@tonic-gate 		    USB_FLAGS_SLEEP)) != USB_SUCCESS) {
33527c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
33537c478bd9Sstevel@tonic-gate 			    "start polling failed, rval=%d", rval);
33547c478bd9Sstevel@tonic-gate 			usb_free_intr_req(reqp);
33557c478bd9Sstevel@tonic-gate 		}
33567c478bd9Sstevel@tonic-gate 
33577c478bd9Sstevel@tonic-gate 		rval = usb_pipe_get_state(hubd->h_ep1_ph, &pipe_state,
3358c0f24e5bSlg 		    USB_FLAGS_SLEEP);
33597c478bd9Sstevel@tonic-gate 		if (pipe_state != USB_PIPE_STATE_ACTIVE) {
33607c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
33617c478bd9Sstevel@tonic-gate 			    "intr pipe state=%d, rval=%d", pipe_state, rval);
33627c478bd9Sstevel@tonic-gate 		}
33637c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3364112116d8Sfb 		    "start polling request 0x%p", (void *)reqp);
33657c478bd9Sstevel@tonic-gate 
33667c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
33677c478bd9Sstevel@tonic-gate 	}
33687c478bd9Sstevel@tonic-gate }
33697c478bd9Sstevel@tonic-gate 
33707c478bd9Sstevel@tonic-gate 
33717c478bd9Sstevel@tonic-gate /*
33727c478bd9Sstevel@tonic-gate  * hubd_stop_polling
33737c478bd9Sstevel@tonic-gate  *	stop polling but do not close the pipe
33747c478bd9Sstevel@tonic-gate  */
33757c478bd9Sstevel@tonic-gate static void
33767c478bd9Sstevel@tonic-gate hubd_stop_polling(hubd_t *hubd)
33777c478bd9Sstevel@tonic-gate {
33787c478bd9Sstevel@tonic-gate 	int			rval;
33797c478bd9Sstevel@tonic-gate 	usb_pipe_state_t	pipe_state;
33807c478bd9Sstevel@tonic-gate 
33817c478bd9Sstevel@tonic-gate 	if (hubd->h_ep1_ph) {
33827c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
33837c478bd9Sstevel@tonic-gate 		    "hubd_stop_polling:");
33847c478bd9Sstevel@tonic-gate 		hubd->h_intr_pipe_state = HUBD_INTR_PIPE_STOPPED;
33857c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
33867c478bd9Sstevel@tonic-gate 
33877c478bd9Sstevel@tonic-gate 		usb_pipe_stop_intr_polling(hubd->h_ep1_ph, USB_FLAGS_SLEEP);
33887c478bd9Sstevel@tonic-gate 		rval = usb_pipe_get_state(hubd->h_ep1_ph, &pipe_state,
3389c0f24e5bSlg 		    USB_FLAGS_SLEEP);
33907c478bd9Sstevel@tonic-gate 
33917c478bd9Sstevel@tonic-gate 		if (pipe_state != USB_PIPE_STATE_IDLE) {
33927c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
33937c478bd9Sstevel@tonic-gate 			    "intr pipe state=%d, rval=%d", pipe_state, rval);
33947c478bd9Sstevel@tonic-gate 		}
33957c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
33967c478bd9Sstevel@tonic-gate 		if (hubd->h_intr_pipe_state == HUBD_INTR_PIPE_STOPPED) {
33977c478bd9Sstevel@tonic-gate 			hubd->h_intr_pipe_state = HUBD_INTR_PIPE_ACTIVE;
33987c478bd9Sstevel@tonic-gate 		}
33997c478bd9Sstevel@tonic-gate 	}
34007c478bd9Sstevel@tonic-gate }
34017c478bd9Sstevel@tonic-gate 
34027c478bd9Sstevel@tonic-gate 
34037c478bd9Sstevel@tonic-gate /*
34047c478bd9Sstevel@tonic-gate  * hubd_close_intr_pipe:
34057c478bd9Sstevel@tonic-gate  *	close the pipe (which also stops the polling
34067c478bd9Sstevel@tonic-gate  *	and wait for the hotplug thread to exit
34077c478bd9Sstevel@tonic-gate  */
34087c478bd9Sstevel@tonic-gate static void
34097c478bd9Sstevel@tonic-gate hubd_close_intr_pipe(hubd_t *hubd)
34107c478bd9Sstevel@tonic-gate {
34117c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
34127c478bd9Sstevel@tonic-gate 	    "hubd_close_intr_pipe:");
34137c478bd9Sstevel@tonic-gate 
34147c478bd9Sstevel@tonic-gate 	/*
34157c478bd9Sstevel@tonic-gate 	 * Now that no async operation is outstanding on pipe,
34167c478bd9Sstevel@tonic-gate 	 * we can change the state to HUBD_INTR_PIPE_CLOSING
34177c478bd9Sstevel@tonic-gate 	 */
34187c478bd9Sstevel@tonic-gate 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_CLOSING;
34197c478bd9Sstevel@tonic-gate 
34207c478bd9Sstevel@tonic-gate 	ASSERT(hubd->h_hotplug_thread == 0);
34217c478bd9Sstevel@tonic-gate 
34227c478bd9Sstevel@tonic-gate 	if (hubd->h_ep1_ph) {
34237c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
34247c478bd9Sstevel@tonic-gate 		usb_pipe_close(hubd->h_dip, hubd->h_ep1_ph, USB_FLAGS_SLEEP,
3425c0f24e5bSlg 		    NULL, NULL);
34267c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
34277c478bd9Sstevel@tonic-gate 		hubd->h_ep1_ph = NULL;
34287c478bd9Sstevel@tonic-gate 	}
34297c478bd9Sstevel@tonic-gate 
34307c478bd9Sstevel@tonic-gate 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_IDLE;
34317c478bd9Sstevel@tonic-gate }
34327c478bd9Sstevel@tonic-gate 
34337c478bd9Sstevel@tonic-gate 
34347c478bd9Sstevel@tonic-gate /*
34357c478bd9Sstevel@tonic-gate  * hubd_exception_cb
34367c478bd9Sstevel@tonic-gate  *	interrupt ep1 exception callback function.
34377c478bd9Sstevel@tonic-gate  *	this callback executes in taskq thread context and assumes
34387c478bd9Sstevel@tonic-gate  *	autoclearing
34397c478bd9Sstevel@tonic-gate  */
34407c478bd9Sstevel@tonic-gate /*ARGSUSED*/
34417c478bd9Sstevel@tonic-gate static void
34427c478bd9Sstevel@tonic-gate hubd_exception_cb(usb_pipe_handle_t pipe, usb_intr_req_t *reqp)
34437c478bd9Sstevel@tonic-gate {
34447c478bd9Sstevel@tonic-gate 	hubd_t		*hubd = (hubd_t *)(reqp->intr_client_private);
34457c478bd9Sstevel@tonic-gate 
34467c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L2(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
34477c478bd9Sstevel@tonic-gate 	    "hubd_exception_cb: "
3448112116d8Sfb 	    "req=0x%p cr=%d data=0x%p cb_flags=0x%x", (void *)reqp,
3449112116d8Sfb 	    reqp->intr_completion_reason, (void *)reqp->intr_data,
34507c478bd9Sstevel@tonic-gate 	    reqp->intr_cb_flags);
34517c478bd9Sstevel@tonic-gate 
34527c478bd9Sstevel@tonic-gate 	ASSERT((reqp->intr_cb_flags & USB_CB_INTR_CONTEXT) == 0);
34537c478bd9Sstevel@tonic-gate 
34547c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
34557c478bd9Sstevel@tonic-gate 	(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
34567c478bd9Sstevel@tonic-gate 
34577c478bd9Sstevel@tonic-gate 	switch (reqp->intr_completion_reason) {
34587c478bd9Sstevel@tonic-gate 	case USB_CR_PIPE_RESET:
34597c478bd9Sstevel@tonic-gate 		/* only restart polling after autoclearing */
34607c478bd9Sstevel@tonic-gate 		if ((hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE) &&
34617c478bd9Sstevel@tonic-gate 		    (hubd->h_port_reset_wait == 0)) {
34627c478bd9Sstevel@tonic-gate 			hubd_start_polling(hubd, 0);
34637c478bd9Sstevel@tonic-gate 		}
34647c478bd9Sstevel@tonic-gate 
34657c478bd9Sstevel@tonic-gate 		break;
34667c478bd9Sstevel@tonic-gate 	case USB_CR_DEV_NOT_RESP:
34677c478bd9Sstevel@tonic-gate 	case USB_CR_STOPPED_POLLING:
34687c478bd9Sstevel@tonic-gate 	case USB_CR_PIPE_CLOSING:
34697c478bd9Sstevel@tonic-gate 	case USB_CR_UNSPECIFIED_ERR:
34707c478bd9Sstevel@tonic-gate 		/* never restart polling on these conditions */
34717c478bd9Sstevel@tonic-gate 	default:
34727c478bd9Sstevel@tonic-gate 		/* for all others, wait for the autoclearing PIPE_RESET cb */
34737c478bd9Sstevel@tonic-gate 
34747c478bd9Sstevel@tonic-gate 		break;
34757c478bd9Sstevel@tonic-gate 	}
34767c478bd9Sstevel@tonic-gate 
34777c478bd9Sstevel@tonic-gate 	usb_free_intr_req(reqp);
34787c478bd9Sstevel@tonic-gate 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
34797c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
34807c478bd9Sstevel@tonic-gate }
34817c478bd9Sstevel@tonic-gate 
34827c478bd9Sstevel@tonic-gate 
34837c478bd9Sstevel@tonic-gate /*
34847c478bd9Sstevel@tonic-gate  * helper function to convert LE bytes to a portmask
34857c478bd9Sstevel@tonic-gate  */
34867c478bd9Sstevel@tonic-gate static usb_port_mask_t
34877c478bd9Sstevel@tonic-gate hubd_mblk2portmask(mblk_t *data)
34887c478bd9Sstevel@tonic-gate {
3489d29f5a71Szhigang lu - Sun Microsystems - Beijing China 	int len = min(MBLKL(data), sizeof (usb_port_mask_t));
34907c478bd9Sstevel@tonic-gate 	usb_port_mask_t rval = 0;
34917c478bd9Sstevel@tonic-gate 	int i;
34927c478bd9Sstevel@tonic-gate 
34937c478bd9Sstevel@tonic-gate 	for (i = 0; i < len; i++) {
34947c478bd9Sstevel@tonic-gate 		rval |= data->b_rptr[i] << (i * 8);
34957c478bd9Sstevel@tonic-gate 	}
34967c478bd9Sstevel@tonic-gate 
34977c478bd9Sstevel@tonic-gate 	return (rval);
34987c478bd9Sstevel@tonic-gate }
34997c478bd9Sstevel@tonic-gate 
35007c478bd9Sstevel@tonic-gate 
35017c478bd9Sstevel@tonic-gate /*
35027c478bd9Sstevel@tonic-gate  * hubd_read_cb:
35037c478bd9Sstevel@tonic-gate  *	interrupt ep1 callback function
35047c478bd9Sstevel@tonic-gate  *
35057c478bd9Sstevel@tonic-gate  *	the status indicates just a change on the pipe with no indication
35067c478bd9Sstevel@tonic-gate  *	of what the change was
35077c478bd9Sstevel@tonic-gate  *
35087c478bd9Sstevel@tonic-gate  *	known conditions:
35097c478bd9Sstevel@tonic-gate  *		- reset port completion
35107c478bd9Sstevel@tonic-gate  *		- connect
35117c478bd9Sstevel@tonic-gate  *		- disconnect
35127c478bd9Sstevel@tonic-gate  *
35137c478bd9Sstevel@tonic-gate  *	for handling the hotplugging, create a new thread that can do
35147c478bd9Sstevel@tonic-gate  *	synchronous usba calls
35157c478bd9Sstevel@tonic-gate  */
35167c478bd9Sstevel@tonic-gate static void
35177c478bd9Sstevel@tonic-gate hubd_read_cb(usb_pipe_handle_t pipe, usb_intr_req_t *reqp)
35187c478bd9Sstevel@tonic-gate {
35197c478bd9Sstevel@tonic-gate 	hubd_t		*hubd = (hubd_t *)(reqp->intr_client_private);
35207c478bd9Sstevel@tonic-gate 	size_t		length;
35217c478bd9Sstevel@tonic-gate 	mblk_t		*data = reqp->intr_data;
35226c7181fcSsl 	int		mem_flag = 0;
35236c7181fcSsl 	hubd_hotplug_arg_t *arg;
35247c478bd9Sstevel@tonic-gate 
35257c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3526112116d8Sfb 	    "hubd_read_cb: ph=0x%p req=0x%p", (void *)pipe, (void *)reqp);
35277c478bd9Sstevel@tonic-gate 
35287c478bd9Sstevel@tonic-gate 	ASSERT((reqp->intr_cb_flags & USB_CB_INTR_CONTEXT) == 0);
35297c478bd9Sstevel@tonic-gate 
35307c478bd9Sstevel@tonic-gate 	/*
35317c478bd9Sstevel@tonic-gate 	 * At present, we are not handling notification for completion of
35327c478bd9Sstevel@tonic-gate 	 * asynchronous pipe reset, for which this data ptr could be NULL
35337c478bd9Sstevel@tonic-gate 	 */
35347c478bd9Sstevel@tonic-gate 
35357c478bd9Sstevel@tonic-gate 	if (data == NULL) {
35367c478bd9Sstevel@tonic-gate 		usb_free_intr_req(reqp);
35377c478bd9Sstevel@tonic-gate 
35387c478bd9Sstevel@tonic-gate 		return;
35397c478bd9Sstevel@tonic-gate 	}
35407c478bd9Sstevel@tonic-gate 
35416c7181fcSsl 	arg = (hubd_hotplug_arg_t *)kmem_zalloc(
35426c7181fcSsl 	    sizeof (hubd_hotplug_arg_t), KM_SLEEP);
35436c7181fcSsl 	mem_flag = 1;
35446c7181fcSsl 
35457c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
35467c478bd9Sstevel@tonic-gate 
35477c478bd9Sstevel@tonic-gate 	if ((hubd->h_dev_state == USB_DEV_SUSPENDED) ||
35487c478bd9Sstevel@tonic-gate 	    (hubd->h_intr_pipe_state != HUBD_INTR_PIPE_ACTIVE)) {
35497c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
35507c478bd9Sstevel@tonic-gate 		usb_free_intr_req(reqp);
35516c7181fcSsl 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
35527c478bd9Sstevel@tonic-gate 
35537c478bd9Sstevel@tonic-gate 		return;
35547c478bd9Sstevel@tonic-gate 	}
35557c478bd9Sstevel@tonic-gate 
35567c478bd9Sstevel@tonic-gate 	ASSERT(hubd->h_ep1_ph == pipe);
35577c478bd9Sstevel@tonic-gate 
3558d29f5a71Szhigang lu - Sun Microsystems - Beijing China 	length = MBLKL(data);
35597c478bd9Sstevel@tonic-gate 
35607c478bd9Sstevel@tonic-gate 	/*
35617c478bd9Sstevel@tonic-gate 	 * Only look at the data and startup the hotplug thread if
35627c478bd9Sstevel@tonic-gate 	 * there actually is data.
35637c478bd9Sstevel@tonic-gate 	 */
35647c478bd9Sstevel@tonic-gate 	if (length != 0) {
35657c478bd9Sstevel@tonic-gate 		usb_port_mask_t port_change = hubd_mblk2portmask(data);
35667c478bd9Sstevel@tonic-gate 
35677c478bd9Sstevel@tonic-gate 		/*
35687c478bd9Sstevel@tonic-gate 		 * if a port change was already reported and we are waiting for
35697c478bd9Sstevel@tonic-gate 		 * reset port completion then wake up the hotplug thread which
35707c478bd9Sstevel@tonic-gate 		 * should be waiting on reset port completion
35717c478bd9Sstevel@tonic-gate 		 *
35727c478bd9Sstevel@tonic-gate 		 * if there is disconnect event instead of reset completion, let
35737c478bd9Sstevel@tonic-gate 		 * the hotplug thread figure this out
35747c478bd9Sstevel@tonic-gate 		 */
35757c478bd9Sstevel@tonic-gate 
35767c478bd9Sstevel@tonic-gate 		/* remove the reset wait bits from the status */
35777c478bd9Sstevel@tonic-gate 		hubd->h_port_change |= port_change &
3578c0f24e5bSlg 		    ~hubd->h_port_reset_wait;
35797c478bd9Sstevel@tonic-gate 
35807c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
35817c478bd9Sstevel@tonic-gate 		    "port change=0x%x port_reset_wait=0x%x",
35827c478bd9Sstevel@tonic-gate 		    hubd->h_port_change, hubd->h_port_reset_wait);
35837c478bd9Sstevel@tonic-gate 
35847c478bd9Sstevel@tonic-gate 		/* there should be only one reset bit active at the time */
35857c478bd9Sstevel@tonic-gate 		if (hubd->h_port_reset_wait & port_change) {
35867c478bd9Sstevel@tonic-gate 			hubd->h_port_reset_wait = 0;
35877c478bd9Sstevel@tonic-gate 			cv_signal(&hubd->h_cv_reset_port);
35887c478bd9Sstevel@tonic-gate 		}
35897c478bd9Sstevel@tonic-gate 
35907c478bd9Sstevel@tonic-gate 		/*
35917c478bd9Sstevel@tonic-gate 		 * kick off the thread only if device is ONLINE and it is not
35927c478bd9Sstevel@tonic-gate 		 * during attaching or detaching
35937c478bd9Sstevel@tonic-gate 		 */
35947c478bd9Sstevel@tonic-gate 		if ((hubd->h_dev_state == USB_DEV_ONLINE) &&
35957c478bd9Sstevel@tonic-gate 		    (!DEVI_IS_ATTACHING(hubd->h_dip)) &&
35967c478bd9Sstevel@tonic-gate 		    (!DEVI_IS_DETACHING(hubd->h_dip)) &&
35977c478bd9Sstevel@tonic-gate 		    (hubd->h_port_change) &&
35987c478bd9Sstevel@tonic-gate 		    (hubd->h_hotplug_thread == 0)) {
35997c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
36007c478bd9Sstevel@tonic-gate 			    "creating hotplug thread: "
36017c478bd9Sstevel@tonic-gate 			    "dev_state=%d", hubd->h_dev_state);
36027c478bd9Sstevel@tonic-gate 
36037c478bd9Sstevel@tonic-gate 			/*
36047c478bd9Sstevel@tonic-gate 			 * Mark this device as busy. The will be marked idle
36057c478bd9Sstevel@tonic-gate 			 * if the async req fails or at the exit of  hotplug
36067c478bd9Sstevel@tonic-gate 			 * thread
36077c478bd9Sstevel@tonic-gate 			 */
36087c478bd9Sstevel@tonic-gate 			(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
36097c478bd9Sstevel@tonic-gate 
36106c7181fcSsl 			arg->hubd = hubd;
36116c7181fcSsl 			arg->hotplug_during_attach = B_FALSE;
36126c7181fcSsl 
36137c478bd9Sstevel@tonic-gate 			if (usb_async_req(hubd->h_dip,
36147c478bd9Sstevel@tonic-gate 			    hubd_hotplug_thread,
36156c7181fcSsl 			    (void *)arg, 0) == USB_SUCCESS) {
36167c478bd9Sstevel@tonic-gate 				hubd->h_hotplug_thread++;
36176c7181fcSsl 				mem_flag = 0;
36187c478bd9Sstevel@tonic-gate 			} else {
36197c478bd9Sstevel@tonic-gate 				/* mark this device as idle */
36207c478bd9Sstevel@tonic-gate 				(void) hubd_pm_idle_component(hubd,
36217c478bd9Sstevel@tonic-gate 				    hubd->h_dip, 0);
36227c478bd9Sstevel@tonic-gate 			}
36237c478bd9Sstevel@tonic-gate 		}
36247c478bd9Sstevel@tonic-gate 	}
36257c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
36267c478bd9Sstevel@tonic-gate 
36276c7181fcSsl 	if (mem_flag == 1) {
36286c7181fcSsl 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
36296c7181fcSsl 	}
36306c7181fcSsl 
36317c478bd9Sstevel@tonic-gate 	usb_free_intr_req(reqp);
36327c478bd9Sstevel@tonic-gate }
36337c478bd9Sstevel@tonic-gate 
36347c478bd9Sstevel@tonic-gate 
36357c478bd9Sstevel@tonic-gate /*
36367c478bd9Sstevel@tonic-gate  * hubd_hotplug_thread:
36377c478bd9Sstevel@tonic-gate  *	handles resetting of port, and creating children
36387c478bd9Sstevel@tonic-gate  *
36397c478bd9Sstevel@tonic-gate  *	the ports to check are indicated in h_port_change bit mask
36407c478bd9Sstevel@tonic-gate  * XXX note that one time poll doesn't work on the root hub
36417c478bd9Sstevel@tonic-gate  */
36427c478bd9Sstevel@tonic-gate static void
36437c478bd9Sstevel@tonic-gate hubd_hotplug_thread(void *arg)
36447c478bd9Sstevel@tonic-gate {
36456c7181fcSsl 	hubd_hotplug_arg_t *hd_arg = (hubd_hotplug_arg_t *)arg;
36466c7181fcSsl 	hubd_t		*hubd = hd_arg->hubd;
36476c7181fcSsl 	boolean_t	attach_flg = hd_arg->hotplug_during_attach;
36487c478bd9Sstevel@tonic-gate 	usb_port_t	port;
36497c478bd9Sstevel@tonic-gate 	uint16_t	nports;
36507c478bd9Sstevel@tonic-gate 	uint16_t	status, change;
36517c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
36527c478bd9Sstevel@tonic-gate 	dev_info_t	*hdip = hubd->h_dip;
36537c478bd9Sstevel@tonic-gate 	dev_info_t	*rh_dip = hubd->h_usba_device->usb_root_hub_dip;
3654c0f24e5bSlg 	dev_info_t	*child_dip;
36557c478bd9Sstevel@tonic-gate 	boolean_t	online_child = B_FALSE;
36567c478bd9Sstevel@tonic-gate 	boolean_t	offline_child = B_FALSE;
36577c478bd9Sstevel@tonic-gate 	boolean_t	pwrup_child = B_FALSE;
3658c0f24e5bSlg 	int		prh_circ, rh_circ, chld_circ, circ, old_state;
36597c478bd9Sstevel@tonic-gate 
36607c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
36617c478bd9Sstevel@tonic-gate 	    "hubd_hotplug_thread:  started");
36627c478bd9Sstevel@tonic-gate 
366340482326SVincent Wang 	/*
366440482326SVincent Wang 	 * Before console is init'd, we temporarily block the hotplug
366540482326SVincent Wang 	 * threads so that BUS_CONFIG_ONE through hubd_bus_config() can be
366640482326SVincent Wang 	 * processed quickly. This reduces the time needed for vfs_mountroot()
36678e1b7aa1Sfei feng - Sun Microsystems - Beijing China 	 * to mount the root FS from a USB disk. And on SPARC platform,
36688e1b7aa1Sfei feng - Sun Microsystems - Beijing China 	 * in order to load 'consconfig' successfully after OBP is gone,
36698e1b7aa1Sfei feng - Sun Microsystems - Beijing China 	 * we need to check 'modrootloaded' to make sure root filesystem is
36708e1b7aa1Sfei feng - Sun Microsystems - Beijing China 	 * available.
367140482326SVincent Wang 	 */
36728e1b7aa1Sfei feng - Sun Microsystems - Beijing China 	while (!modrootloaded || !consconfig_console_is_ready()) {
367340482326SVincent Wang 		delay(drv_usectohz(10000));
367440482326SVincent Wang 	}
367540482326SVincent Wang 
36766c7181fcSsl 	kmem_free(arg, sizeof (hubd_hotplug_arg_t));
36776c7181fcSsl 
36787c478bd9Sstevel@tonic-gate 	/*
36797c478bd9Sstevel@tonic-gate 	 * if our bus power entry point is active, process the change
36807c478bd9Sstevel@tonic-gate 	 * on the next notification of interrupt pipe
36817c478bd9Sstevel@tonic-gate 	 */
36827c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
36837c478bd9Sstevel@tonic-gate 	if (hubd->h_bus_pwr || (hubd->h_hotplug_thread > 1)) {
36847c478bd9Sstevel@tonic-gate 		hubd->h_hotplug_thread--;
36857c478bd9Sstevel@tonic-gate 
36867c478bd9Sstevel@tonic-gate 		/* mark this device as idle */
36877c478bd9Sstevel@tonic-gate 		hubd_pm_idle_component(hubd, hubd->h_dip, 0);
36887c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
36897c478bd9Sstevel@tonic-gate 
36907c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
36917c478bd9Sstevel@tonic-gate 		    "hubd_hotplug_thread: "
36927c478bd9Sstevel@tonic-gate 		    "bus_power in progress/hotplugging undesirable - quit");
36937c478bd9Sstevel@tonic-gate 
36947c478bd9Sstevel@tonic-gate 		return;
36957c478bd9Sstevel@tonic-gate 	}
36967c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
36977c478bd9Sstevel@tonic-gate 
36987c478bd9Sstevel@tonic-gate 	ndi_hold_devi(hdip); /* so we don't race with detach */
36997c478bd9Sstevel@tonic-gate 
37007c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
37017c478bd9Sstevel@tonic-gate 
37027c478bd9Sstevel@tonic-gate 	/* is this the root hub? */
37037c478bd9Sstevel@tonic-gate 	if (hdip == rh_dip) {
37047c478bd9Sstevel@tonic-gate 		if (hubd->h_dev_state == USB_DEV_PWRED_DOWN) {
37057c478bd9Sstevel@tonic-gate 			hubpm = hubd->h_hubpm;
37067c478bd9Sstevel@tonic-gate 
37077c478bd9Sstevel@tonic-gate 			/* mark the root hub as full power */
37087c478bd9Sstevel@tonic-gate 			hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
37097c478bd9Sstevel@tonic-gate 			hubpm->hubp_time_at_full_power = ddi_get_time();
37107c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
37117c478bd9Sstevel@tonic-gate 
37127c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
37137c478bd9Sstevel@tonic-gate 			    "hubd_hotplug_thread: call pm_power_has_changed");
37147c478bd9Sstevel@tonic-gate 
37157c478bd9Sstevel@tonic-gate 			(void) pm_power_has_changed(hdip, 0,
3716c0f24e5bSlg 			    USB_DEV_OS_FULL_PWR);
37177c478bd9Sstevel@tonic-gate 
37187c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
37197c478bd9Sstevel@tonic-gate 			hubd->h_dev_state = USB_DEV_ONLINE;
37207c478bd9Sstevel@tonic-gate 		}
37217c478bd9Sstevel@tonic-gate 
37227c478bd9Sstevel@tonic-gate 	} else {
37237c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
37247c478bd9Sstevel@tonic-gate 		    "hubd_hotplug_thread: not root hub");
37257c478bd9Sstevel@tonic-gate 	}
37267c478bd9Sstevel@tonic-gate 
37277c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
37287c478bd9Sstevel@tonic-gate 
37297c478bd9Sstevel@tonic-gate 	/*
37307c478bd9Sstevel@tonic-gate 	 * this ensures one hotplug activity per system at a time.
37317c478bd9Sstevel@tonic-gate 	 * we enter the parent PCI node to have this serialization.
37327c478bd9Sstevel@tonic-gate 	 * this also excludes ioctls and deathrow thread
37337c478bd9Sstevel@tonic-gate 	 * (a bit crude but easier to debug)
37347c478bd9Sstevel@tonic-gate 	 */
37357c478bd9Sstevel@tonic-gate 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
37367c478bd9Sstevel@tonic-gate 	ndi_devi_enter(rh_dip, &rh_circ);
37377c478bd9Sstevel@tonic-gate 
37387c478bd9Sstevel@tonic-gate 	/* exclude other threads */
37397c478bd9Sstevel@tonic-gate 	ndi_devi_enter(hdip, &circ);
37407c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
37417c478bd9Sstevel@tonic-gate 
3742e4c316c4SVincent Wang 	ASSERT(hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE);
3743e4c316c4SVincent Wang 
3744e4c316c4SVincent Wang 	nports = hubd->h_hub_descr.bNbrPorts;
3745e4c316c4SVincent Wang 
3746e4c316c4SVincent Wang 	hubd_stop_polling(hubd);
3747e4c316c4SVincent Wang 
37487c478bd9Sstevel@tonic-gate 	while ((hubd->h_dev_state == USB_DEV_ONLINE) &&
37497c478bd9Sstevel@tonic-gate 	    (hubd->h_port_change)) {
37507c478bd9Sstevel@tonic-gate 		/*
37517c478bd9Sstevel@tonic-gate 		 * The 0th bit is the hub status change bit.
37527c478bd9Sstevel@tonic-gate 		 * handle loss of local power here
37537c478bd9Sstevel@tonic-gate 		 */
37547c478bd9Sstevel@tonic-gate 		if (hubd->h_port_change & HUB_CHANGE_STATUS) {
37557c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
37567c478bd9Sstevel@tonic-gate 			    "hubd_hotplug_thread: hub status change!");
37577c478bd9Sstevel@tonic-gate 
37587c478bd9Sstevel@tonic-gate 			/*
37597c478bd9Sstevel@tonic-gate 			 * This should be handled properly.  For now,
37607c478bd9Sstevel@tonic-gate 			 * mask off the bit.
37617c478bd9Sstevel@tonic-gate 			 */
37627c478bd9Sstevel@tonic-gate 			hubd->h_port_change &= ~HUB_CHANGE_STATUS;
37637c478bd9Sstevel@tonic-gate 
37647c478bd9Sstevel@tonic-gate 			/*
37657c478bd9Sstevel@tonic-gate 			 * check and ack hub status
37667c478bd9Sstevel@tonic-gate 			 * this causes stall conditions
37677c478bd9Sstevel@tonic-gate 			 * when local power is removed
37687c478bd9Sstevel@tonic-gate 			 */
37697c478bd9Sstevel@tonic-gate 			(void) hubd_get_hub_status(hubd);
37707c478bd9Sstevel@tonic-gate 		}
37717c478bd9Sstevel@tonic-gate 
37727c478bd9Sstevel@tonic-gate 		for (port = 1; port <= nports; port++) {
37737c478bd9Sstevel@tonic-gate 			usb_port_mask_t port_mask;
37747c478bd9Sstevel@tonic-gate 			boolean_t was_connected;
37757c478bd9Sstevel@tonic-gate 
37767c478bd9Sstevel@tonic-gate 			port_mask = 1 << port;
37777c478bd9Sstevel@tonic-gate 			was_connected =
3778c0f24e5bSlg 			    (hubd->h_port_state[port] & PORT_STATUS_CCS) &&
3779c0f24e5bSlg 			    (hubd->h_children_dips[port]);
37807c478bd9Sstevel@tonic-gate 
37817c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
37827c478bd9Sstevel@tonic-gate 			    "hubd_hotplug_thread: "
37837c478bd9Sstevel@tonic-gate 			    "port %d mask=0x%x change=0x%x connected=0x%x",
37847c478bd9Sstevel@tonic-gate 			    port, port_mask, hubd->h_port_change,
37857c478bd9Sstevel@tonic-gate 			    was_connected);
37867c478bd9Sstevel@tonic-gate 
37877c478bd9Sstevel@tonic-gate 			/*
37887c478bd9Sstevel@tonic-gate 			 * is this a port connection that changed?
37897c478bd9Sstevel@tonic-gate 			 */
37907c478bd9Sstevel@tonic-gate 			if ((hubd->h_port_change & port_mask) == 0) {
37917c478bd9Sstevel@tonic-gate 
37927c478bd9Sstevel@tonic-gate 				continue;
37937c478bd9Sstevel@tonic-gate 			}
37947c478bd9Sstevel@tonic-gate 			hubd->h_port_change &= ~port_mask;
37957c478bd9Sstevel@tonic-gate 
37967c478bd9Sstevel@tonic-gate 			/* ack all changes */
37977c478bd9Sstevel@tonic-gate 			(void) hubd_determine_port_status(hubd, port,
37987c478bd9Sstevel@tonic-gate 			    &status, &change, HUBD_ACK_ALL_CHANGES);
37997c478bd9Sstevel@tonic-gate 
38007c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
38017c478bd9Sstevel@tonic-gate 			    "handle port %d:\n\t"
38027c478bd9Sstevel@tonic-gate 			    "new status=0x%x change=0x%x was_conn=0x%x ",
38037c478bd9Sstevel@tonic-gate 			    port, status, change, was_connected);
38047c478bd9Sstevel@tonic-gate 
38057c478bd9Sstevel@tonic-gate 			/* Recover a disabled port */
38067c478bd9Sstevel@tonic-gate 			if (change & PORT_CHANGE_PESC) {
38077c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
3808c0f24e5bSlg 				    hubd->h_log_handle,
3809c0f24e5bSlg 				    "port%d Disabled - "
3810c0f24e5bSlg 				    "status=0x%x, change=0x%x",
3811c0f24e5bSlg 				    port, status, change);
38127c478bd9Sstevel@tonic-gate 
38137c478bd9Sstevel@tonic-gate 				/*
38147c478bd9Sstevel@tonic-gate 				 * if the port was connected and is still
38157c478bd9Sstevel@tonic-gate 				 * connected, recover the port
38167c478bd9Sstevel@tonic-gate 				 */
38177c478bd9Sstevel@tonic-gate 				if (was_connected && (status &
38187c478bd9Sstevel@tonic-gate 				    PORT_STATUS_CCS)) {
38197c478bd9Sstevel@tonic-gate 					online_child |=
38207c478bd9Sstevel@tonic-gate 					    (hubd_recover_disabled_port(hubd,
38217c478bd9Sstevel@tonic-gate 					    port) == USB_SUCCESS);
38227c478bd9Sstevel@tonic-gate 				}
38237c478bd9Sstevel@tonic-gate 			}
38247c478bd9Sstevel@tonic-gate 
38257c478bd9Sstevel@tonic-gate 			/*
38267c478bd9Sstevel@tonic-gate 			 * Now check what changed on the port
38277c478bd9Sstevel@tonic-gate 			 */
38286c7181fcSsl 			if ((change & PORT_CHANGE_CSC) || attach_flg) {
38297c478bd9Sstevel@tonic-gate 				if ((status & PORT_STATUS_CCS) &&
38307c478bd9Sstevel@tonic-gate 				    (!was_connected)) {
38317c478bd9Sstevel@tonic-gate 					/* new device plugged in */
38327c478bd9Sstevel@tonic-gate 					online_child |=
38337c478bd9Sstevel@tonic-gate 					    (hubd_handle_port_connect(hubd,
38347c478bd9Sstevel@tonic-gate 					    port) == USB_SUCCESS);
38357c478bd9Sstevel@tonic-gate 
38367c478bd9Sstevel@tonic-gate 				} else if ((status & PORT_STATUS_CCS) &&
38377c478bd9Sstevel@tonic-gate 				    was_connected) {
38387c478bd9Sstevel@tonic-gate 					/*
38397c478bd9Sstevel@tonic-gate 					 * In this case we can never be sure
38407c478bd9Sstevel@tonic-gate 					 * if the device indeed got hotplugged
38417c478bd9Sstevel@tonic-gate 					 * or the hub is falsely reporting the
38427c478bd9Sstevel@tonic-gate 					 * change.
38437c478bd9Sstevel@tonic-gate 					 */
3844c0f24e5bSlg 					child_dip = hubd->h_children_dips[port];
38457c478bd9Sstevel@tonic-gate 
3846c0f24e5bSlg 					mutex_exit(HUBD_MUTEX(hubd));
38477c478bd9Sstevel@tonic-gate 					/*
3848c0f24e5bSlg 					 * this ensures we do not race with
3849c0f24e5bSlg 					 * other threads which are detaching
3850c0f24e5bSlg 					 * the child driver at the same time.
38517c478bd9Sstevel@tonic-gate 					 */
3852c0f24e5bSlg 					ndi_devi_enter(child_dip, &chld_circ);
3853c0f24e5bSlg 					/*
3854c0f24e5bSlg 					 * Now check if the driver remains
3855c0f24e5bSlg 					 * attached.
3856c0f24e5bSlg 					 */
3857c0f24e5bSlg 					if (i_ddi_devi_attached(child_dip)) {
3858c0f24e5bSlg 						/*
3859c0f24e5bSlg 						 * first post a disconnect event
3860c0f24e5bSlg 						 * to the child.
3861c0f24e5bSlg 						 */
3862c0f24e5bSlg 						hubd_post_event(hubd, port,
3863c0f24e5bSlg 						    USBA_EVENT_TAG_HOT_REMOVAL);
3864c0f24e5bSlg 						mutex_enter(HUBD_MUTEX(hubd));
3865c0f24e5bSlg 
3866c0f24e5bSlg 						/*
3867c0f24e5bSlg 						 * then reset the port and
3868c0f24e5bSlg 						 * recover the device
3869c0f24e5bSlg 						 */
3870c0f24e5bSlg 						online_child |=
3871c0f24e5bSlg 						    (hubd_handle_port_connect(
3872c0f24e5bSlg 						    hubd, port) == USB_SUCCESS);
3873c0f24e5bSlg 
3874c0f24e5bSlg 						mutex_exit(HUBD_MUTEX(hubd));
3875c0f24e5bSlg 					}
3876c0f24e5bSlg 
3877c0f24e5bSlg 					ndi_devi_exit(child_dip, chld_circ);
3878c0f24e5bSlg 					mutex_enter(HUBD_MUTEX(hubd));
38797c478bd9Sstevel@tonic-gate 				} else if (was_connected) {
38807c478bd9Sstevel@tonic-gate 					/* this is a disconnect */
38817c478bd9Sstevel@tonic-gate 					mutex_exit(HUBD_MUTEX(hubd));
38827c478bd9Sstevel@tonic-gate 					hubd_post_event(hubd, port,
38837c478bd9Sstevel@tonic-gate 					    USBA_EVENT_TAG_HOT_REMOVAL);
38847c478bd9Sstevel@tonic-gate 					mutex_enter(HUBD_MUTEX(hubd));
38857c478bd9Sstevel@tonic-gate 
38867c478bd9Sstevel@tonic-gate 					offline_child = B_TRUE;
38877c478bd9Sstevel@tonic-gate 				}
38887c478bd9Sstevel@tonic-gate 			}
38897c478bd9Sstevel@tonic-gate 
38907c478bd9Sstevel@tonic-gate 			/*
38917c478bd9Sstevel@tonic-gate 			 * Check if any port is coming out of suspend
38927c478bd9Sstevel@tonic-gate 			 */
38937c478bd9Sstevel@tonic-gate 			if (change & PORT_CHANGE_PSSC) {
38947c478bd9Sstevel@tonic-gate 				/* a resuming device could have disconnected */
38957c478bd9Sstevel@tonic-gate 				if (was_connected &&
38967c478bd9Sstevel@tonic-gate 				    hubd->h_children_dips[port]) {
38977c478bd9Sstevel@tonic-gate 
38987c478bd9Sstevel@tonic-gate 					/* device on this port resuming */
38997c478bd9Sstevel@tonic-gate 					dev_info_t *dip;
39007c478bd9Sstevel@tonic-gate 
39017c478bd9Sstevel@tonic-gate 					dip = hubd->h_children_dips[port];
39027c478bd9Sstevel@tonic-gate 
39037c478bd9Sstevel@tonic-gate 					/*
39047c478bd9Sstevel@tonic-gate 					 * Don't raise power on detaching child
39057c478bd9Sstevel@tonic-gate 					 */
39067c478bd9Sstevel@tonic-gate 					if (!DEVI_IS_DETACHING(dip)) {
39077c478bd9Sstevel@tonic-gate 						/*
39087c478bd9Sstevel@tonic-gate 						 * As this child is not
39097c478bd9Sstevel@tonic-gate 						 * detaching, we set this
39107c478bd9Sstevel@tonic-gate 						 * flag, causing bus_ctls
39117c478bd9Sstevel@tonic-gate 						 * to stall detach till
39127c478bd9Sstevel@tonic-gate 						 * pm_raise_power returns
39137c478bd9Sstevel@tonic-gate 						 * and flag it for a deferred
39147c478bd9Sstevel@tonic-gate 						 * raise_power.
39157c478bd9Sstevel@tonic-gate 						 *
39167c478bd9Sstevel@tonic-gate 						 * pm_raise_power is deferred
39177c478bd9Sstevel@tonic-gate 						 * because we need to release
39187c478bd9Sstevel@tonic-gate 						 * the locks first.
39197c478bd9Sstevel@tonic-gate 						 */
39207c478bd9Sstevel@tonic-gate 						hubd->h_port_state[port] |=
3921c0f24e5bSlg 						    HUBD_CHILD_RAISE_POWER;
39227c478bd9Sstevel@tonic-gate 						pwrup_child = B_TRUE;
39237c478bd9Sstevel@tonic-gate 						mutex_exit(HUBD_MUTEX(hubd));
39247c478bd9Sstevel@tonic-gate 
39257c478bd9Sstevel@tonic-gate 						/*
39267c478bd9Sstevel@tonic-gate 						 * make sure that child
39277c478bd9Sstevel@tonic-gate 						 * doesn't disappear
39287c478bd9Sstevel@tonic-gate 						 */
39297c478bd9Sstevel@tonic-gate 						ndi_hold_devi(dip);
39307c478bd9Sstevel@tonic-gate 
39317c478bd9Sstevel@tonic-gate 						mutex_enter(HUBD_MUTEX(hubd));
39327c478bd9Sstevel@tonic-gate 					}
39337c478bd9Sstevel@tonic-gate 				}
39347c478bd9Sstevel@tonic-gate 			}
3935fef1e07eSsl 
3936fef1e07eSsl 			/*
3937fef1e07eSsl 			 * Check if the port is over-current
3938fef1e07eSsl 			 */
3939fef1e07eSsl 			if (change & PORT_CHANGE_OCIC) {
3940fef1e07eSsl 				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
3941fef1e07eSsl 				    hubd->h_log_handle,
3942fef1e07eSsl 				    "Port%d in over current condition, "
3943fef1e07eSsl 				    "please check the attached device to "
3944fef1e07eSsl 				    "clear the condition. The system will "
3945fef1e07eSsl 				    "try to recover the port, but if not "
3946fef1e07eSsl 				    "successful, you need to re-connect "
3947fef1e07eSsl 				    "the hub or reboot the system to bring "
3948fef1e07eSsl 				    "the port back to work", port);
3949fef1e07eSsl 
3950fef1e07eSsl 				if (!(status & PORT_STATUS_PPS)) {
3951fef1e07eSsl 					/*
3952fef1e07eSsl 					 * Try to enable port power, but
3953fef1e07eSsl 					 * possibly fail. Ignore failure
3954fef1e07eSsl 					 */
3955fef1e07eSsl 					(void) hubd_enable_port_power(hubd,
3956fef1e07eSsl 					    port);
3957fef1e07eSsl 
3958fef1e07eSsl 					/*
3959fef1e07eSsl 					 * Delay some time to avoid
3960fef1e07eSsl 					 * over-current event to happen
3961fef1e07eSsl 					 * too frequently in some cases
3962fef1e07eSsl 					 */
3963fef1e07eSsl 					mutex_exit(HUBD_MUTEX(hubd));
3964fef1e07eSsl 					delay(drv_usectohz(500000));
3965fef1e07eSsl 					mutex_enter(HUBD_MUTEX(hubd));
3966fef1e07eSsl 				}
3967fef1e07eSsl 			}
39687c478bd9Sstevel@tonic-gate 		}
39697c478bd9Sstevel@tonic-gate 	}
39707c478bd9Sstevel@tonic-gate 
39717c478bd9Sstevel@tonic-gate 	/* release locks so we can do a devfs_clean */
39727c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
39737c478bd9Sstevel@tonic-gate 
39747c478bd9Sstevel@tonic-gate 	/* delete cached dv_node's but drop locks first */
39757c478bd9Sstevel@tonic-gate 	ndi_devi_exit(hdip, circ);
39767c478bd9Sstevel@tonic-gate 	ndi_devi_exit(rh_dip, rh_circ);
39777c478bd9Sstevel@tonic-gate 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
39787c478bd9Sstevel@tonic-gate 
39797c478bd9Sstevel@tonic-gate 	(void) devfs_clean(rh_dip, NULL, 0);
39807c478bd9Sstevel@tonic-gate 
39817c478bd9Sstevel@tonic-gate 	/* now check if any children need onlining */
39827c478bd9Sstevel@tonic-gate 	if (online_child) {
39837c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
39847c478bd9Sstevel@tonic-gate 		    "hubd_hotplug_thread: onlining children");
39857c478bd9Sstevel@tonic-gate 
398640482326SVincent Wang 		(void) ndi_devi_online(hubd->h_dip, 0);
39877c478bd9Sstevel@tonic-gate 	}
39887c478bd9Sstevel@tonic-gate 
39897c478bd9Sstevel@tonic-gate 	/* now check if any disconnected devices need to be cleaned up */
39907c478bd9Sstevel@tonic-gate 	if (offline_child) {
39917c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
39927c478bd9Sstevel@tonic-gate 		    "hubd_hotplug_thread: scheduling cleanup");
39937c478bd9Sstevel@tonic-gate 
39947c478bd9Sstevel@tonic-gate 		hubd_schedule_cleanup(hubd->h_usba_device->usb_root_hub_dip);
39957c478bd9Sstevel@tonic-gate 	}
39967c478bd9Sstevel@tonic-gate 
39977c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
39987c478bd9Sstevel@tonic-gate 
39997c478bd9Sstevel@tonic-gate 	/* now raise power on the children that have woken up */
40007c478bd9Sstevel@tonic-gate 	if (pwrup_child) {
40017c478bd9Sstevel@tonic-gate 		old_state = hubd->h_dev_state;
40027c478bd9Sstevel@tonic-gate 		hubd->h_dev_state = USB_DEV_HUB_CHILD_PWRLVL;
40037c478bd9Sstevel@tonic-gate 		for (port = 1; port <= nports; port++) {
40047c478bd9Sstevel@tonic-gate 			if (hubd->h_port_state[port] & HUBD_CHILD_RAISE_POWER) {
40057c478bd9Sstevel@tonic-gate 				dev_info_t *dip = hubd->h_children_dips[port];
40067c478bd9Sstevel@tonic-gate 
40077c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
40087c478bd9Sstevel@tonic-gate 
40097c478bd9Sstevel@tonic-gate 				/* Get the device to full power */
40107c478bd9Sstevel@tonic-gate 				(void) pm_busy_component(dip, 0);
40117c478bd9Sstevel@tonic-gate 				(void) pm_raise_power(dip, 0,
40127c478bd9Sstevel@tonic-gate 				    USB_DEV_OS_FULL_PWR);
40137c478bd9Sstevel@tonic-gate 				(void) pm_idle_component(dip, 0);
40147c478bd9Sstevel@tonic-gate 
40157c478bd9Sstevel@tonic-gate 				/* release the hold on the child */
40167c478bd9Sstevel@tonic-gate 				ndi_rele_devi(dip);
40177c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
40187c478bd9Sstevel@tonic-gate 				hubd->h_port_state[port] &=
40197c478bd9Sstevel@tonic-gate 				    ~HUBD_CHILD_RAISE_POWER;
40207c478bd9Sstevel@tonic-gate 			}
40217c478bd9Sstevel@tonic-gate 		}
40227c478bd9Sstevel@tonic-gate 		/*
40237c478bd9Sstevel@tonic-gate 		 * make sure that we don't accidentally
40247c478bd9Sstevel@tonic-gate 		 * over write the disconnect state
40257c478bd9Sstevel@tonic-gate 		 */
40267c478bd9Sstevel@tonic-gate 		if (hubd->h_dev_state == USB_DEV_HUB_CHILD_PWRLVL) {
40277c478bd9Sstevel@tonic-gate 			hubd->h_dev_state = old_state;
40287c478bd9Sstevel@tonic-gate 		}
40297c478bd9Sstevel@tonic-gate 	}
40307c478bd9Sstevel@tonic-gate 
40317c478bd9Sstevel@tonic-gate 	/*
40327c478bd9Sstevel@tonic-gate 	 * start polling can immediately kick off read callback
40337c478bd9Sstevel@tonic-gate 	 * we need to set the h_hotplug_thread to 0 so that
40347c478bd9Sstevel@tonic-gate 	 * the callback is not dropped
4035ffcd51f3Slg 	 *
4036ffcd51f3Slg 	 * if there is device during reset, still stop polling to avoid the
4037ffcd51f3Slg 	 * read callback interrupting the reset, the polling will be started
4038ffcd51f3Slg 	 * in hubd_reset_thread.
40397c478bd9Sstevel@tonic-gate 	 */
4040ffcd51f3Slg 	for (port = 1; port <= MAX_PORTS; port++) {
4041ffcd51f3Slg 		if (hubd->h_reset_port[port]) {
4042ffcd51f3Slg 
4043ffcd51f3Slg 			break;
4044ffcd51f3Slg 		}
4045ffcd51f3Slg 	}
4046ffcd51f3Slg 	if (port > MAX_PORTS) {
4047ffcd51f3Slg 		hubd_start_polling(hubd, HUBD_ALWAYS_START_POLLING);
4048ffcd51f3Slg 	}
40497c478bd9Sstevel@tonic-gate 
40507c478bd9Sstevel@tonic-gate 	/*
40517c478bd9Sstevel@tonic-gate 	 * Earlier we would set the h_hotplug_thread = 0 before
40527c478bd9Sstevel@tonic-gate 	 * polling was restarted  so that
40537c478bd9Sstevel@tonic-gate 	 * if there is any root hub status change interrupt, we can still kick
40547c478bd9Sstevel@tonic-gate 	 * off the hotplug thread. This was valid when this interrupt was
40557c478bd9Sstevel@tonic-gate 	 * delivered in hardware, and only ONE interrupt would be delivered.
40567c478bd9Sstevel@tonic-gate 	 * Now that we poll on the root hub looking for status change in
40577c478bd9Sstevel@tonic-gate 	 * software, this assignment is no longer required.
40587c478bd9Sstevel@tonic-gate 	 */
40597c478bd9Sstevel@tonic-gate 	hubd->h_hotplug_thread--;
40607c478bd9Sstevel@tonic-gate 
40617c478bd9Sstevel@tonic-gate 	/* mark this device as idle */
40627c478bd9Sstevel@tonic-gate 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
40637c478bd9Sstevel@tonic-gate 
4064ffcd51f3Slg 	cv_broadcast(&hubd->h_cv_hotplug_dev);
4065ffcd51f3Slg 
40667c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
40677c478bd9Sstevel@tonic-gate 	    "hubd_hotplug_thread: exit");
40687c478bd9Sstevel@tonic-gate 
40697c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
40707c478bd9Sstevel@tonic-gate 
40717c478bd9Sstevel@tonic-gate 	ndi_rele_devi(hdip);
40727c478bd9Sstevel@tonic-gate }
40737c478bd9Sstevel@tonic-gate 
40747c478bd9Sstevel@tonic-gate 
40757c478bd9Sstevel@tonic-gate /*
40767c478bd9Sstevel@tonic-gate  * hubd_handle_port_connect:
40777c478bd9Sstevel@tonic-gate  *	Transition a port from Disabled to Enabled.  Ensure that the
40787c478bd9Sstevel@tonic-gate  *	port is in the correct state before attempting to
40797c478bd9Sstevel@tonic-gate  *	access the device.
40807c478bd9Sstevel@tonic-gate  */
40817c478bd9Sstevel@tonic-gate static int
40827c478bd9Sstevel@tonic-gate hubd_handle_port_connect(hubd_t *hubd, usb_port_t port)
40837c478bd9Sstevel@tonic-gate {
40847c478bd9Sstevel@tonic-gate 	int			rval;
40857c478bd9Sstevel@tonic-gate 	int			retry;
40867c478bd9Sstevel@tonic-gate 	long			time_delay;
40877c478bd9Sstevel@tonic-gate 	long			settling_time;
40887c478bd9Sstevel@tonic-gate 	uint16_t		status;
40897c478bd9Sstevel@tonic-gate 	uint16_t		change;
40907c478bd9Sstevel@tonic-gate 	usb_addr_t		hubd_usb_addr;
40917c478bd9Sstevel@tonic-gate 	usba_device_t		*usba_device;
40927c478bd9Sstevel@tonic-gate 	usb_port_status_t	port_status = 0;
40937c478bd9Sstevel@tonic-gate 	usb_port_status_t	hub_port_status = 0;
40947c478bd9Sstevel@tonic-gate 
40957c478bd9Sstevel@tonic-gate 	/* Get the hub address and port status */
40967c478bd9Sstevel@tonic-gate 	usba_device = hubd->h_usba_device;
40977c478bd9Sstevel@tonic-gate 	mutex_enter(&usba_device->usb_mutex);
40987c478bd9Sstevel@tonic-gate 	hubd_usb_addr = usba_device->usb_addr;
40997c478bd9Sstevel@tonic-gate 	hub_port_status = usba_device->usb_port_status;
41007c478bd9Sstevel@tonic-gate 	mutex_exit(&usba_device->usb_mutex);
41017c478bd9Sstevel@tonic-gate 
41027c478bd9Sstevel@tonic-gate 	/*
41037c478bd9Sstevel@tonic-gate 	 * If a device is connected, transition the
41047c478bd9Sstevel@tonic-gate 	 * port from Disabled to the Enabled state.
41057c478bd9Sstevel@tonic-gate 	 * The device will receive downstream packets
41067c478bd9Sstevel@tonic-gate 	 * in the Enabled state.
41077c478bd9Sstevel@tonic-gate 	 *
41087c478bd9Sstevel@tonic-gate 	 * reset port and wait for the hub to report
41097c478bd9Sstevel@tonic-gate 	 * completion
41107c478bd9Sstevel@tonic-gate 	 */
41117c478bd9Sstevel@tonic-gate 	change = status = 0;
41127c478bd9Sstevel@tonic-gate 
41137c478bd9Sstevel@tonic-gate 	/*
41147c478bd9Sstevel@tonic-gate 	 * According to section 9.1.2 of USB 2.0 spec, the host should
41157c478bd9Sstevel@tonic-gate 	 * wait for atleast 100ms to allow completion of an insertion
41167c478bd9Sstevel@tonic-gate 	 * process and for power at the device to become stable.
41177c478bd9Sstevel@tonic-gate 	 * We wait for 200 ms
41187c478bd9Sstevel@tonic-gate 	 */
41197c478bd9Sstevel@tonic-gate 	settling_time = drv_usectohz(hubd_device_delay / 5);
41207c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
41217c478bd9Sstevel@tonic-gate 	delay(settling_time);
41227c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
41237c478bd9Sstevel@tonic-gate 
41247c478bd9Sstevel@tonic-gate 	/* calculate 600 ms delay time */
41257c478bd9Sstevel@tonic-gate 	time_delay = (6 * drv_usectohz(hubd_device_delay)) / 10;
41267c478bd9Sstevel@tonic-gate 
41277c478bd9Sstevel@tonic-gate 	for (retry = 0; (hubd->h_dev_state == USB_DEV_ONLINE) &&
41287c478bd9Sstevel@tonic-gate 	    (retry < hubd_retry_enumerate); retry++) {
41297c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
41307c478bd9Sstevel@tonic-gate 		    "resetting port%d, retry=%d", port, retry);
41317c478bd9Sstevel@tonic-gate 
41327c478bd9Sstevel@tonic-gate 		if ((rval = hubd_reset_port(hubd, port)) != USB_SUCCESS) {
41337c478bd9Sstevel@tonic-gate 			(void) hubd_determine_port_status(hubd,
41347c478bd9Sstevel@tonic-gate 			    port, &status, &change, 0);
41357c478bd9Sstevel@tonic-gate 
41367c478bd9Sstevel@tonic-gate 			/* continue only if port is still connected */
41377c478bd9Sstevel@tonic-gate 			if (status & PORT_STATUS_CCS) {
41387c478bd9Sstevel@tonic-gate 				continue;
41397c478bd9Sstevel@tonic-gate 			}
41407c478bd9Sstevel@tonic-gate 
41417c478bd9Sstevel@tonic-gate 			/* carry on regardless */
41427c478bd9Sstevel@tonic-gate 		}
41437c478bd9Sstevel@tonic-gate 
41447c478bd9Sstevel@tonic-gate 		/*
41457c478bd9Sstevel@tonic-gate 		 * according to USB 2.0 spec section 11.24.2.7.1.2
41467c478bd9Sstevel@tonic-gate 		 * at the end of port reset, the hub enables the port.
41477c478bd9Sstevel@tonic-gate 		 * But for some strange reasons, uhci port remains disabled.
41487c478bd9Sstevel@tonic-gate 		 * And because the port remains disabled for the settling
41497c478bd9Sstevel@tonic-gate 		 * time below, the device connected to the port gets wedged
41507c478bd9Sstevel@tonic-gate 		 * - fails to enumerate (device not responding)
41517c478bd9Sstevel@tonic-gate 		 * Hence, we enable it here immediately and later again after
41527c478bd9Sstevel@tonic-gate 		 * the delay
41537c478bd9Sstevel@tonic-gate 		 */
41547c478bd9Sstevel@tonic-gate 		(void) hubd_enable_port(hubd, port);
41557c478bd9Sstevel@tonic-gate 
41567c478bd9Sstevel@tonic-gate 		/* we skip this delay in the first iteration */
41577c478bd9Sstevel@tonic-gate 		if (retry) {
41587c478bd9Sstevel@tonic-gate 			/*
41597c478bd9Sstevel@tonic-gate 			 * delay for device to signal disconnect/connect so
41607c478bd9Sstevel@tonic-gate 			 * that hub properly recognizes the speed of the device
41617c478bd9Sstevel@tonic-gate 			 */
41627c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
41637c478bd9Sstevel@tonic-gate 			delay(settling_time);
41647c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
41657c478bd9Sstevel@tonic-gate 
41667c478bd9Sstevel@tonic-gate 			/*
41677c478bd9Sstevel@tonic-gate 			 * When a low speed device is connected to any port of
41687c478bd9Sstevel@tonic-gate 			 * PPX it has to be explicitly enabled
41697c478bd9Sstevel@tonic-gate 			 * Also, if device intentionally signals
41707c478bd9Sstevel@tonic-gate 			 * disconnect/connect, it will disable the port.
41717c478bd9Sstevel@tonic-gate 			 * So enable it again.
41727c478bd9Sstevel@tonic-gate 			 */
41737c478bd9Sstevel@tonic-gate 			(void) hubd_enable_port(hubd, port);
41747c478bd9Sstevel@tonic-gate 		}
41757c478bd9Sstevel@tonic-gate 
41767c478bd9Sstevel@tonic-gate 		if ((rval = hubd_determine_port_status(hubd, port, &status,
41777c478bd9Sstevel@tonic-gate 		    &change, 0)) != USB_SUCCESS) {
41787c478bd9Sstevel@tonic-gate 
4179d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
41807c478bd9Sstevel@tonic-gate 			    "getting status failed (%d)", rval);
41817c478bd9Sstevel@tonic-gate 
41827c478bd9Sstevel@tonic-gate 			(void) hubd_disable_port(hubd, port);
41837c478bd9Sstevel@tonic-gate 
41847c478bd9Sstevel@tonic-gate 			continue;
41857c478bd9Sstevel@tonic-gate 		}
41867c478bd9Sstevel@tonic-gate 
41877c478bd9Sstevel@tonic-gate 		if (status & PORT_STATUS_POCI) {
4188d291d9f2Sfrits 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
41897c478bd9Sstevel@tonic-gate 			    "port %d overcurrent", port);
41907c478bd9Sstevel@tonic-gate 
41917c478bd9Sstevel@tonic-gate 			(void) hubd_disable_port(hubd, port);
41927c478bd9Sstevel@tonic-gate 
41937c478bd9Sstevel@tonic-gate 			/* ack changes */
41947c478bd9Sstevel@tonic-gate 			(void) hubd_determine_port_status(hubd,
41957c478bd9Sstevel@tonic-gate 			    port, &status, &change, PORT_CHANGE_OCIC);
41967c478bd9Sstevel@tonic-gate 
41977c478bd9Sstevel@tonic-gate 			continue;
41987c478bd9Sstevel@tonic-gate 		}
41997c478bd9Sstevel@tonic-gate 
42007c478bd9Sstevel@tonic-gate 		/* is status really OK? */
42017c478bd9Sstevel@tonic-gate 		if ((status & PORT_STATUS_OK) != PORT_STATUS_OK) {
42027c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
42037c478bd9Sstevel@tonic-gate 			    "port %d status (0x%x) not OK on retry %d",
42047c478bd9Sstevel@tonic-gate 			    port, status, retry);
42057c478bd9Sstevel@tonic-gate 
42067c478bd9Sstevel@tonic-gate 			/* check if we still have the connection */
42077c478bd9Sstevel@tonic-gate 			if (!(status & PORT_STATUS_CCS)) {
42087c478bd9Sstevel@tonic-gate 				/* lost connection, set exit condition */
42097c478bd9Sstevel@tonic-gate 				retry = hubd_retry_enumerate;
42107c478bd9Sstevel@tonic-gate 
42117c478bd9Sstevel@tonic-gate 				break;
42127c478bd9Sstevel@tonic-gate 			}
42137c478bd9Sstevel@tonic-gate 		} else {
42147c478bd9Sstevel@tonic-gate 			/*
42157c478bd9Sstevel@tonic-gate 			 * Determine if the device is high or full
42167c478bd9Sstevel@tonic-gate 			 * or low speed.
42177c478bd9Sstevel@tonic-gate 			 */
42187c478bd9Sstevel@tonic-gate 			if (status & PORT_STATUS_LSDA) {
42197c478bd9Sstevel@tonic-gate 				port_status = USBA_LOW_SPEED_DEV;
42207c478bd9Sstevel@tonic-gate 			} else if (status & PORT_STATUS_HSDA) {
42217c478bd9Sstevel@tonic-gate 				port_status = USBA_HIGH_SPEED_DEV;
42227c478bd9Sstevel@tonic-gate 			} else {
42237c478bd9Sstevel@tonic-gate 				port_status = USBA_FULL_SPEED_DEV;
42247c478bd9Sstevel@tonic-gate 			}
42257c478bd9Sstevel@tonic-gate 
42267c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
42277c478bd9Sstevel@tonic-gate 			    "creating child port%d, status=0x%x "
42287c478bd9Sstevel@tonic-gate 			    "port status=0x%x",
42297c478bd9Sstevel@tonic-gate 			    port, status, port_status);
42307c478bd9Sstevel@tonic-gate 
42317c478bd9Sstevel@tonic-gate 			/*
42327c478bd9Sstevel@tonic-gate 			 * if the child already exists, set addrs and config
42337c478bd9Sstevel@tonic-gate 			 * to the device post connect event to the child
42347c478bd9Sstevel@tonic-gate 			 */
42357c478bd9Sstevel@tonic-gate 			if (hubd->h_children_dips[port]) {
42367c478bd9Sstevel@tonic-gate 				/* set addrs to this device */
42377c478bd9Sstevel@tonic-gate 				rval = hubd_setdevaddr(hubd, port);
42387c478bd9Sstevel@tonic-gate 
42397c478bd9Sstevel@tonic-gate 				/*
42407c478bd9Sstevel@tonic-gate 				 * This delay is important for the CATC hub
42417c478bd9Sstevel@tonic-gate 				 * to enumerate. But, avoid delay in the first
42427c478bd9Sstevel@tonic-gate 				 * iteration
42437c478bd9Sstevel@tonic-gate 				 */
42447c478bd9Sstevel@tonic-gate 				if (retry) {
42457c478bd9Sstevel@tonic-gate 					mutex_exit(HUBD_MUTEX(hubd));
42467c478bd9Sstevel@tonic-gate 					delay(drv_usectohz(
42477c478bd9Sstevel@tonic-gate 					    hubd_device_delay/100));
42487c478bd9Sstevel@tonic-gate 					mutex_enter(HUBD_MUTEX(hubd));
42497c478bd9Sstevel@tonic-gate 				}
42507c478bd9Sstevel@tonic-gate 
42517c478bd9Sstevel@tonic-gate 				if (rval == USB_SUCCESS) {
4252ffcd51f3Slg 					/*
4253ffcd51f3Slg 					 * if the port is resetting, check if
4254ffcd51f3Slg 					 * device's descriptors have changed.
4255ffcd51f3Slg 					 */
4256ffcd51f3Slg 					if ((hubd->h_reset_port[port]) &&
4257ffcd51f3Slg 					    (hubd_check_same_device(hubd,
4258ffcd51f3Slg 					    port) != USB_SUCCESS)) {
4259ffcd51f3Slg 						retry = hubd_retry_enumerate;
4260ffcd51f3Slg 
4261ffcd51f3Slg 						break;
4262ffcd51f3Slg 					}
4263ffcd51f3Slg 
42647c478bd9Sstevel@tonic-gate 					/*
42657c478bd9Sstevel@tonic-gate 					 * set the default config for
42667c478bd9Sstevel@tonic-gate 					 * this device
42677c478bd9Sstevel@tonic-gate 					 */
42687c478bd9Sstevel@tonic-gate 					hubd_setdevconfig(hubd, port);
42697c478bd9Sstevel@tonic-gate 
4270ffcd51f3Slg 					/*
4271ffcd51f3Slg 					 * if we are doing Default reset, do
4272ffcd51f3Slg 					 * not post reconnect event since we
4273ffcd51f3Slg 					 * don't know where reset function is
4274ffcd51f3Slg 					 * called.
4275ffcd51f3Slg 					 */
4276ffcd51f3Slg 					if (hubd->h_reset_port[port]) {
4277ffcd51f3Slg 
4278ffcd51f3Slg 						return (USB_SUCCESS);
4279ffcd51f3Slg 					}
4280ffcd51f3Slg 
42817c478bd9Sstevel@tonic-gate 					/*
42827c478bd9Sstevel@tonic-gate 					 * indicate to the child that
42837c478bd9Sstevel@tonic-gate 					 * it is online again
42847c478bd9Sstevel@tonic-gate 					 */
42857c478bd9Sstevel@tonic-gate 					mutex_exit(HUBD_MUTEX(hubd));
42867c478bd9Sstevel@tonic-gate 					hubd_post_event(hubd, port,
42877c478bd9Sstevel@tonic-gate 					    USBA_EVENT_TAG_HOT_INSERTION);
42887c478bd9Sstevel@tonic-gate 					mutex_enter(HUBD_MUTEX(hubd));
42897c478bd9Sstevel@tonic-gate 
42907c478bd9Sstevel@tonic-gate 					return (USB_SUCCESS);
42917c478bd9Sstevel@tonic-gate 				}
42927c478bd9Sstevel@tonic-gate 			} else {
42937c478bd9Sstevel@tonic-gate 				/*
42947c478bd9Sstevel@tonic-gate 				 * We need to release access here
42957c478bd9Sstevel@tonic-gate 				 * so that busctls on other ports can
42967c478bd9Sstevel@tonic-gate 				 * continue and don't cause a deadlock
42977c478bd9Sstevel@tonic-gate 				 * when busctl and removal of prom node
42987c478bd9Sstevel@tonic-gate 				 * takes concurrently. This also ensures
42997c478bd9Sstevel@tonic-gate 				 * busctls for attach of successfully
43007c478bd9Sstevel@tonic-gate 				 * enumerated devices on other ports can
43017c478bd9Sstevel@tonic-gate 				 * continue concurrently with the process
43027c478bd9Sstevel@tonic-gate 				 * of enumerating the new devices. This
43037c478bd9Sstevel@tonic-gate 				 * reduces the overall boot time of the system.
43047c478bd9Sstevel@tonic-gate 				 */
43057c478bd9Sstevel@tonic-gate 				rval = hubd_create_child(hubd->h_dip,
4306c0f24e5bSlg 				    hubd,
4307c0f24e5bSlg 				    hubd->h_usba_device,
4308c0f24e5bSlg 				    port_status, port,
4309c0f24e5bSlg 				    retry);
43107c478bd9Sstevel@tonic-gate 				if (rval == USB_SUCCESS) {
43117c478bd9Sstevel@tonic-gate 					usba_update_hotplug_stats(hubd->h_dip,
43127c478bd9Sstevel@tonic-gate 					    USBA_TOTAL_HOTPLUG_SUCCESS|
43137c478bd9Sstevel@tonic-gate 					    USBA_HOTPLUG_SUCCESS);
43147c478bd9Sstevel@tonic-gate 					hubd->h_total_hotplug_success++;
43157c478bd9Sstevel@tonic-gate 
43167c478bd9Sstevel@tonic-gate 					if (retry > 0) {
4317d291d9f2Sfrits 						USB_DPRINTF_L2(
43187c478bd9Sstevel@tonic-gate 						    DPRINT_MASK_HOTPLUG,
43197c478bd9Sstevel@tonic-gate 						    hubd->h_log_handle,
43207c478bd9Sstevel@tonic-gate 						    "device on port %d "
43217c478bd9Sstevel@tonic-gate 						    "enumerated after %d %s",
43227c478bd9Sstevel@tonic-gate 						    port, retry,
43237c478bd9Sstevel@tonic-gate 						    (retry > 1) ? "retries" :
43247c478bd9Sstevel@tonic-gate 						    "retry");
43257c478bd9Sstevel@tonic-gate 
43267c478bd9Sstevel@tonic-gate 					}
43277c478bd9Sstevel@tonic-gate 
43287c478bd9Sstevel@tonic-gate 					return (USB_SUCCESS);
43297c478bd9Sstevel@tonic-gate 				}
43307c478bd9Sstevel@tonic-gate 			}
43317c478bd9Sstevel@tonic-gate 		}
43327c478bd9Sstevel@tonic-gate 
43337c478bd9Sstevel@tonic-gate 		/* wait a while until it settles? */
43347c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
43357c478bd9Sstevel@tonic-gate 		    "disabling port %d again", port);
43367c478bd9Sstevel@tonic-gate 
43377c478bd9Sstevel@tonic-gate 		(void) hubd_disable_port(hubd, port);
43387c478bd9Sstevel@tonic-gate 		if (retry) {
43397c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
43407c478bd9Sstevel@tonic-gate 			delay(time_delay);
43417c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
43427c478bd9Sstevel@tonic-gate 		}
43437c478bd9Sstevel@tonic-gate 
43447c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
43457c478bd9Sstevel@tonic-gate 		    "retrying on port %d", port);
43467c478bd9Sstevel@tonic-gate 	}
43477c478bd9Sstevel@tonic-gate 
43487c478bd9Sstevel@tonic-gate 	if (retry >= hubd_retry_enumerate) {
43497c478bd9Sstevel@tonic-gate 		/*
43507c478bd9Sstevel@tonic-gate 		 * If it is a High Speed Root Hub and connected device
43517c478bd9Sstevel@tonic-gate 		 * Is a Low/Full Speed, it will be handled by USB 1.1
43527c478bd9Sstevel@tonic-gate 		 * Host Controller. In this case, USB 2.0 Host Controller
43537c478bd9Sstevel@tonic-gate 		 * will transfer the ownership of this port to USB 1.1
43547c478bd9Sstevel@tonic-gate 		 * Host Controller. So don't display any error message on
43557c478bd9Sstevel@tonic-gate 		 * the console.
43567c478bd9Sstevel@tonic-gate 		 */
43577c478bd9Sstevel@tonic-gate 		if ((hubd_usb_addr == ROOT_HUB_ADDR) &&
43587c478bd9Sstevel@tonic-gate 		    (hub_port_status == USBA_HIGH_SPEED_DEV) &&
43597c478bd9Sstevel@tonic-gate 		    (port_status != USBA_HIGH_SPEED_DEV)) {
43607c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
43617c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
43627c478bd9Sstevel@tonic-gate 			    "hubd_handle_port_connect: Low/Full speed "
43637c478bd9Sstevel@tonic-gate 			    "device is connected to High Speed root hub");
43647c478bd9Sstevel@tonic-gate 		} else {
43657c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
43667c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
43677c478bd9Sstevel@tonic-gate 			    "Connecting device on port %d failed", port);
43687c478bd9Sstevel@tonic-gate 		}
43697c478bd9Sstevel@tonic-gate 
43707c478bd9Sstevel@tonic-gate 		(void) hubd_disable_port(hubd, port);
43717c478bd9Sstevel@tonic-gate 		usba_update_hotplug_stats(hubd->h_dip,
43727c478bd9Sstevel@tonic-gate 		    USBA_TOTAL_HOTPLUG_FAILURE|USBA_HOTPLUG_FAILURE);
43737c478bd9Sstevel@tonic-gate 		hubd->h_total_hotplug_failure++;
43747c478bd9Sstevel@tonic-gate 
43757c478bd9Sstevel@tonic-gate 		/*
43767c478bd9Sstevel@tonic-gate 		 * the port should be automagically
43777c478bd9Sstevel@tonic-gate 		 * disabled but just in case, we do
43787c478bd9Sstevel@tonic-gate 		 * it here
43797c478bd9Sstevel@tonic-gate 		 */
43807c478bd9Sstevel@tonic-gate 		(void) hubd_disable_port(hubd, port);
43817c478bd9Sstevel@tonic-gate 
43827c478bd9Sstevel@tonic-gate 		/* ack all changes because we disabled this port */
43837c478bd9Sstevel@tonic-gate 		(void) hubd_determine_port_status(hubd,
43847c478bd9Sstevel@tonic-gate 		    port, &status, &change, HUBD_ACK_ALL_CHANGES);
43857c478bd9Sstevel@tonic-gate 
43867c478bd9Sstevel@tonic-gate 	}
43877c478bd9Sstevel@tonic-gate 
43887c478bd9Sstevel@tonic-gate 	return (USB_FAILURE);
43897c478bd9Sstevel@tonic-gate }
43907c478bd9Sstevel@tonic-gate 
43917c478bd9Sstevel@tonic-gate 
43927c478bd9Sstevel@tonic-gate /*
43937c478bd9Sstevel@tonic-gate  * hubd_get_hub_status:
43947c478bd9Sstevel@tonic-gate  */
43957c478bd9Sstevel@tonic-gate static int
43967c478bd9Sstevel@tonic-gate hubd_get_hub_status(hubd_t *hubd)
43977c478bd9Sstevel@tonic-gate {
43987c478bd9Sstevel@tonic-gate 	int		rval;
43997c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
44007c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
440135f36846Ssl 	uint16_t	stword[2];
44027c478bd9Sstevel@tonic-gate 	uint16_t	status;
44037c478bd9Sstevel@tonic-gate 	uint16_t	change;
44047c478bd9Sstevel@tonic-gate 	usb_cfg_descr_t	cfg_descr;
44057c478bd9Sstevel@tonic-gate 	size_t		cfg_length;
44067c478bd9Sstevel@tonic-gate 	uchar_t		*usb_cfg;
44077c478bd9Sstevel@tonic-gate 	uint8_t		MaxPower;
4408fef1e07eSsl 	usb_hub_descr_t	*hub_descr;
4409fef1e07eSsl 	usb_port_t	port;
44107c478bd9Sstevel@tonic-gate 
4411fef1e07eSsl 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
441235f36846Ssl 	    "hubd_get_hub_status:");
44137c478bd9Sstevel@tonic-gate 
441435f36846Ssl 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
44157c478bd9Sstevel@tonic-gate 
441635f36846Ssl 	if ((hubd_get_hub_status_words(hubd, stword)) != USB_SUCCESS) {
44177c478bd9Sstevel@tonic-gate 
44187c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
44197c478bd9Sstevel@tonic-gate 	}
442035f36846Ssl 	status = stword[0];
442135f36846Ssl 	change = stword[1];
44227c478bd9Sstevel@tonic-gate 
44237c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
44247c478bd9Sstevel@tonic-gate 
44257c478bd9Sstevel@tonic-gate 	/* Obtain the raw configuration descriptor */
44267c478bd9Sstevel@tonic-gate 	usb_cfg = usb_get_raw_cfg_data(hubd->h_dip, &cfg_length);
44277c478bd9Sstevel@tonic-gate 
44287c478bd9Sstevel@tonic-gate 	/* get configuration descriptor */
44297c478bd9Sstevel@tonic-gate 	rval = usb_parse_cfg_descr(usb_cfg, cfg_length,
4430c0f24e5bSlg 	    &cfg_descr, USB_CFG_DESCR_SIZE);
44317c478bd9Sstevel@tonic-gate 
44327c478bd9Sstevel@tonic-gate 	if (rval != USB_CFG_DESCR_SIZE) {
44337c478bd9Sstevel@tonic-gate 
4434fef1e07eSsl 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
44357c478bd9Sstevel@tonic-gate 		    "get hub configuration descriptor failed.");
44367c478bd9Sstevel@tonic-gate 
44377c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
44387c478bd9Sstevel@tonic-gate 
44397c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
44407c478bd9Sstevel@tonic-gate 	} else {
44417c478bd9Sstevel@tonic-gate 		MaxPower = cfg_descr.bMaxPower;
44427c478bd9Sstevel@tonic-gate 	}
44437c478bd9Sstevel@tonic-gate 
44447c478bd9Sstevel@tonic-gate 	/* check if local power status changed. */
44457c478bd9Sstevel@tonic-gate 	if (change & C_HUB_LOCAL_POWER_STATUS) {
44467c478bd9Sstevel@tonic-gate 
44477c478bd9Sstevel@tonic-gate 		/*
44487c478bd9Sstevel@tonic-gate 		 * local power has been lost, check the maximum
44497c478bd9Sstevel@tonic-gate 		 * power consumption of current configuration.
44507c478bd9Sstevel@tonic-gate 		 * see USB2.0 spec Table 11-12.
44517c478bd9Sstevel@tonic-gate 		 */
44527c478bd9Sstevel@tonic-gate 		if (status & HUB_LOCAL_POWER_STATUS) {
44537c478bd9Sstevel@tonic-gate 
44547c478bd9Sstevel@tonic-gate 			if (MaxPower == 0) {
44557c478bd9Sstevel@tonic-gate 
44567c478bd9Sstevel@tonic-gate 				/*
44577c478bd9Sstevel@tonic-gate 				 * Self-powered only hub. Because it could
44587c478bd9Sstevel@tonic-gate 				 * not draw any power from USB bus.
44597c478bd9Sstevel@tonic-gate 				 * It can't work well on this condition.
44607c478bd9Sstevel@tonic-gate 				 */
4461fef1e07eSsl 				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
44627c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
44637c478bd9Sstevel@tonic-gate 				    "local power has been lost, "
44647c478bd9Sstevel@tonic-gate 				    "please disconnect hub");
44657c478bd9Sstevel@tonic-gate 			} else {
44667c478bd9Sstevel@tonic-gate 
44677c478bd9Sstevel@tonic-gate 				/*
44687c478bd9Sstevel@tonic-gate 				 * Bus-powered only or self/bus-powered hub.
44697c478bd9Sstevel@tonic-gate 				 */
4470fef1e07eSsl 				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
44717c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
44727c478bd9Sstevel@tonic-gate 				    "local power has been lost,"
44737c478bd9Sstevel@tonic-gate 				    "the hub could draw %d"
44747c478bd9Sstevel@tonic-gate 				    " mA power from the USB bus.",
44757c478bd9Sstevel@tonic-gate 				    2*MaxPower);
44767c478bd9Sstevel@tonic-gate 			}
44777c478bd9Sstevel@tonic-gate 
44787c478bd9Sstevel@tonic-gate 		}
44797c478bd9Sstevel@tonic-gate 
4480fef1e07eSsl 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
44817c478bd9Sstevel@tonic-gate 		    "clearing feature C_HUB_LOCAL_POWER ");
44827c478bd9Sstevel@tonic-gate 
44837c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
44847c478bd9Sstevel@tonic-gate 		    hubd->h_default_pipe,
4485fef1e07eSsl 		    HUB_HANDLE_HUB_FEATURE_TYPE,
44867c478bd9Sstevel@tonic-gate 		    USB_REQ_CLEAR_FEATURE,
44877c478bd9Sstevel@tonic-gate 		    CFS_C_HUB_LOCAL_POWER,
44887c478bd9Sstevel@tonic-gate 		    0,
44897c478bd9Sstevel@tonic-gate 		    0,
44907c478bd9Sstevel@tonic-gate 		    NULL, 0,
44917c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4492fef1e07eSsl 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
44937c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
44947c478bd9Sstevel@tonic-gate 			    "clear feature C_HUB_LOCAL_POWER "
44957c478bd9Sstevel@tonic-gate 			    "failed (%d 0x%x %d)",
44967c478bd9Sstevel@tonic-gate 			    rval, completion_reason, cb_flags);
44977c478bd9Sstevel@tonic-gate 		}
44987c478bd9Sstevel@tonic-gate 
44997c478bd9Sstevel@tonic-gate 	}
45007c478bd9Sstevel@tonic-gate 
45017c478bd9Sstevel@tonic-gate 	if (change & C_HUB_OVER_CURRENT) {
45027c478bd9Sstevel@tonic-gate 
45037c478bd9Sstevel@tonic-gate 		if (status & HUB_OVER_CURRENT) {
4504fef1e07eSsl 
4505fef1e07eSsl 			if (usba_is_root_hub(hubd->h_dip)) {
4506fef1e07eSsl 				/*
4507fef1e07eSsl 				 * The root hub should be automatically
4508fef1e07eSsl 				 * recovered when over-current condition is
4509fef1e07eSsl 				 * cleared. But there might be exception and
4510fef1e07eSsl 				 * need user interaction to recover.
4511fef1e07eSsl 				 */
4512fef1e07eSsl 				USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
4513fef1e07eSsl 				    hubd->h_log_handle,
4514fef1e07eSsl 				    "Root hub over current condition, "
4515fef1e07eSsl 				    "please check your system to clear the "
4516fef1e07eSsl 				    "condition as soon as possible. And you "
4517fef1e07eSsl 				    "may need to reboot the system to bring "
4518fef1e07eSsl 				    "the root hub back to work if it cannot "
4519fef1e07eSsl 				    "recover automatically");
4520fef1e07eSsl 			} else {
4521fef1e07eSsl 				/*
4522fef1e07eSsl 				 * The driver would try to recover port power
4523fef1e07eSsl 				 * on over current condition. When the recovery
4524fef1e07eSsl 				 * fails, the user may still need to offline
4525fef1e07eSsl 				 * this hub in order to recover.
4526fef1e07eSsl 				 * The port power is automatically disabled,
4527fef1e07eSsl 				 * so we won't see disconnects.
4528fef1e07eSsl 				 */
4529fef1e07eSsl 				USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
4530fef1e07eSsl 				    hubd->h_log_handle,
4531fef1e07eSsl 				    "Hub global over current condition, "
4532fef1e07eSsl 				    "please disconnect the devices connected "
4533fef1e07eSsl 				    "to the hub to clear the condition. And "
4534fef1e07eSsl 				    "you may need to re-connect the hub if "
4535fef1e07eSsl 				    "the ports do not work");
4536fef1e07eSsl 			}
45377c478bd9Sstevel@tonic-gate 		}
45387c478bd9Sstevel@tonic-gate 
4539fef1e07eSsl 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
45407c478bd9Sstevel@tonic-gate 		    "clearing feature C_HUB_OVER_CURRENT");
45417c478bd9Sstevel@tonic-gate 
45427c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
45437c478bd9Sstevel@tonic-gate 		    hubd->h_default_pipe,
4544fef1e07eSsl 		    HUB_HANDLE_HUB_FEATURE_TYPE,
45457c478bd9Sstevel@tonic-gate 		    USB_REQ_CLEAR_FEATURE,
45467c478bd9Sstevel@tonic-gate 		    CFS_C_HUB_OVER_CURRENT,
45477c478bd9Sstevel@tonic-gate 		    0,
45487c478bd9Sstevel@tonic-gate 		    0,
45497c478bd9Sstevel@tonic-gate 		    NULL, 0,
45507c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4551fef1e07eSsl 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
45527c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
45537c478bd9Sstevel@tonic-gate 			    "clear feature C_HUB_OVER_CURRENT "
45547c478bd9Sstevel@tonic-gate 			    "failed (%d 0x%x %d)",
45557c478bd9Sstevel@tonic-gate 			    rval, completion_reason, cb_flags);
45567c478bd9Sstevel@tonic-gate 		}
4557fef1e07eSsl 
4558fef1e07eSsl 		/*
4559fef1e07eSsl 		 * Try to recover all port power if they are turned off.
4560fef1e07eSsl 		 * Don't do this for root hub, but rely on the root hub
4561fef1e07eSsl 		 * to recover itself.
4562fef1e07eSsl 		 */
4563fef1e07eSsl 		if (!usba_is_root_hub(hubd->h_dip)) {
4564fef1e07eSsl 
4565fef1e07eSsl 			mutex_enter(HUBD_MUTEX(hubd));
4566fef1e07eSsl 
4567fef1e07eSsl 			/*
4568fef1e07eSsl 			 * Only check the power status of the 1st port
4569fef1e07eSsl 			 * since all port power status should be the same.
4570fef1e07eSsl 			 */
4571fef1e07eSsl 			(void) hubd_determine_port_status(hubd, 1, &status,
4572fef1e07eSsl 			    &change, 0);
4573fef1e07eSsl 
4574fef1e07eSsl 			if (status & PORT_STATUS_PPS) {
4575fef1e07eSsl 
4576fef1e07eSsl 				return (USB_SUCCESS);
4577fef1e07eSsl 			}
4578fef1e07eSsl 
4579fef1e07eSsl 			hub_descr = &hubd->h_hub_descr;
4580fef1e07eSsl 
4581fef1e07eSsl 			for (port = 1; port <= hub_descr->bNbrPorts;
4582fef1e07eSsl 			    port++) {
4583fef1e07eSsl 
4584fef1e07eSsl 				(void) hubd_enable_port_power(hubd, port);
4585fef1e07eSsl 			}
4586fef1e07eSsl 
4587fef1e07eSsl 			mutex_exit(HUBD_MUTEX(hubd));
4588fef1e07eSsl 
4589fef1e07eSsl 			/*
4590fef1e07eSsl 			 * Delay some time to avoid over-current event
4591fef1e07eSsl 			 * to happen too frequently in some cases
4592fef1e07eSsl 			 */
4593fef1e07eSsl 			delay(drv_usectohz(500000));
4594fef1e07eSsl 		}
45957c478bd9Sstevel@tonic-gate 	}
45967c478bd9Sstevel@tonic-gate 
45977c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
45987c478bd9Sstevel@tonic-gate 
45997c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
46007c478bd9Sstevel@tonic-gate }
46017c478bd9Sstevel@tonic-gate 
46027c478bd9Sstevel@tonic-gate 
46037c478bd9Sstevel@tonic-gate /*
46047c478bd9Sstevel@tonic-gate  * hubd_reset_port:
46057c478bd9Sstevel@tonic-gate  */
46067c478bd9Sstevel@tonic-gate static int
46077c478bd9Sstevel@tonic-gate hubd_reset_port(hubd_t *hubd, usb_port_t port)
46087c478bd9Sstevel@tonic-gate {
46097c478bd9Sstevel@tonic-gate 	int	rval;
46107c478bd9Sstevel@tonic-gate 	usb_cr_t completion_reason;
46117c478bd9Sstevel@tonic-gate 	usb_cb_flags_t cb_flags;
46127c478bd9Sstevel@tonic-gate 	usb_port_mask_t port_mask = 1 << port;
46137c478bd9Sstevel@tonic-gate 	mblk_t	*data;
46147c478bd9Sstevel@tonic-gate 	uint16_t status;
46157c478bd9Sstevel@tonic-gate 	uint16_t change;
46167c478bd9Sstevel@tonic-gate 	int	i;
4617d3d50737SRafael Vanoni 	clock_t	delta;
46187c478bd9Sstevel@tonic-gate 
46197c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
46207c478bd9Sstevel@tonic-gate 	    "hubd_reset_port: port=%d", port);
46217c478bd9Sstevel@tonic-gate 
46227c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
46237c478bd9Sstevel@tonic-gate 
46247c478bd9Sstevel@tonic-gate 	hubd->h_port_reset_wait |= port_mask;
46257c478bd9Sstevel@tonic-gate 
46267c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
46277c478bd9Sstevel@tonic-gate 
46287c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
46297c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
463035f36846Ssl 	    HUB_HANDLE_PORT_FEATURE_TYPE,
46317c478bd9Sstevel@tonic-gate 	    USB_REQ_SET_FEATURE,
46327c478bd9Sstevel@tonic-gate 	    CFS_PORT_RESET,
46337c478bd9Sstevel@tonic-gate 	    port,
46347c478bd9Sstevel@tonic-gate 	    0,
46357c478bd9Sstevel@tonic-gate 	    NULL, 0,
46367c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4637d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
46387c478bd9Sstevel@tonic-gate 		    "reset port%d failed (%d 0x%x %d)",
46397c478bd9Sstevel@tonic-gate 		    port, completion_reason, cb_flags, rval);
46407c478bd9Sstevel@tonic-gate 
46417c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
46427c478bd9Sstevel@tonic-gate 
46437c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
46447c478bd9Sstevel@tonic-gate 	}
46457c478bd9Sstevel@tonic-gate 
46467c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
46477c478bd9Sstevel@tonic-gate 
46487c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
46497c478bd9Sstevel@tonic-gate 	    "waiting on cv for reset completion");
46507c478bd9Sstevel@tonic-gate 
46517c478bd9Sstevel@tonic-gate 	/*
46527c478bd9Sstevel@tonic-gate 	 * wait for port status change event
46537c478bd9Sstevel@tonic-gate 	 */
4654d3d50737SRafael Vanoni 	delta = drv_usectohz(hubd_device_delay / 10);
46557c478bd9Sstevel@tonic-gate 	for (i = 0; i < hubd_retry_enumerate; i++) {
46567c478bd9Sstevel@tonic-gate 		/*
46577c478bd9Sstevel@tonic-gate 		 * start polling ep1 for receiving notification on
46587c478bd9Sstevel@tonic-gate 		 * reset completion
46597c478bd9Sstevel@tonic-gate 		 */
46607c478bd9Sstevel@tonic-gate 		hubd_start_polling(hubd, HUBD_ALWAYS_START_POLLING);
46617c478bd9Sstevel@tonic-gate 
46627c478bd9Sstevel@tonic-gate 		/*
46637c478bd9Sstevel@tonic-gate 		 * sleep a max of 100ms for reset completion
46647c478bd9Sstevel@tonic-gate 		 * notification to be received
46657c478bd9Sstevel@tonic-gate 		 */
46667c478bd9Sstevel@tonic-gate 		if (hubd->h_port_reset_wait & port_mask) {
4667d3d50737SRafael Vanoni 			rval = cv_reltimedwait(&hubd->h_cv_reset_port,
4668d3d50737SRafael Vanoni 			    &hubd->h_mutex, delta, TR_CLOCK_TICK);
46697c478bd9Sstevel@tonic-gate 			if ((rval <= 0) &&
46707c478bd9Sstevel@tonic-gate 			    (hubd->h_port_reset_wait & port_mask)) {
46717c478bd9Sstevel@tonic-gate 				/* we got woken up because of a timeout */
46727c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
46737c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
46747c478bd9Sstevel@tonic-gate 				    "timeout: reset port=%d failed", port);
46757c478bd9Sstevel@tonic-gate 
46767c478bd9Sstevel@tonic-gate 				hubd->h_port_reset_wait &=  ~port_mask;
46777c478bd9Sstevel@tonic-gate 
46787c478bd9Sstevel@tonic-gate 				hubd_stop_polling(hubd);
46797c478bd9Sstevel@tonic-gate 
46807c478bd9Sstevel@tonic-gate 				return (USB_FAILURE);
46817c478bd9Sstevel@tonic-gate 			}
46827c478bd9Sstevel@tonic-gate 		}
46837c478bd9Sstevel@tonic-gate 
46847c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
46857c478bd9Sstevel@tonic-gate 		    "reset completion received");
46867c478bd9Sstevel@tonic-gate 
46877c478bd9Sstevel@tonic-gate 		hubd_stop_polling(hubd);
46887c478bd9Sstevel@tonic-gate 
46897c478bd9Sstevel@tonic-gate 		data = NULL;
46907c478bd9Sstevel@tonic-gate 
46917c478bd9Sstevel@tonic-gate 		/* check status to determine whether reset completed */
46927c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
46937c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
46947c478bd9Sstevel@tonic-gate 		    hubd->h_default_pipe,
469535f36846Ssl 		    HUB_GET_PORT_STATUS_TYPE,
46967c478bd9Sstevel@tonic-gate 		    USB_REQ_GET_STATUS,
46977c478bd9Sstevel@tonic-gate 		    0,
46987c478bd9Sstevel@tonic-gate 		    port,
46997c478bd9Sstevel@tonic-gate 		    GET_STATUS_LENGTH,
47007c478bd9Sstevel@tonic-gate 		    &data, 0,
47017c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4702d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_PORT,
47037c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
47047c478bd9Sstevel@tonic-gate 			    "get status port%d failed (%d 0x%x %d)",
47057c478bd9Sstevel@tonic-gate 			    port, completion_reason, cb_flags, rval);
47067c478bd9Sstevel@tonic-gate 
47077c478bd9Sstevel@tonic-gate 			if (data) {
47087c478bd9Sstevel@tonic-gate 				freemsg(data);
47097c478bd9Sstevel@tonic-gate 				data = NULL;
47107c478bd9Sstevel@tonic-gate 			}
47117c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
47127c478bd9Sstevel@tonic-gate 
47137c478bd9Sstevel@tonic-gate 			continue;
47147c478bd9Sstevel@tonic-gate 		}
47157c478bd9Sstevel@tonic-gate 
47167c478bd9Sstevel@tonic-gate 		status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
47177c478bd9Sstevel@tonic-gate 		change = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);
47187c478bd9Sstevel@tonic-gate 
47197c478bd9Sstevel@tonic-gate 		freemsg(data);
47207c478bd9Sstevel@tonic-gate 
47217c478bd9Sstevel@tonic-gate 		/* continue only if port is still connected */
47227c478bd9Sstevel@tonic-gate 		if (!(status & PORT_STATUS_CCS)) {
47237c478bd9Sstevel@tonic-gate 
47247c478bd9Sstevel@tonic-gate 			/* lost connection, set exit condition */
47257c478bd9Sstevel@tonic-gate 			i = hubd_retry_enumerate;
47267c478bd9Sstevel@tonic-gate 
47277c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
47287c478bd9Sstevel@tonic-gate 
47297c478bd9Sstevel@tonic-gate 			break;
47307c478bd9Sstevel@tonic-gate 		}
47317c478bd9Sstevel@tonic-gate 
47327c478bd9Sstevel@tonic-gate 		if (status & PORT_STATUS_PRS) {
47337c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
47347c478bd9Sstevel@tonic-gate 			    "port%d reset active", port);
47357c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
47367c478bd9Sstevel@tonic-gate 
47377c478bd9Sstevel@tonic-gate 			continue;
47387c478bd9Sstevel@tonic-gate 		} else {
47397c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
47407c478bd9Sstevel@tonic-gate 			    "port%d reset inactive", port);
47417c478bd9Sstevel@tonic-gate 		}
47427c478bd9Sstevel@tonic-gate 
47437c478bd9Sstevel@tonic-gate 		if (change & PORT_CHANGE_PRSC) {
47447c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
47457c478bd9Sstevel@tonic-gate 			    "clearing feature CFS_C_PORT_RESET");
47467c478bd9Sstevel@tonic-gate 
47477c478bd9Sstevel@tonic-gate 			if (usb_pipe_sync_ctrl_xfer(hubd->h_dip,
47487c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
474935f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
47507c478bd9Sstevel@tonic-gate 			    USB_REQ_CLEAR_FEATURE,
47517c478bd9Sstevel@tonic-gate 			    CFS_C_PORT_RESET,
47527c478bd9Sstevel@tonic-gate 			    port,
47537c478bd9Sstevel@tonic-gate 			    0,
47547c478bd9Sstevel@tonic-gate 			    NULL, 0,
47557c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0) != USB_SUCCESS) {
47567c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
47577c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
47587c478bd9Sstevel@tonic-gate 				    "clear feature CFS_C_PORT_RESET"
47597c478bd9Sstevel@tonic-gate 				    " port%d failed (%d 0x%x %d)",
47607c478bd9Sstevel@tonic-gate 				    port, completion_reason, cb_flags, rval);
47617c478bd9Sstevel@tonic-gate 			}
47627c478bd9Sstevel@tonic-gate 		}
47637c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
47647c478bd9Sstevel@tonic-gate 
47657c478bd9Sstevel@tonic-gate 		break;
47667c478bd9Sstevel@tonic-gate 	}
47677c478bd9Sstevel@tonic-gate 
47687c478bd9Sstevel@tonic-gate 	if (i >= hubd_retry_enumerate) {
47697c478bd9Sstevel@tonic-gate 		/* port reset has failed */
47707c478bd9Sstevel@tonic-gate 		rval = USB_FAILURE;
47717c478bd9Sstevel@tonic-gate 	}
47727c478bd9Sstevel@tonic-gate 
47737c478bd9Sstevel@tonic-gate 	return (rval);
47747c478bd9Sstevel@tonic-gate }
47757c478bd9Sstevel@tonic-gate 
47767c478bd9Sstevel@tonic-gate 
47777c478bd9Sstevel@tonic-gate /*
47787c478bd9Sstevel@tonic-gate  * hubd_enable_port:
47797c478bd9Sstevel@tonic-gate  *	this may fail if the hub as been disconnected
47807c478bd9Sstevel@tonic-gate  */
47817c478bd9Sstevel@tonic-gate static int
47827c478bd9Sstevel@tonic-gate hubd_enable_port(hubd_t *hubd, usb_port_t port)
47837c478bd9Sstevel@tonic-gate {
47847c478bd9Sstevel@tonic-gate 	int	rval;
47857c478bd9Sstevel@tonic-gate 	usb_cr_t completion_reason;
47867c478bd9Sstevel@tonic-gate 	usb_cb_flags_t cb_flags;
47877c478bd9Sstevel@tonic-gate 
47887c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
47897c478bd9Sstevel@tonic-gate 	    "hubd_enable_port: port=%d", port);
47907c478bd9Sstevel@tonic-gate 
47917c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
47927c478bd9Sstevel@tonic-gate 
47937c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
47947c478bd9Sstevel@tonic-gate 
47957c478bd9Sstevel@tonic-gate 	/* Do not issue a SetFeature(PORT_ENABLE) on external hubs */
47967c478bd9Sstevel@tonic-gate 	if (!usba_is_root_hub(hubd->h_dip)) {
47977c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
47987c478bd9Sstevel@tonic-gate 
47997c478bd9Sstevel@tonic-gate 		return (USB_SUCCESS);
48007c478bd9Sstevel@tonic-gate 	}
48017c478bd9Sstevel@tonic-gate 
48027c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
48037c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
480435f36846Ssl 	    HUB_HANDLE_PORT_FEATURE_TYPE,
48057c478bd9Sstevel@tonic-gate 	    USB_REQ_SET_FEATURE,
48067c478bd9Sstevel@tonic-gate 	    CFS_PORT_ENABLE,
48077c478bd9Sstevel@tonic-gate 	    port,
48087c478bd9Sstevel@tonic-gate 	    0,
48097c478bd9Sstevel@tonic-gate 	    NULL, 0,
48107c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
48117c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
48127c478bd9Sstevel@tonic-gate 		    "enable port%d failed (%d 0x%x %d)",
48137c478bd9Sstevel@tonic-gate 		    port, completion_reason, cb_flags, rval);
48147c478bd9Sstevel@tonic-gate 	}
48157c478bd9Sstevel@tonic-gate 
48167c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
48177c478bd9Sstevel@tonic-gate 
48187c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
48197c478bd9Sstevel@tonic-gate 	    "enabling port done");
48207c478bd9Sstevel@tonic-gate 
48217c478bd9Sstevel@tonic-gate 	return (rval);
48227c478bd9Sstevel@tonic-gate }
48237c478bd9Sstevel@tonic-gate 
48247c478bd9Sstevel@tonic-gate 
48257c478bd9Sstevel@tonic-gate /*
48267c478bd9Sstevel@tonic-gate  * hubd_disable_port
48277c478bd9Sstevel@tonic-gate  */
48287c478bd9Sstevel@tonic-gate static int
48297c478bd9Sstevel@tonic-gate hubd_disable_port(hubd_t *hubd, usb_port_t port)
48307c478bd9Sstevel@tonic-gate {
48317c478bd9Sstevel@tonic-gate 	int	rval;
48327c478bd9Sstevel@tonic-gate 	usb_cr_t completion_reason;
48337c478bd9Sstevel@tonic-gate 	usb_cb_flags_t cb_flags;
48347c478bd9Sstevel@tonic-gate 
48357c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
48367c478bd9Sstevel@tonic-gate 	    "hubd_disable_port: port=%d", port);
48377c478bd9Sstevel@tonic-gate 
48387c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
48397c478bd9Sstevel@tonic-gate 
48407c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
48417c478bd9Sstevel@tonic-gate 
48427c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
48437c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
484435f36846Ssl 	    HUB_HANDLE_PORT_FEATURE_TYPE,
48457c478bd9Sstevel@tonic-gate 	    USB_REQ_CLEAR_FEATURE,
48467c478bd9Sstevel@tonic-gate 	    CFS_PORT_ENABLE,
48477c478bd9Sstevel@tonic-gate 	    port,
48487c478bd9Sstevel@tonic-gate 	    0,
48497c478bd9Sstevel@tonic-gate 	    NULL, 0,
48507c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
48517c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
48527c478bd9Sstevel@tonic-gate 		    "disable port%d failed (%d 0x%x %d)", port,
48537c478bd9Sstevel@tonic-gate 		    completion_reason, cb_flags, rval);
48547c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
48557c478bd9Sstevel@tonic-gate 
48567c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
48577c478bd9Sstevel@tonic-gate 	}
48587c478bd9Sstevel@tonic-gate 
48597c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
48607c478bd9Sstevel@tonic-gate 	    "clearing feature CFS_C_PORT_ENABLE");
48617c478bd9Sstevel@tonic-gate 
48627c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
48637c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
486435f36846Ssl 	    HUB_HANDLE_PORT_FEATURE_TYPE,
48657c478bd9Sstevel@tonic-gate 	    USB_REQ_CLEAR_FEATURE,
48667c478bd9Sstevel@tonic-gate 	    CFS_C_PORT_ENABLE,
48677c478bd9Sstevel@tonic-gate 	    port,
48687c478bd9Sstevel@tonic-gate 	    0,
48697c478bd9Sstevel@tonic-gate 	    NULL, 0,
48707c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
48717c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PORT,
48727c478bd9Sstevel@tonic-gate 		    hubd->h_log_handle,
48737c478bd9Sstevel@tonic-gate 		    "clear feature CFS_C_PORT_ENABLE port%d failed "
48747c478bd9Sstevel@tonic-gate 		    "(%d 0x%x %d)",
48757c478bd9Sstevel@tonic-gate 		    port, completion_reason, cb_flags, rval);
48767c478bd9Sstevel@tonic-gate 
48777c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
48787c478bd9Sstevel@tonic-gate 
48797c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
48807c478bd9Sstevel@tonic-gate 	}
48817c478bd9Sstevel@tonic-gate 
48827c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
48837c478bd9Sstevel@tonic-gate 
48847c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
48857c478bd9Sstevel@tonic-gate }
48867c478bd9Sstevel@tonic-gate 
48877c478bd9Sstevel@tonic-gate 
48887c478bd9Sstevel@tonic-gate /*
48897c478bd9Sstevel@tonic-gate  * hubd_determine_port_status:
48907c478bd9Sstevel@tonic-gate  */
48917c478bd9Sstevel@tonic-gate static int
48927c478bd9Sstevel@tonic-gate hubd_determine_port_status(hubd_t *hubd, usb_port_t port,
48937c478bd9Sstevel@tonic-gate 		uint16_t *status, uint16_t *change, uint_t ack_flag)
48947c478bd9Sstevel@tonic-gate {
48957c478bd9Sstevel@tonic-gate 	int rval;
48967c478bd9Sstevel@tonic-gate 	mblk_t	*data = NULL;
48977c478bd9Sstevel@tonic-gate 	usb_cr_t completion_reason;
48987c478bd9Sstevel@tonic-gate 	usb_cb_flags_t cb_flags;
48997c478bd9Sstevel@tonic-gate 
49007c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
49017c478bd9Sstevel@tonic-gate 	    "hubd_determine_port_status: port=%d, state=0x%x ack=0x%x", port,
49027c478bd9Sstevel@tonic-gate 	    hubd->h_port_state[port], ack_flag);
49037c478bd9Sstevel@tonic-gate 
49047c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
49057c478bd9Sstevel@tonic-gate 
49067c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
49077c478bd9Sstevel@tonic-gate 
49087c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
49097c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
491035f36846Ssl 	    HUB_GET_PORT_STATUS_TYPE,
49117c478bd9Sstevel@tonic-gate 	    USB_REQ_GET_STATUS,
49127c478bd9Sstevel@tonic-gate 	    0,
49137c478bd9Sstevel@tonic-gate 	    port,
49147c478bd9Sstevel@tonic-gate 	    GET_STATUS_LENGTH,
49157c478bd9Sstevel@tonic-gate 	    &data, 0,
49167c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
49177c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
49187c478bd9Sstevel@tonic-gate 		    "port=%d get status failed (%d 0x%x %d)",
49197c478bd9Sstevel@tonic-gate 		    port, completion_reason, cb_flags, rval);
49207c478bd9Sstevel@tonic-gate 
49217c478bd9Sstevel@tonic-gate 		if (data) {
49227c478bd9Sstevel@tonic-gate 			freemsg(data);
49237c478bd9Sstevel@tonic-gate 		}
49247c478bd9Sstevel@tonic-gate 
49257c478bd9Sstevel@tonic-gate 		*status = *change = 0;
49267c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
49277c478bd9Sstevel@tonic-gate 
49287c478bd9Sstevel@tonic-gate 		return (rval);
49297c478bd9Sstevel@tonic-gate 	}
49307c478bd9Sstevel@tonic-gate 
49317c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
4932d29f5a71Szhigang lu - Sun Microsystems - Beijing China 	if (MBLKL(data) != GET_STATUS_LENGTH) {
49337c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4934112116d8Sfb 		    "port %d: length incorrect %ld",
4935d29f5a71Szhigang lu - Sun Microsystems - Beijing China 		    port, MBLKL(data));
49367c478bd9Sstevel@tonic-gate 		freemsg(data);
49377c478bd9Sstevel@tonic-gate 		*status = *change = 0;
49387c478bd9Sstevel@tonic-gate 
49397c478bd9Sstevel@tonic-gate 		return (rval);
49407c478bd9Sstevel@tonic-gate 	}
49417c478bd9Sstevel@tonic-gate 
49427c478bd9Sstevel@tonic-gate 
49437c478bd9Sstevel@tonic-gate 	*status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
49447c478bd9Sstevel@tonic-gate 	*change = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);
49457c478bd9Sstevel@tonic-gate 
49467c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49477c478bd9Sstevel@tonic-gate 	    "port%d status=0x%x, change=0x%x", port, *status, *change);
49487c478bd9Sstevel@tonic-gate 
49497c478bd9Sstevel@tonic-gate 	freemsg(data);
49507c478bd9Sstevel@tonic-gate 
49517c478bd9Sstevel@tonic-gate 	if (*status & PORT_STATUS_CCS) {
49527c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49537c478bd9Sstevel@tonic-gate 		    "port%d connected", port);
49547c478bd9Sstevel@tonic-gate 
49557c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_STATUS_CCS & ack_flag);
49567c478bd9Sstevel@tonic-gate 	} else {
49577c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49587c478bd9Sstevel@tonic-gate 		    "port%d disconnected", port);
49597c478bd9Sstevel@tonic-gate 
49607c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_STATUS_CCS & ack_flag);
49617c478bd9Sstevel@tonic-gate 	}
49627c478bd9Sstevel@tonic-gate 
49637c478bd9Sstevel@tonic-gate 	if (*status & PORT_STATUS_PES) {
49647c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49657c478bd9Sstevel@tonic-gate 		    "port%d enabled", port);
49667c478bd9Sstevel@tonic-gate 
49677c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_STATUS_PES & ack_flag);
49687c478bd9Sstevel@tonic-gate 	} else {
49697c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49707c478bd9Sstevel@tonic-gate 		    "port%d disabled", port);
49717c478bd9Sstevel@tonic-gate 
49727c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_STATUS_PES & ack_flag);
49737c478bd9Sstevel@tonic-gate 	}
49747c478bd9Sstevel@tonic-gate 
49757c478bd9Sstevel@tonic-gate 	if (*status & PORT_STATUS_PSS) {
49767c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49777c478bd9Sstevel@tonic-gate 		    "port%d suspended", port);
49787c478bd9Sstevel@tonic-gate 
49797c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_STATUS_PSS & ack_flag);
49807c478bd9Sstevel@tonic-gate 	} else {
49817c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49827c478bd9Sstevel@tonic-gate 		    "port%d not suspended", port);
49837c478bd9Sstevel@tonic-gate 
49847c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_STATUS_PSS & ack_flag);
49857c478bd9Sstevel@tonic-gate 	}
49867c478bd9Sstevel@tonic-gate 
49877c478bd9Sstevel@tonic-gate 	if (*change & PORT_CHANGE_PRSC) {
49887c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
49897c478bd9Sstevel@tonic-gate 		    "port%d reset completed", port);
49907c478bd9Sstevel@tonic-gate 
49917c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_CHANGE_PRSC & ack_flag);
49927c478bd9Sstevel@tonic-gate 	} else {
49937c478bd9Sstevel@tonic-gate 
49947c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_CHANGE_PRSC & ack_flag);
49957c478bd9Sstevel@tonic-gate 	}
49967c478bd9Sstevel@tonic-gate 
49977c478bd9Sstevel@tonic-gate 	if (*status & PORT_STATUS_POCI) {
4998d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4999d291d9f2Sfrits 		    "port%d overcurrent!", port);
50007c478bd9Sstevel@tonic-gate 
50017c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_STATUS_POCI & ack_flag);
50027c478bd9Sstevel@tonic-gate 	} else {
50037c478bd9Sstevel@tonic-gate 
50047c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_STATUS_POCI & ack_flag);
50057c478bd9Sstevel@tonic-gate 	}
50067c478bd9Sstevel@tonic-gate 
50077c478bd9Sstevel@tonic-gate 	if (*status & PORT_STATUS_PRS) {
50087c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50097c478bd9Sstevel@tonic-gate 		    "port%d reset active", port);
50107c478bd9Sstevel@tonic-gate 
50117c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_STATUS_PRS & ack_flag);
50127c478bd9Sstevel@tonic-gate 	} else {
50137c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50147c478bd9Sstevel@tonic-gate 		    "port%d reset inactive", port);
50157c478bd9Sstevel@tonic-gate 
50167c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_STATUS_PRS & ack_flag);
50177c478bd9Sstevel@tonic-gate 	}
50187c478bd9Sstevel@tonic-gate 	if (*status & PORT_STATUS_PPS) {
50197c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50207c478bd9Sstevel@tonic-gate 		    "port%d power on", port);
50217c478bd9Sstevel@tonic-gate 
50227c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_STATUS_PPS & ack_flag);
50237c478bd9Sstevel@tonic-gate 	} else {
50247c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50257c478bd9Sstevel@tonic-gate 		    "port%d power off", port);
50267c478bd9Sstevel@tonic-gate 
50277c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_STATUS_PPS & ack_flag);
50287c478bd9Sstevel@tonic-gate 	}
50297c478bd9Sstevel@tonic-gate 	if (*status & PORT_STATUS_LSDA) {
50307c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50317c478bd9Sstevel@tonic-gate 		    "port%d low speed", port);
50327c478bd9Sstevel@tonic-gate 
50337c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= (PORT_STATUS_LSDA & ack_flag);
50347c478bd9Sstevel@tonic-gate 	} else {
50357c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~(PORT_STATUS_LSDA & ack_flag);
50367c478bd9Sstevel@tonic-gate 		if (*status & PORT_STATUS_HSDA) {
50377c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT,
50387c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle, "port%d "
50397c478bd9Sstevel@tonic-gate 			    "high speed", port);
50407c478bd9Sstevel@tonic-gate 
50417c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] |=
5042c0f24e5bSlg 			    (PORT_STATUS_HSDA & ack_flag);
50437c478bd9Sstevel@tonic-gate 		} else {
50447c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT,
50457c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle, "port%d "
50467c478bd9Sstevel@tonic-gate 			    "full speed", port);
50477c478bd9Sstevel@tonic-gate 
50487c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] &=
5049c0f24e5bSlg 			    ~(PORT_STATUS_HSDA & ack_flag);
50507c478bd9Sstevel@tonic-gate 		}
50517c478bd9Sstevel@tonic-gate 	}
50527c478bd9Sstevel@tonic-gate 
50537c478bd9Sstevel@tonic-gate 	/*
50547c478bd9Sstevel@tonic-gate 	 * Acknowledge connection, enable, reset status
50557c478bd9Sstevel@tonic-gate 	 */
50567c478bd9Sstevel@tonic-gate 	if (ack_flag) {
50577c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
50587c478bd9Sstevel@tonic-gate 		if (*change & PORT_CHANGE_CSC & ack_flag) {
50597c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50607c478bd9Sstevel@tonic-gate 			    "clearing feature CFS_C_PORT_CONNECTION");
50617c478bd9Sstevel@tonic-gate 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
50627c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
506335f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
50647c478bd9Sstevel@tonic-gate 			    USB_REQ_CLEAR_FEATURE,
50657c478bd9Sstevel@tonic-gate 			    CFS_C_PORT_CONNECTION,
50667c478bd9Sstevel@tonic-gate 			    port,
50677c478bd9Sstevel@tonic-gate 			    0, NULL, 0,
50687c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0)) !=
50697c478bd9Sstevel@tonic-gate 			    USB_SUCCESS) {
50707c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
50717c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
50727c478bd9Sstevel@tonic-gate 				    "clear feature CFS_C_PORT_CONNECTION"
50737c478bd9Sstevel@tonic-gate 				    " port%d failed (%d 0x%x %d)",
50747c478bd9Sstevel@tonic-gate 				    port, completion_reason, cb_flags, rval);
50757c478bd9Sstevel@tonic-gate 			}
50767c478bd9Sstevel@tonic-gate 		}
50777c478bd9Sstevel@tonic-gate 		if (*change & PORT_CHANGE_PESC & ack_flag) {
50787c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50797c478bd9Sstevel@tonic-gate 			    "clearing feature CFS_C_PORT_ENABLE");
50807c478bd9Sstevel@tonic-gate 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
50817c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
508235f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
50837c478bd9Sstevel@tonic-gate 			    USB_REQ_CLEAR_FEATURE,
50847c478bd9Sstevel@tonic-gate 			    CFS_C_PORT_ENABLE,
50857c478bd9Sstevel@tonic-gate 			    port,
50867c478bd9Sstevel@tonic-gate 			    0, NULL, 0,
50877c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0)) !=
50887c478bd9Sstevel@tonic-gate 			    USB_SUCCESS) {
50897c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
50907c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
50917c478bd9Sstevel@tonic-gate 				    "clear feature CFS_C_PORT_ENABLE"
50927c478bd9Sstevel@tonic-gate 				    " port%d failed (%d 0x%x %d)",
50937c478bd9Sstevel@tonic-gate 				    port, completion_reason, cb_flags, rval);
50947c478bd9Sstevel@tonic-gate 			}
50957c478bd9Sstevel@tonic-gate 		}
50967c478bd9Sstevel@tonic-gate 		if (*change & PORT_CHANGE_PSSC & ack_flag) {
50977c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
50987c478bd9Sstevel@tonic-gate 			    "clearing feature CFS_C_PORT_SUSPEND");
50997c478bd9Sstevel@tonic-gate 
51007c478bd9Sstevel@tonic-gate 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
51017c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
510235f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
51037c478bd9Sstevel@tonic-gate 			    USB_REQ_CLEAR_FEATURE,
51047c478bd9Sstevel@tonic-gate 			    CFS_C_PORT_SUSPEND,
51057c478bd9Sstevel@tonic-gate 			    port,
51067c478bd9Sstevel@tonic-gate 			    0, NULL, 0,
51077c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0)) !=
51087c478bd9Sstevel@tonic-gate 			    USB_SUCCESS) {
51097c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
51107c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
51117c478bd9Sstevel@tonic-gate 				    "clear feature CFS_C_PORT_SUSPEND"
51127c478bd9Sstevel@tonic-gate 				    " port%d failed (%d 0x%x %d)",
51137c478bd9Sstevel@tonic-gate 				    port, completion_reason, cb_flags, rval);
51147c478bd9Sstevel@tonic-gate 			}
51157c478bd9Sstevel@tonic-gate 		}
51167c478bd9Sstevel@tonic-gate 		if (*change & PORT_CHANGE_OCIC & ack_flag) {
51177c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
51187c478bd9Sstevel@tonic-gate 			    "clearing feature CFS_C_PORT_OVER_CURRENT");
51197c478bd9Sstevel@tonic-gate 
51207c478bd9Sstevel@tonic-gate 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
51217c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
512235f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
51237c478bd9Sstevel@tonic-gate 			    USB_REQ_CLEAR_FEATURE,
51247c478bd9Sstevel@tonic-gate 			    CFS_C_PORT_OVER_CURRENT,
51257c478bd9Sstevel@tonic-gate 			    port,
51267c478bd9Sstevel@tonic-gate 			    0, NULL, 0,
51277c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0)) !=
51287c478bd9Sstevel@tonic-gate 			    USB_SUCCESS) {
51297c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
51307c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
51317c478bd9Sstevel@tonic-gate 				    "clear feature CFS_C_PORT_OVER_CURRENT"
51327c478bd9Sstevel@tonic-gate 				    " port%d failed (%d 0x%x %d)",
51337c478bd9Sstevel@tonic-gate 				    port, completion_reason, cb_flags, rval);
51347c478bd9Sstevel@tonic-gate 			}
51357c478bd9Sstevel@tonic-gate 		}
51367c478bd9Sstevel@tonic-gate 		if (*change & PORT_CHANGE_PRSC & ack_flag) {
51377c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
51387c478bd9Sstevel@tonic-gate 			    "clearing feature CFS_C_PORT_RESET");
51397c478bd9Sstevel@tonic-gate 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
51407c478bd9Sstevel@tonic-gate 			    hubd->h_default_pipe,
514135f36846Ssl 			    HUB_HANDLE_PORT_FEATURE_TYPE,
51427c478bd9Sstevel@tonic-gate 			    USB_REQ_CLEAR_FEATURE,
51437c478bd9Sstevel@tonic-gate 			    CFS_C_PORT_RESET,
51447c478bd9Sstevel@tonic-gate 			    port,
51457c478bd9Sstevel@tonic-gate 			    0, NULL, 0,
51467c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0)) !=
51477c478bd9Sstevel@tonic-gate 			    USB_SUCCESS) {
51487c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
51497c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
51507c478bd9Sstevel@tonic-gate 				    "clear feature CFS_C_PORT_RESET"
51517c478bd9Sstevel@tonic-gate 				    " port%d failed (%d 0x%x %d)",
51527c478bd9Sstevel@tonic-gate 				    port, completion_reason, cb_flags, rval);
51537c478bd9Sstevel@tonic-gate 			}
51547c478bd9Sstevel@tonic-gate 		}
51557c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
51567c478bd9Sstevel@tonic-gate 	}
51577c478bd9Sstevel@tonic-gate 
51587c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
51597c478bd9Sstevel@tonic-gate 	    "new port%d state 0x%x", port, hubd->h_port_state[port]);
51607c478bd9Sstevel@tonic-gate 
51617c478bd9Sstevel@tonic-gate 
51627c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
51637c478bd9Sstevel@tonic-gate }
51647c478bd9Sstevel@tonic-gate 
51657c478bd9Sstevel@tonic-gate 
51667c478bd9Sstevel@tonic-gate /*
51677c478bd9Sstevel@tonic-gate  * hubd_recover_disabled_port
51687c478bd9Sstevel@tonic-gate  * if the port got disabled because of an error
51697c478bd9Sstevel@tonic-gate  * enable it. If hub doesn't suport enable port,
51707c478bd9Sstevel@tonic-gate  * reset the port to bring the device to life again
51717c478bd9Sstevel@tonic-gate  */
51727c478bd9Sstevel@tonic-gate static int
51737c478bd9Sstevel@tonic-gate hubd_recover_disabled_port(hubd_t *hubd, usb_port_t port)
51747c478bd9Sstevel@tonic-gate {
51757c478bd9Sstevel@tonic-gate 	uint16_t	status;
51767c478bd9Sstevel@tonic-gate 	uint16_t	change;
51777c478bd9Sstevel@tonic-gate 	int		rval = USB_FAILURE;
51787c478bd9Sstevel@tonic-gate 
51797c478bd9Sstevel@tonic-gate 	/* first try enabling the port */
51807c478bd9Sstevel@tonic-gate 	(void) hubd_enable_port(hubd, port);
51817c478bd9Sstevel@tonic-gate 
51827c478bd9Sstevel@tonic-gate 	/* read the port status */
51837c478bd9Sstevel@tonic-gate 	(void) hubd_determine_port_status(hubd, port, &status, &change,
51847c478bd9Sstevel@tonic-gate 	    PORT_CHANGE_PESC);
51857c478bd9Sstevel@tonic-gate 
51867c478bd9Sstevel@tonic-gate 	if (status & PORT_STATUS_PES) {
51877c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5188c0f24e5bSlg 		    "Port%d now Enabled", port);
51897c478bd9Sstevel@tonic-gate 	} else if (status & PORT_STATUS_CCS) {
51907c478bd9Sstevel@tonic-gate 		/* first post a disconnect event to the child */
51917c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
51927c478bd9Sstevel@tonic-gate 		hubd_post_event(hubd, port, USBA_EVENT_TAG_HOT_REMOVAL);
51937c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
51947c478bd9Sstevel@tonic-gate 
51957c478bd9Sstevel@tonic-gate 		/* then reset the port and recover the device */
51967c478bd9Sstevel@tonic-gate 		rval = hubd_handle_port_connect(hubd, port);
51977c478bd9Sstevel@tonic-gate 
51987c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5199c0f24e5bSlg 		    "Port%d now Enabled by force", port);
52007c478bd9Sstevel@tonic-gate 	}
52017c478bd9Sstevel@tonic-gate 
52027c478bd9Sstevel@tonic-gate 	return (rval);
52037c478bd9Sstevel@tonic-gate }
52047c478bd9Sstevel@tonic-gate 
52057c478bd9Sstevel@tonic-gate 
52067c478bd9Sstevel@tonic-gate /*
52077c478bd9Sstevel@tonic-gate  * hubd_enable_all_port_power:
52087c478bd9Sstevel@tonic-gate  */
52097c478bd9Sstevel@tonic-gate static int
52107c478bd9Sstevel@tonic-gate hubd_enable_all_port_power(hubd_t *hubd)
52117c478bd9Sstevel@tonic-gate {
52127c478bd9Sstevel@tonic-gate 	usb_hub_descr_t	*hub_descr;
52137c478bd9Sstevel@tonic-gate 	int		wait;
52147c478bd9Sstevel@tonic-gate 	usb_port_t	port;
52157c478bd9Sstevel@tonic-gate 	uint_t		retry;
52167c478bd9Sstevel@tonic-gate 	uint16_t	status;
52177c478bd9Sstevel@tonic-gate 	uint16_t	change;
52187c478bd9Sstevel@tonic-gate 
52197c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
52207c478bd9Sstevel@tonic-gate 	    "hubd_enable_all_port_power");
52217c478bd9Sstevel@tonic-gate 
52227c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
52237c478bd9Sstevel@tonic-gate 
52247c478bd9Sstevel@tonic-gate 	hub_descr = &hubd->h_hub_descr;
52257c478bd9Sstevel@tonic-gate 
52267c478bd9Sstevel@tonic-gate 	/*
52277c478bd9Sstevel@tonic-gate 	 * According to section 11.11 of USB, for hubs with no power
52287c478bd9Sstevel@tonic-gate 	 * switches, bPwrOn2PwrGood is zero. But we wait for some
52297c478bd9Sstevel@tonic-gate 	 * arbitrary time to enable power to become stable.
52307c478bd9Sstevel@tonic-gate 	 *
52317c478bd9Sstevel@tonic-gate 	 * If an hub supports port power switching, we need to wait
52327c478bd9Sstevel@tonic-gate 	 * at least 20ms before accessing corresponding usb port.
52337c478bd9Sstevel@tonic-gate 	 */
52347c478bd9Sstevel@tonic-gate 	if ((hub_descr->wHubCharacteristics &
52357c478bd9Sstevel@tonic-gate 	    HUB_CHARS_NO_POWER_SWITCHING) || (!hub_descr->bPwrOn2PwrGood)) {
52367c478bd9Sstevel@tonic-gate 		wait = hubd_device_delay / 10;
52377c478bd9Sstevel@tonic-gate 	} else {
52387c478bd9Sstevel@tonic-gate 		wait = max(HUB_DEFAULT_POPG,
52397c478bd9Sstevel@tonic-gate 		    hub_descr->bPwrOn2PwrGood) * 2 * 1000;
52407c478bd9Sstevel@tonic-gate 	}
52417c478bd9Sstevel@tonic-gate 
52427c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
52437c478bd9Sstevel@tonic-gate 	    "hubd_enable_all_port_power: popg=%d wait=%d",
52447c478bd9Sstevel@tonic-gate 	    hub_descr->bPwrOn2PwrGood, wait);
52457c478bd9Sstevel@tonic-gate 
52467c478bd9Sstevel@tonic-gate 	/*
52477c478bd9Sstevel@tonic-gate 	 * Enable power per port. we ignore gang power and power mask
52487c478bd9Sstevel@tonic-gate 	 * and always enable all ports one by one.
52497c478bd9Sstevel@tonic-gate 	 */
52507c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hub_descr->bNbrPorts; port++) {
52517c478bd9Sstevel@tonic-gate 		/*
52527c478bd9Sstevel@tonic-gate 		 * Transition the port from the Powered Off to the
52537c478bd9Sstevel@tonic-gate 		 * Disconnected state by supplying power to the port.
52547c478bd9Sstevel@tonic-gate 		 */
52557c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_PORT,
52567c478bd9Sstevel@tonic-gate 		    hubd->h_log_handle,
52577c478bd9Sstevel@tonic-gate 		    "hubd_enable_all_port_power: power port=%d", port);
52587c478bd9Sstevel@tonic-gate 
52597c478bd9Sstevel@tonic-gate 		(void) hubd_enable_port_power(hubd, port);
52607c478bd9Sstevel@tonic-gate 	}
52617c478bd9Sstevel@tonic-gate 
52627c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
52637c478bd9Sstevel@tonic-gate 	delay(drv_usectohz(wait));
52647c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
52657c478bd9Sstevel@tonic-gate 
52667c478bd9Sstevel@tonic-gate 	/* For retry if any, use some extra delay */
52677c478bd9Sstevel@tonic-gate 	wait = max(wait, hubd_device_delay / 10);
52687c478bd9Sstevel@tonic-gate 
52697c478bd9Sstevel@tonic-gate 	/* Check each port power status for a given usb hub */
52707c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hub_descr->bNbrPorts; port++) {
52717c478bd9Sstevel@tonic-gate 
52727c478bd9Sstevel@tonic-gate 		/* Get port status */
52737c478bd9Sstevel@tonic-gate 		(void) hubd_determine_port_status(hubd, port,
52747c478bd9Sstevel@tonic-gate 		    &status, &change, 0);
52757c478bd9Sstevel@tonic-gate 
52767c478bd9Sstevel@tonic-gate 		for (retry = 0; ((!(status & PORT_STATUS_PPS)) &&
52777c478bd9Sstevel@tonic-gate 		    (retry < HUBD_PORT_RETRY)); retry++) {
52787c478bd9Sstevel@tonic-gate 
52797c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
52807c478bd9Sstevel@tonic-gate 			    "Retry is in progress %d: port %d status %d",
52817c478bd9Sstevel@tonic-gate 			    retry, port, status);
52827c478bd9Sstevel@tonic-gate 
52837c478bd9Sstevel@tonic-gate 			(void) hubd_enable_port_power(hubd, port);
52847c478bd9Sstevel@tonic-gate 
52857c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
52867c478bd9Sstevel@tonic-gate 			delay(drv_usectohz(wait));
52877c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
52887c478bd9Sstevel@tonic-gate 
52897c478bd9Sstevel@tonic-gate 			/* Get port status */
52907c478bd9Sstevel@tonic-gate 			(void) hubd_determine_port_status(hubd, port,
52917c478bd9Sstevel@tonic-gate 			    &status, &change, 0);
52927c478bd9Sstevel@tonic-gate 		}
52937c478bd9Sstevel@tonic-gate 
52947c478bd9Sstevel@tonic-gate 		/* Print warning message if port has no power */
52957c478bd9Sstevel@tonic-gate 		if (!(status & PORT_STATUS_PPS)) {
52967c478bd9Sstevel@tonic-gate 
5297d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
52987c478bd9Sstevel@tonic-gate 			    "hubd_enable_all_port_power: port %d power-on "
52997c478bd9Sstevel@tonic-gate 			    "failed, port status 0x%x", port, status);
53007c478bd9Sstevel@tonic-gate 		}
53017c478bd9Sstevel@tonic-gate 	}
53027c478bd9Sstevel@tonic-gate 
53037c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
53047c478bd9Sstevel@tonic-gate }
53057c478bd9Sstevel@tonic-gate 
53067c478bd9Sstevel@tonic-gate 
53077c478bd9Sstevel@tonic-gate /*
53087c478bd9Sstevel@tonic-gate  * hubd_enable_port_power:
53097c478bd9Sstevel@tonic-gate  *	enable individual port power
53107c478bd9Sstevel@tonic-gate  */
53117c478bd9Sstevel@tonic-gate static int
53127c478bd9Sstevel@tonic-gate hubd_enable_port_power(hubd_t *hubd, usb_port_t port)
53137c478bd9Sstevel@tonic-gate {
53147c478bd9Sstevel@tonic-gate 	int		rval;
53157c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
53167c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
53177c478bd9Sstevel@tonic-gate 
53187c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
53197c478bd9Sstevel@tonic-gate 	    "hubd_enable_port_power: port=%d", port);
53207c478bd9Sstevel@tonic-gate 
53217c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
53227c478bd9Sstevel@tonic-gate 	ASSERT(hubd->h_default_pipe != 0);
53237c478bd9Sstevel@tonic-gate 
53247c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
53257c478bd9Sstevel@tonic-gate 
53267c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
53277c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
532835f36846Ssl 	    HUB_HANDLE_PORT_FEATURE_TYPE,
53297c478bd9Sstevel@tonic-gate 	    USB_REQ_SET_FEATURE,
53307c478bd9Sstevel@tonic-gate 	    CFS_PORT_POWER,
53317c478bd9Sstevel@tonic-gate 	    port,
53327c478bd9Sstevel@tonic-gate 	    0, NULL, 0,
53337c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
53347c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
53357c478bd9Sstevel@tonic-gate 		    "set port power failed (%d 0x%x %d)",
53367c478bd9Sstevel@tonic-gate 		    completion_reason, cb_flags, rval);
53377c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
53387c478bd9Sstevel@tonic-gate 
53397c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
53407c478bd9Sstevel@tonic-gate 	} else {
53417c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
53427c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] |= PORT_STATUS_PPS;
53437c478bd9Sstevel@tonic-gate 
53447c478bd9Sstevel@tonic-gate 		return (USB_SUCCESS);
53457c478bd9Sstevel@tonic-gate 	}
53467c478bd9Sstevel@tonic-gate }
53477c478bd9Sstevel@tonic-gate 
53487c478bd9Sstevel@tonic-gate 
53497c478bd9Sstevel@tonic-gate /*
53507c478bd9Sstevel@tonic-gate  * hubd_disable_all_port_power:
53517c478bd9Sstevel@tonic-gate  */
53527c478bd9Sstevel@tonic-gate static int
53537c478bd9Sstevel@tonic-gate hubd_disable_all_port_power(hubd_t *hubd)
53547c478bd9Sstevel@tonic-gate {
53557c478bd9Sstevel@tonic-gate 	usb_port_t port;
53567c478bd9Sstevel@tonic-gate 
53577c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
53587c478bd9Sstevel@tonic-gate 	    "hubd_disable_all_port_power");
53597c478bd9Sstevel@tonic-gate 
53607c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
53617c478bd9Sstevel@tonic-gate 
53627c478bd9Sstevel@tonic-gate 	/*
53637c478bd9Sstevel@tonic-gate 	 * disable power per port, ignore gang power and power mask
53647c478bd9Sstevel@tonic-gate 	 */
53657c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
53667c478bd9Sstevel@tonic-gate 		(void) hubd_disable_port_power(hubd, port);
53677c478bd9Sstevel@tonic-gate 	}
53687c478bd9Sstevel@tonic-gate 
53697c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
53707c478bd9Sstevel@tonic-gate }
53717c478bd9Sstevel@tonic-gate 
53727c478bd9Sstevel@tonic-gate 
53737c478bd9Sstevel@tonic-gate /*
53747c478bd9Sstevel@tonic-gate  * hubd_disable_port_power:
53757c478bd9Sstevel@tonic-gate  *	disable individual port power
53767c478bd9Sstevel@tonic-gate  */
53777c478bd9Sstevel@tonic-gate static int
53787c478bd9Sstevel@tonic-gate hubd_disable_port_power(hubd_t *hubd, usb_port_t port)
53797c478bd9Sstevel@tonic-gate {
53807c478bd9Sstevel@tonic-gate 	int		rval;
53817c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
53827c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
53837c478bd9Sstevel@tonic-gate 
53847c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
53857c478bd9Sstevel@tonic-gate 	    "hubd_disable_port_power: port=%d", port);
53867c478bd9Sstevel@tonic-gate 
53877c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
53887c478bd9Sstevel@tonic-gate 
53897c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
53907c478bd9Sstevel@tonic-gate 
53917c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
53927c478bd9Sstevel@tonic-gate 	    hubd->h_default_pipe,
539335f36846Ssl 	    HUB_HANDLE_PORT_FEATURE_TYPE,
53947c478bd9Sstevel@tonic-gate 	    USB_REQ_CLEAR_FEATURE,
53957c478bd9Sstevel@tonic-gate 	    CFS_PORT_POWER,
53967c478bd9Sstevel@tonic-gate 	    port,
53977c478bd9Sstevel@tonic-gate 	    0, NULL, 0,
53987c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
53997c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
54007c478bd9Sstevel@tonic-gate 		    "clearing port%d power failed (%d 0x%x %d)",
54017c478bd9Sstevel@tonic-gate 		    port, completion_reason, cb_flags, rval);
54027c478bd9Sstevel@tonic-gate 
54037c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
54047c478bd9Sstevel@tonic-gate 
54057c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
54067c478bd9Sstevel@tonic-gate 	} else {
54077c478bd9Sstevel@tonic-gate 
54087c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
54097c478bd9Sstevel@tonic-gate 		ASSERT(completion_reason == 0);
54107c478bd9Sstevel@tonic-gate 		hubd->h_port_state[port] &= ~PORT_STATUS_PPS;
54117c478bd9Sstevel@tonic-gate 
54127c478bd9Sstevel@tonic-gate 		return (USB_SUCCESS);
54137c478bd9Sstevel@tonic-gate 	}
54147c478bd9Sstevel@tonic-gate }
54157c478bd9Sstevel@tonic-gate 
54167c478bd9Sstevel@tonic-gate 
54177c478bd9Sstevel@tonic-gate /*
54187c478bd9Sstevel@tonic-gate  * Search the database of user preferences and find out the preferred
54197c478bd9Sstevel@tonic-gate  * configuration for this new device
54207c478bd9Sstevel@tonic-gate  */
5421ff0e937bSRaymond Chen int
54227c478bd9Sstevel@tonic-gate hubd_select_device_configuration(hubd_t *hubd, usb_port_t port,
54237c478bd9Sstevel@tonic-gate 	dev_info_t *child_dip, usba_device_t *child_ud)
54247c478bd9Sstevel@tonic-gate {
54257c478bd9Sstevel@tonic-gate 	char		*pathname = NULL;
54267c478bd9Sstevel@tonic-gate 	char		*tmp_path = NULL;
54277c478bd9Sstevel@tonic-gate 	int		user_conf;
54287c478bd9Sstevel@tonic-gate 	int		pathlen;
54297c478bd9Sstevel@tonic-gate 	usb_dev_descr_t	*usbdev_ptr;
54307c478bd9Sstevel@tonic-gate 	usba_configrec_t *user_pref;
54317c478bd9Sstevel@tonic-gate 
54327c478bd9Sstevel@tonic-gate 	mutex_enter(&child_ud->usb_mutex);
54337c478bd9Sstevel@tonic-gate 	usbdev_ptr = child_ud->usb_dev_descr;
54347c478bd9Sstevel@tonic-gate 	mutex_exit(&child_ud->usb_mutex);
54357c478bd9Sstevel@tonic-gate 
54367c478bd9Sstevel@tonic-gate 	/* try to get pathname for this device */
54377c478bd9Sstevel@tonic-gate 	tmp_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
54387c478bd9Sstevel@tonic-gate 	(void) ddi_pathname(child_dip, tmp_path);
54397c478bd9Sstevel@tonic-gate 
54407c478bd9Sstevel@tonic-gate 	pathlen = strlen(tmp_path) + 32;
54417c478bd9Sstevel@tonic-gate 	pathname = kmem_zalloc(pathlen, KM_SLEEP);
54427c478bd9Sstevel@tonic-gate 
54437c478bd9Sstevel@tonic-gate 	/*
54447c478bd9Sstevel@tonic-gate 	 * We haven't initialized the node and it doesn't have an address
54457c478bd9Sstevel@tonic-gate 	 * yet. Append port number to the physical pathname
54467c478bd9Sstevel@tonic-gate 	 */
54477c478bd9Sstevel@tonic-gate 	(void) sprintf(pathname, "%s@%d", tmp_path, port);
54487c478bd9Sstevel@tonic-gate 
54497c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
54507c478bd9Sstevel@tonic-gate 	    "hubd_select_device_configuration: Device=%s\n\t"
54517c478bd9Sstevel@tonic-gate 	    "Child path=%s",
54527c478bd9Sstevel@tonic-gate 	    usba_get_mfg_prod_sn_str(child_dip, tmp_path, MAXPATHLEN),
54537c478bd9Sstevel@tonic-gate 	    pathname);
54547c478bd9Sstevel@tonic-gate 	kmem_free(tmp_path, MAXPATHLEN);
54557c478bd9Sstevel@tonic-gate 
54567c478bd9Sstevel@tonic-gate 
54577c478bd9Sstevel@tonic-gate 	/* database search for user preferences */
54587c478bd9Sstevel@tonic-gate 	user_pref = usba_devdb_get_user_preferences(usbdev_ptr->idVendor,
54597c478bd9Sstevel@tonic-gate 	    usbdev_ptr->idProduct, child_ud->usb_serialno_str, pathname);
54607c478bd9Sstevel@tonic-gate 
54617c478bd9Sstevel@tonic-gate 	if (user_pref) {
54627c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
54637c478bd9Sstevel@tonic-gate 		    "hubd_select_device_configuration: "
54647c478bd9Sstevel@tonic-gate 		    "usba_devdb_get_user_preferences "
54657c478bd9Sstevel@tonic-gate 		    "return user_conf=%d\npreferred driver=%s path=%s",
54667c478bd9Sstevel@tonic-gate 		    user_pref->cfg_index, user_pref->driver,
54677c478bd9Sstevel@tonic-gate 		    user_pref->pathname);
54687c478bd9Sstevel@tonic-gate 
54697c478bd9Sstevel@tonic-gate 		user_conf = user_pref->cfg_index;
54707c478bd9Sstevel@tonic-gate 
54717c478bd9Sstevel@tonic-gate 		if (user_pref->driver) {
54727c478bd9Sstevel@tonic-gate 			mutex_enter(&child_ud->usb_mutex);
54737c478bd9Sstevel@tonic-gate 			child_ud->usb_preferred_driver = user_pref->driver;
54747c478bd9Sstevel@tonic-gate 			mutex_exit(&child_ud->usb_mutex);
54757c478bd9Sstevel@tonic-gate 		}
54767c478bd9Sstevel@tonic-gate 	} else {
54777c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
54787c478bd9Sstevel@tonic-gate 		    "hubd_select_device_configuration: No match found");
54797c478bd9Sstevel@tonic-gate 
54807c478bd9Sstevel@tonic-gate 		/* select default configuration for this device */
54817c478bd9Sstevel@tonic-gate 		user_conf = USBA_DEV_CONFIG_INDEX_UNDEFINED;
54827c478bd9Sstevel@tonic-gate 	}
54837c478bd9Sstevel@tonic-gate 	kmem_free(pathname, pathlen);
54847c478bd9Sstevel@tonic-gate 
54857c478bd9Sstevel@tonic-gate 	/* if the device has just one configuration, set default value */
54867c478bd9Sstevel@tonic-gate 	if (usbdev_ptr->bNumConfigurations == 1) {
54877c478bd9Sstevel@tonic-gate 		user_conf = USB_DEV_DEFAULT_CONFIG_INDEX;
54887c478bd9Sstevel@tonic-gate 	}
54897c478bd9Sstevel@tonic-gate 
54907c478bd9Sstevel@tonic-gate 	return (user_conf);
54917c478bd9Sstevel@tonic-gate }
54927c478bd9Sstevel@tonic-gate 
54937c478bd9Sstevel@tonic-gate 
54947c478bd9Sstevel@tonic-gate /*
54957c478bd9Sstevel@tonic-gate  * Retrieves config cloud for this configuration
54967c478bd9Sstevel@tonic-gate  */
54977c478bd9Sstevel@tonic-gate int
54987c478bd9Sstevel@tonic-gate hubd_get_this_config_cloud(hubd_t *hubd, dev_info_t *dip,
54997c478bd9Sstevel@tonic-gate 	usba_device_t *child_ud, uint16_t conf_index)
55007c478bd9Sstevel@tonic-gate {
55017c478bd9Sstevel@tonic-gate 	usb_cfg_descr_t	*confdescr;
55027c478bd9Sstevel@tonic-gate 	mblk_t		*pdata = NULL;
55037c478bd9Sstevel@tonic-gate 	int		rval;
55047c478bd9Sstevel@tonic-gate 	size_t		size;
55057c478bd9Sstevel@tonic-gate 	char		*tmpbuf;
55067c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
55077c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
55087c478bd9Sstevel@tonic-gate 	usb_pipe_handle_t	def_ph;
55097c478bd9Sstevel@tonic-gate 
55107c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
55117c478bd9Sstevel@tonic-gate 	    "hubd_get_this_config_cloud: conf_index=%d", conf_index);
55127c478bd9Sstevel@tonic-gate 
55137c478bd9Sstevel@tonic-gate 
55147c478bd9Sstevel@tonic-gate 	/* alloc temporary space for config descriptor */
55157c478bd9Sstevel@tonic-gate 	confdescr = (usb_cfg_descr_t *)kmem_zalloc(USB_CFG_DESCR_SIZE,
55167c478bd9Sstevel@tonic-gate 	    KM_SLEEP);
55177c478bd9Sstevel@tonic-gate 
55187c478bd9Sstevel@tonic-gate 	/* alloc temporary space for string descriptor */
55197c478bd9Sstevel@tonic-gate 	tmpbuf = kmem_zalloc(USB_MAXSTRINGLEN, KM_SLEEP);
55207c478bd9Sstevel@tonic-gate 
55217c478bd9Sstevel@tonic-gate 	def_ph = usba_get_dflt_pipe_handle(dip);
55227c478bd9Sstevel@tonic-gate 
55237c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(dip, def_ph,
55247c478bd9Sstevel@tonic-gate 	    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
55257c478bd9Sstevel@tonic-gate 	    USB_REQ_GET_DESCR,
55267c478bd9Sstevel@tonic-gate 	    USB_DESCR_TYPE_SETUP_CFG | conf_index,
55277c478bd9Sstevel@tonic-gate 	    0,
55287c478bd9Sstevel@tonic-gate 	    USB_CFG_DESCR_SIZE,
55297c478bd9Sstevel@tonic-gate 	    &pdata,
55307c478bd9Sstevel@tonic-gate 	    0,
55317c478bd9Sstevel@tonic-gate 	    &completion_reason,
55327c478bd9Sstevel@tonic-gate 	    &cb_flags,
55337c478bd9Sstevel@tonic-gate 	    0)) == USB_SUCCESS) {
55347c478bd9Sstevel@tonic-gate 
55357c478bd9Sstevel@tonic-gate 		/* this must be true since we didn't allow data underruns */
5536d29f5a71Szhigang lu - Sun Microsystems - Beijing China 		if (MBLKL(pdata) != USB_CFG_DESCR_SIZE) {
553735f36846Ssl 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
553835f36846Ssl 			    "device returned incorrect configuration "
553935f36846Ssl 			    "descriptor size.");
554035f36846Ssl 
554135f36846Ssl 			rval = USB_FAILURE;
554235f36846Ssl 			goto done;
554335f36846Ssl 		}
55447c478bd9Sstevel@tonic-gate 
55457c478bd9Sstevel@tonic-gate 		/*
55467c478bd9Sstevel@tonic-gate 		 * Parse the configuration descriptor
55477c478bd9Sstevel@tonic-gate 		 */
55487c478bd9Sstevel@tonic-gate 		size = usb_parse_cfg_descr(pdata->b_rptr,
5549d29f5a71Szhigang lu - Sun Microsystems - Beijing China 		    MBLKL(pdata), confdescr,
55507c478bd9Sstevel@tonic-gate 		    USB_CFG_DESCR_SIZE);
55517c478bd9Sstevel@tonic-gate 
55527c478bd9Sstevel@tonic-gate 		/* if parse cfg descr error, it should return failure */
55537c478bd9Sstevel@tonic-gate 		if (size == USB_PARSE_ERROR) {
55547c478bd9Sstevel@tonic-gate 
55557c478bd9Sstevel@tonic-gate 			if (pdata->b_rptr[1] != USB_DESCR_TYPE_CFG) {
5556d291d9f2Sfrits 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
55577c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
55587c478bd9Sstevel@tonic-gate 				    "device returned incorrect "
55597c478bd9Sstevel@tonic-gate 				    "configuration descriptor type.");
55607c478bd9Sstevel@tonic-gate 			}
55617c478bd9Sstevel@tonic-gate 			rval = USB_FAILURE;
55627c478bd9Sstevel@tonic-gate 			goto done;
55637c478bd9Sstevel@tonic-gate 		}
55647c478bd9Sstevel@tonic-gate 
55657c478bd9Sstevel@tonic-gate 		if (confdescr->wTotalLength < USB_CFG_DESCR_SIZE) {
5566d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
55677c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
55687c478bd9Sstevel@tonic-gate 			    "device returned incorrect "
55697c478bd9Sstevel@tonic-gate 			    "configuration descriptor size.");
55707c478bd9Sstevel@tonic-gate 
55717c478bd9Sstevel@tonic-gate 			rval = USB_FAILURE;
55727c478bd9Sstevel@tonic-gate 			goto done;
55737c478bd9Sstevel@tonic-gate 		}
55747c478bd9Sstevel@tonic-gate 
55757c478bd9Sstevel@tonic-gate 		freemsg(pdata);
55767c478bd9Sstevel@tonic-gate 		pdata = NULL;
55777c478bd9Sstevel@tonic-gate 
55787c478bd9Sstevel@tonic-gate 		/* Now fetch the complete config cloud */
55797c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(dip, def_ph,
55807c478bd9Sstevel@tonic-gate 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
55817c478bd9Sstevel@tonic-gate 		    USB_REQ_GET_DESCR,
55827c478bd9Sstevel@tonic-gate 		    USB_DESCR_TYPE_SETUP_CFG | conf_index,
55837c478bd9Sstevel@tonic-gate 		    0,
55847c478bd9Sstevel@tonic-gate 		    confdescr->wTotalLength,
55857c478bd9Sstevel@tonic-gate 		    &pdata,
55867c478bd9Sstevel@tonic-gate 		    0,
55877c478bd9Sstevel@tonic-gate 		    &completion_reason,
55887c478bd9Sstevel@tonic-gate 		    &cb_flags,
55897c478bd9Sstevel@tonic-gate 		    0)) == USB_SUCCESS) {
55907c478bd9Sstevel@tonic-gate 
5591d29f5a71Szhigang lu - Sun Microsystems - Beijing China 			if (MBLKL(pdata) !=
55927c478bd9Sstevel@tonic-gate 			    confdescr->wTotalLength) {
55937c478bd9Sstevel@tonic-gate 
5594d291d9f2Sfrits 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
55957c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
55967c478bd9Sstevel@tonic-gate 				    "device returned incorrect "
55977c478bd9Sstevel@tonic-gate 				    "configuration descriptor.");
55987c478bd9Sstevel@tonic-gate 
55997c478bd9Sstevel@tonic-gate 				rval = USB_FAILURE;
56007c478bd9Sstevel@tonic-gate 				goto done;
56017c478bd9Sstevel@tonic-gate 			}
56027c478bd9Sstevel@tonic-gate 
56037c478bd9Sstevel@tonic-gate 			/*
56047c478bd9Sstevel@tonic-gate 			 * copy config descriptor into usba_device
56057c478bd9Sstevel@tonic-gate 			 */
56067c478bd9Sstevel@tonic-gate 			mutex_enter(&child_ud->usb_mutex);
56077c478bd9Sstevel@tonic-gate 			child_ud->usb_cfg_array[conf_index] =
56087c478bd9Sstevel@tonic-gate 			    kmem_alloc(confdescr->wTotalLength, KM_SLEEP);
56097c478bd9Sstevel@tonic-gate 			child_ud->usb_cfg_array_len[conf_index] =
5610c0f24e5bSlg 			    confdescr->wTotalLength;
56117c478bd9Sstevel@tonic-gate 			bcopy((caddr_t)pdata->b_rptr,
56127c478bd9Sstevel@tonic-gate 			    (caddr_t)child_ud->usb_cfg_array[conf_index],
56137c478bd9Sstevel@tonic-gate 			    confdescr->wTotalLength);
56147c478bd9Sstevel@tonic-gate 			mutex_exit(&child_ud->usb_mutex);
56157c478bd9Sstevel@tonic-gate 
56167c478bd9Sstevel@tonic-gate 			/*
56177c478bd9Sstevel@tonic-gate 			 * retrieve string descriptor describing this
56187c478bd9Sstevel@tonic-gate 			 * configuration
56197c478bd9Sstevel@tonic-gate 			 */
56207c478bd9Sstevel@tonic-gate 			if (confdescr->iConfiguration) {
56217c478bd9Sstevel@tonic-gate 
56227c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
56237c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
56247c478bd9Sstevel@tonic-gate 				    "Get conf str descr for config_index=%d",
56257c478bd9Sstevel@tonic-gate 				    conf_index);
56267c478bd9Sstevel@tonic-gate 
56277c478bd9Sstevel@tonic-gate 				/*
56287c478bd9Sstevel@tonic-gate 				 * Now fetch the string descriptor describing
56297c478bd9Sstevel@tonic-gate 				 * this configuration
56307c478bd9Sstevel@tonic-gate 				 */
56317c478bd9Sstevel@tonic-gate 				if ((rval = usb_get_string_descr(dip,
56327c478bd9Sstevel@tonic-gate 				    USB_LANG_ID, confdescr->iConfiguration,
56337c478bd9Sstevel@tonic-gate 				    tmpbuf, USB_MAXSTRINGLEN)) ==
56347c478bd9Sstevel@tonic-gate 				    USB_SUCCESS) {
56357c478bd9Sstevel@tonic-gate 					size = strlen(tmpbuf);
56367c478bd9Sstevel@tonic-gate 					if (size > 0) {
56377c478bd9Sstevel@tonic-gate 						child_ud->usb_cfg_str_descr
56387c478bd9Sstevel@tonic-gate 						    [conf_index] = (char *)
56397c478bd9Sstevel@tonic-gate 						    kmem_zalloc(size + 1,
56407c478bd9Sstevel@tonic-gate 						    KM_SLEEP);
56417c478bd9Sstevel@tonic-gate 						(void) strcpy(
56427c478bd9Sstevel@tonic-gate 						    child_ud->usb_cfg_str_descr
56437c478bd9Sstevel@tonic-gate 						    [conf_index], tmpbuf);
56447c478bd9Sstevel@tonic-gate 					}
56457c478bd9Sstevel@tonic-gate 				} else {
56467c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
56477c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
56487c478bd9Sstevel@tonic-gate 					    "hubd_get_this_config_cloud: "
56497c478bd9Sstevel@tonic-gate 					    "getting config string (%d) "
56507c478bd9Sstevel@tonic-gate 					    "failed",
56517c478bd9Sstevel@tonic-gate 					    confdescr->iConfiguration);
56527c478bd9Sstevel@tonic-gate 
56537c478bd9Sstevel@tonic-gate 					/* ignore this error */
56547c478bd9Sstevel@tonic-gate 					rval = USB_SUCCESS;
56557c478bd9Sstevel@tonic-gate 				}
56567c478bd9Sstevel@tonic-gate 			}
56577c478bd9Sstevel@tonic-gate 		}
56587c478bd9Sstevel@tonic-gate 	}
56597c478bd9Sstevel@tonic-gate 
56607c478bd9Sstevel@tonic-gate done:
56617c478bd9Sstevel@tonic-gate 	if (rval != USB_SUCCESS) {
56627c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
56637c478bd9Sstevel@tonic-gate 		    "hubd_get_this_config_cloud: "
56647c478bd9Sstevel@tonic-gate 		    "error in retrieving config descriptor for "
56657c478bd9Sstevel@tonic-gate 		    "config index=%d rval=%d cr=%d",
56667c478bd9Sstevel@tonic-gate 		    conf_index, rval, completion_reason);
56677c478bd9Sstevel@tonic-gate 	}
56687c478bd9Sstevel@tonic-gate 
56697c478bd9Sstevel@tonic-gate 	if (pdata) {
56707c478bd9Sstevel@tonic-gate 		freemsg(pdata);
56717c478bd9Sstevel@tonic-gate 		pdata = NULL;
56727c478bd9Sstevel@tonic-gate 	}
56737c478bd9Sstevel@tonic-gate 
56747c478bd9Sstevel@tonic-gate 	kmem_free(confdescr, USB_CFG_DESCR_SIZE);
56757c478bd9Sstevel@tonic-gate 	kmem_free(tmpbuf, USB_MAXSTRINGLEN);
56767c478bd9Sstevel@tonic-gate 
56777c478bd9Sstevel@tonic-gate 	return (rval);
56787c478bd9Sstevel@tonic-gate }
56797c478bd9Sstevel@tonic-gate 
56807c478bd9Sstevel@tonic-gate 
56817c478bd9Sstevel@tonic-gate /*
56827c478bd9Sstevel@tonic-gate  * Retrieves the entire config cloud for all configurations of the device
56837c478bd9Sstevel@tonic-gate  */
56847c478bd9Sstevel@tonic-gate int
56857c478bd9Sstevel@tonic-gate hubd_get_all_device_config_cloud(hubd_t *hubd, dev_info_t *dip,
56867c478bd9Sstevel@tonic-gate 	usba_device_t *child_ud)
56877c478bd9Sstevel@tonic-gate {
56887c478bd9Sstevel@tonic-gate 	int		rval = USB_SUCCESS;
56897c478bd9Sstevel@tonic-gate 	int		ncfgs;
56907c478bd9Sstevel@tonic-gate 	uint16_t	size;
56917c478bd9Sstevel@tonic-gate 	uint16_t	conf_index;
56927c478bd9Sstevel@tonic-gate 	uchar_t		**cfg_array;
56937c478bd9Sstevel@tonic-gate 	uint16_t	*cfg_array_len;
56947c478bd9Sstevel@tonic-gate 	char		**str_descr;
56957c478bd9Sstevel@tonic-gate 
56967c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
56977c478bd9Sstevel@tonic-gate 	    "hubd_get_all_device_config_cloud: Start");
56987c478bd9Sstevel@tonic-gate 
56997c478bd9Sstevel@tonic-gate 	/* alloc pointer array for conf. descriptors */
57007c478bd9Sstevel@tonic-gate 	mutex_enter(&child_ud->usb_mutex);
57017c478bd9Sstevel@tonic-gate 	ncfgs = child_ud->usb_n_cfgs;
57027c478bd9Sstevel@tonic-gate 	mutex_exit(&child_ud->usb_mutex);
57037c478bd9Sstevel@tonic-gate 
57047c478bd9Sstevel@tonic-gate 	size = sizeof (uchar_t *) * ncfgs;
57057c478bd9Sstevel@tonic-gate 	cfg_array = kmem_zalloc(size, KM_SLEEP);
57067c478bd9Sstevel@tonic-gate 	cfg_array_len = kmem_zalloc(ncfgs * sizeof (uint16_t), KM_SLEEP);
57077c478bd9Sstevel@tonic-gate 	str_descr = kmem_zalloc(size, KM_SLEEP);
57087c478bd9Sstevel@tonic-gate 
57097c478bd9Sstevel@tonic-gate 	mutex_enter(&child_ud->usb_mutex);
57107c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg_array = cfg_array;
57117c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg_array_len = cfg_array_len;
57127c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg_array_length = size;
57137c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg_array_len_length = ncfgs * sizeof (uint16_t);
57147c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg_str_descr = str_descr;
57157c478bd9Sstevel@tonic-gate 	mutex_exit(&child_ud->usb_mutex);
57167c478bd9Sstevel@tonic-gate 
57177c478bd9Sstevel@tonic-gate 	/* Get configuration descriptor for each configuration */
57187c478bd9Sstevel@tonic-gate 	for (conf_index = 0; (conf_index < ncfgs) &&
57197c478bd9Sstevel@tonic-gate 	    (rval == USB_SUCCESS); conf_index++) {
57207c478bd9Sstevel@tonic-gate 
57217c478bd9Sstevel@tonic-gate 		rval = hubd_get_this_config_cloud(hubd, dip, child_ud,
57227c478bd9Sstevel@tonic-gate 		    conf_index);
57237c478bd9Sstevel@tonic-gate 	}
57247c478bd9Sstevel@tonic-gate 
57257c478bd9Sstevel@tonic-gate 	return (rval);
57267c478bd9Sstevel@tonic-gate }
57277c478bd9Sstevel@tonic-gate 
57287c478bd9Sstevel@tonic-gate 
57297c478bd9Sstevel@tonic-gate /*
57307c478bd9Sstevel@tonic-gate  * hubd_ready_device:
57317c478bd9Sstevel@tonic-gate  *	Update the usba_device structure
57327c478bd9Sstevel@tonic-gate  *	Set the given configuration
57337c478bd9Sstevel@tonic-gate  *	Prepares the device node for driver to online. If an existing
57347c478bd9Sstevel@tonic-gate  *	OBP node is found, it will switch to the OBP node.
57357c478bd9Sstevel@tonic-gate  */
5736ff0e937bSRaymond Chen dev_info_t *
57377c478bd9Sstevel@tonic-gate hubd_ready_device(hubd_t *hubd, dev_info_t *child_dip, usba_device_t *child_ud,
573835f36846Ssl     uint_t config_index)
57397c478bd9Sstevel@tonic-gate {
57407c478bd9Sstevel@tonic-gate 	usb_cr_t	completion_reason;
57417c478bd9Sstevel@tonic-gate 	usb_cb_flags_t	cb_flags;
57427c478bd9Sstevel@tonic-gate 	size_t		size;
57437c478bd9Sstevel@tonic-gate 	usb_cfg_descr_t	config_descriptor;
57447c478bd9Sstevel@tonic-gate 	usb_pipe_handle_t def_ph;
57457c478bd9Sstevel@tonic-gate 	usba_pipe_handle_data_t	*ph;
57467c478bd9Sstevel@tonic-gate 
57477c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5748112116d8Sfb 	    "hubd_ready_device: dip=0x%p, user_conf_index=%d",
5749112116d8Sfb 	    (void *)child_dip, config_index);
57507c478bd9Sstevel@tonic-gate 
57517c478bd9Sstevel@tonic-gate 	size = usb_parse_cfg_descr(
57527c478bd9Sstevel@tonic-gate 	    child_ud->usb_cfg_array[config_index], USB_CFG_DESCR_SIZE,
57537c478bd9Sstevel@tonic-gate 	    &config_descriptor, USB_CFG_DESCR_SIZE);
57547c478bd9Sstevel@tonic-gate 	ASSERT(size == USB_CFG_DESCR_SIZE);
57557c478bd9Sstevel@tonic-gate 
57567c478bd9Sstevel@tonic-gate 	def_ph = usba_get_dflt_pipe_handle(child_dip);
57577c478bd9Sstevel@tonic-gate 
57587c478bd9Sstevel@tonic-gate 	/* Set the configuration */
57597c478bd9Sstevel@tonic-gate 	(void) usb_pipe_sync_ctrl_xfer(child_dip, def_ph,
57607c478bd9Sstevel@tonic-gate 	    USB_DEV_REQ_HOST_TO_DEV,
57617c478bd9Sstevel@tonic-gate 	    USB_REQ_SET_CFG,	/* bRequest */
57627c478bd9Sstevel@tonic-gate 	    config_descriptor.bConfigurationValue,	/* wValue */
57637c478bd9Sstevel@tonic-gate 	    0,				/* wIndex */
57647c478bd9Sstevel@tonic-gate 	    0,				/* wLength */
57657c478bd9Sstevel@tonic-gate 	    NULL,
57667c478bd9Sstevel@tonic-gate 	    0,
57677c478bd9Sstevel@tonic-gate 	    &completion_reason,
57687c478bd9Sstevel@tonic-gate 	    &cb_flags,
57697c478bd9Sstevel@tonic-gate 	    0);
57707c478bd9Sstevel@tonic-gate 
57717c478bd9Sstevel@tonic-gate 	mutex_enter(&child_ud->usb_mutex);
57727c478bd9Sstevel@tonic-gate 	child_ud->usb_active_cfg_ndx	= config_index;
57737c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg		= child_ud->usb_cfg_array[config_index];
57747c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg_length	= config_descriptor.wTotalLength;
57757c478bd9Sstevel@tonic-gate 	child_ud->usb_cfg_value 	= config_descriptor.bConfigurationValue;
57767c478bd9Sstevel@tonic-gate 	child_ud->usb_n_ifs		= config_descriptor.bNumInterfaces;
57777c478bd9Sstevel@tonic-gate 	child_ud->usb_dip		= child_dip;
57787c478bd9Sstevel@tonic-gate 
57797c478bd9Sstevel@tonic-gate 	child_ud->usb_client_flags	= kmem_zalloc(
5780c0f24e5bSlg 	    child_ud->usb_n_ifs * USBA_CLIENT_FLAG_SIZE, KM_SLEEP);
57817c478bd9Sstevel@tonic-gate 
57827c478bd9Sstevel@tonic-gate 	child_ud->usb_client_attach_list = kmem_zalloc(
5783c0f24e5bSlg 	    child_ud->usb_n_ifs *
5784c0f24e5bSlg 	    sizeof (*child_ud->usb_client_attach_list), KM_SLEEP);
57857c478bd9Sstevel@tonic-gate 
57867c478bd9Sstevel@tonic-gate 	child_ud->usb_client_ev_cb_list = kmem_zalloc(
5787c0f24e5bSlg 	    child_ud->usb_n_ifs *
5788c0f24e5bSlg 	    sizeof (*child_ud->usb_client_ev_cb_list), KM_SLEEP);
57897c478bd9Sstevel@tonic-gate 
57907c478bd9Sstevel@tonic-gate 	mutex_exit(&child_ud->usb_mutex);
57917c478bd9Sstevel@tonic-gate 
57927c478bd9Sstevel@tonic-gate 	/* ready the device node */
57937c478bd9Sstevel@tonic-gate 	child_dip = usba_ready_device_node(child_dip);
57947c478bd9Sstevel@tonic-gate 
57957c478bd9Sstevel@tonic-gate 	/* set owner of default pipe to child dip */
57967c478bd9Sstevel@tonic-gate 	ph = usba_get_ph_data(def_ph);
57977c478bd9Sstevel@tonic-gate 	mutex_enter(&ph->p_mutex);
57987c478bd9Sstevel@tonic-gate 	mutex_enter(&ph->p_ph_impl->usba_ph_mutex);
57997c478bd9Sstevel@tonic-gate 	ph->p_ph_impl->usba_ph_dip = ph->p_dip = child_dip;
58007c478bd9Sstevel@tonic-gate 	mutex_exit(&ph->p_ph_impl->usba_ph_mutex);
58017c478bd9Sstevel@tonic-gate 	mutex_exit(&ph->p_mutex);
58027c478bd9Sstevel@tonic-gate 
58037c478bd9Sstevel@tonic-gate 	return (child_dip);
58047c478bd9Sstevel@tonic-gate }
58057c478bd9Sstevel@tonic-gate 
58067c478bd9Sstevel@tonic-gate 
58077c478bd9Sstevel@tonic-gate /*
58087c478bd9Sstevel@tonic-gate  * hubd_create_child
58097c478bd9Sstevel@tonic-gate  *	- create child dip
58107c478bd9Sstevel@tonic-gate  *	- open default pipe
58117c478bd9Sstevel@tonic-gate  *	- get device descriptor
58127c478bd9Sstevel@tonic-gate  *	- set the address
58137c478bd9Sstevel@tonic-gate  *	- get device string descriptors
58147c478bd9Sstevel@tonic-gate  *	- get the entire config cloud (all configurations) of the device
58157c478bd9Sstevel@tonic-gate  *	- set user preferred configuration
58167c478bd9Sstevel@tonic-gate  *	- close default pipe
58177c478bd9Sstevel@tonic-gate  *	- load appropriate driver(s)
58187c478bd9Sstevel@tonic-gate  */
58197c478bd9Sstevel@tonic-gate static int
58207c478bd9Sstevel@tonic-gate hubd_create_child(dev_info_t *dip,
58217c478bd9Sstevel@tonic-gate 		hubd_t		*hubd,
58227c478bd9Sstevel@tonic-gate 		usba_device_t	*hubd_ud,
58237c478bd9Sstevel@tonic-gate 		usb_port_status_t port_status,
58247c478bd9Sstevel@tonic-gate 		usb_port_t	port,
58257c478bd9Sstevel@tonic-gate 		int		iteration)
58267c478bd9Sstevel@tonic-gate {
58277c478bd9Sstevel@tonic-gate 	dev_info_t		*child_dip = NULL;
58287c478bd9Sstevel@tonic-gate 	usb_dev_descr_t	usb_dev_descr;
58297c478bd9Sstevel@tonic-gate 	int			rval;
58307c478bd9Sstevel@tonic-gate 	usba_device_t		*child_ud = NULL;
58317c478bd9Sstevel@tonic-gate 	usba_device_t		*parent_ud = NULL;
58327c478bd9Sstevel@tonic-gate 	usb_pipe_handle_t	ph = NULL; /* default pipe handle */
58337c478bd9Sstevel@tonic-gate 	mblk_t			*pdata = NULL;
58347c478bd9Sstevel@tonic-gate 	usb_cr_t		completion_reason;
583535f36846Ssl 	int			user_conf_index;
583635f36846Ssl 	uint_t			config_index;
58377c478bd9Sstevel@tonic-gate 	usb_cb_flags_t		cb_flags;
58387c478bd9Sstevel@tonic-gate 	uchar_t			address = 0;
58397c478bd9Sstevel@tonic-gate 	uint16_t		length;
58407c478bd9Sstevel@tonic-gate 	size_t			size;
58417c478bd9Sstevel@tonic-gate 	usb_addr_t		parent_usb_addr;
58427c478bd9Sstevel@tonic-gate 	usb_port_t		parent_usb_port;
58437c478bd9Sstevel@tonic-gate 	usba_device_t		*parent_usba_dev;
58447c478bd9Sstevel@tonic-gate 	usb_port_status_t	parent_port_status;
58457c478bd9Sstevel@tonic-gate 
58467c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
58477c478bd9Sstevel@tonic-gate 	    "hubd_create_child: port=%d", port);
58487c478bd9Sstevel@tonic-gate 
58497c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
58507c478bd9Sstevel@tonic-gate 	ASSERT(hubd->h_usba_devices[port] == NULL);
58517c478bd9Sstevel@tonic-gate 
58527c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
58537c478bd9Sstevel@tonic-gate 
58547c478bd9Sstevel@tonic-gate 	/*
58557c478bd9Sstevel@tonic-gate 	 * create a dip which can be used to open the pipe. we set
58567c478bd9Sstevel@tonic-gate 	 * the name after getting the descriptors from the device
58577c478bd9Sstevel@tonic-gate 	 */
58587c478bd9Sstevel@tonic-gate 	rval = usba_create_child_devi(dip,
5859c0f24e5bSlg 	    "device",		/* driver name */
5860c0f24e5bSlg 	    hubd_ud->usb_hcdi_ops, /* usba_hcdi ops */
5861c0f24e5bSlg 	    hubd_ud->usb_root_hub_dip,
5862c0f24e5bSlg 	    port_status,		/* low speed device */
5863c0f24e5bSlg 	    child_ud,
5864c0f24e5bSlg 	    &child_dip);
58657c478bd9Sstevel@tonic-gate 
58667c478bd9Sstevel@tonic-gate 	if (rval != USB_SUCCESS) {
58677c478bd9Sstevel@tonic-gate 
5868d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
58697c478bd9Sstevel@tonic-gate 		    "usb_create_child_devi failed (%d)", rval);
58707c478bd9Sstevel@tonic-gate 
58717c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
58727c478bd9Sstevel@tonic-gate 	}
58737c478bd9Sstevel@tonic-gate 
58747c478bd9Sstevel@tonic-gate 	child_ud = usba_get_usba_device(child_dip);
58757c478bd9Sstevel@tonic-gate 	ASSERT(child_ud != NULL);
58767c478bd9Sstevel@tonic-gate 
58777c478bd9Sstevel@tonic-gate 	parent_ud = hubd->h_usba_device;
58787c478bd9Sstevel@tonic-gate 	mutex_enter(&parent_ud->usb_mutex);
58797c478bd9Sstevel@tonic-gate 	parent_port_status = parent_ud->usb_port_status;
58807c478bd9Sstevel@tonic-gate 
58817c478bd9Sstevel@tonic-gate 	/*
58827c478bd9Sstevel@tonic-gate 	 * To support split transactions, update address and port
58837c478bd9Sstevel@tonic-gate 	 * of high speed hub to which given device is connected.
58847c478bd9Sstevel@tonic-gate 	 */
58857c478bd9Sstevel@tonic-gate 	if (parent_port_status == USBA_HIGH_SPEED_DEV) {
58867c478bd9Sstevel@tonic-gate 		parent_usba_dev = parent_ud;
58877c478bd9Sstevel@tonic-gate 		parent_usb_addr = parent_ud->usb_addr;
58887c478bd9Sstevel@tonic-gate 		parent_usb_port = port;
58897c478bd9Sstevel@tonic-gate 	} else {
58907c478bd9Sstevel@tonic-gate 		parent_usba_dev = parent_ud->usb_hs_hub_usba_dev;
58917c478bd9Sstevel@tonic-gate 		parent_usb_addr = parent_ud->usb_hs_hub_addr;
58927c478bd9Sstevel@tonic-gate 		parent_usb_port = parent_ud->usb_hs_hub_port;
58937c478bd9Sstevel@tonic-gate 	}
58947c478bd9Sstevel@tonic-gate 	mutex_exit(&parent_ud->usb_mutex);
58957c478bd9Sstevel@tonic-gate 
58967c478bd9Sstevel@tonic-gate 	mutex_enter(&child_ud->usb_mutex);
58977c478bd9Sstevel@tonic-gate 	address = child_ud->usb_addr;
58987c478bd9Sstevel@tonic-gate 	child_ud->usb_addr = 0;
58997c478bd9Sstevel@tonic-gate 	child_ud->usb_dev_descr = kmem_alloc(sizeof (usb_dev_descr_t),
59007c478bd9Sstevel@tonic-gate 	    KM_SLEEP);
59017c478bd9Sstevel@tonic-gate 	bzero(&usb_dev_descr, sizeof (usb_dev_descr_t));
59027c478bd9Sstevel@tonic-gate 	usb_dev_descr.bMaxPacketSize0 =
59037c478bd9Sstevel@tonic-gate 	    (port_status == USBA_LOW_SPEED_DEV) ? 8 : 64;
59047c478bd9Sstevel@tonic-gate 	bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
59057c478bd9Sstevel@tonic-gate 	    sizeof (usb_dev_descr_t));
59067c478bd9Sstevel@tonic-gate 	child_ud->usb_port = port;
59077c478bd9Sstevel@tonic-gate 	child_ud->usb_hs_hub_usba_dev = parent_usba_dev;
59087c478bd9Sstevel@tonic-gate 	child_ud->usb_hs_hub_addr = parent_usb_addr;
59097c478bd9Sstevel@tonic-gate 	child_ud->usb_hs_hub_port = parent_usb_port;
59107c478bd9Sstevel@tonic-gate 	mutex_exit(&child_ud->usb_mutex);
59117c478bd9Sstevel@tonic-gate 
59127c478bd9Sstevel@tonic-gate 	/* Open the default pipe */
59137c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
59147c478bd9Sstevel@tonic-gate 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) != USB_SUCCESS) {
5915d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5916d291d9f2Sfrits 		    "usb_pipe_open failed (%d)", rval);
59177c478bd9Sstevel@tonic-gate 
59187c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
59197c478bd9Sstevel@tonic-gate 	}
59207c478bd9Sstevel@tonic-gate 
59217c478bd9Sstevel@tonic-gate 	/*
59227c478bd9Sstevel@tonic-gate 	 * get device descriptor
59237c478bd9Sstevel@tonic-gate 	 */
59247c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
59257c478bd9Sstevel@tonic-gate 	    "hubd_create_child: get device descriptor: 64 bytes");
59267c478bd9Sstevel@tonic-gate 
59277c478bd9Sstevel@tonic-gate 	rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
59287c478bd9Sstevel@tonic-gate 	    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
59297c478bd9Sstevel@tonic-gate 	    USB_REQ_GET_DESCR,			/* bRequest */
59307c478bd9Sstevel@tonic-gate 	    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
59317c478bd9Sstevel@tonic-gate 	    0,					/* wIndex */
59327c478bd9Sstevel@tonic-gate 	    64,					/* wLength */
59337c478bd9Sstevel@tonic-gate 	    &pdata, USB_ATTRS_SHORT_XFER_OK,
59347c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0);
59357c478bd9Sstevel@tonic-gate 
59367c478bd9Sstevel@tonic-gate 	if ((rval != USB_SUCCESS) &&
59377c478bd9Sstevel@tonic-gate 	    (!((completion_reason == USB_CR_DATA_OVERRUN) && pdata))) {
59387c478bd9Sstevel@tonic-gate 
59397c478bd9Sstevel@tonic-gate 		/*
59407c478bd9Sstevel@tonic-gate 		 * rval != USB_SUCCESS AND
59417c478bd9Sstevel@tonic-gate 		 * completion_reason != USB_CR_DATA_OVERRUN
59427c478bd9Sstevel@tonic-gate 		 * pdata could be != NULL.
59437c478bd9Sstevel@tonic-gate 		 * Free pdata now to prevent memory leak.
59447c478bd9Sstevel@tonic-gate 		 */
59457c478bd9Sstevel@tonic-gate 		freemsg(pdata);
59467c478bd9Sstevel@tonic-gate 		pdata = NULL;
59477c478bd9Sstevel@tonic-gate 
59487c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
59497c478bd9Sstevel@tonic-gate 		    "hubd_create_child: get device descriptor: 8 bytes");
59507c478bd9Sstevel@tonic-gate 
59517c478bd9Sstevel@tonic-gate 		rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
59527c478bd9Sstevel@tonic-gate 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
59537c478bd9Sstevel@tonic-gate 		    USB_REQ_GET_DESCR,			/* bRequest */
59547c478bd9Sstevel@tonic-gate 		    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
59557c478bd9Sstevel@tonic-gate 		    0,					/* wIndex */
59567c478bd9Sstevel@tonic-gate 		    8,					/* wLength */
59577c478bd9Sstevel@tonic-gate 		    &pdata, USB_ATTRS_NONE,
59587c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0);
59597c478bd9Sstevel@tonic-gate 
59607c478bd9Sstevel@tonic-gate 		if (rval != USB_SUCCESS) {
5961d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
59627c478bd9Sstevel@tonic-gate 			    "getting device descriptor failed (%s 0x%x %d)",
59637c478bd9Sstevel@tonic-gate 			    usb_str_cr(completion_reason), cb_flags, rval);
59647c478bd9Sstevel@tonic-gate 			goto fail_cleanup;
59657c478bd9Sstevel@tonic-gate 		}
59667c478bd9Sstevel@tonic-gate 	} else {
59677c478bd9Sstevel@tonic-gate 		ASSERT(completion_reason == USB_CR_OK);
59687c478bd9Sstevel@tonic-gate 	}
59697c478bd9Sstevel@tonic-gate 
59707c478bd9Sstevel@tonic-gate 	ASSERT(pdata != NULL);
59717c478bd9Sstevel@tonic-gate 
59727c478bd9Sstevel@tonic-gate 	size = usb_parse_dev_descr(
5973c0f24e5bSlg 	    pdata->b_rptr,
5974d29f5a71Szhigang lu - Sun Microsystems - Beijing China 	    MBLKL(pdata),
5975c0f24e5bSlg 	    &usb_dev_descr,
5976c0f24e5bSlg 	    sizeof (usb_dev_descr_t));
59777c478bd9Sstevel@tonic-gate 
59787c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
59797c478bd9Sstevel@tonic-gate 	    "parsing device descriptor returned %lu", size);
59807c478bd9Sstevel@tonic-gate 
59817c478bd9Sstevel@tonic-gate 	length = *(pdata->b_rptr);
59827c478bd9Sstevel@tonic-gate 	freemsg(pdata);
59837c478bd9Sstevel@tonic-gate 	pdata = NULL;
59847c478bd9Sstevel@tonic-gate 	if (size < 8) {
5985d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
59867c478bd9Sstevel@tonic-gate 		    "get device descriptor returned %lu bytes", size);
59877c478bd9Sstevel@tonic-gate 
59887c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
59897c478bd9Sstevel@tonic-gate 	}
59907c478bd9Sstevel@tonic-gate 
59917c478bd9Sstevel@tonic-gate 	if (length < 8) {
5992d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
59937c478bd9Sstevel@tonic-gate 		    "fail enumeration: bLength=%d", length);
59947c478bd9Sstevel@tonic-gate 
59957c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
59967c478bd9Sstevel@tonic-gate 	}
59977c478bd9Sstevel@tonic-gate 
59987c478bd9Sstevel@tonic-gate 	/* Set the address of the device */
59997c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
60007c478bd9Sstevel@tonic-gate 	    USB_DEV_REQ_HOST_TO_DEV,
60017c478bd9Sstevel@tonic-gate 	    USB_REQ_SET_ADDRESS,	/* bRequest */
60027c478bd9Sstevel@tonic-gate 	    address,			/* wValue */
60037c478bd9Sstevel@tonic-gate 	    0,				/* wIndex */
60047c478bd9Sstevel@tonic-gate 	    0,				/* wLength */
60057c478bd9Sstevel@tonic-gate 	    NULL, 0,
60067c478bd9Sstevel@tonic-gate 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
60077c478bd9Sstevel@tonic-gate 		char buffer[64];
6008d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
60097c478bd9Sstevel@tonic-gate 		    "setting address failed (cr=%s cb_flags=%s rval=%d)",
60107c478bd9Sstevel@tonic-gate 		    usb_str_cr(completion_reason),
60117c478bd9Sstevel@tonic-gate 		    usb_str_cb_flags(cb_flags, buffer, sizeof (buffer)),
60127c478bd9Sstevel@tonic-gate 		    rval);
60137c478bd9Sstevel@tonic-gate 
60147c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
60157c478bd9Sstevel@tonic-gate 	}
60167c478bd9Sstevel@tonic-gate 
60177c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
60187c478bd9Sstevel@tonic-gate 	    "set address 0x%x done", address);
60197c478bd9Sstevel@tonic-gate 
60207c478bd9Sstevel@tonic-gate 	/* now close the pipe for addr 0 */
60217c478bd9Sstevel@tonic-gate 	usb_pipe_close(child_dip, ph,
60227c478bd9Sstevel@tonic-gate 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
60237c478bd9Sstevel@tonic-gate 
60247c478bd9Sstevel@tonic-gate 	/*
60257c478bd9Sstevel@tonic-gate 	 * This delay is important for the CATC hub to enumerate
60267c478bd9Sstevel@tonic-gate 	 * But, avoid delay in the first iteration
60277c478bd9Sstevel@tonic-gate 	 */
60287c478bd9Sstevel@tonic-gate 	if (iteration) {
60297c478bd9Sstevel@tonic-gate 		delay(drv_usectohz(hubd_device_delay/100));
60307c478bd9Sstevel@tonic-gate 	}
60317c478bd9Sstevel@tonic-gate 
60327c478bd9Sstevel@tonic-gate 	/* assign the address in the usba_device structure */
60337c478bd9Sstevel@tonic-gate 	mutex_enter(&child_ud->usb_mutex);
60347c478bd9Sstevel@tonic-gate 	child_ud->usb_addr = address;
60357c478bd9Sstevel@tonic-gate 	child_ud->usb_no_cpr = 0;
60367c478bd9Sstevel@tonic-gate 	child_ud->usb_port_status = port_status;
60377c478bd9Sstevel@tonic-gate 	/* save this device descriptor */
60387c478bd9Sstevel@tonic-gate 	bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
6039c0f24e5bSlg 	    sizeof (usb_dev_descr_t));
60407c478bd9Sstevel@tonic-gate 	child_ud->usb_n_cfgs = usb_dev_descr.bNumConfigurations;
60417c478bd9Sstevel@tonic-gate 	mutex_exit(&child_ud->usb_mutex);
60427c478bd9Sstevel@tonic-gate 
60437c478bd9Sstevel@tonic-gate 	/* re-open the pipe for the device with the new address */
60447c478bd9Sstevel@tonic-gate 	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
60457c478bd9Sstevel@tonic-gate 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) != USB_SUCCESS) {
6046d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
60477c478bd9Sstevel@tonic-gate 		    "usb_pipe_open failed (%d)", rval);
60487c478bd9Sstevel@tonic-gate 
60497c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
60507c478bd9Sstevel@tonic-gate 	}
60517c478bd9Sstevel@tonic-gate 
60527c478bd9Sstevel@tonic-gate 	/*
60537c478bd9Sstevel@tonic-gate 	 * Get full device descriptor only if we have not received full
60547c478bd9Sstevel@tonic-gate 	 * device descriptor earlier.
60557c478bd9Sstevel@tonic-gate 	 */
60567c478bd9Sstevel@tonic-gate 	if (size < length) {
60577c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
60587c478bd9Sstevel@tonic-gate 		    "hubd_create_child: get full device descriptor: "
60597c478bd9Sstevel@tonic-gate 		    "%d bytes", length);
60607c478bd9Sstevel@tonic-gate 
60617c478bd9Sstevel@tonic-gate 		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
60627c478bd9Sstevel@tonic-gate 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
60637c478bd9Sstevel@tonic-gate 		    USB_REQ_GET_DESCR,			/* bRequest */
60647c478bd9Sstevel@tonic-gate 		    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
60657c478bd9Sstevel@tonic-gate 		    0,					/* wIndex */
60667c478bd9Sstevel@tonic-gate 		    length,				/* wLength */
60677c478bd9Sstevel@tonic-gate 		    &pdata, 0,
60687c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
60697c478bd9Sstevel@tonic-gate 			freemsg(pdata);
60707c478bd9Sstevel@tonic-gate 			pdata = NULL;
60717c478bd9Sstevel@tonic-gate 
60727c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
60737c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
60747c478bd9Sstevel@tonic-gate 			    "hubd_create_child: get full device descriptor: "
60757c478bd9Sstevel@tonic-gate 			    "64 bytes");
60767c478bd9Sstevel@tonic-gate 
60777c478bd9Sstevel@tonic-gate 			rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
60787c478bd9Sstevel@tonic-gate 			    USB_DEV_REQ_DEV_TO_HOST |
60797c478bd9Sstevel@tonic-gate 			    USB_DEV_REQ_TYPE_STANDARD,
60807c478bd9Sstevel@tonic-gate 			    USB_REQ_GET_DESCR,		/* bRequest */
60817c478bd9Sstevel@tonic-gate 			    USB_DESCR_TYPE_SETUP_DEV,	/* wValue */
60827c478bd9Sstevel@tonic-gate 			    0,				/* wIndex */
60837c478bd9Sstevel@tonic-gate 			    64,				/* wLength */
60847c478bd9Sstevel@tonic-gate 			    &pdata, USB_ATTRS_SHORT_XFER_OK,
60857c478bd9Sstevel@tonic-gate 			    &completion_reason, &cb_flags, 0);
60867c478bd9Sstevel@tonic-gate 
60877c478bd9Sstevel@tonic-gate 			/* we have to trust the data now */
60887c478bd9Sstevel@tonic-gate 			if (pdata) {
60897c478bd9Sstevel@tonic-gate 				int len = *(pdata->b_rptr);
60907c478bd9Sstevel@tonic-gate 
6091d29f5a71Szhigang lu - Sun Microsystems - Beijing China 				length = MBLKL(pdata);
60927c478bd9Sstevel@tonic-gate 				if (length < len) {
60937c478bd9Sstevel@tonic-gate 
60947c478bd9Sstevel@tonic-gate 					goto fail_cleanup;
60957c478bd9Sstevel@tonic-gate 				}
60967c478bd9Sstevel@tonic-gate 			} else if (rval != USB_SUCCESS) {
6097d291d9f2Sfrits 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
60987c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
60997c478bd9Sstevel@tonic-gate 				    "getting device descriptor failed "
61007c478bd9Sstevel@tonic-gate 				    "(%d 0x%x %d)",
6101c0f24e5bSlg 				    completion_reason, cb_flags, rval);
61027c478bd9Sstevel@tonic-gate 
61037c478bd9Sstevel@tonic-gate 				goto fail_cleanup;
61047c478bd9Sstevel@tonic-gate 			}
61057c478bd9Sstevel@tonic-gate 		}
61067c478bd9Sstevel@tonic-gate 
61077c478bd9Sstevel@tonic-gate 		size = usb_parse_dev_descr(
6108c0f24e5bSlg 		    pdata->b_rptr,
6109d29f5a71Szhigang lu - Sun Microsystems - Beijing China 		    MBLKL(pdata),
6110c0f24e5bSlg 		    &usb_dev_descr,
6111c0f24e5bSlg 		    sizeof (usb_dev_descr_t));
61127c478bd9Sstevel@tonic-gate 
61137c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
61147c478bd9Sstevel@tonic-gate 		    "parsing device descriptor returned %lu", size);
61157c478bd9Sstevel@tonic-gate 
61167c478bd9Sstevel@tonic-gate 		/*
61177c478bd9Sstevel@tonic-gate 		 * For now, free the data
61187c478bd9Sstevel@tonic-gate 		 * eventually, each configuration may need to be looked at
61197c478bd9Sstevel@tonic-gate 		 */
61207c478bd9Sstevel@tonic-gate 		freemsg(pdata);
61217c478bd9Sstevel@tonic-gate 		pdata = NULL;
61227c478bd9Sstevel@tonic-gate 
61237c478bd9Sstevel@tonic-gate 		if (size != USB_DEV_DESCR_SIZE) {
6124d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
61257c478bd9Sstevel@tonic-gate 			    "fail enumeration: descriptor size=%lu "
61267c478bd9Sstevel@tonic-gate 			    "expected size=%u", size, USB_DEV_DESCR_SIZE);
61277c478bd9Sstevel@tonic-gate 
61287c478bd9Sstevel@tonic-gate 			goto fail_cleanup;
61297c478bd9Sstevel@tonic-gate 		}
61307c478bd9Sstevel@tonic-gate 
61317c478bd9Sstevel@tonic-gate 		/*
61327c478bd9Sstevel@tonic-gate 		 * save the device descriptor in usba_device since it is needed
61337c478bd9Sstevel@tonic-gate 		 * later on again
61347c478bd9Sstevel@tonic-gate 		 */
61357c478bd9Sstevel@tonic-gate 		mutex_enter(&child_ud->usb_mutex);
61367c478bd9Sstevel@tonic-gate 		bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
6137c0f24e5bSlg 		    sizeof (usb_dev_descr_t));
61387c478bd9Sstevel@tonic-gate 		child_ud->usb_n_cfgs = usb_dev_descr.bNumConfigurations;
61397c478bd9Sstevel@tonic-gate 		mutex_exit(&child_ud->usb_mutex);
61407c478bd9Sstevel@tonic-gate 	}
61417c478bd9Sstevel@tonic-gate 
61427c478bd9Sstevel@tonic-gate 	if (usb_dev_descr.bNumConfigurations == 0) {
6143d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
61447c478bd9Sstevel@tonic-gate 		    "device descriptor:\n\t"
61457c478bd9Sstevel@tonic-gate 		    "l=0x%x type=0x%x USB=0x%x class=0x%x subclass=0x%x\n\t"
61467c478bd9Sstevel@tonic-gate 		    "protocol=0x%x maxpktsize=0x%x "
61477c478bd9Sstevel@tonic-gate 		    "Vid=0x%x Pid=0x%x rel=0x%x\n\t"
61487c478bd9Sstevel@tonic-gate 		    "Mfg=0x%x P=0x%x sn=0x%x #config=0x%x",
61497c478bd9Sstevel@tonic-gate 		    usb_dev_descr.bLength, usb_dev_descr.bDescriptorType,
61507c478bd9Sstevel@tonic-gate 		    usb_dev_descr.bcdUSB, usb_dev_descr.bDeviceClass,
61517c478bd9Sstevel@tonic-gate 		    usb_dev_descr.bDeviceSubClass,
61527c478bd9Sstevel@tonic-gate 		    usb_dev_descr.bDeviceProtocol,
61537c478bd9Sstevel@tonic-gate 		    usb_dev_descr.bMaxPacketSize0,
61547c478bd9Sstevel@tonic-gate 		    usb_dev_descr.idVendor,
61557c478bd9Sstevel@tonic-gate 		    usb_dev_descr.idProduct, usb_dev_descr.bcdDevice,
61567c478bd9Sstevel@tonic-gate 		    usb_dev_descr.iManufacturer, usb_dev_descr.iProduct,
61577c478bd9Sstevel@tonic-gate 		    usb_dev_descr.iSerialNumber,
61587c478bd9Sstevel@tonic-gate 		    usb_dev_descr.bNumConfigurations);
61597c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
61607c478bd9Sstevel@tonic-gate 	}
61617c478bd9Sstevel@tonic-gate 
61627c478bd9Sstevel@tonic-gate 
61637c478bd9Sstevel@tonic-gate 	/* get the device string descriptor(s) */
61647c478bd9Sstevel@tonic-gate 	usba_get_dev_string_descrs(child_dip, child_ud);
61657c478bd9Sstevel@tonic-gate 
61667c478bd9Sstevel@tonic-gate 	/* retrieve config cloud for all configurations */
61677c478bd9Sstevel@tonic-gate 	rval = hubd_get_all_device_config_cloud(hubd, child_dip, child_ud);
61687c478bd9Sstevel@tonic-gate 	if (rval != USB_SUCCESS) {
6169d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
61707c478bd9Sstevel@tonic-gate 		    "failed to get configuration descriptor(s)");
61717c478bd9Sstevel@tonic-gate 
61727c478bd9Sstevel@tonic-gate 		goto fail_cleanup;
61737c478bd9Sstevel@tonic-gate 	}
61747c478bd9Sstevel@tonic-gate 
61757c478bd9Sstevel@tonic-gate 	/* get the preferred configuration for this device */
61767c478bd9Sstevel@tonic-gate 	user_conf_index = hubd_select_device_configuration(hubd, port,
61777c478bd9Sstevel@tonic-gate 	    child_dip, child_ud);
61787c478bd9Sstevel@tonic-gate 
61797c478bd9Sstevel@tonic-gate 	/* Check if the user selected configuration index is in range */
618035f36846Ssl 	if ((user_conf_index >= usb_dev_descr.bNumConfigurations) ||
618135f36846Ssl 	    (user_conf_index < 0)) {
6182d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
61837c478bd9Sstevel@tonic-gate 		    "Configuration index for device idVendor=%d "
61847c478bd9Sstevel@tonic-gate 		    "idProduct=%d is=%d, and is out of range[0..%d]",
61857c478bd9Sstevel@tonic-gate 		    usb_dev_descr.idVendor, usb_dev_descr.idProduct,
61867c478bd9Sstevel@tonic-gate 		    user_conf_index, usb_dev_descr.bNumConfigurations - 1);
61877c478bd9Sstevel@tonic-gate 
61887c478bd9Sstevel@tonic-gate 		/* treat this as user didn't specify configuration */
61897c478bd9Sstevel@tonic-gate 		user_conf_index = USBA_DEV_CONFIG_INDEX_UNDEFINED;
61907c478bd9Sstevel@tonic-gate 	}
61917c478bd9Sstevel@tonic-gate 
61927c478bd9Sstevel@tonic-gate 
61937c478bd9Sstevel@tonic-gate 	/*
61947c478bd9Sstevel@tonic-gate 	 * Warn users of a performance hit if connecting a
61957c478bd9Sstevel@tonic-gate 	 * High Speed behind a 1.1 hub, which is behind a
61967c478bd9Sstevel@tonic-gate 	 * 2.0 port.
61977c478bd9Sstevel@tonic-gate 	 */
61987c478bd9Sstevel@tonic-gate 	if ((parent_port_status != USBA_HIGH_SPEED_DEV) &&
61997c478bd9Sstevel@tonic-gate 	    !(usba_is_root_hub(parent_ud->usb_dip)) &&
62007c478bd9Sstevel@tonic-gate 	    (parent_usb_addr)) {
62017c478bd9Sstevel@tonic-gate 
62027c478bd9Sstevel@tonic-gate 		/*
62037c478bd9Sstevel@tonic-gate 		 * Now that we know the root port is a high speed port
62047c478bd9Sstevel@tonic-gate 		 * and that the parent port is not a high speed port,
62057c478bd9Sstevel@tonic-gate 		 * let's find out if the device itself is a high speed
62067c478bd9Sstevel@tonic-gate 		 * device.  If it is a high speed device,
62077c478bd9Sstevel@tonic-gate 		 * USB_DESCR_TYPE_SETUP_DEV_QLF should return a value,
62087c478bd9Sstevel@tonic-gate 		 * otherwise the command will fail.
62097c478bd9Sstevel@tonic-gate 		 */
62107c478bd9Sstevel@tonic-gate 		rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
62117c478bd9Sstevel@tonic-gate 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
62127c478bd9Sstevel@tonic-gate 		    USB_REQ_GET_DESCR,			/* bRequest */
62137c478bd9Sstevel@tonic-gate 		    USB_DESCR_TYPE_SETUP_DEV_QLF,	/* wValue */
62147c478bd9Sstevel@tonic-gate 		    0,					/* wIndex */
62157c478bd9Sstevel@tonic-gate 		    10,					/* wLength */
62167c478bd9Sstevel@tonic-gate 		    &pdata, USB_ATTRS_SHORT_XFER_OK,
62177c478bd9Sstevel@tonic-gate 		    &completion_reason, &cb_flags, 0);
62187c478bd9Sstevel@tonic-gate 
62197c478bd9Sstevel@tonic-gate 		if (pdata) {
62207c478bd9Sstevel@tonic-gate 			freemsg(pdata);
62217c478bd9Sstevel@tonic-gate 			pdata = NULL;
62227c478bd9Sstevel@tonic-gate 		}
62237c478bd9Sstevel@tonic-gate 
62247c478bd9Sstevel@tonic-gate 		/*
62257c478bd9Sstevel@tonic-gate 		 * USB_DESCR_TYPE_SETUP_DEV_QLF query was successful
62267c478bd9Sstevel@tonic-gate 		 * that means this is a high speed device behind a
62277c478bd9Sstevel@tonic-gate 		 * high speed root hub, but running at full speed
62287c478bd9Sstevel@tonic-gate 		 * because there is a full speed hub in the middle.
62297c478bd9Sstevel@tonic-gate 		 */
62307c478bd9Sstevel@tonic-gate 		if (rval == USB_SUCCESS) {
6231c0f24e5bSlg 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
6232c0f24e5bSlg 			    hubd->h_log_handle,
6233c0f24e5bSlg 			    "Connecting a high speed device to a "
6234c0f24e5bSlg 			    "non high speed hub (port %d) will result "
6235112cd14aSqz 			    "in a loss of performance.	Please connect "
6236c0f24e5bSlg 			    "the device to a high speed hub to get "
6237c0f24e5bSlg 			    "the maximum performance.",
6238c0f24e5bSlg 			    port);
62397c478bd9Sstevel@tonic-gate 		}
62407c478bd9Sstevel@tonic-gate 	}
62417c478bd9Sstevel@tonic-gate 
62427c478bd9Sstevel@tonic-gate 	/*
62437c478bd9Sstevel@tonic-gate 	 * Now we try to online the device by attaching a driver
62447c478bd9Sstevel@tonic-gate 	 * The following truth table illustrates the logic:-
62457c478bd9Sstevel@tonic-gate 	 * Cfgndx	Driver	Action
62467c478bd9Sstevel@tonic-gate 	 * 0		0	loop all configs for driver with full
62477c478bd9Sstevel@tonic-gate 	 *			compatible properties.
62487c478bd9Sstevel@tonic-gate 	 * 0		1	set first configuration,
62497c478bd9Sstevel@tonic-gate 	 *			compatible prop = drivername.
62507c478bd9Sstevel@tonic-gate 	 * 1		0	Set config, full compatible prop
62517c478bd9Sstevel@tonic-gate 	 * 1		1	Set config, compatible prop = drivername.
62527c478bd9Sstevel@tonic-gate 	 *
62537c478bd9Sstevel@tonic-gate 	 * Note:
62547c478bd9Sstevel@tonic-gate 	 *	cfgndx = user_conf_index
62557c478bd9Sstevel@tonic-gate 	 *	Driver = usb_preferred_driver
62567c478bd9Sstevel@tonic-gate 	 */
62577c478bd9Sstevel@tonic-gate 	if (user_conf_index == USBA_DEV_CONFIG_INDEX_UNDEFINED) {
62587c478bd9Sstevel@tonic-gate 		if (child_ud->usb_preferred_driver) {
62597c478bd9Sstevel@tonic-gate 			/*
62607c478bd9Sstevel@tonic-gate 			 * It is the job of the "preferred driver" to put the
62617c478bd9Sstevel@tonic-gate 			 * device in the desired configuration. Till then
62627c478bd9Sstevel@tonic-gate 			 * put the device in config index 0.
62637c478bd9Sstevel@tonic-gate 			 */
626435f36846Ssl 			if ((rval = usba_hubdi_check_power_budget(dip, child_ud,
626535f36846Ssl 			    USB_DEV_DEFAULT_CONFIG_INDEX)) != USB_SUCCESS) {
626635f36846Ssl 
626735f36846Ssl 				goto fail_cleanup;
626835f36846Ssl 			}
626935f36846Ssl 
62707c478bd9Sstevel@tonic-gate 			child_dip = hubd_ready_device(hubd, child_dip,
62717c478bd9Sstevel@tonic-gate 			    child_ud, USB_DEV_DEFAULT_CONFIG_INDEX);
62727c478bd9Sstevel@tonic-gate 
62737c478bd9Sstevel@tonic-gate 			/*
62747c478bd9Sstevel@tonic-gate 			 * Assign the dip before onlining to avoid race
62757c478bd9Sstevel@tonic-gate 			 * with busctl
62767c478bd9Sstevel@tonic-gate 			 */
62777c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
62787c478bd9Sstevel@tonic-gate 			hubd->h_children_dips[port] = child_dip;
62797c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
62807c478bd9Sstevel@tonic-gate 
62817c478bd9Sstevel@tonic-gate 			(void) usba_bind_driver(child_dip);
62827c478bd9Sstevel@tonic-gate 		} else {
62837c478bd9Sstevel@tonic-gate 			/*
62847c478bd9Sstevel@tonic-gate 			 * loop through all the configurations to see if we
62857c478bd9Sstevel@tonic-gate 			 * can find a driver for any one config. If not, set
62867c478bd9Sstevel@tonic-gate 			 * the device in config_index 0
62877c478bd9Sstevel@tonic-gate 			 */
62887c478bd9Sstevel@tonic-gate 			rval = USB_FAILURE;
62897c478bd9Sstevel@tonic-gate 			for (config_index = 0;
62907c478bd9Sstevel@tonic-gate 			    (config_index < usb_dev_descr.bNumConfigurations) &&
62917c478bd9Sstevel@tonic-gate 			    (rval != USB_SUCCESS); config_index++) {
62927c478bd9Sstevel@tonic-gate 
62937c478bd9Sstevel@tonic-gate 				child_dip = hubd_ready_device(hubd, child_dip,
62947c478bd9Sstevel@tonic-gate 				    child_ud, config_index);
62957c478bd9Sstevel@tonic-gate 
62967c478bd9Sstevel@tonic-gate 				/*
62977c478bd9Sstevel@tonic-gate 				 * Assign the dip before onlining to avoid race
62987c478bd9Sstevel@tonic-gate 				 * with busctl
62997c478bd9Sstevel@tonic-gate 				 */
63007c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
63017c478bd9Sstevel@tonic-gate 				hubd->h_children_dips[port] = child_dip;
63027c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
63037c478bd9Sstevel@tonic-gate 
63047c478bd9Sstevel@tonic-gate 				rval = usba_bind_driver(child_dip);
630535f36846Ssl 
630635f36846Ssl 				/*
630735f36846Ssl 				 * Normally power budget should be checked
630835f36846Ssl 				 * before device is configured. A failure in
630935f36846Ssl 				 * power budget checking will stop the device
631035f36846Ssl 				 * from being configured with current
631135f36846Ssl 				 * config_index and may enable the device to
631235f36846Ssl 				 * be configured in another configuration.
631335f36846Ssl 				 * This may break the user experience that a
631435f36846Ssl 				 * device which previously worked in config
631535f36846Ssl 				 * A now works in config B after power budget
631635f36846Ssl 				 * control is enabled. To avoid such situation,
631735f36846Ssl 				 * power budget checking is moved here and will
631835f36846Ssl 				 * fail the child creation directly if config
631935f36846Ssl 				 * A exceeds the power available.
632035f36846Ssl 				 */
632135f36846Ssl 				if (rval == USB_SUCCESS) {
632235f36846Ssl 					if ((usba_hubdi_check_power_budget(dip,
632335f36846Ssl 					    child_ud, config_index)) !=
632435f36846Ssl 					    USB_SUCCESS) {
632535f36846Ssl 
632635f36846Ssl 						goto fail_cleanup;
632735f36846Ssl 					}
632835f36846Ssl 				}
63297c478bd9Sstevel@tonic-gate 			}
63307c478bd9Sstevel@tonic-gate 			if (rval != USB_SUCCESS) {
633135f36846Ssl 
633235f36846Ssl 				if ((usba_hubdi_check_power_budget(dip,
633335f36846Ssl 				    child_ud, 0)) != USB_SUCCESS) {
633435f36846Ssl 
633535f36846Ssl 					goto fail_cleanup;
633635f36846Ssl 				}
633735f36846Ssl 
63387c478bd9Sstevel@tonic-gate 				child_dip = hubd_ready_device(hubd, child_dip,
63397c478bd9Sstevel@tonic-gate 				    child_ud, 0);
63407c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
63417c478bd9Sstevel@tonic-gate 				hubd->h_children_dips[port] = child_dip;
63427c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
63437c478bd9Sstevel@tonic-gate 			}
63447c478bd9Sstevel@tonic-gate 		} /* end else loop all configs */
63457c478bd9Sstevel@tonic-gate 	} else {
634635f36846Ssl 
634735f36846Ssl 		if ((usba_hubdi_check_power_budget(dip, child_ud,
634835f36846Ssl 		    (uint_t)user_conf_index)) != USB_SUCCESS) {
634935f36846Ssl 
635035f36846Ssl 			goto fail_cleanup;
635135f36846Ssl 		}
635235f36846Ssl 
63537c478bd9Sstevel@tonic-gate 		child_dip = hubd_ready_device(hubd, child_dip,
635435f36846Ssl 		    child_ud, (uint_t)user_conf_index);
63557c478bd9Sstevel@tonic-gate 
63567c478bd9Sstevel@tonic-gate 		/*
63577c478bd9Sstevel@tonic-gate 		 * Assign the dip before onlining to avoid race
63587c478bd9Sstevel@tonic-gate 		 * with busctl
63597c478bd9Sstevel@tonic-gate 		 */
63607c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
63617c478bd9Sstevel@tonic-gate 		hubd->h_children_dips[port] = child_dip;
63627c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
63637c478bd9Sstevel@tonic-gate 
63647c478bd9Sstevel@tonic-gate 		(void) usba_bind_driver(child_dip);
63657c478bd9Sstevel@tonic-gate 	}
63667c478bd9Sstevel@tonic-gate 
636735f36846Ssl 	usba_hubdi_decr_power_budget(dip, child_ud);
636835f36846Ssl 
63697c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
63707c478bd9Sstevel@tonic-gate 	if (hubd->h_usba_devices[port] == NULL) {
63717c478bd9Sstevel@tonic-gate 		hubd->h_usba_devices[port] = usba_get_usba_device(child_dip);
63727c478bd9Sstevel@tonic-gate 	} else {
63737c478bd9Sstevel@tonic-gate 		ASSERT(hubd->h_usba_devices[port] ==
6374c0f24e5bSlg 		    usba_get_usba_device(child_dip));
63757c478bd9Sstevel@tonic-gate 	}
63767c478bd9Sstevel@tonic-gate 
63777c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
63787c478bd9Sstevel@tonic-gate 
63797c478bd9Sstevel@tonic-gate 
63807c478bd9Sstevel@tonic-gate fail_cleanup:
63817c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
63827c478bd9Sstevel@tonic-gate 	    "hubd_create_child: fail_cleanup");
63837c478bd9Sstevel@tonic-gate 
63847c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
63857c478bd9Sstevel@tonic-gate 	hubd->h_children_dips[port] = NULL;
63867c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
63877c478bd9Sstevel@tonic-gate 
63887c478bd9Sstevel@tonic-gate 	if (pdata) {
63897c478bd9Sstevel@tonic-gate 		freemsg(pdata);
63907c478bd9Sstevel@tonic-gate 	}
63917c478bd9Sstevel@tonic-gate 
63927c478bd9Sstevel@tonic-gate 	if (ph) {
63937c478bd9Sstevel@tonic-gate 		usb_pipe_close(child_dip, ph,
63947c478bd9Sstevel@tonic-gate 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
63957c478bd9Sstevel@tonic-gate 	}
63967c478bd9Sstevel@tonic-gate 
63977c478bd9Sstevel@tonic-gate 	if (child_dip) {
63987c478bd9Sstevel@tonic-gate 		int rval = usba_destroy_child_devi(child_dip,
63997c478bd9Sstevel@tonic-gate 		    NDI_DEVI_REMOVE);
64007c478bd9Sstevel@tonic-gate 		if (rval != USB_SUCCESS) {
6401d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
64027c478bd9Sstevel@tonic-gate 			    "failure to remove child node");
64037c478bd9Sstevel@tonic-gate 		}
64047c478bd9Sstevel@tonic-gate 	}
64057c478bd9Sstevel@tonic-gate 
64067c478bd9Sstevel@tonic-gate 	if (child_ud) {
64077c478bd9Sstevel@tonic-gate 		/* to make sure we free the address */
64087c478bd9Sstevel@tonic-gate 		mutex_enter(&child_ud->usb_mutex);
64097c478bd9Sstevel@tonic-gate 		child_ud->usb_addr = address;
64107c478bd9Sstevel@tonic-gate 		ASSERT(child_ud->usb_ref_count == 0);
64117c478bd9Sstevel@tonic-gate 		mutex_exit(&child_ud->usb_mutex);
64127c478bd9Sstevel@tonic-gate 
64137c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
64147c478bd9Sstevel@tonic-gate 		if (hubd->h_usba_devices[port] == NULL) {
64157c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
64167c478bd9Sstevel@tonic-gate 			usba_free_usba_device(child_ud);
64177c478bd9Sstevel@tonic-gate 		} else {
64187c478bd9Sstevel@tonic-gate 			hubd_free_usba_device(hubd, hubd->h_usba_devices[port]);
64197c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
64207c478bd9Sstevel@tonic-gate 		}
64217c478bd9Sstevel@tonic-gate 	}
64227c478bd9Sstevel@tonic-gate 
64237c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
64247c478bd9Sstevel@tonic-gate 
64257c478bd9Sstevel@tonic-gate 	return (USB_FAILURE);
64267c478bd9Sstevel@tonic-gate }
64277c478bd9Sstevel@tonic-gate 
64287c478bd9Sstevel@tonic-gate 
64297c478bd9Sstevel@tonic-gate /*
64307c478bd9Sstevel@tonic-gate  * hubd_delete_child:
64317c478bd9Sstevel@tonic-gate  *	- free usb address
64327c478bd9Sstevel@tonic-gate  *	- lookup child dips, there may be multiple on this port
64337c478bd9Sstevel@tonic-gate  *	- offline each child devi
64347c478bd9Sstevel@tonic-gate  */
64357c478bd9Sstevel@tonic-gate static int
64367c478bd9Sstevel@tonic-gate hubd_delete_child(hubd_t *hubd, usb_port_t port, uint_t flag, boolean_t retry)
64377c478bd9Sstevel@tonic-gate {
64387c478bd9Sstevel@tonic-gate 	dev_info_t	*child_dip;
64397c478bd9Sstevel@tonic-gate 	usba_device_t	*usba_device;
64407c478bd9Sstevel@tonic-gate 	int		rval = USB_SUCCESS;
64417c478bd9Sstevel@tonic-gate 
64427c478bd9Sstevel@tonic-gate 	child_dip = hubd->h_children_dips[port];
644335f36846Ssl 	usba_device = hubd->h_usba_devices[port];
64447c478bd9Sstevel@tonic-gate 
64457c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
64467c478bd9Sstevel@tonic-gate 	    "hubd_delete_child: port=%d, dip=0x%p usba_device=0x%p",
6447112116d8Sfb 	    port, (void *)child_dip, (void *)usba_device);
64487c478bd9Sstevel@tonic-gate 
64497c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
64507c478bd9Sstevel@tonic-gate 	if (child_dip) {
64517c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
64527c478bd9Sstevel@tonic-gate 		    "hubd_delete_child:\n\t"
64537c478bd9Sstevel@tonic-gate 		    "dip = 0x%p (%s) at port %d",
6454112116d8Sfb 		    (void *)child_dip, ddi_node_name(child_dip), port);
64557c478bd9Sstevel@tonic-gate 
645635f36846Ssl 		if (usba_device) {
645735f36846Ssl 			usba_hubdi_incr_power_budget(hubd->h_dip, usba_device);
645835f36846Ssl 		}
645935f36846Ssl 
64607c478bd9Sstevel@tonic-gate 		rval = usba_destroy_child_devi(child_dip, flag);
64617c478bd9Sstevel@tonic-gate 
6462ff0e937bSRaymond Chen 		if ((rval != USB_SUCCESS) && usba_is_hwa(child_dip)) {
6463ff0e937bSRaymond Chen 			/*
6464ff0e937bSRaymond Chen 			 * This is only useful for HWA device node.
6465ff0e937bSRaymond Chen 			 * Since hwahc interface must hold hwarc interface
6466ff0e937bSRaymond Chen 			 * open until hwahc is detached, the first call to
6467ff0e937bSRaymond Chen 			 * ndi_devi_unconfig_one() can only offline hwahc
6468ff0e937bSRaymond Chen 			 * driver but not hwarc driver. Need to make a second
6469ff0e937bSRaymond Chen 			 * call to ndi_devi_unconfig_one() to make the hwarc
6470ff0e937bSRaymond Chen 			 * driver detach.
6471ff0e937bSRaymond Chen 			 */
6472ff0e937bSRaymond Chen 			rval = usba_destroy_child_devi(child_dip, flag);
6473ff0e937bSRaymond Chen 		}
6474ff0e937bSRaymond Chen 
64757c478bd9Sstevel@tonic-gate 		if ((rval == USB_SUCCESS) && (flag & NDI_DEVI_REMOVE)) {
64767c478bd9Sstevel@tonic-gate 			/*
64777c478bd9Sstevel@tonic-gate 			 * if the child was still < DS_INITIALIZED
64787c478bd9Sstevel@tonic-gate 			 * then our bus_unconfig was not called and
64797c478bd9Sstevel@tonic-gate 			 * we have to zap the child here
64807c478bd9Sstevel@tonic-gate 			 */
64817c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
64827c478bd9Sstevel@tonic-gate 			if (hubd->h_children_dips[port] == child_dip) {
64837c478bd9Sstevel@tonic-gate 				usba_device_t *ud =
6484c0f24e5bSlg 				    hubd->h_usba_devices[port];
6485ffcd51f3Slg 					hubd->h_children_dips[port] = NULL;
64867c478bd9Sstevel@tonic-gate 				if (ud) {
64877c478bd9Sstevel@tonic-gate 					mutex_exit(HUBD_MUTEX(hubd));
64887c478bd9Sstevel@tonic-gate 
64897c478bd9Sstevel@tonic-gate 					mutex_enter(&ud->usb_mutex);
64907c478bd9Sstevel@tonic-gate 					ud->usb_ref_count = 0;
64917c478bd9Sstevel@tonic-gate 					mutex_exit(&ud->usb_mutex);
64927c478bd9Sstevel@tonic-gate 
64937c478bd9Sstevel@tonic-gate 					usba_free_usba_device(ud);
64947c478bd9Sstevel@tonic-gate 					mutex_enter(HUBD_MUTEX(hubd));
64957c478bd9Sstevel@tonic-gate 					hubd->h_usba_devices[port] = NULL;
64967c478bd9Sstevel@tonic-gate 				}
64977c478bd9Sstevel@tonic-gate 			}
64987c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
64997c478bd9Sstevel@tonic-gate 		}
65007c478bd9Sstevel@tonic-gate 	}
65017c478bd9Sstevel@tonic-gate 
65027c478bd9Sstevel@tonic-gate 	if ((rval != USB_SUCCESS) && retry) {
65037c478bd9Sstevel@tonic-gate 
65047c478bd9Sstevel@tonic-gate 		hubd_schedule_cleanup(usba_device->usb_root_hub_dip);
65057c478bd9Sstevel@tonic-gate 	}
65067c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
65077c478bd9Sstevel@tonic-gate 
65087c478bd9Sstevel@tonic-gate 	return (rval);
65097c478bd9Sstevel@tonic-gate }
65107c478bd9Sstevel@tonic-gate 
65117c478bd9Sstevel@tonic-gate 
65127c478bd9Sstevel@tonic-gate /*
65137c478bd9Sstevel@tonic-gate  * hubd_free_usba_device:
65147c478bd9Sstevel@tonic-gate  *	free usb device structure unless it is associated with
65157c478bd9Sstevel@tonic-gate  *	the root hub which is handled differently
65167c478bd9Sstevel@tonic-gate  */
65177c478bd9Sstevel@tonic-gate static void
65187c478bd9Sstevel@tonic-gate hubd_free_usba_device(hubd_t *hubd, usba_device_t *usba_device)
65197c478bd9Sstevel@tonic-gate {
65207c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
65217c478bd9Sstevel@tonic-gate 	    "hubd_free_usba_device: hubd=0x%p, usba_device=0x%p",
6522112116d8Sfb 	    (void *)hubd, (void *)usba_device);
65237c478bd9Sstevel@tonic-gate 
65247c478bd9Sstevel@tonic-gate 	if (usba_device && (usba_device->usb_addr != ROOT_HUB_ADDR)) {
65257c478bd9Sstevel@tonic-gate 		usb_port_t port = usba_device->usb_port;
65267c478bd9Sstevel@tonic-gate 		dev_info_t *dip = hubd->h_children_dips[port];
65277c478bd9Sstevel@tonic-gate 
65287c478bd9Sstevel@tonic-gate #ifdef DEBUG
65297c478bd9Sstevel@tonic-gate 		if (dip) {
65307c478bd9Sstevel@tonic-gate 			ASSERT(i_ddi_node_state(dip) < DS_INITIALIZED);
65317c478bd9Sstevel@tonic-gate 		}
65327c478bd9Sstevel@tonic-gate #endif
65337c478bd9Sstevel@tonic-gate 
65347c478bd9Sstevel@tonic-gate 		port = usba_device->usb_port;
65357c478bd9Sstevel@tonic-gate 		hubd->h_usba_devices[port] = NULL;
65367c478bd9Sstevel@tonic-gate 
65377c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
65387c478bd9Sstevel@tonic-gate 		usba_free_usba_device(usba_device);
65397c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
65407c478bd9Sstevel@tonic-gate 	}
65417c478bd9Sstevel@tonic-gate }
65427c478bd9Sstevel@tonic-gate 
65437c478bd9Sstevel@tonic-gate 
65447c478bd9Sstevel@tonic-gate /*
65457c478bd9Sstevel@tonic-gate  * event support
65467c478bd9Sstevel@tonic-gate  *
65477c478bd9Sstevel@tonic-gate  * busctl event support
65487c478bd9Sstevel@tonic-gate  */
65497c478bd9Sstevel@tonic-gate static int
65507c478bd9Sstevel@tonic-gate hubd_busop_get_eventcookie(dev_info_t *dip,
65517c478bd9Sstevel@tonic-gate 	dev_info_t	*rdip,
65527c478bd9Sstevel@tonic-gate 	char		*eventname,
65537c478bd9Sstevel@tonic-gate 	ddi_eventcookie_t *cookie)
65547c478bd9Sstevel@tonic-gate {
65557c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
65567c478bd9Sstevel@tonic-gate 
65577c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
65587c478bd9Sstevel@tonic-gate 	    "hubd_busop_get_eventcookie: dip=0x%p, rdip=0x%p, "
65597c478bd9Sstevel@tonic-gate 	    "event=%s", (void *)dip, (void *)rdip, eventname);
65607c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
65617c478bd9Sstevel@tonic-gate 	    "(dip=%s%d, rdip=%s%d)",
65627c478bd9Sstevel@tonic-gate 	    ddi_driver_name(dip), ddi_get_instance(dip),
65637c478bd9Sstevel@tonic-gate 	    ddi_driver_name(rdip), ddi_get_instance(rdip));
65647c478bd9Sstevel@tonic-gate 
65657c478bd9Sstevel@tonic-gate 	/* return event cookie, iblock cookie, and level */
65667c478bd9Sstevel@tonic-gate 	return (ndi_event_retrieve_cookie(hubd->h_ndi_event_hdl,
6567c0f24e5bSlg 	    rdip, eventname, cookie, NDI_EVENT_NOPASS));
65687c478bd9Sstevel@tonic-gate }
65697c478bd9Sstevel@tonic-gate 
65707c478bd9Sstevel@tonic-gate 
65717c478bd9Sstevel@tonic-gate static int
65727c478bd9Sstevel@tonic-gate hubd_busop_add_eventcall(dev_info_t *dip,
65737c478bd9Sstevel@tonic-gate 	dev_info_t	*rdip,
65747c478bd9Sstevel@tonic-gate 	ddi_eventcookie_t cookie,
65757c478bd9Sstevel@tonic-gate 	void		(*callback)(dev_info_t *dip,
65767c478bd9Sstevel@tonic-gate 			ddi_eventcookie_t cookie, void *arg,
65777c478bd9Sstevel@tonic-gate 			void *bus_impldata),
65787c478bd9Sstevel@tonic-gate 	void *arg, ddi_callback_id_t *cb_id)
65797c478bd9Sstevel@tonic-gate {
65807c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
65817c478bd9Sstevel@tonic-gate 	usb_port_t port = hubd_child_dip2port(hubd, rdip);
65827c478bd9Sstevel@tonic-gate 
65837c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
65847c478bd9Sstevel@tonic-gate 	    "hubd_busop_add_eventcall: dip=0x%p, rdip=0x%p "
65857c478bd9Sstevel@tonic-gate 	    "cookie=0x%p, cb=0x%p, arg=0x%p",
65867c478bd9Sstevel@tonic-gate 	    (void *)dip, (void *)rdip, (void *)cookie, (void *)callback, arg);
65877c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
65887c478bd9Sstevel@tonic-gate 	    "(dip=%s%d, rdip=%s%d, event=%s)",
65897c478bd9Sstevel@tonic-gate 	    ddi_driver_name(dip), ddi_get_instance(dip),
65907c478bd9Sstevel@tonic-gate 	    ddi_driver_name(rdip), ddi_get_instance(rdip),
65917c478bd9Sstevel@tonic-gate 	    ndi_event_cookie_to_name(hubd->h_ndi_event_hdl, cookie));
65927c478bd9Sstevel@tonic-gate 
65937c478bd9Sstevel@tonic-gate 	/* Set flag on children registering events */
65947c478bd9Sstevel@tonic-gate 	switch (ndi_event_cookie_to_tag(hubd->h_ndi_event_hdl, cookie)) {
65957c478bd9Sstevel@tonic-gate 	case USBA_EVENT_TAG_HOT_REMOVAL:
65967c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
65977c478bd9Sstevel@tonic-gate 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_DISCONNECT;
65987c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
65997c478bd9Sstevel@tonic-gate 
66007c478bd9Sstevel@tonic-gate 		break;
66017c478bd9Sstevel@tonic-gate 	case USBA_EVENT_TAG_PRE_SUSPEND:
66027c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
66037c478bd9Sstevel@tonic-gate 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_PRESUSPEND;
66047c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
66057c478bd9Sstevel@tonic-gate 
66067c478bd9Sstevel@tonic-gate 		break;
66077c478bd9Sstevel@tonic-gate 	default:
66087c478bd9Sstevel@tonic-gate 
66097c478bd9Sstevel@tonic-gate 		break;
66107c478bd9Sstevel@tonic-gate 	}
66117c478bd9Sstevel@tonic-gate 
66127c478bd9Sstevel@tonic-gate 	/* add callback to our event set */
66137c478bd9Sstevel@tonic-gate 	return (ndi_event_add_callback(hubd->h_ndi_event_hdl,
6614c0f24e5bSlg 	    rdip, cookie, callback, arg, NDI_SLEEP, cb_id));
66157c478bd9Sstevel@tonic-gate }
66167c478bd9Sstevel@tonic-gate 
66177c478bd9Sstevel@tonic-gate 
66187c478bd9Sstevel@tonic-gate static int
66197c478bd9Sstevel@tonic-gate hubd_busop_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
66207c478bd9Sstevel@tonic-gate {
66217c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
66227c478bd9Sstevel@tonic-gate 	ndi_event_callbacks_t *id = (ndi_event_callbacks_t *)cb_id;
66237c478bd9Sstevel@tonic-gate 
66247c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
66257c478bd9Sstevel@tonic-gate 	    "hubd_busop_remove_eventcall: dip=0x%p, rdip=0x%p "
6626112116d8Sfb 	    "cookie=0x%p", (void *)dip, (void *)id->ndi_evtcb_dip,
6627112116d8Sfb 	    (void *)id->ndi_evtcb_cookie);
66287c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
66297c478bd9Sstevel@tonic-gate 	    "(dip=%s%d, rdip=%s%d, event=%s)",
66307c478bd9Sstevel@tonic-gate 	    ddi_driver_name(dip), ddi_get_instance(dip),
66317c478bd9Sstevel@tonic-gate 	    ddi_driver_name(id->ndi_evtcb_dip),
66327c478bd9Sstevel@tonic-gate 	    ddi_get_instance(id->ndi_evtcb_dip),
66337c478bd9Sstevel@tonic-gate 	    ndi_event_cookie_to_name(hubd->h_ndi_event_hdl,
66347c478bd9Sstevel@tonic-gate 	    id->ndi_evtcb_cookie));
66357c478bd9Sstevel@tonic-gate 
66367c478bd9Sstevel@tonic-gate 	/* remove event registration from our event set */
66377c478bd9Sstevel@tonic-gate 	return (ndi_event_remove_callback(hubd->h_ndi_event_hdl, cb_id));
66387c478bd9Sstevel@tonic-gate }
66397c478bd9Sstevel@tonic-gate 
66407c478bd9Sstevel@tonic-gate 
66417c478bd9Sstevel@tonic-gate /*
66427c478bd9Sstevel@tonic-gate  * event distribution
66437c478bd9Sstevel@tonic-gate  *
66447c478bd9Sstevel@tonic-gate  * hubd_do_callback:
66457c478bd9Sstevel@tonic-gate  *	Post this event to the specified child
66467c478bd9Sstevel@tonic-gate  */
66477c478bd9Sstevel@tonic-gate static void
66487c478bd9Sstevel@tonic-gate hubd_do_callback(hubd_t *hubd, dev_info_t *cdip, ddi_eventcookie_t cookie)
66497c478bd9Sstevel@tonic-gate {
66507c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
66517c478bd9Sstevel@tonic-gate 	    "hubd_do_callback");
66527c478bd9Sstevel@tonic-gate 
66537c478bd9Sstevel@tonic-gate 	(void) ndi_event_do_callback(hubd->h_ndi_event_hdl, cdip, cookie, NULL);
66547c478bd9Sstevel@tonic-gate }
66557c478bd9Sstevel@tonic-gate 
66567c478bd9Sstevel@tonic-gate 
66577c478bd9Sstevel@tonic-gate /*
66587c478bd9Sstevel@tonic-gate  * hubd_run_callbacks:
66597c478bd9Sstevel@tonic-gate  *	Send this event to all children
66607c478bd9Sstevel@tonic-gate  */
66617c478bd9Sstevel@tonic-gate static void
66627c478bd9Sstevel@tonic-gate hubd_run_callbacks(hubd_t *hubd, usba_event_t type)
66637c478bd9Sstevel@tonic-gate {
66647c478bd9Sstevel@tonic-gate 	usb_port_t	port;
66657c478bd9Sstevel@tonic-gate 
66667c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
66677c478bd9Sstevel@tonic-gate 	    "hubd_run_callbacks");
66687c478bd9Sstevel@tonic-gate 
66697c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
66707c478bd9Sstevel@tonic-gate 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
66717c478bd9Sstevel@tonic-gate 		/*
66727c478bd9Sstevel@tonic-gate 		 * the childen_dips list may have dips that have been
66737c478bd9Sstevel@tonic-gate 		 * already deallocated. we only get a post_detach notification
66747c478bd9Sstevel@tonic-gate 		 * but not a destroy notification
66757c478bd9Sstevel@tonic-gate 		 */
66767c478bd9Sstevel@tonic-gate 		if (hubd->h_children_dips[port]) {
66777c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
66787c478bd9Sstevel@tonic-gate 			hubd_post_event(hubd, port, type);
66797c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
66807c478bd9Sstevel@tonic-gate 		}
66817c478bd9Sstevel@tonic-gate 	}
66827c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
66837c478bd9Sstevel@tonic-gate }
66847c478bd9Sstevel@tonic-gate 
66857c478bd9Sstevel@tonic-gate 
66867c478bd9Sstevel@tonic-gate /*
66877c478bd9Sstevel@tonic-gate  * hubd_post_event
66887c478bd9Sstevel@tonic-gate  *	post event to a child on the port depending on the type
66897c478bd9Sstevel@tonic-gate  */
66907c478bd9Sstevel@tonic-gate static void
66917c478bd9Sstevel@tonic-gate hubd_post_event(hubd_t *hubd, usb_port_t port, usba_event_t type)
66927c478bd9Sstevel@tonic-gate {
66937c478bd9Sstevel@tonic-gate 	int	rval;
66947c478bd9Sstevel@tonic-gate 	dev_info_t	*dip;
66957c478bd9Sstevel@tonic-gate 	usba_device_t	*usba_device;
66967c478bd9Sstevel@tonic-gate 	ddi_eventcookie_t cookie, rm_cookie, suspend_cookie;
66977c478bd9Sstevel@tonic-gate 
66987c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
66997c478bd9Sstevel@tonic-gate 	    "hubd_post_event: port=%d event=%s", port,
67007c478bd9Sstevel@tonic-gate 	    ndi_event_tag_to_name(hubd->h_ndi_event_hdl, type));
67017c478bd9Sstevel@tonic-gate 
67027c478bd9Sstevel@tonic-gate 	cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl, type);
67037c478bd9Sstevel@tonic-gate 	rm_cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl,
67047c478bd9Sstevel@tonic-gate 	    USBA_EVENT_TAG_HOT_REMOVAL);
67057c478bd9Sstevel@tonic-gate 	suspend_cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl,
67067c478bd9Sstevel@tonic-gate 	    USBA_EVENT_TAG_PRE_SUSPEND);
67077c478bd9Sstevel@tonic-gate 
67087c478bd9Sstevel@tonic-gate 	/*
67097c478bd9Sstevel@tonic-gate 	 * Hotplug daemon may be attaching a driver that may be registering
67107c478bd9Sstevel@tonic-gate 	 * event callbacks. So it already has got the device tree lock and
67117c478bd9Sstevel@tonic-gate 	 * event handle mutex. So to prevent a deadlock while posting events,
67127c478bd9Sstevel@tonic-gate 	 * we grab and release the locks in the same order.
67137c478bd9Sstevel@tonic-gate 	 */
67147c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
67157c478bd9Sstevel@tonic-gate 	dip = hubd->h_children_dips[port];
67167c478bd9Sstevel@tonic-gate 	usba_device = hubd->h_usba_devices[port];
67177c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
67187c478bd9Sstevel@tonic-gate 
67197c478bd9Sstevel@tonic-gate 	switch (type) {
67207c478bd9Sstevel@tonic-gate 	case USBA_EVENT_TAG_HOT_REMOVAL:
67217c478bd9Sstevel@tonic-gate 		/* Clear the registered event flag */
67227c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
67237c478bd9Sstevel@tonic-gate 		hubd->h_child_events[port] &= ~HUBD_CHILD_EVENT_DISCONNECT;
67247c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
67257c478bd9Sstevel@tonic-gate 
67267c478bd9Sstevel@tonic-gate 		hubd_do_callback(hubd, dip, cookie);
67277c478bd9Sstevel@tonic-gate 		usba_persistent_pipe_close(usba_device);
67287c478bd9Sstevel@tonic-gate 
67297c478bd9Sstevel@tonic-gate 		/*
67307c478bd9Sstevel@tonic-gate 		 * Mark the dip for deletion only after the driver has
67317c478bd9Sstevel@tonic-gate 		 * seen the disconnect event to prevent cleanup thread
67327c478bd9Sstevel@tonic-gate 		 * from stepping in between.
67337c478bd9Sstevel@tonic-gate 		 */
673416747f41Scth 		mutex_enter(&(DEVI(dip)->devi_lock));
67357c478bd9Sstevel@tonic-gate 		DEVI_SET_DEVICE_REMOVED(dip);
673616747f41Scth 		mutex_exit(&(DEVI(dip)->devi_lock));
67377c478bd9Sstevel@tonic-gate 
67387c478bd9Sstevel@tonic-gate 		break;
67397c478bd9Sstevel@tonic-gate 	case USBA_EVENT_TAG_PRE_SUSPEND:
67407c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
67417c478bd9Sstevel@tonic-gate 		hubd->h_child_events[port] &= ~HUBD_CHILD_EVENT_PRESUSPEND;
67427c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
67437c478bd9Sstevel@tonic-gate 
67447c478bd9Sstevel@tonic-gate 		hubd_do_callback(hubd, dip, cookie);
67457c478bd9Sstevel@tonic-gate 		/*
67467c478bd9Sstevel@tonic-gate 		 * persistent pipe close for this event is taken care by the
67477c478bd9Sstevel@tonic-gate 		 * caller after verfying that all children can suspend
67487c478bd9Sstevel@tonic-gate 		 */
67497c478bd9Sstevel@tonic-gate 
67507c478bd9Sstevel@tonic-gate 		break;
67517c478bd9Sstevel@tonic-gate 	case USBA_EVENT_TAG_HOT_INSERTION:
67527c478bd9Sstevel@tonic-gate 		/*
67537c478bd9Sstevel@tonic-gate 		 * Check if this child has missed the disconnect event before
67547c478bd9Sstevel@tonic-gate 		 * it registered for event callbacks
67557c478bd9Sstevel@tonic-gate 		 */
67567c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
67577c478bd9Sstevel@tonic-gate 		if (hubd->h_child_events[port] & HUBD_CHILD_EVENT_DISCONNECT) {
67587c478bd9Sstevel@tonic-gate 			/* clear the flag and post disconnect event */
67597c478bd9Sstevel@tonic-gate 			hubd->h_child_events[port] &=
67607c478bd9Sstevel@tonic-gate 			    ~HUBD_CHILD_EVENT_DISCONNECT;
67617c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
67627c478bd9Sstevel@tonic-gate 			hubd_do_callback(hubd, dip, rm_cookie);
67637c478bd9Sstevel@tonic-gate 			usba_persistent_pipe_close(usba_device);
67647c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
67657c478bd9Sstevel@tonic-gate 		}
67667c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
67677c478bd9Sstevel@tonic-gate 
67687c478bd9Sstevel@tonic-gate 		/*
67697c478bd9Sstevel@tonic-gate 		 * Mark the dip as reinserted to prevent cleanup thread
67707c478bd9Sstevel@tonic-gate 		 * from stepping in.
67717c478bd9Sstevel@tonic-gate 		 */
677216747f41Scth 		mutex_enter(&(DEVI(dip)->devi_lock));
67737c478bd9Sstevel@tonic-gate 		DEVI_SET_DEVICE_REINSERTED(dip);
677416747f41Scth 		mutex_exit(&(DEVI(dip)->devi_lock));
67757c478bd9Sstevel@tonic-gate 
67767c478bd9Sstevel@tonic-gate 		rval = usba_persistent_pipe_open(usba_device);
67777c478bd9Sstevel@tonic-gate 		if (rval != USB_SUCCESS) {
6778d291d9f2Sfrits 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
67797c478bd9Sstevel@tonic-gate 			    hubd->h_log_handle,
67807c478bd9Sstevel@tonic-gate 			    "failed to reopen all pipes on reconnect");
67817c478bd9Sstevel@tonic-gate 		}
67827c478bd9Sstevel@tonic-gate 
67837c478bd9Sstevel@tonic-gate 		hubd_do_callback(hubd, dip, cookie);
67847c478bd9Sstevel@tonic-gate 
67857c478bd9Sstevel@tonic-gate 		/*
67867c478bd9Sstevel@tonic-gate 		 * We might see a connect event only if hotplug thread for
67877c478bd9Sstevel@tonic-gate 		 * disconnect event don't run in time.
67887c478bd9Sstevel@tonic-gate 		 * Set the flag again, so we don't miss posting a
67897c478bd9Sstevel@tonic-gate 		 * disconnect event.
67907c478bd9Sstevel@tonic-gate 		 */
67917c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
67927c478bd9Sstevel@tonic-gate 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_DISCONNECT;
67937c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
67947c478bd9Sstevel@tonic-gate 
67957c478bd9Sstevel@tonic-gate 		break;
67967c478bd9Sstevel@tonic-gate 	case USBA_EVENT_TAG_POST_RESUME:
67977c478bd9Sstevel@tonic-gate 		/*
67987c478bd9Sstevel@tonic-gate 		 * Check if this child has missed the pre-suspend event before
67997c478bd9Sstevel@tonic-gate 		 * it registered for event callbacks
68007c478bd9Sstevel@tonic-gate 		 */
68017c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
68027c478bd9Sstevel@tonic-gate 		if (hubd->h_child_events[port] & HUBD_CHILD_EVENT_PRESUSPEND) {
68037c478bd9Sstevel@tonic-gate 			/* clear the flag and post pre_suspend event */
68047c478bd9Sstevel@tonic-gate 			hubd->h_port_state[port] &=
68057c478bd9Sstevel@tonic-gate 			    ~HUBD_CHILD_EVENT_PRESUSPEND;
68067c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
68077c478bd9Sstevel@tonic-gate 			hubd_do_callback(hubd, dip, suspend_cookie);
68087c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
68097c478bd9Sstevel@tonic-gate 		}
68107c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
68117c478bd9Sstevel@tonic-gate 
68127c478bd9Sstevel@tonic-gate 		mutex_enter(&usba_device->usb_mutex);
68137c478bd9Sstevel@tonic-gate 		usba_device->usb_no_cpr = 0;
68147c478bd9Sstevel@tonic-gate 		mutex_exit(&usba_device->usb_mutex);
68157c478bd9Sstevel@tonic-gate 
68167c478bd9Sstevel@tonic-gate 		/*
68177c478bd9Sstevel@tonic-gate 		 * Since the pipe has already been opened by hub
68187c478bd9Sstevel@tonic-gate 		 * at DDI_RESUME time, there is no need for a
68197c478bd9Sstevel@tonic-gate 		 * persistent pipe open
68207c478bd9Sstevel@tonic-gate 		 */
68217c478bd9Sstevel@tonic-gate 		hubd_do_callback(hubd, dip, cookie);
68227c478bd9Sstevel@tonic-gate 
68237c478bd9Sstevel@tonic-gate 		/*
68247c478bd9Sstevel@tonic-gate 		 * Set the flag again, so we don't miss posting a
68257c478bd9Sstevel@tonic-gate 		 * pre-suspend event. This enforces a tighter
68267c478bd9Sstevel@tonic-gate 		 * dev_state model.
68277c478bd9Sstevel@tonic-gate 		 */
68287c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
68297c478bd9Sstevel@tonic-gate 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_PRESUSPEND;
68307c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
68317c478bd9Sstevel@tonic-gate 		break;
68327c478bd9Sstevel@tonic-gate 	}
68337c478bd9Sstevel@tonic-gate }
68347c478bd9Sstevel@tonic-gate 
68357c478bd9Sstevel@tonic-gate 
68367c478bd9Sstevel@tonic-gate /*
68377c478bd9Sstevel@tonic-gate  * handling of events coming from above
68387c478bd9Sstevel@tonic-gate  */
68397c478bd9Sstevel@tonic-gate static int
68407c478bd9Sstevel@tonic-gate hubd_disconnect_event_cb(dev_info_t *dip)
68417c478bd9Sstevel@tonic-gate {
68427c478bd9Sstevel@tonic-gate 	hubd_t		*hubd = (hubd_t *)hubd_get_soft_state(dip);
68437c478bd9Sstevel@tonic-gate 	usb_port_t	port, nports;
68447c478bd9Sstevel@tonic-gate 	usba_device_t	*usba_dev;
68457c478bd9Sstevel@tonic-gate 	usba_event_t	tag = USBA_EVENT_TAG_HOT_REMOVAL;
68467c478bd9Sstevel@tonic-gate 	int		circ;
68477c478bd9Sstevel@tonic-gate 
68487c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
68497c478bd9Sstevel@tonic-gate 	    "hubd_disconnect_event_cb: tag=%d", tag);
68507c478bd9Sstevel@tonic-gate 
68517c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
68527c478bd9Sstevel@tonic-gate 
68537c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
68547c478bd9Sstevel@tonic-gate 	switch (hubd->h_dev_state) {
68557c478bd9Sstevel@tonic-gate 	case USB_DEV_ONLINE:
68567c478bd9Sstevel@tonic-gate 	case USB_DEV_PWRED_DOWN:
68577c478bd9Sstevel@tonic-gate 		hubd->h_dev_state = USB_DEV_DISCONNECTED;
68587c478bd9Sstevel@tonic-gate 		/* stop polling on the interrupt pipe */
68597c478bd9Sstevel@tonic-gate 		hubd_stop_polling(hubd);
68607c478bd9Sstevel@tonic-gate 
68617c478bd9Sstevel@tonic-gate 		/* FALLTHROUGH */
68627c478bd9Sstevel@tonic-gate 	case USB_DEV_SUSPENDED:
68637c478bd9Sstevel@tonic-gate 		/* we remain in this state */
68647c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
68657c478bd9Sstevel@tonic-gate 		hubd_run_callbacks(hubd, tag);
68667c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
68677c478bd9Sstevel@tonic-gate 
68687c478bd9Sstevel@tonic-gate 		/* close all the open pipes of our children */
68697c478bd9Sstevel@tonic-gate 		nports = hubd->h_hub_descr.bNbrPorts;
68707c478bd9Sstevel@tonic-gate 		for (port = 1; port <= nports; port++) {
68717c478bd9Sstevel@tonic-gate 			usba_dev = hubd->h_usba_devices[port];
68727c478bd9Sstevel@tonic-gate 			if (usba_dev != NULL) {
68737c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
68747c478bd9Sstevel@tonic-gate 				usba_persistent_pipe_close(usba_dev);
68757c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
68767c478bd9Sstevel@tonic-gate 			}
68777c478bd9Sstevel@tonic-gate 		}
68787c478bd9Sstevel@tonic-gate 
68797c478bd9Sstevel@tonic-gate 		break;
68807c478bd9Sstevel@tonic-gate 	case USB_DEV_DISCONNECTED:
68817c478bd9Sstevel@tonic-gate 		/* avoid passing multiple disconnects to children */
68827c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
68837c478bd9Sstevel@tonic-gate 		    "hubd_disconnect_event_cb: Already disconnected");
68847c478bd9Sstevel@tonic-gate 
68857c478bd9Sstevel@tonic-gate 		break;
68867c478bd9Sstevel@tonic-gate 	default:
68877c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
68887c478bd9Sstevel@tonic-gate 		    "hubd_disconnect_event_cb: Illegal devstate=%d",
68897c478bd9Sstevel@tonic-gate 		    hubd->h_dev_state);
68907c478bd9Sstevel@tonic-gate 
68917c478bd9Sstevel@tonic-gate 		break;
68927c478bd9Sstevel@tonic-gate 	}
68937c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
68947c478bd9Sstevel@tonic-gate 
68957c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
68967c478bd9Sstevel@tonic-gate 
68977c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
68987c478bd9Sstevel@tonic-gate }
68997c478bd9Sstevel@tonic-gate 
69007c478bd9Sstevel@tonic-gate 
69017c478bd9Sstevel@tonic-gate static int
69027c478bd9Sstevel@tonic-gate hubd_reconnect_event_cb(dev_info_t *dip)
69037c478bd9Sstevel@tonic-gate {
69047c478bd9Sstevel@tonic-gate 	int	rval, circ;
69057c478bd9Sstevel@tonic-gate 
69067c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
69077c478bd9Sstevel@tonic-gate 	rval = hubd_restore_state_cb(dip);
69087c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
69097c478bd9Sstevel@tonic-gate 
69107c478bd9Sstevel@tonic-gate 	return (rval);
69117c478bd9Sstevel@tonic-gate }
69127c478bd9Sstevel@tonic-gate 
69137c478bd9Sstevel@tonic-gate 
69147c478bd9Sstevel@tonic-gate /*
69157c478bd9Sstevel@tonic-gate  * hubd_pre_suspend_event_cb
69167c478bd9Sstevel@tonic-gate  *	propogate event for binary compatibility of old drivers
69177c478bd9Sstevel@tonic-gate  */
69187c478bd9Sstevel@tonic-gate static int
69197c478bd9Sstevel@tonic-gate hubd_pre_suspend_event_cb(dev_info_t *dip)
69207c478bd9Sstevel@tonic-gate {
69217c478bd9Sstevel@tonic-gate 	int	circ;
69227c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
69237c478bd9Sstevel@tonic-gate 
69247c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
69257c478bd9Sstevel@tonic-gate 	    "hubd_pre_suspend_event_cb");
69267c478bd9Sstevel@tonic-gate 
69277c478bd9Sstevel@tonic-gate 	/* disable hotplug thread */
69287c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
69297c478bd9Sstevel@tonic-gate 	hubd->h_hotplug_thread++;
69307c478bd9Sstevel@tonic-gate 	hubd_stop_polling(hubd);
69317c478bd9Sstevel@tonic-gate 
69327c478bd9Sstevel@tonic-gate 	/* keep PM out till we see a cpr resume */
69337c478bd9Sstevel@tonic-gate 	(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
69347c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
69357c478bd9Sstevel@tonic-gate 
69367c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
69377c478bd9Sstevel@tonic-gate 	hubd_run_callbacks(hubd, USBA_EVENT_TAG_PRE_SUSPEND);
69387c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
69397c478bd9Sstevel@tonic-gate 
69407c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
69417c478bd9Sstevel@tonic-gate }
69427c478bd9Sstevel@tonic-gate 
69437c478bd9Sstevel@tonic-gate 
69447c478bd9Sstevel@tonic-gate /*
69457c478bd9Sstevel@tonic-gate  * hubd_post_resume_event_cb
69467c478bd9Sstevel@tonic-gate  *	propogate event for binary compatibility of old drivers
69477c478bd9Sstevel@tonic-gate  */
69487c478bd9Sstevel@tonic-gate static int
69497c478bd9Sstevel@tonic-gate hubd_post_resume_event_cb(dev_info_t *dip)
69507c478bd9Sstevel@tonic-gate {
69517c478bd9Sstevel@tonic-gate 	int	circ;
69527c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
69537c478bd9Sstevel@tonic-gate 
69547c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
69557c478bd9Sstevel@tonic-gate 	    "hubd_post_resume_event_cb");
69567c478bd9Sstevel@tonic-gate 
69577c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
69587c478bd9Sstevel@tonic-gate 	hubd_run_callbacks(hubd, USBA_EVENT_TAG_POST_RESUME);
69597c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
69607c478bd9Sstevel@tonic-gate 
69617c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
69627c478bd9Sstevel@tonic-gate 
69637c478bd9Sstevel@tonic-gate 	/* enable PM */
69647c478bd9Sstevel@tonic-gate 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
69657c478bd9Sstevel@tonic-gate 
69667c478bd9Sstevel@tonic-gate 	/* allow hotplug thread */
69677c478bd9Sstevel@tonic-gate 	hubd->h_hotplug_thread--;
69687c478bd9Sstevel@tonic-gate 
69697c478bd9Sstevel@tonic-gate 	/* start polling */
69707c478bd9Sstevel@tonic-gate 	hubd_start_polling(hubd, 0);
69717c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
69727c478bd9Sstevel@tonic-gate 
69737c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
69747c478bd9Sstevel@tonic-gate }
69757c478bd9Sstevel@tonic-gate 
69767c478bd9Sstevel@tonic-gate 
69777c478bd9Sstevel@tonic-gate /*
69787c478bd9Sstevel@tonic-gate  * hubd_cpr_suspend
69797c478bd9Sstevel@tonic-gate  *	save the current state of the driver/device
69807c478bd9Sstevel@tonic-gate  */
69817c478bd9Sstevel@tonic-gate static int
69827c478bd9Sstevel@tonic-gate hubd_cpr_suspend(hubd_t *hubd)
69837c478bd9Sstevel@tonic-gate {
69847c478bd9Sstevel@tonic-gate 	usb_port_t	port, nports;
69857c478bd9Sstevel@tonic-gate 	usba_device_t	*usba_dev;
69867c478bd9Sstevel@tonic-gate 	uchar_t		no_cpr = 0;
69877c478bd9Sstevel@tonic-gate 	int		rval = USB_FAILURE;
69887c478bd9Sstevel@tonic-gate 
69897c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
69907c478bd9Sstevel@tonic-gate 	    "hubd_cpr_suspend: Begin");
69917c478bd9Sstevel@tonic-gate 
69927c478bd9Sstevel@tonic-gate 	/* Make sure device is powered up to save state. */
69937c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
69947c478bd9Sstevel@tonic-gate 	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
69957c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
69967c478bd9Sstevel@tonic-gate 
69977c478bd9Sstevel@tonic-gate 	/* bring the device to full power */
69987c478bd9Sstevel@tonic-gate 	(void) pm_raise_power(hubd->h_dip, 0, USB_DEV_OS_FULL_PWR);
69997c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
70007c478bd9Sstevel@tonic-gate 
70017c478bd9Sstevel@tonic-gate 	switch (hubd->h_dev_state) {
70027c478bd9Sstevel@tonic-gate 	case USB_DEV_ONLINE:
70037c478bd9Sstevel@tonic-gate 	case USB_DEV_PWRED_DOWN:
70047c478bd9Sstevel@tonic-gate 	case USB_DEV_DISCONNECTED:
70057c478bd9Sstevel@tonic-gate 		/* find out if all our children have been quiesced */
70067c478bd9Sstevel@tonic-gate 		nports = hubd->h_hub_descr.bNbrPorts;
70077c478bd9Sstevel@tonic-gate 		for (port = 1; (no_cpr == 0) && (port <= nports); port++) {
70087c478bd9Sstevel@tonic-gate 			usba_dev = hubd->h_usba_devices[port];
70097c478bd9Sstevel@tonic-gate 			if (usba_dev != NULL) {
70107c478bd9Sstevel@tonic-gate 				mutex_enter(&usba_dev->usb_mutex);
70117c478bd9Sstevel@tonic-gate 				no_cpr += usba_dev->usb_no_cpr;
70127c478bd9Sstevel@tonic-gate 				mutex_exit(&usba_dev->usb_mutex);
70137c478bd9Sstevel@tonic-gate 			}
70147c478bd9Sstevel@tonic-gate 		}
70157c478bd9Sstevel@tonic-gate 		if (no_cpr > 0) {
70167c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
70177c478bd9Sstevel@tonic-gate 			    "Children busy - can't checkpoint");
70187c478bd9Sstevel@tonic-gate 			/* remain in same state to fail checkpoint */
70197c478bd9Sstevel@tonic-gate 
70207c478bd9Sstevel@tonic-gate 			break;
70217c478bd9Sstevel@tonic-gate 		} else {
70227c478bd9Sstevel@tonic-gate 			/*
70237c478bd9Sstevel@tonic-gate 			 * do not suspend if our hotplug thread
70247c478bd9Sstevel@tonic-gate 			 * or the deathrow thread is active
70257c478bd9Sstevel@tonic-gate 			 */
70267c478bd9Sstevel@tonic-gate 			if ((hubd->h_hotplug_thread > 1) ||
70277c478bd9Sstevel@tonic-gate 			    (hubd->h_cleanup_active == B_TRUE)) {
70287c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
70297c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
70307c478bd9Sstevel@tonic-gate 				    "hotplug thread active  - can't cpr");
70317c478bd9Sstevel@tonic-gate 				/* remain in same state to fail checkpoint */
70327c478bd9Sstevel@tonic-gate 
70337c478bd9Sstevel@tonic-gate 				break;
70347c478bd9Sstevel@tonic-gate 			}
70357c478bd9Sstevel@tonic-gate 
70367c478bd9Sstevel@tonic-gate 			/* quiesce ourselves now */
70377c478bd9Sstevel@tonic-gate 			hubd->h_dev_state = USB_DEV_SUSPENDED;
70387c478bd9Sstevel@tonic-gate 			hubd_stop_polling(hubd);
70397c478bd9Sstevel@tonic-gate 
70407c478bd9Sstevel@tonic-gate 			/* close all the open pipes of our children */
70417c478bd9Sstevel@tonic-gate 			for (port = 1; port <= nports; port++) {
70427c478bd9Sstevel@tonic-gate 				usba_dev = hubd->h_usba_devices[port];
70437c478bd9Sstevel@tonic-gate 				if (usba_dev != NULL) {
70447c478bd9Sstevel@tonic-gate 					mutex_exit(HUBD_MUTEX(hubd));
70457c478bd9Sstevel@tonic-gate 					usba_persistent_pipe_close(usba_dev);
70467c478bd9Sstevel@tonic-gate 					mutex_enter(HUBD_MUTEX(hubd));
70477c478bd9Sstevel@tonic-gate 				}
70487c478bd9Sstevel@tonic-gate 			}
70497c478bd9Sstevel@tonic-gate 			/*
70507c478bd9Sstevel@tonic-gate 			 * turn off power to all the ports so that we
70517c478bd9Sstevel@tonic-gate 			 * don't see any spurious activity
70527c478bd9Sstevel@tonic-gate 			 */
70537c478bd9Sstevel@tonic-gate 			(void) hubd_disable_all_port_power(hubd);
70547c478bd9Sstevel@tonic-gate 
70557c478bd9Sstevel@tonic-gate 			/*
70567c478bd9Sstevel@tonic-gate 			 * if we are the root hub, we close our pipes
70577c478bd9Sstevel@tonic-gate 			 * ourselves.
70587c478bd9Sstevel@tonic-gate 			 */
70597c478bd9Sstevel@tonic-gate 			if (usba_is_root_hub(hubd->h_dip)) {
70607c478bd9Sstevel@tonic-gate 				mutex_exit(HUBD_MUTEX(hubd));
70617c478bd9Sstevel@tonic-gate 				usba_persistent_pipe_close(
70627c478bd9Sstevel@tonic-gate 				    usba_get_usba_device(hubd->h_dip));
70637c478bd9Sstevel@tonic-gate 				mutex_enter(HUBD_MUTEX(hubd));
70647c478bd9Sstevel@tonic-gate 			}
70657c478bd9Sstevel@tonic-gate 			rval = USB_SUCCESS;
70667c478bd9Sstevel@tonic-gate 
70677c478bd9Sstevel@tonic-gate 			break;
70687c478bd9Sstevel@tonic-gate 		}
70697c478bd9Sstevel@tonic-gate 	case USB_DEV_SUSPENDED:
70707c478bd9Sstevel@tonic-gate 	default:
70717c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
70727c478bd9Sstevel@tonic-gate 		    "hubd_cpr_suspend: Illegal dev state=%d",
70737c478bd9Sstevel@tonic-gate 		    hubd->h_dev_state);
70747c478bd9Sstevel@tonic-gate 
70757c478bd9Sstevel@tonic-gate 		break;
70767c478bd9Sstevel@tonic-gate 	}
70777c478bd9Sstevel@tonic-gate 
70787c478bd9Sstevel@tonic-gate 	hubd_pm_idle_component(hubd, hubd->h_dip, 0);
70797c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
70807c478bd9Sstevel@tonic-gate 
70817c478bd9Sstevel@tonic-gate 	return (rval);
70827c478bd9Sstevel@tonic-gate }
70837c478bd9Sstevel@tonic-gate 
70847c478bd9Sstevel@tonic-gate static void
70857c478bd9Sstevel@tonic-gate hubd_cpr_resume(dev_info_t *dip)
70867c478bd9Sstevel@tonic-gate {
70877c478bd9Sstevel@tonic-gate 	int	rval, circ;
70887c478bd9Sstevel@tonic-gate 
70897c478bd9Sstevel@tonic-gate 	ndi_devi_enter(dip, &circ);
70907c478bd9Sstevel@tonic-gate 	/*
70917c478bd9Sstevel@tonic-gate 	 * if we are the root hub, we open our pipes
70927c478bd9Sstevel@tonic-gate 	 * ourselves.
70937c478bd9Sstevel@tonic-gate 	 */
70947c478bd9Sstevel@tonic-gate 	if (usba_is_root_hub(dip)) {
70957c478bd9Sstevel@tonic-gate 		rval = usba_persistent_pipe_open(
70967c478bd9Sstevel@tonic-gate 		    usba_get_usba_device(dip));
70977c478bd9Sstevel@tonic-gate 		ASSERT(rval == USB_SUCCESS);
70987c478bd9Sstevel@tonic-gate 	}
70997c478bd9Sstevel@tonic-gate 	(void) hubd_restore_state_cb(dip);
71007c478bd9Sstevel@tonic-gate 	ndi_devi_exit(dip, circ);
71017c478bd9Sstevel@tonic-gate }
71027c478bd9Sstevel@tonic-gate 
71037c478bd9Sstevel@tonic-gate 
71047c478bd9Sstevel@tonic-gate /*
71057c478bd9Sstevel@tonic-gate  * hubd_restore_state_cb
71067c478bd9Sstevel@tonic-gate  *	Event callback to restore device state
71077c478bd9Sstevel@tonic-gate  */
71087c478bd9Sstevel@tonic-gate static int
71097c478bd9Sstevel@tonic-gate hubd_restore_state_cb(dev_info_t *dip)
71107c478bd9Sstevel@tonic-gate {
71117c478bd9Sstevel@tonic-gate 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
71127c478bd9Sstevel@tonic-gate 
71137c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
71147c478bd9Sstevel@tonic-gate 	    "hubd_restore_state_cb: Begin");
71157c478bd9Sstevel@tonic-gate 
71167c478bd9Sstevel@tonic-gate 	/* restore the state of this device */
71177c478bd9Sstevel@tonic-gate 	hubd_restore_device_state(dip, hubd);
71187c478bd9Sstevel@tonic-gate 
71197c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
71207c478bd9Sstevel@tonic-gate }
71217c478bd9Sstevel@tonic-gate 
71227c478bd9Sstevel@tonic-gate 
71237c478bd9Sstevel@tonic-gate /*
71247c478bd9Sstevel@tonic-gate  * registering for events
71257c478bd9Sstevel@tonic-gate  */
71267c478bd9Sstevel@tonic-gate static int
71277c478bd9Sstevel@tonic-gate hubd_register_events(hubd_t *hubd)
71287c478bd9Sstevel@tonic-gate {
71297c478bd9Sstevel@tonic-gate 	int		rval = USB_SUCCESS;
71307c478bd9Sstevel@tonic-gate 
71317c478bd9Sstevel@tonic-gate 	if (usba_is_root_hub(hubd->h_dip)) {
71327c478bd9Sstevel@tonic-gate 		hubd_register_cpr_callback(hubd);
71337c478bd9Sstevel@tonic-gate 	} else {
71347c478bd9Sstevel@tonic-gate 		rval = usb_register_event_cbs(hubd->h_dip, &hubd_events, 0);
71357c478bd9Sstevel@tonic-gate 	}
71367c478bd9Sstevel@tonic-gate 
71377c478bd9Sstevel@tonic-gate 	return (rval);
71387c478bd9Sstevel@tonic-gate }
71397c478bd9Sstevel@tonic-gate 
71407c478bd9Sstevel@tonic-gate 
71417c478bd9Sstevel@tonic-gate /*
71427c478bd9Sstevel@tonic-gate  * hubd cpr callback related functions
71437c478bd9Sstevel@tonic-gate  *
71447c478bd9Sstevel@tonic-gate  * hubd_cpr_post_user_callb:
71457c478bd9Sstevel@tonic-gate  *	This function is called during checkpoint & resume -
71467c478bd9Sstevel@tonic-gate  *		1. after user threads are stopped during checkpoint
71477c478bd9Sstevel@tonic-gate  *		2. after kernel threads are resumed during resume
71487c478bd9Sstevel@tonic-gate  */
71497c478bd9Sstevel@tonic-gate /* ARGSUSED */
71507c478bd9Sstevel@tonic-gate static boolean_t
71517c478bd9Sstevel@tonic-gate hubd_cpr_post_user_callb(void *arg, int code)
71527c478bd9Sstevel@tonic-gate {
71537c478bd9Sstevel@tonic-gate 	hubd_cpr_t	*cpr_cb = (hubd_cpr_t *)arg;
71547c478bd9Sstevel@tonic-gate 	hubd_t		*hubd = cpr_cb->statep;
71557c478bd9Sstevel@tonic-gate 	int		retry = 0;
71567c478bd9Sstevel@tonic-gate 
71577c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
71587c478bd9Sstevel@tonic-gate 	    "hubd_cpr_post_user_callb");
71597c478bd9Sstevel@tonic-gate 
71607c478bd9Sstevel@tonic-gate 	switch (code) {
71617c478bd9Sstevel@tonic-gate 	case CB_CODE_CPR_CHKPT:
71627c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_EVENTS, hubd->h_log_handle,
71637c478bd9Sstevel@tonic-gate 		    "hubd_cpr_post_user_callb: CB_CODE_CPR_CHKPT");
71647c478bd9Sstevel@tonic-gate 
71657c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
71667c478bd9Sstevel@tonic-gate 
71677c478bd9Sstevel@tonic-gate 		/* turn off deathrow thread */
71687c478bd9Sstevel@tonic-gate 		hubd->h_cleanup_enabled = B_FALSE;
71697c478bd9Sstevel@tonic-gate 
71707c478bd9Sstevel@tonic-gate 		/* give up if deathrow thread doesn't exit */
71717c478bd9Sstevel@tonic-gate 		while ((hubd->h_cleanup_active == B_TRUE) && (retry++ < 3)) {
71727c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
71737c478bd9Sstevel@tonic-gate 			delay(drv_usectohz(hubd_dip_cleanup_delay));
71747c478bd9Sstevel@tonic-gate 
71757c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_EVENTS, hubd->h_log_handle,
71767c478bd9Sstevel@tonic-gate 			    "hubd_cpr_post_user_callb, waiting for "
71777c478bd9Sstevel@tonic-gate 			    "deathrow thread to exit");
71787c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
71797c478bd9Sstevel@tonic-gate 		}
71807c478bd9Sstevel@tonic-gate 
71817c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
71827c478bd9Sstevel@tonic-gate 
71837c478bd9Sstevel@tonic-gate 		/* save the state of the device */
71847c478bd9Sstevel@tonic-gate 		(void) hubd_pre_suspend_event_cb(hubd->h_dip);
71857c478bd9Sstevel@tonic-gate 
71867c478bd9Sstevel@tonic-gate 		return (B_TRUE);
71877c478bd9Sstevel@tonic-gate 	case CB_CODE_CPR_RESUME:
71887c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_EVENTS, hubd->h_log_handle,
71897c478bd9Sstevel@tonic-gate 		    "hubd_cpr_post_user_callb: CB_CODE_CPR_RESUME");
71907c478bd9Sstevel@tonic-gate 
71917c478bd9Sstevel@tonic-gate 		/* restore the state of the device */
71927c478bd9Sstevel@tonic-gate 		(void) hubd_post_resume_event_cb(hubd->h_dip);
71937c478bd9Sstevel@tonic-gate 
71947c478bd9Sstevel@tonic-gate 		/* turn on deathrow thread */
71957c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
71967c478bd9Sstevel@tonic-gate 		hubd->h_cleanup_enabled = B_TRUE;
71977c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
71987c478bd9Sstevel@tonic-gate 
71997c478bd9Sstevel@tonic-gate 		hubd_schedule_cleanup(hubd->h_usba_device->usb_root_hub_dip);
72007c478bd9Sstevel@tonic-gate 
72017c478bd9Sstevel@tonic-gate 		return (B_TRUE);
72027c478bd9Sstevel@tonic-gate 	default:
72037c478bd9Sstevel@tonic-gate 
72047c478bd9Sstevel@tonic-gate 		return (B_FALSE);
72057c478bd9Sstevel@tonic-gate 	}
72067c478bd9Sstevel@tonic-gate 
72077c478bd9Sstevel@tonic-gate }
72087c478bd9Sstevel@tonic-gate 
72097c478bd9Sstevel@tonic-gate 
72107c478bd9Sstevel@tonic-gate /* register callback with cpr framework */
72117c478bd9Sstevel@tonic-gate void
72127c478bd9Sstevel@tonic-gate hubd_register_cpr_callback(hubd_t *hubd)
72137c478bd9Sstevel@tonic-gate {
72147c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
72157c478bd9Sstevel@tonic-gate 	    "hubd_register_cpr_callback");
72167c478bd9Sstevel@tonic-gate 
72177c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
72187c478bd9Sstevel@tonic-gate 	hubd->h_cpr_cb =
72197c478bd9Sstevel@tonic-gate 	    (hubd_cpr_t *)kmem_zalloc(sizeof (hubd_cpr_t), KM_SLEEP);
72207c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
72217c478bd9Sstevel@tonic-gate 	mutex_init(&hubd->h_cpr_cb->lockp, NULL, MUTEX_DRIVER,
72227c478bd9Sstevel@tonic-gate 	    hubd->h_dev_data->dev_iblock_cookie);
72237c478bd9Sstevel@tonic-gate 	hubd->h_cpr_cb->statep = hubd;
72247c478bd9Sstevel@tonic-gate 	hubd->h_cpr_cb->cpr.cc_lockp = &hubd->h_cpr_cb->lockp;
72257c478bd9Sstevel@tonic-gate 	hubd->h_cpr_cb->cpr.cc_id = callb_add(hubd_cpr_post_user_callb,
72267c478bd9Sstevel@tonic-gate 	    (void *)hubd->h_cpr_cb, CB_CL_CPR_POST_USER, "hubd");
72277c478bd9Sstevel@tonic-gate }
72287c478bd9Sstevel@tonic-gate 
72297c478bd9Sstevel@tonic-gate 
72307c478bd9Sstevel@tonic-gate /* unregister callback with cpr framework */
72317c478bd9Sstevel@tonic-gate void
72327c478bd9Sstevel@tonic-gate hubd_unregister_cpr_callback(hubd_t *hubd)
72337c478bd9Sstevel@tonic-gate {
72347c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
72357c478bd9Sstevel@tonic-gate 	    "hubd_unregister_cpr_callback");
72367c478bd9Sstevel@tonic-gate 
72377c478bd9Sstevel@tonic-gate 	if (hubd->h_cpr_cb) {
72387c478bd9Sstevel@tonic-gate 		(void) callb_delete(hubd->h_cpr_cb->cpr.cc_id);
72397c478bd9Sstevel@tonic-gate 		mutex_destroy(&hubd->h_cpr_cb->lockp);
72407c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
72417c478bd9Sstevel@tonic-gate 		kmem_free(hubd->h_cpr_cb, sizeof (hubd_cpr_t));
72427c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
72437c478bd9Sstevel@tonic-gate 	}
72447c478bd9Sstevel@tonic-gate }
72457c478bd9Sstevel@tonic-gate 
72467c478bd9Sstevel@tonic-gate 
72477c478bd9Sstevel@tonic-gate /*
72487c478bd9Sstevel@tonic-gate  * Power management
72497c478bd9Sstevel@tonic-gate  *
72507c478bd9Sstevel@tonic-gate  * create the pm components required for power management
72517c478bd9Sstevel@tonic-gate  */
72527c478bd9Sstevel@tonic-gate static void
72537c478bd9Sstevel@tonic-gate hubd_create_pm_components(dev_info_t *dip, hubd_t *hubd)
72547c478bd9Sstevel@tonic-gate {
72557c478bd9Sstevel@tonic-gate 	hub_power_t	*hubpm;
72567c478bd9Sstevel@tonic-gate 
72577c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
72587c478bd9Sstevel@tonic-gate 	    "hubd_create_pm_components: Begin");
72597c478bd9Sstevel@tonic-gate 
72607c478bd9Sstevel@tonic-gate 	/* Allocate the state structure */
72617c478bd9Sstevel@tonic-gate 	hubpm = kmem_zalloc(sizeof (hub_power_t), KM_SLEEP);
72627c478bd9Sstevel@tonic-gate 
72637c478bd9Sstevel@tonic-gate 	hubd->h_hubpm = hubpm;
72647c478bd9Sstevel@tonic-gate 	hubpm->hubp_hubd = hubd;
72657c478bd9Sstevel@tonic-gate 	hubpm->hubp_pm_capabilities = 0;
72667c478bd9Sstevel@tonic-gate 	hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
72677c478bd9Sstevel@tonic-gate 	hubpm->hubp_time_at_full_power = ddi_get_time();
72687c478bd9Sstevel@tonic-gate 	hubpm->hubp_min_pm_threshold = hubdi_min_pm_threshold;
72697c478bd9Sstevel@tonic-gate 
72707c478bd9Sstevel@tonic-gate 	/* alloc memory to save power states of children */
72717c478bd9Sstevel@tonic-gate 	hubpm->hubp_child_pwrstate = (uint8_t *)
7272c0f24e5bSlg 	    kmem_zalloc(MAX_PORTS + 1, KM_SLEEP);
72737c478bd9Sstevel@tonic-gate 
72747c478bd9Sstevel@tonic-gate 	/*
72757c478bd9Sstevel@tonic-gate 	 * if the enable remote wakeup fails
72767c478bd9Sstevel@tonic-gate 	 * we still want to enable
72777c478bd9Sstevel@tonic-gate 	 * parent notification so we can PM the children
72787c478bd9Sstevel@tonic-gate 	 */
72797c478bd9Sstevel@tonic-gate 	usb_enable_parent_notification(dip);
72807c478bd9Sstevel@tonic-gate 
72817c478bd9Sstevel@tonic-gate 	if (usb_handle_remote_wakeup(dip,
72827c478bd9Sstevel@tonic-gate 	    USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS) {
72837c478bd9Sstevel@tonic-gate 		uint_t		pwr_states;
72847c478bd9Sstevel@tonic-gate 
72857c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
72867c478bd9Sstevel@tonic-gate 		    "hubd_create_pm_components: "
72877c478bd9Sstevel@tonic-gate 		    "Remote Wakeup Enabled");
72887c478bd9Sstevel@tonic-gate 
72897c478bd9Sstevel@tonic-gate 		if (usb_create_pm_components(dip, &pwr_states) ==
72907c478bd9Sstevel@tonic-gate 		    USB_SUCCESS) {
72917c478bd9Sstevel@tonic-gate 			mutex_enter(HUBD_MUTEX(hubd));
72927c478bd9Sstevel@tonic-gate 			hubpm->hubp_wakeup_enabled = 1;
72937c478bd9Sstevel@tonic-gate 			hubpm->hubp_pwr_states = (uint8_t)pwr_states;
72947c478bd9Sstevel@tonic-gate 
72957c478bd9Sstevel@tonic-gate 			/* we are busy now till end of the attach */
72967c478bd9Sstevel@tonic-gate 			hubd_pm_busy_component(hubd, dip, 0);
72977c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
72987c478bd9Sstevel@tonic-gate 
72997c478bd9Sstevel@tonic-gate 			/* bring the device to full power */
73007c478bd9Sstevel@tonic-gate 			(void) pm_raise_power(dip, 0,
73017c478bd9Sstevel@tonic-gate 			    USB_DEV_OS_FULL_PWR);
73027c478bd9Sstevel@tonic-gate 		}
73037c478bd9Sstevel@tonic-gate 	}
73047c478bd9Sstevel@tonic-gate 
73057c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
73067c478bd9Sstevel@tonic-gate 	    "hubd_create_pm_components: END");
73077c478bd9Sstevel@tonic-gate }
73087c478bd9Sstevel@tonic-gate 
73097c478bd9Sstevel@tonic-gate 
73107c478bd9Sstevel@tonic-gate /*
73117c478bd9Sstevel@tonic-gate  * Attachment point management
73127c478bd9Sstevel@tonic-gate  */
73137c478bd9Sstevel@tonic-gate /* ARGSUSED */
73147c478bd9Sstevel@tonic-gate int
73157c478bd9Sstevel@tonic-gate usba_hubdi_open(dev_info_t *dip, dev_t *devp, int flags, int otyp,
73167c478bd9Sstevel@tonic-gate 	cred_t *credp)
73177c478bd9Sstevel@tonic-gate {
73187c478bd9Sstevel@tonic-gate 	hubd_t *hubd;
73197c478bd9Sstevel@tonic-gate 
73207c478bd9Sstevel@tonic-gate 	if (otyp != OTYP_CHR)
73217c478bd9Sstevel@tonic-gate 		return (EINVAL);
73227c478bd9Sstevel@tonic-gate 
73237c478bd9Sstevel@tonic-gate 	hubd = hubd_get_soft_state(dip);
73247c478bd9Sstevel@tonic-gate 	if (hubd == NULL) {
73257c478bd9Sstevel@tonic-gate 		return (ENXIO);
73267c478bd9Sstevel@tonic-gate 	}
73277c478bd9Sstevel@tonic-gate 
73287c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
73297c478bd9Sstevel@tonic-gate 	    "hubd_open:");
73307c478bd9Sstevel@tonic-gate 
73317c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
73327c478bd9Sstevel@tonic-gate 	if ((flags & FEXCL) && (hubd->h_softstate & HUBD_SS_ISOPEN)) {
73337c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
73347c478bd9Sstevel@tonic-gate 
73357c478bd9Sstevel@tonic-gate 		return (EBUSY);
73367c478bd9Sstevel@tonic-gate 	}
73377c478bd9Sstevel@tonic-gate 
73387c478bd9Sstevel@tonic-gate 	hubd->h_softstate |= HUBD_SS_ISOPEN;
73397c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
73407c478bd9Sstevel@tonic-gate 
73417c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "opened");
73427c478bd9Sstevel@tonic-gate 
73437c478bd9Sstevel@tonic-gate 	return (0);
73447c478bd9Sstevel@tonic-gate }
73457c478bd9Sstevel@tonic-gate 
73467c478bd9Sstevel@tonic-gate 
73477c478bd9Sstevel@tonic-gate /* ARGSUSED */
73487c478bd9Sstevel@tonic-gate int
73497c478bd9Sstevel@tonic-gate usba_hubdi_close(dev_info_t *dip, dev_t dev, int flag, int otyp,
73507c478bd9Sstevel@tonic-gate 	cred_t *credp)
73517c478bd9Sstevel@tonic-gate {
73527c478bd9Sstevel@tonic-gate 	hubd_t *hubd;
73537c478bd9Sstevel@tonic-gate 
73547c478bd9Sstevel@tonic-gate 	if (otyp != OTYP_CHR) {
73557c478bd9Sstevel@tonic-gate 		return (EINVAL);
73567c478bd9Sstevel@tonic-gate 	}
73577c478bd9Sstevel@tonic-gate 
73587c478bd9Sstevel@tonic-gate 	hubd = hubd_get_soft_state(dip);
73597c478bd9Sstevel@tonic-gate 
73607c478bd9Sstevel@tonic-gate 	if (hubd == NULL) {
73617c478bd9Sstevel@tonic-gate 		return (ENXIO);
73627c478bd9Sstevel@tonic-gate 	}
73637c478bd9Sstevel@tonic-gate 
73647c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "hubd_close:");
73657c478bd9Sstevel@tonic-gate 
73667c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
73677c478bd9Sstevel@tonic-gate 	hubd->h_softstate &= ~HUBD_SS_ISOPEN;
73687c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
73697c478bd9Sstevel@tonic-gate 
73707c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "closed");
73717c478bd9Sstevel@tonic-gate 
73727c478bd9Sstevel@tonic-gate 	return (0);
73737c478bd9Sstevel@tonic-gate }
73747c478bd9Sstevel@tonic-gate 
73757c478bd9Sstevel@tonic-gate 
73767c478bd9Sstevel@tonic-gate /*
73777c478bd9Sstevel@tonic-gate  * hubd_ioctl: cfgadm controls
73787c478bd9Sstevel@tonic-gate  */
73797c478bd9Sstevel@tonic-gate /* ARGSUSED */
73807c478bd9Sstevel@tonic-gate int
73817c478bd9Sstevel@tonic-gate usba_hubdi_ioctl(dev_info_t *self, dev_t dev, int cmd, intptr_t arg,
73827c478bd9Sstevel@tonic-gate 	int mode, cred_t *credp, int *rvalp)
73837c478bd9Sstevel@tonic-gate {
73847c478bd9Sstevel@tonic-gate 	int			rv = 0;
73857c478bd9Sstevel@tonic-gate 	char			*msg;	/* for messages */
73867c478bd9Sstevel@tonic-gate 	hubd_t			*hubd;
73877c478bd9Sstevel@tonic-gate 	usb_port_t		port = 0;
73887c478bd9Sstevel@tonic-gate 	dev_info_t		*child_dip = NULL;
73897c478bd9Sstevel@tonic-gate 	dev_info_t		*rh_dip;
73907c478bd9Sstevel@tonic-gate 	devctl_ap_state_t	ap_state;
73917c478bd9Sstevel@tonic-gate 	struct devctl_iocdata	*dcp = NULL;
73927c478bd9Sstevel@tonic-gate 	usb_pipe_state_t	prev_pipe_state = 0;
73937c478bd9Sstevel@tonic-gate 	int			circ, rh_circ, prh_circ;
73947c478bd9Sstevel@tonic-gate 
73957c478bd9Sstevel@tonic-gate 	if ((hubd = hubd_get_soft_state(self)) == NULL) {
73967c478bd9Sstevel@tonic-gate 
73977c478bd9Sstevel@tonic-gate 		return (ENXIO);
73987c478bd9Sstevel@tonic-gate 	}
73997c478bd9Sstevel@tonic-gate 
74007c478bd9Sstevel@tonic-gate 	rh_dip = hubd->h_usba_device->usb_root_hub_dip;
74017c478bd9Sstevel@tonic-gate 
74027c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
74037c478bd9Sstevel@tonic-gate 	    "usba_hubdi_ioctl: "
74047c478bd9Sstevel@tonic-gate 	    "cmd=%x, arg=%lx, mode=%x, cred=%p, rval=%p dev=0x%lx",
7405112116d8Sfb 	    cmd, arg, mode, (void *)credp, (void *)rvalp, dev);
74067c478bd9Sstevel@tonic-gate 
74077c478bd9Sstevel@tonic-gate 	/* read devctl ioctl data */
74087c478bd9Sstevel@tonic-gate 	if ((cmd != DEVCTL_AP_CONTROL) &&
74097c478bd9Sstevel@tonic-gate 	    (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)) {
74107c478bd9Sstevel@tonic-gate 
74117c478bd9Sstevel@tonic-gate 		return (EFAULT);
74127c478bd9Sstevel@tonic-gate 	}
74137c478bd9Sstevel@tonic-gate 
74147c478bd9Sstevel@tonic-gate 	/*
74157c478bd9Sstevel@tonic-gate 	 * make sure the hub is connected before trying any
74167c478bd9Sstevel@tonic-gate 	 * of the following operations:
74177c478bd9Sstevel@tonic-gate 	 * configure, connect, disconnect
74187c478bd9Sstevel@tonic-gate 	 */
74197c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
74207c478bd9Sstevel@tonic-gate 
74217c478bd9Sstevel@tonic-gate 	switch (cmd) {
74227c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_DISCONNECT:
74237c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_UNCONFIGURE:
74247c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_CONFIGURE:
74257c478bd9Sstevel@tonic-gate 		if (hubd->h_dev_state == USB_DEV_DISCONNECTED) {
74267c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
74277c478bd9Sstevel@tonic-gate 			    "hubd: already gone");
74287c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
74297c478bd9Sstevel@tonic-gate 			if (dcp) {
74307c478bd9Sstevel@tonic-gate 				ndi_dc_freehdl(dcp);
74317c478bd9Sstevel@tonic-gate 			}
74327c478bd9Sstevel@tonic-gate 
74337c478bd9Sstevel@tonic-gate 			return (EIO);
74347c478bd9Sstevel@tonic-gate 		}
74357c478bd9Sstevel@tonic-gate 
74367c478bd9Sstevel@tonic-gate 		/* FALLTHROUGH */
74377c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_GETSTATE:
74387c478bd9Sstevel@tonic-gate 		if ((port = hubd_get_port_num(hubd, dcp)) == 0) {
74397c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
74407c478bd9Sstevel@tonic-gate 			    "hubd: bad port");
74417c478bd9Sstevel@tonic-gate 			mutex_exit(HUBD_MUTEX(hubd));
74427c478bd9Sstevel@tonic-gate 			if (dcp) {
74437c478bd9Sstevel@tonic-gate 				ndi_dc_freehdl(dcp);
74447c478bd9Sstevel@tonic-gate 			}
74457c478bd9Sstevel@tonic-gate 
74467c478bd9Sstevel@tonic-gate 			return (EINVAL);
74477c478bd9Sstevel@tonic-gate 		}
74487c478bd9Sstevel@tonic-gate 		break;
74497c478bd9Sstevel@tonic-gate 
74507c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_CONTROL:
74517c478bd9Sstevel@tonic-gate 
74527c478bd9Sstevel@tonic-gate 		break;
74537c478bd9Sstevel@tonic-gate 	default:
74547c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
74557c478bd9Sstevel@tonic-gate 		if (dcp) {
74567c478bd9Sstevel@tonic-gate 			ndi_dc_freehdl(dcp);
74577c478bd9Sstevel@tonic-gate 		}
74587c478bd9Sstevel@tonic-gate 
74597c478bd9Sstevel@tonic-gate 		return (ENOTTY);
74607c478bd9Sstevel@tonic-gate 	}
74617c478bd9Sstevel@tonic-gate 
74627c478bd9Sstevel@tonic-gate 	/* should not happen, just in case */
74637c478bd9Sstevel@tonic-gate 	if (hubd->h_dev_state == USB_DEV_SUSPENDED) {
74647c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
74657c478bd9Sstevel@tonic-gate 		if (dcp) {
74667c478bd9Sstevel@tonic-gate 			ndi_dc_freehdl(dcp);
74677c478bd9Sstevel@tonic-gate 		}
74687c478bd9Sstevel@tonic-gate 
74697c478bd9Sstevel@tonic-gate 		return (EIO);
74707c478bd9Sstevel@tonic-gate 	}
74717c478bd9Sstevel@tonic-gate 
7472ffcd51f3Slg 	if (hubd->h_reset_port[port]) {
7473ffcd51f3Slg 		USB_DPRINTF_L2(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7474ffcd51f3Slg 		    "This port is resetting, just return");
7475ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
7476ffcd51f3Slg 		if (dcp) {
7477ffcd51f3Slg 			ndi_dc_freehdl(dcp);
7478ffcd51f3Slg 		}
7479ffcd51f3Slg 
7480ffcd51f3Slg 		return (EIO);
7481ffcd51f3Slg 	}
7482ffcd51f3Slg 
74837c478bd9Sstevel@tonic-gate 	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
74847c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
74857c478bd9Sstevel@tonic-gate 
74867c478bd9Sstevel@tonic-gate 	/* go full power */
74877c478bd9Sstevel@tonic-gate 	(void) pm_raise_power(hubd->h_dip, 0, USB_DEV_OS_FULL_PWR);
74887c478bd9Sstevel@tonic-gate 
74897c478bd9Sstevel@tonic-gate 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
74907c478bd9Sstevel@tonic-gate 	ndi_devi_enter(rh_dip, &rh_circ);
74917c478bd9Sstevel@tonic-gate 	ndi_devi_enter(hubd->h_dip, &circ);
74927c478bd9Sstevel@tonic-gate 
74937c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
74947c478bd9Sstevel@tonic-gate 
7495c0f24e5bSlg 	hubd->h_hotplug_thread++;
7496c0f24e5bSlg 
7497c0f24e5bSlg 	/* stop polling if it was active */
74987c478bd9Sstevel@tonic-gate 	if (hubd->h_ep1_ph) {
74997c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
75007c478bd9Sstevel@tonic-gate 		(void) usb_pipe_get_state(hubd->h_ep1_ph, &prev_pipe_state,
7501c0f24e5bSlg 		    USB_FLAGS_SLEEP);
75027c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
75037c478bd9Sstevel@tonic-gate 
75047c478bd9Sstevel@tonic-gate 		if (prev_pipe_state == USB_PIPE_STATE_ACTIVE) {
75057c478bd9Sstevel@tonic-gate 			hubd_stop_polling(hubd);
75067c478bd9Sstevel@tonic-gate 		}
75077c478bd9Sstevel@tonic-gate 	}
75087c478bd9Sstevel@tonic-gate 
75097c478bd9Sstevel@tonic-gate 	switch (cmd) {
75107c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_DISCONNECT:
75117c478bd9Sstevel@tonic-gate 		if (hubd_delete_child(hubd, port,
75127c478bd9Sstevel@tonic-gate 		    NDI_DEVI_REMOVE, B_FALSE) != USB_SUCCESS) {
75137c478bd9Sstevel@tonic-gate 			rv = EIO;
75147c478bd9Sstevel@tonic-gate 		}
75157c478bd9Sstevel@tonic-gate 
75167c478bd9Sstevel@tonic-gate 		break;
75177c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_UNCONFIGURE:
75187c478bd9Sstevel@tonic-gate 		if (hubd_delete_child(hubd, port,
75197c478bd9Sstevel@tonic-gate 		    NDI_UNCONFIG, B_FALSE) != USB_SUCCESS) {
75207c478bd9Sstevel@tonic-gate 			rv = EIO;
75217c478bd9Sstevel@tonic-gate 		}
75227c478bd9Sstevel@tonic-gate 
75237c478bd9Sstevel@tonic-gate 		break;
75247c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_CONFIGURE:
75257c478bd9Sstevel@tonic-gate 		/* toggle port */
75267c478bd9Sstevel@tonic-gate 		if (hubd_toggle_port(hubd, port) != USB_SUCCESS) {
75277c478bd9Sstevel@tonic-gate 			rv = EIO;
75287c478bd9Sstevel@tonic-gate 
75297c478bd9Sstevel@tonic-gate 			break;
75307c478bd9Sstevel@tonic-gate 		}
75317c478bd9Sstevel@tonic-gate 
75327c478bd9Sstevel@tonic-gate 		(void) hubd_handle_port_connect(hubd, port);
75337c478bd9Sstevel@tonic-gate 		child_dip = hubd_get_child_dip(hubd, port);
75347c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
75357c478bd9Sstevel@tonic-gate 
75367c478bd9Sstevel@tonic-gate 		ndi_devi_exit(hubd->h_dip, circ);
75377c478bd9Sstevel@tonic-gate 		ndi_devi_exit(rh_dip, rh_circ);
75387c478bd9Sstevel@tonic-gate 		ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
7539e4c316c4SVincent Wang 		if (child_dip == NULL) {
75407c478bd9Sstevel@tonic-gate 			rv = EIO;
7541e4c316c4SVincent Wang 		} else {
7542e4c316c4SVincent Wang 			ndi_hold_devi(child_dip);
7543e4c316c4SVincent Wang 			if (ndi_devi_online(child_dip, 0) != NDI_SUCCESS)
7544e4c316c4SVincent Wang 				rv = EIO;
7545e4c316c4SVincent Wang 			ndi_rele_devi(child_dip);
75467c478bd9Sstevel@tonic-gate 		}
75477c478bd9Sstevel@tonic-gate 		ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
75487c478bd9Sstevel@tonic-gate 		ndi_devi_enter(rh_dip, &rh_circ);
75497c478bd9Sstevel@tonic-gate 		ndi_devi_enter(hubd->h_dip, &circ);
75507c478bd9Sstevel@tonic-gate 
75517c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
75527c478bd9Sstevel@tonic-gate 
75537c478bd9Sstevel@tonic-gate 		break;
75547c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_GETSTATE:
75557c478bd9Sstevel@tonic-gate 		switch (hubd_cfgadm_state(hubd, port)) {
75567c478bd9Sstevel@tonic-gate 		case HUBD_CFGADM_DISCONNECTED:
75577c478bd9Sstevel@tonic-gate 			/* port previously 'disconnected' by cfgadm */
75587c478bd9Sstevel@tonic-gate 			ap_state.ap_rstate = AP_RSTATE_DISCONNECTED;
75597c478bd9Sstevel@tonic-gate 			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
75607c478bd9Sstevel@tonic-gate 			ap_state.ap_condition = AP_COND_OK;
75617c478bd9Sstevel@tonic-gate 
75627c478bd9Sstevel@tonic-gate 			break;
75637c478bd9Sstevel@tonic-gate 		case HUBD_CFGADM_UNCONFIGURED:
75647c478bd9Sstevel@tonic-gate 			ap_state.ap_rstate = AP_RSTATE_CONNECTED;
75657c478bd9Sstevel@tonic-gate 			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
75667c478bd9Sstevel@tonic-gate 			ap_state.ap_condition = AP_COND_OK;
75677c478bd9Sstevel@tonic-gate 
75687c478bd9Sstevel@tonic-gate 			break;
75697c478bd9Sstevel@tonic-gate 		case HUBD_CFGADM_CONFIGURED:
75707c478bd9Sstevel@tonic-gate 			ap_state.ap_rstate = AP_RSTATE_CONNECTED;
75717c478bd9Sstevel@tonic-gate 			ap_state.ap_ostate = AP_OSTATE_CONFIGURED;
75727c478bd9Sstevel@tonic-gate 			ap_state.ap_condition = AP_COND_OK;
75737c478bd9Sstevel@tonic-gate 
75747c478bd9Sstevel@tonic-gate 			break;
75757c478bd9Sstevel@tonic-gate 		case HUBD_CFGADM_STILL_REFERENCED:
75767c478bd9Sstevel@tonic-gate 			ap_state.ap_rstate = AP_RSTATE_EMPTY;
75777c478bd9Sstevel@tonic-gate 			ap_state.ap_ostate = AP_OSTATE_CONFIGURED;
75787c478bd9Sstevel@tonic-gate 			ap_state.ap_condition = AP_COND_UNUSABLE;
75797c478bd9Sstevel@tonic-gate 
75807c478bd9Sstevel@tonic-gate 			break;
75817c478bd9Sstevel@tonic-gate 		case HUBD_CFGADM_EMPTY:
75827c478bd9Sstevel@tonic-gate 		default:
75837c478bd9Sstevel@tonic-gate 			ap_state.ap_rstate = AP_RSTATE_EMPTY;
75847c478bd9Sstevel@tonic-gate 			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
75857c478bd9Sstevel@tonic-gate 			ap_state.ap_condition = AP_COND_OK;
75867c478bd9Sstevel@tonic-gate 
75877c478bd9Sstevel@tonic-gate 			break;
75887c478bd9Sstevel@tonic-gate 		}
75897c478bd9Sstevel@tonic-gate 
75907c478bd9Sstevel@tonic-gate 		ap_state.ap_last_change = (time_t)-1;
75917c478bd9Sstevel@tonic-gate 		ap_state.ap_error_code = 0;
75927c478bd9Sstevel@tonic-gate 		ap_state.ap_in_transition = 0;
75937c478bd9Sstevel@tonic-gate 
75947c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
75957c478bd9Sstevel@tonic-gate 		    "DEVCTL_AP_GETSTATE: "
75967c478bd9Sstevel@tonic-gate 		    "ostate=0x%x, rstate=0x%x, condition=0x%x",
75977c478bd9Sstevel@tonic-gate 		    ap_state.ap_ostate,
75987c478bd9Sstevel@tonic-gate 		    ap_state.ap_rstate, ap_state.ap_condition);
75997c478bd9Sstevel@tonic-gate 
76007c478bd9Sstevel@tonic-gate 		/* copy the return-AP-state information to the user space */
76017c478bd9Sstevel@tonic-gate 		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
76027c478bd9Sstevel@tonic-gate 			rv = EFAULT;
76037c478bd9Sstevel@tonic-gate 		}
76047c478bd9Sstevel@tonic-gate 
76057c478bd9Sstevel@tonic-gate 		break;
76067c478bd9Sstevel@tonic-gate 	case DEVCTL_AP_CONTROL:
76077c478bd9Sstevel@tonic-gate 	{
76087c478bd9Sstevel@tonic-gate 		/*
76097c478bd9Sstevel@tonic-gate 		 * Generic devctl for hardware-specific functionality.
76107c478bd9Sstevel@tonic-gate 		 * For list of sub-commands see hubd_impl.h
76117c478bd9Sstevel@tonic-gate 		 */
76127c478bd9Sstevel@tonic-gate 		hubd_ioctl_data_t	ioc;	/* for 64 byte copies */
76137c478bd9Sstevel@tonic-gate 
76147c478bd9Sstevel@tonic-gate 		/* copy user ioctl data in first */
76157c478bd9Sstevel@tonic-gate #ifdef _MULTI_DATAMODEL
76167c478bd9Sstevel@tonic-gate 		if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
76177c478bd9Sstevel@tonic-gate 			hubd_ioctl_data_32_t ioc32;
76187c478bd9Sstevel@tonic-gate 
76197c478bd9Sstevel@tonic-gate 			if (ddi_copyin((void *)arg, (void *)&ioc32,
7620c0f24e5bSlg 			    sizeof (ioc32), mode) != 0) {
76217c478bd9Sstevel@tonic-gate 				rv = EFAULT;
76227c478bd9Sstevel@tonic-gate 
76237c478bd9Sstevel@tonic-gate 				break;
76247c478bd9Sstevel@tonic-gate 			}
76257c478bd9Sstevel@tonic-gate 			ioc.cmd		= (uint_t)ioc32.cmd;
76267c478bd9Sstevel@tonic-gate 			ioc.port	= (uint_t)ioc32.port;
76277c478bd9Sstevel@tonic-gate 			ioc.get_size	= (uint_t)ioc32.get_size;
76287c478bd9Sstevel@tonic-gate 			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;
76297c478bd9Sstevel@tonic-gate 			ioc.bufsiz	= (uint_t)ioc32.bufsiz;
76307c478bd9Sstevel@tonic-gate 			ioc.misc_arg	= (uint_t)ioc32.misc_arg;
76317c478bd9Sstevel@tonic-gate 		} else
76327c478bd9Sstevel@tonic-gate #endif /* _MULTI_DATAMODEL */
76337c478bd9Sstevel@tonic-gate 		if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
76347c478bd9Sstevel@tonic-gate 		    mode) != 0) {
76357c478bd9Sstevel@tonic-gate 			rv = EFAULT;
76367c478bd9Sstevel@tonic-gate 
76377c478bd9Sstevel@tonic-gate 			break;
76387c478bd9Sstevel@tonic-gate 		}
76397c478bd9Sstevel@tonic-gate 
76407c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L3(DPRINT_MASK_CBOPS, hubd->h_log_handle,
76417c478bd9Sstevel@tonic-gate 		    "DEVCTL_AP_CONTROL: ioc: cmd=0x%x port=%d get_size=%d"
76427c478bd9Sstevel@tonic-gate 		    "\n\tbuf=0x%p, bufsiz=%d,  misc_arg=%d", ioc.cmd,
7643112116d8Sfb 		    ioc.port, ioc.get_size, (void *)ioc.buf, ioc.bufsiz,
7644112116d8Sfb 		    ioc.misc_arg);
76457c478bd9Sstevel@tonic-gate 
76467c478bd9Sstevel@tonic-gate 		/*
76477c478bd9Sstevel@tonic-gate 		 * To avoid BE/LE and 32/64 issues, a get_size always
76487c478bd9Sstevel@tonic-gate 		 * returns a 32-bit number.
76497c478bd9Sstevel@tonic-gate 		 */
76507c478bd9Sstevel@tonic-gate 		if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
76517c478bd9Sstevel@tonic-gate 			rv = EINVAL;
76527c478bd9Sstevel@tonic-gate 
76537c478bd9Sstevel@tonic-gate 			break;
76547c478bd9Sstevel@tonic-gate 		}
76557c478bd9Sstevel@tonic-gate 
76567c478bd9Sstevel@tonic-gate 		switch (ioc.cmd) {
76577c478bd9Sstevel@tonic-gate 		case USB_DESCR_TYPE_DEV:
76587c478bd9Sstevel@tonic-gate 			msg = "DEVCTL_AP_CONTROL: GET_DEVICE_DESC";
76597c478bd9Sstevel@tonic-gate 			if (ioc.get_size) {
76607c478bd9Sstevel@tonic-gate 				/* uint32 so this works 32/64 */
76617c478bd9Sstevel@tonic-gate 				uint32_t size = sizeof (usb_dev_descr_t);
76627c478bd9Sstevel@tonic-gate 
76637c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)&size, ioc.buf,
76647c478bd9Sstevel@tonic-gate 				    ioc.bufsiz, mode) != 0) {
76657c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
76667c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
76677c478bd9Sstevel@tonic-gate 					    "%s: get_size copyout failed", msg);
76687c478bd9Sstevel@tonic-gate 					rv = EIO;
76697c478bd9Sstevel@tonic-gate 
76707c478bd9Sstevel@tonic-gate 					break;
76717c478bd9Sstevel@tonic-gate 				}
76727c478bd9Sstevel@tonic-gate 			} else {	/* send out the actual descr */
76737c478bd9Sstevel@tonic-gate 				usb_dev_descr_t *dev_descrp;
76747c478bd9Sstevel@tonic-gate 
76757c478bd9Sstevel@tonic-gate 				/* check child_dip */
76767c478bd9Sstevel@tonic-gate 				if ((child_dip = hubd_get_child_dip(hubd,
76777c478bd9Sstevel@tonic-gate 				    ioc.port)) == NULL) {
76787c478bd9Sstevel@tonic-gate 					rv = EINVAL;
76797c478bd9Sstevel@tonic-gate 
76807c478bd9Sstevel@tonic-gate 					break;
76817c478bd9Sstevel@tonic-gate 				}
76827c478bd9Sstevel@tonic-gate 
76837c478bd9Sstevel@tonic-gate 				dev_descrp = usb_get_dev_descr(child_dip);
76847c478bd9Sstevel@tonic-gate 				if (ioc.bufsiz != sizeof (*dev_descrp)) {
76857c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
76867c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
76877c478bd9Sstevel@tonic-gate 					    "%s: bufsize passed (%d) != sizeof "
76887c478bd9Sstevel@tonic-gate 					    "usba_device_descr_t (%d)", msg,
76897c478bd9Sstevel@tonic-gate 					    ioc.bufsiz, dev_descrp->bLength);
76907c478bd9Sstevel@tonic-gate 					rv = EINVAL;
76917c478bd9Sstevel@tonic-gate 
76927c478bd9Sstevel@tonic-gate 					break;
76937c478bd9Sstevel@tonic-gate 				}
76947c478bd9Sstevel@tonic-gate 
76957c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)dev_descrp,
76967c478bd9Sstevel@tonic-gate 				    ioc.buf, ioc.bufsiz, mode) != 0) {
76977c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
76987c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
76997c478bd9Sstevel@tonic-gate 					    "%s: copyout failed.", msg);
77007c478bd9Sstevel@tonic-gate 					rv = EIO;
77017c478bd9Sstevel@tonic-gate 
77027c478bd9Sstevel@tonic-gate 					break;
77037c478bd9Sstevel@tonic-gate 				}
77047c478bd9Sstevel@tonic-gate 			}
77057c478bd9Sstevel@tonic-gate 			break;
77067c478bd9Sstevel@tonic-gate 		case USB_DESCR_TYPE_STRING:
77077c478bd9Sstevel@tonic-gate 		{
77087c478bd9Sstevel@tonic-gate 			char		*str;
77097c478bd9Sstevel@tonic-gate 			uint32_t	size;
77107c478bd9Sstevel@tonic-gate 			usba_device_t	*usba_device;
77117c478bd9Sstevel@tonic-gate 
77127c478bd9Sstevel@tonic-gate 			msg = "DEVCTL_AP_CONTROL: GET_STRING_DESCR";
77137c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
77147c478bd9Sstevel@tonic-gate 			    "%s: string request: %d", msg, ioc.misc_arg);
77157c478bd9Sstevel@tonic-gate 
77167c478bd9Sstevel@tonic-gate 			/* recheck */
77177c478bd9Sstevel@tonic-gate 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
77187c478bd9Sstevel@tonic-gate 			    NULL) {
77197c478bd9Sstevel@tonic-gate 				rv = EINVAL;
77207c478bd9Sstevel@tonic-gate 
77217c478bd9Sstevel@tonic-gate 				break;
77227c478bd9Sstevel@tonic-gate 			}
77237c478bd9Sstevel@tonic-gate 			usba_device = usba_get_usba_device(child_dip);
77247c478bd9Sstevel@tonic-gate 
77257c478bd9Sstevel@tonic-gate 			switch (ioc.misc_arg) {
77267c478bd9Sstevel@tonic-gate 			case HUBD_MFG_STR:
77277c478bd9Sstevel@tonic-gate 				str = usba_device->usb_mfg_str;
77287c478bd9Sstevel@tonic-gate 
77297c478bd9Sstevel@tonic-gate 				break;
77307c478bd9Sstevel@tonic-gate 			case HUBD_PRODUCT_STR:
77317c478bd9Sstevel@tonic-gate 				str = usba_device->usb_product_str;
77327c478bd9Sstevel@tonic-gate 
77337c478bd9Sstevel@tonic-gate 				break;
77347c478bd9Sstevel@tonic-gate 			case HUBD_SERIALNO_STR:
77357c478bd9Sstevel@tonic-gate 				str = usba_device->usb_serialno_str;
77367c478bd9Sstevel@tonic-gate 
77377c478bd9Sstevel@tonic-gate 				break;
77387c478bd9Sstevel@tonic-gate 			case HUBD_CFG_DESCR_STR:
77397c478bd9Sstevel@tonic-gate 				mutex_enter(&usba_device->usb_mutex);
77407c478bd9Sstevel@tonic-gate 				str = usba_device->usb_cfg_str_descr[
7741c0f24e5bSlg 				    usba_device->usb_active_cfg_ndx];
77427c478bd9Sstevel@tonic-gate 				mutex_exit(&usba_device->usb_mutex);
77437c478bd9Sstevel@tonic-gate 
77447c478bd9Sstevel@tonic-gate 				break;
77457c478bd9Sstevel@tonic-gate 			default:
77467c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
77477c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
77487c478bd9Sstevel@tonic-gate 				    "%s: Invalid string request", msg);
77497c478bd9Sstevel@tonic-gate 				rv = EINVAL;
77507c478bd9Sstevel@tonic-gate 
77517c478bd9Sstevel@tonic-gate 				break;
77527c478bd9Sstevel@tonic-gate 			} /* end of switch */
77537c478bd9Sstevel@tonic-gate 
77547c478bd9Sstevel@tonic-gate 			if (rv != 0) {
77557c478bd9Sstevel@tonic-gate 
77567c478bd9Sstevel@tonic-gate 				break;
77577c478bd9Sstevel@tonic-gate 			}
77587c478bd9Sstevel@tonic-gate 
77597c478bd9Sstevel@tonic-gate 			size = (str != NULL) ? strlen(str) + 1 : 0;
77607c478bd9Sstevel@tonic-gate 			if (ioc.get_size) {
77617c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)&size, ioc.buf,
77627c478bd9Sstevel@tonic-gate 				    ioc.bufsiz, mode) != 0) {
77637c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
77647c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
77657c478bd9Sstevel@tonic-gate 					    "%s: copyout of size failed.", msg);
77667c478bd9Sstevel@tonic-gate 					rv = EIO;
77677c478bd9Sstevel@tonic-gate 
77687c478bd9Sstevel@tonic-gate 					break;
77697c478bd9Sstevel@tonic-gate 				}
77707c478bd9Sstevel@tonic-gate 			} else {
77717c478bd9Sstevel@tonic-gate 				if (size == 0) {
77727c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L3(DPRINT_MASK_CBOPS,
77737c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
77747c478bd9Sstevel@tonic-gate 					    "%s: String is NULL", msg);
77757c478bd9Sstevel@tonic-gate 					rv = EINVAL;
77767c478bd9Sstevel@tonic-gate 
77777c478bd9Sstevel@tonic-gate 					break;
77787c478bd9Sstevel@tonic-gate 				}
77797c478bd9Sstevel@tonic-gate 
77807c478bd9Sstevel@tonic-gate 				if (ioc.bufsiz != size) {
77817c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
77827c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
77837c478bd9Sstevel@tonic-gate 					    "%s: string buf size wrong", msg);
77847c478bd9Sstevel@tonic-gate 					rv = EINVAL;
77857c478bd9Sstevel@tonic-gate 
77867c478bd9Sstevel@tonic-gate 					break;
77877c478bd9Sstevel@tonic-gate 				}
77887c478bd9Sstevel@tonic-gate 
77897c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)str, ioc.buf,
77907c478bd9Sstevel@tonic-gate 				    ioc.bufsiz, mode) != 0) {
77917c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
77927c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
77937c478bd9Sstevel@tonic-gate 					    "%s: copyout failed.", msg);
77947c478bd9Sstevel@tonic-gate 					rv = EIO;
77957c478bd9Sstevel@tonic-gate 
77967c478bd9Sstevel@tonic-gate 					break;
77977c478bd9Sstevel@tonic-gate 				}
77987c478bd9Sstevel@tonic-gate 			}
77997c478bd9Sstevel@tonic-gate 			break;
78007c478bd9Sstevel@tonic-gate 		}
78017c478bd9Sstevel@tonic-gate 		case HUBD_GET_CFGADM_NAME:
78027c478bd9Sstevel@tonic-gate 		{
78037c478bd9Sstevel@tonic-gate 			uint32_t   name_len;
78047c478bd9Sstevel@tonic-gate 			const char *name;
78057c478bd9Sstevel@tonic-gate 
78067c478bd9Sstevel@tonic-gate 			/* recheck */
78077c478bd9Sstevel@tonic-gate 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
78087c478bd9Sstevel@tonic-gate 			    NULL) {
78097c478bd9Sstevel@tonic-gate 				rv = EINVAL;
78107c478bd9Sstevel@tonic-gate 
78117c478bd9Sstevel@tonic-gate 				break;
78127c478bd9Sstevel@tonic-gate 			}
78137c478bd9Sstevel@tonic-gate 			name = ddi_node_name(child_dip);
78147c478bd9Sstevel@tonic-gate 			if (name == NULL) {
78157c478bd9Sstevel@tonic-gate 				name = "unsupported";
78167c478bd9Sstevel@tonic-gate 			}
78177c478bd9Sstevel@tonic-gate 			name_len = strlen(name) + 1;
78187c478bd9Sstevel@tonic-gate 
78197c478bd9Sstevel@tonic-gate 			msg = "DEVCTL_AP_CONTROL: HUBD_GET_CFGADM_NAME";
78207c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
78217c478bd9Sstevel@tonic-gate 			    "%s: name=%s name_len=%d", msg, name, name_len);
78227c478bd9Sstevel@tonic-gate 
78237c478bd9Sstevel@tonic-gate 			if (ioc.get_size) {
78247c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)&name_len,
78257c478bd9Sstevel@tonic-gate 				    ioc.buf, ioc.bufsiz, mode) != 0) {
78267c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
78277c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
78287c478bd9Sstevel@tonic-gate 					    "%s: copyout of size failed", msg);
78297c478bd9Sstevel@tonic-gate 					rv = EIO;
78307c478bd9Sstevel@tonic-gate 
78317c478bd9Sstevel@tonic-gate 					break;
78327c478bd9Sstevel@tonic-gate 				}
78337c478bd9Sstevel@tonic-gate 			} else {
78347c478bd9Sstevel@tonic-gate 				if (ioc.bufsiz != name_len) {
78357c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
78367c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
78377c478bd9Sstevel@tonic-gate 					    "%s: string buf length wrong", msg);
78387c478bd9Sstevel@tonic-gate 					rv = EINVAL;
78397c478bd9Sstevel@tonic-gate 
78407c478bd9Sstevel@tonic-gate 					break;
78417c478bd9Sstevel@tonic-gate 				}
78427c478bd9Sstevel@tonic-gate 
78437c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)name, ioc.buf,
78447c478bd9Sstevel@tonic-gate 				    ioc.bufsiz, mode) != 0) {
78457c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
78467c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
78477c478bd9Sstevel@tonic-gate 					    "%s: copyout failed.", msg);
78487c478bd9Sstevel@tonic-gate 					rv = EIO;
78497c478bd9Sstevel@tonic-gate 
78507c478bd9Sstevel@tonic-gate 					break;
78517c478bd9Sstevel@tonic-gate 				}
78527c478bd9Sstevel@tonic-gate 			}
78537c478bd9Sstevel@tonic-gate 
78547c478bd9Sstevel@tonic-gate 			break;
78557c478bd9Sstevel@tonic-gate 		}
78567c478bd9Sstevel@tonic-gate 
78577c478bd9Sstevel@tonic-gate 		/*
78587c478bd9Sstevel@tonic-gate 		 * Return the config index for the currently-configured
78597c478bd9Sstevel@tonic-gate 		 * configuration.
78607c478bd9Sstevel@tonic-gate 		 */
78617c478bd9Sstevel@tonic-gate 		case HUBD_GET_CURRENT_CONFIG:
78627c478bd9Sstevel@tonic-gate 		{
78637c478bd9Sstevel@tonic-gate 			uint_t		config_index;
78647c478bd9Sstevel@tonic-gate 			uint32_t	size = sizeof (config_index);
78657c478bd9Sstevel@tonic-gate 			usba_device_t	*usba_device;
78667c478bd9Sstevel@tonic-gate 
78677c478bd9Sstevel@tonic-gate 			msg = "DEVCTL_AP_CONTROL: GET_CURRENT_CONFIG";
78687c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
78697c478bd9Sstevel@tonic-gate 			    "%s", msg);
78707c478bd9Sstevel@tonic-gate 
78717c478bd9Sstevel@tonic-gate 			/*
78727c478bd9Sstevel@tonic-gate 			 * Return the config index for the configuration
78737c478bd9Sstevel@tonic-gate 			 * currently in use.
78747c478bd9Sstevel@tonic-gate 			 * Recheck if child_dip exists
78757c478bd9Sstevel@tonic-gate 			 */
78767c478bd9Sstevel@tonic-gate 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
78777c478bd9Sstevel@tonic-gate 			    NULL) {
78787c478bd9Sstevel@tonic-gate 				rv = EINVAL;
78797c478bd9Sstevel@tonic-gate 
78807c478bd9Sstevel@tonic-gate 				break;
78817c478bd9Sstevel@tonic-gate 			}
78827c478bd9Sstevel@tonic-gate 
78837c478bd9Sstevel@tonic-gate 			usba_device = usba_get_usba_device(child_dip);
78847c478bd9Sstevel@tonic-gate 			mutex_enter(&usba_device->usb_mutex);
78857c478bd9Sstevel@tonic-gate 			config_index = usba_device->usb_active_cfg_ndx;
78867c478bd9Sstevel@tonic-gate 			mutex_exit(&usba_device->usb_mutex);
78877c478bd9Sstevel@tonic-gate 
78887c478bd9Sstevel@tonic-gate 			if (ioc.get_size) {
78897c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)&size,
78907c478bd9Sstevel@tonic-gate 				    ioc.buf, ioc.bufsiz, mode) != 0) {
78917c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
78927c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
78937c478bd9Sstevel@tonic-gate 					    "%s: copyout of size failed.", msg);
78947c478bd9Sstevel@tonic-gate 					rv = EIO;
78957c478bd9Sstevel@tonic-gate 
78967c478bd9Sstevel@tonic-gate 					break;
78977c478bd9Sstevel@tonic-gate 				}
78987c478bd9Sstevel@tonic-gate 			} else {
78997c478bd9Sstevel@tonic-gate 				if (ioc.bufsiz != size) {
79007c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
79017c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
79027c478bd9Sstevel@tonic-gate 					    "%s: buffer size wrong", msg);
79037c478bd9Sstevel@tonic-gate 					rv = EINVAL;
79047c478bd9Sstevel@tonic-gate 
79057c478bd9Sstevel@tonic-gate 					break;
79067c478bd9Sstevel@tonic-gate 				}
79077c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)&config_index,
79087c478bd9Sstevel@tonic-gate 				    ioc.buf, ioc.bufsiz, mode) != 0) {
79097c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
79107c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
79117c478bd9Sstevel@tonic-gate 					    "%s: copyout failed", msg);
79127c478bd9Sstevel@tonic-gate 					rv = EIO;
79137c478bd9Sstevel@tonic-gate 				}
79147c478bd9Sstevel@tonic-gate 			}
79157c478bd9Sstevel@tonic-gate 
79167c478bd9Sstevel@tonic-gate 			break;
79177c478bd9Sstevel@tonic-gate 		}
79187c478bd9Sstevel@tonic-gate 		case HUBD_GET_DEVICE_PATH:
79197c478bd9Sstevel@tonic-gate 		{
79207c478bd9Sstevel@tonic-gate 			char		*path;
79217c478bd9Sstevel@tonic-gate 			uint32_t	size;
79227c478bd9Sstevel@tonic-gate 
79237c478bd9Sstevel@tonic-gate 			msg = "DEVCTL_AP_CONTROL: GET_DEVICE_PATH";
79247c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
79257c478bd9Sstevel@tonic-gate 			    "%s", msg);
79267c478bd9Sstevel@tonic-gate 
79277c478bd9Sstevel@tonic-gate 			/* Recheck if child_dip exists */
79287c478bd9Sstevel@tonic-gate 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
79297c478bd9Sstevel@tonic-gate 			    NULL) {
79307c478bd9Sstevel@tonic-gate 				rv = EINVAL;
79317c478bd9Sstevel@tonic-gate 
79327c478bd9Sstevel@tonic-gate 				break;
79337c478bd9Sstevel@tonic-gate 			}
79347c478bd9Sstevel@tonic-gate 
79357c478bd9Sstevel@tonic-gate 			/* ddi_pathname doesn't supply /devices, so we do. */
79367c478bd9Sstevel@tonic-gate 			path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
79377c478bd9Sstevel@tonic-gate 			(void) strcpy(path, "/devices");
79387c478bd9Sstevel@tonic-gate 			(void) ddi_pathname(child_dip, path + strlen(path));
79397c478bd9Sstevel@tonic-gate 			size = strlen(path) + 1;
79407c478bd9Sstevel@tonic-gate 
79417c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
79427c478bd9Sstevel@tonic-gate 			    "%s: device path=%s  size=%d", msg, path, size);
79437c478bd9Sstevel@tonic-gate 
79447c478bd9Sstevel@tonic-gate 			if (ioc.get_size) {
79457c478bd9Sstevel@tonic-gate 				if (ddi_copyout((void *)&size,
79467c478bd9Sstevel@tonic-gate 				    ioc.buf, ioc.bufsiz, mode) != 0) {
79477c478bd9Sstevel@tonic-gate 
79487c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
79497c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
79507c478bd9Sstevel@tonic-gate 					    "%s: copyout of size failed.", msg);
79517c478bd9Sstevel@tonic-gate 					rv = EIO;
79527c478bd9Sstevel@tonic-gate 				}
79537c478bd9Sstevel@tonic-gate 			} else {
79547c478bd9Sstevel@tonic-gate 				if (ioc.bufsiz != size) {
79557c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
79567c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
79577c478bd9Sstevel@tonic-gate 					    "%s: buffer wrong size.", msg);
79587c478bd9Sstevel@tonic-gate 					rv = EINVAL;
79597c478bd9Sstevel@tonic-gate 				} else if (ddi_copyout((void *)path,
79607c478bd9Sstevel@tonic-gate 				    ioc.buf, ioc.bufsiz, mode) != 0) {
79617c478bd9Sstevel@tonic-gate 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
79627c478bd9Sstevel@tonic-gate 					    hubd->h_log_handle,
79637c478bd9Sstevel@tonic-gate 					    "%s: copyout failed.", msg);
79647c478bd9Sstevel@tonic-gate 					rv = EIO;
79657c478bd9Sstevel@tonic-gate 				}
79667c478bd9Sstevel@tonic-gate 			}
79677c478bd9Sstevel@tonic-gate 			kmem_free(path, MAXPATHLEN);
79687c478bd9Sstevel@tonic-gate 
79697c478bd9Sstevel@tonic-gate 			break;
79707c478bd9Sstevel@tonic-gate 		}
79717c478bd9Sstevel@tonic-gate 		case HUBD_REFRESH_DEVDB:
79727c478bd9Sstevel@tonic-gate 			msg = "DEVCTL_AP_CONTROL: HUBD_REFRESH_DEVDB";
79737c478bd9Sstevel@tonic-gate 			USB_DPRINTF_L3(DPRINT_MASK_CBOPS, hubd->h_log_handle,
79747c478bd9Sstevel@tonic-gate 			    "%s", msg);
79757c478bd9Sstevel@tonic-gate 
79767c478bd9Sstevel@tonic-gate 			if ((rv = usba_devdb_refresh()) != USB_SUCCESS) {
79777c478bd9Sstevel@tonic-gate 				USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
79787c478bd9Sstevel@tonic-gate 				    hubd->h_log_handle,
79797c478bd9Sstevel@tonic-gate 				    "%s: Failed: %d", msg, rv);
79807c478bd9Sstevel@tonic-gate 				rv = EIO;
79817c478bd9Sstevel@tonic-gate 			}
79827c478bd9Sstevel@tonic-gate 
79837c478bd9Sstevel@tonic-gate 			break;
79847c478bd9Sstevel@tonic-gate 		default:
79857c478bd9Sstevel@tonic-gate 			rv = ENOTSUP;
79867c478bd9Sstevel@tonic-gate 		}	/* end switch */
79877c478bd9Sstevel@tonic-gate 
79887c478bd9Sstevel@tonic-gate 		break;
79897c478bd9Sstevel@tonic-gate 	}
79907c478bd9Sstevel@tonic-gate 
79917c478bd9Sstevel@tonic-gate 	default:
79927c478bd9Sstevel@tonic-gate 		rv = ENOTTY;
79937c478bd9Sstevel@tonic-gate 	}
79947c478bd9Sstevel@tonic-gate 
79957c478bd9Sstevel@tonic-gate 	if (dcp) {
79967c478bd9Sstevel@tonic-gate 		ndi_dc_freehdl(dcp);
79977c478bd9Sstevel@tonic-gate 	}
79987c478bd9Sstevel@tonic-gate 
79997c478bd9Sstevel@tonic-gate 	/* allow hotplug thread now */
80007c478bd9Sstevel@tonic-gate 	hubd->h_hotplug_thread--;
80017c478bd9Sstevel@tonic-gate 
80027c478bd9Sstevel@tonic-gate 	if ((hubd->h_dev_state == USB_DEV_ONLINE) &&
80037c478bd9Sstevel@tonic-gate 	    hubd->h_ep1_ph && (prev_pipe_state == USB_PIPE_STATE_ACTIVE)) {
80047c478bd9Sstevel@tonic-gate 		hubd_start_polling(hubd, 0);
80057c478bd9Sstevel@tonic-gate 	}
80067c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
80077c478bd9Sstevel@tonic-gate 
80087c478bd9Sstevel@tonic-gate 	ndi_devi_exit(hubd->h_dip, circ);
80097c478bd9Sstevel@tonic-gate 	ndi_devi_exit(rh_dip, rh_circ);
80107c478bd9Sstevel@tonic-gate 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
80117c478bd9Sstevel@tonic-gate 
80127c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
80137c478bd9Sstevel@tonic-gate 	hubd_pm_idle_component(hubd, hubd->h_dip, 0);
80147c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
80157c478bd9Sstevel@tonic-gate 
80167c478bd9Sstevel@tonic-gate 	return (rv);
80177c478bd9Sstevel@tonic-gate }
80187c478bd9Sstevel@tonic-gate 
80197c478bd9Sstevel@tonic-gate 
80207c478bd9Sstevel@tonic-gate /*
80217c478bd9Sstevel@tonic-gate  * Helper func used only to help construct the names for the attachment point
80227c478bd9Sstevel@tonic-gate  * minor nodes.  Used only in usba_hubdi_attach.
80237c478bd9Sstevel@tonic-gate  * Returns whether it found ancestry or not (USB_SUCCESS if yes).
80247c478bd9Sstevel@tonic-gate  * ports between the root hub and the device represented by dip.
80257c478bd9Sstevel@tonic-gate  * E.g.,  "2.4.3.1" means this device is
80267c478bd9Sstevel@tonic-gate  *	plugged into port 1 of a hub that is
80277c478bd9Sstevel@tonic-gate  *	plugged into port 3 of a hub that is
80287c478bd9Sstevel@tonic-gate  *	plugged into port 4 of a hub that is
80297c478bd9Sstevel@tonic-gate  *	plugged into port 2 of the root hub.
80307c478bd9Sstevel@tonic-gate  * NOTE: Max ap_id path len is HUBD_APID_NAMELEN (32 chars), which is
80317c478bd9Sstevel@tonic-gate  * more than sufficient (as hubs are a max 6 levels deep, port needs 3
80327c478bd9Sstevel@tonic-gate  * chars plus NULL each)
80337c478bd9Sstevel@tonic-gate  */
8034ff0e937bSRaymond Chen void
80357c478bd9Sstevel@tonic-gate hubd_get_ancestry_str(hubd_t *hubd)
80367c478bd9Sstevel@tonic-gate {
8037ff0e937bSRaymond Chen 	char		ap_name[HUBD_APID_NAMELEN];
8038ff0e937bSRaymond Chen 	dev_info_t	*pdip;
8039ff0e937bSRaymond Chen 	hubd_t		*phubd;
8040ff0e937bSRaymond Chen 	usb_port_t	port;
80417c478bd9Sstevel@tonic-gate 
80427c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
8043112116d8Sfb 	    "hubd_get_ancestry_str: hubd=0x%p", (void *)hubd);
80447c478bd9Sstevel@tonic-gate 
8045ff0e937bSRaymond Chen 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8046ff0e937bSRaymond Chen 
8047ff0e937bSRaymond Chen 	/*
8048ff0e937bSRaymond Chen 	 * The function is extended to support wire adapter class
8049ff0e937bSRaymond Chen 	 * devices introduced by WUSB spec. The node name is no
8050ff0e937bSRaymond Chen 	 * longer "hub" only.
8051ff0e937bSRaymond Chen 	 * Generate the ap_id str based on the parent and child
8052ff0e937bSRaymond Chen 	 * relationship instead of retrieving it from the hub
8053ff0e937bSRaymond Chen 	 * device path, which simplifies the algorithm.
8054ff0e937bSRaymond Chen 	 */
8055ff0e937bSRaymond Chen 	if (usba_is_root_hub(hubd->h_dip)) {
8056ff0e937bSRaymond Chen 		hubd->h_ancestry_str[0] = '\0';
8057ff0e937bSRaymond Chen 	} else {
8058ff0e937bSRaymond Chen 		port = hubd->h_usba_device->usb_port;
8059ff0e937bSRaymond Chen 		mutex_exit(HUBD_MUTEX(hubd));
80607c478bd9Sstevel@tonic-gate 
8061ff0e937bSRaymond Chen 		pdip = ddi_get_parent(hubd->h_dip);
80627c478bd9Sstevel@tonic-gate 		/*
8063ff0e937bSRaymond Chen 		 * The parent of wire adapter device might be usb_mid.
8064ff0e937bSRaymond Chen 		 * Need to look further up for hub device
80657c478bd9Sstevel@tonic-gate 		 */
8066ff0e937bSRaymond Chen 		if (strcmp(ddi_driver_name(pdip), "usb_mid") == 0) {
8067ff0e937bSRaymond Chen 			pdip = ddi_get_parent(pdip);
8068ff0e937bSRaymond Chen 			ASSERT(pdip != NULL);
80697c478bd9Sstevel@tonic-gate 		}
80707c478bd9Sstevel@tonic-gate 
8071ff0e937bSRaymond Chen 		phubd = hubd_get_soft_state(pdip);
80727c478bd9Sstevel@tonic-gate 
8073ff0e937bSRaymond Chen 		mutex_enter(HUBD_MUTEX(phubd));
8074ff0e937bSRaymond Chen 		(void) snprintf(ap_name, HUBD_APID_NAMELEN, "%s%d",
8075ff0e937bSRaymond Chen 		    phubd->h_ancestry_str, port);
8076ff0e937bSRaymond Chen 		mutex_exit(HUBD_MUTEX(phubd));
80777c478bd9Sstevel@tonic-gate 
8078ff0e937bSRaymond Chen 		mutex_enter(HUBD_MUTEX(hubd));
8079ff0e937bSRaymond Chen 		(void) strcpy(hubd->h_ancestry_str, ap_name);
80807c478bd9Sstevel@tonic-gate 		(void) strcat(hubd->h_ancestry_str, ".");
80817c478bd9Sstevel@tonic-gate 	}
80827c478bd9Sstevel@tonic-gate }
80837c478bd9Sstevel@tonic-gate 
80847c478bd9Sstevel@tonic-gate 
80857c478bd9Sstevel@tonic-gate /* Get which port to operate on.  */
80867c478bd9Sstevel@tonic-gate static usb_port_t
80877c478bd9Sstevel@tonic-gate hubd_get_port_num(hubd_t *hubd, struct devctl_iocdata *dcp)
80887c478bd9Sstevel@tonic-gate {
80897c478bd9Sstevel@tonic-gate 	int32_t port;
80907c478bd9Sstevel@tonic-gate 
80917c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
80927c478bd9Sstevel@tonic-gate 
80937c478bd9Sstevel@tonic-gate 	/* Get which port to operate on.  */
80947c478bd9Sstevel@tonic-gate 	if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
80957c478bd9Sstevel@tonic-gate 		USB_DPRINTF_L2(DPRINT_MASK_CBOPS, hubd->h_log_handle,
80967c478bd9Sstevel@tonic-gate 		    "hubd_get_port_num: port lookup failed");
80977c478bd9Sstevel@tonic-gate 		port = 0;
80987c478bd9Sstevel@tonic-gate 	}
80997c478bd9Sstevel@tonic-gate 
81007c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
8101112116d8Sfb 	    "hubd_get_port_num: hubd=0x%p, port=%d", (void *)hubd, port);
81027c478bd9Sstevel@tonic-gate 
81037c478bd9Sstevel@tonic-gate 	return ((usb_port_t)port);
81047c478bd9Sstevel@tonic-gate }
81057c478bd9Sstevel@tonic-gate 
81067c478bd9Sstevel@tonic-gate 
81077c478bd9Sstevel@tonic-gate /* check if child still exists */
81087c478bd9Sstevel@tonic-gate static dev_info_t *
81097c478bd9Sstevel@tonic-gate hubd_get_child_dip(hubd_t *hubd, usb_port_t port)
81107c478bd9Sstevel@tonic-gate {
81117c478bd9Sstevel@tonic-gate 	dev_info_t *child_dip = hubd->h_children_dips[port];
81127c478bd9Sstevel@tonic-gate 
81137c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
8114112116d8Sfb 	    "hubd_get_child_dip: hubd=0x%p, port=%d", (void *)hubd, port);
81157c478bd9Sstevel@tonic-gate 
81167c478bd9Sstevel@tonic-gate 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
81177c478bd9Sstevel@tonic-gate 
81187c478bd9Sstevel@tonic-gate 	return (child_dip);
81197c478bd9Sstevel@tonic-gate }
81207c478bd9Sstevel@tonic-gate 
81217c478bd9Sstevel@tonic-gate 
81227c478bd9Sstevel@tonic-gate /*
81237c478bd9Sstevel@tonic-gate  * hubd_cfgadm_state:
81247c478bd9Sstevel@tonic-gate  *
81257c478bd9Sstevel@tonic-gate  *	child_dip list		port_state		cfgadm_state
81267c478bd9Sstevel@tonic-gate  *	--------------		----------		------------
81277c478bd9Sstevel@tonic-gate  *	!= NULL			connected		configured or
81287c478bd9Sstevel@tonic-gate  *							unconfigured
81297c478bd9Sstevel@tonic-gate  *	!= NULL			not connected		disconnect but
81307c478bd9Sstevel@tonic-gate  *							busy/still referenced
81317c478bd9Sstevel@tonic-gate  *	NULL			connected		logically disconnected
81327c478bd9Sstevel@tonic-gate  *	NULL			not connected		empty
81337c478bd9Sstevel@tonic-gate  */
81347c478bd9Sstevel@tonic-gate static uint_t
81357c478bd9Sstevel@tonic-gate hubd_cfgadm_state(hubd_t *hubd, usb_port_t port)
81367c478bd9Sstevel@tonic-gate {
81377c478bd9Sstevel@tonic-gate 	uint_t		state;
81387c478bd9Sstevel@tonic-gate 	dev_info_t	*child_dip = hubd_get_child_dip(hubd, port);
81397c478bd9Sstevel@tonic-gate 
81407c478bd9Sstevel@tonic-gate 	if (child_dip) {
81417c478bd9Sstevel@tonic-gate 		if (hubd->h_port_state[port] & PORT_STATUS_CCS) {
81427c478bd9Sstevel@tonic-gate 			/*
81437c478bd9Sstevel@tonic-gate 			 * connected,  now check if driver exists
81447c478bd9Sstevel@tonic-gate 			 */
81457c478bd9Sstevel@tonic-gate 			if (DEVI_IS_DEVICE_OFFLINE(child_dip) ||
8146737d277aScth 			    !i_ddi_devi_attached(child_dip)) {
81477c478bd9Sstevel@tonic-gate 				state = HUBD_CFGADM_UNCONFIGURED;
81487c478bd9Sstevel@tonic-gate 			} else {
81497c478bd9Sstevel@tonic-gate 				state = HUBD_CFGADM_CONFIGURED;
81507c478bd9Sstevel@tonic-gate 			}
81517c478bd9Sstevel@tonic-gate 		} else {
81527c478bd9Sstevel@tonic-gate 			/*
81537c478bd9Sstevel@tonic-gate 			 * this means that the dip is around for
81547c478bd9Sstevel@tonic-gate 			 * a device that is still referenced but
81557c478bd9Sstevel@tonic-gate 			 * has been yanked out. So the cfgadm info
81567c478bd9Sstevel@tonic-gate 			 * for this state should be EMPTY (port empty)
81577c478bd9Sstevel@tonic-gate 			 * and CONFIGURED (dip still valid).
81587c478bd9Sstevel@tonic-gate 			 */
81597c478bd9Sstevel@tonic-gate 			state = HUBD_CFGADM_STILL_REFERENCED;
81607c478bd9Sstevel@tonic-gate 		}
81617c478bd9Sstevel@tonic-gate 	} else {
81627c478bd9Sstevel@tonic-gate 		/* connected but no child dip */
81637c478bd9Sstevel@tonic-gate 		if (hubd->h_port_state[port] & PORT_STATUS_CCS) {
81647c478bd9Sstevel@tonic-gate 			/* logically disconnected */
81657c478bd9Sstevel@tonic-gate 			state = HUBD_CFGADM_DISCONNECTED;
81667c478bd9Sstevel@tonic-gate 		} else {
81677c478bd9Sstevel@tonic-gate 			/* physically disconnected */
81687c478bd9Sstevel@tonic-gate 			state = HUBD_CFGADM_EMPTY;
81697c478bd9Sstevel@tonic-gate 		}
81707c478bd9Sstevel@tonic-gate 	}
81717c478bd9Sstevel@tonic-gate 
81727c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
81737c478bd9Sstevel@tonic-gate 	    "hubd_cfgadm_state: hubd=0x%p, port=%d state=0x%x",
8174112116d8Sfb 	    (void *)hubd, port, state);
81757c478bd9Sstevel@tonic-gate 
81767c478bd9Sstevel@tonic-gate 	return (state);
81777c478bd9Sstevel@tonic-gate }
81787c478bd9Sstevel@tonic-gate 
81797c478bd9Sstevel@tonic-gate 
81807c478bd9Sstevel@tonic-gate /*
81817c478bd9Sstevel@tonic-gate  * hubd_toggle_port:
81827c478bd9Sstevel@tonic-gate  */
81837c478bd9Sstevel@tonic-gate static int
81847c478bd9Sstevel@tonic-gate hubd_toggle_port(hubd_t *hubd, usb_port_t port)
81857c478bd9Sstevel@tonic-gate {
81867c478bd9Sstevel@tonic-gate 	usb_hub_descr_t	*hub_descr;
81877c478bd9Sstevel@tonic-gate 	int		wait;
81887c478bd9Sstevel@tonic-gate 	uint_t		retry;
81897c478bd9Sstevel@tonic-gate 	uint16_t	status;
81907c478bd9Sstevel@tonic-gate 	uint16_t	change;
81917c478bd9Sstevel@tonic-gate 
81927c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
8193112116d8Sfb 	    "hubd_toggle_port: hubd=0x%p, port=%d", (void *)hubd, port);
81947c478bd9Sstevel@tonic-gate 
81957c478bd9Sstevel@tonic-gate 	if ((hubd_disable_port_power(hubd, port)) != USB_SUCCESS) {
81967c478bd9Sstevel@tonic-gate 
81977c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
81987c478bd9Sstevel@tonic-gate 	}
81997c478bd9Sstevel@tonic-gate 
82007c478bd9Sstevel@tonic-gate 	/*
82017c478bd9Sstevel@tonic-gate 	 * see hubd_enable_all_port_power() which
82027c478bd9Sstevel@tonic-gate 	 * requires longer delay for hubs.
82037c478bd9Sstevel@tonic-gate 	 */
82047c478bd9Sstevel@tonic-gate 	mutex_exit(HUBD_MUTEX(hubd));
82057c478bd9Sstevel@tonic-gate 	delay(drv_usectohz(hubd_device_delay / 10));
82067c478bd9Sstevel@tonic-gate 	mutex_enter(HUBD_MUTEX(hubd));
82077c478bd9Sstevel@tonic-gate 
82087c478bd9Sstevel@tonic-gate 	hub_descr = &hubd->h_hub_descr;
82097c478bd9Sstevel@tonic-gate 
82107c478bd9Sstevel@tonic-gate 	/*
82117c478bd9Sstevel@tonic-gate 	 * According to section 11.11 of USB, for hubs with no power
82127c478bd9Sstevel@tonic-gate 	 * switches, bPwrOn2PwrGood is zero. But we wait for some
82137c478bd9Sstevel@tonic-gate 	 * arbitrary time to enable power to become stable.
82147c478bd9Sstevel@tonic-gate 	 *
82157c478bd9Sstevel@tonic-gate 	 * If an hub supports port power swicthing, we need to wait
82167c478bd9Sstevel@tonic-gate 	 * at least 20ms before accesing corresonding usb port.
82177c478bd9Sstevel@tonic-gate 	 */
82187c478bd9Sstevel@tonic-gate 	if ((hub_descr->wHubCharacteristics &
82197c478bd9Sstevel@tonic-gate 	    HUB_CHARS_NO_POWER_SWITCHING) || (!hub_descr->bPwrOn2PwrGood)) {
82207c478bd9Sstevel@tonic-gate 		wait = hubd_device_delay / 10;
82217c478bd9Sstevel@tonic-gate 	} else {
82227c478bd9Sstevel@tonic-gate 		wait = max(HUB_DEFAULT_POPG,
82237c478bd9Sstevel@tonic-gate 		    hub_descr->bPwrOn2PwrGood) * 2 * 1000;
82247c478bd9Sstevel@tonic-gate 	}
82257c478bd9Sstevel@tonic-gate 
82267c478bd9Sstevel@tonic-gate 	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
82277c478bd9Sstevel@tonic-gate 	    "hubd_toggle_port: popg=%d wait=%d",
82287c478bd9Sstevel@tonic-gate 	    hub_descr->bPwrOn2PwrGood, wait);
82297c478bd9Sstevel@tonic-gate 
82307c478bd9Sstevel@tonic-gate 	retry = 0;
82317c478bd9Sstevel@tonic-gate 
82327c478bd9Sstevel@tonic-gate 	do {
82337c478bd9Sstevel@tonic-gate 		(void) hubd_enable_port_power(hubd, port);
82347c478bd9Sstevel@tonic-gate 
82357c478bd9Sstevel@tonic-gate 		mutex_exit(HUBD_MUTEX(hubd));
82367c478bd9Sstevel@tonic-gate 		delay(drv_usectohz(wait));
82377c478bd9Sstevel@tonic-gate 		mutex_enter(HUBD_MUTEX(hubd));
82387c478bd9Sstevel@tonic-gate 
82397c478bd9Sstevel@tonic-gate 		/* Get port status */
82407c478bd9Sstevel@tonic-gate 		(void) hubd_determine_port_status(hubd, port,
82417c478bd9Sstevel@tonic-gate 		    &status, &change, 0);
82427c478bd9Sstevel@tonic-gate 
82437c478bd9Sstevel@tonic-gate 		/* For retry if any, use some extra delay */
82447c478bd9Sstevel@tonic-gate 		wait = max(wait, hubd_device_delay / 10);
82457c478bd9Sstevel@tonic-gate 
82467c478bd9Sstevel@tonic-gate 		retry++;
82477c478bd9Sstevel@tonic-gate 
82487c478bd9Sstevel@tonic-gate 	} while ((!(status & PORT_STATUS_PPS)) && (retry < HUBD_PORT_RETRY));
82497c478bd9Sstevel@tonic-gate 
82507c478bd9Sstevel@tonic-gate 	/* Print warning message if port has no power */
82517c478bd9Sstevel@tonic-gate 	if (!(status & PORT_STATUS_PPS)) {
82527c478bd9Sstevel@tonic-gate 
8253d291d9f2Sfrits 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
82547c478bd9Sstevel@tonic-gate 		    "hubd_toggle_port: port %d power-on failed, "
82557c478bd9Sstevel@tonic-gate 		    "port status 0x%x", port, status);
82567c478bd9Sstevel@tonic-gate 
82577c478bd9Sstevel@tonic-gate 		return (USB_FAILURE);
82587c478bd9Sstevel@tonic-gate 	}
82597c478bd9Sstevel@tonic-gate 
82607c478bd9Sstevel@tonic-gate 	return (USB_SUCCESS);
82617c478bd9Sstevel@tonic-gate }
826235f36846Ssl 
826335f36846Ssl 
826435f36846Ssl /*
826535f36846Ssl  * hubd_init_power_budget:
826635f36846Ssl  *	Init power budget variables in hubd structure. According
826735f36846Ssl  *	to USB spec, the power budget rules are:
826835f36846Ssl  *	1. local-powered hubs including root-hubs can supply
826935f36846Ssl  *	   500mA to each port at maximum
827035f36846Ssl  *	2. two bus-powered hubs are not allowed to concatenate
827135f36846Ssl  *	3. bus-powered hubs can supply 100mA to each port at
827235f36846Ssl  *	   maximum, and the power consumed by all downstream
827335f36846Ssl  *	   ports and the hub itself cannot exceed the max power
827435f36846Ssl  *	   supplied by the upstream port, i.e., 500mA
827535f36846Ssl  *	The routine is only called during hub attach time
827635f36846Ssl  */
827735f36846Ssl static int
827835f36846Ssl hubd_init_power_budget(hubd_t *hubd)
827935f36846Ssl {
828035f36846Ssl 	uint16_t	status = 0;
828135f36846Ssl 	usba_device_t	*hubd_ud = NULL;
828235f36846Ssl 	size_t		size;
828335f36846Ssl 	usb_cfg_descr_t	cfg_descr;
828435f36846Ssl 	dev_info_t	*pdip = NULL;
828535f36846Ssl 	hubd_t		*phubd = NULL;
828635f36846Ssl 
828735f36846Ssl 	if (hubd->h_ignore_pwr_budget) {
828835f36846Ssl 
828935f36846Ssl 		return (USB_SUCCESS);
829035f36846Ssl 	}
829135f36846Ssl 
829235f36846Ssl 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
829335f36846Ssl 	    "hubd_init_power_budget:");
829435f36846Ssl 
829535f36846Ssl 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
829635f36846Ssl 	ASSERT(hubd->h_default_pipe != 0);
829735f36846Ssl 	mutex_exit(HUBD_MUTEX(hubd));
829835f36846Ssl 
829935f36846Ssl 	/* get device status */
830035f36846Ssl 	if ((usb_get_status(hubd->h_dip, hubd->h_default_pipe,
830135f36846Ssl 	    HUB_GET_DEVICE_STATUS_TYPE,
830235f36846Ssl 	    0, &status, 0)) != USB_SUCCESS) {
830335f36846Ssl 		mutex_enter(HUBD_MUTEX(hubd));
830435f36846Ssl 
830535f36846Ssl 		return (USB_FAILURE);
830635f36846Ssl 	}
830735f36846Ssl 
830835f36846Ssl 	hubd_ud = usba_get_usba_device(hubd->h_dip);
830935f36846Ssl 
831035f36846Ssl 	size = usb_parse_cfg_descr(hubd_ud->usb_cfg, hubd_ud->usb_cfg_length,
831135f36846Ssl 	    &cfg_descr, USB_CFG_DESCR_SIZE);
831235f36846Ssl 
831335f36846Ssl 	if (size != USB_CFG_DESCR_SIZE) {
831435f36846Ssl 		USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
831535f36846Ssl 		    "get hub configuration descriptor failed");
831635f36846Ssl 		mutex_enter(HUBD_MUTEX(hubd));
831735f36846Ssl 
831835f36846Ssl 		return (USB_FAILURE);
831935f36846Ssl 	}
832035f36846Ssl 
832135f36846Ssl 	mutex_enter(HUBD_MUTEX(hubd));
832235f36846Ssl 
832335f36846Ssl 	hubd->h_local_pwr_capable = (cfg_descr.bmAttributes &
832435f36846Ssl 	    USB_CFG_ATTR_SELFPWR);
832535f36846Ssl 
832635f36846Ssl 	if (hubd->h_local_pwr_capable) {
832735f36846Ssl 		USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
832835f36846Ssl 		    "hub is capable of local power");
832935f36846Ssl 	}
833035f36846Ssl 
833135f36846Ssl 	hubd->h_local_pwr_on = (status &
833235f36846Ssl 	    USB_DEV_SLF_PWRD_STATUS) && hubd->h_local_pwr_capable;
833335f36846Ssl 
833435f36846Ssl 	if (hubd->h_local_pwr_on) {
833535f36846Ssl 		USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
833635f36846Ssl 		    "hub is local-powered");
833735f36846Ssl 
833835f36846Ssl 		hubd->h_pwr_limit = (USB_PWR_UNIT_LOAD *
833935f36846Ssl 		    USB_HIGH_PWR_VALUE) / USB_CFG_DESCR_PWR_UNIT;
834035f36846Ssl 	} else {
834135f36846Ssl 		hubd->h_pwr_limit = (USB_PWR_UNIT_LOAD *
834235f36846Ssl 		    USB_LOW_PWR_VALUE) / USB_CFG_DESCR_PWR_UNIT;
834335f36846Ssl 
834435f36846Ssl 		hubd->h_pwr_left = (USB_PWR_UNIT_LOAD *
834535f36846Ssl 		    USB_HIGH_PWR_VALUE) / USB_CFG_DESCR_PWR_UNIT;
834635f36846Ssl 
834735f36846Ssl 		ASSERT(!usba_is_root_hub(hubd->h_dip));
834835f36846Ssl 
834935f36846Ssl 		if (!usba_is_root_hub(hubd->h_dip)) {
835035f36846Ssl 			/*
835135f36846Ssl 			 * two bus-powered hubs are not
835235f36846Ssl 			 * allowed to be concatenated
835335f36846Ssl 			 */
835435f36846Ssl 			mutex_exit(HUBD_MUTEX(hubd));
835535f36846Ssl 
835635f36846Ssl 			pdip = ddi_get_parent(hubd->h_dip);
835735f36846Ssl 			phubd = hubd_get_soft_state(pdip);
835835f36846Ssl 			ASSERT(phubd != NULL);
835935f36846Ssl 
836035f36846Ssl 			if (!phubd->h_ignore_pwr_budget) {
836135f36846Ssl 				mutex_enter(HUBD_MUTEX(phubd));
836235f36846Ssl 				if (phubd->h_local_pwr_on == B_FALSE) {
83638668df41Slg 					USB_DPRINTF_L1(DPRINT_MASK_HUB,
836435f36846Ssl 					    hubd->h_log_handle,
836535f36846Ssl 					    "two bus-powered hubs cannot "
836635f36846Ssl 					    "be concatenated");
836735f36846Ssl 
836835f36846Ssl 					mutex_exit(HUBD_MUTEX(phubd));
836935f36846Ssl 					mutex_enter(HUBD_MUTEX(hubd));
837035f36846Ssl 
837135f36846Ssl 					return (USB_FAILURE);
837235f36846Ssl 				}
837335f36846Ssl 				mutex_exit(HUBD_MUTEX(phubd));
837435f36846Ssl 			}
837535f36846Ssl 
837635f36846Ssl 			mutex_enter(HUBD_MUTEX(hubd));
837735f36846Ssl 
837835f36846Ssl 			USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
837935f36846Ssl 			    "hub is bus-powered");
838035f36846Ssl 		} else {
838135f36846Ssl 			USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
838235f36846Ssl 			    "root-hub must be local-powered");
838335f36846Ssl 		}
838435f36846Ssl 
838535f36846Ssl 		/*
838635f36846Ssl 		 * Subtract the power consumed by the hub itself
838735f36846Ssl 		 * and get the power that can be supplied to
838835f36846Ssl 		 * downstream ports
838935f36846Ssl 		 */
839035f36846Ssl 		hubd->h_pwr_left -=
839135f36846Ssl 		    hubd->h_hub_descr.bHubContrCurrent /
839235f36846Ssl 		    USB_CFG_DESCR_PWR_UNIT;
839335f36846Ssl 		if (hubd->h_pwr_left < 0) {
839435f36846Ssl 			USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
839535f36846Ssl 			    "hubd->h_pwr_left is less than bHubContrCurrent, "
839635f36846Ssl 			    "should fail");
839735f36846Ssl 
839835f36846Ssl 			return (USB_FAILURE);
839935f36846Ssl 		}
840035f36846Ssl 	}
840135f36846Ssl 
840235f36846Ssl 	return (USB_SUCCESS);
840335f36846Ssl }
840435f36846Ssl 
840535f36846Ssl 
840635f36846Ssl /*
840735f36846Ssl  * usba_hubdi_check_power_budget:
840835f36846Ssl  *	Check if the hub has enough power budget to allow a
840935f36846Ssl  *	child device to select a configuration of config_index.
841035f36846Ssl  */
841135f36846Ssl int
841235f36846Ssl usba_hubdi_check_power_budget(dev_info_t *dip, usba_device_t *child_ud,
841335f36846Ssl 	uint_t config_index)
841435f36846Ssl {
841535f36846Ssl 	int16_t		pwr_left, pwr_limit, pwr_required;
841635f36846Ssl 	size_t		size;
841735f36846Ssl 	usb_cfg_descr_t cfg_descr;
841835f36846Ssl 	hubd_t		*hubd;
841935f36846Ssl 
842035f36846Ssl 	if ((hubd = hubd_get_soft_state(dip)) == NULL) {
842135f36846Ssl 
842235f36846Ssl 		return (USB_FAILURE);
842335f36846Ssl 	}
842435f36846Ssl 
842535f36846Ssl 	if (hubd->h_ignore_pwr_budget) {
842635f36846Ssl 
842735f36846Ssl 		return (USB_SUCCESS);
842835f36846Ssl 	}
842935f36846Ssl 
843035f36846Ssl 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
843135f36846Ssl 	    "usba_hubdi_check_power_budget: "
8432112116d8Sfb 	    "dip=0x%p child_ud=0x%p conf_index=%d", (void *)dip,
8433112116d8Sfb 	    (void *)child_ud, config_index);
843435f36846Ssl 
843535f36846Ssl 	mutex_enter(HUBD_MUTEX(hubd));
843635f36846Ssl 	pwr_limit = hubd->h_pwr_limit;
843735f36846Ssl 	if (hubd->h_local_pwr_on == B_FALSE) {
843835f36846Ssl 		pwr_left = hubd->h_pwr_left;
843935f36846Ssl 		pwr_limit = (pwr_limit <= pwr_left) ? pwr_limit : pwr_left;
844035f36846Ssl 	}
844135f36846Ssl 	mutex_exit(HUBD_MUTEX(hubd));
844235f36846Ssl 
844335f36846Ssl 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
844435f36846Ssl 	    "usba_hubdi_check_power_budget: "
844535f36846Ssl 	    "available power is %dmA", pwr_limit * USB_CFG_DESCR_PWR_UNIT);
844635f36846Ssl 
844735f36846Ssl 	size = usb_parse_cfg_descr(
844835f36846Ssl 	    child_ud->usb_cfg_array[config_index], USB_CFG_DESCR_SIZE,
844935f36846Ssl 	    &cfg_descr, USB_CFG_DESCR_SIZE);
845035f36846Ssl 
845135f36846Ssl 	if (size != USB_CFG_DESCR_SIZE) {
845235f36846Ssl 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
845335f36846Ssl 		    "get hub configuration descriptor failed");
845435f36846Ssl 
845535f36846Ssl 		return (USB_FAILURE);
845635f36846Ssl 	}
845735f36846Ssl 
845835f36846Ssl 	pwr_required = cfg_descr.bMaxPower;
845935f36846Ssl 
846035f36846Ssl 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
846135f36846Ssl 	    "usba_hubdi_check_power_budget: "
846235f36846Ssl 	    "child bmAttributes=0x%x bMaxPower=%d "
846335f36846Ssl 	    "with config_index=%d", cfg_descr.bmAttributes,
846435f36846Ssl 	    pwr_required, config_index);
846535f36846Ssl 
846635f36846Ssl 	if (pwr_required > pwr_limit) {
84678668df41Slg 		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
846835f36846Ssl 		    "configuration %d for device %s %s at port %d "
846935f36846Ssl 		    "exceeds power available for this port, please "
847035f36846Ssl 		    "re-insert your device into another hub port which "
847135f36846Ssl 		    "has enough power",
847235f36846Ssl 		    config_index,
847335f36846Ssl 		    child_ud->usb_mfg_str,
847435f36846Ssl 		    child_ud->usb_product_str,
847535f36846Ssl 		    child_ud->usb_port);
847635f36846Ssl 
847735f36846Ssl 		return (USB_FAILURE);
847835f36846Ssl 	}
847935f36846Ssl 
848035f36846Ssl 	return (USB_SUCCESS);
848135f36846Ssl }
848235f36846Ssl 
848335f36846Ssl 
848435f36846Ssl /*
848535f36846Ssl  * usba_hubdi_incr_power_budget:
848635f36846Ssl  *	Increase the hub power budget value when a child device
848735f36846Ssl  *	is removed from a bus-powered hub port.
848835f36846Ssl  */
848935f36846Ssl void
849035f36846Ssl usba_hubdi_incr_power_budget(dev_info_t *dip, usba_device_t *child_ud)
849135f36846Ssl {
849235f36846Ssl 	uint16_t	pwr_value;
849335f36846Ssl 	hubd_t		*hubd = hubd_get_soft_state(dip);
849435f36846Ssl 
849535f36846Ssl 	ASSERT(hubd != NULL);
849635f36846Ssl 
849735f36846Ssl 	if (hubd->h_ignore_pwr_budget) {
849835f36846Ssl 
849935f36846Ssl 		return;
850035f36846Ssl 	}
850135f36846Ssl 
850235f36846Ssl 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
850335f36846Ssl 	    "usba_hubdi_incr_power_budget: "
8504112116d8Sfb 	    "dip=0x%p child_ud=0x%p", (void *)dip, (void *)child_ud);
850535f36846Ssl 
850635f36846Ssl 	mutex_enter(HUBD_MUTEX(hubd));
850735f36846Ssl 	if (hubd->h_local_pwr_on == B_TRUE) {
850835f36846Ssl 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
850935f36846Ssl 		    "usba_hubdi_incr_power_budget: "
851035f36846Ssl 		    "hub is local powered");
851135f36846Ssl 		mutex_exit(HUBD_MUTEX(hubd));
851235f36846Ssl 
851335f36846Ssl 		return;
851435f36846Ssl 	}
851535f36846Ssl 	mutex_exit(HUBD_MUTEX(hubd));
851635f36846Ssl 
851735f36846Ssl 	mutex_enter(&child_ud->usb_mutex);
851835f36846Ssl 	if (child_ud->usb_pwr_from_hub == 0) {
851935f36846Ssl 		mutex_exit(&child_ud->usb_mutex);
852035f36846Ssl 
852135f36846Ssl 		return;
852235f36846Ssl 	}
852335f36846Ssl 	pwr_value = child_ud->usb_pwr_from_hub;
852435f36846Ssl 	mutex_exit(&child_ud->usb_mutex);
852535f36846Ssl 
852635f36846Ssl 	mutex_enter(HUBD_MUTEX(hubd));
852735f36846Ssl 	hubd->h_pwr_left += pwr_value;
852835f36846Ssl 
852935f36846Ssl 	USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
853035f36846Ssl 	    "usba_hubdi_incr_power_budget: "
853135f36846Ssl 	    "available power is %dmA, increased by %dmA",
853235f36846Ssl 	    hubd->h_pwr_left * USB_CFG_DESCR_PWR_UNIT,
853335f36846Ssl 	    pwr_value * USB_CFG_DESCR_PWR_UNIT);
853435f36846Ssl 
853535f36846Ssl 	mutex_exit(HUBD_MUTEX(hubd));
853635f36846Ssl 
853735f36846Ssl 	mutex_enter(&child_ud->usb_mutex);
853835f36846Ssl 	child_ud->usb_pwr_from_hub = 0;
853935f36846Ssl 	mutex_exit(&child_ud->usb_mutex);
854035f36846Ssl }
854135f36846Ssl 
854235f36846Ssl 
854335f36846Ssl /*
854435f36846Ssl  * usba_hubdi_decr_power_budget:
854535f36846Ssl  *	Decrease the hub power budget value when a child device
854635f36846Ssl  *	is inserted to a bus-powered hub port.
854735f36846Ssl  */
854835f36846Ssl void
854935f36846Ssl usba_hubdi_decr_power_budget(dev_info_t *dip, usba_device_t *child_ud)
855035f36846Ssl {
855135f36846Ssl 	uint16_t	pwr_value;
855235f36846Ssl 	size_t		size;
855335f36846Ssl 	usb_cfg_descr_t	cfg_descr;
855435f36846Ssl 	hubd_t		*hubd = hubd_get_soft_state(dip);
855535f36846Ssl 
855635f36846Ssl 	ASSERT(hubd != NULL);
855735f36846Ssl 
855835f36846Ssl 	if (hubd->h_ignore_pwr_budget) {
855935f36846Ssl 
856035f36846Ssl 		return;
856135f36846Ssl 	}
856235f36846Ssl 
856335f36846Ssl 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
856435f36846Ssl 	    "usba_hubdi_decr_power_budget: "
8565112116d8Sfb 	    "dip=0x%p child_ud=0x%p", (void *)dip, (void *)child_ud);
856635f36846Ssl 
856735f36846Ssl 	mutex_enter(HUBD_MUTEX(hubd));
856835f36846Ssl 	if (hubd->h_local_pwr_on == B_TRUE) {
856935f36846Ssl 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
857035f36846Ssl 		    "usba_hubdi_decr_power_budget: "
857135f36846Ssl 		    "hub is local powered");
857235f36846Ssl 		mutex_exit(HUBD_MUTEX(hubd));
857335f36846Ssl 
857435f36846Ssl 		return;
857535f36846Ssl 	}
857635f36846Ssl 	mutex_exit(HUBD_MUTEX(hubd));
857735f36846Ssl 
857835f36846Ssl 	mutex_enter(&child_ud->usb_mutex);
857935f36846Ssl 	if (child_ud->usb_pwr_from_hub > 0) {
858035f36846Ssl 		mutex_exit(&child_ud->usb_mutex);
858135f36846Ssl 
858235f36846Ssl 		return;
858335f36846Ssl 	}
858435f36846Ssl 	mutex_exit(&child_ud->usb_mutex);
858535f36846Ssl 
858635f36846Ssl 	size = usb_parse_cfg_descr(
858735f36846Ssl 	    child_ud->usb_cfg, child_ud->usb_cfg_length,
858835f36846Ssl 	    &cfg_descr, USB_CFG_DESCR_SIZE);
858935f36846Ssl 	ASSERT(size == USB_CFG_DESCR_SIZE);
859035f36846Ssl 
859135f36846Ssl 	mutex_enter(HUBD_MUTEX(hubd));
859235f36846Ssl 	pwr_value = cfg_descr.bMaxPower;
859335f36846Ssl 	hubd->h_pwr_left -= pwr_value;
859435f36846Ssl 	ASSERT(hubd->h_pwr_left >= 0);
859535f36846Ssl 
859635f36846Ssl 	USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
859735f36846Ssl 	    "usba_hubdi_decr_power_budget: "
859835f36846Ssl 	    "available power is %dmA, decreased by %dmA",
859935f36846Ssl 	    hubd->h_pwr_left * USB_CFG_DESCR_PWR_UNIT,
860035f36846Ssl 	    pwr_value * USB_CFG_DESCR_PWR_UNIT);
860135f36846Ssl 
860235f36846Ssl 	mutex_exit(HUBD_MUTEX(hubd));
860335f36846Ssl 
860435f36846Ssl 	mutex_enter(&child_ud->usb_mutex);
860535f36846Ssl 	child_ud->usb_pwr_from_hub = pwr_value;
860635f36846Ssl 	mutex_exit(&child_ud->usb_mutex);
860735f36846Ssl }
8608ffcd51f3Slg 
8609ffcd51f3Slg /*
8610ffcd51f3Slg  * hubd_wait_for_hotplug_exit:
8611112cd14aSqz  *	Waiting for the exit of the running hotplug thread or ioctl thread.
8612ffcd51f3Slg  */
8613ffcd51f3Slg static int
8614ffcd51f3Slg hubd_wait_for_hotplug_exit(hubd_t *hubd)
8615ffcd51f3Slg {
8616d3d50737SRafael Vanoni 	clock_t		until = drv_usectohz(1000000);
8617ffcd51f3Slg 	int		rval;
8618ffcd51f3Slg 
8619ffcd51f3Slg 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8620ffcd51f3Slg 
8621ffcd51f3Slg 	if (hubd->h_hotplug_thread) {
8622ffcd51f3Slg 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8623ffcd51f3Slg 		    "waiting for hubd hotplug thread exit");
8624d3d50737SRafael Vanoni 		rval = cv_reltimedwait(&hubd->h_cv_hotplug_dev,
8625d3d50737SRafael Vanoni 		    &hubd->h_mutex, until, TR_CLOCK_TICK);
8626ffcd51f3Slg 
8627ffcd51f3Slg 		if ((rval <= 0) && (hubd->h_hotplug_thread)) {
8628ffcd51f3Slg 
8629ffcd51f3Slg 			return (USB_FAILURE);
8630ffcd51f3Slg 		}
8631ffcd51f3Slg 	}
8632ffcd51f3Slg 
8633ffcd51f3Slg 	return (USB_SUCCESS);
8634ffcd51f3Slg }
8635ffcd51f3Slg 
8636ffcd51f3Slg /*
8637ffcd51f3Slg  * hubd_reset_thread:
8638ffcd51f3Slg  *	handles the "USB_RESET_LVL_REATTACH" reset of usb device.
8639ffcd51f3Slg  *
8640ffcd51f3Slg  *	- delete the child (force detaching the device and its children)
8641ffcd51f3Slg  *	- reset the corresponding parent hub port
8642ffcd51f3Slg  *	- create the child (force re-attaching the device and its children)
8643ffcd51f3Slg  */
8644ffcd51f3Slg static void
8645ffcd51f3Slg hubd_reset_thread(void *arg)
8646ffcd51f3Slg {
8647ffcd51f3Slg 	hubd_reset_arg_t *hd_arg = (hubd_reset_arg_t *)arg;
8648ffcd51f3Slg 	hubd_t		*hubd = hd_arg->hubd;
8649ffcd51f3Slg 	uint16_t	reset_port = hd_arg->reset_port;
8650ffcd51f3Slg 	uint16_t	status, change;
8651ffcd51f3Slg 	hub_power_t	*hubpm;
8652ffcd51f3Slg 	dev_info_t	*hdip = hubd->h_dip;
8653ffcd51f3Slg 	dev_info_t	*rh_dip = hubd->h_usba_device->usb_root_hub_dip;
8654ffcd51f3Slg 	dev_info_t	*child_dip;
8655ffcd51f3Slg 	boolean_t	online_child = B_FALSE;
8656ffcd51f3Slg 	int		prh_circ, rh_circ, circ, devinst;
8657ffcd51f3Slg 	char		*devname;
8658aa041649SRaymond Chen 	int		i = 0;
8659aa041649SRaymond Chen 	int		rval = USB_FAILURE;
8660ffcd51f3Slg 
8661ffcd51f3Slg 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8662ffcd51f3Slg 	    "hubd_reset_thread:  started, hubd_reset_port = 0x%x", reset_port);
8663ffcd51f3Slg 
8664ffcd51f3Slg 	kmem_free(arg, sizeof (hubd_reset_arg_t));
8665ffcd51f3Slg 
8666ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
8667ffcd51f3Slg 
8668ffcd51f3Slg 	child_dip = hubd->h_children_dips[reset_port];
8669ffcd51f3Slg 	ASSERT(child_dip != NULL);
8670ffcd51f3Slg 
8671ffcd51f3Slg 	devname = (char *)ddi_driver_name(child_dip);
8672ffcd51f3Slg 	devinst = ddi_get_instance(child_dip);
8673ffcd51f3Slg 
8674ffcd51f3Slg 	/* if our bus power entry point is active, quit the reset */
8675ffcd51f3Slg 	if (hubd->h_bus_pwr) {
8676ffcd51f3Slg 		USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8677ffcd51f3Slg 		    "%s%d is under bus power management, cannot be reset. "
8678ffcd51f3Slg 		    "Please disconnect and reconnect this device.",
8679ffcd51f3Slg 		    devname, devinst);
8680ffcd51f3Slg 
8681ffcd51f3Slg 		goto Fail;
8682ffcd51f3Slg 	}
8683ffcd51f3Slg 
8684ffcd51f3Slg 	if (hubd_wait_for_hotplug_exit(hubd) == USB_FAILURE) {
8685ffcd51f3Slg 		/* we got woken up because of a timeout */
8686ffcd51f3Slg 		USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
8687ffcd51f3Slg 		    hubd->h_log_handle, "Time out when resetting the device"
8688ffcd51f3Slg 		    " %s%d. Please disconnect and reconnect this device.",
8689ffcd51f3Slg 		    devname, devinst);
8690ffcd51f3Slg 
8691ffcd51f3Slg 		goto Fail;
8692ffcd51f3Slg 	}
8693ffcd51f3Slg 
8694ffcd51f3Slg 	hubd->h_hotplug_thread++;
8695ffcd51f3Slg 
8696ffcd51f3Slg 	/* is this the root hub? */
8697ffcd51f3Slg 	if ((hdip == rh_dip) &&
8698ffcd51f3Slg 	    (hubd->h_dev_state == USB_DEV_PWRED_DOWN)) {
8699ffcd51f3Slg 		hubpm = hubd->h_hubpm;
8700ffcd51f3Slg 
8701ffcd51f3Slg 		/* mark the root hub as full power */
8702ffcd51f3Slg 		hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
8703ffcd51f3Slg 		hubpm->hubp_time_at_full_power = ddi_get_time();
8704ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
8705ffcd51f3Slg 
8706ffcd51f3Slg 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8707ffcd51f3Slg 		    "hubd_reset_thread: call pm_power_has_changed");
8708ffcd51f3Slg 
8709ffcd51f3Slg 		(void) pm_power_has_changed(hdip, 0,
8710ffcd51f3Slg 		    USB_DEV_OS_FULL_PWR);
8711ffcd51f3Slg 
8712ffcd51f3Slg 		mutex_enter(HUBD_MUTEX(hubd));
8713ffcd51f3Slg 		hubd->h_dev_state = USB_DEV_ONLINE;
8714ffcd51f3Slg 	}
8715ffcd51f3Slg 
8716ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
8717ffcd51f3Slg 
8718ffcd51f3Slg 	/*
8719ffcd51f3Slg 	 * this ensures one reset activity per system at a time.
8720ffcd51f3Slg 	 * we enter the parent PCI node to have this serialization.
8721ffcd51f3Slg 	 * this also excludes ioctls and deathrow thread
8722ffcd51f3Slg 	 */
8723ffcd51f3Slg 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
8724ffcd51f3Slg 	ndi_devi_enter(rh_dip, &rh_circ);
8725ffcd51f3Slg 
8726ffcd51f3Slg 	/* exclude other threads */
8727ffcd51f3Slg 	ndi_devi_enter(hdip, &circ);
8728ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
8729ffcd51f3Slg 
8730ffcd51f3Slg 	/*
8731ffcd51f3Slg 	 * We need to make sure that the child is still online for a hotplug
8732ffcd51f3Slg 	 * thread could have inserted which detached the child.
8733ffcd51f3Slg 	 */
8734ffcd51f3Slg 	if (hubd->h_children_dips[reset_port]) {
8735ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
8736ffcd51f3Slg 		/* First disconnect the device */
8737ffcd51f3Slg 		hubd_post_event(hubd, reset_port, USBA_EVENT_TAG_HOT_REMOVAL);
8738aa041649SRaymond Chen 
8739aa041649SRaymond Chen 		/* delete cached dv_node's but drop locks first */
8740aa041649SRaymond Chen 		ndi_devi_exit(hdip, circ);
8741aa041649SRaymond Chen 		ndi_devi_exit(rh_dip, rh_circ);
8742aa041649SRaymond Chen 		ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
8743aa041649SRaymond Chen 
8744aa041649SRaymond Chen 		(void) devfs_clean(rh_dip, NULL, DV_CLEAN_FORCE);
8745aa041649SRaymond Chen 
8746aa041649SRaymond Chen 		/*
8747aa041649SRaymond Chen 		 * workaround only for storage device. When it's able to force
8748aa041649SRaymond Chen 		 * detach a driver, this code can be removed safely.
8749aa041649SRaymond Chen 		 *
8750aa041649SRaymond Chen 		 * If we're to reset storage device and the device is used, we
8751aa041649SRaymond Chen 		 * will wait at most extra 20s for applications to exit and
8752aa041649SRaymond Chen 		 * close the device. This is especially useful for HAL-based
8753aa041649SRaymond Chen 		 * applications.
8754aa041649SRaymond Chen 		 */
8755aa041649SRaymond Chen 		if ((strcmp(devname, "scsa2usb") == 0) &&
8756aa041649SRaymond Chen 		    DEVI(child_dip)->devi_ref != 0) {
8757aa041649SRaymond Chen 			while (i++ < hubdi_reset_delay) {
8758aa041649SRaymond Chen 				mutex_enter(HUBD_MUTEX(hubd));
8759aa041649SRaymond Chen 				rval = hubd_delete_child(hubd, reset_port,
8760aa041649SRaymond Chen 				    NDI_DEVI_REMOVE, B_FALSE);
8761aa041649SRaymond Chen 				mutex_exit(HUBD_MUTEX(hubd));
8762aa041649SRaymond Chen 				if (rval == USB_SUCCESS)
8763aa041649SRaymond Chen 					break;
8764aa041649SRaymond Chen 
8765aa041649SRaymond Chen 				delay(drv_usectohz(1000000)); /* 1s */
8766aa041649SRaymond Chen 			}
8767aa041649SRaymond Chen 		}
8768aa041649SRaymond Chen 
8769aa041649SRaymond Chen 		ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
8770aa041649SRaymond Chen 		ndi_devi_enter(rh_dip, &rh_circ);
8771aa041649SRaymond Chen 		ndi_devi_enter(hdip, &circ);
8772aa041649SRaymond Chen 
8773ffcd51f3Slg 		mutex_enter(HUBD_MUTEX(hubd));
8774ffcd51f3Slg 
8775ffcd51f3Slg 		/* Then force detaching the device */
8776aa041649SRaymond Chen 		if ((rval != USB_SUCCESS) && (hubd_delete_child(hubd,
8777aa041649SRaymond Chen 		    reset_port, NDI_DEVI_REMOVE, B_FALSE) != USB_SUCCESS)) {
8778ffcd51f3Slg 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8779ffcd51f3Slg 			    "%s%d cannot be reset due to other applications "
8780ffcd51f3Slg 			    "are using it, please first close these "
8781ffcd51f3Slg 			    "applications, then disconnect and reconnect"
8782ffcd51f3Slg 			    "the device.", devname, devinst);
8783ffcd51f3Slg 
8784ffcd51f3Slg 			mutex_exit(HUBD_MUTEX(hubd));
8785ffcd51f3Slg 			/* post a re-connect event */
8786ffcd51f3Slg 			hubd_post_event(hubd, reset_port,
8787ffcd51f3Slg 			    USBA_EVENT_TAG_HOT_INSERTION);
8788ffcd51f3Slg 			mutex_enter(HUBD_MUTEX(hubd));
8789ffcd51f3Slg 		} else {
8790ffcd51f3Slg 			(void) hubd_determine_port_status(hubd, reset_port,
8791ffcd51f3Slg 			    &status, &change, HUBD_ACK_ALL_CHANGES);
8792ffcd51f3Slg 
8793ffcd51f3Slg 			/* Reset the parent hubd port and create new child */
8794ffcd51f3Slg 			if (status & PORT_STATUS_CCS) {
8795ffcd51f3Slg 				online_child |=	(hubd_handle_port_connect(hubd,
8796ffcd51f3Slg 				    reset_port) == USB_SUCCESS);
8797ffcd51f3Slg 			}
8798ffcd51f3Slg 		}
8799ffcd51f3Slg 	}
8800ffcd51f3Slg 
8801ffcd51f3Slg 	/* release locks so we can do a devfs_clean */
8802ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
8803ffcd51f3Slg 
8804ffcd51f3Slg 	/* delete cached dv_node's but drop locks first */
8805ffcd51f3Slg 	ndi_devi_exit(hdip, circ);
8806ffcd51f3Slg 	ndi_devi_exit(rh_dip, rh_circ);
8807ffcd51f3Slg 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
8808ffcd51f3Slg 
8809ffcd51f3Slg 	(void) devfs_clean(rh_dip, NULL, 0);
8810ffcd51f3Slg 
8811ffcd51f3Slg 	/* now check if any children need onlining */
8812ffcd51f3Slg 	if (online_child) {
8813ffcd51f3Slg 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8814ffcd51f3Slg 		    "hubd_reset_thread: onlining children");
8815ffcd51f3Slg 
8816ffcd51f3Slg 		(void) ndi_devi_online(hubd->h_dip, 0);
8817ffcd51f3Slg 	}
8818ffcd51f3Slg 
8819ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
8820ffcd51f3Slg 
8821ffcd51f3Slg 	/* allow hotplug thread now */
8822ffcd51f3Slg 	hubd->h_hotplug_thread--;
8823ffcd51f3Slg Fail:
8824ffcd51f3Slg 	hubd_start_polling(hubd, 0);
8825ffcd51f3Slg 
8826ffcd51f3Slg 	/* mark this device as idle */
8827ffcd51f3Slg 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
8828ffcd51f3Slg 
8829ffcd51f3Slg 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8830ffcd51f3Slg 	    "hubd_reset_thread: exit, %d", hubd->h_hotplug_thread);
8831ffcd51f3Slg 
8832ffcd51f3Slg 	hubd->h_reset_port[reset_port] = B_FALSE;
8833ffcd51f3Slg 
8834ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
8835ffcd51f3Slg 
8836ffcd51f3Slg 	ndi_rele_devi(hdip);
8837ffcd51f3Slg }
8838ffcd51f3Slg 
8839ffcd51f3Slg /*
8840ffcd51f3Slg  * hubd_check_same_device:
8841112cd14aSqz  *	- open the default pipe of the device.
8842112cd14aSqz  *	- compare the old and new descriptors of the device.
8843112cd14aSqz  *	- close the default pipe.
8844ffcd51f3Slg  */
8845ffcd51f3Slg static int
8846ffcd51f3Slg hubd_check_same_device(hubd_t *hubd, usb_port_t port)
8847ffcd51f3Slg {
8848112cd14aSqz 	dev_info_t		*dip = hubd->h_children_dips[port];
8849ffcd51f3Slg 	usb_pipe_handle_t	ph;
8850112cd14aSqz 	int			rval = USB_FAILURE;
8851ffcd51f3Slg 
8852ffcd51f3Slg 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8853ffcd51f3Slg 
8854ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
8855ffcd51f3Slg 	/* Open the default pipe to operate the device */
8856ffcd51f3Slg 	if (usb_pipe_open(dip, NULL, NULL,
8857ffcd51f3Slg 	    USB_FLAGS_SLEEP| USBA_FLAGS_PRIVILEGED,
8858ffcd51f3Slg 	    &ph) == USB_SUCCESS) {
8859ffcd51f3Slg 		/*
8860ffcd51f3Slg 		 * Check that if the device's descriptors are different
8861ffcd51f3Slg 		 * from the values saved before the port reset.
8862ffcd51f3Slg 		 */
8863ffcd51f3Slg 		rval = usb_check_same_device(dip,
8864ffcd51f3Slg 		    hubd->h_log_handle, USB_LOG_L0,
8865ffcd51f3Slg 		    DPRINT_MASK_ALL, USB_CHK_ALL, NULL);
8866ffcd51f3Slg 
8867ffcd51f3Slg 		usb_pipe_close(dip, ph, USB_FLAGS_SLEEP |
8868ffcd51f3Slg 		    USBA_FLAGS_PRIVILEGED, NULL, NULL);
8869ffcd51f3Slg 	}
8870ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
8871ffcd51f3Slg 
8872ffcd51f3Slg 	return (rval);
8873ffcd51f3Slg }
8874ffcd51f3Slg 
8875ffcd51f3Slg /*
8876ffcd51f3Slg  * usba_hubdi_reset_device
8877112cd14aSqz  *	Called by usb_reset_device to handle usb device reset.
8878ffcd51f3Slg  */
8879ffcd51f3Slg int
8880ffcd51f3Slg usba_hubdi_reset_device(dev_info_t *dip, usb_dev_reset_lvl_t reset_level)
8881ffcd51f3Slg {
8882ffcd51f3Slg 	hubd_t			*hubd;
8883ffcd51f3Slg 	usb_port_t		port = 0;
8884ffcd51f3Slg 	dev_info_t		*hdip;
8885ffcd51f3Slg 	usb_pipe_state_t	prev_pipe_state = 0;
8886ffcd51f3Slg 	usba_device_t		*usba_device;
8887ffcd51f3Slg 	hubd_reset_arg_t	*arg;
8888ffcd51f3Slg 	int			i, ph_open_cnt;
8889ffcd51f3Slg 	int			rval = USB_FAILURE;
8890ffcd51f3Slg 
8891ffcd51f3Slg 	if ((!dip) || usba_is_root_hub(dip)) {
8892aa041649SRaymond Chen 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8893aa041649SRaymond Chen 		    "usba_hubdi_reset_device: NULL dip or root hub");
8894ffcd51f3Slg 
8895ffcd51f3Slg 		return (USB_INVALID_ARGS);
8896ffcd51f3Slg 	}
8897ffcd51f3Slg 
8898ffcd51f3Slg 	if (!usb_owns_device(dip)) {
8899aa041649SRaymond Chen 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8900aa041649SRaymond Chen 		    "usba_hubdi_reset_device: Not owns the device");
8901ffcd51f3Slg 
8902ffcd51f3Slg 		return (USB_INVALID_PERM);
8903ffcd51f3Slg 	}
8904ffcd51f3Slg 
8905ffcd51f3Slg 	if ((reset_level != USB_RESET_LVL_REATTACH) &&
8906ffcd51f3Slg 	    (reset_level != USB_RESET_LVL_DEFAULT)) {
8907aa041649SRaymond Chen 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8908aa041649SRaymond Chen 		    "usba_hubdi_reset_device: Unknown flags");
8909ffcd51f3Slg 
8910ffcd51f3Slg 		return (USB_INVALID_ARGS);
8911ffcd51f3Slg 	}
8912ffcd51f3Slg 
8913ffcd51f3Slg 	if ((hdip = ddi_get_parent(dip)) == NULL) {
8914aa041649SRaymond Chen 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8915aa041649SRaymond Chen 		    "usba_hubdi_reset_device: fail to get parent hub");
8916ffcd51f3Slg 
8917ffcd51f3Slg 		return (USB_INVALID_ARGS);
8918ffcd51f3Slg 	}
8919ffcd51f3Slg 
8920ffcd51f3Slg 	if ((hubd = hubd_get_soft_state(hdip)) == NULL) {
8921aa041649SRaymond Chen 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8922aa041649SRaymond Chen 		    "usba_hubdi_reset_device: fail to get hub softstate");
8923ffcd51f3Slg 
8924ffcd51f3Slg 		return (USB_INVALID_ARGS);
8925ffcd51f3Slg 	}
8926ffcd51f3Slg 
8927ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
8928ffcd51f3Slg 
8929ffcd51f3Slg 	/* make sure the hub is connected before trying any kinds of reset. */
8930ffcd51f3Slg 	if ((hubd->h_dev_state == USB_DEV_DISCONNECTED) ||
8931ffcd51f3Slg 	    (hubd->h_dev_state == USB_DEV_SUSPENDED)) {
8932ffcd51f3Slg 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8933ffcd51f3Slg 		    "usb_reset_device: the state %d of the hub/roothub "
8934112116d8Sfb 		    "associated to the device 0x%p is incorrect",
8935112116d8Sfb 		    hubd->h_dev_state, (void *)dip);
8936ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
8937ffcd51f3Slg 
8938ffcd51f3Slg 		return (USB_INVALID_ARGS);
8939ffcd51f3Slg 	}
8940ffcd51f3Slg 
8941ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
8942ffcd51f3Slg 
8943ffcd51f3Slg 	port = hubd_child_dip2port(hubd, dip);
8944ffcd51f3Slg 
8945ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
8946ffcd51f3Slg 
8947ffcd51f3Slg 	if (hubd->h_reset_port[port]) {
8948ffcd51f3Slg 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8949ffcd51f3Slg 		    "usb_reset_device: the corresponding port is resetting");
8950ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
8951ffcd51f3Slg 
8952ffcd51f3Slg 		return (USB_SUCCESS);
8953ffcd51f3Slg 	}
8954ffcd51f3Slg 
8955ffcd51f3Slg 	/*
8956ffcd51f3Slg 	 * For Default reset, client drivers should first close all the pipes
8957ffcd51f3Slg 	 * except default pipe before calling the function, also should not
8958ffcd51f3Slg 	 * call the function during interrupt context.
8959ffcd51f3Slg 	 */
8960ffcd51f3Slg 	if (reset_level == USB_RESET_LVL_DEFAULT) {
8961ffcd51f3Slg 		usba_device = hubd->h_usba_devices[port];
8962ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
8963ffcd51f3Slg 
8964ffcd51f3Slg 		if (servicing_interrupt()) {
8965ffcd51f3Slg 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8966ffcd51f3Slg 			    "usb_reset_device: during interrput context, quit");
8967ffcd51f3Slg 
8968ffcd51f3Slg 			return (USB_INVALID_CONTEXT);
8969ffcd51f3Slg 		}
8970ffcd51f3Slg 		/* Check if all the pipes have been closed */
8971ffcd51f3Slg 		for (ph_open_cnt = 0, i = 1; i < USBA_N_ENDPOINTS; i++) {
8972ffcd51f3Slg 			if (usba_device->usb_ph_list[i].usba_ph_data) {
8973ffcd51f3Slg 				ph_open_cnt++;
8974ffcd51f3Slg 				break;
8975ffcd51f3Slg 			}
8976ffcd51f3Slg 		}
8977ffcd51f3Slg 		if (ph_open_cnt) {
8978ffcd51f3Slg 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8979ffcd51f3Slg 			    "usb_reset_device: %d pipes are still open",
8980ffcd51f3Slg 			    ph_open_cnt);
8981ffcd51f3Slg 
8982ffcd51f3Slg 			return (USB_BUSY);
8983ffcd51f3Slg 		}
8984ffcd51f3Slg 		mutex_enter(HUBD_MUTEX(hubd));
8985ffcd51f3Slg 	}
8986ffcd51f3Slg 
8987ffcd51f3Slg 	/* Don't perform reset while the device is detaching */
8988ffcd51f3Slg 	if (hubd->h_port_state[port] & HUBD_CHILD_DETACHING) {
8989ffcd51f3Slg 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8990ffcd51f3Slg 		    "usb_reset_device: the device is detaching, "
8991ffcd51f3Slg 		    "cannot be reset");
8992ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
8993ffcd51f3Slg 
8994ffcd51f3Slg 		return (USB_FAILURE);
8995ffcd51f3Slg 	}
8996ffcd51f3Slg 
8997ffcd51f3Slg 	hubd->h_reset_port[port] = B_TRUE;
8998ffcd51f3Slg 	hdip = hubd->h_dip;
8999ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
9000ffcd51f3Slg 
9001ffcd51f3Slg 	/* Don't allow hub detached during the reset */
9002ffcd51f3Slg 	ndi_hold_devi(hdip);
9003ffcd51f3Slg 
9004ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
9005ffcd51f3Slg 	hubd_pm_busy_component(hubd, hdip, 0);
9006ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
9007ffcd51f3Slg 	/* go full power */
9008ffcd51f3Slg 	(void) pm_raise_power(hdip, 0, USB_DEV_OS_FULL_PWR);
9009ffcd51f3Slg 	mutex_enter(HUBD_MUTEX(hubd));
9010ffcd51f3Slg 
9011ffcd51f3Slg 	hubd->h_hotplug_thread++;
9012ffcd51f3Slg 
9013ffcd51f3Slg 	/* stop polling if it was active */
9014ffcd51f3Slg 	if (hubd->h_ep1_ph) {
9015ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
9016ffcd51f3Slg 		(void) usb_pipe_get_state(hubd->h_ep1_ph, &prev_pipe_state,
9017ffcd51f3Slg 		    USB_FLAGS_SLEEP);
9018ffcd51f3Slg 		mutex_enter(HUBD_MUTEX(hubd));
9019ffcd51f3Slg 
9020ffcd51f3Slg 		if (prev_pipe_state == USB_PIPE_STATE_ACTIVE) {
9021ffcd51f3Slg 			hubd_stop_polling(hubd);
9022ffcd51f3Slg 		}
9023ffcd51f3Slg 	}
9024ffcd51f3Slg 
9025ffcd51f3Slg 	switch (reset_level) {
9026ffcd51f3Slg 	case USB_RESET_LVL_REATTACH:
9027ffcd51f3Slg 		mutex_exit(HUBD_MUTEX(hubd));
9028ffcd51f3Slg 		arg = (hubd_reset_arg_t *)kmem_zalloc(
9029ffcd51f3Slg 		    sizeof (hubd_reset_arg_t), KM_SLEEP);
9030ffcd51f3Slg 		arg->hubd = hubd;
9031ffcd51f3Slg 		arg->reset_port = port;
9032ffcd51f3Slg 		mutex_enter(HUBD_MUTEX(hubd));
9033ffcd51f3Slg 
9034ffcd51f3Slg 		if ((rval = usb_async_req(hdip, hubd_reset_thread,
9035ffcd51f3Slg 		    (void *)arg, 0)) == USB_SUCCESS) {
9036ffcd51f3Slg 			hubd->h_hotplug_thread--;
9037ffcd51f3Slg 			mutex_exit(HUBD_MUTEX(hubd));
9038ffcd51f3Slg 
9039ffcd51f3Slg 			return (USB_SUCCESS);
9040ffcd51f3Slg 		} else {
9041ffcd51f3Slg 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
9042ffcd51f3Slg 			    "Cannot create reset thread, the device %s%d failed"
9043ffcd51f3Slg 			    " to reset", ddi_driver_name(dip),
9044ffcd51f3Slg 			    ddi_get_instance(dip));
9045ffcd51f3Slg 
9046ffcd51f3Slg 			kmem_free(arg, sizeof (hubd_reset_arg_t));
9047ffcd51f3Slg 		}
9048ffcd51f3Slg 
9049ffcd51f3Slg 		break;
9050ffcd51f3Slg 	case USB_RESET_LVL_DEFAULT:
9051ffcd51f3Slg 		/*
9052ffcd51f3Slg 		 * Reset hub port and then recover device's address, set back
9053ffcd51f3Slg 		 * device's configuration, hubd_handle_port_connect() will
9054ffcd51f3Slg 		 * handle errors happened during this process.
9055ffcd51f3Slg 		 */
9056ffcd51f3Slg 		if ((rval = hubd_handle_port_connect(hubd, port))
9057ffcd51f3Slg 		    == USB_SUCCESS) {
9058ffcd51f3Slg 			mutex_exit(HUBD_MUTEX(hubd));
9059ffcd51f3Slg 			/* re-open the default pipe */
9060ffcd51f3Slg 			rval = usba_persistent_pipe_open(usba_device);
9061ffcd51f3Slg 			mutex_enter(HUBD_MUTEX(hubd));
9062ffcd51f3Slg 			if (rval != USB_SUCCESS) {
9063ffcd51f3Slg 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
9064ffcd51f3Slg 				    hubd->h_log_handle, "failed to reopen "
9065ffcd51f3Slg 				    "default pipe after reset, disable hub"
9066ffcd51f3Slg 				    "port for %s%d", ddi_driver_name(dip),
9067ffcd51f3Slg 				    ddi_get_instance(dip));
9068ffcd51f3Slg 				/*
9069ffcd51f3Slg 				 * Disable port to set out a hotplug thread
9070ffcd51f3Slg 				 * which will handle errors.
9071ffcd51f3Slg 				 */
9072ffcd51f3Slg 				(void) hubd_disable_port(hubd, port);
9073ffcd51f3Slg 			}
9074ffcd51f3Slg 		}
9075ffcd51f3Slg 
9076ffcd51f3Slg 		break;
9077ffcd51f3Slg 	default:
9078ffcd51f3Slg 
9079ffcd51f3Slg 		break;
9080ffcd51f3Slg 	}
9081ffcd51f3Slg 
9082ffcd51f3Slg 	/* allow hotplug thread now */
9083ffcd51f3Slg 	hubd->h_hotplug_thread--;
9084ffcd51f3Slg 
9085ffcd51f3Slg 	if ((hubd->h_dev_state == USB_DEV_ONLINE) && hubd->h_ep1_ph &&
9086ffcd51f3Slg 	    (prev_pipe_state == USB_PIPE_STATE_ACTIVE)) {
9087ffcd51f3Slg 		hubd_start_polling(hubd, 0);
9088ffcd51f3Slg 	}
9089ffcd51f3Slg 
9090ffcd51f3Slg 	hubd_pm_idle_component(hubd, hdip, 0);
9091ffcd51f3Slg 
9092ffcd51f3Slg 	/* Clear reset mark for the port. */
9093ffcd51f3Slg 	hubd->h_reset_port[port] = B_FALSE;
9094ffcd51f3Slg 
9095ffcd51f3Slg 	mutex_exit(HUBD_MUTEX(hubd));
9096ffcd51f3Slg 
9097ffcd51f3Slg 	ndi_rele_devi(hdip);
9098ffcd51f3Slg 
9099ffcd51f3Slg 	return (rval);
9100ffcd51f3Slg }
9101