xref: /freebsd/sys/dev/usb/usb_transfer.c (revision a872528155cbb10206ddc95c0c4ae42314516d27)
102ac6454SAndrew Thompson /* $FreeBSD$ */
202ac6454SAndrew Thompson /*-
302ac6454SAndrew Thompson  * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
402ac6454SAndrew Thompson  *
502ac6454SAndrew Thompson  * Redistribution and use in source and binary forms, with or without
602ac6454SAndrew Thompson  * modification, are permitted provided that the following conditions
702ac6454SAndrew Thompson  * are met:
802ac6454SAndrew Thompson  * 1. Redistributions of source code must retain the above copyright
902ac6454SAndrew Thompson  *    notice, this list of conditions and the following disclaimer.
1002ac6454SAndrew Thompson  * 2. Redistributions in binary form must reproduce the above copyright
1102ac6454SAndrew Thompson  *    notice, this list of conditions and the following disclaimer in the
1202ac6454SAndrew Thompson  *    documentation and/or other materials provided with the distribution.
1302ac6454SAndrew Thompson  *
1402ac6454SAndrew Thompson  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1502ac6454SAndrew Thompson  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1602ac6454SAndrew Thompson  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1702ac6454SAndrew Thompson  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1802ac6454SAndrew Thompson  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1902ac6454SAndrew Thompson  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2002ac6454SAndrew Thompson  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2102ac6454SAndrew Thompson  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2202ac6454SAndrew Thompson  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2302ac6454SAndrew Thompson  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2402ac6454SAndrew Thompson  * SUCH DAMAGE.
2502ac6454SAndrew Thompson  */
2602ac6454SAndrew Thompson 
27ed6d949aSAndrew Thompson #include <sys/stdint.h>
28ed6d949aSAndrew Thompson #include <sys/stddef.h>
29ed6d949aSAndrew Thompson #include <sys/param.h>
30ed6d949aSAndrew Thompson #include <sys/queue.h>
31ed6d949aSAndrew Thompson #include <sys/types.h>
32ed6d949aSAndrew Thompson #include <sys/systm.h>
33ed6d949aSAndrew Thompson #include <sys/kernel.h>
34ed6d949aSAndrew Thompson #include <sys/bus.h>
35ed6d949aSAndrew Thompson #include <sys/linker_set.h>
36ed6d949aSAndrew Thompson #include <sys/module.h>
37ed6d949aSAndrew Thompson #include <sys/lock.h>
38ed6d949aSAndrew Thompson #include <sys/mutex.h>
39ed6d949aSAndrew Thompson #include <sys/condvar.h>
40ed6d949aSAndrew Thompson #include <sys/sysctl.h>
41ed6d949aSAndrew Thompson #include <sys/sx.h>
42ed6d949aSAndrew Thompson #include <sys/unistd.h>
43ed6d949aSAndrew Thompson #include <sys/callout.h>
44ed6d949aSAndrew Thompson #include <sys/malloc.h>
45ed6d949aSAndrew Thompson #include <sys/priv.h>
46ed6d949aSAndrew Thompson 
4702ac6454SAndrew Thompson #include <dev/usb/usb.h>
48ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h>
49ed6d949aSAndrew Thompson #include <dev/usb/usbdi_util.h>
5002ac6454SAndrew Thompson 
51a593f6b8SAndrew Thompson #define	USB_DEBUG_VAR usb_debug
5202ac6454SAndrew Thompson 
5302ac6454SAndrew Thompson #include <dev/usb/usb_core.h>
5402ac6454SAndrew Thompson #include <dev/usb/usb_busdma.h>
5502ac6454SAndrew Thompson #include <dev/usb/usb_process.h>
5602ac6454SAndrew Thompson #include <dev/usb/usb_transfer.h>
5702ac6454SAndrew Thompson #include <dev/usb/usb_device.h>
5802ac6454SAndrew Thompson #include <dev/usb/usb_debug.h>
5902ac6454SAndrew Thompson #include <dev/usb/usb_util.h>
6002ac6454SAndrew Thompson 
6102ac6454SAndrew Thompson #include <dev/usb/usb_controller.h>
6202ac6454SAndrew Thompson #include <dev/usb/usb_bus.h>
6302ac6454SAndrew Thompson 
64a593f6b8SAndrew Thompson struct usb_std_packet_size {
6502ac6454SAndrew Thompson 	struct {
6602ac6454SAndrew Thompson 		uint16_t min;		/* inclusive */
6702ac6454SAndrew Thompson 		uint16_t max;		/* inclusive */
6802ac6454SAndrew Thompson 	}	range;
6902ac6454SAndrew Thompson 
7002ac6454SAndrew Thompson 	uint16_t fixed[4];
7102ac6454SAndrew Thompson };
7202ac6454SAndrew Thompson 
73a593f6b8SAndrew Thompson static usb_callback_t usb_request_callback;
7402ac6454SAndrew Thompson 
75a593f6b8SAndrew Thompson static const struct usb_config usb_control_ep_cfg[USB_DEFAULT_XFER_MAX] = {
7602ac6454SAndrew Thompson 
7702ac6454SAndrew Thompson 	/* This transfer is used for generic control endpoint transfers */
7802ac6454SAndrew Thompson 
7902ac6454SAndrew Thompson 	[0] = {
8002ac6454SAndrew Thompson 		.type = UE_CONTROL,
8102ac6454SAndrew Thompson 		.endpoint = 0x00,	/* Control endpoint */
8202ac6454SAndrew Thompson 		.direction = UE_DIR_ANY,
834eae601eSAndrew Thompson 		.bufsize = USB_EP0_BUFSIZE,	/* bytes */
844eae601eSAndrew Thompson 		.flags = {.proxy_buffer = 1,},
85a593f6b8SAndrew Thompson 		.callback = &usb_request_callback,
86f29a0724SAndrew Thompson 		.usb_mode = USB_MODE_DUAL,	/* both modes */
8702ac6454SAndrew Thompson 	},
8802ac6454SAndrew Thompson 
8902ac6454SAndrew Thompson 	/* This transfer is used for generic clear stall only */
9002ac6454SAndrew Thompson 
9102ac6454SAndrew Thompson 	[1] = {
9202ac6454SAndrew Thompson 		.type = UE_CONTROL,
9302ac6454SAndrew Thompson 		.endpoint = 0x00,	/* Control pipe */
9402ac6454SAndrew Thompson 		.direction = UE_DIR_ANY,
95760bc48eSAndrew Thompson 		.bufsize = sizeof(struct usb_device_request),
96a593f6b8SAndrew Thompson 		.callback = &usb_do_clear_stall_callback,
974eae601eSAndrew Thompson 		.timeout = 1000,	/* 1 second */
984eae601eSAndrew Thompson 		.interval = 50,	/* 50ms */
994eae601eSAndrew Thompson 		.usb_mode = USB_MODE_HOST,
10002ac6454SAndrew Thompson 	},
10102ac6454SAndrew Thompson };
10202ac6454SAndrew Thompson 
10302ac6454SAndrew Thompson /* function prototypes */
10402ac6454SAndrew Thompson 
105a593f6b8SAndrew Thompson static void	usbd_update_max_frame_size(struct usb_xfer *);
106a593f6b8SAndrew Thompson static void	usbd_transfer_unsetup_sub(struct usb_xfer_root *, uint8_t);
107a593f6b8SAndrew Thompson static void	usbd_control_transfer_init(struct usb_xfer *);
108ed6d949aSAndrew Thompson static int	usbd_setup_ctrl_transfer(struct usb_xfer *);
109a593f6b8SAndrew Thompson static void	usb_callback_proc(struct usb_proc_msg *);
110a593f6b8SAndrew Thompson static void	usbd_callback_ss_done_defer(struct usb_xfer *);
111a593f6b8SAndrew Thompson static void	usbd_callback_wrapper(struct usb_xfer_queue *);
112a593f6b8SAndrew Thompson static void	usb_dma_delay_done_cb(void *);
113a593f6b8SAndrew Thompson static void	usbd_transfer_start_cb(void *);
114a593f6b8SAndrew Thompson static uint8_t	usbd_callback_wrapper_sub(struct usb_xfer *);
115a593f6b8SAndrew Thompson static void	usbd_get_std_packet_size(struct usb_std_packet_size *ptr,
1168d2dd5ddSAndrew Thompson 		    uint8_t type, enum usb_dev_speed speed);
1174eae601eSAndrew Thompson 
1184eae601eSAndrew Thompson /*------------------------------------------------------------------------*
119a593f6b8SAndrew Thompson  *	usb_request_callback
1204eae601eSAndrew Thompson  *------------------------------------------------------------------------*/
1214eae601eSAndrew Thompson static void
122ed6d949aSAndrew Thompson usb_request_callback(struct usb_xfer *xfer, usb_error_t error)
1234eae601eSAndrew Thompson {
124f29a0724SAndrew Thompson 	if (xfer->flags_int.usb_mode == USB_MODE_DEVICE)
125ed6d949aSAndrew Thompson 		usb_handle_request_callback(xfer, error);
1264eae601eSAndrew Thompson 	else
127ed6d949aSAndrew Thompson 		usbd_do_request_callback(xfer, error);
1284eae601eSAndrew Thompson }
12902ac6454SAndrew Thompson 
13002ac6454SAndrew Thompson /*------------------------------------------------------------------------*
131a593f6b8SAndrew Thompson  *	usbd_update_max_frame_size
13202ac6454SAndrew Thompson  *
13302ac6454SAndrew Thompson  * This function updates the maximum frame size, hence high speed USB
13402ac6454SAndrew Thompson  * can transfer multiple consecutive packets.
13502ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
13602ac6454SAndrew Thompson static void
137a593f6b8SAndrew Thompson usbd_update_max_frame_size(struct usb_xfer *xfer)
13802ac6454SAndrew Thompson {
13902ac6454SAndrew Thompson 	/* compute maximum frame size */
14002ac6454SAndrew Thompson 
14102ac6454SAndrew Thompson 	if (xfer->max_packet_count == 2) {
14202ac6454SAndrew Thompson 		xfer->max_frame_size = 2 * xfer->max_packet_size;
14302ac6454SAndrew Thompson 	} else if (xfer->max_packet_count == 3) {
14402ac6454SAndrew Thompson 		xfer->max_frame_size = 3 * xfer->max_packet_size;
14502ac6454SAndrew Thompson 	} else {
14602ac6454SAndrew Thompson 		xfer->max_frame_size = xfer->max_packet_size;
14702ac6454SAndrew Thompson 	}
14802ac6454SAndrew Thompson }
14902ac6454SAndrew Thompson 
15002ac6454SAndrew Thompson /*------------------------------------------------------------------------*
151a593f6b8SAndrew Thompson  *	usbd_get_dma_delay
15202ac6454SAndrew Thompson  *
15302ac6454SAndrew Thompson  * The following function is called when we need to
15402ac6454SAndrew Thompson  * synchronize with DMA hardware.
15502ac6454SAndrew Thompson  *
15602ac6454SAndrew Thompson  * Returns:
15702ac6454SAndrew Thompson  *    0: no DMA delay required
15802ac6454SAndrew Thompson  * Else: milliseconds of DMA delay
15902ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
160e0a69b51SAndrew Thompson usb_timeout_t
161a593f6b8SAndrew Thompson usbd_get_dma_delay(struct usb_bus *bus)
16202ac6454SAndrew Thompson {
16302ac6454SAndrew Thompson 	uint32_t temp = 0;
16402ac6454SAndrew Thompson 
16502ac6454SAndrew Thompson 	if (bus->methods->get_dma_delay) {
16602ac6454SAndrew Thompson 		(bus->methods->get_dma_delay) (bus, &temp);
16702ac6454SAndrew Thompson 		/*
16802ac6454SAndrew Thompson 		 * Round up and convert to milliseconds. Note that we use
16902ac6454SAndrew Thompson 		 * 1024 milliseconds per second. to save a division.
17002ac6454SAndrew Thompson 		 */
17102ac6454SAndrew Thompson 		temp += 0x3FF;
17202ac6454SAndrew Thompson 		temp /= 0x400;
17302ac6454SAndrew Thompson 	}
17402ac6454SAndrew Thompson 	return (temp);
17502ac6454SAndrew Thompson }
17602ac6454SAndrew Thompson 
17702ac6454SAndrew Thompson /*------------------------------------------------------------------------*
178a593f6b8SAndrew Thompson  *	usbd_transfer_setup_sub_malloc
17902ac6454SAndrew Thompson  *
18002ac6454SAndrew Thompson  * This function will allocate one or more DMA'able memory chunks
18102ac6454SAndrew Thompson  * according to "size", "align" and "count" arguments. "ppc" is
18202ac6454SAndrew Thompson  * pointed to a linear array of USB page caches afterwards.
18302ac6454SAndrew Thompson  *
18402ac6454SAndrew Thompson  * Returns:
18502ac6454SAndrew Thompson  *    0: Success
18602ac6454SAndrew Thompson  * Else: Failure
18702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
188bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
18902ac6454SAndrew Thompson uint8_t
190a593f6b8SAndrew Thompson usbd_transfer_setup_sub_malloc(struct usb_setup_params *parm,
191f9cb546cSAndrew Thompson     struct usb_page_cache **ppc, usb_size_t size, usb_size_t align,
192f9cb546cSAndrew Thompson     usb_size_t count)
19302ac6454SAndrew Thompson {
194760bc48eSAndrew Thompson 	struct usb_page_cache *pc;
195760bc48eSAndrew Thompson 	struct usb_page *pg;
19602ac6454SAndrew Thompson 	void *buf;
197f9cb546cSAndrew Thompson 	usb_size_t n_dma_pc;
198f9cb546cSAndrew Thompson 	usb_size_t n_obj;
199f9cb546cSAndrew Thompson 	usb_size_t x;
200f9cb546cSAndrew Thompson 	usb_size_t y;
201f9cb546cSAndrew Thompson 	usb_size_t r;
202f9cb546cSAndrew Thompson 	usb_size_t z;
20302ac6454SAndrew Thompson 
20402ac6454SAndrew Thompson 	USB_ASSERT(align > 1, ("Invalid alignment, 0x%08x!\n",
20502ac6454SAndrew Thompson 	    align));
20602ac6454SAndrew Thompson 	USB_ASSERT(size > 0, ("Invalid size = 0!\n"));
20702ac6454SAndrew Thompson 
20802ac6454SAndrew Thompson 	if (count == 0) {
20902ac6454SAndrew Thompson 		return (0);		/* nothing to allocate */
21002ac6454SAndrew Thompson 	}
21102ac6454SAndrew Thompson 	/*
21202ac6454SAndrew Thompson 	 * Make sure that the size is aligned properly.
21302ac6454SAndrew Thompson 	 */
21402ac6454SAndrew Thompson 	size = -((-size) & (-align));
21502ac6454SAndrew Thompson 
21602ac6454SAndrew Thompson 	/*
21702ac6454SAndrew Thompson 	 * Try multi-allocation chunks to reduce the number of DMA
21802ac6454SAndrew Thompson 	 * allocations, hence DMA allocations are slow.
21902ac6454SAndrew Thompson 	 */
22002ac6454SAndrew Thompson 	if (size >= PAGE_SIZE) {
22102ac6454SAndrew Thompson 		n_dma_pc = count;
22202ac6454SAndrew Thompson 		n_obj = 1;
22302ac6454SAndrew Thompson 	} else {
22402ac6454SAndrew Thompson 		/* compute number of objects per page */
22502ac6454SAndrew Thompson 		n_obj = (PAGE_SIZE / size);
22602ac6454SAndrew Thompson 		/*
22702ac6454SAndrew Thompson 		 * Compute number of DMA chunks, rounded up
22802ac6454SAndrew Thompson 		 * to nearest one:
22902ac6454SAndrew Thompson 		 */
23002ac6454SAndrew Thompson 		n_dma_pc = ((count + n_obj - 1) / n_obj);
23102ac6454SAndrew Thompson 	}
23202ac6454SAndrew Thompson 
23302ac6454SAndrew Thompson 	if (parm->buf == NULL) {
23402ac6454SAndrew Thompson 		/* for the future */
23502ac6454SAndrew Thompson 		parm->dma_page_ptr += n_dma_pc;
23602ac6454SAndrew Thompson 		parm->dma_page_cache_ptr += n_dma_pc;
23702ac6454SAndrew Thompson 		parm->dma_page_ptr += count;
23802ac6454SAndrew Thompson 		parm->xfer_page_cache_ptr += count;
23902ac6454SAndrew Thompson 		return (0);
24002ac6454SAndrew Thompson 	}
24102ac6454SAndrew Thompson 	for (x = 0; x != n_dma_pc; x++) {
24202ac6454SAndrew Thompson 		/* need to initialize the page cache */
24302ac6454SAndrew Thompson 		parm->dma_page_cache_ptr[x].tag_parent =
24402ac6454SAndrew Thompson 		    &parm->curr_xfer->xroot->dma_parent_tag;
24502ac6454SAndrew Thompson 	}
24602ac6454SAndrew Thompson 	for (x = 0; x != count; x++) {
24702ac6454SAndrew Thompson 		/* need to initialize the page cache */
24802ac6454SAndrew Thompson 		parm->xfer_page_cache_ptr[x].tag_parent =
24902ac6454SAndrew Thompson 		    &parm->curr_xfer->xroot->dma_parent_tag;
25002ac6454SAndrew Thompson 	}
25102ac6454SAndrew Thompson 
25202ac6454SAndrew Thompson 	if (ppc) {
25302ac6454SAndrew Thompson 		*ppc = parm->xfer_page_cache_ptr;
25402ac6454SAndrew Thompson 	}
25502ac6454SAndrew Thompson 	r = count;			/* set remainder count */
25602ac6454SAndrew Thompson 	z = n_obj * size;		/* set allocation size */
25702ac6454SAndrew Thompson 	pc = parm->xfer_page_cache_ptr;
25802ac6454SAndrew Thompson 	pg = parm->dma_page_ptr;
25902ac6454SAndrew Thompson 
26002ac6454SAndrew Thompson 	for (x = 0; x != n_dma_pc; x++) {
26102ac6454SAndrew Thompson 
26202ac6454SAndrew Thompson 		if (r < n_obj) {
26302ac6454SAndrew Thompson 			/* compute last remainder */
26402ac6454SAndrew Thompson 			z = r * size;
26502ac6454SAndrew Thompson 			n_obj = r;
26602ac6454SAndrew Thompson 		}
267a593f6b8SAndrew Thompson 		if (usb_pc_alloc_mem(parm->dma_page_cache_ptr,
26802ac6454SAndrew Thompson 		    pg, z, align)) {
26902ac6454SAndrew Thompson 			return (1);	/* failure */
27002ac6454SAndrew Thompson 		}
27102ac6454SAndrew Thompson 		/* Set beginning of current buffer */
27202ac6454SAndrew Thompson 		buf = parm->dma_page_cache_ptr->buffer;
27302ac6454SAndrew Thompson 		/* Make room for one DMA page cache and one page */
27402ac6454SAndrew Thompson 		parm->dma_page_cache_ptr++;
27502ac6454SAndrew Thompson 		pg++;
27602ac6454SAndrew Thompson 
27702ac6454SAndrew Thompson 		for (y = 0; (y != n_obj); y++, r--, pc++, pg++) {
27802ac6454SAndrew Thompson 
27902ac6454SAndrew Thompson 			/* Load sub-chunk into DMA */
280a593f6b8SAndrew Thompson 			if (usb_pc_dmamap_create(pc, size)) {
28102ac6454SAndrew Thompson 				return (1);	/* failure */
28202ac6454SAndrew Thompson 			}
28302ac6454SAndrew Thompson 			pc->buffer = USB_ADD_BYTES(buf, y * size);
28402ac6454SAndrew Thompson 			pc->page_start = pg;
28502ac6454SAndrew Thompson 
28602ac6454SAndrew Thompson 			mtx_lock(pc->tag_parent->mtx);
287a593f6b8SAndrew Thompson 			if (usb_pc_load_mem(pc, size, 1 /* synchronous */ )) {
28802ac6454SAndrew Thompson 				mtx_unlock(pc->tag_parent->mtx);
28902ac6454SAndrew Thompson 				return (1);	/* failure */
29002ac6454SAndrew Thompson 			}
29102ac6454SAndrew Thompson 			mtx_unlock(pc->tag_parent->mtx);
29202ac6454SAndrew Thompson 		}
29302ac6454SAndrew Thompson 	}
29402ac6454SAndrew Thompson 
29502ac6454SAndrew Thompson 	parm->xfer_page_cache_ptr = pc;
29602ac6454SAndrew Thompson 	parm->dma_page_ptr = pg;
29702ac6454SAndrew Thompson 	return (0);
29802ac6454SAndrew Thompson }
299bdc081c6SAndrew Thompson #endif
30002ac6454SAndrew Thompson 
30102ac6454SAndrew Thompson /*------------------------------------------------------------------------*
302a593f6b8SAndrew Thompson  *	usbd_transfer_setup_sub - transfer setup subroutine
30302ac6454SAndrew Thompson  *
30402ac6454SAndrew Thompson  * This function must be called from the "xfer_setup" callback of the
30502ac6454SAndrew Thompson  * USB Host or Device controller driver when setting up an USB
30602ac6454SAndrew Thompson  * transfer. This function will setup correct packet sizes, buffer
307760bc48eSAndrew Thompson  * sizes, flags and more, that are stored in the "usb_xfer"
30802ac6454SAndrew Thompson  * structure.
30902ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
31002ac6454SAndrew Thompson void
311a593f6b8SAndrew Thompson usbd_transfer_setup_sub(struct usb_setup_params *parm)
31202ac6454SAndrew Thompson {
31302ac6454SAndrew Thompson 	enum {
31402ac6454SAndrew Thompson 		REQ_SIZE = 8,
31502ac6454SAndrew Thompson 		MIN_PKT = 8,
31602ac6454SAndrew Thompson 	};
317760bc48eSAndrew Thompson 	struct usb_xfer *xfer = parm->curr_xfer;
318760bc48eSAndrew Thompson 	const struct usb_config *setup = parm->curr_setup;
319760bc48eSAndrew Thompson 	struct usb_endpoint_descriptor *edesc;
320a593f6b8SAndrew Thompson 	struct usb_std_packet_size std_size;
321e0a69b51SAndrew Thompson 	usb_frcount_t n_frlengths;
322e0a69b51SAndrew Thompson 	usb_frcount_t n_frbuffers;
323e0a69b51SAndrew Thompson 	usb_frcount_t x;
32402ac6454SAndrew Thompson 	uint8_t type;
32502ac6454SAndrew Thompson 	uint8_t zmps;
32602ac6454SAndrew Thompson 
32702ac6454SAndrew Thompson 	/*
32802ac6454SAndrew Thompson 	 * Sanity check. The following parameters must be initialized before
32902ac6454SAndrew Thompson 	 * calling this function.
33002ac6454SAndrew Thompson 	 */
33102ac6454SAndrew Thompson 	if ((parm->hc_max_packet_size == 0) ||
33202ac6454SAndrew Thompson 	    (parm->hc_max_packet_count == 0) ||
33302ac6454SAndrew Thompson 	    (parm->hc_max_frame_size == 0)) {
33402ac6454SAndrew Thompson 		parm->err = USB_ERR_INVAL;
33502ac6454SAndrew Thompson 		goto done;
33602ac6454SAndrew Thompson 	}
337ae60fdfbSAndrew Thompson 	edesc = xfer->endpoint->edesc;
33802ac6454SAndrew Thompson 
33902ac6454SAndrew Thompson 	type = (edesc->bmAttributes & UE_XFERTYPE);
34002ac6454SAndrew Thompson 
3414eae601eSAndrew Thompson 	xfer->flags = setup->flags;
3424eae601eSAndrew Thompson 	xfer->nframes = setup->frames;
3434eae601eSAndrew Thompson 	xfer->timeout = setup->timeout;
3444eae601eSAndrew Thompson 	xfer->callback = setup->callback;
3454eae601eSAndrew Thompson 	xfer->interval = setup->interval;
346ae60fdfbSAndrew Thompson 	xfer->endpointno = edesc->bEndpointAddress;
34702ac6454SAndrew Thompson 	xfer->max_packet_size = UGETW(edesc->wMaxPacketSize);
34802ac6454SAndrew Thompson 	xfer->max_packet_count = 1;
34902ac6454SAndrew Thompson 	/* make a shadow copy: */
350f29a0724SAndrew Thompson 	xfer->flags_int.usb_mode = parm->udev->flags.usb_mode;
35102ac6454SAndrew Thompson 
3524eae601eSAndrew Thompson 	parm->bufsize = setup->bufsize;
35302ac6454SAndrew Thompson 
35402ac6454SAndrew Thompson 	if (parm->speed == USB_SPEED_HIGH) {
35502ac6454SAndrew Thompson 		xfer->max_packet_count += (xfer->max_packet_size >> 11) & 3;
35602ac6454SAndrew Thompson 		xfer->max_packet_size &= 0x7FF;
35702ac6454SAndrew Thompson 	}
35802ac6454SAndrew Thompson 	/* range check "max_packet_count" */
35902ac6454SAndrew Thompson 
36002ac6454SAndrew Thompson 	if (xfer->max_packet_count > parm->hc_max_packet_count) {
36102ac6454SAndrew Thompson 		xfer->max_packet_count = parm->hc_max_packet_count;
36202ac6454SAndrew Thompson 	}
36302ac6454SAndrew Thompson 	/* filter "wMaxPacketSize" according to HC capabilities */
36402ac6454SAndrew Thompson 
36502ac6454SAndrew Thompson 	if ((xfer->max_packet_size > parm->hc_max_packet_size) ||
36602ac6454SAndrew Thompson 	    (xfer->max_packet_size == 0)) {
36702ac6454SAndrew Thompson 		xfer->max_packet_size = parm->hc_max_packet_size;
36802ac6454SAndrew Thompson 	}
36902ac6454SAndrew Thompson 	/* filter "wMaxPacketSize" according to standard sizes */
37002ac6454SAndrew Thompson 
371a593f6b8SAndrew Thompson 	usbd_get_std_packet_size(&std_size, type, parm->speed);
37202ac6454SAndrew Thompson 
37302ac6454SAndrew Thompson 	if (std_size.range.min || std_size.range.max) {
37402ac6454SAndrew Thompson 
37502ac6454SAndrew Thompson 		if (xfer->max_packet_size < std_size.range.min) {
37602ac6454SAndrew Thompson 			xfer->max_packet_size = std_size.range.min;
37702ac6454SAndrew Thompson 		}
37802ac6454SAndrew Thompson 		if (xfer->max_packet_size > std_size.range.max) {
37902ac6454SAndrew Thompson 			xfer->max_packet_size = std_size.range.max;
38002ac6454SAndrew Thompson 		}
38102ac6454SAndrew Thompson 	} else {
38202ac6454SAndrew Thompson 
38302ac6454SAndrew Thompson 		if (xfer->max_packet_size >= std_size.fixed[3]) {
38402ac6454SAndrew Thompson 			xfer->max_packet_size = std_size.fixed[3];
38502ac6454SAndrew Thompson 		} else if (xfer->max_packet_size >= std_size.fixed[2]) {
38602ac6454SAndrew Thompson 			xfer->max_packet_size = std_size.fixed[2];
38702ac6454SAndrew Thompson 		} else if (xfer->max_packet_size >= std_size.fixed[1]) {
38802ac6454SAndrew Thompson 			xfer->max_packet_size = std_size.fixed[1];
38902ac6454SAndrew Thompson 		} else {
39002ac6454SAndrew Thompson 			/* only one possibility left */
39102ac6454SAndrew Thompson 			xfer->max_packet_size = std_size.fixed[0];
39202ac6454SAndrew Thompson 		}
39302ac6454SAndrew Thompson 	}
39402ac6454SAndrew Thompson 
39502ac6454SAndrew Thompson 	/* compute "max_frame_size" */
39602ac6454SAndrew Thompson 
397a593f6b8SAndrew Thompson 	usbd_update_max_frame_size(xfer);
39802ac6454SAndrew Thompson 
39902ac6454SAndrew Thompson 	/* check interrupt interval and transfer pre-delay */
40002ac6454SAndrew Thompson 
40102ac6454SAndrew Thompson 	if (type == UE_ISOCHRONOUS) {
40202ac6454SAndrew Thompson 
403578d0effSAndrew Thompson 		uint16_t frame_limit;
40402ac6454SAndrew Thompson 
40502ac6454SAndrew Thompson 		xfer->interval = 0;	/* not used, must be zero */
40602ac6454SAndrew Thompson 		xfer->flags_int.isochronous_xfr = 1;	/* set flag */
40702ac6454SAndrew Thompson 
40802ac6454SAndrew Thompson 		if (xfer->timeout == 0) {
40902ac6454SAndrew Thompson 			/*
41002ac6454SAndrew Thompson 			 * set a default timeout in
41102ac6454SAndrew Thompson 			 * case something goes wrong!
41202ac6454SAndrew Thompson 			 */
41302ac6454SAndrew Thompson 			xfer->timeout = 1000 / 4;
41402ac6454SAndrew Thompson 		}
41502ac6454SAndrew Thompson 		switch (parm->speed) {
41602ac6454SAndrew Thompson 		case USB_SPEED_LOW:
41702ac6454SAndrew Thompson 		case USB_SPEED_FULL:
41802ac6454SAndrew Thompson 			frame_limit = USB_MAX_FS_ISOC_FRAMES_PER_XFER;
41902ac6454SAndrew Thompson 			break;
42002ac6454SAndrew Thompson 		default:
42102ac6454SAndrew Thompson 			frame_limit = USB_MAX_HS_ISOC_FRAMES_PER_XFER;
42202ac6454SAndrew Thompson 			break;
42302ac6454SAndrew Thompson 		}
42402ac6454SAndrew Thompson 
42502ac6454SAndrew Thompson 		if (xfer->nframes > frame_limit) {
42602ac6454SAndrew Thompson 			/*
42702ac6454SAndrew Thompson 			 * this is not going to work
42802ac6454SAndrew Thompson 			 * cross hardware
42902ac6454SAndrew Thompson 			 */
43002ac6454SAndrew Thompson 			parm->err = USB_ERR_INVAL;
43102ac6454SAndrew Thompson 			goto done;
43202ac6454SAndrew Thompson 		}
43302ac6454SAndrew Thompson 		if (xfer->nframes == 0) {
43402ac6454SAndrew Thompson 			/*
43502ac6454SAndrew Thompson 			 * this is not a valid value
43602ac6454SAndrew Thompson 			 */
43702ac6454SAndrew Thompson 			parm->err = USB_ERR_ZERO_NFRAMES;
43802ac6454SAndrew Thompson 			goto done;
43902ac6454SAndrew Thompson 		}
44002ac6454SAndrew Thompson 	} else {
44102ac6454SAndrew Thompson 
44202ac6454SAndrew Thompson 		/*
44302ac6454SAndrew Thompson 		 * if a value is specified use that else check the endpoint
44402ac6454SAndrew Thompson 		 * descriptor
44502ac6454SAndrew Thompson 		 */
44602ac6454SAndrew Thompson 		if (xfer->interval == 0) {
44702ac6454SAndrew Thompson 
44802ac6454SAndrew Thompson 			if (type == UE_INTERRUPT) {
44902ac6454SAndrew Thompson 
45002ac6454SAndrew Thompson 				xfer->interval = edesc->bInterval;
45102ac6454SAndrew Thompson 
45202ac6454SAndrew Thompson 				switch (parm->speed) {
45302ac6454SAndrew Thompson 				case USB_SPEED_SUPER:
45402ac6454SAndrew Thompson 				case USB_SPEED_VARIABLE:
45502ac6454SAndrew Thompson 					/* 125us -> 1ms */
45602ac6454SAndrew Thompson 					if (xfer->interval < 4)
45702ac6454SAndrew Thompson 						xfer->interval = 1;
45802ac6454SAndrew Thompson 					else if (xfer->interval > 16)
45902ac6454SAndrew Thompson 						xfer->interval = (1<<(16-4));
46002ac6454SAndrew Thompson 					else
46102ac6454SAndrew Thompson 						xfer->interval =
46202ac6454SAndrew Thompson 						    (1 << (xfer->interval-4));
46302ac6454SAndrew Thompson 					break;
46402ac6454SAndrew Thompson 				case USB_SPEED_HIGH:
46502ac6454SAndrew Thompson 					/* 125us -> 1ms */
46602ac6454SAndrew Thompson 					xfer->interval /= 8;
46702ac6454SAndrew Thompson 					break;
46802ac6454SAndrew Thompson 				default:
46902ac6454SAndrew Thompson 					break;
47002ac6454SAndrew Thompson 				}
47102ac6454SAndrew Thompson 				if (xfer->interval == 0) {
47202ac6454SAndrew Thompson 					/*
47302ac6454SAndrew Thompson 					 * One millisecond is the smallest
47402ac6454SAndrew Thompson 					 * interval we support:
47502ac6454SAndrew Thompson 					 */
47602ac6454SAndrew Thompson 					xfer->interval = 1;
47702ac6454SAndrew Thompson 				}
47802ac6454SAndrew Thompson 			}
47902ac6454SAndrew Thompson 		}
48002ac6454SAndrew Thompson 	}
48102ac6454SAndrew Thompson 
48202ac6454SAndrew Thompson 	/*
48302ac6454SAndrew Thompson 	 * NOTE: we do not allow "max_packet_size" or "max_frame_size"
48402ac6454SAndrew Thompson 	 * to be equal to zero when setting up USB transfers, hence
48502ac6454SAndrew Thompson 	 * this leads to alot of extra code in the USB kernel.
48602ac6454SAndrew Thompson 	 */
48702ac6454SAndrew Thompson 
48802ac6454SAndrew Thompson 	if ((xfer->max_frame_size == 0) ||
48902ac6454SAndrew Thompson 	    (xfer->max_packet_size == 0)) {
49002ac6454SAndrew Thompson 
49102ac6454SAndrew Thompson 		zmps = 1;
49202ac6454SAndrew Thompson 
49302ac6454SAndrew Thompson 		if ((parm->bufsize <= MIN_PKT) &&
49402ac6454SAndrew Thompson 		    (type != UE_CONTROL) &&
49502ac6454SAndrew Thompson 		    (type != UE_BULK)) {
49602ac6454SAndrew Thompson 
49702ac6454SAndrew Thompson 			/* workaround */
49802ac6454SAndrew Thompson 			xfer->max_packet_size = MIN_PKT;
49902ac6454SAndrew Thompson 			xfer->max_packet_count = 1;
50002ac6454SAndrew Thompson 			parm->bufsize = 0;	/* automatic setup length */
501a593f6b8SAndrew Thompson 			usbd_update_max_frame_size(xfer);
50202ac6454SAndrew Thompson 
50302ac6454SAndrew Thompson 		} else {
50402ac6454SAndrew Thompson 			parm->err = USB_ERR_ZERO_MAXP;
50502ac6454SAndrew Thompson 			goto done;
50602ac6454SAndrew Thompson 		}
50702ac6454SAndrew Thompson 
50802ac6454SAndrew Thompson 	} else {
50902ac6454SAndrew Thompson 		zmps = 0;
51002ac6454SAndrew Thompson 	}
51102ac6454SAndrew Thompson 
51202ac6454SAndrew Thompson 	/*
51302ac6454SAndrew Thompson 	 * check if we should setup a default
51402ac6454SAndrew Thompson 	 * length:
51502ac6454SAndrew Thompson 	 */
51602ac6454SAndrew Thompson 
51702ac6454SAndrew Thompson 	if (parm->bufsize == 0) {
51802ac6454SAndrew Thompson 
51902ac6454SAndrew Thompson 		parm->bufsize = xfer->max_frame_size;
52002ac6454SAndrew Thompson 
52102ac6454SAndrew Thompson 		if (type == UE_ISOCHRONOUS) {
52202ac6454SAndrew Thompson 			parm->bufsize *= xfer->nframes;
52302ac6454SAndrew Thompson 		}
52402ac6454SAndrew Thompson 	}
52502ac6454SAndrew Thompson 	/*
52602ac6454SAndrew Thompson 	 * check if we are about to setup a proxy
52702ac6454SAndrew Thompson 	 * type of buffer:
52802ac6454SAndrew Thompson 	 */
52902ac6454SAndrew Thompson 
53002ac6454SAndrew Thompson 	if (xfer->flags.proxy_buffer) {
53102ac6454SAndrew Thompson 
53202ac6454SAndrew Thompson 		/* round bufsize up */
53302ac6454SAndrew Thompson 
53402ac6454SAndrew Thompson 		parm->bufsize += (xfer->max_frame_size - 1);
53502ac6454SAndrew Thompson 
53602ac6454SAndrew Thompson 		if (parm->bufsize < xfer->max_frame_size) {
53702ac6454SAndrew Thompson 			/* length wrapped around */
53802ac6454SAndrew Thompson 			parm->err = USB_ERR_INVAL;
53902ac6454SAndrew Thompson 			goto done;
54002ac6454SAndrew Thompson 		}
54102ac6454SAndrew Thompson 		/* subtract remainder */
54202ac6454SAndrew Thompson 
54302ac6454SAndrew Thompson 		parm->bufsize -= (parm->bufsize % xfer->max_frame_size);
54402ac6454SAndrew Thompson 
54502ac6454SAndrew Thompson 		/* add length of USB device request structure, if any */
54602ac6454SAndrew Thompson 
54702ac6454SAndrew Thompson 		if (type == UE_CONTROL) {
54802ac6454SAndrew Thompson 			parm->bufsize += REQ_SIZE;	/* SETUP message */
54902ac6454SAndrew Thompson 		}
55002ac6454SAndrew Thompson 	}
55102ac6454SAndrew Thompson 	xfer->max_data_length = parm->bufsize;
55202ac6454SAndrew Thompson 
55302ac6454SAndrew Thompson 	/* Setup "n_frlengths" and "n_frbuffers" */
55402ac6454SAndrew Thompson 
55502ac6454SAndrew Thompson 	if (type == UE_ISOCHRONOUS) {
55602ac6454SAndrew Thompson 		n_frlengths = xfer->nframes;
55702ac6454SAndrew Thompson 		n_frbuffers = 1;
55802ac6454SAndrew Thompson 	} else {
55902ac6454SAndrew Thompson 
56002ac6454SAndrew Thompson 		if (type == UE_CONTROL) {
56102ac6454SAndrew Thompson 			xfer->flags_int.control_xfr = 1;
56202ac6454SAndrew Thompson 			if (xfer->nframes == 0) {
56302ac6454SAndrew Thompson 				if (parm->bufsize <= REQ_SIZE) {
56402ac6454SAndrew Thompson 					/*
56502ac6454SAndrew Thompson 					 * there will never be any data
56602ac6454SAndrew Thompson 					 * stage
56702ac6454SAndrew Thompson 					 */
56802ac6454SAndrew Thompson 					xfer->nframes = 1;
56902ac6454SAndrew Thompson 				} else {
57002ac6454SAndrew Thompson 					xfer->nframes = 2;
57102ac6454SAndrew Thompson 				}
57202ac6454SAndrew Thompson 			}
57302ac6454SAndrew Thompson 		} else {
57402ac6454SAndrew Thompson 			if (xfer->nframes == 0) {
57502ac6454SAndrew Thompson 				xfer->nframes = 1;
57602ac6454SAndrew Thompson 			}
57702ac6454SAndrew Thompson 		}
57802ac6454SAndrew Thompson 
57902ac6454SAndrew Thompson 		n_frlengths = xfer->nframes;
58002ac6454SAndrew Thompson 		n_frbuffers = xfer->nframes;
58102ac6454SAndrew Thompson 	}
58202ac6454SAndrew Thompson 
58302ac6454SAndrew Thompson 	/*
58402ac6454SAndrew Thompson 	 * check if we have room for the
58502ac6454SAndrew Thompson 	 * USB device request structure:
58602ac6454SAndrew Thompson 	 */
58702ac6454SAndrew Thompson 
58802ac6454SAndrew Thompson 	if (type == UE_CONTROL) {
58902ac6454SAndrew Thompson 
59002ac6454SAndrew Thompson 		if (xfer->max_data_length < REQ_SIZE) {
59102ac6454SAndrew Thompson 			/* length wrapped around or too small bufsize */
59202ac6454SAndrew Thompson 			parm->err = USB_ERR_INVAL;
59302ac6454SAndrew Thompson 			goto done;
59402ac6454SAndrew Thompson 		}
59502ac6454SAndrew Thompson 		xfer->max_data_length -= REQ_SIZE;
59602ac6454SAndrew Thompson 	}
59702ac6454SAndrew Thompson 	/* setup "frlengths" */
59802ac6454SAndrew Thompson 	xfer->frlengths = parm->xfer_length_ptr;
59902ac6454SAndrew Thompson 	parm->xfer_length_ptr += n_frlengths;
60002ac6454SAndrew Thompson 
60102ac6454SAndrew Thompson 	/* setup "frbuffers" */
60202ac6454SAndrew Thompson 	xfer->frbuffers = parm->xfer_page_cache_ptr;
60302ac6454SAndrew Thompson 	parm->xfer_page_cache_ptr += n_frbuffers;
60402ac6454SAndrew Thompson 
605ed6d949aSAndrew Thompson 	/* initialize max frame count */
606ed6d949aSAndrew Thompson 	xfer->max_frame_count = xfer->nframes;
607ed6d949aSAndrew Thompson 
60802ac6454SAndrew Thompson 	/*
60902ac6454SAndrew Thompson 	 * check if we need to setup
61002ac6454SAndrew Thompson 	 * a local buffer:
61102ac6454SAndrew Thompson 	 */
61202ac6454SAndrew Thompson 
61302ac6454SAndrew Thompson 	if (!xfer->flags.ext_buffer) {
61402ac6454SAndrew Thompson 
61502ac6454SAndrew Thompson 		/* align data */
61602ac6454SAndrew Thompson 		parm->size[0] += ((-parm->size[0]) & (USB_HOST_ALIGN - 1));
61702ac6454SAndrew Thompson 
61802ac6454SAndrew Thompson 		if (parm->buf) {
61902ac6454SAndrew Thompson 
62002ac6454SAndrew Thompson 			xfer->local_buffer =
62102ac6454SAndrew Thompson 			    USB_ADD_BYTES(parm->buf, parm->size[0]);
62202ac6454SAndrew Thompson 
623ed6d949aSAndrew Thompson 			usbd_xfer_set_frame_offset(xfer, 0, 0);
62402ac6454SAndrew Thompson 
62502ac6454SAndrew Thompson 			if ((type == UE_CONTROL) && (n_frbuffers > 1)) {
626ed6d949aSAndrew Thompson 				usbd_xfer_set_frame_offset(xfer, REQ_SIZE, 1);
62702ac6454SAndrew Thompson 			}
62802ac6454SAndrew Thompson 		}
62902ac6454SAndrew Thompson 		parm->size[0] += parm->bufsize;
63002ac6454SAndrew Thompson 
63102ac6454SAndrew Thompson 		/* align data again */
63202ac6454SAndrew Thompson 		parm->size[0] += ((-parm->size[0]) & (USB_HOST_ALIGN - 1));
63302ac6454SAndrew Thompson 	}
63402ac6454SAndrew Thompson 	/*
63502ac6454SAndrew Thompson 	 * Compute maximum buffer size
63602ac6454SAndrew Thompson 	 */
63702ac6454SAndrew Thompson 
63802ac6454SAndrew Thompson 	if (parm->bufsize_max < parm->bufsize) {
63902ac6454SAndrew Thompson 		parm->bufsize_max = parm->bufsize;
64002ac6454SAndrew Thompson 	}
641bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
64202ac6454SAndrew Thompson 	if (xfer->flags_int.bdma_enable) {
64302ac6454SAndrew Thompson 		/*
64402ac6454SAndrew Thompson 		 * Setup "dma_page_ptr".
64502ac6454SAndrew Thompson 		 *
64602ac6454SAndrew Thompson 		 * Proof for formula below:
64702ac6454SAndrew Thompson 		 *
64802ac6454SAndrew Thompson 		 * Assume there are three USB frames having length "a", "b" and
64902ac6454SAndrew Thompson 		 * "c". These USB frames will at maximum need "z"
650760bc48eSAndrew Thompson 		 * "usb_page" structures. "z" is given by:
65102ac6454SAndrew Thompson 		 *
65202ac6454SAndrew Thompson 		 * z = ((a / USB_PAGE_SIZE) + 2) + ((b / USB_PAGE_SIZE) + 2) +
65302ac6454SAndrew Thompson 		 * ((c / USB_PAGE_SIZE) + 2);
65402ac6454SAndrew Thompson 		 *
65502ac6454SAndrew Thompson 		 * Constraining "a", "b" and "c" like this:
65602ac6454SAndrew Thompson 		 *
65702ac6454SAndrew Thompson 		 * (a + b + c) <= parm->bufsize
65802ac6454SAndrew Thompson 		 *
65902ac6454SAndrew Thompson 		 * We know that:
66002ac6454SAndrew Thompson 		 *
66102ac6454SAndrew Thompson 		 * z <= ((parm->bufsize / USB_PAGE_SIZE) + (3*2));
66202ac6454SAndrew Thompson 		 *
66302ac6454SAndrew Thompson 		 * Here is the general formula:
66402ac6454SAndrew Thompson 		 */
66502ac6454SAndrew Thompson 		xfer->dma_page_ptr = parm->dma_page_ptr;
66602ac6454SAndrew Thompson 		parm->dma_page_ptr += (2 * n_frbuffers);
66702ac6454SAndrew Thompson 		parm->dma_page_ptr += (parm->bufsize / USB_PAGE_SIZE);
66802ac6454SAndrew Thompson 	}
669bdc081c6SAndrew Thompson #endif
67002ac6454SAndrew Thompson 	if (zmps) {
67102ac6454SAndrew Thompson 		/* correct maximum data length */
67202ac6454SAndrew Thompson 		xfer->max_data_length = 0;
67302ac6454SAndrew Thompson 	}
67402ac6454SAndrew Thompson 	/* subtract USB frame remainder from "hc_max_frame_size" */
67502ac6454SAndrew Thompson 
676578d0effSAndrew Thompson 	xfer->max_hc_frame_size =
67702ac6454SAndrew Thompson 	    (parm->hc_max_frame_size -
67802ac6454SAndrew Thompson 	    (parm->hc_max_frame_size % xfer->max_frame_size));
67902ac6454SAndrew Thompson 
680578d0effSAndrew Thompson 	if (xfer->max_hc_frame_size == 0) {
68102ac6454SAndrew Thompson 		parm->err = USB_ERR_INVAL;
68202ac6454SAndrew Thompson 		goto done;
68302ac6454SAndrew Thompson 	}
68402ac6454SAndrew Thompson 
68502ac6454SAndrew Thompson 	/* initialize frame buffers */
68602ac6454SAndrew Thompson 
68702ac6454SAndrew Thompson 	if (parm->buf) {
68802ac6454SAndrew Thompson 		for (x = 0; x != n_frbuffers; x++) {
68902ac6454SAndrew Thompson 			xfer->frbuffers[x].tag_parent =
69002ac6454SAndrew Thompson 			    &xfer->xroot->dma_parent_tag;
691bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
69202ac6454SAndrew Thompson 			if (xfer->flags_int.bdma_enable &&
69302ac6454SAndrew Thompson 			    (parm->bufsize_max > 0)) {
69402ac6454SAndrew Thompson 
695a593f6b8SAndrew Thompson 				if (usb_pc_dmamap_create(
69602ac6454SAndrew Thompson 				    xfer->frbuffers + x,
69702ac6454SAndrew Thompson 				    parm->bufsize_max)) {
69802ac6454SAndrew Thompson 					parm->err = USB_ERR_NOMEM;
69902ac6454SAndrew Thompson 					goto done;
70002ac6454SAndrew Thompson 				}
70102ac6454SAndrew Thompson 			}
702bdc081c6SAndrew Thompson #endif
70302ac6454SAndrew Thompson 		}
70402ac6454SAndrew Thompson 	}
70502ac6454SAndrew Thompson done:
70602ac6454SAndrew Thompson 	if (parm->err) {
70702ac6454SAndrew Thompson 		/*
70802ac6454SAndrew Thompson 		 * Set some dummy values so that we avoid division by zero:
70902ac6454SAndrew Thompson 		 */
710578d0effSAndrew Thompson 		xfer->max_hc_frame_size = 1;
71102ac6454SAndrew Thompson 		xfer->max_frame_size = 1;
71202ac6454SAndrew Thompson 		xfer->max_packet_size = 1;
71302ac6454SAndrew Thompson 		xfer->max_data_length = 0;
71402ac6454SAndrew Thompson 		xfer->nframes = 0;
71502ac6454SAndrew Thompson 		xfer->max_frame_count = 0;
71602ac6454SAndrew Thompson 	}
71702ac6454SAndrew Thompson }
71802ac6454SAndrew Thompson 
71902ac6454SAndrew Thompson /*------------------------------------------------------------------------*
720a593f6b8SAndrew Thompson  *	usbd_transfer_setup - setup an array of USB transfers
72102ac6454SAndrew Thompson  *
722a593f6b8SAndrew Thompson  * NOTE: You must always call "usbd_transfer_unsetup" after calling
723a593f6b8SAndrew Thompson  * "usbd_transfer_setup" if success was returned.
72402ac6454SAndrew Thompson  *
72502ac6454SAndrew Thompson  * The idea is that the USB device driver should pre-allocate all its
72602ac6454SAndrew Thompson  * transfers by one call to this function.
72702ac6454SAndrew Thompson  *
72802ac6454SAndrew Thompson  * Return values:
72902ac6454SAndrew Thompson  *    0: Success
73002ac6454SAndrew Thompson  * Else: Failure
73102ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
732e0a69b51SAndrew Thompson usb_error_t
733a593f6b8SAndrew Thompson usbd_transfer_setup(struct usb_device *udev,
734760bc48eSAndrew Thompson     const uint8_t *ifaces, struct usb_xfer **ppxfer,
735760bc48eSAndrew Thompson     const struct usb_config *setup_start, uint16_t n_setup,
73602ac6454SAndrew Thompson     void *priv_sc, struct mtx *xfer_mtx)
73702ac6454SAndrew Thompson {
738760bc48eSAndrew Thompson 	struct usb_xfer dummy;
739760bc48eSAndrew Thompson 	struct usb_setup_params parm;
740760bc48eSAndrew Thompson 	const struct usb_config *setup_end = setup_start + n_setup;
741760bc48eSAndrew Thompson 	const struct usb_config *setup;
742ae60fdfbSAndrew Thompson 	struct usb_endpoint *ep;
743760bc48eSAndrew Thompson 	struct usb_xfer_root *info;
744760bc48eSAndrew Thompson 	struct usb_xfer *xfer;
74502ac6454SAndrew Thompson 	void *buf = NULL;
74602ac6454SAndrew Thompson 	uint16_t n;
74702ac6454SAndrew Thompson 	uint16_t refcount;
74802ac6454SAndrew Thompson 
74902ac6454SAndrew Thompson 	parm.err = 0;
75002ac6454SAndrew Thompson 	refcount = 0;
75102ac6454SAndrew Thompson 	info = NULL;
75202ac6454SAndrew Thompson 
75302ac6454SAndrew Thompson 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
754a593f6b8SAndrew Thompson 	    "usbd_transfer_setup can sleep!");
75502ac6454SAndrew Thompson 
75602ac6454SAndrew Thompson 	/* do some checking first */
75702ac6454SAndrew Thompson 
75802ac6454SAndrew Thompson 	if (n_setup == 0) {
75902ac6454SAndrew Thompson 		DPRINTFN(6, "setup array has zero length!\n");
76002ac6454SAndrew Thompson 		return (USB_ERR_INVAL);
76102ac6454SAndrew Thompson 	}
76202ac6454SAndrew Thompson 	if (ifaces == 0) {
76302ac6454SAndrew Thompson 		DPRINTFN(6, "ifaces array is NULL!\n");
76402ac6454SAndrew Thompson 		return (USB_ERR_INVAL);
76502ac6454SAndrew Thompson 	}
76602ac6454SAndrew Thompson 	if (xfer_mtx == NULL) {
76702ac6454SAndrew Thompson 		DPRINTFN(6, "using global lock\n");
76802ac6454SAndrew Thompson 		xfer_mtx = &Giant;
76902ac6454SAndrew Thompson 	}
77002ac6454SAndrew Thompson 	/* sanity checks */
77102ac6454SAndrew Thompson 	for (setup = setup_start, n = 0;
77202ac6454SAndrew Thompson 	    setup != setup_end; setup++, n++) {
773e0a69b51SAndrew Thompson 		if (setup->bufsize == (usb_frlength_t)-1) {
77402ac6454SAndrew Thompson 			parm.err = USB_ERR_BAD_BUFSIZE;
77502ac6454SAndrew Thompson 			DPRINTF("invalid bufsize\n");
77602ac6454SAndrew Thompson 		}
7774eae601eSAndrew Thompson 		if (setup->callback == NULL) {
77802ac6454SAndrew Thompson 			parm.err = USB_ERR_NO_CALLBACK;
77902ac6454SAndrew Thompson 			DPRINTF("no callback\n");
78002ac6454SAndrew Thompson 		}
78102ac6454SAndrew Thompson 		ppxfer[n] = NULL;
78202ac6454SAndrew Thompson 	}
78302ac6454SAndrew Thompson 
78402ac6454SAndrew Thompson 	if (parm.err) {
78502ac6454SAndrew Thompson 		goto done;
78602ac6454SAndrew Thompson 	}
78702ac6454SAndrew Thompson 	bzero(&parm, sizeof(parm));
78802ac6454SAndrew Thompson 
78902ac6454SAndrew Thompson 	parm.udev = udev;
790a593f6b8SAndrew Thompson 	parm.speed = usbd_get_speed(udev);
79102ac6454SAndrew Thompson 	parm.hc_max_packet_count = 1;
79202ac6454SAndrew Thompson 
79302ac6454SAndrew Thompson 	if (parm.speed >= USB_SPEED_MAX) {
79402ac6454SAndrew Thompson 		parm.err = USB_ERR_INVAL;
79502ac6454SAndrew Thompson 		goto done;
79602ac6454SAndrew Thompson 	}
79702ac6454SAndrew Thompson 	/* setup all transfers */
79802ac6454SAndrew Thompson 
79902ac6454SAndrew Thompson 	while (1) {
80002ac6454SAndrew Thompson 
80102ac6454SAndrew Thompson 		if (buf) {
80202ac6454SAndrew Thompson 			/*
803760bc48eSAndrew Thompson 			 * Initialize the "usb_xfer_root" structure,
80402ac6454SAndrew Thompson 			 * which is common for all our USB transfers.
80502ac6454SAndrew Thompson 			 */
80602ac6454SAndrew Thompson 			info = USB_ADD_BYTES(buf, 0);
80702ac6454SAndrew Thompson 
80802ac6454SAndrew Thompson 			info->memory_base = buf;
80902ac6454SAndrew Thompson 			info->memory_size = parm.size[0];
81002ac6454SAndrew Thompson 
811bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
81202ac6454SAndrew Thompson 			info->dma_page_cache_start = USB_ADD_BYTES(buf, parm.size[4]);
81302ac6454SAndrew Thompson 			info->dma_page_cache_end = USB_ADD_BYTES(buf, parm.size[5]);
814bdc081c6SAndrew Thompson #endif
81502ac6454SAndrew Thompson 			info->xfer_page_cache_start = USB_ADD_BYTES(buf, parm.size[5]);
81602ac6454SAndrew Thompson 			info->xfer_page_cache_end = USB_ADD_BYTES(buf, parm.size[2]);
81702ac6454SAndrew Thompson 
8188437751dSAndrew Thompson 			cv_init(&info->cv_drain, "WDRAIN");
81902ac6454SAndrew Thompson 
82002ac6454SAndrew Thompson 			info->xfer_mtx = xfer_mtx;
821bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
822a593f6b8SAndrew Thompson 			usb_dma_tag_setup(&info->dma_parent_tag,
82302ac6454SAndrew Thompson 			    parm.dma_tag_p, udev->bus->dma_parent_tag[0].tag,
824a593f6b8SAndrew Thompson 			    xfer_mtx, &usb_bdma_done_event, 32, parm.dma_tag_max);
825bdc081c6SAndrew Thompson #endif
82602ac6454SAndrew Thompson 
82702ac6454SAndrew Thompson 			info->bus = udev->bus;
82802ac6454SAndrew Thompson 			info->udev = udev;
82902ac6454SAndrew Thompson 
83002ac6454SAndrew Thompson 			TAILQ_INIT(&info->done_q.head);
831a593f6b8SAndrew Thompson 			info->done_q.command = &usbd_callback_wrapper;
832bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
83302ac6454SAndrew Thompson 			TAILQ_INIT(&info->dma_q.head);
834a593f6b8SAndrew Thompson 			info->dma_q.command = &usb_bdma_work_loop;
835bdc081c6SAndrew Thompson #endif
836a593f6b8SAndrew Thompson 			info->done_m[0].hdr.pm_callback = &usb_callback_proc;
83702ac6454SAndrew Thompson 			info->done_m[0].xroot = info;
838a593f6b8SAndrew Thompson 			info->done_m[1].hdr.pm_callback = &usb_callback_proc;
83902ac6454SAndrew Thompson 			info->done_m[1].xroot = info;
84002ac6454SAndrew Thompson 
841672c9965SAndrew Thompson 			/*
842672c9965SAndrew Thompson 			 * In device side mode control endpoint
843672c9965SAndrew Thompson 			 * requests need to run from a separate
844672c9965SAndrew Thompson 			 * context, else there is a chance of
845672c9965SAndrew Thompson 			 * deadlock!
846672c9965SAndrew Thompson 			 */
847a593f6b8SAndrew Thompson 			if (setup_start == usb_control_ep_cfg)
848672c9965SAndrew Thompson 				info->done_p =
849672c9965SAndrew Thompson 				    &udev->bus->control_xfer_proc;
850672c9965SAndrew Thompson 			else if (xfer_mtx == &Giant)
85102ac6454SAndrew Thompson 				info->done_p =
85202ac6454SAndrew Thompson 				    &udev->bus->giant_callback_proc;
85302ac6454SAndrew Thompson 			else
85402ac6454SAndrew Thompson 				info->done_p =
85502ac6454SAndrew Thompson 				    &udev->bus->non_giant_callback_proc;
85602ac6454SAndrew Thompson 		}
85702ac6454SAndrew Thompson 		/* reset sizes */
85802ac6454SAndrew Thompson 
85902ac6454SAndrew Thompson 		parm.size[0] = 0;
86002ac6454SAndrew Thompson 		parm.buf = buf;
86102ac6454SAndrew Thompson 		parm.size[0] += sizeof(info[0]);
86202ac6454SAndrew Thompson 
86302ac6454SAndrew Thompson 		for (setup = setup_start, n = 0;
86402ac6454SAndrew Thompson 		    setup != setup_end; setup++, n++) {
86502ac6454SAndrew Thompson 
86602ac6454SAndrew Thompson 			/* skip USB transfers without callbacks: */
8674eae601eSAndrew Thompson 			if (setup->callback == NULL) {
86802ac6454SAndrew Thompson 				continue;
86902ac6454SAndrew Thompson 			}
87002ac6454SAndrew Thompson 			/* see if there is a matching endpoint */
871a593f6b8SAndrew Thompson 			ep = usbd_get_endpoint(udev,
87202ac6454SAndrew Thompson 			    ifaces[setup->if_index], setup);
87302ac6454SAndrew Thompson 
874ae60fdfbSAndrew Thompson 			if ((ep == NULL) || (ep->methods == NULL)) {
8754eae601eSAndrew Thompson 				if (setup->flags.no_pipe_ok)
87602ac6454SAndrew Thompson 					continue;
877f29a0724SAndrew Thompson 				if ((setup->usb_mode != USB_MODE_DUAL) &&
878f29a0724SAndrew Thompson 				    (setup->usb_mode != udev->flags.usb_mode))
8794eae601eSAndrew Thompson 					continue;
88002ac6454SAndrew Thompson 				parm.err = USB_ERR_NO_PIPE;
88102ac6454SAndrew Thompson 				goto done;
88202ac6454SAndrew Thompson 			}
88302ac6454SAndrew Thompson 
88402ac6454SAndrew Thompson 			/* align data properly */
88502ac6454SAndrew Thompson 			parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1));
88602ac6454SAndrew Thompson 
8874eae601eSAndrew Thompson 			/* store current setup pointer */
8884eae601eSAndrew Thompson 			parm.curr_setup = setup;
8894eae601eSAndrew Thompson 
89002ac6454SAndrew Thompson 			if (buf) {
89102ac6454SAndrew Thompson 				/*
89202ac6454SAndrew Thompson 				 * Common initialization of the
893760bc48eSAndrew Thompson 				 * "usb_xfer" structure.
89402ac6454SAndrew Thompson 				 */
89502ac6454SAndrew Thompson 				xfer = USB_ADD_BYTES(buf, parm.size[0]);
89602ac6454SAndrew Thompson 				xfer->address = udev->address;
89702ac6454SAndrew Thompson 				xfer->priv_sc = priv_sc;
89802ac6454SAndrew Thompson 				xfer->xroot = info;
89902ac6454SAndrew Thompson 
900a593f6b8SAndrew Thompson 				usb_callout_init_mtx(&xfer->timeout_handle,
90102ac6454SAndrew Thompson 				    &udev->bus->bus_mtx, 0);
90202ac6454SAndrew Thompson 			} else {
90302ac6454SAndrew Thompson 				/*
90402ac6454SAndrew Thompson 				 * Setup a dummy xfer, hence we are
905760bc48eSAndrew Thompson 				 * writing to the "usb_xfer"
90602ac6454SAndrew Thompson 				 * structure pointed to by "xfer"
90702ac6454SAndrew Thompson 				 * before we have allocated any
90802ac6454SAndrew Thompson 				 * memory:
90902ac6454SAndrew Thompson 				 */
91002ac6454SAndrew Thompson 				xfer = &dummy;
91102ac6454SAndrew Thompson 				bzero(&dummy, sizeof(dummy));
91202ac6454SAndrew Thompson 				refcount++;
91302ac6454SAndrew Thompson 			}
91402ac6454SAndrew Thompson 
915ae60fdfbSAndrew Thompson 			/* set transfer endpoint pointer */
916ae60fdfbSAndrew Thompson 			xfer->endpoint = ep;
91702ac6454SAndrew Thompson 
918bce32d7bSAndrew Thompson 			parm.size[0] += sizeof(xfer[0]);
919ae60fdfbSAndrew Thompson 			parm.methods = xfer->endpoint->methods;
920bce32d7bSAndrew Thompson 			parm.curr_xfer = xfer;
921bce32d7bSAndrew Thompson 
922bce32d7bSAndrew Thompson 			/*
923bce32d7bSAndrew Thompson 			 * Call the Host or Device controller transfer
924bce32d7bSAndrew Thompson 			 * setup routine:
925bce32d7bSAndrew Thompson 			 */
926bce32d7bSAndrew Thompson 			(udev->bus->methods->xfer_setup) (&parm);
927bce32d7bSAndrew Thompson 
928bce32d7bSAndrew Thompson 			/* check for error */
929bce32d7bSAndrew Thompson 			if (parm.err)
930bce32d7bSAndrew Thompson 				goto done;
931bce32d7bSAndrew Thompson 
93202ac6454SAndrew Thompson 			if (buf) {
93302ac6454SAndrew Thompson 				/*
934ae60fdfbSAndrew Thompson 				 * Increment the endpoint refcount. This
93502ac6454SAndrew Thompson 				 * basically prevents setting a new
93602ac6454SAndrew Thompson 				 * configuration and alternate setting
93702ac6454SAndrew Thompson 				 * when USB transfers are in use on
93802ac6454SAndrew Thompson 				 * the given interface. Search the USB
939ae60fdfbSAndrew Thompson 				 * code for "endpoint->refcount" if you
94002ac6454SAndrew Thompson 				 * want more information.
94102ac6454SAndrew Thompson 				 */
942ae60fdfbSAndrew Thompson 				xfer->endpoint->refcount++;
94302ac6454SAndrew Thompson 
94402ac6454SAndrew Thompson 				/*
945bce32d7bSAndrew Thompson 				 * Whenever we set ppxfer[] then we
946bce32d7bSAndrew Thompson 				 * also need to increment the
947bce32d7bSAndrew Thompson 				 * "setup_refcount":
94802ac6454SAndrew Thompson 				 */
949bce32d7bSAndrew Thompson 				info->setup_refcount++;
95002ac6454SAndrew Thompson 
951bce32d7bSAndrew Thompson 				/*
952bce32d7bSAndrew Thompson 				 * Transfer is successfully setup and
953bce32d7bSAndrew Thompson 				 * can be used:
954bce32d7bSAndrew Thompson 				 */
955bce32d7bSAndrew Thompson 				ppxfer[n] = xfer;
95602ac6454SAndrew Thompson 			}
95702ac6454SAndrew Thompson 		}
95802ac6454SAndrew Thompson 
95902ac6454SAndrew Thompson 		if (buf || parm.err) {
96002ac6454SAndrew Thompson 			goto done;
96102ac6454SAndrew Thompson 		}
96202ac6454SAndrew Thompson 		if (refcount == 0) {
96302ac6454SAndrew Thompson 			/* no transfers - nothing to do ! */
96402ac6454SAndrew Thompson 			goto done;
96502ac6454SAndrew Thompson 		}
96602ac6454SAndrew Thompson 		/* align data properly */
96702ac6454SAndrew Thompson 		parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1));
96802ac6454SAndrew Thompson 
96902ac6454SAndrew Thompson 		/* store offset temporarily */
97002ac6454SAndrew Thompson 		parm.size[1] = parm.size[0];
97102ac6454SAndrew Thompson 
97202ac6454SAndrew Thompson 		/*
97302ac6454SAndrew Thompson 		 * The number of DMA tags required depends on
97402ac6454SAndrew Thompson 		 * the number of endpoints. The current estimate
97502ac6454SAndrew Thompson 		 * for maximum number of DMA tags per endpoint
97602ac6454SAndrew Thompson 		 * is two.
97702ac6454SAndrew Thompson 		 */
97802ac6454SAndrew Thompson 		parm.dma_tag_max += 2 * MIN(n_setup, USB_EP_MAX);
97902ac6454SAndrew Thompson 
98002ac6454SAndrew Thompson 		/*
98102ac6454SAndrew Thompson 		 * DMA tags for QH, TD, Data and more.
98202ac6454SAndrew Thompson 		 */
98302ac6454SAndrew Thompson 		parm.dma_tag_max += 8;
98402ac6454SAndrew Thompson 
98502ac6454SAndrew Thompson 		parm.dma_tag_p += parm.dma_tag_max;
98602ac6454SAndrew Thompson 
98702ac6454SAndrew Thompson 		parm.size[0] += ((uint8_t *)parm.dma_tag_p) -
98802ac6454SAndrew Thompson 		    ((uint8_t *)0);
98902ac6454SAndrew Thompson 
99002ac6454SAndrew Thompson 		/* align data properly */
99102ac6454SAndrew Thompson 		parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1));
99202ac6454SAndrew Thompson 
99302ac6454SAndrew Thompson 		/* store offset temporarily */
99402ac6454SAndrew Thompson 		parm.size[3] = parm.size[0];
99502ac6454SAndrew Thompson 
99602ac6454SAndrew Thompson 		parm.size[0] += ((uint8_t *)parm.dma_page_ptr) -
99702ac6454SAndrew Thompson 		    ((uint8_t *)0);
99802ac6454SAndrew Thompson 
99902ac6454SAndrew Thompson 		/* align data properly */
100002ac6454SAndrew Thompson 		parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1));
100102ac6454SAndrew Thompson 
100202ac6454SAndrew Thompson 		/* store offset temporarily */
100302ac6454SAndrew Thompson 		parm.size[4] = parm.size[0];
100402ac6454SAndrew Thompson 
100502ac6454SAndrew Thompson 		parm.size[0] += ((uint8_t *)parm.dma_page_cache_ptr) -
100602ac6454SAndrew Thompson 		    ((uint8_t *)0);
100702ac6454SAndrew Thompson 
100802ac6454SAndrew Thompson 		/* store end offset temporarily */
100902ac6454SAndrew Thompson 		parm.size[5] = parm.size[0];
101002ac6454SAndrew Thompson 
101102ac6454SAndrew Thompson 		parm.size[0] += ((uint8_t *)parm.xfer_page_cache_ptr) -
101202ac6454SAndrew Thompson 		    ((uint8_t *)0);
101302ac6454SAndrew Thompson 
101402ac6454SAndrew Thompson 		/* store end offset temporarily */
101502ac6454SAndrew Thompson 
101602ac6454SAndrew Thompson 		parm.size[2] = parm.size[0];
101702ac6454SAndrew Thompson 
101802ac6454SAndrew Thompson 		/* align data properly */
101902ac6454SAndrew Thompson 		parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1));
102002ac6454SAndrew Thompson 
102102ac6454SAndrew Thompson 		parm.size[6] = parm.size[0];
102202ac6454SAndrew Thompson 
102302ac6454SAndrew Thompson 		parm.size[0] += ((uint8_t *)parm.xfer_length_ptr) -
102402ac6454SAndrew Thompson 		    ((uint8_t *)0);
102502ac6454SAndrew Thompson 
102602ac6454SAndrew Thompson 		/* align data properly */
102702ac6454SAndrew Thompson 		parm.size[0] += ((-parm.size[0]) & (USB_HOST_ALIGN - 1));
102802ac6454SAndrew Thompson 
102902ac6454SAndrew Thompson 		/* allocate zeroed memory */
103002ac6454SAndrew Thompson 		buf = malloc(parm.size[0], M_USB, M_WAITOK | M_ZERO);
103102ac6454SAndrew Thompson 
103202ac6454SAndrew Thompson 		if (buf == NULL) {
103302ac6454SAndrew Thompson 			parm.err = USB_ERR_NOMEM;
103402ac6454SAndrew Thompson 			DPRINTFN(0, "cannot allocate memory block for "
103502ac6454SAndrew Thompson 			    "configuration (%d bytes)\n",
103602ac6454SAndrew Thompson 			    parm.size[0]);
103702ac6454SAndrew Thompson 			goto done;
103802ac6454SAndrew Thompson 		}
103902ac6454SAndrew Thompson 		parm.dma_tag_p = USB_ADD_BYTES(buf, parm.size[1]);
104002ac6454SAndrew Thompson 		parm.dma_page_ptr = USB_ADD_BYTES(buf, parm.size[3]);
104102ac6454SAndrew Thompson 		parm.dma_page_cache_ptr = USB_ADD_BYTES(buf, parm.size[4]);
104202ac6454SAndrew Thompson 		parm.xfer_page_cache_ptr = USB_ADD_BYTES(buf, parm.size[5]);
104302ac6454SAndrew Thompson 		parm.xfer_length_ptr = USB_ADD_BYTES(buf, parm.size[6]);
104402ac6454SAndrew Thompson 	}
104502ac6454SAndrew Thompson 
104602ac6454SAndrew Thompson done:
104702ac6454SAndrew Thompson 	if (buf) {
104802ac6454SAndrew Thompson 		if (info->setup_refcount == 0) {
104902ac6454SAndrew Thompson 			/*
1050a593f6b8SAndrew Thompson 			 * "usbd_transfer_unsetup_sub" will unlock
105102ac6454SAndrew Thompson 			 * the bus mutex before returning !
105202ac6454SAndrew Thompson 			 */
105302ac6454SAndrew Thompson 			USB_BUS_LOCK(info->bus);
105402ac6454SAndrew Thompson 
105502ac6454SAndrew Thompson 			/* something went wrong */
1056a593f6b8SAndrew Thompson 			usbd_transfer_unsetup_sub(info, 0);
105702ac6454SAndrew Thompson 		}
105802ac6454SAndrew Thompson 	}
105902ac6454SAndrew Thompson 	if (parm.err) {
1060a593f6b8SAndrew Thompson 		usbd_transfer_unsetup(ppxfer, n_setup);
106102ac6454SAndrew Thompson 	}
106202ac6454SAndrew Thompson 	return (parm.err);
106302ac6454SAndrew Thompson }
106402ac6454SAndrew Thompson 
106502ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1066a593f6b8SAndrew Thompson  *	usbd_transfer_unsetup_sub - factored out code
106702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
106802ac6454SAndrew Thompson static void
1069a593f6b8SAndrew Thompson usbd_transfer_unsetup_sub(struct usb_xfer_root *info, uint8_t needs_delay)
107002ac6454SAndrew Thompson {
1071760bc48eSAndrew Thompson 	struct usb_page_cache *pc;
107202ac6454SAndrew Thompson 
107302ac6454SAndrew Thompson 	USB_BUS_LOCK_ASSERT(info->bus, MA_OWNED);
107402ac6454SAndrew Thompson 
107502ac6454SAndrew Thompson 	/* wait for any outstanding DMA operations */
107602ac6454SAndrew Thompson 
107702ac6454SAndrew Thompson 	if (needs_delay) {
1078e0a69b51SAndrew Thompson 		usb_timeout_t temp;
1079a593f6b8SAndrew Thompson 		temp = usbd_get_dma_delay(info->bus);
1080a593f6b8SAndrew Thompson 		usb_pause_mtx(&info->bus->bus_mtx,
108102ac6454SAndrew Thompson 		    USB_MS_TO_TICKS(temp));
108202ac6454SAndrew Thompson 	}
108302ac6454SAndrew Thompson 
108402ac6454SAndrew Thompson 	/* make sure that our done messages are not queued anywhere */
1085a593f6b8SAndrew Thompson 	usb_proc_mwait(info->done_p, &info->done_m[0], &info->done_m[1]);
108602ac6454SAndrew Thompson 
108702ac6454SAndrew Thompson 	USB_BUS_UNLOCK(info->bus);
108802ac6454SAndrew Thompson 
1089bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
109002ac6454SAndrew Thompson 	/* free DMA'able memory, if any */
109102ac6454SAndrew Thompson 	pc = info->dma_page_cache_start;
109202ac6454SAndrew Thompson 	while (pc != info->dma_page_cache_end) {
1093a593f6b8SAndrew Thompson 		usb_pc_free_mem(pc);
109402ac6454SAndrew Thompson 		pc++;
109502ac6454SAndrew Thompson 	}
109602ac6454SAndrew Thompson 
109702ac6454SAndrew Thompson 	/* free DMA maps in all "xfer->frbuffers" */
109802ac6454SAndrew Thompson 	pc = info->xfer_page_cache_start;
109902ac6454SAndrew Thompson 	while (pc != info->xfer_page_cache_end) {
1100a593f6b8SAndrew Thompson 		usb_pc_dmamap_destroy(pc);
110102ac6454SAndrew Thompson 		pc++;
110202ac6454SAndrew Thompson 	}
110302ac6454SAndrew Thompson 
110402ac6454SAndrew Thompson 	/* free all DMA tags */
1105a593f6b8SAndrew Thompson 	usb_dma_tag_unsetup(&info->dma_parent_tag);
1106bdc081c6SAndrew Thompson #endif
110702ac6454SAndrew Thompson 
11088437751dSAndrew Thompson 	cv_destroy(&info->cv_drain);
110902ac6454SAndrew Thompson 
111002ac6454SAndrew Thompson 	/*
111102ac6454SAndrew Thompson 	 * free the "memory_base" last, hence the "info" structure is
111202ac6454SAndrew Thompson 	 * contained within the "memory_base"!
111302ac6454SAndrew Thompson 	 */
111402ac6454SAndrew Thompson 	free(info->memory_base, M_USB);
111502ac6454SAndrew Thompson }
111602ac6454SAndrew Thompson 
111702ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1118a593f6b8SAndrew Thompson  *	usbd_transfer_unsetup - unsetup/free an array of USB transfers
111902ac6454SAndrew Thompson  *
112002ac6454SAndrew Thompson  * NOTE: All USB transfers in progress will get called back passing
112102ac6454SAndrew Thompson  * the error code "USB_ERR_CANCELLED" before this function
112202ac6454SAndrew Thompson  * returns.
112302ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
112402ac6454SAndrew Thompson void
1125a593f6b8SAndrew Thompson usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
112602ac6454SAndrew Thompson {
1127760bc48eSAndrew Thompson 	struct usb_xfer *xfer;
1128760bc48eSAndrew Thompson 	struct usb_xfer_root *info;
112902ac6454SAndrew Thompson 	uint8_t needs_delay = 0;
113002ac6454SAndrew Thompson 
113102ac6454SAndrew Thompson 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1132a593f6b8SAndrew Thompson 	    "usbd_transfer_unsetup can sleep!");
113302ac6454SAndrew Thompson 
113402ac6454SAndrew Thompson 	while (n_setup--) {
113502ac6454SAndrew Thompson 		xfer = pxfer[n_setup];
113602ac6454SAndrew Thompson 
1137bce32d7bSAndrew Thompson 		if (xfer == NULL)
1138bce32d7bSAndrew Thompson 			continue;
1139bce32d7bSAndrew Thompson 
1140bce32d7bSAndrew Thompson 		info = xfer->xroot;
1141bce32d7bSAndrew Thompson 
114202ac6454SAndrew Thompson 		USB_XFER_LOCK(xfer);
1143bce32d7bSAndrew Thompson 		USB_BUS_LOCK(info->bus);
114402ac6454SAndrew Thompson 
114502ac6454SAndrew Thompson 		/*
1146bce32d7bSAndrew Thompson 		 * HINT: when you start/stop a transfer, it might be a
1147bce32d7bSAndrew Thompson 		 * good idea to directly use the "pxfer[]" structure:
114802ac6454SAndrew Thompson 		 *
1149a593f6b8SAndrew Thompson 		 * usbd_transfer_start(sc->pxfer[0]);
1150a593f6b8SAndrew Thompson 		 * usbd_transfer_stop(sc->pxfer[0]);
115102ac6454SAndrew Thompson 		 *
1152bce32d7bSAndrew Thompson 		 * That way, if your code has many parts that will not
1153bce32d7bSAndrew Thompson 		 * stop running under the same lock, in other words
1154a593f6b8SAndrew Thompson 		 * "xfer_mtx", the usbd_transfer_start and
1155a593f6b8SAndrew Thompson 		 * usbd_transfer_stop functions will simply return
1156bce32d7bSAndrew Thompson 		 * when they detect a NULL pointer argument.
115702ac6454SAndrew Thompson 		 *
1158bce32d7bSAndrew Thompson 		 * To avoid any races we clear the "pxfer[]" pointer
1159bce32d7bSAndrew Thompson 		 * while holding the private mutex of the driver:
116002ac6454SAndrew Thompson 		 */
116102ac6454SAndrew Thompson 		pxfer[n_setup] = NULL;
116202ac6454SAndrew Thompson 
1163bce32d7bSAndrew Thompson 		USB_BUS_UNLOCK(info->bus);
116402ac6454SAndrew Thompson 		USB_XFER_UNLOCK(xfer);
116502ac6454SAndrew Thompson 
1166a593f6b8SAndrew Thompson 		usbd_transfer_drain(xfer);
116702ac6454SAndrew Thompson 
1168bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
1169bce32d7bSAndrew Thompson 		if (xfer->flags_int.bdma_enable)
117002ac6454SAndrew Thompson 			needs_delay = 1;
1171bdc081c6SAndrew Thompson #endif
117202ac6454SAndrew Thompson 		/*
1173ae60fdfbSAndrew Thompson 		 * NOTE: default endpoint does not have an
1174ae60fdfbSAndrew Thompson 		 * interface, even if endpoint->iface_index == 0
117502ac6454SAndrew Thompson 		 */
1176ae60fdfbSAndrew Thompson 		xfer->endpoint->refcount--;
117702ac6454SAndrew Thompson 
1178a593f6b8SAndrew Thompson 		usb_callout_drain(&xfer->timeout_handle);
117902ac6454SAndrew Thompson 
118002ac6454SAndrew Thompson 		USB_BUS_LOCK(info->bus);
118102ac6454SAndrew Thompson 
1182bce32d7bSAndrew Thompson 		USB_ASSERT(info->setup_refcount != 0, ("Invalid setup "
118302ac6454SAndrew Thompson 		    "reference count!\n"));
118402ac6454SAndrew Thompson 
118502ac6454SAndrew Thompson 		info->setup_refcount--;
118602ac6454SAndrew Thompson 
118702ac6454SAndrew Thompson 		if (info->setup_refcount == 0) {
1188a593f6b8SAndrew Thompson 			usbd_transfer_unsetup_sub(info,
118902ac6454SAndrew Thompson 			    needs_delay);
119002ac6454SAndrew Thompson 		} else {
119102ac6454SAndrew Thompson 			USB_BUS_UNLOCK(info->bus);
119202ac6454SAndrew Thompson 		}
119302ac6454SAndrew Thompson 	}
119402ac6454SAndrew Thompson }
119502ac6454SAndrew Thompson 
119602ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1197a593f6b8SAndrew Thompson  *	usbd_control_transfer_init - factored out code
119802ac6454SAndrew Thompson  *
119902ac6454SAndrew Thompson  * In USB Device Mode we have to wait for the SETUP packet which
1200760bc48eSAndrew Thompson  * containst the "struct usb_device_request" structure, before we can
120102ac6454SAndrew Thompson  * transfer any data. In USB Host Mode we already have the SETUP
120202ac6454SAndrew Thompson  * packet at the moment the USB transfer is started. This leads us to
120302ac6454SAndrew Thompson  * having to setup the USB transfer at two different places in
120402ac6454SAndrew Thompson  * time. This function just contains factored out control transfer
120502ac6454SAndrew Thompson  * initialisation code, so that we don't duplicate the code.
120602ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
120702ac6454SAndrew Thompson static void
1208a593f6b8SAndrew Thompson usbd_control_transfer_init(struct usb_xfer *xfer)
120902ac6454SAndrew Thompson {
1210760bc48eSAndrew Thompson 	struct usb_device_request req;
121102ac6454SAndrew Thompson 
121202ac6454SAndrew Thompson 	/* copy out the USB request header */
121302ac6454SAndrew Thompson 
1214a593f6b8SAndrew Thompson 	usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
121502ac6454SAndrew Thompson 
121602ac6454SAndrew Thompson 	/* setup remainder */
121702ac6454SAndrew Thompson 
121802ac6454SAndrew Thompson 	xfer->flags_int.control_rem = UGETW(req.wLength);
121902ac6454SAndrew Thompson 
122002ac6454SAndrew Thompson 	/* copy direction to endpoint variable */
122102ac6454SAndrew Thompson 
1222ae60fdfbSAndrew Thompson 	xfer->endpointno &= ~(UE_DIR_IN | UE_DIR_OUT);
1223ae60fdfbSAndrew Thompson 	xfer->endpointno |=
122402ac6454SAndrew Thompson 	    (req.bmRequestType & UT_READ) ? UE_DIR_IN : UE_DIR_OUT;
122502ac6454SAndrew Thompson }
122602ac6454SAndrew Thompson 
122702ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1228ed6d949aSAndrew Thompson  *	usbd_setup_ctrl_transfer
122902ac6454SAndrew Thompson  *
123002ac6454SAndrew Thompson  * This function handles initialisation of control transfers. Control
123102ac6454SAndrew Thompson  * transfers are special in that regard that they can both transmit
123202ac6454SAndrew Thompson  * and receive data.
123302ac6454SAndrew Thompson  *
123402ac6454SAndrew Thompson  * Return values:
123502ac6454SAndrew Thompson  *    0: Success
123602ac6454SAndrew Thompson  * Else: Failure
123702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
1238ed6d949aSAndrew Thompson static int
1239ed6d949aSAndrew Thompson usbd_setup_ctrl_transfer(struct usb_xfer *xfer)
124002ac6454SAndrew Thompson {
1241e0a69b51SAndrew Thompson 	usb_frlength_t len;
124202ac6454SAndrew Thompson 
124302ac6454SAndrew Thompson 	/* Check for control endpoint stall */
1244476183dfSAndrew Thompson 	if (xfer->flags.stall_pipe && xfer->flags_int.control_act) {
1245476183dfSAndrew Thompson 		/* the control transfer is no longer active */
1246476183dfSAndrew Thompson 		xfer->flags_int.control_stall = 1;
124702ac6454SAndrew Thompson 		xfer->flags_int.control_act = 0;
1248476183dfSAndrew Thompson 	} else {
1249476183dfSAndrew Thompson 		/* don't stall control transfer by default */
1250476183dfSAndrew Thompson 		xfer->flags_int.control_stall = 0;
125102ac6454SAndrew Thompson 	}
1252e1ccac96SAndrew Thompson 
1253e1ccac96SAndrew Thompson 	/* Check for invalid number of frames */
1254e1ccac96SAndrew Thompson 	if (xfer->nframes > 2) {
1255e1ccac96SAndrew Thompson 		/*
1256e1ccac96SAndrew Thompson 		 * If you need to split a control transfer, you
1257e1ccac96SAndrew Thompson 		 * have to do one part at a time. Only with
1258e1ccac96SAndrew Thompson 		 * non-control transfers you can do multiple
1259e1ccac96SAndrew Thompson 		 * parts a time.
1260e1ccac96SAndrew Thompson 		 */
1261e1ccac96SAndrew Thompson 		DPRINTFN(0, "Too many frames: %u\n",
1262e1ccac96SAndrew Thompson 		    (unsigned int)xfer->nframes);
1263e1ccac96SAndrew Thompson 		goto error;
1264e1ccac96SAndrew Thompson 	}
1265e1ccac96SAndrew Thompson 
126602ac6454SAndrew Thompson 	/*
126702ac6454SAndrew Thompson          * Check if there is a control
126802ac6454SAndrew Thompson          * transfer in progress:
126902ac6454SAndrew Thompson          */
127002ac6454SAndrew Thompson 	if (xfer->flags_int.control_act) {
127102ac6454SAndrew Thompson 
127202ac6454SAndrew Thompson 		if (xfer->flags_int.control_hdr) {
127302ac6454SAndrew Thompson 
127402ac6454SAndrew Thompson 			/* clear send header flag */
127502ac6454SAndrew Thompson 
127602ac6454SAndrew Thompson 			xfer->flags_int.control_hdr = 0;
127702ac6454SAndrew Thompson 
127802ac6454SAndrew Thompson 			/* setup control transfer */
1279f29a0724SAndrew Thompson 			if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
1280a593f6b8SAndrew Thompson 				usbd_control_transfer_init(xfer);
128102ac6454SAndrew Thompson 			}
128202ac6454SAndrew Thompson 		}
128302ac6454SAndrew Thompson 		/* get data length */
128402ac6454SAndrew Thompson 
128502ac6454SAndrew Thompson 		len = xfer->sumlen;
128602ac6454SAndrew Thompson 
128702ac6454SAndrew Thompson 	} else {
128802ac6454SAndrew Thompson 
128902ac6454SAndrew Thompson 		/* the size of the SETUP structure is hardcoded ! */
129002ac6454SAndrew Thompson 
1291760bc48eSAndrew Thompson 		if (xfer->frlengths[0] != sizeof(struct usb_device_request)) {
129202ac6454SAndrew Thompson 			DPRINTFN(0, "Wrong framelength %u != %zu\n",
129302ac6454SAndrew Thompson 			    xfer->frlengths[0], sizeof(struct
1294760bc48eSAndrew Thompson 			    usb_device_request));
129502ac6454SAndrew Thompson 			goto error;
129602ac6454SAndrew Thompson 		}
129702ac6454SAndrew Thompson 		/* check USB mode */
1298f29a0724SAndrew Thompson 		if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
129902ac6454SAndrew Thompson 
130002ac6454SAndrew Thompson 			/* check number of frames */
130102ac6454SAndrew Thompson 			if (xfer->nframes != 1) {
130202ac6454SAndrew Thompson 				/*
130302ac6454SAndrew Thompson 			         * We need to receive the setup
130402ac6454SAndrew Thompson 			         * message first so that we know the
130502ac6454SAndrew Thompson 			         * data direction!
130602ac6454SAndrew Thompson 			         */
130702ac6454SAndrew Thompson 				DPRINTF("Misconfigured transfer\n");
130802ac6454SAndrew Thompson 				goto error;
130902ac6454SAndrew Thompson 			}
131002ac6454SAndrew Thompson 			/*
131102ac6454SAndrew Thompson 			 * Set a dummy "control_rem" value.  This
131202ac6454SAndrew Thompson 			 * variable will be overwritten later by a
1313a593f6b8SAndrew Thompson 			 * call to "usbd_control_transfer_init()" !
131402ac6454SAndrew Thompson 			 */
131502ac6454SAndrew Thompson 			xfer->flags_int.control_rem = 0xFFFF;
131602ac6454SAndrew Thompson 		} else {
131702ac6454SAndrew Thompson 
131802ac6454SAndrew Thompson 			/* setup "endpoint" and "control_rem" */
131902ac6454SAndrew Thompson 
1320a593f6b8SAndrew Thompson 			usbd_control_transfer_init(xfer);
132102ac6454SAndrew Thompson 		}
132202ac6454SAndrew Thompson 
132302ac6454SAndrew Thompson 		/* set transfer-header flag */
132402ac6454SAndrew Thompson 
132502ac6454SAndrew Thompson 		xfer->flags_int.control_hdr = 1;
132602ac6454SAndrew Thompson 
132702ac6454SAndrew Thompson 		/* get data length */
132802ac6454SAndrew Thompson 
1329760bc48eSAndrew Thompson 		len = (xfer->sumlen - sizeof(struct usb_device_request));
133002ac6454SAndrew Thompson 	}
133102ac6454SAndrew Thompson 
133202ac6454SAndrew Thompson 	/* check if there is a length mismatch */
133302ac6454SAndrew Thompson 
133402ac6454SAndrew Thompson 	if (len > xfer->flags_int.control_rem) {
1335a8725281SAndrew Thompson 		DPRINTFN(0, "Length (%d) greater than "
1336a8725281SAndrew Thompson 		    "remaining length (%d)!\n", len,
1337a8725281SAndrew Thompson 		    xfer->flags_int.control_rem);
133802ac6454SAndrew Thompson 		goto error;
133902ac6454SAndrew Thompson 	}
134002ac6454SAndrew Thompson 	/* check if we are doing a short transfer */
134102ac6454SAndrew Thompson 
134202ac6454SAndrew Thompson 	if (xfer->flags.force_short_xfer) {
134302ac6454SAndrew Thompson 		xfer->flags_int.control_rem = 0;
134402ac6454SAndrew Thompson 	} else {
134502ac6454SAndrew Thompson 		if ((len != xfer->max_data_length) &&
134602ac6454SAndrew Thompson 		    (len != xfer->flags_int.control_rem) &&
134702ac6454SAndrew Thompson 		    (xfer->nframes != 1)) {
134802ac6454SAndrew Thompson 			DPRINTFN(0, "Short control transfer without "
134902ac6454SAndrew Thompson 			    "force_short_xfer set!\n");
135002ac6454SAndrew Thompson 			goto error;
135102ac6454SAndrew Thompson 		}
135202ac6454SAndrew Thompson 		xfer->flags_int.control_rem -= len;
135302ac6454SAndrew Thompson 	}
135402ac6454SAndrew Thompson 
135502ac6454SAndrew Thompson 	/* the status part is executed when "control_act" is 0 */
135602ac6454SAndrew Thompson 
135702ac6454SAndrew Thompson 	if ((xfer->flags_int.control_rem > 0) ||
135802ac6454SAndrew Thompson 	    (xfer->flags.manual_status)) {
135902ac6454SAndrew Thompson 		/* don't execute the STATUS stage yet */
136002ac6454SAndrew Thompson 		xfer->flags_int.control_act = 1;
136102ac6454SAndrew Thompson 
136202ac6454SAndrew Thompson 		/* sanity check */
136302ac6454SAndrew Thompson 		if ((!xfer->flags_int.control_hdr) &&
136402ac6454SAndrew Thompson 		    (xfer->nframes == 1)) {
136502ac6454SAndrew Thompson 			/*
136602ac6454SAndrew Thompson 		         * This is not a valid operation!
136702ac6454SAndrew Thompson 		         */
136802ac6454SAndrew Thompson 			DPRINTFN(0, "Invalid parameter "
136902ac6454SAndrew Thompson 			    "combination\n");
137002ac6454SAndrew Thompson 			goto error;
137102ac6454SAndrew Thompson 		}
137202ac6454SAndrew Thompson 	} else {
137302ac6454SAndrew Thompson 		/* time to execute the STATUS stage */
137402ac6454SAndrew Thompson 		xfer->flags_int.control_act = 0;
137502ac6454SAndrew Thompson 	}
137602ac6454SAndrew Thompson 	return (0);			/* success */
137702ac6454SAndrew Thompson 
137802ac6454SAndrew Thompson error:
137902ac6454SAndrew Thompson 	return (1);			/* failure */
138002ac6454SAndrew Thompson }
138102ac6454SAndrew Thompson 
138202ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1383a593f6b8SAndrew Thompson  *	usbd_transfer_submit - start USB hardware for the given transfer
138402ac6454SAndrew Thompson  *
138502ac6454SAndrew Thompson  * This function should only be called from the USB callback.
138602ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
138702ac6454SAndrew Thompson void
1388a593f6b8SAndrew Thompson usbd_transfer_submit(struct usb_xfer *xfer)
138902ac6454SAndrew Thompson {
1390760bc48eSAndrew Thompson 	struct usb_xfer_root *info;
1391760bc48eSAndrew Thompson 	struct usb_bus *bus;
1392e0a69b51SAndrew Thompson 	usb_frcount_t x;
139302ac6454SAndrew Thompson 
1394bd216778SAndrew Thompson 	info = xfer->xroot;
1395bd216778SAndrew Thompson 	bus = info->bus;
1396bd216778SAndrew Thompson 
1397ae60fdfbSAndrew Thompson 	DPRINTF("xfer=%p, endpoint=%p, nframes=%d, dir=%s\n",
1398ae60fdfbSAndrew Thompson 	    xfer, xfer->endpoint, xfer->nframes, USB_GET_DATA_ISREAD(xfer) ?
139902ac6454SAndrew Thompson 	    "read" : "write");
140002ac6454SAndrew Thompson 
140102ac6454SAndrew Thompson #if USB_DEBUG
140202ac6454SAndrew Thompson 	if (USB_DEBUG_VAR > 0) {
1403bd216778SAndrew Thompson 		USB_BUS_LOCK(bus);
140402ac6454SAndrew Thompson 
1405a593f6b8SAndrew Thompson 		usb_dump_endpoint(xfer->endpoint);
140602ac6454SAndrew Thompson 
1407bd216778SAndrew Thompson 		USB_BUS_UNLOCK(bus);
140802ac6454SAndrew Thompson 	}
140902ac6454SAndrew Thompson #endif
141002ac6454SAndrew Thompson 
141102ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
1412bd216778SAndrew Thompson 	USB_BUS_LOCK_ASSERT(bus, MA_NOTOWNED);
141302ac6454SAndrew Thompson 
141402ac6454SAndrew Thompson 	/* Only open the USB transfer once! */
141502ac6454SAndrew Thompson 	if (!xfer->flags_int.open) {
141602ac6454SAndrew Thompson 		xfer->flags_int.open = 1;
141702ac6454SAndrew Thompson 
141802ac6454SAndrew Thompson 		DPRINTF("open\n");
141902ac6454SAndrew Thompson 
1420bd216778SAndrew Thompson 		USB_BUS_LOCK(bus);
1421ae60fdfbSAndrew Thompson 		(xfer->endpoint->methods->open) (xfer);
1422bd216778SAndrew Thompson 		USB_BUS_UNLOCK(bus);
142302ac6454SAndrew Thompson 	}
142402ac6454SAndrew Thompson 	/* set "transferring" flag */
142502ac6454SAndrew Thompson 	xfer->flags_int.transferring = 1;
142602ac6454SAndrew Thompson 
14274eae601eSAndrew Thompson #if USB_HAVE_POWERD
142802ac6454SAndrew Thompson 	/* increment power reference */
1429a593f6b8SAndrew Thompson 	usbd_transfer_power_ref(xfer, 1);
14304eae601eSAndrew Thompson #endif
143102ac6454SAndrew Thompson 	/*
143202ac6454SAndrew Thompson 	 * Check if the transfer is waiting on a queue, most
143302ac6454SAndrew Thompson 	 * frequently the "done_q":
143402ac6454SAndrew Thompson 	 */
143502ac6454SAndrew Thompson 	if (xfer->wait_queue) {
1436bd216778SAndrew Thompson 		USB_BUS_LOCK(bus);
1437a593f6b8SAndrew Thompson 		usbd_transfer_dequeue(xfer);
1438bd216778SAndrew Thompson 		USB_BUS_UNLOCK(bus);
143902ac6454SAndrew Thompson 	}
144002ac6454SAndrew Thompson 	/* clear "did_dma_delay" flag */
144102ac6454SAndrew Thompson 	xfer->flags_int.did_dma_delay = 0;
144202ac6454SAndrew Thompson 
144302ac6454SAndrew Thompson 	/* clear "did_close" flag */
144402ac6454SAndrew Thompson 	xfer->flags_int.did_close = 0;
144502ac6454SAndrew Thompson 
1446bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
144702ac6454SAndrew Thompson 	/* clear "bdma_setup" flag */
144802ac6454SAndrew Thompson 	xfer->flags_int.bdma_setup = 0;
1449bdc081c6SAndrew Thompson #endif
145002ac6454SAndrew Thompson 	/* by default we cannot cancel any USB transfer immediately */
145102ac6454SAndrew Thompson 	xfer->flags_int.can_cancel_immed = 0;
145202ac6454SAndrew Thompson 
145302ac6454SAndrew Thompson 	/* clear lengths and frame counts by default */
145402ac6454SAndrew Thompson 	xfer->sumlen = 0;
145502ac6454SAndrew Thompson 	xfer->actlen = 0;
145602ac6454SAndrew Thompson 	xfer->aframes = 0;
145702ac6454SAndrew Thompson 
145802ac6454SAndrew Thompson 	/* clear any previous errors */
145902ac6454SAndrew Thompson 	xfer->error = 0;
146002ac6454SAndrew Thompson 
1461ec8f3127SAndrew Thompson 	/* Check if the device is still alive */
1462ec8f3127SAndrew Thompson 	if (info->udev->state < USB_STATE_POWERED) {
1463ec8f3127SAndrew Thompson 		USB_BUS_LOCK(bus);
1464f1f88408SAndrew Thompson 		/*
1465f1f88408SAndrew Thompson 		 * Must return cancelled error code else
1466f1f88408SAndrew Thompson 		 * device drivers can hang.
1467f1f88408SAndrew Thompson 		 */
1468a593f6b8SAndrew Thompson 		usbd_transfer_done(xfer, USB_ERR_CANCELLED);
1469ec8f3127SAndrew Thompson 		USB_BUS_UNLOCK(bus);
1470ec8f3127SAndrew Thompson 		return;
1471ec8f3127SAndrew Thompson 	}
147202ac6454SAndrew Thompson 
1473ec8f3127SAndrew Thompson 	/* sanity check */
147402ac6454SAndrew Thompson 	if (xfer->nframes == 0) {
147502ac6454SAndrew Thompson 		if (xfer->flags.stall_pipe) {
147602ac6454SAndrew Thompson 			/*
147702ac6454SAndrew Thompson 			 * Special case - want to stall without transferring
147802ac6454SAndrew Thompson 			 * any data:
147902ac6454SAndrew Thompson 			 */
148002ac6454SAndrew Thompson 			DPRINTF("xfer=%p nframes=0: stall "
148102ac6454SAndrew Thompson 			    "or clear stall!\n", xfer);
1482bd216778SAndrew Thompson 			USB_BUS_LOCK(bus);
148302ac6454SAndrew Thompson 			xfer->flags_int.can_cancel_immed = 1;
148402ac6454SAndrew Thompson 			/* start the transfer */
1485a593f6b8SAndrew Thompson 			usb_command_wrapper(&xfer->endpoint->endpoint_q, xfer);
1486bd216778SAndrew Thompson 			USB_BUS_UNLOCK(bus);
148702ac6454SAndrew Thompson 			return;
148802ac6454SAndrew Thompson 		}
1489bd216778SAndrew Thompson 		USB_BUS_LOCK(bus);
1490a593f6b8SAndrew Thompson 		usbd_transfer_done(xfer, USB_ERR_INVAL);
1491bd216778SAndrew Thompson 		USB_BUS_UNLOCK(bus);
149202ac6454SAndrew Thompson 		return;
149302ac6454SAndrew Thompson 	}
149402ac6454SAndrew Thompson 	/* compute total transfer length */
149502ac6454SAndrew Thompson 
149602ac6454SAndrew Thompson 	for (x = 0; x != xfer->nframes; x++) {
149702ac6454SAndrew Thompson 		xfer->sumlen += xfer->frlengths[x];
149802ac6454SAndrew Thompson 		if (xfer->sumlen < xfer->frlengths[x]) {
149902ac6454SAndrew Thompson 			/* length wrapped around */
1500bd216778SAndrew Thompson 			USB_BUS_LOCK(bus);
1501a593f6b8SAndrew Thompson 			usbd_transfer_done(xfer, USB_ERR_INVAL);
1502bd216778SAndrew Thompson 			USB_BUS_UNLOCK(bus);
150302ac6454SAndrew Thompson 			return;
150402ac6454SAndrew Thompson 		}
150502ac6454SAndrew Thompson 	}
150602ac6454SAndrew Thompson 
150702ac6454SAndrew Thompson 	/* clear some internal flags */
150802ac6454SAndrew Thompson 
150902ac6454SAndrew Thompson 	xfer->flags_int.short_xfer_ok = 0;
151002ac6454SAndrew Thompson 	xfer->flags_int.short_frames_ok = 0;
151102ac6454SAndrew Thompson 
151202ac6454SAndrew Thompson 	/* check if this is a control transfer */
151302ac6454SAndrew Thompson 
151402ac6454SAndrew Thompson 	if (xfer->flags_int.control_xfr) {
151502ac6454SAndrew Thompson 
1516ed6d949aSAndrew Thompson 		if (usbd_setup_ctrl_transfer(xfer)) {
1517bd216778SAndrew Thompson 			USB_BUS_LOCK(bus);
1518a593f6b8SAndrew Thompson 			usbd_transfer_done(xfer, USB_ERR_STALLED);
1519bd216778SAndrew Thompson 			USB_BUS_UNLOCK(bus);
152002ac6454SAndrew Thompson 			return;
152102ac6454SAndrew Thompson 		}
152202ac6454SAndrew Thompson 	}
152302ac6454SAndrew Thompson 	/*
152402ac6454SAndrew Thompson 	 * Setup filtered version of some transfer flags,
152502ac6454SAndrew Thompson 	 * in case of data read direction
152602ac6454SAndrew Thompson 	 */
152702ac6454SAndrew Thompson 	if (USB_GET_DATA_ISREAD(xfer)) {
152802ac6454SAndrew Thompson 
152902ac6454SAndrew Thompson 		if (xfer->flags.short_frames_ok) {
153002ac6454SAndrew Thompson 			xfer->flags_int.short_xfer_ok = 1;
153102ac6454SAndrew Thompson 			xfer->flags_int.short_frames_ok = 1;
153202ac6454SAndrew Thompson 		} else if (xfer->flags.short_xfer_ok) {
153302ac6454SAndrew Thompson 			xfer->flags_int.short_xfer_ok = 1;
1534e1ccac96SAndrew Thompson 
1535e1ccac96SAndrew Thompson 			/* check for control transfer */
1536e1ccac96SAndrew Thompson 			if (xfer->flags_int.control_xfr) {
1537e1ccac96SAndrew Thompson 				/*
1538e1ccac96SAndrew Thompson 				 * 1) Control transfers do not support
1539e1ccac96SAndrew Thompson 				 * reception of multiple short USB
1540e1ccac96SAndrew Thompson 				 * frames in host mode and device side
1541e1ccac96SAndrew Thompson 				 * mode, with exception of:
1542e1ccac96SAndrew Thompson 				 *
1543e1ccac96SAndrew Thompson 				 * 2) Due to sometimes buggy device
1544e1ccac96SAndrew Thompson 				 * side firmware we need to do a
1545e1ccac96SAndrew Thompson 				 * STATUS stage in case of short
1546e1ccac96SAndrew Thompson 				 * control transfers in USB host mode.
1547e1ccac96SAndrew Thompson 				 * The STATUS stage then becomes the
1548e1ccac96SAndrew Thompson 				 * "alt_next" to the DATA stage.
1549e1ccac96SAndrew Thompson 				 */
1550e1ccac96SAndrew Thompson 				xfer->flags_int.short_frames_ok = 1;
155102ac6454SAndrew Thompson 			}
155202ac6454SAndrew Thompson 		}
155302ac6454SAndrew Thompson 	}
155402ac6454SAndrew Thompson 	/*
155502ac6454SAndrew Thompson 	 * Check if BUS-DMA support is enabled and try to load virtual
155602ac6454SAndrew Thompson 	 * buffers into DMA, if any:
155702ac6454SAndrew Thompson 	 */
1558bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
155902ac6454SAndrew Thompson 	if (xfer->flags_int.bdma_enable) {
156002ac6454SAndrew Thompson 		/* insert the USB transfer last in the BUS-DMA queue */
1561a593f6b8SAndrew Thompson 		usb_command_wrapper(&xfer->xroot->dma_q, xfer);
156202ac6454SAndrew Thompson 		return;
156302ac6454SAndrew Thompson 	}
1564bdc081c6SAndrew Thompson #endif
156502ac6454SAndrew Thompson 	/*
156602ac6454SAndrew Thompson 	 * Enter the USB transfer into the Host Controller or
156702ac6454SAndrew Thompson 	 * Device Controller schedule:
156802ac6454SAndrew Thompson 	 */
1569a593f6b8SAndrew Thompson 	usbd_pipe_enter(xfer);
157002ac6454SAndrew Thompson }
157102ac6454SAndrew Thompson 
157202ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1573a593f6b8SAndrew Thompson  *	usbd_pipe_enter - factored out code
157402ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
157502ac6454SAndrew Thompson void
1576a593f6b8SAndrew Thompson usbd_pipe_enter(struct usb_xfer *xfer)
157702ac6454SAndrew Thompson {
1578ae60fdfbSAndrew Thompson 	struct usb_endpoint *ep;
157902ac6454SAndrew Thompson 
158002ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
158102ac6454SAndrew Thompson 
158202ac6454SAndrew Thompson 	USB_BUS_LOCK(xfer->xroot->bus);
158302ac6454SAndrew Thompson 
1584ae60fdfbSAndrew Thompson 	ep = xfer->endpoint;
158502ac6454SAndrew Thompson 
158602ac6454SAndrew Thompson 	DPRINTF("enter\n");
158702ac6454SAndrew Thompson 
158802ac6454SAndrew Thompson 	/* enter the transfer */
1589ae60fdfbSAndrew Thompson 	(ep->methods->enter) (xfer);
159002ac6454SAndrew Thompson 
159102ac6454SAndrew Thompson 	xfer->flags_int.can_cancel_immed = 1;
15924565300dSAndrew Thompson 
159302ac6454SAndrew Thompson 	/* check for transfer error */
159402ac6454SAndrew Thompson 	if (xfer->error) {
159502ac6454SAndrew Thompson 		/* some error has happened */
1596a593f6b8SAndrew Thompson 		usbd_transfer_done(xfer, 0);
159702ac6454SAndrew Thompson 		USB_BUS_UNLOCK(xfer->xroot->bus);
159802ac6454SAndrew Thompson 		return;
159902ac6454SAndrew Thompson 	}
160002ac6454SAndrew Thompson 
160102ac6454SAndrew Thompson 	/* start the transfer */
1602a593f6b8SAndrew Thompson 	usb_command_wrapper(&ep->endpoint_q, xfer);
160302ac6454SAndrew Thompson 	USB_BUS_UNLOCK(xfer->xroot->bus);
160402ac6454SAndrew Thompson }
160502ac6454SAndrew Thompson 
160602ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1607a593f6b8SAndrew Thompson  *	usbd_transfer_start - start an USB transfer
160802ac6454SAndrew Thompson  *
160902ac6454SAndrew Thompson  * NOTE: Calling this function more than one time will only
161002ac6454SAndrew Thompson  *       result in a single transfer start, until the USB transfer
161102ac6454SAndrew Thompson  *       completes.
161202ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
161302ac6454SAndrew Thompson void
1614a593f6b8SAndrew Thompson usbd_transfer_start(struct usb_xfer *xfer)
161502ac6454SAndrew Thompson {
161602ac6454SAndrew Thompson 	if (xfer == NULL) {
161702ac6454SAndrew Thompson 		/* transfer is gone */
161802ac6454SAndrew Thompson 		return;
161902ac6454SAndrew Thompson 	}
162002ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
162102ac6454SAndrew Thompson 
162202ac6454SAndrew Thompson 	/* mark the USB transfer started */
162302ac6454SAndrew Thompson 
162402ac6454SAndrew Thompson 	if (!xfer->flags_int.started) {
1625a8725281SAndrew Thompson 		/* lock the BUS lock to avoid races updating flags_int */
1626a8725281SAndrew Thompson 		USB_BUS_LOCK(xfer->xroot->bus);
162702ac6454SAndrew Thompson 		xfer->flags_int.started = 1;
1628a8725281SAndrew Thompson 		USB_BUS_UNLOCK(xfer->xroot->bus);
162902ac6454SAndrew Thompson 	}
163002ac6454SAndrew Thompson 	/* check if the USB transfer callback is already transferring */
163102ac6454SAndrew Thompson 
163202ac6454SAndrew Thompson 	if (xfer->flags_int.transferring) {
163302ac6454SAndrew Thompson 		return;
163402ac6454SAndrew Thompson 	}
163502ac6454SAndrew Thompson 	USB_BUS_LOCK(xfer->xroot->bus);
163602ac6454SAndrew Thompson 	/* call the USB transfer callback */
1637a593f6b8SAndrew Thompson 	usbd_callback_ss_done_defer(xfer);
163802ac6454SAndrew Thompson 	USB_BUS_UNLOCK(xfer->xroot->bus);
163902ac6454SAndrew Thompson }
164002ac6454SAndrew Thompson 
164102ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1642a593f6b8SAndrew Thompson  *	usbd_transfer_stop - stop an USB transfer
164302ac6454SAndrew Thompson  *
164402ac6454SAndrew Thompson  * NOTE: Calling this function more than one time will only
164502ac6454SAndrew Thompson  *       result in a single transfer stop.
164602ac6454SAndrew Thompson  * NOTE: When this function returns it is not safe to free nor
1647a593f6b8SAndrew Thompson  *       reuse any DMA buffers. See "usbd_transfer_drain()".
164802ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
164902ac6454SAndrew Thompson void
1650a593f6b8SAndrew Thompson usbd_transfer_stop(struct usb_xfer *xfer)
165102ac6454SAndrew Thompson {
1652ae60fdfbSAndrew Thompson 	struct usb_endpoint *ep;
165302ac6454SAndrew Thompson 
165402ac6454SAndrew Thompson 	if (xfer == NULL) {
165502ac6454SAndrew Thompson 		/* transfer is gone */
165602ac6454SAndrew Thompson 		return;
165702ac6454SAndrew Thompson 	}
165802ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
165902ac6454SAndrew Thompson 
166002ac6454SAndrew Thompson 	/* check if the USB transfer was ever opened */
166102ac6454SAndrew Thompson 
166202ac6454SAndrew Thompson 	if (!xfer->flags_int.open) {
1663a8725281SAndrew Thompson 		if (xfer->flags_int.started) {
166402ac6454SAndrew Thompson 			/* nothing to do except clearing the "started" flag */
1665a8725281SAndrew Thompson 			/* lock the BUS lock to avoid races updating flags_int */
1666a8725281SAndrew Thompson 			USB_BUS_LOCK(xfer->xroot->bus);
166702ac6454SAndrew Thompson 			xfer->flags_int.started = 0;
1668a8725281SAndrew Thompson 			USB_BUS_UNLOCK(xfer->xroot->bus);
1669a8725281SAndrew Thompson 		}
167002ac6454SAndrew Thompson 		return;
167102ac6454SAndrew Thompson 	}
167202ac6454SAndrew Thompson 	/* try to stop the current USB transfer */
167302ac6454SAndrew Thompson 
167402ac6454SAndrew Thompson 	USB_BUS_LOCK(xfer->xroot->bus);
1675a8725281SAndrew Thompson 	/* override any previous error */
1676a8725281SAndrew Thompson 	xfer->error = USB_ERR_CANCELLED;
1677a8725281SAndrew Thompson 
167802ac6454SAndrew Thompson 	/*
167902ac6454SAndrew Thompson 	 * Clear "open" and "started" when both private and USB lock
168002ac6454SAndrew Thompson 	 * is locked so that we don't get a race updating "flags_int"
168102ac6454SAndrew Thompson 	 */
168202ac6454SAndrew Thompson 	xfer->flags_int.open = 0;
168302ac6454SAndrew Thompson 	xfer->flags_int.started = 0;
168402ac6454SAndrew Thompson 
168502ac6454SAndrew Thompson 	/*
168602ac6454SAndrew Thompson 	 * Check if we can cancel the USB transfer immediately.
168702ac6454SAndrew Thompson 	 */
168802ac6454SAndrew Thompson 	if (xfer->flags_int.transferring) {
168902ac6454SAndrew Thompson 		if (xfer->flags_int.can_cancel_immed &&
169002ac6454SAndrew Thompson 		    (!xfer->flags_int.did_close)) {
169102ac6454SAndrew Thompson 			DPRINTF("close\n");
169202ac6454SAndrew Thompson 			/*
169302ac6454SAndrew Thompson 			 * The following will lead to an USB_ERR_CANCELLED
169402ac6454SAndrew Thompson 			 * error code being passed to the USB callback.
169502ac6454SAndrew Thompson 			 */
1696ae60fdfbSAndrew Thompson 			(xfer->endpoint->methods->close) (xfer);
169702ac6454SAndrew Thompson 			/* only close once */
169802ac6454SAndrew Thompson 			xfer->flags_int.did_close = 1;
169902ac6454SAndrew Thompson 		} else {
170002ac6454SAndrew Thompson 			/* need to wait for the next done callback */
170102ac6454SAndrew Thompson 		}
170202ac6454SAndrew Thompson 	} else {
170302ac6454SAndrew Thompson 		DPRINTF("close\n");
170402ac6454SAndrew Thompson 
170502ac6454SAndrew Thompson 		/* close here and now */
1706ae60fdfbSAndrew Thompson 		(xfer->endpoint->methods->close) (xfer);
170702ac6454SAndrew Thompson 
170802ac6454SAndrew Thompson 		/*
170902ac6454SAndrew Thompson 		 * Any additional DMA delay is done by
1710a593f6b8SAndrew Thompson 		 * "usbd_transfer_unsetup()".
171102ac6454SAndrew Thompson 		 */
171202ac6454SAndrew Thompson 
171302ac6454SAndrew Thompson 		/*
171402ac6454SAndrew Thompson 		 * Special case. Check if we need to restart a blocked
1715ae60fdfbSAndrew Thompson 		 * endpoint.
171602ac6454SAndrew Thompson 		 */
1717ae60fdfbSAndrew Thompson 		ep = xfer->endpoint;
171802ac6454SAndrew Thompson 
171902ac6454SAndrew Thompson 		/*
172002ac6454SAndrew Thompson 		 * If the current USB transfer is completing we need
172102ac6454SAndrew Thompson 		 * to start the next one:
172202ac6454SAndrew Thompson 		 */
1723ae60fdfbSAndrew Thompson 		if (ep->endpoint_q.curr == xfer) {
1724a593f6b8SAndrew Thompson 			usb_command_wrapper(&ep->endpoint_q, NULL);
172502ac6454SAndrew Thompson 		}
172602ac6454SAndrew Thompson 	}
172702ac6454SAndrew Thompson 
172802ac6454SAndrew Thompson 	USB_BUS_UNLOCK(xfer->xroot->bus);
172902ac6454SAndrew Thompson }
173002ac6454SAndrew Thompson 
173102ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1732a593f6b8SAndrew Thompson  *	usbd_transfer_pending
173302ac6454SAndrew Thompson  *
173402ac6454SAndrew Thompson  * This function will check if an USB transfer is pending which is a
173502ac6454SAndrew Thompson  * little bit complicated!
173602ac6454SAndrew Thompson  * Return values:
173702ac6454SAndrew Thompson  * 0: Not pending
173802ac6454SAndrew Thompson  * 1: Pending: The USB transfer will receive a callback in the future.
173902ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
174002ac6454SAndrew Thompson uint8_t
1741a593f6b8SAndrew Thompson usbd_transfer_pending(struct usb_xfer *xfer)
174202ac6454SAndrew Thompson {
1743760bc48eSAndrew Thompson 	struct usb_xfer_root *info;
1744760bc48eSAndrew Thompson 	struct usb_xfer_queue *pq;
174502ac6454SAndrew Thompson 
174602ac6454SAndrew Thompson 	if (xfer == NULL) {
174702ac6454SAndrew Thompson 		/* transfer is gone */
174802ac6454SAndrew Thompson 		return (0);
174902ac6454SAndrew Thompson 	}
175002ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
175102ac6454SAndrew Thompson 
175202ac6454SAndrew Thompson 	if (xfer->flags_int.transferring) {
175302ac6454SAndrew Thompson 		/* trivial case */
175402ac6454SAndrew Thompson 		return (1);
175502ac6454SAndrew Thompson 	}
175602ac6454SAndrew Thompson 	USB_BUS_LOCK(xfer->xroot->bus);
175702ac6454SAndrew Thompson 	if (xfer->wait_queue) {
175802ac6454SAndrew Thompson 		/* we are waiting on a queue somewhere */
175902ac6454SAndrew Thompson 		USB_BUS_UNLOCK(xfer->xroot->bus);
176002ac6454SAndrew Thompson 		return (1);
176102ac6454SAndrew Thompson 	}
176202ac6454SAndrew Thompson 	info = xfer->xroot;
176302ac6454SAndrew Thompson 	pq = &info->done_q;
176402ac6454SAndrew Thompson 
176502ac6454SAndrew Thompson 	if (pq->curr == xfer) {
176602ac6454SAndrew Thompson 		/* we are currently scheduled for callback */
176702ac6454SAndrew Thompson 		USB_BUS_UNLOCK(xfer->xroot->bus);
176802ac6454SAndrew Thompson 		return (1);
176902ac6454SAndrew Thompson 	}
177002ac6454SAndrew Thompson 	/* we are not pending */
177102ac6454SAndrew Thompson 	USB_BUS_UNLOCK(xfer->xroot->bus);
177202ac6454SAndrew Thompson 	return (0);
177302ac6454SAndrew Thompson }
177402ac6454SAndrew Thompson 
177502ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1776a593f6b8SAndrew Thompson  *	usbd_transfer_drain
177702ac6454SAndrew Thompson  *
177802ac6454SAndrew Thompson  * This function will stop the USB transfer and wait for any
177902ac6454SAndrew Thompson  * additional BUS-DMA and HW-DMA operations to complete. Buffers that
178002ac6454SAndrew Thompson  * are loaded into DMA can safely be freed or reused after that this
178102ac6454SAndrew Thompson  * function has returned.
178202ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
178302ac6454SAndrew Thompson void
1784a593f6b8SAndrew Thompson usbd_transfer_drain(struct usb_xfer *xfer)
178502ac6454SAndrew Thompson {
178602ac6454SAndrew Thompson 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL,
1787a593f6b8SAndrew Thompson 	    "usbd_transfer_drain can sleep!");
178802ac6454SAndrew Thompson 
178902ac6454SAndrew Thompson 	if (xfer == NULL) {
179002ac6454SAndrew Thompson 		/* transfer is gone */
179102ac6454SAndrew Thompson 		return;
179202ac6454SAndrew Thompson 	}
179302ac6454SAndrew Thompson 	if (xfer->xroot->xfer_mtx != &Giant) {
179402ac6454SAndrew Thompson 		USB_XFER_LOCK_ASSERT(xfer, MA_NOTOWNED);
179502ac6454SAndrew Thompson 	}
179602ac6454SAndrew Thompson 	USB_XFER_LOCK(xfer);
179702ac6454SAndrew Thompson 
1798a593f6b8SAndrew Thompson 	usbd_transfer_stop(xfer);
179902ac6454SAndrew Thompson 
1800a593f6b8SAndrew Thompson 	while (usbd_transfer_pending(xfer)) {
180102ac6454SAndrew Thompson 		xfer->flags_int.draining = 1;
180202ac6454SAndrew Thompson 		/*
180302ac6454SAndrew Thompson 		 * Wait until the current outstanding USB
180402ac6454SAndrew Thompson 		 * transfer is complete !
180502ac6454SAndrew Thompson 		 */
18068437751dSAndrew Thompson 		cv_wait(&xfer->xroot->cv_drain, xfer->xroot->xfer_mtx);
180702ac6454SAndrew Thompson 	}
180802ac6454SAndrew Thompson 	USB_XFER_UNLOCK(xfer);
180902ac6454SAndrew Thompson }
181002ac6454SAndrew Thompson 
1811ed6d949aSAndrew Thompson struct usb_page_cache *
1812ed6d949aSAndrew Thompson usbd_xfer_get_frame(struct usb_xfer *xfer, usb_frcount_t frindex)
1813ed6d949aSAndrew Thompson {
1814ed6d949aSAndrew Thompson 	KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
1815ed6d949aSAndrew Thompson 
1816ed6d949aSAndrew Thompson 	return (&xfer->frbuffers[frindex]);
1817ed6d949aSAndrew Thompson }
1818ed6d949aSAndrew Thompson 
1819ed6d949aSAndrew Thompson usb_frlength_t
18208f9e0ef9SAndrew Thompson usbd_xfer_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex)
1821ed6d949aSAndrew Thompson {
1822ed6d949aSAndrew Thompson 	KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
1823ed6d949aSAndrew Thompson 
1824ed6d949aSAndrew Thompson 	return (xfer->frlengths[frindex]);
1825ed6d949aSAndrew Thompson }
1826ed6d949aSAndrew Thompson 
182702ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1828ed6d949aSAndrew Thompson  *	usbd_xfer_set_frame_data
182902ac6454SAndrew Thompson  *
183002ac6454SAndrew Thompson  * This function sets the pointer of the buffer that should
183102ac6454SAndrew Thompson  * loaded directly into DMA for the given USB frame. Passing "ptr"
183202ac6454SAndrew Thompson  * equal to NULL while the corresponding "frlength" is greater
183302ac6454SAndrew Thompson  * than zero gives undefined results!
183402ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
183502ac6454SAndrew Thompson void
1836ed6d949aSAndrew Thompson usbd_xfer_set_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
1837ed6d949aSAndrew Thompson     void *ptr, usb_frlength_t len)
183802ac6454SAndrew Thompson {
1839ed6d949aSAndrew Thompson 	KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
1840ed6d949aSAndrew Thompson 
184102ac6454SAndrew Thompson 	/* set virtual address to load and length */
184202ac6454SAndrew Thompson 	xfer->frbuffers[frindex].buffer = ptr;
1843ed6d949aSAndrew Thompson 	usbd_xfer_set_frame_len(xfer, frindex, len);
1844ed6d949aSAndrew Thompson }
1845ed6d949aSAndrew Thompson 
1846ed6d949aSAndrew Thompson void
18478f9e0ef9SAndrew Thompson usbd_xfer_frame_data(struct usb_xfer *xfer, usb_frcount_t frindex,
1848ed6d949aSAndrew Thompson     void **ptr, int *len)
1849ed6d949aSAndrew Thompson {
1850ed6d949aSAndrew Thompson 	KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
1851ed6d949aSAndrew Thompson 
1852ed6d949aSAndrew Thompson 	if (ptr != NULL)
1853ed6d949aSAndrew Thompson 		*ptr = xfer->frbuffers[frindex].buffer;
1854ed6d949aSAndrew Thompson 	if (len != NULL)
1855ed6d949aSAndrew Thompson 		*len = xfer->frlengths[frindex];
1856ed6d949aSAndrew Thompson }
1857ed6d949aSAndrew Thompson 
1858ed6d949aSAndrew Thompson void
1859ed6d949aSAndrew Thompson usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen, int *aframes,
1860ed6d949aSAndrew Thompson     int *nframes)
1861ed6d949aSAndrew Thompson {
1862ed6d949aSAndrew Thompson 	if (actlen != NULL)
1863ed6d949aSAndrew Thompson 		*actlen = xfer->actlen;
1864ed6d949aSAndrew Thompson 	if (sumlen != NULL)
1865ed6d949aSAndrew Thompson 		*sumlen = xfer->sumlen;
1866ed6d949aSAndrew Thompson 	if (aframes != NULL)
1867ed6d949aSAndrew Thompson 		*aframes = xfer->aframes;
1868ed6d949aSAndrew Thompson 	if (nframes != NULL)
1869ed6d949aSAndrew Thompson 		*nframes = xfer->nframes;
187002ac6454SAndrew Thompson }
187102ac6454SAndrew Thompson 
187202ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1873ed6d949aSAndrew Thompson  *	usbd_xfer_set_frame_offset
187402ac6454SAndrew Thompson  *
187502ac6454SAndrew Thompson  * This function sets the frame data buffer offset relative to the beginning
187602ac6454SAndrew Thompson  * of the USB DMA buffer allocated for this USB transfer.
187702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
187802ac6454SAndrew Thompson void
1879ed6d949aSAndrew Thompson usbd_xfer_set_frame_offset(struct usb_xfer *xfer, usb_frlength_t offset,
1880e0a69b51SAndrew Thompson     usb_frcount_t frindex)
188102ac6454SAndrew Thompson {
1882ed6d949aSAndrew Thompson 	KASSERT(!xfer->flags.ext_buffer, ("Cannot offset data frame "
188302ac6454SAndrew Thompson 	    "when the USB buffer is external!\n"));
1884ed6d949aSAndrew Thompson 	KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
188502ac6454SAndrew Thompson 
188602ac6454SAndrew Thompson 	/* set virtual address to load */
188702ac6454SAndrew Thompson 	xfer->frbuffers[frindex].buffer =
188802ac6454SAndrew Thompson 	    USB_ADD_BYTES(xfer->local_buffer, offset);
188902ac6454SAndrew Thompson }
189002ac6454SAndrew Thompson 
1891ed6d949aSAndrew Thompson void
1892ed6d949aSAndrew Thompson usbd_xfer_set_interval(struct usb_xfer *xfer, int i)
1893ed6d949aSAndrew Thompson {
1894ed6d949aSAndrew Thompson 	xfer->interval = i;
1895ed6d949aSAndrew Thompson }
1896ed6d949aSAndrew Thompson 
1897ed6d949aSAndrew Thompson void
1898ed6d949aSAndrew Thompson usbd_xfer_set_timeout(struct usb_xfer *xfer, int t)
1899ed6d949aSAndrew Thompson {
1900ed6d949aSAndrew Thompson 	xfer->timeout = t;
1901ed6d949aSAndrew Thompson }
1902ed6d949aSAndrew Thompson 
1903ed6d949aSAndrew Thompson void
1904ed6d949aSAndrew Thompson usbd_xfer_set_frames(struct usb_xfer *xfer, usb_frcount_t n)
1905ed6d949aSAndrew Thompson {
1906ed6d949aSAndrew Thompson 	xfer->nframes = n;
1907ed6d949aSAndrew Thompson }
1908ed6d949aSAndrew Thompson 
1909ed6d949aSAndrew Thompson usb_frcount_t
1910ed6d949aSAndrew Thompson usbd_xfer_max_frames(struct usb_xfer *xfer)
1911ed6d949aSAndrew Thompson {
1912ed6d949aSAndrew Thompson 	return (xfer->max_frame_count);
1913ed6d949aSAndrew Thompson }
1914ed6d949aSAndrew Thompson 
1915ed6d949aSAndrew Thompson usb_frlength_t
1916ed6d949aSAndrew Thompson usbd_xfer_max_len(struct usb_xfer *xfer)
1917ed6d949aSAndrew Thompson {
1918ed6d949aSAndrew Thompson 	return (xfer->max_data_length);
1919ed6d949aSAndrew Thompson }
1920ed6d949aSAndrew Thompson 
1921ed6d949aSAndrew Thompson usb_frlength_t
1922ed6d949aSAndrew Thompson usbd_xfer_max_framelen(struct usb_xfer *xfer)
1923ed6d949aSAndrew Thompson {
1924ed6d949aSAndrew Thompson 	return (xfer->max_frame_size);
1925ed6d949aSAndrew Thompson }
1926ed6d949aSAndrew Thompson 
1927ed6d949aSAndrew Thompson void
1928ed6d949aSAndrew Thompson usbd_xfer_set_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex,
1929ed6d949aSAndrew Thompson     usb_frlength_t len)
1930ed6d949aSAndrew Thompson {
1931ed6d949aSAndrew Thompson 	KASSERT(frindex < xfer->max_frame_count, ("frame index overflow"));
1932ed6d949aSAndrew Thompson 
1933ed6d949aSAndrew Thompson 	xfer->frlengths[frindex] = len;
1934ed6d949aSAndrew Thompson }
1935ed6d949aSAndrew Thompson 
193602ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1937a593f6b8SAndrew Thompson  *	usb_callback_proc - factored out code
193802ac6454SAndrew Thompson  *
193902ac6454SAndrew Thompson  * This function performs USB callbacks.
194002ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
194102ac6454SAndrew Thompson static void
1942a593f6b8SAndrew Thompson usb_callback_proc(struct usb_proc_msg *_pm)
194302ac6454SAndrew Thompson {
1944760bc48eSAndrew Thompson 	struct usb_done_msg *pm = (void *)_pm;
1945760bc48eSAndrew Thompson 	struct usb_xfer_root *info = pm->xroot;
194602ac6454SAndrew Thompson 
194702ac6454SAndrew Thompson 	/* Change locking order */
194802ac6454SAndrew Thompson 	USB_BUS_UNLOCK(info->bus);
194902ac6454SAndrew Thompson 
195002ac6454SAndrew Thompson 	/*
195102ac6454SAndrew Thompson 	 * We exploit the fact that the mutex is the same for all
195202ac6454SAndrew Thompson 	 * callbacks that will be called from this thread:
195302ac6454SAndrew Thompson 	 */
195402ac6454SAndrew Thompson 	mtx_lock(info->xfer_mtx);
195502ac6454SAndrew Thompson 	USB_BUS_LOCK(info->bus);
195602ac6454SAndrew Thompson 
195702ac6454SAndrew Thompson 	/* Continue where we lost track */
1958a593f6b8SAndrew Thompson 	usb_command_wrapper(&info->done_q,
195902ac6454SAndrew Thompson 	    info->done_q.curr);
196002ac6454SAndrew Thompson 
196102ac6454SAndrew Thompson 	mtx_unlock(info->xfer_mtx);
196202ac6454SAndrew Thompson }
196302ac6454SAndrew Thompson 
196402ac6454SAndrew Thompson /*------------------------------------------------------------------------*
1965a593f6b8SAndrew Thompson  *	usbd_callback_ss_done_defer
196602ac6454SAndrew Thompson  *
196702ac6454SAndrew Thompson  * This function will defer the start, stop and done callback to the
196802ac6454SAndrew Thompson  * correct thread.
196902ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
197002ac6454SAndrew Thompson static void
1971a593f6b8SAndrew Thompson usbd_callback_ss_done_defer(struct usb_xfer *xfer)
197202ac6454SAndrew Thompson {
1973760bc48eSAndrew Thompson 	struct usb_xfer_root *info = xfer->xroot;
1974760bc48eSAndrew Thompson 	struct usb_xfer_queue *pq = &info->done_q;
197502ac6454SAndrew Thompson 
197602ac6454SAndrew Thompson 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
197702ac6454SAndrew Thompson 
197802ac6454SAndrew Thompson 	if (pq->curr != xfer) {
1979a593f6b8SAndrew Thompson 		usbd_transfer_enqueue(pq, xfer);
198002ac6454SAndrew Thompson 	}
198102ac6454SAndrew Thompson 	if (!pq->recurse_1) {
198202ac6454SAndrew Thompson 
198302ac6454SAndrew Thompson 		/*
198402ac6454SAndrew Thompson 	         * We have to postpone the callback due to the fact we
198502ac6454SAndrew Thompson 	         * will have a Lock Order Reversal, LOR, if we try to
198602ac6454SAndrew Thompson 	         * proceed !
198702ac6454SAndrew Thompson 	         */
1988a593f6b8SAndrew Thompson 		if (usb_proc_msignal(info->done_p,
198902ac6454SAndrew Thompson 		    &info->done_m[0], &info->done_m[1])) {
199002ac6454SAndrew Thompson 			/* ignore */
199102ac6454SAndrew Thompson 		}
199202ac6454SAndrew Thompson 	} else {
199302ac6454SAndrew Thompson 		/* clear second recurse flag */
199402ac6454SAndrew Thompson 		pq->recurse_2 = 0;
199502ac6454SAndrew Thompson 	}
199602ac6454SAndrew Thompson 	return;
199702ac6454SAndrew Thompson 
199802ac6454SAndrew Thompson }
199902ac6454SAndrew Thompson 
200002ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2001a593f6b8SAndrew Thompson  *	usbd_callback_wrapper
200202ac6454SAndrew Thompson  *
200302ac6454SAndrew Thompson  * This is a wrapper for USB callbacks. This wrapper does some
200402ac6454SAndrew Thompson  * auto-magic things like figuring out if we can call the callback
200502ac6454SAndrew Thompson  * directly from the current context or if we need to wakeup the
200602ac6454SAndrew Thompson  * interrupt process.
200702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
200802ac6454SAndrew Thompson static void
2009a593f6b8SAndrew Thompson usbd_callback_wrapper(struct usb_xfer_queue *pq)
201002ac6454SAndrew Thompson {
2011760bc48eSAndrew Thompson 	struct usb_xfer *xfer = pq->curr;
2012760bc48eSAndrew Thompson 	struct usb_xfer_root *info = xfer->xroot;
201302ac6454SAndrew Thompson 
20144565300dSAndrew Thompson 	USB_BUS_LOCK_ASSERT(info->bus, MA_OWNED);
20154565300dSAndrew Thompson 	if (!mtx_owned(info->xfer_mtx)) {
201602ac6454SAndrew Thompson 		/*
201702ac6454SAndrew Thompson 	       	 * Cases that end up here:
201802ac6454SAndrew Thompson 		 *
201902ac6454SAndrew Thompson 		 * 5) HW interrupt done callback or other source.
202002ac6454SAndrew Thompson 		 */
202102ac6454SAndrew Thompson 		DPRINTFN(3, "case 5\n");
202202ac6454SAndrew Thompson 
202302ac6454SAndrew Thompson 		/*
202402ac6454SAndrew Thompson 	         * We have to postpone the callback due to the fact we
202502ac6454SAndrew Thompson 	         * will have a Lock Order Reversal, LOR, if we try to
202602ac6454SAndrew Thompson 	         * proceed !
202702ac6454SAndrew Thompson 	         */
2028a593f6b8SAndrew Thompson 		if (usb_proc_msignal(info->done_p,
202902ac6454SAndrew Thompson 		    &info->done_m[0], &info->done_m[1])) {
203002ac6454SAndrew Thompson 			/* ignore */
203102ac6454SAndrew Thompson 		}
203202ac6454SAndrew Thompson 		return;
203302ac6454SAndrew Thompson 	}
203402ac6454SAndrew Thompson 	/*
203502ac6454SAndrew Thompson 	 * Cases that end up here:
203602ac6454SAndrew Thompson 	 *
203702ac6454SAndrew Thompson 	 * 1) We are starting a transfer
203802ac6454SAndrew Thompson 	 * 2) We are prematurely calling back a transfer
203902ac6454SAndrew Thompson 	 * 3) We are stopping a transfer
204002ac6454SAndrew Thompson 	 * 4) We are doing an ordinary callback
204102ac6454SAndrew Thompson 	 */
204202ac6454SAndrew Thompson 	DPRINTFN(3, "case 1-4\n");
204302ac6454SAndrew Thompson 	/* get next USB transfer in the queue */
204402ac6454SAndrew Thompson 	info->done_q.curr = NULL;
204502ac6454SAndrew Thompson 
20464565300dSAndrew Thompson 	USB_BUS_UNLOCK(info->bus);
20474565300dSAndrew Thompson 	USB_BUS_LOCK_ASSERT(info->bus, MA_NOTOWNED);
204802ac6454SAndrew Thompson 
204902ac6454SAndrew Thompson 	/* set correct USB state for callback */
205002ac6454SAndrew Thompson 	if (!xfer->flags_int.transferring) {
2051a593f6b8SAndrew Thompson 		xfer->usb_state = USB_ST_SETUP;
205202ac6454SAndrew Thompson 		if (!xfer->flags_int.started) {
205302ac6454SAndrew Thompson 			/* we got stopped before we even got started */
20544565300dSAndrew Thompson 			USB_BUS_LOCK(info->bus);
205502ac6454SAndrew Thompson 			goto done;
205602ac6454SAndrew Thompson 		}
205702ac6454SAndrew Thompson 	} else {
205802ac6454SAndrew Thompson 
2059a593f6b8SAndrew Thompson 		if (usbd_callback_wrapper_sub(xfer)) {
206002ac6454SAndrew Thompson 			/* the callback has been deferred */
20614565300dSAndrew Thompson 			USB_BUS_LOCK(info->bus);
206202ac6454SAndrew Thompson 			goto done;
206302ac6454SAndrew Thompson 		}
20644eae601eSAndrew Thompson #if USB_HAVE_POWERD
206502ac6454SAndrew Thompson 		/* decrement power reference */
2066a593f6b8SAndrew Thompson 		usbd_transfer_power_ref(xfer, -1);
20674eae601eSAndrew Thompson #endif
206802ac6454SAndrew Thompson 		xfer->flags_int.transferring = 0;
206902ac6454SAndrew Thompson 
207002ac6454SAndrew Thompson 		if (xfer->error) {
2071a593f6b8SAndrew Thompson 			xfer->usb_state = USB_ST_ERROR;
207202ac6454SAndrew Thompson 		} else {
207302ac6454SAndrew Thompson 			/* set transferred state */
2074a593f6b8SAndrew Thompson 			xfer->usb_state = USB_ST_TRANSFERRED;
2075bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
207602ac6454SAndrew Thompson 			/* sync DMA memory, if any */
207702ac6454SAndrew Thompson 			if (xfer->flags_int.bdma_enable &&
207802ac6454SAndrew Thompson 			    (!xfer->flags_int.bdma_no_post_sync)) {
2079a593f6b8SAndrew Thompson 				usb_bdma_post_sync(xfer);
208002ac6454SAndrew Thompson 			}
2081bdc081c6SAndrew Thompson #endif
208202ac6454SAndrew Thompson 		}
208302ac6454SAndrew Thompson 	}
208402ac6454SAndrew Thompson 
208502ac6454SAndrew Thompson 	/* call processing routine */
2086ed6d949aSAndrew Thompson 	(xfer->callback) (xfer, xfer->error);
208702ac6454SAndrew Thompson 
208802ac6454SAndrew Thompson 	/* pickup the USB mutex again */
20894565300dSAndrew Thompson 	USB_BUS_LOCK(info->bus);
209002ac6454SAndrew Thompson 
209102ac6454SAndrew Thompson 	/*
209202ac6454SAndrew Thompson 	 * Check if we got started after that we got cancelled, but
209302ac6454SAndrew Thompson 	 * before we managed to do the callback.
209402ac6454SAndrew Thompson 	 */
209502ac6454SAndrew Thompson 	if ((!xfer->flags_int.open) &&
209602ac6454SAndrew Thompson 	    (xfer->flags_int.started) &&
2097a593f6b8SAndrew Thompson 	    (xfer->usb_state == USB_ST_ERROR)) {
209802ac6454SAndrew Thompson 		/* try to loop, but not recursivly */
2099a593f6b8SAndrew Thompson 		usb_command_wrapper(&info->done_q, xfer);
210002ac6454SAndrew Thompson 		return;
210102ac6454SAndrew Thompson 	}
210202ac6454SAndrew Thompson 
210302ac6454SAndrew Thompson done:
210402ac6454SAndrew Thompson 	/*
210502ac6454SAndrew Thompson 	 * Check if we are draining.
210602ac6454SAndrew Thompson 	 */
210702ac6454SAndrew Thompson 	if (xfer->flags_int.draining &&
210802ac6454SAndrew Thompson 	    (!xfer->flags_int.transferring)) {
2109a593f6b8SAndrew Thompson 		/* "usbd_transfer_drain()" is waiting for end of transfer */
211002ac6454SAndrew Thompson 		xfer->flags_int.draining = 0;
21118437751dSAndrew Thompson 		cv_broadcast(&info->cv_drain);
211202ac6454SAndrew Thompson 	}
211302ac6454SAndrew Thompson 
211402ac6454SAndrew Thompson 	/* do the next callback, if any */
2115a593f6b8SAndrew Thompson 	usb_command_wrapper(&info->done_q,
211602ac6454SAndrew Thompson 	    info->done_q.curr);
211702ac6454SAndrew Thompson }
211802ac6454SAndrew Thompson 
211902ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2120a593f6b8SAndrew Thompson  *	usb_dma_delay_done_cb
212102ac6454SAndrew Thompson  *
212202ac6454SAndrew Thompson  * This function is called when the DMA delay has been exectuded, and
212302ac6454SAndrew Thompson  * will make sure that the callback is called to complete the USB
212402ac6454SAndrew Thompson  * transfer. This code path is ususally only used when there is an USB
212502ac6454SAndrew Thompson  * error like USB_ERR_CANCELLED.
212602ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
212702ac6454SAndrew Thompson static void
2128a593f6b8SAndrew Thompson usb_dma_delay_done_cb(void *arg)
212902ac6454SAndrew Thompson {
2130760bc48eSAndrew Thompson 	struct usb_xfer *xfer = arg;
213102ac6454SAndrew Thompson 
213202ac6454SAndrew Thompson 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
213302ac6454SAndrew Thompson 
213402ac6454SAndrew Thompson 	DPRINTFN(3, "Completed %p\n", xfer);
213502ac6454SAndrew Thompson 
213602ac6454SAndrew Thompson 	/* queue callback for execution, again */
2137a593f6b8SAndrew Thompson 	usbd_transfer_done(xfer, 0);
213802ac6454SAndrew Thompson }
213902ac6454SAndrew Thompson 
214002ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2141a593f6b8SAndrew Thompson  *	usbd_transfer_dequeue
214202ac6454SAndrew Thompson  *
214302ac6454SAndrew Thompson  *  - This function is used to remove an USB transfer from a USB
214402ac6454SAndrew Thompson  *  transfer queue.
214502ac6454SAndrew Thompson  *
214602ac6454SAndrew Thompson  *  - This function can be called multiple times in a row.
214702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
214802ac6454SAndrew Thompson void
2149a593f6b8SAndrew Thompson usbd_transfer_dequeue(struct usb_xfer *xfer)
215002ac6454SAndrew Thompson {
2151760bc48eSAndrew Thompson 	struct usb_xfer_queue *pq;
215202ac6454SAndrew Thompson 
215302ac6454SAndrew Thompson 	pq = xfer->wait_queue;
215402ac6454SAndrew Thompson 	if (pq) {
215502ac6454SAndrew Thompson 		TAILQ_REMOVE(&pq->head, xfer, wait_entry);
215602ac6454SAndrew Thompson 		xfer->wait_queue = NULL;
215702ac6454SAndrew Thompson 	}
215802ac6454SAndrew Thompson }
215902ac6454SAndrew Thompson 
216002ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2161a593f6b8SAndrew Thompson  *	usbd_transfer_enqueue
216202ac6454SAndrew Thompson  *
216302ac6454SAndrew Thompson  *  - This function is used to insert an USB transfer into a USB *
216402ac6454SAndrew Thompson  *  transfer queue.
216502ac6454SAndrew Thompson  *
216602ac6454SAndrew Thompson  *  - This function can be called multiple times in a row.
216702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
216802ac6454SAndrew Thompson void
2169a593f6b8SAndrew Thompson usbd_transfer_enqueue(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
217002ac6454SAndrew Thompson {
217102ac6454SAndrew Thompson 	/*
217202ac6454SAndrew Thompson 	 * Insert the USB transfer into the queue, if it is not
217302ac6454SAndrew Thompson 	 * already on a USB transfer queue:
217402ac6454SAndrew Thompson 	 */
217502ac6454SAndrew Thompson 	if (xfer->wait_queue == NULL) {
217602ac6454SAndrew Thompson 		xfer->wait_queue = pq;
217702ac6454SAndrew Thompson 		TAILQ_INSERT_TAIL(&pq->head, xfer, wait_entry);
217802ac6454SAndrew Thompson 	}
217902ac6454SAndrew Thompson }
218002ac6454SAndrew Thompson 
218102ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2182a593f6b8SAndrew Thompson  *	usbd_transfer_done
218302ac6454SAndrew Thompson  *
218402ac6454SAndrew Thompson  *  - This function is used to remove an USB transfer from the busdma,
218502ac6454SAndrew Thompson  *  pipe or interrupt queue.
218602ac6454SAndrew Thompson  *
218702ac6454SAndrew Thompson  *  - This function is used to queue the USB transfer on the done
218802ac6454SAndrew Thompson  *  queue.
218902ac6454SAndrew Thompson  *
219002ac6454SAndrew Thompson  *  - This function is used to stop any USB transfer timeouts.
219102ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
219202ac6454SAndrew Thompson void
2193a593f6b8SAndrew Thompson usbd_transfer_done(struct usb_xfer *xfer, usb_error_t error)
219402ac6454SAndrew Thompson {
219502ac6454SAndrew Thompson 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
219602ac6454SAndrew Thompson 
2197a593f6b8SAndrew Thompson 	DPRINTF("err=%s\n", usbd_errstr(error));
219802ac6454SAndrew Thompson 
219902ac6454SAndrew Thompson 	/*
220002ac6454SAndrew Thompson 	 * If we are not transferring then just return.
220102ac6454SAndrew Thompson 	 * This can happen during transfer cancel.
220202ac6454SAndrew Thompson 	 */
220302ac6454SAndrew Thompson 	if (!xfer->flags_int.transferring) {
220402ac6454SAndrew Thompson 		DPRINTF("not transferring\n");
2205a8725281SAndrew Thompson 		/* end of control transfer, if any */
2206a8725281SAndrew Thompson 		xfer->flags_int.control_act = 0;
220702ac6454SAndrew Thompson 		return;
220802ac6454SAndrew Thompson 	}
220902ac6454SAndrew Thompson 	/* only set transfer error if not already set */
221002ac6454SAndrew Thompson 	if (!xfer->error) {
221102ac6454SAndrew Thompson 		xfer->error = error;
221202ac6454SAndrew Thompson 	}
221302ac6454SAndrew Thompson 	/* stop any callouts */
2214a593f6b8SAndrew Thompson 	usb_callout_stop(&xfer->timeout_handle);
221502ac6454SAndrew Thompson 
221602ac6454SAndrew Thompson 	/*
221702ac6454SAndrew Thompson 	 * If we are waiting on a queue, just remove the USB transfer
221802ac6454SAndrew Thompson 	 * from the queue, if any. We should have the required locks
221902ac6454SAndrew Thompson 	 * locked to do the remove when this function is called.
222002ac6454SAndrew Thompson 	 */
2221a593f6b8SAndrew Thompson 	usbd_transfer_dequeue(xfer);
222202ac6454SAndrew Thompson 
2223bdc081c6SAndrew Thompson #if USB_HAVE_BUSDMA
222402ac6454SAndrew Thompson 	if (mtx_owned(xfer->xroot->xfer_mtx)) {
2225760bc48eSAndrew Thompson 		struct usb_xfer_queue *pq;
2226bdc081c6SAndrew Thompson 
222702ac6454SAndrew Thompson 		/*
222802ac6454SAndrew Thompson 		 * If the private USB lock is not locked, then we assume
222902ac6454SAndrew Thompson 		 * that the BUS-DMA load stage has been passed:
223002ac6454SAndrew Thompson 		 */
223102ac6454SAndrew Thompson 		pq = &xfer->xroot->dma_q;
223202ac6454SAndrew Thompson 
223302ac6454SAndrew Thompson 		if (pq->curr == xfer) {
223402ac6454SAndrew Thompson 			/* start the next BUS-DMA load, if any */
2235a593f6b8SAndrew Thompson 			usb_command_wrapper(pq, NULL);
223602ac6454SAndrew Thompson 		}
223702ac6454SAndrew Thompson 	}
2238bdc081c6SAndrew Thompson #endif
223902ac6454SAndrew Thompson 	/* keep some statistics */
224002ac6454SAndrew Thompson 	if (xfer->error) {
224102ac6454SAndrew Thompson 		xfer->xroot->bus->stats_err.uds_requests
2242ae60fdfbSAndrew Thompson 		    [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
224302ac6454SAndrew Thompson 	} else {
224402ac6454SAndrew Thompson 		xfer->xroot->bus->stats_ok.uds_requests
2245ae60fdfbSAndrew Thompson 		    [xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE]++;
224602ac6454SAndrew Thompson 	}
224702ac6454SAndrew Thompson 
224802ac6454SAndrew Thompson 	/* call the USB transfer callback */
2249a593f6b8SAndrew Thompson 	usbd_callback_ss_done_defer(xfer);
225002ac6454SAndrew Thompson }
225102ac6454SAndrew Thompson 
225202ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2253a593f6b8SAndrew Thompson  *	usbd_transfer_start_cb
225402ac6454SAndrew Thompson  *
225502ac6454SAndrew Thompson  * This function is called to start the USB transfer when
225602ac6454SAndrew Thompson  * "xfer->interval" is greater than zero, and and the endpoint type is
225702ac6454SAndrew Thompson  * BULK or CONTROL.
225802ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
225902ac6454SAndrew Thompson static void
2260a593f6b8SAndrew Thompson usbd_transfer_start_cb(void *arg)
226102ac6454SAndrew Thompson {
2262760bc48eSAndrew Thompson 	struct usb_xfer *xfer = arg;
2263ae60fdfbSAndrew Thompson 	struct usb_endpoint *ep = xfer->endpoint;
226402ac6454SAndrew Thompson 
226502ac6454SAndrew Thompson 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
226602ac6454SAndrew Thompson 
226702ac6454SAndrew Thompson 	DPRINTF("start\n");
226802ac6454SAndrew Thompson 
226902ac6454SAndrew Thompson 	/* start the transfer */
2270ae60fdfbSAndrew Thompson 	(ep->methods->start) (xfer);
227102ac6454SAndrew Thompson 
227202ac6454SAndrew Thompson 	xfer->flags_int.can_cancel_immed = 1;
22734565300dSAndrew Thompson 
22744565300dSAndrew Thompson 	/* check for error */
227502ac6454SAndrew Thompson 	if (xfer->error) {
227602ac6454SAndrew Thompson 		/* some error has happened */
2277a593f6b8SAndrew Thompson 		usbd_transfer_done(xfer, 0);
227802ac6454SAndrew Thompson 	}
227902ac6454SAndrew Thompson }
228002ac6454SAndrew Thompson 
228102ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2282ed6d949aSAndrew Thompson  *	usbd_xfer_set_stall
228302ac6454SAndrew Thompson  *
228402ac6454SAndrew Thompson  * This function is used to set the stall flag outside the
228502ac6454SAndrew Thompson  * callback. This function is NULL safe.
228602ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
228702ac6454SAndrew Thompson void
2288ed6d949aSAndrew Thompson usbd_xfer_set_stall(struct usb_xfer *xfer)
228902ac6454SAndrew Thompson {
229002ac6454SAndrew Thompson 	if (xfer == NULL) {
229102ac6454SAndrew Thompson 		/* tearing down */
229202ac6454SAndrew Thompson 		return;
229302ac6454SAndrew Thompson 	}
229402ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
229502ac6454SAndrew Thompson 
229602ac6454SAndrew Thompson 	/* avoid any races by locking the USB mutex */
229702ac6454SAndrew Thompson 	USB_BUS_LOCK(xfer->xroot->bus);
229802ac6454SAndrew Thompson 	xfer->flags.stall_pipe = 1;
229902ac6454SAndrew Thompson 	USB_BUS_UNLOCK(xfer->xroot->bus);
230002ac6454SAndrew Thompson }
230102ac6454SAndrew Thompson 
2302ed6d949aSAndrew Thompson int
2303ed6d949aSAndrew Thompson usbd_xfer_is_stalled(struct usb_xfer *xfer)
2304ed6d949aSAndrew Thompson {
2305ed6d949aSAndrew Thompson 	return (xfer->endpoint->is_stalled);
2306ed6d949aSAndrew Thompson }
2307ed6d949aSAndrew Thompson 
230802ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2309a593f6b8SAndrew Thompson  *	usbd_transfer_clear_stall
231002ac6454SAndrew Thompson  *
231102ac6454SAndrew Thompson  * This function is used to clear the stall flag outside the
231202ac6454SAndrew Thompson  * callback. This function is NULL safe.
231302ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
231402ac6454SAndrew Thompson void
2315a593f6b8SAndrew Thompson usbd_transfer_clear_stall(struct usb_xfer *xfer)
231602ac6454SAndrew Thompson {
231702ac6454SAndrew Thompson 	if (xfer == NULL) {
231802ac6454SAndrew Thompson 		/* tearing down */
231902ac6454SAndrew Thompson 		return;
232002ac6454SAndrew Thompson 	}
232102ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer, MA_OWNED);
232202ac6454SAndrew Thompson 
232302ac6454SAndrew Thompson 	/* avoid any races by locking the USB mutex */
232402ac6454SAndrew Thompson 	USB_BUS_LOCK(xfer->xroot->bus);
232502ac6454SAndrew Thompson 
232602ac6454SAndrew Thompson 	xfer->flags.stall_pipe = 0;
232702ac6454SAndrew Thompson 
232802ac6454SAndrew Thompson 	USB_BUS_UNLOCK(xfer->xroot->bus);
232902ac6454SAndrew Thompson }
233002ac6454SAndrew Thompson 
233102ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2332a593f6b8SAndrew Thompson  *	usbd_pipe_start
233302ac6454SAndrew Thompson  *
233402ac6454SAndrew Thompson  * This function is used to add an USB transfer to the pipe transfer list.
233502ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
233602ac6454SAndrew Thompson void
2337a593f6b8SAndrew Thompson usbd_pipe_start(struct usb_xfer_queue *pq)
233802ac6454SAndrew Thompson {
2339ae60fdfbSAndrew Thompson 	struct usb_endpoint *ep;
2340760bc48eSAndrew Thompson 	struct usb_xfer *xfer;
234102ac6454SAndrew Thompson 	uint8_t type;
234202ac6454SAndrew Thompson 
234302ac6454SAndrew Thompson 	xfer = pq->curr;
2344ae60fdfbSAndrew Thompson 	ep = xfer->endpoint;
234502ac6454SAndrew Thompson 
234602ac6454SAndrew Thompson 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
234702ac6454SAndrew Thompson 
234802ac6454SAndrew Thompson 	/*
2349ae60fdfbSAndrew Thompson 	 * If the endpoint is already stalled we do nothing !
235002ac6454SAndrew Thompson 	 */
2351ae60fdfbSAndrew Thompson 	if (ep->is_stalled) {
235202ac6454SAndrew Thompson 		return;
235302ac6454SAndrew Thompson 	}
235402ac6454SAndrew Thompson 	/*
2355ae60fdfbSAndrew Thompson 	 * Check if we are supposed to stall the endpoint:
235602ac6454SAndrew Thompson 	 */
235702ac6454SAndrew Thompson 	if (xfer->flags.stall_pipe) {
235802ac6454SAndrew Thompson 		/* clear stall command */
235902ac6454SAndrew Thompson 		xfer->flags.stall_pipe = 0;
236002ac6454SAndrew Thompson 
236102ac6454SAndrew Thompson 		/*
236202ac6454SAndrew Thompson 		 * Only stall BULK and INTERRUPT endpoints.
236302ac6454SAndrew Thompson 		 */
2364ae60fdfbSAndrew Thompson 		type = (ep->edesc->bmAttributes & UE_XFERTYPE);
236502ac6454SAndrew Thompson 		if ((type == UE_BULK) ||
236602ac6454SAndrew Thompson 		    (type == UE_INTERRUPT)) {
2367760bc48eSAndrew Thompson 			struct usb_device *udev;
2368760bc48eSAndrew Thompson 			struct usb_xfer_root *info;
236929bd7d7eSAndrew Thompson 			uint8_t did_stall;
237002ac6454SAndrew Thompson 
237102ac6454SAndrew Thompson 			info = xfer->xroot;
237202ac6454SAndrew Thompson 			udev = info->udev;
237329bd7d7eSAndrew Thompson 			did_stall = 1;
237402ac6454SAndrew Thompson 
2375f29a0724SAndrew Thompson 			if (udev->flags.usb_mode == USB_MODE_DEVICE) {
237602ac6454SAndrew Thompson 				(udev->bus->methods->set_stall) (
237729bd7d7eSAndrew Thompson 				    udev, NULL, ep, &did_stall);
237802ac6454SAndrew Thompson 			} else if (udev->default_xfer[1]) {
237902ac6454SAndrew Thompson 				info = udev->default_xfer[1]->xroot;
238029bd7d7eSAndrew Thompson 				usb_proc_msignal(
238102ac6454SAndrew Thompson 				    &info->bus->non_giant_callback_proc,
238229bd7d7eSAndrew Thompson 				    &udev->cs_msg[0], &udev->cs_msg[1]);
238302ac6454SAndrew Thompson 			} else {
238402ac6454SAndrew Thompson 				/* should not happen */
238502ac6454SAndrew Thompson 				DPRINTFN(0, "No stall handler!\n");
238602ac6454SAndrew Thompson 			}
238702ac6454SAndrew Thompson 			/*
238829bd7d7eSAndrew Thompson 			 * Check if we should stall. Some USB hardware
238929bd7d7eSAndrew Thompson 			 * handles set- and clear-stall in hardware.
239002ac6454SAndrew Thompson 			 */
239129bd7d7eSAndrew Thompson 			if (did_stall) {
239229bd7d7eSAndrew Thompson 				/*
239329bd7d7eSAndrew Thompson 				 * The transfer will be continued when
239429bd7d7eSAndrew Thompson 				 * the clear-stall control endpoint
239529bd7d7eSAndrew Thompson 				 * message is received.
239629bd7d7eSAndrew Thompson 				 */
239729bd7d7eSAndrew Thompson 				ep->is_stalled = 1;
239802ac6454SAndrew Thompson 				return;
239902ac6454SAndrew Thompson 			}
240002ac6454SAndrew Thompson 		}
240129bd7d7eSAndrew Thompson 	}
240202ac6454SAndrew Thompson 	/* Set or clear stall complete - special case */
240302ac6454SAndrew Thompson 	if (xfer->nframes == 0) {
240402ac6454SAndrew Thompson 		/* we are complete */
240502ac6454SAndrew Thompson 		xfer->aframes = 0;
2406a593f6b8SAndrew Thompson 		usbd_transfer_done(xfer, 0);
240702ac6454SAndrew Thompson 		return;
240802ac6454SAndrew Thompson 	}
240902ac6454SAndrew Thompson 	/*
241002ac6454SAndrew Thompson 	 * Handled cases:
241102ac6454SAndrew Thompson 	 *
241202ac6454SAndrew Thompson 	 * 1) Start the first transfer queued.
241302ac6454SAndrew Thompson 	 *
241402ac6454SAndrew Thompson 	 * 2) Re-start the current USB transfer.
241502ac6454SAndrew Thompson 	 */
241602ac6454SAndrew Thompson 	/*
241702ac6454SAndrew Thompson 	 * Check if there should be any
241802ac6454SAndrew Thompson 	 * pre transfer start delay:
241902ac6454SAndrew Thompson 	 */
242002ac6454SAndrew Thompson 	if (xfer->interval > 0) {
2421ae60fdfbSAndrew Thompson 		type = (ep->edesc->bmAttributes & UE_XFERTYPE);
242202ac6454SAndrew Thompson 		if ((type == UE_BULK) ||
242302ac6454SAndrew Thompson 		    (type == UE_CONTROL)) {
2424a593f6b8SAndrew Thompson 			usbd_transfer_timeout_ms(xfer,
2425a593f6b8SAndrew Thompson 			    &usbd_transfer_start_cb,
242602ac6454SAndrew Thompson 			    xfer->interval);
242702ac6454SAndrew Thompson 			return;
242802ac6454SAndrew Thompson 		}
242902ac6454SAndrew Thompson 	}
243002ac6454SAndrew Thompson 	DPRINTF("start\n");
243102ac6454SAndrew Thompson 
243202ac6454SAndrew Thompson 	/* start USB transfer */
2433ae60fdfbSAndrew Thompson 	(ep->methods->start) (xfer);
243402ac6454SAndrew Thompson 
243502ac6454SAndrew Thompson 	xfer->flags_int.can_cancel_immed = 1;
24364565300dSAndrew Thompson 
24374565300dSAndrew Thompson 	/* check for error */
243802ac6454SAndrew Thompson 	if (xfer->error) {
243902ac6454SAndrew Thompson 		/* some error has happened */
2440a593f6b8SAndrew Thompson 		usbd_transfer_done(xfer, 0);
244102ac6454SAndrew Thompson 	}
244202ac6454SAndrew Thompson }
244302ac6454SAndrew Thompson 
244402ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2445a593f6b8SAndrew Thompson  *	usbd_transfer_timeout_ms
244602ac6454SAndrew Thompson  *
244702ac6454SAndrew Thompson  * This function is used to setup a timeout on the given USB
244802ac6454SAndrew Thompson  * transfer. If the timeout has been deferred the callback given by
244902ac6454SAndrew Thompson  * "cb" will get called after "ms" milliseconds.
245002ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
245102ac6454SAndrew Thompson void
2452a593f6b8SAndrew Thompson usbd_transfer_timeout_ms(struct usb_xfer *xfer,
2453e0a69b51SAndrew Thompson     void (*cb) (void *arg), usb_timeout_t ms)
245402ac6454SAndrew Thompson {
245502ac6454SAndrew Thompson 	USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
245602ac6454SAndrew Thompson 
245702ac6454SAndrew Thompson 	/* defer delay */
2458a593f6b8SAndrew Thompson 	usb_callout_reset(&xfer->timeout_handle,
245902ac6454SAndrew Thompson 	    USB_MS_TO_TICKS(ms), cb, xfer);
246002ac6454SAndrew Thompson }
246102ac6454SAndrew Thompson 
246202ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2463a593f6b8SAndrew Thompson  *	usbd_callback_wrapper_sub
246402ac6454SAndrew Thompson  *
246502ac6454SAndrew Thompson  *  - This function will update variables in an USB transfer after
246602ac6454SAndrew Thompson  *  that the USB transfer is complete.
246702ac6454SAndrew Thompson  *
246802ac6454SAndrew Thompson  *  - This function is used to start the next USB transfer on the
2469ae60fdfbSAndrew Thompson  *  ep transfer queue, if any.
247002ac6454SAndrew Thompson  *
247102ac6454SAndrew Thompson  * NOTE: In some special cases the USB transfer will not be removed from
247202ac6454SAndrew Thompson  * the pipe queue, but remain first. To enforce USB transfer removal call
247302ac6454SAndrew Thompson  * this function passing the error code "USB_ERR_CANCELLED".
247402ac6454SAndrew Thompson  *
247502ac6454SAndrew Thompson  * Return values:
247602ac6454SAndrew Thompson  * 0: Success.
247702ac6454SAndrew Thompson  * Else: The callback has been deferred.
247802ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
247902ac6454SAndrew Thompson static uint8_t
2480a593f6b8SAndrew Thompson usbd_callback_wrapper_sub(struct usb_xfer *xfer)
248102ac6454SAndrew Thompson {
2482ae60fdfbSAndrew Thompson 	struct usb_endpoint *ep;
2483e0a69b51SAndrew Thompson 	usb_frcount_t x;
248402ac6454SAndrew Thompson 
248502ac6454SAndrew Thompson 	if ((!xfer->flags_int.open) &&
248602ac6454SAndrew Thompson 	    (!xfer->flags_int.did_close)) {
248702ac6454SAndrew Thompson 		DPRINTF("close\n");
248802ac6454SAndrew Thompson 		USB_BUS_LOCK(xfer->xroot->bus);
2489ae60fdfbSAndrew Thompson 		(xfer->endpoint->methods->close) (xfer);
249002ac6454SAndrew Thompson 		USB_BUS_UNLOCK(xfer->xroot->bus);
249102ac6454SAndrew Thompson 		/* only close once */
249202ac6454SAndrew Thompson 		xfer->flags_int.did_close = 1;
249302ac6454SAndrew Thompson 		return (1);		/* wait for new callback */
249402ac6454SAndrew Thompson 	}
249502ac6454SAndrew Thompson 	/*
249602ac6454SAndrew Thompson 	 * If we have a non-hardware induced error we
249702ac6454SAndrew Thompson 	 * need to do the DMA delay!
249802ac6454SAndrew Thompson 	 */
249902ac6454SAndrew Thompson 	if (((xfer->error == USB_ERR_CANCELLED) ||
250002ac6454SAndrew Thompson 	    (xfer->error == USB_ERR_TIMEOUT)) &&
250102ac6454SAndrew Thompson 	    (!xfer->flags_int.did_dma_delay)) {
250202ac6454SAndrew Thompson 
2503e0a69b51SAndrew Thompson 		usb_timeout_t temp;
250402ac6454SAndrew Thompson 
2505a8725281SAndrew Thompson 		/* only delay once */
2506a8725281SAndrew Thompson 		xfer->flags_int.did_dma_delay = 1;
2507a8725281SAndrew Thompson 
250802ac6454SAndrew Thompson 		/* we can not cancel this delay */
250902ac6454SAndrew Thompson 		xfer->flags_int.can_cancel_immed = 0;
251002ac6454SAndrew Thompson 
2511a593f6b8SAndrew Thompson 		temp = usbd_get_dma_delay(xfer->xroot->bus);
251202ac6454SAndrew Thompson 
251302ac6454SAndrew Thompson 		DPRINTFN(3, "DMA delay, %u ms, "
251402ac6454SAndrew Thompson 		    "on %p\n", temp, xfer);
251502ac6454SAndrew Thompson 
251602ac6454SAndrew Thompson 		if (temp != 0) {
251702ac6454SAndrew Thompson 			USB_BUS_LOCK(xfer->xroot->bus);
2518a593f6b8SAndrew Thompson 			usbd_transfer_timeout_ms(xfer,
2519a593f6b8SAndrew Thompson 			    &usb_dma_delay_done_cb, temp);
252002ac6454SAndrew Thompson 			USB_BUS_UNLOCK(xfer->xroot->bus);
252102ac6454SAndrew Thompson 			return (1);	/* wait for new callback */
252202ac6454SAndrew Thompson 		}
252302ac6454SAndrew Thompson 	}
252402ac6454SAndrew Thompson 	/* check actual number of frames */
252502ac6454SAndrew Thompson 	if (xfer->aframes > xfer->nframes) {
252602ac6454SAndrew Thompson 		if (xfer->error == 0) {
252702ac6454SAndrew Thompson 			panic("%s: actual number of frames, %d, is "
252802ac6454SAndrew Thompson 			    "greater than initial number of frames, %d!\n",
252902ac6454SAndrew Thompson 			    __FUNCTION__, xfer->aframes, xfer->nframes);
253002ac6454SAndrew Thompson 		} else {
253102ac6454SAndrew Thompson 			/* just set some valid value */
253202ac6454SAndrew Thompson 			xfer->aframes = xfer->nframes;
253302ac6454SAndrew Thompson 		}
253402ac6454SAndrew Thompson 	}
253502ac6454SAndrew Thompson 	/* compute actual length */
253602ac6454SAndrew Thompson 	xfer->actlen = 0;
253702ac6454SAndrew Thompson 
253802ac6454SAndrew Thompson 	for (x = 0; x != xfer->aframes; x++) {
253902ac6454SAndrew Thompson 		xfer->actlen += xfer->frlengths[x];
254002ac6454SAndrew Thompson 	}
254102ac6454SAndrew Thompson 
254202ac6454SAndrew Thompson 	/*
254302ac6454SAndrew Thompson 	 * Frames that were not transferred get zero actual length in
254402ac6454SAndrew Thompson 	 * case the USB device driver does not check the actual number
254502ac6454SAndrew Thompson 	 * of frames transferred, "xfer->aframes":
254602ac6454SAndrew Thompson 	 */
254702ac6454SAndrew Thompson 	for (; x < xfer->nframes; x++) {
2548ed6d949aSAndrew Thompson 		usbd_xfer_set_frame_len(xfer, x, 0);
254902ac6454SAndrew Thompson 	}
255002ac6454SAndrew Thompson 
255102ac6454SAndrew Thompson 	/* check actual length */
255202ac6454SAndrew Thompson 	if (xfer->actlen > xfer->sumlen) {
255302ac6454SAndrew Thompson 		if (xfer->error == 0) {
255402ac6454SAndrew Thompson 			panic("%s: actual length, %d, is greater than "
255502ac6454SAndrew Thompson 			    "initial length, %d!\n",
255602ac6454SAndrew Thompson 			    __FUNCTION__, xfer->actlen, xfer->sumlen);
255702ac6454SAndrew Thompson 		} else {
255802ac6454SAndrew Thompson 			/* just set some valid value */
255902ac6454SAndrew Thompson 			xfer->actlen = xfer->sumlen;
256002ac6454SAndrew Thompson 		}
256102ac6454SAndrew Thompson 	}
2562ed6d949aSAndrew Thompson 	DPRINTFN(1, "xfer=%p endpoint=%p sts=%d alen=%d, slen=%d, afrm=%d, nfrm=%d\n",
2563ae60fdfbSAndrew Thompson 	    xfer, xfer->endpoint, xfer->error, xfer->actlen, xfer->sumlen,
256402ac6454SAndrew Thompson 	    xfer->aframes, xfer->nframes);
256502ac6454SAndrew Thompson 
256602ac6454SAndrew Thompson 	if (xfer->error) {
256702ac6454SAndrew Thompson 		/* end of control transfer, if any */
256802ac6454SAndrew Thompson 		xfer->flags_int.control_act = 0;
256902ac6454SAndrew Thompson 
257002ac6454SAndrew Thompson 		/* check if we should block the execution queue */
257102ac6454SAndrew Thompson 		if ((xfer->error != USB_ERR_CANCELLED) &&
257202ac6454SAndrew Thompson 		    (xfer->flags.pipe_bof)) {
257302ac6454SAndrew Thompson 			DPRINTFN(2, "xfer=%p: Block On Failure "
2574ae60fdfbSAndrew Thompson 			    "on endpoint=%p\n", xfer, xfer->endpoint);
257502ac6454SAndrew Thompson 			goto done;
257602ac6454SAndrew Thompson 		}
257702ac6454SAndrew Thompson 	} else {
257802ac6454SAndrew Thompson 		/* check for short transfers */
257902ac6454SAndrew Thompson 		if (xfer->actlen < xfer->sumlen) {
258002ac6454SAndrew Thompson 
258102ac6454SAndrew Thompson 			/* end of control transfer, if any */
258202ac6454SAndrew Thompson 			xfer->flags_int.control_act = 0;
258302ac6454SAndrew Thompson 
258402ac6454SAndrew Thompson 			if (!xfer->flags_int.short_xfer_ok) {
258502ac6454SAndrew Thompson 				xfer->error = USB_ERR_SHORT_XFER;
258602ac6454SAndrew Thompson 				if (xfer->flags.pipe_bof) {
258702ac6454SAndrew Thompson 					DPRINTFN(2, "xfer=%p: Block On Failure on "
2588ae60fdfbSAndrew Thompson 					    "Short Transfer on endpoint %p.\n",
2589ae60fdfbSAndrew Thompson 					    xfer, xfer->endpoint);
259002ac6454SAndrew Thompson 					goto done;
259102ac6454SAndrew Thompson 				}
259202ac6454SAndrew Thompson 			}
259302ac6454SAndrew Thompson 		} else {
259402ac6454SAndrew Thompson 			/*
259502ac6454SAndrew Thompson 			 * Check if we are in the middle of a
259602ac6454SAndrew Thompson 			 * control transfer:
259702ac6454SAndrew Thompson 			 */
259802ac6454SAndrew Thompson 			if (xfer->flags_int.control_act) {
259902ac6454SAndrew Thompson 				DPRINTFN(5, "xfer=%p: Control transfer "
2600ae60fdfbSAndrew Thompson 				    "active on endpoint=%p\n", xfer, xfer->endpoint);
260102ac6454SAndrew Thompson 				goto done;
260202ac6454SAndrew Thompson 			}
260302ac6454SAndrew Thompson 		}
260402ac6454SAndrew Thompson 	}
260502ac6454SAndrew Thompson 
2606ae60fdfbSAndrew Thompson 	ep = xfer->endpoint;
260702ac6454SAndrew Thompson 
260802ac6454SAndrew Thompson 	/*
260902ac6454SAndrew Thompson 	 * If the current USB transfer is completing we need to start the
261002ac6454SAndrew Thompson 	 * next one:
261102ac6454SAndrew Thompson 	 */
261202ac6454SAndrew Thompson 	USB_BUS_LOCK(xfer->xroot->bus);
2613ae60fdfbSAndrew Thompson 	if (ep->endpoint_q.curr == xfer) {
2614a593f6b8SAndrew Thompson 		usb_command_wrapper(&ep->endpoint_q, NULL);
261502ac6454SAndrew Thompson 
2616ae60fdfbSAndrew Thompson 		if (ep->endpoint_q.curr || TAILQ_FIRST(&ep->endpoint_q.head)) {
261702ac6454SAndrew Thompson 			/* there is another USB transfer waiting */
261802ac6454SAndrew Thompson 		} else {
261902ac6454SAndrew Thompson 			/* this is the last USB transfer */
262002ac6454SAndrew Thompson 			/* clear isochronous sync flag */
2621ae60fdfbSAndrew Thompson 			xfer->endpoint->is_synced = 0;
262202ac6454SAndrew Thompson 		}
262302ac6454SAndrew Thompson 	}
262402ac6454SAndrew Thompson 	USB_BUS_UNLOCK(xfer->xroot->bus);
262502ac6454SAndrew Thompson done:
262602ac6454SAndrew Thompson 	return (0);
262702ac6454SAndrew Thompson }
262802ac6454SAndrew Thompson 
262902ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2630a593f6b8SAndrew Thompson  *	usb_command_wrapper
263102ac6454SAndrew Thompson  *
263202ac6454SAndrew Thompson  * This function is used to execute commands non-recursivly on an USB
263302ac6454SAndrew Thompson  * transfer.
263402ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
263502ac6454SAndrew Thompson void
2636a593f6b8SAndrew Thompson usb_command_wrapper(struct usb_xfer_queue *pq, struct usb_xfer *xfer)
263702ac6454SAndrew Thompson {
263802ac6454SAndrew Thompson 	if (xfer) {
263902ac6454SAndrew Thompson 		/*
264002ac6454SAndrew Thompson 		 * If the transfer is not already processing,
264102ac6454SAndrew Thompson 		 * queue it!
264202ac6454SAndrew Thompson 		 */
264302ac6454SAndrew Thompson 		if (pq->curr != xfer) {
2644a593f6b8SAndrew Thompson 			usbd_transfer_enqueue(pq, xfer);
264502ac6454SAndrew Thompson 			if (pq->curr != NULL) {
264602ac6454SAndrew Thompson 				/* something is already processing */
264702ac6454SAndrew Thompson 				DPRINTFN(6, "busy %p\n", pq->curr);
264802ac6454SAndrew Thompson 				return;
264902ac6454SAndrew Thompson 			}
265002ac6454SAndrew Thompson 		}
265102ac6454SAndrew Thompson 	} else {
265202ac6454SAndrew Thompson 		/* Get next element in queue */
265302ac6454SAndrew Thompson 		pq->curr = NULL;
265402ac6454SAndrew Thompson 	}
265502ac6454SAndrew Thompson 
265602ac6454SAndrew Thompson 	if (!pq->recurse_1) {
265702ac6454SAndrew Thompson 
265802ac6454SAndrew Thompson 		do {
265902ac6454SAndrew Thompson 
266002ac6454SAndrew Thompson 			/* set both recurse flags */
266102ac6454SAndrew Thompson 			pq->recurse_1 = 1;
266202ac6454SAndrew Thompson 			pq->recurse_2 = 1;
266302ac6454SAndrew Thompson 
266402ac6454SAndrew Thompson 			if (pq->curr == NULL) {
266502ac6454SAndrew Thompson 				xfer = TAILQ_FIRST(&pq->head);
266602ac6454SAndrew Thompson 				if (xfer) {
266702ac6454SAndrew Thompson 					TAILQ_REMOVE(&pq->head, xfer,
266802ac6454SAndrew Thompson 					    wait_entry);
266902ac6454SAndrew Thompson 					xfer->wait_queue = NULL;
267002ac6454SAndrew Thompson 					pq->curr = xfer;
267102ac6454SAndrew Thompson 				} else {
267202ac6454SAndrew Thompson 					break;
267302ac6454SAndrew Thompson 				}
267402ac6454SAndrew Thompson 			}
267502ac6454SAndrew Thompson 			DPRINTFN(6, "cb %p (enter)\n", pq->curr);
267602ac6454SAndrew Thompson 			(pq->command) (pq);
267702ac6454SAndrew Thompson 			DPRINTFN(6, "cb %p (leave)\n", pq->curr);
267802ac6454SAndrew Thompson 
267902ac6454SAndrew Thompson 		} while (!pq->recurse_2);
268002ac6454SAndrew Thompson 
268102ac6454SAndrew Thompson 		/* clear first recurse flag */
268202ac6454SAndrew Thompson 		pq->recurse_1 = 0;
268302ac6454SAndrew Thompson 
268402ac6454SAndrew Thompson 	} else {
268502ac6454SAndrew Thompson 		/* clear second recurse flag */
268602ac6454SAndrew Thompson 		pq->recurse_2 = 0;
268702ac6454SAndrew Thompson 	}
268802ac6454SAndrew Thompson }
268902ac6454SAndrew Thompson 
269002ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2691a593f6b8SAndrew Thompson  *	usbd_default_transfer_setup
269202ac6454SAndrew Thompson  *
269302ac6454SAndrew Thompson  * This function is used to setup the default USB control endpoint
269402ac6454SAndrew Thompson  * transfer.
269502ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
269602ac6454SAndrew Thompson void
2697a593f6b8SAndrew Thompson usbd_default_transfer_setup(struct usb_device *udev)
269802ac6454SAndrew Thompson {
2699760bc48eSAndrew Thompson 	struct usb_xfer *xfer;
270002ac6454SAndrew Thompson 	uint8_t no_resetup;
270102ac6454SAndrew Thompson 	uint8_t iface_index;
270202ac6454SAndrew Thompson 
270339307315SAndrew Thompson 	/* check for root HUB */
270439307315SAndrew Thompson 	if (udev->parent_hub == NULL)
270539307315SAndrew Thompson 		return;
270602ac6454SAndrew Thompson repeat:
270702ac6454SAndrew Thompson 
270802ac6454SAndrew Thompson 	xfer = udev->default_xfer[0];
270902ac6454SAndrew Thompson 	if (xfer) {
271002ac6454SAndrew Thompson 		USB_XFER_LOCK(xfer);
271102ac6454SAndrew Thompson 		no_resetup =
271202ac6454SAndrew Thompson 		    ((xfer->address == udev->address) &&
271302ac6454SAndrew Thompson 		    (udev->default_ep_desc.wMaxPacketSize[0] ==
271402ac6454SAndrew Thompson 		    udev->ddesc.bMaxPacketSize));
2715f29a0724SAndrew Thompson 		if (udev->flags.usb_mode == USB_MODE_DEVICE) {
271602ac6454SAndrew Thompson 			if (no_resetup) {
271702ac6454SAndrew Thompson 				/*
271802ac6454SAndrew Thompson 				 * NOTE: checking "xfer->address" and
271902ac6454SAndrew Thompson 				 * starting the USB transfer must be
272002ac6454SAndrew Thompson 				 * atomic!
272102ac6454SAndrew Thompson 				 */
2722a593f6b8SAndrew Thompson 				usbd_transfer_start(xfer);
272302ac6454SAndrew Thompson 			}
272402ac6454SAndrew Thompson 		}
272502ac6454SAndrew Thompson 		USB_XFER_UNLOCK(xfer);
272602ac6454SAndrew Thompson 	} else {
272702ac6454SAndrew Thompson 		no_resetup = 0;
272802ac6454SAndrew Thompson 	}
272902ac6454SAndrew Thompson 
273002ac6454SAndrew Thompson 	if (no_resetup) {
273102ac6454SAndrew Thompson 		/*
273202ac6454SAndrew Thompson 	         * All parameters are exactly the same like before.
273302ac6454SAndrew Thompson 	         * Just return.
273402ac6454SAndrew Thompson 	         */
273502ac6454SAndrew Thompson 		return;
273602ac6454SAndrew Thompson 	}
273702ac6454SAndrew Thompson 	/*
273802ac6454SAndrew Thompson 	 * Update wMaxPacketSize for the default control endpoint:
273902ac6454SAndrew Thompson 	 */
274002ac6454SAndrew Thompson 	udev->default_ep_desc.wMaxPacketSize[0] =
274102ac6454SAndrew Thompson 	    udev->ddesc.bMaxPacketSize;
274202ac6454SAndrew Thompson 
274302ac6454SAndrew Thompson 	/*
274402ac6454SAndrew Thompson 	 * Unsetup any existing USB transfer:
274502ac6454SAndrew Thompson 	 */
2746a593f6b8SAndrew Thompson 	usbd_transfer_unsetup(udev->default_xfer, USB_DEFAULT_XFER_MAX);
274702ac6454SAndrew Thompson 
274802ac6454SAndrew Thompson 	/*
274902ac6454SAndrew Thompson 	 * Try to setup a new USB transfer for the
275002ac6454SAndrew Thompson 	 * default control endpoint:
275102ac6454SAndrew Thompson 	 */
275202ac6454SAndrew Thompson 	iface_index = 0;
2753a593f6b8SAndrew Thompson 	if (usbd_transfer_setup(udev, &iface_index,
2754a593f6b8SAndrew Thompson 	    udev->default_xfer, usb_control_ep_cfg, USB_DEFAULT_XFER_MAX, NULL,
275502ac6454SAndrew Thompson 	    udev->default_mtx)) {
275602ac6454SAndrew Thompson 		DPRINTFN(0, "could not setup default "
275702ac6454SAndrew Thompson 		    "USB transfer!\n");
275802ac6454SAndrew Thompson 	} else {
275902ac6454SAndrew Thompson 		goto repeat;
276002ac6454SAndrew Thompson 	}
276102ac6454SAndrew Thompson }
276202ac6454SAndrew Thompson 
276302ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2764a593f6b8SAndrew Thompson  *	usbd_clear_data_toggle - factored out code
276502ac6454SAndrew Thompson  *
276602ac6454SAndrew Thompson  * NOTE: the intention of this function is not to reset the hardware
276702ac6454SAndrew Thompson  * data toggle.
276802ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
276902ac6454SAndrew Thompson void
2770a593f6b8SAndrew Thompson usbd_clear_data_toggle(struct usb_device *udev, struct usb_endpoint *ep)
277102ac6454SAndrew Thompson {
2772ae60fdfbSAndrew Thompson 	DPRINTFN(5, "udev=%p endpoint=%p\n", udev, ep);
277302ac6454SAndrew Thompson 
277402ac6454SAndrew Thompson 	USB_BUS_LOCK(udev->bus);
2775ae60fdfbSAndrew Thompson 	ep->toggle_next = 0;
277602ac6454SAndrew Thompson 	USB_BUS_UNLOCK(udev->bus);
277702ac6454SAndrew Thompson }
277802ac6454SAndrew Thompson 
277902ac6454SAndrew Thompson /*------------------------------------------------------------------------*
2780a593f6b8SAndrew Thompson  *	usbd_clear_stall_callback - factored out clear stall callback
278102ac6454SAndrew Thompson  *
278202ac6454SAndrew Thompson  * Input parameters:
278302ac6454SAndrew Thompson  *  xfer1: Clear Stall Control Transfer
278402ac6454SAndrew Thompson  *  xfer2: Stalled USB Transfer
278502ac6454SAndrew Thompson  *
278602ac6454SAndrew Thompson  * This function is NULL safe.
278702ac6454SAndrew Thompson  *
278802ac6454SAndrew Thompson  * Return values:
278902ac6454SAndrew Thompson  *   0: In progress
279002ac6454SAndrew Thompson  *   Else: Finished
279102ac6454SAndrew Thompson  *
279202ac6454SAndrew Thompson  * Clear stall config example:
279302ac6454SAndrew Thompson  *
2794760bc48eSAndrew Thompson  * static const struct usb_config my_clearstall =  {
279502ac6454SAndrew Thompson  *	.type = UE_CONTROL,
279602ac6454SAndrew Thompson  *	.endpoint = 0,
279702ac6454SAndrew Thompson  *	.direction = UE_DIR_ANY,
279802ac6454SAndrew Thompson  *	.interval = 50, //50 milliseconds
2799760bc48eSAndrew Thompson  *	.bufsize = sizeof(struct usb_device_request),
28004eae601eSAndrew Thompson  *	.timeout = 1000, //1.000 seconds
28014eae601eSAndrew Thompson  *	.callback = &my_clear_stall_callback, // **
28024eae601eSAndrew Thompson  *	.usb_mode = USB_MODE_HOST,
280302ac6454SAndrew Thompson  * };
280402ac6454SAndrew Thompson  *
2805a593f6b8SAndrew Thompson  * ** "my_clear_stall_callback" calls "usbd_clear_stall_callback"
280602ac6454SAndrew Thompson  * passing the correct parameters.
280702ac6454SAndrew Thompson  *------------------------------------------------------------------------*/
280802ac6454SAndrew Thompson uint8_t
2809a593f6b8SAndrew Thompson usbd_clear_stall_callback(struct usb_xfer *xfer1,
2810760bc48eSAndrew Thompson     struct usb_xfer *xfer2)
281102ac6454SAndrew Thompson {
2812760bc48eSAndrew Thompson 	struct usb_device_request req;
281302ac6454SAndrew Thompson 
281402ac6454SAndrew Thompson 	if (xfer2 == NULL) {
281502ac6454SAndrew Thompson 		/* looks like we are tearing down */
281602ac6454SAndrew Thompson 		DPRINTF("NULL input parameter\n");
281702ac6454SAndrew Thompson 		return (0);
281802ac6454SAndrew Thompson 	}
281902ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer1, MA_OWNED);
282002ac6454SAndrew Thompson 	USB_XFER_LOCK_ASSERT(xfer2, MA_OWNED);
282102ac6454SAndrew Thompson 
282202ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer1)) {
282302ac6454SAndrew Thompson 	case USB_ST_SETUP:
282402ac6454SAndrew Thompson 
282502ac6454SAndrew Thompson 		/*
282602ac6454SAndrew Thompson 		 * pre-clear the data toggle to DATA0 ("umass.c" and
282702ac6454SAndrew Thompson 		 * "ata-usb.c" depends on this)
282802ac6454SAndrew Thompson 		 */
282902ac6454SAndrew Thompson 
2830a593f6b8SAndrew Thompson 		usbd_clear_data_toggle(xfer2->xroot->udev, xfer2->endpoint);
283102ac6454SAndrew Thompson 
283202ac6454SAndrew Thompson 		/* setup a clear-stall packet */
283302ac6454SAndrew Thompson 
283402ac6454SAndrew Thompson 		req.bmRequestType = UT_WRITE_ENDPOINT;
283502ac6454SAndrew Thompson 		req.bRequest = UR_CLEAR_FEATURE;
283602ac6454SAndrew Thompson 		USETW(req.wValue, UF_ENDPOINT_HALT);
2837ae60fdfbSAndrew Thompson 		req.wIndex[0] = xfer2->endpoint->edesc->bEndpointAddress;
283802ac6454SAndrew Thompson 		req.wIndex[1] = 0;
283902ac6454SAndrew Thompson 		USETW(req.wLength, 0);
284002ac6454SAndrew Thompson 
284102ac6454SAndrew Thompson 		/*
2842a593f6b8SAndrew Thompson 		 * "usbd_transfer_setup_sub()" will ensure that
284302ac6454SAndrew Thompson 		 * we have sufficient room in the buffer for
284402ac6454SAndrew Thompson 		 * the request structure!
284502ac6454SAndrew Thompson 		 */
284602ac6454SAndrew Thompson 
284702ac6454SAndrew Thompson 		/* copy in the transfer */
284802ac6454SAndrew Thompson 
2849a593f6b8SAndrew Thompson 		usbd_copy_in(xfer1->frbuffers, 0, &req, sizeof(req));
285002ac6454SAndrew Thompson 
285102ac6454SAndrew Thompson 		/* set length */
285202ac6454SAndrew Thompson 		xfer1->frlengths[0] = sizeof(req);
285302ac6454SAndrew Thompson 		xfer1->nframes = 1;
285402ac6454SAndrew Thompson 
2855a593f6b8SAndrew Thompson 		usbd_transfer_submit(xfer1);
285602ac6454SAndrew Thompson 		return (0);
285702ac6454SAndrew Thompson 
285802ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
285902ac6454SAndrew Thompson 		break;
286002ac6454SAndrew Thompson 
286102ac6454SAndrew Thompson 	default:			/* Error */
286202ac6454SAndrew Thompson 		if (xfer1->error == USB_ERR_CANCELLED) {
286302ac6454SAndrew Thompson 			return (0);
286402ac6454SAndrew Thompson 		}
286502ac6454SAndrew Thompson 		break;
286602ac6454SAndrew Thompson 	}
286702ac6454SAndrew Thompson 	return (1);			/* Clear Stall Finished */
286802ac6454SAndrew Thompson }
286902ac6454SAndrew Thompson 
2870dddb25f9SAlfred Perlstein /*------------------------------------------------------------------------*
2871dddb25f9SAlfred Perlstein  *	usbd_transfer_poll
2872dddb25f9SAlfred Perlstein  *
2873dddb25f9SAlfred Perlstein  * The following function gets called from the USB keyboard driver and
2874dddb25f9SAlfred Perlstein  * UMASS when the system has paniced.
2875dddb25f9SAlfred Perlstein  *
2876dddb25f9SAlfred Perlstein  * NOTE: It is currently not possible to resume normal operation on
2877dddb25f9SAlfred Perlstein  * the USB controller which has been polled, due to clearing of the
2878dddb25f9SAlfred Perlstein  * "up_dsleep" and "up_msleep" flags.
2879dddb25f9SAlfred Perlstein  *------------------------------------------------------------------------*/
288002ac6454SAndrew Thompson void
2881ed6d949aSAndrew Thompson usbd_transfer_poll(struct usb_xfer **ppxfer, uint16_t max)
288202ac6454SAndrew Thompson {
2883dddb25f9SAlfred Perlstein 	struct usb_xfer *xfer;
2884dddb25f9SAlfred Perlstein 	struct usb_xfer_root *xroot;
2885dddb25f9SAlfred Perlstein 	struct usb_device *udev;
2886dddb25f9SAlfred Perlstein 	struct usb_proc_msg *pm;
2887dddb25f9SAlfred Perlstein 	uint16_t n;
2888dddb25f9SAlfred Perlstein 	uint16_t drop_bus;
2889dddb25f9SAlfred Perlstein 	uint16_t drop_xfer;
2890dddb25f9SAlfred Perlstein 
2891dddb25f9SAlfred Perlstein 	for (n = 0; n != max; n++) {
2892dddb25f9SAlfred Perlstein 		/* Extra checks to avoid panic */
2893dddb25f9SAlfred Perlstein 		xfer = ppxfer[n];
2894dddb25f9SAlfred Perlstein 		if (xfer == NULL)
2895dddb25f9SAlfred Perlstein 			continue;	/* no USB transfer */
2896dddb25f9SAlfred Perlstein 		xroot = xfer->xroot;
2897dddb25f9SAlfred Perlstein 		if (xroot == NULL)
2898dddb25f9SAlfred Perlstein 			continue;	/* no USB root */
2899dddb25f9SAlfred Perlstein 		udev = xroot->udev;
2900dddb25f9SAlfred Perlstein 		if (udev == NULL)
2901dddb25f9SAlfred Perlstein 			continue;	/* no USB device */
2902dddb25f9SAlfred Perlstein 		if (udev->bus == NULL)
2903dddb25f9SAlfred Perlstein 			continue;	/* no BUS structure */
2904dddb25f9SAlfred Perlstein 		if (udev->bus->methods == NULL)
2905dddb25f9SAlfred Perlstein 			continue;	/* no BUS methods */
2906dddb25f9SAlfred Perlstein 		if (udev->bus->methods->xfer_poll == NULL)
2907dddb25f9SAlfred Perlstein 			continue;	/* no poll method */
2908dddb25f9SAlfred Perlstein 
2909dddb25f9SAlfred Perlstein 		/* make sure that the BUS mutex is not locked */
2910dddb25f9SAlfred Perlstein 		drop_bus = 0;
2911dddb25f9SAlfred Perlstein 		while (mtx_owned(&xroot->udev->bus->bus_mtx)) {
2912dddb25f9SAlfred Perlstein 			mtx_unlock(&xroot->udev->bus->bus_mtx);
2913dddb25f9SAlfred Perlstein 			drop_bus++;
2914dddb25f9SAlfred Perlstein 		}
2915dddb25f9SAlfred Perlstein 
2916dddb25f9SAlfred Perlstein 		/* make sure that the transfer mutex is not locked */
2917dddb25f9SAlfred Perlstein 		drop_xfer = 0;
2918dddb25f9SAlfred Perlstein 		while (mtx_owned(xroot->xfer_mtx)) {
2919dddb25f9SAlfred Perlstein 			mtx_unlock(xroot->xfer_mtx);
2920dddb25f9SAlfred Perlstein 			drop_xfer++;
2921dddb25f9SAlfred Perlstein 		}
2922dddb25f9SAlfred Perlstein 
2923dddb25f9SAlfred Perlstein 		/* Make sure cv_signal() and cv_broadcast() is not called */
2924dddb25f9SAlfred Perlstein 		udev->bus->control_xfer_proc.up_msleep = 0;
2925dddb25f9SAlfred Perlstein 		udev->bus->explore_proc.up_msleep = 0;
2926dddb25f9SAlfred Perlstein 		udev->bus->giant_callback_proc.up_msleep = 0;
2927dddb25f9SAlfred Perlstein 		udev->bus->non_giant_callback_proc.up_msleep = 0;
2928dddb25f9SAlfred Perlstein 
2929dddb25f9SAlfred Perlstein 		/* poll USB hardware */
2930dddb25f9SAlfred Perlstein 		(udev->bus->methods->xfer_poll) (udev->bus);
2931dddb25f9SAlfred Perlstein 
2932dddb25f9SAlfred Perlstein 		USB_BUS_LOCK(xroot->bus);
2933dddb25f9SAlfred Perlstein 
2934dddb25f9SAlfred Perlstein 		/* check for clear stall */
2935dddb25f9SAlfred Perlstein 		if (udev->default_xfer[1] != NULL) {
2936dddb25f9SAlfred Perlstein 
2937dddb25f9SAlfred Perlstein 			/* poll clear stall start */
2938dddb25f9SAlfred Perlstein 			pm = &udev->cs_msg[0].hdr;
2939dddb25f9SAlfred Perlstein 			(pm->pm_callback) (pm);
2940dddb25f9SAlfred Perlstein 			/* poll clear stall done thread */
2941dddb25f9SAlfred Perlstein 			pm = &udev->default_xfer[1]->
2942dddb25f9SAlfred Perlstein 			    xroot->done_m[0].hdr;
2943dddb25f9SAlfred Perlstein 			(pm->pm_callback) (pm);
2944dddb25f9SAlfred Perlstein 		}
2945dddb25f9SAlfred Perlstein 
2946dddb25f9SAlfred Perlstein 		/* poll done thread */
2947dddb25f9SAlfred Perlstein 		pm = &xroot->done_m[0].hdr;
2948dddb25f9SAlfred Perlstein 		(pm->pm_callback) (pm);
2949dddb25f9SAlfred Perlstein 
2950dddb25f9SAlfred Perlstein 		USB_BUS_UNLOCK(xroot->bus);
2951dddb25f9SAlfred Perlstein 
2952dddb25f9SAlfred Perlstein 		/* restore transfer mutex */
2953dddb25f9SAlfred Perlstein 		while (drop_xfer--)
2954dddb25f9SAlfred Perlstein 			mtx_lock(xroot->xfer_mtx);
2955dddb25f9SAlfred Perlstein 
2956dddb25f9SAlfred Perlstein 		/* restore BUS mutex */
2957dddb25f9SAlfred Perlstein 		while (drop_bus--)
2958dddb25f9SAlfred Perlstein 			mtx_lock(&xroot->udev->bus->bus_mtx);
295902ac6454SAndrew Thompson 	}
296002ac6454SAndrew Thompson }
29614eae601eSAndrew Thompson 
29624eae601eSAndrew Thompson static void
2963a593f6b8SAndrew Thompson usbd_get_std_packet_size(struct usb_std_packet_size *ptr,
29648d2dd5ddSAndrew Thompson     uint8_t type, enum usb_dev_speed speed)
29654eae601eSAndrew Thompson {
29664eae601eSAndrew Thompson 	static const uint16_t intr_range_max[USB_SPEED_MAX] = {
29674eae601eSAndrew Thompson 		[USB_SPEED_LOW] = 8,
29684eae601eSAndrew Thompson 		[USB_SPEED_FULL] = 64,
29694eae601eSAndrew Thompson 		[USB_SPEED_HIGH] = 1024,
29704eae601eSAndrew Thompson 		[USB_SPEED_VARIABLE] = 1024,
29714eae601eSAndrew Thompson 		[USB_SPEED_SUPER] = 1024,
29724eae601eSAndrew Thompson 	};
29734eae601eSAndrew Thompson 
29744eae601eSAndrew Thompson 	static const uint16_t isoc_range_max[USB_SPEED_MAX] = {
29754eae601eSAndrew Thompson 		[USB_SPEED_LOW] = 0,	/* invalid */
29764eae601eSAndrew Thompson 		[USB_SPEED_FULL] = 1023,
29774eae601eSAndrew Thompson 		[USB_SPEED_HIGH] = 1024,
29784eae601eSAndrew Thompson 		[USB_SPEED_VARIABLE] = 3584,
29794eae601eSAndrew Thompson 		[USB_SPEED_SUPER] = 1024,
29804eae601eSAndrew Thompson 	};
29814eae601eSAndrew Thompson 
29824eae601eSAndrew Thompson 	static const uint16_t control_min[USB_SPEED_MAX] = {
29834eae601eSAndrew Thompson 		[USB_SPEED_LOW] = 8,
29844eae601eSAndrew Thompson 		[USB_SPEED_FULL] = 8,
29854eae601eSAndrew Thompson 		[USB_SPEED_HIGH] = 64,
29864eae601eSAndrew Thompson 		[USB_SPEED_VARIABLE] = 512,
29874eae601eSAndrew Thompson 		[USB_SPEED_SUPER] = 512,
29884eae601eSAndrew Thompson 	};
29894eae601eSAndrew Thompson 
29904eae601eSAndrew Thompson 	static const uint16_t bulk_min[USB_SPEED_MAX] = {
29914eae601eSAndrew Thompson 		[USB_SPEED_LOW] = 0,	/* not supported */
29924eae601eSAndrew Thompson 		[USB_SPEED_FULL] = 8,
29934eae601eSAndrew Thompson 		[USB_SPEED_HIGH] = 512,
29944eae601eSAndrew Thompson 		[USB_SPEED_VARIABLE] = 512,
29954eae601eSAndrew Thompson 		[USB_SPEED_SUPER] = 1024,
29964eae601eSAndrew Thompson 	};
29974eae601eSAndrew Thompson 
29984eae601eSAndrew Thompson 	uint16_t temp;
29994eae601eSAndrew Thompson 
30004eae601eSAndrew Thompson 	memset(ptr, 0, sizeof(*ptr));
30014eae601eSAndrew Thompson 
30024eae601eSAndrew Thompson 	switch (type) {
30034eae601eSAndrew Thompson 	case UE_INTERRUPT:
30048d2dd5ddSAndrew Thompson 		ptr->range.max = intr_range_max[speed];
30054eae601eSAndrew Thompson 		break;
30064eae601eSAndrew Thompson 	case UE_ISOCHRONOUS:
30078d2dd5ddSAndrew Thompson 		ptr->range.max = isoc_range_max[speed];
30084eae601eSAndrew Thompson 		break;
30094eae601eSAndrew Thompson 	default:
30104eae601eSAndrew Thompson 		if (type == UE_BULK)
30118d2dd5ddSAndrew Thompson 			temp = bulk_min[speed];
30124eae601eSAndrew Thompson 		else /* UE_CONTROL */
30138d2dd5ddSAndrew Thompson 			temp = control_min[speed];
30144eae601eSAndrew Thompson 
30154eae601eSAndrew Thompson 		/* default is fixed */
30164eae601eSAndrew Thompson 		ptr->fixed[0] = temp;
30174eae601eSAndrew Thompson 		ptr->fixed[1] = temp;
30184eae601eSAndrew Thompson 		ptr->fixed[2] = temp;
30194eae601eSAndrew Thompson 		ptr->fixed[3] = temp;
30204eae601eSAndrew Thompson 
30218d2dd5ddSAndrew Thompson 		if (speed == USB_SPEED_FULL) {
30224eae601eSAndrew Thompson 			/* multiple sizes */
30234eae601eSAndrew Thompson 			ptr->fixed[1] = 16;
30244eae601eSAndrew Thompson 			ptr->fixed[2] = 32;
30254eae601eSAndrew Thompson 			ptr->fixed[3] = 64;
30264eae601eSAndrew Thompson 		}
30278d2dd5ddSAndrew Thompson 		if ((speed == USB_SPEED_VARIABLE) &&
30284eae601eSAndrew Thompson 		    (type == UE_BULK)) {
30294eae601eSAndrew Thompson 			/* multiple sizes */
30304eae601eSAndrew Thompson 			ptr->fixed[2] = 1024;
30314eae601eSAndrew Thompson 			ptr->fixed[3] = 1536;
30324eae601eSAndrew Thompson 		}
30334eae601eSAndrew Thompson 		break;
30344eae601eSAndrew Thompson 	}
30354eae601eSAndrew Thompson }
3036ed6d949aSAndrew Thompson 
3037ed6d949aSAndrew Thompson void	*
3038ed6d949aSAndrew Thompson usbd_xfer_softc(struct usb_xfer *xfer)
3039ed6d949aSAndrew Thompson {
3040ed6d949aSAndrew Thompson 	return (xfer->priv_sc);
3041ed6d949aSAndrew Thompson }
3042ed6d949aSAndrew Thompson 
3043ed6d949aSAndrew Thompson void *
3044ed6d949aSAndrew Thompson usbd_xfer_get_priv(struct usb_xfer *xfer)
3045ed6d949aSAndrew Thompson {
3046ed6d949aSAndrew Thompson 	return (xfer->priv_fifo);
3047ed6d949aSAndrew Thompson }
3048ed6d949aSAndrew Thompson 
3049ed6d949aSAndrew Thompson void
3050ed6d949aSAndrew Thompson usbd_xfer_set_priv(struct usb_xfer *xfer, void *ptr)
3051ed6d949aSAndrew Thompson {
3052ed6d949aSAndrew Thompson 	xfer->priv_fifo = ptr;
3053ed6d949aSAndrew Thompson }
3054ed6d949aSAndrew Thompson 
3055ed6d949aSAndrew Thompson uint8_t
3056ed6d949aSAndrew Thompson usbd_xfer_state(struct usb_xfer *xfer)
3057ed6d949aSAndrew Thompson {
3058ed6d949aSAndrew Thompson 	return (xfer->usb_state);
3059ed6d949aSAndrew Thompson }
3060ed6d949aSAndrew Thompson 
3061ed6d949aSAndrew Thompson void
3062ed6d949aSAndrew Thompson usbd_xfer_set_flag(struct usb_xfer *xfer, int flag)
3063ed6d949aSAndrew Thompson {
3064ed6d949aSAndrew Thompson 	switch (flag) {
3065ed6d949aSAndrew Thompson 		case USB_FORCE_SHORT_XFER:
3066ed6d949aSAndrew Thompson 			xfer->flags.force_short_xfer = 1;
3067ed6d949aSAndrew Thompson 			break;
3068ed6d949aSAndrew Thompson 		case USB_SHORT_XFER_OK:
3069ed6d949aSAndrew Thompson 			xfer->flags.short_xfer_ok = 1;
3070ed6d949aSAndrew Thompson 			break;
307129bd7d7eSAndrew Thompson 		case USB_MULTI_SHORT_OK:
307229bd7d7eSAndrew Thompson 			xfer->flags.short_frames_ok = 1;
307329bd7d7eSAndrew Thompson 			break;
307429bd7d7eSAndrew Thompson 		case USB_MANUAL_STATUS:
307529bd7d7eSAndrew Thompson 			xfer->flags.manual_status = 1;
307629bd7d7eSAndrew Thompson 			break;
3077ed6d949aSAndrew Thompson 	}
3078ed6d949aSAndrew Thompson }
3079ed6d949aSAndrew Thompson 
3080ed6d949aSAndrew Thompson void
3081ed6d949aSAndrew Thompson usbd_xfer_clr_flag(struct usb_xfer *xfer, int flag)
3082ed6d949aSAndrew Thompson {
3083ed6d949aSAndrew Thompson 	switch (flag) {
3084ed6d949aSAndrew Thompson 		case USB_FORCE_SHORT_XFER:
3085ed6d949aSAndrew Thompson 			xfer->flags.force_short_xfer = 0;
3086ed6d949aSAndrew Thompson 			break;
3087ed6d949aSAndrew Thompson 		case USB_SHORT_XFER_OK:
3088ed6d949aSAndrew Thompson 			xfer->flags.short_xfer_ok = 0;
3089ed6d949aSAndrew Thompson 			break;
309029bd7d7eSAndrew Thompson 		case USB_MULTI_SHORT_OK:
309129bd7d7eSAndrew Thompson 			xfer->flags.short_frames_ok = 0;
309229bd7d7eSAndrew Thompson 			break;
309329bd7d7eSAndrew Thompson 		case USB_MANUAL_STATUS:
309429bd7d7eSAndrew Thompson 			xfer->flags.manual_status = 0;
309529bd7d7eSAndrew Thompson 			break;
3096ed6d949aSAndrew Thompson 	}
3097ed6d949aSAndrew Thompson }
309829bd7d7eSAndrew Thompson 
309929bd7d7eSAndrew Thompson /*
310029bd7d7eSAndrew Thompson  * The following function returns in milliseconds when the isochronous
310129bd7d7eSAndrew Thompson  * transfer was completed by the hardware. The returned value wraps
310229bd7d7eSAndrew Thompson  * around 65536 milliseconds.
310329bd7d7eSAndrew Thompson  */
310429bd7d7eSAndrew Thompson uint16_t
310529bd7d7eSAndrew Thompson usbd_xfer_get_timestamp(struct usb_xfer *xfer)
310629bd7d7eSAndrew Thompson {
310729bd7d7eSAndrew Thompson 	return (xfer->isoc_time_complete);
310829bd7d7eSAndrew Thompson }
3109