Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369// SPDX-License-Identifier: GPL-2.0+/* * uvc_queue.c -- USB Video Class driver - Buffers management * * Copyright (C) 2005-2010 * Laurent Pinchart (laurent.pinchart@ideasonboard.com) */
#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/v4l2-common.h>#include <media/videobuf2-dma-sg.h>#include <media/videobuf2-vmalloc.h>
#include "uvc.h"#include "uvc_video.h"
/* ------------------------------------------------------------------------ * Video buffers queue management. * * Video queues is initialized by uvcg_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. */
/* ----------------------------------------------------------------------------- * videobuf2 queue operations */
static int uvc_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers, unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[]){ struct uvc_video_queue *queue = vb2_get_drv_priv(vq); struct uvc_video *video = container_of(queue, struct uvc_video, queue);
if (*nbuffers > UVC_MAX_VIDEO_BUFFERS) *nbuffers = UVC_MAX_VIDEO_BUFFERS; if (*nbuffers < UVCG_STREAMING_MIN_BUFFERS) *nbuffers = UVCG_STREAMING_MIN_BUFFERS;
*nplanes = 1;
sizes[0] = video->imagesize;
return 0;}
static int uvc_buffer_prepare(struct vb2_buffer *vb){ struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue); struct uvc_video *video = container_of(queue, struct uvc_video, queue); struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 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; if (queue->use_sg) { buf->sgt = vb2_dma_sg_plane_desc(vb, 0); buf->sg = buf->sgt->sgl; } else { 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);
if (video->reqs_per_frame != 0) { buf->req_payload_size = DIV_ROUND_UP(buf->bytesused + (video->reqs_per_frame * UVCG_REQUEST_HEADER_LEN), video->reqs_per_frame); if (buf->req_payload_size > video->req_size) buf->req_payload_size = video->req_size; } else { buf->req_payload_size = video->max_req_size; } }
return 0;}
static void uvc_buffer_queue(struct vb2_buffer *vb){ struct uvc_video_queue *queue = vb2_get_drv_priv(vb->vb2_queue); struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 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);}
static const struct vb2_ops uvc_queue_qops = { .queue_setup = uvc_queue_setup, .buf_prepare = uvc_buffer_prepare, .buf_queue = uvc_buffer_queue,};
int uvcg_queue_init(struct uvc_video_queue *queue, struct device *dev, enum v4l2_buf_type type, struct mutex *lock){ struct uvc_video *video = container_of(queue, struct uvc_video, queue); struct usb_composite_dev *cdev = video->uvc->func.config->cdev; 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.lock = lock; if (cdev->gadget->sg_supported) { queue->queue.mem_ops = &vb2_dma_sg_memops; queue->use_sg = 1; } else { queue->queue.mem_ops = &vb2_vmalloc_memops; }
queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY | V4L2_BUF_FLAG_TSTAMP_SRC_EOF; queue->queue.dev = dev;
ret = vb2_queue_init(&queue->queue); if (ret) return ret;
spin_lock_init(&queue->irqlock); INIT_LIST_HEAD(&queue->irqqueue); queue->flags = 0;
return 0;}
/* * Free the video buffers. */void uvcg_free_buffers(struct uvc_video_queue *queue){ vb2_queue_release(&queue->queue);}
/* * Allocate the video buffers. */int uvcg_alloc_buffers(struct uvc_video_queue *queue, struct v4l2_requestbuffers *rb){ int ret;
retry: ret = vb2_reqbufs(&queue->queue, rb); if (ret < 0 && queue->use_sg) { uvc_trace(UVC_TRACE_IOCTL, "failed to alloc buffer with sg enabled, try non-sg mode\n"); queue->use_sg = 0; queue->queue.mem_ops = &vb2_vmalloc_memops; goto retry; }
return ret ? ret : rb->count;}
int uvcg_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf){ return vb2_querybuf(&queue->queue, buf);}
int uvcg_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf){ return vb2_qbuf(&queue->queue, NULL, buf);}
/* * Dequeue a video buffer. If nonblocking is false, block until a buffer is * available. */int uvcg_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf, int nonblocking){ return vb2_dqbuf(&queue->queue, buf, nonblocking);}
/* * Poll the video queue. * * This function implements video queue polling and is intended to be used by * the device poll handler. */__poll_t uvcg_queue_poll(struct uvc_video_queue *queue, struct file *file, poll_table *wait){ return vb2_poll(&queue->queue, file, wait);}
int uvcg_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma){ return vb2_mmap(&queue->queue, vma);}
#ifndef CONFIG_MMU/* * Get unmapped area. * * NO-MMU arch need this function to make mmap() work correctly. */unsigned long uvcg_queue_get_unmapped_area(struct uvc_video_queue *queue, unsigned long pgoff){ return vb2_get_unmapped_area(&queue->queue, 0, 0, pgoff, 0);}#endif
/* * 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 uvcg_queue_cancel(struct uvc_video_queue *queue, int disconnect){ struct uvc_buffer *buf; unsigned long flags;
spin_lock_irqsave(&queue->irqlock, flags); while (!list_empty(&queue->irqqueue)) { buf = list_first_entry(&queue->irqqueue, struct uvc_buffer, queue); list_del(&buf->queue); buf->state = UVC_BUF_STATE_ERROR; vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_ERROR); } queue->buf_used = 0;
/* * This must be protected by the irqlock spinlock to avoid race * conditions between uvc_queue_buffer 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_DEV_DISCONNECTED * state outside the queue code. */ if (disconnect) queue->flags |= UVC_QUEUE_DISCONNECTED; spin_unlock_irqrestore(&queue->irqlock, flags);}
/* * Enable or disable the video buffers queue. * * The queue must be enabled before starting video acquisition and must be * disabled after stopping it. This ensures that the video buffers queue * state can be properly initialized before buffers are accessed from the * interrupt handler. * * Enabling the video queue initializes parameters (such as sequence number, * sync pattern, ...). If the queue is already enabled, return -EBUSY. * * Disabling the video queue cancels the queue and removes all buffers from * the main queue. * * This function can't be called from interrupt context. Use * uvcg_queue_cancel() instead. */int uvcg_queue_enable(struct uvc_video_queue *queue, int enable){ unsigned long flags; int ret = 0;
if (enable) { ret = vb2_streamon(&queue->queue, queue->queue.type); if (ret < 0) return ret;
queue->sequence = 0; queue->buf_used = 0; queue->flags &= ~UVC_QUEUE_DROP_INCOMPLETE; } else { ret = vb2_streamoff(&queue->queue, queue->queue.type); if (ret < 0) return ret;
spin_lock_irqsave(&queue->irqlock, flags); INIT_LIST_HEAD(&queue->irqqueue);
/* * FIXME: We need to clear the DISCONNECTED flag to ensure that * applications will be able to queue buffers for the next * streaming run. However, clearing it here doesn't guarantee * that the device will be reconnected in the meantime. */ queue->flags &= ~UVC_QUEUE_DISCONNECTED; spin_unlock_irqrestore(&queue->irqlock, flags); }
return ret;}
/* called with &queue_irqlock held.. */void uvcg_complete_buffer(struct uvc_video_queue *queue, struct uvc_buffer *buf){ if (queue->flags & UVC_QUEUE_DROP_INCOMPLETE) { queue->flags &= ~UVC_QUEUE_DROP_INCOMPLETE; buf->state = UVC_BUF_STATE_ERROR; vb2_set_plane_payload(&buf->buf.vb2_buf, 0, 0); vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_ERROR); return; }
buf->buf.field = V4L2_FIELD_NONE; buf->buf.sequence = queue->sequence++; buf->buf.vb2_buf.timestamp = ktime_get_ns();
vb2_set_plane_payload(&buf->buf.vb2_buf, 0, buf->bytesused); vb2_buffer_done(&buf->buf.vb2_buf, VB2_BUF_STATE_DONE);}
struct uvc_buffer *uvcg_queue_head(struct uvc_video_queue *queue){ struct uvc_buffer *buf = NULL;
if (!list_empty(&queue->irqqueue)) buf = list_first_entry(&queue->irqqueue, struct uvc_buffer, queue);
return buf;}