 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvideo.c,v 1.16 2008/09/20 21:05:58 jmcneill Exp $	*/
+/*	$NetBSD: uvideo.c,v 1.17 2008/09/21 14:13:24 jmcneill Exp $	*/
 /*
  * Copyright (c) 2008 Patrick Mahoney
  * All rights reserved.
+ *
  * This code was written by Patrick Mahoney (pat@polycrystal.org) as
  * part of Google Summer of Code 2008.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -32,64 +32,66 @@
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * USB video specs:
  *      http://www.usb.org/developers/devclass_docs/USB_Video_Class_1_1.zip
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvideo.c,v 1.16 2008/09/20 21:05:58 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvideo.c,v 1.17 2008/09/21 14:13:24 jmcneill Exp $");
 #ifdef _MODULE
 #include <sys/module.h>
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 /* #include <sys/malloc.h> */
 #include <sys/kmem.h>
 #include <sys/device.h>
 #include <sys/ioctl.h>
 #include <sys/uio.h>
 #include <sys/tty.h>
 #include <sys/file.h>
 #include <sys/select.h>
 #include <sys/proc.h>
 #include <sys/conf.h>
 #include <sys/vnode.h>
 #include <sys/poll.h>
 #include <sys/queue.h>	/* SLIST */
 #include <sys/kthread.h>
 #include <sys/videoio.h>
 #include <dev/video_if.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/usb/usb_quirks.h>
 #include <dev/usb/uvideoreg.h>
 #if !defined(_MODULE)
 #include "opt_uvideo.h"
 #endif
 #define UVIDEO_NXFERS	3
 #define PRI_UVIDEO	PRI_BIO
 /* #define UVIDEO_DISABLE_MJPEG */
 #ifdef UVIDEO_DEBUG
 #define DPRINTF(x)	do { if (uvideodebug) logprintf x; } while (0)
 #define DPRINTFN(n,x)	do { if (uvideodebug>(n)) logprintf x; } while (0)
 int	uvideodebug = 20;
 #else
 #define DPRINTF(x)
 #define DPRINTFN(n,x)
 #endif
 typedef enum {
 @@ -191,27 +193,29 @@ struct uvideo_isoc_xfer {
 	struct uvideo_isoc	ix_i[UVIDEO_NXFERS];
 	uint32_t		ix_nframes;
 	uint32_t		ix_uframe_len;
 	struct altlist		ix_altlist;
 };
 struct uvideo_bulk_xfer {
 	uint8_t			bx_endpt;
 	usbd_pipe_handle	bx_pipe;
 	usbd_xfer_handle	bx_xfer;
 	uint8_t			*bx_buffer;
 	int			bx_buflen;
-	int			bx_datalen;
+	bool			bx_running;
 	kcondvar_t		bx_cv;
 	kmutex_t		bx_lock;
 };
 struct uvideo_stream {
 	struct uvideo_softc	*vs_parent;
 	usbd_interface_handle	vs_iface;
 	uint8_t			vs_ifaceno;
 	uint8_t			vs_subtype;  /* input or output */
 	uint16_t		vs_probelen; /* length of probe and
 					      * commit data; varies
 					      * depending on version
 					      * of spec. */
 	struct uvideo_format_list vs_formats;
 	struct uvideo_pixel_format_list vs_pixel_formats;
 @@ -323,31 +327,34 @@ static usbd_status		uvideo_stream_init(
 	uint8_t idx);
 static usbd_status		uvideo_stream_init_desc(
 	struct uvideo_stream *,
 	const usb_interface_descriptor_t *ifdesc,
 	usbd_desc_iter_t *iter);
 static usbd_status		uvideo_stream_init_frame_based_format(
 	struct uvideo_stream *,
 	const uvideo_descriptor_t *,
 	usbd_desc_iter_t *);
 static void			uvideo_stream_free(struct uvideo_stream *);
 static int		uvideo_stream_start_xfer(struct uvideo_stream *);
 static int		uvideo_stream_stop_xfer(struct uvideo_stream *);
 static usbd_status	uvideo_stream_recv_process(struct uvideo_stream *,
 						   uint8_t *, uint32_t);
 static usbd_status	uvideo_stream_recv_isoc_start(struct uvideo_stream *);
 static usbd_status	uvideo_stream_recv_isoc_start1(struct uvideo_isoc *);
 static void		uvideo_stream_recv_isoc_complete(usbd_xfer_handle,
 							 usbd_private_handle,
 							 usbd_status);
 static void		uvideo_stream_recv_bulk_transfer(void *);
 /* format probe and commit */
 #define uvideo_stream_probe(vs, act, data)				\
 	(uvideo_stream_probe_and_commit((vs), (act),			\
 					UVIDEO_VS_PROBE_CONTROL, (data)))
 #define uvideo_stream_commit(vs, act, data)				\
 	(uvideo_stream_probe_and_commit((vs), (act),			\
 					UVIDEO_VS_COMMIT_CONTROL, (data)))
 static usbd_status	uvideo_stream_probe_and_commit(struct uvideo_stream *,
 						       uint8_t, uint8_t,
 						       void *);
 static void		uvideo_init_probe_data(uvideo_probe_and_commit_data_t *);
 @@ -1079,48 +1086,60 @@ uvideo_stream_init(struct uvideo_stream
  * interface descriptor, modifying the iterator.  This may be called
  * multiple times because there may be several alternate interfaces
  * associated with the same interface number. */
 static usbd_status
 uvideo_stream_init_desc(struct uvideo_stream *vs,
 			const usb_interface_descriptor_t *ifdesc,
 			usbd_desc_iter_t *iter)
+{
 	const usb_descriptor_t *desc;
 	const uvideo_descriptor_t *uvdesc;
 	struct uvideo_bulk_xfer *bx;
 	struct uvideo_isoc_xfer *ix;
 	struct uvideo_alternate *alt;
-	uint8_t xfer_type;
+	uint8_t xfer_type, xfer_dir;
 	uint8_t bmAttributes, bEndpointAddress;
 	int i;
 	/* Iterate until the next interface descriptor.  All
 	 * descriptors until then belong to this streaming
 	 * interface. */
 	while ((desc = usb_desc_iter_next_non_interface(iter)) != NULL) {
 		uvdesc = (const uvideo_descriptor_t *)desc;
 		switch (uvdesc->bDescriptorType) {
 		case UDESC_ENDPOINT:
-			xfer_type = UE_GET_XFERTYPE(GET(usb_endpoint_descriptor_t,
+			bmAttributes = GET(usb_endpoint_descriptor_t,
-							desc, bmAttributes));
+					   desc, bmAttributes);
-			if (xfer_type == UE_BULK) {
+			bEndpointAddress = GET(usb_endpoint_descriptor_t,
 					       desc, bEndpointAddress);
 			xfer_type = UE_GET_XFERTYPE(bmAttributes);
 			xfer_dir = UE_GET_DIR(bEndpointAddress);
 			if (xfer_type == UE_BULK && xfer_dir == UE_DIR_IN) {
 				bx = &vs->vs_xfer.bulk;
 				if (vs->vs_xfer_type == 0) {
 					DPRINTFN(15, ("uvideo_attach: "
 						      "BULK stream *\n"));
 					vs->vs_xfer_type = UE_BULK;
-					bx->bx_endpt =
+					bx->bx_endpt = bEndpointAddress;
-					    GET(usb_endpoint_descriptor_t,
+					DPRINTF(("uvideo_attach: BULK "
-						desc, bEndpointAddress);
+						 "endpoint %x\n",
 						 bx->bx_endpt));
 					bx->bx_running = false;
 					cv_init(&bx->bx_cv,
 					    device_xname(vs->vs_parent->sc_dev)
 					    );
 					mutex_init(&bx->bx_lock,
 					  MUTEX_DEFAULT, IPL_NONE);
+				}
 			} else if (xfer_type == UE_ISOCHRONOUS) {
 				ix = &vs->vs_xfer.isoc;
 				for (i = 0; i < UVIDEO_NXFERS; i++) {
 					ix->ix_i[i].i_ix = ix;
 					ix->ix_i[i].i_vs = vs;
+				}
 				if (vs->vs_xfer_type == 0) {
 					DPRINTFN(15, ("uvideo_attach: "
 						      "ISOC stream *\n"));
 					SLIST_INIT(&ix->ix_altlist);
 					vs->vs_xfer_type = UE_ISOCHRONOUS;
 					ix->ix_endpt =
 @@ -1421,34 +1440,81 @@ uvideo_stream_init_frame_based_format(st
 	return USBD_NORMAL_COMPLETION;
+}
 static int
 uvideo_stream_start_xfer(struct uvideo_stream *vs)
+{
 	struct uvideo_softc *sc = vs->vs_parent;
 	struct uvideo_bulk_xfer *bx;
 	struct uvideo_isoc_xfer *ix;
 	uint32_t vframe_len;	/* rough bytes per video frame */
 	uint32_t uframe_len;	/* bytes per usb frame (TODO: or microframe?) */
 	uint32_t nframes;	/* number of usb frames (TODO: or microframs?) */
-	int i;
+	int i, ret;
 	struct uvideo_alternate *alt, *alt_maybe;
 	usbd_status err;
 	switch (vs->vs_xfer_type) {
 	case UE_BULK:
 		ret = 0;
 		bx = &vs->vs_xfer.bulk;
 		bx->bx_xfer = usbd_alloc_xfer(sc->sc_udev);
 		if (bx->bx_xfer == NULL) {
 			DPRINTF(("uvideo: couldn't allocate xfer\n"));
 			return ENOMEM;
+		}
 		DPRINTF(("uvideo: xfer %p\n", bx->bx_xfer));
 		bx->bx_buflen = vs->vs_max_payload_size;
 		DPRINTF(("uvideo: allocating %u byte buffer\n", bx->bx_buflen));
 		bx->bx_buffer = usbd_alloc_buffer(bx->bx_xfer, bx->bx_buflen);
 		if (bx->bx_buffer == NULL) {
 			DPRINTF(("uvideo: couldn't allocate buffer\n"));
 			return ENOMEM;
+		}
 		err = usbd_open_pipe(vs->vs_iface, bx->bx_endpt, 0,
 		    &bx->bx_pipe);
 		if (err != USBD_NORMAL_COMPLETION) {
 			DPRINTF(("uvideo: error opening pipe: %s (%d)\n",
 				 usbd_errstr(err), err));
 			return EIO;
+		}
 		DPRINTF(("uvideo: pipe %p\n", bx->bx_pipe));
 		mutex_enter(&bx->bx_lock);
 		if (bx->bx_running == false) {
 			bx->bx_running = true;
 			ret = kthread_create(PRI_UVIDEO, 0, NULL,
 			    uvideo_stream_recv_bulk_transfer, vs,
 			    NULL, device_xname(sc->sc_dev));
 			if (ret) {
 				DPRINTF(("uvideo: couldn't create kthread:"
 					 " %d\n", err));
 				bx->bx_running = false;
 				mutex_exit(&bx->bx_lock);
 				return err;
+			}
 		} else
 			aprint_error_dev(sc->sc_dev,
 			    "transfer already in progress\n");
 		mutex_exit(&bx->bx_lock);
 		DPRINTF(("uvideo: thread created\n"));
 		return 0;
 	case UE_ISOCHRONOUS:
 		ix = &vs->vs_xfer.isoc;
 		/* Choose an alternate interface most suitable for
 		 * this format.  Choose the smallest size that can
 		 * contain max_payload_size.
+		 *
 		 * It is assumed that the list is sorted in descending
 		 * order from largest to smallest packet size.
+		 *
 		 * TODO: what should the strategy be for choosing an
 		 * alt interface?
 @@ -1549,26 +1615,51 @@ uvideo_stream_start_xfer(struct uvideo_s
+}
 static int
 uvideo_stream_stop_xfer(struct uvideo_stream *vs)
+{
 	struct uvideo_bulk_xfer *bx;
 	struct uvideo_isoc_xfer *ix;
 	usbd_status err;
 	int i;
 	switch (vs->vs_xfer_type) {
 	case UE_BULK:
 		bx = &vs->vs_xfer.bulk;
 		DPRINTF(("uvideo_stream_stop_xfer: UE_BULK: "
 			 "waiting for thread to complete\n"));
 		mutex_enter(&bx->bx_lock);
 		if (bx->bx_running == true) {
 			bx->bx_running = false;
 			cv_wait_sig(&bx->bx_cv, &bx->bx_lock);
+		}
 		mutex_exit(&bx->bx_lock);
 		DPRINTF(("uvideo_stream_stop_xfer: UE_BULK: cleaning up\n"));
 		if (bx->bx_pipe) {
 			usbd_abort_pipe(bx->bx_pipe);
 			usbd_close_pipe(bx->bx_pipe);
 			bx->bx_pipe = NULL;
+		}
 		if (bx->bx_xfer) {
 			usbd_free_xfer(bx->bx_xfer);
 			bx->bx_xfer = NULL;
+		}
 		DPRINTF(("uvideo_stream_stop_xfer: UE_BULK: done\n"));
 		return 0;
 	case UE_ISOCHRONOUS:
 		ix = &vs->vs_xfer.isoc;
 		if (ix->ix_pipe != NULL) {
 			usbd_abort_pipe(ix->ix_pipe);
 			usbd_close_pipe(ix->ix_pipe);
 			ix->ix_pipe = NULL;
+		}
 		for (i = 0; i < UVIDEO_NXFERS; i++) {
 			struct uvideo_isoc *isoc = &ix->ix_i[i];
 			if (isoc->i_xfer != NULL) {
 				usbd_free_buffer(isoc->i_xfer);
 @@ -1637,40 +1728,72 @@ uvideo_stream_recv_isoc_start1(struct uv
 			     ix->ix_nframes,
 			     USBD_NO_COPY | USBD_SHORT_XFER_OK,
 			     uvideo_stream_recv_isoc_complete);
 	err = usbd_transfer(isoc->i_xfer);
 	if (err != USBD_IN_PROGRESS) {
 		DPRINTF(("uvideo_stream_recv_start: "
 			 "usbd_transfer status=%s (%d)\n",
 			 usbd_errstr(err), err));
+	}
 	return err;
+}
 static usbd_status
 uvideo_stream_recv_process(struct uvideo_stream *vs, uint8_t *buf, uint32_t len)
+{
 	uvideo_payload_header_t *hdr;
 	struct video_payload payload;
 	if (len < sizeof(uvideo_payload_header_t)) {
 		DPRINTF(("uvideo_stream_recv_process: len %d < payload hdr\n",
 			 len));
 		return USBD_SHORT_XFER;
+	}
 	hdr = (uvideo_payload_header_t *)buf;
 #if 0
 	if (hdr->bHeaderLength != UVIDEO_PAYLOAD_HEADER_SIZE)
 		return USBD_INVAL;
 #endif
 	if (hdr->bHeaderLength == len && !(hdr->bmHeaderInfo & UV_END_OF_FRAME))
 		return USBD_INVAL;
 	if (hdr->bmHeaderInfo & UV_ERROR)
 		return USBD_IOERROR;
 	payload.data = buf + hdr->bHeaderLength;
 	payload.size = len - hdr->bHeaderLength;
 	payload.frameno = hdr->bmHeaderInfo & UV_FRAME_ID;
 	payload.end_of_frame = hdr->bmHeaderInfo & UV_END_OF_FRAME;
 	video_submit_payload(vs->vs_parent->sc_videodev, &payload);
 	return USBD_NORMAL_COMPLETION;
+}
 /* Callback on completion of usb isoc transfer */
 static void
 uvideo_stream_recv_isoc_complete(usbd_xfer_handle xfer,
 				 usbd_private_handle priv,
 				 usbd_status status)
+{
 	struct uvideo_stream *vs;
 	struct uvideo_isoc_xfer *ix;
 	struct uvideo_isoc *isoc;
 	int i;
 	uint32_t count;
 	const uvideo_payload_header_t *hdr;
 	uint8_t *buf;
 	struct video_payload payload;
 	isoc = priv;
 	vs = isoc->i_vs;
 	ix = isoc->i_ix;
 	if (status != USBD_NORMAL_COMPLETION) {
 		DPRINTF(("uvideo_stream_recv_isoc_complete: status=%s (%d)\n",
 			usbd_errstr(status), status));
 		if (status == USBD_STALLED)
 			usbd_clear_endpoint_stall_async(ix->ix_pipe);
 		else
 			return;
 @@ -1678,57 +1801,76 @@ uvideo_stream_recv_isoc_complete(usbd_xf
 		usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
 		if (count == 0) {
 			/* DPRINTF(("uvideo: zero length transfer\n")); */
 			goto next;
+		}
 		hdr = (const uvideo_payload_header_t *)isoc->i_buf;
 		for (i = 0, buf = isoc->i_buf;
 		     i < ix->ix_nframes;
 		     ++i, buf += ix->ix_uframe_len)
+		{
-			if (isoc->i_frlengths[i] <
+			status = uvideo_stream_recv_process(vs, buf,
-			    sizeof(uvideo_payload_header_t))
+			    isoc->i_frlengths[i]);
-				continue;
+			if (status == USBD_IOERROR)
 			hdr = (uvideo_payload_header_t *)buf;
 			if (hdr->bHeaderLength != UVIDEO_PAYLOAD_HEADER_SIZE)
 				continue;
 			if (hdr->bHeaderLength == isoc->i_frlengths[i] &&
 			    !(hdr->bmHeaderInfo & UV_END_OF_FRAME))
 				continue;
 			if (hdr->bmHeaderInfo & UV_ERROR) {
 				DPRINTF(("uvideo: stream error\n"));
 				break;
 			payload.data = buf + hdr->bHeaderLength;
 			payload.size = isoc->i_frlengths[i] -
 			    hdr->bHeaderLength;
 			payload.frameno = hdr->bmHeaderInfo & UV_FRAME_ID;
 			payload.end_of_frame =
 			    hdr->bmHeaderInfo & UV_END_OF_FRAME;
 			video_submit_payload(vs->vs_parent->sc_videodev,
 					     &payload);
+		}
+	}
 next:
 	uvideo_stream_recv_isoc_start1(isoc);
+}
 static void
 uvideo_stream_recv_bulk_transfer(void *addr)
+{
 	struct uvideo_stream *vs = addr;
 	struct uvideo_softc *sc = vs->vs_parent;
 	struct uvideo_bulk_xfer *bx = &vs->vs_xfer.bulk;
 	usbd_status err;
 	uint32_t len;
 	DPRINTF(("uvideo_stream_recv_bulk_transfer: "
 		 "vs %p sc %p bx %p buffer %p\n", vs, sc, bx, bx->bx_buffer));
 	while (bx->bx_running) {
 		len = bx->bx_buflen;
 		err = usbd_bulk_transfer(bx->bx_xfer, bx->bx_pipe,
 		    USBD_SHORT_XFER_OK /* | USBD_NO_COPY */, 500,
 		    bx->bx_buffer, &len, "uvideorb");
 		if (len == 0)
 			DPRINTF(("uvideo_stream_recv_bulk_transfer: 0 len\n"));
 		if (err == USBD_NORMAL_COMPLETION) {
 			uvideo_stream_recv_process(vs, bx->bx_buffer, len);
 		} else {
 			DPRINTF(("uvideo_stream_recv_bulk_transfer: %s\n",
 				 usbd_errstr(err)));
+		}
+	}
 	DPRINTF(("uvideo_stream_recv_bulk_transfer: notify complete\n"));
 	mutex_enter(&bx->bx_lock);
 	cv_broadcast(&bx->bx_cv);
 	mutex_exit(&bx->bx_lock);
 	DPRINTF(("uvideo_stream_recv_bulk_transfer: return\n"));
 	kthread_exit(0);
+}
 /*
  * uvideo_open - probe and commit video format and start receiving
  * video data
  */
 static int
 uvideo_open(void *addr, int flags)
+{
 	struct uvideo_softc *sc;
 	struct uvideo_stream *vs;
 	struct video_format fmt;
 	sc = addr;