Lines Matching refs:udev
112 static void usb_dev_resume_peer(struct usb_device *udev);
113 static void usb_dev_suspend_peer(struct usb_device *udev);
114 static uint8_t usb_peer_should_wakeup(struct usb_device *udev);
223 struct usb_device *udev = pm->udev;
227 hub = udev->hub;
235 USB_BUS_UNLOCK(udev->bus);
241 USB_BUS_LOCK(udev->bus);
255 struct usb_device *udev;
264 udev = child->parent_hs_hub;
267 if (udev == NULL)
270 hub = udev->hub;
272 (udev->speed != USB_SPEED_HIGH) ||
281 USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
285 if ((udev->ddesc.bDeviceClass == UDCLASS_HUB) &&
286 (udev->ddesc.bDeviceProtocol == UDPROTO_HSHUBSTT))
312 (void)usb_proc_msignal(USB_BUS_TT_PROC(udev->bus),
322 struct usb_device *udev;
329 udev = sc->sc_udev;
335 USB_BUS_LOCK(udev->bus);
337 for (x = 0; x != udev->hub->nports; x++) {
338 up = udev->hub->ports + x;
352 USB_BUS_UNLOCK(udev->bus);
357 USB_BUS_UNLOCK(udev->bus);
376 uhub_count_active_host_ports(struct usb_device *udev, enum usb_dev_speed speed)
385 if (udev == NULL)
387 hub = udev->hub;
396 child = usb_bus_port_get_device(udev->bus, up);
608 struct usb_device *udev;
610 udev = sc->sc_udev;
630 (void)usbd_req_clear_port_feature(udev, NULL,
657 struct usb_device *udev;
668 udev = sc->sc_udev;
669 child = usb_bus_port_get_device(udev->bus,
670 udev->hub->ports + portno - 1);
676 err = usbd_req_clear_port_feature(udev, NULL,
720 switch (udev->speed) {
727 if (udev->parent_hub == NULL)
754 err = usbd_req_clear_port_feature(udev,
765 err = usbd_req_reset_port(udev, NULL, portno);
800 switch (udev->speed) {
819 if (udev->parent_hub == NULL) {
841 speed = udev->speed;
845 err = usbd_req_set_hub_u1_timeout(udev, NULL,
846 portno, 128 - (2 * udev->depth));
852 err = usbd_req_set_hub_u2_timeout(udev, NULL,
853 portno, 128 - (2 * udev->depth));
866 if (udev->parent_hub != NULL) {
868 mode = udev->parent_hub->flags.usb_mode;
875 child = usb_alloc_device(sc->sc_dev, udev->bus, udev,
876 udev->depth + 1, portno - 1, portno, speed, mode);
913 usb_device_20_compatible(struct usb_device *udev)
915 if (udev == NULL)
917 switch (udev->speed) {
938 struct usb_device *udev;
944 udev = sc->sc_udev;
945 child = usb_bus_port_get_device(udev->bus,
946 udev->hub->ports + portno - 1);
950 if (usb_device_20_compatible(udev)) {
951 err = usbd_req_clear_port_feature(udev, NULL,
954 err = usbd_req_clear_port_feature(udev, NULL,
971 if (usb_device_20_compatible(udev)) {
983 (void)usbd_req_warm_reset_port(udev, NULL, portno);
1027 uhub_is_too_deep(struct usb_device *udev)
1029 switch (udev->speed) {
1033 if (udev->depth > USB_HUB_MAX_DEPTH)
1037 if (udev->depth > USB_SS_HUB_DEPTH_MAX)
1054 uhub_explore(struct usb_device *udev)
1064 hub = udev->hub;
1067 DPRINTFN(11, "udev=%p addr=%d\n", udev, udev->address);
1070 if (uhub_is_too_deep(udev))
1074 if (udev->flags.self_suspended) {
1084 do_unlock = usbd_enum_lock(udev);
1102 udev, NULL, portno, UHF_C_PORT_OVER_CURRENT);
1111 udev, NULL, portno, UHF_C_PORT_ENABLE);
1158 usbd_enum_unlock(udev);
1191 uhub_query_info(struct usb_device *udev, uint8_t *pnports, uint8_t *ptt)
1199 if (udev->ddesc.bDeviceClass != UDCLASS_HUB)
1205 switch (udev->speed) {
1210 err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc20, 1);
1220 if (udev->speed == USB_SPEED_HIGH)
1225 err = usbd_req_get_ss_hub_descriptor(udev, NULL, &hubdesc30, 1);
1259 struct usb_device *udev;
1276 udev = uaa->device;
1277 parent_hub = udev->parent_hub;
1279 sc->sc_udev = udev;
1288 udev->depth,
1289 udev->flags.self_powered,
1294 if (uhub_is_too_deep(udev)) {
1296 "exceeds maximum. HUB ignored\n", (int)udev->depth);
1300 if (!udev->flags.self_powered && parent_hub &&
1314 err = usbd_set_alt_interface_index(udev, 0, 0);
1326 switch (udev->speed) {
1331 err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc20, 1);
1353 err = usbd_req_get_hub_descriptor(udev, NULL, &hubdesc20, nports);
1367 if (udev->parent_hub != NULL) {
1368 err = usbd_req_set_hub_depth(udev, NULL,
1369 udev->depth - 1);
1376 err = usbd_req_get_ss_hub_descriptor(udev, NULL, &hubdesc30, 1);
1392 if (nports > ((udev->parent_hub != NULL) ? 15 : 127)) {
1398 err = usbd_req_get_ss_hub_descriptor(udev, NULL, &hubdesc30, nports);
1433 udev->hub = hub;
1439 hub->hubudev = udev;
1442 hub->tt_msg[0].udev = udev;
1444 hub->tt_msg[1].udev = udev;
1447 if (udev->flags.self_powered) {
1455 if (udev->parent_hub == NULL) {
1460 err = usbd_transfer_setup(udev, &iface_index, sc->sc_xfer,
1509 switch (udev->speed) {
1527 err = usbd_req_set_port_feature(udev, NULL,
1558 if (udev->parent_hub == NULL) { /* parent is bus */
1567 parent_info.nameunit = device_get_nameunit(udev->parent_dev);
1568 parent_info.port_no = udev->port_no;
1581 removable, udev->flags.self_powered ? "self" : "bus");
1591 usbd_set_power_mode(udev, USB_POWER_MODE_SAVE);
1599 bsd_free(udev->hub, M_USBDEV);
1601 udev->hub = NULL;
1698 struct usb_device *udev;
1708 struct usb_device *udev;
1715 udev = usb_bus_port_get_device(hub->hubudev->bus,
1717 if (!udev) {
1721 iface = usbd_get_iface(udev, i);
1725 res->udev = udev;
1732 res->udev = NULL;
1758 if (!res.udev) {
1766 device_get_unit(res.udev->bus->bdev),
1767 (res.udev->parent_hub != NULL) ? res.udev->parent_hub->device_index : 0U,
1769 res.udev->device_index, res.iface_index);
1799 if (!res.udev) {
1806 iface = usbd_get_iface(res.udev, res.iface_index);
1815 UGETW(res.udev->ddesc.idVendor),
1816 UGETW(res.udev->ddesc.idProduct),
1817 res.udev->ddesc.bDeviceClass,
1818 res.udev->ddesc.bDeviceSubClass,
1819 usb_get_serial(res.udev),
1820 UGETW(res.udev->ddesc.bcdDevice),
1821 (res.udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
1924 usb_hs_bandwidth_adjust(struct usb_device *udev, int16_t len,
1927 struct usb_bus *bus = udev->bus;
1934 speed = usbd_get_speed(udev);
1949 hub = udev->parent_hs_hub->hub;
1984 struct usb_device *udev;
1989 udev = xfer->xroot->udev;
1991 if (udev->flags.usb_mode != USB_MODE_HOST)
1998 speed = usbd_get_speed(udev);
2005 slot = usb_hs_bandwidth_adjust(udev,
2037 slot = usb_hs_bandwidth_adjust(udev,
2065 struct usb_device *udev;
2069 udev = xfer->xroot->udev;
2071 if (udev->flags.usb_mode != USB_MODE_HOST)
2086 (void)usb_hs_bandwidth_adjust(udev,
2169 if (xfer->xroot->udev->parent_hs_hub !=
2170 isoc_xfer->xroot->udev->parent_hs_hub) {
2173 if ((isoc_xfer->xroot->udev->parent_hs_hub->
2175 (xfer->xroot->udev->hs_port_no !=
2176 isoc_xfer->xroot->udev->hs_port_no)) {
2287 struct usb_device *udev, uint8_t device_index)
2298 if (udev) {
2312 bus->devices[device_index] = udev;
2320 DPRINTFN(2, "bus %p devices[%u] = %p\n", bus, device_index, udev);
2465 struct usb_device *udev;
2470 udev = xfer->xroot->udev;
2472 if (udev->device_index == USB_ROOT_HUB_ADDR) {
2476 USB_BUS_LOCK(udev->bus);
2480 udev->pwr_save.last_xfer_time = CUR_TICKS;
2481 udev->pwr_save.type_refs[xfer_type] += val;
2484 udev->pwr_save.read_refs += val;
2490 udev->pwr_save.write_refs += val;
2493 udev->pwr_save.read_refs += val;
2495 udev->pwr_save.write_refs += val;
2499 if (udev->flags.self_suspended)
2500 needs_explore = usb_peer_should_wakeup(udev);
2504 if (!(udev->bus->hw_power_state & power_mask[xfer_type])) {
2506 udev->bus->hw_power_state |= power_mask[xfer_type];
2516 USB_BUS_UNLOCK(udev->bus);
2520 usb_bus_power_update(udev->bus);
2523 if (udev->bus->methods->set_hw_power != NULL) {
2524 (udev->bus->methods->set_hw_power) (udev->bus);
2536 usb_peer_should_wakeup(struct usb_device *udev)
2538 return (uint8_t)(((udev->power_mode == USB_POWER_MODE_ON) &&
2539 (udev->flags.usb_mode == USB_MODE_HOST)) ||
2540 (udev->driver_added_refcount != udev->bus->driver_added_refcount) ||
2541 (udev->re_enumerate_wait != USB_RE_ENUM_DONE) ||
2542 (udev->pwr_save.type_refs[UE_ISOCHRONOUS] != 0) ||
2543 (udev->pwr_save.write_refs != 0) ||
2544 ((udev->pwr_save.read_refs != 0) &&
2545 (udev->flags.usb_mode == USB_MODE_HOST) &&
2546 (usb_peer_can_wakeup(udev) == 0)));
2559 struct usb_device *udev;
2584 udev = bus->devices[x];
2585 if (udev == NULL)
2588 temp = CUR_TICKS - udev->pwr_save.last_xfer_time;
2590 if (usb_peer_should_wakeup(udev)) {
2592 if (udev->flags.self_suspended != 0) {
2594 usb_dev_resume_peer(udev);
2598 (udev->flags.usb_mode == USB_MODE_HOST) &&
2599 (udev->flags.self_suspended == 0)) {
2603 usb_dev_suspend_peer(udev);
2621 udev = bus->devices[x];
2622 if (udev == NULL)
2629 temp = CUR_TICKS - udev->pwr_save.last_xfer_time;
2638 if (udev->flags.self_suspended == 0) {
2639 type_refs[0] += udev->pwr_save.type_refs[0];
2640 type_refs[1] += udev->pwr_save.type_refs[1];
2641 type_refs[2] += udev->pwr_save.type_refs[2];
2642 type_refs[3] += udev->pwr_save.type_refs[3];
2672 usbd_device_30_remote_wakeup(struct usb_device *udev, uint8_t bRequest)
2682 return (usbd_do_request(udev, NULL, &req, 0));
2686 usbd_clear_dev_wakeup(struct usb_device *udev)
2690 if (usb_device_20_compatible(udev)) {
2691 err = usbd_req_clear_device_feature(udev,
2694 err = usbd_device_30_remote_wakeup(udev,
2701 usbd_set_dev_wakeup(struct usb_device *udev)
2705 if (usb_device_20_compatible(udev)) {
2706 err = usbd_req_set_device_feature(udev,
2709 err = usbd_device_30_remote_wakeup(udev,
2722 usb_dev_resume_peer(struct usb_device *udev)
2728 if (udev == NULL)
2732 if (udev->flags.self_suspended == 0)
2736 if (udev->parent_hub == NULL)
2739 DPRINTF("udev=%p\n", udev);
2741 if ((udev->flags.usb_mode == USB_MODE_DEVICE) &&
2742 (udev->flags.remote_wakeup == 0)) {
2751 bus = udev->bus;
2754 usb_dev_resume_peer(udev->parent_hub);
2759 if (usb_device_20_compatible(udev)) {
2761 err = usbd_req_clear_port_feature(udev->parent_hub,
2762 NULL, udev->port_no, UHF_PORT_SUSPEND);
2765 err = usbd_req_set_port_link_state(udev->parent_hub,
2766 NULL, udev->port_no, UPS_PORT_LS_U0);
2779 (bus->methods->device_resume) (udev);
2783 udev->flags.self_suspended = 0;
2786 udev->pwr_save.last_xfer_time = CUR_TICKS;
2789 if (udev->pwr_save.type_refs[UE_CONTROL] != 0)
2791 if (udev->pwr_save.type_refs[UE_BULK] != 0)
2793 if (udev->pwr_save.type_refs[UE_INTERRUPT] != 0)
2795 if (udev->pwr_save.type_refs[UE_ISOCHRONOUS] != 0)
2805 usbd_sr_lock(udev);
2808 (void)usb_suspend_resume(udev, 0);
2810 usbd_sr_unlock(udev);
2813 if (usb_peer_can_wakeup(udev)) {
2815 err = usbd_clear_dev_wakeup(udev);
2831 usb_dev_suspend_peer(struct usb_device *udev)
2841 if (udev == NULL)
2845 if (udev->flags.self_suspended)
2849 if (udev->parent_hub == NULL)
2852 DPRINTF("udev=%p\n", udev);
2855 if (udev->hub != NULL) {
2856 nports = udev->hub->nports;
2860 child = usb_bus_port_get_device(udev->bus,
2861 udev->hub->ports + x);
2874 if (usb_peer_can_wakeup(udev)) {
2877 * "udev->flags.self_suspended":
2881 err = usbd_set_dev_wakeup(udev);
2889 if (udev->bus == NULL)
2892 USB_BUS_LOCK(udev->bus);
2897 err = usb_peer_should_wakeup(udev);
2904 udev->flags.self_suspended = 1;
2906 USB_BUS_UNLOCK(udev->bus);
2909 if (usb_peer_can_wakeup(udev)) {
2911 err = usbd_clear_dev_wakeup(udev);
2918 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
2920 usb_dev_resume_peer(udev->parent_hub);
2926 err = usbd_req_clear_port_feature(udev->parent_hub,
2927 NULL, udev->port_no, UHF_PORT_SUSPEND);
2940 usbd_sr_lock(udev);
2943 (void)usb_suspend_resume(udev, 1);
2945 usbd_sr_unlock(udev);
2947 if (udev->bus->methods->device_suspend != NULL) {
2950 (udev->bus->methods->device_suspend) (udev);
2953 temp = usbd_get_dma_delay(udev);
2958 if (usb_device_20_compatible(udev)) {
2960 err = usbd_req_set_port_feature(udev->parent_hub,
2961 NULL, udev->port_no, UHF_PORT_SUSPEND);
2968 err = usbd_req_set_port_link_state(udev->parent_hub,
2969 NULL, udev->port_no, UPS_PORT_LS_U3);
2976 udev = udev->parent_hub;
2987 usbd_set_power_mode(struct usb_device *udev, uint8_t power_mode)
2994 power_mode = usbd_filter_power_mode(udev, power_mode);
2996 udev->power_mode = power_mode; /* update copy of power mode */
2999 usb_bus_power_update(udev->bus);
3001 usb_needs_explore(udev->bus, 0 /* no probe */ );
3011 usbd_filter_power_mode(struct usb_device *udev, uint8_t power_mode)
3015 mtod = udev->bus->methods;
3019 (mtod->get_power_mode) (udev, &temp);
3037 usbd_start_re_enumerate(struct usb_device *udev)
3039 if (udev->re_enumerate_wait == USB_RE_ENUM_DONE) {
3040 udev->re_enumerate_wait = USB_RE_ENUM_START;
3041 usb_needs_explore(udev->bus, 0);
3053 usbd_start_set_config(struct usb_device *udev, uint8_t index)
3055 if (udev->re_enumerate_wait == USB_RE_ENUM_DONE) {
3056 if (udev->curr_config_index == index) {
3060 udev->next_config_index = index;
3061 udev->re_enumerate_wait = USB_RE_ENUM_SET_CONFIG;
3062 usb_needs_explore(udev->bus, 0);
3064 } else if (udev->re_enumerate_wait == USB_RE_ENUM_SET_CONFIG) {
3065 if (udev->next_config_index == index) {