usb_device.c revision 250986
189857Sobrien/* $FreeBSD: head/sys/dev/usb/usb_device.c 250986 2013-05-25 17:09:58Z hselasky $ */
289857Sobrien/*-
389857Sobrien * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
489857Sobrien *
589857Sobrien * Redistribution and use in source and binary forms, with or without
689857Sobrien * modification, are permitted provided that the following conditions
789857Sobrien * are met:
889857Sobrien * 1. Redistributions of source code must retain the above copyright
989857Sobrien *    notice, this list of conditions and the following disclaimer.
1089857Sobrien * 2. Redistributions in binary form must reproduce the above copyright
1189857Sobrien *    notice, this list of conditions and the following disclaimer in the
1289857Sobrien *    documentation and/or other materials provided with the distribution.
1389857Sobrien *
1489857Sobrien * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1589857Sobrien * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1689857Sobrien * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1789857Sobrien * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1889857Sobrien * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19218822Sdim * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2089857Sobrien * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2189857Sobrien * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2289857Sobrien * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2389857Sobrien * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2489857Sobrien * SUCH DAMAGE.
2589857Sobrien */
2689857Sobrien
2789857Sobrien#ifdef USB_GLOBAL_INCLUDE_FILE
2889857Sobrien#include USB_GLOBAL_INCLUDE_FILE
2989857Sobrien#else
3089857Sobrien#include <sys/stdint.h>
3189857Sobrien#include <sys/stddef.h>
3289857Sobrien#include <sys/param.h>
3389857Sobrien#include <sys/queue.h>
3489857Sobrien#include <sys/types.h>
3589857Sobrien#include <sys/systm.h>
3689857Sobrien#include <sys/kernel.h>
3789857Sobrien#include <sys/bus.h>
3889857Sobrien#include <sys/module.h>
3989857Sobrien#include <sys/lock.h>
4089857Sobrien#include <sys/mutex.h>
41218822Sdim#include <sys/condvar.h>
42218822Sdim#include <sys/sysctl.h>
4389857Sobrien#include <sys/sx.h>
4489857Sobrien#include <sys/unistd.h>
4589857Sobrien#include <sys/callout.h>
46218822Sdim#include <sys/malloc.h>
4789857Sobrien#include <sys/priv.h>
4889857Sobrien#include <sys/conf.h>
4989857Sobrien#include <sys/fcntl.h>
50218822Sdim
5189857Sobrien#include <dev/usb/usb.h>
52#include <dev/usb/usbdi.h>
53#include <dev/usb/usbdi_util.h>
54#include <dev/usb/usb_ioctl.h>
55
56#if USB_HAVE_UGEN
57#include <sys/sbuf.h>
58#endif
59
60#include "usbdevs.h"
61
62#define	USB_DEBUG_VAR usb_debug
63
64#include <dev/usb/usb_core.h>
65#include <dev/usb/usb_debug.h>
66#include <dev/usb/usb_process.h>
67#include <dev/usb/usb_device.h>
68#include <dev/usb/usb_busdma.h>
69#include <dev/usb/usb_transfer.h>
70#include <dev/usb/usb_request.h>
71#include <dev/usb/usb_dynamic.h>
72#include <dev/usb/usb_hub.h>
73#include <dev/usb/usb_util.h>
74#include <dev/usb/usb_msctest.h>
75#if USB_HAVE_UGEN
76#include <dev/usb/usb_dev.h>
77#include <dev/usb/usb_generic.h>
78#endif
79
80#include <dev/usb/quirk/usb_quirk.h>
81
82#include <dev/usb/usb_controller.h>
83#include <dev/usb/usb_bus.h>
84#endif			/* USB_GLOBAL_INCLUDE_FILE */
85
86/* function prototypes  */
87
88static void	usb_init_endpoint(struct usb_device *, uint8_t,
89		    struct usb_endpoint_descriptor *,
90		    struct usb_endpoint_ss_comp_descriptor *,
91		    struct usb_endpoint *);
92static void	usb_unconfigure(struct usb_device *, uint8_t);
93static void	usb_detach_device_sub(struct usb_device *, device_t *,
94		    char **, uint8_t);
95static uint8_t	usb_probe_and_attach_sub(struct usb_device *,
96		    struct usb_attach_arg *);
97static void	usb_init_attach_arg(struct usb_device *,
98		    struct usb_attach_arg *);
99static void	usb_suspend_resume_sub(struct usb_device *, device_t,
100		    uint8_t);
101static void	usbd_clear_stall_proc(struct usb_proc_msg *_pm);
102static usb_error_t usb_config_parse(struct usb_device *, uint8_t, uint8_t);
103static void	usbd_set_device_strings(struct usb_device *);
104#if USB_HAVE_DEVCTL
105static void	usb_notify_addq(const char *type, struct usb_device *);
106#endif
107#if USB_HAVE_UGEN
108static void	usb_fifo_free_wrap(struct usb_device *, uint8_t, uint8_t);
109static void	usb_cdev_create(struct usb_device *);
110static void	usb_cdev_free(struct usb_device *);
111#endif
112
113/* This variable is global to allow easy access to it: */
114
115#ifdef	USB_TEMPLATE
116int	usb_template = USB_TEMPLATE;
117#else
118int	usb_template;
119#endif
120
121TUNABLE_INT("hw.usb.usb_template", &usb_template);
122SYSCTL_INT(_hw_usb, OID_AUTO, template, CTLFLAG_RW | CTLFLAG_TUN,
123    &usb_template, 0, "Selected USB device side template");
124
125/* English is default language */
126
127static int usb_lang_id = 0x0009;
128static int usb_lang_mask = 0x00FF;
129
130TUNABLE_INT("hw.usb.usb_lang_id", &usb_lang_id);
131SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_id, CTLFLAG_RW | CTLFLAG_TUN,
132    &usb_lang_id, 0, "Preferred USB language ID");
133
134TUNABLE_INT("hw.usb.usb_lang_mask", &usb_lang_mask);
135SYSCTL_INT(_hw_usb, OID_AUTO, usb_lang_mask, CTLFLAG_RW | CTLFLAG_TUN,
136    &usb_lang_mask, 0, "Preferred USB language mask");
137
138static const char* statestr[USB_STATE_MAX] = {
139	[USB_STATE_DETACHED]	= "DETACHED",
140	[USB_STATE_ATTACHED]	= "ATTACHED",
141	[USB_STATE_POWERED]	= "POWERED",
142	[USB_STATE_ADDRESSED]	= "ADDRESSED",
143	[USB_STATE_CONFIGURED]	= "CONFIGURED",
144};
145
146const char *
147usb_statestr(enum usb_dev_state state)
148{
149	return ((state < USB_STATE_MAX) ? statestr[state] : "UNKNOWN");
150}
151
152const char *
153usb_get_manufacturer(struct usb_device *udev)
154{
155	return (udev->manufacturer ? udev->manufacturer : "Unknown");
156}
157
158const char *
159usb_get_product(struct usb_device *udev)
160{
161	return (udev->product ? udev->product : "");
162}
163
164const char *
165usb_get_serial(struct usb_device *udev)
166{
167	return (udev->serial ? udev->serial : "");
168}
169
170/*------------------------------------------------------------------------*
171 *	usbd_get_ep_by_addr
172 *
173 * This function searches for an USB ep by endpoint address and
174 * direction.
175 *
176 * Returns:
177 * NULL: Failure
178 * Else: Success
179 *------------------------------------------------------------------------*/
180struct usb_endpoint *
181usbd_get_ep_by_addr(struct usb_device *udev, uint8_t ea_val)
182{
183	struct usb_endpoint *ep = udev->endpoints;
184	struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
185	enum {
186		EA_MASK = (UE_DIR_IN | UE_DIR_OUT | UE_ADDR),
187	};
188
189	/*
190	 * According to the USB specification not all bits are used
191	 * for the endpoint address. Keep defined bits only:
192	 */
193	ea_val &= EA_MASK;
194
195	/*
196	 * Iterate accross all the USB endpoints searching for a match
197	 * based on the endpoint address:
198	 */
199	for (; ep != ep_end; ep++) {
200
201		if (ep->edesc == NULL) {
202			continue;
203		}
204		/* do the mask and check the value */
205		if ((ep->edesc->bEndpointAddress & EA_MASK) == ea_val) {
206			goto found;
207		}
208	}
209
210	/*
211	 * The default endpoint is always present and is checked separately:
212	 */
213	if ((udev->ctrl_ep.edesc != NULL) &&
214	    ((udev->ctrl_ep.edesc->bEndpointAddress & EA_MASK) == ea_val)) {
215		ep = &udev->ctrl_ep;
216		goto found;
217	}
218	return (NULL);
219
220found:
221	return (ep);
222}
223
224/*------------------------------------------------------------------------*
225 *	usbd_get_endpoint
226 *
227 * This function searches for an USB endpoint based on the information
228 * given by the passed "struct usb_config" pointer.
229 *
230 * Return values:
231 * NULL: No match.
232 * Else: Pointer to "struct usb_endpoint".
233 *------------------------------------------------------------------------*/
234struct usb_endpoint *
235usbd_get_endpoint(struct usb_device *udev, uint8_t iface_index,
236    const struct usb_config *setup)
237{
238	struct usb_endpoint *ep = udev->endpoints;
239	struct usb_endpoint *ep_end = udev->endpoints + udev->endpoints_max;
240	uint8_t index = setup->ep_index;
241	uint8_t ea_mask;
242	uint8_t ea_val;
243	uint8_t type_mask;
244	uint8_t type_val;
245
246	DPRINTFN(10, "udev=%p iface_index=%d address=0x%x "
247	    "type=0x%x dir=0x%x index=%d\n",
248	    udev, iface_index, setup->endpoint,
249	    setup->type, setup->direction, setup->ep_index);
250
251	/* check USB mode */
252
253	if (setup->usb_mode != USB_MODE_DUAL &&
254	    udev->flags.usb_mode != setup->usb_mode) {
255		/* wrong mode - no endpoint */
256		return (NULL);
257	}
258
259	/* setup expected endpoint direction mask and value */
260
261	if (setup->direction == UE_DIR_RX) {
262		ea_mask = (UE_DIR_IN | UE_DIR_OUT);
263		ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ?
264		    UE_DIR_OUT : UE_DIR_IN;
265	} else if (setup->direction == UE_DIR_TX) {
266		ea_mask = (UE_DIR_IN | UE_DIR_OUT);
267		ea_val = (udev->flags.usb_mode == USB_MODE_DEVICE) ?
268		    UE_DIR_IN : UE_DIR_OUT;
269	} else if (setup->direction == UE_DIR_ANY) {
270		/* match any endpoint direction */
271		ea_mask = 0;
272		ea_val = 0;
273	} else {
274		/* match the given endpoint direction */
275		ea_mask = (UE_DIR_IN | UE_DIR_OUT);
276		ea_val = (setup->direction & (UE_DIR_IN | UE_DIR_OUT));
277	}
278
279	/* setup expected endpoint address */
280
281	if (setup->endpoint == UE_ADDR_ANY) {
282		/* match any endpoint address */
283	} else {
284		/* match the given endpoint address */
285		ea_mask |= UE_ADDR;
286		ea_val |= (setup->endpoint & UE_ADDR);
287	}
288
289	/* setup expected endpoint type */
290
291	if (setup->type == UE_BULK_INTR) {
292		/* this will match BULK and INTERRUPT endpoints */
293		type_mask = 2;
294		type_val = 2;
295	} else if (setup->type == UE_TYPE_ANY) {
296		/* match any endpoint type */
297		type_mask = 0;
298		type_val = 0;
299	} else {
300		/* match the given endpoint type */
301		type_mask = UE_XFERTYPE;
302		type_val = (setup->type & UE_XFERTYPE);
303	}
304
305	/*
306	 * Iterate accross all the USB endpoints searching for a match
307	 * based on the endpoint address. Note that we are searching
308	 * the endpoints from the beginning of the "udev->endpoints" array.
309	 */
310	for (; ep != ep_end; ep++) {
311
312		if ((ep->edesc == NULL) ||
313		    (ep->iface_index != iface_index)) {
314			continue;
315		}
316		/* do the masks and check the values */
317
318		if (((ep->edesc->bEndpointAddress & ea_mask) == ea_val) &&
319		    ((ep->edesc->bmAttributes & type_mask) == type_val)) {
320			if (!index--) {
321				goto found;
322			}
323		}
324	}
325
326	/*
327	 * Match against default endpoint last, so that "any endpoint", "any
328	 * address" and "any direction" returns the first endpoint of the
329	 * interface. "iface_index" and "direction" is ignored:
330	 */
331	if ((udev->ctrl_ep.edesc != NULL) &&
332	    ((udev->ctrl_ep.edesc->bEndpointAddress & ea_mask) == ea_val) &&
333	    ((udev->ctrl_ep.edesc->bmAttributes & type_mask) == type_val) &&
334	    (!index)) {
335		ep = &udev->ctrl_ep;
336		goto found;
337	}
338	return (NULL);
339
340found:
341	return (ep);
342}
343
344/*------------------------------------------------------------------------*
345 *	usbd_interface_count
346 *
347 * This function stores the number of USB interfaces excluding
348 * alternate settings, which the USB config descriptor reports into
349 * the unsigned 8-bit integer pointed to by "count".
350 *
351 * Returns:
352 *    0: Success
353 * Else: Failure
354 *------------------------------------------------------------------------*/
355usb_error_t
356usbd_interface_count(struct usb_device *udev, uint8_t *count)
357{
358	if (udev->cdesc == NULL) {
359		*count = 0;
360		return (USB_ERR_NOT_CONFIGURED);
361	}
362	*count = udev->ifaces_max;
363	return (USB_ERR_NORMAL_COMPLETION);
364}
365
366/*------------------------------------------------------------------------*
367 *	usb_init_endpoint
368 *
369 * This function will initialise the USB endpoint structure pointed to by
370 * the "endpoint" argument. The structure pointed to by "endpoint" must be
371 * zeroed before calling this function.
372 *------------------------------------------------------------------------*/
373static void
374usb_init_endpoint(struct usb_device *udev, uint8_t iface_index,
375    struct usb_endpoint_descriptor *edesc,
376    struct usb_endpoint_ss_comp_descriptor *ecomp,
377    struct usb_endpoint *ep)
378{
379	struct usb_bus_methods *methods;
380	usb_stream_t x;
381
382	methods = udev->bus->methods;
383
384	(methods->endpoint_init) (udev, edesc, ep);
385
386	/* initialise USB endpoint structure */
387	ep->edesc = edesc;
388	ep->ecomp = ecomp;
389	ep->iface_index = iface_index;
390
391	/* setup USB stream queues */
392	for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
393		TAILQ_INIT(&ep->endpoint_q[x].head);
394		ep->endpoint_q[x].command = &usbd_pipe_start;
395	}
396
397	/* the pipe is not supported by the hardware */
398 	if (ep->methods == NULL)
399		return;
400
401	/* check for SUPER-speed streams mode endpoint */
402	if (udev->speed == USB_SPEED_SUPER && ecomp != NULL &&
403	    (edesc->bmAttributes & UE_XFERTYPE) == UE_BULK &&
404	    (UE_GET_BULK_STREAMS(ecomp->bmAttributes) != 0)) {
405		usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_STREAMS);
406	} else {
407		usbd_set_endpoint_mode(udev, ep, USB_EP_MODE_DEFAULT);
408	}
409
410	/* clear stall, if any */
411	if (methods->clear_stall != NULL) {
412		USB_BUS_LOCK(udev->bus);
413		(methods->clear_stall) (udev, ep);
414		USB_BUS_UNLOCK(udev->bus);
415	}
416}
417
418/*-----------------------------------------------------------------------*
419 *	usb_endpoint_foreach
420 *
421 * This function will iterate all the USB endpoints except the control
422 * endpoint. This function is NULL safe.
423 *
424 * Return values:
425 * NULL: End of USB endpoints
426 * Else: Pointer to next USB endpoint
427 *------------------------------------------------------------------------*/
428struct usb_endpoint *
429usb_endpoint_foreach(struct usb_device *udev, struct usb_endpoint *ep)
430{
431	struct usb_endpoint *ep_end;
432
433	/* be NULL safe */
434	if (udev == NULL)
435		return (NULL);
436
437	ep_end = udev->endpoints + udev->endpoints_max;
438
439	/* get next endpoint */
440	if (ep == NULL)
441		ep = udev->endpoints;
442	else
443		ep++;
444
445	/* find next allocated ep */
446	while (ep != ep_end) {
447		if (ep->edesc != NULL)
448			return (ep);
449		ep++;
450	}
451	return (NULL);
452}
453
454/*------------------------------------------------------------------------*
455 *	usb_unconfigure
456 *
457 * This function will free all USB interfaces and USB endpoints belonging
458 * to an USB device.
459 *
460 * Flag values, see "USB_UNCFG_FLAG_XXX".
461 *------------------------------------------------------------------------*/
462static void
463usb_unconfigure(struct usb_device *udev, uint8_t flag)
464{
465	uint8_t do_unlock;
466
467	/* Prevent re-enumeration */
468	do_unlock = usbd_enum_lock(udev);
469
470	/* detach all interface drivers */
471	usb_detach_device(udev, USB_IFACE_INDEX_ANY, flag);
472
473#if USB_HAVE_UGEN
474	/* free all FIFOs except control endpoint FIFOs */
475	usb_fifo_free_wrap(udev, USB_IFACE_INDEX_ANY, flag);
476
477	/*
478	 * Free all cdev's, if any.
479	 */
480	usb_cdev_free(udev);
481#endif
482
483#if USB_HAVE_COMPAT_LINUX
484	/* free Linux compat device, if any */
485	if (udev->linux_endpoint_start) {
486		usb_linux_free_device(udev);
487		udev->linux_endpoint_start = NULL;
488	}
489#endif
490
491	usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_FREE);
492
493	/* free "cdesc" after "ifaces" and "endpoints", if any */
494	if (udev->cdesc != NULL) {
495		if (udev->flags.usb_mode != USB_MODE_DEVICE)
496			usbd_free_config_desc(udev, udev->cdesc);
497		udev->cdesc = NULL;
498	}
499	/* set unconfigured state */
500	udev->curr_config_no = USB_UNCONFIG_NO;
501	udev->curr_config_index = USB_UNCONFIG_INDEX;
502
503	if (do_unlock)
504		usbd_enum_unlock(udev);
505}
506
507/*------------------------------------------------------------------------*
508 *	usbd_set_config_index
509 *
510 * This function selects configuration by index, independent of the
511 * actual configuration number. This function should not be used by
512 * USB drivers.
513 *
514 * Returns:
515 *    0: Success
516 * Else: Failure
517 *------------------------------------------------------------------------*/
518usb_error_t
519usbd_set_config_index(struct usb_device *udev, uint8_t index)
520{
521	struct usb_status ds;
522	struct usb_config_descriptor *cdp;
523	uint16_t power;
524	uint16_t max_power;
525	uint8_t selfpowered;
526	uint8_t do_unlock;
527	usb_error_t err;
528
529	DPRINTFN(6, "udev=%p index=%d\n", udev, index);
530
531	/* Prevent re-enumeration */
532	do_unlock = usbd_enum_lock(udev);
533
534	usb_unconfigure(udev, 0);
535
536	if (index == USB_UNCONFIG_INDEX) {
537		/*
538		 * Leave unallocated when unconfiguring the
539		 * device. "usb_unconfigure()" will also reset
540		 * the current config number and index.
541		 */
542		err = usbd_req_set_config(udev, NULL, USB_UNCONFIG_NO);
543		if (udev->state == USB_STATE_CONFIGURED)
544			usb_set_device_state(udev, USB_STATE_ADDRESSED);
545		goto done;
546	}
547	/* get the full config descriptor */
548	if (udev->flags.usb_mode == USB_MODE_DEVICE) {
549		/* save some memory */
550		err = usbd_req_get_descriptor_ptr(udev, &cdp,
551		    (UDESC_CONFIG << 8) | index);
552	} else {
553		/* normal request */
554		err = usbd_req_get_config_desc_full(udev,
555		    NULL, &cdp, index);
556	}
557	if (err) {
558		goto done;
559	}
560	/* set the new config descriptor */
561
562	udev->cdesc = cdp;
563
564	/* Figure out if the device is self or bus powered. */
565	selfpowered = 0;
566	if ((!udev->flags.uq_bus_powered) &&
567	    (cdp->bmAttributes & UC_SELF_POWERED) &&
568	    (udev->flags.usb_mode == USB_MODE_HOST)) {
569		/* May be self powered. */
570		if (cdp->bmAttributes & UC_BUS_POWERED) {
571			/* Must ask device. */
572			err = usbd_req_get_device_status(udev, NULL, &ds);
573			if (err) {
574				DPRINTFN(0, "could not read "
575				    "device status: %s\n",
576				    usbd_errstr(err));
577			} else if (UGETW(ds.wStatus) & UDS_SELF_POWERED) {
578				selfpowered = 1;
579			}
580			DPRINTF("status=0x%04x \n",
581				UGETW(ds.wStatus));
582		} else
583			selfpowered = 1;
584	}
585	DPRINTF("udev=%p cdesc=%p (addr %d) cno=%d attr=0x%02x, "
586	    "selfpowered=%d, power=%d\n",
587	    udev, cdp,
588	    udev->address, cdp->bConfigurationValue, cdp->bmAttributes,
589	    selfpowered, cdp->bMaxPower * 2);
590
591	/* Check if we have enough power. */
592	power = cdp->bMaxPower * 2;
593
594	if (udev->parent_hub) {
595		max_power = udev->parent_hub->hub->portpower;
596	} else {
597		max_power = USB_MAX_POWER;
598	}
599
600	if (power > max_power) {
601		DPRINTFN(0, "power exceeded %d > %d\n", power, max_power);
602		err = USB_ERR_NO_POWER;
603		goto done;
604	}
605	/* Only update "self_powered" in USB Host Mode */
606	if (udev->flags.usb_mode == USB_MODE_HOST) {
607		udev->flags.self_powered = selfpowered;
608	}
609	udev->power = power;
610	udev->curr_config_no = cdp->bConfigurationValue;
611	udev->curr_config_index = index;
612	usb_set_device_state(udev, USB_STATE_CONFIGURED);
613
614	/* Set the actual configuration value. */
615	err = usbd_req_set_config(udev, NULL, cdp->bConfigurationValue);
616	if (err) {
617		goto done;
618	}
619
620	err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_ALLOC);
621	if (err) {
622		goto done;
623	}
624
625	err = usb_config_parse(udev, USB_IFACE_INDEX_ANY, USB_CFG_INIT);
626	if (err) {
627		goto done;
628	}
629
630#if USB_HAVE_UGEN
631	/* create device nodes for each endpoint */
632	usb_cdev_create(udev);
633#endif
634
635done:
636	DPRINTF("error=%s\n", usbd_errstr(err));
637	if (err) {
638		usb_unconfigure(udev, 0);
639	}
640	if (do_unlock)
641		usbd_enum_unlock(udev);
642	return (err);
643}
644
645/*------------------------------------------------------------------------*
646 *	usb_config_parse
647 *
648 * This function will allocate and free USB interfaces and USB endpoints,
649 * parse the USB configuration structure and initialise the USB endpoints
650 * and interfaces. If "iface_index" is not equal to
651 * "USB_IFACE_INDEX_ANY" then the "cmd" parameter is the
652 * alternate_setting to be selected for the given interface. Else the
653 * "cmd" parameter is defined by "USB_CFG_XXX". "iface_index" can be
654 * "USB_IFACE_INDEX_ANY" or a valid USB interface index. This function
655 * is typically called when setting the configuration or when setting
656 * an alternate interface.
657 *
658 * Returns:
659 *    0: Success
660 * Else: Failure
661 *------------------------------------------------------------------------*/
662static usb_error_t
663usb_config_parse(struct usb_device *udev, uint8_t iface_index, uint8_t cmd)
664{
665	struct usb_idesc_parse_state ips;
666	struct usb_interface_descriptor *id;
667	struct usb_endpoint_descriptor *ed;
668	struct usb_interface *iface;
669	struct usb_endpoint *ep;
670	usb_error_t err;
671	uint8_t ep_curr;
672	uint8_t ep_max;
673	uint8_t temp;
674	uint8_t do_init;
675	uint8_t alt_index;
676
677	if (iface_index != USB_IFACE_INDEX_ANY) {
678		/* parameter overload */
679		alt_index = cmd;
680		cmd = USB_CFG_INIT;
681	} else {
682		/* not used */
683		alt_index = 0;
684	}
685
686	err = 0;
687
688	DPRINTFN(5, "iface_index=%d cmd=%d\n",
689	    iface_index, cmd);
690
691	if (cmd == USB_CFG_FREE)
692		goto cleanup;
693
694	if (cmd == USB_CFG_INIT) {
695		sx_assert(&udev->enum_sx, SA_LOCKED);
696
697		/* check for in-use endpoints */
698
699		ep = udev->endpoints;
700		ep_max = udev->endpoints_max;
701		while (ep_max--) {
702			/* look for matching endpoints */
703			if ((iface_index == USB_IFACE_INDEX_ANY) ||
704			    (iface_index == ep->iface_index)) {
705				if (ep->refcount_alloc != 0) {
706					/*
707					 * This typically indicates a
708					 * more serious error.
709					 */
710					err = USB_ERR_IN_USE;
711				} else {
712					/* reset endpoint */
713					memset(ep, 0, sizeof(*ep));
714					/* make sure we don't zero the endpoint again */
715					ep->iface_index = USB_IFACE_INDEX_ANY;
716				}
717			}
718			ep++;
719		}
720
721		if (err)
722			return (err);
723	}
724
725	memset(&ips, 0, sizeof(ips));
726
727	ep_curr = 0;
728	ep_max = 0;
729
730	while ((id = usb_idesc_foreach(udev->cdesc, &ips))) {
731
732		iface = udev->ifaces + ips.iface_index;
733
734		/* check for specific interface match */
735
736		if (cmd == USB_CFG_INIT) {
737			if ((iface_index != USB_IFACE_INDEX_ANY) &&
738			    (iface_index != ips.iface_index)) {
739				/* wrong interface */
740				do_init = 0;
741			} else if (alt_index != ips.iface_index_alt) {
742				/* wrong alternate setting */
743				do_init = 0;
744			} else {
745				/* initialise interface */
746				do_init = 1;
747			}
748		} else
749			do_init = 0;
750
751		/* check for new interface */
752		if (ips.iface_index_alt == 0) {
753			/* update current number of endpoints */
754			ep_curr = ep_max;
755		}
756		/* check for init */
757		if (do_init) {
758			/* setup the USB interface structure */
759			iface->idesc = id;
760			/* set alternate index */
761			iface->alt_index = alt_index;
762			/* set default interface parent */
763			if (iface_index == USB_IFACE_INDEX_ANY) {
764				iface->parent_iface_index =
765				    USB_IFACE_INDEX_ANY;
766			}
767		}
768
769		DPRINTFN(5, "found idesc nendpt=%d\n", id->bNumEndpoints);
770
771		ed = (struct usb_endpoint_descriptor *)id;
772
773		temp = ep_curr;
774
775		/* iterate all the endpoint descriptors */
776		while ((ed = usb_edesc_foreach(udev->cdesc, ed))) {
777
778			/* check if endpoint limit has been reached */
779			if (temp >= USB_MAX_EP_UNITS) {
780				DPRINTF("Endpoint limit reached\n");
781				break;
782			}
783
784			ep = udev->endpoints + temp;
785
786			if (do_init) {
787				void *ecomp;
788
789				ecomp = usb_ed_comp_foreach(udev->cdesc, (void *)ed);
790				if (ecomp != NULL)
791					DPRINTFN(5, "Found endpoint companion descriptor\n");
792
793				usb_init_endpoint(udev,
794				    ips.iface_index, ed, ecomp, ep);
795			}
796
797			temp ++;
798
799			/* find maximum number of endpoints */
800			if (ep_max < temp)
801				ep_max = temp;
802		}
803	}
804
805	/* NOTE: It is valid to have no interfaces and no endpoints! */
806
807	if (cmd == USB_CFG_ALLOC) {
808		udev->ifaces_max = ips.iface_index;
809#if (USB_HAVE_FIXED_IFACE == 0)
810		udev->ifaces = NULL;
811		if (udev->ifaces_max != 0) {
812			udev->ifaces = malloc(sizeof(*iface) * udev->ifaces_max,
813			        M_USB, M_WAITOK | M_ZERO);
814			if (udev->ifaces == NULL) {
815				err = USB_ERR_NOMEM;
816				goto done;
817			}
818		}
819#endif
820#if (USB_HAVE_FIXED_ENDPOINT == 0)
821		if (ep_max != 0) {
822			udev->endpoints = malloc(sizeof(*ep) * ep_max,
823			        M_USB, M_WAITOK | M_ZERO);
824			if (udev->endpoints == NULL) {
825				err = USB_ERR_NOMEM;
826				goto done;
827			}
828		} else {
829			udev->endpoints = NULL;
830		}
831#endif
832		USB_BUS_LOCK(udev->bus);
833		udev->endpoints_max = ep_max;
834		/* reset any ongoing clear-stall */
835		udev->ep_curr = NULL;
836		USB_BUS_UNLOCK(udev->bus);
837	}
838#if (USB_HAVE_FIXED_IFACE == 0) || (USB_HAVE_FIXED_ENDPOINT == 0)
839done:
840#endif
841	if (err) {
842		if (cmd == USB_CFG_ALLOC) {
843cleanup:
844			USB_BUS_LOCK(udev->bus);
845			udev->endpoints_max = 0;
846			/* reset any ongoing clear-stall */
847			udev->ep_curr = NULL;
848			USB_BUS_UNLOCK(udev->bus);
849
850#if (USB_HAVE_FIXED_IFACE == 0)
851			free(udev->ifaces, M_USB);
852			udev->ifaces = NULL;
853#endif
854#if (USB_HAVE_FIXED_ENDPOINT == 0)
855			free(udev->endpoints, M_USB);
856			udev->endpoints = NULL;
857#endif
858			udev->ifaces_max = 0;
859		}
860	}
861	return (err);
862}
863
864/*------------------------------------------------------------------------*
865 *	usbd_set_alt_interface_index
866 *
867 * This function will select an alternate interface index for the
868 * given interface index. The interface should not be in use when this
869 * function is called. That means there should not be any open USB
870 * transfers. Else an error is returned. If the alternate setting is
871 * already set this function will simply return success. This function
872 * is called in Host mode and Device mode!
873 *
874 * Returns:
875 *    0: Success
876 * Else: Failure
877 *------------------------------------------------------------------------*/
878usb_error_t
879usbd_set_alt_interface_index(struct usb_device *udev,
880    uint8_t iface_index, uint8_t alt_index)
881{
882	struct usb_interface *iface = usbd_get_iface(udev, iface_index);
883	usb_error_t err;
884	uint8_t do_unlock;
885
886	/* Prevent re-enumeration */
887	do_unlock = usbd_enum_lock(udev);
888
889	if (iface == NULL) {
890		err = USB_ERR_INVAL;
891		goto done;
892	}
893	if (iface->alt_index == alt_index) {
894		/*
895		 * Optimise away duplicate setting of
896		 * alternate setting in USB Host Mode!
897		 */
898		err = 0;
899		goto done;
900	}
901#if USB_HAVE_UGEN
902	/*
903	 * Free all generic FIFOs for this interface, except control
904	 * endpoint FIFOs:
905	 */
906	usb_fifo_free_wrap(udev, iface_index, 0);
907#endif
908
909	err = usb_config_parse(udev, iface_index, alt_index);
910	if (err) {
911		goto done;
912	}
913	if (iface->alt_index != alt_index) {
914		/* the alternate setting does not exist */
915		err = USB_ERR_INVAL;
916		goto done;
917	}
918
919	err = usbd_req_set_alt_interface_no(udev, NULL, iface_index,
920	    iface->idesc->bAlternateSetting);
921
922done:
923	if (do_unlock)
924		usbd_enum_unlock(udev);
925	return (err);
926}
927
928/*------------------------------------------------------------------------*
929 *	usbd_set_endpoint_stall
930 *
931 * This function is used to make a BULK or INTERRUPT endpoint send
932 * STALL tokens in USB device mode.
933 *
934 * Returns:
935 *    0: Success
936 * Else: Failure
937 *------------------------------------------------------------------------*/
938usb_error_t
939usbd_set_endpoint_stall(struct usb_device *udev, struct usb_endpoint *ep,
940    uint8_t do_stall)
941{
942	struct usb_xfer *xfer;
943	usb_stream_t x;
944	uint8_t et;
945	uint8_t was_stalled;
946
947	if (ep == NULL) {
948		/* nothing to do */
949		DPRINTF("Cannot find endpoint\n");
950		/*
951		 * Pretend that the clear or set stall request is
952		 * successful else some USB host stacks can do
953		 * strange things, especially when a control endpoint
954		 * stalls.
955		 */
956		return (0);
957	}
958	et = (ep->edesc->bmAttributes & UE_XFERTYPE);
959
960	if ((et != UE_BULK) &&
961	    (et != UE_INTERRUPT)) {
962		/*
963	         * Should not stall control
964	         * nor isochronous endpoints.
965	         */
966		DPRINTF("Invalid endpoint\n");
967		return (0);
968	}
969	USB_BUS_LOCK(udev->bus);
970
971	/* store current stall state */
972	was_stalled = ep->is_stalled;
973
974	/* check for no change */
975	if (was_stalled && do_stall) {
976		/* if the endpoint is already stalled do nothing */
977		USB_BUS_UNLOCK(udev->bus);
978		DPRINTF("No change\n");
979		return (0);
980	}
981	/* set stalled state */
982	ep->is_stalled = 1;
983
984	if (do_stall || (!was_stalled)) {
985		if (!was_stalled) {
986			for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
987				/* lookup the current USB transfer, if any */
988				xfer = ep->endpoint_q[x].curr;
989				if (xfer != NULL) {
990					/*
991					 * The "xfer_stall" method
992					 * will complete the USB
993					 * transfer like in case of a
994					 * timeout setting the error
995					 * code "USB_ERR_STALLED".
996					 */
997					(udev->bus->methods->xfer_stall) (xfer);
998				}
999			}
1000		}
1001		(udev->bus->methods->set_stall) (udev, ep, &do_stall);
1002	}
1003	if (!do_stall) {
1004		ep->toggle_next = 0;	/* reset data toggle */
1005		ep->is_stalled = 0;	/* clear stalled state */
1006
1007		(udev->bus->methods->clear_stall) (udev, ep);
1008
1009		/* start the current or next transfer, if any */
1010		for (x = 0; x != USB_MAX_EP_STREAMS; x++) {
1011			usb_command_wrapper(&ep->endpoint_q[x],
1012			    ep->endpoint_q[x].curr);
1013		}
1014	}
1015	USB_BUS_UNLOCK(udev->bus);
1016	return (0);
1017}
1018
1019/*------------------------------------------------------------------------*
1020 *	usb_reset_iface_endpoints - used in USB device side mode
1021 *------------------------------------------------------------------------*/
1022usb_error_t
1023usb_reset_iface_endpoints(struct usb_device *udev, uint8_t iface_index)
1024{
1025	struct usb_endpoint *ep;
1026	struct usb_endpoint *ep_end;
1027
1028	ep = udev->endpoints;
1029	ep_end = udev->endpoints + udev->endpoints_max;
1030
1031	for (; ep != ep_end; ep++) {
1032
1033		if ((ep->edesc == NULL) ||
1034		    (ep->iface_index != iface_index)) {
1035			continue;
1036		}
1037		/* simulate a clear stall from the peer */
1038		usbd_set_endpoint_stall(udev, ep, 0);
1039	}
1040	return (0);
1041}
1042
1043/*------------------------------------------------------------------------*
1044 *	usb_detach_device_sub
1045 *
1046 * This function will try to detach an USB device. If it fails a panic
1047 * will result.
1048 *
1049 * Flag values, see "USB_UNCFG_FLAG_XXX".
1050 *------------------------------------------------------------------------*/
1051static void
1052usb_detach_device_sub(struct usb_device *udev, device_t *ppdev,
1053    char **ppnpinfo, uint8_t flag)
1054{
1055	device_t dev;
1056	char *pnpinfo;
1057	int err;
1058
1059	dev = *ppdev;
1060	if (dev) {
1061		/*
1062		 * NOTE: It is important to clear "*ppdev" before deleting
1063		 * the child due to some device methods being called late
1064		 * during the delete process !
1065		 */
1066		*ppdev = NULL;
1067
1068		device_printf(dev, "at %s, port %d, addr %d "
1069		    "(disconnected)\n",
1070		    device_get_nameunit(udev->parent_dev),
1071		    udev->port_no, udev->address);
1072
1073		if (device_is_attached(dev)) {
1074			if (udev->flags.peer_suspended) {
1075				err = DEVICE_RESUME(dev);
1076				if (err) {
1077					device_printf(dev, "Resume failed\n");
1078				}
1079			}
1080			if (device_detach(dev)) {
1081				goto error;
1082			}
1083		}
1084		if (device_delete_child(udev->parent_dev, dev)) {
1085			goto error;
1086		}
1087	}
1088
1089	pnpinfo = *ppnpinfo;
1090	if (pnpinfo != NULL) {
1091		*ppnpinfo = NULL;
1092		free(pnpinfo, M_USBDEV);
1093	}
1094	return;
1095
1096error:
1097	/* Detach is not allowed to fail in the USB world */
1098	panic("usb_detach_device_sub: A USB driver would not detach\n");
1099}
1100
1101/*------------------------------------------------------------------------*
1102 *	usb_detach_device
1103 *
1104 * The following function will detach the matching interfaces.
1105 * This function is NULL safe.
1106 *
1107 * Flag values, see "USB_UNCFG_FLAG_XXX".
1108 *------------------------------------------------------------------------*/
1109void
1110usb_detach_device(struct usb_device *udev, uint8_t iface_index,
1111    uint8_t flag)
1112{
1113	struct usb_interface *iface;
1114	uint8_t i;
1115
1116	if (udev == NULL) {
1117		/* nothing to do */
1118		return;
1119	}
1120	DPRINTFN(4, "udev=%p\n", udev);
1121
1122	sx_assert(&udev->enum_sx, SA_LOCKED);
1123
1124	/*
1125	 * First detach the child to give the child's detach routine a
1126	 * chance to detach the sub-devices in the correct order.
1127	 * Then delete the child using "device_delete_child()" which
1128	 * will detach all sub-devices from the bottom and upwards!
1129	 */
1130	if (iface_index != USB_IFACE_INDEX_ANY) {
1131		i = iface_index;
1132		iface_index = i + 1;
1133	} else {
1134		i = 0;
1135		iface_index = USB_IFACE_MAX;
1136	}
1137
1138	/* do the detach */
1139
1140	for (; i != iface_index; i++) {
1141
1142		iface = usbd_get_iface(udev, i);
1143		if (iface == NULL) {
1144			/* looks like the end of the USB interfaces */
1145			break;
1146		}
1147		usb_detach_device_sub(udev, &iface->subdev,
1148		    &iface->pnpinfo, flag);
1149	}
1150}
1151
1152/*------------------------------------------------------------------------*
1153 *	usb_probe_and_attach_sub
1154 *
1155 * Returns:
1156 *    0: Success
1157 * Else: Failure
1158 *------------------------------------------------------------------------*/
1159static uint8_t
1160usb_probe_and_attach_sub(struct usb_device *udev,
1161    struct usb_attach_arg *uaa)
1162{
1163	struct usb_interface *iface;
1164	device_t dev;
1165	int err;
1166
1167	iface = uaa->iface;
1168	if (iface->parent_iface_index != USB_IFACE_INDEX_ANY) {
1169		/* leave interface alone */
1170		return (0);
1171	}
1172	dev = iface->subdev;
1173	if (dev) {
1174
1175		/* clean up after module unload */
1176
1177		if (device_is_attached(dev)) {
1178			/* already a device there */
1179			return (0);
1180		}
1181		/* clear "iface->subdev" as early as possible */
1182
1183		iface->subdev = NULL;
1184
1185		if (device_delete_child(udev->parent_dev, dev)) {
1186
1187			/*
1188			 * Panic here, else one can get a double call
1189			 * to device_detach().  USB devices should
1190			 * never fail on detach!
1191			 */
1192			panic("device_delete_child() failed\n");
1193		}
1194	}
1195	if (uaa->temp_dev == NULL) {
1196
1197		/* create a new child */
1198		uaa->temp_dev = device_add_child(udev->parent_dev, NULL, -1);
1199		if (uaa->temp_dev == NULL) {
1200			device_printf(udev->parent_dev,
1201			    "Device creation failed\n");
1202			return (1);	/* failure */
1203		}
1204		device_set_ivars(uaa->temp_dev, uaa);
1205		device_quiet(uaa->temp_dev);
1206	}
1207	/*
1208	 * Set "subdev" before probe and attach so that "devd" gets
1209	 * the information it needs.
1210	 */
1211	iface->subdev = uaa->temp_dev;
1212
1213	if (device_probe_and_attach(iface->subdev) == 0) {
1214		/*
1215		 * The USB attach arguments are only available during probe
1216		 * and attach !
1217		 */
1218		uaa->temp_dev = NULL;
1219		device_set_ivars(iface->subdev, NULL);
1220
1221		if (udev->flags.peer_suspended) {
1222			err = DEVICE_SUSPEND(iface->subdev);
1223			if (err)
1224				device_printf(iface->subdev, "Suspend failed\n");
1225		}
1226		return (0);		/* success */
1227	} else {
1228		/* No USB driver found */
1229		iface->subdev = NULL;
1230	}
1231	return (1);			/* failure */
1232}
1233
1234/*------------------------------------------------------------------------*
1235 *	usbd_set_parent_iface
1236 *
1237 * Using this function will lock the alternate interface setting on an
1238 * interface. It is typically used for multi interface drivers. In USB
1239 * device side mode it is assumed that the alternate interfaces all
1240 * have the same endpoint descriptors. The default parent index value
1241 * is "USB_IFACE_INDEX_ANY". Then the alternate setting value is not
1242 * locked.
1243 *------------------------------------------------------------------------*/
1244void
1245usbd_set_parent_iface(struct usb_device *udev, uint8_t iface_index,
1246    uint8_t parent_index)
1247{
1248	struct usb_interface *iface;
1249
1250	if (udev == NULL) {
1251		/* nothing to do */
1252		return;
1253	}
1254	iface = usbd_get_iface(udev, iface_index);
1255	if (iface != NULL)
1256		iface->parent_iface_index = parent_index;
1257}
1258
1259static void
1260usb_init_attach_arg(struct usb_device *udev,
1261    struct usb_attach_arg *uaa)
1262{
1263	memset(uaa, 0, sizeof(*uaa));
1264
1265	uaa->device = udev;
1266	uaa->usb_mode = udev->flags.usb_mode;
1267	uaa->port = udev->port_no;
1268	uaa->dev_state = UAA_DEV_READY;
1269
1270	uaa->info.idVendor = UGETW(udev->ddesc.idVendor);
1271	uaa->info.idProduct = UGETW(udev->ddesc.idProduct);
1272	uaa->info.bcdDevice = UGETW(udev->ddesc.bcdDevice);
1273	uaa->info.bDeviceClass = udev->ddesc.bDeviceClass;
1274	uaa->info.bDeviceSubClass = udev->ddesc.bDeviceSubClass;
1275	uaa->info.bDeviceProtocol = udev->ddesc.bDeviceProtocol;
1276	uaa->info.bConfigIndex = udev->curr_config_index;
1277	uaa->info.bConfigNum = udev->curr_config_no;
1278}
1279
1280/*------------------------------------------------------------------------*
1281 *	usb_probe_and_attach
1282 *
1283 * This function is called from "uhub_explore_sub()",
1284 * "usb_handle_set_config()" and "usb_handle_request()".
1285 *
1286 * Returns:
1287 *    0: Success
1288 * Else: A control transfer failed
1289 *------------------------------------------------------------------------*/
1290usb_error_t
1291usb_probe_and_attach(struct usb_device *udev, uint8_t iface_index)
1292{
1293	struct usb_attach_arg uaa;
1294	struct usb_interface *iface;
1295	uint8_t i;
1296	uint8_t j;
1297	uint8_t do_unlock;
1298
1299	if (udev == NULL) {
1300		DPRINTF("udev == NULL\n");
1301		return (USB_ERR_INVAL);
1302	}
1303	/* Prevent re-enumeration */
1304	do_unlock = usbd_enum_lock(udev);
1305
1306	if (udev->curr_config_index == USB_UNCONFIG_INDEX) {
1307		/* do nothing - no configuration has been set */
1308		goto done;
1309	}
1310	/* setup USB attach arguments */
1311
1312	usb_init_attach_arg(udev, &uaa);
1313
1314	/*
1315	 * If the whole USB device is targeted, invoke the USB event
1316	 * handler(s):
1317	 */
1318	if (iface_index == USB_IFACE_INDEX_ANY) {
1319
1320		EVENTHANDLER_INVOKE(usb_dev_configured, udev, &uaa);
1321
1322		if (uaa.dev_state != UAA_DEV_READY) {
1323			/* leave device unconfigured */
1324			usb_unconfigure(udev, 0);
1325			goto done;
1326		}
1327	}
1328
1329	/* Check if only one interface should be probed: */
1330	if (iface_index != USB_IFACE_INDEX_ANY) {
1331		i = iface_index;
1332		j = i + 1;
1333	} else {
1334		i = 0;
1335		j = USB_IFACE_MAX;
1336	}
1337
1338	/* Do the probe and attach */
1339	for (; i != j; i++) {
1340
1341		iface = usbd_get_iface(udev, i);
1342		if (iface == NULL) {
1343			/*
1344			 * Looks like the end of the USB
1345			 * interfaces !
1346			 */
1347			DPRINTFN(2, "end of interfaces "
1348			    "at %u\n", i);
1349			break;
1350		}
1351		if (iface->idesc == NULL) {
1352			/* no interface descriptor */
1353			continue;
1354		}
1355		uaa.iface = iface;
1356
1357		uaa.info.bInterfaceClass =
1358		    iface->idesc->bInterfaceClass;
1359		uaa.info.bInterfaceSubClass =
1360		    iface->idesc->bInterfaceSubClass;
1361		uaa.info.bInterfaceProtocol =
1362		    iface->idesc->bInterfaceProtocol;
1363		uaa.info.bIfaceIndex = i;
1364		uaa.info.bIfaceNum =
1365		    iface->idesc->bInterfaceNumber;
1366		uaa.driver_info = 0;	/* reset driver_info */
1367
1368		DPRINTFN(2, "iclass=%u/%u/%u iindex=%u/%u\n",
1369		    uaa.info.bInterfaceClass,
1370		    uaa.info.bInterfaceSubClass,
1371		    uaa.info.bInterfaceProtocol,
1372		    uaa.info.bIfaceIndex,
1373		    uaa.info.bIfaceNum);
1374
1375		usb_probe_and_attach_sub(udev, &uaa);
1376
1377		/*
1378		 * Remove the leftover child, if any, to enforce that
1379		 * a new nomatch devd event is generated for the next
1380		 * interface if no driver is found:
1381		 */
1382		if (uaa.temp_dev == NULL)
1383			continue;
1384		if (device_delete_child(udev->parent_dev, uaa.temp_dev))
1385			DPRINTFN(0, "device delete child failed\n");
1386		uaa.temp_dev = NULL;
1387	}
1388done:
1389	if (do_unlock)
1390		usbd_enum_unlock(udev);
1391	return (0);
1392}
1393
1394/*------------------------------------------------------------------------*
1395 *	usb_suspend_resume_sub
1396 *
1397 * This function is called when the suspend or resume methods should
1398 * be executed on an USB device.
1399 *------------------------------------------------------------------------*/
1400static void
1401usb_suspend_resume_sub(struct usb_device *udev, device_t dev, uint8_t do_suspend)
1402{
1403	int err;
1404
1405	if (dev == NULL) {
1406		return;
1407	}
1408	if (!device_is_attached(dev)) {
1409		return;
1410	}
1411	if (do_suspend) {
1412		err = DEVICE_SUSPEND(dev);
1413	} else {
1414		err = DEVICE_RESUME(dev);
1415	}
1416	if (err) {
1417		device_printf(dev, "%s failed\n",
1418		    do_suspend ? "Suspend" : "Resume");
1419	}
1420}
1421
1422/*------------------------------------------------------------------------*
1423 *	usb_suspend_resume
1424 *
1425 * The following function will suspend or resume the USB device.
1426 *
1427 * Returns:
1428 *    0: Success
1429 * Else: Failure
1430 *------------------------------------------------------------------------*/
1431usb_error_t
1432usb_suspend_resume(struct usb_device *udev, uint8_t do_suspend)
1433{
1434	struct usb_interface *iface;
1435	uint8_t i;
1436
1437	if (udev == NULL) {
1438		/* nothing to do */
1439		return (0);
1440	}
1441	DPRINTFN(4, "udev=%p do_suspend=%d\n", udev, do_suspend);
1442
1443	sx_assert(&udev->sr_sx, SA_LOCKED);
1444
1445	USB_BUS_LOCK(udev->bus);
1446	/* filter the suspend events */
1447	if (udev->flags.peer_suspended == do_suspend) {
1448		USB_BUS_UNLOCK(udev->bus);
1449		/* nothing to do */
1450		return (0);
1451	}
1452	udev->flags.peer_suspended = do_suspend;
1453	USB_BUS_UNLOCK(udev->bus);
1454
1455	/* do the suspend or resume */
1456
1457	for (i = 0; i != USB_IFACE_MAX; i++) {
1458
1459		iface = usbd_get_iface(udev, i);
1460		if (iface == NULL) {
1461			/* looks like the end of the USB interfaces */
1462			break;
1463		}
1464		usb_suspend_resume_sub(udev, iface->subdev, do_suspend);
1465	}
1466	return (0);
1467}
1468
1469/*------------------------------------------------------------------------*
1470 *      usbd_clear_stall_proc
1471 *
1472 * This function performs generic USB clear stall operations.
1473 *------------------------------------------------------------------------*/
1474static void
1475usbd_clear_stall_proc(struct usb_proc_msg *_pm)
1476{
1477	struct usb_clear_stall_msg *pm = (void *)_pm;
1478	struct usb_device *udev = pm->udev;
1479
1480	/* Change lock */
1481	USB_BUS_UNLOCK(udev->bus);
1482	mtx_lock(&udev->device_mtx);
1483
1484	/* Start clear stall callback */
1485	usbd_transfer_start(udev->ctrl_xfer[1]);
1486
1487	/* Change lock */
1488	mtx_unlock(&udev->device_mtx);
1489	USB_BUS_LOCK(udev->bus);
1490}
1491
1492/*------------------------------------------------------------------------*
1493 *	usb_alloc_device
1494 *
1495 * This function allocates a new USB device. This function is called
1496 * when a new device has been put in the powered state, but not yet in
1497 * the addressed state. Get initial descriptor, set the address, get
1498 * full descriptor and get strings.
1499 *
1500 * Return values:
1501 *    0: Failure
1502 * Else: Success
1503 *------------------------------------------------------------------------*/
1504struct usb_device *
1505usb_alloc_device(device_t parent_dev, struct usb_bus *bus,
1506    struct usb_device *parent_hub, uint8_t depth, uint8_t port_index,
1507    uint8_t port_no, enum usb_dev_speed speed, enum usb_hc_mode mode)
1508{
1509	struct usb_attach_arg uaa;
1510	struct usb_device *udev;
1511	struct usb_device *adev;
1512	struct usb_device *hub;
1513	uint8_t *scratch_ptr;
1514	usb_error_t err;
1515	uint8_t device_index;
1516	uint8_t config_index;
1517	uint8_t config_quirk;
1518	uint8_t set_config_failed;
1519	uint8_t do_unlock;
1520
1521	DPRINTF("parent_dev=%p, bus=%p, parent_hub=%p, depth=%u, "
1522	    "port_index=%u, port_no=%u, speed=%u, usb_mode=%u\n",
1523	    parent_dev, bus, parent_hub, depth, port_index, port_no,
1524	    speed, mode);
1525
1526	/*
1527	 * Find an unused device index. In USB Host mode this is the
1528	 * same as the device address.
1529	 *
1530	 * Device index zero is not used and device index 1 should
1531	 * always be the root hub.
1532	 */
1533	for (device_index = USB_ROOT_HUB_ADDR;
1534	    (device_index != bus->devices_max) &&
1535	    (bus->devices[device_index] != NULL);
1536	    device_index++) /* nop */;
1537
1538	if (device_index == bus->devices_max) {
1539		device_printf(bus->bdev,
1540		    "No free USB device index for new device\n");
1541		return (NULL);
1542	}
1543
1544	if (depth > 0x10) {
1545		device_printf(bus->bdev,
1546		    "Invalid device depth\n");
1547		return (NULL);
1548	}
1549	udev = malloc(sizeof(*udev), M_USB, M_WAITOK | M_ZERO);
1550	if (udev == NULL) {
1551		return (NULL);
1552	}
1553	/* initialise our SX-lock */
1554	sx_init_flags(&udev->enum_sx, "USB config SX lock", SX_DUPOK);
1555	sx_init_flags(&udev->sr_sx, "USB suspend and resume SX lock", SX_NOWITNESS);
1556
1557	cv_init(&udev->ctrlreq_cv, "WCTRL");
1558	cv_init(&udev->ref_cv, "UGONE");
1559
1560	/* initialise our mutex */
1561	mtx_init(&udev->device_mtx, "USB device mutex", NULL, MTX_DEF);
1562
1563	/* initialise generic clear stall */
1564	udev->cs_msg[0].hdr.pm_callback = &usbd_clear_stall_proc;
1565	udev->cs_msg[0].udev = udev;
1566	udev->cs_msg[1].hdr.pm_callback = &usbd_clear_stall_proc;
1567	udev->cs_msg[1].udev = udev;
1568
1569	/* initialise some USB device fields */
1570	udev->parent_hub = parent_hub;
1571	udev->parent_dev = parent_dev;
1572	udev->port_index = port_index;
1573	udev->port_no = port_no;
1574	udev->depth = depth;
1575	udev->bus = bus;
1576	udev->address = USB_START_ADDR;	/* default value */
1577	udev->plugtime = (usb_ticks_t)ticks;
1578	/*
1579	 * We need to force the power mode to "on" because there are plenty
1580	 * of USB devices out there that do not work very well with
1581	 * automatic suspend and resume!
1582	 */
1583	udev->power_mode = usbd_filter_power_mode(udev, USB_POWER_MODE_ON);
1584	udev->pwr_save.last_xfer_time = ticks;
1585	/* we are not ready yet */
1586	udev->refcount = 1;
1587
1588	/* set up default endpoint descriptor */
1589	udev->ctrl_ep_desc.bLength = sizeof(udev->ctrl_ep_desc);
1590	udev->ctrl_ep_desc.bDescriptorType = UDESC_ENDPOINT;
1591	udev->ctrl_ep_desc.bEndpointAddress = USB_CONTROL_ENDPOINT;
1592	udev->ctrl_ep_desc.bmAttributes = UE_CONTROL;
1593	udev->ctrl_ep_desc.wMaxPacketSize[0] = USB_MAX_IPACKET;
1594	udev->ctrl_ep_desc.wMaxPacketSize[1] = 0;
1595	udev->ctrl_ep_desc.bInterval = 0;
1596
1597	/* set up default endpoint companion descriptor */
1598	udev->ctrl_ep_comp_desc.bLength = sizeof(udev->ctrl_ep_comp_desc);
1599	udev->ctrl_ep_comp_desc.bDescriptorType = UDESC_ENDPOINT_SS_COMP;
1600
1601	udev->ddesc.bMaxPacketSize = USB_MAX_IPACKET;
1602
1603	udev->speed = speed;
1604	udev->flags.usb_mode = mode;
1605
1606	/* search for our High Speed USB HUB, if any */
1607
1608	adev = udev;
1609	hub = udev->parent_hub;
1610
1611	while (hub) {
1612		if (hub->speed == USB_SPEED_HIGH) {
1613			udev->hs_hub_addr = hub->address;
1614			udev->parent_hs_hub = hub;
1615			udev->hs_port_no = adev->port_no;
1616			break;
1617		}
1618		adev = hub;
1619		hub = hub->parent_hub;
1620	}
1621
1622	/* init the default endpoint */
1623	usb_init_endpoint(udev, 0,
1624	    &udev->ctrl_ep_desc,
1625	    &udev->ctrl_ep_comp_desc,
1626	    &udev->ctrl_ep);
1627
1628	/* set device index */
1629	udev->device_index = device_index;
1630
1631#if USB_HAVE_UGEN
1632	/* Create ugen name */
1633	snprintf(udev->ugen_name, sizeof(udev->ugen_name),
1634	    USB_GENERIC_NAME "%u.%u", device_get_unit(bus->bdev),
1635	    device_index);
1636	LIST_INIT(&udev->pd_list);
1637
1638	/* Create the control endpoint device */
1639	udev->ctrl_dev = usb_make_dev(udev, NULL, 0, 0,
1640	    FREAD|FWRITE, UID_ROOT, GID_OPERATOR, 0600);
1641
1642	/* Create a link from /dev/ugenX.X to the default endpoint */
1643	if (udev->ctrl_dev != NULL)
1644		make_dev_alias(udev->ctrl_dev->cdev, "%s", udev->ugen_name);
1645#endif
1646	/* Initialise device */
1647	if (bus->methods->device_init != NULL) {
1648		err = (bus->methods->device_init) (udev);
1649		if (err != 0) {
1650			DPRINTFN(0, "device init %d failed "
1651			    "(%s, ignored)\n", device_index,
1652			    usbd_errstr(err));
1653			goto done;
1654		}
1655	}
1656	/* set powered device state after device init is complete */
1657	usb_set_device_state(udev, USB_STATE_POWERED);
1658
1659	if (udev->flags.usb_mode == USB_MODE_HOST) {
1660
1661		err = usbd_req_set_address(udev, NULL, device_index);
1662
1663		/*
1664		 * This is the new USB device address from now on, if
1665		 * the set address request didn't set it already.
1666		 */
1667		if (udev->address == USB_START_ADDR)
1668			udev->address = device_index;
1669
1670		/*
1671		 * We ignore any set-address errors, hence there are
1672		 * buggy USB devices out there that actually receive
1673		 * the SETUP PID, but manage to set the address before
1674		 * the STATUS stage is ACK'ed. If the device responds
1675		 * to the subsequent get-descriptor at the new
1676		 * address, then we know that the set-address command
1677		 * was successful.
1678		 */
1679		if (err) {
1680			DPRINTFN(0, "set address %d failed "
1681			    "(%s, ignored)\n", udev->address,
1682			    usbd_errstr(err));
1683		}
1684	} else {
1685		/* We are not self powered */
1686		udev->flags.self_powered = 0;
1687
1688		/* Set unconfigured state */
1689		udev->curr_config_no = USB_UNCONFIG_NO;
1690		udev->curr_config_index = USB_UNCONFIG_INDEX;
1691
1692		/* Setup USB descriptors */
1693		err = (usb_temp_setup_by_index_p) (udev, usb_template);
1694		if (err) {
1695			DPRINTFN(0, "setting up USB template failed maybe the USB "
1696			    "template module has not been loaded\n");
1697			goto done;
1698		}
1699	}
1700	usb_set_device_state(udev, USB_STATE_ADDRESSED);
1701
1702	/* setup the device descriptor and the initial "wMaxPacketSize" */
1703	err = usbd_setup_device_desc(udev, NULL);
1704
1705	if (err != 0) {
1706		/* try to enumerate two more times */
1707		err = usbd_req_re_enumerate(udev, NULL);
1708		if (err != 0) {
1709			err = usbd_req_re_enumerate(udev, NULL);
1710			if (err != 0) {
1711				goto done;
1712			}
1713		}
1714	}
1715
1716	/*
1717	 * Setup temporary USB attach args so that we can figure out some
1718	 * basic quirks for this device.
1719	 */
1720	usb_init_attach_arg(udev, &uaa);
1721
1722	if (usb_test_quirk(&uaa, UQ_BUS_POWERED)) {
1723		udev->flags.uq_bus_powered = 1;
1724	}
1725	if (usb_test_quirk(&uaa, UQ_NO_STRINGS)) {
1726		udev->flags.no_strings = 1;
1727	}
1728	/*
1729	 * Workaround for buggy USB devices.
1730	 *
1731	 * It appears that some string-less USB chips will crash and
1732	 * disappear if any attempts are made to read any string
1733	 * descriptors.
1734	 *
1735	 * Try to detect such chips by checking the strings in the USB
1736	 * device descriptor. If no strings are present there we
1737	 * simply disable all USB strings.
1738	 */
1739
1740	/* Protect scratch area */
1741	do_unlock = usbd_enum_lock(udev);
1742
1743	scratch_ptr = udev->scratch.data;
1744
1745	if (udev->ddesc.iManufacturer ||
1746	    udev->ddesc.iProduct ||
1747	    udev->ddesc.iSerialNumber) {
1748		/* read out the language ID string */
1749		err = usbd_req_get_string_desc(udev, NULL,
1750		    (char *)scratch_ptr, 4, 0, USB_LANGUAGE_TABLE);
1751	} else {
1752		err = USB_ERR_INVAL;
1753	}
1754
1755	if (err || (scratch_ptr[0] < 4)) {
1756		udev->flags.no_strings = 1;
1757	} else {
1758		uint16_t langid;
1759		uint16_t pref;
1760		uint16_t mask;
1761		uint8_t x;
1762
1763		/* load preferred value and mask */
1764		pref = usb_lang_id;
1765		mask = usb_lang_mask;
1766
1767		/* align length correctly */
1768		scratch_ptr[0] &= ~1U;
1769
1770		/* fix compiler warning */
1771		langid = 0;
1772
1773		/* search for preferred language */
1774		for (x = 2; (x < scratch_ptr[0]); x += 2) {
1775			langid = UGETW(scratch_ptr + x);
1776			if ((langid & mask) == pref)
1777				break;
1778		}
1779		if (x >= scratch_ptr[0]) {
1780			/* pick the first language as the default */
1781			DPRINTFN(1, "Using first language\n");
1782			langid = UGETW(scratch_ptr + 2);
1783		}
1784
1785		DPRINTFN(1, "Language selected: 0x%04x\n", langid);
1786		udev->langid = langid;
1787	}
1788
1789	if (do_unlock)
1790		usbd_enum_unlock(udev);
1791
1792	/* assume 100mA bus powered for now. Changed when configured. */
1793	udev->power = USB_MIN_POWER;
1794	/* fetch the vendor and product strings from the device */
1795	usbd_set_device_strings(udev);
1796
1797	if (udev->flags.usb_mode == USB_MODE_DEVICE) {
1798		/* USB device mode setup is complete */
1799		err = 0;
1800		goto config_done;
1801	}
1802
1803	/*
1804	 * Most USB devices should attach to config index 0 by
1805	 * default
1806	 */
1807	if (usb_test_quirk(&uaa, UQ_CFG_INDEX_0)) {
1808		config_index = 0;
1809		config_quirk = 1;
1810	} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_1)) {
1811		config_index = 1;
1812		config_quirk = 1;
1813	} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_2)) {
1814		config_index = 2;
1815		config_quirk = 1;
1816	} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_3)) {
1817		config_index = 3;
1818		config_quirk = 1;
1819	} else if (usb_test_quirk(&uaa, UQ_CFG_INDEX_4)) {
1820		config_index = 4;
1821		config_quirk = 1;
1822	} else {
1823		config_index = 0;
1824		config_quirk = 0;
1825	}
1826
1827	set_config_failed = 0;
1828repeat_set_config:
1829
1830	DPRINTF("setting config %u\n", config_index);
1831
1832	/* get the USB device configured */
1833	err = usbd_set_config_index(udev, config_index);
1834	if (err) {
1835		if (udev->ddesc.bNumConfigurations != 0) {
1836			if (!set_config_failed) {
1837				set_config_failed = 1;
1838				/* XXX try to re-enumerate the device */
1839				err = usbd_req_re_enumerate(udev, NULL);
1840				if (err == 0)
1841					goto repeat_set_config;
1842			}
1843			DPRINTFN(0, "Failure selecting configuration index %u:"
1844			    "%s, port %u, addr %u (ignored)\n",
1845			    config_index, usbd_errstr(err), udev->port_no,
1846			    udev->address);
1847		}
1848		/*
1849		 * Some USB devices do not have any configurations. Ignore any
1850		 * set config failures!
1851		 */
1852		err = 0;
1853		goto config_done;
1854	}
1855	if (!config_quirk && config_index + 1 < udev->ddesc.bNumConfigurations) {
1856		if ((udev->cdesc->bNumInterface < 2) &&
1857		    usbd_get_no_descriptors(udev->cdesc, UDESC_ENDPOINT) == 0) {
1858			DPRINTFN(0, "Found no endpoints, trying next config\n");
1859			config_index++;
1860			goto repeat_set_config;
1861		}
1862#if USB_HAVE_MSCTEST
1863		if (config_index == 0) {
1864			/*
1865			 * Try to figure out if we have an
1866			 * auto-install disk there:
1867			 */
1868			if (usb_iface_is_cdrom(udev, 0)) {
1869				DPRINTFN(0, "Found possible auto-install "
1870				    "disk (trying next config)\n");
1871				config_index++;
1872				goto repeat_set_config;
1873			}
1874		}
1875#endif
1876	}
1877#if USB_HAVE_MSCTEST
1878	if (set_config_failed == 0 && config_index == 0 &&
1879	    usb_test_quirk(&uaa, UQ_MSC_NO_SYNC_CACHE) == 0 &&
1880	    usb_test_quirk(&uaa, UQ_MSC_NO_GETMAXLUN) == 0) {
1881
1882		/*
1883		 * Try to figure out if there are any MSC quirks we
1884		 * should apply automatically:
1885		 */
1886		err = usb_msc_auto_quirk(udev, 0);
1887
1888		if (err != 0) {
1889			set_config_failed = 1;
1890			goto repeat_set_config;
1891		}
1892	}
1893#endif
1894
1895config_done:
1896	DPRINTF("new dev (addr %d), udev=%p, parent_hub=%p\n",
1897	    udev->address, udev, udev->parent_hub);
1898
1899	/* register our device - we are ready */
1900	usb_bus_port_set_device(bus, parent_hub ?
1901	    parent_hub->hub->ports + port_index : NULL, udev, device_index);
1902
1903#if USB_HAVE_UGEN
1904	/* Symlink the ugen device name */
1905	udev->ugen_symlink = usb_alloc_symlink(udev->ugen_name);
1906
1907	/* Announce device */
1908	printf("%s: <%s> at %s\n", udev->ugen_name,
1909	    usb_get_manufacturer(udev),
1910	    device_get_nameunit(udev->bus->bdev));
1911#endif
1912
1913#if USB_HAVE_DEVCTL
1914	usb_notify_addq("ATTACH", udev);
1915#endif
1916done:
1917	if (err) {
1918		/*
1919		 * Free USB device and all subdevices, if any.
1920		 */
1921		usb_free_device(udev, 0);
1922		udev = NULL;
1923	}
1924	return (udev);
1925}
1926
1927#if USB_HAVE_UGEN
1928struct usb_fs_privdata *
1929usb_make_dev(struct usb_device *udev, const char *devname, int ep,
1930    int fi, int rwmode, uid_t uid, gid_t gid, int mode)
1931{
1932	struct usb_fs_privdata* pd;
1933	char buffer[32];
1934
1935	/* Store information to locate ourselves again later */
1936	pd = malloc(sizeof(struct usb_fs_privdata), M_USBDEV,
1937	    M_WAITOK | M_ZERO);
1938	pd->bus_index = device_get_unit(udev->bus->bdev);
1939	pd->dev_index = udev->device_index;
1940	pd->ep_addr = ep;
1941	pd->fifo_index = fi;
1942	pd->mode = rwmode;
1943
1944	/* Now, create the device itself */
1945	if (devname == NULL) {
1946		devname = buffer;
1947		snprintf(buffer, sizeof(buffer), USB_DEVICE_DIR "/%u.%u.%u",
1948		    pd->bus_index, pd->dev_index, pd->ep_addr);
1949	}
1950
1951	pd->cdev = make_dev(&usb_devsw, 0, uid, gid, mode, "%s", devname);
1952
1953	if (pd->cdev == NULL) {
1954		DPRINTFN(0, "Failed to create device %s\n", devname);
1955		free(pd, M_USBDEV);
1956		return (NULL);
1957	}
1958
1959	/* XXX setting si_drv1 and creating the device is not atomic! */
1960	pd->cdev->si_drv1 = pd;
1961
1962	return (pd);
1963}
1964
1965void
1966usb_destroy_dev(struct usb_fs_privdata *pd)
1967{
1968	if (pd == NULL)
1969		return;
1970
1971	destroy_dev(pd->cdev);
1972
1973	free(pd, M_USBDEV);
1974}
1975
1976static void
1977usb_cdev_create(struct usb_device *udev)
1978{
1979	struct usb_config_descriptor *cd;
1980	struct usb_endpoint_descriptor *ed;
1981	struct usb_descriptor *desc;
1982	struct usb_fs_privdata* pd;
1983	int inmode, outmode, inmask, outmask, mode;
1984	uint8_t ep;
1985
1986	KASSERT(LIST_FIRST(&udev->pd_list) == NULL, ("stale cdev entries"));
1987
1988	DPRINTFN(2, "Creating device nodes\n");
1989
1990	if (usbd_get_mode(udev) == USB_MODE_DEVICE) {
1991		inmode = FWRITE;
1992		outmode = FREAD;
1993	} else {		 /* USB_MODE_HOST */
1994		inmode = FREAD;
1995		outmode = FWRITE;
1996	}
1997
1998	inmask = 0;
1999	outmask = 0;
2000	desc = NULL;
2001
2002	/*
2003	 * Collect all used endpoint numbers instead of just
2004	 * generating 16 static endpoints.
2005	 */
2006	cd = usbd_get_config_descriptor(udev);
2007	while ((desc = usb_desc_foreach(cd, desc))) {
2008		/* filter out all endpoint descriptors */
2009		if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
2010		    (desc->bLength >= sizeof(*ed))) {
2011			ed = (struct usb_endpoint_descriptor *)desc;
2012
2013			/* update masks */
2014			ep = ed->bEndpointAddress;
2015			if (UE_GET_DIR(ep)  == UE_DIR_OUT)
2016				outmask |= 1 << UE_GET_ADDR(ep);
2017			else
2018				inmask |= 1 << UE_GET_ADDR(ep);
2019		}
2020	}
2021
2022	/* Create all available endpoints except EP0 */
2023	for (ep = 1; ep < 16; ep++) {
2024		mode = (inmask & (1 << ep)) ? inmode : 0;
2025		mode |= (outmask & (1 << ep)) ? outmode : 0;
2026		if (mode == 0)
2027			continue;	/* no IN or OUT endpoint */
2028
2029		pd = usb_make_dev(udev, NULL, ep, 0,
2030		    mode, UID_ROOT, GID_OPERATOR, 0600);
2031
2032		if (pd != NULL)
2033			LIST_INSERT_HEAD(&udev->pd_list, pd, pd_next);
2034	}
2035}
2036
2037static void
2038usb_cdev_free(struct usb_device *udev)
2039{
2040	struct usb_fs_privdata* pd;
2041
2042	DPRINTFN(2, "Freeing device nodes\n");
2043
2044	while ((pd = LIST_FIRST(&udev->pd_list)) != NULL) {
2045		KASSERT(pd->cdev->si_drv1 == pd, ("privdata corrupt"));
2046
2047		LIST_REMOVE(pd, pd_next);
2048
2049		usb_destroy_dev(pd);
2050	}
2051}
2052#endif
2053
2054/*------------------------------------------------------------------------*
2055 *	usb_free_device
2056 *
2057 * This function is NULL safe and will free an USB device and its
2058 * children devices, if any.
2059 *
2060 * Flag values: Reserved, set to zero.
2061 *------------------------------------------------------------------------*/
2062void
2063usb_free_device(struct usb_device *udev, uint8_t flag)
2064{
2065	struct usb_bus *bus;
2066
2067	if (udev == NULL)
2068		return;		/* already freed */
2069
2070	DPRINTFN(4, "udev=%p port=%d\n", udev, udev->port_no);
2071
2072	bus = udev->bus;
2073	usb_set_device_state(udev, USB_STATE_DETACHED);
2074
2075#if USB_HAVE_DEVCTL
2076	usb_notify_addq("DETACH", udev);
2077#endif
2078
2079#if USB_HAVE_UGEN
2080	printf("%s: <%s> at %s (disconnected)\n", udev->ugen_name,
2081	    usb_get_manufacturer(udev), device_get_nameunit(bus->bdev));
2082
2083	/* Destroy UGEN symlink, if any */
2084	if (udev->ugen_symlink) {
2085		usb_free_symlink(udev->ugen_symlink);
2086		udev->ugen_symlink = NULL;
2087	}
2088#endif
2089	/*
2090	 * Unregister our device first which will prevent any further
2091	 * references:
2092	 */
2093	usb_bus_port_set_device(bus, udev->parent_hub ?
2094	    udev->parent_hub->hub->ports + udev->port_index : NULL,
2095	    NULL, USB_ROOT_HUB_ADDR);
2096
2097#if USB_HAVE_UGEN
2098	/* wait for all pending references to go away: */
2099	mtx_lock(&usb_ref_lock);
2100	udev->refcount--;
2101	while (udev->refcount != 0) {
2102		cv_wait(&udev->ref_cv, &usb_ref_lock);
2103	}
2104	mtx_unlock(&usb_ref_lock);
2105
2106	usb_destroy_dev(udev->ctrl_dev);
2107#endif
2108
2109	if (udev->flags.usb_mode == USB_MODE_DEVICE) {
2110		/* stop receiving any control transfers (Device Side Mode) */
2111		usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX);
2112	}
2113
2114	/* the following will get the device unconfigured in software */
2115	usb_unconfigure(udev, USB_UNCFG_FLAG_FREE_EP0);
2116
2117	/* unsetup any leftover default USB transfers */
2118	usbd_transfer_unsetup(udev->ctrl_xfer, USB_CTRL_XFER_MAX);
2119
2120	/* template unsetup, if any */
2121	(usb_temp_unsetup_p) (udev);
2122
2123	/*
2124	 * Make sure that our clear-stall messages are not queued
2125	 * anywhere:
2126	 */
2127	USB_BUS_LOCK(udev->bus);
2128	usb_proc_mwait(USB_BUS_NON_GIANT_PROC(udev->bus),
2129	    &udev->cs_msg[0], &udev->cs_msg[1]);
2130	USB_BUS_UNLOCK(udev->bus);
2131
2132	sx_destroy(&udev->enum_sx);
2133	sx_destroy(&udev->sr_sx);
2134
2135	cv_destroy(&udev->ctrlreq_cv);
2136	cv_destroy(&udev->ref_cv);
2137
2138	mtx_destroy(&udev->device_mtx);
2139#if USB_HAVE_UGEN
2140	KASSERT(LIST_FIRST(&udev->pd_list) == NULL, ("leaked cdev entries"));
2141#endif
2142
2143	/* Uninitialise device */
2144	if (bus->methods->device_uninit != NULL)
2145		(bus->methods->device_uninit) (udev);
2146
2147	/* free device */
2148	free(udev->serial, M_USB);
2149	free(udev->manufacturer, M_USB);
2150	free(udev->product, M_USB);
2151	free(udev, M_USB);
2152}
2153
2154/*------------------------------------------------------------------------*
2155 *	usbd_get_iface
2156 *
2157 * This function is the safe way to get the USB interface structure
2158 * pointer by interface index.
2159 *
2160 * Return values:
2161 *   NULL: Interface not present.
2162 *   Else: Pointer to USB interface structure.
2163 *------------------------------------------------------------------------*/
2164struct usb_interface *
2165usbd_get_iface(struct usb_device *udev, uint8_t iface_index)
2166{
2167	struct usb_interface *iface = udev->ifaces + iface_index;
2168
2169	if (iface_index >= udev->ifaces_max)
2170		return (NULL);
2171	return (iface);
2172}
2173
2174/*------------------------------------------------------------------------*
2175 *	usbd_find_descriptor
2176 *
2177 * This function will lookup the first descriptor that matches the
2178 * criteria given by the arguments "type" and "subtype". Descriptors
2179 * will only be searched within the interface having the index
2180 * "iface_index".  If the "id" argument points to an USB descriptor,
2181 * it will be skipped before the search is started. This allows
2182 * searching for multiple descriptors using the same criteria. Else
2183 * the search is started after the interface descriptor.
2184 *
2185 * Return values:
2186 *   NULL: End of descriptors
2187 *   Else: A descriptor matching the criteria
2188 *------------------------------------------------------------------------*/
2189void   *
2190usbd_find_descriptor(struct usb_device *udev, void *id, uint8_t iface_index,
2191    uint8_t type, uint8_t type_mask,
2192    uint8_t subtype, uint8_t subtype_mask)
2193{
2194	struct usb_descriptor *desc;
2195	struct usb_config_descriptor *cd;
2196	struct usb_interface *iface;
2197
2198	cd = usbd_get_config_descriptor(udev);
2199	if (cd == NULL) {
2200		return (NULL);
2201	}
2202	if (id == NULL) {
2203		iface = usbd_get_iface(udev, iface_index);
2204		if (iface == NULL) {
2205			return (NULL);
2206		}
2207		id = usbd_get_interface_descriptor(iface);
2208		if (id == NULL) {
2209			return (NULL);
2210		}
2211	}
2212	desc = (void *)id;
2213
2214	while ((desc = usb_desc_foreach(cd, desc))) {
2215
2216		if (desc->bDescriptorType == UDESC_INTERFACE) {
2217			break;
2218		}
2219		if (((desc->bDescriptorType & type_mask) == type) &&
2220		    ((desc->bDescriptorSubtype & subtype_mask) == subtype)) {
2221			return (desc);
2222		}
2223	}
2224	return (NULL);
2225}
2226
2227/*------------------------------------------------------------------------*
2228 *	usb_devinfo
2229 *
2230 * This function will dump information from the device descriptor
2231 * belonging to the USB device pointed to by "udev", to the string
2232 * pointed to by "dst_ptr" having a maximum length of "dst_len" bytes
2233 * including the terminating zero.
2234 *------------------------------------------------------------------------*/
2235void
2236usb_devinfo(struct usb_device *udev, char *dst_ptr, uint16_t dst_len)
2237{
2238	struct usb_device_descriptor *udd = &udev->ddesc;
2239	uint16_t bcdDevice;
2240	uint16_t bcdUSB;
2241
2242	bcdUSB = UGETW(udd->bcdUSB);
2243	bcdDevice = UGETW(udd->bcdDevice);
2244
2245	if (udd->bDeviceClass != 0xFF) {
2246		snprintf(dst_ptr, dst_len, "%s %s, class %d/%d, rev %x.%02x/"
2247		    "%x.%02x, addr %d",
2248		    usb_get_manufacturer(udev),
2249		    usb_get_product(udev),
2250		    udd->bDeviceClass, udd->bDeviceSubClass,
2251		    (bcdUSB >> 8), bcdUSB & 0xFF,
2252		    (bcdDevice >> 8), bcdDevice & 0xFF,
2253		    udev->address);
2254	} else {
2255		snprintf(dst_ptr, dst_len, "%s %s, rev %x.%02x/"
2256		    "%x.%02x, addr %d",
2257		    usb_get_manufacturer(udev),
2258		    usb_get_product(udev),
2259		    (bcdUSB >> 8), bcdUSB & 0xFF,
2260		    (bcdDevice >> 8), bcdDevice & 0xFF,
2261		    udev->address);
2262	}
2263}
2264
2265#ifdef USB_VERBOSE
2266/*
2267 * Descriptions of of known vendors and devices ("products").
2268 */
2269struct usb_knowndev {
2270	uint16_t vendor;
2271	uint16_t product;
2272	uint32_t flags;
2273	const char *vendorname;
2274	const char *productname;
2275};
2276
2277#define	USB_KNOWNDEV_NOPROD	0x01	/* match on vendor only */
2278
2279#include "usbdevs.h"
2280#include "usbdevs_data.h"
2281#endif					/* USB_VERBOSE */
2282
2283static void
2284usbd_set_device_strings(struct usb_device *udev)
2285{
2286	struct usb_device_descriptor *udd = &udev->ddesc;
2287#ifdef USB_VERBOSE
2288	const struct usb_knowndev *kdp;
2289#endif
2290	char *temp_ptr;
2291	size_t temp_size;
2292	uint16_t vendor_id;
2293	uint16_t product_id;
2294	uint8_t do_unlock;
2295
2296	/* Protect scratch area */
2297	do_unlock = usbd_enum_lock(udev);
2298
2299	temp_ptr = (char *)udev->scratch.data;
2300	temp_size = sizeof(udev->scratch.data);
2301
2302	vendor_id = UGETW(udd->idVendor);
2303	product_id = UGETW(udd->idProduct);
2304
2305	/* get serial number string */
2306	usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2307	    udev->ddesc.iSerialNumber);
2308	udev->serial = strdup(temp_ptr, M_USB);
2309
2310	/* get manufacturer string */
2311	usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2312	    udev->ddesc.iManufacturer);
2313	usb_trim_spaces(temp_ptr);
2314	if (temp_ptr[0] != '\0')
2315		udev->manufacturer = strdup(temp_ptr, M_USB);
2316
2317	/* get product string */
2318	usbd_req_get_string_any(udev, NULL, temp_ptr, temp_size,
2319	    udev->ddesc.iProduct);
2320	usb_trim_spaces(temp_ptr);
2321	if (temp_ptr[0] != '\0')
2322		udev->product = strdup(temp_ptr, M_USB);
2323
2324#ifdef USB_VERBOSE
2325	if (udev->manufacturer == NULL || udev->product == NULL) {
2326		for (kdp = usb_knowndevs; kdp->vendorname != NULL; kdp++) {
2327			if (kdp->vendor == vendor_id &&
2328			    (kdp->product == product_id ||
2329			    (kdp->flags & USB_KNOWNDEV_NOPROD) != 0))
2330				break;
2331		}
2332		if (kdp->vendorname != NULL) {
2333			/* XXX should use pointer to knowndevs string */
2334			if (udev->manufacturer == NULL) {
2335				udev->manufacturer = strdup(kdp->vendorname,
2336				    M_USB);
2337			}
2338			if (udev->product == NULL &&
2339			    (kdp->flags & USB_KNOWNDEV_NOPROD) == 0) {
2340				udev->product = strdup(kdp->productname,
2341				    M_USB);
2342			}
2343		}
2344	}
2345#endif
2346	/* Provide default strings if none were found */
2347	if (udev->manufacturer == NULL) {
2348		snprintf(temp_ptr, temp_size, "vendor 0x%04x", vendor_id);
2349		udev->manufacturer = strdup(temp_ptr, M_USB);
2350	}
2351	if (udev->product == NULL) {
2352		snprintf(temp_ptr, temp_size, "product 0x%04x", product_id);
2353		udev->product = strdup(temp_ptr, M_USB);
2354	}
2355
2356	if (do_unlock)
2357		usbd_enum_unlock(udev);
2358}
2359
2360/*
2361 * Returns:
2362 * See: USB_MODE_XXX
2363 */
2364enum usb_hc_mode
2365usbd_get_mode(struct usb_device *udev)
2366{
2367	return (udev->flags.usb_mode);
2368}
2369
2370/*
2371 * Returns:
2372 * See: USB_SPEED_XXX
2373 */
2374enum usb_dev_speed
2375usbd_get_speed(struct usb_device *udev)
2376{
2377	return (udev->speed);
2378}
2379
2380uint32_t
2381usbd_get_isoc_fps(struct usb_device *udev)
2382{
2383	;				/* indent fix */
2384	switch (udev->speed) {
2385	case USB_SPEED_LOW:
2386	case USB_SPEED_FULL:
2387		return (1000);
2388	default:
2389		return (8000);
2390	}
2391}
2392
2393struct usb_device_descriptor *
2394usbd_get_device_descriptor(struct usb_device *udev)
2395{
2396	if (udev == NULL)
2397		return (NULL);		/* be NULL safe */
2398	return (&udev->ddesc);
2399}
2400
2401struct usb_config_descriptor *
2402usbd_get_config_descriptor(struct usb_device *udev)
2403{
2404	if (udev == NULL)
2405		return (NULL);		/* be NULL safe */
2406	return (udev->cdesc);
2407}
2408
2409/*------------------------------------------------------------------------*
2410 *	usb_test_quirk - test a device for a given quirk
2411 *
2412 * Return values:
2413 * 0: The USB device does not have the given quirk.
2414 * Else: The USB device has the given quirk.
2415 *------------------------------------------------------------------------*/
2416uint8_t
2417usb_test_quirk(const struct usb_attach_arg *uaa, uint16_t quirk)
2418{
2419	uint8_t found;
2420	uint8_t x;
2421
2422	if (quirk == UQ_NONE)
2423		return (0);
2424
2425	/* search the automatic per device quirks first */
2426
2427	for (x = 0; x != USB_MAX_AUTO_QUIRK; x++) {
2428		if (uaa->device->autoQuirk[x] == quirk)
2429			return (1);
2430	}
2431
2432	/* search global quirk table, if any */
2433
2434	found = (usb_test_quirk_p) (&uaa->info, quirk);
2435
2436	return (found);
2437}
2438
2439struct usb_interface_descriptor *
2440usbd_get_interface_descriptor(struct usb_interface *iface)
2441{
2442	if (iface == NULL)
2443		return (NULL);		/* be NULL safe */
2444	return (iface->idesc);
2445}
2446
2447uint8_t
2448usbd_get_interface_altindex(struct usb_interface *iface)
2449{
2450	return (iface->alt_index);
2451}
2452
2453uint8_t
2454usbd_get_bus_index(struct usb_device *udev)
2455{
2456	return ((uint8_t)device_get_unit(udev->bus->bdev));
2457}
2458
2459uint8_t
2460usbd_get_device_index(struct usb_device *udev)
2461{
2462	return (udev->device_index);
2463}
2464
2465#if USB_HAVE_DEVCTL
2466static void
2467usb_notify_addq(const char *type, struct usb_device *udev)
2468{
2469	struct usb_interface *iface;
2470	struct sbuf *sb;
2471	int i;
2472
2473	/* announce the device */
2474	sb = sbuf_new_auto();
2475	sbuf_printf(sb,
2476#if USB_HAVE_UGEN
2477	    "ugen=%s "
2478	    "cdev=%s "
2479#endif
2480	    "vendor=0x%04x "
2481	    "product=0x%04x "
2482	    "devclass=0x%02x "
2483	    "devsubclass=0x%02x "
2484	    "sernum=\"%s\" "
2485	    "release=0x%04x "
2486	    "mode=%s "
2487	    "port=%u "
2488#if USB_HAVE_UGEN
2489	    "parent=%s"
2490#endif
2491	    "",
2492#if USB_HAVE_UGEN
2493	    udev->ugen_name,
2494	    udev->ugen_name,
2495#endif
2496	    UGETW(udev->ddesc.idVendor),
2497	    UGETW(udev->ddesc.idProduct),
2498	    udev->ddesc.bDeviceClass,
2499	    udev->ddesc.bDeviceSubClass,
2500	    usb_get_serial(udev),
2501	    UGETW(udev->ddesc.bcdDevice),
2502	    (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
2503	    udev->port_no
2504#if USB_HAVE_UGEN
2505	    , udev->parent_hub != NULL ?
2506		udev->parent_hub->ugen_name :
2507		device_get_nameunit(device_get_parent(udev->bus->bdev))
2508#endif
2509	    );
2510	sbuf_finish(sb);
2511	devctl_notify("USB", "DEVICE", type, sbuf_data(sb));
2512	sbuf_delete(sb);
2513
2514	/* announce each interface */
2515	for (i = 0; i < USB_IFACE_MAX; i++) {
2516		iface = usbd_get_iface(udev, i);
2517		if (iface == NULL)
2518			break;		/* end of interfaces */
2519		if (iface->idesc == NULL)
2520			continue;	/* no interface descriptor */
2521
2522		sb = sbuf_new_auto();
2523		sbuf_printf(sb,
2524#if USB_HAVE_UGEN
2525		    "ugen=%s "
2526		    "cdev=%s "
2527#endif
2528		    "vendor=0x%04x "
2529		    "product=0x%04x "
2530		    "devclass=0x%02x "
2531		    "devsubclass=0x%02x "
2532		    "sernum=\"%s\" "
2533		    "release=0x%04x "
2534		    "mode=%s "
2535		    "interface=%d "
2536		    "endpoints=%d "
2537		    "intclass=0x%02x "
2538		    "intsubclass=0x%02x "
2539		    "intprotocol=0x%02x",
2540#if USB_HAVE_UGEN
2541		    udev->ugen_name,
2542		    udev->ugen_name,
2543#endif
2544		    UGETW(udev->ddesc.idVendor),
2545		    UGETW(udev->ddesc.idProduct),
2546		    udev->ddesc.bDeviceClass,
2547		    udev->ddesc.bDeviceSubClass,
2548		    usb_get_serial(udev),
2549		    UGETW(udev->ddesc.bcdDevice),
2550		    (udev->flags.usb_mode == USB_MODE_HOST) ? "host" : "device",
2551		    iface->idesc->bInterfaceNumber,
2552		    iface->idesc->bNumEndpoints,
2553		    iface->idesc->bInterfaceClass,
2554		    iface->idesc->bInterfaceSubClass,
2555		    iface->idesc->bInterfaceProtocol);
2556		sbuf_finish(sb);
2557		devctl_notify("USB", "INTERFACE", type, sbuf_data(sb));
2558		sbuf_delete(sb);
2559	}
2560}
2561#endif
2562
2563#if USB_HAVE_UGEN
2564/*------------------------------------------------------------------------*
2565 *	usb_fifo_free_wrap
2566 *
2567 * This function will free the FIFOs.
2568 *
2569 * Description of "flag" argument: If the USB_UNCFG_FLAG_FREE_EP0 flag
2570 * is set and "iface_index" is set to "USB_IFACE_INDEX_ANY", we free
2571 * all FIFOs. If the USB_UNCFG_FLAG_FREE_EP0 flag is not set and
2572 * "iface_index" is set to "USB_IFACE_INDEX_ANY", we free all non
2573 * control endpoint FIFOs. If "iface_index" is not set to
2574 * "USB_IFACE_INDEX_ANY" the flag has no effect.
2575 *------------------------------------------------------------------------*/
2576static void
2577usb_fifo_free_wrap(struct usb_device *udev,
2578    uint8_t iface_index, uint8_t flag)
2579{
2580	struct usb_fifo *f;
2581	uint16_t i;
2582
2583	/*
2584	 * Free any USB FIFOs on the given interface:
2585	 */
2586	for (i = 0; i != USB_FIFO_MAX; i++) {
2587		f = udev->fifo[i];
2588		if (f == NULL) {
2589			continue;
2590		}
2591		/* Check if the interface index matches */
2592		if (iface_index == f->iface_index) {
2593			if (f->methods != &usb_ugen_methods) {
2594				/*
2595				 * Don't free any non-generic FIFOs in
2596				 * this case.
2597				 */
2598				continue;
2599			}
2600			if ((f->dev_ep_index == 0) &&
2601			    (f->fs_xfer == NULL)) {
2602				/* no need to free this FIFO */
2603				continue;
2604			}
2605		} else if (iface_index == USB_IFACE_INDEX_ANY) {
2606			if ((f->methods == &usb_ugen_methods) &&
2607			    (f->dev_ep_index == 0) &&
2608			    (!(flag & USB_UNCFG_FLAG_FREE_EP0)) &&
2609			    (f->fs_xfer == NULL)) {
2610				/* no need to free this FIFO */
2611				continue;
2612			}
2613		} else {
2614			/* no need to free this FIFO */
2615			continue;
2616		}
2617		/* free this FIFO */
2618		usb_fifo_free(f);
2619	}
2620}
2621#endif
2622
2623/*------------------------------------------------------------------------*
2624 *	usb_peer_can_wakeup
2625 *
2626 * Return values:
2627 * 0: Peer cannot do resume signalling.
2628 * Else: Peer can do resume signalling.
2629 *------------------------------------------------------------------------*/
2630uint8_t
2631usb_peer_can_wakeup(struct usb_device *udev)
2632{
2633	const struct usb_config_descriptor *cdp;
2634
2635	cdp = udev->cdesc;
2636	if ((cdp != NULL) && (udev->flags.usb_mode == USB_MODE_HOST)) {
2637		return (cdp->bmAttributes & UC_REMOTE_WAKEUP);
2638	}
2639	return (0);			/* not supported */
2640}
2641
2642void
2643usb_set_device_state(struct usb_device *udev, enum usb_dev_state state)
2644{
2645
2646	KASSERT(state < USB_STATE_MAX, ("invalid udev state"));
2647
2648	DPRINTF("udev %p state %s -> %s\n", udev,
2649	    usb_statestr(udev->state), usb_statestr(state));
2650	udev->state = state;
2651
2652	if (udev->bus->methods->device_state_change != NULL)
2653		(udev->bus->methods->device_state_change) (udev);
2654}
2655
2656enum usb_dev_state
2657usb_get_device_state(struct usb_device *udev)
2658{
2659	if (udev == NULL)
2660		return (USB_STATE_DETACHED);
2661	return (udev->state);
2662}
2663
2664uint8_t
2665usbd_device_attached(struct usb_device *udev)
2666{
2667	return (udev->state > USB_STATE_DETACHED);
2668}
2669
2670/*
2671 * The following function locks enumerating the given USB device. If
2672 * the lock is already grabbed this function returns zero. Else a
2673 * non-zero value is returned.
2674 */
2675uint8_t
2676usbd_enum_lock(struct usb_device *udev)
2677{
2678	if (sx_xlocked(&udev->enum_sx))
2679		return (0);
2680
2681	sx_xlock(&udev->enum_sx);
2682	sx_xlock(&udev->sr_sx);
2683	/*
2684	 * NEWBUS LOCK NOTE: We should check if any parent SX locks
2685	 * are locked before locking Giant. Else the lock can be
2686	 * locked multiple times.
2687	 */
2688	mtx_lock(&Giant);
2689	return (1);
2690}
2691
2692/* The following function unlocks enumerating the given USB device. */
2693
2694void
2695usbd_enum_unlock(struct usb_device *udev)
2696{
2697	mtx_unlock(&Giant);
2698	sx_xunlock(&udev->enum_sx);
2699	sx_xunlock(&udev->sr_sx);
2700}
2701
2702/* The following function locks suspend and resume. */
2703
2704void
2705usbd_sr_lock(struct usb_device *udev)
2706{
2707	sx_xlock(&udev->sr_sx);
2708	/*
2709	 * NEWBUS LOCK NOTE: We should check if any parent SX locks
2710	 * are locked before locking Giant. Else the lock can be
2711	 * locked multiple times.
2712	 */
2713	mtx_lock(&Giant);
2714}
2715
2716/* The following function unlocks suspend and resume. */
2717
2718void
2719usbd_sr_unlock(struct usb_device *udev)
2720{
2721	mtx_unlock(&Giant);
2722	sx_xunlock(&udev->sr_sx);
2723}
2724
2725/*
2726 * The following function checks the enumerating lock for the given
2727 * USB device.
2728 */
2729
2730uint8_t
2731usbd_enum_is_locked(struct usb_device *udev)
2732{
2733	return (sx_xlocked(&udev->enum_sx));
2734}
2735
2736/*
2737 * The following function is used to set the per-interface specific
2738 * plug and play information. The string referred to by the pnpinfo
2739 * argument can safely be freed after calling this function. The
2740 * pnpinfo of an interface will be reset at device detach or when
2741 * passing a NULL argument to this function. This function
2742 * returns zero on success, else a USB_ERR_XXX failure code.
2743 */
2744
2745usb_error_t
2746usbd_set_pnpinfo(struct usb_device *udev, uint8_t iface_index, const char *pnpinfo)
2747{
2748	struct usb_interface *iface;
2749
2750	iface = usbd_get_iface(udev, iface_index);
2751	if (iface == NULL)
2752		return (USB_ERR_INVAL);
2753
2754	if (iface->pnpinfo != NULL) {
2755		free(iface->pnpinfo, M_USBDEV);
2756		iface->pnpinfo = NULL;
2757	}
2758
2759	if (pnpinfo == NULL || pnpinfo[0] == 0)
2760		return (0);		/* success */
2761
2762	iface->pnpinfo = strdup(pnpinfo, M_USBDEV);
2763	if (iface->pnpinfo == NULL)
2764		return (USB_ERR_NOMEM);
2765
2766	return (0);			/* success */
2767}
2768
2769usb_error_t
2770usbd_add_dynamic_quirk(struct usb_device *udev, uint16_t quirk)
2771{
2772	uint8_t x;
2773
2774	for (x = 0; x != USB_MAX_AUTO_QUIRK; x++) {
2775		if (udev->autoQuirk[x] == 0 ||
2776		    udev->autoQuirk[x] == quirk) {
2777			udev->autoQuirk[x] = quirk;
2778			return (0);	/* success */
2779		}
2780	}
2781	return (USB_ERR_NOMEM);
2782}
2783
2784/*
2785 * The following function is used to select the endpoint mode. It
2786 * should not be called outside enumeration context.
2787 */
2788
2789usb_error_t
2790usbd_set_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep,
2791    uint8_t ep_mode)
2792{
2793	usb_error_t error;
2794	uint8_t do_unlock;
2795
2796	/* Prevent re-enumeration */
2797	do_unlock = usbd_enum_lock(udev);
2798
2799	if (udev->bus->methods->set_endpoint_mode != NULL) {
2800		error = (udev->bus->methods->set_endpoint_mode) (
2801		    udev, ep, ep_mode);
2802	} else if (ep_mode != USB_EP_MODE_DEFAULT) {
2803		error = USB_ERR_INVAL;
2804	} else {
2805		error = 0;
2806	}
2807
2808	/* only set new mode regardless of error */
2809	ep->ep_mode = ep_mode;
2810
2811	if (do_unlock)
2812		usbd_enum_unlock(udev);
2813	return (error);
2814}
2815
2816uint8_t
2817usbd_get_endpoint_mode(struct usb_device *udev, struct usb_endpoint *ep)
2818{
2819	return (ep->ep_mode);
2820}
2821