The branch main has been updated by adrian: URL: https://cgit.FreeBSD.org/src/commit/?id=8cdcf4b27c7b9e0266d3d37c83566016d71582b4
commit 8cdcf4b27c7b9e0266d3d37c83566016d71582b4 Author: Abdelkader Boudih <[email protected]> AuthorDate: 2026-08-09 16:53:58 +0000 Commit: Adrian Chadd <[email protected]> CommitDate: 2026-08-09 16:54:00 +0000 uvideo: convert to video(4) framework Replaced the monolithic cdevsw implementation with the video(4) framework. Reviewed by: adrian Differential Revision: https://reviews.freebsd.org/D58368 --- share/man/man4/uvideo.4 | 5 +- sys/dev/usb/video/uvideo.c | 1698 ++++++++++----------------------------- sys/modules/usb/uvideo/Makefile | 3 +- 3 files changed, 419 insertions(+), 1287 deletions(-) diff --git a/share/man/man4/uvideo.4 b/share/man/man4/uvideo.4 index c7de2d7a0859..254b0429ce0f 100644 --- a/share/man/man4/uvideo.4 +++ b/share/man/man4/uvideo.4 @@ -3,14 +3,15 @@ .\" .\" SPDX-License-Identifier: BSD-2-Clause .\" -.Dd June 17, 2026 +.Dd July 27, 2026 .Dt UVIDEO 4 .Os .Sh NAME .Nm uvideo .Nd USB video class webcam and capture driver .Sh SYNOPSIS -.Cd device uvideo +.Cd "device video" +.Cd "device uvideo" .Sh HARDWARE The .Nm diff --git a/sys/dev/usb/video/uvideo.c b/sys/dev/usb/video/uvideo.c index 6bed4b4acee3..1e19ab42d869 100644 --- a/sys/dev/usb/video/uvideo.c +++ b/sys/dev/usb/video/uvideo.c @@ -23,7 +23,6 @@ * USB Video Class (UVC) driver. * * Implements standard UVC 1.0/1.1/1.5 devices only. - * Creates /dev/videoN character devices with V4L2 ioctl interface. */ #include <sys/param.h> @@ -36,25 +35,12 @@ #include <sys/malloc.h> #include <sys/module.h> #include <sys/mutex.h> -#include <sys/poll.h> #include <sys/proc.h> -#include <sys/event.h> -#include <sys/selinfo.h> #include <sys/limits.h> #include <sys/sysctl.h> #include <sys/uio.h> #include <sys/rwlock.h> -#include <vm/vm.h> -#include <vm/vm_extern.h> -#include <vm/vm_kern.h> -#include <vm/vm_object.h> -#include <vm/vm_page.h> -#include <vm/vm_pager.h> -#include <vm/vm_param.h> -#include <vm/pmap.h> -#include <vm/vm_map.h> - #include <dev/usb/usb.h> #include <dev/usb/usbdi.h> #include <dev/usb/usbdi_util.h> @@ -62,6 +48,9 @@ #include "usbdevs.h" #include <dev/usb/video/uvideo.h> +#include <dev/video/video.h> + +#include "video_if.h" #define USB_DEBUG_VAR uvideo_debug #include <dev/usb/usb_debug.h> @@ -83,11 +72,6 @@ SYSCTL_INT(_hw_usb_uvideo, OID_AUTO, debug, CTLFLAG_RWTUN, #define UE_GET_SIZE(x) ((x) & 0x7FF) #define UE_GET_TRANS(x) (((x) >> 11) & 0x03) -/* IO_NDELAY from sys/vnode.h - avoid pulling in vnode_if.h dependency */ -#ifndef IO_NDELAY -#define IO_NDELAY 0x0004 -#endif - /* Forward declarations */ struct uvideo_softc; @@ -154,50 +138,32 @@ static usb_error_t uvideo_vs_alloc_frame(struct uvideo_softc *); static void uvideo_vs_free_frame(struct uvideo_softc *); static usb_error_t uvideo_vs_open(struct uvideo_softc *); static void uvideo_vs_close(struct uvideo_softc *); -static usb_error_t uvideo_vs_init(struct uvideo_softc *); static void uvideo_vs_decode_stream_header(struct uvideo_softc *, uint8_t *, int); static void uvideo_vs_decode_stream_header_isight( struct uvideo_softc *, uint8_t *, int); static void uvideo_isoc_decode(struct uvideo_softc *, struct usb_page_cache *, int, int); -static uint8_t *uvideo_mmap_getbuf(struct uvideo_softc *); -static void uvideo_mmap_queue(struct uvideo_softc *, int, int); -static void uvideo_read_frame(struct uvideo_softc *, uint8_t *, int); - -static d_open_t uvideo_cdev_open; -static d_close_t uvideo_cdev_close; -static d_read_t uvideo_cdev_read; -static d_ioctl_t uvideo_cdev_ioctl; -static d_poll_t uvideo_cdev_poll; -static d_kqfilter_t uvideo_cdev_kqfilter; -static d_mmap_single_t uvideo_cdev_mmap_single; - -static int uvideo_querycap(struct uvideo_softc *, struct v4l2_capability *); -static int uvideo_enum_fmt(struct uvideo_softc *, struct v4l2_fmtdesc *); -static int uvideo_enum_fsizes(struct uvideo_softc *, - struct v4l2_frmsizeenum *); -static int uvideo_enum_fivals(struct uvideo_softc *, - struct v4l2_frmivalenum *); -static int uvideo_s_fmt(struct uvideo_softc *, struct v4l2_format *); -static int uvideo_g_fmt(struct uvideo_softc *, struct v4l2_format *); -static int uvideo_s_parm(struct uvideo_softc *, struct v4l2_streamparm *); -static int uvideo_g_parm(struct uvideo_softc *, struct v4l2_streamparm *); -static int uvideo_enum_input(struct uvideo_softc *, struct v4l2_input *); -static int uvideo_s_input(struct uvideo_softc *, int); -static int uvideo_g_input(struct uvideo_softc *, int *); -static int uvideo_reqbufs(struct uvideo_softc *, - struct v4l2_requestbuffers *); -static int uvideo_querybuf(struct uvideo_softc *, struct v4l2_buffer *); -static int uvideo_qbuf(struct uvideo_softc *, struct v4l2_buffer *); -static int uvideo_dqbuf(struct uvideo_softc *, struct v4l2_buffer *); -static int uvideo_streamon(struct uvideo_softc *, int); -static int uvideo_streamoff(struct uvideo_softc *, int); -static int uvideo_try_fmt(struct uvideo_softc *, struct v4l2_format *); -static int uvideo_queryctrl(struct uvideo_softc *, - struct v4l2_queryctrl *); -static int uvideo_g_ctrl(struct uvideo_softc *, struct v4l2_control *); -static int uvideo_s_ctrl(struct uvideo_softc *, struct v4l2_control *); +static void uvideo_frame_done(struct uvideo_softc *); + +static int uvideo_hw_querycap(device_t, struct video_caps *); +static int uvideo_hw_enum_format(device_t, uint32_t, struct video_format *); +static int uvideo_hw_get_format(device_t, struct video_format *); +static int uvideo_hw_try_format(device_t, struct video_format *); +static int uvideo_hw_set_format(device_t, const struct video_format *); +static int uvideo_hw_enum_framesizes(device_t, struct video_frmsizeenum *); +static int uvideo_hw_enum_frameintervals(device_t, + struct video_frmivalenum *); +static int uvideo_hw_get_parm(device_t, struct video_fract *); +static int uvideo_hw_set_parm(device_t, struct video_fract *); +static int uvideo_hw_enum_input(device_t, uint32_t, struct video_input *); +static int uvideo_hw_get_input(device_t, uint32_t *); +static int uvideo_hw_set_input(device_t, uint32_t); +static int uvideo_hw_query_control(device_t, struct video_control_desc *); +static int uvideo_hw_get_control(device_t, struct video_control *); +static int uvideo_hw_set_control(device_t, const struct video_control *); +static int uvideo_hw_start_stream(device_t); +static void uvideo_hw_stop_stream(device_t); /* * Transfer configuration indices. @@ -219,15 +185,13 @@ struct uvideo_softc { device_t sc_dev; struct usb_device *sc_udev; struct mtx sc_mtx; - struct cdev *sc_cdev; - int sc_unit; + + struct video_device *sc_vd; + uint32_t sc_sequence; uint8_t sc_iface_index; uint8_t sc_nifaces; int sc_dying; - int sc_open; - uint32_t sc_priority; - struct proc *sc_owner; struct usb_xfer *sc_xfer[UVIDEO_N_XFER]; int sc_streaming; @@ -239,17 +203,6 @@ struct uvideo_softc { struct uvideo_frame_buffer sc_frame_buffer; - struct uvideo_mmap sc_mmap[UVIDEO_MAX_BUFFERS]; - struct uvideo_mmap *sc_mmap_cur; - uint8_t *sc_mmap_buffer; - size_t sc_mmap_buffer_size; - vm_offset_t sc_mmap_kva; - int sc_mmap_buffer_idx; - q_mmap sc_mmap_q; - size_t sc_mmap_count; - int sc_mmap_flag; - vm_object_t sc_mmap_object; - uint8_t *sc_tmpbuf; int sc_tmpbuf_size; @@ -278,17 +231,6 @@ struct uvideo_softc { struct uvideo_vs_iface *sc_vs_cur; struct uvideo_vs_iface sc_vs_coll[UVIDEO_MAX_VS_NUM]; - int sc_fsize; - uint8_t *sc_fbuffer; - size_t sc_fbufferlen; - int sc_vidmode; -#define VIDMODE_NONE 0 -#define VIDMODE_MMAP 1 -#define VIDMODE_READ 2 - int sc_frames_ready; - - struct selinfo sc_selinfo; - const struct uvideo_quirk *sc_quirk; void (*sc_decode_stream_header)( @@ -655,6 +597,26 @@ static device_method_t uvideo_methods[] = { DEVMETHOD(device_probe, uvideo_probe), DEVMETHOD(device_attach, uvideo_attach), DEVMETHOD(device_detach, uvideo_detach), + + /* video(4) interface */ + DEVMETHOD(video_querycap, uvideo_hw_querycap), + DEVMETHOD(video_enum_format, uvideo_hw_enum_format), + DEVMETHOD(video_get_format, uvideo_hw_get_format), + DEVMETHOD(video_try_format, uvideo_hw_try_format), + DEVMETHOD(video_set_format, uvideo_hw_set_format), + DEVMETHOD(video_enum_framesizes, uvideo_hw_enum_framesizes), + DEVMETHOD(video_enum_frameintervals, uvideo_hw_enum_frameintervals), + DEVMETHOD(video_get_parm, uvideo_hw_get_parm), + DEVMETHOD(video_set_parm, uvideo_hw_set_parm), + DEVMETHOD(video_enum_input, uvideo_hw_enum_input), + DEVMETHOD(video_get_input, uvideo_hw_get_input), + DEVMETHOD(video_set_input, uvideo_hw_set_input), + DEVMETHOD(video_query_control, uvideo_hw_query_control), + DEVMETHOD(video_get_control, uvideo_hw_get_control), + DEVMETHOD(video_set_control, uvideo_hw_set_control), + DEVMETHOD(video_start_stream, uvideo_hw_start_stream), + DEVMETHOD(video_stop_stream, uvideo_hw_stop_stream), + DEVMETHOD_END }; @@ -666,6 +628,7 @@ static driver_t uvideo_driver = { DRIVER_MODULE(uvideo, uhub, uvideo_driver, NULL, NULL); MODULE_DEPEND(uvideo, usb, 1, 1, 1); +MODULE_DEPEND(uvideo, video, 1, 1, 1); MODULE_VERSION(uvideo, 1); USB_PNP_HOST_INFO(uvideo_devs); @@ -731,26 +694,6 @@ static const struct usb_config uvideo_bulk_config[1] = { }, }; -/* - * Character device switch - */ -static struct cdevsw uvideo_cdevsw = { - .d_version = D_VERSION, - .d_open = uvideo_cdev_open, - .d_close = uvideo_cdev_close, - .d_read = uvideo_cdev_read, - .d_ioctl = uvideo_cdev_ioctl, - .d_poll = uvideo_cdev_poll, - .d_kqfilter = uvideo_cdev_kqfilter, - .d_mmap_single = uvideo_cdev_mmap_single, - .d_name = "video", -}; - -/* - * Unit number allocator - */ -/* Unit number allocation is handled by scanning for free /dev/videoN names */ - /* ---------------------------------------------------------------- */ /* Probe / Attach / Detach */ /* ---------------------------------------------------------------- */ @@ -792,7 +735,6 @@ uvideo_attach(device_t dev) struct usb_config_descriptor *cdesc; struct usb_descriptor *desc; struct usb_interface_assoc_descriptor *iad; - struct make_dev_args args; usb_error_t error; int first_iface, nifaces; int i; @@ -803,7 +745,6 @@ uvideo_attach(device_t dev) device_set_usb_desc(dev); mtx_init(&sc->sc_mtx, "uvideo", NULL, MTX_DEF); - knlist_init_mtx(&sc->sc_selinfo.si_note, &sc->sc_mtx); /* Look up quirks for this device */ sc->sc_quirk = uvideo_lookup_quirk(uaa); @@ -917,35 +858,12 @@ uvideo_attach(device_t dev) } } - /* Init mmap queue */ - STAILQ_INIT(&sc->sc_mmap_q); - sc->sc_mmap_count = 0; - sc->sc_mmap_kva = 0; - sc->sc_mmap_object = NULL; - - /* Allocate unit number and create character device */ - make_dev_args_init(&args); - args.mda_devsw = &uvideo_cdevsw; - args.mda_uid = UID_ROOT; - args.mda_gid = GID_VIDEO; - args.mda_mode = 0660; - args.mda_si_drv1 = sc; - args.mda_flags = MAKEDEV_CHECKNAME; - - sc->sc_unit = -1; - for (i = 0; i < 256; i++) { - if (make_dev_s(&args, &sc->sc_cdev, "video%d", i) == 0) { - sc->sc_unit = i; - break; - } - } - if (sc->sc_unit < 0) { - device_printf(dev, "failed to create /dev/video device\n"); + i = video_register(dev, &sc->sc_vd); + if (i != 0) { + device_printf(dev, "failed to register video device\n"); goto detach; } - device_printf(dev, "UVC camera on /dev/video%d\n", sc->sc_unit); - return (0); detach: @@ -960,29 +878,22 @@ uvideo_detach(device_t dev) sc->sc_dying = 1; - /* Destroy character device */ - if (sc->sc_cdev != NULL) { - destroy_dev(sc->sc_cdev); - sc->sc_cdev = NULL; - } + if (sc->sc_vd != NULL) + video_unregister(sc->sc_vd); - /* Stop streaming if still active (e.g. detached while idle). */ - mtx_lock(&sc->sc_mtx); if (sc->sc_streaming) { + mtx_lock(&sc->sc_mtx); sc->sc_streaming = 0; mtx_unlock(&sc->sc_mtx); uvideo_vs_close(sc); - } else - mtx_unlock(&sc->sc_mtx); + } + - /* Free frame buffers */ uvideo_vs_free_frame(sc); /* Unsetup USB transfers */ usbd_transfer_unsetup(sc->sc_xfer, UVIDEO_N_XFER); - seldrain(&sc->sc_selinfo); - knlist_destroy(&sc->sc_selinfo.si_note); mtx_destroy(&sc->sc_mtx); return (0); @@ -1813,7 +1724,8 @@ uvideo_vs_parse_desc_frame_max_rate(struct uvideo_softc *sc, length -= sizeof(uDWord); } - fbuf_size = UGETDW(UVIDEO_FRAME_FIELD(fd, dwMaxBitRate)) * frame_ival; + fbuf_size = (uint64_t)UGETDW(UVIDEO_FRAME_FIELD(fd, dwMaxBitRate)) * + frame_ival; fbuf_size /= 8 * 10000000; if (fbuf_size > sc->sc_max_fbuf_size) @@ -1826,6 +1738,68 @@ uvideo_vs_parse_desc_frame_max_rate(struct uvideo_softc *sc, return (USB_ERR_NORMAL_COMPLETION); } +/* + * Smallest alt satisfying dwMaxPayloadTransferSize. A larger one loses the + * payload framing. XXX high speed only: bMaxBurst from the SuperSpeed + * endpoint companion descriptor is not accounted for. + */ +static void +uvideo_vs_select_alt(struct uvideo_softc *sc, uint32_t payload) +{ + struct uvideo_vs_iface *vs = sc->sc_vs_cur; + struct usb_config_descriptor *cdesc; + struct usb_descriptor *desc; + struct usb_interface_descriptor *id; + struct usb_endpoint_descriptor *ed; + uint32_t psize, best_psize; + int best_alt; + + if (vs->bulk_endpoint || payload == 0) + return; + + cdesc = usbd_get_config_descriptor(sc->sc_udev); + if (cdesc == NULL) + return; + + best_alt = -1; + best_psize = 0; + + desc = NULL; + id = NULL; + while ((desc = usb_desc_foreach(cdesc, desc)) != NULL) { + if (desc->bDescriptorType == UDESC_INTERFACE) { + id = (struct usb_interface_descriptor *)desc; + continue; + } + if (desc->bDescriptorType != UDESC_ENDPOINT || id == NULL) + continue; + if (id->bInterfaceNumber != vs->iface_index) + continue; + + ed = (struct usb_endpoint_descriptor *)desc; + if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_IN || + UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS) + continue; + + psize = UGETW(ed->wMaxPacketSize); + psize = UE_GET_SIZE(psize) * (1 + UE_GET_TRANS(psize)); + if (psize < payload) + continue; + if (best_alt < 0 || psize < best_psize) { + best_alt = id->bAlternateSetting; + best_psize = psize; + } + } + + if (best_alt >= 0) { + DPRINTFN(1, "alt %d psize %u for payload %u (was alt %d " + "psize %u)\n", best_alt, best_psize, payload, vs->curalt, + vs->psize); + vs->curalt = best_alt; + vs->psize = best_psize; + } +} + static usb_error_t uvideo_vs_parse_desc_alt(struct uvideo_softc *sc, int vs_nr, int iface, int numalts) @@ -2262,6 +2236,7 @@ uvideo_vs_alloc_frame(struct uvideo_softc *sc) return (USB_ERR_NOMEM); } + fb->buf = malloc(fb->buf_size, M_USBDEV, M_WAITOK | M_ZERO); if (fb->buf == NULL) { device_printf(sc->sc_dev, @@ -2291,20 +2266,6 @@ uvideo_vs_free_frame(struct uvideo_softc *sc) free(fb->buf, M_USBDEV); fb->buf = NULL; } - - if (sc->sc_mmap_kva != 0) { - vm_map_remove(kernel_map, sc->sc_mmap_kva, - sc->sc_mmap_kva + sc->sc_mmap_buffer_size); - sc->sc_mmap_buffer = NULL; - sc->sc_mmap_kva = 0; - sc->sc_mmap_buffer_size = 0; - } - sc->sc_mmap_object = NULL; - - while (!STAILQ_EMPTY(&sc->sc_mmap_q)) - STAILQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames); - - sc->sc_mmap_count = 0; } static usb_error_t @@ -2322,6 +2283,9 @@ uvideo_vs_open(struct uvideo_softc *sc) return (error); } + uvideo_vs_select_alt(sc, + UGETDW(sc->sc_desc_probe.dwMaxPayloadTransferSize)); + /* For bulk endpoints, alt 0 is always used */ if (!sc->sc_vs_cur->bulk_endpoint) { /* @@ -2405,22 +2369,6 @@ uvideo_vs_close(struct uvideo_softc *sc) } } -static usb_error_t -uvideo_vs_init(struct uvideo_softc *sc) -{ - usb_error_t error; - - error = uvideo_vs_open(sc); - if (error != USB_ERR_NORMAL_COMPLETION) - return (USB_ERR_INVAL); - - error = uvideo_vs_alloc_frame(sc); - if (error != USB_ERR_NORMAL_COMPLETION) - return (USB_ERR_INVAL); - - return (USB_ERR_NORMAL_COMPLETION); -} - /* ---------------------------------------------------------------- */ /* Transfer Callbacks */ /* ---------------------------------------------------------------- */ @@ -2437,7 +2385,6 @@ uvideo_isoc_decode(struct uvideo_softc *sc, struct usb_page_cache *pc, struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; uint8_t shdr[2]; uint8_t flags; - uint8_t *buf; int hdrlen, payload_len; if (len < UVIDEO_SH_MIN_LEN) @@ -2471,16 +2418,6 @@ uvideo_isoc_decode(struct uvideo_softc *sc, struct usb_page_cache *pc, fb->error = 1; } - /* Get destination buffer */ - if (sc->sc_mmap_flag) { - if (!fb->mmap_q_full) { - buf = uvideo_mmap_getbuf(sc); - if (buf == NULL) - fb->mmap_q_full = 1; - } - } else - buf = fb->buf; - /* Copy payload directly from USB DMA into frame buffer */ payload_len = len - hdrlen; if (payload_len > fb->buf_size - fb->offset) { @@ -2488,9 +2425,9 @@ uvideo_isoc_decode(struct uvideo_softc *sc, struct usb_page_cache *pc, payload_len = fb->buf_size - fb->offset; fb->error = 1; } - if (!fb->mmap_q_full && payload_len > 0) { + if (payload_len > 0) { usbd_copy_out(pc, offset + hdrlen, - buf + fb->offset, payload_len); + fb->buf + fb->offset, payload_len); fb->offset += payload_len; } @@ -2503,13 +2440,14 @@ uvideo_isoc_decode(struct uvideo_softc *sc, struct usb_page_cache *pc, fb->error = 1; } - if (sc->sc_mmap_flag) { - if (!fb->mmap_q_full) - uvideo_mmap_queue(sc, fb->offset, fb->error); - } else if (fb->error) { - DPRINTFN(1, "error frame, skipped\n"); + if (!fb->error) { + uvideo_frame_done(sc); } else { - uvideo_read_frame(sc, fb->buf, fb->offset); + struct video_buf *vb; + + vb = video_buf_acquire(sc->sc_vd); + if (vb != NULL) + video_buf_error(vb); } fb->sample = 0; @@ -2524,12 +2462,15 @@ uvideo_isoc_callback(struct usb_xfer *xfer, usb_error_t error) { struct uvideo_softc *sc = usbd_xfer_softc(xfer); struct usb_page_cache *pc; + usb_frcount_t maxframes; int nframes, i, offset, len; + maxframes = usbd_xfer_max_frames(xfer); + switch (USB_GET_STATE(xfer)) { case USB_ST_TRANSFERRED: + usbd_xfer_status(xfer, NULL, NULL, NULL, &nframes); pc = usbd_xfer_get_frame(xfer, 0); - nframes = usbd_xfer_max_frames(xfer); offset = 0; for (i = 0; i < nframes; i++) { len = usbd_xfer_frame_len(xfer, i); @@ -2540,7 +2481,11 @@ uvideo_isoc_callback(struct usb_xfer *xfer, usb_error_t error) /* FALLTHROUGH */ case USB_ST_SETUP: tr_setup: - nframes = usbd_xfer_max_frames(xfer); + nframes = sc->sc_nframes; + if (nframes > (int)maxframes) + nframes = maxframes; + if (nframes < 1) + nframes = 1; usbd_xfer_set_frames(xfer, nframes); for (i = 0; i < nframes; i++) usbd_xfer_set_frame_len(xfer, i, @@ -2600,7 +2545,6 @@ uvideo_vs_decode_stream_header(struct uvideo_softc *sc, uint8_t *frame, struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; struct usb_video_stream_header *sh; int sample_len; - uint8_t *buf; if (frame_size < UVIDEO_SH_MIN_LEN) return; @@ -2634,15 +2578,6 @@ uvideo_vs_decode_stream_header(struct uvideo_softc *sc, uint8_t *frame, fb->error = 1; } - if (sc->sc_mmap_flag) { - if (!fb->mmap_q_full) { - buf = uvideo_mmap_getbuf(sc); - if (buf == NULL) - fb->mmap_q_full = 1; - } - } else - buf = sc->sc_frame_buffer.buf; - /* Save sample data */ sample_len = frame_size - sh->bLength; if (sample_len > fb->buf_size - fb->offset) { @@ -2650,8 +2585,8 @@ uvideo_vs_decode_stream_header(struct uvideo_softc *sc, uint8_t *frame, sample_len = fb->buf_size - fb->offset; fb->error = 1; } - if (!fb->mmap_q_full && sample_len > 0) { - bcopy(frame + sh->bLength, buf + fb->offset, sample_len); + if (sample_len > 0) { + bcopy(frame + sh->bLength, fb->buf + fb->offset, sample_len); fb->offset += sample_len; } @@ -2665,13 +2600,14 @@ uvideo_vs_decode_stream_header(struct uvideo_softc *sc, uint8_t *frame, fb->error = 1; } - if (sc->sc_mmap_flag) { - if (!fb->mmap_q_full) - uvideo_mmap_queue(sc, fb->offset, fb->error); - } else if (fb->error) { - DPRINTFN(1, "error frame, skipped\n"); + if (!fb->error) { + uvideo_frame_done(sc); } else { - uvideo_read_frame(sc, fb->buf, fb->offset); + struct video_buf *vb; + + vb = video_buf_acquire(sc->sc_vd); + if (vb != NULL) + video_buf_error(vb); } fb->sample = 0; @@ -2681,25 +2617,12 @@ uvideo_vs_decode_stream_header(struct uvideo_softc *sc, uint8_t *frame, } } -/* - * The iSight first generation device uses a non-standard streaming - * protocol. The stream header is sent once per image and looks like: - * - * uByte header length - * uByte flags - * uByte magic1[4] always "11223344" - * uByte magic2[8] always "deadbeefdeadface" - * uByte unknown[16] - * - * Sometimes the stream header is prefixed by an unknown byte. - */ static void uvideo_vs_decode_stream_header_isight(struct uvideo_softc *sc, uint8_t *frame, int frame_size) { struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; int sample_len, header = 0; - uint8_t *buf; uint8_t magic[] = { 0x11, 0x22, 0x33, 0x44, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xfa, 0xce }; @@ -2714,640 +2637,220 @@ uvideo_vs_decode_stream_header_isight(struct uvideo_softc *sc, } if (header) { - if (sc->sc_mmap_flag) { - if (!fb->mmap_q_full) - uvideo_mmap_queue(sc, fb->offset, 0); - } else { - uvideo_read_frame(sc, fb->buf, fb->offset); - } + if (fb->offset > 0) + uvideo_frame_done(sc); fb->offset = 0; - fb->mmap_q_full = 0; } else { - if (sc->sc_mmap_flag) { - if (!fb->mmap_q_full) { - buf = uvideo_mmap_getbuf(sc); - if (buf == NULL) - fb->mmap_q_full = 1; - } - } else - buf = sc->sc_frame_buffer.buf; - - /* Save sample */ sample_len = frame_size; - if (!fb->mmap_q_full && - (fb->offset + sample_len) < fb->buf_size) { - bcopy(frame, buf + fb->offset, sample_len); + if ((fb->offset + sample_len) < fb->buf_size) { + bcopy(frame, fb->buf + fb->offset, sample_len); fb->offset += sample_len; } } } -static uint8_t * -uvideo_mmap_getbuf(struct uvideo_softc *sc) +static void +uvideo_frame_done(struct uvideo_softc *sc) { - int i, idx; - - /* - * Multiple frames per transfer / multiple transfers per frame. - */ - if (sc->sc_mmap_cur != NULL) - return (sc->sc_mmap_cur->buf); - - if (sc->sc_mmap_count == 0 || sc->sc_mmap_buffer == NULL) - return (NULL); - - idx = sc->sc_mmap_buffer_idx; + struct video_buf *vb; - /* Find a buffer which is queued and ready */ - for (i = 0; i < sc->sc_mmap_count; i++) { - if (sc->sc_mmap[sc->sc_mmap_buffer_idx].v4l2_buf.flags & - V4L2_BUF_FLAG_QUEUED) { - idx = sc->sc_mmap_buffer_idx; - if (++sc->sc_mmap_buffer_idx == sc->sc_mmap_count) - sc->sc_mmap_buffer_idx = 0; - break; - } - if (++sc->sc_mmap_buffer_idx == sc->sc_mmap_count) - sc->sc_mmap_buffer_idx = 0; - } + vb = video_buf_acquire(sc->sc_vd); + if (vb == NULL) + return; - if (i == sc->sc_mmap_count) { - DPRINTFN(1, "mmap queue is full!\n"); - return (NULL); + if (video_buf_write(vb, 0, sc->sc_frame_buffer.buf, + sc->sc_frame_buffer.offset) != 0) { + video_buf_error(vb); + return; } - - sc->sc_mmap_cur = &sc->sc_mmap[idx]; - return (sc->sc_mmap_cur->buf); + video_buf_done(vb, sc->sc_frame_buffer.offset, sc->sc_sequence++); } -static void -uvideo_mmap_queue(struct uvideo_softc *sc, int len, int err) +static int +uvideo_hw_querycap(device_t dev, struct video_caps *caps) { + struct uvideo_softc *sc = device_get_softc(dev); - if (sc->sc_mmap_cur == NULL) - return; - - sc->sc_mmap_cur->v4l2_buf.bytesused = len; - - getmicrouptime(&sc->sc_mmap_cur->v4l2_buf.timestamp); - sc->sc_mmap_cur->v4l2_buf.flags &= ~V4L2_BUF_FLAG_TIMESTAMP_MASK; - sc->sc_mmap_cur->v4l2_buf.flags |= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; - sc->sc_mmap_cur->v4l2_buf.flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK; - sc->sc_mmap_cur->v4l2_buf.flags |= V4L2_BUF_FLAG_TSTAMP_SRC_EOF; - sc->sc_mmap_cur->v4l2_buf.flags &= ~V4L2_BUF_FLAG_TIMECODE; - - sc->sc_mmap_cur->v4l2_buf.flags &= ~V4L2_BUF_FLAG_ERROR; - if (err) - sc->sc_mmap_cur->v4l2_buf.flags |= V4L2_BUF_FLAG_ERROR; - - sc->sc_mmap_cur->v4l2_buf.flags |= V4L2_BUF_FLAG_DONE; - sc->sc_mmap_cur->v4l2_buf.flags &= ~V4L2_BUF_FLAG_QUEUED; - STAILQ_INSERT_TAIL(&sc->sc_mmap_q, sc->sc_mmap_cur, q_frames); - sc->sc_mmap_cur = NULL; - - DPRINTFN(2, "frame queued\n"); + bzero(caps, sizeof(*caps)); + strlcpy(caps->driver, "uvideo", sizeof(caps->driver)); + strlcpy(caps->card, usb_get_product(sc->sc_udev), + sizeof(caps->card)); + snprintf(caps->bus_info, sizeof(caps->bus_info), "usb-%s", + device_get_nameunit(sc->sc_dev)); + caps->version = (5 << 16) | (0 << 8) | 0; /* 5.0.0 */ + caps->capabilities = VIDEO_CAP_CAPTURE | + VIDEO_CAP_READWRITE | VIDEO_CAP_STREAMING; - wakeup(sc); - selwakeup(&sc->sc_selinfo); - KNOTE_LOCKED(&sc->sc_selinfo.si_note, 0); + return (0); } -static void -uvideo_read_frame(struct uvideo_softc *sc, uint8_t *buf, int len) +static int +uvideo_hw_enum_format(device_t dev, uint32_t index, struct video_format *fmt) { + struct uvideo_softc *sc = device_get_softc(dev); + struct uvideo_format_group *fmtgrp; + struct usb_video_frame_desc *frame; - /* - * In read mode, copy the frame into the upper-layer buffer - * so the USB callback can start assembling the next frame - * without racing with the cdev read. - */ - if (sc->sc_fbuffer == NULL || len > sc->sc_fbufferlen) - return; - - bcopy(buf, sc->sc_fbuffer, len); - sc->sc_fsize = len; - sc->sc_frames_ready++; - - wakeup(sc); - selwakeup(&sc->sc_selinfo); - KNOTE_LOCKED(&sc->sc_selinfo.si_note, 0); -} + if (index >= (uint32_t)sc->sc_fmtgrp_num) + return (EINVAL); -/* ---------------------------------------------------------------- */ -/* Character Device Operations */ -/* ---------------------------------------------------------------- */ + fmtgrp = &sc->sc_fmtgrp[index]; + frame = fmtgrp->frame_cur; -/* - * Per-fd state (via devfs cdevpriv). Tracks whether this fd started - * streaming so that STREAMOFF or close from a non-streaming fd (e.g. a - * second tab that failed REQBUFS) does not tear down the active stream - * owned by another fd. - */ -struct uvideo_cdevpriv { - int streaming; -}; + bzero(fmt, sizeof(*fmt)); + fmt->pixelformat = fmtgrp->pixelformat; + if (frame != NULL) { + fmt->width = UGETW(UVIDEO_FRAME_FIELD(frame, wWidth)); + fmt->height = UGETW(UVIDEO_FRAME_FIELD(frame, wHeight)); + } + fmt->sizeimage = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize); + fmt->field = V4L2_FIELD_NONE; -static void uvideo_cdevpriv_dtor(void *); + if (fmtgrp->has_colorformat) { + fmt->colorspace = fmtgrp->colorspace; + fmt->xfer_func = fmtgrp->xfer_func; + fmt->ycbcr_enc = fmtgrp->ycbcr_enc; + } -static void -uvideo_cdevpriv_dtor(void *data) -{ + switch (fmtgrp->format->bDescriptorSubtype) { + case UDESCSUB_VS_FORMAT_MJPEG: + fmt->flags = V4L2_FMT_FLAG_COMPRESSED; + strlcpy(fmt->description, "Motion-JPEG", + sizeof(fmt->description)); + break; + case UDESCSUB_VS_FORMAT_H264: + case UDESCSUB_VS_FORMAT_H264_SIMULCAST: + fmt->flags = V4L2_FMT_FLAG_COMPRESSED; + strlcpy(fmt->description, "H.264", + sizeof(fmt->description)); + break; + case UDESCSUB_VS_FORMAT_FRAME_BASED: + if (fmtgrp->format->u.fb.bVariableSize) + fmt->flags = V4L2_FMT_FLAG_COMPRESSED; + break; + default: + strlcpy(fmt->description, "YUV", + sizeof(fmt->description)); + break; + } - free(data, M_USBDEV); + return (0); } static int -uvideo_cdev_open(struct cdev *dev, int flags, int fmt, struct thread *td) +uvideo_hw_get_format(device_t dev, struct video_format *fmt) { - struct uvideo_softc *sc = dev->si_drv1; - struct uvideo_cdevpriv *priv; - int error; - - if (sc == NULL || sc->sc_dying) - return (ENXIO); + struct uvideo_softc *sc = device_get_softc(dev); + struct usb_video_frame_desc *frame; - if (sc->sc_vs_cur == NULL) + if (sc->sc_fmtgrp_cur == NULL) return (EIO); - priv = malloc(sizeof(*priv), M_USBDEV, M_WAITOK | M_ZERO); - error = devfs_set_cdevpriv(priv, uvideo_cdevpriv_dtor); - if (error != 0) { - free(priv, M_USBDEV); - return (error); + frame = sc->sc_fmtgrp_cur->frame_cur; + + bzero(fmt, sizeof(*fmt)); + fmt->pixelformat = sc->sc_fmtgrp_cur->pixelformat; + fmt->field = V4L2_FIELD_NONE; + if (frame != NULL) { + fmt->width = UGETW(UVIDEO_FRAME_FIELD(frame, wWidth)); + fmt->height = UGETW(UVIDEO_FRAME_FIELD(frame, wHeight)); } + fmt->sizeimage = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize); - mtx_lock(&sc->sc_mtx); - if (sc->sc_open == 0) { - /* First open: initialize state */ - sc->sc_owner = td->td_proc; - sc->sc_mmap_flag = 0; - sc->sc_negotiated_flag = 0; - sc->sc_vidmode = VIDMODE_NONE; - sc->sc_frames_ready = 0; - sc->sc_priority = 1; /* V4L2_PRIORITY_DEFAULT */ + if (sc->sc_fmtgrp_cur->has_colorformat) { + fmt->colorspace = sc->sc_fmtgrp_cur->colorspace; + fmt->xfer_func = sc->sc_fmtgrp_cur->xfer_func; + fmt->ycbcr_enc = sc->sc_fmtgrp_cur->ycbcr_enc; } - sc->sc_open++; - mtx_unlock(&sc->sc_mtx); return (0); } static int -uvideo_cdev_close(struct cdev *dev, int flags, int fmt, struct thread *td) +uvideo_hw_try_format(device_t dev, struct video_format *fmt) { - struct uvideo_softc *sc = dev->si_drv1; - struct uvideo_cdevpriv *priv; - - if (sc == NULL) - return (0); + struct uvideo_softc *sc = device_get_softc(dev); + struct uvideo_res r; + int found, i; - /* - * If this fd started streaming, stop the stream and free the - * buffers so that a new fd (e.g. a refreshed browser tab) can - * re-acquire the camera. Other fds sharing the stream will get - * EPIPE on DQBUF and should re-open. - */ - if (devfs_get_cdevpriv((void **)&priv) == 0 && priv != NULL && - priv->streaming) { *** 1357 LINES SKIPPED ***
