Release 4.7 drivers/media/usb/uvc/uvc_queue.c

Directory: drivers/media/usb/uvc
/*
 *      uvc_queue.c  --  USB Video Class driver - Buffers management
 *
 *      Copyright (C) 2005-2010
 *          Laurent Pinchart (laurent.pinchart@ideasonboard.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/atomic.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/videodev2.h>
#include <linux/vmalloc.h>
#include <linux/wait.h>
#include <media/videobuf2-v4l2.h>
#include <media/videobuf2-vmalloc.h>

#include "uvcvideo.h"

/* ------------------------------------------------------------------------
 * Video buffers queue management.
 *
 * Video queues is initialized by uvc_queue_init(). The function performs
 * basic initialization of the uvc_video_queue struct and never fails.
 *
 * Video buffers are managed by videobuf2. The driver uses a mutex to protect
 * the videobuf2 queue operations by serializing calls to videobuf2 and a
 * spinlock to protect the IRQ queue that holds the buffers to be processed by
 * the driver.
 */


static inline struct uvc_streaming *

uvc_queue_to_stream(struct uvc_video_queue *queue)
{
	return container_of(queue, struct uvc_streaming, queue);
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 25 100.00% 1 100.00%
Total 25 100.00% 1 100.00%

/*
 * Return all queued buffers to videobuf2 in the requested state.
 *
 * This function must be called with the queue spinlock held.
 */


static void uvc_queue_return_buffers(struct uvc_video_queue *queue,
			       enum uvc_buffer_state state)
{
	enum vb2_buffer_state vb2_state = state == UVC_BUF_STATE_ERROR
					? VB2_BUF_STATE_ERROR
					: VB2_BUF_STATE_QUEUED;

	while (!list_empty(&queue->irqqueue)) {
		struct uvc_buffer *buf = list_first_entry(&queue->irqqueue,
							  struct uvc_buffer,
							  queue);
		list_del(&buf->queue);
		buf->state = state;
		vb2_buffer_done(&buf->buf.vb2_buf, vb2_state);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 82 97.62% 1 50.00%
junghak sung junghak sung 2 2.38% 1 50.00%
Total 84 100.00% 2 100.00%

/* -----------------------------------------------------------------------------
 * videobuf2 queue operations
 */



static int uvc_queue_setup(struct vb2_queue *vq,
			   unsigned int *nbuffers, unsigned int *nplanes,
			   unsigned int sizes[], void *alloc_ctxs[])
{
	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
	struct uvc_streaming *stream = uvc_queue_to_stream(queue);
	unsigned size = stream->ctrl.dwMaxVideoFrameSize;

	/* Make sure the image size is large enough. */
	if (*nplanes)
		return sizes[0] < size ? -EINVAL : 0;
	*nplanes = 1;
	sizes[0] = size;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 75 79.79% 6 85.71%
hans verkuil hans verkuil 19 20.21% 1 14.29%
Total 94 100.00% 7 100.00%



static int uvc_buffer_prepare(struct vb2_buffer *vb)
{
	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
	struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
	struct uvc_buffer *buf = container_of(vbuf, struct uvc_buffer, buf);

	if (vb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
	    vb2_get_plane_payload(vb, 0) > vb2_plane_size(vb, 0)) {
		uvc_trace(UVC_TRACE_CAPTURE, "[E] Bytes used out of bounds.\n");
		return -EINVAL;
	}

	if (unlikely(queue->flags & UVC_QUEUE_DISCONNECTED))
		return -ENODEV;

	buf->state = UVC_BUF_STATE_QUEUED;
	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)
		buf->bytesused = 0;
	else
		buf->bytesused = vb2_get_plane_payload(vb, 0);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 142 88.20% 2 50.00%
junghak sung junghak sung 11 6.83% 1 25.00%
sjoerd simons sjoerd simons 8 4.97% 1 25.00%
Total 161 100.00% 4 100.00%



static void uvc_buffer_queue(struct vb2_buffer *vb)
{
	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
	struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
	struct uvc_buffer *buf = container_of(vbuf, struct uvc_buffer, buf);
	unsigned long flags;

	spin_lock_irqsave(&queue->irqlock, flags);
	if (likely(!(queue->flags & UVC_QUEUE_DISCONNECTED))) {
		list_add_tail(&buf->queue, &queue->irqqueue);
	} else {
		/* If the device is disconnected return the buffer to userspace
                 * directly. The next QBUF call will fail with -ENODEV.
                 */
		buf->state = UVC_BUF_STATE_ERROR;
		vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
	}

	spin_unlock_irqrestore(&queue->irqlock, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 106 89.83% 4 80.00%
junghak sung junghak sung 12 10.17% 1 20.00%
Total 118 100.00% 5 100.00%



static void uvc_buffer_finish(struct vb2_buffer *vb)
{
	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
	struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue);
	struct uvc_streaming *stream = uvc_queue_to_stream(queue);
	struct uvc_buffer *buf = container_of(vbuf, struct uvc_buffer, buf);

	if (vb->state == VB2_BUF_STATE_DONE)
		uvc_video_clock_update(stream, vbuf, buf);
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 54 72.00% 2 40.00%
junghak sung junghak sung 12 16.00% 1 20.00%
hans verkuil hans verkuil 9 12.00% 2 40.00%
Total 75 100.00% 5 100.00%



static int uvc_start_streaming(struct vb2_queue *vq, unsigned int count)
{
	struct uvc_video_queue *queue = vb2_get_drv_priv(vq);
	struct uvc_streaming *stream = uvc_queue_to_stream(queue);
	unsigned long flags;
	int ret;

	queue->buf_used = 0;

	ret = uvc_video_enable(stream, 1);
	if (ret == 0)
		return 0;

	spin_lock_irqsave(&queue->irqlock, flags);
	uvc_queue_return_buffers(queue, UVC_BUF_STATE_QUEUED);
	spin_unlock_irqrestore(&queue->irqlock, flags);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 96 100.00% 2 100.00%
Total 96 100.00% 2 100.00%



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);

	spin_lock_irqsave(&queue->irqlock, flags);
	uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
	spin_unlock_irqrestore(&queue->irqlock, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 69 100.00% 2 100.00%
Total 69 100.00% 2 100.00%


static struct vb2_ops uvc_queue_qops = {
	.queue_setup = uvc_queue_setup,
	.buf_prepare = uvc_buffer_prepare,
	.buf_queue = uvc_buffer_queue,
	.buf_finish = uvc_buffer_finish,
	.wait_prepare = vb2_ops_wait_prepare,
	.wait_finish = vb2_ops_wait_finish,
	.start_streaming = uvc_start_streaming,
	.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.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;
	ret = vb2_queue_init(&queue->queue);
	if (ret)
		return ret;

	mutex_init(&queue->mutex);
	spin_lock_init(&queue->irqlock);
	INIT_LIST_HEAD(&queue->irqqueue);
	queue->flags = drop_corrupted ? UVC_QUEUE_DROP_CORRUPTED : 0;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 112 73.20% 4 36.36%
ezequiel garcia ezequiel garcia 16 10.46% 1 9.09%
prabhakar lad prabhakar lad 11 7.19% 1 9.09%
kamil debski kamil debski 7 4.58% 1 9.09%
sakari ailus sakari ailus 3 1.96% 2 18.18%
javier martin javier martin 2 1.31% 1 9.09%
tomasz stanislawski tomasz stanislawski 2 1.31% 1 9.09%
Total 153 100.00% 11 100.00%



void uvc_queue_release(struct uvc_video_queue *queue)
{
	mutex_lock(&queue->mutex);
	vb2_queue_release(&queue->queue);
	mutex_unlock(&queue->mutex);
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 34 100.00% 4 100.00%
Total 34 100.00% 4 100.00%

/* -----------------------------------------------------------------------------
 * V4L2 queue operations
 */



int uvc_request_buffers(struct uvc_video_queue *queue,
			struct v4l2_requestbuffers *rb)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_reqbufs(&queue->queue, rb);
	mutex_unlock(&queue->mutex);

	return ret ? ret : rb->count;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 55 100.00% 4 100.00%
Total 55 100.00% 4 100.00%



int uvc_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_querybuf(&queue->queue, buf);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 49 100.00% 2 100.00%
Total 49 100.00% 2 100.00%



int uvc_create_buffers(struct uvc_video_queue *queue,
		       struct v4l2_create_buffers *cb)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_create_bufs(&queue->queue, cb);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
philipp zabel philipp zabel 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%



int uvc_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_qbuf(&queue->queue, buf);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 49 100.00% 2 100.00%
Total 49 100.00% 2 100.00%



int uvc_export_buffer(struct uvc_video_queue *queue,
		      struct v4l2_exportbuffer *exp)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_expbuf(&queue->queue, exp);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 49 100.00% 1 100.00%
Total 49 100.00% 1 100.00%



int uvc_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
		       int nonblocking)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_dqbuf(&queue->queue, buf, nonblocking);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 54 100.00% 2 100.00%
Total 54 100.00% 2 100.00%



int uvc_queue_streamon(struct uvc_video_queue *queue, enum v4l2_buf_type type)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_streamon(&queue->queue, type);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 48 100.00% 1 100.00%
Total 48 100.00% 1 100.00%



int uvc_queue_streamoff(struct uvc_video_queue *queue, enum v4l2_buf_type type)
{
	int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_streamoff(&queue->queue, type);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 48 100.00% 1 100.00%
Total 48 100.00% 1 100.00%



int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
{
	return vb2_mmap(&queue->queue, vma);
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 25 96.15% 3 75.00%
bob liu bob liu 1 3.85% 1 25.00%
Total 26 100.00% 4 100.00%

#ifndef CONFIG_MMU


unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
		unsigned long pgoff)
{
	return vb2_get_unmapped_area(&queue->queue, 0, 0, pgoff, 0);
}
Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 32 100.00% 4 100.00%
Total 32 100.00% 4 100.00%

#endif



unsigned int uvc_queue_poll(struct uvc_video_queue *queue, struct file *file,
			    poll_table *wait)
{
	unsigned int ret;

	mutex_lock(&queue->mutex);
	ret = vb2_poll(&queue->queue, file, wait);
	mutex_unlock(&queue->mutex);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 57 100.00% 4 100.00%
Total 57 100.00% 4 100.00%

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

/*
 * Check if buffers have been allocated.
 */


int uvc_queue_allocated(struct uvc_video_queue *queue)
{
	int allocated;

	mutex_lock(&queue->mutex);
	allocated = vb2_is_busy(&queue->queue);
	mutex_unlock(&queue->mutex);

	return allocated;
}

Contributors
Person Tokens Prop Commits CommitProp
bob liu bob liu 34 80.95% 1 50.00%
laurent pinchart laurent pinchart 8 19.05% 1 50.00%
Total 42 100.00% 2 100.00%

/*
 * Cancel the video buffers queue.
 *
 * Cancelling the queue marks all buffers on the irq queue as erroneous,
 * wakes them up and removes them from the queue.
 *
 * If the disconnect parameter is set, further calls to uvc_queue_buffer will
 * fail with -ENODEV.
 *
 * This function acquires the irq spinlock and can be called from interrupt
 * context.
 */


void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
{
	unsigned long flags;

	spin_lock_irqsave(&queue->irqlock, flags);
	uvc_queue_return_buffers(queue, UVC_BUF_STATE_ERROR);
	/* This must be protected by the irqlock spinlock to avoid race
         * conditions between uvc_buffer_queue and the disconnection event that
         * could result in an interruptible wait in uvc_dequeue_buffer. Do not
         * blindly replace this logic by checking for the UVC_QUEUE_DISCONNECTED
         * state outside the queue code.
         */
	if (disconnect)
		queue->flags |= UVC_QUEUE_DISCONNECTED;
	spin_unlock_irqrestore(&queue->irqlock, flags);
}

Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 55 100.00% 3 100.00%
Total 55 100.00% 3 100.00%



struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
		struct uvc_buffer *buf)
{
	struct uvc_buffer *nextbuf;
	unsigned long flags;

	if ((queue->flags & UVC_QUEUE_DROP_CORRUPTED) && buf->error) {
		buf->error = 0;
		buf->state = UVC_BUF_STATE_QUEUED;
		buf->bytesused = 0;
		vb2_set_plane_payload(&buf->buf.vb2_buf, 0, 0);
		return buf;
	}

	spin_lock_irqsave(&queue->irqlock, flags);
	list_del(&buf->queue);
	if (!list_empty(&queue->irqqueue))
		nextbuf = list_first_entry(&queue->irqqueue, struct uvc_buffer,
					   queue);
	else
		nextbuf = NULL;
	spin_unlock_irqrestore(&queue->irqlock, flags);

	buf->state = buf->error ? VB2_BUF_STATE_ERROR : UVC_BUF_STATE_DONE;
	vb2_set_plane_payload(&buf->buf.vb2_buf, 0, buf->bytesused);
	vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_DONE);

	return nextbuf;
}
Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 167 93.30% 3 60.00%
jayakrishnan memana jayakrishnan memana 6 3.35% 1 20.00%
junghak sung junghak sung 6 3.35% 1 20.00%
Total 179 100.00% 5 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
laurent pinchart laurent pinchart 1579 87.87% 22 57.89%
philipp zabel philipp zabel 49 2.73% 1 2.63%
junghak sung junghak sung 46 2.56% 1 2.63%
bob liu bob liu 35 1.95% 1 2.63%
hans verkuil hans verkuil 28 1.56% 3 7.89%
ezequiel garcia ezequiel garcia 16 0.89% 1 2.63%
prabhakar lad prabhakar lad 13 0.72% 1 2.63%
sjoerd simons sjoerd simons 8 0.45% 1 2.63%
kamil debski kamil debski 7 0.39% 1 2.63%
jayakrishnan memana jayakrishnan memana 6 0.33% 1 2.63%
andrea righi andrea righi 3 0.17% 1 2.63%
sakari ailus sakari ailus 3 0.17% 2 5.26%
tomasz stanislawski tomasz stanislawski 2 0.11% 1 2.63%
javier martin javier martin 2 0.11% 1 2.63%
Total 1797 100.00% 38 100.00%
  Directory: drivers/media/usb/uvc

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
laurent pinchart	laurent pinchart	25	100.00%	1	100.00%
	Total	25	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/media/usb/uvc/uvc_queue.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
