Lines Matching defs:udev
139 struct usb_device *udev;
155 udev = bus->devices[USB_ROOT_HUB_ADDR];
157 if (udev->refcount == USB_DEV_REF_MAX) {
162 udev->refcount++;
165 do_unlock = usbd_enum_lock(udev);
171 err = usbd_req_get_port_status(udev, NULL, &ps, 1);
182 err = usbd_req_set_port_feature(udev, NULL, 1,
189 err = usbd_req_clear_port_feature(udev, NULL, 1,
200 usbd_enum_unlock(udev);
201 if (--(udev->refcount) == 0)
202 cv_broadcast(&udev->ref_cv);
280 usb_get_manufacturer(struct usb_device *udev)
282 return (udev->manufacturer ? udev->manufacturer : "Unknown");
286 usb_get_product(struct usb_device *udev)
288 return (udev->product ? udev->product : "");
292 usb_get_serial(struct usb_device *udev)
294 return (udev->serial ? udev->serial : "");
308 usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val)
310 struct usb_endpoint *ep = udev->endpoints;
311 struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
339 if ((udev->ctrl_ep.edesc != NULL) &&
340 ((udev->ctrl_ep.edesc->bEndpointAddress & EA_MASK) == ea_val)) {
341 ep = &udev->ctrl_ep;
361 usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index,
364 struct usb_endpoint *ep = udev->endpoints;
365 struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
372 DPRINTFN(10, "udev=%p iface_index=%d address=0x%x "
374 udev, iface_index, setup->endpoint,
380 udev->flags.usb_mode != setup->usb_mode) {
389 ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ?
393 ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ?
434 * the endpoints from the beginning of the "udev->endpoints" array.
456 if ((udev->ctrl_ep.edesc != NULL) &&
457 ((udev->ctrl_ep.edesc->bEndpointAddress & ea_mask) == ea_val) &&
458 ((udev->ctrl_ep.edesc->bmAttributes & type_mask) == type_val) &&
460 ep = &udev->ctrl_ep;
481 usbd_interface_count(struct usb_device *udev, uint8_t *count)
483 if (udev->cdesc == NULL) {
487 *count = udev->ifaces_max;
499 usb_init_endpoint(struct usb_device *udev, uint8_t iface_index,
507 methods = udev->bus->methods;
509 (methods->endpoint_init) (udev, edesc, ep);
527 if (udev->speed == USB_SPEED_SUPER && ecomp != NULL &&
530 usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_STREAMS);
532 usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_DEFAULT);
537 USB_BUS_LOCK(udev->bus);
538 (methods->clear_stall) (udev, ep);
539 USB_BUS_UNLOCK(udev->bus);
554 usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep)
559 if (udev == NULL)
562 ep_end = udev->endpoints + udev->endpoints_max;
566 ep = udev->endpoints;
586 usb_wait_pending_refs(struct usb_device *udev)
589 DPRINTF("Refcount = %d\n", (int)udev->refcount);
592 udev->refcount--;
595 if (udev->refcount == 0) {
597 udev->refcount = USB_DEV_REF_MAX;
600 cv_wait(&udev->ref_cv, &usb_ref_lock);
615 usb_unconfigure(struct usb_device *udev, uint8_t flag)
620 do_unlock = usbd_enum_lock(udev);
623 usb_detach_device(udev, USB_IFACE_INDEX_ANY, flag);
627 usb_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag);
632 usb_cdev_free(udev);
637 if (udev->linux_endpoint_start != NULL) {
638 usb_linux_free_device_p(udev);
639 udev->linux_endpoint_start = NULL;
643 usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE);
646 if (udev->cdesc != NULL) {
647 if (udev->flags.usb_mode != USB_MODE_DEVICE)
648 usbd_free_config_desc(udev, udev->cdesc);
649 udev->cdesc = NULL;
652 udev->curr_config_no = USB_UNCONFIG_NO;
653 udev->curr_config_index = USB_UNCONFIG_INDEX;
656 usbd_enum_unlock(udev);
671 usbd_set_config_index(struct usb_device *udev, uint8_t index)
681 DPRINTFN(6, "udev=%p index=%d\n", udev, index);
684 do_unlock = usbd_enum_lock(udev);
686 usb_unconfigure(udev, 0);
694 err = usbd_req_set_config(udev, NULL, USB_UNCONFIG_NO);
695 if (udev->state == USB_STATE_CONFIGURED)
696 usb_set_device_state(udev, USB_STATE_ADDRESSED);
700 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
702 err = usbd_req_get_descriptor_ptr(udev, &cdp,
706 err = usbd_req_get_config_desc_full(udev,
714 udev->cdesc = cdp;
718 if ((!udev->flags.uq_bus_powered) &&
720 (udev->flags.usb_mode == USB_MODE_HOST)) {
724 err = usbd_req_get_device_status(udev, NULL, &ds);
737 DPRINTF("udev=%p cdesc=%p (addr %d) cno=%d attr=0x%02x, "
739 udev, cdp,
740 udev->address, cdp->bConfigurationValue, cdp->bmAttributes,
746 if (udev->parent_hub) {
747 max_power = udev->parent_hub->hub->portpower;
758 if (udev->flags.usb_mode == USB_MODE_HOST) {
759 udev->flags.self_powered = selfpowered;
761 udev->power = power;
762 udev->curr_config_no = cdp->bConfigurationValue;
763 udev->curr_config_index = index;
764 usb_set_device_state(udev, USB_STATE_CONFIGURED);
767 err = usbd_req_set_config(udev, NULL, cdp->bConfigurationValue);
772 err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC);
777 err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT);
784 usb_cdev_create(udev);
790 usb_unconfigure(udev, 0);
793 usbd_enum_unlock(udev);
815 usb_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
844 sx_assert(&udev->enum_sx, SA_LOCKED);
849 ep = udev->endpoints;
850 ep_max = udev->endpoints_max;
862 ep = udev->endpoints;
863 ep_max = udev->endpoints_max;
878 udev->bus->methods->endpoint_uninit != NULL)
879 udev->bus->methods->endpoint_uninit(udev, ep);
898 while ((id = usb_idesc_foreach(udev->cdesc, &ips))) {
899 iface = udev->ifaces + ips.iface_index;
947 while ((ed = usb_edesc_foreach(udev->cdesc, ed))) {
954 ep = udev->endpoints + temp;
959 ecomp = usb_ed_comp_foreach(udev->cdesc, (void *)ed);
963 usb_init_endpoint(udev,
978 udev->ifaces_max = ips.iface_index;
980 udev->ifaces = NULL;
981 if (udev->ifaces_max != 0) {
982 udev->ifaces = malloc(sizeof(*iface) * udev->ifaces_max,
984 if (udev->ifaces == NULL) {
992 udev->endpoints = malloc(sizeof(*ep) * ep_max,
994 if (udev->endpoints == NULL) {
999 udev->endpoints = NULL;
1002 USB_BUS_LOCK(udev->bus);
1003 udev->endpoints_max = ep_max;
1005 udev->ep_curr = NULL;
1006 USB_BUS_UNLOCK(udev->bus);
1014 USB_BUS_LOCK(udev->bus);
1015 udev->endpoints_max = 0;
1017 udev->ep_curr = NULL;
1018 USB_BUS_UNLOCK(udev->bus);
1021 free(udev->ifaces, M_USB);
1022 udev->ifaces = NULL;
1025 free(udev->endpoints, M_USB);
1026 udev->endpoints = NULL;
1028 udev->ifaces_max = 0;
1049 usbd_set_alt_interface_index(struct usb_device *udev,
1052 struct usb_interface *iface = usbd_get_iface(udev, iface_index);
1057 do_unlock = usbd_enum_lock(udev);
1076 usb_fifo_free_wrap(udev, iface_index, 0);
1079 err = usb_config_parse(udev, iface_index, alt_index);
1089 err = usbd_req_set_alt_interface_no(udev, NULL, iface_index,
1094 usbd_enum_unlock(udev);
1109 usbd_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep,
1139 USB_BUS_LOCK(udev->bus);
1147 USB_BUS_UNLOCK(udev->bus);
1167 (udev->bus->methods->xfer_stall) (xfer);
1171 (udev->bus->methods->set_stall) (udev, ep, &do_stall);
1177 (udev->bus->methods->clear_stall) (udev, ep);
1185 USB_BUS_UNLOCK(udev->bus);
1193 usb_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
1198 ep = udev->endpoints;
1199 ep_end = udev->endpoints + udev->endpoints_max;
1207 usbd_set_endpoint_stall(udev, ep, 0);
1221 usb_detach_device_sub(struct usb_device *udev, device_t *ppdev,
1240 device_get_nameunit(udev->parent_dev),
1241 udev->port_no, udev->address);
1245 if (udev->flags.peer_suspended) {
1253 if (device_delete_child(udev->parent_dev, dev)) {
1279 usb_detach_device(struct usb_device *udev, uint8_t iface_index,
1285 if (udev == NULL) {
1289 DPRINTFN(4, "udev=%p\n", udev);
1291 sx_assert(&udev->enum_sx, SA_LOCKED);
1310 iface = usbd_get_iface(udev, i);
1315 usb_detach_device_sub(udev, &iface->subdev,
1328 usb_probe_and_attach_sub(struct usb_device *udev,
1352 if (device_delete_child(udev->parent_dev, dev)) {
1363 uaa->temp_dev = device_add_child(udev->parent_dev, NULL, DEVICE_UNIT_ANY);
1365 device_printf(udev->parent_dev,
1386 if (udev->flags.peer_suspended) {
1410 usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
1415 if (udev == NULL || iface_index == parent_index) {
1419 iface = usbd_get_iface(udev, iface_index);
1425 usb_init_attach_arg(struct usb_device *udev,
1430 uaa->device = udev;
1431 uaa->usb_mode = udev->flags.usb_mode;
1432 uaa->port = udev->port_no;
1435 uaa->info.idVendor = UGETW(udev->ddesc.idVendor);
1436 uaa->info.idProduct = UGETW(udev->ddesc.idProduct);
1437 uaa->info.bcdDevice = UGETW(udev->ddesc.bcdDevice);
1438 uaa->info.bDeviceClass = udev->ddesc.bDeviceClass;
1439 uaa->info.bDeviceSubClass = udev->ddesc.bDeviceSubClass;
1440 uaa->info.bDeviceProtocol = udev->ddesc.bDeviceProtocol;
1441 uaa->info.bConfigIndex = udev->curr_config_index;
1442 uaa->info.bConfigNum = udev->curr_config_no;
1456 usb_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
1464 if (udev == NULL) {
1465 DPRINTF("udev == NULL\n");
1469 do_unlock = usbd_enum_lock(udev);
1471 if (udev->curr_config_index == USB_UNCONFIG_INDEX) {
1477 usb_init_attach_arg(udev, &uaa);
1485 usb_dymo_eject(udev, 0) == 0) {
1486 /* success, mark the udev as disappearing */
1490 EVENTHANDLER_INVOKE(usb_dev_configured, udev, &uaa);
1494 usb_unconfigure(udev, 0);
1510 iface = usbd_get_iface(udev, i);
1544 usb_probe_and_attach_sub(udev, &uaa);
1553 if (device_delete_child(udev->parent_dev, uaa.temp_dev))
1559 usbd_enum_unlock(udev);
1570 usb_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend)
1601 usb_suspend_resume(struct usb_device *udev, uint8_t do_suspend)
1606 if (udev == NULL) {
1610 DPRINTFN(4, "udev=%p do_suspend=%d\n", udev, do_suspend);
1612 sx_assert(&udev->sr_sx, SA_LOCKED);
1614 USB_BUS_LOCK(udev->bus);
1616 if (udev->flags.peer_suspended == do_suspend) {
1617 USB_BUS_UNLOCK(udev->bus);
1621 udev->flags.peer_suspended = do_suspend;
1622 USB_BUS_UNLOCK(udev->bus);
1627 iface = usbd_get_iface(udev, i);
1632 usb_suspend_resume_sub(udev, iface->subdev, do_suspend);
1646 struct usb_device *udev = pm->udev;
1649 USB_BUS_UNLOCK(udev->bus);
1650 USB_MTX_LOCK(&udev->device_mtx);
1653 usbd_transfer_start(udev->ctrl_xfer[1]);
1656 USB_MTX_UNLOCK(&udev->device_mtx);
1657 USB_BUS_LOCK(udev->bus);
1666 usb_get_langid(struct usb_device *udev)
1685 do_unlock = usbd_ctrl_lock(udev);
1687 scratch_ptr = udev->scratch.data;
1689 if (udev->flags.no_strings) {
1691 } else if (udev->ddesc.iManufacturer ||
1692 udev->ddesc.iProduct ||
1693 udev->ddesc.iSerialNumber) {
1695 err = usbd_req_get_string_desc(udev, NULL,
1702 udev->flags.no_strings = 1;
1732 udev->langid = langid;
1736 usbd_ctrl_unlock(udev);
1757 struct usb_device *udev;
1794 udev = malloc(sizeof(*udev), M_USB, M_WAITOK | M_ZERO);
1796 if (udev == NULL) {
1801 sx_init_flags(&udev->enum_sx, "USB config SX lock", SX_DUPOK);
1802 sx_init_flags(&udev->sr_sx, "USB suspend and resume SX lock", SX_NOWITNESS);
1803 sx_init_flags(&udev->ctrl_sx, "USB control transfer SX lock", SX_DUPOK);
1805 cv_init(&udev->ctrlreq_cv, "WCTRL");
1806 cv_init(&udev->ref_cv, "UGONE");
1809 mtx_init(&udev->device_mtx, "USB device mutex", NULL, MTX_DEF);
1812 udev->cs_msg[0].hdr.pm_callback = &usbd_clear_stall_proc;
1813 udev->cs_msg[0].udev = udev;
1814 udev->cs_msg[1].hdr.pm_callback = &usbd_clear_stall_proc;
1815 udev->cs_msg[1].udev = udev;
1818 udev->parent_hub = parent_hub;
1819 udev->parent_dev = parent_dev;
1820 udev->port_index = port_index;
1821 udev->port_no = port_no;
1822 udev->depth = depth;
1823 udev->bus = bus;
1824 udev->address = USB_START_ADDR; /* default value */
1825 udev->plugtime = (usb_ticks_t)ticks;
1831 udev->power_mode = usbd_filter_power_mode(udev, USB_POWER_MODE_ON);
1832 udev->pwr_save.last_xfer_time = ticks;
1834 udev->refcount = 1;
1837 udev->ctrl_ep_desc.bLength = sizeof(udev->ctrl_ep_desc);
1838 udev->ctrl_ep_desc.bDescriptorType = UDESC_ENDPOINT;
1839 udev->ctrl_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT;
1840 udev->ctrl_ep_desc.bmAttributes = UE_CONTROL;
1841 udev->ctrl_ep_desc.wMaxPacketSize[0] = USB_MAX_IPACKET;
1842 udev->ctrl_ep_desc.wMaxPacketSize[1] = 0;
1843 udev->ctrl_ep_desc.bInterval = 0;
1846 udev->ctrl_ep_comp_desc.bLength = sizeof(udev->ctrl_ep_comp_desc);
1847 udev->ctrl_ep_comp_desc.bDescriptorType = UDESC_ENDPOINT_SS_COMP;
1849 udev->ddesc.bMaxPacketSize = USB_MAX_IPACKET;
1851 udev->speed = speed;
1852 udev->flags.usb_mode = mode;
1856 adev = udev;
1857 hub = udev->parent_hub;
1861 udev->hs_hub_addr = hub->address;
1862 udev->parent_hs_hub = hub;
1863 udev->hs_port_no = adev->port_no;
1871 usb_init_endpoint(udev, 0,
1872 &udev->ctrl_ep_desc,
1873 &udev->ctrl_ep_comp_desc,
1874 &udev->ctrl_ep);
1877 udev->device_index = device_index;
1881 snprintf(udev->ugen_name, sizeof(udev->ugen_name),
1884 SLIST_INIT(&udev->pd_list);
1887 udev->ctrl_dev = usb_make_dev(udev, NULL, 0, 0,
1891 if (udev->ctrl_dev != NULL)
1892 make_dev_alias(udev->ctrl_dev->cdev, "%s", udev->ugen_name);
1896 err = (bus->methods->device_init) (udev);
1905 usb_set_device_state(udev, USB_STATE_POWERED);
1907 if (udev->flags.usb_mode == USB_MODE_HOST) {
1908 err = usbd_req_set_address(udev, NULL, device_index);
1914 if (udev->address == USB_START_ADDR)
1915 udev->address = device_index;
1928 "(%s, ignored)\n", udev->address,
1933 udev->flags.self_powered = 0;
1936 udev->curr_config_no = USB_UNCONFIG_NO;
1937 udev->curr_config_index = USB_UNCONFIG_INDEX;
1940 err = (usb_temp_setup_by_index_p) (udev, usb_template);
1947 usb_set_device_state(udev, USB_STATE_ADDRESSED);
1950 err = usbd_setup_device_desc(udev, NULL);
1954 err = usbd_req_re_enumerate(udev, NULL);
1956 err = usbd_req_re_enumerate(udev, NULL);
1967 usb_init_attach_arg(udev, &uaa);
1970 udev->flags.uq_bus_powered = 1;
1973 udev->flags.no_strings = 1;
1976 usb_get_langid(udev);
1979 udev->power = USB_MIN_POWER;
1981 usb_set_device_strings(udev);
1983 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
2019 err = usbd_set_config_index(udev, config_index);
2021 if (udev->ddesc.bNumConfigurations != 0) {
2025 err = usbd_req_re_enumerate(udev, NULL);
2031 config_index, usbd_errstr(err), udev->port_no,
2032 udev->address);
2041 if (!config_quirk && config_index + 1 < udev->ddesc.bNumConfigurations) {
2042 if ((udev->cdesc->bNumInterface < 2) &&
2043 usbd_get_no_descriptors(udev->cdesc, UDESC_ENDPOINT) == 0) {
2055 if (usb_iface_is_cdrom(udev, 0)) {
2076 err = usb_msc_auto_quirk(udev, 0, &uaa);
2086 DPRINTF("new dev (addr %d), udev=%p, parent_hub=%p\n",
2087 udev->address, udev, udev->parent_hub);
2091 parent_hub->hub->ports + port_index : NULL, udev, device_index);
2095 udev->ugen_symlink = usb_alloc_symlink(udev->ugen_name);
2098 printf("%s: <%s %s> at %s\n", udev->ugen_name,
2099 usb_get_manufacturer(udev), usb_get_product(udev),
2100 device_get_nameunit(udev->bus->bdev));
2104 usb_notify_addq("ATTACH", udev);
2111 usb_free_device(udev, 0);
2112 udev = NULL;
2114 return (udev);
2119 usb_make_dev(struct usb_device *udev, const char *devname, int ep,
2129 pd->bus_index = device_get_unit(udev->bus->bdev);
2130 pd->dev_index = udev->device_index;
2202 usb_cdev_create(struct usb_device *udev)
2211 KASSERT(SLIST_FIRST(&udev->pd_list) == NULL, ("stale cdev entries"));
2215 if (usbd_get_mode(udev) == USB_MODE_DEVICE) {
2231 cd = usbd_get_config_descriptor(udev);
2254 pd = usb_make_dev(udev, NULL, ep, 0,
2258 SLIST_INSERT_HEAD(&udev->pd_list, pd, pd_next);
2263 usb_cdev_free(struct usb_device *udev)
2269 while ((pd = SLIST_FIRST(&udev->pd_list)) != NULL) {
2272 SLIST_REMOVE(&udev->pd_list, pd, usb_fs_privdata, pd_next);
2288 usb_free_device(struct usb_device *udev, uint8_t flag)
2292 if (udev == NULL)
2295 DPRINTFN(4, "udev=%p port=%d\n", udev, udev->port_no);
2297 bus = udev->bus;
2300 usb_set_device_state(udev, USB_STATE_DETACHED);
2303 usb_notify_addq("DETACH", udev);
2308 printf("%s: <%s %s> at %s (disconnected)\n", udev->ugen_name,
2309 usb_get_manufacturer(udev), usb_get_product(udev),
2314 if (udev->ugen_symlink) {
2315 usb_free_symlink(udev->ugen_symlink);
2316 udev->ugen_symlink = NULL;
2319 usb_destroy_dev(udev->ctrl_dev);
2322 if (udev->flags.usb_mode == USB_MODE_DEVICE) {
2324 usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX);
2328 usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_EP0);
2331 usb_bus_port_set_device(bus, udev->parent_hub ?
2332 udev->parent_hub->hub->ports + udev->port_index : NULL,
2336 usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX);
2339 (usb_temp_unsetup_p) (udev);
2345 USB_BUS_LOCK(udev->bus);
2346 usb_proc_mwait(USB_BUS_CS_PROC(udev->bus),
2347 &udev->cs_msg[0], &udev->cs_msg[1]);
2348 USB_BUS_UNLOCK(udev->bus);
2351 usb_wait_pending_refs(udev);
2353 sx_destroy(&udev->enum_sx);
2354 sx_destroy(&udev->sr_sx);
2355 sx_destroy(&udev->ctrl_sx);
2357 cv_destroy(&udev->ctrlreq_cv);
2358 cv_destroy(&udev->ref_cv);
2360 mtx_destroy(&udev->device_mtx);
2362 KASSERT(SLIST_FIRST(&udev->pd_list) == NULL, ("leaked cdev entries"));
2367 (bus->methods->device_uninit) (udev);
2370 free(udev->serial, M_USB);
2371 free(udev->manufacturer, M_USB);
2372 free(udev->product, M_USB);
2373 free(udev, M_USB);
2387 usbd_get_iface(struct usb_device *udev, uint8_t iface_index)
2389 struct usb_interface *iface = udev->ifaces + iface_index;
2391 if (iface_index >= udev->ifaces_max)
2412 usbd_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index,
2420 cd = usbd_get_config_descriptor(udev);
2425 iface = usbd_get_iface(udev, iface_index);
2452 * belonging to the USB device pointed to by "udev", to the string
2457 usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len)
2459 struct usb_device_descriptor *udd = &udev->ddesc;
2469 usb_get_manufacturer(udev),
2470 usb_get_product(udev),
2474 udev->address);
2478 usb_get_manufacturer(udev),
2479 usb_get_product(udev),
2482 udev->address);
2505 usb_set_device_strings(struct usb_device *udev)
2507 struct usb_device_descriptor *udd = &udev->ddesc;
2518 do_unlock = usbd_ctrl_lock(udev);
2520 temp_ptr = (char *)udev->scratch.data;
2521 temp_size = sizeof(udev->scratch.data);
2527 free(udev->serial, M_USB);
2528 free(udev->manufacturer, M_USB);
2529 free(udev->product, M_USB);
2532 udev->serial = NULL;
2533 udev->manufacturer = NULL;
2534 udev->product = NULL;
2537 usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2538 udev->ddesc.iSerialNumber);
2539 udev->serial = strdup(temp_ptr, M_USB);
2542 usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2543 udev->ddesc.iManufacturer);
2546 udev->manufacturer = strdup(temp_ptr, M_USB);
2549 usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2550 udev->ddesc.iProduct);
2553 udev->product = strdup(temp_ptr, M_USB);
2556 if (udev->manufacturer == NULL || udev->product == NULL) {
2565 if (udev->manufacturer == NULL) {
2566 udev->manufacturer = strdup(kdp->vendorname,
2569 if (udev->product == NULL &&
2571 udev->product = strdup(kdp->productname,
2578 if (udev->manufacturer == NULL) {
2580 udev->manufacturer = strdup(temp_ptr, M_USB);
2582 if (udev->product == NULL) {
2584 udev->product = strdup(temp_ptr, M_USB);
2588 usbd_ctrl_unlock(udev);
2596 usbd_get_mode(struct usb_device *udev)
2598 return (udev->flags.usb_mode);
2606 usbd_get_speed(struct usb_device *udev)
2608 return (udev->speed);
2612 usbd_get_isoc_fps(struct usb_device *udev)
2615 switch (udev->speed) {
2625 usbd_get_device_descriptor(struct usb_device *udev)
2627 if (udev == NULL)
2629 return (&udev->ddesc);
2633 usbd_get_config_descriptor(struct usb_device *udev)
2635 if (udev == NULL)
2637 return (udev->cdesc);
2685 usbd_get_bus_index(struct usb_device *udev)
2687 return ((uint8_t)device_get_unit(udev->bus->bdev));
2691 usbd_get_device_index(struct usb_device *udev)
2693 return (udev->device_index);
2698 usb_notify_addq(const char *type, struct usb_device *udev)
2724 udev->ugen_name,
2725 udev->ugen_name,
2727 UGETW(udev->ddesc.idVendor),
2728 UGETW(udev->ddesc.idProduct),
2729 udev->ddesc.bDeviceClass,
2730 udev->ddesc.bDeviceSubClass,
2731 usb_get_serial(udev),
2732 UGETW(udev->ddesc.bcdDevice),
2733 (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
2734 udev->port_no
2736 , udev->parent_hub != NULL ?
2737 udev->parent_hub->ugen_name :
2738 device_get_nameunit(device_get_parent(udev->bus->bdev))
2747 iface = usbd_get_iface(udev, i);
2772 udev->ugen_name,
2773 udev->ugen_name,
2775 UGETW(udev->ddesc.idVendor),
2776 UGETW(udev->ddesc.idProduct),
2777 udev->ddesc.bDeviceClass,
2778 udev->ddesc.bDeviceSubClass,
2779 usb_get_serial(udev),
2780 UGETW(udev->ddesc.bcdDevice),
2781 (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
2808 usb_fifo_free_wrap(struct usb_device *udev,
2818 f = udev->fifo[i];
2862 usb_peer_can_wakeup(struct usb_device *udev)
2866 cdp = udev->cdesc;
2867 if ((cdp != NULL) && (udev->flags.usb_mode == USB_MODE_HOST)) {
2874 usb_set_device_state(struct usb_device *udev, enum usb_dev_state state)
2877 KASSERT(state < USB_STATE_MAX, ("invalid udev state"));
2879 DPRINTF("udev %p state %s -> %s\n", udev,
2880 usb_statestr(udev->state), usb_statestr(state));
2885 udev->state = state;
2889 if (udev->bus->methods->device_state_change != NULL)
2890 (udev->bus->methods->device_state_change) (udev);
2894 usb_get_device_state(struct usb_device *udev)
2896 if (udev == NULL)
2898 return (udev->state);
2902 usbd_device_attached(struct usb_device *udev)
2904 return (udev->state > USB_STATE_DETACHED);
2913 usbd_enum_lock(struct usb_device *udev)
2915 if (sx_xlocked(&udev->enum_sx))
2918 sx_xlock(&udev->enum_sx);
2919 sx_xlock(&udev->sr_sx);
2935 usbd_enum_lock_sig(struct usb_device *udev)
2937 if (sx_xlocked(&udev->enum_sx))
2939 if (sx_xlock_sig(&udev->enum_sx))
2941 if (sx_xlock_sig(&udev->sr_sx)) {
2942 sx_xunlock(&udev->enum_sx);
2953 usbd_enum_unlock(struct usb_device *udev)
2956 sx_xunlock(&udev->enum_sx);
2957 sx_xunlock(&udev->sr_sx);
2963 usbd_sr_lock(struct usb_device *udev)
2965 sx_xlock(&udev->sr_sx);
2977 usbd_sr_unlock(struct usb_device *udev)
2980 sx_xunlock(&udev->sr_sx);
2989 usbd_enum_is_locked(struct usb_device *udev)
2991 return (sx_xlocked(&udev->enum_sx));
3000 usbd_ctrl_lock(struct usb_device *udev)
3002 if (sx_xlocked(&udev->ctrl_sx))
3004 sx_xlock(&udev->ctrl_sx);
3010 if (usbd_enum_is_locked(udev))
3011 usbd_sr_unlock(udev);
3016 usbd_ctrl_unlock(struct usb_device *udev)
3018 sx_xunlock(&udev->ctrl_sx);
3024 if (usbd_enum_is_locked(udev))
3025 usbd_sr_lock(udev);
3038 usbd_set_pnpinfo(struct usb_device *udev, uint8_t iface_index, const char *pnpinfo)
3042 iface = usbd_get_iface(udev, iface_index);
3062 usbd_add_dynamic_quirk(struct usb_device *udev, uint16_t quirk)
3067 if (udev->autoQuirk[x] == 0 ||
3068 udev->autoQuirk[x] == quirk) {
3069 udev->autoQuirk[x] = quirk;
3082 usbd_set_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep,
3089 do_unlock = usbd_enum_lock(udev);
3091 if (udev->bus->methods->set_endpoint_mode != NULL) {
3092 error = (udev->bus->methods->set_endpoint_mode) (
3093 udev, ep, ep_mode);
3104 usbd_enum_unlock(udev);
3109 usbd_get_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep)