1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
5 * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
6 * Copyright (c) 2008-2022 Hans Petter Selasky
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 /*
31 * USB spec: http://www.usb.org/developers/docs/usbspec.zip
32 */
33
34 #ifdef USB_GLOBAL_INCLUDE_FILE
35 #include USB_GLOBAL_INCLUDE_FILE
36 #else
37 #include <sys/stdint.h>
38 #include <sys/stddef.h>
39 #include <sys/param.h>
40 #include <sys/queue.h>
41 #include <sys/types.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
44 #include <sys/bus.h>
45 #include <sys/module.h>
46 #include <sys/lock.h>
47 #include <sys/mutex.h>
48 #include <sys/condvar.h>
49 #include <sys/sysctl.h>
50 #include <sys/sx.h>
51 #include <sys/unistd.h>
52 #include <sys/callout.h>
53 #include <sys/malloc.h>
54 #include <sys/priv.h>
55
56 #include <dev/usb/usb.h>
57 #include <dev/usb/usbdi.h>
58 #include <dev/usb/usbdi_util.h>
59
60 #define USB_DEBUG_VAR uhub_debug
61
62 #include <dev/usb/usb_core.h>
63 #include <dev/usb/usb_process.h>
64 #include <dev/usb/usb_device.h>
65 #include <dev/usb/usb_request.h>
66 #include <dev/usb/usb_debug.h>
67 #include <dev/usb/usb_hub.h>
68 #include <dev/usb/usb_util.h>
69 #include <dev/usb/usb_busdma.h>
70 #include <dev/usb/usb_transfer.h>
71 #include <dev/usb/usb_dynamic.h>
72
73 #include <dev/usb/usb_controller.h>
74 #include <dev/usb/usb_bus.h>
75 #endif /* USB_GLOBAL_INCLUDE_FILE */
76
77 #include <dev/usb/usb_hub_private.h>
78
79 #ifdef USB_DEBUG
80 static int uhub_debug = 0;
81
82 static SYSCTL_NODE(_hw_usb, OID_AUTO, uhub, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
83 "USB HUB");
84 SYSCTL_INT(_hw_usb_uhub, OID_AUTO, debug, CTLFLAG_RWTUN, &uhub_debug, 0,
85 "Debug level");
86 #endif
87
88 #if USB_HAVE_POWERD
89 static int usb_power_timeout = 30; /* seconds */
90
91 SYSCTL_INT(_hw_usb, OID_AUTO, power_timeout, CTLFLAG_RWTUN,
92 &usb_power_timeout, 0, "USB power timeout");
93 #endif
94
95 #if USB_HAVE_DISABLE_ENUM
96 static int usb_disable_enumeration = 0;
97 SYSCTL_INT(_hw_usb, OID_AUTO, disable_enumeration, CTLFLAG_RWTUN,
98 &usb_disable_enumeration, 0, "Set to disable all USB device enumeration. "
99 "This can secure against USB devices turning evil, "
100 "for example a USB memory stick becoming a USB keyboard.");
101
102 static int usb_disable_port_power = 0;
103 SYSCTL_INT(_hw_usb, OID_AUTO, disable_port_power, CTLFLAG_RWTUN,
104 &usb_disable_port_power, 0, "Set to disable all USB port power.");
105 #endif
106
107 #define UHUB_PROTO(sc) ((sc)->sc_udev->ddesc.bDeviceProtocol)
108 #define UHUB_IS_HIGH_SPEED(sc) (UHUB_PROTO(sc) != UDPROTO_FSHUB)
109 #define UHUB_IS_SINGLE_TT(sc) (UHUB_PROTO(sc) == UDPROTO_HSHUBSTT)
110 #define UHUB_IS_MULTI_TT(sc) (UHUB_PROTO(sc) == UDPROTO_HSHUBMTT)
111 #define UHUB_IS_SUPER_SPEED(sc) (UHUB_PROTO(sc) == UDPROTO_SSHUB)
112
113 /* prototypes for type checking: */
114
115 static device_suspend_t uhub_suspend;
116 static device_resume_t uhub_resume;
117
118 static bus_driver_added_t uhub_driver_added;
119 static bus_child_pnpinfo_str_t uhub_child_pnpinfo_string;
120
121 static usb_callback_t uhub_intr_callback;
122 #if USB_HAVE_TT_SUPPORT
123 static usb_callback_t uhub_reset_tt_callback;
124 #endif
125
126 static void usb_dev_resume_peer(struct usb_device *udev);
127 static void usb_dev_suspend_peer(struct usb_device *udev);
128 static uint8_t usb_peer_should_wakeup(struct usb_device *udev);
129
130 static const struct usb_config uhub_config[UHUB_N_TRANSFER] = {
131 [UHUB_INTR_TRANSFER] = {
132 .type = UE_INTERRUPT,
133 .endpoint = UE_ADDR_ANY,
134 .direction = UE_DIR_ANY,
135 .timeout = 0,
136 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
137 .bufsize = 0, /* use wMaxPacketSize */
138 .callback = &uhub_intr_callback,
139 .interval = UHUB_INTR_INTERVAL,
140 },
141 #if USB_HAVE_TT_SUPPORT
142 [UHUB_RESET_TT_TRANSFER] = {
143 .type = UE_CONTROL,
144 .endpoint = 0x00, /* Control pipe */
145 .direction = UE_DIR_ANY,
146 .bufsize = sizeof(struct usb_device_request),
147 .callback = &uhub_reset_tt_callback,
148 .timeout = 1000, /* 1 second */
149 .usb_mode = USB_MODE_HOST,
150 },
151 #endif
152 };
153
154 /*
155 * driver instance for "hub" connected to "usb"
156 * and "hub" connected to "hub"
157 */
158 static devclass_t uhub_devclass;
159
160 static device_method_t uhub_methods[] = {
161 DEVMETHOD(device_probe, uhub_probe),
162 DEVMETHOD(device_attach, uhub_attach),
163 DEVMETHOD(device_detach, uhub_detach),
164
165 DEVMETHOD(device_suspend, uhub_suspend),
166 DEVMETHOD(device_resume, uhub_resume),
167
168 DEVMETHOD(bus_child_location_str, uhub_child_location_string),
169 DEVMETHOD(bus_child_pnpinfo_str, uhub_child_pnpinfo_string),
170 DEVMETHOD(bus_driver_added, uhub_driver_added),
171 DEVMETHOD_END
172 };
173
174 driver_t uhub_driver = {
175 .name = "uhub",
176 .methods = uhub_methods,
177 .size = sizeof(struct uhub_softc)
178 };
179
180 DRIVER_MODULE(uhub, usbus, uhub_driver, uhub_devclass, 0, 0);
181 DRIVER_MODULE(uhub, uhub, uhub_driver, uhub_devclass, NULL, 0);
182 MODULE_VERSION(uhub, 1);
183
184 static void
uhub_intr_callback(struct usb_xfer * xfer,usb_error_t error)185 uhub_intr_callback(struct usb_xfer *xfer, usb_error_t error)
186 {
187 struct uhub_softc *sc = usbd_xfer_softc(xfer);
188
189 switch (USB_GET_STATE(xfer)) {
190 case USB_ST_TRANSFERRED:
191 DPRINTFN(2, "\n");
192 /*
193 * This is an indication that some port
194 * has changed status. Notify the bus
195 * event handler thread that we need
196 * to be explored again:
197 */
198 usb_needs_explore(sc->sc_udev->bus, 0);
199
200 case USB_ST_SETUP:
201 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
202 usbd_transfer_submit(xfer);
203 break;
204
205 default: /* Error */
206 if (xfer->error != USB_ERR_CANCELLED) {
207 /*
208 * Do a clear-stall. The "stall_pipe" flag
209 * will get cleared before next callback by
210 * the USB stack.
211 */
212 usbd_xfer_set_stall(xfer);
213 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
214 usbd_transfer_submit(xfer);
215 }
216 break;
217 }
218 }
219
220 /*------------------------------------------------------------------------*
221 * uhub_reset_tt_proc
222 *
223 * This function starts the TT reset USB request
224 *------------------------------------------------------------------------*/
225 #if USB_HAVE_TT_SUPPORT
226 static void
uhub_reset_tt_proc(struct usb_proc_msg * _pm)227 uhub_reset_tt_proc(struct usb_proc_msg *_pm)
228 {
229 struct usb_udev_msg *pm = (void *)_pm;
230 struct usb_device *udev = pm->udev;
231 struct usb_hub *hub;
232 struct uhub_softc *sc;
233
234 hub = udev->hub;
235 if (hub == NULL)
236 return;
237 sc = hub->hubsoftc;
238 if (sc == NULL)
239 return;
240
241 /* Change lock */
242 USB_BUS_UNLOCK(udev->bus);
243 USB_MTX_LOCK(&sc->sc_mtx);
244 /* Start transfer */
245 usbd_transfer_start(sc->sc_xfer[UHUB_RESET_TT_TRANSFER]);
246 /* Change lock */
247 USB_MTX_UNLOCK(&sc->sc_mtx);
248 USB_BUS_LOCK(udev->bus);
249 }
250 #endif
251
252 /*------------------------------------------------------------------------*
253 * uhub_tt_buffer_reset_async_locked
254 *
255 * This function queues a TT reset for the given USB device and endpoint.
256 *------------------------------------------------------------------------*/
257 #if USB_HAVE_TT_SUPPORT
258 void
uhub_tt_buffer_reset_async_locked(struct usb_device * child,struct usb_endpoint * ep)259 uhub_tt_buffer_reset_async_locked(struct usb_device *child, struct usb_endpoint *ep)
260 {
261 struct usb_device_request req;
262 struct usb_device *udev;
263 struct usb_hub *hub;
264 struct usb_port *up;
265 uint16_t wValue;
266 uint8_t port;
267
268 if (child == NULL || ep == NULL)
269 return;
270
271 udev = child->parent_hs_hub;
272 port = child->hs_port_no;
273
274 if (udev == NULL)
275 return;
276
277 hub = udev->hub;
278 if ((hub == NULL) ||
279 (udev->speed != USB_SPEED_HIGH) ||
280 (child->speed != USB_SPEED_LOW &&
281 child->speed != USB_SPEED_FULL) ||
282 (child->flags.usb_mode != USB_MODE_HOST) ||
283 (port == 0) || (ep->edesc == NULL)) {
284 /* not applicable */
285 return;
286 }
287
288 USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
289
290 up = hub->ports + port - 1;
291
292 if (udev->ddesc.bDeviceClass == UDCLASS_HUB &&
293 udev->ddesc.bDeviceProtocol == UDPROTO_HSHUBSTT)
294 port = 1;
295
296 /* if we already received a clear buffer request, reset the whole TT */
297 if (up->req_reset_tt.bRequest != 0) {
298 req.bmRequestType = UT_WRITE_CLASS_OTHER;
299 req.bRequest = UR_RESET_TT;
300 USETW(req.wValue, 0);
301 req.wIndex[0] = port;
302 req.wIndex[1] = 0;
303 USETW(req.wLength, 0);
304 } else {
305 wValue = (ep->edesc->bEndpointAddress & 0xF) |
306 ((child->address & 0x7F) << 4) |
307 ((ep->edesc->bEndpointAddress & 0x80) << 8) |
308 ((ep->edesc->bmAttributes & 3) << 12);
309
310 req.bmRequestType = UT_WRITE_CLASS_OTHER;
311 req.bRequest = UR_CLEAR_TT_BUFFER;
312 USETW(req.wValue, wValue);
313 req.wIndex[0] = port;
314 req.wIndex[1] = 0;
315 USETW(req.wLength, 0);
316 }
317 up->req_reset_tt = req;
318 /* get reset transfer started */
319 usb_proc_msignal(USB_BUS_TT_PROC(udev->bus),
320 &hub->tt_msg[0], &hub->tt_msg[1]);
321 }
322 #endif
323
324 #if USB_HAVE_TT_SUPPORT
325 static void
uhub_reset_tt_callback(struct usb_xfer * xfer,usb_error_t error)326 uhub_reset_tt_callback(struct usb_xfer *xfer, usb_error_t error)
327 {
328 struct uhub_softc *sc;
329 struct usb_device *udev;
330 struct usb_port *up;
331 uint8_t x;
332
333 DPRINTF("TT buffer reset\n");
334
335 sc = usbd_xfer_softc(xfer);
336 udev = sc->sc_udev;
337
338 switch (USB_GET_STATE(xfer)) {
339 case USB_ST_TRANSFERRED:
340 case USB_ST_SETUP:
341 tr_setup:
342 USB_BUS_LOCK(udev->bus);
343 /* find first port which needs a TT reset */
344 for (x = 0; x != udev->hub->nports; x++) {
345 up = udev->hub->ports + x;
346
347 if (up->req_reset_tt.bRequest == 0)
348 continue;
349
350 /* copy in the transfer */
351 usbd_copy_in(xfer->frbuffers, 0, &up->req_reset_tt,
352 sizeof(up->req_reset_tt));
353 /* reset buffer */
354 memset(&up->req_reset_tt, 0, sizeof(up->req_reset_tt));
355
356 /* set length */
357 usbd_xfer_set_frame_len(xfer, 0, sizeof(up->req_reset_tt));
358 xfer->nframes = 1;
359 USB_BUS_UNLOCK(udev->bus);
360
361 usbd_transfer_submit(xfer);
362 return;
363 }
364 USB_BUS_UNLOCK(udev->bus);
365 break;
366
367 default:
368 if (error == USB_ERR_CANCELLED)
369 break;
370
371 DPRINTF("TT buffer reset failed (%s)\n", usbd_errstr(error));
372 goto tr_setup;
373 }
374 }
375 #endif
376
377 /*------------------------------------------------------------------------*
378 * uhub_count_active_host_ports
379 *
380 * This function counts the number of active ports at the given speed.
381 *------------------------------------------------------------------------*/
382 uint8_t
uhub_count_active_host_ports(struct usb_device * udev,enum usb_dev_speed speed)383 uhub_count_active_host_ports(struct usb_device *udev, enum usb_dev_speed speed)
384 {
385 struct uhub_softc *sc;
386 struct usb_device *child;
387 struct usb_hub *hub;
388 struct usb_port *up;
389 uint8_t retval = 0;
390 uint8_t x;
391
392 if (udev == NULL)
393 goto done;
394 hub = udev->hub;
395 if (hub == NULL)
396 goto done;
397 sc = hub->hubsoftc;
398 if (sc == NULL)
399 goto done;
400
401 for (x = 0; x != hub->nports; x++) {
402 up = hub->ports + x;
403 child = usb_bus_port_get_device(udev->bus, up);
404 if (child != NULL &&
405 child->flags.usb_mode == USB_MODE_HOST &&
406 child->speed == speed)
407 retval++;
408 }
409 done:
410 return (retval);
411 }
412
413 void
uhub_explore_handle_re_enumerate(struct usb_device * child)414 uhub_explore_handle_re_enumerate(struct usb_device *child)
415 {
416 uint8_t do_unlock;
417 usb_error_t err;
418
419 /* check if device should be re-enumerated */
420 if (child->flags.usb_mode != USB_MODE_HOST)
421 return;
422
423 do_unlock = usbd_enum_lock(child);
424 switch (child->re_enumerate_wait) {
425 case USB_RE_ENUM_START:
426 err = usbd_set_config_index(child,
427 USB_UNCONFIG_INDEX);
428 if (err != 0) {
429 DPRINTF("Unconfigure failed: %s: Ignored.\n",
430 usbd_errstr(err));
431 }
432 if (child->parent_hub == NULL) {
433 /* the root HUB cannot be re-enumerated */
434 DPRINTFN(6, "cannot reset root HUB\n");
435 err = 0;
436 } else {
437 err = usbd_req_re_enumerate(child, NULL);
438 }
439 if (err == 0) {
440 /* refresh device strings */
441 usb_get_langid(child);
442 usb_set_device_strings(child);
443
444 /* set default configuration */
445 err = usbd_set_config_index(child, 0);
446 }
447 if (err == 0) {
448 err = usb_probe_and_attach(child,
449 USB_IFACE_INDEX_ANY);
450 }
451 child->re_enumerate_wait = USB_RE_ENUM_DONE;
452 break;
453
454 case USB_RE_ENUM_PWR_OFF:
455 /* get the device unconfigured */
456 err = usbd_set_config_index(child,
457 USB_UNCONFIG_INDEX);
458 if (err) {
459 DPRINTFN(0, "Could not unconfigure "
460 "device (ignored)\n");
461 }
462 if (child->parent_hub == NULL) {
463 /* the root HUB cannot be re-enumerated */
464 DPRINTFN(6, "cannot set port feature\n");
465 err = 0;
466 } else {
467 /* clear port enable */
468 err = usbd_req_clear_port_feature(child->parent_hub,
469 NULL, child->port_no, UHF_PORT_ENABLE);
470 if (err) {
471 DPRINTFN(0, "Could not disable port "
472 "(ignored)\n");
473 }
474 }
475 child->re_enumerate_wait = USB_RE_ENUM_DONE;
476 break;
477
478 case USB_RE_ENUM_SET_CONFIG:
479 err = usbd_set_config_index(child,
480 child->next_config_index);
481 if (err != 0) {
482 DPRINTF("Configure failed: %s: Ignored.\n",
483 usbd_errstr(err));
484 } else {
485 err = usb_probe_and_attach(child,
486 USB_IFACE_INDEX_ANY);
487 }
488 child->re_enumerate_wait = USB_RE_ENUM_DONE;
489 break;
490
491 default:
492 child->re_enumerate_wait = USB_RE_ENUM_DONE;
493 break;
494 }
495 if (do_unlock)
496 usbd_enum_unlock(child);
497 }
498
499 /*------------------------------------------------------------------------*
500 * uhub_explore_sub - subroutine
501 *
502 * Return values:
503 * 0: Success
504 * Else: A control transaction failed
505 *------------------------------------------------------------------------*/
506 static usb_error_t
uhub_explore_sub(struct uhub_softc * sc,struct usb_port * up)507 uhub_explore_sub(struct uhub_softc *sc, struct usb_port *up)
508 {
509 struct usb_bus *bus;
510 struct usb_device *child;
511 uint8_t refcount;
512 usb_error_t err;
513
514 bus = sc->sc_udev->bus;
515 err = USB_ERR_NORMAL_COMPLETION;
516
517 /* get driver added refcount from USB bus */
518 refcount = bus->driver_added_refcount;
519
520 /* get device assosiated with the given port */
521 child = usb_bus_port_get_device(bus, up);
522 if (child == NULL) {
523 /* nothing to do */
524 goto done;
525 }
526
527 uhub_explore_handle_re_enumerate(child);
528
529 /* check if probe and attach should be done */
530
531 if (child->driver_added_refcount != refcount) {
532 child->driver_added_refcount = refcount;
533 err = usb_probe_and_attach(child,
534 USB_IFACE_INDEX_ANY);
535 if (err) {
536 goto done;
537 }
538 }
539 /* start control transfer, if device mode */
540
541 if (child->flags.usb_mode == USB_MODE_DEVICE)
542 usbd_ctrl_transfer_setup(child);
543
544 /* if a HUB becomes present, do a recursive HUB explore */
545
546 if (child->hub)
547 err = (child->hub->explore) (child);
548
549 done:
550 return (err);
551 }
552
553 /*------------------------------------------------------------------------*
554 * uhub_read_port_status - factored out code
555 *------------------------------------------------------------------------*/
556 static usb_error_t
uhub_read_port_status(struct uhub_softc * sc,uint8_t portno)557 uhub_read_port_status(struct uhub_softc *sc, uint8_t portno)
558 {
559 struct usb_port_status ps;
560 usb_error_t err;
561
562 if (sc->sc_usb_port_errors >= UHUB_USB_PORT_ERRORS_MAX) {
563 DPRINTFN(4, "port %d, HUB looks dead, too many errors\n", portno);
564 sc->sc_st.port_status = 0;
565 sc->sc_st.port_change = 0;
566 return (USB_ERR_TIMEOUT);
567 }
568
569 err = usbd_req_get_port_status(
570 sc->sc_udev, NULL, &ps, portno);
571
572 if (err == 0) {
573 sc->sc_st.port_status = UGETW(ps.wPortStatus);
574 sc->sc_st.port_change = UGETW(ps.wPortChange);
575 sc->sc_usb_port_errors = 0;
576 } else {
577 sc->sc_st.port_status = 0;
578 sc->sc_st.port_change = 0;
579 sc->sc_usb_port_errors++;
580 }
581
582 /* debugging print */
583
584 DPRINTFN(4, "port %d, wPortStatus=0x%04x, "
585 "wPortChange=0x%04x, err=%s\n",
586 portno, sc->sc_st.port_status,
587 sc->sc_st.port_change, usbd_errstr(err));
588 return (err);
589 }
590
591 /*------------------------------------------------------------------------*
592 * uhub_reattach_port
593 *
594 * Returns:
595 * 0: Success
596 * Else: A control transaction failed
597 *------------------------------------------------------------------------*/
598 static usb_error_t
uhub_reattach_port(struct uhub_softc * sc,uint8_t portno)599 uhub_reattach_port(struct uhub_softc *sc, uint8_t portno)
600 {
601 struct usb_device *child;
602 struct usb_device *udev;
603 enum usb_dev_speed speed;
604 enum usb_hc_mode mode;
605 usb_error_t err;
606 uint16_t power_mask;
607 uint8_t timeout;
608
609 DPRINTF("reattaching port %d\n", portno);
610
611 timeout = 0;
612 udev = sc->sc_udev;
613 child = usb_bus_port_get_device(udev->bus,
614 udev->hub->ports + portno - 1);
615
616 repeat:
617
618 /* first clear the port connection change bit */
619
620 err = usbd_req_clear_port_feature(udev, NULL,
621 portno, UHF_C_PORT_CONNECTION);
622
623 if (err)
624 goto error;
625
626 /* check if there is a child */
627
628 if (child != NULL) {
629 /*
630 * Free USB device and all subdevices, if any.
631 */
632 usb_free_device(child, 0);
633 child = NULL;
634 }
635 /* get fresh status */
636
637 err = uhub_read_port_status(sc, portno);
638 if (err)
639 goto error;
640
641 #if USB_HAVE_DISABLE_ENUM
642 /* check if we should skip enumeration from this USB HUB */
643 if (usb_disable_enumeration != 0 ||
644 sc->sc_disable_enumeration != 0) {
645 DPRINTF("Enumeration is disabled!\n");
646 goto error;
647 }
648 #endif
649 /* check if nothing is connected to the port */
650
651 if (!(sc->sc_st.port_status & UPS_CURRENT_CONNECT_STATUS))
652 goto error;
653
654 /* check if there is no power on the port and print a warning */
655
656 switch (udev->speed) {
657 case USB_SPEED_HIGH:
658 case USB_SPEED_FULL:
659 case USB_SPEED_LOW:
660 power_mask = UPS_PORT_POWER;
661 break;
662 case USB_SPEED_SUPER:
663 if (udev->parent_hub == NULL)
664 power_mask = 0; /* XXX undefined */
665 else
666 power_mask = UPS_PORT_POWER_SS;
667 break;
668 default:
669 power_mask = 0;
670 break;
671 }
672 if ((sc->sc_st.port_status & power_mask) != power_mask) {
673 DPRINTF("WARNING: strange, connected port %d "
674 "has no power\n", portno);
675 }
676
677 /* check if the device is in Host Mode */
678
679 if (!(sc->sc_st.port_status & UPS_PORT_MODE_DEVICE)) {
680 DPRINTF("Port %d is in Host Mode\n", portno);
681
682 if (sc->sc_st.port_status & UPS_SUSPEND) {
683 /*
684 * NOTE: Should not get here in SuperSpeed
685 * mode, because the HUB should report this
686 * bit as zero.
687 */
688 DPRINTF("Port %d was still "
689 "suspended, clearing.\n", portno);
690 err = usbd_req_clear_port_feature(udev,
691 NULL, portno, UHF_PORT_SUSPEND);
692 }
693
694 /* USB Host Mode */
695
696 /* wait for maximum device power up time */
697
698 usb_pause_mtx(NULL,
699 USB_MS_TO_TICKS(usb_port_powerup_delay));
700
701 /* reset port, which implies enabling it */
702
703 err = usbd_req_reset_port(udev, NULL, portno);
704
705 if (err) {
706 DPRINTFN(0, "port %d reset "
707 "failed, error=%s\n",
708 portno, usbd_errstr(err));
709 goto error;
710 }
711 /* get port status again, it might have changed during reset */
712
713 err = uhub_read_port_status(sc, portno);
714 if (err) {
715 goto error;
716 }
717 /* check if something changed during port reset */
718
719 if ((sc->sc_st.port_change & UPS_C_CONNECT_STATUS) ||
720 (!(sc->sc_st.port_status & UPS_CURRENT_CONNECT_STATUS))) {
721 if (timeout) {
722 DPRINTFN(0, "giving up port %d reset - "
723 "device vanished: change %#x status %#x\n",
724 portno, sc->sc_st.port_change,
725 sc->sc_st.port_status);
726 goto error;
727 }
728 timeout = 1;
729 goto repeat;
730 }
731 } else {
732 DPRINTF("Port %d is in Device Mode\n", portno);
733 }
734
735 /*
736 * Figure out the device speed
737 */
738 switch (udev->speed) {
739 case USB_SPEED_HIGH:
740 if (sc->sc_st.port_status & UPS_HIGH_SPEED)
741 speed = USB_SPEED_HIGH;
742 else if (sc->sc_st.port_status & UPS_LOW_SPEED)
743 speed = USB_SPEED_LOW;
744 else
745 speed = USB_SPEED_FULL;
746 break;
747 case USB_SPEED_FULL:
748 if (sc->sc_st.port_status & UPS_LOW_SPEED)
749 speed = USB_SPEED_LOW;
750 else
751 speed = USB_SPEED_FULL;
752 break;
753 case USB_SPEED_LOW:
754 speed = USB_SPEED_LOW;
755 break;
756 case USB_SPEED_SUPER:
757 if (udev->parent_hub == NULL) {
758 /* Root HUB - special case */
759 switch (sc->sc_st.port_status & UPS_OTHER_SPEED) {
760 case 0:
761 speed = USB_SPEED_FULL;
762 break;
763 case UPS_LOW_SPEED:
764 speed = USB_SPEED_LOW;
765 break;
766 case UPS_HIGH_SPEED:
767 speed = USB_SPEED_HIGH;
768 break;
769 default:
770 speed = USB_SPEED_SUPER;
771 break;
772 }
773 } else {
774 speed = USB_SPEED_SUPER;
775 }
776 break;
777 default:
778 /* same speed like parent */
779 speed = udev->speed;
780 break;
781 }
782 if (speed == USB_SPEED_SUPER) {
783 err = usbd_req_set_hub_u1_timeout(udev, NULL,
784 portno, 128 - (2 * udev->depth));
785 if (err) {
786 DPRINTFN(0, "port %d U1 timeout "
787 "failed, error=%s\n",
788 portno, usbd_errstr(err));
789 }
790 err = usbd_req_set_hub_u2_timeout(udev, NULL,
791 portno, 128 - (2 * udev->depth));
792 if (err) {
793 DPRINTFN(0, "port %d U2 timeout "
794 "failed, error=%s\n",
795 portno, usbd_errstr(err));
796 }
797 }
798
799 /*
800 * Figure out the device mode
801 *
802 * NOTE: This part is currently FreeBSD specific.
803 */
804 if (udev->parent_hub != NULL) {
805 /* inherit mode from the parent HUB */
806 mode = udev->parent_hub->flags.usb_mode;
807 } else if (sc->sc_st.port_status & UPS_PORT_MODE_DEVICE)
808 mode = USB_MODE_DEVICE;
809 else
810 mode = USB_MODE_HOST;
811
812 /* need to create a new child */
813 child = usb_alloc_device(sc->sc_dev, udev->bus, udev,
814 udev->depth + 1, portno - 1, portno, speed, mode);
815 if (child == NULL) {
816 DPRINTFN(0, "could not allocate new device\n");
817 goto error;
818 }
819 return (0); /* success */
820
821 error:
822 if (child != NULL) {
823 /*
824 * Free USB device and all subdevices, if any.
825 */
826 usb_free_device(child, 0);
827 child = NULL;
828 }
829 if (err == 0) {
830 if (sc->sc_st.port_status & UPS_PORT_ENABLED) {
831 err = usbd_req_clear_port_feature(
832 sc->sc_udev, NULL,
833 portno, UHF_PORT_ENABLE);
834 }
835 }
836 if (err) {
837 DPRINTFN(0, "device problem (%s), "
838 "disabling port %d\n", usbd_errstr(err), portno);
839 }
840 return (err);
841 }
842
843 /*------------------------------------------------------------------------*
844 * usb_device_20_compatible
845 *
846 * Returns:
847 * 0: HUB does not support suspend and resume
848 * Else: HUB supports suspend and resume
849 *------------------------------------------------------------------------*/
850 static uint8_t
usb_device_20_compatible(struct usb_device * udev)851 usb_device_20_compatible(struct usb_device *udev)
852 {
853 if (udev == NULL)
854 return (0);
855 switch (udev->speed) {
856 case USB_SPEED_LOW:
857 case USB_SPEED_FULL:
858 case USB_SPEED_HIGH:
859 return (1);
860 default:
861 return (0);
862 }
863 }
864
865 /*------------------------------------------------------------------------*
866 * uhub_suspend_resume_port
867 *
868 * Returns:
869 * 0: Success
870 * Else: A control transaction failed
871 *------------------------------------------------------------------------*/
872 static usb_error_t
uhub_suspend_resume_port(struct uhub_softc * sc,uint8_t portno)873 uhub_suspend_resume_port(struct uhub_softc *sc, uint8_t portno)
874 {
875 struct usb_device *child;
876 struct usb_device *udev;
877 uint8_t is_suspend;
878 usb_error_t err;
879
880 DPRINTF("port %d\n", portno);
881
882 udev = sc->sc_udev;
883 child = usb_bus_port_get_device(udev->bus,
884 udev->hub->ports + portno - 1);
885
886 /* first clear the port suspend change bit */
887
888 if (usb_device_20_compatible(udev)) {
889 err = usbd_req_clear_port_feature(udev, NULL,
890 portno, UHF_C_PORT_SUSPEND);
891 } else {
892 err = usbd_req_clear_port_feature(udev, NULL,
893 portno, UHF_C_PORT_LINK_STATE);
894 }
895
896 if (err) {
897 DPRINTF("clearing suspend failed.\n");
898 goto done;
899 }
900 /* get fresh status */
901
902 err = uhub_read_port_status(sc, portno);
903 if (err) {
904 DPRINTF("reading port status failed.\n");
905 goto done;
906 }
907 /* convert current state */
908
909 if (usb_device_20_compatible(udev)) {
910 if (sc->sc_st.port_status & UPS_SUSPEND) {
911 is_suspend = 1;
912 } else {
913 is_suspend = 0;
914 }
915 } else {
916 switch (UPS_PORT_LINK_STATE_GET(sc->sc_st.port_status)) {
917 case UPS_PORT_LS_U3:
918 is_suspend = 1;
919 break;
920 case UPS_PORT_LS_SS_INA:
921 usbd_req_warm_reset_port(udev, NULL, portno);
922 is_suspend = 0;
923 break;
924 default:
925 is_suspend = 0;
926 break;
927 }
928 }
929
930 DPRINTF("suspended=%u\n", is_suspend);
931
932 /* do the suspend or resume */
933
934 if (child) {
935 /*
936 * This code handle two cases: 1) Host Mode - we can only
937 * receive resume here 2) Device Mode - we can receive
938 * suspend and resume here
939 */
940 if (is_suspend == 0)
941 usb_dev_resume_peer(child);
942 else if (child->flags.usb_mode == USB_MODE_DEVICE)
943 usb_dev_suspend_peer(child);
944 }
945 done:
946 return (err);
947 }
948
949 /*------------------------------------------------------------------------*
950 * uhub_root_interrupt
951 *
952 * This function is called when a Root HUB interrupt has
953 * happened. "ptr" and "len" makes up the Root HUB interrupt
954 * packet. This function is called having the "bus_mtx" locked.
955 *------------------------------------------------------------------------*/
956 void
uhub_root_intr(struct usb_bus * bus,const uint8_t * ptr,uint8_t len)957 uhub_root_intr(struct usb_bus *bus, const uint8_t *ptr, uint8_t len)
958 {
959 USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
960
961 usb_needs_explore(bus, 0);
962 }
963
964 static uint8_t
uhub_is_too_deep(struct usb_device * udev)965 uhub_is_too_deep(struct usb_device *udev)
966 {
967 switch (udev->speed) {
968 case USB_SPEED_FULL:
969 case USB_SPEED_LOW:
970 case USB_SPEED_HIGH:
971 if (udev->depth > USB_HUB_MAX_DEPTH)
972 return (1);
973 break;
974 case USB_SPEED_SUPER:
975 if (udev->depth > USB_SS_HUB_DEPTH_MAX)
976 return (1);
977 break;
978 default:
979 break;
980 }
981 return (0);
982 }
983
984 /*------------------------------------------------------------------------*
985 * uhub_explore
986 *
987 * Returns:
988 * 0: Success
989 * Else: Failure
990 *------------------------------------------------------------------------*/
991 static usb_error_t
uhub_explore(struct usb_device * udev)992 uhub_explore(struct usb_device *udev)
993 {
994 struct usb_hub *hub;
995 struct uhub_softc *sc;
996 struct usb_port *up;
997 usb_error_t retval;
998 usb_error_t err;
999 uint8_t portno;
1000 uint8_t x;
1001 uint8_t do_unlock;
1002
1003 hub = udev->hub;
1004 sc = hub->hubsoftc;
1005
1006 DPRINTFN(11, "udev=%p addr=%d\n", udev, udev->address);
1007
1008 /* ignore devices that are too deep */
1009 if (uhub_is_too_deep(udev))
1010 return (USB_ERR_TOO_DEEP);
1011
1012 /* check if device is suspended */
1013 if (udev->flags.self_suspended) {
1014 /* need to wait until the child signals resume */
1015 DPRINTF("Device is suspended!\n");
1016 return (USB_ERR_NORMAL_COMPLETION);
1017 }
1018
1019 /*
1020 * Make sure we don't race against user-space applications
1021 * like LibUSB:
1022 */
1023 do_unlock = usbd_enum_lock(udev);
1024
1025 /*
1026 * Set default error code to avoid compiler warnings.
1027 * Note that hub->nports cannot be zero.
1028 */
1029 retval = USB_ERR_NORMAL_COMPLETION;
1030
1031 for (x = 0; x != hub->nports; x++) {
1032 up = hub->ports + x;
1033 portno = x + 1;
1034
1035 err = uhub_read_port_status(sc, portno);
1036 if (err != USB_ERR_NORMAL_COMPLETION)
1037 retval = err;
1038
1039 if (sc->sc_st.port_change & UPS_C_OVERCURRENT_INDICATOR) {
1040 DPRINTF("Overcurrent on port %u.\n", portno);
1041 err = usbd_req_clear_port_feature(
1042 udev, NULL, portno, UHF_C_PORT_OVER_CURRENT);
1043 if (err != USB_ERR_NORMAL_COMPLETION)
1044 retval = err;
1045 }
1046 if (!(sc->sc_flags & UHUB_FLAG_DID_EXPLORE)) {
1047 /*
1048 * Fake a connect status change so that the
1049 * status gets checked initially!
1050 */
1051 sc->sc_st.port_change |=
1052 UPS_C_CONNECT_STATUS;
1053 }
1054 if (sc->sc_st.port_change & UPS_C_PORT_ENABLED) {
1055 err = usbd_req_clear_port_feature(
1056 udev, NULL, portno, UHF_C_PORT_ENABLE);
1057 if (err != USB_ERR_NORMAL_COMPLETION)
1058 retval = err;
1059 if (sc->sc_st.port_change & UPS_C_CONNECT_STATUS) {
1060 /*
1061 * Ignore the port error if the device
1062 * has vanished !
1063 */
1064 } else if (sc->sc_st.port_status & UPS_PORT_ENABLED) {
1065 DPRINTFN(0, "illegal enable change, "
1066 "port %d\n", portno);
1067 } else {
1068 if (up->restartcnt == USB_RESTART_MAX) {
1069 /* XXX could try another speed ? */
1070 DPRINTFN(0, "port error, giving up "
1071 "port %d\n", portno);
1072 } else {
1073 sc->sc_st.port_change |=
1074 UPS_C_CONNECT_STATUS;
1075 up->restartcnt++;
1076 }
1077 }
1078 }
1079 if (sc->sc_st.port_change & UPS_C_CONNECT_STATUS) {
1080 err = uhub_reattach_port(sc, portno);
1081 if (err != USB_ERR_NORMAL_COMPLETION)
1082 retval = err;
1083 }
1084 if (sc->sc_st.port_change & (UPS_C_SUSPEND |
1085 UPS_C_PORT_LINK_STATE)) {
1086 err = uhub_suspend_resume_port(sc, portno);
1087 if (err != USB_ERR_NORMAL_COMPLETION)
1088 retval = err;
1089 }
1090 if (udev->speed == USB_SPEED_SUPER &&
1091 (sc->sc_st.port_change & UPS_C_BH_PORT_RESET) != 0) {
1092 DPRINTF("Warm reset finished on port %u.\n", portno);
1093 err = usbd_req_clear_port_feature(
1094 udev, NULL, portno, UHF_C_BH_PORT_RESET);
1095 if (err != USB_ERR_NORMAL_COMPLETION)
1096 retval = err;
1097 }
1098 if (sc->sc_st.port_change & UPS_C_PORT_RESET) {
1099 DPRINTF("Port reset finished on port %u.\n", portno);
1100 err = usbd_req_clear_port_feature(
1101 udev, NULL, portno, UHF_C_PORT_RESET);
1102 if (err != USB_ERR_NORMAL_COMPLETION)
1103 retval = err;
1104 }
1105
1106 if (uhub_explore_sub(sc, up) == USB_ERR_NORMAL_COMPLETION) {
1107 /* explore succeeded - reset restart counter */
1108 up->restartcnt = 0;
1109 }
1110 }
1111
1112 if (do_unlock)
1113 usbd_enum_unlock(udev);
1114
1115 /* initial status checked */
1116 sc->sc_flags |= UHUB_FLAG_DID_EXPLORE;
1117
1118 return (retval);
1119 }
1120
1121 int
uhub_probe(device_t dev)1122 uhub_probe(device_t dev)
1123 {
1124 struct usb_attach_arg *uaa = device_get_ivars(dev);
1125
1126 if (uaa->usb_mode != USB_MODE_HOST)
1127 return (ENXIO);
1128
1129 /*
1130 * The subclass for USB HUBs is currently ignored because it
1131 * is 0 for some and 1 for others.
1132 */
1133 if (uaa->info.bConfigIndex == 0 &&
1134 uaa->info.bDeviceClass == UDCLASS_HUB)
1135 return (BUS_PROBE_DEFAULT);
1136
1137 return (ENXIO);
1138 }
1139
1140 /* NOTE: The information returned by this function can be wrong. */
1141 usb_error_t
uhub_query_info(struct usb_device * udev,uint8_t * pnports,uint8_t * ptt)1142 uhub_query_info(struct usb_device *udev, uint8_t *pnports, uint8_t *ptt)
1143 {
1144 struct usb_hub_descriptor hubdesc20;
1145 struct usb_hub_ss_descriptor hubdesc30;
1146 usb_error_t err;
1147 uint8_t nports;
1148 uint8_t tt;
1149
1150 if (udev->ddesc.bDeviceClass != UDCLASS_HUB)
1151 return (USB_ERR_INVAL);
1152
1153 nports = 0;
1154 tt = 0;
1155
1156 switch (udev->speed) {
1157 case USB_SPEED_LOW:
1158 case USB_SPEED_FULL:
1159 case USB_SPEED_HIGH:
1160 /* assuming that there is one port */
1161 err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc20, 1);
1162 if (err) {
1163 DPRINTFN(0, "getting USB 2.0 HUB descriptor failed,"
1164 "error=%s\n", usbd_errstr(err));
1165 break;
1166 }
1167 nports = hubdesc20.bNbrPorts;
1168 if (nports > 127)
1169 nports = 127;
1170
1171 if (udev->speed == USB_SPEED_HIGH)
1172 tt = (UGETW(hubdesc20.wHubCharacteristics) >> 5) & 3;
1173 break;
1174
1175 case USB_SPEED_SUPER:
1176 err = usbd_req_get_ss_hub_descriptor(udev, NULL, &hubdesc30, 1);
1177 if (err) {
1178 DPRINTFN(0, "Getting USB 3.0 HUB descriptor failed,"
1179 "error=%s\n", usbd_errstr(err));
1180 break;
1181 }
1182 nports = hubdesc30.bNbrPorts;
1183 if (nports > 16)
1184 nports = 16;
1185 break;
1186
1187 default:
1188 err = USB_ERR_INVAL;
1189 break;
1190 }
1191
1192 if (pnports != NULL)
1193 *pnports = nports;
1194
1195 if (ptt != NULL)
1196 *ptt = tt;
1197
1198 return (err);
1199 }
1200
1201 int
uhub_attach(device_t dev)1202 uhub_attach(device_t dev)
1203 {
1204 struct uhub_softc *sc = device_get_softc(dev);
1205 struct usb_attach_arg *uaa = device_get_ivars(dev);
1206 struct usb_device *udev = uaa->device;
1207 struct usb_device *parent_hub = udev->parent_hub;
1208 struct usb_hub *hub;
1209 struct usb_hub_descriptor hubdesc20;
1210 struct usb_hub_ss_descriptor hubdesc30;
1211 #if USB_HAVE_DISABLE_ENUM
1212 struct sysctl_ctx_list *sysctl_ctx;
1213 struct sysctl_oid *sysctl_tree;
1214 #endif
1215 uint16_t pwrdly;
1216 uint16_t nports;
1217 uint8_t x;
1218 uint8_t portno;
1219 uint8_t removable;
1220 uint8_t iface_index;
1221 usb_error_t err;
1222
1223 sc->sc_udev = udev;
1224 sc->sc_dev = dev;
1225
1226 mtx_init(&sc->sc_mtx, "USB HUB mutex", NULL, MTX_DEF);
1227
1228 device_set_usb_desc(dev);
1229
1230 DPRINTFN(2, "depth=%d selfpowered=%d, parent=%p, "
1231 "parent->selfpowered=%d\n",
1232 udev->depth,
1233 udev->flags.self_powered,
1234 parent_hub,
1235 parent_hub ?
1236 parent_hub->flags.self_powered : 0);
1237
1238 if (uhub_is_too_deep(udev)) {
1239 DPRINTFN(0, "HUB at depth %d, "
1240 "exceeds maximum. HUB ignored\n", (int)udev->depth);
1241 goto error;
1242 }
1243
1244 if (!udev->flags.self_powered && parent_hub &&
1245 !parent_hub->flags.self_powered) {
1246 DPRINTFN(0, "Bus powered HUB connected to "
1247 "bus powered HUB. HUB ignored\n");
1248 goto error;
1249 }
1250
1251 if (UHUB_IS_MULTI_TT(sc)) {
1252 err = usbd_set_alt_interface_index(udev, 0, 1);
1253 if (err) {
1254 device_printf(dev, "MTT could not be enabled\n");
1255 goto error;
1256 }
1257 device_printf(dev, "MTT enabled\n");
1258 }
1259
1260 /* get HUB descriptor */
1261
1262 DPRINTFN(2, "Getting HUB descriptor\n");
1263
1264 switch (udev->speed) {
1265 case USB_SPEED_LOW:
1266 case USB_SPEED_FULL:
1267 case USB_SPEED_HIGH:
1268 /* assuming that there is one port */
1269 err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc20, 1);
1270 if (err) {
1271 DPRINTFN(0, "getting USB 2.0 HUB descriptor failed,"
1272 "error=%s\n", usbd_errstr(err));
1273 goto error;
1274 }
1275 /* get number of ports */
1276 nports = hubdesc20.bNbrPorts;
1277
1278 /* get power delay */
1279 pwrdly = ((hubdesc20.bPwrOn2PwrGood * UHD_PWRON_FACTOR) +
1280 usb_extra_power_up_time);
1281
1282 /* get complete HUB descriptor */
1283 if (nports >= 8) {
1284 /* check number of ports */
1285 if (nports > 127) {
1286 DPRINTFN(0, "Invalid number of USB 2.0 ports,"
1287 "error=%s\n", usbd_errstr(err));
1288 goto error;
1289 }
1290 /* get complete HUB descriptor */
1291 err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc20, nports);
1292
1293 if (err) {
1294 DPRINTFN(0, "Getting USB 2.0 HUB descriptor failed,"
1295 "error=%s\n", usbd_errstr(err));
1296 goto error;
1297 }
1298 if (hubdesc20.bNbrPorts != nports) {
1299 DPRINTFN(0, "Number of ports changed\n");
1300 goto error;
1301 }
1302 }
1303 break;
1304 case USB_SPEED_SUPER:
1305 if (udev->parent_hub != NULL) {
1306 err = usbd_req_set_hub_depth(udev, NULL,
1307 udev->depth - 1);
1308 if (err) {
1309 DPRINTFN(0, "Setting USB 3.0 HUB depth failed,"
1310 "error=%s\n", usbd_errstr(err));
1311 goto error;
1312 }
1313 }
1314 err = usbd_req_get_ss_hub_descriptor(udev, NULL, &hubdesc30, 1);
1315 if (err) {
1316 DPRINTFN(0, "Getting USB 3.0 HUB descriptor failed,"
1317 "error=%s\n", usbd_errstr(err));
1318 goto error;
1319 }
1320 /* get number of ports */
1321 nports = hubdesc30.bNbrPorts;
1322
1323 /* get power delay */
1324 pwrdly = ((hubdesc30.bPwrOn2PwrGood * UHD_PWRON_FACTOR) +
1325 usb_extra_power_up_time);
1326
1327 /* get complete HUB descriptor */
1328 if (nports >= 8) {
1329 /* check number of ports */
1330 if (nports > ((udev->parent_hub != NULL) ? 15 : 127)) {
1331 DPRINTFN(0, "Invalid number of USB 3.0 ports,"
1332 "error=%s\n", usbd_errstr(err));
1333 goto error;
1334 }
1335 /* get complete HUB descriptor */
1336 err = usbd_req_get_ss_hub_descriptor(udev, NULL, &hubdesc30, nports);
1337
1338 if (err) {
1339 DPRINTFN(0, "Getting USB 2.0 HUB descriptor failed,"
1340 "error=%s\n", usbd_errstr(err));
1341 goto error;
1342 }
1343 if (hubdesc30.bNbrPorts != nports) {
1344 DPRINTFN(0, "Number of ports changed\n");
1345 goto error;
1346 }
1347 }
1348 break;
1349 default:
1350 DPRINTF("Assuming HUB has only one port\n");
1351 /* default number of ports */
1352 nports = 1;
1353 /* default power delay */
1354 pwrdly = ((10 * UHD_PWRON_FACTOR) + usb_extra_power_up_time);
1355 break;
1356 }
1357 if (nports == 0) {
1358 DPRINTFN(0, "portless HUB\n");
1359 goto error;
1360 }
1361 if (nports > USB_MAX_PORTS) {
1362 DPRINTF("Port limit exceeded\n");
1363 goto error;
1364 }
1365 #if (USB_HAVE_FIXED_PORT == 0)
1366 hub = malloc(sizeof(hub[0]) + (sizeof(hub->ports[0]) * nports),
1367 M_USBDEV, M_WAITOK | M_ZERO);
1368
1369 if (hub == NULL)
1370 goto error;
1371 #else
1372 hub = &sc->sc_hub;
1373 #endif
1374 udev->hub = hub;
1375
1376 /* initialize HUB structure */
1377 hub->hubsoftc = sc;
1378 hub->explore = &uhub_explore;
1379 hub->nports = nports;
1380 hub->hubudev = udev;
1381 #if USB_HAVE_TT_SUPPORT
1382 hub->tt_msg[0].hdr.pm_callback = &uhub_reset_tt_proc;
1383 hub->tt_msg[0].udev = udev;
1384 hub->tt_msg[1].hdr.pm_callback = &uhub_reset_tt_proc;
1385 hub->tt_msg[1].udev = udev;
1386 #endif
1387 /* if self powered hub, give ports maximum current */
1388 if (udev->flags.self_powered) {
1389 hub->portpower = USB_MAX_POWER;
1390 } else {
1391 hub->portpower = USB_MIN_POWER;
1392 }
1393
1394 /* set up interrupt pipe */
1395 iface_index = 0;
1396 if (udev->parent_hub == NULL) {
1397 /* root HUB is special */
1398 err = 0;
1399 } else {
1400 /* normal HUB */
1401 err = usbd_transfer_setup(udev, &iface_index, sc->sc_xfer,
1402 uhub_config, UHUB_N_TRANSFER, sc, &sc->sc_mtx);
1403 }
1404 if (err) {
1405 DPRINTFN(0, "cannot setup interrupt transfer, "
1406 "errstr=%s\n", usbd_errstr(err));
1407 goto error;
1408 }
1409 /* wait with power off for a while */
1410 usb_pause_mtx(NULL, USB_MS_TO_TICKS(USB_POWER_DOWN_TIME));
1411
1412 #if USB_HAVE_DISABLE_ENUM
1413 /* Add device sysctls */
1414
1415 sysctl_ctx = device_get_sysctl_ctx(dev);
1416 sysctl_tree = device_get_sysctl_tree(dev);
1417
1418 if (sysctl_ctx != NULL && sysctl_tree != NULL) {
1419 (void) SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
1420 OID_AUTO, "disable_enumeration", CTLFLAG_RWTUN,
1421 &sc->sc_disable_enumeration, 0,
1422 "Set to disable enumeration on this USB HUB.");
1423
1424 (void) SYSCTL_ADD_INT(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
1425 OID_AUTO, "disable_port_power", CTLFLAG_RWTUN,
1426 &sc->sc_disable_port_power, 0,
1427 "Set to disable USB port power on this USB HUB.");
1428 }
1429 #endif
1430 /*
1431 * To have the best chance of success we do things in the exact same
1432 * order as Windoze98. This should not be necessary, but some
1433 * devices do not follow the USB specs to the letter.
1434 *
1435 * These are the events on the bus when a hub is attached:
1436 * Get device and config descriptors (see attach code)
1437 * Get hub descriptor (see above)
1438 * For all ports
1439 * turn on power
1440 * wait for power to become stable
1441 * (all below happens in explore code)
1442 * For all ports
1443 * clear C_PORT_CONNECTION
1444 * For all ports
1445 * get port status
1446 * if device connected
1447 * wait 100 ms
1448 * turn on reset
1449 * wait
1450 * clear C_PORT_RESET
1451 * get port status
1452 * proceed with device attachment
1453 */
1454
1455 /* XXX should check for none, individual, or ganged power? */
1456
1457 removable = 0;
1458
1459 for (x = 0; x != nports; x++) {
1460 /* set up data structures */
1461 struct usb_port *up = hub->ports + x;
1462
1463 up->device_index = 0;
1464 up->restartcnt = 0;
1465 portno = x + 1;
1466
1467 /* check if port is removable */
1468 switch (udev->speed) {
1469 case USB_SPEED_LOW:
1470 case USB_SPEED_FULL:
1471 case USB_SPEED_HIGH:
1472 if (!UHD_NOT_REMOV(&hubdesc20, portno))
1473 removable++;
1474 break;
1475 case USB_SPEED_SUPER:
1476 if (!UHD_NOT_REMOV(&hubdesc30, portno))
1477 removable++;
1478 break;
1479 default:
1480 DPRINTF("Assuming removable port\n");
1481 removable++;
1482 break;
1483 }
1484 if (err == 0) {
1485 #if USB_HAVE_DISABLE_ENUM
1486 /* check if we should disable USB port power or not */
1487 if (usb_disable_port_power != 0 ||
1488 sc->sc_disable_port_power != 0) {
1489 /* turn the power off */
1490 DPRINTFN(2, "Turning port %d power off\n", portno);
1491 err = usbd_req_clear_port_feature(udev, NULL,
1492 portno, UHF_PORT_POWER);
1493 } else {
1494 #endif
1495 /* turn the power on */
1496 DPRINTFN(2, "Turning port %d power on\n", portno);
1497 err = usbd_req_set_port_feature(udev, NULL,
1498 portno, UHF_PORT_POWER);
1499 #if USB_HAVE_DISABLE_ENUM
1500 }
1501 #endif
1502 }
1503 if (err != 0) {
1504 DPRINTFN(0, "port %d power on or off failed, %s\n",
1505 portno, usbd_errstr(err));
1506 }
1507 DPRINTF("turn on port %d power\n",
1508 portno);
1509
1510 /* wait for stable power */
1511 usb_pause_mtx(NULL, USB_MS_TO_TICKS(pwrdly));
1512 }
1513
1514 device_printf(dev, "%d port%s with %d "
1515 "removable, %s powered\n", nports, (nports != 1) ? "s" : "",
1516 removable, udev->flags.self_powered ? "self" : "bus");
1517
1518 /* Start the interrupt endpoint, if any */
1519
1520 USB_MTX_LOCK(&sc->sc_mtx);
1521 usbd_transfer_start(sc->sc_xfer[UHUB_INTR_TRANSFER]);
1522 USB_MTX_UNLOCK(&sc->sc_mtx);
1523
1524 /* Enable automatic power save on all USB HUBs */
1525
1526 usbd_set_power_mode(udev, USB_POWER_MODE_SAVE);
1527
1528 return (0);
1529
1530 error:
1531 usbd_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER);
1532
1533 #if (USB_HAVE_FIXED_PORT == 0)
1534 free(udev->hub, M_USBDEV);
1535 #endif
1536 udev->hub = NULL;
1537
1538 mtx_destroy(&sc->sc_mtx);
1539
1540 return (ENXIO);
1541 }
1542
1543 /*
1544 * Called from process context when the hub is gone.
1545 * Detach all devices on active ports.
1546 */
1547 int
uhub_detach(device_t dev)1548 uhub_detach(device_t dev)
1549 {
1550 struct uhub_softc *sc = device_get_softc(dev);
1551 struct usb_hub *hub = sc->sc_udev->hub;
1552 struct usb_bus *bus = sc->sc_udev->bus;
1553 struct usb_device *child;
1554 uint8_t x;
1555
1556 if (hub == NULL) /* must be partially working */
1557 return (0);
1558
1559 /* Make sure interrupt transfer is gone. */
1560 usbd_transfer_unsetup(sc->sc_xfer, UHUB_N_TRANSFER);
1561
1562 /* Detach all ports */
1563 for (x = 0; x != hub->nports; x++) {
1564 child = usb_bus_port_get_device(bus, hub->ports + x);
1565
1566 if (child == NULL) {
1567 continue;
1568 }
1569
1570 /*
1571 * Free USB device and all subdevices, if any.
1572 */
1573 usb_free_device(child, 0);
1574 }
1575
1576 #if USB_HAVE_TT_SUPPORT
1577 /* Make sure our TT messages are not queued anywhere */
1578 USB_BUS_LOCK(bus);
1579 usb_proc_mwait(USB_BUS_TT_PROC(bus),
1580 &hub->tt_msg[0], &hub->tt_msg[1]);
1581 USB_BUS_UNLOCK(bus);
1582 #endif
1583
1584 #if (USB_HAVE_FIXED_PORT == 0)
1585 free(hub, M_USBDEV);
1586 #endif
1587 sc->sc_udev->hub = NULL;
1588
1589 mtx_destroy(&sc->sc_mtx);
1590
1591 return (0);
1592 }
1593
1594 static int
uhub_suspend(device_t dev)1595 uhub_suspend(device_t dev)
1596 {
1597 DPRINTF("\n");
1598 /* Sub-devices are not suspended here! */
1599 return (0);
1600 }
1601
1602 static int
uhub_resume(device_t dev)1603 uhub_resume(device_t dev)
1604 {
1605 DPRINTF("\n");
1606 /* Sub-devices are not resumed here! */
1607 return (0);
1608 }
1609
1610 static void
uhub_driver_added(device_t dev,driver_t * driver)1611 uhub_driver_added(device_t dev, driver_t *driver)
1612 {
1613 usb_needs_explore_all();
1614 }
1615
1616 void
uhub_find_iface_index(struct usb_hub * hub,device_t child,struct hub_result * res)1617 uhub_find_iface_index(struct usb_hub *hub, device_t child,
1618 struct hub_result *res)
1619 {
1620 struct usb_interface *iface;
1621 struct usb_device *udev;
1622 uint8_t nports;
1623 uint8_t x;
1624 uint8_t i;
1625
1626 nports = hub->nports;
1627 for (x = 0; x != nports; x++) {
1628 udev = usb_bus_port_get_device(hub->hubudev->bus,
1629 hub->ports + x);
1630 if (!udev) {
1631 continue;
1632 }
1633 for (i = 0; i != USB_IFACE_MAX; i++) {
1634 iface = usbd_get_iface(udev, i);
1635 if (iface &&
1636 (iface->subdev == child)) {
1637 res->iface_index = i;
1638 res->udev = udev;
1639 res->portno = x + 1;
1640 return;
1641 }
1642 }
1643 }
1644 res->iface_index = 0;
1645 res->udev = NULL;
1646 res->portno = 0;
1647 }
1648
1649 int
uhub_child_location_string(device_t parent,device_t child,char * buf,size_t buflen)1650 uhub_child_location_string(device_t parent, device_t child,
1651 char *buf, size_t buflen)
1652 {
1653 struct uhub_softc *sc;
1654 struct usb_hub *hub;
1655 struct hub_result res;
1656
1657 if (!device_is_attached(parent)) {
1658 if (buflen)
1659 buf[0] = 0;
1660 return (0);
1661 }
1662
1663 sc = device_get_softc(parent);
1664 hub = sc->sc_udev->hub;
1665
1666 mtx_lock(&Giant);
1667 uhub_find_iface_index(hub, child, &res);
1668 if (!res.udev) {
1669 DPRINTF("device not on hub\n");
1670 if (buflen) {
1671 buf[0] = '\0';
1672 }
1673 goto done;
1674 }
1675 snprintf(buf, buflen, "bus=%u hubaddr=%u port=%u devaddr=%u"
1676 " interface=%u"
1677 #if USB_HAVE_UGEN
1678 " ugen=%s"
1679 #endif
1680 , device_get_unit(res.udev->bus->bdev)
1681 , (res.udev->parent_hub != NULL) ?
1682 res.udev->parent_hub->device_index : 0
1683 , res.portno, res.udev->device_index, res.iface_index
1684 #if USB_HAVE_UGEN
1685 , res.udev->ugen_name
1686 #endif
1687 );
1688 done:
1689 mtx_unlock(&Giant);
1690
1691 return (0);
1692 }
1693
1694 static int
uhub_child_pnpinfo_string(device_t parent,device_t child,char * buf,size_t buflen)1695 uhub_child_pnpinfo_string(device_t parent, device_t child,
1696 char *buf, size_t buflen)
1697 {
1698 struct uhub_softc *sc;
1699 struct usb_hub *hub;
1700 struct usb_interface *iface;
1701 struct hub_result res;
1702 uint8_t do_unlock;
1703
1704 if (!device_is_attached(parent)) {
1705 if (buflen)
1706 buf[0] = 0;
1707 return (0);
1708 }
1709
1710 sc = device_get_softc(parent);
1711 hub = sc->sc_udev->hub;
1712
1713 mtx_lock(&Giant);
1714 uhub_find_iface_index(hub, child, &res);
1715 if (!res.udev) {
1716 DPRINTF("device not on hub\n");
1717 if (buflen) {
1718 buf[0] = '\0';
1719 }
1720 goto done;
1721 }
1722 iface = usbd_get_iface(res.udev, res.iface_index);
1723 if (iface && iface->idesc) {
1724 /* Make sure device information is not changed during the print. */
1725 do_unlock = usbd_ctrl_lock(res.udev);
1726
1727 snprintf(buf, buflen, "vendor=0x%04x product=0x%04x "
1728 "devclass=0x%02x devsubclass=0x%02x "
1729 "devproto=0x%02x "
1730 "sernum=\"%s\" "
1731 "release=0x%04x "
1732 "mode=%s "
1733 "intclass=0x%02x intsubclass=0x%02x "
1734 "intprotocol=0x%02x" "%s%s",
1735 UGETW(res.udev->ddesc.idVendor),
1736 UGETW(res.udev->ddesc.idProduct),
1737 res.udev->ddesc.bDeviceClass,
1738 res.udev->ddesc.bDeviceSubClass,
1739 res.udev->ddesc.bDeviceProtocol,
1740 usb_get_serial(res.udev),
1741 UGETW(res.udev->ddesc.bcdDevice),
1742 (res.udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
1743 iface->idesc->bInterfaceClass,
1744 iface->idesc->bInterfaceSubClass,
1745 iface->idesc->bInterfaceProtocol,
1746 iface->pnpinfo ? " " : "",
1747 iface->pnpinfo ? iface->pnpinfo : "");
1748
1749 if (do_unlock)
1750 usbd_ctrl_unlock(res.udev);
1751 } else {
1752 if (buflen) {
1753 buf[0] = '\0';
1754 }
1755 goto done;
1756 }
1757 done:
1758 mtx_unlock(&Giant);
1759
1760 return (0);
1761 }
1762
1763 /*
1764 * The USB Transaction Translator:
1765 * ===============================
1766 *
1767 * When doing LOW- and FULL-speed USB transfers across a HIGH-speed
1768 * USB HUB, bandwidth must be allocated for ISOCHRONOUS and INTERRUPT
1769 * USB transfers. To utilize bandwidth dynamically the "scatter and
1770 * gather" principle must be applied. This means that bandwidth must
1771 * be divided into equal parts of bandwidth. With regard to USB all
1772 * data is transferred in smaller packets with length
1773 * "wMaxPacketSize". The problem however is that "wMaxPacketSize" is
1774 * not a constant!
1775 *
1776 * The bandwidth scheduler which I have implemented will simply pack
1777 * the USB transfers back to back until there is no more space in the
1778 * schedule. Out of the 8 microframes which the USB 2.0 standard
1779 * provides, only 6 are available for non-HIGH-speed devices. I have
1780 * reserved the first 4 microframes for ISOCHRONOUS transfers. The
1781 * last 2 microframes I have reserved for INTERRUPT transfers. Without
1782 * this division, it is very difficult to allocate and free bandwidth
1783 * dynamically.
1784 *
1785 * NOTE about the Transaction Translator in USB HUBs:
1786 *
1787 * USB HUBs have a very simple Transaction Translator, that will
1788 * simply pipeline all the SPLIT transactions. That means that the
1789 * transactions will be executed in the order they are queued!
1790 *
1791 */
1792
1793 /*------------------------------------------------------------------------*
1794 * usb_intr_find_best_slot
1795 *
1796 * Return value:
1797 * The best Transaction Translation slot for an interrupt endpoint.
1798 *------------------------------------------------------------------------*/
1799 static uint8_t
usb_intr_find_best_slot(usb_size_t * ptr,uint8_t start,uint8_t end,uint8_t mask)1800 usb_intr_find_best_slot(usb_size_t *ptr, uint8_t start,
1801 uint8_t end, uint8_t mask)
1802 {
1803 usb_size_t min = (usb_size_t)-1;
1804 usb_size_t sum;
1805 uint8_t x;
1806 uint8_t y;
1807 uint8_t z;
1808
1809 y = 0;
1810
1811 /* find the last slot with lesser used bandwidth */
1812
1813 for (x = start; x < end; x++) {
1814 sum = 0;
1815
1816 /* compute sum of bandwidth */
1817 for (z = x; z < end; z++) {
1818 if (mask & (1U << (z - x)))
1819 sum += ptr[z];
1820 }
1821
1822 /* check if the current multi-slot is more optimal */
1823 if (min >= sum) {
1824 min = sum;
1825 y = x;
1826 }
1827
1828 /* check if the mask is about to be shifted out */
1829 if (mask & (1U << (end - 1 - x)))
1830 break;
1831 }
1832 return (y);
1833 }
1834
1835 /*------------------------------------------------------------------------*
1836 * usb_hs_bandwidth_adjust
1837 *
1838 * This function will update the bandwidth usage for the microframe
1839 * having index "slot" by "len" bytes. "len" can be negative. If the
1840 * "slot" argument is greater or equal to "USB_HS_MICRO_FRAMES_MAX"
1841 * the "slot" argument will be replaced by the slot having least used
1842 * bandwidth. The "mask" argument is used for multi-slot allocations.
1843 *
1844 * Returns:
1845 * The slot in which the bandwidth update was done: 0..7
1846 *------------------------------------------------------------------------*/
1847 static uint8_t
usb_hs_bandwidth_adjust(struct usb_device * udev,int16_t len,uint8_t slot,uint8_t mask)1848 usb_hs_bandwidth_adjust(struct usb_device *udev, int16_t len,
1849 uint8_t slot, uint8_t mask)
1850 {
1851 struct usb_bus *bus = udev->bus;
1852 struct usb_hub *hub;
1853 enum usb_dev_speed speed;
1854 uint8_t x;
1855
1856 USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
1857
1858 speed = usbd_get_speed(udev);
1859
1860 switch (speed) {
1861 case USB_SPEED_LOW:
1862 case USB_SPEED_FULL:
1863 if (speed == USB_SPEED_LOW) {
1864 len *= 8;
1865 }
1866 /*
1867 * The Host Controller Driver should have
1868 * performed checks so that the lookup
1869 * below does not result in a NULL pointer
1870 * access.
1871 */
1872
1873 hub = udev->parent_hs_hub->hub;
1874 if (slot >= USB_HS_MICRO_FRAMES_MAX) {
1875 slot = usb_intr_find_best_slot(hub->uframe_usage,
1876 USB_FS_ISOC_UFRAME_MAX, 6, mask);
1877 }
1878 for (x = slot; x < 8; x++) {
1879 if (mask & (1U << (x - slot))) {
1880 hub->uframe_usage[x] += len;
1881 bus->uframe_usage[x] += len;
1882 }
1883 }
1884 break;
1885 default:
1886 if (slot >= USB_HS_MICRO_FRAMES_MAX) {
1887 slot = usb_intr_find_best_slot(bus->uframe_usage, 0,
1888 USB_HS_MICRO_FRAMES_MAX, mask);
1889 }
1890 for (x = slot; x < 8; x++) {
1891 if (mask & (1U << (x - slot))) {
1892 bus->uframe_usage[x] += len;
1893 }
1894 }
1895 break;
1896 }
1897 return (slot);
1898 }
1899
1900 /*------------------------------------------------------------------------*
1901 * usb_hs_bandwidth_alloc
1902 *
1903 * This function is a wrapper function for "usb_hs_bandwidth_adjust()".
1904 *------------------------------------------------------------------------*/
1905 void
usb_hs_bandwidth_alloc(struct usb_xfer * xfer)1906 usb_hs_bandwidth_alloc(struct usb_xfer *xfer)
1907 {
1908 struct usb_device *udev;
1909 uint8_t slot;
1910 uint8_t mask;
1911 uint8_t speed;
1912
1913 udev = xfer->xroot->udev;
1914
1915 if (udev->flags.usb_mode != USB_MODE_HOST)
1916 return; /* not supported */
1917
1918 xfer->endpoint->refcount_bw++;
1919 if (xfer->endpoint->refcount_bw != 1)
1920 return; /* already allocated */
1921
1922 speed = usbd_get_speed(udev);
1923
1924 switch (xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE) {
1925 case UE_INTERRUPT:
1926 /* allocate a microframe slot */
1927
1928 mask = 0x01;
1929 slot = usb_hs_bandwidth_adjust(udev,
1930 xfer->max_frame_size, USB_HS_MICRO_FRAMES_MAX, mask);
1931
1932 xfer->endpoint->usb_uframe = slot;
1933 xfer->endpoint->usb_smask = mask << slot;
1934
1935 if ((speed != USB_SPEED_FULL) &&
1936 (speed != USB_SPEED_LOW)) {
1937 xfer->endpoint->usb_cmask = 0x00 ;
1938 } else {
1939 xfer->endpoint->usb_cmask = (-(0x04 << slot)) & 0xFE;
1940 }
1941 break;
1942
1943 case UE_ISOCHRONOUS:
1944 switch (usbd_xfer_get_fps_shift(xfer)) {
1945 case 0:
1946 mask = 0xFF;
1947 break;
1948 case 1:
1949 mask = 0x55;
1950 break;
1951 case 2:
1952 mask = 0x11;
1953 break;
1954 default:
1955 mask = 0x01;
1956 break;
1957 }
1958
1959 /* allocate a microframe multi-slot */
1960
1961 slot = usb_hs_bandwidth_adjust(udev,
1962 xfer->max_frame_size, USB_HS_MICRO_FRAMES_MAX, mask);
1963
1964 xfer->endpoint->usb_uframe = slot;
1965 xfer->endpoint->usb_cmask = 0;
1966 xfer->endpoint->usb_smask = mask << slot;
1967 break;
1968
1969 default:
1970 xfer->endpoint->usb_uframe = 0;
1971 xfer->endpoint->usb_cmask = 0;
1972 xfer->endpoint->usb_smask = 0;
1973 break;
1974 }
1975
1976 DPRINTFN(11, "slot=%d, mask=0x%02x\n",
1977 xfer->endpoint->usb_uframe,
1978 xfer->endpoint->usb_smask >> xfer->endpoint->usb_uframe);
1979 }
1980
1981 /*------------------------------------------------------------------------*
1982 * usb_hs_bandwidth_free
1983 *
1984 * This function is a wrapper function for "usb_hs_bandwidth_adjust()".
1985 *------------------------------------------------------------------------*/
1986 void
usb_hs_bandwidth_free(struct usb_xfer * xfer)1987 usb_hs_bandwidth_free(struct usb_xfer *xfer)
1988 {
1989 struct usb_device *udev;
1990 uint8_t slot;
1991 uint8_t mask;
1992
1993 udev = xfer->xroot->udev;
1994
1995 if (udev->flags.usb_mode != USB_MODE_HOST)
1996 return; /* not supported */
1997
1998 xfer->endpoint->refcount_bw--;
1999 if (xfer->endpoint->refcount_bw != 0)
2000 return; /* still allocated */
2001
2002 switch (xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE) {
2003 case UE_INTERRUPT:
2004 case UE_ISOCHRONOUS:
2005
2006 slot = xfer->endpoint->usb_uframe;
2007 mask = xfer->endpoint->usb_smask;
2008
2009 /* free microframe slot(s): */
2010 usb_hs_bandwidth_adjust(udev,
2011 -xfer->max_frame_size, slot, mask >> slot);
2012
2013 DPRINTFN(11, "slot=%d, mask=0x%02x\n",
2014 slot, mask >> slot);
2015
2016 xfer->endpoint->usb_uframe = 0;
2017 xfer->endpoint->usb_cmask = 0;
2018 xfer->endpoint->usb_smask = 0;
2019 break;
2020
2021 default:
2022 break;
2023 }
2024 }
2025
2026 /*------------------------------------------------------------------------*
2027 * usb_isoc_time_expand
2028 *
2029 * This function will expand the time counter from 7-bit to 16-bit.
2030 *
2031 * Returns:
2032 * 16-bit isochronous time counter.
2033 *------------------------------------------------------------------------*/
2034 uint16_t
usb_isoc_time_expand(struct usb_bus * bus,uint16_t isoc_time_curr)2035 usb_isoc_time_expand(struct usb_bus *bus, uint16_t isoc_time_curr)
2036 {
2037 uint16_t rem;
2038
2039 USB_BUS_LOCK_ASSERT(bus, MA_OWNED);
2040
2041 rem = bus->isoc_time_last & (USB_ISOC_TIME_MAX - 1);
2042
2043 isoc_time_curr &= (USB_ISOC_TIME_MAX - 1);
2044
2045 if (isoc_time_curr < rem) {
2046 /* the time counter wrapped around */
2047 bus->isoc_time_last += USB_ISOC_TIME_MAX;
2048 }
2049 /* update the remainder */
2050
2051 bus->isoc_time_last &= ~(USB_ISOC_TIME_MAX - 1);
2052 bus->isoc_time_last |= isoc_time_curr;
2053
2054 return (bus->isoc_time_last);
2055 }
2056
2057 /*------------------------------------------------------------------------*
2058 * usbd_fs_isoc_schedule_alloc_slot
2059 *
2060 * This function will allocate bandwidth for an isochronous FULL speed
2061 * transaction in the FULL speed schedule.
2062 *
2063 * Returns:
2064 * <8: Success
2065 * Else: Error
2066 *------------------------------------------------------------------------*/
2067 #if USB_HAVE_TT_SUPPORT
2068 uint8_t
usbd_fs_isoc_schedule_alloc_slot(struct usb_xfer * isoc_xfer,uint16_t isoc_time)2069 usbd_fs_isoc_schedule_alloc_slot(struct usb_xfer *isoc_xfer, uint16_t isoc_time)
2070 {
2071 struct usb_xfer *xfer;
2072 struct usb_xfer *pipe_xfer;
2073 struct usb_bus *bus;
2074 usb_frlength_t len;
2075 usb_frlength_t data_len;
2076 uint16_t delta;
2077 uint16_t slot;
2078 uint8_t retval;
2079
2080 data_len = 0;
2081 slot = 0;
2082
2083 bus = isoc_xfer->xroot->bus;
2084
2085 TAILQ_FOREACH(xfer, &bus->intr_q.head, wait_entry) {
2086 /* skip self, if any */
2087
2088 if (xfer == isoc_xfer)
2089 continue;
2090
2091 /* check if this USB transfer is going through the same TT */
2092
2093 if (xfer->xroot->udev->parent_hs_hub !=
2094 isoc_xfer->xroot->udev->parent_hs_hub) {
2095 continue;
2096 }
2097 if ((isoc_xfer->xroot->udev->parent_hs_hub->
2098 ddesc.bDeviceProtocol == UDPROTO_HSHUBMTT) &&
2099 (xfer->xroot->udev->hs_port_no !=
2100 isoc_xfer->xroot->udev->hs_port_no)) {
2101 continue;
2102 }
2103 if (xfer->endpoint->methods != isoc_xfer->endpoint->methods)
2104 continue;
2105
2106 /* check if isoc_time is part of this transfer */
2107
2108 delta = xfer->isoc_time_complete - isoc_time;
2109 if (delta > 0 && delta <= xfer->nframes) {
2110 delta = xfer->nframes - delta;
2111
2112 len = xfer->frlengths[delta];
2113 len += 8;
2114 len *= 7;
2115 len /= 6;
2116
2117 data_len += len;
2118 }
2119
2120 /*
2121 * Check double buffered transfers. Only stream ID
2122 * equal to zero is valid here!
2123 */
2124 TAILQ_FOREACH(pipe_xfer, &xfer->endpoint->endpoint_q[0].head,
2125 wait_entry) {
2126 /* skip self, if any */
2127
2128 if (pipe_xfer == isoc_xfer)
2129 continue;
2130
2131 /* check if isoc_time is part of this transfer */
2132
2133 delta = pipe_xfer->isoc_time_complete - isoc_time;
2134 if (delta > 0 && delta <= pipe_xfer->nframes) {
2135 delta = pipe_xfer->nframes - delta;
2136
2137 len = pipe_xfer->frlengths[delta];
2138 len += 8;
2139 len *= 7;
2140 len /= 6;
2141
2142 data_len += len;
2143 }
2144 }
2145 }
2146
2147 while (data_len >= USB_FS_BYTES_PER_HS_UFRAME) {
2148 data_len -= USB_FS_BYTES_PER_HS_UFRAME;
2149 slot++;
2150 }
2151
2152 /* check for overflow */
2153
2154 if (slot >= USB_FS_ISOC_UFRAME_MAX)
2155 return (255);
2156
2157 retval = slot;
2158
2159 delta = isoc_xfer->isoc_time_complete - isoc_time;
2160 if (delta > 0 && delta <= isoc_xfer->nframes) {
2161 delta = isoc_xfer->nframes - delta;
2162
2163 len = isoc_xfer->frlengths[delta];
2164 len += 8;
2165 len *= 7;
2166 len /= 6;
2167
2168 data_len += len;
2169 }
2170
2171 while (data_len >= USB_FS_BYTES_PER_HS_UFRAME) {
2172 data_len -= USB_FS_BYTES_PER_HS_UFRAME;
2173 slot++;
2174 }
2175
2176 /* check for overflow */
2177
2178 if (slot >= USB_FS_ISOC_UFRAME_MAX)
2179 return (255);
2180
2181 return (retval);
2182 }
2183 #endif
2184
2185 /*------------------------------------------------------------------------*
2186 * usb_bus_port_get_device
2187 *
2188 * This function is NULL safe.
2189 *------------------------------------------------------------------------*/
2190 struct usb_device *
usb_bus_port_get_device(struct usb_bus * bus,struct usb_port * up)2191 usb_bus_port_get_device(struct usb_bus *bus, struct usb_port *up)
2192 {
2193 if ((bus == NULL) || (up == NULL)) {
2194 /* be NULL safe */
2195 return (NULL);
2196 }
2197 if (up->device_index == 0) {
2198 /* nothing to do */
2199 return (NULL);
2200 }
2201 return (bus->devices[up->device_index]);
2202 }
2203
2204 /*------------------------------------------------------------------------*
2205 * usb_bus_port_set_device
2206 *
2207 * This function is NULL safe.
2208 *------------------------------------------------------------------------*/
2209 void
usb_bus_port_set_device(struct usb_bus * bus,struct usb_port * up,struct usb_device * udev,uint8_t device_index)2210 usb_bus_port_set_device(struct usb_bus *bus, struct usb_port *up,
2211 struct usb_device *udev, uint8_t device_index)
2212 {
2213 if (bus == NULL) {
2214 /* be NULL safe */
2215 return;
2216 }
2217 /*
2218 * There is only one case where we don't
2219 * have an USB port, and that is the Root Hub!
2220 */
2221 if (up) {
2222 if (udev) {
2223 up->device_index = device_index;
2224 } else {
2225 device_index = up->device_index;
2226 up->device_index = 0;
2227 }
2228 }
2229 /*
2230 * Make relationships to our new device
2231 */
2232 if (device_index != 0) {
2233 #if USB_HAVE_UGEN
2234 mtx_lock(&usb_ref_lock);
2235 #endif
2236 bus->devices[device_index] = udev;
2237 #if USB_HAVE_UGEN
2238 mtx_unlock(&usb_ref_lock);
2239 #endif
2240 }
2241 /*
2242 * Debug print
2243 */
2244 DPRINTFN(2, "bus %p devices[%u] = %p\n", bus, device_index, udev);
2245 }
2246
2247 /*------------------------------------------------------------------------*
2248 * usb_needs_explore
2249 *
2250 * This functions is called when the USB event thread needs to run.
2251 *------------------------------------------------------------------------*/
2252 void
usb_needs_explore(struct usb_bus * bus,uint8_t do_probe)2253 usb_needs_explore(struct usb_bus *bus, uint8_t do_probe)
2254 {
2255 uint8_t do_unlock;
2256
2257 DPRINTF("\n");
2258
2259 if (cold != 0) {
2260 DPRINTF("Cold\n");
2261 return;
2262 }
2263
2264 if (bus == NULL) {
2265 DPRINTF("No bus pointer!\n");
2266 return;
2267 }
2268 if ((bus->devices == NULL) ||
2269 (bus->devices[USB_ROOT_HUB_ADDR] == NULL)) {
2270 DPRINTF("No root HUB\n");
2271 return;
2272 }
2273 if (mtx_owned(&bus->bus_mtx)) {
2274 do_unlock = 0;
2275 } else {
2276 USB_BUS_LOCK(bus);
2277 do_unlock = 1;
2278 }
2279 if (do_probe) {
2280 bus->do_probe = 1;
2281 }
2282 if (usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus),
2283 &bus->explore_msg[0], &bus->explore_msg[1])) {
2284 /* ignore */
2285 }
2286 if (do_unlock) {
2287 USB_BUS_UNLOCK(bus);
2288 }
2289 }
2290
2291 /*------------------------------------------------------------------------*
2292 * usb_needs_explore_all
2293 *
2294 * This function is called whenever a new driver is loaded and will
2295 * cause that all USB buses are re-explored.
2296 *------------------------------------------------------------------------*/
2297 void
usb_needs_explore_all(void)2298 usb_needs_explore_all(void)
2299 {
2300 struct usb_bus *bus;
2301 devclass_t dc;
2302 device_t dev;
2303 int max;
2304
2305 DPRINTFN(3, "\n");
2306
2307 dc = usb_devclass_ptr;
2308 if (dc == NULL) {
2309 DPRINTFN(0, "no devclass\n");
2310 return;
2311 }
2312 /*
2313 * Explore all USB buses in parallel.
2314 */
2315 max = devclass_get_maxunit(dc);
2316 while (max >= 0) {
2317 dev = devclass_get_device(dc, max);
2318 if (dev) {
2319 bus = device_get_softc(dev);
2320 if (bus) {
2321 usb_needs_explore(bus, 1);
2322 }
2323 }
2324 max--;
2325 }
2326 }
2327
2328 /*------------------------------------------------------------------------*
2329 * usb_needs_explore_init
2330 *
2331 * This function will ensure that the USB controllers are not enumerated
2332 * until the "cold" variable is cleared.
2333 *------------------------------------------------------------------------*/
2334 static void
usb_needs_explore_init(void * arg)2335 usb_needs_explore_init(void *arg)
2336 {
2337 /*
2338 * The cold variable should be cleared prior to this function
2339 * being called:
2340 */
2341 if (cold == 0)
2342 usb_needs_explore_all();
2343 else
2344 DPRINTFN(-1, "Cold variable is still set!\n");
2345 }
2346 SYSINIT(usb_needs_explore_init, SI_SUB_KICK_SCHEDULER, SI_ORDER_SECOND, usb_needs_explore_init, NULL);
2347
2348 /*------------------------------------------------------------------------*
2349 * usb_bus_power_update
2350 *
2351 * This function will ensure that all USB devices on the given bus are
2352 * properly suspended or resumed according to the device transfer
2353 * state.
2354 *------------------------------------------------------------------------*/
2355 #if USB_HAVE_POWERD
2356 void
usb_bus_power_update(struct usb_bus * bus)2357 usb_bus_power_update(struct usb_bus *bus)
2358 {
2359 usb_needs_explore(bus, 0 /* no probe */ );
2360 }
2361 #endif
2362
2363 /*------------------------------------------------------------------------*
2364 * usbd_transfer_power_ref
2365 *
2366 * This function will modify the power save reference counts and
2367 * wakeup the USB device associated with the given USB transfer, if
2368 * needed.
2369 *------------------------------------------------------------------------*/
2370 #if USB_HAVE_POWERD
2371 void
usbd_transfer_power_ref(struct usb_xfer * xfer,int val)2372 usbd_transfer_power_ref(struct usb_xfer *xfer, int val)
2373 {
2374 static const usb_power_mask_t power_mask[4] = {
2375 [UE_CONTROL] = USB_HW_POWER_CONTROL,
2376 [UE_BULK] = USB_HW_POWER_BULK,
2377 [UE_INTERRUPT] = USB_HW_POWER_INTERRUPT,
2378 [UE_ISOCHRONOUS] = USB_HW_POWER_ISOC,
2379 };
2380 struct usb_device *udev;
2381 uint8_t needs_explore;
2382 uint8_t needs_hw_power;
2383 uint8_t xfer_type;
2384
2385 udev = xfer->xroot->udev;
2386
2387 if (udev->device_index == USB_ROOT_HUB_ADDR) {
2388 /* no power save for root HUB */
2389 return;
2390 }
2391 USB_BUS_LOCK(udev->bus);
2392
2393 xfer_type = xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE;
2394
2395 udev->pwr_save.last_xfer_time = ticks;
2396 udev->pwr_save.type_refs[xfer_type] += val;
2397
2398 if (xfer->flags_int.control_xfr) {
2399 udev->pwr_save.read_refs += val;
2400 if (xfer->flags_int.usb_mode == USB_MODE_HOST) {
2401 /*
2402 * It is not allowed to suspend during a
2403 * control transfer:
2404 */
2405 udev->pwr_save.write_refs += val;
2406 }
2407 } else if (USB_GET_DATA_ISREAD(xfer)) {
2408 udev->pwr_save.read_refs += val;
2409 } else {
2410 udev->pwr_save.write_refs += val;
2411 }
2412
2413 if (val > 0) {
2414 if (udev->flags.self_suspended)
2415 needs_explore = usb_peer_should_wakeup(udev);
2416 else
2417 needs_explore = 0;
2418
2419 if (!(udev->bus->hw_power_state & power_mask[xfer_type])) {
2420 DPRINTF("Adding type %u to power state\n", xfer_type);
2421 udev->bus->hw_power_state |= power_mask[xfer_type];
2422 needs_hw_power = 1;
2423 } else {
2424 needs_hw_power = 0;
2425 }
2426 } else {
2427 needs_explore = 0;
2428 needs_hw_power = 0;
2429 }
2430
2431 USB_BUS_UNLOCK(udev->bus);
2432
2433 if (needs_explore) {
2434 DPRINTF("update\n");
2435 usb_bus_power_update(udev->bus);
2436 } else if (needs_hw_power) {
2437 DPRINTF("needs power\n");
2438 if (udev->bus->methods->set_hw_power != NULL) {
2439 (udev->bus->methods->set_hw_power) (udev->bus);
2440 }
2441 }
2442 }
2443 #endif
2444
2445 /*------------------------------------------------------------------------*
2446 * usb_peer_should_wakeup
2447 *
2448 * This function returns non-zero if the current device should wake up.
2449 *------------------------------------------------------------------------*/
2450 static uint8_t
usb_peer_should_wakeup(struct usb_device * udev)2451 usb_peer_should_wakeup(struct usb_device *udev)
2452 {
2453 return (((udev->power_mode == USB_POWER_MODE_ON) &&
2454 (udev->flags.usb_mode == USB_MODE_HOST)) ||
2455 (udev->driver_added_refcount != udev->bus->driver_added_refcount) ||
2456 (udev->re_enumerate_wait != USB_RE_ENUM_DONE) ||
2457 (udev->pwr_save.type_refs[UE_ISOCHRONOUS] != 0) ||
2458 (udev->pwr_save.write_refs != 0) ||
2459 ((udev->pwr_save.read_refs != 0) &&
2460 (udev->flags.usb_mode == USB_MODE_HOST) &&
2461 (usb_peer_can_wakeup(udev) == 0)));
2462 }
2463
2464 /*------------------------------------------------------------------------*
2465 * usb_bus_powerd
2466 *
2467 * This function implements the USB power daemon and is called
2468 * regularly from the USB explore thread.
2469 *------------------------------------------------------------------------*/
2470 #if USB_HAVE_POWERD
2471 void
usb_bus_powerd(struct usb_bus * bus)2472 usb_bus_powerd(struct usb_bus *bus)
2473 {
2474 struct usb_device *udev;
2475 usb_ticks_t temp;
2476 usb_ticks_t limit;
2477 usb_ticks_t mintime;
2478 usb_size_t type_refs[5];
2479 uint8_t x;
2480
2481 limit = usb_power_timeout;
2482 if (limit == 0)
2483 limit = hz;
2484 else if (limit > 255)
2485 limit = 255 * hz;
2486 else
2487 limit = limit * hz;
2488
2489 DPRINTF("bus=%p\n", bus);
2490
2491 USB_BUS_LOCK(bus);
2492
2493 /*
2494 * The root HUB device is never suspended
2495 * and we simply skip it.
2496 */
2497 for (x = USB_ROOT_HUB_ADDR + 1;
2498 x != bus->devices_max; x++) {
2499 udev = bus->devices[x];
2500 if (udev == NULL)
2501 continue;
2502
2503 temp = ticks - udev->pwr_save.last_xfer_time;
2504
2505 if (usb_peer_should_wakeup(udev)) {
2506 /* check if we are suspended */
2507 if (udev->flags.self_suspended != 0) {
2508 USB_BUS_UNLOCK(bus);
2509 usb_dev_resume_peer(udev);
2510 USB_BUS_LOCK(bus);
2511 }
2512 } else if ((temp >= limit) &&
2513 (udev->flags.usb_mode == USB_MODE_HOST) &&
2514 (udev->flags.self_suspended == 0)) {
2515 /* try to do suspend */
2516
2517 USB_BUS_UNLOCK(bus);
2518 usb_dev_suspend_peer(udev);
2519 USB_BUS_LOCK(bus);
2520 }
2521 }
2522
2523 /* reset counters */
2524
2525 mintime = (usb_ticks_t)-1;
2526 type_refs[0] = 0;
2527 type_refs[1] = 0;
2528 type_refs[2] = 0;
2529 type_refs[3] = 0;
2530 type_refs[4] = 0;
2531
2532 /* Re-loop all the devices to get the actual state */
2533
2534 for (x = USB_ROOT_HUB_ADDR + 1;
2535 x != bus->devices_max; x++) {
2536 udev = bus->devices[x];
2537 if (udev == NULL)
2538 continue;
2539
2540 /* we found a non-Root-Hub USB device */
2541 type_refs[4] += 1;
2542
2543 /* "last_xfer_time" can be updated by a resume */
2544 temp = ticks - udev->pwr_save.last_xfer_time;
2545
2546 /*
2547 * Compute minimum time since last transfer for the complete
2548 * bus:
2549 */
2550 if (temp < mintime)
2551 mintime = temp;
2552
2553 if (udev->flags.self_suspended == 0) {
2554 type_refs[0] += udev->pwr_save.type_refs[0];
2555 type_refs[1] += udev->pwr_save.type_refs[1];
2556 type_refs[2] += udev->pwr_save.type_refs[2];
2557 type_refs[3] += udev->pwr_save.type_refs[3];
2558 }
2559 }
2560
2561 if (mintime >= (usb_ticks_t)(1 * hz)) {
2562 /* recompute power masks */
2563 DPRINTF("Recomputing power masks\n");
2564 bus->hw_power_state = 0;
2565 if (type_refs[UE_CONTROL] != 0)
2566 bus->hw_power_state |= USB_HW_POWER_CONTROL;
2567 if (type_refs[UE_BULK] != 0)
2568 bus->hw_power_state |= USB_HW_POWER_BULK;
2569 if (type_refs[UE_INTERRUPT] != 0)
2570 bus->hw_power_state |= USB_HW_POWER_INTERRUPT;
2571 if (type_refs[UE_ISOCHRONOUS] != 0)
2572 bus->hw_power_state |= USB_HW_POWER_ISOC;
2573 if (type_refs[4] != 0)
2574 bus->hw_power_state |= USB_HW_POWER_NON_ROOT_HUB;
2575 }
2576 USB_BUS_UNLOCK(bus);
2577
2578 if (bus->methods->set_hw_power != NULL) {
2579 /* always update hardware power! */
2580 (bus->methods->set_hw_power) (bus);
2581 }
2582 return;
2583 }
2584 #endif
2585
2586 static usb_error_t
usbd_device_30_remote_wakeup(struct usb_device * udev,uint8_t bRequest)2587 usbd_device_30_remote_wakeup(struct usb_device *udev, uint8_t bRequest)
2588 {
2589 struct usb_device_request req = {};
2590
2591 req.bmRequestType = UT_WRITE_INTERFACE;
2592 req.bRequest = bRequest;
2593 USETW(req.wValue, USB_INTERFACE_FUNC_SUSPEND);
2594 USETW(req.wIndex, USB_INTERFACE_FUNC_SUSPEND_LP |
2595 USB_INTERFACE_FUNC_SUSPEND_RW);
2596
2597 return (usbd_do_request(udev, NULL, &req, 0));
2598 }
2599
2600 static usb_error_t
usbd_clear_dev_wakeup(struct usb_device * udev)2601 usbd_clear_dev_wakeup(struct usb_device *udev)
2602 {
2603 usb_error_t err;
2604
2605 if (usb_device_20_compatible(udev)) {
2606 err = usbd_req_clear_device_feature(udev,
2607 NULL, UF_DEVICE_REMOTE_WAKEUP);
2608 } else {
2609 err = usbd_device_30_remote_wakeup(udev,
2610 UR_CLEAR_FEATURE);
2611 }
2612 return (err);
2613 }
2614
2615 static usb_error_t
usbd_set_dev_wakeup(struct usb_device * udev)2616 usbd_set_dev_wakeup(struct usb_device *udev)
2617 {
2618 usb_error_t err;
2619
2620 if (usb_device_20_compatible(udev)) {
2621 err = usbd_req_set_device_feature(udev,
2622 NULL, UF_DEVICE_REMOTE_WAKEUP);
2623 } else {
2624 err = usbd_device_30_remote_wakeup(udev,
2625 UR_SET_FEATURE);
2626 }
2627 return (err);
2628 }
2629
2630 /*------------------------------------------------------------------------*
2631 * usb_dev_resume_peer
2632 *
2633 * This function will resume an USB peer and do the required USB
2634 * signalling to get an USB device out of the suspended state.
2635 *------------------------------------------------------------------------*/
2636 static void
usb_dev_resume_peer(struct usb_device * udev)2637 usb_dev_resume_peer(struct usb_device *udev)
2638 {
2639 struct usb_bus *bus;
2640 int err;
2641
2642 /* be NULL safe */
2643 if (udev == NULL)
2644 return;
2645
2646 /* check if already resumed */
2647 if (udev->flags.self_suspended == 0)
2648 return;
2649
2650 /* we need a parent HUB to do resume */
2651 if (udev->parent_hub == NULL)
2652 return;
2653
2654 DPRINTF("udev=%p\n", udev);
2655
2656 if ((udev->flags.usb_mode == USB_MODE_DEVICE) &&
2657 (udev->flags.remote_wakeup == 0)) {
2658 /*
2659 * If the host did not set the remote wakeup feature, we can
2660 * not wake it up either!
2661 */
2662 DPRINTF("remote wakeup is not set!\n");
2663 return;
2664 }
2665 /* get bus pointer */
2666 bus = udev->bus;
2667
2668 /* resume parent hub first */
2669 usb_dev_resume_peer(udev->parent_hub);
2670
2671 /* reduce chance of instant resume failure by waiting a little bit */
2672 usb_pause_mtx(NULL, USB_MS_TO_TICKS(20));
2673
2674 if (usb_device_20_compatible(udev)) {
2675 /* resume current port (Valid in Host and Device Mode) */
2676 err = usbd_req_clear_port_feature(udev->parent_hub,
2677 NULL, udev->port_no, UHF_PORT_SUSPEND);
2678 } else {
2679 /* resume current port (Valid in Host and Device Mode) */
2680 err = usbd_req_set_port_link_state(udev->parent_hub,
2681 NULL, udev->port_no, UPS_PORT_LS_U0);
2682 }
2683
2684 if (err != 0) {
2685 DPRINTFN(0, "Resuming port failed: %s (ignored)\n",
2686 usbd_errstr(err));
2687 }
2688
2689 /* resume settle time */
2690 usb_pause_mtx(NULL, USB_MS_TO_TICKS(usb_port_resume_delay));
2691
2692 if (bus->methods->device_resume != NULL) {
2693 /* resume USB device on the USB controller */
2694 (bus->methods->device_resume) (udev);
2695 }
2696 USB_BUS_LOCK(bus);
2697 /* set that this device is now resumed */
2698 udev->flags.self_suspended = 0;
2699 #if USB_HAVE_POWERD
2700 /* make sure that we don't go into suspend right away */
2701 udev->pwr_save.last_xfer_time = ticks;
2702
2703 /* make sure the needed power masks are on */
2704 if (udev->pwr_save.type_refs[UE_CONTROL] != 0)
2705 bus->hw_power_state |= USB_HW_POWER_CONTROL;
2706 if (udev->pwr_save.type_refs[UE_BULK] != 0)
2707 bus->hw_power_state |= USB_HW_POWER_BULK;
2708 if (udev->pwr_save.type_refs[UE_INTERRUPT] != 0)
2709 bus->hw_power_state |= USB_HW_POWER_INTERRUPT;
2710 if (udev->pwr_save.type_refs[UE_ISOCHRONOUS] != 0)
2711 bus->hw_power_state |= USB_HW_POWER_ISOC;
2712 #endif
2713 USB_BUS_UNLOCK(bus);
2714
2715 if (bus->methods->set_hw_power != NULL) {
2716 /* always update hardware power! */
2717 (bus->methods->set_hw_power) (bus);
2718 }
2719
2720 usbd_sr_lock(udev);
2721
2722 /* notify all sub-devices about resume */
2723 err = usb_suspend_resume(udev, 0);
2724
2725 usbd_sr_unlock(udev);
2726
2727 /* check if peer has wakeup capability */
2728 if (usb_peer_can_wakeup(udev)) {
2729 /* clear remote wakeup */
2730 err = usbd_clear_dev_wakeup(udev);
2731 if (err) {
2732 DPRINTFN(0, "Clearing device "
2733 "remote wakeup failed: %s\n",
2734 usbd_errstr(err));
2735 }
2736 }
2737 }
2738
2739 /*------------------------------------------------------------------------*
2740 * usb_dev_suspend_peer
2741 *
2742 * This function will suspend an USB peer and do the required USB
2743 * signalling to get an USB device into the suspended state.
2744 *------------------------------------------------------------------------*/
2745 static void
usb_dev_suspend_peer(struct usb_device * udev)2746 usb_dev_suspend_peer(struct usb_device *udev)
2747 {
2748 struct usb_device *child;
2749 int err;
2750 uint8_t x;
2751 uint8_t nports;
2752
2753 repeat:
2754 /* be NULL safe */
2755 if (udev == NULL)
2756 return;
2757
2758 /* check if already suspended */
2759 if (udev->flags.self_suspended)
2760 return;
2761
2762 /* we need a parent HUB to do suspend */
2763 if (udev->parent_hub == NULL)
2764 return;
2765
2766 DPRINTF("udev=%p\n", udev);
2767
2768 /* check if the current device is a HUB */
2769 if (udev->hub != NULL) {
2770 nports = udev->hub->nports;
2771
2772 /* check if all devices on the HUB are suspended */
2773 for (x = 0; x != nports; x++) {
2774 child = usb_bus_port_get_device(udev->bus,
2775 udev->hub->ports + x);
2776
2777 if (child == NULL)
2778 continue;
2779
2780 if (child->flags.self_suspended)
2781 continue;
2782
2783 DPRINTFN(1, "Port %u is busy on the HUB!\n", x + 1);
2784 return;
2785 }
2786 }
2787
2788 if (usb_peer_can_wakeup(udev)) {
2789 /*
2790 * This request needs to be done before we set
2791 * "udev->flags.self_suspended":
2792 */
2793
2794 /* allow device to do remote wakeup */
2795 err = usbd_set_dev_wakeup(udev);
2796 if (err) {
2797 DPRINTFN(0, "Setting device "
2798 "remote wakeup failed\n");
2799 }
2800 }
2801
2802 USB_BUS_LOCK(udev->bus);
2803 /*
2804 * Checking for suspend condition and setting suspended bit
2805 * must be atomic!
2806 */
2807 err = usb_peer_should_wakeup(udev);
2808 if (err == 0) {
2809 /*
2810 * Set that this device is suspended. This variable
2811 * must be set before calling USB controller suspend
2812 * callbacks.
2813 */
2814 udev->flags.self_suspended = 1;
2815 }
2816 USB_BUS_UNLOCK(udev->bus);
2817
2818 if (err != 0) {
2819 if (usb_peer_can_wakeup(udev)) {
2820 /* allow device to do remote wakeup */
2821 err = usbd_clear_dev_wakeup(udev);
2822 if (err) {
2823 DPRINTFN(0, "Setting device "
2824 "remote wakeup failed\n");
2825 }
2826 }
2827
2828 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
2829 /* resume parent HUB first */
2830 usb_dev_resume_peer(udev->parent_hub);
2831
2832 /* reduce chance of instant resume failure by waiting a little bit */
2833 usb_pause_mtx(NULL, USB_MS_TO_TICKS(20));
2834
2835 /* resume current port (Valid in Host and Device Mode) */
2836 err = usbd_req_clear_port_feature(udev->parent_hub,
2837 NULL, udev->port_no, UHF_PORT_SUSPEND);
2838
2839 /* resume settle time */
2840 usb_pause_mtx(NULL, USB_MS_TO_TICKS(usb_port_resume_delay));
2841 }
2842 DPRINTF("Suspend was cancelled!\n");
2843 return;
2844 }
2845
2846 usbd_sr_lock(udev);
2847
2848 /* notify all sub-devices about suspend */
2849 err = usb_suspend_resume(udev, 1);
2850
2851 usbd_sr_unlock(udev);
2852
2853 if (udev->bus->methods->device_suspend != NULL) {
2854 usb_timeout_t temp;
2855
2856 /* suspend device on the USB controller */
2857 (udev->bus->methods->device_suspend) (udev);
2858
2859 /* do DMA delay */
2860 temp = usbd_get_dma_delay(udev);
2861 if (temp != 0)
2862 usb_pause_mtx(NULL, USB_MS_TO_TICKS(temp));
2863 }
2864
2865 if (usb_device_20_compatible(udev)) {
2866 /* suspend current port */
2867 err = usbd_req_set_port_feature(udev->parent_hub,
2868 NULL, udev->port_no, UHF_PORT_SUSPEND);
2869 if (err) {
2870 DPRINTFN(0, "Suspending port failed\n");
2871 return;
2872 }
2873 } else {
2874 /* suspend current port */
2875 err = usbd_req_set_port_link_state(udev->parent_hub,
2876 NULL, udev->port_no, UPS_PORT_LS_U3);
2877 if (err) {
2878 DPRINTFN(0, "Suspending port failed\n");
2879 return;
2880 }
2881 }
2882
2883 udev = udev->parent_hub;
2884 goto repeat;
2885 }
2886
2887 /*------------------------------------------------------------------------*
2888 * usbd_set_power_mode
2889 *
2890 * This function will set the power mode, see USB_POWER_MODE_XXX for a
2891 * USB device.
2892 *------------------------------------------------------------------------*/
2893 void
usbd_set_power_mode(struct usb_device * udev,uint8_t power_mode)2894 usbd_set_power_mode(struct usb_device *udev, uint8_t power_mode)
2895 {
2896 /* filter input argument */
2897 if ((power_mode != USB_POWER_MODE_ON) &&
2898 (power_mode != USB_POWER_MODE_OFF))
2899 power_mode = USB_POWER_MODE_SAVE;
2900
2901 power_mode = usbd_filter_power_mode(udev, power_mode);
2902
2903 udev->power_mode = power_mode; /* update copy of power mode */
2904
2905 #if USB_HAVE_POWERD
2906 usb_bus_power_update(udev->bus);
2907 #else
2908 usb_needs_explore(udev->bus, 0 /* no probe */ );
2909 #endif
2910 }
2911
2912 /*------------------------------------------------------------------------*
2913 * usbd_filter_power_mode
2914 *
2915 * This function filters the power mode based on hardware requirements.
2916 *------------------------------------------------------------------------*/
2917 uint8_t
usbd_filter_power_mode(struct usb_device * udev,uint8_t power_mode)2918 usbd_filter_power_mode(struct usb_device *udev, uint8_t power_mode)
2919 {
2920 const struct usb_bus_methods *mtod;
2921 int8_t temp;
2922
2923 mtod = udev->bus->methods;
2924 temp = -1;
2925
2926 if (mtod->get_power_mode != NULL)
2927 (mtod->get_power_mode) (udev, &temp);
2928
2929 /* check if we should not filter */
2930 if (temp < 0)
2931 return (power_mode);
2932
2933 /* use fixed power mode given by hardware driver */
2934 return (temp);
2935 }
2936
2937 /*------------------------------------------------------------------------*
2938 * usbd_start_re_enumerate
2939 *
2940 * This function starts re-enumeration of the given USB device. This
2941 * function does not need to be called BUS-locked. This function does
2942 * not wait until the re-enumeration is completed.
2943 *------------------------------------------------------------------------*/
2944 void
usbd_start_re_enumerate(struct usb_device * udev)2945 usbd_start_re_enumerate(struct usb_device *udev)
2946 {
2947 if (udev->re_enumerate_wait == USB_RE_ENUM_DONE) {
2948 udev->re_enumerate_wait = USB_RE_ENUM_START;
2949 usb_needs_explore(udev->bus, 0);
2950 }
2951 }
2952
2953 /*-----------------------------------------------------------------------*
2954 * usbd_start_set_config
2955 *
2956 * This function starts setting a USB configuration. This function
2957 * does not need to be called BUS-locked. This function does not wait
2958 * until the set USB configuratino is completed.
2959 *------------------------------------------------------------------------*/
2960 usb_error_t
usbd_start_set_config(struct usb_device * udev,uint8_t index)2961 usbd_start_set_config(struct usb_device *udev, uint8_t index)
2962 {
2963 if (udev->re_enumerate_wait == USB_RE_ENUM_DONE) {
2964 if (udev->curr_config_index == index) {
2965 /* no change needed */
2966 return (0);
2967 }
2968 udev->next_config_index = index;
2969 udev->re_enumerate_wait = USB_RE_ENUM_SET_CONFIG;
2970 usb_needs_explore(udev->bus, 0);
2971 return (0);
2972 } else if (udev->re_enumerate_wait == USB_RE_ENUM_SET_CONFIG) {
2973 if (udev->next_config_index == index) {
2974 /* no change needed */
2975 return (0);
2976 }
2977 }
2978 return (USB_ERR_PENDING_REQUESTS);
2979 }
2980