Commit 088ead25 authored by Guennadi Liakhovetski's avatar Guennadi Liakhovetski Committed by Mauro Carvalho Chehab
Browse files

media: uvcvideo: Add a metadata device node 



Some UVC video cameras contain metadata in their payload headers. This
patch extracts that data, adding more clock synchronisation information,
on both bulk and isochronous endpoints and makes it available to the user
space on a separate video node, using the V4L2_CAP_META_CAPTURE capability
and the V4L2_BUF_TYPE_META_CAPTURE buffer queue type. By default, only the
V4L2_META_FMT_UVC pixel format is available from those nodes. However,
cameras can be added to the device ID table to additionally specify their
own metadata format, in which case that format will also become available
from the metadata node.

[Use put_unaligned instead of __put_unaligned_cpu64]
[Use put_unaligned for the sof field as well]

Signed-off-by: default avatarGuennadi Liakhovetski <guennadi.liakhovetski@intel.com>
Signed-off-by: default avatarLaurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@s-opensource.com>
parent 3bc85817

drivers/media/usb/uvc/Makefile

+1 −1
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

uvcvideo-objs  := uvc_driver.o uvc_queue.o uvc_v4l2.o uvc_video.o uvc_ctrl.o \

		  uvc_status.o uvc_isight.o uvc_debugfs.o

		  uvc_status.o uvc_isight.o uvc_debugfs.o uvc_metadata.o

ifeq ($(CONFIG_MEDIA_CONTROLLER),y)

uvcvideo-objs  += uvc_entity.o

endif

drivers/media/usb/uvc/uvc_driver.c

+14 −1
Original line number Diff line number Diff line
@@ -1883,6 +1883,7 @@ static void uvc_unregister_video(struct uvc_device *dev) 
			continue;



		video_unregister_device(&stream->vdev);

		video_unregister_device(&stream->meta.vdev);



		uvc_debugfs_cleanup_stream(stream);

	}
@@ -1930,6 +1931,9 @@ int uvc_register_video_device(struct uvc_device *dev, 
	case V4L2_BUF_TYPE_VIDEO_OUTPUT:

		vdev->device_caps = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;

		break;

	case V4L2_BUF_TYPE_META_CAPTURE:

		vdev->device_caps = V4L2_CAP_META_CAPTURE | V4L2_CAP_STREAMING;

		break;

	}



	strlcpy(vdev->name, dev->name, sizeof vdev->name);
@@ -1965,7 +1969,8 @@ static int uvc_register_video(struct uvc_device *dev, 
	}



	if (stream->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)

		stream->chain->caps |= V4L2_CAP_VIDEO_CAPTURE;

		stream->chain->caps |= V4L2_CAP_VIDEO_CAPTURE

			| V4L2_CAP_META_CAPTURE;

	else

		stream->chain->caps |= V4L2_CAP_VIDEO_OUTPUT;
@@ -2003,6 +2008,11 @@ static int uvc_register_terms(struct uvc_device *dev, 
		if (ret < 0)

			return ret;



		/* Register a metadata node, but ignore a possible failure,

		 * complete registration of video nodes anyway.

		 */

		uvc_meta_register(stream);



		term->vdev = &stream->vdev;

	}
@@ -2037,6 +2047,7 @@ static int uvc_register_chains(struct uvc_device *dev) 


struct uvc_device_info {

	u32	quirks;

	u32	meta_format;

};



