videobuf2-core.h

Go to the documentation of this file.

/*
 * videobuf2-core.h - V4L2 driver helper framework
 *
 * Copyright (C) 2010 Samsung Electronics
 *
 * Author: Pawel Osciak <[email protected]>
 *
 * 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.
 */
#ifndef _MEDIA_VIDEOBUF2_CORE_H
#define _MEDIA_VIDEOBUF2_CORE_H

#include <linux/mm_types.h>
#include <linux/mutex.h>
#include <linux/poll.h>
#include <linux/videodev2.h>

struct vb2_alloc_ctx;
struct vb2_fileio_data;

struct vb2_mem_ops {
    void        *(*alloc)(void *alloc_ctx, unsigned long size);
    void        (*put)(void *buf_priv);

    void        *(*get_userptr)(void *alloc_ctx, unsigned long vaddr,
                    unsigned long size, int write);
    void        (*put_userptr)(void *buf_priv);

    void        *(*vaddr)(void *buf_priv);
    void        *(*cookie)(void *buf_priv);

    unsigned int    (*num_users)(void *buf_priv);

    int     (*mmap)(void *buf_priv, struct vm_area_struct *vma);
};

struct vb2_plane {
    void            *mem_priv;
};

enum vb2_io_modes {
    VB2_MMAP    = (1 << 0),
    VB2_USERPTR = (1 << 1),
    VB2_READ    = (1 << 2),
    VB2_WRITE   = (1 << 3),
};

enum vb2_fileio_flags {
    VB2_FILEIO_READ_ONCE        = (1 << 0),
    VB2_FILEIO_WRITE_IMMEDIATELY    = (1 << 1),
};

enum vb2_buffer_state {
    VB2_BUF_STATE_DEQUEUED,
    VB2_BUF_STATE_PREPARED,
    VB2_BUF_STATE_QUEUED,
    VB2_BUF_STATE_ACTIVE,
    VB2_BUF_STATE_DONE,
    VB2_BUF_STATE_ERROR,
};

struct vb2_queue;

struct vb2_buffer {
    struct v4l2_buffer  v4l2_buf;
    struct v4l2_plane   v4l2_planes[VIDEO_MAX_PLANES];

    struct vb2_queue    *vb2_queue;

    unsigned int        num_planes;

/* Private: internal use only */
    enum vb2_buffer_state   state;

    struct list_head    queued_entry;
    struct list_head    done_entry;

    struct vb2_plane    planes[VIDEO_MAX_PLANES];
};

struct vb2_ops {
    int (*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[]);

    void (*wait_prepare)(struct vb2_queue *q);
    void (*wait_finish)(struct vb2_queue *q);

    int (*buf_init)(struct vb2_buffer *vb);
    int (*buf_prepare)(struct vb2_buffer *vb);
    int (*buf_finish)(struct vb2_buffer *vb);
    void (*buf_cleanup)(struct vb2_buffer *vb);

    int (*start_streaming)(struct vb2_queue *q, unsigned int count);
    int (*stop_streaming)(struct vb2_queue *q);

    void (*buf_queue)(struct vb2_buffer *vb);
};

struct v4l2_fh;

struct vb2_queue {
    enum v4l2_buf_type      type;
    unsigned int            io_modes;
    unsigned int            io_flags;
    struct mutex            *lock;
    struct v4l2_fh          *owner;

    const struct vb2_ops        *ops;
    const struct vb2_mem_ops    *mem_ops;
    void                *drv_priv;
    unsigned int            buf_struct_size;

/* private: internal use only */
    enum v4l2_memory        memory;
    struct vb2_buffer       *bufs[VIDEO_MAX_FRAME];
    unsigned int            num_buffers;

    struct list_head        queued_list;

    atomic_t            queued_count;
    struct list_head        done_list;
    spinlock_t          done_lock;
    wait_queue_head_t       done_wq;

    void                *alloc_ctx[VIDEO_MAX_PLANES];
    unsigned int            plane_sizes[VIDEO_MAX_PLANES];

    unsigned int            streaming:1;

    struct vb2_fileio_data      *fileio;
};

void *vb2_plane_vaddr(struct vb2_buffer *vb, unsigned int plane_no);
void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no);

