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