system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-09-24 21:38:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

[media] solo6x10: convert encoder nodes to vb2

Browse source 
As a consequence the ioctl op has been replaced by unlocked_ioctl.
Since we are now using the core lock the locking scheme has been
simplified as well.

Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Hans Verkuil 2013-03-15 12:04:14 -03:00 committed by Mauro Carvalho Chehab
parent a7eb931d63
commit 382c31a943
3 changed files with 139 additions and 378 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
drivers/staging/media/solo6x10/Kconfig
View file

@ -2,6 +2,7 @@ config SOLO6X10
tristate "Softlogic 6x10 MPEG codec cards"
depends on PCI && VIDEO_DEV && SND && I2C
select VIDEOBUF_DMA_SG
select VIDEOBUF2_DMA_SG
select SND_PCM
---help---
This driver supports the Softlogic based MPEG-4 and h.264 codec

13
drivers/staging/media/solo6x10/solo6x10.h
View file

@ -40,6 +40,7 @@
#include <media/v4l2-device.h>
#include <media/v4l2-ctrls.h>
#include <media/videobuf-core.h>
#include <media/videobuf2-core.h>
#include "registers.h"
@ -135,6 +136,11 @@ struct solo_p2m_dev {
#define OSD_TEXT_MAX 44
struct solo_vb2_buf {
struct vb2_buffer vb;
struct list_head list;
};
enum solo_enc_types {
SOLO_ENC_TYPE_STD,
SOLO_ENC_TYPE_EXT,
@ -146,10 +152,8 @@ struct solo_enc_dev {
struct v4l2_ctrl_handler hdl;
struct video_device *vfd;
/* General accounting */
struct mutex enable_lock;
struct mutex lock;
spinlock_t motion_lock;
atomic_t readers;
atomic_t mpeg_readers;
u8 ch;
u8 mode, gop, qp, interlaced, interval;
u8 bw_weight;
@ -169,9 +173,8 @@ struct solo_enc_dev {
int jpeg_len;
u32 fmt;
u8 enc_on;
enum solo_enc_types type;
struct videobuf_queue vidq;
struct vb2_queue vidq;
struct list_head vidq_active;
int desc_count;
int desc_nelts;

503
drivers/staging/media/solo6x10/v4l2-enc.c
View file

@ -30,7 +30,7 @@
#include <media/v4l2-ioctl.h>
#include <media/v4l2-common.h>
#include <media/v4l2-event.h>
#include <media/videobuf-dma-sg.h>
#include <media/videobuf2-dma-sg.h>
#include "solo6x10.h"
#include "tw28.h"
@ -181,7 +181,6 @@ static void solo_motion_toggle(struct solo_enc_dev *solo_enc, int on)
spin_unlock_irqrestore(&solo_enc->motion_lock, flags);
}
/* MUST be called with solo_enc->enable_lock held */
static void solo_update_mode(struct solo_enc_dev *solo_enc)
{
struct solo_dev *solo_dev = solo_enc->solo_dev;
@ -264,43 +263,22 @@ static void solo_update_mode(struct solo_enc_dev *solo_enc)
jpeg_dqt[solo_g_jpeg_qp(solo_dev, solo_enc->ch)], DQT_LEN);
}
/* MUST be called with solo_enc->enable_lock held */
static int __solo_enc_on(struct solo_enc_dev *solo_enc)
static int solo_enc_on(struct solo_enc_dev *solo_enc)
{
u8 ch = solo_enc->ch;
struct solo_dev *solo_dev = solo_enc->solo_dev;
u8 interval;
BUG_ON(!mutex_is_locked(&solo_enc->enable_lock));
if (solo_enc->enc_on)
return 0;
solo_update_mode(solo_enc);
/* Make sure to bw check on first reader */
if (!atomic_read(&solo_enc->readers)) {
if (solo_enc->bw_weight > solo_dev->enc_bw_remain)
return -EBUSY;
else
solo_dev->enc_bw_remain -= solo_enc->bw_weight;
}
solo_enc->enc_on = 1;
/* Make sure to do a bandwidth check */
if (solo_enc->bw_weight > solo_dev->enc_bw_remain)
return -EBUSY;
solo_dev->enc_bw_remain -= solo_enc->bw_weight;
if (solo_enc->type == SOLO_ENC_TYPE_EXT)
solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(ch), 1);
/* Reset the encoder if we are the first mpeg reader, else only reset
* on the first mjpeg reader. */
if (solo_enc->fmt == V4L2_PIX_FMT_MPEG) {
atomic_inc(&solo_enc->readers);
if (atomic_inc_return(&solo_enc->mpeg_readers) > 1)
return 0;
} else if (atomic_inc_return(&solo_enc->readers) > 1) {
return 0;
}
/* Disable all encoding for this channel */
solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(ch), 0);
@ -329,47 +307,16 @@ static int __solo_enc_on(struct solo_enc_dev *solo_enc)
return 0;
}
static int solo_enc_on(struct solo_enc_dev *solo_enc)
{
int ret;
mutex_lock(&solo_enc->enable_lock);
ret = __solo_enc_on(solo_enc);
mutex_unlock(&solo_enc->enable_lock);
return ret;
}
static void __solo_enc_off(struct solo_enc_dev *solo_enc)
static void solo_enc_off(struct solo_enc_dev *solo_enc)
{
struct solo_dev *solo_dev = solo_enc->solo_dev;
BUG_ON(!mutex_is_locked(&solo_enc->enable_lock));
if (!solo_enc->enc_on)
return;
solo_enc->enc_on = 0;
if (solo_enc->fmt == V4L2_PIX_FMT_MPEG)
atomic_dec(&solo_enc->mpeg_readers);
if (atomic_dec_return(&solo_enc->readers) > 0)
return;
solo_dev->enc_bw_remain += solo_enc->bw_weight;
solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(solo_enc->ch), 0);
solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(solo_enc->ch), 0);
}
static void solo_enc_off(struct solo_enc_dev *solo_enc)
{
mutex_lock(&solo_enc->enable_lock);
__solo_enc_off(solo_enc);
mutex_unlock(&solo_enc->enable_lock);
}
static int enc_get_mpeg_dma(struct solo_dev *solo_dev, dma_addr_t dma,
unsigned int off, unsigned int size)
{
@ -403,7 +350,7 @@ static int enc_get_mpeg_dma(struct solo_dev *solo_dev, dma_addr_t dma,
/* Build a descriptor queue out of an SG list and send it to the P2M for
* processing. */
static int solo_send_desc(struct solo_enc_dev *solo_enc, int skip,
struct videobuf_dmabuf *vbuf, int off, int size,
struct vb2_dma_sg_desc *vbuf, int off, int size,
unsigned int base, unsigned int base_size)
{
struct solo_dev *solo_dev = solo_enc->solo_dev;
@ -416,7 +363,7 @@ static int solo_send_desc(struct solo_enc_dev *solo_enc, int skip,
solo_enc->desc_count = 1;
for_each_sg(vbuf->sglist, sg, vbuf->sglen, i) {
for_each_sg(vbuf->sglist, sg, vbuf->num_pages, i) {
struct solo_p2m_desc *desc;
dma_addr_t dma;
int len;
@ -487,61 +434,62 @@ static int solo_send_desc(struct solo_enc_dev *solo_enc, int skip,
solo_enc->desc_count - 1);
}
static int solo_fill_jpeg(struct solo_enc_dev *solo_enc, struct videobuf_buffer *vb,
struct videobuf_dmabuf *vbuf, struct vop_header *vh)
static int solo_fill_jpeg(struct solo_enc_dev *solo_enc,
struct vb2_buffer *vb, struct vop_header *vh)
{
struct solo_dev *solo_dev = solo_enc->solo_dev;
struct solo_videobuf *svb = (struct solo_videobuf *)vb;
struct vb2_dma_sg_desc *vbuf = vb2_dma_sg_plane_desc(vb, 0);
int frame_size;
int ret;
svb->flags |= V4L2_BUF_FLAG_KEYFRAME;
vb->v4l2_buf.flags |= V4L2_BUF_FLAG_KEYFRAME;
if (vb->bsize < (vh->jpeg_size + solo_enc->jpeg_len))
if (vb2_plane_size(vb, 0) < vh->jpeg_size + solo_enc->jpeg_len)
return -EIO;
vb->width = solo_enc->width;
vb->height = solo_enc->height;
vb->size = vh->jpeg_size + solo_enc->jpeg_len;
sg_copy_from_buffer(vbuf->sglist, vbuf->sglen,
solo_enc->jpeg_header,
solo_enc->jpeg_len);
sg_copy_from_buffer(vbuf->sglist, vbuf->num_pages,
solo_enc->jpeg_header,
solo_enc->jpeg_len);
frame_size = (vh->jpeg_size + solo_enc->jpeg_len + (DMA_ALIGN - 1))
& ~(DMA_ALIGN - 1);
vb2_set_plane_payload(vb, 0, vh->jpeg_size + solo_enc->jpeg_len);
return solo_send_desc(solo_enc, solo_enc->jpeg_len, vbuf, vh->jpeg_off,
frame_size, SOLO_JPEG_EXT_ADDR(solo_dev),
SOLO_JPEG_EXT_SIZE(solo_dev));
dma_map_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,
DMA_FROM_DEVICE);
ret = solo_send_desc(solo_enc, solo_enc->jpeg_len, vbuf, vh->jpeg_off,
frame_size, SOLO_JPEG_EXT_ADDR(solo_dev),
SOLO_JPEG_EXT_SIZE(solo_dev));
dma_unmap_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,
DMA_FROM_DEVICE);
return ret;
}
static int solo_fill_mpeg(struct solo_enc_dev *solo_enc, struct videobuf_buffer *vb,
struct videobuf_dmabuf *vbuf, struct vop_header *vh)
static int solo_fill_mpeg(struct solo_enc_dev *solo_enc,
struct vb2_buffer *vb, struct vop_header *vh)
{
struct solo_dev *solo_dev = solo_enc->solo_dev;
struct solo_videobuf *svb = (struct solo_videobuf *)vb;
struct vb2_dma_sg_desc *vbuf = vb2_dma_sg_plane_desc(vb, 0);
int frame_off, frame_size;
int skip = 0;
int ret;
if (vb->bsize < vh->mpeg_size)
if (vb2_plane_size(vb, 0) < vh->mpeg_size)
return -EIO;
vb->width = vh->hsize << 4;
vb->height = vh->vsize << 4;
vb->size = vh->mpeg_size;
/* If this is a key frame, add extra header */
if (!vh->vop_type) {
sg_copy_from_buffer(vbuf->sglist, vbuf->sglen,
solo_enc->vop,
solo_enc->vop_len);
sg_copy_from_buffer(vbuf->sglist, vbuf->num_pages,
solo_enc->vop,
solo_enc->vop_len);
skip = solo_enc->vop_len;
vb->size += solo_enc->vop_len;
svb->flags |= V4L2_BUF_FLAG_KEYFRAME;
vb->v4l2_buf.flags |= V4L2_BUF_FLAG_KEYFRAME;
vb2_set_plane_payload(vb, 0, vh->mpeg_size + solo_enc->vop_len);
} else {
svb->flags |= V4L2_BUF_FLAG_PFRAME;
vb->v4l2_buf.flags |= V4L2_BUF_FLAG_PFRAME;
vb2_set_plane_payload(vb, 0, vh->mpeg_size);
}
/* Now get the actual mpeg payload */
@ -550,93 +498,67 @@ static int solo_fill_mpeg(struct solo_enc_dev *solo_enc, struct videobuf_buffer
frame_size = (vh->mpeg_size + skip + (DMA_ALIGN - 1))
& ~(DMA_ALIGN - 1);
return solo_send_desc(solo_enc, skip, vbuf, frame_off, frame_size,
SOLO_MP4E_EXT_ADDR(solo_dev),
SOLO_MP4E_EXT_SIZE(solo_dev));
dma_map_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,
DMA_FROM_DEVICE);
ret = solo_send_desc(solo_enc, skip, vbuf, frame_off, frame_size,
SOLO_MP4E_EXT_ADDR(solo_dev),
SOLO_MP4E_EXT_SIZE(solo_dev));
dma_unmap_sg(&solo_dev->pdev->dev, vbuf->sglist, vbuf->num_pages,
DMA_FROM_DEVICE);
return ret;
}
static int solo_enc_fillbuf(struct solo_enc_dev *solo_enc,
struct videobuf_buffer *vb,
struct solo_enc_buf *enc_buf)
struct vb2_buffer *vb, struct solo_enc_buf *enc_buf)
{
struct solo_videobuf *svb = (struct solo_videobuf *)vb;
struct videobuf_dmabuf *vbuf = NULL;
struct vop_header *vh = enc_buf->vh;
int ret;
vbuf = videobuf_to_dma(vb);
if (WARN_ON_ONCE(!vbuf)) {
ret = -EIO;
goto vbuf_error;
}
/* Setup some common flags for both types */
svb->flags = V4L2_BUF_FLAG_TIMECODE;
vb->ts.tv_sec = vh->sec;
vb->ts.tv_usec = vh->usec;
/* Check for motion flags */
if (solo_is_motion_on(solo_enc)) {
svb->flags |= V4L2_BUF_FLAG_MOTION_ON;
vb->v4l2_buf.flags |= V4L2_BUF_FLAG_MOTION_ON;
if (enc_buf->motion)
svb->flags |= V4L2_BUF_FLAG_MOTION_DETECTED;
vb->v4l2_buf.flags |= V4L2_BUF_FLAG_MOTION_DETECTED;
}
if (solo_enc->fmt == V4L2_PIX_FMT_MPEG)
ret = solo_fill_mpeg(solo_enc, vb, vbuf, vh);
ret = solo_fill_mpeg(solo_enc, vb, vh);
else
ret = solo_fill_jpeg(solo_enc, vb, vbuf, vh);
ret = solo_fill_jpeg(solo_enc, vb, vh);
vbuf_error:
/* On error, we push this buffer back into the queue. The
* videobuf-core doesn't handle error packets very well. Plus
* we recover nicely internally anyway. */
if (ret) {
unsigned long flags;
spin_lock_irqsave(&solo_enc->av_lock, flags);
list_add(&vb->queue, &solo_enc->vidq_active);
vb->state = VIDEOBUF_QUEUED;
spin_unlock_irqrestore(&solo_enc->av_lock, flags);
} else {
vb->state = VIDEOBUF_DONE;
vb->field_count++;
vb->width = solo_enc->width;
vb->height = solo_enc->height;
wake_up(&vb->done);
if (!ret) {
vb->v4l2_buf.sequence++;
vb->v4l2_buf.timestamp.tv_sec = vh->sec;
vb->v4l2_buf.timestamp.tv_usec = vh->usec;
}
vb2_buffer_done(vb, ret ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
return ret;
}
static void solo_enc_handle_one(struct solo_enc_dev *solo_enc,
struct solo_enc_buf *enc_buf)
{
struct videobuf_buffer *vb;
struct solo_vb2_buf *vb;
unsigned long flags;
mutex_lock(&solo_enc->enable_lock);
mutex_lock(&solo_enc->lock);
if (solo_enc->type != enc_buf->type)
goto unlock;
if (list_empty(&solo_enc->vidq_active))
goto unlock;
spin_lock_irqsave(&solo_enc->av_lock, flags);
vb = list_first_entry(&solo_enc->vidq_active,
struct videobuf_buffer, queue);
list_del(&vb->queue);
vb->state = VIDEOBUF_ACTIVE;
if (list_empty(&solo_enc->vidq_active)) {
spin_unlock_irqrestore(&solo_enc->av_lock, flags);
goto unlock;
}
vb = list_first_entry(&solo_enc->vidq_active, struct solo_vb2_buf, list);
list_del(&vb->list);
spin_unlock_irqrestore(&solo_enc->av_lock, flags);
solo_enc_fillbuf(solo_enc, vb, enc_buf);
solo_enc_fillbuf(solo_enc, &vb->vb, enc_buf);
unlock:
mutex_unlock(&solo_enc->enable_lock);
mutex_unlock(&solo_enc->lock);
}
void solo_enc_v4l2_isr(struct solo_dev *solo_dev)
@ -723,85 +645,29 @@ static int solo_ring_thread(void *data)
return 0;
}
static int solo_enc_buf_setup(struct videobuf_queue *vq, unsigned int *count,
unsigned int *size)
static int solo_enc_queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
unsigned int *num_buffers, unsigned int *num_planes,
unsigned int sizes[], void *alloc_ctxs[])
{
*size = FRAME_BUF_SIZE;
sizes[0] = FRAME_BUF_SIZE;
*num_planes = 1;
if (*count < MIN_VID_BUFFERS)
*count = MIN_VID_BUFFERS;
if (*num_buffers < MIN_VID_BUFFERS)
*num_buffers = MIN_VID_BUFFERS;
return 0;
}
static int solo_enc_buf_prepare(struct videobuf_queue *vq,
struct videobuf_buffer *vb,
enum v4l2_field field)
static void solo_enc_buf_queue(struct vb2_buffer *vb)
{
vb->size = FRAME_BUF_SIZE;
if (vb->baddr != 0 && vb->bsize < vb->size)
return -EINVAL;
struct vb2_queue *vq = vb->vb2_queue;
struct solo_enc_dev *solo_enc = vb2_get_drv_priv(vq);
struct solo_vb2_buf *solo_vb =
container_of(vb, struct solo_vb2_buf, vb);
/* This property only change when queue is idle */
vb->field = field;
if (vb->state == VIDEOBUF_NEEDS_INIT) {
int rc = videobuf_iolock(vq, vb, NULL);
if (rc < 0) {
struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
videobuf_dma_unmap(vq->dev, dma);
videobuf_dma_free(dma);
return rc;
}
}
vb->state = VIDEOBUF_PREPARED;
return 0;
}
static void solo_enc_buf_queue(struct videobuf_queue *vq,
struct videobuf_buffer *vb)
{
struct solo_enc_dev *solo_enc = vq->priv_data;
vb->state = VIDEOBUF_QUEUED;
list_add_tail(&vb->queue, &solo_enc->vidq_active);
}
static void solo_enc_buf_release(struct videobuf_queue *vq,
struct videobuf_buffer *vb)
{
struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
videobuf_dma_unmap(vq->dev, dma);
videobuf_dma_free(dma);
vb->state = VIDEOBUF_NEEDS_INIT;
}
static const struct videobuf_queue_ops solo_enc_video_qops = {
.buf_setup = solo_enc_buf_setup,
.buf_prepare = solo_enc_buf_prepare,
.buf_queue = solo_enc_buf_queue,
.buf_release = solo_enc_buf_release,
};
static unsigned int solo_enc_poll(struct file *file,
struct poll_table_struct *wait)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
unsigned long req_events = poll_requested_events(wait);
unsigned res = v4l2_ctrl_poll(file, wait);
if (!(req_events & (POLLIN | POLLRDNORM)))
return res;
return videobuf_poll_stream(file, &solo_enc->vidq, wait);
}
static int solo_enc_mmap(struct file *file, struct vm_area_struct *vma)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
return videobuf_mmap_mapper(&solo_enc->vidq, vma);
spin_lock(&solo_enc->av_lock);
list_add_tail(&solo_vb->list, &solo_enc->vidq_active);
spin_unlock(&solo_enc->av_lock);
}
static int solo_ring_start(struct solo_dev *solo_dev)
@ -835,50 +701,36 @@ static void solo_ring_stop(struct solo_dev *solo_dev)
solo_irq_off(solo_dev, SOLO_IRQ_ENCODER);
}
static int solo_enc_open(struct file *file)
static int solo_enc_start_streaming(struct vb2_queue *q, unsigned int count)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
struct solo_dev *solo_dev = solo_enc->solo_dev;
int ret = v4l2_fh_open(file);
if (ret)
return ret;
ret = solo_ring_start(solo_dev);
if (ret) {
v4l2_fh_release(file);
return ret;
}
return 0;
}
static ssize_t solo_enc_read(struct file *file, char __user *data,
size_t count, loff_t *ppos)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
struct solo_enc_dev *solo_enc = vb2_get_drv_priv(q);
int ret;
/* Make sure the encoder is on */
ret = solo_enc_on(solo_enc);
if (ret)
return ret;
return videobuf_read_stream(&solo_enc->vidq, data, count, ppos, 0,
file->f_flags & O_NONBLOCK);
return solo_ring_start(solo_enc->solo_dev);
}
static int solo_enc_release(struct file *file)
static int solo_enc_stop_streaming(struct vb2_queue *q)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
struct solo_dev *solo_dev = solo_enc->solo_dev;
struct solo_enc_dev *solo_enc = vb2_get_drv_priv(q);
solo_enc_off(solo_enc);
videobuf_stop(&solo_enc->vidq);
videobuf_mmap_free(&solo_enc->vidq);
solo_ring_stop(solo_dev);
return v4l2_fh_release(file);
INIT_LIST_HEAD(&solo_enc->vidq_active);
solo_ring_stop(solo_enc->solo_dev);
return 0;
}
static struct vb2_ops solo_enc_video_qops = {
.queue_setup = solo_enc_queue_setup,
.buf_queue = solo_enc_buf_queue,
.start_streaming = solo_enc_start_streaming,
.stop_streaming = solo_enc_stop_streaming,
.wait_prepare = vb2_ops_wait_prepare,
.wait_finish = vb2_ops_wait_finish,
};
static int solo_enc_querycap(struct file *file, void *priv,
struct v4l2_capability *cap)
{
@ -1007,23 +859,13 @@ static int solo_enc_set_fmt_cap(struct file *file, void *priv,
struct v4l2_pix_format *pix = &f->fmt.pix;
int ret;
mutex_lock(&solo_enc->enable_lock);
if (vb2_is_busy(&solo_enc->vidq))
return -EBUSY;
ret = solo_enc_try_fmt_cap(file, priv, f);
if (ret)
return ret;
/* We cannot change width/height in mid read */
if (!ret && atomic_read(&solo_enc->readers) > 0) {
if (pix->width != solo_enc->width ||
pix->height != solo_enc->height)
ret = -EBUSY;
}
if (ret) {
mutex_unlock(&solo_enc->enable_lock);
return ret;
}
if (pix->width == solo_dev->video_hsize)
solo_enc->mode = SOLO_ENC_MODE_D1;
else
@ -1034,9 +876,6 @@ static int solo_enc_set_fmt_cap(struct file *file, void *priv,
if (pix->priv)
solo_enc->type = SOLO_ENC_TYPE_EXT;
mutex_unlock(&solo_enc->enable_lock);
return 0;
}
@ -1058,80 +897,6 @@ static int solo_enc_get_fmt_cap(struct file *file, void *priv,
return 0;
}
static int solo_enc_reqbufs(struct file *file, void *priv,
struct v4l2_requestbuffers *req)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
return videobuf_reqbufs(&solo_enc->vidq, req);
}
static int solo_enc_querybuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
return videobuf_querybuf(&solo_enc->vidq, buf);
}
static int solo_enc_qbuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
return videobuf_qbuf(&solo_enc->vidq, buf);
}
static int solo_enc_dqbuf(struct file *file, void *priv,
struct v4l2_buffer *buf)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
struct solo_videobuf *svb;
int ret;
/* Make sure the encoder is on */
ret = solo_enc_on(solo_enc);
if (ret)
return ret;
ret = videobuf_dqbuf(&solo_enc->vidq, buf, file->f_flags & O_NONBLOCK);
if (ret)
return ret;
/* Copy over the flags */
svb = (struct solo_videobuf *)solo_enc->vidq.bufs[buf->index];
buf->flags |= svb->flags;
return 0;
}
static int solo_enc_streamon(struct file *file, void *priv,
enum v4l2_buf_type i)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
return videobuf_streamon(&solo_enc->vidq);
}
static int solo_enc_streamoff(struct file *file, void *priv,
enum v4l2_buf_type i)
{
struct solo_enc_dev *solo_enc = video_drvdata(file);
int ret;
if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
return -EINVAL;
ret = videobuf_streamoff(&solo_enc->vidq);
if (!ret)
solo_enc_off(solo_enc);
return ret;
}
static int solo_enc_s_std(struct file *file, void *priv, v4l2_std_id i)
{
return 0;
@ -1220,12 +985,8 @@ static int solo_s_parm(struct file *file, void *priv,
struct solo_dev *solo_dev = solo_enc->solo_dev;
struct v4l2_captureparm *cp = &sp->parm.capture;
mutex_lock(&solo_enc->enable_lock);
if (atomic_read(&solo_enc->mpeg_readers) > 0) {
mutex_unlock(&solo_enc->enable_lock);
if (vb2_is_streaming(&solo_enc->vidq))
return -EBUSY;
}
if ((cp->timeperframe.numerator == 0) ||
(cp->timeperframe.denominator == 0)) {
@ -1246,9 +1007,6 @@ static int solo_s_parm(struct file *file, void *priv,
cp->readbuffers = 2;
solo_update_mode(solo_enc);
mutex_unlock(&solo_enc->enable_lock);
return 0;
}
@ -1297,10 +1055,8 @@ static int solo_s_ctrl(struct v4l2_ctrl *ctrl)
solo_motion_toggle(solo_enc, ctrl->val);
return 0;
case V4L2_CID_OSD_TEXT:
mutex_lock(&solo_enc->enable_lock);
strcpy(solo_enc->osd_text, ctrl->string);
err = solo_osd_print(solo_enc);
mutex_unlock(&solo_enc->enable_lock);
return err;
default:
return -EINVAL;
@ -1311,12 +1067,12 @@ static int solo_s_ctrl(struct v4l2_ctrl *ctrl)
static const struct v4l2_file_operations solo_enc_fops = {
.owner = THIS_MODULE,
.open = solo_enc_open,
.release = solo_enc_release,
.read = solo_enc_read,
.poll = solo_enc_poll,
.mmap = solo_enc_mmap,
.ioctl = video_ioctl2,
.open = v4l2_fh_open,
.release = vb2_fop_release,
.read = vb2_fop_read,
.poll = vb2_fop_poll,
.mmap = vb2_fop_mmap,
.unlocked_ioctl = video_ioctl2,
};
static const struct v4l2_ioctl_ops solo_enc_ioctl_ops = {
@ -1332,12 +1088,12 @@ static const struct v4l2_ioctl_ops solo_enc_ioctl_ops = {
.vidioc_s_fmt_vid_cap = solo_enc_set_fmt_cap,
.vidioc_g_fmt_vid_cap = solo_enc_get_fmt_cap,
/* Streaming I/O */
.vidioc_reqbufs = solo_enc_reqbufs,
.vidioc_querybuf = solo_enc_querybuf,
.vidioc_qbuf = solo_enc_qbuf,
.vidioc_dqbuf = solo_enc_dqbuf,
.vidioc_streamon = solo_enc_streamon,
.vidioc_streamoff = solo_enc_streamoff,
.vidioc_reqbufs = vb2_ioctl_reqbufs,
.vidioc_querybuf = vb2_ioctl_querybuf,
.vidioc_qbuf = vb2_ioctl_qbuf,
.vidioc_dqbuf = vb2_ioctl_dqbuf,
.vidioc_streamon = vb2_ioctl_streamon,
.vidioc_streamoff = vb2_ioctl_streamoff,
/* Frame size and interval */
.vidioc_enum_framesizes = solo_enum_framesizes,
.vidioc_enum_frameintervals = solo_enum_frameintervals,
@ -1434,29 +1190,36 @@ static struct solo_enc_dev *solo_enc_alloc(struct solo_dev *solo_dev,
solo_enc->solo_dev = solo_dev;
solo_enc->ch = ch;
mutex_init(&solo_enc->lock);
spin_lock_init(&solo_enc->av_lock);
INIT_LIST_HEAD(&solo_enc->vidq_active);
solo_enc->fmt = V4L2_PIX_FMT_MPEG;
solo_enc->type = SOLO_ENC_TYPE_STD;
atomic_set(&solo_enc->readers, 0);
solo_enc->qp = SOLO_DEFAULT_QP;
solo_enc->gop = solo_dev->fps;
solo_enc->interval = 1;
solo_enc->mode = SOLO_ENC_MODE_CIF;
solo_enc->motion_thresh = SOLO_DEF_MOT_THRESH;
solo_enc->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
solo_enc->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
solo_enc->vidq.ops = &solo_enc_video_qops;
solo_enc->vidq.mem_ops = &vb2_dma_sg_memops;
solo_enc->vidq.drv_priv = solo_enc;
solo_enc->vidq.gfp_flags = __GFP_DMA32;
solo_enc->vidq.timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
solo_enc->vidq.buf_struct_size = sizeof(struct solo_vb2_buf);
solo_enc->vidq.lock = &solo_enc->lock;
ret = vb2_queue_init(&solo_enc->vidq);
if (ret)
goto hdl_free;
spin_lock(&solo_enc->av_lock);
solo_update_mode(solo_enc);
spin_unlock(&solo_enc->av_lock);
mutex_init(&solo_enc->enable_lock);
spin_lock_init(&solo_enc->motion_lock);
atomic_set(&solo_enc->readers, 0);
atomic_set(&solo_enc->mpeg_readers, 0);
/* Initialize this per encoder */
solo_enc->jpeg_len = sizeof(jpeg_header);
memcpy(solo_enc->jpeg_header, jpeg_header, solo_enc->jpeg_len);
@ -1469,14 +1232,6 @@ static struct solo_enc_dev *solo_enc_alloc(struct solo_dev *solo_dev,
if (solo_enc->desc_items == NULL)
goto hdl_free;
videobuf_queue_sg_init(&solo_enc->vidq, &solo_enc_video_qops,
&solo_dev->pdev->dev,
&solo_enc->av_lock,
V4L2_BUF_TYPE_VIDEO_CAPTURE,
V4L2_FIELD_INTERLACED,
sizeof(struct solo_videobuf),
solo_enc, NULL);
solo_enc->vfd = video_device_alloc();
if (!solo_enc->vfd)
goto pci_free;
@ -1484,6 +1239,8 @@ static struct solo_enc_dev *solo_enc_alloc(struct solo_dev *solo_dev,
*solo_enc->vfd = solo_enc_template;
solo_enc->vfd->v4l2_dev = &solo_dev->v4l2_dev;
solo_enc->vfd->ctrl_handler = hdl;
solo_enc->vfd->queue = &solo_enc->vidq;
solo_enc->vfd->lock = &solo_enc->lock;
set_bit(V4L2_FL_USE_FH_PRIO, &solo_enc->vfd->flags);
video_set_drvdata(solo_enc->vfd, solo_enc);
ret = video_register_device(solo_enc->vfd, VFL_TYPE_GRABBER, nr);