Hello,
On Mon, May 30, 2016 at 04:22:56PM +0200, Martin Pieuchot wrote:
> On 26/05/16(Thu) 16:09, patrick keshishian wrote:
> >
> > Included is my initial effort to port the dual-licensed driver
> > for Fushicai Audio-Video Grabber (vendor 0x1b71 product 0x3002).
>
> Nice. Did you test both bulk and iso? Some comments inline.
As far as I can tell, this device's video streaming endpoint
is isochronous.
I think I have addressed most of the points you highlighted.
I'll reply inline to each. New diff is inline at the end. I
had to add a rwlock as I hit a race condition testing, where
the bulk thread was accessing variables, as they are being
cleared when the audio client was closing the device.
> > Index: dev/usb/files.usb
> > ===================================================================
> > RCS file: /cvs/obsd/src/sys/dev/usb/files.usb,v
> > retrieving revision 1.126
> > diff -u -p -u -p -r1.126 files.usb
> > --- dev/usb/files.usb 8 Jan 2016 15:54:13 -0000 1.126
> > +++ dev/usb/files.usb 26 May 2016 22:34:38 -0000
> > @@ -35,6 +35,12 @@ device uvideo: video, firmload
> > attach uvideo at uhub
> > file dev/usb/uvideo.c uvideo
> >
> > +# USBTV007 devices
> > +device utvfu: video, audio
> > +attach utvfu at uhub
> > +file dev/usb/utvfu.c utvfu
> > +file dev/usb/utvfu_ops.c utvfu
>
> I'd appreciate if we can keep the driver in one file, when the license
> issue is solved, this is coherent with the rest of our tree.
*cringe* ... I'll let the more experienced decide how this is
handled. I don't have strong feelings on this subject, whichever
way it is decided. Just that, one of the licenses is slightly
more restrictive.
> > +#ifndef _UTVFU_H_
> > +#define _UTVFU_H_
>
> Is there any hardware reference for this device or everything is reverse
> engineered? I mean the values below are specified somewhere?
None which I am aware of. The original driver mentions reverse
engineering it.
> > +#define UTVFU_COMPOSITE_INPUT 0
> > +#define UTVFU_SVIDEO_INPUT 1
> ^^^^^^
> We try to avoid mixing space and tab after "#define"
I fixed this and two others. Hopefully that was all there was.
> > +/* parameters for supported TV norms */
> > +struct utvfu_norm_params {
> > + v4l2_std_id norm;
> > + int cap_width,
> > + cap_height,
> > + frame_len;
>
> Please one type per line.
Fixed.
> > +struct utvfu_isoc_xfer {
> > + struct utvfu_softc *sc;
> > + struct usbd_xfer *xfer;
> > + void *buf;
> > + uint16_t size[UTVFU_NFRAMES_MAX];
> > +};
> > +
> > +struct utvfu_bulk_xfer {
> > + struct usbd_xfer *xfer;
> > + void *buf;
>
> I'd use the simpler approach of using KERNADDR(&xfer->dmabuf, 0) instead
> of defining another structure to abstract an USB xfer. You can look at
> uhidev_get_report_async_cb() for an example.
I had to scratch my head a few times then look in the usb
sources to see exactly what was going on. So yes. I agree
and have made the change.
> > +#define UTVFU_DEBUG
> > +#ifdef UTVFU_DEBUG
> > +extern int utvfu_debug;
> > +#define DPRINTF(l, x...) do { if ((l) <= utvfu_debug) printf(x); } while
> > (0)
>
> You mostly have 1 level, so do you really want a `D'PRINTF()? By the
> way, we try to remove debug printf before committing code. So if you
> think some of the printfs you added won't help later, just get rid of
> them.
This came over from uvideo.c. I have gotten rid of a few in
this revision. As I shuffle around code, if I break things,
they sometimes are helpful. They can be trimmed more later.
> > + 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 (USBD_NORMAL_COMPLETION != error) {
>
> This way of checking for error value might be clever, but I IMHO being
> coherent with the rest of the code base is more important. So I would
> stick to the "if (variable == constant)" style.
OK.
> > + DPRINTF(1, "%s: %s: calling usbd_set_interface(ifaceh, 0)\n",
> > + DEVNAME(sc), __func__);
> > + /* default video stream interface */
> > + error = usbd_set_interface(sc->sc_uifaceh, 0);
>
> Could you add a define for `0' and `1` below. This would auto-document
> the code, and you can also remove these debug-only printfs ;)
Done.
> > +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);
> > +}
>
> These two functions seem unused.
True. I haven't, but I'll look to see how they are used in
Linux to switch between the two flavors.
> > + while (len >= UTVFU_CHUNK_SIZE) {
> > + /*
> > + * Header is 0xdd000000 -> 0xdd0003ff
> > + * Seems, 0x03ff mask grabs the chunk number.
> > + */
>
> This comment is confusing. Since you're using defines, I'd kill it.
Well, I updated it to something better. I was documenting, for
myself at least, what I was seeing in the header. 0xdd seems
to be a "magic" byte, with the lower bits being the "chunk"
number: starting at 0 and counting all the way up to 0x3ff.
The video chunk header is similar with "magic" of 0x88 and
a "chunk" counter, but also contains frame-id and odd/even
scan-line indicator.
> > +const struct cfattach utvfu_ca = {
> > + sizeof(struct utvfu_softc),
> > + utvfu_match,
> > + utvfu_attach,
> > + utvfu_detach,
> > + utvfu_activate
>
> Could you tell me if you really need an *activate() function? The
> configure(9) framework should already keep track of your children
> (video(9) and audio(9)) and do the right thing (tm).
You are correct. It is gone.
> > +utvfu_match(struct device *parent, void *match, void *aux)
> > +{
> > + struct usb_attach_arg *uaa = aux;
> > + usb_device_descriptor_t *dd;
> > + int ret = UMATCH_NONE;
> > +
> > + if (uaa->iface == NULL)
> > + return ret;
> > +
> > + dd = usbd_get_device_descriptor(uaa->device);
> > + if (dd == NULL)
> > + return ret;
>
> You can remove this check it is useless.
OK.
> > + if (UGETW(dd->idVendor) == USB_VENDOR_FUSHICAI &&
> > + UGETW(dd->idProduct) == USB_PRODUCT_FUSHICAI_USBTV007)
> > + ret = UMATCH_VENDOR_PRODUCT;
>
> Can't you match based on the device descriptor rather than the ID? If
> this is possible then we won't have to add a new entry for every device
> attaching to your driver.
Not sure if I understand. You mean by bDeviceClass or
bDeviceSubClass? If so, nope, as at least, my device has
those set to 0.
> > + * XXX
>
> No need for a XXX your comment is good enough :)
>
> > + * 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."
> > + */
> > + if (!utvfu_check_if_alt_cond(uaa->device))
> > + ret = UMATCH_NONE;
>
> Since you're not using this function anywhere else, I'd inline it here.
Fixed.
> > + /* XXX What happens if this fails? Can this fail? */
> > + (void)utvfu_parse_desc(sc);
>
> Since you're parsing an already fetched descriptor, if the descriptor is
> valid it should not fail. So I would do this check in *match() so you
> know for sure here it won't fail.
>
> As a general rule I try to only return a usbd_status for function
> generating I/O. This would help your question because any function
> generating I/O can fail. But that's not the case here.
I followed this advice.
> > + /* set default video stream interface */
> > + (void)usbd_set_interface(sc->sc_uifaceh, 0);
>
> This should not be necessary since your *match() function wait for a
> valid `uaa->iface'. You could check that the active iface is the
> correct one though.
OK. Works fine.
> > + /* calculate optimal isoc xfer size */
> > + if (strcmp(sc->sc_udev->bus->bdev.dv_cfdata->cf_driver->cd_name,
> > + "ohci") == 0) {
> > + /* ohci workaround */
> > + sc->sc_nframes = 8;
>
> WTF? Is this a USB 1 device? Did you try it on ohci(4)? That's ugly!
Came over from uvideo.c. Now removed.
> > + if (USBD_NORMAL_COMPLETION != utvfu_vs_init(sc) ||
> > + USBD_NORMAL_COMPLETION != utvfu_as_init(sc))
> > + return (EINVAL);
>
> Are these functions generating I/O? I doubt it, so if you like my rule
> below, I'd make then return an `int' rather than a usbd_status.
Yes. Like the rule and applied.
> > + bcopy(buf, sc->sc_uplayer_fbuffer, len);
>
> Can you use memcpy() (or memmove()) to be coherent with your memset().
OK.
> > +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 */
>
> You should ask ratchov@
I had reached out to him privately, he assured me he reads
tech@ :-) I'll Cc him in this reply.
Thank you for the comments and the time reading/looking through
this code Martin.
You too Marcus for all the help and advice.
--patrick
2nd (public) revision:
Index: arch/amd64/conf/GENERIC
===================================================================
RCS file: /cvs/obsd/src/sys/arch/amd64/conf/GENERIC,v
retrieving revision 1.418
diff -u -p -u -p -r1.418 GENERIC
--- arch/amd64/conf/GENERIC 7 May 2016 23:10:50 -0000 1.418
+++ arch/amd64/conf/GENERIC 1 Jun 2016 05:45:53 -0000
@@ -290,6 +290,9 @@ uoakv* at uhidev? # Toradex OAK 10V sen
onewire* at uow?
uvideo* at uhub? # USB Video
video* at uvideo?
+utvfu* at uhub? # Fushicai Audio-Video Grabber
+video* at utvfu?
+audio* at utvfu?
udl* at uhub? # DisplayLink USB displays
wsdisplay* at udl?
Index: arch/macppc/conf/GENERIC
===================================================================
RCS file: /cvs/obsd/src/sys/arch/macppc/conf/GENERIC,v
retrieving revision 1.256
diff -u -p -u -p -r1.256 GENERIC
--- arch/macppc/conf/GENERIC 24 Apr 2016 17:30:31 -0000 1.256
+++ arch/macppc/conf/GENERIC 1 Jun 2016 05:45:53 -0000
@@ -302,6 +302,10 @@ onewire* at uow?
uvideo* at uhub?
video* at uvideo?
+utvfu* at uhub? # Fushicai Audio-Video Grabber
+video* at utvfu?
+audio* at utvfu?
+
udl* at uhub?
wsdisplay* at udl?
Index: dev/audio.c
===================================================================
RCS file: /cvs/obsd/src/sys/dev/audio.c,v
retrieving revision 1.147
diff -u -p -u -p -r1.147 audio.c
--- dev/audio.c 11 May 2016 16:16:58 -0000 1.147
+++ dev/audio.c 1 Jun 2016 05:45:53 -0000
@@ -1344,6 +1344,14 @@ audio_detach(struct device *self, int fl
return 0;
}
+int
+audio_submatch(struct device *parent, void *match, void *aux)
+{
+ struct cfdata *cf = match;
+
+ return (cf->cf_driver == &audio_cd);
+}
+
struct device *
audio_attach_mi(struct audio_hw_if *ops, void *arg, struct device *dev)
{
@@ -1357,7 +1365,7 @@ audio_attach_mi(struct audio_hw_if *ops,
* attach this driver to the caller (hardware driver), this
* checks the kernel config and possibly calls audio_attach()
*/
- return config_found(dev, &aa, audioprint);
+ return config_found_sm(dev, &aa, audioprint, audio_submatch);
}
int
Index: dev/video.c
===================================================================
RCS file: /cvs/obsd/src/sys/dev/video.c,v
retrieving revision 1.38
diff -u -p -u -p -r1.38 video.c
--- dev/video.c 8 Feb 2016 17:21:10 -0000 1.38
+++ dev/video.c 1 Jun 2016 05:45:53 -0000
@@ -392,6 +392,14 @@ videommap(dev_t dev, off_t off, int prot
return (pa);
}
+int
+video_submatch(struct device *parent, void *match, void *aux)
+{
+ struct cfdata *cf = match;
+
+ return (cf->cf_driver == &video_cd);
+}
+
/*
* Called from hardware driver. This is where the MI video driver gets
* probed/attached to the hardware driver
@@ -403,7 +411,7 @@ video_attach_mi(struct video_hw_if *rhwp
arg.hwif = rhwp;
arg.hdl = hdlp;
- return (config_found(dev, &arg, videoprint));
+ return (config_found_sm(dev, &arg, videoprint, video_submatch));
}
void
Index: dev/usb/usbdevs
===================================================================
RCS file: /cvs/obsd/src/sys/dev/usb/usbdevs,v
retrieving revision 1.664
diff -u -p -u -p -r1.664 usbdevs
--- dev/usb/usbdevs 20 May 2016 02:04:24 -0000 1.664
+++ dev/usb/usbdevs 1 Jun 2016 05:45:53 -0000
@@ -591,6 +591,7 @@ vendor SILABS5 0x1ba4 Silicon Labs
vendor CORSAIR 0x1b1c Corsair
vendor MATRIXORB 0x1b3d Matrix Orbital
vendor TORADEX 0x1b67 Toradex inc.
+vendor FUSHICAI 0x1b71 Fushicai
vendor OVISLINK 0x1b75 OvisLink
vendor TML 0x1b91 The Mobility Lab
vendor TCTMOBILE 0x1bbb TCT Mobile
@@ -1996,6 +1997,9 @@ product FUJITSUCOMP VIRTETH 0xa4a2 Virtu
/* Fujitsu Siemens Computers products */
product FSC E5400 0x1009 PrismGT USB 2.0 WLAN
+
+/* Fushicai */
+product FUSHICAI USBTV007 0x3002 Fushicai Audio-Video Grabber
/* G.Mate */
product GMATE YP3X00 0x1001 YP3X00 PDA
Index: dev/usb/files.usb
===================================================================
RCS file: /cvs/obsd/src/sys/dev/usb/files.usb,v
retrieving revision 1.126
diff -u -p -u -p -r1.126 files.usb
--- dev/usb/files.usb 8 Jan 2016 15:54:13 -0000 1.126
+++ dev/usb/files.usb 1 Jun 2016 05:45:53 -0000
@@ -35,6 +35,12 @@ device uvideo: video, firmload
attach uvideo at uhub
file dev/usb/uvideo.c uvideo
+# USBTV007 devices
+device utvfu: video, audio
+attach utvfu at uhub
+file dev/usb/utvfu.c utvfu
+file dev/usb/utvfu_ops.c utvfu
+
device udl: wsemuldisplaydev, rasops16, edid
attach udl at uhub
file dev/usb/udl.c udl
Index: ./dev/usb/utvfu.c
===================================================================
RCS file: ./dev/usb/utvfu.c
diff -N ./dev/usb/utvfu.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ./dev/usb/utvfu.c 1 Jun 2016 05:45:53 -0000
@@ -0,0 +1,694 @@
+/* $OpenBSD$ */
+/*
+ * 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/kernel.h>
+#include <sys/malloc.h>
+#include <sys/audioio.h>
+#include <sys/videoio.h>
+
+#include <machine/bus.h>
+
+#include <dev/audio_if.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/video_if.h>
+
+#include "utvfu.h"
+
+#ifdef UTVFU_DEBUG
+extern int utvfu_debug;
+#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;
+
+ DPRINTF(1, "%s: %s: size=%d enter\n", DEVNAME(sc), __func__, size);
+
+ 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);
+ }
+ }
+
+ DPRINTF(1, "%s: %s: exit OK\n", DEVNAME(sc), __func__);
+
+ 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 copyting,
+ * 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;
+
+ DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__);
+
+ 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);
+
+ 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);
+
+ 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);
+}
Index: ./dev/usb/utvfu.h
===================================================================
RCS file: ./dev/usb/utvfu.h
diff -N ./dev/usb/utvfu.h
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ./dev/usb/utvfu.h 1 Jun 2016 05:45:53 -0000
@@ -0,0 +1,196 @@
+/* $OpenBSD$ */
+/*
+ * Copyright (c) 2013 Lubomir Rintel
+ * 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
+ *
+ * No physical hardware was harmed running Windows during the
+ * reverse-engineering activity
+ */
+
+#ifndef _UTVFU_H_
+#define _UTVFU_H_
+
+#include <sys/rwlock.h>
+#include <sys/queue.h>
+#include <sys/videoio.h>
+
+#define UTVFU_DEBUG
+
+/* Hardware. */
+#define UTVFU_VIDEO_ENDP 0x81
+#define UTVFU_AUDIO_ENDP 0x83
+#define UTVFU_BASE 0xc000
+#define UTVFU_REQUEST_REG 12
+
+#define UTVFU_DFLT_IFACE_IDX 0
+#define UTVFU_ALT_IFACE_IDX 1
+
+/*
+ * Number of concurrent isochronous urbs submitted.
+ * Higher numbers was seen to overly saturate the USB bus.
+ */
+#define UTVFU_ISOC_TRANSFERS 16
+#define UTVFU_ISOC_PACKETS 8
+
+#define UTVFU_CHUNK_SIZE 256
+#define UTVFU_CHUNK 240
+
+#define UTVFU_AUDIO_URBSIZE 20480
+#define UTVFU_AUDIO_HDRSIZE 4
+#define UTVFU_AUDIO_BUFFER 65536
+
+#define UTVFU_COMPOSITE_INPUT 0
+#define UTVFU_SVIDEO_INPUT 1
+
+/* Chunk header. */
+#define UTVFU_MAGIC(hdr) (hdr & 0xff000000U)
+#define UTVFU_MAGIC_OK(hdr) ((hdr & 0xff000000U) == 0x88000000U)
+#define UTVFU_FRAME_ID(hdr) ((hdr & 0x00ff0000U) >> 16)
+#define UTVFU_ODD(hdr) ((hdr & 0x0000f000U) >> 15)
+#define UTVFU_CHUNK_NO(hdr) (hdr & 0x00000fffU)
+
+#define UTVFU_TV_STD (V4L2_STD_525_60 | V4L2_STD_PAL)
+
+/* parameters for supported TV norms */
+struct utvfu_norm_params {
+ v4l2_std_id norm;
+ int cap_width;
+ int cap_height;
+ int frame_len;
+};
+extern struct utvfu_norm_params utvfu_norm_params[];
+
+#define UTVFU_MAX_BUFFERS 32
+struct utvfu_mmap {
+ SIMPLEQ_ENTRY(utvfu_mmap) q_frames;
+ uint8_t *buf;
+ struct v4l2_buffer v4l2_buf;
+};
+typedef SIMPLEQ_HEAD(, utvfu_mmap) q_mmap;
+
+struct utvfu_frame_buf {
+ uint off;
+ uint size;
+ uint16_t chunks_done;
+ uint8_t fid;
+ uint8_t last_odd;
+ uint8_t *buf;
+};
+
+#define UTVFU_NFRAMES_MAX 40
+struct utvfu_isoc_xfer {
+ struct utvfu_softc *sc;
+ struct usbd_xfer *xfer;
+ uint16_t size[UTVFU_NFRAMES_MAX];
+};
+
+struct utvfu_vs_iface {
+ struct usbd_pipe *pipeh;
+ int endpoint;
+ uint32_t psize;
+ struct utvfu_isoc_xfer ixfer[UTVFU_ISOC_TRANSFERS];
+};
+
+struct utvfu_as_iface {
+ struct usbd_pipe *pipeh;
+ int endpoint;
+ struct usbd_xfer *xfer;
+};
+
+struct utvfu_audio_chan {
+ uint8_t *start;
+ uint8_t *end;
+ uint8_t *cur;
+ int blksize;
+ void *intr_arg;
+ void (*intr)(void *);
+ struct utvfu_as_iface iface;
+ struct rwlock rwlock;
+};
+
+/* Per-device structure. */
+struct utvfu_softc {
+ struct device sc_dev;
+ struct usbd_device *sc_udev;
+ struct usbd_interface *sc_uifaceh;
+
+ /* audio & video device */
+ struct device *sc_audiodev;
+ struct device *sc_videodev;
+
+#define UTVFU_FLAG_MMAP 0x01
+#define UTVFU_FLAG_AUDIO_CLI 0x02
+#define UTVFU_FLAG_VIDEO_CLI 0x04
+ int sc_flags;
+
+ int sc_normi;
+ int sc_nchunks;
+ int sc_input;
+ int sc_max_frame_sz;
+ int sc_nframes;
+
+ struct utvfu_vs_iface sc_iface;
+ struct utvfu_frame_buf sc_fb;
+
+ int sc_as_running;
+ struct utvfu_audio_chan sc_audio;
+
+ /* mmap */
+ struct utvfu_mmap sc_mmap[UTVFU_MAX_BUFFERS];
+ uint8_t *sc_mmap_buffer;
+ q_mmap sc_mmap_q;
+ int sc_mmap_bufsz;
+ int sc_mmap_count;
+
+ /* uplayer */
+ void *sc_uplayer_arg;
+ int *sc_uplayer_fsize;
+ uint8_t *sc_uplayer_fbuffer;
+ void (*sc_uplayer_intr)(void *);
+};
+
+int utvfu_max_frame_size(void);
+int utvfu_set_regs(struct utvfu_softc *, const uint16_t regs[][2], int);
+void utvfu_image_chunk(struct utvfu_softc *, u_char *);
+int utvfu_configure_for_norm(struct utvfu_softc *, v4l2_std_id);
+int utvfu_start_capture(struct utvfu_softc *);
+int utvfu_mmap_queue(struct utvfu_softc *, uint8_t *, int);
+void utvfu_read(struct utvfu_softc *, uint8_t *, int);
+
+void utvfu_audio_decode(struct utvfu_softc *, int);
+int utvfu_audio_start(struct utvfu_softc *);
+int utvfu_audio_stop(struct utvfu_softc *);
+int utvfu_audio_start_chip(struct utvfu_softc *);
+int utvfu_audio_stop_chip(struct utvfu_softc *);
+
+#endif
Index: ./dev/usb/utvfu_ops.c
===================================================================
RCS file: ./dev/usb/utvfu_ops.c
diff -N ./dev/usb/utvfu_ops.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ./dev/usb/utvfu_ops.c 1 Jun 2016 05:45:53 -0000
@@ -0,0 +1,1440 @@
+/* $OpenBSD$ */
+/*
+ * Copyright (c) 2008 Robert Nagy <[email protected]>
+ * Copyright (c) 2008 Marcus Glocker <[email protected]>
+ * Copyright (c) 2016 OpenBSD
+ *
+ * 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 sources; work done by Patrick Keshishian.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/fcntl.h>
+#include <sys/kernel.h>
+#include <sys/kthread.h>
+#include <sys/malloc.h>
+#include <sys/audioio.h>
+#include <sys/videoio.h>
+
+#include <uvm/uvm_extern.h>
+
+#include <machine/bus.h>
+
+#include <dev/audio_if.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/video_if.h>
+
+#include "utvfu.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)
+
+int utvfu_match(struct device *, void *, void *);
+void utvfu_attach(struct device *, struct device *, void *);
+int utvfu_detach(struct device *, int);
+
+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_query_encoding(void *, struct audio_encoding *);
+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_getdev(void *, struct audio_device *);
+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_get_props(void *);
+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 *);
+void utvfu_audio_get_default_params(void *, int,
+ struct audio_params *);
+
+#define UTVFU_AUDIO_HAS_CLIENT(sc) ((sc)->sc_flags &
UTVFU_FLAG_AUDIO_CLI)
+#define UTVFU_VIDEO_HAS_CLIENT(sc) ((sc)->sc_flags &
UTVFU_FLAG_VIDEO_CLI)
+
+
+struct cfdriver utvfu_cd = {
+ NULL, "utvfu", DV_DULL
+};
+
+const struct cfattach utvfu_ca = {
+ sizeof(struct utvfu_softc),
+ utvfu_match,
+ utvfu_attach,
+ utvfu_detach,
+ NULL
+};
+
+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 */
+};
+
+
+struct audio_device utvfu_audio_device = {
+ "UTVFU Audio", /* name */
+ "", /* version */
+ "utvfu" /* config */
+};
+
+struct audio_hw_if utvfu_au_hw_if = {
+ utvfu_audio_open, /* open hardware */
+ utvfu_audio_close, /* close hardware */
+ NULL, /* Optional: drain buffers */
+ utvfu_audio_query_encoding,
+ utvfu_audio_set_params,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ utvfu_audio_halt_out,
+ utvfu_audio_halt_in,
+ NULL,
+ utvfu_audio_getdev,
+ NULL,
+ utvfu_audio_mixer_set_port,
+ utvfu_audio_mixer_get_port,
+ utvfu_audio_query_devinfo,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ utvfu_audio_get_props,
+ utvfu_audio_trigger_output,
+ utvfu_audio_trigger_input,
+ utvfu_audio_get_default_params
+};
+
+/* prototypes */
+usbd_status utvfu_parse_desc(struct utvfu_softc *);
+
+int
+utvfu_match(struct device *parent, void *match, void *aux)
+{
+ struct usb_attach_arg *uaa = aux;
+ struct usb_descriptor const *ud;
+ struct usbd_desc_iter iter;
+ struct usb_interface_descriptor *uid = NULL;
+ usb_device_descriptor_t *dd;
+ int ret = UMATCH_NONE;
+ int nep, nalt;
+
+ 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."
+ */
+ 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)
+ nep++;
+ break;
+ }
+ if (uid != NULL && uid->bInterfaceNumber > 0)
+ break;
+ }
+
+ if (nalt != 2 || nep != 4)
+ 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, &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);
+
+ sc->sc_flags = 0;
+ utvfu_as_free(sc);
+ utvfu_vs_free(sc);
+
+ 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;
+ }
+ if (uid == NULL || uid->bInterfaceNumber != 0 ||
+ uid->bAlternateSetting != 1)
+ goto bad;
+
+ /* now looking for endpoint with maximum bandwidth */
+ while ((ud = usbd_desc_iter_next(&iter)) != NULL) {
+ if (ud->bDescriptorType != UDESC_ENDPOINT)
+ break;
+
+ ued = (void *)ud;
+ psize = UGETW(ued->wMaxPacketSize);
+ psize = UE_GET_SIZE(psize) * (1 + UE_GET_TRANS(psize));
+ if (psize > sc->sc_iface.psize) {
+ /* bInterfaceNumber = 0 */
+ sc->sc_uifaceh = &sc->sc_udev->ifaces[0];
+ sc->sc_iface.endpoint = ued->bEndpointAddress;
+ sc->sc_iface.psize = psize;
+ }
+ }
+
+ if (sc->sc_uifaceh != NULL)
+ return (USBD_NORMAL_COMPLETION);
+bad:
+ printf("%s: no valid alternate interface found!\n", DEVNAME(sc));
+ return (USBD_INVAL);
+}
+
+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 || (rv = utvfu_as_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_VIDEO_CLI;
+ 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);
+ sc->sc_flags &= ~UTVFU_FLAG_VIDEO_CLI;
+
+ if (!UTVFU_AUDIO_HAS_CLIENT(sc))
+ utvfu_as_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),
+ sc->sc_iface.psize);
+
+ 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,
+ sc->sc_iface.endpoint);
+ 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),
+ sc->sc_iface.endpoint,
+ UGETW(ed->wMaxPacketSize),
+ sc->sc_iface.psize);
+
+ error = usbd_open_pipe(
+ sc->sc_uifaceh,
+ sc->sc_iface.endpoint,
+ 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)
+{
+ if (sc->sc_audio.iface.pipeh != NULL) {
+ usbd_abort_pipe(sc->sc_audio.iface.pipeh);
+ 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_abort_pipe(sc->sc_iface.pipeh);
+ 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 (sc->sc_as_running == 1)
+ return (0);
+ if (sc->sc_audio.iface.pipeh == NULL)
+ return (ENXIO);
+
+ sc->sc_as_running = 1;
+ error = kthread_create(utvfu_as_bulk_thread, sc, NULL, DEVNAME(sc));
+ if (error) {
+ sc->sc_as_running = 0;
+ 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;
+
+ iface = &sc->sc_audio.iface;
+ while (sc->sc_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);
+
+ if (UTVFU_AUDIO_HAS_CLIENT(sc)) {
+ rw_enter_read(&sc->sc_audio.rwlock);
+ utvfu_audio_decode(sc, actlen);
+ rw_exit_read(&sc->sc_audio.rwlock);
+ }
+ }
+
+ sc->sc_as_running = 0;
+
+ 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 */
+ getmicrotime(&sc->sc_mmap[i].v4l2_buf.timestamp);
+
+ /* 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)
+{
+ sc->sc_flags &= ~UTVFU_FLAG_AUDIO_CLI;
+
+ 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_DEVBUF, 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_DEVBUF, fb->size);
+ fb->buf = NULL;
+ }
+
+ if (sc->sc_mmap_buffer != NULL) {
+ free(sc->sc_mmap_buffer, M_DEVBUF, 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)
+{
+ 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_DEVBUF, 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;
+
+ 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(sc, 0, "vid_mmap", 10 * hz);
+ 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 (UTVFU_AUDIO_HAS_CLIENT(sc))
+ return (EBUSY);
+
+ return utvfu_as_init(sc);
+}
+
+void
+utvfu_audio_close(void *v)
+{
+ struct utvfu_softc *sc = v;
+
+ /* Leave the audio thread running if video is streaming */
+ if (!UTVFU_VIDEO_HAS_CLIENT(sc))
+ utvfu_as_free(sc);
+
+ utvfu_audio_clear_client(sc);
+}
+
+int
+utvfu_audio_query_encoding(void *v, struct audio_encoding *p)
+{
+ struct utvfu_softc *sc = v;
+
+ if (usbd_is_dying(sc->sc_udev))
+ return (EIO);
+
+ DPRINTF(1, "%s %s\n", DEVNAME(sc), __func__);
+
+ if (p->index != 0)
+ return (EINVAL);
+
+ strlcpy(p->name, AudioEslinear_le, sizeof(p->name));
+ p->encoding = AUDIO_ENCODING_SLINEAR_LE;
+ p->precision = 16;
+ p->bps = 2;
+ p->msb = 1;
+ p->flags = 0;
+
+ return (0);
+}
+
+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__);
+
+ if (!UTVFU_VIDEO_HAS_CLIENT(sc))
+ utvfu_audio_stop(sc);
+
+ utvfu_audio_clear_client(sc);
+
+ return (0);
+}
+
+int
+utvfu_audio_getdev(void *v, struct audio_device *retp)
+{
+ struct utvfu_softc *sc = v;
+
+ if (usbd_is_dying(sc->sc_udev))
+ return (EIO);
+
+ *retp = utvfu_audio_device;
+ 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_get_props(void *v)
+{
+ return (0);
+}
+
+void
+utvfu_audio_get_default_params(void *v, int mode, struct audio_params *p)
+{
+ if (mode != AUMODE_RECORD)
+ return;
+
+ DPRINTF(1, "%s %s\n", DEVNAME((struct utvfu_softc *)v), __func__);
+
+ p->sample_rate = 48000;
+ p->encoding = AUDIO_ENCODING_SLINEAR_LE;
+ p->precision = 16;
+ p->bps = 2;
+ p->msb = 1;
+ p->channels = 2;
+}
+
+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);
+
+ sc->sc_flags |= UTVFU_FLAG_AUDIO_CLI;
+
+ 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)
+{
+ if (sc->sc_as_running == 1)
+ return (0);
+
+ utvfu_audio_start_chip(sc);
+
+ 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)
+{
+ if (sc->sc_as_running == 1) {
+ utvfu_audio_stop_chip(sc);
+ utvfu_as_close(sc);
+ }
+ return (0);
+}