static int uvc_probe(struct usb_interface *intf,
@@ -2074,6 +2085,8 @@ static int uvc_probe(struct usb_interface *intf, 
	dev->intfnum = intf->cur_altsetting->desc.bInterfaceNumber;

	dev->quirks = (uvc_quirks_param == -1)

		    ? quirks : uvc_quirks_param;

	if (info)

		dev->meta_format = info->meta_format;



	if (udev->product != NULL)

		strlcpy(dev->name, udev->product, sizeof dev->name);

drivers/media/usb/uvc/uvc_isight.c

+1 −1
Original line number Diff line number Diff line
@@ -100,7 +100,7 @@ static int isight_decode(struct uvc_video_queue *queue, struct uvc_buffer *buf, 
}



void uvc_video_decode_isight(struct urb *urb, struct uvc_streaming *stream,

		struct uvc_buffer *buf)

			struct uvc_buffer *buf, struct uvc_buffer *meta_buf)

{

	int ret, i;

drivers/media/usb/uvc/uvc_metadata.c

0 → 100644
+179 −0
Original line number Diff line number Diff line 
/*

 *      uvc_metadata.c  --  USB Video Class driver - Metadata handling

 *

 *      Copyright (C) 2016

 *          Guennadi Liakhovetski (guennadi.liakhovetski@intel.com)

 *

 *      This program is free software; you can redistribute it and/or modify

 *      it under the terms of the GNU General Public License as published by

 *      the Free Software Foundation; either version 2 of the License, or

 *      (at your option) any later version.

 */



#include <linux/kernel.h>

#include <linux/list.h>

#include <linux/module.h>

#include <linux/usb.h>

#include <linux/videodev2.h>



#include <media/v4l2-ioctl.h>

#include <media/videobuf2-v4l2.h>

#include <media/videobuf2-vmalloc.h>



#include "uvcvideo.h"



/* -----------------------------------------------------------------------------

 * V4L2 ioctls

 */



static int uvc_meta_v4l2_querycap(struct file *file, void *fh,

				  struct v4l2_capability *cap)

{

	struct v4l2_fh *vfh = file->private_data;

	struct uvc_streaming *stream = video_get_drvdata(vfh->vdev);

	struct uvc_video_chain *chain = stream->chain;



	strlcpy(cap->driver, "uvcvideo", sizeof(cap->driver));

	strlcpy(cap->card, vfh->vdev->name, sizeof(cap->card));

	usb_make_path(stream->dev->udev, cap->bus_info, sizeof(cap->bus_info));

	cap->capabilities = V4L2_CAP_DEVICE_CAPS | V4L2_CAP_STREAMING

			  | chain->caps;



	return 0;

}



static int uvc_meta_v4l2_get_format(struct file *file, void *fh,

				    struct v4l2_format *format)

{

	struct v4l2_fh *vfh = file->private_data;

	struct uvc_streaming *stream = video_get_drvdata(vfh->vdev);

	struct v4l2_meta_format *fmt = &format->fmt.meta;



	if (format->type != vfh->vdev->queue->type)

		return -EINVAL;



	memset(fmt, 0, sizeof(*fmt));



	fmt->dataformat = stream->meta.format;

	fmt->buffersize = UVC_METATADA_BUF_SIZE;



	return 0;

}



static int uvc_meta_v4l2_try_format(struct file *file, void *fh,

				    struct v4l2_format *format)

{

	struct v4l2_fh *vfh = file->private_data;

	struct uvc_streaming *stream = video_get_drvdata(vfh->vdev);

	struct uvc_device *dev = stream->dev;

	struct v4l2_meta_format *fmt = &format->fmt.meta;

	u32 fmeta = fmt->dataformat;



	if (format->type != vfh->vdev->queue->type)

		return -EINVAL;



	memset(fmt, 0, sizeof(*fmt));



	fmt->dataformat = fmeta == dev->meta_format ? fmeta : V4L2_META_FMT_UVC;

	fmt->buffersize = UVC_METATADA_BUF_SIZE;



	return 0;

}



static int uvc_meta_v4l2_set_format(struct file *file, void *fh,

				    struct v4l2_format *format)

{

	struct v4l2_fh *vfh = file->private_data;

	struct uvc_streaming *stream = video_get_drvdata(vfh->vdev);

	struct v4l2_meta_format *fmt = &format->fmt.meta;

	int ret;



	ret = uvc_meta_v4l2_try_format(file, fh, format);

	if (ret < 0)

		return ret;



	/*

	 * We could in principle switch at any time, also during streaming.

	 * Metadata buffers would still be perfectly parseable, but it's more

	 * consistent and cleaner to disallow that.

	 */

	mutex_lock(&stream->mutex);



	if (uvc_queue_allocated(&stream->queue))

		ret = -EBUSY;

	else

		stream->meta.format = fmt->dataformat;



	mutex_unlock(&stream->mutex);



	return ret;

}



static int uvc_meta_v4l2_enum_formats(struct file *file, void *fh,

				      struct v4l2_fmtdesc *fdesc)

{

	struct v4l2_fh *vfh = file->private_data;

	struct uvc_streaming *stream = video_get_drvdata(vfh->vdev);

	struct uvc_device *dev = stream->dev;

	u32 index = fdesc->index;



	if (fdesc->type != vfh->vdev->queue->type ||

	    index > 1U || (index && !dev->meta_format))

		return -EINVAL;



	memset(fdesc, 0, sizeof(*fdesc));



	fdesc->type = vfh->vdev->queue->type;

	fdesc->index = index;

	fdesc->pixelformat = index ? dev->meta_format : V4L2_META_FMT_UVC;



	return 0;

}



static const struct v4l2_ioctl_ops uvc_meta_ioctl_ops = {

	.vidioc_querycap		= uvc_meta_v4l2_querycap,

	.vidioc_g_fmt_meta_cap		= uvc_meta_v4l2_get_format,

	.vidioc_s_fmt_meta_cap		= uvc_meta_v4l2_set_format,

	.vidioc_try_fmt_meta_cap	= uvc_meta_v4l2_try_format,

	.vidioc_enum_fmt_meta_cap	= uvc_meta_v4l2_enum_formats,

	.vidioc_reqbufs			= vb2_ioctl_reqbufs,

	.vidioc_querybuf		= vb2_ioctl_querybuf,

	.vidioc_qbuf			= vb2_ioctl_qbuf,

	.vidioc_dqbuf			= vb2_ioctl_dqbuf,

	.vidioc_create_bufs		= vb2_ioctl_create_bufs,

	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,

	.vidioc_streamon		= vb2_ioctl_streamon,

	.vidioc_streamoff		= vb2_ioctl_streamoff,

};



/* -----------------------------------------------------------------------------

 * V4L2 File Operations

 */



static const struct v4l2_file_operations uvc_meta_fops = {

	.owner = THIS_MODULE,

	.unlocked_ioctl = video_ioctl2,

	.open = v4l2_fh_open,

	.release = vb2_fop_release,

	.poll = vb2_fop_poll,

	.mmap = vb2_fop_mmap,

};



int uvc_meta_register(struct uvc_streaming *stream)

{

	struct uvc_device *dev = stream->dev;

	struct video_device *vdev = &stream->meta.vdev;

	struct uvc_video_queue *queue = &stream->meta.queue;



	stream->meta.format = V4L2_META_FMT_UVC;



	/*

	 * The video interface queue uses manual locking and thus does not set

	 * the queue pointer. Set it manually here.

	 */

	vdev->queue = &queue->queue;



	return uvc_register_video_device(dev, stream, vdev, queue,

					 V4L2_BUF_TYPE_META_CAPTURE,

					 &uvc_meta_fops, &uvc_meta_ioctl_ops);

}

drivers/media/usb/uvc/uvc_queue.c

+37 −7
Original line number Diff line number Diff line
@@ -79,8 +79,19 @@ static int uvc_queue_setup(struct vb2_queue *vq, 
			   unsigned int sizes[], struct device *alloc_devs[])

{

	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);

	struct uvc_streaming *stream = uvc_queue_to_stream(queue);

	unsigned size = stream->ctrl.dwMaxVideoFrameSize;

	struct uvc_streaming *stream;

	unsigned int size;



	switch (vq->type) {

	case V4L2_BUF_TYPE_META_CAPTURE:

		size = UVC_METATADA_BUF_SIZE;

		break;



	default:

		stream = uvc_queue_to_stream(queue);

		size = stream->ctrl.dwMaxVideoFrameSize;

		break;

	}



	/*

	 * When called with plane sizes, validate them. The driver supports
@@ -114,7 +125,7 @@ static int uvc_buffer_prepare(struct vb2_buffer *vb) 
	buf->error = 0;

	buf->mem = vb2_plane_vaddr(vb, 0);

	buf->length = vb2_plane_size(vb, 0);

	if (vb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)

	if (vb->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)

		buf->bytesused = 0;

	else

		buf->bytesused = vb2_get_plane_payload(vb, 0);
@@ -177,10 +188,10 @@ static int uvc_start_streaming(struct vb2_queue *vq, unsigned int count) 
static void uvc_stop_streaming(struct vb2_queue *vq)

{

	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);

	struct uvc_streaming *stream = uvc_queue_to_stream(queue);

	unsigned long flags;



	uvc_video_enable(stream, 0);

	if (vq->type != V4L2_BUF_TYPE_META_CAPTURE)

		uvc_video_enable(uvc_queue_to_stream(queue), 0);



	spin_lock_irqsave(&queue->irqlock, flags);

	uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
@@ -198,20 +209,39 @@ static const struct vb2_ops uvc_queue_qops = { 
	.stop_streaming = uvc_stop_streaming,

};



static const struct vb2_ops uvc_meta_queue_qops = {

	.queue_setup = uvc_queue_setup,

	.buf_prepare = uvc_buffer_prepare,

	.buf_queue = uvc_buffer_queue,

	.wait_prepare = vb2_ops_wait_prepare,

	.wait_finish = vb2_ops_wait_finish,

	.stop_streaming = uvc_stop_streaming,

};



int uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,

		    int drop_corrupted)

{

	int ret;



	queue->queue.type = type;

	queue->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;

	queue->queue.io_modes = VB2_MMAP | VB2_USERPTR;

	queue->queue.drv_priv = queue;

	queue->queue.buf_struct_size = sizeof(struct uvc_buffer);

	queue->queue.ops = &uvc_queue_qops;

	queue->queue.mem_ops = &vb2_vmalloc_memops;

	queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC

		| V4L2_BUF_FLAG_TSTAMP_SRC_SOE;

	queue->queue.lock = &queue->mutex;



	switch (type) {

	case V4L2_BUF_TYPE_META_CAPTURE:

		queue->queue.ops = &uvc_meta_queue_qops;

		break;

	default:

		queue->queue.io_modes |= VB2_DMABUF;

		queue->queue.ops = &uvc_queue_qops;

		break;

	}



	ret = vb2_queue_init(&queue->queue);

	if (ret)

		return ret;

CRA Git | Maintained and supported by SUSTech CRA and CCSE