Lines Matching refs:udev
88 usb_get_manufacturer(struct usb_device *udev)
90 return (udev->manufacturer ? udev->manufacturer : "Unknown");
94 usb_get_product(struct usb_device *udev)
96 return (udev->product ? udev->product : "");
100 usb_get_serial(struct usb_device *udev)
102 return (udev->serial ? udev->serial : "");
116 usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val)
118 struct usb_endpoint *ep = udev->endpoints;
119 struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
147 if ((udev->ctrl_ep.edesc != NULL) &&
148 ((udev->ctrl_ep.edesc->bEndpointAddress & EA_MASK) == ea_val)) {
149 ep = &udev->ctrl_ep;
169 usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index,
172 struct usb_endpoint *ep = udev->endpoints;
173 struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
180 DPRINTFN(10, "udev=%p iface_index=%d address=0x%x "
182 udev, iface_index, setup->endpoint,
188 (udev->flags.usb_mode != setup->usb_mode)) {
197 ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ?
201 ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ?
242 * the endpoints from the beginning of the "udev->endpoints" array.
264 if ((udev->ctrl_ep.edesc != NULL) &&
265 ((udev->ctrl_ep.edesc->bEndpointAddress & ea_mask) == ea_val) &&
266 ((udev->ctrl_ep.edesc->bmAttributes & type_mask) == type_val) &&
268 ep = &udev->ctrl_ep;
289 usbd_interface_count(struct usb_device *udev, uint8_t *count)
291 if (udev->cdesc == NULL) {
295 *count = udev->ifaces_max;
307 usb_init_endpoint(struct usb_device *udev, uint8_t iface_index,
315 methods = udev->bus->methods;
317 (methods->endpoint_init) (udev, edesc, ep);
335 if ((udev->speed == USB_SPEED_SUPER) && (ecomp != NULL) &&
338 (void)usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_STREAMS);
340 (void)usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_DEFAULT);
345 USB_BUS_LOCK(udev->bus);
346 (methods->clear_stall) (udev, ep);
347 USB_BUS_UNLOCK(udev->bus);
362 usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep)
367 if (udev == NULL)
370 ep_end = udev->endpoints + udev->endpoints_max;
374 ep = udev->endpoints;
394 usb_wait_pending_refs(struct usb_device *udev)
397 DPRINTF("Refcount = %d\n", (int)udev->refcount);
400 udev->refcount--;
403 if (udev->refcount == 0) {
405 udev->refcount = USB_DEV_REF_MAX;
408 cv_wait(&udev->ref_cv, &usb_ref_lock);
423 usb_unconfigure(struct usb_device *udev, uint8_t flag)
429 do_unlock = usbd_enum_lock(udev);
432 usb_detach_device(udev, USB_IFACE_INDEX_ANY, flag);
436 usb_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag);
441 usb_cdev_free(udev);
446 if (udev->linux_endpoint_start) {
447 usb_linux_free_device(udev);
448 udev->linux_endpoint_start = NULL;
452 err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE);
457 if (udev->cdesc != NULL) {
458 if (udev->flags.usb_mode != USB_MODE_DEVICE)
459 usbd_free_config_desc(udev, udev->cdesc);
460 udev->cdesc = NULL;
463 udev->curr_config_no = USB_UNCONFIG_NO;
464 udev->curr_config_index = USB_UNCONFIG_INDEX;
467 usbd_enum_unlock(udev);
482 usbd_set_config_index(struct usb_device *udev, uint8_t index)
492 DPRINTFN(6, "udev=%p index=%d\n", udev, index);
495 do_unlock = usbd_enum_lock(udev);
497 usb_unconfigure(udev, 0);
505 err = usbd_req_set_config(udev, NULL, USB_UNCONFIG_NO);
506 if (udev->state == USB_STATE_CONFIGURED)
507 usb_set_device_state(udev, USB_STATE_ADDRESSED);
511 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
513 err = usbd_req_get_descriptor_ptr(udev, &cdp,
517 err = usbd_req_get_config_desc_full(udev,
525 udev->cdesc = cdp;
529 if ((!udev->flags.uq_bus_powered) &&
531 (udev->flags.usb_mode == USB_MODE_HOST)) {
535 err = usbd_req_get_device_status(udev, NULL, &ds);
548 DPRINTF("udev=%p cdesc=%p (addr %d) cno=%d attr=0x%02x, "
550 udev, cdp,
551 udev->address, cdp->bConfigurationValue, cdp->bmAttributes,
557 if (udev->parent_hub) {
558 max_power = udev->parent_hub->hub->portpower;
569 if (udev->flags.usb_mode == USB_MODE_HOST) {
570 udev->flags.self_powered = selfpowered;
572 udev->power = power;
573 udev->curr_config_no = cdp->bConfigurationValue;
574 udev->curr_config_index = index;
575 usb_set_device_state(udev, USB_STATE_CONFIGURED);
578 err = usbd_req_set_config(udev, NULL, cdp->bConfigurationValue);
583 err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC);
588 err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT);
595 usb_cdev_create(udev);
601 usb_unconfigure(udev, 0);
604 usbd_enum_unlock(udev);
626 usb_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
658 sx_assert(&udev->enum_sx, SA_LOCKED);
662 ep = udev->endpoints;
663 ep_max = udev->endpoints_max;
693 while ((id = usb_idesc_foreach(udev->cdesc, &ips))) {
694 iface = udev->ifaces + ips.iface_index;
739 while ((ed = usb_edesc_foreach(udev->cdesc, ed))) {
746 ep = udev->endpoints + temp;
751 ecomp = usb_ed_comp_foreach(udev->cdesc, (void *)ed);
755 usb_init_endpoint(udev,
770 udev->ifaces_max = ips.iface_index;
772 udev->ifaces = NULL;
773 if (udev->ifaces_max != 0) {
774 udev->ifaces = bsd_malloc(sizeof(*iface) * udev->ifaces_max,
776 if (udev->ifaces == NULL) {
784 udev->endpoints = bsd_malloc(sizeof(*ep) * ep_max,
786 if (udev->endpoints == NULL) {
791 udev->endpoints = NULL;
794 USB_BUS_LOCK(udev->bus);
795 udev->endpoints_max = ep_max;
797 udev->ep_curr = NULL;
798 USB_BUS_UNLOCK(udev->bus);
806 USB_BUS_LOCK(udev->bus);
807 udev->endpoints_max = 0;
809 udev->ep_curr = NULL;
810 USB_BUS_UNLOCK(udev->bus);
813 bsd_free(udev->ifaces, M_USB);
814 udev->ifaces = NULL;
817 bsd_free(udev->endpoints, M_USB);
818 udev->endpoints = NULL;
820 udev->ifaces_max = 0;
841 usbd_set_alt_interface_index(struct usb_device *udev,
844 struct usb_interface *iface = usbd_get_iface(udev, iface_index);
849 do_unlock = usbd_enum_lock(udev);
868 usb_fifo_free_wrap(udev, iface_index, 0);
871 err = usb_config_parse(udev, iface_index, alt_index);
881 err = usbd_req_set_alt_interface_no(udev, NULL, iface_index,
886 usbd_enum_unlock(udev);
901 usbd_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep,
931 USB_BUS_LOCK(udev->bus);
939 USB_BUS_UNLOCK(udev->bus);
959 (udev->bus->methods->xfer_stall) (xfer);
963 (udev->bus->methods->set_stall) (udev, ep, &do_stall);
969 (udev->bus->methods->clear_stall) (udev, ep);
977 USB_BUS_UNLOCK(udev->bus);
985 usb_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
990 ep = udev->endpoints;
991 ep_end = udev->endpoints + udev->endpoints_max;
999 (void)usbd_set_endpoint_stall(udev, ep, 0);
1013 usb_detach_device_sub(struct usb_device *udev, device_t *ppdev,
1033 device_get_nameunit(udev->parent_dev),
1034 udev->port_no, udev->address);
1038 if (udev->flags.peer_suspended) {
1046 if (device_delete_child(udev->parent_dev, dev)) {
1072 usb_detach_device(struct usb_device *udev, uint8_t iface_index,
1078 if (udev == NULL) {
1082 DPRINTFN(4, "udev=%p\n", udev);
1084 sx_assert(&udev->enum_sx, SA_LOCKED);
1103 iface = usbd_get_iface(udev, i);
1108 usb_detach_device_sub(udev, &iface->subdev,
1121 usb_probe_and_attach_sub(struct usb_device *udev,
1145 if (device_delete_child(udev->parent_dev, dev)) {
1156 uaa->temp_dev = device_add_child(udev->parent_dev, NULL, -1);
1158 device_printf(udev->parent_dev,
1179 if (udev->flags.peer_suspended) {
1203 usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
1208 if (udev == NULL) {
1212 iface = usbd_get_iface(udev, iface_index);
1218 usb_init_attach_arg(struct usb_device *udev,
1223 uaa->device = udev;
1224 uaa->usb_mode = udev->flags.usb_mode;
1225 uaa->port = udev->port_no;
1228 uaa->info.idVendor = UGETW(udev->ddesc.idVendor);
1229 uaa->info.idProduct = UGETW(udev->ddesc.idProduct);
1230 uaa->info.bcdDevice = UGETW(udev->ddesc.bcdDevice);
1231 uaa->info.bDeviceClass = udev->ddesc.bDeviceClass;
1232 uaa->info.bDeviceSubClass = udev->ddesc.bDeviceSubClass;
1233 uaa->info.bDeviceProtocol = udev->ddesc.bDeviceProtocol;
1234 uaa->info.bConfigIndex = udev->curr_config_index;
1235 uaa->info.bConfigNum = udev->curr_config_no;
1253 usb_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
1261 if (udev == NULL) {
1262 DPRINTF("udev == NULL\n");
1266 do_unlock = usbd_enum_lock(udev);
1268 if (udev->curr_config_index == USB_UNCONFIG_INDEX) {
1274 usb_init_attach_arg(udev, &uaa);
1281 EVENTHANDLER_INVOKE(usb_dev_configured, udev, &uaa);
1285 usb_unconfigure(udev, 0);
1301 iface = usbd_get_iface(udev, i);
1335 (void)usb_probe_and_attach_sub(udev, &uaa);
1344 if (device_delete_child(udev->parent_dev, uaa.temp_dev))
1350 usbd_enum_unlock(udev);
1361 usb_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend)
1392 usb_suspend_resume(struct usb_device *udev, uint8_t do_suspend)
1397 if (udev == NULL) {
1401 DPRINTFN(4, "udev=%p do_suspend=%d\n", udev, do_suspend);
1403 sx_assert(&udev->sr_sx, SA_LOCKED);
1405 USB_BUS_LOCK(udev->bus);
1407 if (udev->flags.peer_suspended == do_suspend) {
1408 USB_BUS_UNLOCK(udev->bus);
1412 udev->flags.peer_suspended = do_suspend;
1413 USB_BUS_UNLOCK(udev->bus);
1418 iface = usbd_get_iface(udev, i);
1423 usb_suspend_resume_sub(udev, iface->subdev, do_suspend);
1437 struct usb_device *udev = pm->udev;
1440 USB_BUS_UNLOCK(udev->bus);
1441 USB_MTX_LOCK(&udev->device_mtx);
1444 usbd_transfer_start(udev->ctrl_xfer[1]);
1447 USB_MTX_UNLOCK(&udev->device_mtx);
1448 USB_BUS_LOCK(udev->bus);
1469 struct usb_device *udev;
1508 udev = bsd_malloc(sizeof(*udev), M_USB, M_WAITOK | M_ZERO);
1509 if (udev == NULL) {
1513 sx_init_flags(&udev->enum_sx, "USB config SX lock", SX_DUPOK);
1514 sx_init_flags(&udev->sr_sx, "USB suspend and resume SX lock", SX_NOWITNESS);
1515 sx_init_flags(&udev->ctrl_sx, "USB control transfer SX lock", SX_DUPOK);
1517 cv_init(&udev->ctrlreq_cv, "WCTRL");
1518 cv_init(&udev->ref_cv, "UGONE");
1521 mtx_init(&udev->device_mtx, "USB device mutex", NULL, MTX_DEF);
1524 udev->cs_msg[0].hdr.pm_callback = &usbd_clear_stall_proc;
1525 udev->cs_msg[0].udev = udev;
1526 udev->cs_msg[1].hdr.pm_callback = &usbd_clear_stall_proc;
1527 udev->cs_msg[1].udev = udev;
1530 udev->parent_hub = parent_hub;
1531 udev->parent_dev = parent_dev;
1532 udev->port_index = port_index;
1533 udev->port_no = port_no;
1534 udev->depth = depth;
1535 udev->bus = bus;
1536 udev->address = USB_START_ADDR; /* default value */
1537 udev->plugtime = (usb_ticks_t)CUR_TICKS;
1543 udev->power_mode = usbd_filter_power_mode(udev, USB_POWER_MODE_ON);
1544 udev->pwr_save.last_xfer_time = CUR_TICKS;
1546 udev->refcount = 1;
1549 udev->ctrl_ep_desc.bLength = sizeof(udev->ctrl_ep_desc);
1550 udev->ctrl_ep_desc.bDescriptorType = UDESC_ENDPOINT;
1551 udev->ctrl_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT;
1552 udev->ctrl_ep_desc.bmAttributes = UE_CONTROL;
1553 udev->ctrl_ep_desc.wMaxPacketSize[0] = USB_MAX_IPACKET;
1554 udev->ctrl_ep_desc.wMaxPacketSize[1] = 0;
1555 udev->ctrl_ep_desc.bInterval = 0;
1558 udev->ctrl_ep_comp_desc.bLength = sizeof(udev->ctrl_ep_comp_desc);
1559 udev->ctrl_ep_comp_desc.bDescriptorType = UDESC_ENDPOINT_SS_COMP;
1561 udev->ddesc.bMaxPacketSize = USB_MAX_IPACKET;
1563 udev->speed = speed;
1564 udev->flags.usb_mode = mode;
1568 adev = udev;
1569 hub = udev->parent_hub;
1573 udev->hs_hub_addr = hub->address;
1574 udev->parent_hs_hub = hub;
1575 udev->hs_port_no = adev->port_no;
1583 usb_init_endpoint(udev, 0,
1584 &udev->ctrl_ep_desc,
1585 &udev->ctrl_ep_comp_desc,
1586 &udev->ctrl_ep);
1589 udev->device_index = device_index;
1593 (void)snprintf_s(udev->ugen_name, sizeof(udev->ugen_name),
1594 sizeof(udev->ugen_name) - 1, USB_GENERIC_NAME "%u.%u",
1596 LIST_FIRST(&udev->pd_list) = NULL;
1599 udev->ctrl_dev = usb_make_dev(udev, NULL, 0, 0,
1604 err = (bus->methods->device_init) (udev);
1614 usb_set_device_state(udev, USB_STATE_POWERED);
1616 if (udev->flags.usb_mode == USB_MODE_HOST) {
1617 err = usbd_req_set_address(udev, NULL, device_index);
1623 if (udev->address == USB_START_ADDR)
1624 udev->address = device_index;
1636 "(%s, ignored)\n", udev->address,
1641 udev->flags.self_powered = 0;
1644 udev->curr_config_no = USB_UNCONFIG_NO;
1645 udev->curr_config_index = USB_UNCONFIG_INDEX;
1648 err = (usb_temp_setup_by_index_p) (udev, usb_template);
1656 usb_set_device_state(udev, USB_STATE_ADDRESSED);
1659 err = usbd_setup_device_desc(udev, NULL);
1663 err = usbd_req_re_enumerate(udev, NULL);
1665 err = usbd_req_re_enumerate(udev, NULL);
1676 usb_init_attach_arg(udev, &uaa);
1679 udev->flags.uq_bus_powered = 1;
1682 udev->flags.no_strings = 1;
1697 do_unlock = usbd_ctrl_lock(udev);
1699 scratch_ptr = udev->scratch.data;
1701 if (udev->flags.no_strings) {
1703 } else if (udev->ddesc.iManufacturer ||
1704 udev->ddesc.iProduct ||
1705 udev->ddesc.iSerialNumber) {
1707 err = usbd_req_get_string_desc(udev, NULL,
1714 udev->flags.no_strings = 1;
1744 udev->langid = langid;
1748 usbd_ctrl_unlock(udev);
1751 udev->power = USB_MIN_POWER;
1753 usbd_set_device_strings(udev);
1755 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
1792 err = usbd_set_config_index(udev, config_index);
1794 if (udev->ddesc.bNumConfigurations != 0) {
1798 err = usbd_req_re_enumerate(udev, NULL);
1804 config_index, usbd_errstr(err), udev->port_no,
1805 udev->address);
1814 if ((!config_quirk) && (config_index + 1 < udev->ddesc.bNumConfigurations)) {
1815 if ((udev->cdesc->bNumInterface < 2) &&
1816 (usbd_get_no_descriptors(udev->cdesc, UDESC_ENDPOINT) == 0)) {
1824 DPRINTF("new dev (addr %d), udev=%p, parent_hub=%p\n",
1825 udev->address, udev, udev->parent_hub);
1829 (parent_hub->hub->ports + port_index) : NULL, udev, device_index);
1833 udev->ugen_symlink = usb_alloc_symlink(udev->ugen_name);
1836 PRINTK("%s: <%s> at %s\n", udev->ugen_name,
1837 usb_get_manufacturer(udev),
1838 device_get_nameunit(udev->bus->bdev));
1842 UsbPnpNotifyDevice("ATTACH", udev);
1846 usb_notify_addq("ATTACH", udev);
1853 usb_free_device(udev, 0);
1854 udev = NULL;
1856 return (udev);
1861 usb_make_dev(struct usb_device *udev, const char *devname, int ep,
1873 pd->bus_index = device_get_unit(udev->bus->bdev);
1874 pd->dev_index = udev->device_index;
1924 usb_cdev_create(struct usb_device *udev)
1933 KASSERT(LIST_FIRST(&udev->pd_list) == NULL, ("stale cdev entries"));
1937 if (usbd_get_mode(udev) == USB_MODE_DEVICE) {
1953 cd = usbd_get_config_descriptor(udev);
1976 pd = usb_make_dev(udev, NULL, ep, 0,
1980 LIST_INSERT_HEAD(&udev->pd_list, pd, pd_next);
1985 usb_cdev_free(struct usb_device *udev)
1991 while ((pd = LIST_FIRST(&udev->pd_list)) != NULL) {
2010 usb_free_device(struct usb_device *udev, uint8_t flag)
2014 if (udev == NULL)
2017 DPRINTFN(4, "udev=%p port=%d\n", udev, udev->port_no);
2019 bus = udev->bus;
2022 usb_set_device_state(udev, USB_STATE_DETACHED);
2025 UsbPnpNotifyDevice("DETACH", udev);
2029 usb_notify_addq("DETACH", udev);
2034 PRINTK("%s: <%s> at %s (disconnected)\n", udev->ugen_name,
2035 usb_get_manufacturer(udev), device_get_nameunit(bus->bdev));
2039 if (udev->ugen_symlink) {
2040 usb_free_symlink(udev->ugen_symlink);
2041 udev->ugen_symlink = NULL;
2044 usb_destroy_dev(udev->ctrl_dev);
2047 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
2049 usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX);
2053 usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_EP0);
2056 usb_bus_port_set_device(bus, udev->parent_hub ?
2057 (udev->parent_hub->hub->ports + udev->port_index) : NULL,
2061 usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX);
2064 (usb_temp_unsetup_p) (udev);
2070 USB_BUS_LOCK(udev->bus);
2071 usb_proc_mwait(USB_BUS_CS_PROC(udev->bus),
2072 &udev->cs_msg[0], &udev->cs_msg[1]);
2073 USB_BUS_UNLOCK(udev->bus);
2076 usb_wait_pending_refs(udev);
2078 sx_destroy(&udev->enum_sx);
2079 sx_destroy(&udev->sr_sx);
2080 sx_destroy(&udev->ctrl_sx);
2082 cv_destroy(&udev->ctrlreq_cv);
2083 cv_destroy(&udev->ref_cv);
2085 mtx_destroy(&udev->device_mtx);
2087 KASSERT(LIST_FIRST(&udev->pd_list) == NULL, ("leaked cdev entries"));
2092 (bus->methods->device_uninit) (udev);
2095 bsd_free(udev->serial, M_USB);
2096 udev->serial = NULL;
2097 bsd_free(udev->manufacturer, M_USB);
2098 udev->manufacturer = NULL;
2099 bsd_free(udev->product, M_USB);
2100 udev->product = NULL;
2101 bsd_free(udev, M_USB);
2115 usbd_get_iface(struct usb_device *udev, uint8_t iface_index)
2117 struct usb_interface *iface = udev->ifaces + iface_index;
2119 if (iface_index >= udev->ifaces_max)
2140 usbd_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index,
2148 cd = usbd_get_config_descriptor(udev);
2153 iface = usbd_get_iface(udev, iface_index);
2180 * belonging to the USB device pointed to by "udev", to the string
2185 usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len)
2187 struct usb_device_descriptor *udd = &udev->ddesc;
2197 usb_get_manufacturer(udev),
2198 usb_get_product(udev),
2202 udev->address);
2206 usb_get_manufacturer(udev),
2207 usb_get_product(udev),
2210 udev->address);
2233 usbd_set_device_strings(struct usb_device *udev)
2235 struct usb_device_descriptor *udd = &udev->ddesc;
2246 do_unlock = usbd_ctrl_lock(udev);
2248 temp_ptr = (char *)udev->scratch.data;
2249 temp_size = sizeof(udev->scratch.data);
2255 (void)usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2256 udev->ddesc.iSerialNumber);
2257 udev->serial = bsd_strdup(temp_ptr, M_USB);
2260 (void)usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2261 udev->ddesc.iManufacturer);
2264 udev->manufacturer = bsd_strdup(temp_ptr, M_USB);
2267 (void)usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2268 udev->ddesc.iProduct);
2271 udev->product = bsd_strdup(temp_ptr, M_USB);
2274 if ((udev->manufacturer == NULL) || (udev->product == NULL)) {
2283 if (udev->manufacturer == NULL) {
2284 udev->manufacturer = bsd_strdup(kdp->vendorname,
2287 if ((udev->product == NULL) &&
2289 udev->product = bsd_strdup(kdp->productname,
2296 if (udev->manufacturer == NULL) {
2298 udev->manufacturer = bsd_strdup(temp_ptr, M_USB);
2300 if (udev->product == NULL) {
2302 udev->product = bsd_strdup(temp_ptr, M_USB);
2306 usbd_ctrl_unlock(udev);
2314 usbd_get_mode(struct usb_device *udev)
2316 return (udev->flags.usb_mode);
2324 usbd_get_speed(struct usb_device *udev)
2326 return (udev->speed);
2330 usbd_get_isoc_fps(struct usb_device *udev)
2333 switch (udev->speed) {
2343 usbd_get_device_descriptor(struct usb_device *udev)
2345 if (udev == NULL)
2347 return (&udev->ddesc);
2351 usbd_get_config_descriptor(struct usb_device *udev)
2353 if (udev == NULL)
2355 return (udev->cdesc);
2403 usbd_get_bus_index(struct usb_device *udev)
2405 return ((uint8_t)device_get_unit(udev->bus->bdev));
2409 usbd_get_device_index(struct usb_device *udev)
2411 return (udev->device_index);
2416 usb_notify_addq(const char *type, struct usb_device *udev)
2442 udev->ugen_name,
2443 udev->ugen_name,
2445 UGETW(udev->ddesc.idVendor),
2446 UGETW(udev->ddesc.idProduct),
2447 udev->ddesc.bDeviceClass,
2448 udev->ddesc.bDeviceSubClass,
2449 usb_get_serial(udev),
2450 UGETW(udev->ddesc.bcdDevice),
2451 (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
2452 udev->port_no
2454 , udev->parent_hub != NULL ?
2455 udev->parent_hub->ugen_name :
2456 device_get_nameunit(device_get_parent(udev->bus->bdev))
2465 iface = usbd_get_iface(udev, i);
2490 udev->ugen_name,
2491 udev->ugen_name,
2493 UGETW(udev->ddesc.idVendor),
2494 UGETW(udev->ddesc.idProduct),
2495 udev->ddesc.bDeviceClass,
2496 udev->ddesc.bDeviceSubClass,
2497 usb_get_serial(udev),
2498 UGETW(udev->ddesc.bcdDevice),
2499 (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
2526 usb_fifo_free_wrap(struct usb_device *udev,
2536 f = udev->fifo[i];
2580 usb_peer_can_wakeup(struct usb_device *udev)
2584 cdp = udev->cdesc;
2585 if ((cdp != NULL) && (udev->flags.usb_mode == USB_MODE_HOST)) {
2592 usb_set_device_state(struct usb_device *udev, enum usb_dev_state state)
2595 KASSERT(state < USB_STATE_MAX, ("invalid udev state"));
2597 DPRINTF("udev %p state %s -> %s\n", udev,
2598 usb_statestr(udev->state), usb_statestr(state));
2603 udev->state = state;
2607 if (udev->bus->methods->device_state_change != NULL)
2608 (udev->bus->methods->device_state_change) (udev);
2612 usb_get_device_state(struct usb_device *udev)
2614 if (udev == NULL)
2616 return (udev->state);
2620 usbd_device_attached(struct usb_device *udev)
2622 return (udev->state > USB_STATE_DETACHED);
2631 usbd_enum_lock(struct usb_device *udev)
2633 if (sx_xlocked(&udev->enum_sx))
2636 sx_xlock(&udev->enum_sx);
2637 sx_xlock(&udev->sr_sx);
2652 usbd_enum_unlock(struct usb_device *udev)
2655 sx_xunlock(&udev->enum_sx);
2656 sx_xunlock(&udev->sr_sx);
2662 usbd_sr_lock(struct usb_device *udev)
2664 sx_xlock(&udev->sr_sx);
2676 usbd_sr_unlock(struct usb_device *udev)
2679 sx_xunlock(&udev->sr_sx);
2688 usbd_enum_is_locked(struct usb_device *udev)
2690 return (sx_xlocked(&udev->enum_sx));
2699 usbd_ctrl_lock(struct usb_device *udev)
2701 if (sx_xlocked(&udev->ctrl_sx))
2703 sx_xlock(&udev->ctrl_sx);
2709 if (usbd_enum_is_locked(udev))
2710 usbd_sr_unlock(udev);
2715 usbd_ctrl_unlock(struct usb_device *udev)
2717 sx_xunlock(&udev->ctrl_sx);
2723 if (usbd_enum_is_locked(udev))
2724 usbd_sr_lock(udev);
2737 usbd_set_pnpinfo(struct usb_device *udev, uint8_t iface_index, const char *pnpinfo)
2741 iface = usbd_get_iface(udev, iface_index);
2761 usbd_add_dynamic_quirk(struct usb_device *udev, uint16_t quirk)
2766 if ((udev->autoQuirk[x] == 0) ||
2767 (udev->autoQuirk[x] == quirk)) {
2768 udev->autoQuirk[x] = quirk;
2781 usbd_set_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep,
2788 do_unlock = usbd_enum_lock(udev);
2790 if (udev->bus->methods->set_endpoint_mode != NULL) {
2791 error = (udev->bus->methods->set_endpoint_mode) (
2792 udev, ep, ep_mode);
2803 usbd_enum_unlock(udev);
2809 usbd_get_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep)