openbsd-src / sys / dev / usb / utvfu.c

/*	$OpenBSD: utvfu.c,v 1.23 2025/02/25 22:10:39 kirill Exp $ */
/*
 * Copyright (c) 2013 Lubomir Rintel
 * Copyright (c) 2013 Federico Simoncelli
 * All rights reserved.
 *
 * 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,
 *    without modification.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL").
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF 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.
 */
/*
 * Fushicai USBTV007 Audio-Video Grabber Driver
 *
 * Product web site:
 * http://www.fushicai.com/products_detail/&productId=d05449ee-b690-42f9-a661-aa7353894bed.html
 *
 * Following LWN articles were very useful in construction of this driver:
 * Video4Linux2 API series: http://lwn.net/Articles/203924/
 * videobuf2 API explanation: http://lwn.net/Articles/447435/
 * Thanks go to Jonathan Corbet for providing this quality documentation.
 * He is awesome.
 *
 * No physical hardware was harmed running Windows during the
 * reverse-engineering activity
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/fcntl.h>
#include <sys/kthread.h>
#include <sys/malloc.h>
#include <sys/device.h>

#include <uvm/uvm_extern.h>

#include <machine/bus.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdivar.h>
#include <dev/usb/usb_mem.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbdevs.h>
#include <dev/usb/utvfu.h>

#include <dev/audio_if.h>
#include <dev/video_if.h>

#ifdef UTVFU_DEBUG
int utvfu_debug = 1;
#define DPRINTF(l, x...) do { if ((l) <= utvfu_debug) printf(x); } while (0)
#else
#define DPRINTF(l, x...)
#endif

#define DEVNAME(_s) ((_s)->sc_dev.dv_xname)

struct utvfu_norm_params utvfu_norm_params[] = {
	{
		.norm = V4L2_STD_525_60,
		.cap_width = 720,
		.cap_height = 480,
		/* 4 bytes/2 pixel YUYV/YUV 4:2:2 */
		.frame_len = (720 * 480 * 2),
	},
	{
		.norm = V4L2_STD_PAL,
		.cap_width = 720,
		.cap_height = 576,
		/* 4 bytes/2 pixel YUYV/YUV 4:2:2 */
		.frame_len = (720 * 576 * 2),
	}
};

int
utvfu_set_regs(struct utvfu_softc *sc, const uint16_t regs[][2], int size)
{
	int i;
	usbd_status error;
	usb_device_request_t req;

	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
	req.bRequest = UTVFU_REQUEST_REG;
	USETW(req.wLength, 0);

	for (i = 0; i < size; i++) {
		USETW(req.wIndex, regs[i][0]);
		USETW(req.wValue, regs[i][1]);

		error = usbd_do_request(sc->sc_udev, &req, NULL);
		if (error != USBD_NORMAL_COMPLETION) {
			DPRINTF(1, "%s: %s: exit EINVAL\n",
			    DEVNAME(sc), __func__);
			return (EINVAL);
		}
	}

	return (0);
}

int
utvfu_max_frame_size(void)
{
	int i, sz = 0;

	for (i = 0; i < nitems(utvfu_norm_params); i++) {
		if (sz < utvfu_norm_params[i].frame_len)
			sz = utvfu_norm_params[i].frame_len;
	}

	return (sz);
}

int
utvfu_configure_for_norm(struct utvfu_softc *sc, v4l2_std_id norm)
{
	int i, ret = EINVAL;
	struct utvfu_norm_params *params = NULL;

	for (i = 0; i < nitems(utvfu_norm_params); i++) {
		if (utvfu_norm_params[i].norm & norm) {
			params = &utvfu_norm_params[i];
			break;
		}
	}

	if (params != NULL) {
		sc->sc_normi = i;
		sc->sc_nchunks = params->cap_width * params->cap_height
		    / 4 / UTVFU_CHUNK;
		ret = 0;
	}

	return (ret);
}

int
utvfu_select_input(struct utvfu_softc *sc, int input)
{
	int ret;

	static const uint16_t composite[][2] = {
		{ UTVFU_BASE + 0x0105, 0x0060 },
		{ UTVFU_BASE + 0x011f, 0x00f2 },
		{ UTVFU_BASE + 0x0127, 0x0060 },
		{ UTVFU_BASE + 0x00ae, 0x0010 },
		{ UTVFU_BASE + 0x0239, 0x0060 },
	};

	static const uint16_t svideo[][2] = {
		{ UTVFU_BASE + 0x0105, 0x0010 },
		{ UTVFU_BASE + 0x011f, 0x00ff },
		{ UTVFU_BASE + 0x0127, 0x0060 },
		{ UTVFU_BASE + 0x00ae, 0x0030 },
		{ UTVFU_BASE + 0x0239, 0x0060 },
	};

	switch (input) {
	case UTVFU_COMPOSITE_INPUT:
		ret = utvfu_set_regs(sc, composite, nitems(composite));
		break;
	case UTVFU_SVIDEO_INPUT:
		ret = utvfu_set_regs(sc, svideo, nitems(svideo));
		break;
	default:
		ret = EINVAL;
	}

	if (ret == 0)
		sc->sc_input = input;

	return (ret);
}

int
utvfu_select_norm(struct utvfu_softc *sc, v4l2_std_id norm)
{
	int ret;
	static const uint16_t pal[][2] = {
		{ UTVFU_BASE + 0x001a, 0x0068 },
		{ UTVFU_BASE + 0x010e, 0x0072 },
		{ UTVFU_BASE + 0x010f, 0x00a2 },
		{ UTVFU_BASE + 0x0112, 0x00b0 },
		{ UTVFU_BASE + 0x0117, 0x0001 },
		{ UTVFU_BASE + 0x0118, 0x002c },
		{ UTVFU_BASE + 0x012d, 0x0010 },
		{ UTVFU_BASE + 0x012f, 0x0020 },
		{ UTVFU_BASE + 0x024f, 0x0002 },
		{ UTVFU_BASE + 0x0254, 0x0059 },
		{ UTVFU_BASE + 0x025a, 0x0016 },
		{ UTVFU_BASE + 0x025b, 0x0035 },
		{ UTVFU_BASE + 0x0263, 0x0017 },
		{ UTVFU_BASE + 0x0266, 0x0016 },
		{ UTVFU_BASE + 0x0267, 0x0036 }
	};

	static const uint16_t ntsc[][2] = {
		{ UTVFU_BASE + 0x001a, 0x0079 },
		{ UTVFU_BASE + 0x010e, 0x0068 },
		{ UTVFU_BASE + 0x010f, 0x009c },
		{ UTVFU_BASE + 0x0112, 0x00f0 },
		{ UTVFU_BASE + 0x0117, 0x0000 },
		{ UTVFU_BASE + 0x0118, 0x00fc },
		{ UTVFU_BASE + 0x012d, 0x0004 },
		{ UTVFU_BASE + 0x012f, 0x0008 },
		{ UTVFU_BASE + 0x024f, 0x0001 },
		{ UTVFU_BASE + 0x0254, 0x005f },
		{ UTVFU_BASE + 0x025a, 0x0012 },
		{ UTVFU_BASE + 0x025b, 0x0001 },
		{ UTVFU_BASE + 0x0263, 0x001c },
		{ UTVFU_BASE + 0x0266, 0x0011 },
		{ UTVFU_BASE + 0x0267, 0x0005 }
	};

	ret = utvfu_configure_for_norm(sc, norm);

	if (ret == 0) {
		if (norm & V4L2_STD_525_60)
			ret = utvfu_set_regs(sc, ntsc, nitems(ntsc));
		else if (norm & V4L2_STD_PAL)
			ret = utvfu_set_regs(sc, pal, nitems(pal));
	}

	return (ret);
}

int
utvfu_setup_capture(struct utvfu_softc *sc)
{
	int ret;
	static const uint16_t setup[][2] = {
		/* These seem to enable the device. */
		{ UTVFU_BASE + 0x0008, 0x0001 },
		{ UTVFU_BASE + 0x01d0, 0x00ff },
		{ UTVFU_BASE + 0x01d9, 0x0002 },

		/*
		 * These seem to influence color parameters, such as
		 * brightness, etc.
		 */
		{ UTVFU_BASE + 0x0239, 0x0040 },
		{ UTVFU_BASE + 0x0240, 0x0000 },
		{ UTVFU_BASE + 0x0241, 0x0000 },
		{ UTVFU_BASE + 0x0242, 0x0002 },
		{ UTVFU_BASE + 0x0243, 0x0080 },
		{ UTVFU_BASE + 0x0244, 0x0012 },
		{ UTVFU_BASE + 0x0245, 0x0090 },
		{ UTVFU_BASE + 0x0246, 0x0000 },

		{ UTVFU_BASE + 0x0278, 0x002d },
		{ UTVFU_BASE + 0x0279, 0x000a },
		{ UTVFU_BASE + 0x027a, 0x0032 },
		{ 0xf890, 0x000c },
		{ 0xf894, 0x0086 },

		{ UTVFU_BASE + 0x00ac, 0x00c0 },
		{ UTVFU_BASE + 0x00ad, 0x0000 },
		{ UTVFU_BASE + 0x00a2, 0x0012 },
		{ UTVFU_BASE + 0x00a3, 0x00e0 },
		{ UTVFU_BASE + 0x00a4, 0x0028 },
		{ UTVFU_BASE + 0x00a5, 0x0082 },
		{ UTVFU_BASE + 0x00a7, 0x0080 },
		{ UTVFU_BASE + 0x0000, 0x0014 },
		{ UTVFU_BASE + 0x0006, 0x0003 },
		{ UTVFU_BASE + 0x0090, 0x0099 },
		{ UTVFU_BASE + 0x0091, 0x0090 },
		{ UTVFU_BASE + 0x0094, 0x0068 },
		{ UTVFU_BASE + 0x0095, 0x0070 },
		{ UTVFU_BASE + 0x009c, 0x0030 },
		{ UTVFU_BASE + 0x009d, 0x00c0 },
		{ UTVFU_BASE + 0x009e, 0x00e0 },
		{ UTVFU_BASE + 0x0019, 0x0006 },
		{ UTVFU_BASE + 0x008c, 0x00ba },
		{ UTVFU_BASE + 0x0101, 0x00ff },
		{ UTVFU_BASE + 0x010c, 0x00b3 },
		{ UTVFU_BASE + 0x01b2, 0x0080 },
		{ UTVFU_BASE + 0x01b4, 0x00a0 },
		{ UTVFU_BASE + 0x014c, 0x00ff },
		{ UTVFU_BASE + 0x014d, 0x00ca },
		{ UTVFU_BASE + 0x0113, 0x0053 },
		{ UTVFU_BASE + 0x0119, 0x008a },
		{ UTVFU_BASE + 0x013c, 0x0003 },
		{ UTVFU_BASE + 0x0150, 0x009c },
		{ UTVFU_BASE + 0x0151, 0x0071 },
		{ UTVFU_BASE + 0x0152, 0x00c6 },
		{ UTVFU_BASE + 0x0153, 0x0084 },
		{ UTVFU_BASE + 0x0154, 0x00bc },
		{ UTVFU_BASE + 0x0155, 0x00a0 },
		{ UTVFU_BASE + 0x0156, 0x00a0 },
		{ UTVFU_BASE + 0x0157, 0x009c },
		{ UTVFU_BASE + 0x0158, 0x001f },
		{ UTVFU_BASE + 0x0159, 0x0006 },
		{ UTVFU_BASE + 0x015d, 0x0000 },

		{ UTVFU_BASE + 0x0003, 0x0004 },
		{ UTVFU_BASE + 0x0100, 0x00d3 },
		{ UTVFU_BASE + 0x0115, 0x0015 },
		{ UTVFU_BASE + 0x0220, 0x002e },
		{ UTVFU_BASE + 0x0225, 0x0008 },
		{ UTVFU_BASE + 0x024e, 0x0002 },
		{ UTVFU_BASE + 0x024e, 0x0002 },
		{ UTVFU_BASE + 0x024f, 0x0002 },
	};

	ret = utvfu_set_regs(sc, setup, nitems(setup));
	if (ret)
		return (ret);

	ret = utvfu_select_norm(sc, utvfu_norm_params[sc->sc_normi].norm);
	if (ret)
		return (ret);

	ret = utvfu_select_input(sc, sc->sc_input);
	if (ret)
		return (ret);

	return (0);
}

/*
 * Copy data from chunk into a frame buffer, deinterlacing the data
 * into every second line. Unfortunately, they don't align nicely into
 * 720 pixel lines, as the chunk is 240 words long, which is 480 pixels.
 * Therefore, we break down the chunk into two halves before copying,
 * so that we can interleave a line if needed.
 *
 * Each "chunk" is 240 words; a word in this context equals 4 bytes.
 * Image format is YUYV/YUV 4:2:2, consisting of Y Cr Y Cb, defining two
 * pixels, the Cr and Cb shared between the two pixels, but each having
 * separate Y values. Thus, the 240 words equal 480 pixels. It therefore,
 * takes 1.5 chunks to make a 720 pixel-wide line for the frame.
 * The image is interlaced, so there is a "scan" of odd lines, followed
 * by "scan" of even numbered lines.
 *
 * Following code is writing the chunks in correct sequence, skipping
 * the rows based on "odd" value.
 * line 1: chunk[0][  0..479] chunk[0][480..959] chunk[1][  0..479]
 * line 3: chunk[1][480..959] chunk[2][  0..479] chunk[2][480..959]
 * ...etc
 */
void
utvfu_chunk_to_vbuf(uint8_t *frame, uint8_t *src, int chunk_no, int odd)
{
	uint8_t *dst;
	int half, line, part_no, part_index;
	#define	UTVFU_STRIDE	(UTVFU_CHUNK/2 * 4)

	for (half = 0; half < 2; half++) {
		part_no = chunk_no * 2 + half;
		line = part_no / 3;
		part_index = (line * 2 + !odd) * 3 + (part_no % 3);

		dst = &frame[part_index * UTVFU_STRIDE];

		memcpy(dst, src, UTVFU_STRIDE);
		src += UTVFU_STRIDE;
	}
	#undef	UTVFU_STRIDE
}

/*
 * Called for each 256-byte image chunk.
 * First word identifies the chunk, followed by 240 words of image
 * data and padding.
 */
void
utvfu_image_chunk(struct utvfu_softc *sc, u_char *chunk)
{
	int frame_id, odd, chunk_no, frame_len;
	uint32_t hdr;

	memcpy(&hdr, chunk, sizeof(hdr));
	chunk += sizeof(hdr);
	hdr = be32toh(hdr);

	/* Ignore corrupted lines. */
	if (!UTVFU_MAGIC_OK(hdr)) {
		DPRINTF(2, "%s: bad magic=0x%08x\n",
		    DEVNAME(sc), UTVFU_MAGIC(hdr));
		return;
	}

	frame_id = UTVFU_FRAME_ID(hdr);
	odd = UTVFU_ODD(hdr);
	chunk_no = UTVFU_CHUNK_NO(hdr);
	if (chunk_no >= sc->sc_nchunks) {
		DPRINTF(2, "%s: chunk_no=%d >= sc_nchunks=%d\n",
		    DEVNAME(sc), chunk_no, sc->sc_nchunks);
		return;
	}

	/* Beginning of a frame. */
	if (chunk_no == 0) {
		sc->sc_fb.fid = frame_id;
		sc->sc_fb.chunks_done = 0;
	}
	else if (sc->sc_fb.fid != frame_id) {
		DPRINTF(2, "%s: frame id mismatch expecting=%d got=%d\n",
		    DEVNAME(sc), sc->sc_fb.fid, frame_id);
		return;
	}

	frame_len = utvfu_norm_params[sc->sc_normi].frame_len;

	/* Copy the chunk data. */
	utvfu_chunk_to_vbuf(sc->sc_fb.buf, chunk, chunk_no, odd);
	sc->sc_fb.chunks_done++;

	/* Last chunk in a field */
	if (chunk_no == sc->sc_nchunks-1) {
		/* Last chunk in a frame, signalling an end */
		if (odd && !sc->sc_fb.last_odd) {
			if (sc->sc_fb.chunks_done != sc->sc_nchunks) {
				DPRINTF(1, "%s: chunks_done=%d != nchunks=%d\n",
				    DEVNAME(sc),
				    sc->sc_fb.chunks_done, sc->sc_nchunks);
			}

			if (sc->sc_flags & UTVFU_FLAG_MMAP) {
				utvfu_mmap_queue(sc, sc->sc_fb.buf, frame_len);
			}
			else {
				utvfu_read(sc, sc->sc_fb.buf, frame_len);
			}
		}
		sc->sc_fb.last_odd = odd;
	}
}

int
utvfu_start_capture(struct utvfu_softc *sc)
{
	usbd_status error;
	int restart_au;

	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	restart_au = ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING);
	utvfu_audio_stop(sc);

	/* default video stream interface */
	error = usbd_set_interface(sc->sc_uifaceh, UTVFU_DFLT_IFACE_IDX);
	if (error != USBD_NORMAL_COMPLETION)
		return (EINVAL);

	if (utvfu_setup_capture(sc) != 0)
		return (EINVAL);

	/* alt setting */
	error = usbd_set_interface(sc->sc_uifaceh, UTVFU_ALT_IFACE_IDX);
	if (error != USBD_NORMAL_COMPLETION)
		return (EINVAL);

	if (restart_au)
		utvfu_audio_start(sc);

	return (0);
}

int
utvfu_querycap(void *v, struct v4l2_capability *cap)
{
	struct utvfu_softc *sc = v;

	memset(cap, 0, sizeof(*cap));
	strlcpy(cap->driver, DEVNAME(sc), sizeof(cap->driver));
	strlcpy(cap->card, "utvfu", sizeof(cap->card));
	strlcpy(cap->bus_info, "usb", sizeof(cap->bus_info));
	cap->device_caps = V4L2_CAP_VIDEO_CAPTURE;
	cap->device_caps |= V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
	cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;

	return (0);
}

int
utvfu_enum_input(void *v, struct v4l2_input *i)
{
	struct utvfu_softc *sc = v;

	switch (i->index) {
	case UTVFU_COMPOSITE_INPUT:
		strlcpy(i->name, "Composite", sizeof(i->name));
		break;
	case UTVFU_SVIDEO_INPUT:
		strlcpy(i->name, "S-Video", sizeof(i->name));
		break;
	default:
		return (EINVAL);
	}

	i->type = V4L2_INPUT_TYPE_CAMERA;
	i->std = utvfu_norm_params[sc->sc_normi].norm;

	return (0);
}

int
utvfu_enum_fmt_vid_cap(void *v, struct v4l2_fmtdesc *f)
{
	if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || f->index != 0)
		return (EINVAL);

	strlcpy(f->description, "16 bpp YUY2, 4:2:2, packed",
					sizeof(f->description));
	f->pixelformat = V4L2_PIX_FMT_YUYV;

	return (0);
}

int
utvfu_enum_fsizes(void *v, struct v4l2_frmsizeenum *fsizes)
{
	struct utvfu_softc *sc = v;

	if (fsizes->pixel_format != V4L2_PIX_FMT_YUYV)
		return (EINVAL);

	/* The device only supports one frame size. */
	if (fsizes->index >= 1)
		return (EINVAL);

	fsizes->type = V4L2_FRMSIZE_TYPE_DISCRETE;
	fsizes->discrete.width = utvfu_norm_params[sc->sc_normi].cap_width;
	fsizes->discrete.height = utvfu_norm_params[sc->sc_normi].cap_height;

	return (0);
}

int
utvfu_g_fmt(void *v, struct v4l2_format *f)
{
	struct utvfu_softc *sc = v;

	f->fmt.pix.width = utvfu_norm_params[sc->sc_normi].cap_width;
	f->fmt.pix.height = utvfu_norm_params[sc->sc_normi].cap_height;
	f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
	f->fmt.pix.field = V4L2_FIELD_INTERLACED;
	f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
	f->fmt.pix.sizeimage = (f->fmt.pix.bytesperline * f->fmt.pix.height);
	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;

	return (0);
}

int
utvfu_s_fmt(void *v, struct v4l2_format *f)
{
	if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_YUYV)
		return (EINVAL);

	return (0);
}

int
utvfu_g_std(void *v, v4l2_std_id *norm)
{
	struct utvfu_softc *sc = v;

	*norm = utvfu_norm_params[sc->sc_normi].norm;

	return (0);
}

int
utvfu_s_std(void *v, v4l2_std_id norm)
{
	int ret = EINVAL;
	struct utvfu_softc *sc = v;

	if ((norm & V4L2_STD_525_60) || (norm & V4L2_STD_PAL))
		ret = utvfu_select_norm(sc, norm);

	return (ret);
}

int
utvfu_g_input(void *v, int *i)
{
	struct utvfu_softc *sc = v;

	*i = sc->sc_input;

	return (0);
}

int
utvfu_s_input(void *v, int i)
{
	return utvfu_select_input(v, i);
}

/* A U D I O */

void
utvfu_audio_decode(struct utvfu_softc *sc, int len)
{
	uint8_t *dst, *src;
	int n, chunk, ncopied;

	if (sc->sc_audio.blksize == 0)
		return;

	src = KERNADDR(&sc->sc_audio.iface.xfer->dmabuf, 0);
	dst = sc->sc_audio.cur;
	ncopied = sc->sc_audio.cur - sc->sc_audio.start;
	/* b/c region start->end is a multiple blksize chunks */
	ncopied %= sc->sc_audio.blksize;

	while (len >= UTVFU_CHUNK_SIZE) {
		/*
		 * The header, skipped here, ranges from 0xdd000000 to
		 * 0xdd0003ff.  The 0xdd seems to be the "magic" and
		 * 0x3ff masks the chunk number.
		 */
		src += UTVFU_AUDIO_HDRSIZE;
		chunk = UTVFU_CHUNK;
		while (chunk > 0) {
			n = min(chunk, sc->sc_audio.blksize - ncopied);
			memcpy(dst, src, n);
			dst += n;
			src += n;
			chunk -= n;
			ncopied += n;
			if (ncopied >= sc->sc_audio.blksize) {
				mtx_enter(&audio_lock);
				(*sc->sc_audio.intr)(sc->sc_audio.intr_arg);
				mtx_leave(&audio_lock);
				ncopied -= sc->sc_audio.blksize;
			}
			if (dst > sc->sc_audio.end)
				dst = sc->sc_audio.start;
		}
		len -= UTVFU_CHUNK_SIZE; /* _CHUNK + _AUDIO_HDRSIZE */
	}
	sc->sc_audio.cur = dst;
}

int
utvfu_audio_start_chip(struct utvfu_softc *sc)
{
	static const uint16_t setup[][2] = {
		/* These seem to enable the device. */
		{ UTVFU_BASE + 0x0008, 0x0001 },
		{ UTVFU_BASE + 0x01d0, 0x00ff },
		{ UTVFU_BASE + 0x01d9, 0x0002 },

		{ UTVFU_BASE + 0x01da, 0x0013 },
		{ UTVFU_BASE + 0x01db, 0x0012 },
		{ UTVFU_BASE + 0x01e9, 0x0002 },
		{ UTVFU_BASE + 0x01ec, 0x006c },
		{ UTVFU_BASE + 0x0294, 0x0020 },
		{ UTVFU_BASE + 0x0255, 0x00cf },
		{ UTVFU_BASE + 0x0256, 0x0020 },
		{ UTVFU_BASE + 0x01eb, 0x0030 },
		{ UTVFU_BASE + 0x027d, 0x00a6 },
		{ UTVFU_BASE + 0x0280, 0x0011 },
		{ UTVFU_BASE + 0x0281, 0x0040 },
		{ UTVFU_BASE + 0x0282, 0x0011 },
		{ UTVFU_BASE + 0x0283, 0x0040 },
		{ 0xf891, 0x0010 },

		/* this sets the input from composite */
		{ UTVFU_BASE + 0x0284, 0x00aa },
	};

	/* starting the stream */
	utvfu_set_regs(sc, setup, nitems(setup));

	return (0);
}

int
utvfu_audio_stop_chip(struct utvfu_softc *sc)
{
	static const uint16_t setup[][2] = {
	/*
	 * The original windows driver sometimes sends also:
	 *   { UTVFU_BASE + 0x00a2, 0x0013 }
	 * but it seems useless and its real effects are untested at
	 * the moment.
	 */
		{ UTVFU_BASE + 0x027d, 0x0000 },
		{ UTVFU_BASE + 0x0280, 0x0010 },
		{ UTVFU_BASE + 0x0282, 0x0010 },
	};

	utvfu_set_regs(sc, setup, nitems(setup));

	return (0);
}

/*
 * Copyright (c) 2008 Robert Nagy <[e-mail]>
 * Copyright (c) 2008 Marcus Glocker <[e-mail]>
 * Copyright (c) 2016 Patrick Keshishian <[e-mail]>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/*
 * Heavily based on uvideo.c source.
 */

int		utvfu_match(struct device *, void *, void *);
void		utvfu_attach(struct device *, struct device *, void *);
int		utvfu_detach(struct device *, int);

usbd_status	utvfu_parse_desc(struct utvfu_softc *);

void		utvfu_vs_close(struct utvfu_softc *);
void		utvfu_vs_free_frame(struct utvfu_softc *);
void		utvfu_vs_free_isoc(struct utvfu_softc *);
void		utvfu_vs_start_isoc_ixfer(struct utvfu_softc *,
		    struct utvfu_isoc_xfer *);
void		utvfu_vs_cb(struct usbd_xfer *, void *, usbd_status);

void		utvfu_vs_free(struct utvfu_softc *);
int		utvfu_vs_init(struct utvfu_softc *);
int		utvfu_vs_alloc_frame(struct utvfu_softc *);
usbd_status	utvfu_vs_alloc_isoc(struct utvfu_softc *);

int		utvfu_open(void *, int, int *, uint8_t *,
		    void (*)(void *), void *);
int		utvfu_close(void *);
int		utvfu_querycap(void *, struct v4l2_capability *);
int		utvfu_enum_fmt_vid_cap(void *, struct v4l2_fmtdesc *);
int		utvfu_enum_fsizes(void *, struct v4l2_frmsizeenum *);
int		utvfu_g_fmt(void *, struct v4l2_format *);
int		utvfu_s_fmt(void *, struct v4l2_format *);
int		utvfu_g_parm(void *, struct v4l2_streamparm *);
int		utvfu_s_parm(void *, struct v4l2_streamparm *);
int		utvfu_enum_input(void *, struct v4l2_input *);
int		utvfu_s_input(void *, int);
int		utvfu_g_input(void *, int *);

int		utvfu_reqbufs(void *, struct v4l2_requestbuffers *);
int		utvfu_querybuf(void *, struct v4l2_buffer *);
int		utvfu_qbuf(void *, struct v4l2_buffer *);
int		utvfu_dqbuf(void *, struct v4l2_buffer *);
int		utvfu_streamon(void *, int);
int		utvfu_streamoff(void *, int);
int		utvfu_queryctrl(void *, struct v4l2_queryctrl *);
caddr_t		utvfu_mappage(void *, off_t, int);
int		utvfu_get_bufsize(void *);
int		utvfu_start_read(void *);

int		utvfu_as_init(struct utvfu_softc *);
void		utvfu_as_free(struct utvfu_softc *);

usbd_status	utvfu_as_open(struct utvfu_softc *);
int		utvfu_as_alloc_bulk(struct utvfu_softc *);
void		utvfu_as_free_bulk(struct utvfu_softc *);
int		utvfu_as_start_bulk(struct utvfu_softc *);
void		utvfu_as_bulk_thread(void *);

int		utvfu_audio_open(void *, int);
void		utvfu_audio_close(void *);
int		utvfu_audio_set_params(void *, int, int,
		    struct audio_params *, struct audio_params *);
int		utvfu_audio_halt_out(void *);
int		utvfu_audio_halt_in(void *);
int		utvfu_audio_mixer_set_port(void *, struct mixer_ctrl *);
int		utvfu_audio_mixer_get_port(void *, struct mixer_ctrl *);
int		utvfu_audio_query_devinfo(void *, struct mixer_devinfo *);
int		utvfu_audio_trigger_output(void *, void *, void *, int,
		    void (*)(void *), void *, struct audio_params *);
int		utvfu_audio_trigger_input(void *, void *, void *, int,
		    void (*)(void *), void *, struct audio_params *);

struct cfdriver utvfu_cd = {
	NULL, "utvfu", DV_DULL
};

const struct cfattach utvfu_ca = {
	sizeof(struct utvfu_softc),
	utvfu_match,
	utvfu_attach,
	utvfu_detach,
	NULL
};

const struct video_hw_if utvfu_vid_hw_if = {
	utvfu_open,		/* open */
	utvfu_close,		/* close */
	utvfu_querycap,		/* VIDIOC_QUERYCAP */
	utvfu_enum_fmt_vid_cap,	/* VIDIOC_ENUM_FMT */
	utvfu_enum_fsizes,	/* VIDIOC_ENUM_FRAMESIZES */
	NULL,			/* VIDIOC_ENUM_FRAMEINTERVALS */
	utvfu_s_fmt,		/* VIDIOC_S_FMT */
	utvfu_g_fmt,		/* VIDIOC_G_FMT */
	utvfu_s_parm,		/* VIDIOC_S_PARM */
	utvfu_g_parm,		/* VIDIOC_G_PARM */
	utvfu_enum_input,	/* VIDIOC_ENUMINPUT */
	utvfu_s_input,		/* VIDIOC_S_INPUT */
	utvfu_g_input,		/* VIDIOC_G_INPUT */
	utvfu_reqbufs,		/* VIDIOC_REQBUFS */
	utvfu_querybuf,		/* VIDIOC_QUERYBUF */
	utvfu_qbuf,		/* VIDIOC_QBUF */
	utvfu_dqbuf,		/* VIDIOC_DQBUF */
	utvfu_streamon,		/* VIDIOC_STREAMON */
	utvfu_streamoff,	/* VIDIOC_STREAMOFF */
	NULL,			/* VIDIOC_TRY_FMT */
	utvfu_queryctrl,	/* VIDIOC_QUERYCTRL */
	NULL,			/* VIDIOC_G_CTRL */
	NULL,			/* VIDIOC_S_CTRL */
	utvfu_mappage,		/* mmap */
	utvfu_get_bufsize,	/* read */
	utvfu_start_read	/* start stream for read */
};

const struct audio_hw_if utvfu_au_hw_if = {
	.open = utvfu_audio_open,
	.close = utvfu_audio_close,
	.set_params = utvfu_audio_set_params,
	.halt_output = utvfu_audio_halt_out,
	.halt_input = utvfu_audio_halt_in,
	.set_port = utvfu_audio_mixer_set_port,
	.get_port = utvfu_audio_mixer_get_port,
	.query_devinfo = utvfu_audio_query_devinfo,
	.trigger_output = utvfu_audio_trigger_output,
	.trigger_input = utvfu_audio_trigger_input,
};

int
utvfu_match(struct device *parent, void *match, void *aux)
{
	struct usb_attach_arg *uaa = aux;
	const struct usb_descriptor *ud;
	struct usbd_desc_iter iter;
	struct usb_interface_descriptor *uid = NULL;
	const struct usb_endpoint_descriptor *ued = NULL;
	usb_device_descriptor_t *dd;
	int ret = UMATCH_NONE;
	int nep, nalt;
	uint16_t psize = 0;

	if (uaa->iface == NULL)
		return ret;

	dd = usbd_get_device_descriptor(uaa->device);

	if (UGETW(dd->idVendor) == USB_VENDOR_FUSHICAI &&
	    UGETW(dd->idProduct) == USB_PRODUCT_FUSHICAI_USBTV007)
		ret = UMATCH_VENDOR_PRODUCT;
	/*
	 * This seems like a fragile check, but the original driver ensures
	 * there are two alternate settings for the interface, and alternate
	 * setting 1 has four endpoints.
	 *
	 * Comment says "Checks that the device is what we think it is."
	 *
	 * Adding check that wMaxPacketSize for the video endpoint is > 0.
	 */
	nep = nalt = 0;
	usbd_desc_iter_init(uaa->device, &iter);
	while ((ud = usbd_desc_iter_next(&iter)) != NULL) {
		switch (ud->bDescriptorType) {
		default:
			break;
		case UDESC_INTERFACE:
			uid = (void *)ud;
			if (uid->bInterfaceNumber == 0)
				nalt++;
			break;
		case UDESC_ENDPOINT:
			if (uid->bAlternateSetting == 1) {
				ued = (void *)ud;
				if (ued->bEndpointAddress == UTVFU_VIDEO_ENDP)
					psize = UGETW(ued->wMaxPacketSize);
				nep++;
			}
			break;
		}
		if (uid != NULL && uid->bInterfaceNumber > 0)
			break;
	}

	if (nalt != 2 || nep != 4 || psize == 0)
		ret = UMATCH_NONE;

	return (ret);
}

void
utvfu_attach(struct device *parent, struct device *self, void *aux)
{
	int i;
	struct utvfu_softc *sc = (struct utvfu_softc *)self;
	struct usb_attach_arg *uaa = aux;

	sc->sc_udev = uaa->device;
	for (i = 0; i < uaa->nifaces; i++) {
		if (usbd_iface_claimed(sc->sc_udev, i))
			continue;
		usbd_claim_iface(sc->sc_udev, i);
	}

	utvfu_parse_desc(sc);

	/* init mmap queue */
	SIMPLEQ_INIT(&sc->sc_mmap_q);
	sc->sc_mmap_count = 0;

	sc->sc_max_frame_sz = utvfu_max_frame_size();

	/* calculate optimal isoc xfer size */
	sc->sc_nframes = (sc->sc_max_frame_sz + sc->sc_iface.psize - 1)
	    / sc->sc_iface.psize;
	if (sc->sc_nframes > UTVFU_NFRAMES_MAX)
		sc->sc_nframes = UTVFU_NFRAMES_MAX;
	DPRINTF(1, "%s: nframes=%d\n", DEVNAME(sc), sc->sc_nframes);

	rw_init(&sc->sc_audio.rwlock, "audiorwl");

	sc->sc_audiodev = audio_attach_mi(&utvfu_au_hw_if, sc, NULL, &sc->sc_dev);
	sc->sc_videodev = video_attach_mi(&utvfu_vid_hw_if, sc, &sc->sc_dev);
}

int
utvfu_detach(struct device *self, int flags)
{
	struct utvfu_softc *sc = (struct utvfu_softc *)self;
	int rv = 0;

	/* Wait for outstanding requests to complete */
	usbd_delay_ms(sc->sc_udev, UTVFU_NFRAMES_MAX); /* XXX meh? */

	if (sc->sc_videodev != NULL)
		rv = config_detach(sc->sc_videodev, flags);

	if (sc->sc_audiodev != NULL)
		rv += config_detach(sc->sc_audiodev, flags);

	utvfu_as_free(sc);
	utvfu_vs_free(sc);

	sc->sc_flags = 0;

	return (rv);
}

usbd_status
utvfu_parse_desc(struct utvfu_softc *sc)
{
	int nif, nep;
	uint32_t psize;
	struct usbd_desc_iter iter;
	const struct usb_descriptor *ud;
	struct usb_endpoint_descriptor *ued;
	struct usb_interface_descriptor *uid = NULL;

	nif = nep = 0;
	usbd_desc_iter_init(sc->sc_udev, &iter);
	while ((ud = usbd_desc_iter_next(&iter)) != NULL) {
		if (ud->bDescriptorType != UDESC_INTERFACE)
			continue;
		/* looking for interface 0, alt-setting 1 */
		uid = (void *)ud;
		if (uid->bInterfaceNumber > 0)
			break;
		if (uid->bAlternateSetting == 1)
			break;
	}

	/* this should not fail as it was ensured during match */
	if (uid == NULL || uid->bInterfaceNumber != 0 ||
	    uid->bAlternateSetting != 1) {
		printf("%s: no valid alternate interface found!\n",
		    DEVNAME(sc));
		return (USBD_INVAL);
	}

	/* bInterfaceNumber = 0 */
	sc->sc_uifaceh = &sc->sc_udev->ifaces[0];

	/* looking for video endpoint to on alternate setting 1 */
	while ((ud = usbd_desc_iter_next(&iter)) != NULL) {
		if (ud->bDescriptorType != UDESC_ENDPOINT)
			break;

		ued = (void *)ud;
		if (ued->bEndpointAddress != UTVFU_VIDEO_ENDP)
			continue;

		psize = UGETW(ued->wMaxPacketSize);
		psize = UE_GET_SIZE(psize) * (1 + UE_GET_TRANS(psize));
		sc->sc_iface.psize = psize;
		break;
	}

	return (USBD_NORMAL_COMPLETION);
}

int
utvfu_open(void *addr, int flags, int *size, uint8_t *buffer,
    void (*intr)(void *), void *arg)
{
	struct utvfu_softc *sc = addr;
	int rv;

	DPRINTF(1, "%s: utvfu_open: sc=%p\n", DEVNAME(sc), sc);

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	if ((rv = utvfu_vs_init(sc)) != 0)
		return (rv);

	/* pointers to upper video layer */
	sc->sc_uplayer_arg = arg;
	sc->sc_uplayer_fsize = size;
	sc->sc_uplayer_fbuffer = buffer;
	sc->sc_uplayer_intr = intr;

	sc->sc_flags &= ~UTVFU_FLAG_MMAP;

	return (0);
}

int
utvfu_close(void *addr)
{
	struct utvfu_softc *sc = addr;

	DPRINTF(1, "%s: utvfu_close: sc=%p\n", DEVNAME(sc), sc);

	/* free & clean up video stream */
	utvfu_vs_free(sc);

	return (0);
}

usbd_status
utvfu_as_open(struct utvfu_softc *sc)
{
	usb_endpoint_descriptor_t *ed;
	usbd_status error;

	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	if (sc->sc_audio.iface.pipeh != NULL) {
		printf("%s: %s called while sc_audio.iface.pipeh not NULL\n",
		    DEVNAME(sc), __func__);
		return (USBD_INVAL);
	}

	ed = usbd_get_endpoint_descriptor(sc->sc_uifaceh, UTVFU_AUDIO_ENDP);
	if (ed == NULL) {
		printf("%s: no endpoint descriptor for AS iface\n",
		    DEVNAME(sc));
		return (USBD_INVAL);
	}
	DPRINTF(1, "%s: open pipe for ", DEVNAME(sc));
	DPRINTF(1, "bEndpointAddress=0x%02x (0x%02x), wMaxPacketSize="
	    "0x%04x (%d)\n",
	    UE_GET_ADDR(ed->bEndpointAddress),
	    UTVFU_AUDIO_ENDP,
	    UGETW(ed->wMaxPacketSize),
	    UE_GET_SIZE(UGETW(ed->wMaxPacketSize))
	    * (1 + UE_GET_TRANS(UGETW(ed->wMaxPacketSize))));

	error = usbd_open_pipe(
	    sc->sc_uifaceh,
	    UTVFU_AUDIO_ENDP,
	    USBD_EXCLUSIVE_USE,
	    &sc->sc_audio.iface.pipeh);
	if (error != USBD_NORMAL_COMPLETION) {
		printf("%s: could not open AS pipe: %s\n",
		    DEVNAME(sc), usbd_errstr(error));
	}

	return (error);
}

usbd_status
utvfu_vs_open(struct utvfu_softc *sc)
{
	usb_endpoint_descriptor_t *ed;
	usbd_status error;

	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	if (sc->sc_iface.pipeh != NULL) {
		printf("%s: %s called while sc_iface.pipeh not NULL\n",
		    DEVNAME(sc), __func__);
		return (USBD_INVAL);
	}

	ed = usbd_get_endpoint_descriptor(sc->sc_uifaceh, UTVFU_VIDEO_ENDP);
	if (ed == NULL) {
		printf("%s: no endpoint descriptor for VS iface\n",
		    DEVNAME(sc));
		return (USBD_INVAL);
	}
	DPRINTF(1, "%s: open pipe for ", DEVNAME(sc));
	DPRINTF(1, "bEndpointAddress=0x%02x (0x%02x), wMaxPacketSize="
	    "0x%04x (%d)\n",
	    UE_GET_ADDR(ed->bEndpointAddress),
	    UTVFU_VIDEO_ENDP,
	    UGETW(ed->wMaxPacketSize),
	    sc->sc_iface.psize);

	error = usbd_open_pipe(
	    sc->sc_uifaceh,
	    UTVFU_VIDEO_ENDP,
	    USBD_EXCLUSIVE_USE,
	    &sc->sc_iface.pipeh);
	if (error != USBD_NORMAL_COMPLETION) {
		printf("%s: could not open VS pipe: %s\n",
		    DEVNAME(sc), usbd_errstr(error));
	}

	return (error);
}

void
utvfu_as_close(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	CLR(sc->sc_flags, UTVFU_FLAG_AS_RUNNING);

	if (sc->sc_audio.iface.pipeh != NULL) {
		usbd_abort_pipe(sc->sc_audio.iface.pipeh);

		usbd_ref_wait(sc->sc_udev);

		usbd_close_pipe(sc->sc_audio.iface.pipeh);
		sc->sc_audio.iface.pipeh = NULL;
	}
}

void
utvfu_vs_close(struct utvfu_softc *sc)
{
	if (sc->sc_iface.pipeh != NULL) {
		usbd_close_pipe(sc->sc_iface.pipeh);
		sc->sc_iface.pipeh = NULL;
	}

	/*
	 * Some devices need time to shutdown before we switch back to
	 * the default interface (0).  Not doing so can leave the device
	 * back in a undefined condition.
	 */
	usbd_delay_ms(sc->sc_udev, 100);

	/* switch back to default interface (turns off cam LED) */
	(void)usbd_set_interface(sc->sc_uifaceh, UTVFU_DFLT_IFACE_IDX);
}

void
utvfu_read(struct utvfu_softc *sc, uint8_t *buf, int len)
{
	/*
	 * Copy video frame to upper layer buffer and call
	 * upper layer interrupt.
	 */
	*sc->sc_uplayer_fsize = len;
	memcpy(sc->sc_uplayer_fbuffer, buf, len);
	(*sc->sc_uplayer_intr)(sc->sc_uplayer_arg);
}

int
utvfu_as_start_bulk(struct utvfu_softc *sc)
{
	int error;

	if (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING))
		return (0);
	if (sc->sc_audio.iface.pipeh == NULL)
		return (ENXIO);

	SET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING);
	error = kthread_create(utvfu_as_bulk_thread, sc, NULL, DEVNAME(sc));
	if (error) {
		CLR(sc->sc_flags, UTVFU_FLAG_AS_RUNNING);
		printf("%s: can't create kernel thread!", DEVNAME(sc));
	}

	return (error);
}

void
utvfu_as_bulk_thread(void *arg)
{
	struct utvfu_softc *sc = arg;
	struct utvfu_as_iface *iface;
	usbd_status error;
	uint32_t actlen;

	DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__);

	iface = &sc->sc_audio.iface;
	usbd_ref_incr(sc->sc_udev);
	while (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING)) {
		usbd_setup_xfer(
		    iface->xfer,
		    iface->pipeh,
		    0,
		    NULL,
		    UTVFU_AUDIO_URBSIZE,
		    USBD_NO_COPY | USBD_SHORT_XFER_OK | USBD_SYNCHRONOUS,
		    0,
		    NULL);
		error = usbd_transfer(iface->xfer);

		if (error != USBD_NORMAL_COMPLETION) {
			DPRINTF(1, "%s: error in bulk xfer: %s!\n",
			    DEVNAME(sc), usbd_errstr(error));
			break;
		}

		usbd_get_xfer_status(iface->xfer, NULL, NULL, &actlen,
		    NULL);
		DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), actlen);

		rw_enter_read(&sc->sc_audio.rwlock);
		utvfu_audio_decode(sc, actlen);
		rw_exit_read(&sc->sc_audio.rwlock);
	}

	CLR(sc->sc_flags, UTVFU_FLAG_AS_RUNNING);
	usbd_ref_decr(sc->sc_udev);

	DPRINTF(1, "%s %s: exiting\n", DEVNAME(sc), __func__);

	kthread_exit(0);
}

void
utvfu_vs_start_isoc(struct utvfu_softc *sc)
{
	int i;

	for (i = 0; i < UTVFU_ISOC_TRANSFERS; i++)
		utvfu_vs_start_isoc_ixfer(sc, &sc->sc_iface.ixfer[i]);
}

void
utvfu_vs_start_isoc_ixfer(struct utvfu_softc *sc,
	struct utvfu_isoc_xfer *ixfer)
{
	int i;
	usbd_status error;

	DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__);

	if (usbd_is_dying(sc->sc_udev))
		return;

	for (i = 0; i < sc->sc_nframes; i++)
		ixfer->size[i] = sc->sc_iface.psize;

	usbd_setup_isoc_xfer(
	    ixfer->xfer,
	    sc->sc_iface.pipeh,
	    ixfer,
	    ixfer->size,
	    sc->sc_nframes,
	    USBD_NO_COPY | USBD_SHORT_XFER_OK,
	    utvfu_vs_cb);

	error = usbd_transfer(ixfer->xfer);
	if (error && error != USBD_IN_PROGRESS) {
		DPRINTF(1, "%s: usbd_transfer error=%s!\n",
		    DEVNAME(sc), usbd_errstr(error));
	}
}

/*
 * Each packet contains a number of 256-byte chunks composing the image frame.
 */
void
utvfu_vs_cb(struct usbd_xfer *xfer, void *priv, usbd_status status)
{
	struct utvfu_isoc_xfer *ixfer = priv;
	struct utvfu_softc *sc = ixfer->sc;
	int i, off, frame_size;
	uint32_t actlen;
	uint8_t *frame;

	DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__);

	if (status != USBD_NORMAL_COMPLETION) {
		DPRINTF(1, "%s: %s: %s\n", DEVNAME(sc), __func__,
		    usbd_errstr(status));
		return;
	}
	usbd_get_xfer_status(xfer, NULL, NULL, &actlen, NULL);

	DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), actlen);
	if (actlen == 0)
		goto skip;

	frame = KERNADDR(&xfer->dmabuf, 0);
	for (i = 0; i < sc->sc_nframes; i++, frame += sc->sc_iface.psize) {
		frame_size = ixfer->size[i];

		if (frame_size == 0)
			/* frame is empty */
			continue;

		#define	CHUNK_STRIDE	(UTVFU_CHUNK_SIZE*4)
		for (off = 0; off + CHUNK_STRIDE <= frame_size;
		     off += CHUNK_STRIDE) {
			utvfu_image_chunk(sc, frame + off);
		}
		#undef	CHUNK_STRIDE
	}

skip:	/* setup new transfer */
	utvfu_vs_start_isoc_ixfer(sc, ixfer);
}

int
utvfu_find_queued(struct utvfu_softc *sc)
{
	int i;

	/* find a buffer which is ready for queueing */
	for (i = 0; i < sc->sc_mmap_count; i++) {
		if (sc->sc_mmap[i].v4l2_buf.flags & V4L2_BUF_FLAG_DONE)
			continue;
		if (sc->sc_mmap[i].v4l2_buf.flags & V4L2_BUF_FLAG_QUEUED)
			return (i);
	}

	return (-1);
}

int
utvfu_mmap_queue(struct utvfu_softc *sc, uint8_t *buf, int len)
{
	int i;

	if (sc->sc_mmap_count == 0 || sc->sc_mmap_buffer == NULL)
		panic("%s: mmap buffers not allocated", __func__);

	/* find a buffer which is ready for queueing */
	if ((i = utvfu_find_queued(sc)) == -1) {
		DPRINTF(2, "%s: mmap queue is full!\n", DEVNAME(sc));
		return (ENOMEM);
	}

	/* copy frame to mmap buffer and report length */
	memcpy(sc->sc_mmap[i].buf, buf, len);
	sc->sc_mmap[i].v4l2_buf.bytesused = len;

	/* timestamp it */
	getmicrouptime(&sc->sc_mmap[i].v4l2_buf.timestamp);
	sc->sc_mmap[i].v4l2_buf.flags &= ~V4L2_BUF_FLAG_TIMESTAMP_MASK;
	sc->sc_mmap[i].v4l2_buf.flags |= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
	sc->sc_mmap[i].v4l2_buf.flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
	sc->sc_mmap[i].v4l2_buf.flags |= V4L2_BUF_FLAG_TSTAMP_SRC_EOF;
	sc->sc_mmap[i].v4l2_buf.flags &= ~V4L2_BUF_FLAG_TIMECODE;

	/* appropriately set/clear flags */
	sc->sc_mmap[i].v4l2_buf.flags &= ~V4L2_BUF_FLAG_QUEUED;
	sc->sc_mmap[i].v4l2_buf.flags |= V4L2_BUF_FLAG_DONE;

	/* queue it */
	SIMPLEQ_INSERT_TAIL(&sc->sc_mmap_q, &sc->sc_mmap[i], q_frames);
	DPRINTF(2, "%s: %s: frame queued on index %d\n",
	    DEVNAME(sc), __func__, i);

	wakeup(sc);

	/*
	 * In case userland uses poll(2), signal that we have a frame
	 * ready to dequeue.
	 */
	(*sc->sc_uplayer_intr)(sc->sc_uplayer_arg);

	return (0);
}

caddr_t
utvfu_mappage(void *v, off_t off, int prot)
{
	struct utvfu_softc *sc = v;
	caddr_t p = NULL;

	if (off < sc->sc_mmap_bufsz) {
		if ((sc->sc_flags & UTVFU_FLAG_MMAP) == 0)
			sc->sc_flags |= UTVFU_FLAG_MMAP;

		p = sc->sc_mmap_buffer + off;
	}

	return (p);
}

int
utvfu_get_bufsize(void *v)
{
	struct utvfu_softc *sc = v;

	/* YUYV/YUV-422: 4 bytes/2 pixel */
	return (utvfu_norm_params[sc->sc_normi].cap_width *
	    utvfu_norm_params[sc->sc_normi].cap_height * 2);
}

int
utvfu_start_read(void *v)
{
	struct utvfu_softc *sc = v;
	usbd_status error;

	if (sc->sc_flags & UTVFU_FLAG_MMAP)
		sc->sc_flags &= ~UTVFU_FLAG_MMAP;

	/* open video stream pipe */
	error = utvfu_vs_open(sc);
	if (error != USBD_NORMAL_COMPLETION)
		return (EINVAL);

	utvfu_vs_start_isoc(sc);

	return (0);
}

void
utvfu_audio_clear_client(struct utvfu_softc *sc)
{
	rw_enter_write(&sc->sc_audio.rwlock);

	sc->sc_audio.intr = NULL;
	sc->sc_audio.intr_arg = NULL;
	sc->sc_audio.start = NULL;
	sc->sc_audio.end = NULL;
	sc->sc_audio.cur = NULL;
	sc->sc_audio.blksize = 0;

	rw_exit_write(&sc->sc_audio.rwlock);
}

void
utvfu_as_free(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	utvfu_as_close(sc);
	utvfu_as_free_bulk(sc);
}

void
utvfu_vs_free(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);
	utvfu_vs_close(sc);
	utvfu_vs_free_isoc(sc);
	utvfu_vs_free_frame(sc);
}

int
utvfu_as_init(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	if (sc->sc_audio.iface.xfer != NULL)
		return (0);

	/* allocate audio and video stream xfer buffer */
	return utvfu_as_alloc_bulk(sc);
}

int
utvfu_vs_init(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	if (utvfu_start_capture(sc) != 0)
		return (EINVAL);

	if (utvfu_vs_alloc_isoc(sc) != 0 || utvfu_vs_alloc_frame(sc) != 0)
		return (ENOMEM);

	return (0);
}

int
utvfu_vs_alloc_frame(struct utvfu_softc *sc)
{
	struct utvfu_frame_buf *fb = &sc->sc_fb;

	fb->size = sc->sc_max_frame_sz;
	fb->buf = malloc(fb->size, M_USBDEV, M_NOWAIT);
	if (fb->buf == NULL) {
		printf("%s: can't allocate frame buffer!\n", DEVNAME(sc));
		return (ENOMEM);
	}

	DPRINTF(1, "%s: %s: allocated %d bytes frame buffer\n",
	    DEVNAME(sc), __func__, fb->size);

	fb->chunks_done = 0;
	fb->fid = 0;
	fb->last_odd = 1;

	return (0);
}

void
utvfu_vs_free_frame(struct utvfu_softc *sc)
{
	struct utvfu_frame_buf *fb = &sc->sc_fb;

	if (fb->buf != NULL) {
		free(fb->buf, M_USBDEV, fb->size);
		fb->buf = NULL;
	}

	if (sc->sc_mmap_buffer != NULL) {
		free(sc->sc_mmap_buffer, M_USBDEV, sc->sc_mmap_bufsz);
		sc->sc_mmap_buffer = NULL;
		memset(sc->sc_mmap, 0, sizeof(sc->sc_mmap));
	}

	while (!SIMPLEQ_EMPTY(&sc->sc_mmap_q))
		SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames);

	sc->sc_mmap_count = 0;
}

usbd_status
utvfu_vs_alloc_isoc(struct utvfu_softc *sc)
{
	int size, i;
	void *buf;

	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	for (i = 0; i < UTVFU_ISOC_TRANSFERS; i++) {
		sc->sc_iface.ixfer[i].sc = sc;
		sc->sc_iface.ixfer[i].xfer = usbd_alloc_xfer(sc->sc_udev);	
		if (sc->sc_iface.ixfer[i].xfer == NULL) {
			printf("%s: could not allocate isoc VS xfer!\n",
			    DEVNAME(sc));
			return (USBD_NOMEM);	
		}

		size = sc->sc_iface.psize * sc->sc_nframes;

		buf = usbd_alloc_buffer(sc->sc_iface.ixfer[i].xfer, size);
		if (buf == NULL) {
			printf("%s: could not allocate isoc VS buffer!\n",
			    DEVNAME(sc));
			return (USBD_NOMEM);
		}
		DPRINTF(1, "%s: allocated %d bytes isoc VS xfer buffer\n",
		    DEVNAME(sc), size);
	}

	return (USBD_NORMAL_COMPLETION);
}

int
utvfu_as_alloc_bulk(struct utvfu_softc *sc)
{
	struct usbd_xfer *xfer;

	xfer = usbd_alloc_xfer(sc->sc_udev);
	if (xfer == NULL) {
		printf("%s: could not allocate bulk AUDIO xfer!\n",
		    DEVNAME(sc));
		return (ENOMEM);
	}

	if (usbd_alloc_buffer(xfer, UTVFU_AUDIO_URBSIZE) == NULL) {
		usbd_free_xfer(xfer);
		printf("%s: could not allocate bulk AUDIO buffer!\n",
		    DEVNAME(sc));
		return (ENOMEM);
	}
	DPRINTF(1, "%s: allocated %d bytes bulk AUDIO xfer buffer\n",
	    DEVNAME(sc), UTVFU_AUDIO_URBSIZE);

	sc->sc_audio.iface.xfer = xfer;

	return (0);
}

void
utvfu_vs_free_isoc(struct utvfu_softc *sc)
{
	int i;

	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	for (i = 0; i < UTVFU_ISOC_TRANSFERS; i++) {
		if (sc->sc_iface.ixfer[i].xfer != NULL) {
			usbd_free_xfer(sc->sc_iface.ixfer[i].xfer);
			sc->sc_iface.ixfer[i].xfer = NULL;
		}
	}
}

void
utvfu_as_free_bulk(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	if (sc->sc_audio.iface.xfer != NULL) {
		usbd_free_xfer(sc->sc_audio.iface.xfer);
		sc->sc_audio.iface.xfer = NULL;
	}
}

int
utvfu_reqbufs(void *v, struct v4l2_requestbuffers *rb)
{
	struct utvfu_softc *sc = v;
	int i;

	DPRINTF(1, "%s: %s: count=%d\n", DEVNAME(sc), __func__, rb->count);

	/* We do not support freeing buffers via reqbufs(0) */
	if (rb->count == 0)
		return (EINVAL);

	if (sc->sc_mmap_count > 0 || sc->sc_mmap_buffer != NULL) {
		DPRINTF(1, "%s: %s: mmap buffers already allocated\n",
		    DEVNAME(sc), __func__);
		return (EINVAL);
	}

	/* limit the buffers */
	if (rb->count > UTVFU_MAX_BUFFERS)
		sc->sc_mmap_count = UTVFU_MAX_BUFFERS;
	else
		sc->sc_mmap_count = rb->count;

	/* allocate the total mmap buffer */	
	sc->sc_mmap_bufsz = sc->sc_max_frame_sz;
	if (INT_MAX / sc->sc_mmap_count < sc->sc_max_frame_sz) /* overflow */
		return (ENOMEM);
	sc->sc_mmap_bufsz *= sc->sc_mmap_count;
	sc->sc_mmap_bufsz = round_page(sc->sc_mmap_bufsz); /* page align */
	sc->sc_mmap_buffer = malloc(sc->sc_mmap_bufsz, M_USBDEV, M_NOWAIT);
	if (sc->sc_mmap_buffer == NULL) {
		printf("%s: can't allocate mmap buffer!\n", DEVNAME(sc));
		return (ENOMEM);
	}
	DPRINTF(1, "%s: allocated %d bytes mmap buffer\n",
	    DEVNAME(sc), sc->sc_mmap_bufsz);

	/* fill the v4l2_buffer structure */
	for (i = 0; i < sc->sc_mmap_count; i++) {
		sc->sc_mmap[i].buf = sc->sc_mmap_buffer
		    + (i * sc->sc_max_frame_sz);
		sc->sc_mmap[i].v4l2_buf.index = i;
		sc->sc_mmap[i].v4l2_buf.m.offset = i * sc->sc_max_frame_sz;
		sc->sc_mmap[i].v4l2_buf.length = sc->sc_max_frame_sz;
		sc->sc_mmap[i].v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		sc->sc_mmap[i].v4l2_buf.sequence = 0;
		sc->sc_mmap[i].v4l2_buf.field = V4L2_FIELD_NONE;
		sc->sc_mmap[i].v4l2_buf.memory = V4L2_MEMORY_MMAP;
		sc->sc_mmap[i].v4l2_buf.flags = V4L2_BUF_FLAG_MAPPED;

		DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n",
		    DEVNAME(sc), __func__,
		    sc->sc_mmap[i].v4l2_buf.index,
		    sc->sc_mmap[i].v4l2_buf.m.offset,
		    sc->sc_mmap[i].v4l2_buf.length);
	}

	/* tell how many buffers we have really allocated */
	rb->count = sc->sc_mmap_count;

	rb->capabilities = V4L2_BUF_CAP_SUPPORTS_MMAP;

	return (0);
}

int
utvfu_querybuf(void *v, struct v4l2_buffer *qb)
{
	struct utvfu_softc *sc = v;

	if (qb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
	    qb->memory != V4L2_MEMORY_MMAP ||
	    qb->index >= sc->sc_mmap_count)
		return (EINVAL);

	memcpy(qb, &sc->sc_mmap[qb->index].v4l2_buf,
	    sizeof(struct v4l2_buffer));

	DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n",
	    DEVNAME(sc), __func__, qb->index, qb->m.offset, qb->length);

	return (0);
}

