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 }