void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state);
int vb2_wait_for_all_buffers(struct vb2_queue *q);

int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b);
int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req);

int vb2_create_bufs(struct vb2_queue *q, struct v4l2_create_buffers *create);
int vb2_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b);

int __must_check vb2_queue_init(struct vb2_queue *q);

void vb2_queue_release(struct vb2_queue *q);

int vb2_qbuf(struct vb2_queue *q, struct v4l2_buffer *b);
int vb2_dqbuf(struct vb2_queue *q, struct v4l2_buffer *b, bool nonblocking);

int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type);
int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type);

int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma);
#ifndef CONFIG_MMU
unsigned long vb2_get_unmapped_area(struct vb2_queue *q,
                    unsigned long addr,
                    unsigned long len,
                    unsigned long pgoff,
                    unsigned long flags);
#endif
unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait);
size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count,
        loff_t *ppos, int nonblock);
size_t vb2_write(struct vb2_queue *q, char __user *data, size_t count,
        loff_t *ppos, int nonblock);

static inline bool vb2_is_streaming(struct vb2_queue *q)
{
    return q->streaming;
}

static inline bool vb2_is_busy(struct vb2_queue *q)
{
    return (q->num_buffers > 0);
}

static inline void *vb2_get_drv_priv(struct vb2_queue *q)
{
    return q->drv_priv;
}

static inline void vb2_set_plane_payload(struct vb2_buffer *vb,
                 unsigned int plane_no, unsigned long size)
{
    if (plane_no < vb->num_planes)
        vb->v4l2_planes[plane_no].bytesused = size;
}

static inline unsigned long vb2_get_plane_payload(struct vb2_buffer *vb,
                 unsigned int plane_no)
{
    if (plane_no < vb->num_planes)
        return vb->v4l2_planes[plane_no].bytesused;
    return 0;
}

static inline unsigned long
vb2_plane_size(struct vb2_buffer *vb, unsigned int plane_no)
{
    if (plane_no < vb->num_planes)
        return vb->v4l2_planes[plane_no].length;
    return 0;
}

/*
 * The following functions are not part of the vb2 core API, but are simple
 * helper functions that you can use in your struct v4l2_file_operations,
 * struct v4l2_ioctl_ops and struct vb2_ops. They will serialize if vb2_queue->lock
 * or video_device->lock is set, and they will set and test vb2_queue->owner
 * to check if the calling filehandle is permitted to do the queuing operation.
 */

/* struct v4l2_ioctl_ops helpers */

int vb2_ioctl_reqbufs(struct file *file, void *priv,
              struct v4l2_requestbuffers *p);
int vb2_ioctl_create_bufs(struct file *file, void *priv,
              struct v4l2_create_buffers *p);
int vb2_ioctl_prepare_buf(struct file *file, void *priv,
              struct v4l2_buffer *p);
int vb2_ioctl_querybuf(struct file *file, void *priv, struct v4l2_buffer *p);
int vb2_ioctl_qbuf(struct file *file, void *priv, struct v4l2_buffer *p);
int vb2_ioctl_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p);
int vb2_ioctl_streamon(struct file *file, void *priv, enum v4l2_buf_type i);
int vb2_ioctl_streamoff(struct file *file, void *priv, enum v4l2_buf_type i);

/* struct v4l2_file_operations helpers */

int vb2_fop_mmap(struct file *file, struct vm_area_struct *vma);
int vb2_fop_release(struct file *file);
ssize_t vb2_fop_write(struct file *file, char __user *buf,
        size_t count, loff_t *ppos);
ssize_t vb2_fop_read(struct file *file, char __user *buf,
        size_t count, loff_t *ppos);
unsigned int vb2_fop_poll(struct file *file, poll_table *wait);
#ifndef CONFIG_MMU
unsigned long vb2_fop_get_unmapped_area(struct file *file, unsigned long addr,
        unsigned long len, unsigned long pgoff, unsigned long flags);
#endif

/* struct vb2_ops helpers, only use if vq->lock is non-NULL. */

void vb2_ops_wait_prepare(struct vb2_queue *vq);
void vb2_ops_wait_finish(struct vb2_queue *vq);

#endif /* _MEDIA_VIDEOBUF2_CORE_H */