| blob | 121dfb5d02a4cf7cfb1e123fb80ff2398684fa55 |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved.
24 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
25 * Copyright (c) 2018, Joyent, Inc.
26 */
28 /*
29 * USBA: Solaris USB Architecture support for the hub
30 * including root hub
31 * Most of the code for hubd resides in this file and
32 * is shared between the HCD root hub support and hubd
33 */
34 #define USBA_FRAMEWORK
35 #include <sys/usb/usba.h>
36 #include <sys/usb/usba/usba_devdb.h>
37 #include <sys/sunndi.h>
38 #include <sys/usb/usba/usba_impl.h>
39 #include <sys/usb/usba/usba_types.h>
40 #include <sys/usb/usba/hubdi.h>
41 #include <sys/usb/usba/hcdi_impl.h>
42 #include <sys/usb/hubd/hub.h>
43 #include <sys/usb/hubd/hubdvar.h>
44 #include <sys/usb/hubd/hubd_impl.h>
45 #include <sys/kobj.h>
46 #include <sys/kobj_lex.h>
47 #include <sys/fs/dv_node.h>
48 #include <sys/strsun.h>
50 /*
51 * External functions
52 */
55 /*
56 * Prototypes for static functions
57 */
61 ddi_ctl_enum_t op,
70 caddr_t addr,
72 pfn_t pfn,
73 uint_t prot,
74 uint_t lock);
82 ddi_eventcookie_t cookie,
88 ddi_callback_id_t cb_id);
90 uint_t flag,
91 ddi_bus_config_op_t op,
95 uint_t flag,
96 ddi_bus_config_op_t op,
108 /*
109 * Busops vector for USB HUB's
110 */
112 BUSO_REV,
119 ddi_dma_allochdl,
120 ddi_dma_freehdl,
121 ddi_dma_bindhdl,
122 ddi_dma_unbindhdl,
123 ddi_dma_flush,
124 ddi_dma_win,
128 hubd_busop_get_eventcookie,
129 hubd_busop_add_eventcall,
130 hubd_busop_remove_eventcall,
139 hubd_bus_power /* bus_power */
140 };
142 #define USB_HUB_INTEL_VID 0x8087
143 #define USB_HUB_INTEL_PID 0x0020
145 /*
146 * local variables
147 */
152 usb_log_handle_t hubdi_log_handle;
159 /*
160 * initialize private data
161 */
162 void
164 {
174 }
177 void
179 {
187 }
190 /*
191 * Called by an HUB to attach an instance of the driver
192 * make this instance known to USBA
193 * the HUB should initialize usba_hubdi structure prior
194 * to calling this interface
195 */
196 int
198 {
210 /*
211 * add this hubdi instance to the list of known hubdi's
212 */
215 hcdi_iblock_cookie);
221 }
224 /*
225 * Called by an HUB to detach an instance of the driver
226 */
227 int
229 {
245 }
248 /*
249 * misc bus routines currently not used
250 */
251 /*ARGSUSED*/
252 static int
257 caddr_t addr,
259 pfn_t pfn,
260 uint_t prot,
261 uint_t lock)
262 {
264 }
267 /*
268 * root hub support. the root hub uses the same devi as the HCD
269 */
270 int
275 {
286 }
292 /*
293 * create and initialize a usba_device structure
294 */
306 KM_SLEEP);
310 KM_SLEEP);
318 KM_SLEEP);
334 /*
335 * The bDeviceProtocol field of root hub device specifies,
336 * whether root hub is a Super, High, or Full speed usb device.
337 */
344 }
350 /*
351 * For the root hub the default pipe is not yet open
352 */
356 }
358 /*
359 * kill off all OBP children, they may not be fully
360 * enumerated
361 */
366 }
368 /*
369 * "attach" the root hub driver
370 */
373 }
377 fail:
381 }
396 }
403 }
406 int
408 {
411 /* was root hub attached? */
414 /* return success anyway */
416 }
418 /*
419 * usba_hubdi_detach also closes the default pipe
420 * and removes properties so there is no need to
421 * do it here
422 */
428 }
431 }
451 }
454 /*
455 * Actual Hub Driver support code:
456 * shared by root hub and non-root hubs
457 */
458 #include <sys/usb/usba/usbai_version.h>
460 /* Debugging support */
474 /*
475 * local variables:
476 *
477 * Amount of time to wait between resetting the port and accessing
478 * the device. The value is in microseconds.
479 */
482 /*
483 * enumeration retry
484 */
485 #define HUBD_PORT_RETRY 5
488 /*
489 * Stale hotremoved device cleanup delay
490 */
491 #define HUBD_STALE_DIP_CLEANUP_DELAY 5000000
494 /*
495 * retries for USB suspend and resume
496 */
497 #define HUBD_SUS_RES_RETRY 2
501 /*
502 * prototypes
503 */
520 usb_port_status_t port_status,
521 usb_port_t port,
525 boolean_t retry);
546 uint_t ack_flag);
562 ddi_eventcookie_t cookie);
580 NDI_EVENT_POST_TO_ALL},
582 NDI_EVENT_POST_TO_ALL},
584 NDI_EVENT_POST_TO_ALL},
586 NDI_EVENT_POST_TO_ALL}
587 };
589 #define HUBD_N_NDI_EVENTS \
590 (sizeof (hubd_ndi_event_defs) / sizeof (ndi_event_definition_t))
595 /* events received from parent */
597 hubd_disconnect_event_cb,
598 hubd_reconnect_event_cb,
599 hubd_pre_suspend_event_cb,
600 hubd_post_resume_event_cb
601 };
604 /*
605 * hubd_get_soft_state() returns the hubd soft state
606 */
607 hubd_t *
609 {
612 }
622 }
623 }
626 /*
627 * PM support functions:
628 */
629 /*ARGSUSED*/
630 static void
632 {
640 }
644 }
645 }
648 /*ARGSUSED*/
649 static void
651 {
659 }
663 }
664 }
667 /*
668 * track power level changes for children of this instance
669 */
670 static void
672 {
674 usb_port_t portno;
687 }
689 /* assign the port power */
699 /* we have the first child coming out of low power */
702 /* we have the last child going to low power */
704 }
706 }
709 /*
710 * given a child dip, locate its port number
711 */
712 static usb_port_t
714 {
715 usb_port_t port;
722 }
723 }
728 }
731 /*
732 * if the hub can be put into low power mode, return success
733 * NOTE: suspend here means going to lower power, not CPR suspend.
734 */
735 static int
737 {
740 usb_port_t port;
747 }
749 /*
750 * Don't go to lower power if haven't been at full power for enough
751 * time to let hotplug thread kickoff.
752 */
757 }
762 }
768 }
771 /*
772 * resume port depending on current device state
773 */
774 static int
776 {
778 usb_cr_t completion_reason;
779 usb_cb_flags_t cb_flags;
792 /*
793 * This could be a bus ctl for a port other than the one
794 * that has a remote wakeup condition. So check.
795 */
797 /* the port isn't suspended, so don't resume */
804 }
805 /*
806 * Device has initiated a wakeup.
807 * Issue a ClearFeature(PortSuspend)
808 */
812 HUB_HANDLE_PORT_FEATURE_TYPE,
813 USB_REQ_CLEAR_FEATURE,
814 CFS_PORT_SUSPEND,
815 port,
819 "ClearFeature(PortSuspend) fails "
822 }
825 /* either way ack changes on the port */
832 /*
833 * When hubd's connect event callback posts a connect
834 * event to its child, it results in this busctl call
835 * which is valid
836 */
837 /* FALLTHRU */
841 /*
842 * the port isn't suspended, or connected
843 * so don't resume
844 */
851 }
852 /*
853 * prevent kicking off the hotplug thread
854 */
858 /* Now ClearFeature(PortSuspend) */
863 HUB_HANDLE_PORT_FEATURE_TYPE,
864 USB_REQ_CLEAR_FEATURE,
865 CFS_PORT_SUSPEND,
866 port,
873 "ClearFeature(PortSuspend) fails"
877 /*
878 * As per spec section 11.9 and 7.1.7.7
879 * hub need to provide at least 20ms of
880 * resume signalling, and s/w provide 10ms of
881 * recovery time before accessing the port.
882 */
890 /* the port did finally resume */
894 }
895 }
896 }
898 /* allow hotplug thread again */
904 /* Ignore - NO Operation */
915 }
919 }
922 /*
923 * suspend port depending on device state
924 */
925 static int
927 {
930 usb_cr_t completion_reason;
931 usb_cb_flags_t cb_flags;
942 /*
943 * When hubd's connect event callback posts a connect
944 * event to its child, it results in this busctl call
945 * which is valid
946 */
947 /* FALLTHRU */
949 /*
950 * When one child is resuming, the other could timeout
951 * and go to low power mode, which is valid
952 */
953 /* FALLTHRU */
958 /*
959 * Some devices start an unprovoked resume. According to spec,
960 * normal resume time for port is 10ms. Wait for double that
961 * time, then check to be sure port is really suspended.
962 */
964 /* Now SetFeature(PortSuspend) */
968 HUB_HANDLE_PORT_FEATURE_TYPE,
969 USB_REQ_SET_FEATURE,
970 CFS_PORT_SUSPEND,
971 port,
974 USB_SUCCESS) {
977 "SetFeature(PortSuspend) fails"
980 }
982 /*
983 * some devices start an unprovoked resume
984 * wait and check port status after some time
985 */
988 /* either ways ack changes on the port */
993 /* the port is indeed suspended */
1001 port);
1002 }
1003 }
1011 /* Ignore - No Operation */
1023 }
1027 }
1030 /*
1031 * child post attach/detach notifications
1032 */
1033 static void
1035 {
1043 /*
1044 * Check if the child created wants to be power managed.
1045 * If yes, the childs power level gets automatically tracked
1046 * by DDI_CTLOPS_POWER busctl.
1047 * If no, we set power of the new child by default
1048 * to USB_DEV_OS_FULL_PWR. Because we should never suspend.
1049 */
1055 }
1056 }
1057 }
1060 static void
1062 {
1066 /*
1067 * if the device is successfully detached and is the
1068 * last device to detach, mark component as idle
1069 */
1078 /*
1079 * We set power of the detached child
1080 * to 0, so that we can suspend if all
1081 * our children are gone
1082 */
1085 /* check for leaks on detaching */
1088 }
1091 }
1092 }
1095 /*
1096 * hubd_post_power
1097 * After the child's power entry point has been called
1098 * we record its power level in our local struct.
1099 * If the device has powered off, we suspend port
1100 */
1101 static int
1104 {
1112 /* record this power in our local struct */
1117 /* now suspend the port */
1121 /* make sure the port is resumed */
1123 }
1126 /* record old power in our local struct */
1131 /*
1132 * As this device failed to transition from
1133 * power off state, suspend the port again
1134 */
1136 }
1137 }
1140 }
1143 /*
1144 * bus ctl notifications are handled here, the rest goes up to root hub/hcd
1145 */
1146 static int
1149 ddi_ctl_enum_t op,
1152 {
1158 usb_port_t port;
1166 /* flag that we are currently running bus_ctl */
1180 /* there is nothing to do at resume time */
1183 }
1185 /* serialize access */
1197 /* Go busy here. Matching idle is DDI_POST case. */
1201 /*
1202 * if we suspended the port previously
1203 * because child went to low power state, and
1204 * someone unloaded the driver, the port would
1205 * still be suspended and needs to be resumed
1206 */
1210 }
1226 /* Matching idle call for DDI_PRE busy call. */
1229 }
1237 /* there is nothing to do at suspend time */
1240 }
1242 /* serialize access */
1254 /* Go busy here. Matching idle is DDI_POST case. */
1270 /* Matching idle call for DDI_PRE busy call. */
1278 }
1284 }
1286 /* decrement bus_ctls count */
1293 }
1295 /*
1296 * hubd_config_one:
1297 * enumerate one child according to 'port'
1298 */
1300 static boolean_t
1302 {
1313 /*
1314 * this ensures one config activity per system at a time.
1315 * we enter the parent PCI node to have this serialization.
1316 * this also excludes ioctls and deathrow thread
1317 */
1321 /* exclude other threads */
1337 }
1340 }
1353 }
1367 }
1369 /*
1370 * bus enumeration entry points
1371 */
1372 static int
1375 {
1385 }
1388 boolean_t found;
1396 /* split name into "name@addr" parts */
1402 }
1408 }
1410 }
1416 }
1419 static int
1422 {
1425 usb_port_t port;
1434 }
1438 }
1440 /* serialize access */
1445 /* logically zap children's list */
1449 }
1452 /* fill in what's left */
1460 }
1466 }
1468 /* physically zap the children we didn't find */
1472 /* zap the dip and usba_device structure as well */
1476 }
1477 }
1486 }
1489 /* bus_power entry point */
1490 static int
1493 {
1496 usb_port_t port;
1499 pm_bp_nexus_pwrup_t bpn;
1504 "hubd_bus_power: dip=%p, impl_arg=%p, power_op=%d, arg=%p, "
1518 port);
1520 /* go to full power if we are powered down */
1523 /*
1524 * If this case completes normally, idle will be in
1525 * hubd_bus_power / BUS_POWER_POST_NOTIFICATION
1526 */
1529 /*
1530 * raise power only if we have created the components
1531 * and are currently in low power
1532 */
1552 }
1554 }
1556 /* indicate that child is changing power level */
1562 /*
1563 * this child is transitioning from power off
1564 * to power on state - resume port
1565 */
1570 /* reset this flag on failure */
1576 }
1579 }
1586 port);
1592 /* record child's pwr and suspend port if required */
1597 }
1601 /*
1602 * Matching idle for the busy in
1603 * hubd_bus_power / BUS_POWER_PRE_NOTIFICATION
1604 */
1614 }
1621 }
1624 /*
1625 * functions to handle power transition for OS levels 0 -> 3
1626 */
1627 static int
1629 {
1632 /* We can't power down if hotplug thread is running */
1637 }
1643 /*
1644 * To avoid race with bus_power pre_notify on check over
1645 * dev_state, we need to correctly set the dev state
1646 * before the mutex is dropped in stop polling.
1647 */
1651 /*
1652 * if we are the root hub, do not stop polling
1653 * otherwise, we will never see a resume
1654 */
1656 /* place holder to implement Global Suspend */
1661 }
1663 /* Issue USB D3 command to the device here */
1673 }
1676 }
1679 /* ARGSUSED */
1680 static int
1682 {
1683 /* Issue USB D2 command to the device here */
1687 }
1690 /* ARGSUSED */
1691 static int
1693 {
1694 /* Issue USB D1 command to the device here */
1698 }
1701 static int
1703 {
1714 /* implement global resume here */
1718 }
1719 /* Issue USB D0 command to the device here */
1727 /* FALLTHRU */
1729 /* we are already in full power */
1731 /* FALLTHRU */
1734 /*
1735 * PM framework tries to put you in full power
1736 * during system shutdown. If we are disconnected
1737 * return success. Also, we should not change state
1738 * when we are disconnected or suspended or about to
1739 * transition to that state
1740 */
1748 }
1749 }
1752 /* power entry point */
1753 /* ARGSUSED */
1754 int
1756 {
1771 /* check if we are transitioning to a legal power level */
1774 "usba_hubdi_power: illegal power level=%d "
1781 }
1800 }
1806 }
1809 /* power entry point for the root hub */
1810 int
1812 {
1814 }
1817 /*
1818 * standard driver entry points support code
1819 */
1820 int
1822 {
1848 }
1850 /*
1851 * Allocate softc information.
1852 */
1854 /* soft state has already been allocated */
1858 /* generate readable labels for different root hubs */
1867 /* std. for ohci */
1869 }
1878 }
1883 }
1884 }
1904 "Use of a USB1.0 hub behind a higher speed port may "
1906 }
1910 /* register with USBA as client driver */
1916 }
1924 }
1933 }
1938 }
1951 /*
1952 * register this hub instance with usba
1953 */
1959 }
1966 /* now create components to power manage this device */
1969 /*
1970 * Event handling: definition and registration
1971 *
1972 * first the definition:
1973 * get event handle
1974 */
1977 /* bind event set to the handle */
1979 NDI_SLEEP)) {
1984 }
1986 /* event registration */
1992 }
2001 }
2003 /*
2004 * Now that we have our descriptors, we need to give the host controller
2005 * a chance to properly configure the device if needed (this is required
2006 * for xHCI).
2007 *
2008 * Note, if anyone ever adds support for using the Multi TT mode for USB
2009 * 2 High speed Hubs, the xhci driver will need to be updated and that
2010 * will need to be done before this is called.
2011 */
2019 HUB_CHARS_TT_SHIFT;
2025 }
2026 }
2031 }
2040 /* initialize hub power budget variables */
2047 }
2048 }
2050 /* initialize and create children */
2057 }
2059 /*
2060 * create cfgadm nodes
2061 */
2080 instance);
2084 }
2085 }
2090 /* create minor nodes */
2098 }
2108 }
2110 /*
2111 * host controller driver has already reported this dev
2112 * if we are the root hub
2113 */
2116 }
2118 /* enable deathrow thread */
2126 fail:
2127 {
2134 }
2145 }
2146 }
2149 }
2152 int
2154 {
2172 }
2173 }
2176 /*
2177 * hubd_setdevaddr
2178 * set the device addrs on this port
2179 */
2180 static int
2182 {
2184 usb_cr_t completion_reason;
2185 usb_cb_flags_t cb_flags;
2186 usb_pipe_handle_t ph;
2202 /* close the default pipe with addr x */
2209 /*
2210 * If the host controller is in charge of addressing, have it do that
2211 * now and skip everything else.
2212 */
2216 usba_device);
2221 }
2223 /*
2224 * As this device has been reset, temporarily
2225 * assign the default address
2226 */
2237 /* open child's default pipe with USBA_DEFAULT_ADDR */
2240 USB_SUCCESS) {
2245 }
2247 /* Set the address of the device */
2249 USB_DEV_REQ_HOST_TO_DEV,
2259 }
2267 }
2270 }
2272 /* Reset to the old address */
2281 }
2284 /*
2285 * hubd_setdevconfig
2286 * set the device addrs on this port
2287 */
2288 static void
2290 {
2292 usb_cr_t completion_reason;
2293 usb_cb_flags_t cb_flags;
2294 usb_pipe_handle_t ph;
2309 /* open the default control pipe */
2312 USB_SUCCESS) {
2314 /* Set the default configuration of the device */
2316 USB_DEV_REQ_HOST_TO_DEV,
2324 "hubd_setdevconfig: set device config failed: "
2327 }
2328 /*
2329 * After setting the configuration, we make this default
2330 * control pipe persistent, so that it gets re-opened
2331 * on posting a connect event
2332 */
2337 }
2339 }
2342 /*ARGSUSED*/
2343 static int
2345 {
2347 usb_port_t port;
2353 /*
2354 * make sure dip is a usb hub, major of root hub is HCD
2355 * major
2356 */
2359 /*
2360 * need to walk the children since it might be a
2361 * HWA device
2362 */
2365 }
2367 /* TODO: DWA device may also need special handling */
2374 }
2375 }
2381 }
2383 /* walk child list and remove nodes with flag DEVI_DEVICE_REMOVED */
2387 /* for normal usb hub or root hub */
2395 }
2398 B_TRUE);
2399 }
2402 /* for HWA */
2408 }
2413 }
2414 }
2418 /* skip siblings of root hub */
2422 }
2425 }
2428 /*
2429 * this thread will walk all children under the root hub for this
2430 * USB bus instance and attempt to remove them
2431 */
2432 static void
2434 {
2438 #ifndef __lock_lint
2439 callb_cpr_t cprinfo;
2443 #endif
2446 /* don't race with detach */
2457 NULL);
2458 #ifdef __lock_lint
2460 #endif
2463 /* quit if we are not enabled anymore */
2472 }
2476 #ifndef __lock_lint
2486 #endif
2487 }
2489 #ifndef __lock_lint
2492 #endif
2493 }
2496 void
2498 {
2501 /*
2502 * The usb_root_hub_dip pointer for the child hub of the WUSB
2503 * wire adapter class device points to the wire adapter, not
2504 * the root hub. Need to find the real root hub dip so that
2505 * the cleanup thread only starts from the root hub.
2506 */
2517 }
2524 }
2525 }
2534 hubd_root_hub_cleanup_thread,
2536 minclsyspri);
2539 }
2540 }
2543 /*
2544 * hubd_restore_device_state:
2545 * - set config for the hub
2546 * - power cycle all the ports
2547 * - for each port that was connected
2548 * - reset port
2549 * - assign addrs to the device on this port
2550 * - restart polling
2551 * - reset suspend flag
2552 */
2553 static void
2555 {
2558 uint_t hub_prev_state;
2559 usb_port_t port;
2563 boolean_t ehci_root_hub;
2572 /* First bring the device to full power */
2580 DPRINT_MASK_HOTPLUG,
2583 /* change the device state to disconnected */
2590 }
2595 /* First turn off all port power */
2599 "hubd_restore_device_state:"
2601 }
2603 /* Settling time before turning on again */
2608 /* enable power on all ports so we can see connects */
2613 /* disable whatever was enabled */
2620 }
2622 /*
2623 * wait at least 3 frames before accessing devices
2624 * (note that delay's minimal time is one clock tick which
2625 * is 10ms unless hires_tick has been changed)
2626 */
2637 /*
2638 * the childen_dips list may have dips that have been
2639 * already deallocated. we only get a post_detach notification
2640 * but not a destroy notification
2641 */
2644 /* get port status */
2648 /* check if it is truly connected */
2650 /*
2651 * Now reset port and assign the device
2652 * its original address
2653 */
2658 /* required for ppx */
2666 }
2669 retry++;
2676 /* post a connect event */
2679 USBA_EVENT_TAG_HOT_INSERTION);
2682 /*
2683 * Since we have this device connected
2684 * mark it reinserted to prevent
2685 * cleanup thread from stepping in.
2686 */
2692 /*
2693 * reopen pipes for children for
2694 * their DDI_RESUME
2695 */
2700 }
2702 /*
2703 * Mark this dip for deletion as the device
2704 * is not physically present, and schedule
2705 * cleanup thread upon post resume
2706 */
2711 "hubd_restore_device_state: "
2719 }
2721 /* get port status */
2725 /* check if it is truly connected */
2727 /*
2728 * reset the port to find out if we have
2729 * 2.0 device connected or 1.X. A 2.0
2730 * device will still be seen as connected,
2731 * while a 1.X device will switch over to
2732 * the companion controller.
2733 */
2741 /*
2742 * We have a USB 2.0 device
2743 * connected. Power cycle this port
2744 * so that hotplug thread can
2745 * enumerate this device.
2746 */
2751 "hubd_restore_device_state: "
2753 port);
2754 }
2755 }
2757 }
2758 }
2761 /* if the device had remote wakeup earlier, enable it again */
2765 USB_REMOTE_WAKEUP_ENABLE);
2767 }
2773 }
2776 /*
2777 * hubd_cleanup:
2778 * cleanup hubd and deallocate. this function is called for
2779 * handling attach failures and detaching including dynamic
2780 * reconfiguration. If called from attaching, it must clean
2781 * up the whole thing and return success.
2782 */
2783 /*ARGSUSED*/
2784 static int
2786 {
2789 #ifdef DEBUG
2790 usb_port_t port;
2791 #endif
2798 }
2800 /* ensure we are the only one active */
2805 /* Cleanup failure is only allowed if called from detach */
2809 /*
2810 * We are being called from detach.
2811 * Fail immediately if the hotplug thread is running
2812 * else set the dev_state to disconnected so that
2813 * hotplug thread just exits without doing anything.
2814 */
2821 "hubd_cleanup: hotplug thread/bus ctl active "
2825 }
2827 /*
2828 * if the deathrow thread is still active or about
2829 * to become active, fail detach
2830 * the roothup can only be detached if nexus drivers
2831 * are unloaded or explicitly offlined
2832 */
2841 "hubd_cleanup: deathrow still active?"
2845 }
2846 }
2847 }
2860 /*
2861 * deallocate events, if events are still registered
2862 * (ie. children still attached) then we have to fail the detach
2863 */
2869 /* It must return success if attaching. */
2880 }
2881 }
2886 #ifdef DEBUG
2890 }
2891 #endif
2894 }
2896 /*
2897 * Disable the event callbacks first, after this point, event
2898 * callbacks will never get called. Note we shouldn't hold
2899 * mutex while unregistering events because there may be a
2900 * competing event callback thread. Event callbacks are done
2901 * with ndi mutex held and this can cause a potential deadlock.
2902 * Note that cleanup can't fail after deregistration of events.
2903 */
2909 }
2911 /* restore the old dev state so that device can be put into low power */
2919 /*
2920 * Bring the hub to full power before
2921 * issuing the disable remote wakeup command
2922 */
2929 "hubd_cleanup: disable remote wakeup "
2931 }
2932 }
2938 }
2944 }
2946 }
2955 }
2961 }
2967 }
2972 }
2974 done:
2977 }
2985 }
2990 }
2993 /*
2994 * hubd_determine_port_connection:
2995 * Determine which port is in connect status but does not
2996 * have connect status change bit set, and mark port change
2997 * bit accordingly.
2998 * This function is applied during hub attach time.
2999 */
3000 static usb_port_mask_t
3002 {
3003 usb_port_t port;
3015 /* Check if port is in connect status */
3019 }
3021 /*
3022 * Check if port Connect Status Change bit has been set.
3023 * If already set, the connection will be handled by
3024 * intr polling callback, not during attach.
3025 */
3029 }
3032 }
3035 }
3038 /*
3039 * hubd_check_ports:
3040 * - get hub descriptor
3041 * - check initial port status
3042 * - enable power on all ports
3043 * - enable polling on ep1
3044 */
3045 static int
3047 {
3057 /*
3058 * First turn off all port power
3059 */
3062 /* disable whatever was enabled */
3066 }
3068 /*
3069 * do not switch on immediately (instantly on root hub)
3070 * and allow time to settle
3071 */
3076 /*
3077 * enable power on all ports so we can see connects
3078 */
3080 /* disable whatever was enabled */
3084 }
3086 /* wait at least 3 frames before accessing devices */
3091 /*
3092 * allocate arrays for saving the dips of each child per port
3093 *
3094 * ports go from 1 - n, allocate 1 more entry
3095 */
3115 }
3119 /*
3120 * Some hub devices, like the embedded hub in the CKS ErgoMagic
3121 * keyboard, may only have connection status bit set, but not
3122 * have connect status change bit set when a device has been
3123 * connected to its downstream port before the hub is enumerated.
3124 * Then when the hub is in enumeration, the devices connected to
3125 * it cannot be detected by the intr pipe and won't be enumerated.
3126 * We need to check such situation here and enumerate the downstream
3127 * devices for such hubs.
3128 */
3146 /* mark this device as idle */
3149 }
3152 }
3158 }
3161 /*
3162 * hubd_get_hub_descriptor:
3163 */
3164 static int
3166 {
3168 usb_cr_t completion_reason;
3169 usb_cb_flags_t cb_flags;
3180 }
3187 /*
3188 * The contents of wValue change depending on whether this is a USB 2 or
3189 * USB 3 device. SuperSpeed Hubs have different descriptors and you
3190 * cannot ask them for the traditional USB 2 descriptor.
3191 */
3196 }
3198 /*
3199 * The hub descriptor length varies in various versions of USB. For
3200 * example, in USB 2 it's at least 9 bytes long. To start with, we
3201 * always get the first 8 bytes so we can figure out how long it
3202 * actually is.
3203 */
3206 HUB_CLASS_REQ_TYPE,
3220 }
3228 /* get complete hub descriptor */
3231 HUB_CLASS_REQ_TYPE,
3239 /*
3240 * Hub descriptor data less than 9 bytes is not valid and
3241 * may cause trouble if we use it. See USB2.0 Tab11-13.
3242 */
3245 "get hub descriptor failed: "
3253 }
3254 }
3258 /*
3259 * Parse the hub descriptor. Note that the format of the descriptor
3260 * itself depends on the USB version. We handle the different ones and
3261 * transform it into a single uniform view.
3262 */
3266 usb_ss_hub_descr_t hub_descr;
3270 /*
3271 * Note many hubs may support less than the 255 devices that the
3272 * USB specification allows for. In those cases, we'll simply
3273 * read less and it should be okay.
3274 */
3281 }
3288 usb_hub_descr_t hub_descr;
3296 }
3302 }
3307 "rval=0x%x bNbrPorts=0x%x wHubChars=0x%x "
3314 "Hub driver supports max of %d ports on hub. "
3319 }
3322 }
3324 static int
3326 {
3328 usb_cr_t completion_reason;
3329 usb_cb_flags_t cb_flags;
3333 /*
3334 * We only need to set the hub depth devices for hubs that are at least
3335 * SuperSpeed devices. This didn't exist for USB 2.0 and older hubs.
3336 * There's also no need to call this on the root hub.
3337 */
3345 depth++;
3347 }
3362 HUBD_SS_MAX_DEPTH);
3364 }
3366 /*
3367 * When making the HUB_REQ_SET_HUB_DEPTH request, a hub connected to a
3368 * root port is considered to have a hub depth of zero whereas we
3369 * consider having a hub depth of one above.
3370 */
3371 depth--;
3375 HUB_SET_HUB_DEPTH_TYPE,
3385 }
3388 }
3390 /*
3391 * hubd_get_hub_status_words:
3392 */
3393 static int
3395 {
3396 usb_cr_t completion_reason;
3397 usb_cb_flags_t cb_flags;
3405 HUB_CLASS_REQ_TYPE,
3406 USB_REQ_GET_STATUS,
3409 GET_STATUS_LENGTH,
3418 }
3423 }
3436 }
3439 /*
3440 * hubd_open_intr_pipe:
3441 * we read all descriptors first for curiosity and then simply
3442 * open the pipe
3443 */
3444 static int
3446 {
3467 }
3476 }
3479 /*
3480 * hubd_start_polling:
3481 * start or restart the polling
3482 */
3483 static void
3485 {
3488 usb_pipe_state_t pipe_state;
3496 /*
3497 * start or restart polling on the intr pipe
3498 * only if hotplug thread is not running
3499 */
3511 USB_ATTRS_AUTOCLEARING;
3521 }
3524 USB_FLAGS_SLEEP);
3528 }
3533 }
3534 }
3537 /*
3538 * hubd_stop_polling
3539 * stop polling but do not close the pipe
3540 */
3541 static void
3543 {
3545 usb_pipe_state_t pipe_state;
3555 USB_FLAGS_SLEEP);
3560 }
3564 }
3565 }
3566 }
3569 /*
3570 * hubd_close_intr_pipe:
3571 * close the pipe (which also stops the polling
3572 * and wait for the hotplug thread to exit
3573 */
3574 static void
3576 {
3580 /*
3581 * Now that no async operation is outstanding on pipe,
3582 * we can change the state to HUBD_INTR_PIPE_CLOSING
3583 */
3594 }
3597 }
3600 /*
3601 * hubd_exception_cb
3602 * interrupt ep1 exception callback function.
3603 * this callback executes in taskq thread context and assumes
3604 * autoclearing
3605 */
3606 /*ARGSUSED*/
3607 static void
3609 {
3613 "hubd_exception_cb: "
3625 /* only restart polling after autoclearing */
3629 }
3636 /* never restart polling on these conditions */
3638 /* for all others, wait for the autoclearing PIPE_RESET cb */
3641 }
3646 }
3649 /*
3650 * helper function to convert LE bytes to a portmask
3651 */
3652 static usb_port_mask_t
3654 {
3661 }
3664 }
3667 /*
3668 * hubd_read_cb:
3669 * interrupt ep1 callback function
3670 *
3671 * the status indicates just a change on the pipe with no indication
3672 * of what the change was
3673 *
3674 * known conditions:
3675 * - reset port completion
3676 * - connect
3677 * - disconnect
3678 *
3679 * for handling the hotplugging, create a new thread that can do
3680 * synchronous usba calls
3681 */
3682 static void
3684 {
3696 /*
3697 * At present, we are not handling notification for completion of
3698 * asynchronous pipe reset, for which this data ptr could be NULL
3699 */
3705 }
3720 }
3726 /*
3727 * Only look at the data and startup the hotplug thread if
3728 * there actually is data.
3729 */
3733 /*
3734 * if a port change was already reported and we are waiting for
3735 * reset port completion then wake up the hotplug thread which
3736 * should be waiting on reset port completion
3737 *
3738 * if there is disconnect event instead of reset completion, let
3739 * the hotplug thread figure this out
3740 */
3742 /* remove the reset wait bits from the status */
3750 /* there should be only one reset bit active at the time */
3754 }
3756 /*
3757 * kick off the thread only if device is ONLINE and it is not
3758 * during attaching or detaching
3759 */
3766 "creating hotplug thread: "
3769 /*
3770 * Mark this device as busy. The will be marked idle
3771 * if the async req fails or at the exit of hotplug
3772 * thread
3773 */
3780 hubd_hotplug_thread,
3785 /* mark this device as idle */
3788 }
3789 }
3790 }
3795 }
3798 }
3801 /*
3802 * hubd_hotplug_thread:
3803 * handles resetting of port, and creating children
3804 *
3805 * the ports to check are indicated in h_port_change bit mask
3806 * XXX note that one time poll doesn't work on the root hub
3807 */
3808 static void
3810 {
3814 usb_port_t port;
3829 /*
3830 * Before console is init'd, we temporarily block the hotplug
3831 * threads so that BUS_CONFIG_ONE through hubd_bus_config() can be
3832 * processed quickly. This reduces the time needed for vfs_mountroot()
3833 * to mount the root FS from a USB disk. And on SPARC platform,
3834 * in order to load 'consconfig' successfully after OBP is gone,
3835 * we need to check 'modrootloaded' to make sure root filesystem is
3836 * available.
3837 */
3840 }
3844 /*
3845 * if our bus power entry point is active, process the change
3846 * on the next notification of interrupt pipe
3847 */
3852 /* mark this device as idle */
3857 "hubd_hotplug_thread: "
3861 }
3868 /* is this the root hub? */
3873 /* mark the root hub as full power */
3882 USB_DEV_OS_FULL_PWR);
3886 }
3891 }
3895 /*
3896 * this ensures one hotplug activity per system at a time.
3897 * we enter the parent PCI node to have this serialization.
3898 * this also excludes ioctls and deathrow thread
3899 * (a bit crude but easier to debug)
3900 */
3904 /* exclude other threads */
3916 /*
3917 * The 0th bit is the hub status change bit.
3918 * handle loss of local power here
3919 */
3924 /*
3925 * This should be handled properly. For now,
3926 * mask off the bit.
3927 */
3930 /*
3931 * check and ack hub status
3932 * this causes stall conditions
3933 * when local power is removed
3934 */
3936 }
3939 usb_port_mask_t port_mask;
3940 boolean_t was_connected;
3943 was_connected =
3948 "hubd_hotplug_thread: "
3951 was_connected);
3953 /*
3954 * is this a port connection that changed?
3955 */
3959 }
3962 /* ack all changes */
3971 /* Recover a disabled port */
3975 "port%d Disabled - "
3979 /*
3980 * if the port was connected and is still
3981 * connected, recover the port
3982 */
3984 PORT_STATUS_CCS)) {
3985 online_child |=
3988 }
3989 }
3991 /*
3992 * Now check what changed on the port
3993 */
3997 /* new device plugged in */
3998 online_child |=
4003 was_connected) {
4004 /*
4005 * In this case we can never be sure
4006 * if the device indeed got hotplugged
4007 * or the hub is falsely reporting the
4008 * change.
4009 */
4013 /*
4014 * this ensures we do not race with
4015 * other threads which are detaching
4016 * the child driver at the same time.
4017 */
4019 /*
4020 * Now check if the driver remains
4021 * attached.
4022 */
4024 /*
4025 * first post a disconnect event
4026 * to the child.
4027 */
4029 USBA_EVENT_TAG_HOT_REMOVAL);
4032 /*
4033 * then reset the port and
4034 * recover the device
4035 */
4036 online_child |=
4041 }
4046 /* this is a disconnect */
4049 USBA_EVENT_TAG_HOT_REMOVAL);
4053 }
4054 }
4056 /*
4057 * Check if any port is coming out of suspend
4058 */
4060 /* a resuming device could have disconnected */
4064 /* device on this port resuming */
4069 /*
4070 * Don't raise power on detaching child
4071 */
4073 /*
4074 * As this child is not
4075 * detaching, we set this
4076 * flag, causing bus_ctls
4077 * to stall detach till
4078 * pm_raise_power returns
4079 * and flag it for a deferred
4080 * raise_power.
4081 *
4082 * pm_raise_power is deferred
4083 * because we need to release
4084 * the locks first.
4085 */
4087 HUBD_CHILD_RAISE_POWER;
4091 /*
4092 * make sure that child
4093 * doesn't disappear
4094 */
4098 }
4099 }
4100 }
4102 /*
4103 * Check if the port is over-current
4104 */
4108 "Port%d in over current condition, "
4109 "please check the attached device to "
4110 "clear the condition. The system will "
4111 "try to recover the port, but if not "
4112 "successful, you need to re-connect "
4113 "the hub or reboot the system to bring "
4117 /*
4118 * Try to enable port power, but
4119 * possibly fail. Ignore failure
4120 */
4122 port);
4124 /*
4125 * Delay some time to avoid
4126 * over-current event to happen
4127 * too frequently in some cases
4128 */
4132 }
4133 }
4134 }
4135 }
4137 /* release locks so we can do a devfs_clean */
4140 /* delete cached dv_node's but drop locks first */
4147 /* now check if any children need onlining */
4153 }
4155 /* now check if any disconnected devices need to be cleaned up */
4161 }
4165 /* now raise power on the children that have woken up */
4175 /* Get the device to full power */
4178 USB_DEV_OS_FULL_PWR);
4181 /* release the hold on the child */
4186 }
4187 }
4188 /*
4189 * make sure that we don't accidentally
4190 * over write the disconnect state
4191 */
4194 }
4195 }
4197 /*
4198 * start polling can immediately kick off read callback
4199 * we need to set the h_hotplug_thread to 0 so that
4200 * the callback is not dropped
4201 *
4202 * if there is device during reset, still stop polling to avoid the
4203 * read callback interrupting the reset, the polling will be started
4204 * in hubd_reset_thread.
4205 */
4210 }
4211 }
4214 }
4216 /*
4217 * Earlier we would set the h_hotplug_thread = 0 before
4218 * polling was restarted so that
4219 * if there is any root hub status change interrupt, we can still kick
4220 * off the hotplug thread. This was valid when this interrupt was
4221 * delivered in hardware, and only ONE interrupt would be delivered.
4222 * Now that we poll on the root hub looking for status change in
4223 * software, this assignment is no longer required.
4224 */
4227 /* mark this device as idle */
4238 }
4241 /*
4242 * hubd_handle_port_connect:
4243 * Transition a port from Disabled to Enabled. Ensure that the
4244 * port is in the correct state before attempting to
4245 * access the device.
4246 */
4247 static int
4249 {
4256 usb_port_status_t speed;
4257 usb_addr_t hubd_usb_addr;
4262 /* Get the hub address and port status */
4269 /*
4270 * If a device is connected, transition the
4271 * port from Disabled to the Enabled state.
4272 * The device will receive downstream packets
4273 * in the Enabled state.
4274 *
4275 * reset port and wait for the hub to report
4276 * completion
4277 */
4280 /*
4281 * According to section 9.1.2 of USB 2.0 spec, the host should
4282 * wait for atleast 100ms to allow completion of an insertion
4283 * process and for power at the device to become stable.
4284 * We wait for 200 ms
4285 */
4291 /* calculate 600 ms delay time */
4303 /* continue only if port is still connected */
4306 }
4308 /* carry on regardless */
4309 }
4311 /*
4312 * according to USB 2.0 spec section 11.24.2.7.1.2
4313 * at the end of port reset, the hub enables the port.
4314 * But for some strange reasons, uhci port remains disabled.
4315 * And because the port remains disabled for the settling
4316 * time below, the device connected to the port gets wedged
4317 * - fails to enumerate (device not responding)
4318 * Hence, we enable it here immediately and later again after
4319 * the delay
4320 */
4323 /* we skip this delay in the first iteration */
4325 /*
4326 * delay for device to signal disconnect/connect so
4327 * that hub properly recognizes the speed of the device
4328 */
4333 /*
4334 * When a low speed device is connected to any port of
4335 * PPX it has to be explicitly enabled
4336 * Also, if device intentionally signals
4337 * disconnect/connect, it will disable the port.
4338 * So enable it again.
4339 */
4341 }
4352 }
4360 /* ack changes */
4365 }
4367 /* is status really OK? */
4373 /* check if we still have the connection */
4375 /* lost connection, set exit condition */
4379 }
4383 "creating child port%d, status=0x%x "
4387 /*
4388 * if the child already exists, set addrs and config
4389 * to the device post connect event to the child
4390 */
4392 /* set addrs to this device */
4395 /*
4396 * This delay is important for the CATC hub
4397 * to enumerate. But, avoid delay in the first
4398 * iteration
4399 */
4405 }
4408 /*
4409 * if the port is resetting, check if
4410 * device's descriptors have changed.
4411 */
4418 }
4420 /*
4421 * set the default config for
4422 * this device
4423 */
4426 /*
4427 * if we are doing Default reset, do
4428 * not post reconnect event since we
4429 * don't know where reset function is
4430 * called.
4431 */
4435 }
4437 /*
4438 * indicate to the child that
4439 * it is online again
4440 */
4443 USBA_EVENT_TAG_HOT_INSERTION);
4447 }
4449 /*
4450 * We need to release access here
4451 * so that busctls on other ports can
4452 * continue and don't cause a deadlock
4453 * when busctl and removal of prom node
4454 * takes concurrently. This also ensures
4455 * busctls for attach of successfully
4456 * enumerated devices on other ports can
4457 * continue concurrently with the process
4458 * of enumerating the new devices. This
4459 * reduces the overall boot time of the system.
4460 */
4462 hubd,
4465 retry);
4468 USBA_TOTAL_HOTPLUG_SUCCESS|
4469 USBA_HOTPLUG_SUCCESS);
4474 DPRINT_MASK_HOTPLUG,
4476 "device on port %d "
4482 }
4485 }
4486 }
4487 }
4489 /* wait a while until it settles? */
4498 }
4502 }
4505 /*
4506 * If it is a High Speed Root Hub and connected device
4507 * Is a Low/Full Speed, it will be handled by USB 1.1
4508 * Host Controller. In this case, USB 2.0 Host Controller
4509 * will transfer the ownership of this port to USB 1.1
4510 * Host Controller. So don't display any error message on
4511 * the console. Note, this isn't the case for USB 3.x.
4512 */
4518 "hubd_handle_port_connect: Low/Full speed "
4524 }
4531 /*
4532 * the port should be automagically
4533 * disabled but just in case, we do
4534 * it here
4535 */
4538 /* ack all changes because we disabled this port */
4542 }
4545 }
4548 /*
4549 * hubd_get_hub_status:
4550 */
4551 static int
4553 {
4555 usb_cr_t completion_reason;
4556 usb_cb_flags_t cb_flags;
4560 usb_cfg_descr_t cfg_descr;
4564 usb_port_t port;
4574 }
4580 /* Obtain the raw configuration descriptor */
4583 /* get configuration descriptor */
4597 }
4599 /* check if local power status changed. */
4602 /*
4603 * local power has been lost, check the maximum
4604 * power consumption of current configuration.
4605 * see USB2.0 spec Table 11-12.
4606 */
4611 /*
4612 * Self-powered only hub. Because it could
4613 * not draw any power from USB bus.
4614 * It can't work well on this condition.
4615 */
4618 "local power has been lost, "
4622 /*
4623 * Bus-powered only or self/bus-powered hub.
4624 */
4627 "local power has been lost,"
4628 "the hub could draw %d"
4631 }
4633 }
4640 HUB_HANDLE_HUB_FEATURE_TYPE,
4641 USB_REQ_CLEAR_FEATURE,
4642 CFS_C_HUB_LOCAL_POWER,
4649 "clear feature C_HUB_LOCAL_POWER "
4652 }
4654 }
4661 /*
4662 * The root hub should be automatically
4663 * recovered when over-current condition is
4664 * cleared. But there might be exception and
4665 * need user interaction to recover.
4666 */
4669 "Root hub over current condition, "
4670 "please check your system to clear the "
4671 "condition as soon as possible. And you "
4672 "may need to reboot the system to bring "
4673 "the root hub back to work if it cannot "
4676 /*
4677 * The driver would try to recover port power
4678 * on over current condition. When the recovery
4679 * fails, the user may still need to offline
4680 * this hub in order to recover.
4681 * The port power is automatically disabled,
4682 * so we won't see disconnects.
4683 */
4686 "Hub global over current condition, "
4687 "please disconnect the devices connected "
4688 "to the hub to clear the condition. And "
4689 "you may need to re-connect the hub if "
4691 }
4692 }
4699 HUB_HANDLE_HUB_FEATURE_TYPE,
4700 USB_REQ_CLEAR_FEATURE,
4701 CFS_C_HUB_OVER_CURRENT,
4708 "clear feature C_HUB_OVER_CURRENT "
4711 }
4713 /*
4714 * Try to recover all port power if they are turned off.
4715 * Don't do this for root hub, but rely on the root hub
4716 * to recover itself.
4717 */
4722 /*
4723 * Only check the power status of the 1st port
4724 * since all port power status should be the same.
4725 */
4731 }
4735 }
4739 /*
4740 * Delay some time to avoid over-current event
4741 * to happen too frequently in some cases
4742 */
4744 }
4745 }
4750 }
4752 /*
4753 * Convert a series of USB status requests from USB 2 and USB 3 into a single
4754 * uniform type. We separate out the speed into its own value from both USB 2
4755 * and USB 3 and from there we transform the status to look like a USB 2 one.
4756 */
4757 static void
4760 {
4766 /*
4767 * USB 3 devices are always at super speed when plugged into a
4768 * super speed hub. However, this is only true if we're talking
4769 * about actual hubs. This doesn't hold for the root hub, which
4770 * can support USB 3.x, USB 2.x, and USB 1.x devices operating
4771 * at different speeds. To handle this, the USB 3 HCD driver
4772 * (xhci) uses some of the extra status bits to stash the
4773 * current device's detected speed.
4774 */
4778 PORT_STATUS_SPSHIFT_SS;
4779 }
4783 }
4789 }
4791 /*
4792 * For USB 2, the only thing we need to do is transform the
4793 * speed.
4794 */
4802 else
4804 }
4805 }
4808 /*
4809 * Attempt to reset a port. This feels a bit more complicated than it should be
4810 * in part due to how HCD, change status notifications, and the hotplug thread
4811 * might interact. Basically we try to block port changes by using the
4812 * h_port_reset_wait which says we should get signalled rather than kicking off
4813 * the hotplug thread. We'll give this a shot for about 100ms at best.
4814 */
4815 static int
4817 {
4819 usb_cr_t completion_reason;
4820 usb_cb_flags_t cb_flags;
4826 boolean_t first;
4839 HUB_HANDLE_PORT_FEATURE_TYPE,
4840 USB_REQ_SET_FEATURE,
4841 CFS_PORT_RESET,
4842 port,
4853 }
4860 /*
4861 * wait for port status change event
4862 */
4870 }
4874 else
4879 /*
4880 * Regardless of the status, we always check to see if the port
4881 * has been reset.
4882 */
4892 /* check status to determine whether reset completed */
4896 HUB_GET_PORT_STATUS_TYPE,
4897 USB_REQ_GET_STATUS,
4899 port,
4900 GET_STATUS_LENGTH,
4911 }
4915 }
4924 /* continue only if port is still connected */
4927 /* lost connection, set exit condition */
4933 }
4944 }
4952 HUB_HANDLE_PORT_FEATURE_TYPE,
4953 USB_REQ_CLEAR_FEATURE,
4954 CFS_C_PORT_RESET,
4955 port,
4961 "clear feature CFS_C_PORT_RESET"
4964 }
4965 }
4967 /*
4968 * In addition to a normal reset, a warm reset may have
4969 * happened. Acknowledge that as well.
4970 */
4977 HUB_HANDLE_PORT_FEATURE_TYPE,
4978 USB_REQ_CLEAR_FEATURE,
4979 CFS_C_BH_PORT_RESET,
4980 port,
4986 "clear feature CFS_C_BH_PORT_RESET"
4989 }
4990 }
4996 }
4999 }
5002 /*
5003 * hubd_enable_port:
5004 * this may fail if the hub as been disconnected
5005 */
5006 static int
5008 {
5010 usb_cr_t completion_reason;
5011 usb_cb_flags_t cb_flags;
5020 /* Do not issue a SetFeature(PORT_ENABLE) on external hubs */
5025 }
5029 HUB_HANDLE_PORT_FEATURE_TYPE,
5030 USB_REQ_SET_FEATURE,
5031 CFS_PORT_ENABLE,
5032 port,
5039 }
5047 }
5050 /*
5051 * hubd_disable_port
5052 */
5053 static int
5055 {
5057 usb_cr_t completion_reason;
5058 usb_cb_flags_t cb_flags;
5069 HUB_HANDLE_PORT_FEATURE_TYPE,
5070 USB_REQ_CLEAR_FEATURE,
5071 CFS_PORT_ENABLE,
5072 port,
5082 }
5089 HUB_HANDLE_PORT_FEATURE_TYPE,
5090 USB_REQ_CLEAR_FEATURE,
5091 CFS_C_PORT_ENABLE,
5092 port,
5098 "clear feature CFS_C_PORT_ENABLE port%d failed "
5105 }
5110 }
5113 /*
5114 * hubd_determine_port_status:
5115 */
5116 static int
5119 {
5122 usb_cr_t completion_reason;
5123 usb_cb_flags_t cb_flags;
5125 usb_port_status_t sp;
5147 HUB_GET_PORT_STATUS_TYPE,
5148 USB_REQ_GET_STATUS,
5150 port,
5151 GET_STATUS_LENGTH,
5160 }
5165 }
5175 }
5197 }
5209 }
5221 }
5231 }
5241 }
5253 }
5264 }
5266 /*
5267 * Acknowledge connection, enable, reset status
5268 */
5276 HUB_HANDLE_PORT_FEATURE_TYPE,
5277 USB_REQ_CLEAR_FEATURE,
5278 CFS_C_PORT_CONNECTION,
5279 port,
5282 USB_SUCCESS) {
5285 "clear feature CFS_C_PORT_CONNECTION"
5288 }
5289 }
5295 HUB_HANDLE_PORT_FEATURE_TYPE,
5296 USB_REQ_CLEAR_FEATURE,
5297 CFS_C_PORT_ENABLE,
5298 port,
5301 USB_SUCCESS) {
5304 "clear feature CFS_C_PORT_ENABLE"
5307 }
5308 }
5315 HUB_HANDLE_PORT_FEATURE_TYPE,
5316 USB_REQ_CLEAR_FEATURE,
5317 CFS_C_PORT_SUSPEND,
5318 port,
5321 USB_SUCCESS) {
5324 "clear feature CFS_C_PORT_SUSPEND"
5327 }
5328 }
5335 HUB_HANDLE_PORT_FEATURE_TYPE,
5336 USB_REQ_CLEAR_FEATURE,
5337 CFS_C_PORT_OVER_CURRENT,
5338 port,
5341 USB_SUCCESS) {
5344 "clear feature CFS_C_PORT_OVER_CURRENT"
5347 }
5348 }
5354 HUB_HANDLE_PORT_FEATURE_TYPE,
5355 USB_REQ_CLEAR_FEATURE,
5356 CFS_C_PORT_RESET,
5357 port,
5360 USB_SUCCESS) {
5363 "clear feature CFS_C_PORT_RESET"
5366 }
5367 }
5373 HUB_HANDLE_PORT_FEATURE_TYPE,
5374 USB_REQ_CLEAR_FEATURE,
5375 CFS_C_BH_PORT_RESET,
5376 port,
5379 USB_SUCCESS) {
5382 "clear feature CFS_C_BH_PORT_RESET"
5385 }
5386 }
5392 HUB_HANDLE_PORT_FEATURE_TYPE,
5393 USB_REQ_CLEAR_FEATURE,
5394 CFS_C_PORT_LINK_STATE,
5395 port,
5398 USB_SUCCESS) {
5401 "clear feature CFS_C_PORT_LINK_STATE"
5404 }
5405 }
5411 HUB_HANDLE_PORT_FEATURE_TYPE,
5412 USB_REQ_CLEAR_FEATURE,
5413 CFS_C_PORT_CONFIG_ERROR,
5414 port,
5417 USB_SUCCESS) {
5420 "clear feature CFS_C_PORT_CONFIG_ERROR"
5423 }
5424 }
5426 }
5433 }
5436 /*
5437 * hubd_recover_disabled_port
5438 * if the port got disabled because of an error
5439 * enable it. If hub doesn't suport enable port,
5440 * reset the port to bring the device to life again
5441 */
5442 static int
5444 {
5449 /* first try enabling the port */
5452 /* read the port status */
5454 PORT_CHANGE_PESC);
5460 /* first post a disconnect event to the child */
5465 /* then reset the port and recover the device */
5470 }
5473 }
5476 /*
5477 * hubd_enable_all_port_power:
5478 */
5479 static int
5481 {
5483 usb_port_t port;
5484 uint_t retry;
5493 /*
5494 * According to section 11.11 of USB, for hubs with no power
5495 * switches, bPwrOn2PwrGood is zero. But we wait for some
5496 * arbitrary time to enable power to become stable.
5497 *
5498 * If an hub supports port power switching, we need to wait
5499 * at least 20ms before accessing corresponding usb port. Note,
5500 * this member is stored in the h_power_good member.
5501 */
5508 }
5514 /*
5515 * Enable power per port. we ignore gang power and power mask
5516 * and always enable all ports one by one.
5517 */
5519 /*
5520 * Transition the port from the Powered Off to the
5521 * Disconnected state by supplying power to the port.
5522 */
5528 }
5534 /* For retry if any, use some extra delay */
5537 /* Check each port power status for a given usb hub */
5540 /* Get port status */
5557 /* Get port status */
5560 }
5562 /* Print warning message if port has no power */
5566 "hubd_enable_all_port_power: port %d power-on "
5568 }
5569 }
5572 }
5575 /*
5576 * hubd_enable_port_power:
5577 * enable individual port power
5578 */
5579 static int
5581 {
5583 usb_cr_t completion_reason;
5584 usb_cb_flags_t cb_flags;
5596 HUB_HANDLE_PORT_FEATURE_TYPE,
5597 USB_REQ_SET_FEATURE,
5598 CFS_PORT_POWER,
5599 port,
5613 }
5614 }
5617 /*
5618 * hubd_disable_all_port_power:
5619 */
5620 static int
5622 {
5623 usb_port_t port;
5630 /*
5631 * disable power per port, ignore gang power and power mask
5632 */
5635 }
5638 }
5641 /*
5642 * hubd_disable_port_power:
5643 * disable individual port power
5644 */
5645 static int
5647 {
5649 usb_cr_t completion_reason;
5650 usb_cb_flags_t cb_flags;
5661 HUB_HANDLE_PORT_FEATURE_TYPE,
5662 USB_REQ_CLEAR_FEATURE,
5663 CFS_PORT_POWER,
5664 port,
5681 }
5682 }
5685 /*
5686 * Search the database of user preferences and find out the preferred
5687 * configuration for this new device
5688 */
5689 int
5692 {
5704 /* try to get pathname for this device */
5711 /*
5712 * We haven't initialized the node and it doesn't have an address
5713 * yet. Append port number to the physical pathname
5714 */
5721 pathname);
5725 /* database search for user preferences */
5731 "hubd_select_device_configuration: "
5732 "usba_devdb_get_user_preferences "
5743 }
5748 /* select default configuration for this device */
5750 }
5753 /* if the device has just one configuration, set default value */
5756 }
5759 }
5762 /*
5763 * Retrieves config cloud for this configuration
5764 */
5765 int
5768 {
5774 usb_cr_t completion_reason;
5775 usb_cb_flags_t cb_flags;
5776 usb_pipe_handle_t def_ph;
5782 /* alloc temporary space for config descriptor */
5784 KM_SLEEP);
5786 /* alloc temporary space for string descriptor */
5793 USB_REQ_GET_DESCR,
5796 USB_CFG_DESCR_SIZE,
5803 /* this must be true since we didn't allow data underruns */
5806 "device returned incorrect configuration "
5811 }
5813 /*
5814 * Parse the configuration descriptor
5815 */
5818 USB_CFG_DESCR_SIZE);
5820 /* if parse cfg descr error, it should return failure */
5826 "device returned incorrect "
5828 }
5831 }
5836 "device returned incorrect "
5841 }
5846 /* Now fetch the complete config cloud */
5849 USB_REQ_GET_DESCR,
5864 "device returned incorrect "
5869 }
5871 /*
5872 * copy config descriptor into usba_device
5873 */
5884 /*
5885 * retrieve string descriptor describing this
5886 * configuration
5887 */
5893 conf_index);
5895 /*
5896 * Now fetch the string descriptor describing
5897 * this configuration
5898 */
5902 USB_SUCCESS) {
5905 child_ud->usb_cfg_str_descr
5908 KM_SLEEP);
5910 child_ud->usb_cfg_str_descr
5912 }
5916 "hubd_get_this_config_cloud: "
5917 "getting config string (%d) "
5921 /* ignore this error */
5923 }
5924 }
5925 }
5926 }
5928 done:
5931 "hubd_get_this_config_cloud: "
5932 "error in retrieving config descriptor for "
5935 }
5940 }
5946 }
5949 /*
5950 * Retrieves the entire config cloud for all configurations of the device
5951 */
5952 int
5955 {
5967 /* alloc pointer array for conf. descriptors */
5985 /* Get configuration descriptor for each configuration */
5990 conf_index);
5991 }
5994 }
5997 /*
5998 * hubd_ready_device:
5999 * Update the usba_device structure
6000 * Set the given configuration
6001 * Prepares the device node for driver to online. If an existing
6002 * OBP node is found, it will switch to the OBP node.
6003 */
6004 dev_info_t *
6006 uint_t config_index)
6007 {
6008 usb_cr_t completion_reason;
6009 usb_cb_flags_t cb_flags;
6011 usb_cfg_descr_t config_descriptor;
6012 usb_pipe_handle_t def_ph;
6026 /* Set the configuration */
6028 USB_DEV_REQ_HOST_TO_DEV,
6033 NULL,
6060 /* ready the device node */
6063 /* set owner of default pipe to child dip */
6072 }
6075 /*
6076 * hubd_create_child
6077 * - create child dip
6078 * - open default pipe
6079 * - get device descriptor
6080 * - set the address
6081 * - get device string descriptors
6082 * - get the entire config cloud (all configurations) of the device
6083 * - set user preferred configuration
6084 * - close default pipe
6085 * - load appropriate driver(s)
6086 */
6087 static int
6091 usb_port_status_t port_status,
6092 usb_port_t port,
6094 {
6096 usb_dev_descr_t usb_dev_descr;
6102 usb_cr_t completion_reason;
6104 uint_t config_index;
6105 usb_cb_flags_t cb_flags;
6109 usb_addr_t parent_usb_addr;
6110 usb_port_t parent_usb_port;
6112 usb_port_status_t parent_port_status;
6123 /*
6124 * create a dip which can be used to open the pipe. we set
6125 * the name after getting the descriptors from the device
6126 */
6132 child_ud,
6141 }
6150 /*
6151 * To support split transactions, update address and port of high speed
6152 * hub to which given device is connected. Note, split transactions
6153 * only exist for high speed devices.
6154 */
6163 }
6170 KM_SLEEP);
6183 }
6188 /*
6189 * The parent hub always keeps track of the hub this device is connected
6190 * to; however, the hs_hub_* variables are only keeping track of the
6191 * closest high speed hub. Unfortunately, we need both.
6192 */
6199 /*
6200 * Before we open up the default pipe, give the HCD a chance to do
6201 * something here.
6202 */
6213 }
6217 }
6221 /* Open the default pipe */
6228 }
6230 /*
6231 * get device descriptor
6232 */
6245 /*
6246 * If this is a full speed device, we cannot assume that its default
6247 * packet size is 64 bytes, it may be 8 bytes.
6248 */
6253 /*
6254 * rval != USB_SUCCESS AND
6255 * completion_reason != USB_CR_DATA_OVERRUN
6256 * pdata could be != NULL.
6257 * Free pdata now to prevent memory leak.
6258 */
6279 }
6282 }
6303 }
6310 }
6314 child_ud);
6318 /* Set the address of the device */
6320 USB_DEV_REQ_HOST_TO_DEV,
6329 "setting address failed (cr=%s cb_flags=%s "
6332 rval);
6335 }
6336 }
6341 /* now close the pipe for addr 0 */
6345 /*
6346 * This delay is important for the CATC hub to enumerate
6347 * But, avoid delay in the first iteration
6348 */
6351 }
6353 /* assign the address in the usba_device structure */
6358 /* save this device descriptor */
6364 /* re-open the pipe for the device with the new address */
6371 }
6373 /*
6374 * Get full device descriptor only if we have not received full
6375 * device descriptor earlier.
6376 */
6379 "hubd_create_child: get full device descriptor: "
6395 "hubd_create_child: get full device descriptor: "
6399 USB_DEV_REQ_DEV_TO_HOST |
6400 USB_DEV_REQ_TYPE_STANDARD,
6408 /* we have to trust the data now */
6416 }
6420 "getting device descriptor failed "
6425 }
6426 }
6437 /*
6438 * For now, free the data
6439 * eventually, each configuration may need to be looked at
6440 */
6446 "fail enumeration: descriptor size=%lu "
6450 }
6452 /*
6453 * save the device descriptor in usba_device since it is needed
6454 * later on again
6455 */
6461 }
6467 "protocol=0x%x maxpktsize=0x%x "
6481 }
6484 /* get the device string descriptor(s) */
6487 /* retrieve config cloud for all configurations */
6494 }
6496 /* get the preferred configuration for this device */
6500 /* Check if the user selected configuration index is in range */
6504 "Configuration index for device idVendor=%d "
6509 /* treat this as user didn't specify configuration */
6511 }
6514 /*
6515 * Warn users of a performance hit if connecting a
6516 * High Speed behind a 1.1 hub, which is behind a
6517 * 2.0 port. Don't worry about this for USB 3.x for now.
6518 */
6523 /*
6524 * Now that we know the root port is a high speed port
6525 * and that the parent port is not a high speed port,
6526 * let's find out if the device itself is a high speed
6527 * device. If it is a high speed device,
6528 * USB_DESCR_TYPE_SETUP_DEV_QLF should return a value,
6529 * otherwise the command will fail.
6530 */
6543 }
6545 /*
6546 * USB_DESCR_TYPE_SETUP_DEV_QLF query was successful
6547 * that means this is a high speed device behind a
6548 * high speed root hub, but running at full speed
6549 * because there is a full speed hub in the middle.
6550 */
6554 "Connecting a high speed device to a "
6555 "non high speed hub (port %d) will result "
6556 "in a loss of performance. Please connect "
6557 "the device to a high speed hub to get "
6559 port);
6560 }
6561 }
6563 /*
6564 * Now we try to online the device by attaching a driver
6565 * The following truth table illustrates the logic:-
6566 * Cfgndx Driver Action
6567 * 0 0 loop all configs for driver with full
6568 * compatible properties.
6569 * 0 1 set first configuration,
6570 * compatible prop = drivername.
6571 * 1 0 Set config, full compatible prop
6572 * 1 1 Set config, compatible prop = drivername.
6573 *
6574 * Note:
6575 * cfgndx = user_conf_index
6576 * Driver = usb_preferred_driver
6577 */
6580 /*
6581 * It is the job of the "preferred driver" to put the
6582 * device in the desired configuration. Till then
6583 * put the device in config index 0.
6584 */
6589 }
6594 /*
6595 * Assign the dip before onlining to avoid race
6596 * with busctl
6597 */
6604 /*
6605 * loop through all the configurations to see if we
6606 * can find a driver for any one config. If not, set
6607 * the device in config_index 0
6608 */
6617 /*
6618 * Assign the dip before onlining to avoid race
6619 * with busctl
6620 */
6627 /*
6628 * Normally power budget should be checked
6629 * before device is configured. A failure in
6630 * power budget checking will stop the device
6631 * from being configured with current
6632 * config_index and may enable the device to
6633 * be configured in another configuration.
6634 * This may break the user experience that a
6635 * device which previously worked in config
6636 * A now works in config B after power budget
6637 * control is enabled. To avoid such situation,
6638 * power budget checking is moved here and will
6639 * fail the child creation directly if config
6640 * A exceeds the power available.
6641 */
6645 USB_SUCCESS) {
6648 }
6649 }
6650 }
6657 }
6664 }
6672 }
6677 /*
6678 * Assign the dip before onlining to avoid race
6679 * with busctl
6680 */
6686 }
6696 }
6701 fail_cleanup:
6711 }
6716 }
6723 }
6728 NDI_DEVI_REMOVE);
6732 }
6733 }
6736 /* to make sure we free the address */
6749 }
6750 }
6755 }
6758 /*
6759 * hubd_delete_child:
6760 * - free usb address
6761 * - lookup child dips, there may be multiple on this port
6762 * - offline each child devi
6763 */
6764 static int
6766 {
6787 }
6793 /*
6794 * if the child was still < DS_INITIALIZED
6795 * then our bus_unconfig was not called and
6796 * we have to zap the child here
6797 */
6813 }
6814 }
6816 }
6817 }
6822 }
6826 }
6829 /*
6830 * hubd_free_usba_device:
6831 * free usb device structure unless it is associated with
6832 * the root hub which is handled differently
6833 */
6834 static void
6836 {
6845 #ifdef DEBUG
6848 }
6849 #endif
6856 }
6857 }
6860 /*
6861 * event support
6862 *
6863 * busctl event support
6864 */
6865 static int
6870 {
6874 "hubd_busop_get_eventcookie: dip=0x%p, rdip=0x%p, "
6881 /* return event cookie, iblock cookie, and level */
6884 }
6887 static int
6890 ddi_eventcookie_t cookie,
6895 {
6900 "hubd_busop_add_eventcall: dip=0x%p, rdip=0x%p "
6909 /* Set flag on children registering events */
6926 }
6928 /* add callback to our event set */
6931 }
6934 static int
6936 {
6941 "hubd_busop_remove_eventcall: dip=0x%p, rdip=0x%p "
6952 /* remove event registration from our event set */
6954 }
6957 /*
6958 * event distribution
6959 *
6960 * hubd_do_callback:
6961 * Post this event to the specified child
6962 */
6963 static void
6965 {
6970 }
6973 /*
6974 * hubd_run_callbacks:
6975 * Send this event to all children
6976 */
6977 static void
6979 {
6980 usb_port_t port;
6987 /*
6988 * the childen_dips list may have dips that have been
6989 * already deallocated. we only get a post_detach notification
6990 * but not a destroy notification
6991 */
6996 }
6997 }
6999 }
7002 /*
7003 * hubd_post_event
7004 * post event to a child on the port depending on the type
7005 */
7006 static void
7008 {
7020 USBA_EVENT_TAG_HOT_REMOVAL);
7022 USBA_EVENT_TAG_PRE_SUSPEND);
7024 /*
7025 * Hotplug daemon may be attaching a driver that may be registering
7026 * event callbacks. So it already has got the device tree lock and
7027 * event handle mutex. So to prevent a deadlock while posting events,
7028 * we grab and release the locks in the same order.
7029 */
7037 /* Clear the registered event flag */
7045 /*
7046 * Mark the dip for deletion only after the driver has
7047 * seen the disconnect event to prevent cleanup thread
7048 * from stepping in between.
7049 */
7061 /*
7062 * persistent pipe close for this event is taken care by the
7063 * caller after verfying that all children can suspend
7064 */
7068 /*
7069 * Check if this child has missed the disconnect event before
7070 * it registered for event callbacks
7071 */
7074 /* clear the flag and post disconnect event */
7081 }
7084 /*
7085 * Mark the dip as reinserted to prevent cleanup thread
7086 * from stepping in.
7087 */
7097 }
7101 /*
7102 * We might see a connect event only if hotplug thread for
7103 * disconnect event don't run in time.
7104 * Set the flag again, so we don't miss posting a
7105 * disconnect event.
7106 */
7113 /*
7114 * Check if this child has missed the pre-suspend event before
7115 * it registered for event callbacks
7116 */
7119 /* clear the flag and post pre_suspend event */
7125 }
7132 /*
7133 * Since the pipe has already been opened by hub
7134 * at DDI_RESUME time, there is no need for a
7135 * persistent pipe open
7136 */
7139 /*
7140 * Set the flag again, so we don't miss posting a
7141 * pre-suspend event. This enforces a tighter
7142 * dev_state model.
7143 */
7148 }
7149 }
7152 /*
7153 * handling of events coming from above
7154 */
7155 static int
7157 {
7174 /* stop polling on the interrupt pipe */
7177 /* FALLTHROUGH */
7179 /* we remain in this state */
7184 /* close all the open pipes of our children */
7192 }
7193 }
7197 /* avoid passing multiple disconnects to children */
7208 }
7214 }
7217 static int
7219 {
7227 }
7230 /*
7231 * hubd_pre_suspend_event_cb
7232 * propogate event for binary compatibility of old drivers
7233 */
7234 static int
7236 {
7243 /* disable hotplug thread */
7248 /* keep PM out till we see a cpr resume */
7257 }
7260 /*
7261 * hubd_post_resume_event_cb
7262 * propogate event for binary compatibility of old drivers
7263 */
7264 static int
7266 {
7279 /* enable PM */
7282 /* allow hotplug thread */
7285 /* start polling */
7290 }
7293 /*
7294 * hubd_cpr_suspend
7295 * save the current state of the driver/device
7296 */
7297 static int
7299 {
7308 /* Make sure device is powered up to save state. */
7313 /* bring the device to full power */
7321 /* find out if all our children have been quiesced */
7329 }
7330 }
7334 /* remain in same state to fail checkpoint */
7338 /*
7339 * do not suspend if our hotplug thread
7340 * or the deathrow thread is active
7341 */
7347 /* remain in same state to fail checkpoint */
7350 }
7352 /* quiesce ourselves now */
7355 /* close all the open pipes of our children */
7363 DPRINT_MASK_HOTPLUG,
7366 port);
7367 }
7369 }
7371 }
7374 /*
7375 * if we are the root hub, we close our pipes
7376 * ourselves.
7377 */
7383 }
7387 }
7395 }
7401 }
7403 static void
7405 {
7409 /*
7410 * if we are the root hub, we open our pipes
7411 * ourselves.
7412 */
7417 }
7420 }
7423 /*
7424 * hubd_restore_state_cb
7425 * Event callback to restore device state
7426 */
7427 static int
7429 {
7435 /* restore the state of this device */
7439 }
7442 /*
7443 * registering for events
7444 */
7445 static int
7447 {
7454 }
7457 }
7460 /*
7461 * hubd cpr callback related functions
7462 *
7463 * hubd_cpr_post_user_callb:
7464 * This function is called during checkpoint & resume -
7465 * 1. after user threads are stopped during checkpoint
7466 * 2. after kernel threads are resumed during resume
7467 */
7468 /* ARGSUSED */
7469 static boolean_t
7471 {
7486 /* turn off deathrow thread */
7489 /* give up if deathrow thread doesn't exit */
7495 "hubd_cpr_post_user_callb, waiting for "
7498 }
7502 /* save the state of the device */
7510 /* restore the state of the device */
7513 /* turn on deathrow thread */
7524 }
7526 }
7529 /* register callback with cpr framework */
7530 void
7532 {
7546 }
7549 /* unregister callback with cpr framework */
7550 void
7552 {
7562 }
7563 }
7566 /*
7567 * Power management
7568 *
7569 * create the pm components required for power management
7570 */
7571 static void
7573 {
7579 /* Allocate the state structure */
7589 /* alloc memory to save power states of children */
7593 /*
7594 * if the enable remote wakeup fails
7595 * we still want to enable
7596 * parent notification so we can PM the children
7597 */
7602 uint_t pwr_states;
7605 "hubd_create_pm_components: "
7609 USB_SUCCESS) {
7614 /* we are busy now till end of the attach */
7618 /* bring the device to full power */
7620 USB_DEV_OS_FULL_PWR);
7621 }
7622 }
7626 }
7629 /*
7630 * Attachment point management
7631 */
7632 /* ARGSUSED */
7633 int
7636 {
7645 }
7655 }
7663 }
7666 /* ARGSUSED */
7667 int
7670 {
7675 }
7681 }
7692 }
7695 /*
7696 * hubd_ioctl: cfgadm controls
7697 */
7698 /* ARGSUSED */
7699 int
7702 {
7709 devctl_ap_state_t ap_state;
7717 }
7722 "usba_hubdi_ioctl: "
7726 /* read devctl ioctl data */
7731 }
7733 /*
7734 * make sure the hub is connected before trying any
7735 * of the following operations:
7736 * configure, connect, disconnect
7737 */
7750 }
7753 }
7755 /* FALLTHROUGH */
7763 }
7766 }
7776 }
7779 }
7781 /* should not happen, just in case */
7786 }
7789 }
7797 }
7800 }
7805 /* go full power */
7816 /* stop polling if it was active */
7820 USB_FLAGS_SLEEP);
7825 }
7826 }
7833 }
7840 }
7844 /* toggle port */
7849 }
7865 }
7876 /* port previously 'disconnected' by cfgadm */
7907 }
7914 "DEVCTL_AP_GETSTATE: "
7919 /* copy the return-AP-state information to the user space */
7922 }
7926 {
7927 /*
7928 * Generic devctl for hardware-specific functionality.
7929 * For list of sub-commands see hubd_impl.h
7930 */
7933 /* copy user ioctl data in first */
7934 #ifdef _MULTI_DATAMODEL
7936 hubd_ioctl_data_32_t ioc32;
7943 }
7957 }
7960 "DEVCTL_AP_CONTROL: ioc: cmd=0x%x port=%d get_size=%d"
7965 /*
7966 * To avoid BE/LE and 32/64 issues, a get_size always
7967 * returns a 32-bit number.
7968 */
7973 }
7979 /* uint32 so this works 32/64 */
7990 }
7994 /* check child_dip */
8000 }
8006 "%s: bufsize passed (%d) != sizeof "
8012 }
8022 }
8023 }
8026 {
8035 /* recheck */
8037 NULL) {
8041 }
8076 }
8088 }
8097 }
8106 }
8116 }
8117 }
8119 }
8121 {
8125 /* recheck */
8127 NULL) {
8131 }
8135 }
8151 }
8160 }
8170 }
8171 }
8174 }
8176 /*
8177 * Return the config index for the currently-configured
8178 * configuration.
8179 */
8181 {
8182 uint_t config_index;
8190 /*
8191 * Return the config index for the configuration
8192 * currently in use.
8193 * Recheck if child_dip exists
8194 */
8196 NULL) {
8200 }
8216 }
8225 }
8232 }
8233 }
8236 }
8238 {
8246 /* Recheck if child_dip exists */
8248 NULL) {
8252 }
8254 /* ddi_pathname doesn't supply /devices, so we do. */
8271 }
8284 }
8285 }
8289 }
8300 }
8308 }
8312 }
8316 }
8318 /* allow hotplug thread now */
8324 }
8336 }
8339 /*
8340 * Helper func used only to help construct the names for the attachment point
8341 * minor nodes. Used only in usba_hubdi_attach.
8342 * Returns whether it found ancestry or not (USB_SUCCESS if yes).
8343 * ports between the root hub and the device represented by dip.
8344 * E.g., "2.4.3.1" means this device is
8345 * plugged into port 1 of a hub that is
8346 * plugged into port 3 of a hub that is
8347 * plugged into port 4 of a hub that is
8348 * plugged into port 2 of the root hub.
8349 * NOTE: Max ap_id path len is HUBD_APID_NAMELEN (32 chars), which is
8350 * more than sufficient (as hubs are a max 6 levels deep, port needs 3
8351 * chars plus NULL each)
8352 */
8353 void
8355 {
8359 usb_port_t port;
8366 /*
8367 * The function is extended to support wire adapter class
8368 * devices introduced by WUSB spec. The node name is no
8369 * longer "hub" only.
8370 * Generate the ap_id str based on the parent and child
8371 * relationship instead of retrieving it from the hub
8372 * device path, which simplifies the algorithm.
8373 */
8381 /*
8382 * The parent of wire adapter device might be usb_mid.
8383 * Need to look further up for hub device
8384 */
8388 }
8400 }
8401 }
8404 /* Get which port to operate on. */
8405 static usb_port_t
8407 {
8412 /* Get which port to operate on. */
8417 }
8423 }
8426 /* check if child still exists */
8429 {
8438 }
8441 /*
8442 * hubd_cfgadm_state:
8443 *
8444 * child_dip list port_state cfgadm_state
8445 * -------------- ---------- ------------
8446 * != NULL connected configured or
8447 * unconfigured
8448 * != NULL not connected disconnect but
8449 * busy/still referenced
8450 * NULL connected logically disconnected
8451 * NULL not connected empty
8452 */
8453 static uint_t
8455 {
8456 uint_t state;
8461 /*
8462 * connected, now check if driver exists
8463 */
8469 }
8471 /*
8472 * this means that the dip is around for
8473 * a device that is still referenced but
8474 * has been yanked out. So the cfgadm info
8475 * for this state should be EMPTY (port empty)
8476 * and CONFIGURED (dip still valid).
8477 */
8479 }
8481 /* connected but no child dip */
8483 /* logically disconnected */
8486 /* physically disconnected */
8488 }
8489 }
8496 }
8499 /*
8500 * hubd_toggle_port:
8501 */
8502 static int
8504 {
8506 uint_t retry;
8516 }
8518 /*
8519 * see hubd_enable_all_port_power() which
8520 * requires longer delay for hubs.
8521 */
8526 /*
8527 * According to section 11.11 of USB, for hubs with no power
8528 * switches, bPwrOn2PwrGood is zero. But we wait for some
8529 * arbitrary time to enable power to become stable.
8530 *
8531 * If an hub supports port power swicthing, we need to wait
8532 * at least 20ms before accesing corresonding usb port. Note
8533 * this member is stored in the h_power_good member.
8534 */
8541 }
8556 /* Get port status */
8560 /* For retry if any, use some extra delay */
8563 retry++;
8567 /* Print warning message if port has no power */
8571 "hubd_toggle_port: port %d power-on failed, "
8575 }
8578 }
8581 /*
8582 * hubd_init_power_budget:
8583 * Init power budget variables in hubd structure. According
8584 * to USB spec, the power budget rules are:
8585 * 1. local-powered hubs including root-hubs can supply
8586 * 500mA to each port at maximum
8587 * 2. two bus-powered hubs are not allowed to concatenate
8588 * 3. bus-powered hubs can supply 100mA to each port at
8589 * maximum, and the power consumed by all downstream
8590 * ports and the hub itself cannot exceed the max power
8591 * supplied by the upstream port, i.e., 500mA
8592 * The routine is only called during hub attach time
8593 */
8594 static int
8596 {
8600 usb_cfg_descr_t cfg_descr;
8607 }
8616 /* get device status */
8618 HUB_GET_DEVICE_STATUS_TYPE,
8623 }
8636 }
8641 USB_CFG_ATTR_SELFPWR);
8646 }
8667 /*
8668 * two bus-powered hubs are not
8669 * allowed to be concatenated
8670 */
8682 "two bus-powered hubs cannot "
8689 }
8691 }
8700 }
8702 /*
8703 * Subtract the power consumed by the hub itself
8704 * and get the power that can be supplied to
8705 * downstream ports
8706 */
8710 "hubd->h_pwr_left is less than bHubContrCurrent, "
8714 }
8715 }
8718 }
8721 /*
8722 * usba_hubdi_check_power_budget:
8723 * Check if the hub has enough power budget to allow a
8724 * child device to select a configuration of config_index.
8725 */
8726 int
8728 uint_t config_index)
8729 {
8732 usb_cfg_descr_t cfg_descr;
8738 }
8743 }
8746 "usba_hubdi_check_power_budget: "
8755 }
8759 "usba_hubdi_check_power_budget: "
8771 }
8776 "usba_hubdi_check_power_budget: "
8777 "child bmAttributes=0x%x bMaxPower=%d "
8783 "configuration %d for device %s %s at port %d "
8784 "exceeds power available for this port, please "
8785 "re-insert your device into another hub port which "
8787 config_index,
8793 }
8796 }
8799 /*
8800 * usba_hubdi_incr_power_budget:
8801 * Increase the hub power budget value when a child device
8802 * is removed from a bus-powered hub port.
8803 */
8804 void
8806 {
8815 }
8818 "usba_hubdi_incr_power_budget: "
8824 "usba_hubdi_incr_power_budget: "
8829 }
8837 }
8845 "usba_hubdi_incr_power_budget: "
8855 }
8858 /*
8859 * usba_hubdi_decr_power_budget:
8860 * Decrease the hub power budget value when a child device
8861 * is inserted to a bus-powered hub port.
8862 */
8863 void
8865 {
8868 usb_cfg_descr_t cfg_descr;
8876 }
8879 "usba_hubdi_decr_power_budget: "
8885 "usba_hubdi_decr_power_budget: "
8890 }
8898 }
8912 "usba_hubdi_decr_power_budget: "
8922 }
8924 /*
8925 * hubd_wait_for_hotplug_exit:
8926 * Waiting for the exit of the running hotplug thread or ioctl thread.
8927 */
8928 static int
8930 {
8945 }
8946 }
8949 }
8951 /*
8952 * hubd_reset_thread:
8953 * handles the "USB_RESET_LVL_REATTACH" reset of usb device.
8954 *
8955 * - delete the child (force detaching the device and its children)
8956 * - reset the corresponding parent hub port
8957 * - create the child (force re-attaching the device and its children)
8958 */
8959 static void
8961 {
8989 /* if our bus power entry point is active, quit the reset */
8992 "%s%d is under bus power management, cannot be reset. "
8997 }
9000 /* we got woken up because of a timeout */
9007 }
9011 /* is this the root hub? */
9016 /* mark the root hub as full power */
9025 USB_DEV_OS_FULL_PWR);
9029 }
9033 /*
9034 * this ensures one reset activity per system at a time.
9035 * we enter the parent PCI node to have this serialization.
9036 * this also excludes ioctls and deathrow thread
9037 */
9041 /* exclude other threads */
9045 /*
9046 * We need to make sure that the child is still online for a hotplug
9047 * thread could have inserted which detached the child.
9048 */
9051 /* First disconnect the device */
9054 /* delete cached dv_node's but drop locks first */
9061 /*
9062 * workaround only for storage device. When it's able to force
9063 * detach a driver, this code can be removed safely.
9064 *
9065 * If we're to reset storage device and the device is used, we
9066 * will wait at most extra 20s for applications to exit and
9067 * close the device. This is especially useful for HAL-based
9068 * applications.
9069 */
9081 }
9082 }
9090 /* Then force detaching the device */
9094 "%s%d cannot be reset due to other applications "
9095 "are using it, please first close these "
9096 "applications, then disconnect and reconnect"
9100 /* post a re-connect event */
9102 USBA_EVENT_TAG_HOT_INSERTION);
9108 /* Reset the parent hubd port and create new child */
9112 }
9113 }
9114 }
9116 /* release locks so we can do a devfs_clean */
9119 /* delete cached dv_node's but drop locks first */
9126 /* now check if any children need onlining */
9132 }
9136 /* allow hotplug thread now */
9138 Fail:
9141 /* mark this device as idle */
9152 }
9154 /*
9155 * hubd_check_same_device:
9156 * - open the default pipe of the device.
9157 * - compare the old and new descriptors of the device.
9158 * - close the default pipe.
9159 */
9160 static int
9162 {
9164 usb_pipe_handle_t ph;
9170 /* Open the default pipe to operate the device */
9174 /*
9175 * Check that if the device's descriptors are different
9176 * from the values saved before the port reset.
9177 */
9184 }
9188 }
9190 /*
9191 * usba_hubdi_reset_device
9192 * Called by usb_reset_device to handle usb device reset.
9193 */
9194 int
9196 {
9211 }
9218 }
9226 }
9233 }
9240 }
9244 /* make sure the hub is connected before trying any kinds of reset. */
9248 "usb_reset_device: the state %d of the hub/roothub "
9254 }
9268 }
9270 /*
9271 * For Default reset, client drivers should first close all the pipes
9272 * except default pipe before calling the function, also should not
9273 * call the function during interrupt context.
9274 */
9284 }
9285 /* Check if all the pipes have been closed */
9288 ph_open_cnt++;
9290 }
9291 }
9295 ph_open_cnt);
9298 }
9300 }
9302 /* Don't perform reset while the device is detaching */
9305 "usb_reset_device: the device is detaching, "
9310 }
9316 /* Don't allow hub detached during the reset */
9322 /* go full power */
9328 /* stop polling if it was active */
9332 USB_FLAGS_SLEEP);
9337 }
9338 }
9357 "Cannot create reset thread, the device %s%d failed"
9362 }
9366 /*
9367 * Reset hub port and then recover device's address, set back
9368 * device's configuration, hubd_handle_port_connect() will
9369 * handle errors happened during this process.
9370 */
9374 /* re-open the default pipe */
9380 "default pipe after reset, disable hub"
9383 /*
9384 * Disable port to set out a hotplug thread
9385 * which will handle errors.
9386 */
9388 }
9389 }
9395 }
9397 /* allow hotplug thread now */
9403 }
9407 /* Clear reset mark for the port. */
9415 }