int
utvfu_qbuf(void *v, struct v4l2_buffer *qb)
{
	struct utvfu_softc *sc = v;

	if (qb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
	    qb->memory != V4L2_MEMORY_MMAP ||
	    qb->index >= sc->sc_mmap_count)
		return (EINVAL);

	sc->sc_mmap[qb->index].v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE;
	sc->sc_mmap[qb->index].v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED;
	sc->sc_mmap[qb->index].v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED;

	DPRINTF(2, "%s: %s: buffer on index %d ready for queueing\n",
	    DEVNAME(sc), __func__, qb->index);

	return (0);
}

int
utvfu_dqbuf(void *v, struct v4l2_buffer *dqb)
{
	struct utvfu_softc *sc = v;
	struct utvfu_mmap *mmap;
	int error;

	if (dqb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
	    dqb->memory != V4L2_MEMORY_MMAP)
		return (EINVAL);

	if (SIMPLEQ_EMPTY(&sc->sc_mmap_q)) {
		/* mmap queue is empty, block until first frame is queued */
		error = tsleep_nsec(sc, 0, "vid_mmap", SEC_TO_NSEC(10));
		if (error)
			return (EINVAL);
	}

	mmap = SIMPLEQ_FIRST(&sc->sc_mmap_q);
	if (mmap == NULL)
		panic("utvfu_dqbuf: NULL pointer!");

	memcpy(dqb, &mmap->v4l2_buf, sizeof(struct v4l2_buffer));

	mmap->v4l2_buf.flags &= ~(V4L2_BUF_FLAG_DONE|V4L2_BUF_FLAG_QUEUED);
	mmap->v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED;

	DPRINTF(2, "%s: %s: frame dequeued from index %d\n",
	    DEVNAME(sc), __func__, mmap->v4l2_buf.index);
	SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames);

	return (0);
}

int
utvfu_streamon(void *v, int type)
{
	struct utvfu_softc *sc = v;
	usbd_status error;

	/* open video stream pipe */
	error = utvfu_vs_open(sc);
	if (error != USBD_NORMAL_COMPLETION)
		return (EINVAL);

	utvfu_vs_start_isoc(sc);

	return (0);
}

int
utvfu_streamoff(void *v, int type)
{
	utvfu_vs_close(v);

	return (0);
}

int
utvfu_queryctrl(void *v, struct v4l2_queryctrl *qctrl)
{
	qctrl->flags = V4L2_CTRL_FLAG_DISABLED;

	return (0);
}

int
utvfu_g_parm(void *v, struct v4l2_streamparm *parm)
{
	struct utvfu_softc *sc = v;

	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		return (EINVAL);

	/*
	 * XXX Unsure whether there is a way to negotiate this with the
	 * device, but returning 0 will allow xenocara's video to run
	 */
	switch (utvfu_norm_params[sc->sc_normi].norm) {
	default:
		return (EINVAL);
	case V4L2_STD_525_60:
		parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
		parm->parm.capture.capturemode = 0;
		parm->parm.capture.timeperframe.numerator = 30;
		parm->parm.capture.timeperframe.denominator = 1;
		break;
	case V4L2_STD_PAL:
		parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
		parm->parm.capture.capturemode = 0;
		parm->parm.capture.timeperframe.numerator = 25;
		parm->parm.capture.timeperframe.denominator = 1;
		break;
	}

	return (0);
}

int
utvfu_s_parm(void *v, struct v4l2_streamparm *parm)
{
	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
		return (EINVAL);

	return (0);
}

/*
 * A U D I O   O P S
 */

int
utvfu_audio_open(void *v, int flags)
{
	struct utvfu_softc *sc = v;

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	if ((flags & FWRITE))
		return (ENXIO);

	if (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING))
		return (EBUSY);

	return utvfu_as_init(sc);
}

void
utvfu_audio_close(void *v)
{
	struct utvfu_softc *sc = v;

	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	utvfu_audio_stop(sc);
	utvfu_audio_clear_client(sc);
}

int
utvfu_audio_set_params(void *v, int setmode, int usemode,
    struct audio_params *play, struct audio_params *rec)
{
	struct utvfu_softc *sc = v;

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__);

	/* XXX ? */
	play->sample_rate = 0;
	play->encoding = AUDIO_ENCODING_NONE;

	rec->sample_rate = 48000;
	rec->encoding = AUDIO_ENCODING_SLINEAR_LE;
	rec->precision = 16;
	rec->bps = 2;
	rec->msb = 1;
	rec->channels = 2;

	return (0);
}

int
utvfu_audio_halt_out(void *v)
{
	return (EIO);
}

int
utvfu_audio_halt_in(void *v)
{
	struct utvfu_softc *sc = v;

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	utvfu_audio_stop(sc);
	utvfu_audio_clear_client(sc);

	return (0);
}

int
utvfu_audio_mixer_set_port(void *v, struct mixer_ctrl *cp)
{
	struct utvfu_softc *sc = v;

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__);

	if (cp->type != AUDIO_MIXER_ENUM ||
	    cp->un.ord < 0 || cp->un.ord > 1)
		return (EINVAL);

	/* XXX TODO */

	DPRINTF(1, "%s %s: cp->un.ord=%d\n", DEVNAME(sc), __func__, cp->un.ord);

	return (0);
}

int
utvfu_audio_mixer_get_port(void *v, struct mixer_ctrl *cp)
{
	struct utvfu_softc *sc = v;

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__);

	if (cp->type != AUDIO_MIXER_ENUM ||
	    cp->un.ord < 0 || cp->un.ord > 1)
		return (EINVAL);

	/* XXX TODO */

	DPRINTF(1, "%s %s: cp->un.ord=%d\n", DEVNAME(sc), __func__, cp->un.ord);

	return (0);
}

int
utvfu_audio_query_devinfo(void *v, struct mixer_devinfo *mi)
{
	struct utvfu_softc *sc = v;

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__);

	if (mi->index != 0)
		return (EINVAL);

	/* XXX SOMEONE WITH AUDIO EXPERTIZE NEEDS TO HELP HERE */
	strlcpy(mi->label.name, "mix0-i0", sizeof(mi->label.name));
	mi->type = AUDIO_MIXER_ENUM;
	mi->un.e.num_mem = 2;
	mi->un.e.member[0].ord = 0;
	strlcpy(mi->un.e.member[0].label.name, AudioNoff,
	    sizeof(mi->un.e.member[0].label.name));
	mi->un.e.member[1].ord = 1;
	strlcpy(mi->un.e.member[1].label.name, AudioNon,
	    sizeof(mi->un.e.member[1].label.name));

	return (0);
}

int
utvfu_audio_trigger_output(void *v, void *start, void *end, int blksize,
    void (*intr)(void *), void *arg, struct audio_params *param)
{
	return (EIO);
}

int
utvfu_audio_trigger_input(void *v, void *start, void *end, int blksize,
    void (*intr)(void *), void *arg, struct audio_params *param)
{
	struct utvfu_softc *sc = v;

	if (usbd_is_dying(sc->sc_udev))
		return (EIO);

	rw_enter_write(&sc->sc_audio.rwlock);

	sc->sc_audio.intr_arg = arg;
	sc->sc_audio.intr = intr;
	sc->sc_audio.start = start;
	sc->sc_audio.end = end;
	sc->sc_audio.cur = start;
	sc->sc_audio.blksize = blksize;

	rw_exit_write(&sc->sc_audio.rwlock);

	DPRINTF(1, "%s %s: start=%p end=%p diff=%lu blksize=%d\n",
	    DEVNAME(sc), __func__, start, end,
	    ((u_char *)end - (u_char *)start), blksize);

	return utvfu_audio_start(sc);
}

int
utvfu_audio_start(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	if (ISSET(sc->sc_flags, UTVFU_FLAG_AS_RUNNING))
		return (0);

	utvfu_audio_start_chip(sc);

	if (utvfu_as_init(sc) != 0)
		return (ENOMEM);
	if (sc->sc_audio.iface.pipeh == NULL) {
		if (utvfu_as_open(sc) != USBD_NORMAL_COMPLETION)
			return (ENOMEM);
	}

	return utvfu_as_start_bulk(sc);
}

int
utvfu_audio_stop(struct utvfu_softc *sc)
{
	DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);

	utvfu_audio_stop_chip(sc);
	utvfu_as_free(sc);

	return (0);
}