| blob | 132b27bb169c41911bb28d0e951911d9208e3f5a |
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 */
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>
49 /*
50 * External functions
51 */
54 /*
55 * Prototypes for static functions
56 */
60 ddi_ctl_enum_t op,
69 caddr_t addr,
71 pfn_t pfn,
72 uint_t prot,
73 uint_t lock);
81 ddi_eventcookie_t cookie,
87 ddi_callback_id_t cb_id);
89 uint_t flag,
90 ddi_bus_config_op_t op,
94 uint_t flag,
95 ddi_bus_config_op_t op,
107 /*
108 * Busops vector for USB HUB's
109 */
111 BUSO_REV,
118 ddi_dma_allochdl,
119 ddi_dma_freehdl,
120 ddi_dma_bindhdl,
121 ddi_dma_unbindhdl,
122 ddi_dma_flush,
123 ddi_dma_win,
127 hubd_busop_get_eventcookie,
128 hubd_busop_add_eventcall,
129 hubd_busop_remove_eventcall,
138 hubd_bus_power /* bus_power */
139 };
141 #define USB_HUB_INTEL_VID 0x8087
142 #define USB_HUB_INTEL_PID 0x0020
144 /*
145 * local variables
146 */
151 usb_log_handle_t hubdi_log_handle;
158 /*
159 * initialize private data
160 */
161 void
163 {
173 }
176 void
178 {
186 }
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
197 uint_t flags)
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 High or Full speed usb device.
337 */
342 }
348 /*
349 * For the root hub the default pipe is not yet open
350 */
354 }
356 /*
357 * kill off all OBP children, they may not be fully
358 * enumerated
359 */
364 }
366 /*
367 * "attach" the root hub driver
368 */
371 }
375 fail:
383 }
397 }
400 }
403 int
405 {
408 /* was root hub attached? */
411 /* return success anyway */
413 }
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 */
425 }
428 }
448 }
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>
457 /* Debugging support */
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 */
479 /*
480 * enumeration retry
481 */
482 #define HUBD_PORT_RETRY 5
485 /*
486 * Stale hotremoved device cleanup delay
487 */
488 #define HUBD_STALE_DIP_CLEANUP_DELAY 5000000
491 /*
492 * retries for USB suspend and resume
493 */
494 #define HUBD_SUS_RES_RETRY 2
498 /*
499 * prototypes
500 */
517 usb_port_status_t port_status,
518 usb_port_t port,
522 boolean_t retry);
556 ddi_eventcookie_t cookie);
574 NDI_EVENT_POST_TO_ALL},
576 NDI_EVENT_POST_TO_ALL},
578 NDI_EVENT_POST_TO_ALL},
580 NDI_EVENT_POST_TO_ALL}
581 };
583 #define HUBD_N_NDI_EVENTS \
584 (sizeof (hubd_ndi_event_defs) / sizeof (ndi_event_definition_t))
589 /* events received from parent */
591 hubd_disconnect_event_cb,
592 hubd_reconnect_event_cb,
593 hubd_pre_suspend_event_cb,
594 hubd_post_resume_event_cb
595 };
598 /*
599 * hubd_get_soft_state() returns the hubd soft state
600 *
601 * WUSB support extends this function to support wire adapter class
602 * devices. The hubd soft state for the wire adapter class device
603 * would be stored in usb_root_hubd field of the usba_device structure,
604 * just as the USB host controller drivers do.
605 */
606 hubd_t *
608 {
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 {
1314 /*
1315 * this ensures one config activity per system at a time.
1316 * we enter the parent PCI node to have this serialization.
1317 * this also excludes ioctls and deathrow thread
1318 */
1322 /* 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 */
1865 /* std. for ohci */
1867 }
1876 }
1881 }
1882 }
1902 "Use of a USB1.0 hub behind a high speed port may "
1904 }
1908 /* register with USBA as client driver */
1914 }
1922 }
1931 }
1945 /*
1946 * register this hub instance with usba
1947 */
1953 }
1960 /* now create components to power manage this device */
1963 /*
1964 * Event handling: definition and registration
1965 *
1966 * first the definition:
1967 * get event handle
1968 */
1971 /* bind event set to the handle */
1973 NDI_SLEEP)) {
1978 }
1980 /* event registration */
1986 }
1995 }
2004 /* initialize hub power budget variables */
2011 }
2012 }
2014 /* initialize and create children */
2021 }
2023 /*
2024 * create cfgadm nodes
2025 */
2044 instance);
2048 }
2049 }
2054 /* create minor nodes */
2062 }
2072 }
2074 /*
2075 * host controller driver has already reported this dev
2076 * if we are the root hub
2077 */
2080 }
2082 /* enable deathrow thread */
2090 fail:
2091 {
2098 }
2109 }
2110 }
2113 }
2116 int
2118 {
2136 }
2137 }
2140 /*
2141 * hubd_setdevaddr
2142 * set the device addrs on this port
2143 */
2144 static int
2146 {
2148 usb_cr_t completion_reason;
2149 usb_cb_flags_t cb_flags;
2150 usb_pipe_handle_t ph;
2166 /* close the default pipe with addr x */
2173 /*
2174 * As this device has been reset, temporarily
2175 * assign the default address
2176 */
2187 /* open child's default pipe with USBA_DEFAULT_ADDR */
2190 USB_SUCCESS) {
2195 }
2197 /* Set the address of the device */
2199 USB_DEV_REQ_HOST_TO_DEV,
2209 }
2217 }
2220 }
2222 /* Reset to the old address */
2231 }
2234 /*
2235 * hubd_setdevconfig
2236 * set the device addrs on this port
2237 */
2238 static void
2240 {
2242 usb_cr_t completion_reason;
2243 usb_cb_flags_t cb_flags;
2244 usb_pipe_handle_t ph;
2259 /* open the default control pipe */
2262 USB_SUCCESS) {
2264 /* Set the default configuration of the device */
2266 USB_DEV_REQ_HOST_TO_DEV,
2274 "hubd_setdevconfig: set device config failed: "
2277 }
2278 /*
2279 * After setting the configuration, we make this default
2280 * control pipe persistent, so that it gets re-opened
2281 * on posting a connect event
2282 */
2287 }
2289 }
2292 /*ARGSUSED*/
2293 static int
2295 {
2297 usb_port_t port;
2303 /*
2304 * make sure dip is a usb hub, major of root hub is HCD
2305 * major
2306 */
2309 /*
2310 * need to walk the children since it might be a
2311 * HWA device
2312 */
2315 }
2317 /* TODO: DWA device may also need special handling */
2324 }
2325 }
2331 }
2333 /* walk child list and remove nodes with flag DEVI_DEVICE_REMOVED */
2337 /* for normal usb hub or root hub */
2345 }
2348 B_TRUE);
2349 }
2352 /* for HWA */
2358 }
2363 }
2364 }
2368 /* skip siblings of root hub */
2372 }
2375 }
2378 /*
2379 * this thread will walk all children under the root hub for this
2380 * USB bus instance and attempt to remove them
2381 */
2382 static void
2384 {
2388 #ifndef __lock_lint
2389 callb_cpr_t cprinfo;
2393 #endif
2396 /* don't race with detach */
2407 NULL);
2408 #ifdef __lock_lint
2410 #endif
2413 /* quit if we are not enabled anymore */
2422 }
2426 #ifndef __lock_lint
2436 #endif
2437 }
2439 #ifndef __lock_lint
2442 #endif
2443 }
2446 void
2448 {
2451 /*
2452 * The usb_root_hub_dip pointer for the child hub of the WUSB
2453 * wire adapter class device points to the wire adapter, not
2454 * the root hub. Need to find the real root hub dip so that
2455 * the cleanup thread only starts from the root hub.
2456 */
2467 }
2474 }
2475 }
2484 hubd_root_hub_cleanup_thread,
2486 minclsyspri);
2489 }
2490 }
2493 /*
2494 * hubd_restore_device_state:
2495 * - set config for the hub
2496 * - power cycle all the ports
2497 * - for each port that was connected
2498 * - reset port
2499 * - assign addrs to the device on this port
2500 * - restart polling
2501 * - reset suspend flag
2502 */
2503 static void
2505 {
2508 uint_t hub_prev_state;
2509 usb_port_t port;
2513 boolean_t ehci_root_hub;
2522 /* First bring the device to full power */
2530 DPRINT_MASK_HOTPLUG,
2533 /* change the device state to disconnected */
2540 }
2545 /* First turn off all port power */
2549 "hubd_restore_device_state:"
2551 }
2553 /* Settling time before turning on again */
2558 /* enable power on all ports so we can see connects */
2563 /* disable whatever was enabled */
2570 }
2572 /*
2573 * wait at least 3 frames before accessing devices
2574 * (note that delay's minimal time is one clock tick which
2575 * is 10ms unless hires_tick has been changed)
2576 */
2587 /*
2588 * the childen_dips list may have dips that have been
2589 * already deallocated. we only get a post_detach notification
2590 * but not a destroy notification
2591 */
2594 /* get port status */
2598 /* check if it is truly connected */
2600 /*
2601 * Now reset port and assign the device
2602 * its original address
2603 */
2608 /* required for ppx */
2616 }
2619 retry++;
2626 /* post a connect event */
2629 USBA_EVENT_TAG_HOT_INSERTION);
2632 /*
2633 * Since we have this device connected
2634 * mark it reinserted to prevent
2635 * cleanup thread from stepping in.
2636 */
2642 /*
2643 * reopen pipes for children for
2644 * their DDI_RESUME
2645 */
2650 }
2652 /*
2653 * Mark this dip for deletion as the device
2654 * is not physically present, and schedule
2655 * cleanup thread upon post resume
2656 */
2661 "hubd_restore_device_state: "
2669 }
2671 /* get port status */
2675 /* check if it is truly connected */
2677 /*
2678 * reset the port to find out if we have
2679 * 2.0 device connected or 1.X. A 2.0
2680 * device will still be seen as connected,
2681 * while a 1.X device will switch over to
2682 * the companion controller.
2683 */
2691 /*
2692 * We have a USB 2.0 device
2693 * connected. Power cycle this port
2694 * so that hotplug thread can
2695 * enumerate this device.
2696 */
2701 "hubd_restore_device_state: "
2703 port);
2704 }
2705 }
2707 }
2708 }
2711 /* if the device had remote wakeup earlier, enable it again */
2715 USB_REMOTE_WAKEUP_ENABLE);
2717 }
2723 }
2726 /*
2727 * hubd_cleanup:
2728 * cleanup hubd and deallocate. this function is called for
2729 * handling attach failures and detaching including dynamic
2730 * reconfiguration. If called from attaching, it must clean
2731 * up the whole thing and return success.
2732 */
2733 /*ARGSUSED*/
2734 static int
2736 {
2739 #ifdef DEBUG
2740 usb_port_t port;
2741 #endif
2748 }
2750 /* ensure we are the only one active */
2755 /* Cleanup failure is only allowed if called from detach */
2759 /*
2760 * We are being called from detach.
2761 * Fail immediately if the hotplug thread is running
2762 * else set the dev_state to disconnected so that
2763 * hotplug thread just exits without doing anything.
2764 */
2771 "hubd_cleanup: hotplug thread/bus ctl active "
2775 }
2777 /*
2778 * if the deathrow thread is still active or about
2779 * to become active, fail detach
2780 * the roothup can only be detached if nexus drivers
2781 * are unloaded or explicitly offlined
2782 */
2791 "hubd_cleanup: deathrow still active?"
2795 }
2796 }
2797 }
2810 /*
2811 * deallocate events, if events are still registered
2812 * (ie. children still attached) then we have to fail the detach
2813 */
2819 /* It must return success if attaching. */
2830 }
2831 }
2836 #ifdef DEBUG
2840 }
2841 #endif
2844 }
2846 /*
2847 * Disable the event callbacks first, after this point, event
2848 * callbacks will never get called. Note we shouldn't hold
2849 * mutex while unregistering events because there may be a
2850 * competing event callback thread. Event callbacks are done
2851 * with ndi mutex held and this can cause a potential deadlock.
2852 * Note that cleanup can't fail after deregistration of events.
2853 */
2859 }
2861 /* restore the old dev state so that device can be put into low power */
2869 /*
2870 * Bring the hub to full power before
2871 * issuing the disable remote wakeup command
2872 */
2879 "hubd_cleanup: disable remote wakeup "
2881 }
2882 }
2888 }
2894 }
2896 }
2905 }
2911 }
2917 }
2922 }
2924 done:
2927 }
2935 }
2940 }
2943 /*
2944 * hubd_determine_port_connection:
2945 * Determine which port is in connect status but does not
2946 * have connect status change bit set, and mark port change
2947 * bit accordingly.
2948 * This function is applied during hub attach time.
2949 */
2950 static usb_port_mask_t
2952 {
2953 usb_port_t port;
2968 /* Check if port is in connect status */
2972 }
2974 /*
2975 * Check if port Connect Status Change bit has been set.
2976 * If already set, the connection will be handled by
2977 * intr polling callback, not during attach.
2978 */
2982 }
2985 }
2988 }
2991 /*
2992 * hubd_check_ports:
2993 * - get hub descriptor
2994 * - check initial port status
2995 * - enable power on all ports
2996 * - enable polling on ep1
2997 */
2998 static int
3000 {
3010 /*
3011 * First turn off all port power
3012 */
3015 /* disable whatever was enabled */
3019 }
3021 /*
3022 * do not switch on immediately (instantly on root hub)
3023 * and allow time to settle
3024 */
3029 /*
3030 * enable power on all ports so we can see connects
3031 */
3033 /* disable whatever was enabled */
3037 }
3039 /* wait at least 3 frames before accessing devices */
3044 /*
3045 * allocate arrays for saving the dips of each child per port
3046 *
3047 * ports go from 1 - n, allocate 1 more entry
3048 */
3068 }
3072 /*
3073 * Some hub devices, like the embedded hub in the CKS ErgoMagic
3074 * keyboard, may only have connection status bit set, but not
3075 * have connect status change bit set when a device has been
3076 * connected to its downstream port before the hub is enumerated.
3077 * Then when the hub is in enumeration, the devices connected to
3078 * it cannot be detected by the intr pipe and won't be enumerated.
3079 * We need to check such situation here and enumerate the downstream
3080 * devices for such hubs.
3081 */
3099 /* mark this device as idle */
3102 }
3105 }
3111 }
3114 /*
3115 * hubd_get_hub_descriptor:
3116 */
3117 static int
3119 {
3122 usb_cr_t completion_reason;
3123 usb_cb_flags_t cb_flags;
3134 }
3139 /* get hub descriptor length first by requesting 8 bytes only */
3144 HUB_CLASS_REQ_TYPE,
3158 }
3166 /* get complete hub descriptor */
3169 HUB_CLASS_REQ_TYPE,
3177 /*
3178 * Hub descriptor data less than 9 bytes is not valid and
3179 * may cause trouble if we use it. See USB2.0 Tab11-13.
3180 */
3183 "get hub descriptor failed: "
3191 }
3192 }
3196 /* parse the hub descriptor */
3197 /* only 32 ports are supported at present */
3208 }
3213 "rval=0x%x bNbrPorts=0x%x wHubChars=0x%x "
3220 "Hub driver supports max of %d ports on hub. "
3225 }
3228 }
3231 /*
3232 * hubd_get_hub_status_words:
3233 */
3234 static int
3236 {
3237 usb_cr_t completion_reason;
3238 usb_cb_flags_t cb_flags;
3246 HUB_CLASS_REQ_TYPE,
3247 USB_REQ_GET_STATUS,
3250 GET_STATUS_LENGTH,
3259 }
3264 }
3277 }
3280 /*
3281 * hubd_open_intr_pipe:
3282 * we read all descriptors first for curiosity and then simply
3283 * open the pipe
3284 */
3285 static int
3287 {
3308 }
3317 }
3320 /*
3321 * hubd_start_polling:
3322 * start or restart the polling
3323 */
3324 static void
3326 {
3329 usb_pipe_state_t pipe_state;
3337 /*
3338 * start or restart polling on the intr pipe
3339 * only if hotplug thread is not running
3340 */
3352 USB_ATTRS_AUTOCLEARING;
3362 }
3365 USB_FLAGS_SLEEP);
3369 }
3374 }
3375 }
3378 /*
3379 * hubd_stop_polling
3380 * stop polling but do not close the pipe
3381 */
3382 static void
3384 {
3386 usb_pipe_state_t pipe_state;
3396 USB_FLAGS_SLEEP);
3401 }
3405 }
3406 }
3407 }
3410 /*
3411 * hubd_close_intr_pipe:
3412 * close the pipe (which also stops the polling
3413 * and wait for the hotplug thread to exit
3414 */
3415 static void
3417 {
3421 /*
3422 * Now that no async operation is outstanding on pipe,
3423 * we can change the state to HUBD_INTR_PIPE_CLOSING
3424 */
3435 }
3438 }
3441 /*
3442 * hubd_exception_cb
3443 * interrupt ep1 exception callback function.
3444 * this callback executes in taskq thread context and assumes
3445 * autoclearing
3446 */
3447 /*ARGSUSED*/
3448 static void
3450 {
3454 "hubd_exception_cb: "
3466 /* only restart polling after autoclearing */
3470 }
3477 /* never restart polling on these conditions */
3479 /* for all others, wait for the autoclearing PIPE_RESET cb */
3482 }
3487 }
3490 /*
3491 * helper function to convert LE bytes to a portmask
3492 */
3493 static usb_port_mask_t
3495 {
3502 }
3505 }
3508 /*
3509 * hubd_read_cb:
3510 * interrupt ep1 callback function
3511 *
3512 * the status indicates just a change on the pipe with no indication
3513 * of what the change was
3514 *
3515 * known conditions:
3516 * - reset port completion
3517 * - connect
3518 * - disconnect
3519 *
3520 * for handling the hotplugging, create a new thread that can do
3521 * synchronous usba calls
3522 */
3523 static void
3525 {
3537 /*
3538 * At present, we are not handling notification for completion of
3539 * asynchronous pipe reset, for which this data ptr could be NULL
3540 */
3546 }
3561 }
3567 /*
3568 * Only look at the data and startup the hotplug thread if
3569 * there actually is data.
3570 */
3574 /*
3575 * if a port change was already reported and we are waiting for
3576 * reset port completion then wake up the hotplug thread which
3577 * should be waiting on reset port completion
3578 *
3579 * if there is disconnect event instead of reset completion, let
3580 * the hotplug thread figure this out
3581 */
3583 /* remove the reset wait bits from the status */
3591 /* there should be only one reset bit active at the time */
3595 }
3597 /*
3598 * kick off the thread only if device is ONLINE and it is not
3599 * during attaching or detaching
3600 */
3607 "creating hotplug thread: "
3610 /*
3611 * Mark this device as busy. The will be marked idle
3612 * if the async req fails or at the exit of hotplug
3613 * thread
3614 */
3621 hubd_hotplug_thread,
3626 /* mark this device as idle */
3629 }
3630 }
3631 }
3636 }
3639 }
3642 /*
3643 * hubd_hotplug_thread:
3644 * handles resetting of port, and creating children
3645 *
3646 * the ports to check are indicated in h_port_change bit mask
3647 * XXX note that one time poll doesn't work on the root hub
3648 */
3649 static void
3651 {
3655 usb_port_t port;
3670 /*
3671 * Before console is init'd, we temporarily block the hotplug
3672 * threads so that BUS_CONFIG_ONE through hubd_bus_config() can be
3673 * processed quickly. This reduces the time needed for vfs_mountroot()
3674 * to mount the root FS from a USB disk. And on SPARC platform,
3675 * in order to load 'consconfig' successfully after OBP is gone,
3676 * we need to check 'modrootloaded' to make sure root filesystem is
3677 * available.
3678 */
3681 }
3685 /*
3686 * if our bus power entry point is active, process the change
3687 * on the next notification of interrupt pipe
3688 */
3693 /* mark this device as idle */
3698 "hubd_hotplug_thread: "
3702 }
3709 /* is this the root hub? */
3714 /* mark the root hub as full power */
3723 USB_DEV_OS_FULL_PWR);
3727 }
3732 }
3736 /*
3737 * this ensures one hotplug activity per system at a time.
3738 * we enter the parent PCI node to have this serialization.
3739 * this also excludes ioctls and deathrow thread
3740 * (a bit crude but easier to debug)
3741 */
3745 /* exclude other threads */
3757 /*
3758 * The 0th bit is the hub status change bit.
3759 * handle loss of local power here
3760 */
3765 /*
3766 * This should be handled properly. For now,
3767 * mask off the bit.
3768 */
3771 /*
3772 * check and ack hub status
3773 * this causes stall conditions
3774 * when local power is removed
3775 */
3777 }
3780 usb_port_mask_t port_mask;
3781 boolean_t was_connected;
3784 was_connected =
3789 "hubd_hotplug_thread: "
3792 was_connected);
3794 /*
3795 * is this a port connection that changed?
3796 */
3800 }
3803 /* ack all changes */
3812 /* Recover a disabled port */
3816 "port%d Disabled - "
3820 /*
3821 * if the port was connected and is still
3822 * connected, recover the port
3823 */
3825 PORT_STATUS_CCS)) {
3826 online_child |=
3829 }
3830 }
3832 /*
3833 * Now check what changed on the port
3834 */
3838 /* new device plugged in */
3839 online_child |=
3844 was_connected) {
3845 /*
3846 * In this case we can never be sure
3847 * if the device indeed got hotplugged
3848 * or the hub is falsely reporting the
3849 * change.
3850 */
3854 /*
3855 * this ensures we do not race with
3856 * other threads which are detaching
3857 * the child driver at the same time.
3858 */
3860 /*
3861 * Now check if the driver remains
3862 * attached.
3863 */
3865 /*
3866 * first post a disconnect event
3867 * to the child.
3868 */
3870 USBA_EVENT_TAG_HOT_REMOVAL);
3873 /*
3874 * then reset the port and
3875 * recover the device
3876 */
3877 online_child |=
3882 }
3887 /* this is a disconnect */
3890 USBA_EVENT_TAG_HOT_REMOVAL);
3894 }
3895 }
3897 /*
3898 * Check if any port is coming out of suspend
3899 */
3901 /* a resuming device could have disconnected */
3905 /* device on this port resuming */
3910 /*
3911 * Don't raise power on detaching child
3912 */
3914 /*
3915 * As this child is not
3916 * detaching, we set this
3917 * flag, causing bus_ctls
3918 * to stall detach till
3919 * pm_raise_power returns
3920 * and flag it for a deferred
3921 * raise_power.
3922 *
3923 * pm_raise_power is deferred
3924 * because we need to release
3925 * the locks first.
3926 */
3928 HUBD_CHILD_RAISE_POWER;
3932 /*
3933 * make sure that child
3934 * doesn't disappear
3935 */
3939 }
3940 }
3941 }
3943 /*
3944 * Check if the port is over-current
3945 */
3949 "Port%d in over current condition, "
3950 "please check the attached device to "
3951 "clear the condition. The system will "
3952 "try to recover the port, but if not "
3953 "successful, you need to re-connect "
3954 "the hub or reboot the system to bring "
3958 /*
3959 * Try to enable port power, but
3960 * possibly fail. Ignore failure
3961 */
3963 port);
3965 /*
3966 * Delay some time to avoid
3967 * over-current event to happen
3968 * too frequently in some cases
3969 */
3973 }
3974 }
3975 }
3976 }
3978 /* release locks so we can do a devfs_clean */
3981 /* delete cached dv_node's but drop locks first */
3988 /* now check if any children need onlining */
3994 }
3996 /* now check if any disconnected devices need to be cleaned up */
4002 }
4006 /* now raise power on the children that have woken up */
4016 /* Get the device to full power */
4019 USB_DEV_OS_FULL_PWR);
4022 /* release the hold on the child */
4027 }
4028 }
4029 /*
4030 * make sure that we don't accidentally
4031 * over write the disconnect state
4032 */
4035 }
4036 }
4038 /*
4039 * start polling can immediately kick off read callback
4040 * we need to set the h_hotplug_thread to 0 so that
4041 * the callback is not dropped
4042 *
4043 * if there is device during reset, still stop polling to avoid the
4044 * read callback interrupting the reset, the polling will be started
4045 * in hubd_reset_thread.
4046 */
4051 }
4052 }
4055 }
4057 /*
4058 * Earlier we would set the h_hotplug_thread = 0 before
4059 * polling was restarted so that
4060 * if there is any root hub status change interrupt, we can still kick
4061 * off the hotplug thread. This was valid when this interrupt was
4062 * delivered in hardware, and only ONE interrupt would be delivered.
4063 * Now that we poll on the root hub looking for status change in
4064 * software, this assignment is no longer required.
4065 */
4068 /* mark this device as idle */
4079 }
4082 /*
4083 * hubd_handle_port_connect:
4084 * Transition a port from Disabled to Enabled. Ensure that the
4085 * port is in the correct state before attempting to
4086 * access the device.
4087 */
4088 static int
4090 {
4097 usb_addr_t hubd_usb_addr;
4102 /* Get the hub address and port status */
4109 /*
4110 * If a device is connected, transition the
4111 * port from Disabled to the Enabled state.
4112 * The device will receive downstream packets
4113 * in the Enabled state.
4114 *
4115 * reset port and wait for the hub to report
4116 * completion
4117 */
4120 /*
4121 * According to section 9.1.2 of USB 2.0 spec, the host should
4122 * wait for atleast 100ms to allow completion of an insertion
4123 * process and for power at the device to become stable.
4124 * We wait for 200 ms
4125 */
4131 /* calculate 600 ms delay time */
4143 /* continue only if port is still connected */
4146 }
4148 /* carry on regardless */
4149 }
4151 /*
4152 * according to USB 2.0 spec section 11.24.2.7.1.2
4153 * at the end of port reset, the hub enables the port.
4154 * But for some strange reasons, uhci port remains disabled.
4155 * And because the port remains disabled for the settling
4156 * time below, the device connected to the port gets wedged
4157 * - fails to enumerate (device not responding)
4158 * Hence, we enable it here immediately and later again after
4159 * the delay
4160 */
4163 /* we skip this delay in the first iteration */
4165 /*
4166 * delay for device to signal disconnect/connect so
4167 * that hub properly recognizes the speed of the device
4168 */
4173 /*
4174 * When a low speed device is connected to any port of
4175 * PPX it has to be explicitly enabled
4176 * Also, if device intentionally signals
4177 * disconnect/connect, it will disable the port.
4178 * So enable it again.
4179 */
4181 }
4192 }
4200 /* ack changes */
4205 }
4207 /* is status really OK? */
4213 /* check if we still have the connection */
4215 /* lost connection, set exit condition */
4219 }
4221 /*
4222 * Determine if the device is high or full
4223 * or low speed.
4224 */
4231 }
4234 "creating child port%d, status=0x%x "
4238 /*
4239 * if the child already exists, set addrs and config
4240 * to the device post connect event to the child
4241 */
4243 /* set addrs to this device */
4246 /*
4247 * This delay is important for the CATC hub
4248 * to enumerate. But, avoid delay in the first
4249 * iteration
4250 */
4256 }
4259 /*
4260 * if the port is resetting, check if
4261 * device's descriptors have changed.
4262 */
4269 }
4271 /*
4272 * set the default config for
4273 * this device
4274 */
4277 /*
4278 * if we are doing Default reset, do
4279 * not post reconnect event since we
4280 * don't know where reset function is
4281 * called.
4282 */
4286 }
4288 /*
4289 * indicate to the child that
4290 * it is online again
4291 */
4294 USBA_EVENT_TAG_HOT_INSERTION);
4298 }
4300 /*
4301 * We need to release access here
4302 * so that busctls on other ports can
4303 * continue and don't cause a deadlock
4304 * when busctl and removal of prom node
4305 * takes concurrently. This also ensures
4306 * busctls for attach of successfully
4307 * enumerated devices on other ports can
4308 * continue concurrently with the process
4309 * of enumerating the new devices. This
4310 * reduces the overall boot time of the system.
4311 */
4313 hubd,
4316 retry);
4319 USBA_TOTAL_HOTPLUG_SUCCESS|
4320 USBA_HOTPLUG_SUCCESS);
4325 DPRINT_MASK_HOTPLUG,
4327 "device on port %d "
4333 }
4336 }
4337 }
4338 }
4340 /* wait a while until it settles? */
4349 }
4353 }
4356 /*
4357 * If it is a High Speed Root Hub and connected device
4358 * Is a Low/Full Speed, it will be handled by USB 1.1
4359 * Host Controller. In this case, USB 2.0 Host Controller
4360 * will transfer the ownership of this port to USB 1.1
4361 * Host Controller. So don't display any error message on
4362 * the console.
4363 */
4369 "hubd_handle_port_connect: Low/Full speed "
4375 }
4382 /*
4383 * the port should be automagically
4384 * disabled but just in case, we do
4385 * it here
4386 */
4389 /* ack all changes because we disabled this port */
4393 }
4396 }
4399 /*
4400 * hubd_get_hub_status:
4401 */
4402 static int
4404 {
4406 usb_cr_t completion_reason;
4407 usb_cb_flags_t cb_flags;
4411 usb_cfg_descr_t cfg_descr;
4416 usb_port_t port;
4426 }
4432 /* Obtain the raw configuration descriptor */
4435 /* get configuration descriptor */
4449 }
4451 /* check if local power status changed. */
4454 /*
4455 * local power has been lost, check the maximum
4456 * power consumption of current configuration.
4457 * see USB2.0 spec Table 11-12.
4458 */
4463 /*
4464 * Self-powered only hub. Because it could
4465 * not draw any power from USB bus.
4466 * It can't work well on this condition.
4467 */
4470 "local power has been lost, "
4474 /*
4475 * Bus-powered only or self/bus-powered hub.
4476 */
4479 "local power has been lost,"
4480 "the hub could draw %d"
4483 }
4485 }
4492 HUB_HANDLE_HUB_FEATURE_TYPE,
4493 USB_REQ_CLEAR_FEATURE,
4494 CFS_C_HUB_LOCAL_POWER,
4501 "clear feature C_HUB_LOCAL_POWER "
4504 }
4506 }
4513 /*
4514 * The root hub should be automatically
4515 * recovered when over-current condition is
4516 * cleared. But there might be exception and
4517 * need user interaction to recover.
4518 */
4521 "Root hub over current condition, "
4522 "please check your system to clear the "
4523 "condition as soon as possible. And you "
4524 "may need to reboot the system to bring "
4525 "the root hub back to work if it cannot "
4528 /*
4529 * The driver would try to recover port power
4530 * on over current condition. When the recovery
4531 * fails, the user may still need to offline
4532 * this hub in order to recover.
4533 * The port power is automatically disabled,
4534 * so we won't see disconnects.
4535 */
4538 "Hub global over current condition, "
4539 "please disconnect the devices connected "
4540 "to the hub to clear the condition. And "
4541 "you may need to re-connect the hub if "
4543 }
4544 }
4551 HUB_HANDLE_HUB_FEATURE_TYPE,
4552 USB_REQ_CLEAR_FEATURE,
4553 CFS_C_HUB_OVER_CURRENT,
4560 "clear feature C_HUB_OVER_CURRENT "
4563 }
4565 /*
4566 * Try to recover all port power if they are turned off.
4567 * Don't do this for root hub, but rely on the root hub
4568 * to recover itself.
4569 */
4574 /*
4575 * Only check the power status of the 1st port
4576 * since all port power status should be the same.
4577 */
4584 }
4589 port++) {
4592 }
4596 /*
4597 * Delay some time to avoid over-current event
4598 * to happen too frequently in some cases
4599 */
4601 }
4602 }
4607 }
4610 /*
4611 * hubd_reset_port:
4612 */
4613 static int
4615 {
4617 usb_cr_t completion_reason;
4618 usb_cb_flags_t cb_flags;
4637 HUB_HANDLE_PORT_FEATURE_TYPE,
4638 USB_REQ_SET_FEATURE,
4639 CFS_PORT_RESET,
4640 port,
4651 }
4658 /*
4659 * wait for port status change event
4660 */
4663 /*
4664 * start polling ep1 for receiving notification on
4665 * reset completion
4666 */
4669 /*
4670 * sleep a max of 100ms for reset completion
4671 * notification to be received
4672 */
4678 /* we got woken up because of a timeout */
4688 }
4689 }
4698 /* check status to determine whether reset completed */
4702 HUB_GET_PORT_STATUS_TYPE,
4703 USB_REQ_GET_STATUS,
4705 port,
4706 GET_STATUS_LENGTH,
4717 }
4721 }
4728 /* continue only if port is still connected */
4731 /* lost connection, set exit condition */
4737 }
4748 }
4756 HUB_HANDLE_PORT_FEATURE_TYPE,
4757 USB_REQ_CLEAR_FEATURE,
4758 CFS_C_PORT_RESET,
4759 port,
4765 "clear feature CFS_C_PORT_RESET"
4768 }
4769 }
4773 }
4776 /* port reset has failed */
4778 }
4781 }
4784 /*
4785 * hubd_enable_port:
4786 * this may fail if the hub as been disconnected
4787 */
4788 static int
4790 {
4792 usb_cr_t completion_reason;
4793 usb_cb_flags_t cb_flags;
4802 /* Do not issue a SetFeature(PORT_ENABLE) on external hubs */
4807 }
4811 HUB_HANDLE_PORT_FEATURE_TYPE,
4812 USB_REQ_SET_FEATURE,
4813 CFS_PORT_ENABLE,
4814 port,
4821 }
4829 }
4832 /*
4833 * hubd_disable_port
4834 */
4835 static int
4837 {
4839 usb_cr_t completion_reason;
4840 usb_cb_flags_t cb_flags;
4851 HUB_HANDLE_PORT_FEATURE_TYPE,
4852 USB_REQ_CLEAR_FEATURE,
4853 CFS_PORT_ENABLE,
4854 port,
4864 }
4871 HUB_HANDLE_PORT_FEATURE_TYPE,
4872 USB_REQ_CLEAR_FEATURE,
4873 CFS_C_PORT_ENABLE,
4874 port,
4880 "clear feature CFS_C_PORT_ENABLE port%d failed "
4887 }
4892 }
4895 /*
4896 * hubd_determine_port_status:
4897 */
4898 static int
4901 {
4904 usb_cr_t completion_reason;
4905 usb_cb_flags_t cb_flags;
4917 HUB_GET_PORT_STATUS_TYPE,
4918 USB_REQ_GET_STATUS,
4920 port,
4921 GET_STATUS_LENGTH,
4930 }
4936 }
4947 }
4968 }
4980 }
4992 }
5002 }
5012 }
5024 }
5035 }
5057 }
5058 }
5060 /*
5061 * Acknowledge connection, enable, reset status
5062 */
5070 HUB_HANDLE_PORT_FEATURE_TYPE,
5071 USB_REQ_CLEAR_FEATURE,
5072 CFS_C_PORT_CONNECTION,
5073 port,
5076 USB_SUCCESS) {
5079 "clear feature CFS_C_PORT_CONNECTION"
5082 }
5083 }
5089 HUB_HANDLE_PORT_FEATURE_TYPE,
5090 USB_REQ_CLEAR_FEATURE,
5091 CFS_C_PORT_ENABLE,
5092 port,
5095 USB_SUCCESS) {
5098 "clear feature CFS_C_PORT_ENABLE"
5101 }
5102 }
5109 HUB_HANDLE_PORT_FEATURE_TYPE,
5110 USB_REQ_CLEAR_FEATURE,
5111 CFS_C_PORT_SUSPEND,
5112 port,
5115 USB_SUCCESS) {
5118 "clear feature CFS_C_PORT_SUSPEND"
5121 }
5122 }
5129 HUB_HANDLE_PORT_FEATURE_TYPE,
5130 USB_REQ_CLEAR_FEATURE,
5131 CFS_C_PORT_OVER_CURRENT,
5132 port,
5135 USB_SUCCESS) {
5138 "clear feature CFS_C_PORT_OVER_CURRENT"
5141 }
5142 }
5148 HUB_HANDLE_PORT_FEATURE_TYPE,
5149 USB_REQ_CLEAR_FEATURE,
5150 CFS_C_PORT_RESET,
5151 port,
5154 USB_SUCCESS) {
5157 "clear feature CFS_C_PORT_RESET"
5160 }
5161 }
5163 }
5170 }
5173 /*
5174 * hubd_recover_disabled_port
5175 * if the port got disabled because of an error
5176 * enable it. If hub doesn't suport enable port,
5177 * reset the port to bring the device to life again
5178 */
5179 static int
5181 {
5186 /* first try enabling the port */
5189 /* read the port status */
5191 PORT_CHANGE_PESC);
5197 /* first post a disconnect event to the child */
5202 /* then reset the port and recover the device */
5207 }
5210 }
5213 /*
5214 * hubd_enable_all_port_power:
5215 */
5216 static int
5218 {
5221 usb_port_t port;
5222 uint_t retry;
5233 /*
5234 * According to section 11.11 of USB, for hubs with no power
5235 * switches, bPwrOn2PwrGood is zero. But we wait for some
5236 * arbitrary time to enable power to become stable.
5237 *
5238 * If an hub supports port power switching, we need to wait
5239 * at least 20ms before accessing corresponding usb port.
5240 */
5247 }
5253 /*
5254 * Enable power per port. we ignore gang power and power mask
5255 * and always enable all ports one by one.
5256 */
5258 /*
5259 * Transition the port from the Powered Off to the
5260 * Disconnected state by supplying power to the port.
5261 */
5267 }
5273 /* For retry if any, use some extra delay */
5276 /* Check each port power status for a given usb hub */
5279 /* Get port status */
5296 /* Get port status */
5299 }
5301 /* Print warning message if port has no power */
5305 "hubd_enable_all_port_power: port %d power-on "
5307 }
5308 }
5311 }
5314 /*
5315 * hubd_enable_port_power:
5316 * enable individual port power
5317 */
5318 static int
5320 {
5322 usb_cr_t completion_reason;
5323 usb_cb_flags_t cb_flags;
5335 HUB_HANDLE_PORT_FEATURE_TYPE,
5336 USB_REQ_SET_FEATURE,
5337 CFS_PORT_POWER,
5338 port,
5352 }
5353 }
5356 /*
5357 * hubd_disable_all_port_power:
5358 */
5359 static int
5361 {
5362 usb_port_t port;
5369 /*
5370 * disable power per port, ignore gang power and power mask
5371 */
5374 }
5377 }
5380 /*
5381 * hubd_disable_port_power:
5382 * disable individual port power
5383 */
5384 static int
5386 {
5388 usb_cr_t completion_reason;
5389 usb_cb_flags_t cb_flags;
5400 HUB_HANDLE_PORT_FEATURE_TYPE,
5401 USB_REQ_CLEAR_FEATURE,
5402 CFS_PORT_POWER,
5403 port,
5420 }
5421 }
5424 /*
5425 * Search the database of user preferences and find out the preferred
5426 * configuration for this new device
5427 */
5428 int
5431 {
5443 /* try to get pathname for this device */
5450 /*
5451 * We haven't initialized the node and it doesn't have an address
5452 * yet. Append port number to the physical pathname
5453 */
5460 pathname);
5464 /* database search for user preferences */
5470 "hubd_select_device_configuration: "
5471 "usba_devdb_get_user_preferences "
5482 }
5487 /* select default configuration for this device */
5489 }
5492 /* if the device has just one configuration, set default value */
5495 }
5498 }
5501 /*
5502 * Retrieves config cloud for this configuration
5503 */
5504 int
5507 {
5513 usb_cr_t completion_reason;
5514 usb_cb_flags_t cb_flags;
5515 usb_pipe_handle_t def_ph;
5521 /* alloc temporary space for config descriptor */
5523 KM_SLEEP);
5525 /* alloc temporary space for string descriptor */
5532 USB_REQ_GET_DESCR,
5535 USB_CFG_DESCR_SIZE,
5542 /* this must be true since we didn't allow data underruns */
5545 "device returned incorrect configuration "
5550 }
5552 /*
5553 * Parse the configuration descriptor
5554 */
5557 USB_CFG_DESCR_SIZE);
5559 /* if parse cfg descr error, it should return failure */
5565 "device returned incorrect "
5567 }
5570 }
5575 "device returned incorrect "
5580 }
5585 /* Now fetch the complete config cloud */
5588 USB_REQ_GET_DESCR,
5603 "device returned incorrect "
5608 }
5610 /*
5611 * copy config descriptor into usba_device
5612 */
5623 /*
5624 * retrieve string descriptor describing this
5625 * configuration
5626 */
5632 conf_index);
5634 /*
5635 * Now fetch the string descriptor describing
5636 * this configuration
5637 */
5641 USB_SUCCESS) {
5644 child_ud->usb_cfg_str_descr
5647 KM_SLEEP);
5649 child_ud->usb_cfg_str_descr
5651 }
5655 "hubd_get_this_config_cloud: "
5656 "getting config string (%d) "
5660 /* ignore this error */
5662 }
5663 }
5664 }
5665 }
5667 done:
5670 "hubd_get_this_config_cloud: "
5671 "error in retrieving config descriptor for "
5674 }
5679 }
5685 }
5688 /*
5689 * Retrieves the entire config cloud for all configurations of the device
5690 */
5691 int
5694 {
5706 /* alloc pointer array for conf. descriptors */
5724 /* Get configuration descriptor for each configuration */
5729 conf_index);
5730 }
5733 }
5736 /*
5737 * hubd_ready_device:
5738 * Update the usba_device structure
5739 * Set the given configuration
5740 * Prepares the device node for driver to online. If an existing
5741 * OBP node is found, it will switch to the OBP node.
5742 */
5743 dev_info_t *
5745 uint_t config_index)
5746 {
5747 usb_cr_t completion_reason;
5748 usb_cb_flags_t cb_flags;
5750 usb_cfg_descr_t config_descriptor;
5751 usb_pipe_handle_t def_ph;
5765 /* Set the configuration */
5767 USB_DEV_REQ_HOST_TO_DEV,
5772 NULL,
5799 /* ready the device node */
5802 /* set owner of default pipe to child dip */
5811 }
5814 /*
5815 * hubd_create_child
5816 * - create child dip
5817 * - open default pipe
5818 * - get device descriptor
5819 * - set the address
5820 * - get device string descriptors
5821 * - get the entire config cloud (all configurations) of the device
5822 * - set user preferred configuration
5823 * - close default pipe
5824 * - load appropriate driver(s)
5825 */
5826 static int
5830 usb_port_status_t port_status,
5831 usb_port_t port,
5833 {
5835 usb_dev_descr_t usb_dev_descr;
5841 usb_cr_t completion_reason;
5843 uint_t config_index;
5844 usb_cb_flags_t cb_flags;
5848 usb_addr_t parent_usb_addr;
5849 usb_port_t parent_usb_port;
5851 usb_port_status_t parent_port_status;
5861 /*
5862 * create a dip which can be used to open the pipe. we set
5863 * the name after getting the descriptors from the device
5864 */
5870 child_ud,
5879 }
5888 /*
5889 * To support split transactions, update address and port
5890 * of high speed hub to which given device is connected.
5891 */
5900 }
5907 KM_SLEEP);
5919 /* Open the default pipe */
5926 }
5928 /*
5929 * get device descriptor
5930 */
5946 /*
5947 * rval != USB_SUCCESS AND
5948 * completion_reason != USB_CR_DATA_OVERRUN
5949 * pdata could be != NULL.
5950 * Free pdata now to prevent memory leak.
5951 */
5972 }
5975 }
5996 }
6003 }
6005 /* Set the address of the device */
6007 USB_DEV_REQ_HOST_TO_DEV,
6019 rval);
6022 }
6027 /* now close the pipe for addr 0 */
6031 /*
6032 * This delay is important for the CATC hub to enumerate
6033 * But, avoid delay in the first iteration
6034 */
6037 }
6039 /* assign the address in the usba_device structure */
6044 /* save this device descriptor */
6050 /* re-open the pipe for the device with the new address */
6057 }
6059 /*
6060 * Get full device descriptor only if we have not received full
6061 * device descriptor earlier.
6062 */
6065 "hubd_create_child: get full device descriptor: "
6081 "hubd_create_child: get full device descriptor: "
6085 USB_DEV_REQ_DEV_TO_HOST |
6086 USB_DEV_REQ_TYPE_STANDARD,
6094 /* we have to trust the data now */
6102 }
6106 "getting device descriptor failed "
6111 }
6112 }
6123 /*
6124 * For now, free the data
6125 * eventually, each configuration may need to be looked at
6126 */
6132 "fail enumeration: descriptor size=%lu "
6136 }
6138 /*
6139 * save the device descriptor in usba_device since it is needed
6140 * later on again
6141 */
6147 }
6153 "protocol=0x%x maxpktsize=0x%x "
6167 }
6170 /* get the device string descriptor(s) */
6173 /* retrieve config cloud for all configurations */
6180 }
6182 /* get the preferred configuration for this device */
6186 /* Check if the user selected configuration index is in range */
6190 "Configuration index for device idVendor=%d "
6195 /* treat this as user didn't specify configuration */
6197 }
6200 /*
6201 * Warn users of a performance hit if connecting a
6202 * High Speed behind a 1.1 hub, which is behind a
6203 * 2.0 port.
6204 */
6209 /*
6210 * Now that we know the root port is a high speed port
6211 * and that the parent port is not a high speed port,
6212 * let's find out if the device itself is a high speed
6213 * device. If it is a high speed device,
6214 * USB_DESCR_TYPE_SETUP_DEV_QLF should return a value,
6215 * otherwise the command will fail.
6216 */
6229 }
6231 /*
6232 * USB_DESCR_TYPE_SETUP_DEV_QLF query was successful
6233 * that means this is a high speed device behind a
6234 * high speed root hub, but running at full speed
6235 * because there is a full speed hub in the middle.
6236 */
6240 "Connecting a high speed device to a "
6241 "non high speed hub (port %d) will result "
6242 "in a loss of performance. Please connect "
6243 "the device to a high speed hub to get "
6245 port);
6246 }
6247 }
6249 /*
6250 * Now we try to online the device by attaching a driver
6251 * The following truth table illustrates the logic:-
6252 * Cfgndx Driver Action
6253 * 0 0 loop all configs for driver with full
6254 * compatible properties.
6255 * 0 1 set first configuration,
6256 * compatible prop = drivername.
6257 * 1 0 Set config, full compatible prop
6258 * 1 1 Set config, compatible prop = drivername.
6259 *
6260 * Note:
6261 * cfgndx = user_conf_index
6262 * Driver = usb_preferred_driver
6263 */
6266 /*
6267 * It is the job of the "preferred driver" to put the
6268 * device in the desired configuration. Till then
6269 * put the device in config index 0.
6270 */
6275 }
6280 /*
6281 * Assign the dip before onlining to avoid race
6282 * with busctl
6283 */
6290 /*
6291 * loop through all the configurations to see if we
6292 * can find a driver for any one config. If not, set
6293 * the device in config_index 0
6294 */
6303 /*
6304 * Assign the dip before onlining to avoid race
6305 * with busctl
6306 */
6313 /*
6314 * Normally power budget should be checked
6315 * before device is configured. A failure in
6316 * power budget checking will stop the device
6317 * from being configured with current
6318 * config_index and may enable the device to
6319 * be configured in another configuration.
6320 * This may break the user experience that a
6321 * device which previously worked in config
6322 * A now works in config B after power budget
6323 * control is enabled. To avoid such situation,
6324 * power budget checking is moved here and will
6325 * fail the child creation directly if config
6326 * A exceeds the power available.
6327 */
6331 USB_SUCCESS) {
6334 }
6335 }
6336 }
6343 }
6350 }
6358 }
6363 /*
6364 * Assign the dip before onlining to avoid race
6365 * with busctl
6366 */
6372 }
6382 }
6387 fail_cleanup:
6397 }
6402 }
6406 NDI_DEVI_REMOVE);
6410 }
6411 }
6414 /* to make sure we free the address */
6427 }
6428 }
6433 }
6436 /*
6437 * hubd_delete_child:
6438 * - free usb address
6439 * - lookup child dips, there may be multiple on this port
6440 * - offline each child devi
6441 */
6442 static int
6444 {
6465 }
6470 /*
6471 * This is only useful for HWA device node.
6472 * Since hwahc interface must hold hwarc interface
6473 * open until hwahc is detached, the first call to
6474 * ndi_devi_unconfig_one() can only offline hwahc
6475 * driver but not hwarc driver. Need to make a second
6476 * call to ndi_devi_unconfig_one() to make the hwarc
6477 * driver detach.
6478 */
6480 }
6483 /*
6484 * if the child was still < DS_INITIALIZED
6485 * then our bus_unconfig was not called and
6486 * we have to zap the child here
6487 */
6503 }
6504 }
6506 }
6507 }
6512 }
6516 }
6519 /*
6520 * hubd_free_usba_device:
6521 * free usb device structure unless it is associated with
6522 * the root hub which is handled differently
6523 */
6524 static void
6526 {
6535 #ifdef DEBUG
6538 }
6539 #endif
6547 }
6548 }
6551 /*
6552 * event support
6553 *
6554 * busctl event support
6555 */
6556 static int
6561 {
6565 "hubd_busop_get_eventcookie: dip=0x%p, rdip=0x%p, "
6572 /* return event cookie, iblock cookie, and level */
6575 }
6578 static int
6581 ddi_eventcookie_t cookie,
6586 {
6591 "hubd_busop_add_eventcall: dip=0x%p, rdip=0x%p "
6600 /* Set flag on children registering events */
6617 }
6619 /* add callback to our event set */
6622 }
6625 static int
6627 {
6632 "hubd_busop_remove_eventcall: dip=0x%p, rdip=0x%p "
6643 /* remove event registration from our event set */
6645 }
6648 /*
6649 * event distribution
6650 *
6651 * hubd_do_callback:
6652 * Post this event to the specified child
6653 */
6654 static void
6656 {
6661 }
6664 /*
6665 * hubd_run_callbacks:
6666 * Send this event to all children
6667 */
6668 static void
6670 {
6671 usb_port_t port;
6678 /*
6679 * the childen_dips list may have dips that have been
6680 * already deallocated. we only get a post_detach notification
6681 * but not a destroy notification
6682 */
6687 }
6688 }
6690 }
6693 /*
6694 * hubd_post_event
6695 * post event to a child on the port depending on the type
6696 */
6697 static void
6699 {
6711 USBA_EVENT_TAG_HOT_REMOVAL);
6713 USBA_EVENT_TAG_PRE_SUSPEND);
6715 /*
6716 * Hotplug daemon may be attaching a driver that may be registering
6717 * event callbacks. So it already has got the device tree lock and
6718 * event handle mutex. So to prevent a deadlock while posting events,
6719 * we grab and release the locks in the same order.
6720 */
6728 /* Clear the registered event flag */
6736 /*
6737 * Mark the dip for deletion only after the driver has
6738 * seen the disconnect event to prevent cleanup thread
6739 * from stepping in between.
6740 */
6752 /*
6753 * persistent pipe close for this event is taken care by the
6754 * caller after verfying that all children can suspend
6755 */
6759 /*
6760 * Check if this child has missed the disconnect event before
6761 * it registered for event callbacks
6762 */
6765 /* clear the flag and post disconnect event */
6772 }
6775 /*
6776 * Mark the dip as reinserted to prevent cleanup thread
6777 * from stepping in.
6778 */
6788 }
6792 /*
6793 * We might see a connect event only if hotplug thread for
6794 * disconnect event don't run in time.
6795 * Set the flag again, so we don't miss posting a
6796 * disconnect event.
6797 */
6804 /*
6805 * Check if this child has missed the pre-suspend event before
6806 * it registered for event callbacks
6807 */
6810 /* clear the flag and post pre_suspend event */
6816 }
6823 /*
6824 * Since the pipe has already been opened by hub
6825 * at DDI_RESUME time, there is no need for a
6826 * persistent pipe open
6827 */
6830 /*
6831 * Set the flag again, so we don't miss posting a
6832 * pre-suspend event. This enforces a tighter
6833 * dev_state model.
6834 */
6839 }
6840 }
6843 /*
6844 * handling of events coming from above
6845 */
6846 static int
6848 {
6865 /* stop polling on the interrupt pipe */
6868 /* FALLTHROUGH */
6870 /* we remain in this state */
6875 /* close all the open pipes of our children */
6883 }
6884 }
6888 /* avoid passing multiple disconnects to children */
6899 }
6905 }
6908 static int
6910 {
6918 }
6921 /*
6922 * hubd_pre_suspend_event_cb
6923 * propogate event for binary compatibility of old drivers
6924 */
6925 static int
6927 {
6934 /* disable hotplug thread */
6939 /* keep PM out till we see a cpr resume */
6948 }
6951 /*
6952 * hubd_post_resume_event_cb
6953 * propogate event for binary compatibility of old drivers
6954 */
6955 static int
6957 {
6970 /* enable PM */
6973 /* allow hotplug thread */
6976 /* start polling */
6981 }
6984 /*
6985 * hubd_cpr_suspend
6986 * save the current state of the driver/device
6987 */
6988 static int
6990 {
6999 /* Make sure device is powered up to save state. */
7004 /* bring the device to full power */
7012 /* find out if all our children have been quiesced */
7020 }
7021 }
7025 /* remain in same state to fail checkpoint */
7029 /*
7030 * do not suspend if our hotplug thread
7031 * or the deathrow thread is active
7032 */
7038 /* remain in same state to fail checkpoint */
7041 }
7043 /* quiesce ourselves now */
7046 /* close all the open pipes of our children */
7054 DPRINT_MASK_HOTPLUG,
7057 port);
7058 }
7060 }
7062 }
7065 /*
7066 * if we are the root hub, we close our pipes
7067 * ourselves.
7068 */
7074 }
7078 }
7086 }
7092 }
7094 static void
7096 {
7100 /*
7101 * if we are the root hub, we open our pipes
7102 * ourselves.
7103 */
7108 }
7111 }
7114 /*
7115 * hubd_restore_state_cb
7116 * Event callback to restore device state
7117 */
7118 static int
7120 {
7126 /* restore the state of this device */
7130 }
7133 /*
7134 * registering for events
7135 */
7136 static int
7138 {
7145 }
7148 }
7151 /*
7152 * hubd cpr callback related functions
7153 *
7154 * hubd_cpr_post_user_callb:
7155 * This function is called during checkpoint & resume -
7156 * 1. after user threads are stopped during checkpoint
7157 * 2. after kernel threads are resumed during resume
7158 */
7159 /* ARGSUSED */
7160 static boolean_t
7162 {
7177 /* turn off deathrow thread */
7180 /* give up if deathrow thread doesn't exit */
7186 "hubd_cpr_post_user_callb, waiting for "
7189 }
7193 /* save the state of the device */
7201 /* restore the state of the device */
7204 /* turn on deathrow thread */
7215 }
7217 }
7220 /* register callback with cpr framework */
7221 void
7223 {
7237 }
7240 /* unregister callback with cpr framework */
7241 void
7243 {
7253 }
7254 }
7257 /*
7258 * Power management
7259 *
7260 * create the pm components required for power management
7261 */
7262 static void
7264 {
7270 /* Allocate the state structure */
7280 /* alloc memory to save power states of children */
7284 /*
7285 * if the enable remote wakeup fails
7286 * we still want to enable
7287 * parent notification so we can PM the children
7288 */
7293 uint_t pwr_states;
7296 "hubd_create_pm_components: "
7300 USB_SUCCESS) {
7305 /* we are busy now till end of the attach */
7309 /* bring the device to full power */
7311 USB_DEV_OS_FULL_PWR);
7312 }
7313 }
7317 }
7320 /*
7321 * Attachment point management
7322 */
7323 /* ARGSUSED */
7324 int
7327 {
7336 }
7346 }
7354 }
7357 /* ARGSUSED */
7358 int
7361 {
7366 }
7372 }
7383 }
7386 /*
7387 * hubd_ioctl: cfgadm controls
7388 */
7389 /* ARGSUSED */
7390 int
7393 {
7400 devctl_ap_state_t ap_state;
7408 }
7413 "usba_hubdi_ioctl: "
7417 /* read devctl ioctl data */
7422 }
7424 /*
7425 * make sure the hub is connected before trying any
7426 * of the following operations:
7427 * configure, connect, disconnect
7428 */
7441 }
7444 }
7446 /* FALLTHROUGH */
7454 }
7457 }
7467 }
7470 }
7472 /* should not happen, just in case */
7477 }
7480 }
7488 }
7491 }
7496 /* go full power */
7507 /* stop polling if it was active */
7511 USB_FLAGS_SLEEP);
7516 }
7517 }
7524 }
7531 }
7535 /* toggle port */
7540 }
7556 }
7567 /* port previously 'disconnected' by cfgadm */
7598 }
7605 "DEVCTL_AP_GETSTATE: "
7610 /* copy the return-AP-state information to the user space */
7613 }
7617 {
7618 /*
7619 * Generic devctl for hardware-specific functionality.
7620 * For list of sub-commands see hubd_impl.h
7621 */
7624 /* copy user ioctl data in first */
7625 #ifdef _MULTI_DATAMODEL
7627 hubd_ioctl_data_32_t ioc32;
7634 }
7648 }
7651 "DEVCTL_AP_CONTROL: ioc: cmd=0x%x port=%d get_size=%d"
7656 /*
7657 * To avoid BE/LE and 32/64 issues, a get_size always
7658 * returns a 32-bit number.
7659 */
7664 }
7670 /* uint32 so this works 32/64 */
7681 }
7685 /* check child_dip */
7691 }
7697 "%s: bufsize passed (%d) != sizeof "
7703 }
7713 }
7714 }
7717 {
7726 /* recheck */
7728 NULL) {
7732 }
7767 }
7779 }
7788 }
7797 }
7807 }
7808 }
7810 }
7812 {
7816 /* recheck */
7818 NULL) {
7822 }
7826 }
7842 }
7851 }
7861 }
7862 }
7865 }
7867 /*
7868 * Return the config index for the currently-configured
7869 * configuration.
7870 */
7872 {
7873 uint_t config_index;
7881 /*
7882 * Return the config index for the configuration
7883 * currently in use.
7884 * Recheck if child_dip exists
7885 */
7887 NULL) {
7891 }
7907 }
7916 }
7923 }
7924 }
7927 }
7929 {
7937 /* Recheck if child_dip exists */
7939 NULL) {
7943 }
7945 /* ddi_pathname doesn't supply /devices, so we do. */
7962 }
7975 }
7976 }
7980 }
7991 }
7999 }
8003 }
8007 }
8009 /* allow hotplug thread now */
8015 }
8027 }
8030 /*
8031 * Helper func used only to help construct the names for the attachment point
8032 * minor nodes. Used only in usba_hubdi_attach.
8033 * Returns whether it found ancestry or not (USB_SUCCESS if yes).
8034 * ports between the root hub and the device represented by dip.
8035 * E.g., "2.4.3.1" means this device is
8036 * plugged into port 1 of a hub that is
8037 * plugged into port 3 of a hub that is
8038 * plugged into port 4 of a hub that is
8039 * plugged into port 2 of the root hub.
8040 * NOTE: Max ap_id path len is HUBD_APID_NAMELEN (32 chars), which is
8041 * more than sufficient (as hubs are a max 6 levels deep, port needs 3
8042 * chars plus NULL each)
8043 */
8044 void
8046 {
8050 usb_port_t port;
8057 /*
8058 * The function is extended to support wire adapter class
8059 * devices introduced by WUSB spec. The node name is no
8060 * longer "hub" only.
8061 * Generate the ap_id str based on the parent and child
8062 * relationship instead of retrieving it from the hub
8063 * device path, which simplifies the algorithm.
8064 */
8072 /*
8073 * The parent of wire adapter device might be usb_mid.
8074 * Need to look further up for hub device
8075 */
8079 }
8091 }
8092 }
8095 /* Get which port to operate on. */
8096 static usb_port_t
8098 {
8103 /* Get which port to operate on. */
8108 }
8114 }
8117 /* check if child still exists */
8120 {
8129 }
8132 /*
8133 * hubd_cfgadm_state:
8134 *
8135 * child_dip list port_state cfgadm_state
8136 * -------------- ---------- ------------
8137 * != NULL connected configured or
8138 * unconfigured
8139 * != NULL not connected disconnect but
8140 * busy/still referenced
8141 * NULL connected logically disconnected
8142 * NULL not connected empty
8143 */
8144 static uint_t
8146 {
8147 uint_t state;
8152 /*
8153 * connected, now check if driver exists
8154 */
8160 }
8162 /*
8163 * this means that the dip is around for
8164 * a device that is still referenced but
8165 * has been yanked out. So the cfgadm info
8166 * for this state should be EMPTY (port empty)
8167 * and CONFIGURED (dip still valid).
8168 */
8170 }
8172 /* connected but no child dip */
8174 /* logically disconnected */
8177 /* physically disconnected */
8179 }
8180 }
8187 }
8190 /*
8191 * hubd_toggle_port:
8192 */
8193 static int
8195 {
8198 uint_t retry;
8208 }
8210 /*
8211 * see hubd_enable_all_port_power() which
8212 * requires longer delay for hubs.
8213 */
8220 /*
8221 * According to section 11.11 of USB, for hubs with no power
8222 * switches, bPwrOn2PwrGood is zero. But we wait for some
8223 * arbitrary time to enable power to become stable.
8224 *
8225 * If an hub supports port power swicthing, we need to wait
8226 * at least 20ms before accesing corresonding usb port.
8227 */
8234 }
8249 /* Get port status */
8253 /* For retry if any, use some extra delay */
8256 retry++;
8260 /* Print warning message if port has no power */
8264 "hubd_toggle_port: port %d power-on failed, "
8268 }
8271 }
8274 /*
8275 * hubd_init_power_budget:
8276 * Init power budget variables in hubd structure. According
8277 * to USB spec, the power budget rules are:
8278 * 1. local-powered hubs including root-hubs can supply
8279 * 500mA to each port at maximum
8280 * 2. two bus-powered hubs are not allowed to concatenate
8281 * 3. bus-powered hubs can supply 100mA to each port at
8282 * maximum, and the power consumed by all downstream
8283 * ports and the hub itself cannot exceed the max power
8284 * supplied by the upstream port, i.e., 500mA
8285 * The routine is only called during hub attach time
8286 */
8287 static int
8289 {
8293 usb_cfg_descr_t cfg_descr;
8300 }
8309 /* get device status */
8311 HUB_GET_DEVICE_STATUS_TYPE,
8316 }
8329 }
8334 USB_CFG_ATTR_SELFPWR);
8339 }
8360 /*
8361 * two bus-powered hubs are not
8362 * allowed to be concatenated
8363 */
8375 "two bus-powered hubs cannot "
8382 }
8384 }
8393 }
8395 /*
8396 * Subtract the power consumed by the hub itself
8397 * and get the power that can be supplied to
8398 * downstream ports
8399 */
8402 USB_CFG_DESCR_PWR_UNIT;
8405 "hubd->h_pwr_left is less than bHubContrCurrent, "
8409 }
8410 }
8413 }
8416 /*
8417 * usba_hubdi_check_power_budget:
8418 * Check if the hub has enough power budget to allow a
8419 * child device to select a configuration of config_index.
8420 */
8421 int
8423 uint_t config_index)
8424 {
8427 usb_cfg_descr_t cfg_descr;
8433 }
8438 }
8441 "usba_hubdi_check_power_budget: "
8450 }
8454 "usba_hubdi_check_power_budget: "
8466 }
8471 "usba_hubdi_check_power_budget: "
8472 "child bmAttributes=0x%x bMaxPower=%d "
8478 "configuration %d for device %s %s at port %d "
8479 "exceeds power available for this port, please "
8480 "re-insert your device into another hub port which "
8482 config_index,
8488 }
8491 }
8494 /*
8495 * usba_hubdi_incr_power_budget:
8496 * Increase the hub power budget value when a child device
8497 * is removed from a bus-powered hub port.
8498 */
8499 void
8501 {
8510 }
8513 "usba_hubdi_incr_power_budget: "
8519 "usba_hubdi_incr_power_budget: "
8524 }
8532 }
8540 "usba_hubdi_incr_power_budget: "
8550 }
8553 /*
8554 * usba_hubdi_decr_power_budget:
8555 * Decrease the hub power budget value when a child device
8556 * is inserted to a bus-powered hub port.
8557 */
8558 void
8560 {
8563 usb_cfg_descr_t cfg_descr;
8571 }
8574 "usba_hubdi_decr_power_budget: "
8580 "usba_hubdi_decr_power_budget: "
8585 }
8593 }
8607 "usba_hubdi_decr_power_budget: "
8617 }
8619 /*
8620 * hubd_wait_for_hotplug_exit:
8621 * Waiting for the exit of the running hotplug thread or ioctl thread.
8622 */
8623 static int
8625 {
8640 }
8641 }
8644 }
8646 /*
8647 * hubd_reset_thread:
8648 * handles the "USB_RESET_LVL_REATTACH" reset of usb device.
8649 *
8650 * - delete the child (force detaching the device and its children)
8651 * - reset the corresponding parent hub port
8652 * - create the child (force re-attaching the device and its children)
8653 */
8654 static void
8656 {
8684 /* if our bus power entry point is active, quit the reset */
8687 "%s%d is under bus power management, cannot be reset. "
8692 }
8695 /* we got woken up because of a timeout */
8702 }
8706 /* is this the root hub? */
8711 /* mark the root hub as full power */
8720 USB_DEV_OS_FULL_PWR);
8724 }
8728 /*
8729 * this ensures one reset activity per system at a time.
8730 * we enter the parent PCI node to have this serialization.
8731 * this also excludes ioctls and deathrow thread
8732 */
8736 /* exclude other threads */
8740 /*
8741 * We need to make sure that the child is still online for a hotplug
8742 * thread could have inserted which detached the child.
8743 */
8746 /* First disconnect the device */
8749 /* delete cached dv_node's but drop locks first */
8756 /*
8757 * workaround only for storage device. When it's able to force
8758 * detach a driver, this code can be removed safely.
8759 *
8760 * If we're to reset storage device and the device is used, we
8761 * will wait at most extra 20s for applications to exit and
8762 * close the device. This is especially useful for HAL-based
8763 * applications.
8764 */
8776 }
8777 }
8785 /* Then force detaching the device */
8789 "%s%d cannot be reset due to other applications "
8790 "are using it, please first close these "
8791 "applications, then disconnect and reconnect"
8795 /* post a re-connect event */
8797 USBA_EVENT_TAG_HOT_INSERTION);
8803 /* Reset the parent hubd port and create new child */
8807 }
8808 }
8809 }
8811 /* release locks so we can do a devfs_clean */
8814 /* delete cached dv_node's but drop locks first */
8821 /* now check if any children need onlining */
8827 }
8831 /* allow hotplug thread now */
8833 Fail:
8836 /* mark this device as idle */
8847 }
8849 /*
8850 * hubd_check_same_device:
8851 * - open the default pipe of the device.
8852 * - compare the old and new descriptors of the device.
8853 * - close the default pipe.
8854 */
8855 static int
8857 {
8859 usb_pipe_handle_t ph;
8865 /* Open the default pipe to operate the device */
8869 /*
8870 * Check that if the device's descriptors are different
8871 * from the values saved before the port reset.
8872 */
8879 }
8883 }
8885 /*
8886 * usba_hubdi_reset_device
8887 * Called by usb_reset_device to handle usb device reset.
8888 */
8889 int
8891 {
8906 }
8913 }
8921 }
8928 }
8935 }
8939 /* make sure the hub is connected before trying any kinds of reset. */
8943 "usb_reset_device: the state %d of the hub/roothub "
8949 }
8963 }
8965 /*
8966 * For Default reset, client drivers should first close all the pipes
8967 * except default pipe before calling the function, also should not
8968 * call the function during interrupt context.
8969 */
8979 }
8980 /* Check if all the pipes have been closed */
8983 ph_open_cnt++;
8985 }
8986 }
8990 ph_open_cnt);
8993 }
8995 }
8997 /* Don't perform reset while the device is detaching */
9000 "usb_reset_device: the device is detaching, "
9005 }
9011 /* Don't allow hub detached during the reset */
9017 /* go full power */
9023 /* stop polling if it was active */
9027 USB_FLAGS_SLEEP);
9032 }
9033 }
9052 "Cannot create reset thread, the device %s%d failed"
9057 }
9061 /*
9062 * Reset hub port and then recover device's address, set back
9063 * device's configuration, hubd_handle_port_connect() will
9064 * handle errors happened during this process.
9065 */
9069 /* re-open the default pipe */
9075 "default pipe after reset, disable hub"
9078 /*
9079 * Disable port to set out a hotplug thread
9080 * which will handle errors.
9081 */
9083 }
9084 }
9090 }
9092 /* allow hotplug thread now */
9098 }
9102 /* Clear reset mark for the port. */
9110 }