LXR linux/include/media/videobuf-core.h

   1/*
   2 * generic helper functions for handling video4linux capture buffers
   3 *
   4 * (c) 2007 Mauro Carvalho Chehab, <mchehab@infradead.org>
   5 *
   6 * Highly based on video-buf written originally by:
   7 * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org>
   8 * (c) 2006 Mauro Carvalho Chehab, <mchehab@infradead.org>
   9 * (c) 2006 Ted Walther and John Sokol
  10 *
  11 * This program is free software; you can redistribute it and/or modify
  12 * it under the terms of the GNU General Public License as published by
  13 * the Free Software Foundation; either version 2
  14 */
  15
  16#ifndef _VIDEOBUF_CORE_H
  17#define _VIDEOBUF_CORE_H
  18
  19#include <linux/poll.h>
  20#ifdef CONFIG_VIDEO_V4L1_COMPAT
  21#define __MIN_V4L1
  22#include <linux/videodev.h>
  23#endif
  24#include <linux/videodev2.h>
  25
  26#define UNSET (-1U)
  27
  28
  29struct videobuf_buffer;
  30struct videobuf_queue;
  31
  32/* --------------------------------------------------------------------- */
  33
  34/*
  35 * A small set of helper functions to manage video4linux buffers.
  36 *
  37 * struct videobuf_buffer holds the data structures used by the helper
  38 * functions, additionally some commonly used fields for v4l buffers
  39 * (width, height, lists, waitqueue) are in there.  That struct should
  40 * be used as first element in the drivers buffer struct.
  41 *
  42 * about the mmap helpers (videobuf_mmap_*):
  43 *
  44 * The mmaper function allows to map any subset of contingous buffers.
  45 * This includes one mmap() call for all buffers (which the original
  46 * video4linux API uses) as well as one mmap() for every single buffer
  47 * (which v4l2 uses).
  48 *
  49 * If there is a valid mapping for a buffer, buffer->baddr/bsize holds
  50 * userspace address + size which can be feeded into the
  51 * videobuf_dma_init_user function listed above.
  52 *
  53 */
  54
  55struct videobuf_mapping {
  56        unsigned int count;
  57        unsigned long start;
  58        unsigned long end;
  59        struct videobuf_queue *q;
  60};
  61
  62enum videobuf_state {
  63        VIDEOBUF_NEEDS_INIT = 0,
  64        VIDEOBUF_PREPARED   = 1,
  65        VIDEOBUF_QUEUED     = 2,
  66        VIDEOBUF_ACTIVE     = 3,
  67        VIDEOBUF_DONE       = 4,
  68        VIDEOBUF_ERROR      = 5,
  69        VIDEOBUF_IDLE       = 6,
  70};
  71
  72struct videobuf_buffer {
  73        unsigned int            i;
  74        u32                     magic;
  75
  76        /* info about the buffer */
  77        unsigned int            width;
  78        unsigned int            height;
  79        unsigned int            bytesperline; /* use only if != 0 */
  80        unsigned long           size;
  81        unsigned int            input;
  82        enum v4l2_field         field;
  83        enum videobuf_state     state;
  84        struct list_head        stream;  /* QBUF/DQBUF list */
  85
  86        /* touched by irq handler */
  87        struct list_head        queue;
  88        wait_queue_head_t       done;
  89        unsigned int            field_count;
  90        struct timeval          ts;
  91
  92        /* Memory type */
  93        enum v4l2_memory        memory;
  94
  95        /* buffer size */
  96        size_t                  bsize;
  97
  98        /* buffer offset (mmap + overlay) */
  99        size_t                  boff;
 100
 101        /* buffer addr (userland ptr!) */
 102        unsigned long           baddr;
 103
 104        /* for mmap'ed buffers */
 105        struct videobuf_mapping *map;
 106
 107        /* Private pointer to allow specific methods to store their data */
 108        int                     privsize;
 109        void                    *priv;
 110};
 111
 112struct videobuf_queue_ops {
 113        int (*buf_setup)(struct videobuf_queue *q,
 114                         unsigned int *count, unsigned int *size);
 115        int (*buf_prepare)(struct videobuf_queue *q,
 116                           struct videobuf_buffer *vb,
 117                           enum v4l2_field field);
 118        void (*buf_queue)(struct videobuf_queue *q,
 119                          struct videobuf_buffer *vb);
 120        void (*buf_release)(struct videobuf_queue *q,
 121                            struct videobuf_buffer *vb);
 122};
 123
 124#define MAGIC_QTYPE_OPS 0x12261003
 125
 126/* Helper operations - device type dependent */
 127struct videobuf_qtype_ops {
 128        u32                     magic;
 129
 130        void *(*alloc)          (size_t size);
 131        void *(*vmalloc)        (struct videobuf_buffer *buf);
 132        int (*iolock)           (struct videobuf_queue* q,
 133                                 struct videobuf_buffer *vb,
 134                                 struct v4l2_framebuffer *fbuf);
 135        int (*mmap)             (struct videobuf_queue *q,
 136                                 unsigned int *count,
 137                                 unsigned int *size,
 138                                 enum v4l2_memory memory);
 139        int (*sync)             (struct videobuf_queue* q,
 140                                 struct videobuf_buffer *buf);
 141        int (*video_copy_to_user)(struct videobuf_queue *q,
 142                                 char __user *data,
 143                                 size_t count,
 144                                 int nonblocking);
 145        int (*copy_stream)      (struct videobuf_queue *q,
 146                                 char __user *data,
 147                                 size_t count,
 148                                 size_t pos,
 149                                 int vbihack,
 150                                 int nonblocking);
 151        int (*mmap_free)        (struct videobuf_queue *q);
 152        int (*mmap_mapper)      (struct videobuf_queue *q,
 153                                struct vm_area_struct *vma);
 154};
 155
 156struct videobuf_queue {
 157        struct mutex               vb_lock;
 158        spinlock_t                 *irqlock;
 159        struct device              *dev;
 160
 161        wait_queue_head_t          wait; /* wait if queue is empty */
 162
 163        enum v4l2_buf_type         type;
 164        unsigned int               inputs; /* for V4L2_BUF_FLAG_INPUT */
 165        unsigned int               msize;
 166        enum v4l2_field            field;
 167        enum v4l2_field            last;   /* for field=V4L2_FIELD_ALTERNATE */
 168        struct videobuf_buffer     *bufs[VIDEO_MAX_FRAME];
 169        struct videobuf_queue_ops  *ops;
 170        struct videobuf_qtype_ops  *int_ops;
 171
 172        unsigned int               streaming:1;
 173        unsigned int               reading:1;
 174        unsigned int               is_mmapped:1;
 175
 176        /* capture via mmap() + ioctl(QBUF/DQBUF) */
 177        struct list_head           stream;
 178
 179        /* capture via read() */
 180        unsigned int               read_off;
 181        struct videobuf_buffer     *read_buf;
 182
 183        /* driver private data */
 184        void                       *priv_data;
 185};
 186
 187int videobuf_waiton(struct videobuf_buffer *vb, int non_blocking, int intr);
 188int videobuf_iolock(struct videobuf_queue* q, struct videobuf_buffer *vb,
 189                struct v4l2_framebuffer *fbuf);
 190
 191void *videobuf_alloc(struct videobuf_queue* q);
 192
 193/* Used on videobuf-dvb */
 194void *videobuf_queue_to_vmalloc (struct videobuf_queue* q,
 195                                 struct videobuf_buffer *buf);
 196
 197void videobuf_queue_core_init(struct videobuf_queue *q,
 198                         struct videobuf_queue_ops *ops,
 199                         struct device *dev,
 200                         spinlock_t *irqlock,
 201                         enum v4l2_buf_type type,
 202                         enum v4l2_field field,
 203                         unsigned int msize,
 204                         void *priv,
 205                         struct videobuf_qtype_ops *int_ops);
 206int  videobuf_queue_is_busy(struct videobuf_queue *q);
 207void videobuf_queue_cancel(struct videobuf_queue *q);
 208
 209enum v4l2_field videobuf_next_field(struct videobuf_queue *q);
 210int videobuf_reqbufs(struct videobuf_queue *q,
 211                     struct v4l2_requestbuffers *req);
 212int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b);
 213int videobuf_qbuf(struct videobuf_queue *q,
 214                  struct v4l2_buffer *b);
 215int videobuf_dqbuf(struct videobuf_queue *q,
 216                   struct v4l2_buffer *b, int nonblocking);
 217#ifdef CONFIG_VIDEO_V4L1_COMPAT
 218int videobuf_cgmbuf(struct videobuf_queue *q,
 219                    struct video_mbuf *mbuf, int count);
 220#endif
 221int videobuf_streamon(struct videobuf_queue *q);
 222int videobuf_streamoff(struct videobuf_queue *q);
 223
 224void videobuf_stop(struct videobuf_queue *q);
 225
 226int videobuf_read_start(struct videobuf_queue *q);
 227void videobuf_read_stop(struct videobuf_queue *q);
 228ssize_t videobuf_read_stream(struct videobuf_queue *q,
 229                             char __user *data, size_t count, loff_t *ppos,
 230                             int vbihack, int nonblocking);
 231ssize_t videobuf_read_one(struct videobuf_queue *q,
 232                          char __user *data, size_t count, loff_t *ppos,
 233                          int nonblocking);
 234unsigned int videobuf_poll_stream(struct file *file,
 235                                  struct videobuf_queue *q,
 236                                  poll_table *wait);
 237
 238int videobuf_mmap_setup(struct videobuf_queue *q,
 239                        unsigned int bcount, unsigned int bsize,
 240                        enum v4l2_memory memory);
 241int __videobuf_mmap_setup(struct videobuf_queue *q,
 242                        unsigned int bcount, unsigned int bsize,
 243                        enum v4l2_memory memory);
 244int videobuf_mmap_free(struct videobuf_queue *q);
 245int videobuf_mmap_mapper(struct videobuf_queue *q,
 246                         struct vm_area_struct *vma);
 247
 248#endif
 249