1 /* $FreeBSD: head/sys/dev/usb/usb_device.c 269566 2014-08-05 06:38:21Z hselasky $ */
3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/stdint.h>
28 #include <sys/param.h>
29 #include <sys/queue.h>
30 #include <sys/types.h>
31 #include <sys/systm.h>
32 #include <sys/kernel.h>
34 #include <sys/module.h>
36 #include <sys/condvar.h>
37 #include <sys/sysctl.h>
38 #include <sys/unistd.h>
39 #include <sys/callout.h>
40 #include <sys/malloc.h>
43 #include <sys/fcntl.h>
44 #include <sys/devfs.h>
46 #include <bus/u4b/usb.h>
47 #include <bus/u4b/usbdi.h>
48 #include <bus/u4b/usbdi_util.h>
49 #include <bus/u4b/usb_ioctl.h>
57 #define USB_DEBUG_VAR usb_debug
59 #include <bus/u4b/usb_core.h>
60 #include <bus/u4b/usb_debug.h>
61 #include <bus/u4b/usb_process.h>
62 #include <bus/u4b/usb_device.h>
63 #include <bus/u4b/usb_busdma.h>
64 #include <bus/u4b/usb_transfer.h>
65 #include <bus/u4b/usb_request.h>
66 #include <bus/u4b/usb_dynamic.h>
67 #include <bus/u4b/usb_hub.h>
68 #include <bus/u4b/usb_util.h>
69 #include <bus/u4b/usb_msctest.h>
71 #include <bus/u4b/usb_dev.h>
72 #include <bus/u4b/usb_generic.h>
75 #include <bus/u4b/quirk/usb_quirk.h>
77 #include <bus/u4b/usb_controller.h>
78 #include <bus/u4b/usb_bus.h>
80 /* function prototypes */
82 static void usb_init_endpoint(struct usb_device
*, uint8_t,
83 struct usb_endpoint_descriptor
*,
84 struct usb_endpoint_ss_comp_descriptor
*,
85 struct usb_endpoint
*);
86 static void usb_unconfigure(struct usb_device
*, uint8_t);
87 static void usb_detach_device_sub(struct usb_device
*, device_t
*,
89 static uint8_t usb_probe_and_attach_sub(struct usb_device
*,
90 struct usb_attach_arg
*);
91 static void usb_init_attach_arg(struct usb_device
*,
92 struct usb_attach_arg
*);
93 static void usb_suspend_resume_sub(struct usb_device
*, device_t
,
95 static usb_proc_callback_t usbd_clear_stall_proc
;
96 static usb_error_t
usb_config_parse(struct usb_device
*, uint8_t, uint8_t);
97 static void usbd_set_device_strings(struct usb_device
*);
99 static void usb_notify_addq(const char *type
, struct usb_device
*);
102 static void usb_fifo_free_wrap(struct usb_device
*, uint8_t, uint8_t);
103 static void usb_cdev_create(struct usb_device
*);
104 static void usb_cdev_free(struct usb_device
*);
107 /* This variable is global to allow easy access to it: */
110 int usb_template
= USB_TEMPLATE
;
115 TUNABLE_INT("hw.usb.usb_template", &usb_template
);
116 SYSCTL_INT(_hw_usb
, OID_AUTO
, template, CTLFLAG_RW
,
117 &usb_template
, 0, "Selected USB device side template");
119 /* English is default language */
121 static int usb_lang_id
= 0x0009;
122 static int usb_lang_mask
= 0x00FF;
124 TUNABLE_INT("hw.usb.usb_lang_id", &usb_lang_id
);
125 SYSCTL_INT(_hw_usb
, OID_AUTO
, usb_lang_id
, CTLFLAG_RW
,
126 &usb_lang_id
, 0, "Preferred USB language ID");
128 TUNABLE_INT("hw.usb.usb_lang_mask", &usb_lang_mask
);
129 SYSCTL_INT(_hw_usb
, OID_AUTO
, usb_lang_mask
, CTLFLAG_RW
,
130 &usb_lang_mask
, 0, "Preferred USB language mask");
132 static const char* statestr
[USB_STATE_MAX
] = {
133 [USB_STATE_DETACHED
] = "DETACHED",
134 [USB_STATE_ATTACHED
] = "ATTACHED",
135 [USB_STATE_POWERED
] = "POWERED",
136 [USB_STATE_ADDRESSED
] = "ADDRESSED",
137 [USB_STATE_CONFIGURED
] = "CONFIGURED",
141 usb_statestr(enum usb_dev_state state
)
143 return ((state
< USB_STATE_MAX
) ? statestr
[state
] : "UNKNOWN");
147 usb_get_manufacturer(struct usb_device
*udev
)
149 return (udev
->manufacturer
? udev
->manufacturer
: "Unknown");
153 usb_get_product(struct usb_device
*udev
)
155 return (udev
->product
? udev
->product
: "");
159 usb_get_serial(struct usb_device
*udev
)
161 return (udev
->serial
? udev
->serial
: "");
164 /*------------------------------------------------------------------------*
165 * usbd_get_ep_by_addr
167 * This function searches for an USB ep by endpoint address and
173 *------------------------------------------------------------------------*/
174 struct usb_endpoint
*
175 usbd_get_ep_by_addr(struct usb_device
*udev
, uint8_t ea_val
)
177 struct usb_endpoint
*ep
= udev
->endpoints
;
178 struct usb_endpoint
*ep_end
= udev
->endpoints
+ udev
->endpoints_max
;
180 EA_MASK
= (UE_DIR_IN
| UE_DIR_OUT
| UE_ADDR
),
184 * According to the USB specification not all bits are used
185 * for the endpoint address. Keep defined bits only:
190 * Iterate accross all the USB endpoints searching for a match
191 * based on the endpoint address:
193 for (; ep
!= ep_end
; ep
++) {
195 if (ep
->edesc
== NULL
) {
198 /* do the mask and check the value */
199 if ((ep
->edesc
->bEndpointAddress
& EA_MASK
) == ea_val
) {
205 * The default endpoint is always present and is checked separately:
207 if ((udev
->ctrl_ep
.edesc
!= NULL
) &&
208 ((udev
->ctrl_ep
.edesc
->bEndpointAddress
& EA_MASK
) == ea_val
)) {
218 /*------------------------------------------------------------------------*
221 * This function searches for an USB endpoint based on the information
222 * given by the passed "struct usb_config" pointer.
226 * Else: Pointer to "struct usb_endpoint".
227 *------------------------------------------------------------------------*/
228 struct usb_endpoint
*
229 usbd_get_endpoint(struct usb_device
*udev
, uint8_t iface_index
,
230 const struct usb_config
*setup
)
232 struct usb_endpoint
*ep
= udev
->endpoints
;
233 struct usb_endpoint
*ep_end
= udev
->endpoints
+ udev
->endpoints_max
;
234 uint8_t index
= setup
->ep_index
;
240 DPRINTFN(10, "udev=%p iface_index=%d address=0x%x "
241 "type=0x%x dir=0x%x index=%d\n",
242 udev
, iface_index
, setup
->endpoint
,
243 setup
->type
, setup
->direction
, setup
->ep_index
);
247 if (setup
->usb_mode
!= USB_MODE_DUAL
&&
248 udev
->flags
.usb_mode
!= setup
->usb_mode
) {
249 /* wrong mode - no endpoint */
253 /* setup expected endpoint direction mask and value */
255 if (setup
->direction
== UE_DIR_RX
) {
256 ea_mask
= (UE_DIR_IN
| UE_DIR_OUT
);
257 ea_val
= (udev
->flags
.usb_mode
== USB_MODE_DEVICE
) ?
258 UE_DIR_OUT
: UE_DIR_IN
;
259 } else if (setup
->direction
== UE_DIR_TX
) {
260 ea_mask
= (UE_DIR_IN
| UE_DIR_OUT
);
261 ea_val
= (udev
->flags
.usb_mode
== USB_MODE_DEVICE
) ?
262 UE_DIR_IN
: UE_DIR_OUT
;
263 } else if (setup
->direction
== UE_DIR_ANY
) {
264 /* match any endpoint direction */
268 /* match the given endpoint direction */
269 ea_mask
= (UE_DIR_IN
| UE_DIR_OUT
);
270 ea_val
= (setup
->direction
& (UE_DIR_IN
| UE_DIR_OUT
));
273 /* setup expected endpoint address */
275 if (setup
->endpoint
== UE_ADDR_ANY
) {
276 /* match any endpoint address */
278 /* match the given endpoint address */
280 ea_val
|= (setup
->endpoint
& UE_ADDR
);
283 /* setup expected endpoint type */
285 if (setup
->type
== UE_BULK_INTR
) {
286 /* this will match BULK and INTERRUPT endpoints */
289 } else if (setup
->type
== UE_TYPE_ANY
) {
290 /* match any endpoint type */
294 /* match the given endpoint type */
295 type_mask
= UE_XFERTYPE
;
296 type_val
= (setup
->type
& UE_XFERTYPE
);
300 * Iterate accross all the USB endpoints searching for a match
301 * based on the endpoint address. Note that we are searching
302 * the endpoints from the beginning of the "udev->endpoints" array.
304 for (; ep
!= ep_end
; ep
++) {
306 if ((ep
->edesc
== NULL
) ||
307 (ep
->iface_index
!= iface_index
)) {
310 /* do the masks and check the values */
312 if (((ep
->edesc
->bEndpointAddress
& ea_mask
) == ea_val
) &&
313 ((ep
->edesc
->bmAttributes
& type_mask
) == type_val
)) {
321 * Match against default endpoint last, so that "any endpoint", "any
322 * address" and "any direction" returns the first endpoint of the
323 * interface. "iface_index" and "direction" is ignored:
325 if ((udev
->ctrl_ep
.edesc
!= NULL
) &&
326 ((udev
->ctrl_ep
.edesc
->bEndpointAddress
& ea_mask
) == ea_val
) &&
327 ((udev
->ctrl_ep
.edesc
->bmAttributes
& type_mask
) == type_val
) &&
338 /*------------------------------------------------------------------------*
339 * usbd_interface_count
341 * This function stores the number of USB interfaces excluding
342 * alternate settings, which the USB config descriptor reports into
343 * the unsigned 8-bit integer pointed to by "count".
348 *------------------------------------------------------------------------*/
350 usbd_interface_count(struct usb_device
*udev
, uint8_t *count
)
352 if (udev
->cdesc
== NULL
) {
354 return (USB_ERR_NOT_CONFIGURED
);
356 *count
= udev
->ifaces_max
;
357 return (USB_ERR_NORMAL_COMPLETION
);
360 /*------------------------------------------------------------------------*
363 * This function will initialise the USB endpoint structure pointed to by
364 * the "endpoint" argument. The structure pointed to by "endpoint" must be
365 * zeroed before calling this function.
366 *------------------------------------------------------------------------*/
368 usb_init_endpoint(struct usb_device
*udev
, uint8_t iface_index
,
369 struct usb_endpoint_descriptor
*edesc
,
370 struct usb_endpoint_ss_comp_descriptor
*ecomp
,
371 struct usb_endpoint
*ep
)
373 const struct usb_bus_methods
*methods
;
376 methods
= udev
->bus
->methods
;
378 (methods
->endpoint_init
) (udev
, edesc
, ep
);
380 /* initialise USB endpoint structure */
383 ep
->iface_index
= iface_index
;
385 /* setup USB stream queues */
386 for (x
= 0; x
!= USB_MAX_EP_STREAMS
; x
++) {
387 TAILQ_INIT(&ep
->endpoint_q
[x
].head
);
388 ep
->endpoint_q
[x
].command
= &usbd_pipe_start
;
391 /* the pipe is not supported by the hardware */
392 if (ep
->methods
== NULL
)
395 /* check for SUPER-speed streams mode endpoint */
396 if (udev
->speed
== USB_SPEED_SUPER
&& ecomp
!= NULL
&&
397 (edesc
->bmAttributes
& UE_XFERTYPE
) == UE_BULK
&&
398 (UE_GET_BULK_STREAMS(ecomp
->bmAttributes
) != 0)) {
399 usbd_set_endpoint_mode(udev
, ep
, USB_EP_MODE_STREAMS
);
401 usbd_set_endpoint_mode(udev
, ep
, USB_EP_MODE_DEFAULT
);
404 /* clear stall, if any */
405 if (methods
->clear_stall
!= NULL
) {
406 USB_BUS_LOCK(udev
->bus
);
407 (methods
->clear_stall
) (udev
, ep
);
408 USB_BUS_UNLOCK(udev
->bus
);
412 /*-----------------------------------------------------------------------*
413 * usb_endpoint_foreach
415 * This function will iterate all the USB endpoints except the control
416 * endpoint. This function is NULL safe.
419 * NULL: End of USB endpoints
420 * Else: Pointer to next USB endpoint
421 *------------------------------------------------------------------------*/
422 struct usb_endpoint
*
423 usb_endpoint_foreach(struct usb_device
*udev
, struct usb_endpoint
*ep
)
425 struct usb_endpoint
*ep_end
;
431 ep_end
= udev
->endpoints
+ udev
->endpoints_max
;
433 /* get next endpoint */
435 ep
= udev
->endpoints
;
439 /* find next allocated ep */
440 while (ep
!= ep_end
) {
441 if (ep
->edesc
!= NULL
)
448 /*------------------------------------------------------------------------*
449 * usb_wait_pending_refs
451 * This function will wait for any USB references to go away before
452 * returning. This function is used before freeing a USB device.
453 *------------------------------------------------------------------------*/
455 usb_wait_pending_refs(struct usb_device
*udev
)
458 DPRINTF("Refcount = %d\n", (int)udev
->refcount
);
460 lockmgr(&usb_ref_lock
, LK_EXCLUSIVE
);
463 /* wait for any pending references to go away */
464 if (udev
->refcount
== 0) {
465 /* prevent further refs being taken, if any */
466 udev
->refcount
= USB_DEV_REF_MAX
;
469 cv_wait(&udev
->ref_cv
, &usb_ref_lock
);
471 lockmgr(&usb_ref_lock
, LK_RELEASE
);
475 /*------------------------------------------------------------------------*
478 * This function will free all USB interfaces and USB endpoints belonging
481 * Flag values, see "USB_UNCFG_FLAG_XXX".
482 *------------------------------------------------------------------------*/
484 usb_unconfigure(struct usb_device
*udev
, uint8_t flag
)
488 /* Prevent re-enumeration */
489 do_unlock
= usbd_enum_lock(udev
);
491 /* detach all interface drivers */
492 usb_detach_device(udev
, USB_IFACE_INDEX_ANY
, flag
);
495 /* free all FIFOs except control endpoint FIFOs */
496 usb_fifo_free_wrap(udev
, USB_IFACE_INDEX_ANY
, flag
);
499 * Free all cdev's, if any.
504 #if USB_HAVE_COMPAT_LINUX
505 /* free Linux compat device, if any */
506 if (udev
->linux_endpoint_start
) {
507 usb_linux_free_device(udev
);
508 udev
->linux_endpoint_start
= NULL
;
512 usb_config_parse(udev
, USB_IFACE_INDEX_ANY
, USB_CFG_FREE
);
514 /* free "cdesc" after "ifaces" and "endpoints", if any */
515 if (udev
->cdesc
!= NULL
) {
516 if (udev
->flags
.usb_mode
!= USB_MODE_DEVICE
)
517 usbd_free_config_desc(udev
, udev
->cdesc
);
520 /* set unconfigured state */
521 udev
->curr_config_no
= USB_UNCONFIG_NO
;
522 udev
->curr_config_index
= USB_UNCONFIG_INDEX
;
525 usbd_enum_unlock(udev
);
528 /*------------------------------------------------------------------------*
529 * usbd_set_config_index
531 * This function selects configuration by index, independent of the
532 * actual configuration number. This function should not be used by
538 *------------------------------------------------------------------------*/
540 usbd_set_config_index(struct usb_device
*udev
, uint8_t index
)
542 struct usb_status ds
;
543 struct usb_config_descriptor
*cdp
;
550 DPRINTFN(6, "udev=%p index=%d\n", udev
, index
);
552 /* Prevent re-enumeration */
553 do_unlock
= usbd_enum_lock(udev
);
555 usb_unconfigure(udev
, 0);
557 if (index
== USB_UNCONFIG_INDEX
) {
559 * Leave unallocated when unconfiguring the
560 * device. "usb_unconfigure()" will also reset
561 * the current config number and index.
563 err
= usbd_req_set_config(udev
, NULL
, USB_UNCONFIG_NO
);
564 if (udev
->state
== USB_STATE_CONFIGURED
)
565 usb_set_device_state(udev
, USB_STATE_ADDRESSED
);
568 /* get the full config descriptor */
569 if (udev
->flags
.usb_mode
== USB_MODE_DEVICE
) {
570 /* save some memory */
571 err
= usbd_req_get_descriptor_ptr(udev
, &cdp
,
572 (UDESC_CONFIG
<< 8) | index
);
575 err
= usbd_req_get_config_desc_full(udev
,
581 /* set the new config descriptor */
585 /* Figure out if the device is self or bus powered. */
587 if ((!udev
->flags
.uq_bus_powered
) &&
588 (cdp
->bmAttributes
& UC_SELF_POWERED
) &&
589 (udev
->flags
.usb_mode
== USB_MODE_HOST
)) {
590 /* May be self powered. */
591 if (cdp
->bmAttributes
& UC_BUS_POWERED
) {
592 /* Must ask device. */
593 err
= usbd_req_get_device_status(udev
, NULL
, &ds
);
595 DPRINTFN(0, "could not read "
596 "device status: %s\n",
598 } else if (UGETW(ds
.wStatus
) & UDS_SELF_POWERED
) {
601 DPRINTF("status=0x%04x \n",
606 DPRINTF("udev=%p cdesc=%p (addr %d) cno=%d attr=0x%02x, "
607 "selfpowered=%d, power=%d\n",
609 udev
->address
, cdp
->bConfigurationValue
, cdp
->bmAttributes
,
610 selfpowered
, cdp
->bMaxPower
* 2);
612 /* Check if we have enough power. */
613 power
= cdp
->bMaxPower
* 2;
615 if (udev
->parent_hub
) {
616 max_power
= udev
->parent_hub
->hub
->portpower
;
618 max_power
= USB_MAX_POWER
;
621 if (power
> max_power
) {
622 DPRINTFN(0, "power exceeded %d > %d\n", power
, max_power
);
623 err
= USB_ERR_NO_POWER
;
626 /* Only update "self_powered" in USB Host Mode */
627 if (udev
->flags
.usb_mode
== USB_MODE_HOST
) {
628 udev
->flags
.self_powered
= selfpowered
;
631 udev
->curr_config_no
= cdp
->bConfigurationValue
;
632 udev
->curr_config_index
= index
;
633 usb_set_device_state(udev
, USB_STATE_CONFIGURED
);
635 /* Set the actual configuration value. */
636 err
= usbd_req_set_config(udev
, NULL
, cdp
->bConfigurationValue
);
641 err
= usb_config_parse(udev
, USB_IFACE_INDEX_ANY
, USB_CFG_ALLOC
);
646 err
= usb_config_parse(udev
, USB_IFACE_INDEX_ANY
, USB_CFG_INIT
);
652 /* create device nodes for each endpoint */
653 usb_cdev_create(udev
);
657 DPRINTF("error=%s\n", usbd_errstr(err
));
659 usb_unconfigure(udev
, 0);
662 usbd_enum_unlock(udev
);
666 /*------------------------------------------------------------------------*
669 * This function will allocate and free USB interfaces and USB endpoints,
670 * parse the USB configuration structure and initialise the USB endpoints
671 * and interfaces. If "iface_index" is not equal to
672 * "USB_IFACE_INDEX_ANY" then the "cmd" parameter is the
673 * alternate_setting to be selected for the given interface. Else the
674 * "cmd" parameter is defined by "USB_CFG_XXX". "iface_index" can be
675 * "USB_IFACE_INDEX_ANY" or a valid USB interface index. This function
676 * is typically called when setting the configuration or when setting
677 * an alternate interface.
682 *------------------------------------------------------------------------*/
684 usb_config_parse(struct usb_device
*udev
, uint8_t iface_index
, uint8_t cmd
)
686 struct usb_idesc_parse_state ips
;
687 struct usb_interface_descriptor
*id
;
688 struct usb_endpoint_descriptor
*ed
;
689 struct usb_interface
*iface
;
690 struct usb_endpoint
*ep
;
698 if (iface_index
!= USB_IFACE_INDEX_ANY
) {
699 /* parameter overload */
709 DPRINTFN(5, "iface_index=%d cmd=%d\n",
712 if (cmd
== USB_CFG_FREE
)
715 if (cmd
== USB_CFG_INIT
) {
716 KKASSERT(lockowned(&udev
->enum_lock
));
718 /* check for in-use endpoints */
720 ep
= udev
->endpoints
;
721 ep_max
= udev
->endpoints_max
;
723 /* look for matching endpoints */
724 if ((iface_index
== USB_IFACE_INDEX_ANY
) ||
725 (iface_index
== ep
->iface_index
)) {
726 if (ep
->refcount_alloc
!= 0) {
728 * This typically indicates a
729 * more serious error.
731 err
= USB_ERR_IN_USE
;
734 memset(ep
, 0, sizeof(*ep
));
735 /* make sure we don't zero the endpoint again */
736 ep
->iface_index
= USB_IFACE_INDEX_ANY
;
746 memset(&ips
, 0, sizeof(ips
));
751 while ((id
= usb_idesc_foreach(udev
->cdesc
, &ips
))) {
753 iface
= udev
->ifaces
+ ips
.iface_index
;
755 /* check for specific interface match */
757 if (cmd
== USB_CFG_INIT
) {
758 if ((iface_index
!= USB_IFACE_INDEX_ANY
) &&
759 (iface_index
!= ips
.iface_index
)) {
760 /* wrong interface */
762 } else if (alt_index
!= ips
.iface_index_alt
) {
763 /* wrong alternate setting */
766 /* initialise interface */
772 /* check for new interface */
773 if (ips
.iface_index_alt
== 0) {
774 /* update current number of endpoints */
779 /* setup the USB interface structure */
781 /* set alternate index */
782 iface
->alt_index
= alt_index
;
783 /* set default interface parent */
784 if (iface_index
== USB_IFACE_INDEX_ANY
) {
785 iface
->parent_iface_index
=
790 DPRINTFN(5, "found idesc nendpt=%d\n", id
->bNumEndpoints
);
792 ed
= (struct usb_endpoint_descriptor
*)id
;
796 /* iterate all the endpoint descriptors */
797 while ((ed
= usb_edesc_foreach(udev
->cdesc
, ed
))) {
799 /* check if endpoint limit has been reached */
800 if (temp
>= USB_MAX_EP_UNITS
) {
801 DPRINTF("Endpoint limit reached\n");
805 ep
= udev
->endpoints
+ temp
;
810 ecomp
= usb_ed_comp_foreach(udev
->cdesc
, (void *)ed
);
812 DPRINTFN(5, "Found endpoint companion descriptor\n");
814 usb_init_endpoint(udev
,
815 ips
.iface_index
, ed
, ecomp
, ep
);
820 /* find maximum number of endpoints */
826 /* NOTE: It is valid to have no interfaces and no endpoints! */
828 if (cmd
== USB_CFG_ALLOC
) {
829 udev
->ifaces_max
= ips
.iface_index
;
830 #if (USB_HAVE_FIXED_IFACE == 0)
832 if (udev
->ifaces_max
!= 0) {
833 udev
->ifaces
= kmalloc(sizeof(*iface
) * udev
->ifaces_max
,
834 M_USB
, M_WAITOK
| M_ZERO
);
835 if (udev
->ifaces
== NULL
) {
841 #if (USB_HAVE_FIXED_ENDPOINT == 0)
843 udev
->endpoints
= kmalloc(sizeof(*ep
) * ep_max
,
844 M_USB
, M_WAITOK
| M_ZERO
);
845 if (udev
->endpoints
== NULL
) {
850 udev
->endpoints
= NULL
;
853 USB_BUS_LOCK(udev
->bus
);
854 udev
->endpoints_max
= ep_max
;
855 /* reset any ongoing clear-stall */
856 udev
->ep_curr
= NULL
;
857 USB_BUS_UNLOCK(udev
->bus
);
859 #if (USB_HAVE_FIXED_IFACE == 0) || (USB_HAVE_FIXED_ENDPOINT == 0)
863 if (cmd
== USB_CFG_ALLOC
) {
865 USB_BUS_LOCK(udev
->bus
);
866 udev
->endpoints_max
= 0;
867 /* reset any ongoing clear-stall */
868 udev
->ep_curr
= NULL
;
869 USB_BUS_UNLOCK(udev
->bus
);
871 #if (USB_HAVE_FIXED_IFACE == 0)
872 if(udev
->ifaces
!= NULL
) {
873 kfree(udev
->ifaces
, M_USB
);
877 #if (USB_HAVE_FIXED_ENDPOINT == 0)
878 if(udev
->endpoints
!= NULL
) {
879 kfree(udev
->endpoints
, M_USB
);
880 udev
->endpoints
= NULL
;
883 udev
->ifaces_max
= 0;
889 /*------------------------------------------------------------------------*
890 * usbd_set_alt_interface_index
892 * This function will select an alternate interface index for the
893 * given interface index. The interface should not be in use when this
894 * function is called. That means there should not be any open USB
895 * transfers. Else an error is returned. If the alternate setting is
896 * already set this function will simply return success. This function
897 * is called in Host mode and Device mode!
902 *------------------------------------------------------------------------*/
904 usbd_set_alt_interface_index(struct usb_device
*udev
,
905 uint8_t iface_index
, uint8_t alt_index
)
907 struct usb_interface
*iface
= usbd_get_iface(udev
, iface_index
);
911 /* Prevent re-enumeration */
912 do_unlock
= usbd_enum_lock(udev
);
918 if (iface
->alt_index
== alt_index
) {
920 * Optimise away duplicate setting of
921 * alternate setting in USB Host Mode!
928 * Free all generic FIFOs for this interface, except control
931 usb_fifo_free_wrap(udev
, iface_index
, 0);
934 err
= usb_config_parse(udev
, iface_index
, alt_index
);
938 if (iface
->alt_index
!= alt_index
) {
939 /* the alternate setting does not exist */
944 err
= usbd_req_set_alt_interface_no(udev
, NULL
, iface_index
,
945 iface
->idesc
->bAlternateSetting
);
949 usbd_enum_unlock(udev
);
953 /*------------------------------------------------------------------------*
954 * usbd_set_endpoint_stall
956 * This function is used to make a BULK or INTERRUPT endpoint send
957 * STALL tokens in USB device mode.
962 *------------------------------------------------------------------------*/
964 usbd_set_endpoint_stall(struct usb_device
*udev
, struct usb_endpoint
*ep
,
967 struct usb_xfer
*xfer
;
974 DPRINTF("Cannot find endpoint\n");
976 * Pretend that the clear or set stall request is
977 * successful else some USB host stacks can do
978 * strange things, especially when a control endpoint
983 et
= (ep
->edesc
->bmAttributes
& UE_XFERTYPE
);
985 if ((et
!= UE_BULK
) &&
986 (et
!= UE_INTERRUPT
)) {
988 * Should not stall control
989 * nor isochronous endpoints.
991 DPRINTF("Invalid endpoint\n");
994 USB_BUS_LOCK(udev
->bus
);
996 /* store current stall state */
997 was_stalled
= ep
->is_stalled
;
999 /* check for no change */
1000 if (was_stalled
&& do_stall
) {
1001 /* if the endpoint is already stalled do nothing */
1002 USB_BUS_UNLOCK(udev
->bus
);
1003 DPRINTF("No change\n");
1006 /* set stalled state */
1009 if (do_stall
|| (!was_stalled
)) {
1011 for (x
= 0; x
!= USB_MAX_EP_STREAMS
; x
++) {
1012 /* lookup the current USB transfer, if any */
1013 xfer
= ep
->endpoint_q
[x
].curr
;
1016 * The "xfer_stall" method
1017 * will complete the USB
1018 * transfer like in case of a
1019 * timeout setting the error
1020 * code "USB_ERR_STALLED".
1022 (udev
->bus
->methods
->xfer_stall
) (xfer
);
1026 (udev
->bus
->methods
->set_stall
) (udev
, ep
, &do_stall
);
1029 ep
->toggle_next
= 0; /* reset data toggle */
1030 ep
->is_stalled
= 0; /* clear stalled state */
1032 (udev
->bus
->methods
->clear_stall
) (udev
, ep
);
1034 /* start the current or next transfer, if any */
1035 for (x
= 0; x
!= USB_MAX_EP_STREAMS
; x
++) {
1036 usb_command_wrapper(&ep
->endpoint_q
[x
],
1037 ep
->endpoint_q
[x
].curr
);
1040 USB_BUS_UNLOCK(udev
->bus
);
1044 /*------------------------------------------------------------------------*
1045 * usb_reset_iface_endpoints - used in USB device side mode
1046 *------------------------------------------------------------------------*/
1048 usb_reset_iface_endpoints(struct usb_device
*udev
, uint8_t iface_index
)
1050 struct usb_endpoint
*ep
;
1051 struct usb_endpoint
*ep_end
;
1053 ep
= udev
->endpoints
;
1054 ep_end
= udev
->endpoints
+ udev
->endpoints_max
;
1056 for (; ep
!= ep_end
; ep
++) {
1058 if ((ep
->edesc
== NULL
) ||
1059 (ep
->iface_index
!= iface_index
)) {
1062 /* simulate a clear stall from the peer */
1063 usbd_set_endpoint_stall(udev
, ep
, 0);
1068 /*------------------------------------------------------------------------*
1069 * usb_detach_device_sub
1071 * This function will try to detach an USB device. If it fails a panic
1074 * Flag values, see "USB_UNCFG_FLAG_XXX".
1075 *------------------------------------------------------------------------*/
1077 usb_detach_device_sub(struct usb_device
*udev
, device_t
*ppdev
,
1078 char **ppnpinfo
, uint8_t flag
)
1087 * NOTE: It is important to clear "*ppdev" before deleting
1088 * the child due to some device methods being called late
1089 * during the delete process !
1093 device_printf(dev
, "at %s, port %d, addr %d "
1095 device_get_nameunit(udev
->parent_dev
),
1096 udev
->port_no
, udev
->address
);
1098 if (device_is_attached(dev
)) {
1099 if (udev
->flags
.peer_suspended
) {
1100 err
= DEVICE_RESUME(dev
);
1102 device_printf(dev
, "Resume failed\n");
1105 if (device_detach(dev
)) {
1109 if (device_delete_child(udev
->parent_dev
, dev
)) {
1114 pnpinfo
= *ppnpinfo
;
1115 if (pnpinfo
!= NULL
) {
1117 kfree(pnpinfo
, M_USBDEV
);
1122 /* Detach is not allowed to fail in the USB world */
1123 panic("usb_detach_device_sub: A USB driver would not detach\n");
1126 /*------------------------------------------------------------------------*
1129 * The following function will detach the matching interfaces.
1130 * This function is NULL safe.
1132 * Flag values, see "USB_UNCFG_FLAG_XXX".
1133 *------------------------------------------------------------------------*/
1135 usb_detach_device(struct usb_device
*udev
, uint8_t iface_index
,
1138 struct usb_interface
*iface
;
1145 DPRINTFN(4, "udev=%p\n", udev
);
1147 KKASSERT(lockowned(&udev
->enum_lock
));
1150 * First detach the child to give the child's detach routine a
1151 * chance to detach the sub-devices in the correct order.
1152 * Then delete the child using "device_delete_child()" which
1153 * will detach all sub-devices from the bottom and upwards!
1155 if (iface_index
!= USB_IFACE_INDEX_ANY
) {
1157 iface_index
= i
+ 1;
1160 iface_index
= USB_IFACE_MAX
;
1165 for (; i
!= iface_index
; i
++) {
1167 iface
= usbd_get_iface(udev
, i
);
1168 if (iface
== NULL
) {
1169 /* looks like the end of the USB interfaces */
1172 usb_detach_device_sub(udev
, &iface
->subdev
,
1173 &iface
->pnpinfo
, flag
);
1177 /*------------------------------------------------------------------------*
1178 * usb_probe_and_attach_sub
1183 *------------------------------------------------------------------------*/
1185 usb_probe_and_attach_sub(struct usb_device
*udev
,
1186 struct usb_attach_arg
*uaa
)
1188 struct usb_interface
*iface
;
1193 if (iface
->parent_iface_index
!= USB_IFACE_INDEX_ANY
) {
1194 /* leave interface alone */
1197 dev
= iface
->subdev
;
1200 /* clean up after module unload */
1202 if (device_is_attached(dev
)) {
1203 /* already a device there */
1206 /* clear "iface->subdev" as early as possible */
1208 iface
->subdev
= NULL
;
1210 if (device_delete_child(udev
->parent_dev
, dev
)) {
1213 * Panic here, else one can get a double call
1214 * to device_detach(). USB devices should
1215 * never fail on detach!
1217 panic("device_delete_child() failed\n");
1220 if (uaa
->temp_dev
== NULL
) {
1222 /* create a new child */
1223 uaa
->temp_dev
= device_add_child(udev
->parent_dev
, NULL
, -1);
1224 if (uaa
->temp_dev
== NULL
) {
1225 device_printf(udev
->parent_dev
,
1226 "Device creation failed\n");
1227 return (1); /* failure */
1229 device_set_ivars(uaa
->temp_dev
, uaa
);
1230 device_quiet(uaa
->temp_dev
);
1233 * Set "subdev" before probe and attach so that "devd" gets
1234 * the information it needs.
1236 iface
->subdev
= uaa
->temp_dev
;
1238 if (device_probe_and_attach(iface
->subdev
) == 0) {
1240 * The USB attach arguments are only available during probe
1243 uaa
->temp_dev
= NULL
;
1244 device_set_ivars(iface
->subdev
, NULL
);
1246 if (udev
->flags
.peer_suspended
) {
1247 err
= DEVICE_SUSPEND(iface
->subdev
);
1249 device_printf(iface
->subdev
, "Suspend failed\n");
1251 return (0); /* success */
1253 /* No USB driver found */
1254 iface
->subdev
= NULL
;
1256 return (1); /* failure */
1259 /*------------------------------------------------------------------------*
1260 * usbd_set_parent_iface
1262 * Using this function will lock the alternate interface setting on an
1263 * interface. It is typically used for multi interface drivers. In USB
1264 * device side mode it is assumed that the alternate interfaces all
1265 * have the same endpoint descriptors. The default parent index value
1266 * is "USB_IFACE_INDEX_ANY". Then the alternate setting value is not
1268 *------------------------------------------------------------------------*/
1270 usbd_set_parent_iface(struct usb_device
*udev
, uint8_t iface_index
,
1271 uint8_t parent_index
)
1273 struct usb_interface
*iface
;
1279 iface
= usbd_get_iface(udev
, iface_index
);
1281 iface
->parent_iface_index
= parent_index
;
1285 usb_init_attach_arg(struct usb_device
*udev
,
1286 struct usb_attach_arg
*uaa
)
1288 memset(uaa
, 0, sizeof(*uaa
));
1291 uaa
->usb_mode
= udev
->flags
.usb_mode
;
1292 uaa
->port
= udev
->port_no
;
1293 uaa
->dev_state
= UAA_DEV_READY
;
1295 uaa
->info
.idVendor
= UGETW(udev
->ddesc
.idVendor
);
1296 uaa
->info
.idProduct
= UGETW(udev
->ddesc
.idProduct
);
1297 uaa
->info
.bcdDevice
= UGETW(udev
->ddesc
.bcdDevice
);
1298 uaa
->info
.bDeviceClass
= udev
->ddesc
.bDeviceClass
;
1299 uaa
->info
.bDeviceSubClass
= udev
->ddesc
.bDeviceSubClass
;
1300 uaa
->info
.bDeviceProtocol
= udev
->ddesc
.bDeviceProtocol
;
1301 uaa
->info
.bConfigIndex
= udev
->curr_config_index
;
1302 uaa
->info
.bConfigNum
= udev
->curr_config_no
;
1305 /*------------------------------------------------------------------------*
1306 * usb_probe_and_attach
1308 * This function is called from "uhub_explore_sub()",
1309 * "usb_handle_set_config()" and "usb_handle_request()".
1313 * Else: A control transfer failed
1314 *------------------------------------------------------------------------*/
1316 usb_probe_and_attach(struct usb_device
*udev
, uint8_t iface_index
)
1318 struct usb_attach_arg uaa
;
1319 struct usb_interface
*iface
;
1325 DPRINTF("udev == NULL\n");
1326 return (USB_ERR_INVAL
);
1328 /* Prevent re-enumeration */
1329 do_unlock
= usbd_enum_lock(udev
);
1331 if (udev
->curr_config_index
== USB_UNCONFIG_INDEX
) {
1332 /* do nothing - no configuration has been set */
1335 /* setup USB attach arguments */
1337 usb_init_attach_arg(udev
, &uaa
);
1340 * If the whole USB device is targeted, invoke the USB event
1343 if (iface_index
== USB_IFACE_INDEX_ANY
) {
1345 if (usb_test_quirk(&uaa
, UQ_MSC_DYMO_EJECT
) != 0 &&
1346 usb_dymo_eject(udev
, 0) == 0) {
1347 /* success, mark the udev as disappearing */
1348 uaa
.dev_state
= UAA_DEV_EJECTING
;
1351 EVENTHANDLER_INVOKE(usb_dev_configured
, udev
, &uaa
);
1353 if (uaa
.dev_state
!= UAA_DEV_READY
) {
1354 /* leave device unconfigured */
1355 usb_unconfigure(udev
, 0);
1360 /* Check if only one interface should be probed: */
1361 if (iface_index
!= USB_IFACE_INDEX_ANY
) {
1369 /* Do the probe and attach */
1370 for (; i
!= j
; i
++) {
1372 iface
= usbd_get_iface(udev
, i
);
1373 if (iface
== NULL
) {
1375 * Looks like the end of the USB
1378 DPRINTFN(2, "end of interfaces "
1382 if (iface
->idesc
== NULL
) {
1383 /* no interface descriptor */
1388 uaa
.info
.bInterfaceClass
=
1389 iface
->idesc
->bInterfaceClass
;
1390 uaa
.info
.bInterfaceSubClass
=
1391 iface
->idesc
->bInterfaceSubClass
;
1392 uaa
.info
.bInterfaceProtocol
=
1393 iface
->idesc
->bInterfaceProtocol
;
1394 uaa
.info
.bIfaceIndex
= i
;
1395 uaa
.info
.bIfaceNum
=
1396 iface
->idesc
->bInterfaceNumber
;
1397 uaa
.driver_info
= 0; /* reset driver_info */
1399 DPRINTFN(2, "iclass=%u/%u/%u iindex=%u/%u\n",
1400 uaa
.info
.bInterfaceClass
,
1401 uaa
.info
.bInterfaceSubClass
,
1402 uaa
.info
.bInterfaceProtocol
,
1403 uaa
.info
.bIfaceIndex
,
1404 uaa
.info
.bIfaceNum
);
1406 usb_probe_and_attach_sub(udev
, &uaa
);
1409 * Remove the leftover child, if any, to enforce that
1410 * a new nomatch devd event is generated for the next
1411 * interface if no driver is found:
1413 if (uaa
.temp_dev
== NULL
)
1415 if (device_delete_child(udev
->parent_dev
, uaa
.temp_dev
))
1416 DPRINTFN(0, "device delete child failed\n");
1417 uaa
.temp_dev
= NULL
;
1421 usbd_enum_unlock(udev
);
1425 /*------------------------------------------------------------------------*
1426 * usb_suspend_resume_sub
1428 * This function is called when the suspend or resume methods should
1429 * be executed on an USB device.
1430 *------------------------------------------------------------------------*/
1432 usb_suspend_resume_sub(struct usb_device
*udev
, device_t dev
, uint8_t do_suspend
)
1439 if (!device_is_attached(dev
)) {
1443 err
= DEVICE_SUSPEND(dev
);
1445 err
= DEVICE_RESUME(dev
);
1448 device_printf(dev
, "%s failed\n",
1449 do_suspend
? "Suspend" : "Resume");
1453 /*------------------------------------------------------------------------*
1454 * usb_suspend_resume
1456 * The following function will suspend or resume the USB device.
1461 *------------------------------------------------------------------------*/
1463 usb_suspend_resume(struct usb_device
*udev
, uint8_t do_suspend
)
1465 struct usb_interface
*iface
;
1472 DPRINTFN(4, "udev=%p do_suspend=%d\n", udev
, do_suspend
);
1474 KKASSERT(lockowned(&udev
->sr_lock
));
1476 USB_BUS_LOCK(udev
->bus
);
1477 /* filter the suspend events */
1478 if (udev
->flags
.peer_suspended
== do_suspend
) {
1479 USB_BUS_UNLOCK(udev
->bus
);
1483 udev
->flags
.peer_suspended
= do_suspend
;
1484 USB_BUS_UNLOCK(udev
->bus
);
1486 /* do the suspend or resume */
1488 for (i
= 0; i
!= USB_IFACE_MAX
; i
++) {
1490 iface
= usbd_get_iface(udev
, i
);
1491 if (iface
== NULL
) {
1492 /* looks like the end of the USB interfaces */
1495 usb_suspend_resume_sub(udev
, iface
->subdev
, do_suspend
);
1500 /*------------------------------------------------------------------------*
1501 * usbd_clear_stall_proc
1503 * This function performs generic USB clear stall operations.
1504 *------------------------------------------------------------------------*/
1506 usbd_clear_stall_proc(struct usb_proc_msg
*_pm
)
1508 struct usb_udev_msg
*pm
= (void *)_pm
;
1509 struct usb_device
*udev
= pm
->udev
;
1512 USB_BUS_UNLOCK(udev
->bus
);
1513 lockmgr(&udev
->device_lock
, LK_EXCLUSIVE
);
1515 /* Start clear stall callback */
1516 usbd_transfer_start(udev
->ctrl_xfer
[1]);
1519 lockmgr(&udev
->device_lock
, LK_RELEASE
);
1520 USB_BUS_LOCK(udev
->bus
);
1523 /*------------------------------------------------------------------------*
1526 * This function allocates a new USB device. This function is called
1527 * when a new device has been put in the powered state, but not yet in
1528 * the addressed state. Get initial descriptor, set the address, get
1529 * full descriptor and get strings.
1534 *------------------------------------------------------------------------*/
1536 usb_alloc_device(device_t parent_dev
, struct usb_bus
*bus
,
1537 struct usb_device
*parent_hub
, uint8_t depth
, uint8_t port_index
,
1538 uint8_t port_no
, enum usb_dev_speed speed
, enum usb_hc_mode mode
)
1540 struct usb_attach_arg uaa
;
1541 struct usb_device
*udev
;
1542 struct usb_device
*adev
;
1543 struct usb_device
*hub
;
1544 uint8_t *scratch_ptr
;
1546 uint8_t device_index
;
1547 uint8_t config_index
;
1548 uint8_t config_quirk
;
1549 uint8_t set_config_failed
;
1552 DPRINTF("parent_dev=%p, bus=%p, parent_hub=%p, depth=%u, "
1553 "port_index=%u, port_no=%u, speed=%u, usb_mode=%u\n",
1554 parent_dev
, bus
, parent_hub
, depth
, port_index
, port_no
,
1558 * Find an unused device index. In USB Host mode this is the
1559 * same as the device address.
1561 * Device index zero is not used and device index 1 should
1562 * always be the root hub.
1564 for (device_index
= USB_ROOT_HUB_ADDR
;
1565 (device_index
!= bus
->devices_max
) &&
1566 (bus
->devices
[device_index
] != NULL
);
1567 device_index
++) /* nop */;
1569 if (device_index
== bus
->devices_max
) {
1570 device_printf(bus
->bdev
,
1571 "No free USB device index for new device\n");
1576 device_printf(bus
->bdev
,
1577 "Invalid device depth\n");
1580 udev
= kmalloc(sizeof(*udev
), M_USB
, M_WAITOK
| M_ZERO
);
1585 /* Initialise SX-locks */
1586 lockinit(&udev
->enum_lock
, "USB config SX lock", 0, LK_CANRECURSE
);
1587 /* XXX (mp) is this LK_CANRECURSE necessary? */
1588 lockinit(&udev
->sr_lock
, "USB suspend and resume SX lock", 0, LK_CANRECURSE
);
1590 cv_init(&udev
->ctrlreq_cv
, "WCTRL");
1591 cv_init(&udev
->ref_cv
, "UGONE");
1593 /* initialise our mutex */
1594 lockinit(&udev
->device_lock
, "USB device mutex", 0, 0);
1596 /* initialise generic clear stall */
1597 udev
->cs_msg
[0].hdr
.pm_callback
= &usbd_clear_stall_proc
;
1598 udev
->cs_msg
[0].udev
= udev
;
1599 udev
->cs_msg
[1].hdr
.pm_callback
= &usbd_clear_stall_proc
;
1600 udev
->cs_msg
[1].udev
= udev
;
1602 /* initialise some USB device fields */
1603 udev
->parent_hub
= parent_hub
;
1604 udev
->parent_dev
= parent_dev
;
1605 udev
->port_index
= port_index
;
1606 udev
->port_no
= port_no
;
1607 udev
->depth
= depth
;
1609 udev
->address
= USB_START_ADDR
; /* default value */
1610 udev
->plugtime
= (usb_ticks_t
)ticks
;
1612 * We need to force the power mode to "on" because there are plenty
1613 * of USB devices out there that do not work very well with
1614 * automatic suspend and resume!
1616 udev
->power_mode
= usbd_filter_power_mode(udev
, USB_POWER_MODE_ON
);
1617 udev
->pwr_save
.last_xfer_time
= ticks
;
1618 /* we are not ready yet */
1621 /* set up default endpoint descriptor */
1622 udev
->ctrl_ep_desc
.bLength
= sizeof(udev
->ctrl_ep_desc
);
1623 udev
->ctrl_ep_desc
.bDescriptorType
= UDESC_ENDPOINT
;
1624 udev
->ctrl_ep_desc
.bEndpointAddress
= USB_CONTROL_ENDPOINT
;
1625 udev
->ctrl_ep_desc
.bmAttributes
= UE_CONTROL
;
1626 udev
->ctrl_ep_desc
.wMaxPacketSize
[0] = USB_MAX_IPACKET
;
1627 udev
->ctrl_ep_desc
.wMaxPacketSize
[1] = 0;
1628 udev
->ctrl_ep_desc
.bInterval
= 0;
1630 /* set up default endpoint companion descriptor */
1631 udev
->ctrl_ep_comp_desc
.bLength
= sizeof(udev
->ctrl_ep_comp_desc
);
1632 udev
->ctrl_ep_comp_desc
.bDescriptorType
= UDESC_ENDPOINT_SS_COMP
;
1634 udev
->ddesc
.bMaxPacketSize
= USB_MAX_IPACKET
;
1636 udev
->speed
= speed
;
1637 udev
->flags
.usb_mode
= mode
;
1639 /* search for our High Speed USB HUB, if any */
1642 hub
= udev
->parent_hub
;
1645 if (hub
->speed
== USB_SPEED_HIGH
) {
1646 udev
->hs_hub_addr
= hub
->address
;
1647 udev
->parent_hs_hub
= hub
;
1648 udev
->hs_port_no
= adev
->port_no
;
1652 hub
= hub
->parent_hub
;
1655 /* init the default endpoint */
1656 usb_init_endpoint(udev
, 0,
1657 &udev
->ctrl_ep_desc
,
1658 &udev
->ctrl_ep_comp_desc
,
1661 /* set device index */
1662 udev
->device_index
= device_index
;
1665 /* Create ugen name */
1666 ksnprintf(udev
->ugen_name
, sizeof(udev
->ugen_name
),
1667 USB_GENERIC_NAME
"%u.%u", device_get_unit(bus
->bdev
),
1669 LIST_INIT(&udev
->pd_list
);
1671 /* Create the control endpoint device */
1672 udev
->ctrl_dev
= usb_make_dev(udev
, NULL
, 0, 0,
1673 FREAD
|FWRITE
, UID_ROOT
, GID_OPERATOR
, 0600);
1675 /* Create a link from /dev/ugenX.X to the default endpoint */
1676 if (udev
->ctrl_dev
!= NULL
)
1677 make_dev_alias(udev
->ctrl_dev
->cdev
, "%s", udev
->ugen_name
);
1679 /* Initialise device */
1680 if (bus
->methods
->device_init
!= NULL
) {
1681 err
= (bus
->methods
->device_init
) (udev
);
1683 DPRINTFN(0, "device init %d failed "
1684 "(%s, ignored)\n", device_index
,
1689 /* set powered device state after device init is complete */
1690 usb_set_device_state(udev
, USB_STATE_POWERED
);
1692 if (udev
->flags
.usb_mode
== USB_MODE_HOST
) {
1694 err
= usbd_req_set_address(udev
, NULL
, device_index
);
1697 * This is the new USB device address from now on, if
1698 * the set address request didn't set it already.
1700 if (udev
->address
== USB_START_ADDR
)
1701 udev
->address
= device_index
;
1704 * We ignore any set-address errors, hence there are
1705 * buggy USB devices out there that actually receive
1706 * the SETUP PID, but manage to set the address before
1707 * the STATUS stage is ACK'ed. If the device responds
1708 * to the subsequent get-descriptor at the new
1709 * address, then we know that the set-address command
1713 DPRINTFN(0, "set address %d failed "
1714 "(%s, ignored)\n", udev
->address
,
1718 /* We are not self powered */
1719 udev
->flags
.self_powered
= 0;
1721 /* Set unconfigured state */
1722 udev
->curr_config_no
= USB_UNCONFIG_NO
;
1723 udev
->curr_config_index
= USB_UNCONFIG_INDEX
;
1725 /* Setup USB descriptors */
1726 err
= (usb_temp_setup_by_index_p
) (udev
, usb_template
);
1728 DPRINTFN(0, "setting up USB template failed maybe the USB "
1729 "template module has not been loaded\n");
1733 usb_set_device_state(udev
, USB_STATE_ADDRESSED
);
1735 /* setup the device descriptor and the initial "wMaxPacketSize" */
1736 err
= usbd_setup_device_desc(udev
, NULL
);
1739 /* try to enumerate two more times */
1740 err
= usbd_req_re_enumerate(udev
, NULL
);
1742 err
= usbd_req_re_enumerate(udev
, NULL
);
1750 * Setup temporary USB attach args so that we can figure out some
1751 * basic quirks for this device.
1753 usb_init_attach_arg(udev
, &uaa
);
1755 if (usb_test_quirk(&uaa
, UQ_BUS_POWERED
))
1756 udev
->flags
.uq_bus_powered
= 1;
1757 if (usb_test_quirk(&uaa
, UQ_NO_STRINGS
))
1758 udev
->flags
.no_strings
= 1;
1759 if (usb_test_quirk(&uaa
, UQ_KBD_DELAY_INIT
))
1760 udev
->flags
.uq_delay_init
= 1;
1761 if (usb_test_quirk(&uaa
, UQ_KBD_DELAY_CTRL_MSG
))
1762 udev
->flags
.uq_delay_ctrl
= 1;
1764 * Workaround for buggy USB devices.
1766 * It appears that some string-less USB chips will crash and
1767 * disappear if any attempts are made to read any string
1770 * Try to detect such chips by checking the strings in the USB
1771 * device descriptor. If no strings are present there we
1772 * simply disable all USB strings.
1775 /* Protect scratch area */
1776 do_unlock
= usbd_enum_lock(udev
);
1778 scratch_ptr
= udev
->scratch
.data
;
1780 if (udev
->ddesc
.iManufacturer
||
1781 udev
->ddesc
.iProduct
||
1782 udev
->ddesc
.iSerialNumber
) {
1783 /* read out the language ID string */
1784 err
= usbd_req_get_string_desc(udev
, NULL
,
1785 (char *)scratch_ptr
, 4, 0, USB_LANGUAGE_TABLE
);
1787 err
= USB_ERR_INVAL
;
1790 if (err
|| (scratch_ptr
[0] < 4)) {
1791 udev
->flags
.no_strings
= 1;
1798 /* load preferred value and mask */
1800 mask
= usb_lang_mask
;
1802 /* align length correctly */
1803 scratch_ptr
[0] &= ~1U;
1805 /* fix compiler warning */
1808 /* search for preferred language */
1809 for (x
= 2; (x
< scratch_ptr
[0]); x
+= 2) {
1810 langid
= UGETW(scratch_ptr
+ x
);
1811 if ((langid
& mask
) == pref
)
1814 if (x
>= scratch_ptr
[0]) {
1815 /* pick the first language as the default */
1816 DPRINTFN(1, "Using first language\n");
1817 langid
= UGETW(scratch_ptr
+ 2);
1820 DPRINTFN(1, "Language selected: 0x%04x\n", langid
);
1821 udev
->langid
= langid
;
1825 usbd_enum_unlock(udev
);
1827 /* assume 100mA bus powered for now. Changed when configured. */
1828 udev
->power
= USB_MIN_POWER
;
1829 /* fetch the vendor and product strings from the device */
1830 usbd_set_device_strings(udev
);
1832 if (udev
->flags
.usb_mode
== USB_MODE_DEVICE
) {
1833 /* USB device mode setup is complete */
1839 * Most USB devices should attach to config index 0 by
1842 if (usb_test_quirk(&uaa
, UQ_CFG_INDEX_0
)) {
1845 } else if (usb_test_quirk(&uaa
, UQ_CFG_INDEX_1
)) {
1848 } else if (usb_test_quirk(&uaa
, UQ_CFG_INDEX_2
)) {
1851 } else if (usb_test_quirk(&uaa
, UQ_CFG_INDEX_3
)) {
1854 } else if (usb_test_quirk(&uaa
, UQ_CFG_INDEX_4
)) {
1862 set_config_failed
= 0;
1865 DPRINTF("setting config %u\n", config_index
);
1867 /* get the USB device configured */
1868 err
= usbd_set_config_index(udev
, config_index
);
1870 if (udev
->ddesc
.bNumConfigurations
!= 0) {
1871 if (!set_config_failed
) {
1872 set_config_failed
= 1;
1873 /* XXX try to re-enumerate the device */
1874 err
= usbd_req_re_enumerate(udev
, NULL
);
1876 goto repeat_set_config
;
1878 DPRINTFN(0, "Failure selecting configuration index %u:"
1879 "%s, port %u, addr %u (ignored)\n",
1880 config_index
, usbd_errstr(err
), udev
->port_no
,
1884 * Some USB devices do not have any configurations. Ignore any
1885 * set config failures!
1890 if (!config_quirk
&& config_index
+ 1 < udev
->ddesc
.bNumConfigurations
) {
1891 if ((udev
->cdesc
->bNumInterface
< 2) &&
1892 usbd_get_no_descriptors(udev
->cdesc
, UDESC_ENDPOINT
) == 0) {
1893 DPRINTFN(0, "Found no endpoints, trying next config\n");
1895 goto repeat_set_config
;
1897 #if USB_HAVE_MSCTEST
1898 if (config_index
== 0) {
1900 * Try to figure out if we have an
1901 * auto-install disk there:
1903 if (usb_iface_is_cdrom(udev
, 0)) {
1904 DPRINTFN(0, "Found possible auto-install "
1905 "disk (trying next config)\n");
1907 goto repeat_set_config
;
1912 #if USB_HAVE_MSCTEST
1913 if (set_config_failed
== 0 && config_index
== 0 &&
1914 usb_test_quirk(&uaa
, UQ_MSC_NO_SYNC_CACHE
) == 0 &&
1915 usb_test_quirk(&uaa
, UQ_MSC_NO_GETMAXLUN
) == 0) {
1918 * Try to figure out if there are any MSC quirks we
1919 * should apply automatically:
1921 err
= usb_msc_auto_quirk(udev
, 0);
1924 set_config_failed
= 1;
1925 goto repeat_set_config
;
1931 DPRINTF("new dev (addr %d), udev=%p, parent_hub=%p\n",
1932 udev
->address
, udev
, udev
->parent_hub
);
1934 /* register our device - we are ready */
1935 usb_bus_port_set_device(bus
, parent_hub
?
1936 parent_hub
->hub
->ports
+ port_index
: NULL
, udev
, device_index
);
1939 /* Symlink the ugen device name */
1940 udev
->ugen_symlink
= usb_alloc_symlink(udev
->ugen_name
);
1942 /* Announce device */
1943 kprintf("%s: <%s> at %s\n", udev
->ugen_name
,
1944 usb_get_manufacturer(udev
),
1945 device_get_nameunit(udev
->bus
->bdev
));
1949 usb_notify_addq("ATTACH", udev
);
1954 * Free USB device and all subdevices, if any.
1956 usb_free_device(udev
, 0);
1963 struct usb_fs_privdata
*
1964 usb_make_dev(struct usb_device
*udev
, const char *devname
, int ep
,
1965 int fi
, int rwmode
, uid_t uid
, gid_t gid
, int mode
)
1967 struct usb_fs_privdata
* pd
;
1970 /* Store information to locate ourselves again later */
1971 pd
= kmalloc(sizeof(struct usb_fs_privdata
), M_USBDEV
,
1973 pd
->bus_index
= device_get_unit(udev
->bus
->bdev
);
1974 pd
->dev_index
= udev
->device_index
;
1976 pd
->fifo_index
= fi
;
1979 /* Now, create the device itself */
1980 if (devname
== NULL
) {
1982 ksnprintf(buffer
, sizeof(buffer
), USB_DEVICE_DIR
"/%u.%u.%u",
1983 pd
->bus_index
, pd
->dev_index
, pd
->ep_addr
);
1986 pd
->cdev
= make_dev(&usb_ops
, 0, uid
, gid
, mode
, "%s", devname
);
1988 if (pd
->cdev
== NULL
) {
1989 DPRINTFN(0, "Failed to create device %s\n", devname
);
1990 kfree(pd
, M_USBDEV
);
1994 /* XXX setting si_drv1 and creating the device is not atomic! */
1995 pd
->cdev
->si_drv1
= pd
;
2001 usb_destroy_dev_sync(struct usb_fs_privdata
*pd
)
2003 DPRINTFN(1, "Destroying device at ugen%d.%d\n",
2004 pd
->bus_index
, pd
->dev_index
);
2007 * Destroy character device synchronously. After this
2008 * all system calls are returned. Can block.
2010 destroy_dev(pd
->cdev
);
2012 kfree(pd
, M_USBDEV
);
2016 usb_destroy_dev(struct usb_fs_privdata
*pd
)
2018 struct usb_bus
*bus
;
2023 lockmgr(&usb_ref_lock
, LK_EXCLUSIVE
);
2024 bus
= devclass_get_softc(usb_devclass_ptr
, pd
->bus_index
);
2025 lockmgr(&usb_ref_lock
, LK_RELEASE
);
2028 usb_destroy_dev_sync(pd
);
2033 /* XXX what is FreeBSD doing here? */
2034 /* make sure we can re-use the device name */
2035 delist_dev(pd
->cdev
);
2039 LIST_INSERT_HEAD(&bus
->pd_cleanup_list
, pd
, pd_next
);
2040 /* get cleanup going */
2041 usb_proc_msignal(USB_BUS_EXPLORE_PROC(bus
),
2042 &bus
->cleanup_msg
[0], &bus
->cleanup_msg
[1]);
2043 USB_BUS_UNLOCK(bus
);
2047 usb_cdev_create(struct usb_device
*udev
)
2049 struct usb_config_descriptor
*cd
;
2050 struct usb_endpoint_descriptor
*ed
;
2051 struct usb_descriptor
*desc
;
2052 struct usb_fs_privdata
* pd
;
2053 int inmode
, outmode
, inmask
, outmask
, mode
;
2056 KASSERT(LIST_FIRST(&udev
->pd_list
) == NULL
, ("stale cdev entries"));
2058 DPRINTFN(2, "Creating device nodes\n");
2060 if (usbd_get_mode(udev
) == USB_MODE_DEVICE
) {
2063 } else { /* USB_MODE_HOST */
2073 * Collect all used endpoint numbers instead of just
2074 * generating 16 static endpoints.
2076 cd
= usbd_get_config_descriptor(udev
);
2077 while ((desc
= usb_desc_foreach(cd
, desc
))) {
2078 /* filter out all endpoint descriptors */
2079 if ((desc
->bDescriptorType
== UDESC_ENDPOINT
) &&
2080 (desc
->bLength
>= sizeof(*ed
))) {
2081 ed
= (struct usb_endpoint_descriptor
*)desc
;
2084 ep
= ed
->bEndpointAddress
;
2085 if (UE_GET_DIR(ep
) == UE_DIR_OUT
)
2086 outmask
|= 1 << UE_GET_ADDR(ep
);
2088 inmask
|= 1 << UE_GET_ADDR(ep
);
2092 /* Create all available endpoints except EP0 */
2093 for (ep
= 1; ep
< 16; ep
++) {
2094 mode
= (inmask
& (1 << ep
)) ? inmode
: 0;
2095 mode
|= (outmask
& (1 << ep
)) ? outmode
: 0;
2097 continue; /* no IN or OUT endpoint */
2099 pd
= usb_make_dev(udev
, NULL
, ep
, 0,
2100 mode
, UID_ROOT
, GID_OPERATOR
, 0600);
2103 LIST_INSERT_HEAD(&udev
->pd_list
, pd
, pd_next
);
2108 usb_cdev_free(struct usb_device
*udev
)
2110 struct usb_fs_privdata
* pd
;
2112 DPRINTFN(2, "Freeing device nodes\n");
2114 while ((pd
= LIST_FIRST(&udev
->pd_list
)) != NULL
) {
2115 KASSERT(pd
->cdev
->si_drv1
== pd
, ("privdata corrupt"));
2117 LIST_REMOVE(pd
, pd_next
);
2119 usb_destroy_dev(pd
);
2124 /*------------------------------------------------------------------------*
2127 * This function is NULL safe and will free an USB device and its
2128 * children devices, if any.
2130 * Flag values: Reserved, set to zero.
2131 *------------------------------------------------------------------------*/
2133 usb_free_device(struct usb_device
*udev
, uint8_t flag
)
2135 struct usb_bus
*bus
;
2138 return; /* already freed */
2140 DPRINTFN(4, "udev=%p port=%d\n", udev
, udev
->port_no
);
2144 /* set DETACHED state to prevent any further references */
2145 usb_set_device_state(udev
, USB_STATE_DETACHED
);
2148 usb_notify_addq("DETACH", udev
);
2152 kprintf("%s: <%s> at %s (disconnected)\n", udev
->ugen_name
,
2153 usb_get_manufacturer(udev
), device_get_nameunit(bus
->bdev
));
2155 /* Destroy UGEN symlink, if any */
2156 if (udev
->ugen_symlink
) {
2157 usb_free_symlink(udev
->ugen_symlink
);
2158 udev
->ugen_symlink
= NULL
;
2161 usb_destroy_dev(udev
->ctrl_dev
);
2164 if (udev
->flags
.usb_mode
== USB_MODE_DEVICE
) {
2165 /* stop receiving any control transfers (Device Side Mode) */
2166 usbd_transfer_unsetup(udev
->ctrl_xfer
, USB_CTRL_XFER_MAX
);
2169 /* the following will get the device unconfigured in software */
2170 usb_unconfigure(udev
, USB_UNCFG_FLAG_FREE_EP0
);
2172 /* final device unregister after all character devices are closed */
2173 usb_bus_port_set_device(bus
, udev
->parent_hub
?
2174 udev
->parent_hub
->hub
->ports
+ udev
->port_index
: NULL
,
2175 NULL
, USB_ROOT_HUB_ADDR
);
2177 /* unsetup any leftover default USB transfers */
2178 usbd_transfer_unsetup(udev
->ctrl_xfer
, USB_CTRL_XFER_MAX
);
2180 /* template unsetup, if any */
2181 (usb_temp_unsetup_p
) (udev
);
2184 * Make sure that our clear-stall messages are not queued
2187 USB_BUS_LOCK(udev
->bus
);
2188 usb_proc_mwait(USB_BUS_NON_GIANT_PROC(udev
->bus
),
2189 &udev
->cs_msg
[0], &udev
->cs_msg
[1]);
2190 USB_BUS_UNLOCK(udev
->bus
);
2192 /* wait for all references to go away */
2193 usb_wait_pending_refs(udev
);
2195 lockuninit(&udev
->enum_lock
);
2196 lockuninit(&udev
->sr_lock
);
2198 cv_destroy(&udev
->ctrlreq_cv
);
2199 cv_destroy(&udev
->ref_cv
);
2201 lockuninit(&udev
->device_lock
);
2203 KASSERT(LIST_FIRST(&udev
->pd_list
) == NULL
, ("leaked cdev entries"));
2206 /* Uninitialise device */
2207 if (bus
->methods
->device_uninit
!= NULL
)
2208 (bus
->methods
->device_uninit
) (udev
);
2212 kfree(udev
->serial
, M_USB
);
2213 if(udev
->manufacturer
)
2214 kfree(udev
->manufacturer
, M_USB
);
2216 kfree(udev
->product
, M_USB
);
2220 /*------------------------------------------------------------------------*
2223 * This function is the safe way to get the USB interface structure
2224 * pointer by interface index.
2227 * NULL: Interface not present.
2228 * Else: Pointer to USB interface structure.
2229 *------------------------------------------------------------------------*/
2230 struct usb_interface
*
2231 usbd_get_iface(struct usb_device
*udev
, uint8_t iface_index
)
2233 struct usb_interface
*iface
= udev
->ifaces
+ iface_index
;
2235 if (iface_index
>= udev
->ifaces_max
)
2240 /*------------------------------------------------------------------------*
2241 * usbd_find_descriptor
2243 * This function will lookup the first descriptor that matches the
2244 * criteria given by the arguments "type" and "subtype". Descriptors
2245 * will only be searched within the interface having the index
2246 * "iface_index". If the "id" argument points to an USB descriptor,
2247 * it will be skipped before the search is started. This allows
2248 * searching for multiple descriptors using the same criteria. Else
2249 * the search is started after the interface descriptor.
2252 * NULL: End of descriptors
2253 * Else: A descriptor matching the criteria
2254 *------------------------------------------------------------------------*/
2256 usbd_find_descriptor(struct usb_device
*udev
, void *id
, uint8_t iface_index
,
2257 uint8_t type
, uint8_t type_mask
,
2258 uint8_t subtype
, uint8_t subtype_mask
)
2260 struct usb_descriptor
*desc
;
2261 struct usb_config_descriptor
*cd
;
2262 struct usb_interface
*iface
;
2264 cd
= usbd_get_config_descriptor(udev
);
2269 iface
= usbd_get_iface(udev
, iface_index
);
2270 if (iface
== NULL
) {
2273 id
= usbd_get_interface_descriptor(iface
);
2280 while ((desc
= usb_desc_foreach(cd
, desc
))) {
2282 if (desc
->bDescriptorType
== UDESC_INTERFACE
) {
2285 if (((desc
->bDescriptorType
& type_mask
) == type
) &&
2286 ((desc
->bDescriptorSubtype
& subtype_mask
) == subtype
)) {
2293 /*------------------------------------------------------------------------*
2296 * This function will dump information from the device descriptor
2297 * belonging to the USB device pointed to by "udev", to the string
2298 * pointed to by "dst_ptr" having a maximum length of "dst_len" bytes
2299 * including the terminating zero.
2300 *------------------------------------------------------------------------*/
2302 usb_devinfo(struct usb_device
*udev
, char *dst_ptr
, uint16_t dst_len
)
2304 struct usb_device_descriptor
*udd
= &udev
->ddesc
;
2308 bcdUSB
= UGETW(udd
->bcdUSB
);
2309 bcdDevice
= UGETW(udd
->bcdDevice
);
2311 if (udd
->bDeviceClass
!= 0xFF) {
2312 ksnprintf(dst_ptr
, dst_len
, "%s %s, class %d/%d, rev %x.%02x/"
2314 usb_get_manufacturer(udev
),
2315 usb_get_product(udev
),
2316 udd
->bDeviceClass
, udd
->bDeviceSubClass
,
2317 (bcdUSB
>> 8), bcdUSB
& 0xFF,
2318 (bcdDevice
>> 8), bcdDevice
& 0xFF,
2321 ksnprintf(dst_ptr
, dst_len
, "%s %s, rev %x.%02x/"
2323 usb_get_manufacturer(udev
),
2324 usb_get_product(udev
),
2325 (bcdUSB
>> 8), bcdUSB
& 0xFF,
2326 (bcdDevice
>> 8), bcdDevice
& 0xFF,
2333 * Descriptions of of known vendors and devices ("products").
2335 struct usb_knowndev
{
2339 const char *vendorname
;
2340 const char *productname
;
2343 #define USB_KNOWNDEV_NOPROD 0x01 /* match on vendor only */
2345 #include "usbdevs.h"
2346 #include "usbdevs_data.h"
2347 #endif /* USB_VERBOSE */
2350 usbd_set_device_strings(struct usb_device
*udev
)
2352 struct usb_device_descriptor
*udd
= &udev
->ddesc
;
2354 const struct usb_knowndev
*kdp
;
2359 uint16_t product_id
;
2362 /* Protect scratch area */
2363 do_unlock
= usbd_enum_lock(udev
);
2365 temp_ptr
= (char *)udev
->scratch
.data
;
2366 temp_size
= sizeof(udev
->scratch
.data
);
2368 vendor_id
= UGETW(udd
->idVendor
);
2369 product_id
= UGETW(udd
->idProduct
);
2371 /* get serial number string */
2372 usbd_req_get_string_any(udev
, NULL
, temp_ptr
, temp_size
,
2373 udev
->ddesc
.iSerialNumber
);
2374 udev
->serial
= kstrdup(temp_ptr
, M_USB
);
2376 /* get manufacturer string */
2377 usbd_req_get_string_any(udev
, NULL
, temp_ptr
, temp_size
,
2378 udev
->ddesc
.iManufacturer
);
2379 usb_trim_spaces(temp_ptr
);
2380 if (temp_ptr
[0] != '\0')
2381 udev
->manufacturer
= kstrdup(temp_ptr
, M_USB
);
2383 /* get product string */
2384 usbd_req_get_string_any(udev
, NULL
, temp_ptr
, temp_size
,
2385 udev
->ddesc
.iProduct
);
2386 usb_trim_spaces(temp_ptr
);
2387 if (temp_ptr
[0] != '\0')
2388 udev
->product
= kstrdup(temp_ptr
, M_USB
);
2391 if (udev
->manufacturer
== NULL
|| udev
->product
== NULL
) {
2392 for (kdp
= usb_knowndevs
; kdp
->vendorname
!= NULL
; kdp
++) {
2393 if (kdp
->vendor
== vendor_id
&&
2394 (kdp
->product
== product_id
||
2395 (kdp
->flags
& USB_KNOWNDEV_NOPROD
) != 0))
2398 if (kdp
->vendorname
!= NULL
) {
2399 /* XXX should use pointer to knowndevs string */
2400 if (udev
->manufacturer
== NULL
) {
2401 udev
->manufacturer
= kstrdup(kdp
->vendorname
,
2404 if (udev
->product
== NULL
&&
2405 (kdp
->flags
& USB_KNOWNDEV_NOPROD
) == 0) {
2406 udev
->product
= kstrdup(kdp
->productname
,
2412 /* Provide default strings if none were found */
2413 if (udev
->manufacturer
== NULL
) {
2414 ksnprintf(temp_ptr
, temp_size
, "vendor 0x%04x", vendor_id
);
2415 udev
->manufacturer
= kstrdup(temp_ptr
, M_USB
);
2417 if (udev
->product
== NULL
) {
2418 ksnprintf(temp_ptr
, temp_size
, "product 0x%04x", product_id
);
2419 udev
->product
= kstrdup(temp_ptr
, M_USB
);
2423 usbd_enum_unlock(udev
);
2431 usbd_get_mode(struct usb_device
*udev
)
2433 return (udev
->flags
.usb_mode
);
2438 * See: USB_SPEED_XXX
2441 usbd_get_speed(struct usb_device
*udev
)
2443 return (udev
->speed
);
2447 usbd_get_isoc_fps(struct usb_device
*udev
)
2450 switch (udev
->speed
) {
2452 case USB_SPEED_FULL
:
2459 struct usb_device_descriptor
*
2460 usbd_get_device_descriptor(struct usb_device
*udev
)
2463 return (NULL
); /* be NULL safe */
2464 return (&udev
->ddesc
);
2467 struct usb_config_descriptor
*
2468 usbd_get_config_descriptor(struct usb_device
*udev
)
2471 return (NULL
); /* be NULL safe */
2472 return (udev
->cdesc
);
2475 /*------------------------------------------------------------------------*
2476 * usb_test_quirk - test a device for a given quirk
2479 * 0: The USB device does not have the given quirk.
2480 * Else: The USB device has the given quirk.
2481 *------------------------------------------------------------------------*/
2483 usb_test_quirk(const struct usb_attach_arg
*uaa
, uint16_t quirk
)
2488 if (quirk
== UQ_NONE
)
2491 /* search the automatic per device quirks first */
2493 for (x
= 0; x
!= USB_MAX_AUTO_QUIRK
; x
++) {
2494 if (uaa
->device
->autoQuirk
[x
] == quirk
)
2498 /* search global quirk table, if any */
2500 found
= (usb_test_quirk_p
) (&uaa
->info
, quirk
);
2505 struct usb_interface_descriptor
*
2506 usbd_get_interface_descriptor(struct usb_interface
*iface
)
2509 return (NULL
); /* be NULL safe */
2510 return (iface
->idesc
);
2514 usbd_get_interface_altindex(struct usb_interface
*iface
)
2516 return (iface
->alt_index
);
2520 usbd_get_bus_index(struct usb_device
*udev
)
2522 return ((uint8_t)device_get_unit(udev
->bus
->bdev
));
2526 usbd_get_device_index(struct usb_device
*udev
)
2528 return (udev
->device_index
);
2533 usb_notify_addq(const char *type
, struct usb_device
*udev
)
2535 struct usb_interface
*iface
;
2539 /* announce the device */
2540 sb
= sbuf_new(NULL
, NULL
, 4096, SBUF_AUTOEXTEND
);
2549 "devsubclass=0x%02x "
2562 UGETW(udev
->ddesc
.idVendor
),
2563 UGETW(udev
->ddesc
.idProduct
),
2564 udev
->ddesc
.bDeviceClass
,
2565 udev
->ddesc
.bDeviceSubClass
,
2566 usb_get_serial(udev
),
2567 UGETW(udev
->ddesc
.bcdDevice
),
2568 (udev
->flags
.usb_mode
== USB_MODE_HOST
) ? "host" : "device",
2571 , udev
->parent_hub
!= NULL
?
2572 udev
->parent_hub
->ugen_name
:
2573 device_get_nameunit(device_get_parent(udev
->bus
->bdev
))
2577 devctl_notify("USB", "DEVICE", type
, sbuf_data(sb
));
2580 /* announce each interface */
2581 for (i
= 0; i
< USB_IFACE_MAX
; i
++) {
2582 iface
= usbd_get_iface(udev
, i
);
2584 break; /* end of interfaces */
2585 if (iface
->idesc
== NULL
)
2586 continue; /* no interface descriptor */
2589 sb
= sbuf_new(NULL
, NULL
, 4096, SBUF_AUTOEXTEND
);
2598 "devsubclass=0x%02x "
2605 "intsubclass=0x%02x "
2606 "intprotocol=0x%02x",
2611 UGETW(udev
->ddesc
.idVendor
),
2612 UGETW(udev
->ddesc
.idProduct
),
2613 udev
->ddesc
.bDeviceClass
,
2614 udev
->ddesc
.bDeviceSubClass
,
2615 usb_get_serial(udev
),
2616 UGETW(udev
->ddesc
.bcdDevice
),
2617 (udev
->flags
.usb_mode
== USB_MODE_HOST
) ? "host" : "device",
2618 iface
->idesc
->bInterfaceNumber
,
2619 iface
->idesc
->bNumEndpoints
,
2620 iface
->idesc
->bInterfaceClass
,
2621 iface
->idesc
->bInterfaceSubClass
,
2622 iface
->idesc
->bInterfaceProtocol
);
2624 devctl_notify("USB", "INTERFACE", type
, sbuf_data(sb
));
2631 /*------------------------------------------------------------------------*
2632 * usb_fifo_free_wrap
2634 * This function will free the FIFOs.
2636 * Description of "flag" argument: If the USB_UNCFG_FLAG_FREE_EP0 flag
2637 * is set and "iface_index" is set to "USB_IFACE_INDEX_ANY", we free
2638 * all FIFOs. If the USB_UNCFG_FLAG_FREE_EP0 flag is not set and
2639 * "iface_index" is set to "USB_IFACE_INDEX_ANY", we free all non
2640 * control endpoint FIFOs. If "iface_index" is not set to
2641 * "USB_IFACE_INDEX_ANY" the flag has no effect.
2642 *------------------------------------------------------------------------*/
2644 usb_fifo_free_wrap(struct usb_device
*udev
,
2645 uint8_t iface_index
, uint8_t flag
)
2651 * Free any USB FIFOs on the given interface:
2653 for (i
= 0; i
!= USB_FIFO_MAX
; i
++) {
2658 /* Check if the interface index matches */
2659 if (iface_index
== f
->iface_index
) {
2660 if (f
->methods
!= &usb_ugen_methods
) {
2662 * Don't free any non-generic FIFOs in
2667 if ((f
->dev_ep_index
== 0) &&
2668 (f
->fs_xfer
== NULL
)) {
2669 /* no need to free this FIFO */
2672 } else if (iface_index
== USB_IFACE_INDEX_ANY
) {
2673 if ((f
->methods
== &usb_ugen_methods
) &&
2674 (f
->dev_ep_index
== 0) &&
2675 (!(flag
& USB_UNCFG_FLAG_FREE_EP0
)) &&
2676 (f
->fs_xfer
== NULL
)) {
2677 /* no need to free this FIFO */
2681 /* no need to free this FIFO */
2684 /* free this FIFO */
2690 /*------------------------------------------------------------------------*
2691 * usb_peer_can_wakeup
2694 * 0: Peer cannot do resume signalling.
2695 * Else: Peer can do resume signalling.
2696 *------------------------------------------------------------------------*/
2698 usb_peer_can_wakeup(struct usb_device
*udev
)
2700 const struct usb_config_descriptor
*cdp
;
2703 if ((cdp
!= NULL
) && (udev
->flags
.usb_mode
== USB_MODE_HOST
)) {
2704 return (cdp
->bmAttributes
& UC_REMOTE_WAKEUP
);
2706 return (0); /* not supported */
2710 usb_set_device_state(struct usb_device
*udev
, enum usb_dev_state state
)
2713 KASSERT(state
< USB_STATE_MAX
, ("invalid udev state"));
2715 DPRINTF("udev %p state %s -> %s\n", udev
,
2716 usb_statestr(udev
->state
), usb_statestr(state
));
2719 lockmgr(&usb_ref_lock
, LK_EXCLUSIVE
);
2721 udev
->state
= state
;
2723 lockmgr(&usb_ref_lock
, LK_RELEASE
);
2725 if (udev
->bus
->methods
->device_state_change
!= NULL
)
2726 (udev
->bus
->methods
->device_state_change
) (udev
);
2730 usb_get_device_state(struct usb_device
*udev
)
2733 return (USB_STATE_DETACHED
);
2734 return (udev
->state
);
2738 usbd_device_attached(struct usb_device
*udev
)
2740 return (udev
->state
> USB_STATE_DETACHED
);
2744 * The following function locks enumerating the given USB device. If
2745 * the lock is already grabbed this function returns zero. Else a
2746 * non-zero value is returned.
2749 usbd_enum_lock(struct usb_device
*udev
)
2751 if (lockstatus(&udev
->enum_lock
, curthread
)==LK_EXCLUSIVE
)
2754 lockmgr(&udev
->enum_lock
, LK_EXCLUSIVE
);
2755 lockmgr(&udev
->sr_lock
, LK_EXCLUSIVE
);
2757 * NEWBUS LOCK NOTE: We should check if any parent SX locks
2758 * are locked before locking Giant. Else the lock can be
2759 * locked multiple times.
2764 /* The following function unlocks enumerating the given USB device. */
2767 usbd_enum_unlock(struct usb_device
*udev
)
2769 lockmgr(&udev
->enum_lock
, LK_RELEASE
);
2770 lockmgr(&udev
->sr_lock
, LK_RELEASE
);
2773 /* The following function locks suspend and resume. */
2776 usbd_sr_lock(struct usb_device
*udev
)
2778 lockmgr(&udev
->sr_lock
, LK_EXCLUSIVE
);
2780 * NEWBUS LOCK NOTE: We should check if any parent SX locks
2781 * are locked before locking Giant. Else the lock can be
2782 * locked multiple times.
2786 /* The following function unlocks suspend and resume. */
2789 usbd_sr_unlock(struct usb_device
*udev
)
2791 lockmgr(&udev
->sr_lock
, LK_RELEASE
);
2795 * The following function checks the enumerating lock for the given
2800 usbd_enum_is_locked(struct usb_device
*udev
)
2802 /* XXX: Make sure that we return a correct value here */
2803 return (lockowned(&udev
->enum_lock
));
2807 * The following function is used to set the per-interface specific
2808 * plug and play information. The string referred to by the pnpinfo
2809 * argument can safely be freed after calling this function. The
2810 * pnpinfo of an interface will be reset at device detach or when
2811 * passing a NULL argument to this function. This function
2812 * returns zero on success, else a USB_ERR_XXX failure code.
2816 usbd_set_pnpinfo(struct usb_device
*udev
, uint8_t iface_index
, const char *pnpinfo
)
2818 struct usb_interface
*iface
;
2820 iface
= usbd_get_iface(udev
, iface_index
);
2822 return (USB_ERR_INVAL
);
2824 if (iface
->pnpinfo
!= NULL
) {
2825 kfree(iface
->pnpinfo
, M_USBDEV
);
2826 iface
->pnpinfo
= NULL
;
2829 if (pnpinfo
== NULL
|| pnpinfo
[0] == 0)
2830 return (0); /* success */
2832 iface
->pnpinfo
= kstrdup(pnpinfo
, M_USBDEV
);
2833 if (iface
->pnpinfo
== NULL
)
2834 return (USB_ERR_NOMEM
);
2836 return (0); /* success */
2840 usbd_add_dynamic_quirk(struct usb_device
*udev
, uint16_t quirk
)
2844 for (x
= 0; x
!= USB_MAX_AUTO_QUIRK
; x
++) {
2845 if (udev
->autoQuirk
[x
] == 0 ||
2846 udev
->autoQuirk
[x
] == quirk
) {
2847 udev
->autoQuirk
[x
] = quirk
;
2848 return (0); /* success */
2851 return (USB_ERR_NOMEM
);
2855 * The following function is used to select the endpoint mode. It
2856 * should not be called outside enumeration context.
2860 usbd_set_endpoint_mode(struct usb_device
*udev
, struct usb_endpoint
*ep
,
2866 /* Prevent re-enumeration */
2867 do_unlock
= usbd_enum_lock(udev
);
2869 if (udev
->bus
->methods
->set_endpoint_mode
!= NULL
) {
2870 error
= (udev
->bus
->methods
->set_endpoint_mode
) (
2872 } else if (ep_mode
!= USB_EP_MODE_DEFAULT
) {
2873 error
= USB_ERR_INVAL
;
2878 /* only set new mode regardless of error */
2879 ep
->ep_mode
= ep_mode
;
2882 usbd_enum_unlock(udev
);
2887 usbd_get_endpoint_mode(struct usb_device
*udev
, struct usb_endpoint
*ep
)
2889 return (ep
->ep_mode
);