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