xref: /titanic_52/usr/src/uts/common/io/usb/usba/hubdi.c (revision 69112edd987c28fa551d4f8d9362a84a45365f17)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 
27 /*
28  * USBA: Solaris USB Architecture support for the hub
29  * including root hub
30  * Most of the code for hubd resides in this file and
31  * is shared between the HCD root hub support and hubd
32  */
33 #define	USBA_FRAMEWORK
34 #include <sys/usb/usba.h>
35 #include <sys/usb/usba/usba_devdb.h>
36 #include <sys/sunndi.h>
37 #include <sys/usb/usba/usba_impl.h>
38 #include <sys/usb/usba/usba_types.h>
39 #include <sys/usb/usba/hubdi.h>
40 #include <sys/usb/usba/hcdi_impl.h>
41 #include <sys/usb/hubd/hub.h>
42 #include <sys/usb/hubd/hubdvar.h>
43 #include <sys/usb/hubd/hubd_impl.h>
44 #include <sys/kobj.h>
45 #include <sys/kobj_lex.h>
46 #include <sys/fs/dv_node.h>
47 #include <sys/strsun.h>
48 
49 /*
50  * External functions
51  */
52 extern boolean_t consconfig_console_is_ready(void);
53 
54 /*
55  * Prototypes for static functions
56  */
57 static	int	usba_hubdi_bus_ctl(
58 			dev_info_t		*dip,
59 			dev_info_t		*rdip,
60 			ddi_ctl_enum_t		op,
61 			void			*arg,
62 			void			*result);
63 
64 static int	usba_hubdi_map_fault(
65 			dev_info_t		*dip,
66 			dev_info_t		*rdip,
67 			struct hat		*hat,
68 			struct seg		*seg,
69 			caddr_t 		addr,
70 			struct devpage		*dp,
71 			pfn_t			pfn,
72 			uint_t			prot,
73 			uint_t			lock);
74 
75 static int hubd_busop_get_eventcookie(dev_info_t *dip,
76 			dev_info_t *rdip,
77 			char *eventname,
78 			ddi_eventcookie_t *cookie);
79 static int hubd_busop_add_eventcall(dev_info_t *dip,
80 			dev_info_t *rdip,
81 			ddi_eventcookie_t cookie,
82 			void (*callback)(dev_info_t *dip,
83 				ddi_eventcookie_t cookie, void *arg,
84 				void *bus_impldata),
85 			void *arg, ddi_callback_id_t *cb_id);
86 static int hubd_busop_remove_eventcall(dev_info_t *dip,
87 			ddi_callback_id_t cb_id);
88 static int hubd_bus_config(dev_info_t *dip,
89 			uint_t flag,
90 			ddi_bus_config_op_t op,
91 			void *arg,
92 			dev_info_t **child);
93 static int hubd_bus_unconfig(dev_info_t *dip,
94 			uint_t flag,
95 			ddi_bus_config_op_t op,
96 			void *arg);
97 static int hubd_bus_power(dev_info_t *dip, void *impl_arg,
98 			pm_bus_power_op_t op, void *arg, void *result);
99 
100 static usb_port_t  hubd_get_port_num(hubd_t *, struct devctl_iocdata *);
101 static dev_info_t *hubd_get_child_dip(hubd_t *, usb_port_t);
102 static uint_t hubd_cfgadm_state(hubd_t *, usb_port_t);
103 static int hubd_toggle_port(hubd_t *, usb_port_t);
104 static void hubd_register_cpr_callback(hubd_t *);
105 static void hubd_unregister_cpr_callback(hubd_t *);
106 
107 /*
108  * Busops vector for USB HUB's
109  */
110 struct bus_ops usba_hubdi_busops =	{
111 	BUSO_REV,
112 	nullbusmap,			/* bus_map */
113 	NULL,				/* bus_get_intrspec */
114 	NULL,				/* bus_add_intrspec */
115 	NULL,				/* bus_remove_intrspec */
116 	usba_hubdi_map_fault,		/* bus_map_fault */
117 	ddi_dma_map,			/* bus_dma_map */
118 	ddi_dma_allochdl,
119 	ddi_dma_freehdl,
120 	ddi_dma_bindhdl,
121 	ddi_dma_unbindhdl,
122 	ddi_dma_flush,
123 	ddi_dma_win,
124 	ddi_dma_mctl,			/* bus_dma_ctl */
125 	usba_hubdi_bus_ctl,		/* bus_ctl */
126 	ddi_bus_prop_op,		/* bus_prop_op */
127 	hubd_busop_get_eventcookie,
128 	hubd_busop_add_eventcall,
129 	hubd_busop_remove_eventcall,
130 	NULL,				/* bus_post_event */
131 	NULL,				/* bus_intr_ctl */
132 	hubd_bus_config,		/* bus_config */
133 	hubd_bus_unconfig,		/* bus_unconfig */
134 	NULL,				/* bus_fm_init */
135 	NULL,				/* bus_fm_fini */
136 	NULL,				/* bus_fm_access_enter */
137 	NULL,				/* bus_fm_access_exit */
138 	hubd_bus_power			/* bus_power */
139 };
140 
141 
142 /*
143  * local variables
144  */
145 static kmutex_t	usba_hubdi_mutex;	/* protects USBA HUB data structures */
146 
147 static usba_list_entry_t	usba_hubdi_list;
148 
149 usb_log_handle_t	hubdi_log_handle;
150 uint_t			hubdi_errlevel = USB_LOG_L4;
151 uint_t			hubdi_errmask = (uint_t)-1;
152 uint8_t			hubdi_min_pm_threshold = 5; /* seconds */
153 uint8_t			hubdi_reset_delay = 20; /* seconds */
154 
155 /*
156  * initialize private data
157  */
158 void
159 usba_hubdi_initialization()
160 {
161 	hubdi_log_handle = usb_alloc_log_hdl(NULL, "hubdi", &hubdi_errlevel,
162 	    &hubdi_errmask, NULL, 0);
163 
164 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
165 	    "usba_hubdi_initialization");
166 
167 	mutex_init(&usba_hubdi_mutex, NULL, MUTEX_DRIVER, NULL);
168 
169 	usba_init_list(&usba_hubdi_list, NULL, NULL);
170 }
171 
172 
173 void
174 usba_hubdi_destroy()
175 {
176 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
177 	    "usba_hubdi_destroy");
178 
179 	mutex_destroy(&usba_hubdi_mutex);
180 	usba_destroy_list(&usba_hubdi_list);
181 
182 	usb_free_log_hdl(hubdi_log_handle);
183 }
184 
185 
186 /*
187  * Called by an	HUB to attach an instance of the driver
188  *	make this instance known to USBA
189  *	the HUB	should initialize usba_hubdi structure prior
190  *	to calling this	interface
191  */
192 int
193 usba_hubdi_register(dev_info_t	*dip,
194 		uint_t		flags)
195 {
196 	usba_hubdi_t *hubdi = kmem_zalloc(sizeof (usba_hubdi_t), KM_SLEEP);
197 	usba_device_t *usba_device = usba_get_usba_device(dip);
198 
199 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
200 	    "usba_hubdi_register: %s", ddi_node_name(dip));
201 
202 	hubdi->hubdi_dip = dip;
203 	hubdi->hubdi_flags = flags;
204 
205 	usba_device->usb_hubdi = hubdi;
206 
207 	/*
208 	 * add this hubdi instance to the list of known hubdi's
209 	 */
210 	usba_init_list(&hubdi->hubdi_list, (usb_opaque_t)hubdi,
211 	    usba_hcdi_get_hcdi(usba_device->usb_root_hub_dip)->
212 	    hcdi_iblock_cookie);
213 	mutex_enter(&usba_hubdi_mutex);
214 	usba_add_to_list(&usba_hubdi_list, &hubdi->hubdi_list);
215 	mutex_exit(&usba_hubdi_mutex);
216 
217 	return (DDI_SUCCESS);
218 }
219 
220 
221 /*
222  * Called by an	HUB to detach an instance of the driver
223  */
224 int
225 usba_hubdi_unregister(dev_info_t *dip)
226 {
227 	usba_device_t *usba_device = usba_get_usba_device(dip);
228 	usba_hubdi_t *hubdi = usba_device->usb_hubdi;
229 
230 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubdi_log_handle,
231 	    "usba_hubdi_unregister: %s", ddi_node_name(dip));
232 
233 	mutex_enter(&usba_hubdi_mutex);
234 	(void) usba_rm_from_list(&usba_hubdi_list, &hubdi->hubdi_list);
235 	mutex_exit(&usba_hubdi_mutex);
236 
237 	usba_destroy_list(&hubdi->hubdi_list);
238 
239 	kmem_free(hubdi, sizeof (usba_hubdi_t));
240 
241 	return (DDI_SUCCESS);
242 }
243 
244 
245 /*
246  * misc bus routines currently not used
247  */
248 /*ARGSUSED*/
249 static int
250 usba_hubdi_map_fault(dev_info_t *dip,
251 	dev_info_t	*rdip,
252 	struct hat	*hat,
253 	struct seg	*seg,
254 	caddr_t 	addr,
255 	struct devpage	*dp,
256 	pfn_t		pfn,
257 	uint_t		prot,
258 	uint_t		lock)
259 {
260 	return (DDI_FAILURE);
261 }
262 
263 
264 /*
265  * root hub support. the root hub uses the same devi as the HCD
266  */
267 int
268 usba_hubdi_bind_root_hub(dev_info_t *dip,
269 	uchar_t	*root_hub_config_descriptor,
270 	size_t config_length,
271 	usb_dev_descr_t *root_hub_device_descriptor)
272 {
273 	usba_device_t *usba_device;
274 	usba_hcdi_t *hcdi = usba_hcdi_get_hcdi(dip);
275 	hubd_t	*root_hubd;
276 	usb_pipe_handle_t ph = NULL;
277 	dev_info_t *child = ddi_get_child(dip);
278 
279 	if (ndi_prop_create_boolean(DDI_DEV_T_NONE, dip,
280 	    "root-hub") != NDI_SUCCESS) {
281 
282 		return (USB_FAILURE);
283 	}
284 
285 	usba_add_root_hub(dip);
286 
287 	root_hubd = kmem_zalloc(sizeof (hubd_t), KM_SLEEP);
288 
289 	/*
290 	 * create and initialize a usba_device structure
291 	 */
292 	usba_device = usba_alloc_usba_device(dip);
293 
294 	mutex_enter(&usba_device->usb_mutex);
295 	usba_device->usb_hcdi_ops = hcdi->hcdi_ops;
296 	usba_device->usb_cfg = root_hub_config_descriptor;
297 	usba_device->usb_cfg_length = config_length;
298 	usba_device->usb_dev_descr = root_hub_device_descriptor;
299 	usba_device->usb_port = 1;
300 	usba_device->usb_addr = ROOT_HUB_ADDR;
301 	usba_device->usb_root_hubd = root_hubd;
302 	usba_device->usb_cfg_array = kmem_zalloc(sizeof (uchar_t *),
303 	    KM_SLEEP);
304 	usba_device->usb_cfg_array_length = sizeof (uchar_t *);
305 
306 	usba_device->usb_cfg_array_len = kmem_zalloc(sizeof (uint16_t),
307 	    KM_SLEEP);
308 	usba_device->usb_cfg_array_len_length = sizeof (uint16_t);
309 
310 	usba_device->usb_cfg_array[0] = root_hub_config_descriptor;
311 	usba_device->usb_cfg_array_len[0] =
312 	    sizeof (root_hub_config_descriptor);
313 
314 	usba_device->usb_cfg_str_descr = kmem_zalloc(sizeof (uchar_t *),
315 	    KM_SLEEP);
316 	usba_device->usb_n_cfgs = 1;
317 	usba_device->usb_n_ifs = 1;
318 	usba_device->usb_dip = dip;
319 
320 	usba_device->usb_client_flags = kmem_zalloc(
321 	    usba_device->usb_n_ifs * USBA_CLIENT_FLAG_SIZE, KM_SLEEP);
322 
323 	usba_device->usb_client_attach_list = kmem_zalloc(
324 	    usba_device->usb_n_ifs *
325 	    sizeof (*usba_device->usb_client_attach_list), KM_SLEEP);
326 
327 	usba_device->usb_client_ev_cb_list = kmem_zalloc(
328 	    usba_device->usb_n_ifs *
329 	    sizeof (*usba_device->usb_client_ev_cb_list), KM_SLEEP);
330 
331 	/*
332 	 * The bDeviceProtocol field of root hub device specifies,
333 	 * whether root hub is a High or Full speed usb device.
334 	 */
335 	if (root_hub_device_descriptor->bDeviceProtocol) {
336 		usba_device->usb_port_status = USBA_HIGH_SPEED_DEV;
337 	} else {
338 		usba_device->usb_port_status = USBA_FULL_SPEED_DEV;
339 	}
340 
341 	mutex_exit(&usba_device->usb_mutex);
342 
343 	usba_set_usba_device(dip, usba_device);
344 
345 	/*
346 	 * For the root hub the default pipe is not yet open
347 	 */
348 	if (usb_pipe_open(dip, NULL, NULL,
349 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph) != USB_SUCCESS) {
350 		goto fail;
351 	}
352 
353 	/*
354 	 * kill off all OBP children, they may not be fully
355 	 * enumerated
356 	 */
357 	while (child) {
358 		dev_info_t *next = ddi_get_next_sibling(child);
359 		(void) ddi_remove_child(child, 0);
360 		child = next;
361 	}
362 
363 	/*
364 	 * "attach" the root hub driver
365 	 */
366 	if (usba_hubdi_attach(dip, DDI_ATTACH) != DDI_SUCCESS) {
367 		goto fail;
368 	}
369 
370 	return (USB_SUCCESS);
371 
372 fail:
373 	(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "root-hub");
374 
375 	usba_rem_root_hub(dip);
376 
377 	if (ph) {
378 		usb_pipe_close(dip, ph,
379 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
380 	}
381 
382 	kmem_free(usba_device->usb_cfg_array,
383 	    usba_device->usb_cfg_array_length);
384 	kmem_free(usba_device->usb_cfg_array_len,
385 	    usba_device->usb_cfg_array_len_length);
386 
387 	kmem_free(usba_device->usb_cfg_str_descr, sizeof (uchar_t *));
388 
389 	usba_free_usba_device(usba_device);
390 
391 	usba_set_usba_device(dip, NULL);
392 	if (root_hubd) {
393 		kmem_free(root_hubd, sizeof (hubd_t));
394 	}
395 
396 	return (USB_FAILURE);
397 }
398 
399 
400 int
401 usba_hubdi_unbind_root_hub(dev_info_t *dip)
402 {
403 	usba_device_t *usba_device;
404 
405 	/* was root hub attached? */
406 	if (!(usba_is_root_hub(dip))) {
407 
408 		/* return success anyway */
409 		return (USB_SUCCESS);
410 	}
411 
412 	/*
413 	 * usba_hubdi_detach also closes the default pipe
414 	 * and removes properties so there is no need to
415 	 * do it here
416 	 */
417 	if (usba_hubdi_detach(dip, DDI_DETACH) != DDI_SUCCESS) {
418 
419 		if (DEVI_IS_ATTACHING(dip)) {
420 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
421 			    "failure to unbind root hub after attach failure");
422 		}
423 
424 		return (USB_FAILURE);
425 	}
426 
427 	usba_device = usba_get_usba_device(dip);
428 
429 	kmem_free(usba_device->usb_root_hubd, sizeof (hubd_t));
430 
431 	kmem_free(usba_device->usb_cfg_array,
432 	    usba_device->usb_cfg_array_length);
433 	kmem_free(usba_device->usb_cfg_array_len,
434 	    usba_device->usb_cfg_array_len_length);
435 
436 	kmem_free(usba_device->usb_cfg_str_descr, sizeof (uchar_t *));
437 
438 	usba_free_usba_device(usba_device);
439 
440 	usba_rem_root_hub(dip);
441 
442 	(void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "root-hub");
443 
444 	return (USB_SUCCESS);
445 }
446 
447 
448 /*
449  * Actual Hub Driver support code:
450  *	shared by root hub and non-root hubs
451  */
452 #include <sys/usb/usba/usbai_version.h>
453 
454 /* Debugging support */
455 uint_t hubd_errlevel	= USB_LOG_L4;
456 uint_t hubd_errmask	= (uint_t)DPRINT_MASK_ALL;
457 uint_t hubd_instance_debug = (uint_t)-1;
458 static uint_t hubdi_bus_config_debug = 0;
459 
460 _NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_errlevel))
461 _NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_errmask))
462 _NOTE(DATA_READABLE_WITHOUT_LOCK(hubd_instance_debug))
463 
464 _NOTE(SCHEME_PROTECTS_DATA("unique", msgb))
465 _NOTE(SCHEME_PROTECTS_DATA("unique", dev_info))
466 
467 
468 /*
469  * local variables:
470  *
471  * Amount of time to wait between resetting the port and accessing
472  * the device.	The value is in microseconds.
473  */
474 static uint_t hubd_device_delay = 1000000;
475 
476 /*
477  * enumeration retry
478  */
479 #define	HUBD_PORT_RETRY 5
480 static uint_t hubd_retry_enumerate = HUBD_PORT_RETRY;
481 
482 /*
483  * Stale hotremoved device cleanup delay
484  */
485 #define	HUBD_STALE_DIP_CLEANUP_DELAY	5000000
486 static uint_t hubd_dip_cleanup_delay = HUBD_STALE_DIP_CLEANUP_DELAY;
487 
488 /*
489  * retries for USB suspend and resume
490  */
491 #define	HUBD_SUS_RES_RETRY	2
492 
493 void	*hubd_statep;
494 
495 /*
496  * prototypes
497  */
498 static int hubd_cleanup(dev_info_t *dip, hubd_t  *hubd);
499 static int hubd_check_ports(hubd_t  *hubd);
500 
501 static int  hubd_open_intr_pipe(hubd_t *hubd);
502 static void hubd_start_polling(hubd_t *hubd, int always);
503 static void hubd_stop_polling(hubd_t *hubd);
504 static void hubd_close_intr_pipe(hubd_t *hubd);
505 
506 static void hubd_read_cb(usb_pipe_handle_t pipe, usb_intr_req_t *req);
507 static void hubd_exception_cb(usb_pipe_handle_t pipe,
508 						usb_intr_req_t *req);
509 static void hubd_hotplug_thread(void *arg);
510 static void hubd_reset_thread(void *arg);
511 static int hubd_create_child(dev_info_t *dip,
512 		hubd_t		*hubd,
513 		usba_device_t	*usba_device,
514 		usb_port_status_t port_status,
515 		usb_port_t	port,
516 		int		iteration);
517 
518 static int hubd_delete_child(hubd_t *hubd, usb_port_t port, uint_t flag,
519 	boolean_t retry);
520 
521 static int hubd_get_hub_descriptor(hubd_t *hubd);
522 
523 static int hubd_get_hub_status_words(hubd_t *hubd, uint16_t *status);
524 
525 static int hubd_reset_port(hubd_t *hubd, usb_port_t port);
526 
527 static int hubd_get_hub_status(hubd_t *hubd);
528 
529 static int hubd_handle_port_connect(hubd_t *hubd, usb_port_t port);
530 
531 static int hubd_disable_port(hubd_t *hubd, usb_port_t port);
532 
533 static int hubd_enable_port(hubd_t *hubd, usb_port_t port);
534 static int hubd_recover_disabled_port(hubd_t *hubd, usb_port_t port);
535 
536 static int hubd_determine_port_status(hubd_t *hubd, usb_port_t port,
537 	uint16_t *status, uint16_t *change, uint_t ack_flag);
538 
539 static int hubd_enable_all_port_power(hubd_t *hubd);
540 static int hubd_disable_all_port_power(hubd_t *hubd);
541 static int hubd_disable_port_power(hubd_t *hubd, usb_port_t port);
542 static int hubd_enable_port_power(hubd_t *hubd, usb_port_t port);
543 
544 static void hubd_free_usba_device(hubd_t *hubd, usba_device_t *usba_device);
545 
546 static int hubd_can_suspend(hubd_t *hubd);
547 static void hubd_restore_device_state(dev_info_t *dip, hubd_t *hubd);
548 static int hubd_setdevaddr(hubd_t *hubd, usb_port_t port);
549 static void hubd_setdevconfig(hubd_t *hubd, usb_port_t port);
550 
551 static int hubd_register_events(hubd_t *hubd);
552 static void hubd_do_callback(hubd_t *hubd, dev_info_t *dip,
553 	ddi_eventcookie_t cookie);
554 static void hubd_run_callbacks(hubd_t *hubd, usba_event_t type);
555 static void hubd_post_event(hubd_t *hubd, usb_port_t port, usba_event_t type);
556 static void hubd_create_pm_components(dev_info_t *dip, hubd_t *hubd);
557 
558 static int hubd_disconnect_event_cb(dev_info_t *dip);
559 static int hubd_reconnect_event_cb(dev_info_t *dip);
560 static int hubd_pre_suspend_event_cb(dev_info_t *dip);
561 static int hubd_post_resume_event_cb(dev_info_t *dip);
562 static int hubd_cpr_suspend(hubd_t *hubd);
563 static void hubd_cpr_resume(dev_info_t *dip);
564 static int hubd_restore_state_cb(dev_info_t *dip);
565 static int hubd_check_same_device(hubd_t *hubd, usb_port_t port);
566 
567 static int hubd_init_power_budget(hubd_t *hubd);
568 
569 static ndi_event_definition_t hubd_ndi_event_defs[] = {
570 	{USBA_EVENT_TAG_HOT_REMOVAL, DDI_DEVI_REMOVE_EVENT, EPL_KERNEL,
571 						NDI_EVENT_POST_TO_ALL},
572 	{USBA_EVENT_TAG_HOT_INSERTION, DDI_DEVI_INSERT_EVENT, EPL_KERNEL,
573 						NDI_EVENT_POST_TO_ALL},
574 	{USBA_EVENT_TAG_POST_RESUME, USBA_POST_RESUME_EVENT, EPL_KERNEL,
575 						NDI_EVENT_POST_TO_ALL},
576 	{USBA_EVENT_TAG_PRE_SUSPEND, USBA_PRE_SUSPEND_EVENT, EPL_KERNEL,
577 						NDI_EVENT_POST_TO_ALL}
578 };
579 
580 #define	HUBD_N_NDI_EVENTS \
581 	(sizeof (hubd_ndi_event_defs) / sizeof (ndi_event_definition_t))
582 
583 static ndi_event_set_t hubd_ndi_events = {
584 	NDI_EVENTS_REV1, HUBD_N_NDI_EVENTS, hubd_ndi_event_defs};
585 
586 /* events received from parent */
587 static usb_event_t hubd_events = {
588 	hubd_disconnect_event_cb,
589 	hubd_reconnect_event_cb,
590 	hubd_pre_suspend_event_cb,
591 	hubd_post_resume_event_cb
592 };
593 
594 
595 /*
596  * hubd_get_soft_state() returns the hubd soft state
597  *
598  * WUSB support extends this function to support wire adapter class
599  * devices. The hubd soft state for the wire adapter class device
600  * would be stored in usb_root_hubd field of the usba_device structure,
601  * just as the USB host controller drivers do.
602  */
603 hubd_t *
604 hubd_get_soft_state(dev_info_t *dip)
605 {
606 	if (dip == NULL) {
607 
608 		return (NULL);
609 	}
610 
611 	if (usba_is_root_hub(dip) || usba_is_wa(dip)) {
612 		usba_device_t *usba_device = usba_get_usba_device(dip);
613 
614 		return (usba_device->usb_root_hubd);
615 	} else {
616 		int instance = ddi_get_instance(dip);
617 
618 		return (ddi_get_soft_state(hubd_statep, instance));
619 	}
620 }
621 
622 
623 /*
624  * PM support functions:
625  */
626 /*ARGSUSED*/
627 static void
628 hubd_pm_busy_component(hubd_t *hubd, dev_info_t *dip, int component)
629 {
630 	if (hubd->h_hubpm != NULL) {
631 		hubd->h_hubpm->hubp_busy_pm++;
632 		mutex_exit(HUBD_MUTEX(hubd));
633 		if (pm_busy_component(dip, 0) != DDI_SUCCESS) {
634 			mutex_enter(HUBD_MUTEX(hubd));
635 			hubd->h_hubpm->hubp_busy_pm--;
636 			mutex_exit(HUBD_MUTEX(hubd));
637 		}
638 		mutex_enter(HUBD_MUTEX(hubd));
639 		USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
640 		    "hubd_pm_busy_component: %d", hubd->h_hubpm->hubp_busy_pm);
641 	}
642 }
643 
644 
645 /*ARGSUSED*/
646 static void
647 hubd_pm_idle_component(hubd_t *hubd, dev_info_t *dip, int component)
648 {
649 	if (hubd->h_hubpm != NULL) {
650 		mutex_exit(HUBD_MUTEX(hubd));
651 		if (pm_idle_component(dip, 0) == DDI_SUCCESS) {
652 			mutex_enter(HUBD_MUTEX(hubd));
653 			ASSERT(hubd->h_hubpm->hubp_busy_pm > 0);
654 			hubd->h_hubpm->hubp_busy_pm--;
655 			mutex_exit(HUBD_MUTEX(hubd));
656 		}
657 		mutex_enter(HUBD_MUTEX(hubd));
658 		USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
659 		    "hubd_pm_idle_component: %d", hubd->h_hubpm->hubp_busy_pm);
660 	}
661 }
662 
663 
664 /*
665  * track power level changes for children of this instance
666  */
667 static void
668 hubd_set_child_pwrlvl(hubd_t *hubd, usb_port_t port, uint8_t power)
669 {
670 	int	old_power, new_power, pwr;
671 	usb_port_t	portno;
672 	hub_power_t	*hubpm;
673 
674 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
675 	    "hubd_set_child_pwrlvl: port=%d power=%d",
676 	    port, power);
677 
678 	mutex_enter(HUBD_MUTEX(hubd));
679 	hubpm = hubd->h_hubpm;
680 
681 	old_power = 0;
682 	for (portno = 1; portno <= hubd->h_hub_descr.bNbrPorts; portno++) {
683 		old_power += hubpm->hubp_child_pwrstate[portno];
684 	}
685 
686 	/* assign the port power */
687 	pwr = hubd->h_hubpm->hubp_child_pwrstate[port];
688 	hubd->h_hubpm->hubp_child_pwrstate[port] = power;
689 	new_power = old_power - pwr + power;
690 
691 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
692 	    "hubd_set_child_pwrlvl: new_power=%d old_power=%d",
693 	    new_power, old_power);
694 
695 	if ((new_power > 0) && (old_power == 0)) {
696 		/* we have the first child coming out of low power */
697 		(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
698 	} else if ((new_power == 0) && (old_power > 0)) {
699 		/* we have the last child going to low power */
700 		(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
701 	}
702 	mutex_exit(HUBD_MUTEX(hubd));
703 }
704 
705 
706 /*
707  * given a child dip, locate its port number
708  */
709 static usb_port_t
710 hubd_child_dip2port(hubd_t *hubd, dev_info_t *dip)
711 {
712 	usb_port_t	port;
713 
714 	mutex_enter(HUBD_MUTEX(hubd));
715 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
716 		if (hubd->h_children_dips[port] == dip) {
717 
718 			break;
719 		}
720 	}
721 	ASSERT(port <= hubd->h_hub_descr.bNbrPorts);
722 	mutex_exit(HUBD_MUTEX(hubd));
723 
724 	return (port);
725 }
726 
727 
728 /*
729  * if the hub can be put into low power mode, return success
730  * NOTE: suspend here means going to lower power, not CPR suspend.
731  */
732 static int
733 hubd_can_suspend(hubd_t *hubd)
734 {
735 	hub_power_t	*hubpm;
736 	int		total_power = 0;
737 	usb_port_t	port;
738 
739 	hubpm = hubd->h_hubpm;
740 
741 	if (DEVI_IS_DETACHING(hubd->h_dip)) {
742 
743 		return (USB_SUCCESS);
744 	}
745 
746 	/*
747 	 * Don't go to lower power if haven't been at full power for enough
748 	 * time to let hotplug thread kickoff.
749 	 */
750 	if (ddi_get_time() < (hubpm->hubp_time_at_full_power +
751 	    hubpm->hubp_min_pm_threshold)) {
752 
753 		return (USB_FAILURE);
754 	}
755 
756 	for (port = 1; (total_power == 0) &&
757 	    (port <= hubd->h_hub_descr.bNbrPorts); port++) {
758 		total_power += hubpm->hubp_child_pwrstate[port];
759 	}
760 
761 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
762 	    "hubd_can_suspend: %d", total_power);
763 
764 	return (total_power ? USB_FAILURE : USB_SUCCESS);
765 }
766 
767 
768 /*
769  * resume port depending on current device state
770  */
771 static int
772 hubd_resume_port(hubd_t *hubd, usb_port_t port)
773 {
774 	int		rval, retry;
775 	usb_cr_t	completion_reason;
776 	usb_cb_flags_t	cb_flags;
777 	uint16_t	status;
778 	uint16_t	change;
779 	int		retval = USB_FAILURE;
780 
781 	mutex_enter(HUBD_MUTEX(hubd));
782 
783 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
784 	    "hubd_resume_port: port=%d state=0x%x (%s)", port,
785 	    hubd->h_dev_state, usb_str_dev_state(hubd->h_dev_state));
786 
787 	switch (hubd->h_dev_state) {
788 	case USB_DEV_HUB_CHILD_PWRLVL:
789 		/*
790 		 * This could be a bus ctl for a port other than the one
791 		 * that has a remote wakeup condition. So check.
792 		 */
793 		if ((hubd->h_port_state[port] & PORT_STATUS_PSS) == 0) {
794 			/* the port isn't suspended, so don't resume */
795 			retval = USB_SUCCESS;
796 
797 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
798 			    "hubd_resume_port: port=%d not suspended", port);
799 
800 			break;
801 		}
802 		/*
803 		 * Device has initiated a wakeup.
804 		 * Issue a ClearFeature(PortSuspend)
805 		 */
806 		mutex_exit(HUBD_MUTEX(hubd));
807 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
808 		    hubd->h_default_pipe,
809 		    HUB_HANDLE_PORT_FEATURE_TYPE,
810 		    USB_REQ_CLEAR_FEATURE,
811 		    CFS_PORT_SUSPEND,
812 		    port,
813 		    0, NULL, 0,
814 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
815 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
816 			    "ClearFeature(PortSuspend) fails "
817 			    "rval=%d cr=%d cb=0x%x", rval,
818 			    completion_reason, cb_flags);
819 		}
820 		mutex_enter(HUBD_MUTEX(hubd));
821 
822 		/* either way ack changes on the port */
823 		(void) hubd_determine_port_status(hubd, port,
824 		    &status, &change, PORT_CHANGE_PSSC);
825 		retval = USB_SUCCESS;
826 
827 		break;
828 	case USB_DEV_HUB_STATE_RECOVER:
829 		/*
830 		 * When hubd's connect event callback posts a connect
831 		 * event to its child, it results in this busctl call
832 		 * which is valid
833 		 */
834 		/* FALLTHRU */
835 	case USB_DEV_ONLINE:
836 		if (((hubd->h_port_state[port] & PORT_STATUS_CCS) == 0) ||
837 		    ((hubd->h_port_state[port] & PORT_STATUS_PSS) == 0)) {
838 			/*
839 			 * the port isn't suspended, or connected
840 			 * so don't resume
841 			 */
842 			retval = USB_SUCCESS;
843 
844 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
845 			    "hubd_resume_port: port=%d not suspended", port);
846 
847 			break;
848 		}
849 		/*
850 		 * prevent kicking off the hotplug thread
851 		 */
852 		hubd->h_hotplug_thread++;
853 		hubd_stop_polling(hubd);
854 
855 		/* Now ClearFeature(PortSuspend) */
856 		for (retry = 0; retry < HUBD_SUS_RES_RETRY; retry++) {
857 			mutex_exit(HUBD_MUTEX(hubd));
858 			rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
859 			    hubd->h_default_pipe,
860 			    HUB_HANDLE_PORT_FEATURE_TYPE,
861 			    USB_REQ_CLEAR_FEATURE,
862 			    CFS_PORT_SUSPEND,
863 			    port,
864 			    0, NULL, 0,
865 			    &completion_reason, &cb_flags, 0);
866 			mutex_enter(HUBD_MUTEX(hubd));
867 			if (rval != USB_SUCCESS) {
868 				USB_DPRINTF_L2(DPRINT_MASK_PM,
869 				    hubd->h_log_handle,
870 				    "ClearFeature(PortSuspend) fails"
871 				    "rval=%d cr=%d cb=0x%x", rval,
872 				    completion_reason, cb_flags);
873 			} else {
874 				/*
875 				 * As per spec section 11.9 and 7.1.7.7
876 				 * hub need to provide at least 20ms of
877 				 * resume signalling, and s/w provide 10ms of
878 				 * recovery time before accessing the port.
879 				 */
880 				mutex_exit(HUBD_MUTEX(hubd));
881 				delay(drv_usectohz(40000));
882 				mutex_enter(HUBD_MUTEX(hubd));
883 				(void) hubd_determine_port_status(hubd, port,
884 				    &status, &change, PORT_CHANGE_PSSC);
885 
886 				if ((status & PORT_STATUS_PSS) == 0) {
887 					/* the port did finally resume */
888 					retval = USB_SUCCESS;
889 
890 					break;
891 				}
892 			}
893 		}
894 
895 		/* allow hotplug thread again */
896 		hubd->h_hotplug_thread--;
897 		hubd_start_polling(hubd, 0);
898 
899 		break;
900 	case USB_DEV_DISCONNECTED:
901 		/* Ignore - NO Operation */
902 		retval = USB_SUCCESS;
903 
904 		break;
905 	case USB_DEV_SUSPENDED:
906 	case USB_DEV_PWRED_DOWN:
907 	default:
908 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
909 		    "Improper state for port Resume");
910 
911 		break;
912 	}
913 	mutex_exit(HUBD_MUTEX(hubd));
914 
915 	return (retval);
916 }
917 
918 
919 /*
920  * suspend port depending on device state
921  */
922 static int
923 hubd_suspend_port(hubd_t *hubd, usb_port_t port)
924 {
925 	int		rval, retry;
926 	int		retval = USB_FAILURE;
927 	usb_cr_t	completion_reason;
928 	usb_cb_flags_t	cb_flags;
929 	uint16_t	status;
930 	uint16_t	change;
931 
932 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
933 	    "hubd_suspend_port: port=%d", port);
934 
935 	mutex_enter(HUBD_MUTEX(hubd));
936 
937 	switch (hubd->h_dev_state) {
938 	case USB_DEV_HUB_STATE_RECOVER:
939 		/*
940 		 * When hubd's connect event callback posts a connect
941 		 * event to its child, it results in this busctl call
942 		 * which is valid
943 		 */
944 		/* FALLTHRU */
945 	case USB_DEV_HUB_CHILD_PWRLVL:
946 		/*
947 		 * When one child is resuming, the other could timeout
948 		 * and go to low power mode, which is valid
949 		 */
950 		/* FALLTHRU */
951 	case USB_DEV_ONLINE:
952 		hubd->h_hotplug_thread++;
953 		hubd_stop_polling(hubd);
954 
955 		/*
956 		 * Some devices start an unprovoked resume.  According to spec,
957 		 * normal resume time for port is 10ms.  Wait for double that
958 		 * time, then check to be sure port is really suspended.
959 		 */
960 		for (retry = 0; retry < HUBD_SUS_RES_RETRY; retry++) {
961 			/* Now SetFeature(PortSuspend) */
962 			mutex_exit(HUBD_MUTEX(hubd));
963 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
964 			    hubd->h_default_pipe,
965 			    HUB_HANDLE_PORT_FEATURE_TYPE,
966 			    USB_REQ_SET_FEATURE,
967 			    CFS_PORT_SUSPEND,
968 			    port,
969 			    0, NULL, 0,
970 			    &completion_reason, &cb_flags, 0)) !=
971 			    USB_SUCCESS) {
972 				USB_DPRINTF_L2(DPRINT_MASK_PM,
973 				    hubd->h_log_handle,
974 				    "SetFeature(PortSuspend) fails"
975 				    "rval=%d cr=%d cb=0x%x",
976 				    rval, completion_reason, cb_flags);
977 			}
978 
979 			/*
980 			 * some devices start an unprovoked resume
981 			 * wait and check port status after some time
982 			 */
983 			delay(drv_usectohz(20000));
984 
985 			/* either ways ack changes on the port */
986 			mutex_enter(HUBD_MUTEX(hubd));
987 			(void) hubd_determine_port_status(hubd, port,
988 			    &status, &change, PORT_CHANGE_PSSC);
989 			if (status & PORT_STATUS_PSS) {
990 				/* the port is indeed suspended */
991 				retval = USB_SUCCESS;
992 
993 				break;
994 			}
995 		}
996 
997 		hubd->h_hotplug_thread--;
998 		hubd_start_polling(hubd, 0);
999 
1000 		break;
1001 
1002 	case USB_DEV_DISCONNECTED:
1003 		/* Ignore - No Operation */
1004 		retval = USB_SUCCESS;
1005 
1006 		break;
1007 
1008 	case USB_DEV_SUSPENDED:
1009 	case USB_DEV_PWRED_DOWN:
1010 	default:
1011 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
1012 		    "Improper state for port Suspend");
1013 
1014 		break;
1015 	}
1016 	mutex_exit(HUBD_MUTEX(hubd));
1017 
1018 	return (retval);
1019 }
1020 
1021 
1022 /*
1023  * child post attach/detach notifications
1024  */
1025 static void
1026 hubd_post_attach(hubd_t *hubd, usb_port_t port, struct attachspec *as)
1027 {
1028 	dev_info_t	*dip;
1029 
1030 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
1031 	    "hubd_post_attach: port=%d result=%d",
1032 	    port, as->result);
1033 
1034 	if (as->result == DDI_SUCCESS) {
1035 		/*
1036 		 * Check if the child created wants to be power managed.
1037 		 * If yes, the childs power level gets automatically tracked
1038 		 * by DDI_CTLOPS_POWER busctl.
1039 		 * If no, we set power of the new child by default
1040 		 * to USB_DEV_OS_FULL_PWR. Because we should never suspend.
1041 		 */
1042 		mutex_enter(HUBD_MUTEX(hubd));
1043 		dip = hubd->h_children_dips[port];
1044 		mutex_exit(HUBD_MUTEX(hubd));
1045 		if (DEVI(dip)->devi_pm_info == NULL) {
1046 			hubd_set_child_pwrlvl(hubd, port, USB_DEV_OS_FULL_PWR);
1047 		}
1048 	}
1049 }
1050 
1051 
1052 static void
1053 hubd_post_detach(hubd_t *hubd, usb_port_t port, struct detachspec *ds)
1054 {
1055 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
1056 	    "hubd_post_detach: port=%d result=%d", port, ds->result);
1057 
1058 	/*
1059 	 * if the device is successfully detached and is the
1060 	 * last device to detach, mark component as idle
1061 	 */
1062 	mutex_enter(HUBD_MUTEX(hubd));
1063 	if (ds->result == DDI_SUCCESS) {
1064 		usba_device_t	*usba_device = hubd->h_usba_devices[port];
1065 		dev_info_t	*pdip = hubd->h_dip;
1066 		mutex_exit(HUBD_MUTEX(hubd));
1067 
1068 		usba_hubdi_incr_power_budget(pdip, usba_device);
1069 
1070 		/*
1071 		 * We set power of the detached child
1072 		 * to 0, so that we can suspend if all
1073 		 * our children are gone
1074 		 */
1075 		hubd_set_child_pwrlvl(hubd, port, USB_DEV_OS_PWR_OFF);
1076 
1077 		/* check for leaks on detaching */
1078 		if ((usba_device) && (ds->cmd == DDI_DETACH)) {
1079 			usba_check_for_leaks(usba_device);
1080 		}
1081 	} else {
1082 		mutex_exit(HUBD_MUTEX(hubd));
1083 	}
1084 }
1085 
1086 
1087 /*
1088  * hubd_post_power
1089  *	After the child's power entry point has been called
1090  *	we record its power level in our local struct.
1091  *	If the device has powered off, we suspend port
1092  */
1093 static int
1094 hubd_post_power(hubd_t *hubd, usb_port_t port, pm_bp_child_pwrchg_t *bpc,
1095     int result)
1096 {
1097 	int	retval = USB_SUCCESS;
1098 
1099 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1100 	    "hubd_post_power: port=%d", port);
1101 
1102 	if (result == DDI_SUCCESS) {
1103 
1104 		/* record this power in our local struct */
1105 		hubd_set_child_pwrlvl(hubd, port, bpc->bpc_nlevel);
1106 
1107 		if (bpc->bpc_nlevel == USB_DEV_OS_PWR_OFF) {
1108 
1109 			/* now suspend the port */
1110 			retval = hubd_suspend_port(hubd, port);
1111 		} else if (bpc->bpc_nlevel == USB_DEV_OS_FULL_PWR) {
1112 
1113 			/* make sure the port is resumed */
1114 			retval = hubd_resume_port(hubd, port);
1115 		}
1116 	} else {
1117 
1118 		/* record old power in our local struct */
1119 		hubd_set_child_pwrlvl(hubd, port, bpc->bpc_olevel);
1120 
1121 		if (bpc->bpc_olevel == USB_DEV_OS_PWR_OFF) {
1122 
1123 			/*
1124 			 * As this device failed to transition from
1125 			 * power off state, suspend the port again
1126 			 */
1127 			retval = hubd_suspend_port(hubd, port);
1128 		}
1129 	}
1130 
1131 	return (retval);
1132 }
1133 
1134 
1135 /*
1136  * bus ctl notifications are handled here, the rest goes up to root hub/hcd
1137  */
1138 static int
1139 usba_hubdi_bus_ctl(dev_info_t *dip,
1140 	dev_info_t	*rdip,
1141 	ddi_ctl_enum_t	op,
1142 	void		*arg,
1143 	void		*result)
1144 {
1145 	usba_device_t *hub_usba_device = usba_get_usba_device(rdip);
1146 	dev_info_t *root_hub_dip = hub_usba_device->usb_root_hub_dip;
1147 	struct attachspec *as;
1148 	struct detachspec *ds;
1149 	hubd_t		*hubd;
1150 	usb_port_t	port;
1151 	int		circ, rval;
1152 	int		retval = DDI_FAILURE;
1153 
1154 	hubd = hubd_get_soft_state(dip);
1155 
1156 	mutex_enter(HUBD_MUTEX(hubd));
1157 
1158 	/* flag that we are currently running bus_ctl */
1159 	hubd->h_bus_ctls++;
1160 	mutex_exit(HUBD_MUTEX(hubd));
1161 
1162 	USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
1163 	    "usba_hubdi_bus_ctl:\n\t"
1164 	    "dip=0x%p, rdip=0x%p, op=0x%x, arg=0x%p",
1165 	    (void *)dip, (void *)rdip, op, arg);
1166 
1167 	switch (op) {
1168 	case DDI_CTLOPS_ATTACH:
1169 		as = (struct attachspec *)arg;
1170 		port = hubd_child_dip2port(hubd, rdip);
1171 
1172 		/* there is nothing to do at resume time */
1173 		if (as->cmd == DDI_RESUME) {
1174 			break;
1175 		}
1176 
1177 		/* serialize access */
1178 		ndi_devi_enter(hubd->h_dip, &circ);
1179 
1180 		switch (as->when) {
1181 		case DDI_PRE:
1182 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1183 			    "DDI_PRE DDI_CTLOPS_ATTACH: dip=%p, port=%d",
1184 			    (void *)rdip, port);
1185 
1186 			mutex_enter(HUBD_MUTEX(hubd));
1187 			hubd->h_port_state[port] |= HUBD_CHILD_ATTACHING;
1188 
1189 			/* Go busy here.  Matching idle is DDI_POST case. */
1190 			(void) hubd_pm_busy_component(hubd, dip, 0);
1191 			mutex_exit(HUBD_MUTEX(hubd));
1192 
1193 			/*
1194 			 * if we suspended the port previously
1195 			 * because child went to low power state, and
1196 			 * someone unloaded the driver, the port would
1197 			 * still be suspended and needs to be resumed
1198 			 */
1199 			rval = hubd_resume_port(hubd, port);
1200 			if (rval == USB_SUCCESS) {
1201 				retval = DDI_SUCCESS;
1202 			}
1203 
1204 			break;
1205 		case DDI_POST:
1206 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1207 			    "DDI_POST DDI_CTLOPS_ATTACH: dip=%p, port=%d",
1208 			    (void *)rdip, port);
1209 
1210 			mutex_enter(HUBD_MUTEX(hubd));
1211 			hubd->h_port_state[port] &= ~HUBD_CHILD_ATTACHING;
1212 			mutex_exit(HUBD_MUTEX(hubd));
1213 
1214 			hubd_post_attach(hubd, port, (struct attachspec *)arg);
1215 			retval = DDI_SUCCESS;
1216 			mutex_enter(HUBD_MUTEX(hubd));
1217 
1218 			/* Matching idle call for DDI_PRE busy call. */
1219 			(void) hubd_pm_idle_component(hubd, dip, 0);
1220 			mutex_exit(HUBD_MUTEX(hubd));
1221 		}
1222 		ndi_devi_exit(hubd->h_dip, circ);
1223 
1224 		break;
1225 	case DDI_CTLOPS_DETACH:
1226 		ds = (struct detachspec *)arg;
1227 		port = hubd_child_dip2port(hubd, rdip);
1228 
1229 		/* there is nothing to do at suspend time */
1230 		if (ds->cmd == DDI_SUSPEND) {
1231 			break;
1232 		}
1233 
1234 		/* serialize access */
1235 		ndi_devi_enter(hubd->h_dip, &circ);
1236 
1237 		switch (ds->when) {
1238 		case DDI_PRE:
1239 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1240 			    "DDI_PRE DDI_CTLOPS_DETACH: dip=%p port=%d",
1241 			    (void *)rdip, port);
1242 
1243 			mutex_enter(HUBD_MUTEX(hubd));
1244 			hubd->h_port_state[port] |= HUBD_CHILD_DETACHING;
1245 
1246 			/* Go busy here.  Matching idle is DDI_POST case. */
1247 			(void) hubd_pm_busy_component(hubd, dip, 0);
1248 
1249 			mutex_exit(HUBD_MUTEX(hubd));
1250 			retval = DDI_SUCCESS;
1251 
1252 			break;
1253 		case DDI_POST:
1254 			USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1255 			    "DDI_POST DDI_CTLOPS_DETACH: dip=%p port=%d",
1256 			    (void *)rdip, port);
1257 
1258 			mutex_enter(HUBD_MUTEX(hubd));
1259 			hubd->h_port_state[port] &= ~HUBD_CHILD_DETACHING;
1260 			mutex_exit(HUBD_MUTEX(hubd));
1261 
1262 			/* Matching idle call for DDI_PRE busy call. */
1263 			hubd_post_detach(hubd, port, (struct detachspec *)arg);
1264 			retval = DDI_SUCCESS;
1265 			mutex_enter(HUBD_MUTEX(hubd));
1266 			(void) hubd_pm_idle_component(hubd, dip, 0);
1267 			mutex_exit(HUBD_MUTEX(hubd));
1268 
1269 			break;
1270 		}
1271 		ndi_devi_exit(hubd->h_dip, circ);
1272 
1273 		break;
1274 	default:
1275 		retval = usba_bus_ctl(root_hub_dip, rdip, op, arg, result);
1276 	}
1277 
1278 	/* decrement bus_ctls count */
1279 	mutex_enter(HUBD_MUTEX(hubd));
1280 	hubd->h_bus_ctls--;
1281 	ASSERT(hubd->h_bus_ctls >= 0);
1282 	mutex_exit(HUBD_MUTEX(hubd));
1283 
1284 	return (retval);
1285 }
1286 
1287 /*
1288  * hubd_config_one:
1289  * 	enumerate one child according to 'port'
1290  */
1291 
1292 static boolean_t
1293 hubd_config_one(hubd_t *hubd, int port)
1294 {
1295 	uint16_t	status, change;
1296 	dev_info_t	*hdip = hubd->h_dip;
1297 	dev_info_t	*rh_dip = hubd->h_usba_device->usb_root_hub_dip;
1298 	boolean_t	online_child = B_FALSE, found = B_FALSE;
1299 	int		prh_circ, rh_circ, circ;
1300 
1301 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
1302 	    "hubd_config_one:  started, hubd_reset_port = 0x%x", port);
1303 
1304 	ndi_hold_devi(hdip); /* so we don't race with detach */
1305 
1306 	/*
1307 	 * this ensures one config activity per system at a time.
1308 	 * we enter the parent PCI node to have this serialization.
1309 	 * this also excludes ioctls and deathrow thread
1310 	 */
1311 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
1312 	ndi_devi_enter(rh_dip, &rh_circ);
1313 
1314 	/* exclude other threads */
1315 	ndi_devi_enter(hdip, &circ);
1316 	mutex_enter(HUBD_MUTEX(hubd));
1317 
1318 	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
1319 
1320 	if (!hubd->h_children_dips[port]) {
1321 
1322 		(void) hubd_determine_port_status(hubd, port,
1323 		    &status, &change, HUBD_ACK_ALL_CHANGES);
1324 
1325 		if (status & PORT_STATUS_CCS) {
1326 			online_child |=	(hubd_handle_port_connect(hubd,
1327 			    port) == USB_SUCCESS);
1328 			found = online_child;
1329 		}
1330 	} else {
1331 		found = B_TRUE;
1332 	}
1333 
1334 	mutex_exit(HUBD_MUTEX(hubd));
1335 
1336 	ndi_devi_exit(hdip, circ);
1337 	ndi_devi_exit(rh_dip, rh_circ);
1338 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
1339 
1340 	if (online_child) {
1341 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
1342 		    "hubd_config_one: onlining child");
1343 
1344 		(void) ndi_devi_online(hubd->h_dip, 0);
1345 	}
1346 
1347 	mutex_enter(HUBD_MUTEX(hubd));
1348 
1349 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
1350 
1351 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
1352 	    "hubd_config_one: exit");
1353 
1354 	mutex_exit(HUBD_MUTEX(hubd));
1355 
1356 	ndi_rele_devi(hdip);
1357 
1358 	return (found);
1359 }
1360 
1361 /*
1362  * bus enumeration entry points
1363  */
1364 static int
1365 hubd_bus_config(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
1366     void *arg, dev_info_t **child)
1367 {
1368 	hubd_t	*hubd = hubd_get_soft_state(dip);
1369 	int	rval, circ;
1370 	long port;
1371 
1372 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1373 	    "hubd_bus_config: op=%d", op);
1374 
1375 	if (hubdi_bus_config_debug) {
1376 		flag |= NDI_DEVI_DEBUG;
1377 	}
1378 
1379 	if (op == BUS_CONFIG_ONE) {
1380 		boolean_t found;
1381 		char cname[80];
1382 		char *name, *addr;
1383 
1384 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
1385 		    "hubd_bus_config: op=%d (BUS_CONFIG_ONE)", op);
1386 
1387 		(void) snprintf(cname, 80, "%s", (char *)arg);
1388 		/* split name into "name@addr" parts */
1389 		i_ddi_parse_name(cname, &name, &addr, NULL);
1390 		if (addr && *addr) {
1391 			(void) ddi_strtol(addr, NULL, 16, &port);
1392 		} else {
1393 			return (NDI_FAILURE);
1394 		}
1395 
1396 		found = hubd_config_one(hubd, port);
1397 
1398 		if (found == 0) {
1399 			return (NDI_FAILURE);
1400 		}
1401 
1402 	}
1403 	ndi_devi_enter(hubd->h_dip, &circ);
1404 	rval = ndi_busop_bus_config(dip, flag, op, arg, child, 0);
1405 	ndi_devi_exit(hubd->h_dip, circ);
1406 
1407 	return (rval);
1408 }
1409 
1410 
1411 static int
1412 hubd_bus_unconfig(dev_info_t *dip, uint_t flag, ddi_bus_config_op_t op,
1413     void *arg)
1414 {
1415 	hubd_t		*hubd = hubd_get_soft_state(dip);
1416 	dev_info_t	*cdip;
1417 	usb_port_t	port;
1418 	int		circ;
1419 	int		rval;
1420 
1421 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1422 	    "hubd_bus_unconfig: op=%d", op);
1423 
1424 	if (hubdi_bus_config_debug) {
1425 		flag |= NDI_DEVI_DEBUG;
1426 	}
1427 
1428 	if ((op == BUS_UNCONFIG_ALL) && (flag & NDI_AUTODETACH) == 0) {
1429 		flag |= NDI_DEVI_REMOVE;
1430 	}
1431 
1432 	/* serialize access */
1433 	ndi_devi_enter(dip, &circ);
1434 
1435 	rval = ndi_busop_bus_unconfig(dip, flag, op, arg);
1436 
1437 	/* logically zap children's list */
1438 	mutex_enter(HUBD_MUTEX(hubd));
1439 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
1440 		hubd->h_port_state[port] |= HUBD_CHILD_ZAP;
1441 	}
1442 	mutex_exit(HUBD_MUTEX(hubd));
1443 
1444 	/* fill in what's left */
1445 	for (cdip = ddi_get_child(dip); cdip;
1446 	    cdip = ddi_get_next_sibling(cdip)) {
1447 		usba_device_t *usba_device = usba_get_usba_device(cdip);
1448 
1449 		if (usba_device == NULL) {
1450 
1451 			continue;
1452 		}
1453 		mutex_enter(HUBD_MUTEX(hubd));
1454 		port = usba_device->usb_port;
1455 		hubd->h_children_dips[port] = cdip;
1456 		hubd->h_port_state[port] &= ~HUBD_CHILD_ZAP;
1457 		mutex_exit(HUBD_MUTEX(hubd));
1458 	}
1459 
1460 	/* physically zap the children we didn't find */
1461 	mutex_enter(HUBD_MUTEX(hubd));
1462 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
1463 		if (hubd->h_port_state[port] &	HUBD_CHILD_ZAP) {
1464 			/* zap the dip and usba_device structure as well */
1465 			hubd_free_usba_device(hubd, hubd->h_usba_devices[port]);
1466 			hubd->h_children_dips[port] = NULL;
1467 			hubd->h_port_state[port] &= ~HUBD_CHILD_ZAP;
1468 		}
1469 	}
1470 	mutex_exit(HUBD_MUTEX(hubd));
1471 
1472 	ndi_devi_exit(dip, circ);
1473 
1474 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
1475 	    "hubd_bus_unconfig: rval=%d", rval);
1476 
1477 	return (rval);
1478 }
1479 
1480 
1481 /* bus_power entry point */
1482 static int
1483 hubd_bus_power(dev_info_t *dip, void *impl_arg, pm_bus_power_op_t op,
1484     void *arg, void *result)
1485 {
1486 	hubd_t		*hubd;
1487 	int		rval, pwrup_res;
1488 	usb_port_t	port;
1489 	int		retval = DDI_FAILURE;
1490 	pm_bp_child_pwrchg_t	*bpc;
1491 	pm_bp_nexus_pwrup_t	bpn;
1492 
1493 	hubd = hubd_get_soft_state(dip);
1494 
1495 	USB_DPRINTF_L4(DPRINT_MASK_HUBDI, hubd->h_log_handle,
1496 	    "hubd_bus_power: dip=%p, impl_arg=%p, power_op=%d, arg=%p, "
1497 	    "result=%d\n", (void *)dip, impl_arg, op, arg, *(int *)result);
1498 
1499 	bpc = (pm_bp_child_pwrchg_t *)arg;
1500 
1501 	mutex_enter(HUBD_MUTEX(hubd));
1502 	hubd->h_bus_pwr++;
1503 	mutex_exit(HUBD_MUTEX(hubd));
1504 
1505 	switch (op) {
1506 	case BUS_POWER_PRE_NOTIFICATION:
1507 		port = hubd_child_dip2port(hubd, bpc->bpc_dip);
1508 		USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
1509 		    "hubd_bus_power: BUS_POWER_PRE_NOTIFICATION, port=%d",
1510 		    port);
1511 
1512 		/* go to full power if we are powered down */
1513 		mutex_enter(HUBD_MUTEX(hubd));
1514 
1515 		/*
1516 		 * If this case completes normally, idle will be in
1517 		 * hubd_bus_power / BUS_POWER_POST_NOTIFICATION
1518 		 */
1519 		hubd_pm_busy_component(hubd, dip, 0);
1520 
1521 		/*
1522 		 * raise power only if we have created the components
1523 		 * and are currently in low power
1524 		 */
1525 		if ((hubd->h_dev_state == USB_DEV_PWRED_DOWN) &&
1526 		    hubd->h_hubpm->hubp_wakeup_enabled) {
1527 			mutex_exit(HUBD_MUTEX(hubd));
1528 
1529 			bpn.bpn_comp = 0;
1530 			bpn.bpn_dip = dip;
1531 			bpn.bpn_level = USB_DEV_OS_FULL_PWR;
1532 			bpn.bpn_private = bpc->bpc_private;
1533 
1534 			rval = pm_busop_bus_power(dip, impl_arg,
1535 			    BUS_POWER_NEXUS_PWRUP, (void *)&bpn,
1536 			    (void *)&pwrup_res);
1537 
1538 			if (rval != DDI_SUCCESS || pwrup_res != DDI_SUCCESS) {
1539 				mutex_enter(HUBD_MUTEX(hubd));
1540 				hubd_pm_idle_component(hubd, dip, 0);
1541 				mutex_exit(HUBD_MUTEX(hubd));
1542 
1543 				break;
1544 			}
1545 			mutex_enter(HUBD_MUTEX(hubd));
1546 		}
1547 
1548 		/* indicate that child is changing power level */
1549 		hubd->h_port_state[port] |= HUBD_CHILD_PWRLVL_CHNG;
1550 		mutex_exit(HUBD_MUTEX(hubd));
1551 
1552 		if ((bpc->bpc_olevel == 0) &&
1553 		    (bpc->bpc_nlevel > bpc->bpc_olevel)) {
1554 			/*
1555 			 * this child is transitioning from power off
1556 			 * to power on state - resume port
1557 			 */
1558 			rval = hubd_resume_port(hubd, port);
1559 			if (rval == USB_SUCCESS) {
1560 				retval = DDI_SUCCESS;
1561 			} else {
1562 				/* reset this flag on failure */
1563 				mutex_enter(HUBD_MUTEX(hubd));
1564 				hubd->h_port_state[port] &=
1565 				    ~HUBD_CHILD_PWRLVL_CHNG;
1566 				hubd_pm_idle_component(hubd, dip, 0);
1567 				mutex_exit(HUBD_MUTEX(hubd));
1568 			}
1569 		} else {
1570 			retval = DDI_SUCCESS;
1571 		}
1572 
1573 		break;
1574 	case BUS_POWER_POST_NOTIFICATION:
1575 		port = hubd_child_dip2port(hubd, bpc->bpc_dip);
1576 		USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
1577 		    "hubd_bus_power: BUS_POWER_POST_NOTIFICATION, port=%d",
1578 		    port);
1579 
1580 		mutex_enter(HUBD_MUTEX(hubd));
1581 		hubd->h_port_state[port] &= ~HUBD_CHILD_PWRLVL_CHNG;
1582 		mutex_exit(HUBD_MUTEX(hubd));
1583 
1584 		/* record child's pwr and suspend port if required */
1585 		rval = hubd_post_power(hubd, port, bpc, *(int *)result);
1586 		if (rval == USB_SUCCESS) {
1587 
1588 			retval = DDI_SUCCESS;
1589 		}
1590 
1591 		mutex_enter(HUBD_MUTEX(hubd));
1592 
1593 		/*
1594 		 * Matching idle for the busy in
1595 		 * hubd_bus_power / BUS_POWER_PRE_NOTIFICATION
1596 		 */
1597 		hubd_pm_idle_component(hubd, dip, 0);
1598 
1599 		mutex_exit(HUBD_MUTEX(hubd));
1600 
1601 		break;
1602 	default:
1603 		retval = pm_busop_bus_power(dip, impl_arg, op, arg, result);
1604 
1605 		break;
1606 	}
1607 
1608 	mutex_enter(HUBD_MUTEX(hubd));
1609 	hubd->h_bus_pwr--;
1610 	mutex_exit(HUBD_MUTEX(hubd));
1611 
1612 	return (retval);
1613 }
1614 
1615 
1616 /*
1617  * functions to handle power transition for OS levels 0 -> 3
1618  */
1619 static int
1620 hubd_pwrlvl0(hubd_t *hubd)
1621 {
1622 	hub_power_t	*hubpm;
1623 
1624 	/* We can't power down if hotplug thread is running */
1625 	if (hubd->h_hotplug_thread || hubd->h_hubpm->hubp_busy_pm ||
1626 	    (hubd_can_suspend(hubd) == USB_FAILURE)) {
1627 
1628 		return (USB_FAILURE);
1629 	}
1630 
1631 	switch (hubd->h_dev_state) {
1632 	case USB_DEV_ONLINE:
1633 		hubpm = hubd->h_hubpm;
1634 
1635 		/*
1636 		 * To avoid race with bus_power pre_notify on check over
1637 		 * dev_state, we need to correctly set the dev state
1638 		 * before the mutex is dropped in stop polling.
1639 		 */
1640 		hubd->h_dev_state = USB_DEV_PWRED_DOWN;
1641 		hubpm->hubp_current_power = USB_DEV_OS_PWR_OFF;
1642 
1643 		/*
1644 		 * if we are the root hub, do not stop polling
1645 		 * otherwise, we will never see a resume
1646 		 */
1647 		if (usba_is_root_hub(hubd->h_dip)) {
1648 			/* place holder to implement Global Suspend */
1649 			USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
1650 			    "Global Suspend: Not Yet Implemented");
1651 		} else {
1652 			hubd_stop_polling(hubd);
1653 		}
1654 
1655 		/* Issue USB D3 command to the device here */
1656 		(void) usb_set_device_pwrlvl3(hubd->h_dip);
1657 
1658 		break;
1659 	case USB_DEV_DISCONNECTED:
1660 	case USB_DEV_SUSPENDED:
1661 	case USB_DEV_PWRED_DOWN:
1662 	default:
1663 
1664 		break;
1665 	}
1666 
1667 	return (USB_SUCCESS);
1668 }
1669 
1670 
1671 /* ARGSUSED */
1672 static int
1673 hubd_pwrlvl1(hubd_t *hubd)
1674 {
1675 	/* Issue USB D2 command to the device here */
1676 	(void) usb_set_device_pwrlvl2(hubd->h_dip);
1677 
1678 	return (USB_FAILURE);
1679 }
1680 
1681 
1682 /* ARGSUSED */
1683 static int
1684 hubd_pwrlvl2(hubd_t *hubd)
1685 {
1686 	/* Issue USB D1 command to the device here */
1687 	(void) usb_set_device_pwrlvl1(hubd->h_dip);
1688 
1689 	return (USB_FAILURE);
1690 }
1691 
1692 
1693 static int
1694 hubd_pwrlvl3(hubd_t *hubd)
1695 {
1696 	hub_power_t	*hubpm;
1697 	int		rval;
1698 
1699 	USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle, "hubd_pwrlvl3");
1700 
1701 	hubpm = hubd->h_hubpm;
1702 	switch (hubd->h_dev_state) {
1703 	case USB_DEV_PWRED_DOWN:
1704 		ASSERT(hubpm->hubp_current_power == USB_DEV_OS_PWR_OFF);
1705 		if (usba_is_root_hub(hubd->h_dip)) {
1706 			/* implement global resume here */
1707 			USB_DPRINTF_L2(DPRINT_MASK_PM,
1708 			    hubd->h_log_handle,
1709 			    "Global Resume: Not Yet Implemented");
1710 		}
1711 		/* Issue USB D0 command to the device here */
1712 		rval = usb_set_device_pwrlvl0(hubd->h_dip);
1713 		ASSERT(rval == USB_SUCCESS);
1714 		hubd->h_dev_state = USB_DEV_ONLINE;
1715 		hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
1716 		hubpm->hubp_time_at_full_power = ddi_get_time();
1717 		hubd_start_polling(hubd, 0);
1718 
1719 		/* FALLTHRU */
1720 	case USB_DEV_ONLINE:
1721 		/* we are already in full power */
1722 
1723 		/* FALLTHRU */
1724 	case USB_DEV_DISCONNECTED:
1725 	case USB_DEV_SUSPENDED:
1726 		/*
1727 		 * PM framework tries to put you in full power
1728 		 * during system shutdown. If we are disconnected
1729 		 * return success. Also, we should not change state
1730 		 * when we are disconnected or suspended or about to
1731 		 * transition to that state
1732 		 */
1733 
1734 		return (USB_SUCCESS);
1735 	default:
1736 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
1737 		    "hubd_pwrlvl3: Illegal dev_state=%d", hubd->h_dev_state);
1738 
1739 		return (USB_FAILURE);
1740 	}
1741 }
1742 
1743 
1744 /* power entry point */
1745 /* ARGSUSED */
1746 int
1747 usba_hubdi_power(dev_info_t *dip, int comp, int level)
1748 {
1749 	hubd_t		*hubd;
1750 	hub_power_t	*hubpm;
1751 	int		retval;
1752 	int		circ;
1753 
1754 	hubd = hubd_get_soft_state(dip);
1755 	USB_DPRINTF_L3(DPRINT_MASK_HUBDI, hubd->h_log_handle,
1756 	    "usba_hubdi_power: level=%d", level);
1757 
1758 	ndi_devi_enter(dip, &circ);
1759 
1760 	mutex_enter(HUBD_MUTEX(hubd));
1761 	hubpm = hubd->h_hubpm;
1762 
1763 	/* check if we are transitioning to a legal power level */
1764 	if (USB_DEV_PWRSTATE_OK(hubpm->hubp_pwr_states, level)) {
1765 		USB_DPRINTF_L2(DPRINT_MASK_HUBDI, hubd->h_log_handle,
1766 		    "usba_hubdi_power: illegal power level=%d "
1767 		    "hubp_pwr_states=0x%x", level, hubpm->hubp_pwr_states);
1768 		mutex_exit(HUBD_MUTEX(hubd));
1769 
1770 		ndi_devi_exit(dip, circ);
1771 
1772 		return (DDI_FAILURE);
1773 	}
1774 
1775 	switch (level) {
1776 	case USB_DEV_OS_PWR_OFF:
1777 		retval = hubd_pwrlvl0(hubd);
1778 
1779 		break;
1780 	case USB_DEV_OS_PWR_1:
1781 		retval = hubd_pwrlvl1(hubd);
1782 
1783 		break;
1784 	case USB_DEV_OS_PWR_2:
1785 		retval = hubd_pwrlvl2(hubd);
1786 
1787 		break;
1788 	case USB_DEV_OS_FULL_PWR:
1789 		retval = hubd_pwrlvl3(hubd);
1790 
1791 		break;
1792 	}
1793 	mutex_exit(HUBD_MUTEX(hubd));
1794 
1795 	ndi_devi_exit(dip, circ);
1796 
1797 	return ((retval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
1798 }
1799 
1800 
1801 /* power entry point for the root hub */
1802 int
1803 usba_hubdi_root_hub_power(dev_info_t *dip, int comp, int level)
1804 {
1805 	return (usba_hubdi_power(dip, comp, level));
1806 }
1807 
1808 
1809 /*
1810  * standard driver entry points support code
1811  */
1812 int
1813 usba_hubdi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1814 {
1815 	int			instance = ddi_get_instance(dip);
1816 	hubd_t			*hubd = NULL;
1817 	int			i, rval;
1818 	int			minor;
1819 	uint8_t			ports_count;
1820 	char			*log_name = NULL;
1821 	const char		*root_hub_drvname;
1822 	usb_ep_data_t		*ep_data;
1823 	usba_device_t		*child_ud = NULL;
1824 	usb_dev_descr_t		*usb_dev_descr;
1825 	usb_port_status_t	parent_port_status, child_port_status;
1826 
1827 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubdi_log_handle,
1828 	    "hubd_attach instance %d, cmd=0x%x", instance, cmd);
1829 
1830 	switch (cmd) {
1831 	case DDI_ATTACH:
1832 
1833 		break;
1834 	case DDI_RESUME:
1835 		hubd_cpr_resume(dip);
1836 
1837 		return (DDI_SUCCESS);
1838 	default:
1839 		return (DDI_FAILURE);
1840 	}
1841 
1842 	/*
1843 	 * Allocate softc information.
1844 	 */
1845 	if (usba_is_root_hub(dip)) {
1846 		/* soft state has already been allocated */
1847 		hubd = hubd_get_soft_state(dip);
1848 		minor = HUBD_IS_ROOT_HUB;
1849 
1850 		/* generate readable labels for different root hubs */
1851 		root_hub_drvname = ddi_driver_name(dip);
1852 		if (strcmp(root_hub_drvname, "ehci") == 0) {
1853 			log_name = "eusb";
1854 		} else if (strcmp(root_hub_drvname, "uhci") == 0) {
1855 			log_name = "uusb";
1856 		} else {
1857 			/* std. for ohci */
1858 			log_name = "usb";
1859 		}
1860 	} else {
1861 		rval = ddi_soft_state_zalloc(hubd_statep, instance);
1862 		minor = 0;
1863 
1864 		if (rval != DDI_SUCCESS) {
1865 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
1866 			    "cannot allocate soft state (%d)", instance);
1867 			goto fail;
1868 		}
1869 
1870 		hubd = hubd_get_soft_state(dip);
1871 		if (hubd == NULL) {
1872 			goto fail;
1873 		}
1874 	}
1875 
1876 	hubd->h_log_handle = usb_alloc_log_hdl(dip, log_name, &hubd_errlevel,
1877 	    &hubd_errmask, &hubd_instance_debug, 0);
1878 
1879 	hubd->h_usba_device	= child_ud = usba_get_usba_device(dip);
1880 	hubd->h_dip		= dip;
1881 	hubd->h_instance	= instance;
1882 
1883 	mutex_enter(&child_ud->usb_mutex);
1884 	child_port_status = child_ud->usb_port_status;
1885 	usb_dev_descr = child_ud->usb_dev_descr;
1886 	parent_port_status = (child_ud->usb_hs_hub_usba_dev) ?
1887 	    child_ud->usb_hs_hub_usba_dev->usb_port_status : 0;
1888 	mutex_exit(&child_ud->usb_mutex);
1889 
1890 	if ((child_port_status == USBA_FULL_SPEED_DEV) &&
1891 	    (parent_port_status == USBA_HIGH_SPEED_DEV) &&
1892 	    (usb_dev_descr->bcdUSB == 0x100)) {
1893 		USB_DPRINTF_L0(DPRINT_MASK_ATTA, hubd->h_log_handle,
1894 		    "Use of a USB1.0 hub behind a high speed port may "
1895 		    "cause unexpected failures");
1896 	}
1897 
1898 	hubd->h_pipe_policy.pp_max_async_reqs = 1;
1899 
1900 	/* register with USBA as client driver */
1901 	if (usb_client_attach(dip, USBDRV_VERSION, 0) != USB_SUCCESS) {
1902 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
1903 		    "client attach failed");
1904 
1905 		goto fail;
1906 	}
1907 
1908 	if (usb_get_dev_data(dip, &hubd->h_dev_data,
1909 	    USB_PARSE_LVL_IF, 0) != USB_SUCCESS) {
1910 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
1911 		    "cannot get dev_data");
1912 
1913 		goto fail;
1914 	}
1915 
1916 	if ((ep_data = usb_lookup_ep_data(dip, hubd->h_dev_data,
1917 	    hubd->h_dev_data->dev_curr_if, 0, 0,
1918 	    (uint_t)USB_EP_ATTR_INTR, (uint_t)USB_EP_DIR_IN)) == NULL) {
1919 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
1920 		    "no interrupt IN endpoint found");
1921 
1922 		goto fail;
1923 	}
1924 
1925 	hubd->h_ep1_descr = ep_data->ep_descr;
1926 	hubd->h_default_pipe = hubd->h_dev_data->dev_default_ph;
1927 
1928 	mutex_init(HUBD_MUTEX(hubd), NULL, MUTEX_DRIVER,
1929 	    hubd->h_dev_data->dev_iblock_cookie);
1930 	cv_init(&hubd->h_cv_reset_port, NULL, CV_DRIVER, NULL);
1931 	cv_init(&hubd->h_cv_hotplug_dev, NULL, CV_DRIVER, NULL);
1932 
1933 	hubd->h_init_state |= HUBD_LOCKS_DONE;
1934 
1935 	usb_free_descr_tree(dip, hubd->h_dev_data);
1936 
1937 	/*
1938 	 * register this hub instance with usba
1939 	 */
1940 	rval = usba_hubdi_register(dip, 0);
1941 	if (rval != USB_SUCCESS) {
1942 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
1943 		    "usba_hubdi_register failed");
1944 		goto fail;
1945 	}
1946 
1947 	mutex_enter(HUBD_MUTEX(hubd));
1948 	hubd->h_init_state |= HUBD_HUBDI_REGISTERED;
1949 	hubd->h_dev_state = USB_DEV_ONLINE;
1950 	mutex_exit(HUBD_MUTEX(hubd));
1951 
1952 	/* now create components to power manage this device */
1953 	hubd_create_pm_components(dip, hubd);
1954 
1955 	/*
1956 	 * Event handling: definition and registration
1957 	 *
1958 	 * first the  definition:
1959 	 * get event handle
1960 	 */
1961 	(void) ndi_event_alloc_hdl(dip, 0, &hubd->h_ndi_event_hdl, NDI_SLEEP);
1962 
1963 	/* bind event set to the handle */
1964 	if (ndi_event_bind_set(hubd->h_ndi_event_hdl, &hubd_ndi_events,
1965 	    NDI_SLEEP)) {
1966 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
1967 		    "binding event set failed");
1968 
1969 		goto fail;
1970 	}
1971 
1972 	/* event registration */
1973 	if (hubd_register_events(hubd) != USB_SUCCESS) {
1974 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
1975 		    "hubd_register_events failed");
1976 
1977 		goto fail;
1978 	}
1979 
1980 	mutex_enter(HUBD_MUTEX(hubd));
1981 	hubd->h_init_state |= HUBD_EVENTS_REGISTERED;
1982 
1983 	if ((hubd_get_hub_descriptor(hubd)) != USB_SUCCESS) {
1984 		mutex_exit(HUBD_MUTEX(hubd));
1985 
1986 		goto fail;
1987 	}
1988 
1989 	if (ddi_prop_exists(DDI_DEV_T_ANY, dip,
1990 	    (DDI_PROP_DONTPASS | DDI_PROP_NOTPROM),
1991 	    "hub-ignore-power-budget") == 1) {
1992 		hubd->h_ignore_pwr_budget = B_TRUE;
1993 	} else {
1994 		hubd->h_ignore_pwr_budget = B_FALSE;
1995 
1996 		/* initialize hub power budget variables */
1997 		if (hubd_init_power_budget(hubd) != USB_SUCCESS) {
1998 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
1999 			    "hubd_init_power_budget failed");
2000 			mutex_exit(HUBD_MUTEX(hubd));
2001 
2002 			goto fail;
2003 		}
2004 	}
2005 
2006 	/* initialize and create children */
2007 	if (hubd_check_ports(hubd) != USB_SUCCESS) {
2008 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2009 		    "hubd_check_ports failed");
2010 		mutex_exit(HUBD_MUTEX(hubd));
2011 
2012 		goto fail;
2013 	}
2014 
2015 	/*
2016 	 * create cfgadm nodes
2017 	 */
2018 	hubd->h_ancestry_str = (char *)kmem_zalloc(HUBD_APID_NAMELEN, KM_SLEEP);
2019 	hubd_get_ancestry_str(hubd);
2020 
2021 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2022 	    "#ports=0x%x", hubd->h_hub_descr.bNbrPorts);
2023 
2024 	for (i = 1; i <= hubd->h_hub_descr.bNbrPorts; i++) {
2025 		char ap_name[HUBD_APID_NAMELEN];
2026 
2027 		(void) snprintf(ap_name, HUBD_APID_NAMELEN, "%s%d",
2028 		    hubd->h_ancestry_str, i);
2029 		USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2030 		    "ap_name=%s", ap_name);
2031 
2032 		if (ddi_create_minor_node(dip, ap_name, S_IFCHR, instance,
2033 		    DDI_NT_USB_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
2034 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2035 			    "cannot create attachment point node (%d)",
2036 			    instance);
2037 			mutex_exit(HUBD_MUTEX(hubd));
2038 
2039 			goto fail;
2040 		}
2041 	}
2042 
2043 	ports_count = hubd->h_hub_descr.bNbrPorts;
2044 	mutex_exit(HUBD_MUTEX(hubd));
2045 
2046 	/* create minor nodes */
2047 	if (ddi_create_minor_node(dip, "hubd", S_IFCHR,
2048 	    instance | minor, DDI_NT_NEXUS, 0) != DDI_SUCCESS) {
2049 
2050 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2051 		    "cannot create devctl minor node (%d)", instance);
2052 
2053 		goto fail;
2054 	}
2055 
2056 	mutex_enter(HUBD_MUTEX(hubd));
2057 	hubd->h_init_state |= HUBD_MINOR_NODE_CREATED;
2058 	mutex_exit(HUBD_MUTEX(hubd));
2059 
2060 	if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
2061 	    "usb-port-count", ports_count) != DDI_PROP_SUCCESS) {
2062 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2063 		    "usb-port-count update failed");
2064 	}
2065 
2066 	/*
2067 	 * host controller driver has already reported this dev
2068 	 * if we are the root hub
2069 	 */
2070 	if (!usba_is_root_hub(dip)) {
2071 		ddi_report_dev(dip);
2072 	}
2073 
2074 	/* enable deathrow thread */
2075 	hubd->h_cleanup_enabled = B_TRUE;
2076 	mutex_enter(HUBD_MUTEX(hubd));
2077 	hubd_pm_idle_component(hubd, dip, 0);
2078 	mutex_exit(HUBD_MUTEX(hubd));
2079 
2080 	return (DDI_SUCCESS);
2081 
2082 fail:
2083 	{
2084 		char *pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2085 
2086 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
2087 		    "cannot attach %s", ddi_pathname(dip, pathname));
2088 
2089 		kmem_free(pathname, MAXPATHLEN);
2090 	}
2091 
2092 	mutex_enter(HUBD_MUTEX(hubd));
2093 	hubd_pm_idle_component(hubd, dip, 0);
2094 	mutex_exit(HUBD_MUTEX(hubd));
2095 
2096 	if (hubd) {
2097 		rval = hubd_cleanup(dip, hubd);
2098 		if (rval != USB_SUCCESS) {
2099 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
2100 			    "failure to complete cleanup after attach failure");
2101 		}
2102 	}
2103 
2104 	return (DDI_FAILURE);
2105 }
2106 
2107 
2108 int
2109 usba_hubdi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
2110 {
2111 	hubd_t	*hubd = hubd_get_soft_state(dip);
2112 	int	rval;
2113 
2114 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2115 	    "hubd_detach: cmd=0x%x", cmd);
2116 
2117 	switch (cmd) {
2118 	case DDI_DETACH:
2119 		rval = hubd_cleanup(dip, hubd);
2120 
2121 		return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
2122 	case DDI_SUSPEND:
2123 		rval = hubd_cpr_suspend(hubd);
2124 
2125 		return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE);
2126 	default:
2127 		return (DDI_FAILURE);
2128 	}
2129 }
2130 
2131 
2132 /*
2133  * hubd_setdevaddr
2134  *	set the device addrs on this port
2135  */
2136 static int
2137 hubd_setdevaddr(hubd_t *hubd, usb_port_t port)
2138 {
2139 	int		rval;
2140 	usb_cr_t	completion_reason;
2141 	usb_cb_flags_t	cb_flags;
2142 	usb_pipe_handle_t ph;
2143 	dev_info_t	*child_dip = NULL;
2144 	uchar_t		address = 0;
2145 	usba_device_t	*usba_device;
2146 	int		retry = 0;
2147 	long		time_delay;
2148 
2149 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2150 	    "hubd_setdevaddr: port=%d", port);
2151 
2152 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
2153 
2154 	child_dip = hubd->h_children_dips[port];
2155 	address = hubd->h_usba_devices[port]->usb_addr;
2156 	usba_device = hubd->h_usba_devices[port];
2157 
2158 	/* close the default pipe with addr x */
2159 	mutex_exit(HUBD_MUTEX(hubd));
2160 	ph = usba_get_dflt_pipe_handle(child_dip);
2161 	usb_pipe_close(child_dip, ph,
2162 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
2163 	mutex_enter(HUBD_MUTEX(hubd));
2164 
2165 	/*
2166 	 * As this device has been reset, temporarily
2167 	 * assign the default address
2168 	 */
2169 	mutex_enter(&usba_device->usb_mutex);
2170 	address = usba_device->usb_addr;
2171 	usba_device->usb_addr = USBA_DEFAULT_ADDR;
2172 	mutex_exit(&usba_device->usb_mutex);
2173 
2174 	mutex_exit(HUBD_MUTEX(hubd));
2175 
2176 	time_delay = drv_usectohz(hubd_device_delay / 20);
2177 	for (retry = 0; retry < hubd_retry_enumerate; retry++) {
2178 
2179 		/* open child's default pipe with USBA_DEFAULT_ADDR */
2180 		if (usb_pipe_open(child_dip, NULL, NULL,
2181 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph) !=
2182 		    USB_SUCCESS) {
2183 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2184 			    "hubd_setdevaddr: Unable to open default pipe");
2185 
2186 			break;
2187 		}
2188 
2189 		/* Set the address of the device */
2190 		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
2191 		    USB_DEV_REQ_HOST_TO_DEV,
2192 		    USB_REQ_SET_ADDRESS,	/* bRequest */
2193 		    address,			/* wValue */
2194 		    0,				/* wIndex */
2195 		    0,				/* wLength */
2196 		    NULL, 0,
2197 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
2198 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2199 			    "hubd_setdevaddr(%d): rval=%d cr=%d cb_fl=0x%x",
2200 			    retry, rval, completion_reason, cb_flags);
2201 		}
2202 
2203 		usb_pipe_close(child_dip, ph,
2204 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
2205 
2206 		if (rval == USB_SUCCESS) {
2207 
2208 			break;
2209 		}
2210 
2211 		delay(time_delay);
2212 	}
2213 
2214 	/* Reset to the old address */
2215 	mutex_enter(&usba_device->usb_mutex);
2216 	usba_device->usb_addr = address;
2217 	mutex_exit(&usba_device->usb_mutex);
2218 	mutex_enter(HUBD_MUTEX(hubd));
2219 
2220 	usba_clear_data_toggle(usba_device);
2221 
2222 	return (rval);
2223 }
2224 
2225 
2226 /*
2227  * hubd_setdevconfig
2228  *	set the device addrs on this port
2229  */
2230 static void
2231 hubd_setdevconfig(hubd_t *hubd, usb_port_t port)
2232 {
2233 	int			rval;
2234 	usb_cr_t		completion_reason;
2235 	usb_cb_flags_t		cb_flags;
2236 	usb_pipe_handle_t	ph;
2237 	dev_info_t		*child_dip = NULL;
2238 	usba_device_t		*usba_device = NULL;
2239 	uint16_t		config_value;
2240 
2241 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2242 	    "hubd_setdevconfig: port=%d", port);
2243 
2244 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
2245 
2246 	child_dip = hubd->h_children_dips[port];
2247 	usba_device = hubd->h_usba_devices[port];
2248 	config_value = hubd->h_usba_devices[port]->usb_cfg_value;
2249 	mutex_exit(HUBD_MUTEX(hubd));
2250 
2251 	/* open the default control pipe */
2252 	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
2253 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) ==
2254 	    USB_SUCCESS) {
2255 
2256 		/* Set the default configuration of the device */
2257 		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
2258 		    USB_DEV_REQ_HOST_TO_DEV,
2259 		    USB_REQ_SET_CFG,		/* bRequest */
2260 		    config_value,		/* wValue */
2261 		    0,				/* wIndex */
2262 		    0,				/* wLength */
2263 		    NULL, 0,
2264 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
2265 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2266 			    "hubd_setdevconfig: set device config failed: "
2267 			    "cr=%d cb_fl=0x%x rval=%d",
2268 			    completion_reason, cb_flags, rval);
2269 		}
2270 		/*
2271 		 * After setting the configuration, we make this default
2272 		 * control pipe persistent, so that it gets re-opened
2273 		 * on posting a connect event
2274 		 */
2275 		usba_persistent_pipe_close(usba_device);
2276 	} else {
2277 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2278 		    "pipe open fails: rval=%d", rval);
2279 	}
2280 	mutex_enter(HUBD_MUTEX(hubd));
2281 }
2282 
2283 
2284 /*ARGSUSED*/
2285 static int
2286 hubd_check_disconnected_ports(dev_info_t *dip, void *arg)
2287 {
2288 	int circ;
2289 	usb_port_t port;
2290 	hubd_t *hubd;
2291 	major_t hub_major = ddi_name_to_major("hubd");
2292 	major_t hwahc_major = ddi_name_to_major("hwahc");
2293 	major_t usbmid_major = ddi_name_to_major("usb_mid");
2294 
2295 	/*
2296 	 * make sure dip is a usb hub, major of root hub is HCD
2297 	 * major
2298 	 */
2299 	if (!usba_is_root_hub(dip)) {
2300 		if (ddi_driver_major(dip) == usbmid_major) {
2301 			/*
2302 			 * need to walk the children since it might be a
2303 			 * HWA device
2304 			 */
2305 
2306 			return (DDI_WALK_CONTINUE);
2307 		}
2308 
2309 		/* TODO: DWA device may also need special handling */
2310 
2311 		if (((ddi_driver_major(dip) != hub_major) &&
2312 		    (ddi_driver_major(dip) != hwahc_major)) ||
2313 		    !i_ddi_devi_attached(dip)) {
2314 
2315 			return (DDI_WALK_PRUNECHILD);
2316 		}
2317 	}
2318 
2319 	hubd = hubd_get_soft_state(dip);
2320 	if (hubd == NULL) {
2321 
2322 		return (DDI_WALK_PRUNECHILD);
2323 	}
2324 
2325 	/* walk child list and remove nodes with flag DEVI_DEVICE_REMOVED */
2326 	ndi_devi_enter(dip, &circ);
2327 
2328 	if (ddi_driver_major(dip) != hwahc_major) {
2329 		/* for normal usb hub or root hub */
2330 		mutex_enter(HUBD_MUTEX(hubd));
2331 		for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
2332 			dev_info_t *cdip = hubd->h_children_dips[port];
2333 
2334 			if (cdip == NULL || DEVI_IS_DEVICE_REMOVED(cdip) == 0) {
2335 
2336 				continue;
2337 			}
2338 
2339 			(void) hubd_delete_child(hubd, port, NDI_DEVI_REMOVE,
2340 			    B_TRUE);
2341 		}
2342 		mutex_exit(HUBD_MUTEX(hubd));
2343 	} else {
2344 		/* for HWA */
2345 		if (hubd->h_cleanup_child != NULL) {
2346 			if (hubd->h_cleanup_child(dip) != USB_SUCCESS) {
2347 				ndi_devi_exit(dip, circ);
2348 
2349 				return (DDI_WALK_PRUNECHILD);
2350 			}
2351 		} else {
2352 			ndi_devi_exit(dip, circ);
2353 
2354 			return (DDI_WALK_PRUNECHILD);
2355 		}
2356 	}
2357 
2358 	ndi_devi_exit(dip, circ);
2359 
2360 	/* skip siblings of root hub */
2361 	if (usba_is_root_hub(dip)) {
2362 
2363 		return (DDI_WALK_PRUNESIB);
2364 	}
2365 
2366 	return (DDI_WALK_CONTINUE);
2367 }
2368 
2369 
2370 /*
2371  * this thread will walk all children under the root hub for this
2372  * USB bus instance and attempt to remove them
2373  */
2374 static void
2375 hubd_root_hub_cleanup_thread(void *arg)
2376 {
2377 	int circ;
2378 	hubd_t *root_hubd = (hubd_t *)arg;
2379 	dev_info_t *rh_dip = root_hubd->h_dip;
2380 #ifndef __lock_lint
2381 	callb_cpr_t cprinfo;
2382 
2383 	CALLB_CPR_INIT(&cprinfo, HUBD_MUTEX(root_hubd), callb_generic_cpr,
2384 	    "USB root hub");
2385 #endif
2386 
2387 	for (;;) {
2388 		/* don't race with detach */
2389 		ndi_hold_devi(rh_dip);
2390 
2391 		mutex_enter(HUBD_MUTEX(root_hubd));
2392 		root_hubd->h_cleanup_needed = 0;
2393 		mutex_exit(HUBD_MUTEX(root_hubd));
2394 
2395 		(void) devfs_clean(rh_dip, NULL, 0);
2396 
2397 		ndi_devi_enter(ddi_get_parent(rh_dip), &circ);
2398 		ddi_walk_devs(rh_dip, hubd_check_disconnected_ports,
2399 		    NULL);
2400 #ifdef __lock_lint
2401 		(void) hubd_check_disconnected_ports(rh_dip, NULL);
2402 #endif
2403 		ndi_devi_exit(ddi_get_parent(rh_dip), circ);
2404 
2405 		/* quit if we are not enabled anymore */
2406 		mutex_enter(HUBD_MUTEX(root_hubd));
2407 		if ((root_hubd->h_cleanup_enabled == B_FALSE) ||
2408 		    (root_hubd->h_cleanup_needed == B_FALSE)) {
2409 			root_hubd->h_cleanup_active = B_FALSE;
2410 			mutex_exit(HUBD_MUTEX(root_hubd));
2411 			ndi_rele_devi(rh_dip);
2412 
2413 			break;
2414 		}
2415 		mutex_exit(HUBD_MUTEX(root_hubd));
2416 		ndi_rele_devi(rh_dip);
2417 
2418 #ifndef __lock_lint
2419 		mutex_enter(HUBD_MUTEX(root_hubd));
2420 		CALLB_CPR_SAFE_BEGIN(&cprinfo);
2421 		mutex_exit(HUBD_MUTEX(root_hubd));
2422 
2423 		delay(drv_usectohz(hubd_dip_cleanup_delay));
2424 
2425 		mutex_enter(HUBD_MUTEX(root_hubd));
2426 		CALLB_CPR_SAFE_END(&cprinfo, HUBD_MUTEX(root_hubd));
2427 		mutex_exit(HUBD_MUTEX(root_hubd));
2428 #endif
2429 	}
2430 
2431 #ifndef __lock_lint
2432 	mutex_enter(HUBD_MUTEX(root_hubd));
2433 	CALLB_CPR_EXIT(&cprinfo);
2434 #endif
2435 }
2436 
2437 
2438 void
2439 hubd_schedule_cleanup(dev_info_t *rh_dip)
2440 {
2441 	hubd_t	*root_hubd;
2442 
2443 	/*
2444 	 * The usb_root_hub_dip pointer for the child hub of the WUSB
2445 	 * wire adapter class device points to the wire adapter, not
2446 	 * the root hub. Need to find the real root hub dip so that
2447 	 * the cleanup thread only starts from the root hub.
2448 	 */
2449 	while (!usba_is_root_hub(rh_dip)) {
2450 		root_hubd = hubd_get_soft_state(rh_dip);
2451 		if (root_hubd != NULL) {
2452 			rh_dip = root_hubd->h_usba_device->usb_root_hub_dip;
2453 			if (rh_dip == NULL) {
2454 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
2455 				    root_hubd->h_log_handle,
2456 				    "hubd_schedule_cleanup: null rh dip");
2457 
2458 				return;
2459 			}
2460 		} else {
2461 			USB_DPRINTF_L2(DPRINT_MASK_ATTA,
2462 			    root_hubd->h_log_handle,
2463 			    "hubd_schedule_cleanup: cannot find root hub");
2464 
2465 			return;
2466 		}
2467 	}
2468 	root_hubd = hubd_get_soft_state(rh_dip);
2469 
2470 	mutex_enter(HUBD_MUTEX(root_hubd));
2471 	root_hubd->h_cleanup_needed = B_TRUE;
2472 	if (root_hubd->h_cleanup_enabled && !(root_hubd->h_cleanup_active)) {
2473 		root_hubd->h_cleanup_active = B_TRUE;
2474 		mutex_exit(HUBD_MUTEX(root_hubd));
2475 		(void) thread_create(NULL, 0,
2476 		    hubd_root_hub_cleanup_thread,
2477 		    (void *)root_hubd, 0, &p0, TS_RUN,
2478 		    minclsyspri);
2479 	} else {
2480 		mutex_exit(HUBD_MUTEX(root_hubd));
2481 	}
2482 }
2483 
2484 
2485 /*
2486  * hubd_restore_device_state:
2487  *	- set config for the hub
2488  *	- power cycle all the ports
2489  *	- for each port that was connected
2490  *		- reset port
2491  *		- assign addrs to the device on this port
2492  *	- restart polling
2493  *	- reset suspend flag
2494  */
2495 static void
2496 hubd_restore_device_state(dev_info_t *dip, hubd_t *hubd)
2497 {
2498 	int		rval;
2499 	int		retry;
2500 	uint_t		hub_prev_state;
2501 	usb_port_t	port;
2502 	uint16_t	status;
2503 	uint16_t	change;
2504 	dev_info_t	*ch_dip;
2505 	boolean_t	ehci_root_hub;
2506 
2507 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2508 	    "hubd_restore_device_state:");
2509 
2510 	mutex_enter(HUBD_MUTEX(hubd));
2511 	hub_prev_state = hubd->h_dev_state;
2512 	ASSERT(hub_prev_state != USB_DEV_PWRED_DOWN);
2513 
2514 	/* First bring the device to full power */
2515 	(void) hubd_pm_busy_component(hubd, dip, 0);
2516 	mutex_exit(HUBD_MUTEX(hubd));
2517 
2518 	(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
2519 
2520 	if (!usba_is_root_hub(dip) &&
2521 	    (usb_check_same_device(dip, hubd->h_log_handle, USB_LOG_L0,
2522 	    DPRINT_MASK_HOTPLUG,
2523 	    USB_CHK_BASIC|USB_CHK_CFG, NULL) != USB_SUCCESS)) {
2524 
2525 		/* change the device state to disconnected */
2526 		mutex_enter(HUBD_MUTEX(hubd));
2527 		hubd->h_dev_state = USB_DEV_DISCONNECTED;
2528 		(void) hubd_pm_idle_component(hubd, dip, 0);
2529 		mutex_exit(HUBD_MUTEX(hubd));
2530 
2531 		return;
2532 	}
2533 
2534 	ehci_root_hub = (strcmp(ddi_driver_name(dip), "ehci") == 0);
2535 
2536 	mutex_enter(HUBD_MUTEX(hubd));
2537 	/* First turn off all port power */
2538 	rval = hubd_disable_all_port_power(hubd);
2539 	if (rval != USB_SUCCESS) {
2540 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
2541 		    "hubd_restore_device_state:"
2542 		    "turning off port power failed");
2543 	}
2544 
2545 	/* Settling time before turning on again */
2546 	mutex_exit(HUBD_MUTEX(hubd));
2547 	delay(drv_usectohz(hubd_device_delay / 100));
2548 	mutex_enter(HUBD_MUTEX(hubd));
2549 
2550 	/* enable power on all ports so we can see connects */
2551 	if (hubd_enable_all_port_power(hubd) != USB_SUCCESS) {
2552 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2553 		    "hubd_restore_device_state: turn on port power failed");
2554 
2555 		/* disable whatever was enabled */
2556 		(void) hubd_disable_all_port_power(hubd);
2557 
2558 		(void) hubd_pm_idle_component(hubd, dip, 0);
2559 		mutex_exit(HUBD_MUTEX(hubd));
2560 
2561 		return;
2562 	}
2563 
2564 	/*
2565 	 * wait at least 3 frames before accessing devices
2566 	 * (note that delay's minimal time is one clock tick which
2567 	 * is 10ms unless hires_tick has been changed)
2568 	 */
2569 	mutex_exit(HUBD_MUTEX(hubd));
2570 	delay(drv_usectohz(10000));
2571 	mutex_enter(HUBD_MUTEX(hubd));
2572 
2573 	hubd->h_dev_state = USB_DEV_HUB_STATE_RECOVER;
2574 
2575 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
2576 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
2577 		    "hubd_restore_device_state: port=%d", port);
2578 
2579 		/*
2580 		 * the childen_dips list may have dips that have been
2581 		 * already deallocated. we only get a post_detach notification
2582 		 * but not a destroy notification
2583 		 */
2584 		ch_dip = hubd->h_children_dips[port];
2585 		if (ch_dip) {
2586 			/* get port status */
2587 			(void) hubd_determine_port_status(hubd, port,
2588 			    &status, &change, PORT_CHANGE_CSC);
2589 
2590 			/* check if it is truly connected */
2591 			if (status & PORT_STATUS_CCS) {
2592 				/*
2593 				 * Now reset port and assign the device
2594 				 * its original address
2595 				 */
2596 				retry = 0;
2597 				do {
2598 					(void) hubd_reset_port(hubd, port);
2599 
2600 					/* required for ppx */
2601 					(void) hubd_enable_port(hubd, port);
2602 
2603 					if (retry) {
2604 						mutex_exit(HUBD_MUTEX(hubd));
2605 						delay(drv_usectohz(
2606 						    hubd_device_delay/2));
2607 						mutex_enter(HUBD_MUTEX(hubd));
2608 					}
2609 
2610 					rval = hubd_setdevaddr(hubd, port);
2611 					retry++;
2612 				} while ((rval != USB_SUCCESS) &&
2613 				    (retry < hubd_retry_enumerate));
2614 
2615 				hubd_setdevconfig(hubd, port);
2616 
2617 				if (hub_prev_state == USB_DEV_DISCONNECTED) {
2618 					/* post a connect event */
2619 					mutex_exit(HUBD_MUTEX(hubd));
2620 					hubd_post_event(hubd, port,
2621 					    USBA_EVENT_TAG_HOT_INSERTION);
2622 					mutex_enter(HUBD_MUTEX(hubd));
2623 				} else {
2624 					/*
2625 					 * Since we have this device connected
2626 					 * mark it reinserted to prevent
2627 					 * cleanup thread from stepping in.
2628 					 */
2629 					mutex_exit(HUBD_MUTEX(hubd));
2630 					mutex_enter(&(DEVI(ch_dip)->devi_lock));
2631 					DEVI_SET_DEVICE_REINSERTED(ch_dip);
2632 					mutex_exit(&(DEVI(ch_dip)->devi_lock));
2633 
2634 					/*
2635 					 * reopen pipes for children for
2636 					 * their DDI_RESUME
2637 					 */
2638 					rval = usba_persistent_pipe_open(
2639 					    usba_get_usba_device(ch_dip));
2640 					mutex_enter(HUBD_MUTEX(hubd));
2641 					ASSERT(rval == USB_SUCCESS);
2642 				}
2643 			} else {
2644 				/*
2645 				 * Mark this dip for deletion as the device
2646 				 * is not physically present, and schedule
2647 				 * cleanup thread upon post resume
2648 				 */
2649 				mutex_exit(HUBD_MUTEX(hubd));
2650 
2651 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
2652 				    hubd->h_log_handle,
2653 				    "hubd_restore_device_state: "
2654 				    "dip=%p on port=%d marked for cleanup",
2655 				    (void *)ch_dip, port);
2656 				mutex_enter(&(DEVI(ch_dip)->devi_lock));
2657 				DEVI_SET_DEVICE_REMOVED(ch_dip);
2658 				mutex_exit(&(DEVI(ch_dip)->devi_lock));
2659 
2660 				mutex_enter(HUBD_MUTEX(hubd));
2661 			}
2662 		} else if (ehci_root_hub) {
2663 			/* get port status */
2664 			(void) hubd_determine_port_status(hubd, port,
2665 			    &status, &change, PORT_CHANGE_CSC);
2666 
2667 			/* check if it is truly connected */
2668 			if (status & PORT_STATUS_CCS) {
2669 				/*
2670 				 * reset the port to find out if we have
2671 				 * 2.0 device connected or 1.X. A 2.0
2672 				 * device will still be seen as connected,
2673 				 * while a 1.X device will switch over to
2674 				 * the companion controller.
2675 				 */
2676 				(void) hubd_reset_port(hubd, port);
2677 
2678 				(void) hubd_determine_port_status(hubd, port,
2679 				    &status, &change, PORT_CHANGE_CSC);
2680 
2681 				if (status &
2682 				    (PORT_STATUS_CCS | PORT_STATUS_HSDA)) {
2683 					/*
2684 					 * We have a USB 2.0 device
2685 					 * connected. Power cycle this port
2686 					 * so that hotplug thread can
2687 					 * enumerate this device.
2688 					 */
2689 					(void) hubd_toggle_port(hubd, port);
2690 				} else {
2691 					USB_DPRINTF_L2(DPRINT_MASK_ATTA,
2692 					    hubd->h_log_handle,
2693 					    "hubd_restore_device_state: "
2694 					    "device on port %d switched over",
2695 					    port);
2696 				}
2697 			}
2698 
2699 		}
2700 	}
2701 
2702 
2703 	/* if the device had remote wakeup earlier, enable it again */
2704 	if (hubd->h_hubpm->hubp_wakeup_enabled) {
2705 		mutex_exit(HUBD_MUTEX(hubd));
2706 		(void) usb_handle_remote_wakeup(hubd->h_dip,
2707 		    USB_REMOTE_WAKEUP_ENABLE);
2708 		mutex_enter(HUBD_MUTEX(hubd));
2709 	}
2710 
2711 	hubd->h_dev_state = USB_DEV_ONLINE;
2712 	hubd_start_polling(hubd, 0);
2713 	(void) hubd_pm_idle_component(hubd, dip, 0);
2714 	mutex_exit(HUBD_MUTEX(hubd));
2715 }
2716 
2717 
2718 /*
2719  * hubd_cleanup:
2720  *	cleanup hubd and deallocate. this function is called for
2721  *	handling attach failures and detaching including dynamic
2722  *	reconfiguration. If called from attaching, it must clean
2723  *	up the whole thing and return success.
2724  */
2725 /*ARGSUSED*/
2726 static int
2727 hubd_cleanup(dev_info_t *dip, hubd_t *hubd)
2728 {
2729 	int		circ, rval, old_dev_state;
2730 	hub_power_t	*hubpm;
2731 #ifdef DEBUG
2732 	usb_port_t	port;
2733 #endif
2734 
2735 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2736 	    "hubd_cleanup:");
2737 
2738 	if ((hubd->h_init_state & HUBD_LOCKS_DONE) == 0) {
2739 		goto done;
2740 	}
2741 
2742 	/* ensure we are the only one active */
2743 	ndi_devi_enter(dip, &circ);
2744 
2745 	mutex_enter(HUBD_MUTEX(hubd));
2746 
2747 	/* Cleanup failure is only allowed if called from detach */
2748 	if (DEVI_IS_DETACHING(dip)) {
2749 		dev_info_t *rh_dip = hubd->h_usba_device->usb_root_hub_dip;
2750 
2751 		/*
2752 		 * We are being called from detach.
2753 		 * Fail immediately if the hotplug thread is running
2754 		 * else set the dev_state to disconnected so that
2755 		 * hotplug thread just exits without doing anything.
2756 		 */
2757 		if (hubd->h_bus_ctls || hubd->h_bus_pwr ||
2758 		    hubd->h_hotplug_thread) {
2759 			mutex_exit(HUBD_MUTEX(hubd));
2760 			ndi_devi_exit(dip, circ);
2761 
2762 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
2763 			    "hubd_cleanup: hotplug thread/bus ctl active "
2764 			    "- failing detach");
2765 
2766 			return (USB_FAILURE);
2767 		}
2768 
2769 		/*
2770 		 * if the deathrow thread is still active or about
2771 		 * to become active, fail detach
2772 		 * the roothup can only be detached if nexus drivers
2773 		 * are unloaded or explicitly offlined
2774 		 */
2775 		if (rh_dip == dip) {
2776 			if (hubd->h_cleanup_needed ||
2777 			    hubd->h_cleanup_active) {
2778 				mutex_exit(HUBD_MUTEX(hubd));
2779 				ndi_devi_exit(dip, circ);
2780 
2781 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
2782 				    hubd->h_log_handle,
2783 				    "hubd_cleanup: deathrow still active?"
2784 				    "- failing detach");
2785 
2786 				return (USB_FAILURE);
2787 			}
2788 		}
2789 	}
2790 
2791 	old_dev_state = hubd->h_dev_state;
2792 	hubd->h_dev_state = USB_DEV_DISCONNECTED;
2793 
2794 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2795 	    "hubd_cleanup: stop polling");
2796 	hubd_close_intr_pipe(hubd);
2797 
2798 	ASSERT((hubd->h_bus_ctls || hubd->h_bus_pwr ||
2799 	    hubd->h_hotplug_thread) == 0);
2800 	mutex_exit(HUBD_MUTEX(hubd));
2801 
2802 	/*
2803 	 * deallocate events, if events are still registered
2804 	 * (ie. children still attached) then we have to fail the detach
2805 	 */
2806 	if (hubd->h_ndi_event_hdl) {
2807 
2808 		rval = ndi_event_free_hdl(hubd->h_ndi_event_hdl);
2809 		if (DEVI_IS_ATTACHING(dip)) {
2810 
2811 			/* It must return success if attaching. */
2812 			ASSERT(rval == NDI_SUCCESS);
2813 
2814 		} else if (rval != NDI_SUCCESS) {
2815 
2816 			USB_DPRINTF_L2(DPRINT_MASK_ALL, hubd->h_log_handle,
2817 			    "hubd_cleanup: ndi_event_free_hdl failed");
2818 			ndi_devi_exit(dip, circ);
2819 
2820 			return (USB_FAILURE);
2821 
2822 		}
2823 	}
2824 
2825 	mutex_enter(HUBD_MUTEX(hubd));
2826 
2827 	if (hubd->h_init_state & HUBD_CHILDREN_CREATED) {
2828 #ifdef DEBUG
2829 		for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
2830 			ASSERT(hubd->h_usba_devices[port] == NULL);
2831 			ASSERT(hubd->h_children_dips[port] == NULL);
2832 		}
2833 #endif
2834 		kmem_free(hubd->h_children_dips, hubd->h_cd_list_length);
2835 		kmem_free(hubd->h_usba_devices, hubd->h_cd_list_length);
2836 	}
2837 
2838 	/*
2839 	 * Disable the event callbacks first, after this point, event
2840 	 * callbacks will never get called. Note we shouldn't hold
2841 	 * mutex while unregistering events because there may be a
2842 	 * competing event callback thread. Event callbacks are done
2843 	 * with ndi mutex held and this can cause a potential deadlock.
2844 	 * Note that cleanup can't fail after deregistration of events.
2845 	 */
2846 	if (hubd->h_init_state &  HUBD_EVENTS_REGISTERED) {
2847 		mutex_exit(HUBD_MUTEX(hubd));
2848 		usb_unregister_event_cbs(dip, &hubd_events);
2849 		hubd_unregister_cpr_callback(hubd);
2850 		mutex_enter(HUBD_MUTEX(hubd));
2851 	}
2852 
2853 	/* restore the old dev state so that device can be put into low power */
2854 	hubd->h_dev_state = old_dev_state;
2855 	hubpm = hubd->h_hubpm;
2856 
2857 	if ((hubpm) && (hubd->h_dev_state != USB_DEV_DISCONNECTED)) {
2858 		(void) hubd_pm_busy_component(hubd, dip, 0);
2859 		mutex_exit(HUBD_MUTEX(hubd));
2860 		if (hubd->h_hubpm->hubp_wakeup_enabled) {
2861 			/*
2862 			 * Bring the hub to full power before
2863 			 * issuing the disable remote wakeup command
2864 			 */
2865 			(void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
2866 
2867 			if ((rval = usb_handle_remote_wakeup(hubd->h_dip,
2868 			    USB_REMOTE_WAKEUP_DISABLE)) != USB_SUCCESS) {
2869 				USB_DPRINTF_L2(DPRINT_MASK_PM,
2870 				    hubd->h_log_handle,
2871 				    "hubd_cleanup: disable remote wakeup "
2872 				    "fails=%d", rval);
2873 			}
2874 		}
2875 
2876 		(void) pm_lower_power(hubd->h_dip, 0, USB_DEV_OS_PWR_OFF);
2877 
2878 		mutex_enter(HUBD_MUTEX(hubd));
2879 		(void) hubd_pm_idle_component(hubd, dip, 0);
2880 	}
2881 
2882 	if (hubpm) {
2883 		if (hubpm->hubp_child_pwrstate) {
2884 			kmem_free(hubpm->hubp_child_pwrstate,
2885 			    MAX_PORTS + 1);
2886 		}
2887 		kmem_free(hubpm, sizeof (hub_power_t));
2888 	}
2889 	mutex_exit(HUBD_MUTEX(hubd));
2890 
2891 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
2892 	    "hubd_cleanup: freeing space");
2893 
2894 	if (hubd->h_init_state & HUBD_HUBDI_REGISTERED) {
2895 		rval = usba_hubdi_unregister(dip);
2896 		ASSERT(rval == USB_SUCCESS);
2897 	}
2898 
2899 	if (hubd->h_init_state & HUBD_LOCKS_DONE) {
2900 		mutex_destroy(HUBD_MUTEX(hubd));
2901 		cv_destroy(&hubd->h_cv_reset_port);
2902 		cv_destroy(&hubd->h_cv_hotplug_dev);
2903 	}
2904 
2905 	ndi_devi_exit(dip, circ);
2906 
2907 	if (hubd->h_init_state & HUBD_MINOR_NODE_CREATED) {
2908 		ddi_remove_minor_node(dip, NULL);
2909 	}
2910 
2911 	if (usba_is_root_hub(dip)) {
2912 		usb_pipe_close(dip, hubd->h_default_pipe,
2913 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
2914 	}
2915 
2916 done:
2917 	if (hubd->h_ancestry_str) {
2918 		kmem_free(hubd->h_ancestry_str, HUBD_APID_NAMELEN);
2919 	}
2920 
2921 	usb_client_detach(dip, hubd->h_dev_data);
2922 
2923 	usb_free_log_hdl(hubd->h_log_handle);
2924 
2925 	if (!usba_is_root_hub(dip)) {
2926 		ddi_soft_state_free(hubd_statep, ddi_get_instance(dip));
2927 	}
2928 
2929 	ddi_prop_remove_all(dip);
2930 
2931 	return (USB_SUCCESS);
2932 }
2933 
2934 
2935 /*
2936  * hubd_determine_port_connection:
2937  *	Determine which port is in connect status but does not
2938  *	have connect status change bit set, and mark port change
2939  *	bit accordingly.
2940  *	This function is applied during hub attach time.
2941  */
2942 static usb_port_mask_t
2943 hubd_determine_port_connection(hubd_t	*hubd)
2944 {
2945 	usb_port_t	port;
2946 	usb_hub_descr_t	*hub_descr;
2947 	uint16_t	status;
2948 	uint16_t	change;
2949 	usb_port_mask_t	port_change = 0;
2950 
2951 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
2952 
2953 	hub_descr = &hubd->h_hub_descr;
2954 
2955 	for (port = 1; port <= hub_descr->bNbrPorts; port++) {
2956 
2957 		(void) hubd_determine_port_status(hubd, port, &status,
2958 		    &change, 0);
2959 
2960 		/* Check if port is in connect status */
2961 		if (!(status & PORT_STATUS_CCS)) {
2962 
2963 			continue;
2964 		}
2965 
2966 		/*
2967 		 * Check if port Connect Status Change bit has been set.
2968 		 * If already set, the connection will be handled by
2969 		 * intr polling callback, not during attach.
2970 		 */
2971 		if (change & PORT_CHANGE_CSC) {
2972 
2973 			continue;
2974 		}
2975 
2976 		port_change |= 1 << port;
2977 	}
2978 
2979 	return (port_change);
2980 }
2981 
2982 
2983 /*
2984  * hubd_check_ports:
2985  *	- get hub descriptor
2986  *	- check initial port status
2987  *	- enable power on all ports
2988  *	- enable polling on ep1
2989  */
2990 static int
2991 hubd_check_ports(hubd_t  *hubd)
2992 {
2993 	int			rval;
2994 	usb_port_mask_t		port_change = 0;
2995 	hubd_hotplug_arg_t	*arg;
2996 
2997 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
2998 
2999 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
3000 	    "hubd_check_ports: addr=0x%x", usb_get_addr(hubd->h_dip));
3001 
3002 	/*
3003 	 * First turn off all port power
3004 	 */
3005 	if ((rval = hubd_disable_all_port_power(hubd)) != USB_SUCCESS) {
3006 
3007 		/* disable whatever was enabled */
3008 		(void) hubd_disable_all_port_power(hubd);
3009 
3010 		return (rval);
3011 	}
3012 
3013 	/*
3014 	 * do not switch on immediately (instantly on root hub)
3015 	 * and allow time to settle
3016 	 */
3017 	mutex_exit(HUBD_MUTEX(hubd));
3018 	delay(drv_usectohz(10000));
3019 	mutex_enter(HUBD_MUTEX(hubd));
3020 
3021 	/*
3022 	 * enable power on all ports so we can see connects
3023 	 */
3024 	if ((rval = hubd_enable_all_port_power(hubd)) != USB_SUCCESS) {
3025 		/* disable whatever was enabled */
3026 		(void) hubd_disable_all_port_power(hubd);
3027 
3028 		return (rval);
3029 	}
3030 
3031 	/* wait at least 3 frames before accessing devices */
3032 	mutex_exit(HUBD_MUTEX(hubd));
3033 	delay(drv_usectohz(10000));
3034 	mutex_enter(HUBD_MUTEX(hubd));
3035 
3036 	/*
3037 	 * allocate arrays for saving the dips of each child per port
3038 	 *
3039 	 * ports go from 1 - n, allocate 1 more entry
3040 	 */
3041 	hubd->h_cd_list_length =
3042 	    (sizeof (dev_info_t **)) * (hubd->h_hub_descr.bNbrPorts + 1);
3043 
3044 	hubd->h_children_dips = (dev_info_t **)kmem_zalloc(
3045 	    hubd->h_cd_list_length, KM_SLEEP);
3046 	hubd->h_usba_devices = (usba_device_t **)kmem_zalloc(
3047 	    hubd->h_cd_list_length, KM_SLEEP);
3048 
3049 	hubd->h_init_state |= HUBD_CHILDREN_CREATED;
3050 
3051 	mutex_exit(HUBD_MUTEX(hubd));
3052 	arg = (hubd_hotplug_arg_t *)kmem_zalloc(
3053 	    sizeof (hubd_hotplug_arg_t), KM_SLEEP);
3054 	mutex_enter(HUBD_MUTEX(hubd));
3055 
3056 	if ((rval = hubd_open_intr_pipe(hubd)) != USB_SUCCESS) {
3057 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
3058 
3059 		return (rval);
3060 	}
3061 
3062 	hubd_start_polling(hubd, 0);
3063 
3064 	/*
3065 	 * Some hub devices, like the embedded hub in the CKS ErgoMagic
3066 	 * keyboard, may only have connection status bit set, but not
3067 	 * have connect status change bit set when a device has been
3068 	 * connected to its downstream port before the hub is enumerated.
3069 	 * Then when the hub is in enumeration, the devices connected to
3070 	 * it cannot be detected by the intr pipe and won't be enumerated.
3071 	 * We need to check such situation here and enumerate the downstream
3072 	 * devices for such hubs.
3073 	 */
3074 	port_change = hubd_determine_port_connection(hubd);
3075 
3076 	if (port_change) {
3077 		hubd_pm_busy_component(hubd, hubd->h_dip, 0);
3078 
3079 		arg->hubd = hubd;
3080 		arg->hotplug_during_attach = B_TRUE;
3081 		hubd->h_port_change |= port_change;
3082 
3083 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
3084 		    "hubd_check_ports: port change=0x%x, need to connect",
3085 		    hubd->h_port_change);
3086 
3087 		if (usb_async_req(hubd->h_dip, hubd_hotplug_thread,
3088 		    (void *)arg, 0) == USB_SUCCESS) {
3089 			hubd->h_hotplug_thread++;
3090 		} else {
3091 			/* mark this device as idle */
3092 			hubd_pm_idle_component(hubd, hubd->h_dip, 0);
3093 			kmem_free(arg, sizeof (hubd_hotplug_arg_t));
3094 		}
3095 	} else {
3096 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
3097 	}
3098 
3099 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
3100 	    "hubd_check_ports done");
3101 
3102 	return (USB_SUCCESS);
3103 }
3104 
3105 
3106 /*
3107  * hubd_get_hub_descriptor:
3108  */
3109 static int
3110 hubd_get_hub_descriptor(hubd_t *hubd)
3111 {
3112 	usb_hub_descr_t	*hub_descr = &hubd->h_hub_descr;
3113 	mblk_t		*data = NULL;
3114 	usb_cr_t	completion_reason;
3115 	usb_cb_flags_t	cb_flags;
3116 	uint16_t	length;
3117 	int		rval;
3118 
3119 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3120 	    "hubd_get_hub_descriptor:");
3121 
3122 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
3123 	ASSERT(hubd->h_default_pipe != 0);
3124 
3125 	/* get hub descriptor length first by requesting 8 bytes only */
3126 	mutex_exit(HUBD_MUTEX(hubd));
3127 
3128 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
3129 	    hubd->h_default_pipe,
3130 	    HUB_CLASS_REQ_TYPE,
3131 	    USB_REQ_GET_DESCR,		/* bRequest */
3132 	    USB_DESCR_TYPE_SETUP_HUB,	/* wValue */
3133 	    0,				/* wIndex */
3134 	    8,				/* wLength */
3135 	    &data, 0,
3136 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
3137 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
3138 		    "get hub descriptor failed: cr=%d cb_fl=0x%x rval=%d",
3139 		    completion_reason, cb_flags, rval);
3140 		freemsg(data);
3141 		mutex_enter(HUBD_MUTEX(hubd));
3142 
3143 		return (rval);
3144 	}
3145 
3146 	length = *(data->b_rptr);
3147 
3148 	if (length > 8) {
3149 		freemsg(data);
3150 		data = NULL;
3151 
3152 		/* get complete hub descriptor */
3153 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
3154 		    hubd->h_default_pipe,
3155 		    HUB_CLASS_REQ_TYPE,
3156 		    USB_REQ_GET_DESCR,		/* bRequest */
3157 		    USB_DESCR_TYPE_SETUP_HUB,	/* wValue */
3158 		    0,				/* wIndex */
3159 		    length,			/* wLength */
3160 		    &data, 0,
3161 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
3162 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
3163 			    "get hub descriptor failed: "
3164 			    "cr=%d cb_fl=0x%x rval=%d",
3165 			    completion_reason, cb_flags, rval);
3166 			freemsg(data);
3167 			mutex_enter(HUBD_MUTEX(hubd));
3168 
3169 			return (rval);
3170 		}
3171 	}
3172 
3173 	mutex_enter(HUBD_MUTEX(hubd));
3174 
3175 	/* parse the hub descriptor */
3176 	/* only 32 ports are supported at present */
3177 	ASSERT(*(data->b_rptr + 2) <= 32);
3178 	if (usb_parse_CV_descr("cccscccccc",
3179 	    data->b_rptr, MBLKL(data),
3180 	    (void *)hub_descr, sizeof (usb_hub_descr_t)) == 0) {
3181 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
3182 		    "parsing hub descriptor failed");
3183 
3184 		freemsg(data);
3185 
3186 		return (USB_FAILURE);
3187 	}
3188 
3189 	freemsg(data);
3190 
3191 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
3192 	    "rval=0x%x bNbrPorts=0x%x wHubChars=0x%x "
3193 	    "PwrOn2PwrGood=0x%x HubContrCurrent=%dmA", rval,
3194 	    hub_descr->bNbrPorts, hub_descr->wHubCharacteristics,
3195 	    hub_descr->bPwrOn2PwrGood, hub_descr->bHubContrCurrent);
3196 
3197 	if (hub_descr->bNbrPorts > MAX_PORTS) {
3198 		USB_DPRINTF_L0(DPRINT_MASK_ATTA, hubd->h_log_handle,
3199 		    "Hub driver supports max of %d ports on hub. "
3200 		    "Hence using the first %d port of %d ports available",
3201 		    MAX_PORTS, MAX_PORTS, hub_descr->bNbrPorts);
3202 
3203 		hub_descr->bNbrPorts = MAX_PORTS;
3204 	}
3205 
3206 	return (USB_SUCCESS);
3207 }
3208 
3209 
3210 /*
3211  * hubd_get_hub_status_words:
3212  */
3213 static int
3214 hubd_get_hub_status_words(hubd_t *hubd, uint16_t *status)
3215 {
3216 	usb_cr_t	completion_reason;
3217 	usb_cb_flags_t	cb_flags;
3218 	mblk_t		*data = NULL;
3219 
3220 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
3221 
3222 	mutex_exit(HUBD_MUTEX(hubd));
3223 
3224 	if (usb_pipe_sync_ctrl_xfer(hubd->h_dip, hubd->h_default_pipe,
3225 	    HUB_CLASS_REQ_TYPE,
3226 	    USB_REQ_GET_STATUS,
3227 	    0,
3228 	    0,
3229 	    GET_STATUS_LENGTH,
3230 	    &data, 0,
3231 	    &completion_reason, &cb_flags, 0) != USB_SUCCESS) {
3232 		USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
3233 		    "get hub status failed: cr=%d cb=0x%x",
3234 		    completion_reason, cb_flags);
3235 
3236 		if (data) {
3237 			freemsg(data);
3238 		}
3239 
3240 		mutex_enter(HUBD_MUTEX(hubd));
3241 
3242 		return (USB_FAILURE);
3243 	}
3244 
3245 	mutex_enter(HUBD_MUTEX(hubd));
3246 
3247 	status[0] = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
3248 	status[1] = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);
3249 
3250 	USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
3251 	    "hub status=0x%x change=0x%x", status[0], status[1]);
3252 
3253 	freemsg(data);
3254 
3255 	return (USB_SUCCESS);
3256 }
3257 
3258 
3259 /*
3260  * hubd_open_intr_pipe:
3261  *	we read all descriptors first for curiosity and then simply
3262  *	open the pipe
3263  */
3264 static int
3265 hubd_open_intr_pipe(hubd_t	*hubd)
3266 {
3267 	int			rval;
3268 
3269 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3270 	    "hubd_open_intr_pipe:");
3271 
3272 	ASSERT(hubd->h_intr_pipe_state == HUBD_INTR_PIPE_IDLE);
3273 
3274 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_OPENING;
3275 	mutex_exit(HUBD_MUTEX(hubd));
3276 
3277 	if ((rval = usb_pipe_open(hubd->h_dip,
3278 	    &hubd->h_ep1_descr, &hubd->h_pipe_policy,
3279 	    0, &hubd->h_ep1_ph)) != USB_SUCCESS) {
3280 		USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
3281 		    "open intr pipe failed (%d)", rval);
3282 
3283 		mutex_enter(HUBD_MUTEX(hubd));
3284 		hubd->h_intr_pipe_state = HUBD_INTR_PIPE_IDLE;
3285 
3286 		return (rval);
3287 	}
3288 
3289 	mutex_enter(HUBD_MUTEX(hubd));
3290 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_ACTIVE;
3291 
3292 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3293 	    "open intr pipe succeeded, ph=0x%p", (void *)hubd->h_ep1_ph);
3294 
3295 	return (USB_SUCCESS);
3296 }
3297 
3298 
3299 /*
3300  * hubd_start_polling:
3301  *	start or restart the polling
3302  */
3303 static void
3304 hubd_start_polling(hubd_t *hubd, int always)
3305 {
3306 	usb_intr_req_t	*reqp;
3307 	int			rval;
3308 	usb_pipe_state_t	pipe_state;
3309 
3310 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3311 	    "start polling: always=%d dev_state=%d pipe_state=%d\n\t"
3312 	    "thread=%d ep1_ph=0x%p",
3313 	    always, hubd->h_dev_state, hubd->h_intr_pipe_state,
3314 	    hubd->h_hotplug_thread, (void *)hubd->h_ep1_ph);
3315 
3316 	/*
3317 	 * start or restart polling on the intr pipe
3318 	 * only if hotplug thread is not running
3319 	 */
3320 	if ((always == HUBD_ALWAYS_START_POLLING) ||
3321 	    ((hubd->h_dev_state == USB_DEV_ONLINE) &&
3322 	    (hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE) &&
3323 	    (hubd->h_hotplug_thread == 0) && hubd->h_ep1_ph)) {
3324 		USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3325 		    "start polling requested");
3326 
3327 		reqp = usb_alloc_intr_req(hubd->h_dip, 0, USB_FLAGS_SLEEP);
3328 
3329 		reqp->intr_client_private = (usb_opaque_t)hubd;
3330 		reqp->intr_attributes = USB_ATTRS_SHORT_XFER_OK |
3331 		    USB_ATTRS_AUTOCLEARING;
3332 		reqp->intr_len = hubd->h_ep1_descr.wMaxPacketSize;
3333 		reqp->intr_cb = hubd_read_cb;
3334 		reqp->intr_exc_cb = hubd_exception_cb;
3335 		mutex_exit(HUBD_MUTEX(hubd));
3336 		if ((rval = usb_pipe_intr_xfer(hubd->h_ep1_ph, reqp,
3337 		    USB_FLAGS_SLEEP)) != USB_SUCCESS) {
3338 			USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
3339 			    "start polling failed, rval=%d", rval);
3340 			usb_free_intr_req(reqp);
3341 		}
3342 
3343 		rval = usb_pipe_get_state(hubd->h_ep1_ph, &pipe_state,
3344 		    USB_FLAGS_SLEEP);
3345 		if (pipe_state != USB_PIPE_STATE_ACTIVE) {
3346 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
3347 			    "intr pipe state=%d, rval=%d", pipe_state, rval);
3348 		}
3349 		USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3350 		    "start polling request 0x%p", (void *)reqp);
3351 
3352 		mutex_enter(HUBD_MUTEX(hubd));
3353 	}
3354 }
3355 
3356 
3357 /*
3358  * hubd_stop_polling
3359  *	stop polling but do not close the pipe
3360  */
3361 static void
3362 hubd_stop_polling(hubd_t *hubd)
3363 {
3364 	int			rval;
3365 	usb_pipe_state_t	pipe_state;
3366 
3367 	if (hubd->h_ep1_ph) {
3368 		USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
3369 		    "hubd_stop_polling:");
3370 		hubd->h_intr_pipe_state = HUBD_INTR_PIPE_STOPPED;
3371 		mutex_exit(HUBD_MUTEX(hubd));
3372 
3373 		usb_pipe_stop_intr_polling(hubd->h_ep1_ph, USB_FLAGS_SLEEP);
3374 		rval = usb_pipe_get_state(hubd->h_ep1_ph, &pipe_state,
3375 		    USB_FLAGS_SLEEP);
3376 
3377 		if (pipe_state != USB_PIPE_STATE_IDLE) {
3378 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
3379 			    "intr pipe state=%d, rval=%d", pipe_state, rval);
3380 		}
3381 		mutex_enter(HUBD_MUTEX(hubd));
3382 		if (hubd->h_intr_pipe_state == HUBD_INTR_PIPE_STOPPED) {
3383 			hubd->h_intr_pipe_state = HUBD_INTR_PIPE_ACTIVE;
3384 		}
3385 	}
3386 }
3387 
3388 
3389 /*
3390  * hubd_close_intr_pipe:
3391  *	close the pipe (which also stops the polling
3392  *	and wait for the hotplug thread to exit
3393  */
3394 static void
3395 hubd_close_intr_pipe(hubd_t *hubd)
3396 {
3397 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3398 	    "hubd_close_intr_pipe:");
3399 
3400 	/*
3401 	 * Now that no async operation is outstanding on pipe,
3402 	 * we can change the state to HUBD_INTR_PIPE_CLOSING
3403 	 */
3404 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_CLOSING;
3405 
3406 	ASSERT(hubd->h_hotplug_thread == 0);
3407 
3408 	if (hubd->h_ep1_ph) {
3409 		mutex_exit(HUBD_MUTEX(hubd));
3410 		usb_pipe_close(hubd->h_dip, hubd->h_ep1_ph, USB_FLAGS_SLEEP,
3411 		    NULL, NULL);
3412 		mutex_enter(HUBD_MUTEX(hubd));
3413 		hubd->h_ep1_ph = NULL;
3414 	}
3415 
3416 	hubd->h_intr_pipe_state = HUBD_INTR_PIPE_IDLE;
3417 }
3418 
3419 
3420 /*
3421  * hubd_exception_cb
3422  *	interrupt ep1 exception callback function.
3423  *	this callback executes in taskq thread context and assumes
3424  *	autoclearing
3425  */
3426 /*ARGSUSED*/
3427 static void
3428 hubd_exception_cb(usb_pipe_handle_t pipe, usb_intr_req_t *reqp)
3429 {
3430 	hubd_t		*hubd = (hubd_t *)(reqp->intr_client_private);
3431 
3432 	USB_DPRINTF_L2(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
3433 	    "hubd_exception_cb: "
3434 	    "req=0x%p cr=%d data=0x%p cb_flags=0x%x", (void *)reqp,
3435 	    reqp->intr_completion_reason, (void *)reqp->intr_data,
3436 	    reqp->intr_cb_flags);
3437 
3438 	ASSERT((reqp->intr_cb_flags & USB_CB_INTR_CONTEXT) == 0);
3439 
3440 	mutex_enter(HUBD_MUTEX(hubd));
3441 	(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
3442 
3443 	switch (reqp->intr_completion_reason) {
3444 	case USB_CR_PIPE_RESET:
3445 		/* only restart polling after autoclearing */
3446 		if ((hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE) &&
3447 		    (hubd->h_port_reset_wait == 0)) {
3448 			hubd_start_polling(hubd, 0);
3449 		}
3450 
3451 		break;
3452 	case USB_CR_DEV_NOT_RESP:
3453 	case USB_CR_STOPPED_POLLING:
3454 	case USB_CR_PIPE_CLOSING:
3455 	case USB_CR_UNSPECIFIED_ERR:
3456 		/* never restart polling on these conditions */
3457 	default:
3458 		/* for all others, wait for the autoclearing PIPE_RESET cb */
3459 
3460 		break;
3461 	}
3462 
3463 	usb_free_intr_req(reqp);
3464 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
3465 	mutex_exit(HUBD_MUTEX(hubd));
3466 }
3467 
3468 
3469 /*
3470  * helper function to convert LE bytes to a portmask
3471  */
3472 static usb_port_mask_t
3473 hubd_mblk2portmask(mblk_t *data)
3474 {
3475 	int len = min(MBLKL(data), sizeof (usb_port_mask_t));
3476 	usb_port_mask_t rval = 0;
3477 	int i;
3478 
3479 	for (i = 0; i < len; i++) {
3480 		rval |= data->b_rptr[i] << (i * 8);
3481 	}
3482 
3483 	return (rval);
3484 }
3485 
3486 
3487 /*
3488  * hubd_read_cb:
3489  *	interrupt ep1 callback function
3490  *
3491  *	the status indicates just a change on the pipe with no indication
3492  *	of what the change was
3493  *
3494  *	known conditions:
3495  *		- reset port completion
3496  *		- connect
3497  *		- disconnect
3498  *
3499  *	for handling the hotplugging, create a new thread that can do
3500  *	synchronous usba calls
3501  */
3502 static void
3503 hubd_read_cb(usb_pipe_handle_t pipe, usb_intr_req_t *reqp)
3504 {
3505 	hubd_t		*hubd = (hubd_t *)(reqp->intr_client_private);
3506 	size_t		length;
3507 	mblk_t		*data = reqp->intr_data;
3508 	int		mem_flag = 0;
3509 	hubd_hotplug_arg_t *arg;
3510 
3511 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
3512 	    "hubd_read_cb: ph=0x%p req=0x%p", (void *)pipe, (void *)reqp);
3513 
3514 	ASSERT((reqp->intr_cb_flags & USB_CB_INTR_CONTEXT) == 0);
3515 
3516 	/*
3517 	 * At present, we are not handling notification for completion of
3518 	 * asynchronous pipe reset, for which this data ptr could be NULL
3519 	 */
3520 
3521 	if (data == NULL) {
3522 		usb_free_intr_req(reqp);
3523 
3524 		return;
3525 	}
3526 
3527 	arg = (hubd_hotplug_arg_t *)kmem_zalloc(
3528 	    sizeof (hubd_hotplug_arg_t), KM_SLEEP);
3529 	mem_flag = 1;
3530 
3531 	mutex_enter(HUBD_MUTEX(hubd));
3532 
3533 	if ((hubd->h_dev_state == USB_DEV_SUSPENDED) ||
3534 	    (hubd->h_intr_pipe_state != HUBD_INTR_PIPE_ACTIVE)) {
3535 		mutex_exit(HUBD_MUTEX(hubd));
3536 		usb_free_intr_req(reqp);
3537 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
3538 
3539 		return;
3540 	}
3541 
3542 	ASSERT(hubd->h_ep1_ph == pipe);
3543 
3544 	length = MBLKL(data);
3545 
3546 	/*
3547 	 * Only look at the data and startup the hotplug thread if
3548 	 * there actually is data.
3549 	 */
3550 	if (length != 0) {
3551 		usb_port_mask_t port_change = hubd_mblk2portmask(data);
3552 
3553 		/*
3554 		 * if a port change was already reported and we are waiting for
3555 		 * reset port completion then wake up the hotplug thread which
3556 		 * should be waiting on reset port completion
3557 		 *
3558 		 * if there is disconnect event instead of reset completion, let
3559 		 * the hotplug thread figure this out
3560 		 */
3561 
3562 		/* remove the reset wait bits from the status */
3563 		hubd->h_port_change |= port_change &
3564 		    ~hubd->h_port_reset_wait;
3565 
3566 		USB_DPRINTF_L3(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
3567 		    "port change=0x%x port_reset_wait=0x%x",
3568 		    hubd->h_port_change, hubd->h_port_reset_wait);
3569 
3570 		/* there should be only one reset bit active at the time */
3571 		if (hubd->h_port_reset_wait & port_change) {
3572 			hubd->h_port_reset_wait = 0;
3573 			cv_signal(&hubd->h_cv_reset_port);
3574 		}
3575 
3576 		/*
3577 		 * kick off the thread only if device is ONLINE and it is not
3578 		 * during attaching or detaching
3579 		 */
3580 		if ((hubd->h_dev_state == USB_DEV_ONLINE) &&
3581 		    (!DEVI_IS_ATTACHING(hubd->h_dip)) &&
3582 		    (!DEVI_IS_DETACHING(hubd->h_dip)) &&
3583 		    (hubd->h_port_change) &&
3584 		    (hubd->h_hotplug_thread == 0)) {
3585 			USB_DPRINTF_L3(DPRINT_MASK_CALLBACK, hubd->h_log_handle,
3586 			    "creating hotplug thread: "
3587 			    "dev_state=%d", hubd->h_dev_state);
3588 
3589 			/*
3590 			 * Mark this device as busy. The will be marked idle
3591 			 * if the async req fails or at the exit of  hotplug
3592 			 * thread
3593 			 */
3594 			(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
3595 
3596 			arg->hubd = hubd;
3597 			arg->hotplug_during_attach = B_FALSE;
3598 
3599 			if (usb_async_req(hubd->h_dip,
3600 			    hubd_hotplug_thread,
3601 			    (void *)arg, 0) == USB_SUCCESS) {
3602 				hubd->h_hotplug_thread++;
3603 				mem_flag = 0;
3604 			} else {
3605 				/* mark this device as idle */
3606 				(void) hubd_pm_idle_component(hubd,
3607 				    hubd->h_dip, 0);
3608 			}
3609 		}
3610 	}
3611 	mutex_exit(HUBD_MUTEX(hubd));
3612 
3613 	if (mem_flag == 1) {
3614 		kmem_free(arg, sizeof (hubd_hotplug_arg_t));
3615 	}
3616 
3617 	usb_free_intr_req(reqp);
3618 }
3619 
3620 
3621 /*
3622  * hubd_hotplug_thread:
3623  *	handles resetting of port, and creating children
3624  *
3625  *	the ports to check are indicated in h_port_change bit mask
3626  * XXX note that one time poll doesn't work on the root hub
3627  */
3628 static void
3629 hubd_hotplug_thread(void *arg)
3630 {
3631 	hubd_hotplug_arg_t *hd_arg = (hubd_hotplug_arg_t *)arg;
3632 	hubd_t		*hubd = hd_arg->hubd;
3633 	boolean_t	attach_flg = hd_arg->hotplug_during_attach;
3634 	usb_port_t	port;
3635 	uint16_t	nports;
3636 	uint16_t	status, change;
3637 	hub_power_t	*hubpm;
3638 	dev_info_t	*hdip = hubd->h_dip;
3639 	dev_info_t	*rh_dip = hubd->h_usba_device->usb_root_hub_dip;
3640 	dev_info_t	*child_dip;
3641 	boolean_t	online_child = B_FALSE;
3642 	boolean_t	offline_child = B_FALSE;
3643 	boolean_t	pwrup_child = B_FALSE;
3644 	int		prh_circ, rh_circ, chld_circ, circ, old_state;
3645 
3646 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3647 	    "hubd_hotplug_thread:  started");
3648 
3649 	/*
3650 	 * Before console is init'd, we temporarily block the hotplug
3651 	 * threads so that BUS_CONFIG_ONE through hubd_bus_config() can be
3652 	 * processed quickly. This reduces the time needed for vfs_mountroot()
3653 	 * to mount the root FS from a USB disk.
3654 	 */
3655 	while (!consconfig_console_is_ready()) {
3656 		delay(drv_usectohz(10000));
3657 	}
3658 
3659 	kmem_free(arg, sizeof (hubd_hotplug_arg_t));
3660 
3661 	/*
3662 	 * if our bus power entry point is active, process the change
3663 	 * on the next notification of interrupt pipe
3664 	 */
3665 	mutex_enter(HUBD_MUTEX(hubd));
3666 	if (hubd->h_bus_pwr || (hubd->h_hotplug_thread > 1)) {
3667 		hubd->h_hotplug_thread--;
3668 
3669 		/* mark this device as idle */
3670 		hubd_pm_idle_component(hubd, hubd->h_dip, 0);
3671 		mutex_exit(HUBD_MUTEX(hubd));
3672 
3673 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3674 		    "hubd_hotplug_thread: "
3675 		    "bus_power in progress/hotplugging undesirable - quit");
3676 
3677 		return;
3678 	}
3679 	mutex_exit(HUBD_MUTEX(hubd));
3680 
3681 	ndi_hold_devi(hdip); /* so we don't race with detach */
3682 
3683 	mutex_enter(HUBD_MUTEX(hubd));
3684 
3685 	/* is this the root hub? */
3686 	if (hdip == rh_dip) {
3687 		if (hubd->h_dev_state == USB_DEV_PWRED_DOWN) {
3688 			hubpm = hubd->h_hubpm;
3689 
3690 			/* mark the root hub as full power */
3691 			hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
3692 			hubpm->hubp_time_at_full_power = ddi_get_time();
3693 			mutex_exit(HUBD_MUTEX(hubd));
3694 
3695 			USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3696 			    "hubd_hotplug_thread: call pm_power_has_changed");
3697 
3698 			(void) pm_power_has_changed(hdip, 0,
3699 			    USB_DEV_OS_FULL_PWR);
3700 
3701 			mutex_enter(HUBD_MUTEX(hubd));
3702 			hubd->h_dev_state = USB_DEV_ONLINE;
3703 		}
3704 
3705 	} else {
3706 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3707 		    "hubd_hotplug_thread: not root hub");
3708 	}
3709 
3710 	mutex_exit(HUBD_MUTEX(hubd));
3711 
3712 	/*
3713 	 * this ensures one hotplug activity per system at a time.
3714 	 * we enter the parent PCI node to have this serialization.
3715 	 * this also excludes ioctls and deathrow thread
3716 	 * (a bit crude but easier to debug)
3717 	 */
3718 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
3719 	ndi_devi_enter(rh_dip, &rh_circ);
3720 
3721 	/* exclude other threads */
3722 	ndi_devi_enter(hdip, &circ);
3723 	mutex_enter(HUBD_MUTEX(hubd));
3724 
3725 	ASSERT(hubd->h_intr_pipe_state == HUBD_INTR_PIPE_ACTIVE);
3726 
3727 	nports = hubd->h_hub_descr.bNbrPorts;
3728 
3729 	hubd_stop_polling(hubd);
3730 
3731 	while ((hubd->h_dev_state == USB_DEV_ONLINE) &&
3732 	    (hubd->h_port_change)) {
3733 		/*
3734 		 * The 0th bit is the hub status change bit.
3735 		 * handle loss of local power here
3736 		 */
3737 		if (hubd->h_port_change & HUB_CHANGE_STATUS) {
3738 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3739 			    "hubd_hotplug_thread: hub status change!");
3740 
3741 			/*
3742 			 * This should be handled properly.  For now,
3743 			 * mask off the bit.
3744 			 */
3745 			hubd->h_port_change &= ~HUB_CHANGE_STATUS;
3746 
3747 			/*
3748 			 * check and ack hub status
3749 			 * this causes stall conditions
3750 			 * when local power is removed
3751 			 */
3752 			(void) hubd_get_hub_status(hubd);
3753 		}
3754 
3755 		for (port = 1; port <= nports; port++) {
3756 			usb_port_mask_t port_mask;
3757 			boolean_t was_connected;
3758 
3759 			port_mask = 1 << port;
3760 			was_connected =
3761 			    (hubd->h_port_state[port] & PORT_STATUS_CCS) &&
3762 			    (hubd->h_children_dips[port]);
3763 
3764 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3765 			    "hubd_hotplug_thread: "
3766 			    "port %d mask=0x%x change=0x%x connected=0x%x",
3767 			    port, port_mask, hubd->h_port_change,
3768 			    was_connected);
3769 
3770 			/*
3771 			 * is this a port connection that changed?
3772 			 */
3773 			if ((hubd->h_port_change & port_mask) == 0) {
3774 
3775 				continue;
3776 			}
3777 			hubd->h_port_change &= ~port_mask;
3778 
3779 			/* ack all changes */
3780 			(void) hubd_determine_port_status(hubd, port,
3781 			    &status, &change, HUBD_ACK_ALL_CHANGES);
3782 
3783 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3784 			    "handle port %d:\n\t"
3785 			    "new status=0x%x change=0x%x was_conn=0x%x ",
3786 			    port, status, change, was_connected);
3787 
3788 			/* Recover a disabled port */
3789 			if (change & PORT_CHANGE_PESC) {
3790 				USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
3791 				    hubd->h_log_handle,
3792 				    "port%d Disabled - "
3793 				    "status=0x%x, change=0x%x",
3794 				    port, status, change);
3795 
3796 				/*
3797 				 * if the port was connected and is still
3798 				 * connected, recover the port
3799 				 */
3800 				if (was_connected && (status &
3801 				    PORT_STATUS_CCS)) {
3802 					online_child |=
3803 					    (hubd_recover_disabled_port(hubd,
3804 					    port) == USB_SUCCESS);
3805 				}
3806 			}
3807 
3808 			/*
3809 			 * Now check what changed on the port
3810 			 */
3811 			if ((change & PORT_CHANGE_CSC) || attach_flg) {
3812 				if ((status & PORT_STATUS_CCS) &&
3813 				    (!was_connected)) {
3814 					/* new device plugged in */
3815 					online_child |=
3816 					    (hubd_handle_port_connect(hubd,
3817 					    port) == USB_SUCCESS);
3818 
3819 				} else if ((status & PORT_STATUS_CCS) &&
3820 				    was_connected) {
3821 					/*
3822 					 * In this case we can never be sure
3823 					 * if the device indeed got hotplugged
3824 					 * or the hub is falsely reporting the
3825 					 * change.
3826 					 */
3827 					child_dip = hubd->h_children_dips[port];
3828 
3829 					mutex_exit(HUBD_MUTEX(hubd));
3830 					/*
3831 					 * this ensures we do not race with
3832 					 * other threads which are detaching
3833 					 * the child driver at the same time.
3834 					 */
3835 					ndi_devi_enter(child_dip, &chld_circ);
3836 					/*
3837 					 * Now check if the driver remains
3838 					 * attached.
3839 					 */
3840 					if (i_ddi_devi_attached(child_dip)) {
3841 						/*
3842 						 * first post a disconnect event
3843 						 * to the child.
3844 						 */
3845 						hubd_post_event(hubd, port,
3846 						    USBA_EVENT_TAG_HOT_REMOVAL);
3847 						mutex_enter(HUBD_MUTEX(hubd));
3848 
3849 						/*
3850 						 * then reset the port and
3851 						 * recover the device
3852 						 */
3853 						online_child |=
3854 						    (hubd_handle_port_connect(
3855 						    hubd, port) == USB_SUCCESS);
3856 
3857 						mutex_exit(HUBD_MUTEX(hubd));
3858 					}
3859 
3860 					ndi_devi_exit(child_dip, chld_circ);
3861 					mutex_enter(HUBD_MUTEX(hubd));
3862 				} else if (was_connected) {
3863 					/* this is a disconnect */
3864 					mutex_exit(HUBD_MUTEX(hubd));
3865 					hubd_post_event(hubd, port,
3866 					    USBA_EVENT_TAG_HOT_REMOVAL);
3867 					mutex_enter(HUBD_MUTEX(hubd));
3868 
3869 					offline_child = B_TRUE;
3870 				}
3871 			}
3872 
3873 			/*
3874 			 * Check if any port is coming out of suspend
3875 			 */
3876 			if (change & PORT_CHANGE_PSSC) {
3877 				/* a resuming device could have disconnected */
3878 				if (was_connected &&
3879 				    hubd->h_children_dips[port]) {
3880 
3881 					/* device on this port resuming */
3882 					dev_info_t *dip;
3883 
3884 					dip = hubd->h_children_dips[port];
3885 
3886 					/*
3887 					 * Don't raise power on detaching child
3888 					 */
3889 					if (!DEVI_IS_DETACHING(dip)) {
3890 						/*
3891 						 * As this child is not
3892 						 * detaching, we set this
3893 						 * flag, causing bus_ctls
3894 						 * to stall detach till
3895 						 * pm_raise_power returns
3896 						 * and flag it for a deferred
3897 						 * raise_power.
3898 						 *
3899 						 * pm_raise_power is deferred
3900 						 * because we need to release
3901 						 * the locks first.
3902 						 */
3903 						hubd->h_port_state[port] |=
3904 						    HUBD_CHILD_RAISE_POWER;
3905 						pwrup_child = B_TRUE;
3906 						mutex_exit(HUBD_MUTEX(hubd));
3907 
3908 						/*
3909 						 * make sure that child
3910 						 * doesn't disappear
3911 						 */
3912 						ndi_hold_devi(dip);
3913 
3914 						mutex_enter(HUBD_MUTEX(hubd));
3915 					}
3916 				}
3917 			}
3918 
3919 			/*
3920 			 * Check if the port is over-current
3921 			 */
3922 			if (change & PORT_CHANGE_OCIC) {
3923 				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
3924 				    hubd->h_log_handle,
3925 				    "Port%d in over current condition, "
3926 				    "please check the attached device to "
3927 				    "clear the condition. The system will "
3928 				    "try to recover the port, but if not "
3929 				    "successful, you need to re-connect "
3930 				    "the hub or reboot the system to bring "
3931 				    "the port back to work", port);
3932 
3933 				if (!(status & PORT_STATUS_PPS)) {
3934 					/*
3935 					 * Try to enable port power, but
3936 					 * possibly fail. Ignore failure
3937 					 */
3938 					(void) hubd_enable_port_power(hubd,
3939 					    port);
3940 
3941 					/*
3942 					 * Delay some time to avoid
3943 					 * over-current event to happen
3944 					 * too frequently in some cases
3945 					 */
3946 					mutex_exit(HUBD_MUTEX(hubd));
3947 					delay(drv_usectohz(500000));
3948 					mutex_enter(HUBD_MUTEX(hubd));
3949 				}
3950 			}
3951 		}
3952 	}
3953 
3954 	/* release locks so we can do a devfs_clean */
3955 	mutex_exit(HUBD_MUTEX(hubd));
3956 
3957 	/* delete cached dv_node's but drop locks first */
3958 	ndi_devi_exit(hdip, circ);
3959 	ndi_devi_exit(rh_dip, rh_circ);
3960 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
3961 
3962 	(void) devfs_clean(rh_dip, NULL, 0);
3963 
3964 	/* now check if any children need onlining */
3965 	if (online_child) {
3966 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3967 		    "hubd_hotplug_thread: onlining children");
3968 
3969 		(void) ndi_devi_online(hubd->h_dip, 0);
3970 	}
3971 
3972 	/* now check if any disconnected devices need to be cleaned up */
3973 	if (offline_child) {
3974 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
3975 		    "hubd_hotplug_thread: scheduling cleanup");
3976 
3977 		hubd_schedule_cleanup(hubd->h_usba_device->usb_root_hub_dip);
3978 	}
3979 
3980 	mutex_enter(HUBD_MUTEX(hubd));
3981 
3982 	/* now raise power on the children that have woken up */
3983 	if (pwrup_child) {
3984 		old_state = hubd->h_dev_state;
3985 		hubd->h_dev_state = USB_DEV_HUB_CHILD_PWRLVL;
3986 		for (port = 1; port <= nports; port++) {
3987 			if (hubd->h_port_state[port] & HUBD_CHILD_RAISE_POWER) {
3988 				dev_info_t *dip = hubd->h_children_dips[port];
3989 
3990 				mutex_exit(HUBD_MUTEX(hubd));
3991 
3992 				/* Get the device to full power */
3993 				(void) pm_busy_component(dip, 0);
3994 				(void) pm_raise_power(dip, 0,
3995 				    USB_DEV_OS_FULL_PWR);
3996 				(void) pm_idle_component(dip, 0);
3997 
3998 				/* release the hold on the child */
3999 				ndi_rele_devi(dip);
4000 				mutex_enter(HUBD_MUTEX(hubd));
4001 				hubd->h_port_state[port] &=
4002 				    ~HUBD_CHILD_RAISE_POWER;
4003 			}
4004 		}
4005 		/*
4006 		 * make sure that we don't accidentally
4007 		 * over write the disconnect state
4008 		 */
4009 		if (hubd->h_dev_state == USB_DEV_HUB_CHILD_PWRLVL) {
4010 			hubd->h_dev_state = old_state;
4011 		}
4012 	}
4013 
4014 	/*
4015 	 * start polling can immediately kick off read callback
4016 	 * we need to set the h_hotplug_thread to 0 so that
4017 	 * the callback is not dropped
4018 	 *
4019 	 * if there is device during reset, still stop polling to avoid the
4020 	 * read callback interrupting the reset, the polling will be started
4021 	 * in hubd_reset_thread.
4022 	 */
4023 	for (port = 1; port <= MAX_PORTS; port++) {
4024 		if (hubd->h_reset_port[port]) {
4025 
4026 			break;
4027 		}
4028 	}
4029 	if (port > MAX_PORTS) {
4030 		hubd_start_polling(hubd, HUBD_ALWAYS_START_POLLING);
4031 	}
4032 
4033 	/*
4034 	 * Earlier we would set the h_hotplug_thread = 0 before
4035 	 * polling was restarted  so that
4036 	 * if there is any root hub status change interrupt, we can still kick
4037 	 * off the hotplug thread. This was valid when this interrupt was
4038 	 * delivered in hardware, and only ONE interrupt would be delivered.
4039 	 * Now that we poll on the root hub looking for status change in
4040 	 * software, this assignment is no longer required.
4041 	 */
4042 	hubd->h_hotplug_thread--;
4043 
4044 	/* mark this device as idle */
4045 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
4046 
4047 	cv_broadcast(&hubd->h_cv_hotplug_dev);
4048 
4049 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4050 	    "hubd_hotplug_thread: exit");
4051 
4052 	mutex_exit(HUBD_MUTEX(hubd));
4053 
4054 	ndi_rele_devi(hdip);
4055 }
4056 
4057 
4058 /*
4059  * hubd_handle_port_connect:
4060  *	Transition a port from Disabled to Enabled.  Ensure that the
4061  *	port is in the correct state before attempting to
4062  *	access the device.
4063  */
4064 static int
4065 hubd_handle_port_connect(hubd_t *hubd, usb_port_t port)
4066 {
4067 	int			rval;
4068 	int			retry;
4069 	long			time_delay;
4070 	long			settling_time;
4071 	uint16_t		status;
4072 	uint16_t		change;
4073 	usb_addr_t		hubd_usb_addr;
4074 	usba_device_t		*usba_device;
4075 	usb_port_status_t	port_status = 0;
4076 	usb_port_status_t	hub_port_status = 0;
4077 
4078 	/* Get the hub address and port status */
4079 	usba_device = hubd->h_usba_device;
4080 	mutex_enter(&usba_device->usb_mutex);
4081 	hubd_usb_addr = usba_device->usb_addr;
4082 	hub_port_status = usba_device->usb_port_status;
4083 	mutex_exit(&usba_device->usb_mutex);
4084 
4085 	/*
4086 	 * If a device is connected, transition the
4087 	 * port from Disabled to the Enabled state.
4088 	 * The device will receive downstream packets
4089 	 * in the Enabled state.
4090 	 *
4091 	 * reset port and wait for the hub to report
4092 	 * completion
4093 	 */
4094 	change = status = 0;
4095 
4096 	/*
4097 	 * According to section 9.1.2 of USB 2.0 spec, the host should
4098 	 * wait for atleast 100ms to allow completion of an insertion
4099 	 * process and for power at the device to become stable.
4100 	 * We wait for 200 ms
4101 	 */
4102 	settling_time = drv_usectohz(hubd_device_delay / 5);
4103 	mutex_exit(HUBD_MUTEX(hubd));
4104 	delay(settling_time);
4105 	mutex_enter(HUBD_MUTEX(hubd));
4106 
4107 	/* calculate 600 ms delay time */
4108 	time_delay = (6 * drv_usectohz(hubd_device_delay)) / 10;
4109 
4110 	for (retry = 0; (hubd->h_dev_state == USB_DEV_ONLINE) &&
4111 	    (retry < hubd_retry_enumerate); retry++) {
4112 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4113 		    "resetting port%d, retry=%d", port, retry);
4114 
4115 		if ((rval = hubd_reset_port(hubd, port)) != USB_SUCCESS) {
4116 			(void) hubd_determine_port_status(hubd,
4117 			    port, &status, &change, 0);
4118 
4119 			/* continue only if port is still connected */
4120 			if (status & PORT_STATUS_CCS) {
4121 				continue;
4122 			}
4123 
4124 			/* carry on regardless */
4125 		}
4126 
4127 		/*
4128 		 * according to USB 2.0 spec section 11.24.2.7.1.2
4129 		 * at the end of port reset, the hub enables the port.
4130 		 * But for some strange reasons, uhci port remains disabled.
4131 		 * And because the port remains disabled for the settling
4132 		 * time below, the device connected to the port gets wedged
4133 		 * - fails to enumerate (device not responding)
4134 		 * Hence, we enable it here immediately and later again after
4135 		 * the delay
4136 		 */
4137 		(void) hubd_enable_port(hubd, port);
4138 
4139 		/* we skip this delay in the first iteration */
4140 		if (retry) {
4141 			/*
4142 			 * delay for device to signal disconnect/connect so
4143 			 * that hub properly recognizes the speed of the device
4144 			 */
4145 			mutex_exit(HUBD_MUTEX(hubd));
4146 			delay(settling_time);
4147 			mutex_enter(HUBD_MUTEX(hubd));
4148 
4149 			/*
4150 			 * When a low speed device is connected to any port of
4151 			 * PPX it has to be explicitly enabled
4152 			 * Also, if device intentionally signals
4153 			 * disconnect/connect, it will disable the port.
4154 			 * So enable it again.
4155 			 */
4156 			(void) hubd_enable_port(hubd, port);
4157 		}
4158 
4159 		if ((rval = hubd_determine_port_status(hubd, port, &status,
4160 		    &change, 0)) != USB_SUCCESS) {
4161 
4162 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4163 			    "getting status failed (%d)", rval);
4164 
4165 			(void) hubd_disable_port(hubd, port);
4166 
4167 			continue;
4168 		}
4169 
4170 		if (status & PORT_STATUS_POCI) {
4171 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4172 			    "port %d overcurrent", port);
4173 
4174 			(void) hubd_disable_port(hubd, port);
4175 
4176 			/* ack changes */
4177 			(void) hubd_determine_port_status(hubd,
4178 			    port, &status, &change, PORT_CHANGE_OCIC);
4179 
4180 			continue;
4181 		}
4182 
4183 		/* is status really OK? */
4184 		if ((status & PORT_STATUS_OK) != PORT_STATUS_OK) {
4185 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4186 			    "port %d status (0x%x) not OK on retry %d",
4187 			    port, status, retry);
4188 
4189 			/* check if we still have the connection */
4190 			if (!(status & PORT_STATUS_CCS)) {
4191 				/* lost connection, set exit condition */
4192 				retry = hubd_retry_enumerate;
4193 
4194 				break;
4195 			}
4196 		} else {
4197 			/*
4198 			 * Determine if the device is high or full
4199 			 * or low speed.
4200 			 */
4201 			if (status & PORT_STATUS_LSDA) {
4202 				port_status = USBA_LOW_SPEED_DEV;
4203 			} else if (status & PORT_STATUS_HSDA) {
4204 				port_status = USBA_HIGH_SPEED_DEV;
4205 			} else {
4206 				port_status = USBA_FULL_SPEED_DEV;
4207 			}
4208 
4209 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4210 			    "creating child port%d, status=0x%x "
4211 			    "port status=0x%x",
4212 			    port, status, port_status);
4213 
4214 			/*
4215 			 * if the child already exists, set addrs and config
4216 			 * to the device post connect event to the child
4217 			 */
4218 			if (hubd->h_children_dips[port]) {
4219 				/* set addrs to this device */
4220 				rval = hubd_setdevaddr(hubd, port);
4221 
4222 				/*
4223 				 * This delay is important for the CATC hub
4224 				 * to enumerate. But, avoid delay in the first
4225 				 * iteration
4226 				 */
4227 				if (retry) {
4228 					mutex_exit(HUBD_MUTEX(hubd));
4229 					delay(drv_usectohz(
4230 					    hubd_device_delay/100));
4231 					mutex_enter(HUBD_MUTEX(hubd));
4232 				}
4233 
4234 				if (rval == USB_SUCCESS) {
4235 					/*
4236 					 * if the port is resetting, check if
4237 					 * device's descriptors have changed.
4238 					 */
4239 					if ((hubd->h_reset_port[port]) &&
4240 					    (hubd_check_same_device(hubd,
4241 					    port) != USB_SUCCESS)) {
4242 						retry = hubd_retry_enumerate;
4243 
4244 						break;
4245 					}
4246 
4247 					/*
4248 					 * set the default config for
4249 					 * this device
4250 					 */
4251 					hubd_setdevconfig(hubd, port);
4252 
4253 					/*
4254 					 * if we are doing Default reset, do
4255 					 * not post reconnect event since we
4256 					 * don't know where reset function is
4257 					 * called.
4258 					 */
4259 					if (hubd->h_reset_port[port]) {
4260 
4261 						return (USB_SUCCESS);
4262 					}
4263 
4264 					/*
4265 					 * indicate to the child that
4266 					 * it is online again
4267 					 */
4268 					mutex_exit(HUBD_MUTEX(hubd));
4269 					hubd_post_event(hubd, port,
4270 					    USBA_EVENT_TAG_HOT_INSERTION);
4271 					mutex_enter(HUBD_MUTEX(hubd));
4272 
4273 					return (USB_SUCCESS);
4274 				}
4275 			} else {
4276 				/*
4277 				 * We need to release access here
4278 				 * so that busctls on other ports can
4279 				 * continue and don't cause a deadlock
4280 				 * when busctl and removal of prom node
4281 				 * takes concurrently. This also ensures
4282 				 * busctls for attach of successfully
4283 				 * enumerated devices on other ports can
4284 				 * continue concurrently with the process
4285 				 * of enumerating the new devices. This
4286 				 * reduces the overall boot time of the system.
4287 				 */
4288 				rval = hubd_create_child(hubd->h_dip,
4289 				    hubd,
4290 				    hubd->h_usba_device,
4291 				    port_status, port,
4292 				    retry);
4293 				if (rval == USB_SUCCESS) {
4294 					usba_update_hotplug_stats(hubd->h_dip,
4295 					    USBA_TOTAL_HOTPLUG_SUCCESS|
4296 					    USBA_HOTPLUG_SUCCESS);
4297 					hubd->h_total_hotplug_success++;
4298 
4299 					if (retry > 0) {
4300 						USB_DPRINTF_L2(
4301 						    DPRINT_MASK_HOTPLUG,
4302 						    hubd->h_log_handle,
4303 						    "device on port %d "
4304 						    "enumerated after %d %s",
4305 						    port, retry,
4306 						    (retry > 1) ? "retries" :
4307 						    "retry");
4308 
4309 					}
4310 
4311 					return (USB_SUCCESS);
4312 				}
4313 			}
4314 		}
4315 
4316 		/* wait a while until it settles? */
4317 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4318 		    "disabling port %d again", port);
4319 
4320 		(void) hubd_disable_port(hubd, port);
4321 		if (retry) {
4322 			mutex_exit(HUBD_MUTEX(hubd));
4323 			delay(time_delay);
4324 			mutex_enter(HUBD_MUTEX(hubd));
4325 		}
4326 
4327 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4328 		    "retrying on port %d", port);
4329 	}
4330 
4331 	if (retry >= hubd_retry_enumerate) {
4332 		/*
4333 		 * If it is a High Speed Root Hub and connected device
4334 		 * Is a Low/Full Speed, it will be handled by USB 1.1
4335 		 * Host Controller. In this case, USB 2.0 Host Controller
4336 		 * will transfer the ownership of this port to USB 1.1
4337 		 * Host Controller. So don't display any error message on
4338 		 * the console.
4339 		 */
4340 		if ((hubd_usb_addr == ROOT_HUB_ADDR) &&
4341 		    (hub_port_status == USBA_HIGH_SPEED_DEV) &&
4342 		    (port_status != USBA_HIGH_SPEED_DEV)) {
4343 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
4344 			    hubd->h_log_handle,
4345 			    "hubd_handle_port_connect: Low/Full speed "
4346 			    "device is connected to High Speed root hub");
4347 		} else {
4348 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
4349 			    hubd->h_log_handle,
4350 			    "Connecting device on port %d failed", port);
4351 		}
4352 
4353 		(void) hubd_disable_port(hubd, port);
4354 		usba_update_hotplug_stats(hubd->h_dip,
4355 		    USBA_TOTAL_HOTPLUG_FAILURE|USBA_HOTPLUG_FAILURE);
4356 		hubd->h_total_hotplug_failure++;
4357 
4358 		/*
4359 		 * the port should be automagically
4360 		 * disabled but just in case, we do
4361 		 * it here
4362 		 */
4363 		(void) hubd_disable_port(hubd, port);
4364 
4365 		/* ack all changes because we disabled this port */
4366 		(void) hubd_determine_port_status(hubd,
4367 		    port, &status, &change, HUBD_ACK_ALL_CHANGES);
4368 
4369 	}
4370 
4371 	return (USB_FAILURE);
4372 }
4373 
4374 
4375 /*
4376  * hubd_get_hub_status:
4377  */
4378 static int
4379 hubd_get_hub_status(hubd_t *hubd)
4380 {
4381 	int		rval;
4382 	usb_cr_t	completion_reason;
4383 	usb_cb_flags_t	cb_flags;
4384 	uint16_t	stword[2];
4385 	uint16_t	status;
4386 	uint16_t	change;
4387 	usb_cfg_descr_t	cfg_descr;
4388 	size_t		cfg_length;
4389 	uchar_t		*usb_cfg;
4390 	uint8_t		MaxPower;
4391 	usb_hub_descr_t	*hub_descr;
4392 	usb_port_t	port;
4393 
4394 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4395 	    "hubd_get_hub_status:");
4396 
4397 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
4398 
4399 	if ((hubd_get_hub_status_words(hubd, stword)) != USB_SUCCESS) {
4400 
4401 		return (USB_FAILURE);
4402 	}
4403 	status = stword[0];
4404 	change = stword[1];
4405 
4406 	mutex_exit(HUBD_MUTEX(hubd));
4407 
4408 	/* Obtain the raw configuration descriptor */
4409 	usb_cfg = usb_get_raw_cfg_data(hubd->h_dip, &cfg_length);
4410 
4411 	/* get configuration descriptor */
4412 	rval = usb_parse_cfg_descr(usb_cfg, cfg_length,
4413 	    &cfg_descr, USB_CFG_DESCR_SIZE);
4414 
4415 	if (rval != USB_CFG_DESCR_SIZE) {
4416 
4417 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4418 		    "get hub configuration descriptor failed.");
4419 
4420 		mutex_enter(HUBD_MUTEX(hubd));
4421 
4422 		return (USB_FAILURE);
4423 	} else {
4424 		MaxPower = cfg_descr.bMaxPower;
4425 	}
4426 
4427 	/* check if local power status changed. */
4428 	if (change & C_HUB_LOCAL_POWER_STATUS) {
4429 
4430 		/*
4431 		 * local power has been lost, check the maximum
4432 		 * power consumption of current configuration.
4433 		 * see USB2.0 spec Table 11-12.
4434 		 */
4435 		if (status & HUB_LOCAL_POWER_STATUS) {
4436 
4437 			if (MaxPower == 0) {
4438 
4439 				/*
4440 				 * Self-powered only hub. Because it could
4441 				 * not draw any power from USB bus.
4442 				 * It can't work well on this condition.
4443 				 */
4444 				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
4445 				    hubd->h_log_handle,
4446 				    "local power has been lost, "
4447 				    "please disconnect hub");
4448 			} else {
4449 
4450 				/*
4451 				 * Bus-powered only or self/bus-powered hub.
4452 				 */
4453 				USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG,
4454 				    hubd->h_log_handle,
4455 				    "local power has been lost,"
4456 				    "the hub could draw %d"
4457 				    " mA power from the USB bus.",
4458 				    2*MaxPower);
4459 			}
4460 
4461 		}
4462 
4463 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4464 		    "clearing feature C_HUB_LOCAL_POWER ");
4465 
4466 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4467 		    hubd->h_default_pipe,
4468 		    HUB_HANDLE_HUB_FEATURE_TYPE,
4469 		    USB_REQ_CLEAR_FEATURE,
4470 		    CFS_C_HUB_LOCAL_POWER,
4471 		    0,
4472 		    0,
4473 		    NULL, 0,
4474 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4475 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
4476 			    hubd->h_log_handle,
4477 			    "clear feature C_HUB_LOCAL_POWER "
4478 			    "failed (%d 0x%x %d)",
4479 			    rval, completion_reason, cb_flags);
4480 		}
4481 
4482 	}
4483 
4484 	if (change & C_HUB_OVER_CURRENT) {
4485 
4486 		if (status & HUB_OVER_CURRENT) {
4487 
4488 			if (usba_is_root_hub(hubd->h_dip)) {
4489 				/*
4490 				 * The root hub should be automatically
4491 				 * recovered when over-current condition is
4492 				 * cleared. But there might be exception and
4493 				 * need user interaction to recover.
4494 				 */
4495 				USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
4496 				    hubd->h_log_handle,
4497 				    "Root hub over current condition, "
4498 				    "please check your system to clear the "
4499 				    "condition as soon as possible. And you "
4500 				    "may need to reboot the system to bring "
4501 				    "the root hub back to work if it cannot "
4502 				    "recover automatically");
4503 			} else {
4504 				/*
4505 				 * The driver would try to recover port power
4506 				 * on over current condition. When the recovery
4507 				 * fails, the user may still need to offline
4508 				 * this hub in order to recover.
4509 				 * The port power is automatically disabled,
4510 				 * so we won't see disconnects.
4511 				 */
4512 				USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
4513 				    hubd->h_log_handle,
4514 				    "Hub global over current condition, "
4515 				    "please disconnect the devices connected "
4516 				    "to the hub to clear the condition. And "
4517 				    "you may need to re-connect the hub if "
4518 				    "the ports do not work");
4519 			}
4520 		}
4521 
4522 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
4523 		    "clearing feature C_HUB_OVER_CURRENT");
4524 
4525 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4526 		    hubd->h_default_pipe,
4527 		    HUB_HANDLE_HUB_FEATURE_TYPE,
4528 		    USB_REQ_CLEAR_FEATURE,
4529 		    CFS_C_HUB_OVER_CURRENT,
4530 		    0,
4531 		    0,
4532 		    NULL, 0,
4533 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4534 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
4535 			    hubd->h_log_handle,
4536 			    "clear feature C_HUB_OVER_CURRENT "
4537 			    "failed (%d 0x%x %d)",
4538 			    rval, completion_reason, cb_flags);
4539 		}
4540 
4541 		/*
4542 		 * Try to recover all port power if they are turned off.
4543 		 * Don't do this for root hub, but rely on the root hub
4544 		 * to recover itself.
4545 		 */
4546 		if (!usba_is_root_hub(hubd->h_dip)) {
4547 
4548 			mutex_enter(HUBD_MUTEX(hubd));
4549 
4550 			/*
4551 			 * Only check the power status of the 1st port
4552 			 * since all port power status should be the same.
4553 			 */
4554 			(void) hubd_determine_port_status(hubd, 1, &status,
4555 			    &change, 0);
4556 
4557 			if (status & PORT_STATUS_PPS) {
4558 
4559 				return (USB_SUCCESS);
4560 			}
4561 
4562 			hub_descr = &hubd->h_hub_descr;
4563 
4564 			for (port = 1; port <= hub_descr->bNbrPorts;
4565 			    port++) {
4566 
4567 				(void) hubd_enable_port_power(hubd, port);
4568 			}
4569 
4570 			mutex_exit(HUBD_MUTEX(hubd));
4571 
4572 			/*
4573 			 * Delay some time to avoid over-current event
4574 			 * to happen too frequently in some cases
4575 			 */
4576 			delay(drv_usectohz(500000));
4577 		}
4578 	}
4579 
4580 	mutex_enter(HUBD_MUTEX(hubd));
4581 
4582 	return (USB_SUCCESS);
4583 }
4584 
4585 
4586 /*
4587  * hubd_reset_port:
4588  */
4589 static int
4590 hubd_reset_port(hubd_t *hubd, usb_port_t port)
4591 {
4592 	int	rval;
4593 	usb_cr_t completion_reason;
4594 	usb_cb_flags_t cb_flags;
4595 	usb_port_mask_t port_mask = 1 << port;
4596 	mblk_t	*data;
4597 	uint16_t status;
4598 	uint16_t change;
4599 	int	i;
4600 	clock_t	delta;
4601 
4602 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
4603 	    "hubd_reset_port: port=%d", port);
4604 
4605 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
4606 
4607 	hubd->h_port_reset_wait |= port_mask;
4608 
4609 	mutex_exit(HUBD_MUTEX(hubd));
4610 
4611 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4612 	    hubd->h_default_pipe,
4613 	    HUB_HANDLE_PORT_FEATURE_TYPE,
4614 	    USB_REQ_SET_FEATURE,
4615 	    CFS_PORT_RESET,
4616 	    port,
4617 	    0,
4618 	    NULL, 0,
4619 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4620 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4621 		    "reset port%d failed (%d 0x%x %d)",
4622 		    port, completion_reason, cb_flags, rval);
4623 
4624 		mutex_enter(HUBD_MUTEX(hubd));
4625 
4626 		return (USB_FAILURE);
4627 	}
4628 
4629 	mutex_enter(HUBD_MUTEX(hubd));
4630 
4631 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
4632 	    "waiting on cv for reset completion");
4633 
4634 	/*
4635 	 * wait for port status change event
4636 	 */
4637 	delta = drv_usectohz(hubd_device_delay / 10);
4638 	for (i = 0; i < hubd_retry_enumerate; i++) {
4639 		/*
4640 		 * start polling ep1 for receiving notification on
4641 		 * reset completion
4642 		 */
4643 		hubd_start_polling(hubd, HUBD_ALWAYS_START_POLLING);
4644 
4645 		/*
4646 		 * sleep a max of 100ms for reset completion
4647 		 * notification to be received
4648 		 */
4649 		if (hubd->h_port_reset_wait & port_mask) {
4650 			rval = cv_reltimedwait(&hubd->h_cv_reset_port,
4651 			    &hubd->h_mutex, delta, TR_CLOCK_TICK);
4652 			if ((rval <= 0) &&
4653 			    (hubd->h_port_reset_wait & port_mask)) {
4654 				/* we got woken up because of a timeout */
4655 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
4656 				    hubd->h_log_handle,
4657 				    "timeout: reset port=%d failed", port);
4658 
4659 				hubd->h_port_reset_wait &=  ~port_mask;
4660 
4661 				hubd_stop_polling(hubd);
4662 
4663 				return (USB_FAILURE);
4664 			}
4665 		}
4666 
4667 		USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
4668 		    "reset completion received");
4669 
4670 		hubd_stop_polling(hubd);
4671 
4672 		data = NULL;
4673 
4674 		/* check status to determine whether reset completed */
4675 		mutex_exit(HUBD_MUTEX(hubd));
4676 		if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4677 		    hubd->h_default_pipe,
4678 		    HUB_GET_PORT_STATUS_TYPE,
4679 		    USB_REQ_GET_STATUS,
4680 		    0,
4681 		    port,
4682 		    GET_STATUS_LENGTH,
4683 		    &data, 0,
4684 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4685 			USB_DPRINTF_L2(DPRINT_MASK_PORT,
4686 			    hubd->h_log_handle,
4687 			    "get status port%d failed (%d 0x%x %d)",
4688 			    port, completion_reason, cb_flags, rval);
4689 
4690 			if (data) {
4691 				freemsg(data);
4692 				data = NULL;
4693 			}
4694 			mutex_enter(HUBD_MUTEX(hubd));
4695 
4696 			continue;
4697 		}
4698 
4699 		status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
4700 		change = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);
4701 
4702 		freemsg(data);
4703 
4704 		/* continue only if port is still connected */
4705 		if (!(status & PORT_STATUS_CCS)) {
4706 
4707 			/* lost connection, set exit condition */
4708 			i = hubd_retry_enumerate;
4709 
4710 			mutex_enter(HUBD_MUTEX(hubd));
4711 
4712 			break;
4713 		}
4714 
4715 		if (status & PORT_STATUS_PRS) {
4716 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4717 			    "port%d reset active", port);
4718 			mutex_enter(HUBD_MUTEX(hubd));
4719 
4720 			continue;
4721 		} else {
4722 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4723 			    "port%d reset inactive", port);
4724 		}
4725 
4726 		if (change & PORT_CHANGE_PRSC) {
4727 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4728 			    "clearing feature CFS_C_PORT_RESET");
4729 
4730 			if (usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4731 			    hubd->h_default_pipe,
4732 			    HUB_HANDLE_PORT_FEATURE_TYPE,
4733 			    USB_REQ_CLEAR_FEATURE,
4734 			    CFS_C_PORT_RESET,
4735 			    port,
4736 			    0,
4737 			    NULL, 0,
4738 			    &completion_reason, &cb_flags, 0) != USB_SUCCESS) {
4739 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
4740 				    hubd->h_log_handle,
4741 				    "clear feature CFS_C_PORT_RESET"
4742 				    " port%d failed (%d 0x%x %d)",
4743 				    port, completion_reason, cb_flags, rval);
4744 			}
4745 		}
4746 		mutex_enter(HUBD_MUTEX(hubd));
4747 
4748 		break;
4749 	}
4750 
4751 	if (i >= hubd_retry_enumerate) {
4752 		/* port reset has failed */
4753 		rval = USB_FAILURE;
4754 	}
4755 
4756 	return (rval);
4757 }
4758 
4759 
4760 /*
4761  * hubd_enable_port:
4762  *	this may fail if the hub as been disconnected
4763  */
4764 static int
4765 hubd_enable_port(hubd_t *hubd, usb_port_t port)
4766 {
4767 	int	rval;
4768 	usb_cr_t completion_reason;
4769 	usb_cb_flags_t cb_flags;
4770 
4771 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
4772 	    "hubd_enable_port: port=%d", port);
4773 
4774 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
4775 
4776 	mutex_exit(HUBD_MUTEX(hubd));
4777 
4778 	/* Do not issue a SetFeature(PORT_ENABLE) on external hubs */
4779 	if (!usba_is_root_hub(hubd->h_dip)) {
4780 		mutex_enter(HUBD_MUTEX(hubd));
4781 
4782 		return (USB_SUCCESS);
4783 	}
4784 
4785 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4786 	    hubd->h_default_pipe,
4787 	    HUB_HANDLE_PORT_FEATURE_TYPE,
4788 	    USB_REQ_SET_FEATURE,
4789 	    CFS_PORT_ENABLE,
4790 	    port,
4791 	    0,
4792 	    NULL, 0,
4793 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4794 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4795 		    "enable port%d failed (%d 0x%x %d)",
4796 		    port, completion_reason, cb_flags, rval);
4797 	}
4798 
4799 	mutex_enter(HUBD_MUTEX(hubd));
4800 
4801 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
4802 	    "enabling port done");
4803 
4804 	return (rval);
4805 }
4806 
4807 
4808 /*
4809  * hubd_disable_port
4810  */
4811 static int
4812 hubd_disable_port(hubd_t *hubd, usb_port_t port)
4813 {
4814 	int	rval;
4815 	usb_cr_t completion_reason;
4816 	usb_cb_flags_t cb_flags;
4817 
4818 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
4819 	    "hubd_disable_port: port=%d", port);
4820 
4821 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
4822 
4823 	mutex_exit(HUBD_MUTEX(hubd));
4824 
4825 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4826 	    hubd->h_default_pipe,
4827 	    HUB_HANDLE_PORT_FEATURE_TYPE,
4828 	    USB_REQ_CLEAR_FEATURE,
4829 	    CFS_PORT_ENABLE,
4830 	    port,
4831 	    0,
4832 	    NULL, 0,
4833 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4834 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4835 		    "disable port%d failed (%d 0x%x %d)", port,
4836 		    completion_reason, cb_flags, rval);
4837 		mutex_enter(HUBD_MUTEX(hubd));
4838 
4839 		return (USB_FAILURE);
4840 	}
4841 
4842 	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4843 	    "clearing feature CFS_C_PORT_ENABLE");
4844 
4845 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4846 	    hubd->h_default_pipe,
4847 	    HUB_HANDLE_PORT_FEATURE_TYPE,
4848 	    USB_REQ_CLEAR_FEATURE,
4849 	    CFS_C_PORT_ENABLE,
4850 	    port,
4851 	    0,
4852 	    NULL, 0,
4853 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4854 		USB_DPRINTF_L2(DPRINT_MASK_PORT,
4855 		    hubd->h_log_handle,
4856 		    "clear feature CFS_C_PORT_ENABLE port%d failed "
4857 		    "(%d 0x%x %d)",
4858 		    port, completion_reason, cb_flags, rval);
4859 
4860 		mutex_enter(HUBD_MUTEX(hubd));
4861 
4862 		return (USB_FAILURE);
4863 	}
4864 
4865 	mutex_enter(HUBD_MUTEX(hubd));
4866 
4867 	return (USB_SUCCESS);
4868 }
4869 
4870 
4871 /*
4872  * hubd_determine_port_status:
4873  */
4874 static int
4875 hubd_determine_port_status(hubd_t *hubd, usb_port_t port,
4876 		uint16_t *status, uint16_t *change, uint_t ack_flag)
4877 {
4878 	int rval;
4879 	mblk_t	*data = NULL;
4880 	usb_cr_t completion_reason;
4881 	usb_cb_flags_t cb_flags;
4882 
4883 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
4884 	    "hubd_determine_port_status: port=%d, state=0x%x ack=0x%x", port,
4885 	    hubd->h_port_state[port], ack_flag);
4886 
4887 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
4888 
4889 	mutex_exit(HUBD_MUTEX(hubd));
4890 
4891 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
4892 	    hubd->h_default_pipe,
4893 	    HUB_GET_PORT_STATUS_TYPE,
4894 	    USB_REQ_GET_STATUS,
4895 	    0,
4896 	    port,
4897 	    GET_STATUS_LENGTH,
4898 	    &data, 0,
4899 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
4900 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4901 		    "port=%d get status failed (%d 0x%x %d)",
4902 		    port, completion_reason, cb_flags, rval);
4903 
4904 		if (data) {
4905 			freemsg(data);
4906 		}
4907 
4908 		*status = *change = 0;
4909 		mutex_enter(HUBD_MUTEX(hubd));
4910 
4911 		return (rval);
4912 	}
4913 
4914 	mutex_enter(HUBD_MUTEX(hubd));
4915 	if (MBLKL(data) != GET_STATUS_LENGTH) {
4916 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4917 		    "port %d: length incorrect %ld",
4918 		    port, MBLKL(data));
4919 		freemsg(data);
4920 		*status = *change = 0;
4921 
4922 		return (rval);
4923 	}
4924 
4925 
4926 	*status = (*(data->b_rptr + 1) << 8) | *(data->b_rptr);
4927 	*change = (*(data->b_rptr + 3) << 8) | *(data->b_rptr + 2);
4928 
4929 	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4930 	    "port%d status=0x%x, change=0x%x", port, *status, *change);
4931 
4932 	freemsg(data);
4933 
4934 	if (*status & PORT_STATUS_CCS) {
4935 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4936 		    "port%d connected", port);
4937 
4938 		hubd->h_port_state[port] |= (PORT_STATUS_CCS & ack_flag);
4939 	} else {
4940 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4941 		    "port%d disconnected", port);
4942 
4943 		hubd->h_port_state[port] &= ~(PORT_STATUS_CCS & ack_flag);
4944 	}
4945 
4946 	if (*status & PORT_STATUS_PES) {
4947 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4948 		    "port%d enabled", port);
4949 
4950 		hubd->h_port_state[port] |= (PORT_STATUS_PES & ack_flag);
4951 	} else {
4952 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4953 		    "port%d disabled", port);
4954 
4955 		hubd->h_port_state[port] &= ~(PORT_STATUS_PES & ack_flag);
4956 	}
4957 
4958 	if (*status & PORT_STATUS_PSS) {
4959 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4960 		    "port%d suspended", port);
4961 
4962 		hubd->h_port_state[port] |= (PORT_STATUS_PSS & ack_flag);
4963 	} else {
4964 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4965 		    "port%d not suspended", port);
4966 
4967 		hubd->h_port_state[port] &= ~(PORT_STATUS_PSS & ack_flag);
4968 	}
4969 
4970 	if (*change & PORT_CHANGE_PRSC) {
4971 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4972 		    "port%d reset completed", port);
4973 
4974 		hubd->h_port_state[port] |= (PORT_CHANGE_PRSC & ack_flag);
4975 	} else {
4976 
4977 		hubd->h_port_state[port] &= ~(PORT_CHANGE_PRSC & ack_flag);
4978 	}
4979 
4980 	if (*status & PORT_STATUS_POCI) {
4981 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
4982 		    "port%d overcurrent!", port);
4983 
4984 		hubd->h_port_state[port] |= (PORT_STATUS_POCI & ack_flag);
4985 	} else {
4986 
4987 		hubd->h_port_state[port] &= ~(PORT_STATUS_POCI & ack_flag);
4988 	}
4989 
4990 	if (*status & PORT_STATUS_PRS) {
4991 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4992 		    "port%d reset active", port);
4993 
4994 		hubd->h_port_state[port] |= (PORT_STATUS_PRS & ack_flag);
4995 	} else {
4996 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
4997 		    "port%d reset inactive", port);
4998 
4999 		hubd->h_port_state[port] &= ~(PORT_STATUS_PRS & ack_flag);
5000 	}
5001 	if (*status & PORT_STATUS_PPS) {
5002 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5003 		    "port%d power on", port);
5004 
5005 		hubd->h_port_state[port] |= (PORT_STATUS_PPS & ack_flag);
5006 	} else {
5007 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5008 		    "port%d power off", port);
5009 
5010 		hubd->h_port_state[port] &= ~(PORT_STATUS_PPS & ack_flag);
5011 	}
5012 	if (*status & PORT_STATUS_LSDA) {
5013 		USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5014 		    "port%d low speed", port);
5015 
5016 		hubd->h_port_state[port] |= (PORT_STATUS_LSDA & ack_flag);
5017 	} else {
5018 		hubd->h_port_state[port] &= ~(PORT_STATUS_LSDA & ack_flag);
5019 		if (*status & PORT_STATUS_HSDA) {
5020 			USB_DPRINTF_L3(DPRINT_MASK_PORT,
5021 			    hubd->h_log_handle, "port%d "
5022 			    "high speed", port);
5023 
5024 			hubd->h_port_state[port] |=
5025 			    (PORT_STATUS_HSDA & ack_flag);
5026 		} else {
5027 			USB_DPRINTF_L3(DPRINT_MASK_PORT,
5028 			    hubd->h_log_handle, "port%d "
5029 			    "full speed", port);
5030 
5031 			hubd->h_port_state[port] &=
5032 			    ~(PORT_STATUS_HSDA & ack_flag);
5033 		}
5034 	}
5035 
5036 	/*
5037 	 * Acknowledge connection, enable, reset status
5038 	 */
5039 	if (ack_flag) {
5040 		mutex_exit(HUBD_MUTEX(hubd));
5041 		if (*change & PORT_CHANGE_CSC & ack_flag) {
5042 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5043 			    "clearing feature CFS_C_PORT_CONNECTION");
5044 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
5045 			    hubd->h_default_pipe,
5046 			    HUB_HANDLE_PORT_FEATURE_TYPE,
5047 			    USB_REQ_CLEAR_FEATURE,
5048 			    CFS_C_PORT_CONNECTION,
5049 			    port,
5050 			    0, NULL, 0,
5051 			    &completion_reason, &cb_flags, 0)) !=
5052 			    USB_SUCCESS) {
5053 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
5054 				    hubd->h_log_handle,
5055 				    "clear feature CFS_C_PORT_CONNECTION"
5056 				    " port%d failed (%d 0x%x %d)",
5057 				    port, completion_reason, cb_flags, rval);
5058 			}
5059 		}
5060 		if (*change & PORT_CHANGE_PESC & ack_flag) {
5061 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5062 			    "clearing feature CFS_C_PORT_ENABLE");
5063 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
5064 			    hubd->h_default_pipe,
5065 			    HUB_HANDLE_PORT_FEATURE_TYPE,
5066 			    USB_REQ_CLEAR_FEATURE,
5067 			    CFS_C_PORT_ENABLE,
5068 			    port,
5069 			    0, NULL, 0,
5070 			    &completion_reason, &cb_flags, 0)) !=
5071 			    USB_SUCCESS) {
5072 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
5073 				    hubd->h_log_handle,
5074 				    "clear feature CFS_C_PORT_ENABLE"
5075 				    " port%d failed (%d 0x%x %d)",
5076 				    port, completion_reason, cb_flags, rval);
5077 			}
5078 		}
5079 		if (*change & PORT_CHANGE_PSSC & ack_flag) {
5080 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5081 			    "clearing feature CFS_C_PORT_SUSPEND");
5082 
5083 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
5084 			    hubd->h_default_pipe,
5085 			    HUB_HANDLE_PORT_FEATURE_TYPE,
5086 			    USB_REQ_CLEAR_FEATURE,
5087 			    CFS_C_PORT_SUSPEND,
5088 			    port,
5089 			    0, NULL, 0,
5090 			    &completion_reason, &cb_flags, 0)) !=
5091 			    USB_SUCCESS) {
5092 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
5093 				    hubd->h_log_handle,
5094 				    "clear feature CFS_C_PORT_SUSPEND"
5095 				    " port%d failed (%d 0x%x %d)",
5096 				    port, completion_reason, cb_flags, rval);
5097 			}
5098 		}
5099 		if (*change & PORT_CHANGE_OCIC & ack_flag) {
5100 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5101 			    "clearing feature CFS_C_PORT_OVER_CURRENT");
5102 
5103 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
5104 			    hubd->h_default_pipe,
5105 			    HUB_HANDLE_PORT_FEATURE_TYPE,
5106 			    USB_REQ_CLEAR_FEATURE,
5107 			    CFS_C_PORT_OVER_CURRENT,
5108 			    port,
5109 			    0, NULL, 0,
5110 			    &completion_reason, &cb_flags, 0)) !=
5111 			    USB_SUCCESS) {
5112 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
5113 				    hubd->h_log_handle,
5114 				    "clear feature CFS_C_PORT_OVER_CURRENT"
5115 				    " port%d failed (%d 0x%x %d)",
5116 				    port, completion_reason, cb_flags, rval);
5117 			}
5118 		}
5119 		if (*change & PORT_CHANGE_PRSC & ack_flag) {
5120 			USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
5121 			    "clearing feature CFS_C_PORT_RESET");
5122 			if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
5123 			    hubd->h_default_pipe,
5124 			    HUB_HANDLE_PORT_FEATURE_TYPE,
5125 			    USB_REQ_CLEAR_FEATURE,
5126 			    CFS_C_PORT_RESET,
5127 			    port,
5128 			    0, NULL, 0,
5129 			    &completion_reason, &cb_flags, 0)) !=
5130 			    USB_SUCCESS) {
5131 				USB_DPRINTF_L2(DPRINT_MASK_PORT,
5132 				    hubd->h_log_handle,
5133 				    "clear feature CFS_C_PORT_RESET"
5134 				    " port%d failed (%d 0x%x %d)",
5135 				    port, completion_reason, cb_flags, rval);
5136 			}
5137 		}
5138 		mutex_enter(HUBD_MUTEX(hubd));
5139 	}
5140 
5141 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
5142 	    "new port%d state 0x%x", port, hubd->h_port_state[port]);
5143 
5144 
5145 	return (USB_SUCCESS);
5146 }
5147 
5148 
5149 /*
5150  * hubd_recover_disabled_port
5151  * if the port got disabled because of an error
5152  * enable it. If hub doesn't suport enable port,
5153  * reset the port to bring the device to life again
5154  */
5155 static int
5156 hubd_recover_disabled_port(hubd_t *hubd, usb_port_t port)
5157 {
5158 	uint16_t	status;
5159 	uint16_t	change;
5160 	int		rval = USB_FAILURE;
5161 
5162 	/* first try enabling the port */
5163 	(void) hubd_enable_port(hubd, port);
5164 
5165 	/* read the port status */
5166 	(void) hubd_determine_port_status(hubd, port, &status, &change,
5167 	    PORT_CHANGE_PESC);
5168 
5169 	if (status & PORT_STATUS_PES) {
5170 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5171 		    "Port%d now Enabled", port);
5172 	} else if (status & PORT_STATUS_CCS) {
5173 		/* first post a disconnect event to the child */
5174 		mutex_exit(HUBD_MUTEX(hubd));
5175 		hubd_post_event(hubd, port, USBA_EVENT_TAG_HOT_REMOVAL);
5176 		mutex_enter(HUBD_MUTEX(hubd));
5177 
5178 		/* then reset the port and recover the device */
5179 		rval = hubd_handle_port_connect(hubd, port);
5180 
5181 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5182 		    "Port%d now Enabled by force", port);
5183 	}
5184 
5185 	return (rval);
5186 }
5187 
5188 
5189 /*
5190  * hubd_enable_all_port_power:
5191  */
5192 static int
5193 hubd_enable_all_port_power(hubd_t *hubd)
5194 {
5195 	usb_hub_descr_t	*hub_descr;
5196 	int		wait;
5197 	usb_port_t	port;
5198 	uint_t		retry;
5199 	uint16_t	status;
5200 	uint16_t	change;
5201 
5202 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
5203 	    "hubd_enable_all_port_power");
5204 
5205 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
5206 
5207 	hub_descr = &hubd->h_hub_descr;
5208 
5209 	/*
5210 	 * According to section 11.11 of USB, for hubs with no power
5211 	 * switches, bPwrOn2PwrGood is zero. But we wait for some
5212 	 * arbitrary time to enable power to become stable.
5213 	 *
5214 	 * If an hub supports port power switching, we need to wait
5215 	 * at least 20ms before accessing corresponding usb port.
5216 	 */
5217 	if ((hub_descr->wHubCharacteristics &
5218 	    HUB_CHARS_NO_POWER_SWITCHING) || (!hub_descr->bPwrOn2PwrGood)) {
5219 		wait = hubd_device_delay / 10;
5220 	} else {
5221 		wait = max(HUB_DEFAULT_POPG,
5222 		    hub_descr->bPwrOn2PwrGood) * 2 * 1000;
5223 	}
5224 
5225 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
5226 	    "hubd_enable_all_port_power: popg=%d wait=%d",
5227 	    hub_descr->bPwrOn2PwrGood, wait);
5228 
5229 	/*
5230 	 * Enable power per port. we ignore gang power and power mask
5231 	 * and always enable all ports one by one.
5232 	 */
5233 	for (port = 1; port <= hub_descr->bNbrPorts; port++) {
5234 		/*
5235 		 * Transition the port from the Powered Off to the
5236 		 * Disconnected state by supplying power to the port.
5237 		 */
5238 		USB_DPRINTF_L4(DPRINT_MASK_PORT,
5239 		    hubd->h_log_handle,
5240 		    "hubd_enable_all_port_power: power port=%d", port);
5241 
5242 		(void) hubd_enable_port_power(hubd, port);
5243 	}
5244 
5245 	mutex_exit(HUBD_MUTEX(hubd));
5246 	delay(drv_usectohz(wait));
5247 	mutex_enter(HUBD_MUTEX(hubd));
5248 
5249 	/* For retry if any, use some extra delay */
5250 	wait = max(wait, hubd_device_delay / 10);
5251 
5252 	/* Check each port power status for a given usb hub */
5253 	for (port = 1; port <= hub_descr->bNbrPorts; port++) {
5254 
5255 		/* Get port status */
5256 		(void) hubd_determine_port_status(hubd, port,
5257 		    &status, &change, 0);
5258 
5259 		for (retry = 0; ((!(status & PORT_STATUS_PPS)) &&
5260 		    (retry < HUBD_PORT_RETRY)); retry++) {
5261 
5262 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
5263 			    "Retry is in progress %d: port %d status %d",
5264 			    retry, port, status);
5265 
5266 			(void) hubd_enable_port_power(hubd, port);
5267 
5268 			mutex_exit(HUBD_MUTEX(hubd));
5269 			delay(drv_usectohz(wait));
5270 			mutex_enter(HUBD_MUTEX(hubd));
5271 
5272 			/* Get port status */
5273 			(void) hubd_determine_port_status(hubd, port,
5274 			    &status, &change, 0);
5275 		}
5276 
5277 		/* Print warning message if port has no power */
5278 		if (!(status & PORT_STATUS_PPS)) {
5279 
5280 			USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
5281 			    "hubd_enable_all_port_power: port %d power-on "
5282 			    "failed, port status 0x%x", port, status);
5283 		}
5284 	}
5285 
5286 	return (USB_SUCCESS);
5287 }
5288 
5289 
5290 /*
5291  * hubd_enable_port_power:
5292  *	enable individual port power
5293  */
5294 static int
5295 hubd_enable_port_power(hubd_t *hubd, usb_port_t port)
5296 {
5297 	int		rval;
5298 	usb_cr_t	completion_reason;
5299 	usb_cb_flags_t	cb_flags;
5300 
5301 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
5302 	    "hubd_enable_port_power: port=%d", port);
5303 
5304 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
5305 	ASSERT(hubd->h_default_pipe != 0);
5306 
5307 	mutex_exit(HUBD_MUTEX(hubd));
5308 
5309 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
5310 	    hubd->h_default_pipe,
5311 	    HUB_HANDLE_PORT_FEATURE_TYPE,
5312 	    USB_REQ_SET_FEATURE,
5313 	    CFS_PORT_POWER,
5314 	    port,
5315 	    0, NULL, 0,
5316 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
5317 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
5318 		    "set port power failed (%d 0x%x %d)",
5319 		    completion_reason, cb_flags, rval);
5320 		mutex_enter(HUBD_MUTEX(hubd));
5321 
5322 		return (USB_FAILURE);
5323 	} else {
5324 		mutex_enter(HUBD_MUTEX(hubd));
5325 		hubd->h_port_state[port] |= PORT_STATUS_PPS;
5326 
5327 		return (USB_SUCCESS);
5328 	}
5329 }
5330 
5331 
5332 /*
5333  * hubd_disable_all_port_power:
5334  */
5335 static int
5336 hubd_disable_all_port_power(hubd_t *hubd)
5337 {
5338 	usb_port_t port;
5339 
5340 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
5341 	    "hubd_disable_all_port_power");
5342 
5343 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
5344 
5345 	/*
5346 	 * disable power per port, ignore gang power and power mask
5347 	 */
5348 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
5349 		(void) hubd_disable_port_power(hubd, port);
5350 	}
5351 
5352 	return (USB_SUCCESS);
5353 }
5354 
5355 
5356 /*
5357  * hubd_disable_port_power:
5358  *	disable individual port power
5359  */
5360 static int
5361 hubd_disable_port_power(hubd_t *hubd, usb_port_t port)
5362 {
5363 	int		rval;
5364 	usb_cr_t	completion_reason;
5365 	usb_cb_flags_t	cb_flags;
5366 
5367 	USB_DPRINTF_L4(DPRINT_MASK_PORT, hubd->h_log_handle,
5368 	    "hubd_disable_port_power: port=%d", port);
5369 
5370 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
5371 
5372 	mutex_exit(HUBD_MUTEX(hubd));
5373 
5374 	if ((rval = usb_pipe_sync_ctrl_xfer(hubd->h_dip,
5375 	    hubd->h_default_pipe,
5376 	    HUB_HANDLE_PORT_FEATURE_TYPE,
5377 	    USB_REQ_CLEAR_FEATURE,
5378 	    CFS_PORT_POWER,
5379 	    port,
5380 	    0, NULL, 0,
5381 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
5382 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
5383 		    "clearing port%d power failed (%d 0x%x %d)",
5384 		    port, completion_reason, cb_flags, rval);
5385 
5386 		mutex_enter(HUBD_MUTEX(hubd));
5387 
5388 		return (USB_FAILURE);
5389 	} else {
5390 
5391 		mutex_enter(HUBD_MUTEX(hubd));
5392 		ASSERT(completion_reason == 0);
5393 		hubd->h_port_state[port] &= ~PORT_STATUS_PPS;
5394 
5395 		return (USB_SUCCESS);
5396 	}
5397 }
5398 
5399 
5400 /*
5401  * Search the database of user preferences and find out the preferred
5402  * configuration for this new device
5403  */
5404 int
5405 hubd_select_device_configuration(hubd_t *hubd, usb_port_t port,
5406 	dev_info_t *child_dip, usba_device_t *child_ud)
5407 {
5408 	char		*pathname = NULL;
5409 	char		*tmp_path = NULL;
5410 	int		user_conf;
5411 	int		pathlen;
5412 	usb_dev_descr_t	*usbdev_ptr;
5413 	usba_configrec_t *user_pref;
5414 
5415 	mutex_enter(&child_ud->usb_mutex);
5416 	usbdev_ptr = child_ud->usb_dev_descr;
5417 	mutex_exit(&child_ud->usb_mutex);
5418 
5419 	/* try to get pathname for this device */
5420 	tmp_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
5421 	(void) ddi_pathname(child_dip, tmp_path);
5422 
5423 	pathlen = strlen(tmp_path) + 32;
5424 	pathname = kmem_zalloc(pathlen, KM_SLEEP);
5425 
5426 	/*
5427 	 * We haven't initialized the node and it doesn't have an address
5428 	 * yet. Append port number to the physical pathname
5429 	 */
5430 	(void) sprintf(pathname, "%s@%d", tmp_path, port);
5431 
5432 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5433 	    "hubd_select_device_configuration: Device=%s\n\t"
5434 	    "Child path=%s",
5435 	    usba_get_mfg_prod_sn_str(child_dip, tmp_path, MAXPATHLEN),
5436 	    pathname);
5437 	kmem_free(tmp_path, MAXPATHLEN);
5438 
5439 
5440 	/* database search for user preferences */
5441 	user_pref = usba_devdb_get_user_preferences(usbdev_ptr->idVendor,
5442 	    usbdev_ptr->idProduct, child_ud->usb_serialno_str, pathname);
5443 
5444 	if (user_pref) {
5445 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5446 		    "hubd_select_device_configuration: "
5447 		    "usba_devdb_get_user_preferences "
5448 		    "return user_conf=%d\npreferred driver=%s path=%s",
5449 		    user_pref->cfg_index, user_pref->driver,
5450 		    user_pref->pathname);
5451 
5452 		user_conf = user_pref->cfg_index;
5453 
5454 		if (user_pref->driver) {
5455 			mutex_enter(&child_ud->usb_mutex);
5456 			child_ud->usb_preferred_driver = user_pref->driver;
5457 			mutex_exit(&child_ud->usb_mutex);
5458 		}
5459 	} else {
5460 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5461 		    "hubd_select_device_configuration: No match found");
5462 
5463 		/* select default configuration for this device */
5464 		user_conf = USBA_DEV_CONFIG_INDEX_UNDEFINED;
5465 	}
5466 	kmem_free(pathname, pathlen);
5467 
5468 	/* if the device has just one configuration, set default value */
5469 	if (usbdev_ptr->bNumConfigurations == 1) {
5470 		user_conf = USB_DEV_DEFAULT_CONFIG_INDEX;
5471 	}
5472 
5473 	return (user_conf);
5474 }
5475 
5476 
5477 /*
5478  * Retrieves config cloud for this configuration
5479  */
5480 int
5481 hubd_get_this_config_cloud(hubd_t *hubd, dev_info_t *dip,
5482 	usba_device_t *child_ud, uint16_t conf_index)
5483 {
5484 	usb_cfg_descr_t	*confdescr;
5485 	mblk_t		*pdata = NULL;
5486 	int		rval;
5487 	size_t		size;
5488 	char		*tmpbuf;
5489 	usb_cr_t	completion_reason;
5490 	usb_cb_flags_t	cb_flags;
5491 	usb_pipe_handle_t	def_ph;
5492 
5493 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5494 	    "hubd_get_this_config_cloud: conf_index=%d", conf_index);
5495 
5496 
5497 	/* alloc temporary space for config descriptor */
5498 	confdescr = (usb_cfg_descr_t *)kmem_zalloc(USB_CFG_DESCR_SIZE,
5499 	    KM_SLEEP);
5500 
5501 	/* alloc temporary space for string descriptor */
5502 	tmpbuf = kmem_zalloc(USB_MAXSTRINGLEN, KM_SLEEP);
5503 
5504 	def_ph = usba_get_dflt_pipe_handle(dip);
5505 
5506 	if ((rval = usb_pipe_sync_ctrl_xfer(dip, def_ph,
5507 	    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
5508 	    USB_REQ_GET_DESCR,
5509 	    USB_DESCR_TYPE_SETUP_CFG | conf_index,
5510 	    0,
5511 	    USB_CFG_DESCR_SIZE,
5512 	    &pdata,
5513 	    0,
5514 	    &completion_reason,
5515 	    &cb_flags,
5516 	    0)) == USB_SUCCESS) {
5517 
5518 		/* this must be true since we didn't allow data underruns */
5519 		if (MBLKL(pdata) != USB_CFG_DESCR_SIZE) {
5520 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5521 			    "device returned incorrect configuration "
5522 			    "descriptor size.");
5523 
5524 			rval = USB_FAILURE;
5525 			goto done;
5526 		}
5527 
5528 		/*
5529 		 * Parse the configuration descriptor
5530 		 */
5531 		size = usb_parse_cfg_descr(pdata->b_rptr,
5532 		    MBLKL(pdata), confdescr,
5533 		    USB_CFG_DESCR_SIZE);
5534 
5535 		/* if parse cfg descr error, it should return failure */
5536 		if (size == USB_PARSE_ERROR) {
5537 
5538 			if (pdata->b_rptr[1] != USB_DESCR_TYPE_CFG) {
5539 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
5540 				    hubd->h_log_handle,
5541 				    "device returned incorrect "
5542 				    "configuration descriptor type.");
5543 			}
5544 			rval = USB_FAILURE;
5545 			goto done;
5546 		}
5547 
5548 		if (confdescr->wTotalLength < USB_CFG_DESCR_SIZE) {
5549 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
5550 			    hubd->h_log_handle,
5551 			    "device returned incorrect "
5552 			    "configuration descriptor size.");
5553 
5554 			rval = USB_FAILURE;
5555 			goto done;
5556 		}
5557 
5558 		freemsg(pdata);
5559 		pdata = NULL;
5560 
5561 		/* Now fetch the complete config cloud */
5562 		if ((rval = usb_pipe_sync_ctrl_xfer(dip, def_ph,
5563 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
5564 		    USB_REQ_GET_DESCR,
5565 		    USB_DESCR_TYPE_SETUP_CFG | conf_index,
5566 		    0,
5567 		    confdescr->wTotalLength,
5568 		    &pdata,
5569 		    0,
5570 		    &completion_reason,
5571 		    &cb_flags,
5572 		    0)) == USB_SUCCESS) {
5573 
5574 			if (MBLKL(pdata) !=
5575 			    confdescr->wTotalLength) {
5576 
5577 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
5578 				    hubd->h_log_handle,
5579 				    "device returned incorrect "
5580 				    "configuration descriptor.");
5581 
5582 				rval = USB_FAILURE;
5583 				goto done;
5584 			}
5585 
5586 			/*
5587 			 * copy config descriptor into usba_device
5588 			 */
5589 			mutex_enter(&child_ud->usb_mutex);
5590 			child_ud->usb_cfg_array[conf_index] =
5591 			    kmem_alloc(confdescr->wTotalLength, KM_SLEEP);
5592 			child_ud->usb_cfg_array_len[conf_index] =
5593 			    confdescr->wTotalLength;
5594 			bcopy((caddr_t)pdata->b_rptr,
5595 			    (caddr_t)child_ud->usb_cfg_array[conf_index],
5596 			    confdescr->wTotalLength);
5597 			mutex_exit(&child_ud->usb_mutex);
5598 
5599 			/*
5600 			 * retrieve string descriptor describing this
5601 			 * configuration
5602 			 */
5603 			if (confdescr->iConfiguration) {
5604 
5605 				USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
5606 				    hubd->h_log_handle,
5607 				    "Get conf str descr for config_index=%d",
5608 				    conf_index);
5609 
5610 				/*
5611 				 * Now fetch the string descriptor describing
5612 				 * this configuration
5613 				 */
5614 				if ((rval = usb_get_string_descr(dip,
5615 				    USB_LANG_ID, confdescr->iConfiguration,
5616 				    tmpbuf, USB_MAXSTRINGLEN)) ==
5617 				    USB_SUCCESS) {
5618 					size = strlen(tmpbuf);
5619 					if (size > 0) {
5620 						child_ud->usb_cfg_str_descr
5621 						    [conf_index] = (char *)
5622 						    kmem_zalloc(size + 1,
5623 						    KM_SLEEP);
5624 						(void) strcpy(
5625 						    child_ud->usb_cfg_str_descr
5626 						    [conf_index], tmpbuf);
5627 					}
5628 				} else {
5629 					USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
5630 					    hubd->h_log_handle,
5631 					    "hubd_get_this_config_cloud: "
5632 					    "getting config string (%d) "
5633 					    "failed",
5634 					    confdescr->iConfiguration);
5635 
5636 					/* ignore this error */
5637 					rval = USB_SUCCESS;
5638 				}
5639 			}
5640 		}
5641 	}
5642 
5643 done:
5644 	if (rval != USB_SUCCESS) {
5645 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5646 		    "hubd_get_this_config_cloud: "
5647 		    "error in retrieving config descriptor for "
5648 		    "config index=%d rval=%d cr=%d",
5649 		    conf_index, rval, completion_reason);
5650 	}
5651 
5652 	if (pdata) {
5653 		freemsg(pdata);
5654 		pdata = NULL;
5655 	}
5656 
5657 	kmem_free(confdescr, USB_CFG_DESCR_SIZE);
5658 	kmem_free(tmpbuf, USB_MAXSTRINGLEN);
5659 
5660 	return (rval);
5661 }
5662 
5663 
5664 /*
5665  * Retrieves the entire config cloud for all configurations of the device
5666  */
5667 int
5668 hubd_get_all_device_config_cloud(hubd_t *hubd, dev_info_t *dip,
5669 	usba_device_t *child_ud)
5670 {
5671 	int		rval = USB_SUCCESS;
5672 	int		ncfgs;
5673 	uint16_t	size;
5674 	uint16_t	conf_index;
5675 	uchar_t		**cfg_array;
5676 	uint16_t	*cfg_array_len;
5677 	char		**str_descr;
5678 
5679 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5680 	    "hubd_get_all_device_config_cloud: Start");
5681 
5682 	/* alloc pointer array for conf. descriptors */
5683 	mutex_enter(&child_ud->usb_mutex);
5684 	ncfgs = child_ud->usb_n_cfgs;
5685 	mutex_exit(&child_ud->usb_mutex);
5686 
5687 	size = sizeof (uchar_t *) * ncfgs;
5688 	cfg_array = kmem_zalloc(size, KM_SLEEP);
5689 	cfg_array_len = kmem_zalloc(ncfgs * sizeof (uint16_t), KM_SLEEP);
5690 	str_descr = kmem_zalloc(size, KM_SLEEP);
5691 
5692 	mutex_enter(&child_ud->usb_mutex);
5693 	child_ud->usb_cfg_array = cfg_array;
5694 	child_ud->usb_cfg_array_len = cfg_array_len;
5695 	child_ud->usb_cfg_array_length = size;
5696 	child_ud->usb_cfg_array_len_length = ncfgs * sizeof (uint16_t);
5697 	child_ud->usb_cfg_str_descr = str_descr;
5698 	mutex_exit(&child_ud->usb_mutex);
5699 
5700 	/* Get configuration descriptor for each configuration */
5701 	for (conf_index = 0; (conf_index < ncfgs) &&
5702 	    (rval == USB_SUCCESS); conf_index++) {
5703 
5704 		rval = hubd_get_this_config_cloud(hubd, dip, child_ud,
5705 		    conf_index);
5706 	}
5707 
5708 	return (rval);
5709 }
5710 
5711 
5712 /*
5713  * hubd_ready_device:
5714  *	Update the usba_device structure
5715  *	Set the given configuration
5716  *	Prepares the device node for driver to online. If an existing
5717  *	OBP node is found, it will switch to the OBP node.
5718  */
5719 dev_info_t *
5720 hubd_ready_device(hubd_t *hubd, dev_info_t *child_dip, usba_device_t *child_ud,
5721     uint_t config_index)
5722 {
5723 	usb_cr_t	completion_reason;
5724 	usb_cb_flags_t	cb_flags;
5725 	size_t		size;
5726 	usb_cfg_descr_t	config_descriptor;
5727 	usb_pipe_handle_t def_ph;
5728 	usba_pipe_handle_data_t	*ph;
5729 
5730 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5731 	    "hubd_ready_device: dip=0x%p, user_conf_index=%d",
5732 	    (void *)child_dip, config_index);
5733 
5734 	size = usb_parse_cfg_descr(
5735 	    child_ud->usb_cfg_array[config_index], USB_CFG_DESCR_SIZE,
5736 	    &config_descriptor, USB_CFG_DESCR_SIZE);
5737 	ASSERT(size == USB_CFG_DESCR_SIZE);
5738 
5739 	def_ph = usba_get_dflt_pipe_handle(child_dip);
5740 
5741 	/* Set the configuration */
5742 	(void) usb_pipe_sync_ctrl_xfer(child_dip, def_ph,
5743 	    USB_DEV_REQ_HOST_TO_DEV,
5744 	    USB_REQ_SET_CFG,	/* bRequest */
5745 	    config_descriptor.bConfigurationValue,	/* wValue */
5746 	    0,				/* wIndex */
5747 	    0,				/* wLength */
5748 	    NULL,
5749 	    0,
5750 	    &completion_reason,
5751 	    &cb_flags,
5752 	    0);
5753 
5754 	mutex_enter(&child_ud->usb_mutex);
5755 	child_ud->usb_active_cfg_ndx	= config_index;
5756 	child_ud->usb_cfg		= child_ud->usb_cfg_array[config_index];
5757 	child_ud->usb_cfg_length	= config_descriptor.wTotalLength;
5758 	child_ud->usb_cfg_value 	= config_descriptor.bConfigurationValue;
5759 	child_ud->usb_n_ifs		= config_descriptor.bNumInterfaces;
5760 	child_ud->usb_dip		= child_dip;
5761 
5762 	child_ud->usb_client_flags	= kmem_zalloc(
5763 	    child_ud->usb_n_ifs * USBA_CLIENT_FLAG_SIZE, KM_SLEEP);
5764 
5765 	child_ud->usb_client_attach_list = kmem_zalloc(
5766 	    child_ud->usb_n_ifs *
5767 	    sizeof (*child_ud->usb_client_attach_list), KM_SLEEP);
5768 
5769 	child_ud->usb_client_ev_cb_list = kmem_zalloc(
5770 	    child_ud->usb_n_ifs *
5771 	    sizeof (*child_ud->usb_client_ev_cb_list), KM_SLEEP);
5772 
5773 	mutex_exit(&child_ud->usb_mutex);
5774 
5775 	/* ready the device node */
5776 	child_dip = usba_ready_device_node(child_dip);
5777 
5778 	/* set owner of default pipe to child dip */
5779 	ph = usba_get_ph_data(def_ph);
5780 	mutex_enter(&ph->p_mutex);
5781 	mutex_enter(&ph->p_ph_impl->usba_ph_mutex);
5782 	ph->p_ph_impl->usba_ph_dip = ph->p_dip = child_dip;
5783 	mutex_exit(&ph->p_ph_impl->usba_ph_mutex);
5784 	mutex_exit(&ph->p_mutex);
5785 
5786 	return (child_dip);
5787 }
5788 
5789 
5790 /*
5791  * hubd_create_child
5792  *	- create child dip
5793  *	- open default pipe
5794  *	- get device descriptor
5795  *	- set the address
5796  *	- get device string descriptors
5797  *	- get the entire config cloud (all configurations) of the device
5798  *	- set user preferred configuration
5799  *	- close default pipe
5800  *	- load appropriate driver(s)
5801  */
5802 static int
5803 hubd_create_child(dev_info_t *dip,
5804 		hubd_t		*hubd,
5805 		usba_device_t	*hubd_ud,
5806 		usb_port_status_t port_status,
5807 		usb_port_t	port,
5808 		int		iteration)
5809 {
5810 	dev_info_t		*child_dip = NULL;
5811 	usb_dev_descr_t	usb_dev_descr;
5812 	int			rval;
5813 	usba_device_t		*child_ud = NULL;
5814 	usba_device_t		*parent_ud = NULL;
5815 	usb_pipe_handle_t	ph = NULL; /* default pipe handle */
5816 	mblk_t			*pdata = NULL;
5817 	usb_cr_t		completion_reason;
5818 	int			user_conf_index;
5819 	uint_t			config_index;
5820 	usb_cb_flags_t		cb_flags;
5821 	uchar_t			address = 0;
5822 	uint16_t		length;
5823 	size_t			size;
5824 	usb_addr_t		parent_usb_addr;
5825 	usb_port_t		parent_usb_port;
5826 	usba_device_t		*parent_usba_dev;
5827 	usb_port_status_t	parent_port_status;
5828 
5829 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5830 	    "hubd_create_child: port=%d", port);
5831 
5832 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
5833 	ASSERT(hubd->h_usba_devices[port] == NULL);
5834 
5835 	mutex_exit(HUBD_MUTEX(hubd));
5836 
5837 	/*
5838 	 * create a dip which can be used to open the pipe. we set
5839 	 * the name after getting the descriptors from the device
5840 	 */
5841 	rval = usba_create_child_devi(dip,
5842 	    "device",		/* driver name */
5843 	    hubd_ud->usb_hcdi_ops, /* usba_hcdi ops */
5844 	    hubd_ud->usb_root_hub_dip,
5845 	    port_status,		/* low speed device */
5846 	    child_ud,
5847 	    &child_dip);
5848 
5849 	if (rval != USB_SUCCESS) {
5850 
5851 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5852 		    "usb_create_child_devi failed (%d)", rval);
5853 
5854 		goto fail_cleanup;
5855 	}
5856 
5857 	child_ud = usba_get_usba_device(child_dip);
5858 	ASSERT(child_ud != NULL);
5859 
5860 	parent_ud = hubd->h_usba_device;
5861 	mutex_enter(&parent_ud->usb_mutex);
5862 	parent_port_status = parent_ud->usb_port_status;
5863 
5864 	/*
5865 	 * To support split transactions, update address and port
5866 	 * of high speed hub to which given device is connected.
5867 	 */
5868 	if (parent_port_status == USBA_HIGH_SPEED_DEV) {
5869 		parent_usba_dev = parent_ud;
5870 		parent_usb_addr = parent_ud->usb_addr;
5871 		parent_usb_port = port;
5872 	} else {
5873 		parent_usba_dev = parent_ud->usb_hs_hub_usba_dev;
5874 		parent_usb_addr = parent_ud->usb_hs_hub_addr;
5875 		parent_usb_port = parent_ud->usb_hs_hub_port;
5876 	}
5877 	mutex_exit(&parent_ud->usb_mutex);
5878 
5879 	mutex_enter(&child_ud->usb_mutex);
5880 	address = child_ud->usb_addr;
5881 	child_ud->usb_addr = 0;
5882 	child_ud->usb_dev_descr = kmem_alloc(sizeof (usb_dev_descr_t),
5883 	    KM_SLEEP);
5884 	bzero(&usb_dev_descr, sizeof (usb_dev_descr_t));
5885 	usb_dev_descr.bMaxPacketSize0 =
5886 	    (port_status == USBA_LOW_SPEED_DEV) ? 8 : 64;
5887 	bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
5888 	    sizeof (usb_dev_descr_t));
5889 	child_ud->usb_port = port;
5890 	child_ud->usb_hs_hub_usba_dev = parent_usba_dev;
5891 	child_ud->usb_hs_hub_addr = parent_usb_addr;
5892 	child_ud->usb_hs_hub_port = parent_usb_port;
5893 	mutex_exit(&child_ud->usb_mutex);
5894 
5895 	/* Open the default pipe */
5896 	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
5897 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) != USB_SUCCESS) {
5898 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5899 		    "usb_pipe_open failed (%d)", rval);
5900 
5901 		goto fail_cleanup;
5902 	}
5903 
5904 	/*
5905 	 * get device descriptor
5906 	 */
5907 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5908 	    "hubd_create_child: get device descriptor: 64 bytes");
5909 
5910 	rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
5911 	    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
5912 	    USB_REQ_GET_DESCR,			/* bRequest */
5913 	    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
5914 	    0,					/* wIndex */
5915 	    64,					/* wLength */
5916 	    &pdata, USB_ATTRS_SHORT_XFER_OK,
5917 	    &completion_reason, &cb_flags, 0);
5918 
5919 	if ((rval != USB_SUCCESS) &&
5920 	    (!((completion_reason == USB_CR_DATA_OVERRUN) && pdata))) {
5921 
5922 		/*
5923 		 * rval != USB_SUCCESS AND
5924 		 * completion_reason != USB_CR_DATA_OVERRUN
5925 		 * pdata could be != NULL.
5926 		 * Free pdata now to prevent memory leak.
5927 		 */
5928 		freemsg(pdata);
5929 		pdata = NULL;
5930 
5931 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5932 		    "hubd_create_child: get device descriptor: 8 bytes");
5933 
5934 		rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
5935 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
5936 		    USB_REQ_GET_DESCR,			/* bRequest */
5937 		    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
5938 		    0,					/* wIndex */
5939 		    8,					/* wLength */
5940 		    &pdata, USB_ATTRS_NONE,
5941 		    &completion_reason, &cb_flags, 0);
5942 
5943 		if (rval != USB_SUCCESS) {
5944 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5945 			    "getting device descriptor failed (%s 0x%x %d)",
5946 			    usb_str_cr(completion_reason), cb_flags, rval);
5947 			goto fail_cleanup;
5948 		}
5949 	} else {
5950 		ASSERT(completion_reason == USB_CR_OK);
5951 	}
5952 
5953 	ASSERT(pdata != NULL);
5954 
5955 	size = usb_parse_dev_descr(
5956 	    pdata->b_rptr,
5957 	    MBLKL(pdata),
5958 	    &usb_dev_descr,
5959 	    sizeof (usb_dev_descr_t));
5960 
5961 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5962 	    "parsing device descriptor returned %lu", size);
5963 
5964 	length = *(pdata->b_rptr);
5965 	freemsg(pdata);
5966 	pdata = NULL;
5967 	if (size < 8) {
5968 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5969 		    "get device descriptor returned %lu bytes", size);
5970 
5971 		goto fail_cleanup;
5972 	}
5973 
5974 	if (length < 8) {
5975 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5976 		    "fail enumeration: bLength=%d", length);
5977 
5978 		goto fail_cleanup;
5979 	}
5980 
5981 	/* Set the address of the device */
5982 	if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
5983 	    USB_DEV_REQ_HOST_TO_DEV,
5984 	    USB_REQ_SET_ADDRESS,	/* bRequest */
5985 	    address,			/* wValue */
5986 	    0,				/* wIndex */
5987 	    0,				/* wLength */
5988 	    NULL, 0,
5989 	    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
5990 		char buffer[64];
5991 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
5992 		    "setting address failed (cr=%s cb_flags=%s rval=%d)",
5993 		    usb_str_cr(completion_reason),
5994 		    usb_str_cb_flags(cb_flags, buffer, sizeof (buffer)),
5995 		    rval);
5996 
5997 		goto fail_cleanup;
5998 	}
5999 
6000 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6001 	    "set address 0x%x done", address);
6002 
6003 	/* now close the pipe for addr 0 */
6004 	usb_pipe_close(child_dip, ph,
6005 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
6006 
6007 	/*
6008 	 * This delay is important for the CATC hub to enumerate
6009 	 * But, avoid delay in the first iteration
6010 	 */
6011 	if (iteration) {
6012 		delay(drv_usectohz(hubd_device_delay/100));
6013 	}
6014 
6015 	/* assign the address in the usba_device structure */
6016 	mutex_enter(&child_ud->usb_mutex);
6017 	child_ud->usb_addr = address;
6018 	child_ud->usb_no_cpr = 0;
6019 	child_ud->usb_port_status = port_status;
6020 	/* save this device descriptor */
6021 	bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
6022 	    sizeof (usb_dev_descr_t));
6023 	child_ud->usb_n_cfgs = usb_dev_descr.bNumConfigurations;
6024 	mutex_exit(&child_ud->usb_mutex);
6025 
6026 	/* re-open the pipe for the device with the new address */
6027 	if ((rval = usb_pipe_open(child_dip, NULL, NULL,
6028 	    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, &ph)) != USB_SUCCESS) {
6029 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6030 		    "usb_pipe_open failed (%d)", rval);
6031 
6032 		goto fail_cleanup;
6033 	}
6034 
6035 	/*
6036 	 * Get full device descriptor only if we have not received full
6037 	 * device descriptor earlier.
6038 	 */
6039 	if (size < length) {
6040 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6041 		    "hubd_create_child: get full device descriptor: "
6042 		    "%d bytes", length);
6043 
6044 		if ((rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
6045 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
6046 		    USB_REQ_GET_DESCR,			/* bRequest */
6047 		    USB_DESCR_TYPE_SETUP_DEV,		/* wValue */
6048 		    0,					/* wIndex */
6049 		    length,				/* wLength */
6050 		    &pdata, 0,
6051 		    &completion_reason, &cb_flags, 0)) != USB_SUCCESS) {
6052 			freemsg(pdata);
6053 			pdata = NULL;
6054 
6055 			USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG,
6056 			    hubd->h_log_handle,
6057 			    "hubd_create_child: get full device descriptor: "
6058 			    "64 bytes");
6059 
6060 			rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
6061 			    USB_DEV_REQ_DEV_TO_HOST |
6062 			    USB_DEV_REQ_TYPE_STANDARD,
6063 			    USB_REQ_GET_DESCR,		/* bRequest */
6064 			    USB_DESCR_TYPE_SETUP_DEV,	/* wValue */
6065 			    0,				/* wIndex */
6066 			    64,				/* wLength */
6067 			    &pdata, USB_ATTRS_SHORT_XFER_OK,
6068 			    &completion_reason, &cb_flags, 0);
6069 
6070 			/* we have to trust the data now */
6071 			if (pdata) {
6072 				int len = *(pdata->b_rptr);
6073 
6074 				length = MBLKL(pdata);
6075 				if (length < len) {
6076 
6077 					goto fail_cleanup;
6078 				}
6079 			} else if (rval != USB_SUCCESS) {
6080 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
6081 				    hubd->h_log_handle,
6082 				    "getting device descriptor failed "
6083 				    "(%d 0x%x %d)",
6084 				    completion_reason, cb_flags, rval);
6085 
6086 				goto fail_cleanup;
6087 			}
6088 		}
6089 
6090 		size = usb_parse_dev_descr(
6091 		    pdata->b_rptr,
6092 		    MBLKL(pdata),
6093 		    &usb_dev_descr,
6094 		    sizeof (usb_dev_descr_t));
6095 
6096 		USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6097 		    "parsing device descriptor returned %lu", size);
6098 
6099 		/*
6100 		 * For now, free the data
6101 		 * eventually, each configuration may need to be looked at
6102 		 */
6103 		freemsg(pdata);
6104 		pdata = NULL;
6105 
6106 		if (size != USB_DEV_DESCR_SIZE) {
6107 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6108 			    "fail enumeration: descriptor size=%lu "
6109 			    "expected size=%u", size, USB_DEV_DESCR_SIZE);
6110 
6111 			goto fail_cleanup;
6112 		}
6113 
6114 		/*
6115 		 * save the device descriptor in usba_device since it is needed
6116 		 * later on again
6117 		 */
6118 		mutex_enter(&child_ud->usb_mutex);
6119 		bcopy(&usb_dev_descr, child_ud->usb_dev_descr,
6120 		    sizeof (usb_dev_descr_t));
6121 		child_ud->usb_n_cfgs = usb_dev_descr.bNumConfigurations;
6122 		mutex_exit(&child_ud->usb_mutex);
6123 	}
6124 
6125 	if (usb_dev_descr.bNumConfigurations == 0) {
6126 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6127 		    "device descriptor:\n\t"
6128 		    "l=0x%x type=0x%x USB=0x%x class=0x%x subclass=0x%x\n\t"
6129 		    "protocol=0x%x maxpktsize=0x%x "
6130 		    "Vid=0x%x Pid=0x%x rel=0x%x\n\t"
6131 		    "Mfg=0x%x P=0x%x sn=0x%x #config=0x%x",
6132 		    usb_dev_descr.bLength, usb_dev_descr.bDescriptorType,
6133 		    usb_dev_descr.bcdUSB, usb_dev_descr.bDeviceClass,
6134 		    usb_dev_descr.bDeviceSubClass,
6135 		    usb_dev_descr.bDeviceProtocol,
6136 		    usb_dev_descr.bMaxPacketSize0,
6137 		    usb_dev_descr.idVendor,
6138 		    usb_dev_descr.idProduct, usb_dev_descr.bcdDevice,
6139 		    usb_dev_descr.iManufacturer, usb_dev_descr.iProduct,
6140 		    usb_dev_descr.iSerialNumber,
6141 		    usb_dev_descr.bNumConfigurations);
6142 		goto fail_cleanup;
6143 	}
6144 
6145 
6146 	/* get the device string descriptor(s) */
6147 	usba_get_dev_string_descrs(child_dip, child_ud);
6148 
6149 	/* retrieve config cloud for all configurations */
6150 	rval = hubd_get_all_device_config_cloud(hubd, child_dip, child_ud);
6151 	if (rval != USB_SUCCESS) {
6152 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6153 		    "failed to get configuration descriptor(s)");
6154 
6155 		goto fail_cleanup;
6156 	}
6157 
6158 	/* get the preferred configuration for this device */
6159 	user_conf_index = hubd_select_device_configuration(hubd, port,
6160 	    child_dip, child_ud);
6161 
6162 	/* Check if the user selected configuration index is in range */
6163 	if ((user_conf_index >= usb_dev_descr.bNumConfigurations) ||
6164 	    (user_conf_index < 0)) {
6165 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6166 		    "Configuration index for device idVendor=%d "
6167 		    "idProduct=%d is=%d, and is out of range[0..%d]",
6168 		    usb_dev_descr.idVendor, usb_dev_descr.idProduct,
6169 		    user_conf_index, usb_dev_descr.bNumConfigurations - 1);
6170 
6171 		/* treat this as user didn't specify configuration */
6172 		user_conf_index = USBA_DEV_CONFIG_INDEX_UNDEFINED;
6173 	}
6174 
6175 
6176 	/*
6177 	 * Warn users of a performance hit if connecting a
6178 	 * High Speed behind a 1.1 hub, which is behind a
6179 	 * 2.0 port.
6180 	 */
6181 	if ((parent_port_status != USBA_HIGH_SPEED_DEV) &&
6182 	    !(usba_is_root_hub(parent_ud->usb_dip)) &&
6183 	    (parent_usb_addr)) {
6184 
6185 		/*
6186 		 * Now that we know the root port is a high speed port
6187 		 * and that the parent port is not a high speed port,
6188 		 * let's find out if the device itself is a high speed
6189 		 * device.  If it is a high speed device,
6190 		 * USB_DESCR_TYPE_SETUP_DEV_QLF should return a value,
6191 		 * otherwise the command will fail.
6192 		 */
6193 		rval = usb_pipe_sync_ctrl_xfer(child_dip, ph,
6194 		    USB_DEV_REQ_DEV_TO_HOST | USB_DEV_REQ_TYPE_STANDARD,
6195 		    USB_REQ_GET_DESCR,			/* bRequest */
6196 		    USB_DESCR_TYPE_SETUP_DEV_QLF,	/* wValue */
6197 		    0,					/* wIndex */
6198 		    10,					/* wLength */
6199 		    &pdata, USB_ATTRS_SHORT_XFER_OK,
6200 		    &completion_reason, &cb_flags, 0);
6201 
6202 		if (pdata) {
6203 			freemsg(pdata);
6204 			pdata = NULL;
6205 		}
6206 
6207 		/*
6208 		 * USB_DESCR_TYPE_SETUP_DEV_QLF query was successful
6209 		 * that means this is a high speed device behind a
6210 		 * high speed root hub, but running at full speed
6211 		 * because there is a full speed hub in the middle.
6212 		 */
6213 		if (rval == USB_SUCCESS) {
6214 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
6215 			    hubd->h_log_handle,
6216 			    "Connecting a high speed device to a "
6217 			    "non high speed hub (port %d) will result "
6218 			    "in a loss of performance.	Please connect "
6219 			    "the device to a high speed hub to get "
6220 			    "the maximum performance.",
6221 			    port);
6222 		}
6223 	}
6224 
6225 	/*
6226 	 * Now we try to online the device by attaching a driver
6227 	 * The following truth table illustrates the logic:-
6228 	 * Cfgndx	Driver	Action
6229 	 * 0		0	loop all configs for driver with full
6230 	 *			compatible properties.
6231 	 * 0		1	set first configuration,
6232 	 *			compatible prop = drivername.
6233 	 * 1		0	Set config, full compatible prop
6234 	 * 1		1	Set config, compatible prop = drivername.
6235 	 *
6236 	 * Note:
6237 	 *	cfgndx = user_conf_index
6238 	 *	Driver = usb_preferred_driver
6239 	 */
6240 	if (user_conf_index == USBA_DEV_CONFIG_INDEX_UNDEFINED) {
6241 		if (child_ud->usb_preferred_driver) {
6242 			/*
6243 			 * It is the job of the "preferred driver" to put the
6244 			 * device in the desired configuration. Till then
6245 			 * put the device in config index 0.
6246 			 */
6247 			if ((rval = usba_hubdi_check_power_budget(dip, child_ud,
6248 			    USB_DEV_DEFAULT_CONFIG_INDEX)) != USB_SUCCESS) {
6249 
6250 				goto fail_cleanup;
6251 			}
6252 
6253 			child_dip = hubd_ready_device(hubd, child_dip,
6254 			    child_ud, USB_DEV_DEFAULT_CONFIG_INDEX);
6255 
6256 			/*
6257 			 * Assign the dip before onlining to avoid race
6258 			 * with busctl
6259 			 */
6260 			mutex_enter(HUBD_MUTEX(hubd));
6261 			hubd->h_children_dips[port] = child_dip;
6262 			mutex_exit(HUBD_MUTEX(hubd));
6263 
6264 			(void) usba_bind_driver(child_dip);
6265 		} else {
6266 			/*
6267 			 * loop through all the configurations to see if we
6268 			 * can find a driver for any one config. If not, set
6269 			 * the device in config_index 0
6270 			 */
6271 			rval = USB_FAILURE;
6272 			for (config_index = 0;
6273 			    (config_index < usb_dev_descr.bNumConfigurations) &&
6274 			    (rval != USB_SUCCESS); config_index++) {
6275 
6276 				child_dip = hubd_ready_device(hubd, child_dip,
6277 				    child_ud, config_index);
6278 
6279 				/*
6280 				 * Assign the dip before onlining to avoid race
6281 				 * with busctl
6282 				 */
6283 				mutex_enter(HUBD_MUTEX(hubd));
6284 				hubd->h_children_dips[port] = child_dip;
6285 				mutex_exit(HUBD_MUTEX(hubd));
6286 
6287 				rval = usba_bind_driver(child_dip);
6288 
6289 				/*
6290 				 * Normally power budget should be checked
6291 				 * before device is configured. A failure in
6292 				 * power budget checking will stop the device
6293 				 * from being configured with current
6294 				 * config_index and may enable the device to
6295 				 * be configured in another configuration.
6296 				 * This may break the user experience that a
6297 				 * device which previously worked in config
6298 				 * A now works in config B after power budget
6299 				 * control is enabled. To avoid such situation,
6300 				 * power budget checking is moved here and will
6301 				 * fail the child creation directly if config
6302 				 * A exceeds the power available.
6303 				 */
6304 				if (rval == USB_SUCCESS) {
6305 					if ((usba_hubdi_check_power_budget(dip,
6306 					    child_ud, config_index)) !=
6307 					    USB_SUCCESS) {
6308 
6309 						goto fail_cleanup;
6310 					}
6311 				}
6312 			}
6313 			if (rval != USB_SUCCESS) {
6314 
6315 				if ((usba_hubdi_check_power_budget(dip,
6316 				    child_ud, 0)) != USB_SUCCESS) {
6317 
6318 					goto fail_cleanup;
6319 				}
6320 
6321 				child_dip = hubd_ready_device(hubd, child_dip,
6322 				    child_ud, 0);
6323 				mutex_enter(HUBD_MUTEX(hubd));
6324 				hubd->h_children_dips[port] = child_dip;
6325 				mutex_exit(HUBD_MUTEX(hubd));
6326 			}
6327 		} /* end else loop all configs */
6328 	} else {
6329 
6330 		if ((usba_hubdi_check_power_budget(dip, child_ud,
6331 		    (uint_t)user_conf_index)) != USB_SUCCESS) {
6332 
6333 			goto fail_cleanup;
6334 		}
6335 
6336 		child_dip = hubd_ready_device(hubd, child_dip,
6337 		    child_ud, (uint_t)user_conf_index);
6338 
6339 		/*
6340 		 * Assign the dip before onlining to avoid race
6341 		 * with busctl
6342 		 */
6343 		mutex_enter(HUBD_MUTEX(hubd));
6344 		hubd->h_children_dips[port] = child_dip;
6345 		mutex_exit(HUBD_MUTEX(hubd));
6346 
6347 		(void) usba_bind_driver(child_dip);
6348 	}
6349 
6350 	usba_hubdi_decr_power_budget(dip, child_ud);
6351 
6352 	mutex_enter(HUBD_MUTEX(hubd));
6353 	if (hubd->h_usba_devices[port] == NULL) {
6354 		hubd->h_usba_devices[port] = usba_get_usba_device(child_dip);
6355 	} else {
6356 		ASSERT(hubd->h_usba_devices[port] ==
6357 		    usba_get_usba_device(child_dip));
6358 	}
6359 
6360 	return (USB_SUCCESS);
6361 
6362 
6363 fail_cleanup:
6364 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6365 	    "hubd_create_child: fail_cleanup");
6366 
6367 	mutex_enter(HUBD_MUTEX(hubd));
6368 	hubd->h_children_dips[port] = NULL;
6369 	mutex_exit(HUBD_MUTEX(hubd));
6370 
6371 	if (pdata) {
6372 		freemsg(pdata);
6373 	}
6374 
6375 	if (ph) {
6376 		usb_pipe_close(child_dip, ph,
6377 		    USB_FLAGS_SLEEP | USBA_FLAGS_PRIVILEGED, NULL, NULL);
6378 	}
6379 
6380 	if (child_dip) {
6381 		int rval = usba_destroy_child_devi(child_dip,
6382 		    NDI_DEVI_REMOVE);
6383 		if (rval != USB_SUCCESS) {
6384 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6385 			    "failure to remove child node");
6386 		}
6387 	}
6388 
6389 	if (child_ud) {
6390 		/* to make sure we free the address */
6391 		mutex_enter(&child_ud->usb_mutex);
6392 		child_ud->usb_addr = address;
6393 		ASSERT(child_ud->usb_ref_count == 0);
6394 		mutex_exit(&child_ud->usb_mutex);
6395 
6396 		mutex_enter(HUBD_MUTEX(hubd));
6397 		if (hubd->h_usba_devices[port] == NULL) {
6398 			mutex_exit(HUBD_MUTEX(hubd));
6399 			usba_free_usba_device(child_ud);
6400 		} else {
6401 			hubd_free_usba_device(hubd, hubd->h_usba_devices[port]);
6402 			mutex_exit(HUBD_MUTEX(hubd));
6403 		}
6404 	}
6405 
6406 	mutex_enter(HUBD_MUTEX(hubd));
6407 
6408 	return (USB_FAILURE);
6409 }
6410 
6411 
6412 /*
6413  * hubd_delete_child:
6414  *	- free usb address
6415  *	- lookup child dips, there may be multiple on this port
6416  *	- offline each child devi
6417  */
6418 static int
6419 hubd_delete_child(hubd_t *hubd, usb_port_t port, uint_t flag, boolean_t retry)
6420 {
6421 	dev_info_t	*child_dip;
6422 	usba_device_t	*usba_device;
6423 	int		rval = USB_SUCCESS;
6424 
6425 	child_dip = hubd->h_children_dips[port];
6426 	usba_device = hubd->h_usba_devices[port];
6427 
6428 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6429 	    "hubd_delete_child: port=%d, dip=0x%p usba_device=0x%p",
6430 	    port, (void *)child_dip, (void *)usba_device);
6431 
6432 	mutex_exit(HUBD_MUTEX(hubd));
6433 	if (child_dip) {
6434 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6435 		    "hubd_delete_child:\n\t"
6436 		    "dip = 0x%p (%s) at port %d",
6437 		    (void *)child_dip, ddi_node_name(child_dip), port);
6438 
6439 		if (usba_device) {
6440 			usba_hubdi_incr_power_budget(hubd->h_dip, usba_device);
6441 		}
6442 
6443 		rval = usba_destroy_child_devi(child_dip, flag);
6444 
6445 		if ((rval != USB_SUCCESS) && usba_is_hwa(child_dip)) {
6446 			/*
6447 			 * This is only useful for HWA device node.
6448 			 * Since hwahc interface must hold hwarc interface
6449 			 * open until hwahc is detached, the first call to
6450 			 * ndi_devi_unconfig_one() can only offline hwahc
6451 			 * driver but not hwarc driver. Need to make a second
6452 			 * call to ndi_devi_unconfig_one() to make the hwarc
6453 			 * driver detach.
6454 			 */
6455 			rval = usba_destroy_child_devi(child_dip, flag);
6456 		}
6457 
6458 		if ((rval == USB_SUCCESS) && (flag & NDI_DEVI_REMOVE)) {
6459 			/*
6460 			 * if the child was still < DS_INITIALIZED
6461 			 * then our bus_unconfig was not called and
6462 			 * we have to zap the child here
6463 			 */
6464 			mutex_enter(HUBD_MUTEX(hubd));
6465 			if (hubd->h_children_dips[port] == child_dip) {
6466 				usba_device_t *ud =
6467 				    hubd->h_usba_devices[port];
6468 					hubd->h_children_dips[port] = NULL;
6469 				if (ud) {
6470 					mutex_exit(HUBD_MUTEX(hubd));
6471 
6472 					mutex_enter(&ud->usb_mutex);
6473 					ud->usb_ref_count = 0;
6474 					mutex_exit(&ud->usb_mutex);
6475 
6476 					usba_free_usba_device(ud);
6477 					mutex_enter(HUBD_MUTEX(hubd));
6478 					hubd->h_usba_devices[port] = NULL;
6479 				}
6480 			}
6481 			mutex_exit(HUBD_MUTEX(hubd));
6482 		}
6483 	}
6484 
6485 	if ((rval != USB_SUCCESS) && retry) {
6486 
6487 		hubd_schedule_cleanup(usba_device->usb_root_hub_dip);
6488 	}
6489 	mutex_enter(HUBD_MUTEX(hubd));
6490 
6491 	return (rval);
6492 }
6493 
6494 
6495 /*
6496  * hubd_free_usba_device:
6497  *	free usb device structure unless it is associated with
6498  *	the root hub which is handled differently
6499  */
6500 static void
6501 hubd_free_usba_device(hubd_t *hubd, usba_device_t *usba_device)
6502 {
6503 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6504 	    "hubd_free_usba_device: hubd=0x%p, usba_device=0x%p",
6505 	    (void *)hubd, (void *)usba_device);
6506 
6507 	if (usba_device && (usba_device->usb_addr != ROOT_HUB_ADDR)) {
6508 		usb_port_t port = usba_device->usb_port;
6509 		dev_info_t *dip = hubd->h_children_dips[port];
6510 
6511 #ifdef DEBUG
6512 		if (dip) {
6513 			ASSERT(i_ddi_node_state(dip) < DS_INITIALIZED);
6514 		}
6515 #endif
6516 
6517 		port = usba_device->usb_port;
6518 		hubd->h_usba_devices[port] = NULL;
6519 
6520 		mutex_exit(HUBD_MUTEX(hubd));
6521 		usba_free_usba_device(usba_device);
6522 		mutex_enter(HUBD_MUTEX(hubd));
6523 	}
6524 }
6525 
6526 
6527 /*
6528  * event support
6529  *
6530  * busctl event support
6531  */
6532 static int
6533 hubd_busop_get_eventcookie(dev_info_t *dip,
6534 	dev_info_t	*rdip,
6535 	char		*eventname,
6536 	ddi_eventcookie_t *cookie)
6537 {
6538 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
6539 
6540 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6541 	    "hubd_busop_get_eventcookie: dip=0x%p, rdip=0x%p, "
6542 	    "event=%s", (void *)dip, (void *)rdip, eventname);
6543 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6544 	    "(dip=%s%d, rdip=%s%d)",
6545 	    ddi_driver_name(dip), ddi_get_instance(dip),
6546 	    ddi_driver_name(rdip), ddi_get_instance(rdip));
6547 
6548 	/* return event cookie, iblock cookie, and level */
6549 	return (ndi_event_retrieve_cookie(hubd->h_ndi_event_hdl,
6550 	    rdip, eventname, cookie, NDI_EVENT_NOPASS));
6551 }
6552 
6553 
6554 static int
6555 hubd_busop_add_eventcall(dev_info_t *dip,
6556 	dev_info_t	*rdip,
6557 	ddi_eventcookie_t cookie,
6558 	void		(*callback)(dev_info_t *dip,
6559 			ddi_eventcookie_t cookie, void *arg,
6560 			void *bus_impldata),
6561 	void *arg, ddi_callback_id_t *cb_id)
6562 {
6563 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
6564 	usb_port_t port = hubd_child_dip2port(hubd, rdip);
6565 
6566 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6567 	    "hubd_busop_add_eventcall: dip=0x%p, rdip=0x%p "
6568 	    "cookie=0x%p, cb=0x%p, arg=0x%p",
6569 	    (void *)dip, (void *)rdip, (void *)cookie, (void *)callback, arg);
6570 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6571 	    "(dip=%s%d, rdip=%s%d, event=%s)",
6572 	    ddi_driver_name(dip), ddi_get_instance(dip),
6573 	    ddi_driver_name(rdip), ddi_get_instance(rdip),
6574 	    ndi_event_cookie_to_name(hubd->h_ndi_event_hdl, cookie));
6575 
6576 	/* Set flag on children registering events */
6577 	switch (ndi_event_cookie_to_tag(hubd->h_ndi_event_hdl, cookie)) {
6578 	case USBA_EVENT_TAG_HOT_REMOVAL:
6579 		mutex_enter(HUBD_MUTEX(hubd));
6580 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_DISCONNECT;
6581 		mutex_exit(HUBD_MUTEX(hubd));
6582 
6583 		break;
6584 	case USBA_EVENT_TAG_PRE_SUSPEND:
6585 		mutex_enter(HUBD_MUTEX(hubd));
6586 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_PRESUSPEND;
6587 		mutex_exit(HUBD_MUTEX(hubd));
6588 
6589 		break;
6590 	default:
6591 
6592 		break;
6593 	}
6594 
6595 	/* add callback to our event set */
6596 	return (ndi_event_add_callback(hubd->h_ndi_event_hdl,
6597 	    rdip, cookie, callback, arg, NDI_SLEEP, cb_id));
6598 }
6599 
6600 
6601 static int
6602 hubd_busop_remove_eventcall(dev_info_t *dip, ddi_callback_id_t cb_id)
6603 {
6604 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
6605 	ndi_event_callbacks_t *id = (ndi_event_callbacks_t *)cb_id;
6606 
6607 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6608 	    "hubd_busop_remove_eventcall: dip=0x%p, rdip=0x%p "
6609 	    "cookie=0x%p", (void *)dip, (void *)id->ndi_evtcb_dip,
6610 	    (void *)id->ndi_evtcb_cookie);
6611 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6612 	    "(dip=%s%d, rdip=%s%d, event=%s)",
6613 	    ddi_driver_name(dip), ddi_get_instance(dip),
6614 	    ddi_driver_name(id->ndi_evtcb_dip),
6615 	    ddi_get_instance(id->ndi_evtcb_dip),
6616 	    ndi_event_cookie_to_name(hubd->h_ndi_event_hdl,
6617 	    id->ndi_evtcb_cookie));
6618 
6619 	/* remove event registration from our event set */
6620 	return (ndi_event_remove_callback(hubd->h_ndi_event_hdl, cb_id));
6621 }
6622 
6623 
6624 /*
6625  * event distribution
6626  *
6627  * hubd_do_callback:
6628  *	Post this event to the specified child
6629  */
6630 static void
6631 hubd_do_callback(hubd_t *hubd, dev_info_t *cdip, ddi_eventcookie_t cookie)
6632 {
6633 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6634 	    "hubd_do_callback");
6635 
6636 	(void) ndi_event_do_callback(hubd->h_ndi_event_hdl, cdip, cookie, NULL);
6637 }
6638 
6639 
6640 /*
6641  * hubd_run_callbacks:
6642  *	Send this event to all children
6643  */
6644 static void
6645 hubd_run_callbacks(hubd_t *hubd, usba_event_t type)
6646 {
6647 	usb_port_t	port;
6648 
6649 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6650 	    "hubd_run_callbacks");
6651 
6652 	mutex_enter(HUBD_MUTEX(hubd));
6653 	for (port = 1; port <= hubd->h_hub_descr.bNbrPorts; port++) {
6654 		/*
6655 		 * the childen_dips list may have dips that have been
6656 		 * already deallocated. we only get a post_detach notification
6657 		 * but not a destroy notification
6658 		 */
6659 		if (hubd->h_children_dips[port]) {
6660 			mutex_exit(HUBD_MUTEX(hubd));
6661 			hubd_post_event(hubd, port, type);
6662 			mutex_enter(HUBD_MUTEX(hubd));
6663 		}
6664 	}
6665 	mutex_exit(HUBD_MUTEX(hubd));
6666 }
6667 
6668 
6669 /*
6670  * hubd_post_event
6671  *	post event to a child on the port depending on the type
6672  */
6673 static void
6674 hubd_post_event(hubd_t *hubd, usb_port_t port, usba_event_t type)
6675 {
6676 	int	rval;
6677 	dev_info_t	*dip;
6678 	usba_device_t	*usba_device;
6679 	ddi_eventcookie_t cookie, rm_cookie, suspend_cookie;
6680 
6681 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6682 	    "hubd_post_event: port=%d event=%s", port,
6683 	    ndi_event_tag_to_name(hubd->h_ndi_event_hdl, type));
6684 
6685 	cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl, type);
6686 	rm_cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl,
6687 	    USBA_EVENT_TAG_HOT_REMOVAL);
6688 	suspend_cookie = ndi_event_tag_to_cookie(hubd->h_ndi_event_hdl,
6689 	    USBA_EVENT_TAG_PRE_SUSPEND);
6690 
6691 	/*
6692 	 * Hotplug daemon may be attaching a driver that may be registering
6693 	 * event callbacks. So it already has got the device tree lock and
6694 	 * event handle mutex. So to prevent a deadlock while posting events,
6695 	 * we grab and release the locks in the same order.
6696 	 */
6697 	mutex_enter(HUBD_MUTEX(hubd));
6698 	dip = hubd->h_children_dips[port];
6699 	usba_device = hubd->h_usba_devices[port];
6700 	mutex_exit(HUBD_MUTEX(hubd));
6701 
6702 	switch (type) {
6703 	case USBA_EVENT_TAG_HOT_REMOVAL:
6704 		/* Clear the registered event flag */
6705 		mutex_enter(HUBD_MUTEX(hubd));
6706 		hubd->h_child_events[port] &= ~HUBD_CHILD_EVENT_DISCONNECT;
6707 		mutex_exit(HUBD_MUTEX(hubd));
6708 
6709 		hubd_do_callback(hubd, dip, cookie);
6710 		usba_persistent_pipe_close(usba_device);
6711 
6712 		/*
6713 		 * Mark the dip for deletion only after the driver has
6714 		 * seen the disconnect event to prevent cleanup thread
6715 		 * from stepping in between.
6716 		 */
6717 		mutex_enter(&(DEVI(dip)->devi_lock));
6718 		DEVI_SET_DEVICE_REMOVED(dip);
6719 		mutex_exit(&(DEVI(dip)->devi_lock));
6720 
6721 		break;
6722 	case USBA_EVENT_TAG_PRE_SUSPEND:
6723 		mutex_enter(HUBD_MUTEX(hubd));
6724 		hubd->h_child_events[port] &= ~HUBD_CHILD_EVENT_PRESUSPEND;
6725 		mutex_exit(HUBD_MUTEX(hubd));
6726 
6727 		hubd_do_callback(hubd, dip, cookie);
6728 		/*
6729 		 * persistent pipe close for this event is taken care by the
6730 		 * caller after verfying that all children can suspend
6731 		 */
6732 
6733 		break;
6734 	case USBA_EVENT_TAG_HOT_INSERTION:
6735 		/*
6736 		 * Check if this child has missed the disconnect event before
6737 		 * it registered for event callbacks
6738 		 */
6739 		mutex_enter(HUBD_MUTEX(hubd));
6740 		if (hubd->h_child_events[port] & HUBD_CHILD_EVENT_DISCONNECT) {
6741 			/* clear the flag and post disconnect event */
6742 			hubd->h_child_events[port] &=
6743 			    ~HUBD_CHILD_EVENT_DISCONNECT;
6744 			mutex_exit(HUBD_MUTEX(hubd));
6745 			hubd_do_callback(hubd, dip, rm_cookie);
6746 			usba_persistent_pipe_close(usba_device);
6747 			mutex_enter(HUBD_MUTEX(hubd));
6748 		}
6749 		mutex_exit(HUBD_MUTEX(hubd));
6750 
6751 		/*
6752 		 * Mark the dip as reinserted to prevent cleanup thread
6753 		 * from stepping in.
6754 		 */
6755 		mutex_enter(&(DEVI(dip)->devi_lock));
6756 		DEVI_SET_DEVICE_REINSERTED(dip);
6757 		mutex_exit(&(DEVI(dip)->devi_lock));
6758 
6759 		rval = usba_persistent_pipe_open(usba_device);
6760 		if (rval != USB_SUCCESS) {
6761 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
6762 			    hubd->h_log_handle,
6763 			    "failed to reopen all pipes on reconnect");
6764 		}
6765 
6766 		hubd_do_callback(hubd, dip, cookie);
6767 
6768 		/*
6769 		 * We might see a connect event only if hotplug thread for
6770 		 * disconnect event don't run in time.
6771 		 * Set the flag again, so we don't miss posting a
6772 		 * disconnect event.
6773 		 */
6774 		mutex_enter(HUBD_MUTEX(hubd));
6775 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_DISCONNECT;
6776 		mutex_exit(HUBD_MUTEX(hubd));
6777 
6778 		break;
6779 	case USBA_EVENT_TAG_POST_RESUME:
6780 		/*
6781 		 * Check if this child has missed the pre-suspend event before
6782 		 * it registered for event callbacks
6783 		 */
6784 		mutex_enter(HUBD_MUTEX(hubd));
6785 		if (hubd->h_child_events[port] & HUBD_CHILD_EVENT_PRESUSPEND) {
6786 			/* clear the flag and post pre_suspend event */
6787 			hubd->h_port_state[port] &=
6788 			    ~HUBD_CHILD_EVENT_PRESUSPEND;
6789 			mutex_exit(HUBD_MUTEX(hubd));
6790 			hubd_do_callback(hubd, dip, suspend_cookie);
6791 			mutex_enter(HUBD_MUTEX(hubd));
6792 		}
6793 		mutex_exit(HUBD_MUTEX(hubd));
6794 
6795 		mutex_enter(&usba_device->usb_mutex);
6796 		usba_device->usb_no_cpr = 0;
6797 		mutex_exit(&usba_device->usb_mutex);
6798 
6799 		/*
6800 		 * Since the pipe has already been opened by hub
6801 		 * at DDI_RESUME time, there is no need for a
6802 		 * persistent pipe open
6803 		 */
6804 		hubd_do_callback(hubd, dip, cookie);
6805 
6806 		/*
6807 		 * Set the flag again, so we don't miss posting a
6808 		 * pre-suspend event. This enforces a tighter
6809 		 * dev_state model.
6810 		 */
6811 		mutex_enter(HUBD_MUTEX(hubd));
6812 		hubd->h_child_events[port] |= HUBD_CHILD_EVENT_PRESUSPEND;
6813 		mutex_exit(HUBD_MUTEX(hubd));
6814 		break;
6815 	}
6816 }
6817 
6818 
6819 /*
6820  * handling of events coming from above
6821  */
6822 static int
6823 hubd_disconnect_event_cb(dev_info_t *dip)
6824 {
6825 	hubd_t		*hubd = (hubd_t *)hubd_get_soft_state(dip);
6826 	usb_port_t	port, nports;
6827 	usba_device_t	*usba_dev;
6828 	usba_event_t	tag = USBA_EVENT_TAG_HOT_REMOVAL;
6829 	int		circ;
6830 
6831 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6832 	    "hubd_disconnect_event_cb: tag=%d", tag);
6833 
6834 	ndi_devi_enter(dip, &circ);
6835 
6836 	mutex_enter(HUBD_MUTEX(hubd));
6837 	switch (hubd->h_dev_state) {
6838 	case USB_DEV_ONLINE:
6839 	case USB_DEV_PWRED_DOWN:
6840 		hubd->h_dev_state = USB_DEV_DISCONNECTED;
6841 		/* stop polling on the interrupt pipe */
6842 		hubd_stop_polling(hubd);
6843 
6844 		/* FALLTHROUGH */
6845 	case USB_DEV_SUSPENDED:
6846 		/* we remain in this state */
6847 		mutex_exit(HUBD_MUTEX(hubd));
6848 		hubd_run_callbacks(hubd, tag);
6849 		mutex_enter(HUBD_MUTEX(hubd));
6850 
6851 		/* close all the open pipes of our children */
6852 		nports = hubd->h_hub_descr.bNbrPorts;
6853 		for (port = 1; port <= nports; port++) {
6854 			usba_dev = hubd->h_usba_devices[port];
6855 			if (usba_dev != NULL) {
6856 				mutex_exit(HUBD_MUTEX(hubd));
6857 				usba_persistent_pipe_close(usba_dev);
6858 				mutex_enter(HUBD_MUTEX(hubd));
6859 			}
6860 		}
6861 
6862 		break;
6863 	case USB_DEV_DISCONNECTED:
6864 		/* avoid passing multiple disconnects to children */
6865 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6866 		    "hubd_disconnect_event_cb: Already disconnected");
6867 
6868 		break;
6869 	default:
6870 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6871 		    "hubd_disconnect_event_cb: Illegal devstate=%d",
6872 		    hubd->h_dev_state);
6873 
6874 		break;
6875 	}
6876 	mutex_exit(HUBD_MUTEX(hubd));
6877 
6878 	ndi_devi_exit(dip, circ);
6879 
6880 	return (USB_SUCCESS);
6881 }
6882 
6883 
6884 static int
6885 hubd_reconnect_event_cb(dev_info_t *dip)
6886 {
6887 	int	rval, circ;
6888 
6889 	ndi_devi_enter(dip, &circ);
6890 	rval = hubd_restore_state_cb(dip);
6891 	ndi_devi_exit(dip, circ);
6892 
6893 	return (rval);
6894 }
6895 
6896 
6897 /*
6898  * hubd_pre_suspend_event_cb
6899  *	propogate event for binary compatibility of old drivers
6900  */
6901 static int
6902 hubd_pre_suspend_event_cb(dev_info_t *dip)
6903 {
6904 	int	circ;
6905 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
6906 
6907 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
6908 	    "hubd_pre_suspend_event_cb");
6909 
6910 	/* disable hotplug thread */
6911 	mutex_enter(HUBD_MUTEX(hubd));
6912 	hubd->h_hotplug_thread++;
6913 	hubd_stop_polling(hubd);
6914 
6915 	/* keep PM out till we see a cpr resume */
6916 	(void) hubd_pm_busy_component(hubd, hubd->h_dip, 0);
6917 	mutex_exit(HUBD_MUTEX(hubd));
6918 
6919 	ndi_devi_enter(dip, &circ);
6920 	hubd_run_callbacks(hubd, USBA_EVENT_TAG_PRE_SUSPEND);
6921 	ndi_devi_exit(dip, circ);
6922 
6923 	return (USB_SUCCESS);
6924 }
6925 
6926 
6927 /*
6928  * hubd_post_resume_event_cb
6929  *	propogate event for binary compatibility of old drivers
6930  */
6931 static int
6932 hubd_post_resume_event_cb(dev_info_t *dip)
6933 {
6934 	int	circ;
6935 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
6936 
6937 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
6938 	    "hubd_post_resume_event_cb");
6939 
6940 	ndi_devi_enter(dip, &circ);
6941 	hubd_run_callbacks(hubd, USBA_EVENT_TAG_POST_RESUME);
6942 	ndi_devi_exit(dip, circ);
6943 
6944 	mutex_enter(HUBD_MUTEX(hubd));
6945 
6946 	/* enable PM */
6947 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
6948 
6949 	/* allow hotplug thread */
6950 	hubd->h_hotplug_thread--;
6951 
6952 	/* start polling */
6953 	hubd_start_polling(hubd, 0);
6954 	mutex_exit(HUBD_MUTEX(hubd));
6955 
6956 	return (USB_SUCCESS);
6957 }
6958 
6959 
6960 /*
6961  * hubd_cpr_suspend
6962  *	save the current state of the driver/device
6963  */
6964 static int
6965 hubd_cpr_suspend(hubd_t *hubd)
6966 {
6967 	usb_port_t	port, nports;
6968 	usba_device_t	*usba_dev;
6969 	uchar_t		no_cpr = 0;
6970 	int		rval = USB_FAILURE;
6971 
6972 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
6973 	    "hubd_cpr_suspend: Begin");
6974 
6975 	/* Make sure device is powered up to save state. */
6976 	mutex_enter(HUBD_MUTEX(hubd));
6977 	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
6978 	mutex_exit(HUBD_MUTEX(hubd));
6979 
6980 	/* bring the device to full power */
6981 	(void) pm_raise_power(hubd->h_dip, 0, USB_DEV_OS_FULL_PWR);
6982 	mutex_enter(HUBD_MUTEX(hubd));
6983 
6984 	switch (hubd->h_dev_state) {
6985 	case USB_DEV_ONLINE:
6986 	case USB_DEV_PWRED_DOWN:
6987 	case USB_DEV_DISCONNECTED:
6988 		/* find out if all our children have been quiesced */
6989 		nports = hubd->h_hub_descr.bNbrPorts;
6990 		for (port = 1; (no_cpr == 0) && (port <= nports); port++) {
6991 			usba_dev = hubd->h_usba_devices[port];
6992 			if (usba_dev != NULL) {
6993 				mutex_enter(&usba_dev->usb_mutex);
6994 				no_cpr += usba_dev->usb_no_cpr;
6995 				mutex_exit(&usba_dev->usb_mutex);
6996 			}
6997 		}
6998 		if (no_cpr > 0) {
6999 			USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
7000 			    "Children busy - can't checkpoint");
7001 			/* remain in same state to fail checkpoint */
7002 
7003 			break;
7004 		} else {
7005 			/*
7006 			 * do not suspend if our hotplug thread
7007 			 * or the deathrow thread is active
7008 			 */
7009 			if ((hubd->h_hotplug_thread > 1) ||
7010 			    (hubd->h_cleanup_active == B_TRUE)) {
7011 				USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG,
7012 				    hubd->h_log_handle,
7013 				    "hotplug thread active  - can't cpr");
7014 				/* remain in same state to fail checkpoint */
7015 
7016 				break;
7017 			}
7018 
7019 			/* quiesce ourselves now */
7020 			hubd->h_dev_state = USB_DEV_SUSPENDED;
7021 			hubd_stop_polling(hubd);
7022 
7023 			/* close all the open pipes of our children */
7024 			for (port = 1; port <= nports; port++) {
7025 				usba_dev = hubd->h_usba_devices[port];
7026 				if (usba_dev != NULL) {
7027 					mutex_exit(HUBD_MUTEX(hubd));
7028 					usba_persistent_pipe_close(usba_dev);
7029 					mutex_enter(HUBD_MUTEX(hubd));
7030 				}
7031 			}
7032 			/*
7033 			 * turn off power to all the ports so that we
7034 			 * don't see any spurious activity
7035 			 */
7036 			(void) hubd_disable_all_port_power(hubd);
7037 
7038 			/*
7039 			 * if we are the root hub, we close our pipes
7040 			 * ourselves.
7041 			 */
7042 			if (usba_is_root_hub(hubd->h_dip)) {
7043 				mutex_exit(HUBD_MUTEX(hubd));
7044 				usba_persistent_pipe_close(
7045 				    usba_get_usba_device(hubd->h_dip));
7046 				mutex_enter(HUBD_MUTEX(hubd));
7047 			}
7048 			rval = USB_SUCCESS;
7049 
7050 			break;
7051 		}
7052 	case USB_DEV_SUSPENDED:
7053 	default:
7054 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
7055 		    "hubd_cpr_suspend: Illegal dev state=%d",
7056 		    hubd->h_dev_state);
7057 
7058 		break;
7059 	}
7060 
7061 	hubd_pm_idle_component(hubd, hubd->h_dip, 0);
7062 	mutex_exit(HUBD_MUTEX(hubd));
7063 
7064 	return (rval);
7065 }
7066 
7067 static void
7068 hubd_cpr_resume(dev_info_t *dip)
7069 {
7070 	int	rval, circ;
7071 
7072 	ndi_devi_enter(dip, &circ);
7073 	/*
7074 	 * if we are the root hub, we open our pipes
7075 	 * ourselves.
7076 	 */
7077 	if (usba_is_root_hub(dip)) {
7078 		rval = usba_persistent_pipe_open(
7079 		    usba_get_usba_device(dip));
7080 		ASSERT(rval == USB_SUCCESS);
7081 	}
7082 	(void) hubd_restore_state_cb(dip);
7083 	ndi_devi_exit(dip, circ);
7084 }
7085 
7086 
7087 /*
7088  * hubd_restore_state_cb
7089  *	Event callback to restore device state
7090  */
7091 static int
7092 hubd_restore_state_cb(dev_info_t *dip)
7093 {
7094 	hubd_t	*hubd = (hubd_t *)hubd_get_soft_state(dip);
7095 
7096 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
7097 	    "hubd_restore_state_cb: Begin");
7098 
7099 	/* restore the state of this device */
7100 	hubd_restore_device_state(dip, hubd);
7101 
7102 	return (USB_SUCCESS);
7103 }
7104 
7105 
7106 /*
7107  * registering for events
7108  */
7109 static int
7110 hubd_register_events(hubd_t *hubd)
7111 {
7112 	int		rval = USB_SUCCESS;
7113 
7114 	if (usba_is_root_hub(hubd->h_dip)) {
7115 		hubd_register_cpr_callback(hubd);
7116 	} else {
7117 		rval = usb_register_event_cbs(hubd->h_dip, &hubd_events, 0);
7118 	}
7119 
7120 	return (rval);
7121 }
7122 
7123 
7124 /*
7125  * hubd cpr callback related functions
7126  *
7127  * hubd_cpr_post_user_callb:
7128  *	This function is called during checkpoint & resume -
7129  *		1. after user threads are stopped during checkpoint
7130  *		2. after kernel threads are resumed during resume
7131  */
7132 /* ARGSUSED */
7133 static boolean_t
7134 hubd_cpr_post_user_callb(void *arg, int code)
7135 {
7136 	hubd_cpr_t	*cpr_cb = (hubd_cpr_t *)arg;
7137 	hubd_t		*hubd = cpr_cb->statep;
7138 	int		retry = 0;
7139 
7140 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
7141 	    "hubd_cpr_post_user_callb");
7142 
7143 	switch (code) {
7144 	case CB_CODE_CPR_CHKPT:
7145 		USB_DPRINTF_L3(DPRINT_MASK_EVENTS, hubd->h_log_handle,
7146 		    "hubd_cpr_post_user_callb: CB_CODE_CPR_CHKPT");
7147 
7148 		mutex_enter(HUBD_MUTEX(hubd));
7149 
7150 		/* turn off deathrow thread */
7151 		hubd->h_cleanup_enabled = B_FALSE;
7152 
7153 		/* give up if deathrow thread doesn't exit */
7154 		while ((hubd->h_cleanup_active == B_TRUE) && (retry++ < 3)) {
7155 			mutex_exit(HUBD_MUTEX(hubd));
7156 			delay(drv_usectohz(hubd_dip_cleanup_delay));
7157 
7158 			USB_DPRINTF_L2(DPRINT_MASK_EVENTS, hubd->h_log_handle,
7159 			    "hubd_cpr_post_user_callb, waiting for "
7160 			    "deathrow thread to exit");
7161 			mutex_enter(HUBD_MUTEX(hubd));
7162 		}
7163 
7164 		mutex_exit(HUBD_MUTEX(hubd));
7165 
7166 		/* save the state of the device */
7167 		(void) hubd_pre_suspend_event_cb(hubd->h_dip);
7168 
7169 		return (B_TRUE);
7170 	case CB_CODE_CPR_RESUME:
7171 		USB_DPRINTF_L3(DPRINT_MASK_EVENTS, hubd->h_log_handle,
7172 		    "hubd_cpr_post_user_callb: CB_CODE_CPR_RESUME");
7173 
7174 		/* restore the state of the device */
7175 		(void) hubd_post_resume_event_cb(hubd->h_dip);
7176 
7177 		/* turn on deathrow thread */
7178 		mutex_enter(HUBD_MUTEX(hubd));
7179 		hubd->h_cleanup_enabled = B_TRUE;
7180 		mutex_exit(HUBD_MUTEX(hubd));
7181 
7182 		hubd_schedule_cleanup(hubd->h_usba_device->usb_root_hub_dip);
7183 
7184 		return (B_TRUE);
7185 	default:
7186 
7187 		return (B_FALSE);
7188 	}
7189 
7190 }
7191 
7192 
7193 /* register callback with cpr framework */
7194 void
7195 hubd_register_cpr_callback(hubd_t *hubd)
7196 {
7197 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
7198 	    "hubd_register_cpr_callback");
7199 
7200 	mutex_enter(HUBD_MUTEX(hubd));
7201 	hubd->h_cpr_cb =
7202 	    (hubd_cpr_t *)kmem_zalloc(sizeof (hubd_cpr_t), KM_SLEEP);
7203 	mutex_exit(HUBD_MUTEX(hubd));
7204 	mutex_init(&hubd->h_cpr_cb->lockp, NULL, MUTEX_DRIVER,
7205 	    hubd->h_dev_data->dev_iblock_cookie);
7206 	hubd->h_cpr_cb->statep = hubd;
7207 	hubd->h_cpr_cb->cpr.cc_lockp = &hubd->h_cpr_cb->lockp;
7208 	hubd->h_cpr_cb->cpr.cc_id = callb_add(hubd_cpr_post_user_callb,
7209 	    (void *)hubd->h_cpr_cb, CB_CL_CPR_POST_USER, "hubd");
7210 }
7211 
7212 
7213 /* unregister callback with cpr framework */
7214 void
7215 hubd_unregister_cpr_callback(hubd_t *hubd)
7216 {
7217 	USB_DPRINTF_L4(DPRINT_MASK_EVENTS, hubd->h_log_handle,
7218 	    "hubd_unregister_cpr_callback");
7219 
7220 	if (hubd->h_cpr_cb) {
7221 		(void) callb_delete(hubd->h_cpr_cb->cpr.cc_id);
7222 		mutex_destroy(&hubd->h_cpr_cb->lockp);
7223 		mutex_enter(HUBD_MUTEX(hubd));
7224 		kmem_free(hubd->h_cpr_cb, sizeof (hubd_cpr_t));
7225 		mutex_exit(HUBD_MUTEX(hubd));
7226 	}
7227 }
7228 
7229 
7230 /*
7231  * Power management
7232  *
7233  * create the pm components required for power management
7234  */
7235 static void
7236 hubd_create_pm_components(dev_info_t *dip, hubd_t *hubd)
7237 {
7238 	hub_power_t	*hubpm;
7239 
7240 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
7241 	    "hubd_create_pm_components: Begin");
7242 
7243 	/* Allocate the state structure */
7244 	hubpm = kmem_zalloc(sizeof (hub_power_t), KM_SLEEP);
7245 
7246 	hubd->h_hubpm = hubpm;
7247 	hubpm->hubp_hubd = hubd;
7248 	hubpm->hubp_pm_capabilities = 0;
7249 	hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
7250 	hubpm->hubp_time_at_full_power = ddi_get_time();
7251 	hubpm->hubp_min_pm_threshold = hubdi_min_pm_threshold;
7252 
7253 	/* alloc memory to save power states of children */
7254 	hubpm->hubp_child_pwrstate = (uint8_t *)
7255 	    kmem_zalloc(MAX_PORTS + 1, KM_SLEEP);
7256 
7257 	/*
7258 	 * if the enable remote wakeup fails
7259 	 * we still want to enable
7260 	 * parent notification so we can PM the children
7261 	 */
7262 	usb_enable_parent_notification(dip);
7263 
7264 	if (usb_handle_remote_wakeup(dip,
7265 	    USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS) {
7266 		uint_t		pwr_states;
7267 
7268 		USB_DPRINTF_L2(DPRINT_MASK_PM, hubd->h_log_handle,
7269 		    "hubd_create_pm_components: "
7270 		    "Remote Wakeup Enabled");
7271 
7272 		if (usb_create_pm_components(dip, &pwr_states) ==
7273 		    USB_SUCCESS) {
7274 			mutex_enter(HUBD_MUTEX(hubd));
7275 			hubpm->hubp_wakeup_enabled = 1;
7276 			hubpm->hubp_pwr_states = (uint8_t)pwr_states;
7277 
7278 			/* we are busy now till end of the attach */
7279 			hubd_pm_busy_component(hubd, dip, 0);
7280 			mutex_exit(HUBD_MUTEX(hubd));
7281 
7282 			/* bring the device to full power */
7283 			(void) pm_raise_power(dip, 0,
7284 			    USB_DEV_OS_FULL_PWR);
7285 		}
7286 	}
7287 
7288 	USB_DPRINTF_L4(DPRINT_MASK_PM, hubd->h_log_handle,
7289 	    "hubd_create_pm_components: END");
7290 }
7291 
7292 
7293 /*
7294  * Attachment point management
7295  */
7296 /* ARGSUSED */
7297 int
7298 usba_hubdi_open(dev_info_t *dip, dev_t *devp, int flags, int otyp,
7299 	cred_t *credp)
7300 {
7301 	hubd_t *hubd;
7302 
7303 	if (otyp != OTYP_CHR)
7304 		return (EINVAL);
7305 
7306 	hubd = hubd_get_soft_state(dip);
7307 	if (hubd == NULL) {
7308 		return (ENXIO);
7309 	}
7310 
7311 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7312 	    "hubd_open:");
7313 
7314 	mutex_enter(HUBD_MUTEX(hubd));
7315 	if ((flags & FEXCL) && (hubd->h_softstate & HUBD_SS_ISOPEN)) {
7316 		mutex_exit(HUBD_MUTEX(hubd));
7317 
7318 		return (EBUSY);
7319 	}
7320 
7321 	hubd->h_softstate |= HUBD_SS_ISOPEN;
7322 	mutex_exit(HUBD_MUTEX(hubd));
7323 
7324 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "opened");
7325 
7326 	return (0);
7327 }
7328 
7329 
7330 /* ARGSUSED */
7331 int
7332 usba_hubdi_close(dev_info_t *dip, dev_t dev, int flag, int otyp,
7333 	cred_t *credp)
7334 {
7335 	hubd_t *hubd;
7336 
7337 	if (otyp != OTYP_CHR) {
7338 		return (EINVAL);
7339 	}
7340 
7341 	hubd = hubd_get_soft_state(dip);
7342 
7343 	if (hubd == NULL) {
7344 		return (ENXIO);
7345 	}
7346 
7347 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "hubd_close:");
7348 
7349 	mutex_enter(HUBD_MUTEX(hubd));
7350 	hubd->h_softstate &= ~HUBD_SS_ISOPEN;
7351 	mutex_exit(HUBD_MUTEX(hubd));
7352 
7353 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle, "closed");
7354 
7355 	return (0);
7356 }
7357 
7358 
7359 /*
7360  * hubd_ioctl: cfgadm controls
7361  */
7362 /* ARGSUSED */
7363 int
7364 usba_hubdi_ioctl(dev_info_t *self, dev_t dev, int cmd, intptr_t arg,
7365 	int mode, cred_t *credp, int *rvalp)
7366 {
7367 	int			rv = 0;
7368 	char			*msg;	/* for messages */
7369 	hubd_t			*hubd;
7370 	usb_port_t		port = 0;
7371 	dev_info_t		*child_dip = NULL;
7372 	dev_info_t		*rh_dip;
7373 	devctl_ap_state_t	ap_state;
7374 	struct devctl_iocdata	*dcp = NULL;
7375 	usb_pipe_state_t	prev_pipe_state = 0;
7376 	int			circ, rh_circ, prh_circ;
7377 
7378 	if ((hubd = hubd_get_soft_state(self)) == NULL) {
7379 
7380 		return (ENXIO);
7381 	}
7382 
7383 	rh_dip = hubd->h_usba_device->usb_root_hub_dip;
7384 
7385 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7386 	    "usba_hubdi_ioctl: "
7387 	    "cmd=%x, arg=%lx, mode=%x, cred=%p, rval=%p dev=0x%lx",
7388 	    cmd, arg, mode, (void *)credp, (void *)rvalp, dev);
7389 
7390 	/* read devctl ioctl data */
7391 	if ((cmd != DEVCTL_AP_CONTROL) &&
7392 	    (ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)) {
7393 
7394 		return (EFAULT);
7395 	}
7396 
7397 	/*
7398 	 * make sure the hub is connected before trying any
7399 	 * of the following operations:
7400 	 * configure, connect, disconnect
7401 	 */
7402 	mutex_enter(HUBD_MUTEX(hubd));
7403 
7404 	switch (cmd) {
7405 	case DEVCTL_AP_DISCONNECT:
7406 	case DEVCTL_AP_UNCONFIGURE:
7407 	case DEVCTL_AP_CONFIGURE:
7408 		if (hubd->h_dev_state == USB_DEV_DISCONNECTED) {
7409 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
7410 			    "hubd: already gone");
7411 			mutex_exit(HUBD_MUTEX(hubd));
7412 			if (dcp) {
7413 				ndi_dc_freehdl(dcp);
7414 			}
7415 
7416 			return (EIO);
7417 		}
7418 
7419 		/* FALLTHROUGH */
7420 	case DEVCTL_AP_GETSTATE:
7421 		if ((port = hubd_get_port_num(hubd, dcp)) == 0) {
7422 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
7423 			    "hubd: bad port");
7424 			mutex_exit(HUBD_MUTEX(hubd));
7425 			if (dcp) {
7426 				ndi_dc_freehdl(dcp);
7427 			}
7428 
7429 			return (EINVAL);
7430 		}
7431 		break;
7432 
7433 	case DEVCTL_AP_CONTROL:
7434 
7435 		break;
7436 	default:
7437 		mutex_exit(HUBD_MUTEX(hubd));
7438 		if (dcp) {
7439 			ndi_dc_freehdl(dcp);
7440 		}
7441 
7442 		return (ENOTTY);
7443 	}
7444 
7445 	/* should not happen, just in case */
7446 	if (hubd->h_dev_state == USB_DEV_SUSPENDED) {
7447 		mutex_exit(HUBD_MUTEX(hubd));
7448 		if (dcp) {
7449 			ndi_dc_freehdl(dcp);
7450 		}
7451 
7452 		return (EIO);
7453 	}
7454 
7455 	if (hubd->h_reset_port[port]) {
7456 		USB_DPRINTF_L2(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7457 		    "This port is resetting, just return");
7458 		mutex_exit(HUBD_MUTEX(hubd));
7459 		if (dcp) {
7460 			ndi_dc_freehdl(dcp);
7461 		}
7462 
7463 		return (EIO);
7464 	}
7465 
7466 	hubd_pm_busy_component(hubd, hubd->h_dip, 0);
7467 	mutex_exit(HUBD_MUTEX(hubd));
7468 
7469 	/* go full power */
7470 	(void) pm_raise_power(hubd->h_dip, 0, USB_DEV_OS_FULL_PWR);
7471 
7472 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
7473 	ndi_devi_enter(rh_dip, &rh_circ);
7474 	ndi_devi_enter(hubd->h_dip, &circ);
7475 
7476 	mutex_enter(HUBD_MUTEX(hubd));
7477 
7478 	hubd->h_hotplug_thread++;
7479 
7480 	/* stop polling if it was active */
7481 	if (hubd->h_ep1_ph) {
7482 		mutex_exit(HUBD_MUTEX(hubd));
7483 		(void) usb_pipe_get_state(hubd->h_ep1_ph, &prev_pipe_state,
7484 		    USB_FLAGS_SLEEP);
7485 		mutex_enter(HUBD_MUTEX(hubd));
7486 
7487 		if (prev_pipe_state == USB_PIPE_STATE_ACTIVE) {
7488 			hubd_stop_polling(hubd);
7489 		}
7490 	}
7491 
7492 	switch (cmd) {
7493 	case DEVCTL_AP_DISCONNECT:
7494 		if (hubd_delete_child(hubd, port,
7495 		    NDI_DEVI_REMOVE, B_FALSE) != USB_SUCCESS) {
7496 			rv = EIO;
7497 		}
7498 
7499 		break;
7500 	case DEVCTL_AP_UNCONFIGURE:
7501 		if (hubd_delete_child(hubd, port,
7502 		    NDI_UNCONFIG, B_FALSE) != USB_SUCCESS) {
7503 			rv = EIO;
7504 		}
7505 
7506 		break;
7507 	case DEVCTL_AP_CONFIGURE:
7508 		/* toggle port */
7509 		if (hubd_toggle_port(hubd, port) != USB_SUCCESS) {
7510 			rv = EIO;
7511 
7512 			break;
7513 		}
7514 
7515 		(void) hubd_handle_port_connect(hubd, port);
7516 		child_dip = hubd_get_child_dip(hubd, port);
7517 		mutex_exit(HUBD_MUTEX(hubd));
7518 
7519 		ndi_devi_exit(hubd->h_dip, circ);
7520 		ndi_devi_exit(rh_dip, rh_circ);
7521 		ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
7522 		if (child_dip == NULL) {
7523 			rv = EIO;
7524 		} else {
7525 			ndi_hold_devi(child_dip);
7526 			if (ndi_devi_online(child_dip, 0) != NDI_SUCCESS)
7527 				rv = EIO;
7528 			ndi_rele_devi(child_dip);
7529 		}
7530 		ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
7531 		ndi_devi_enter(rh_dip, &rh_circ);
7532 		ndi_devi_enter(hubd->h_dip, &circ);
7533 
7534 		mutex_enter(HUBD_MUTEX(hubd));
7535 
7536 		break;
7537 	case DEVCTL_AP_GETSTATE:
7538 		switch (hubd_cfgadm_state(hubd, port)) {
7539 		case HUBD_CFGADM_DISCONNECTED:
7540 			/* port previously 'disconnected' by cfgadm */
7541 			ap_state.ap_rstate = AP_RSTATE_DISCONNECTED;
7542 			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
7543 			ap_state.ap_condition = AP_COND_OK;
7544 
7545 			break;
7546 		case HUBD_CFGADM_UNCONFIGURED:
7547 			ap_state.ap_rstate = AP_RSTATE_CONNECTED;
7548 			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
7549 			ap_state.ap_condition = AP_COND_OK;
7550 
7551 			break;
7552 		case HUBD_CFGADM_CONFIGURED:
7553 			ap_state.ap_rstate = AP_RSTATE_CONNECTED;
7554 			ap_state.ap_ostate = AP_OSTATE_CONFIGURED;
7555 			ap_state.ap_condition = AP_COND_OK;
7556 
7557 			break;
7558 		case HUBD_CFGADM_STILL_REFERENCED:
7559 			ap_state.ap_rstate = AP_RSTATE_EMPTY;
7560 			ap_state.ap_ostate = AP_OSTATE_CONFIGURED;
7561 			ap_state.ap_condition = AP_COND_UNUSABLE;
7562 
7563 			break;
7564 		case HUBD_CFGADM_EMPTY:
7565 		default:
7566 			ap_state.ap_rstate = AP_RSTATE_EMPTY;
7567 			ap_state.ap_ostate = AP_OSTATE_UNCONFIGURED;
7568 			ap_state.ap_condition = AP_COND_OK;
7569 
7570 			break;
7571 		}
7572 
7573 		ap_state.ap_last_change = (time_t)-1;
7574 		ap_state.ap_error_code = 0;
7575 		ap_state.ap_in_transition = 0;
7576 
7577 		USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7578 		    "DEVCTL_AP_GETSTATE: "
7579 		    "ostate=0x%x, rstate=0x%x, condition=0x%x",
7580 		    ap_state.ap_ostate,
7581 		    ap_state.ap_rstate, ap_state.ap_condition);
7582 
7583 		/* copy the return-AP-state information to the user space */
7584 		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS) {
7585 			rv = EFAULT;
7586 		}
7587 
7588 		break;
7589 	case DEVCTL_AP_CONTROL:
7590 	{
7591 		/*
7592 		 * Generic devctl for hardware-specific functionality.
7593 		 * For list of sub-commands see hubd_impl.h
7594 		 */
7595 		hubd_ioctl_data_t	ioc;	/* for 64 byte copies */
7596 
7597 		/* copy user ioctl data in first */
7598 #ifdef _MULTI_DATAMODEL
7599 		if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
7600 			hubd_ioctl_data_32_t ioc32;
7601 
7602 			if (ddi_copyin((void *)arg, (void *)&ioc32,
7603 			    sizeof (ioc32), mode) != 0) {
7604 				rv = EFAULT;
7605 
7606 				break;
7607 			}
7608 			ioc.cmd		= (uint_t)ioc32.cmd;
7609 			ioc.port	= (uint_t)ioc32.port;
7610 			ioc.get_size	= (uint_t)ioc32.get_size;
7611 			ioc.buf		= (caddr_t)(uintptr_t)ioc32.buf;
7612 			ioc.bufsiz	= (uint_t)ioc32.bufsiz;
7613 			ioc.misc_arg	= (uint_t)ioc32.misc_arg;
7614 		} else
7615 #endif /* _MULTI_DATAMODEL */
7616 		if (ddi_copyin((void *)arg, (void *)&ioc, sizeof (ioc),
7617 		    mode) != 0) {
7618 			rv = EFAULT;
7619 
7620 			break;
7621 		}
7622 
7623 		USB_DPRINTF_L3(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7624 		    "DEVCTL_AP_CONTROL: ioc: cmd=0x%x port=%d get_size=%d"
7625 		    "\n\tbuf=0x%p, bufsiz=%d,  misc_arg=%d", ioc.cmd,
7626 		    ioc.port, ioc.get_size, (void *)ioc.buf, ioc.bufsiz,
7627 		    ioc.misc_arg);
7628 
7629 		/*
7630 		 * To avoid BE/LE and 32/64 issues, a get_size always
7631 		 * returns a 32-bit number.
7632 		 */
7633 		if (ioc.get_size != 0 && ioc.bufsiz != (sizeof (uint32_t))) {
7634 			rv = EINVAL;
7635 
7636 			break;
7637 		}
7638 
7639 		switch (ioc.cmd) {
7640 		case USB_DESCR_TYPE_DEV:
7641 			msg = "DEVCTL_AP_CONTROL: GET_DEVICE_DESC";
7642 			if (ioc.get_size) {
7643 				/* uint32 so this works 32/64 */
7644 				uint32_t size = sizeof (usb_dev_descr_t);
7645 
7646 				if (ddi_copyout((void *)&size, ioc.buf,
7647 				    ioc.bufsiz, mode) != 0) {
7648 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7649 					    hubd->h_log_handle,
7650 					    "%s: get_size copyout failed", msg);
7651 					rv = EIO;
7652 
7653 					break;
7654 				}
7655 			} else {	/* send out the actual descr */
7656 				usb_dev_descr_t *dev_descrp;
7657 
7658 				/* check child_dip */
7659 				if ((child_dip = hubd_get_child_dip(hubd,
7660 				    ioc.port)) == NULL) {
7661 					rv = EINVAL;
7662 
7663 					break;
7664 				}
7665 
7666 				dev_descrp = usb_get_dev_descr(child_dip);
7667 				if (ioc.bufsiz != sizeof (*dev_descrp)) {
7668 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7669 					    hubd->h_log_handle,
7670 					    "%s: bufsize passed (%d) != sizeof "
7671 					    "usba_device_descr_t (%d)", msg,
7672 					    ioc.bufsiz, dev_descrp->bLength);
7673 					rv = EINVAL;
7674 
7675 					break;
7676 				}
7677 
7678 				if (ddi_copyout((void *)dev_descrp,
7679 				    ioc.buf, ioc.bufsiz, mode) != 0) {
7680 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7681 					    hubd->h_log_handle,
7682 					    "%s: copyout failed.", msg);
7683 					rv = EIO;
7684 
7685 					break;
7686 				}
7687 			}
7688 			break;
7689 		case USB_DESCR_TYPE_STRING:
7690 		{
7691 			char		*str;
7692 			uint32_t	size;
7693 			usba_device_t	*usba_device;
7694 
7695 			msg = "DEVCTL_AP_CONTROL: GET_STRING_DESCR";
7696 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7697 			    "%s: string request: %d", msg, ioc.misc_arg);
7698 
7699 			/* recheck */
7700 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
7701 			    NULL) {
7702 				rv = EINVAL;
7703 
7704 				break;
7705 			}
7706 			usba_device = usba_get_usba_device(child_dip);
7707 
7708 			switch (ioc.misc_arg) {
7709 			case HUBD_MFG_STR:
7710 				str = usba_device->usb_mfg_str;
7711 
7712 				break;
7713 			case HUBD_PRODUCT_STR:
7714 				str = usba_device->usb_product_str;
7715 
7716 				break;
7717 			case HUBD_SERIALNO_STR:
7718 				str = usba_device->usb_serialno_str;
7719 
7720 				break;
7721 			case HUBD_CFG_DESCR_STR:
7722 				mutex_enter(&usba_device->usb_mutex);
7723 				str = usba_device->usb_cfg_str_descr[
7724 				    usba_device->usb_active_cfg_ndx];
7725 				mutex_exit(&usba_device->usb_mutex);
7726 
7727 				break;
7728 			default:
7729 				USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7730 				    hubd->h_log_handle,
7731 				    "%s: Invalid string request", msg);
7732 				rv = EINVAL;
7733 
7734 				break;
7735 			} /* end of switch */
7736 
7737 			if (rv != 0) {
7738 
7739 				break;
7740 			}
7741 
7742 			size = (str != NULL) ? strlen(str) + 1 : 0;
7743 			if (ioc.get_size) {
7744 				if (ddi_copyout((void *)&size, ioc.buf,
7745 				    ioc.bufsiz, mode) != 0) {
7746 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7747 					    hubd->h_log_handle,
7748 					    "%s: copyout of size failed.", msg);
7749 					rv = EIO;
7750 
7751 					break;
7752 				}
7753 			} else {
7754 				if (size == 0) {
7755 					USB_DPRINTF_L3(DPRINT_MASK_CBOPS,
7756 					    hubd->h_log_handle,
7757 					    "%s: String is NULL", msg);
7758 					rv = EINVAL;
7759 
7760 					break;
7761 				}
7762 
7763 				if (ioc.bufsiz != size) {
7764 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7765 					    hubd->h_log_handle,
7766 					    "%s: string buf size wrong", msg);
7767 					rv = EINVAL;
7768 
7769 					break;
7770 				}
7771 
7772 				if (ddi_copyout((void *)str, ioc.buf,
7773 				    ioc.bufsiz, mode) != 0) {
7774 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7775 					    hubd->h_log_handle,
7776 					    "%s: copyout failed.", msg);
7777 					rv = EIO;
7778 
7779 					break;
7780 				}
7781 			}
7782 			break;
7783 		}
7784 		case HUBD_GET_CFGADM_NAME:
7785 		{
7786 			uint32_t   name_len;
7787 			const char *name;
7788 
7789 			/* recheck */
7790 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
7791 			    NULL) {
7792 				rv = EINVAL;
7793 
7794 				break;
7795 			}
7796 			name = ddi_node_name(child_dip);
7797 			if (name == NULL) {
7798 				name = "unsupported";
7799 			}
7800 			name_len = strlen(name) + 1;
7801 
7802 			msg = "DEVCTL_AP_CONTROL: HUBD_GET_CFGADM_NAME";
7803 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7804 			    "%s: name=%s name_len=%d", msg, name, name_len);
7805 
7806 			if (ioc.get_size) {
7807 				if (ddi_copyout((void *)&name_len,
7808 				    ioc.buf, ioc.bufsiz, mode) != 0) {
7809 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7810 					    hubd->h_log_handle,
7811 					    "%s: copyout of size failed", msg);
7812 					rv = EIO;
7813 
7814 					break;
7815 				}
7816 			} else {
7817 				if (ioc.bufsiz != name_len) {
7818 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7819 					    hubd->h_log_handle,
7820 					    "%s: string buf length wrong", msg);
7821 					rv = EINVAL;
7822 
7823 					break;
7824 				}
7825 
7826 				if (ddi_copyout((void *)name, ioc.buf,
7827 				    ioc.bufsiz, mode) != 0) {
7828 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7829 					    hubd->h_log_handle,
7830 					    "%s: copyout failed.", msg);
7831 					rv = EIO;
7832 
7833 					break;
7834 				}
7835 			}
7836 
7837 			break;
7838 		}
7839 
7840 		/*
7841 		 * Return the config index for the currently-configured
7842 		 * configuration.
7843 		 */
7844 		case HUBD_GET_CURRENT_CONFIG:
7845 		{
7846 			uint_t		config_index;
7847 			uint32_t	size = sizeof (config_index);
7848 			usba_device_t	*usba_device;
7849 
7850 			msg = "DEVCTL_AP_CONTROL: GET_CURRENT_CONFIG";
7851 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7852 			    "%s", msg);
7853 
7854 			/*
7855 			 * Return the config index for the configuration
7856 			 * currently in use.
7857 			 * Recheck if child_dip exists
7858 			 */
7859 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
7860 			    NULL) {
7861 				rv = EINVAL;
7862 
7863 				break;
7864 			}
7865 
7866 			usba_device = usba_get_usba_device(child_dip);
7867 			mutex_enter(&usba_device->usb_mutex);
7868 			config_index = usba_device->usb_active_cfg_ndx;
7869 			mutex_exit(&usba_device->usb_mutex);
7870 
7871 			if (ioc.get_size) {
7872 				if (ddi_copyout((void *)&size,
7873 				    ioc.buf, ioc.bufsiz, mode) != 0) {
7874 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7875 					    hubd->h_log_handle,
7876 					    "%s: copyout of size failed.", msg);
7877 					rv = EIO;
7878 
7879 					break;
7880 				}
7881 			} else {
7882 				if (ioc.bufsiz != size) {
7883 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7884 					    hubd->h_log_handle,
7885 					    "%s: buffer size wrong", msg);
7886 					rv = EINVAL;
7887 
7888 					break;
7889 				}
7890 				if (ddi_copyout((void *)&config_index,
7891 				    ioc.buf, ioc.bufsiz, mode) != 0) {
7892 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7893 					    hubd->h_log_handle,
7894 					    "%s: copyout failed", msg);
7895 					rv = EIO;
7896 				}
7897 			}
7898 
7899 			break;
7900 		}
7901 		case HUBD_GET_DEVICE_PATH:
7902 		{
7903 			char		*path;
7904 			uint32_t	size;
7905 
7906 			msg = "DEVCTL_AP_CONTROL: GET_DEVICE_PATH";
7907 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7908 			    "%s", msg);
7909 
7910 			/* Recheck if child_dip exists */
7911 			if ((child_dip = hubd_get_child_dip(hubd, ioc.port)) ==
7912 			    NULL) {
7913 				rv = EINVAL;
7914 
7915 				break;
7916 			}
7917 
7918 			/* ddi_pathname doesn't supply /devices, so we do. */
7919 			path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
7920 			(void) strcpy(path, "/devices");
7921 			(void) ddi_pathname(child_dip, path + strlen(path));
7922 			size = strlen(path) + 1;
7923 
7924 			USB_DPRINTF_L4(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7925 			    "%s: device path=%s  size=%d", msg, path, size);
7926 
7927 			if (ioc.get_size) {
7928 				if (ddi_copyout((void *)&size,
7929 				    ioc.buf, ioc.bufsiz, mode) != 0) {
7930 
7931 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7932 					    hubd->h_log_handle,
7933 					    "%s: copyout of size failed.", msg);
7934 					rv = EIO;
7935 				}
7936 			} else {
7937 				if (ioc.bufsiz != size) {
7938 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7939 					    hubd->h_log_handle,
7940 					    "%s: buffer wrong size.", msg);
7941 					rv = EINVAL;
7942 				} else if (ddi_copyout((void *)path,
7943 				    ioc.buf, ioc.bufsiz, mode) != 0) {
7944 					USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7945 					    hubd->h_log_handle,
7946 					    "%s: copyout failed.", msg);
7947 					rv = EIO;
7948 				}
7949 			}
7950 			kmem_free(path, MAXPATHLEN);
7951 
7952 			break;
7953 		}
7954 		case HUBD_REFRESH_DEVDB:
7955 			msg = "DEVCTL_AP_CONTROL: HUBD_REFRESH_DEVDB";
7956 			USB_DPRINTF_L3(DPRINT_MASK_CBOPS, hubd->h_log_handle,
7957 			    "%s", msg);
7958 
7959 			if ((rv = usba_devdb_refresh()) != USB_SUCCESS) {
7960 				USB_DPRINTF_L2(DPRINT_MASK_CBOPS,
7961 				    hubd->h_log_handle,
7962 				    "%s: Failed: %d", msg, rv);
7963 				rv = EIO;
7964 			}
7965 
7966 			break;
7967 		default:
7968 			rv = ENOTSUP;
7969 		}	/* end switch */
7970 
7971 		break;
7972 	}
7973 
7974 	default:
7975 		rv = ENOTTY;
7976 	}
7977 
7978 	if (dcp) {
7979 		ndi_dc_freehdl(dcp);
7980 	}
7981 
7982 	/* allow hotplug thread now */
7983 	hubd->h_hotplug_thread--;
7984 
7985 	if ((hubd->h_dev_state == USB_DEV_ONLINE) &&
7986 	    hubd->h_ep1_ph && (prev_pipe_state == USB_PIPE_STATE_ACTIVE)) {
7987 		hubd_start_polling(hubd, 0);
7988 	}
7989 	mutex_exit(HUBD_MUTEX(hubd));
7990 
7991 	ndi_devi_exit(hubd->h_dip, circ);
7992 	ndi_devi_exit(rh_dip, rh_circ);
7993 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
7994 
7995 	mutex_enter(HUBD_MUTEX(hubd));
7996 	hubd_pm_idle_component(hubd, hubd->h_dip, 0);
7997 	mutex_exit(HUBD_MUTEX(hubd));
7998 
7999 	return (rv);
8000 }
8001 
8002 
8003 /*
8004  * Helper func used only to help construct the names for the attachment point
8005  * minor nodes.  Used only in usba_hubdi_attach.
8006  * Returns whether it found ancestry or not (USB_SUCCESS if yes).
8007  * ports between the root hub and the device represented by dip.
8008  * E.g.,  "2.4.3.1" means this device is
8009  *	plugged into port 1 of a hub that is
8010  *	plugged into port 3 of a hub that is
8011  *	plugged into port 4 of a hub that is
8012  *	plugged into port 2 of the root hub.
8013  * NOTE: Max ap_id path len is HUBD_APID_NAMELEN (32 chars), which is
8014  * more than sufficient (as hubs are a max 6 levels deep, port needs 3
8015  * chars plus NULL each)
8016  */
8017 void
8018 hubd_get_ancestry_str(hubd_t *hubd)
8019 {
8020 	char		ap_name[HUBD_APID_NAMELEN];
8021 	dev_info_t	*pdip;
8022 	hubd_t		*phubd;
8023 	usb_port_t	port;
8024 
8025 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
8026 	    "hubd_get_ancestry_str: hubd=0x%p", (void *)hubd);
8027 
8028 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8029 
8030 	/*
8031 	 * The function is extended to support wire adapter class
8032 	 * devices introduced by WUSB spec. The node name is no
8033 	 * longer "hub" only.
8034 	 * Generate the ap_id str based on the parent and child
8035 	 * relationship instead of retrieving it from the hub
8036 	 * device path, which simplifies the algorithm.
8037 	 */
8038 	if (usba_is_root_hub(hubd->h_dip)) {
8039 		hubd->h_ancestry_str[0] = '\0';
8040 	} else {
8041 		port = hubd->h_usba_device->usb_port;
8042 		mutex_exit(HUBD_MUTEX(hubd));
8043 
8044 		pdip = ddi_get_parent(hubd->h_dip);
8045 		/*
8046 		 * The parent of wire adapter device might be usb_mid.
8047 		 * Need to look further up for hub device
8048 		 */
8049 		if (strcmp(ddi_driver_name(pdip), "usb_mid") == 0) {
8050 			pdip = ddi_get_parent(pdip);
8051 			ASSERT(pdip != NULL);
8052 		}
8053 
8054 		phubd = hubd_get_soft_state(pdip);
8055 
8056 		mutex_enter(HUBD_MUTEX(phubd));
8057 		(void) snprintf(ap_name, HUBD_APID_NAMELEN, "%s%d",
8058 		    phubd->h_ancestry_str, port);
8059 		mutex_exit(HUBD_MUTEX(phubd));
8060 
8061 		mutex_enter(HUBD_MUTEX(hubd));
8062 		(void) strcpy(hubd->h_ancestry_str, ap_name);
8063 		(void) strcat(hubd->h_ancestry_str, ".");
8064 	}
8065 }
8066 
8067 
8068 /* Get which port to operate on.  */
8069 static usb_port_t
8070 hubd_get_port_num(hubd_t *hubd, struct devctl_iocdata *dcp)
8071 {
8072 	int32_t port;
8073 
8074 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8075 
8076 	/* Get which port to operate on.  */
8077 	if (nvlist_lookup_int32(ndi_dc_get_ap_data(dcp), "port", &port) != 0) {
8078 		USB_DPRINTF_L2(DPRINT_MASK_CBOPS, hubd->h_log_handle,
8079 		    "hubd_get_port_num: port lookup failed");
8080 		port = 0;
8081 	}
8082 
8083 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
8084 	    "hubd_get_port_num: hubd=0x%p, port=%d", (void *)hubd, port);
8085 
8086 	return ((usb_port_t)port);
8087 }
8088 
8089 
8090 /* check if child still exists */
8091 static dev_info_t *
8092 hubd_get_child_dip(hubd_t *hubd, usb_port_t port)
8093 {
8094 	dev_info_t *child_dip = hubd->h_children_dips[port];
8095 
8096 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
8097 	    "hubd_get_child_dip: hubd=0x%p, port=%d", (void *)hubd, port);
8098 
8099 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8100 
8101 	return (child_dip);
8102 }
8103 
8104 
8105 /*
8106  * hubd_cfgadm_state:
8107  *
8108  *	child_dip list		port_state		cfgadm_state
8109  *	--------------		----------		------------
8110  *	!= NULL			connected		configured or
8111  *							unconfigured
8112  *	!= NULL			not connected		disconnect but
8113  *							busy/still referenced
8114  *	NULL			connected		logically disconnected
8115  *	NULL			not connected		empty
8116  */
8117 static uint_t
8118 hubd_cfgadm_state(hubd_t *hubd, usb_port_t port)
8119 {
8120 	uint_t		state;
8121 	dev_info_t	*child_dip = hubd_get_child_dip(hubd, port);
8122 
8123 	if (child_dip) {
8124 		if (hubd->h_port_state[port] & PORT_STATUS_CCS) {
8125 			/*
8126 			 * connected,  now check if driver exists
8127 			 */
8128 			if (DEVI_IS_DEVICE_OFFLINE(child_dip) ||
8129 			    !i_ddi_devi_attached(child_dip)) {
8130 				state = HUBD_CFGADM_UNCONFIGURED;
8131 			} else {
8132 				state = HUBD_CFGADM_CONFIGURED;
8133 			}
8134 		} else {
8135 			/*
8136 			 * this means that the dip is around for
8137 			 * a device that is still referenced but
8138 			 * has been yanked out. So the cfgadm info
8139 			 * for this state should be EMPTY (port empty)
8140 			 * and CONFIGURED (dip still valid).
8141 			 */
8142 			state = HUBD_CFGADM_STILL_REFERENCED;
8143 		}
8144 	} else {
8145 		/* connected but no child dip */
8146 		if (hubd->h_port_state[port] & PORT_STATUS_CCS) {
8147 			/* logically disconnected */
8148 			state = HUBD_CFGADM_DISCONNECTED;
8149 		} else {
8150 			/* physically disconnected */
8151 			state = HUBD_CFGADM_EMPTY;
8152 		}
8153 	}
8154 
8155 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
8156 	    "hubd_cfgadm_state: hubd=0x%p, port=%d state=0x%x",
8157 	    (void *)hubd, port, state);
8158 
8159 	return (state);
8160 }
8161 
8162 
8163 /*
8164  * hubd_toggle_port:
8165  */
8166 static int
8167 hubd_toggle_port(hubd_t *hubd, usb_port_t port)
8168 {
8169 	usb_hub_descr_t	*hub_descr;
8170 	int		wait;
8171 	uint_t		retry;
8172 	uint16_t	status;
8173 	uint16_t	change;
8174 
8175 	USB_DPRINTF_L4(DPRINT_MASK_CBOPS,  hubd->h_log_handle,
8176 	    "hubd_toggle_port: hubd=0x%p, port=%d", (void *)hubd, port);
8177 
8178 	if ((hubd_disable_port_power(hubd, port)) != USB_SUCCESS) {
8179 
8180 		return (USB_FAILURE);
8181 	}
8182 
8183 	/*
8184 	 * see hubd_enable_all_port_power() which
8185 	 * requires longer delay for hubs.
8186 	 */
8187 	mutex_exit(HUBD_MUTEX(hubd));
8188 	delay(drv_usectohz(hubd_device_delay / 10));
8189 	mutex_enter(HUBD_MUTEX(hubd));
8190 
8191 	hub_descr = &hubd->h_hub_descr;
8192 
8193 	/*
8194 	 * According to section 11.11 of USB, for hubs with no power
8195 	 * switches, bPwrOn2PwrGood is zero. But we wait for some
8196 	 * arbitrary time to enable power to become stable.
8197 	 *
8198 	 * If an hub supports port power swicthing, we need to wait
8199 	 * at least 20ms before accesing corresonding usb port.
8200 	 */
8201 	if ((hub_descr->wHubCharacteristics &
8202 	    HUB_CHARS_NO_POWER_SWITCHING) || (!hub_descr->bPwrOn2PwrGood)) {
8203 		wait = hubd_device_delay / 10;
8204 	} else {
8205 		wait = max(HUB_DEFAULT_POPG,
8206 		    hub_descr->bPwrOn2PwrGood) * 2 * 1000;
8207 	}
8208 
8209 	USB_DPRINTF_L3(DPRINT_MASK_PORT, hubd->h_log_handle,
8210 	    "hubd_toggle_port: popg=%d wait=%d",
8211 	    hub_descr->bPwrOn2PwrGood, wait);
8212 
8213 	retry = 0;
8214 
8215 	do {
8216 		(void) hubd_enable_port_power(hubd, port);
8217 
8218 		mutex_exit(HUBD_MUTEX(hubd));
8219 		delay(drv_usectohz(wait));
8220 		mutex_enter(HUBD_MUTEX(hubd));
8221 
8222 		/* Get port status */
8223 		(void) hubd_determine_port_status(hubd, port,
8224 		    &status, &change, 0);
8225 
8226 		/* For retry if any, use some extra delay */
8227 		wait = max(wait, hubd_device_delay / 10);
8228 
8229 		retry++;
8230 
8231 	} while ((!(status & PORT_STATUS_PPS)) && (retry < HUBD_PORT_RETRY));
8232 
8233 	/* Print warning message if port has no power */
8234 	if (!(status & PORT_STATUS_PPS)) {
8235 
8236 		USB_DPRINTF_L2(DPRINT_MASK_PORT, hubd->h_log_handle,
8237 		    "hubd_toggle_port: port %d power-on failed, "
8238 		    "port status 0x%x", port, status);
8239 
8240 		return (USB_FAILURE);
8241 	}
8242 
8243 	return (USB_SUCCESS);
8244 }
8245 
8246 
8247 /*
8248  * hubd_init_power_budget:
8249  *	Init power budget variables in hubd structure. According
8250  *	to USB spec, the power budget rules are:
8251  *	1. local-powered hubs including root-hubs can supply
8252  *	   500mA to each port at maximum
8253  *	2. two bus-powered hubs are not allowed to concatenate
8254  *	3. bus-powered hubs can supply 100mA to each port at
8255  *	   maximum, and the power consumed by all downstream
8256  *	   ports and the hub itself cannot exceed the max power
8257  *	   supplied by the upstream port, i.e., 500mA
8258  *	The routine is only called during hub attach time
8259  */
8260 static int
8261 hubd_init_power_budget(hubd_t *hubd)
8262 {
8263 	uint16_t	status = 0;
8264 	usba_device_t	*hubd_ud = NULL;
8265 	size_t		size;
8266 	usb_cfg_descr_t	cfg_descr;
8267 	dev_info_t	*pdip = NULL;
8268 	hubd_t		*phubd = NULL;
8269 
8270 	if (hubd->h_ignore_pwr_budget) {
8271 
8272 		return (USB_SUCCESS);
8273 	}
8274 
8275 	USB_DPRINTF_L4(DPRINT_MASK_HUB, hubd->h_log_handle,
8276 	    "hubd_init_power_budget:");
8277 
8278 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8279 	ASSERT(hubd->h_default_pipe != 0);
8280 	mutex_exit(HUBD_MUTEX(hubd));
8281 
8282 	/* get device status */
8283 	if ((usb_get_status(hubd->h_dip, hubd->h_default_pipe,
8284 	    HUB_GET_DEVICE_STATUS_TYPE,
8285 	    0, &status, 0)) != USB_SUCCESS) {
8286 		mutex_enter(HUBD_MUTEX(hubd));
8287 
8288 		return (USB_FAILURE);
8289 	}
8290 
8291 	hubd_ud = usba_get_usba_device(hubd->h_dip);
8292 
8293 	size = usb_parse_cfg_descr(hubd_ud->usb_cfg, hubd_ud->usb_cfg_length,
8294 	    &cfg_descr, USB_CFG_DESCR_SIZE);
8295 
8296 	if (size != USB_CFG_DESCR_SIZE) {
8297 		USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
8298 		    "get hub configuration descriptor failed");
8299 		mutex_enter(HUBD_MUTEX(hubd));
8300 
8301 		return (USB_FAILURE);
8302 	}
8303 
8304 	mutex_enter(HUBD_MUTEX(hubd));
8305 
8306 	hubd->h_local_pwr_capable = (cfg_descr.bmAttributes &
8307 	    USB_CFG_ATTR_SELFPWR);
8308 
8309 	if (hubd->h_local_pwr_capable) {
8310 		USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
8311 		    "hub is capable of local power");
8312 	}
8313 
8314 	hubd->h_local_pwr_on = (status &
8315 	    USB_DEV_SLF_PWRD_STATUS) && hubd->h_local_pwr_capable;
8316 
8317 	if (hubd->h_local_pwr_on) {
8318 		USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
8319 		    "hub is local-powered");
8320 
8321 		hubd->h_pwr_limit = (USB_PWR_UNIT_LOAD *
8322 		    USB_HIGH_PWR_VALUE) / USB_CFG_DESCR_PWR_UNIT;
8323 	} else {
8324 		hubd->h_pwr_limit = (USB_PWR_UNIT_LOAD *
8325 		    USB_LOW_PWR_VALUE) / USB_CFG_DESCR_PWR_UNIT;
8326 
8327 		hubd->h_pwr_left = (USB_PWR_UNIT_LOAD *
8328 		    USB_HIGH_PWR_VALUE) / USB_CFG_DESCR_PWR_UNIT;
8329 
8330 		ASSERT(!usba_is_root_hub(hubd->h_dip));
8331 
8332 		if (!usba_is_root_hub(hubd->h_dip)) {
8333 			/*
8334 			 * two bus-powered hubs are not
8335 			 * allowed to be concatenated
8336 			 */
8337 			mutex_exit(HUBD_MUTEX(hubd));
8338 
8339 			pdip = ddi_get_parent(hubd->h_dip);
8340 			phubd = hubd_get_soft_state(pdip);
8341 			ASSERT(phubd != NULL);
8342 
8343 			if (!phubd->h_ignore_pwr_budget) {
8344 				mutex_enter(HUBD_MUTEX(phubd));
8345 				if (phubd->h_local_pwr_on == B_FALSE) {
8346 					USB_DPRINTF_L1(DPRINT_MASK_HUB,
8347 					    hubd->h_log_handle,
8348 					    "two bus-powered hubs cannot "
8349 					    "be concatenated");
8350 
8351 					mutex_exit(HUBD_MUTEX(phubd));
8352 					mutex_enter(HUBD_MUTEX(hubd));
8353 
8354 					return (USB_FAILURE);
8355 				}
8356 				mutex_exit(HUBD_MUTEX(phubd));
8357 			}
8358 
8359 			mutex_enter(HUBD_MUTEX(hubd));
8360 
8361 			USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
8362 			    "hub is bus-powered");
8363 		} else {
8364 			USB_DPRINTF_L3(DPRINT_MASK_HUB, hubd->h_log_handle,
8365 			    "root-hub must be local-powered");
8366 		}
8367 
8368 		/*
8369 		 * Subtract the power consumed by the hub itself
8370 		 * and get the power that can be supplied to
8371 		 * downstream ports
8372 		 */
8373 		hubd->h_pwr_left -=
8374 		    hubd->h_hub_descr.bHubContrCurrent /
8375 		    USB_CFG_DESCR_PWR_UNIT;
8376 		if (hubd->h_pwr_left < 0) {
8377 			USB_DPRINTF_L2(DPRINT_MASK_HUB, hubd->h_log_handle,
8378 			    "hubd->h_pwr_left is less than bHubContrCurrent, "
8379 			    "should fail");
8380 
8381 			return (USB_FAILURE);
8382 		}
8383 	}
8384 
8385 	return (USB_SUCCESS);
8386 }
8387 
8388 
8389 /*
8390  * usba_hubdi_check_power_budget:
8391  *	Check if the hub has enough power budget to allow a
8392  *	child device to select a configuration of config_index.
8393  */
8394 int
8395 usba_hubdi_check_power_budget(dev_info_t *dip, usba_device_t *child_ud,
8396 	uint_t config_index)
8397 {
8398 	int16_t		pwr_left, pwr_limit, pwr_required;
8399 	size_t		size;
8400 	usb_cfg_descr_t cfg_descr;
8401 	hubd_t		*hubd;
8402 
8403 	if ((hubd = hubd_get_soft_state(dip)) == NULL) {
8404 
8405 		return (USB_FAILURE);
8406 	}
8407 
8408 	if (hubd->h_ignore_pwr_budget) {
8409 
8410 		return (USB_SUCCESS);
8411 	}
8412 
8413 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8414 	    "usba_hubdi_check_power_budget: "
8415 	    "dip=0x%p child_ud=0x%p conf_index=%d", (void *)dip,
8416 	    (void *)child_ud, config_index);
8417 
8418 	mutex_enter(HUBD_MUTEX(hubd));
8419 	pwr_limit = hubd->h_pwr_limit;
8420 	if (hubd->h_local_pwr_on == B_FALSE) {
8421 		pwr_left = hubd->h_pwr_left;
8422 		pwr_limit = (pwr_limit <= pwr_left) ? pwr_limit : pwr_left;
8423 	}
8424 	mutex_exit(HUBD_MUTEX(hubd));
8425 
8426 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8427 	    "usba_hubdi_check_power_budget: "
8428 	    "available power is %dmA", pwr_limit * USB_CFG_DESCR_PWR_UNIT);
8429 
8430 	size = usb_parse_cfg_descr(
8431 	    child_ud->usb_cfg_array[config_index], USB_CFG_DESCR_SIZE,
8432 	    &cfg_descr, USB_CFG_DESCR_SIZE);
8433 
8434 	if (size != USB_CFG_DESCR_SIZE) {
8435 		USB_DPRINTF_L2(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8436 		    "get hub configuration descriptor failed");
8437 
8438 		return (USB_FAILURE);
8439 	}
8440 
8441 	pwr_required = cfg_descr.bMaxPower;
8442 
8443 	USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8444 	    "usba_hubdi_check_power_budget: "
8445 	    "child bmAttributes=0x%x bMaxPower=%d "
8446 	    "with config_index=%d", cfg_descr.bmAttributes,
8447 	    pwr_required, config_index);
8448 
8449 	if (pwr_required > pwr_limit) {
8450 		USB_DPRINTF_L1(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8451 		    "configuration %d for device %s %s at port %d "
8452 		    "exceeds power available for this port, please "
8453 		    "re-insert your device into another hub port which "
8454 		    "has enough power",
8455 		    config_index,
8456 		    child_ud->usb_mfg_str,
8457 		    child_ud->usb_product_str,
8458 		    child_ud->usb_port);
8459 
8460 		return (USB_FAILURE);
8461 	}
8462 
8463 	return (USB_SUCCESS);
8464 }
8465 
8466 
8467 /*
8468  * usba_hubdi_incr_power_budget:
8469  *	Increase the hub power budget value when a child device
8470  *	is removed from a bus-powered hub port.
8471  */
8472 void
8473 usba_hubdi_incr_power_budget(dev_info_t *dip, usba_device_t *child_ud)
8474 {
8475 	uint16_t	pwr_value;
8476 	hubd_t		*hubd = hubd_get_soft_state(dip);
8477 
8478 	ASSERT(hubd != NULL);
8479 
8480 	if (hubd->h_ignore_pwr_budget) {
8481 
8482 		return;
8483 	}
8484 
8485 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
8486 	    "usba_hubdi_incr_power_budget: "
8487 	    "dip=0x%p child_ud=0x%p", (void *)dip, (void *)child_ud);
8488 
8489 	mutex_enter(HUBD_MUTEX(hubd));
8490 	if (hubd->h_local_pwr_on == B_TRUE) {
8491 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
8492 		    "usba_hubdi_incr_power_budget: "
8493 		    "hub is local powered");
8494 		mutex_exit(HUBD_MUTEX(hubd));
8495 
8496 		return;
8497 	}
8498 	mutex_exit(HUBD_MUTEX(hubd));
8499 
8500 	mutex_enter(&child_ud->usb_mutex);
8501 	if (child_ud->usb_pwr_from_hub == 0) {
8502 		mutex_exit(&child_ud->usb_mutex);
8503 
8504 		return;
8505 	}
8506 	pwr_value = child_ud->usb_pwr_from_hub;
8507 	mutex_exit(&child_ud->usb_mutex);
8508 
8509 	mutex_enter(HUBD_MUTEX(hubd));
8510 	hubd->h_pwr_left += pwr_value;
8511 
8512 	USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
8513 	    "usba_hubdi_incr_power_budget: "
8514 	    "available power is %dmA, increased by %dmA",
8515 	    hubd->h_pwr_left * USB_CFG_DESCR_PWR_UNIT,
8516 	    pwr_value * USB_CFG_DESCR_PWR_UNIT);
8517 
8518 	mutex_exit(HUBD_MUTEX(hubd));
8519 
8520 	mutex_enter(&child_ud->usb_mutex);
8521 	child_ud->usb_pwr_from_hub = 0;
8522 	mutex_exit(&child_ud->usb_mutex);
8523 }
8524 
8525 
8526 /*
8527  * usba_hubdi_decr_power_budget:
8528  *	Decrease the hub power budget value when a child device
8529  *	is inserted to a bus-powered hub port.
8530  */
8531 void
8532 usba_hubdi_decr_power_budget(dev_info_t *dip, usba_device_t *child_ud)
8533 {
8534 	uint16_t	pwr_value;
8535 	size_t		size;
8536 	usb_cfg_descr_t	cfg_descr;
8537 	hubd_t		*hubd = hubd_get_soft_state(dip);
8538 
8539 	ASSERT(hubd != NULL);
8540 
8541 	if (hubd->h_ignore_pwr_budget) {
8542 
8543 		return;
8544 	}
8545 
8546 	USB_DPRINTF_L4(DPRINT_MASK_ATTA, hubd->h_log_handle,
8547 	    "usba_hubdi_decr_power_budget: "
8548 	    "dip=0x%p child_ud=0x%p", (void *)dip, (void *)child_ud);
8549 
8550 	mutex_enter(HUBD_MUTEX(hubd));
8551 	if (hubd->h_local_pwr_on == B_TRUE) {
8552 		USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
8553 		    "usba_hubdi_decr_power_budget: "
8554 		    "hub is local powered");
8555 		mutex_exit(HUBD_MUTEX(hubd));
8556 
8557 		return;
8558 	}
8559 	mutex_exit(HUBD_MUTEX(hubd));
8560 
8561 	mutex_enter(&child_ud->usb_mutex);
8562 	if (child_ud->usb_pwr_from_hub > 0) {
8563 		mutex_exit(&child_ud->usb_mutex);
8564 
8565 		return;
8566 	}
8567 	mutex_exit(&child_ud->usb_mutex);
8568 
8569 	size = usb_parse_cfg_descr(
8570 	    child_ud->usb_cfg, child_ud->usb_cfg_length,
8571 	    &cfg_descr, USB_CFG_DESCR_SIZE);
8572 	ASSERT(size == USB_CFG_DESCR_SIZE);
8573 
8574 	mutex_enter(HUBD_MUTEX(hubd));
8575 	pwr_value = cfg_descr.bMaxPower;
8576 	hubd->h_pwr_left -= pwr_value;
8577 	ASSERT(hubd->h_pwr_left >= 0);
8578 
8579 	USB_DPRINTF_L3(DPRINT_MASK_ATTA, hubd->h_log_handle,
8580 	    "usba_hubdi_decr_power_budget: "
8581 	    "available power is %dmA, decreased by %dmA",
8582 	    hubd->h_pwr_left * USB_CFG_DESCR_PWR_UNIT,
8583 	    pwr_value * USB_CFG_DESCR_PWR_UNIT);
8584 
8585 	mutex_exit(HUBD_MUTEX(hubd));
8586 
8587 	mutex_enter(&child_ud->usb_mutex);
8588 	child_ud->usb_pwr_from_hub = pwr_value;
8589 	mutex_exit(&child_ud->usb_mutex);
8590 }
8591 
8592 /*
8593  * hubd_wait_for_hotplug_exit:
8594  *	Waiting for the exit of the running hotplug thread or ioctl thread.
8595  */
8596 static int
8597 hubd_wait_for_hotplug_exit(hubd_t *hubd)
8598 {
8599 	clock_t		until = drv_usectohz(1000000);
8600 	int		rval;
8601 
8602 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8603 
8604 	if (hubd->h_hotplug_thread) {
8605 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8606 		    "waiting for hubd hotplug thread exit");
8607 		rval = cv_reltimedwait(&hubd->h_cv_hotplug_dev,
8608 		    &hubd->h_mutex, until, TR_CLOCK_TICK);
8609 
8610 		if ((rval <= 0) && (hubd->h_hotplug_thread)) {
8611 
8612 			return (USB_FAILURE);
8613 		}
8614 	}
8615 
8616 	return (USB_SUCCESS);
8617 }
8618 
8619 /*
8620  * hubd_reset_thread:
8621  *	handles the "USB_RESET_LVL_REATTACH" reset of usb device.
8622  *
8623  *	- delete the child (force detaching the device and its children)
8624  *	- reset the corresponding parent hub port
8625  *	- create the child (force re-attaching the device and its children)
8626  */
8627 static void
8628 hubd_reset_thread(void *arg)
8629 {
8630 	hubd_reset_arg_t *hd_arg = (hubd_reset_arg_t *)arg;
8631 	hubd_t		*hubd = hd_arg->hubd;
8632 	uint16_t	reset_port = hd_arg->reset_port;
8633 	uint16_t	status, change;
8634 	hub_power_t	*hubpm;
8635 	dev_info_t	*hdip = hubd->h_dip;
8636 	dev_info_t	*rh_dip = hubd->h_usba_device->usb_root_hub_dip;
8637 	dev_info_t	*child_dip;
8638 	boolean_t	online_child = B_FALSE;
8639 	int		prh_circ, rh_circ, circ, devinst;
8640 	char		*devname;
8641 	int		i = 0;
8642 	int		rval = USB_FAILURE;
8643 
8644 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8645 	    "hubd_reset_thread:  started, hubd_reset_port = 0x%x", reset_port);
8646 
8647 	kmem_free(arg, sizeof (hubd_reset_arg_t));
8648 
8649 	mutex_enter(HUBD_MUTEX(hubd));
8650 
8651 	child_dip = hubd->h_children_dips[reset_port];
8652 	ASSERT(child_dip != NULL);
8653 
8654 	devname = (char *)ddi_driver_name(child_dip);
8655 	devinst = ddi_get_instance(child_dip);
8656 
8657 	/* if our bus power entry point is active, quit the reset */
8658 	if (hubd->h_bus_pwr) {
8659 		USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8660 		    "%s%d is under bus power management, cannot be reset. "
8661 		    "Please disconnect and reconnect this device.",
8662 		    devname, devinst);
8663 
8664 		goto Fail;
8665 	}
8666 
8667 	if (hubd_wait_for_hotplug_exit(hubd) == USB_FAILURE) {
8668 		/* we got woken up because of a timeout */
8669 		USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG,
8670 		    hubd->h_log_handle, "Time out when resetting the device"
8671 		    " %s%d. Please disconnect and reconnect this device.",
8672 		    devname, devinst);
8673 
8674 		goto Fail;
8675 	}
8676 
8677 	hubd->h_hotplug_thread++;
8678 
8679 	/* is this the root hub? */
8680 	if ((hdip == rh_dip) &&
8681 	    (hubd->h_dev_state == USB_DEV_PWRED_DOWN)) {
8682 		hubpm = hubd->h_hubpm;
8683 
8684 		/* mark the root hub as full power */
8685 		hubpm->hubp_current_power = USB_DEV_OS_FULL_PWR;
8686 		hubpm->hubp_time_at_full_power = ddi_get_time();
8687 		mutex_exit(HUBD_MUTEX(hubd));
8688 
8689 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8690 		    "hubd_reset_thread: call pm_power_has_changed");
8691 
8692 		(void) pm_power_has_changed(hdip, 0,
8693 		    USB_DEV_OS_FULL_PWR);
8694 
8695 		mutex_enter(HUBD_MUTEX(hubd));
8696 		hubd->h_dev_state = USB_DEV_ONLINE;
8697 	}
8698 
8699 	mutex_exit(HUBD_MUTEX(hubd));
8700 
8701 	/*
8702 	 * this ensures one reset activity per system at a time.
8703 	 * we enter the parent PCI node to have this serialization.
8704 	 * this also excludes ioctls and deathrow thread
8705 	 */
8706 	ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
8707 	ndi_devi_enter(rh_dip, &rh_circ);
8708 
8709 	/* exclude other threads */
8710 	ndi_devi_enter(hdip, &circ);
8711 	mutex_enter(HUBD_MUTEX(hubd));
8712 
8713 	/*
8714 	 * We need to make sure that the child is still online for a hotplug
8715 	 * thread could have inserted which detached the child.
8716 	 */
8717 	if (hubd->h_children_dips[reset_port]) {
8718 		mutex_exit(HUBD_MUTEX(hubd));
8719 		/* First disconnect the device */
8720 		hubd_post_event(hubd, reset_port, USBA_EVENT_TAG_HOT_REMOVAL);
8721 
8722 		/* delete cached dv_node's but drop locks first */
8723 		ndi_devi_exit(hdip, circ);
8724 		ndi_devi_exit(rh_dip, rh_circ);
8725 		ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
8726 
8727 		(void) devfs_clean(rh_dip, NULL, DV_CLEAN_FORCE);
8728 
8729 		/*
8730 		 * workaround only for storage device. When it's able to force
8731 		 * detach a driver, this code can be removed safely.
8732 		 *
8733 		 * If we're to reset storage device and the device is used, we
8734 		 * will wait at most extra 20s for applications to exit and
8735 		 * close the device. This is especially useful for HAL-based
8736 		 * applications.
8737 		 */
8738 		if ((strcmp(devname, "scsa2usb") == 0) &&
8739 		    DEVI(child_dip)->devi_ref != 0) {
8740 			while (i++ < hubdi_reset_delay) {
8741 				mutex_enter(HUBD_MUTEX(hubd));
8742 				rval = hubd_delete_child(hubd, reset_port,
8743 				    NDI_DEVI_REMOVE, B_FALSE);
8744 				mutex_exit(HUBD_MUTEX(hubd));
8745 				if (rval == USB_SUCCESS)
8746 					break;
8747 
8748 				delay(drv_usectohz(1000000)); /* 1s */
8749 			}
8750 		}
8751 
8752 		ndi_devi_enter(ddi_get_parent(rh_dip), &prh_circ);
8753 		ndi_devi_enter(rh_dip, &rh_circ);
8754 		ndi_devi_enter(hdip, &circ);
8755 
8756 		mutex_enter(HUBD_MUTEX(hubd));
8757 
8758 		/* Then force detaching the device */
8759 		if ((rval != USB_SUCCESS) && (hubd_delete_child(hubd,
8760 		    reset_port, NDI_DEVI_REMOVE, B_FALSE) != USB_SUCCESS)) {
8761 			USB_DPRINTF_L0(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8762 			    "%s%d cannot be reset due to other applications "
8763 			    "are using it, please first close these "
8764 			    "applications, then disconnect and reconnect"
8765 			    "the device.", devname, devinst);
8766 
8767 			mutex_exit(HUBD_MUTEX(hubd));
8768 			/* post a re-connect event */
8769 			hubd_post_event(hubd, reset_port,
8770 			    USBA_EVENT_TAG_HOT_INSERTION);
8771 			mutex_enter(HUBD_MUTEX(hubd));
8772 		} else {
8773 			(void) hubd_determine_port_status(hubd, reset_port,
8774 			    &status, &change, HUBD_ACK_ALL_CHANGES);
8775 
8776 			/* Reset the parent hubd port and create new child */
8777 			if (status & PORT_STATUS_CCS) {
8778 				online_child |=	(hubd_handle_port_connect(hubd,
8779 				    reset_port) == USB_SUCCESS);
8780 			}
8781 		}
8782 	}
8783 
8784 	/* release locks so we can do a devfs_clean */
8785 	mutex_exit(HUBD_MUTEX(hubd));
8786 
8787 	/* delete cached dv_node's but drop locks first */
8788 	ndi_devi_exit(hdip, circ);
8789 	ndi_devi_exit(rh_dip, rh_circ);
8790 	ndi_devi_exit(ddi_get_parent(rh_dip), prh_circ);
8791 
8792 	(void) devfs_clean(rh_dip, NULL, 0);
8793 
8794 	/* now check if any children need onlining */
8795 	if (online_child) {
8796 		USB_DPRINTF_L3(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8797 		    "hubd_reset_thread: onlining children");
8798 
8799 		(void) ndi_devi_online(hubd->h_dip, 0);
8800 	}
8801 
8802 	mutex_enter(HUBD_MUTEX(hubd));
8803 
8804 	/* allow hotplug thread now */
8805 	hubd->h_hotplug_thread--;
8806 Fail:
8807 	hubd_start_polling(hubd, 0);
8808 
8809 	/* mark this device as idle */
8810 	(void) hubd_pm_idle_component(hubd, hubd->h_dip, 0);
8811 
8812 	USB_DPRINTF_L4(DPRINT_MASK_HOTPLUG, hubd->h_log_handle,
8813 	    "hubd_reset_thread: exit, %d", hubd->h_hotplug_thread);
8814 
8815 	hubd->h_reset_port[reset_port] = B_FALSE;
8816 
8817 	mutex_exit(HUBD_MUTEX(hubd));
8818 
8819 	ndi_rele_devi(hdip);
8820 }
8821 
8822 /*
8823  * hubd_check_same_device:
8824  *	- open the default pipe of the device.
8825  *	- compare the old and new descriptors of the device.
8826  *	- close the default pipe.
8827  */
8828 static int
8829 hubd_check_same_device(hubd_t *hubd, usb_port_t port)
8830 {
8831 	dev_info_t		*dip = hubd->h_children_dips[port];
8832 	usb_pipe_handle_t	ph;
8833 	int			rval = USB_FAILURE;
8834 
8835 	ASSERT(mutex_owned(HUBD_MUTEX(hubd)));
8836 
8837 	mutex_exit(HUBD_MUTEX(hubd));
8838 	/* Open the default pipe to operate the device */
8839 	if (usb_pipe_open(dip, NULL, NULL,
8840 	    USB_FLAGS_SLEEP| USBA_FLAGS_PRIVILEGED,
8841 	    &ph) == USB_SUCCESS) {
8842 		/*
8843 		 * Check that if the device's descriptors are different
8844 		 * from the values saved before the port reset.
8845 		 */
8846 		rval = usb_check_same_device(dip,
8847 		    hubd->h_log_handle, USB_LOG_L0,
8848 		    DPRINT_MASK_ALL, USB_CHK_ALL, NULL);
8849 
8850 		usb_pipe_close(dip, ph, USB_FLAGS_SLEEP |
8851 		    USBA_FLAGS_PRIVILEGED, NULL, NULL);
8852 	}
8853 	mutex_enter(HUBD_MUTEX(hubd));
8854 
8855 	return (rval);
8856 }
8857 
8858 /*
8859  * usba_hubdi_reset_device
8860  *	Called by usb_reset_device to handle usb device reset.
8861  */
8862 int
8863 usba_hubdi_reset_device(dev_info_t *dip, usb_dev_reset_lvl_t reset_level)
8864 {
8865 	hubd_t			*hubd;
8866 	usb_port_t		port = 0;
8867 	dev_info_t		*hdip;
8868 	usb_pipe_state_t	prev_pipe_state = 0;
8869 	usba_device_t		*usba_device;
8870 	hubd_reset_arg_t	*arg;
8871 	int			i, ph_open_cnt;
8872 	int			rval = USB_FAILURE;
8873 
8874 	if ((!dip) || usba_is_root_hub(dip)) {
8875 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8876 		    "usba_hubdi_reset_device: NULL dip or root hub");
8877 
8878 		return (USB_INVALID_ARGS);
8879 	}
8880 
8881 	if (!usb_owns_device(dip)) {
8882 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8883 		    "usba_hubdi_reset_device: Not owns the device");
8884 
8885 		return (USB_INVALID_PERM);
8886 	}
8887 
8888 	if ((reset_level != USB_RESET_LVL_REATTACH) &&
8889 	    (reset_level != USB_RESET_LVL_DEFAULT)) {
8890 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8891 		    "usba_hubdi_reset_device: Unknown flags");
8892 
8893 		return (USB_INVALID_ARGS);
8894 	}
8895 
8896 	if ((hdip = ddi_get_parent(dip)) == NULL) {
8897 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8898 		    "usba_hubdi_reset_device: fail to get parent hub");
8899 
8900 		return (USB_INVALID_ARGS);
8901 	}
8902 
8903 	if ((hubd = hubd_get_soft_state(hdip)) == NULL) {
8904 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubdi_log_handle,
8905 		    "usba_hubdi_reset_device: fail to get hub softstate");
8906 
8907 		return (USB_INVALID_ARGS);
8908 	}
8909 
8910 	mutex_enter(HUBD_MUTEX(hubd));
8911 
8912 	/* make sure the hub is connected before trying any kinds of reset. */
8913 	if ((hubd->h_dev_state == USB_DEV_DISCONNECTED) ||
8914 	    (hubd->h_dev_state == USB_DEV_SUSPENDED)) {
8915 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8916 		    "usb_reset_device: the state %d of the hub/roothub "
8917 		    "associated to the device 0x%p is incorrect",
8918 		    hubd->h_dev_state, (void *)dip);
8919 		mutex_exit(HUBD_MUTEX(hubd));
8920 
8921 		return (USB_INVALID_ARGS);
8922 	}
8923 
8924 	mutex_exit(HUBD_MUTEX(hubd));
8925 
8926 	port = hubd_child_dip2port(hubd, dip);
8927 
8928 	mutex_enter(HUBD_MUTEX(hubd));
8929 
8930 	if (hubd->h_reset_port[port]) {
8931 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8932 		    "usb_reset_device: the corresponding port is resetting");
8933 		mutex_exit(HUBD_MUTEX(hubd));
8934 
8935 		return (USB_SUCCESS);
8936 	}
8937 
8938 	/*
8939 	 * For Default reset, client drivers should first close all the pipes
8940 	 * except default pipe before calling the function, also should not
8941 	 * call the function during interrupt context.
8942 	 */
8943 	if (reset_level == USB_RESET_LVL_DEFAULT) {
8944 		usba_device = hubd->h_usba_devices[port];
8945 		mutex_exit(HUBD_MUTEX(hubd));
8946 
8947 		if (servicing_interrupt()) {
8948 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8949 			    "usb_reset_device: during interrput context, quit");
8950 
8951 			return (USB_INVALID_CONTEXT);
8952 		}
8953 		/* Check if all the pipes have been closed */
8954 		for (ph_open_cnt = 0, i = 1; i < USBA_N_ENDPOINTS; i++) {
8955 			if (usba_device->usb_ph_list[i].usba_ph_data) {
8956 				ph_open_cnt++;
8957 				break;
8958 			}
8959 		}
8960 		if (ph_open_cnt) {
8961 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8962 			    "usb_reset_device: %d pipes are still open",
8963 			    ph_open_cnt);
8964 
8965 			return (USB_BUSY);
8966 		}
8967 		mutex_enter(HUBD_MUTEX(hubd));
8968 	}
8969 
8970 	/* Don't perform reset while the device is detaching */
8971 	if (hubd->h_port_state[port] & HUBD_CHILD_DETACHING) {
8972 		USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
8973 		    "usb_reset_device: the device is detaching, "
8974 		    "cannot be reset");
8975 		mutex_exit(HUBD_MUTEX(hubd));
8976 
8977 		return (USB_FAILURE);
8978 	}
8979 
8980 	hubd->h_reset_port[port] = B_TRUE;
8981 	hdip = hubd->h_dip;
8982 	mutex_exit(HUBD_MUTEX(hubd));
8983 
8984 	/* Don't allow hub detached during the reset */
8985 	ndi_hold_devi(hdip);
8986 
8987 	mutex_enter(HUBD_MUTEX(hubd));
8988 	hubd_pm_busy_component(hubd, hdip, 0);
8989 	mutex_exit(HUBD_MUTEX(hubd));
8990 	/* go full power */
8991 	(void) pm_raise_power(hdip, 0, USB_DEV_OS_FULL_PWR);
8992 	mutex_enter(HUBD_MUTEX(hubd));
8993 
8994 	hubd->h_hotplug_thread++;
8995 
8996 	/* stop polling if it was active */
8997 	if (hubd->h_ep1_ph) {
8998 		mutex_exit(HUBD_MUTEX(hubd));
8999 		(void) usb_pipe_get_state(hubd->h_ep1_ph, &prev_pipe_state,
9000 		    USB_FLAGS_SLEEP);
9001 		mutex_enter(HUBD_MUTEX(hubd));
9002 
9003 		if (prev_pipe_state == USB_PIPE_STATE_ACTIVE) {
9004 			hubd_stop_polling(hubd);
9005 		}
9006 	}
9007 
9008 	switch (reset_level) {
9009 	case USB_RESET_LVL_REATTACH:
9010 		mutex_exit(HUBD_MUTEX(hubd));
9011 		arg = (hubd_reset_arg_t *)kmem_zalloc(
9012 		    sizeof (hubd_reset_arg_t), KM_SLEEP);
9013 		arg->hubd = hubd;
9014 		arg->reset_port = port;
9015 		mutex_enter(HUBD_MUTEX(hubd));
9016 
9017 		if ((rval = usb_async_req(hdip, hubd_reset_thread,
9018 		    (void *)arg, 0)) == USB_SUCCESS) {
9019 			hubd->h_hotplug_thread--;
9020 			mutex_exit(HUBD_MUTEX(hubd));
9021 
9022 			return (USB_SUCCESS);
9023 		} else {
9024 			USB_DPRINTF_L2(DPRINT_MASK_ATTA, hubd->h_log_handle,
9025 			    "Cannot create reset thread, the device %s%d failed"
9026 			    " to reset", ddi_driver_name(dip),
9027 			    ddi_get_instance(dip));
9028 
9029 			kmem_free(arg, sizeof (hubd_reset_arg_t));
9030 		}
9031 
9032 		break;
9033 	case USB_RESET_LVL_DEFAULT:
9034 		/*
9035 		 * Reset hub port and then recover device's address, set back
9036 		 * device's configuration, hubd_handle_port_connect() will
9037 		 * handle errors happened during this process.
9038 		 */
9039 		if ((rval = hubd_handle_port_connect(hubd, port))
9040 		    == USB_SUCCESS) {
9041 			mutex_exit(HUBD_MUTEX(hubd));
9042 			/* re-open the default pipe */
9043 			rval = usba_persistent_pipe_open(usba_device);
9044 			mutex_enter(HUBD_MUTEX(hubd));
9045 			if (rval != USB_SUCCESS) {
9046 				USB_DPRINTF_L2(DPRINT_MASK_ATTA,
9047 				    hubd->h_log_handle, "failed to reopen "
9048 				    "default pipe after reset, disable hub"
9049 				    "port for %s%d", ddi_driver_name(dip),
9050 				    ddi_get_instance(dip));
9051 				/*
9052 				 * Disable port to set out a hotplug thread
9053 				 * which will handle errors.
9054 				 */
9055 				(void) hubd_disable_port(hubd, port);
9056 			}
9057 		}
9058 
9059 		break;
9060 	default:
9061 
9062 		break;
9063 	}
9064 
9065 	/* allow hotplug thread now */
9066 	hubd->h_hotplug_thread--;
9067 
9068 	if ((hubd->h_dev_state == USB_DEV_ONLINE) && hubd->h_ep1_ph &&
9069 	    (prev_pipe_state == USB_PIPE_STATE_ACTIVE)) {
9070 		hubd_start_polling(hubd, 0);
9071 	}
9072 
9073 	hubd_pm_idle_component(hubd, hdip, 0);
9074 
9075 	/* Clear reset mark for the port. */
9076 	hubd->h_reset_port[port] = B_FALSE;
9077 
9078 	mutex_exit(HUBD_MUTEX(hubd));
9079 
9080 	ndi_rele_devi(hdip);
9081 
9082 	return (rval);
9083 }
9084