2 * generic helper functions for handling video4linux capture buffers
4 * (c) 2007 Mauro Carvalho Chehab, <mchehab@infradead.org>
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
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
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
20 #include <linux/sched.h>
21 #include <linux/slab.h>
22 #include <linux/interrupt.h>
24 #include <media/videobuf-core.h>
26 #define MAGIC_BUFFER 0x20070728
27 #define MAGIC_CHECK(is, should) do { \
28 if (unlikely((is) != (should))) { \
29 printk(KERN_ERR "magic mismatch: %x (expected %x)\n", is, should); \
33 module_param(debug
, int, 0644);
35 MODULE_DESCRIPTION("helper module to manage video4linux buffers");
36 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
37 MODULE_LICENSE("GPL");
39 #define dprintk(level, fmt, arg...) do { \
41 printk(KERN_DEBUG "vbuf: " fmt , ## arg); } while (0)
43 /* --------------------------------------------------------------------- */
45 #define CALL(q, f, arg...) \
46 ((q->int_ops->f) ? q->int_ops->f(arg) : 0)
48 void *videobuf_alloc(struct videobuf_queue
*q
)
50 struct videobuf_buffer
*vb
;
52 BUG_ON(q
->msize
< sizeof(*vb
));
54 if (!q
->int_ops
|| !q
->int_ops
->alloc
) {
55 printk(KERN_ERR
"No specific ops defined!\n");
59 vb
= q
->int_ops
->alloc(q
->msize
);
62 init_waitqueue_head(&vb
->done
);
63 vb
->magic
= MAGIC_BUFFER
;
69 #define WAITON_CONDITION (vb->state != VIDEOBUF_ACTIVE &&\
70 vb->state != VIDEOBUF_QUEUED)
71 int videobuf_waiton(struct videobuf_buffer
*vb
, int non_blocking
, int intr
)
73 MAGIC_CHECK(vb
->magic
, MAGIC_BUFFER
);
83 return wait_event_interruptible(vb
->done
, WAITON_CONDITION
);
85 wait_event(vb
->done
, WAITON_CONDITION
);
90 int videobuf_iolock(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
91 struct v4l2_framebuffer
*fbuf
)
93 MAGIC_CHECK(vb
->magic
, MAGIC_BUFFER
);
94 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
96 return CALL(q
, iolock
, q
, vb
, fbuf
);
99 void *videobuf_queue_to_vmalloc (struct videobuf_queue
*q
,
100 struct videobuf_buffer
*buf
)
102 if (q
->int_ops
->vmalloc
)
103 return q
->int_ops
->vmalloc(buf
);
107 EXPORT_SYMBOL_GPL(videobuf_queue_to_vmalloc
);
109 /* --------------------------------------------------------------------- */
112 void videobuf_queue_core_init(struct videobuf_queue
*q
,
113 const struct videobuf_queue_ops
*ops
,
116 enum v4l2_buf_type type
,
117 enum v4l2_field field
,
120 struct videobuf_qtype_ops
*int_ops
)
123 memset(q
, 0, sizeof(*q
));
124 q
->irqlock
= irqlock
;
131 q
->int_ops
= int_ops
;
133 /* All buffer operations are mandatory */
134 BUG_ON(!q
->ops
->buf_setup
);
135 BUG_ON(!q
->ops
->buf_prepare
);
136 BUG_ON(!q
->ops
->buf_queue
);
137 BUG_ON(!q
->ops
->buf_release
);
139 /* Lock is mandatory for queue_cancel to work */
142 /* Having implementations for abstract methods are mandatory */
145 mutex_init(&q
->vb_lock
);
146 init_waitqueue_head(&q
->wait
);
147 INIT_LIST_HEAD(&q
->stream
);
150 /* Locking: Only usage in bttv unsafe find way to remove */
151 int videobuf_queue_is_busy(struct videobuf_queue
*q
)
155 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
158 dprintk(1, "busy: streaming active\n");
162 dprintk(1, "busy: pending read #1\n");
166 dprintk(1, "busy: pending read #2\n");
169 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
170 if (NULL
== q
->bufs
[i
])
172 if (q
->bufs
[i
]->map
) {
173 dprintk(1, "busy: buffer #%d mapped\n", i
);
176 if (q
->bufs
[i
]->state
== VIDEOBUF_QUEUED
) {
177 dprintk(1, "busy: buffer #%d queued\n", i
);
180 if (q
->bufs
[i
]->state
== VIDEOBUF_ACTIVE
) {
181 dprintk(1, "busy: buffer #%d avtive\n", i
);
188 /* Locking: Caller holds q->vb_lock */
189 void videobuf_queue_cancel(struct videobuf_queue
*q
)
191 unsigned long flags
= 0;
196 wake_up_interruptible_sync(&q
->wait
);
198 /* remove queued buffers from list */
199 spin_lock_irqsave(q
->irqlock
, flags
);
200 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
201 if (NULL
== q
->bufs
[i
])
203 if (q
->bufs
[i
]->state
== VIDEOBUF_QUEUED
) {
204 list_del(&q
->bufs
[i
]->queue
);
205 q
->bufs
[i
]->state
= VIDEOBUF_ERROR
;
206 wake_up_all(&q
->bufs
[i
]->done
);
209 spin_unlock_irqrestore(q
->irqlock
, flags
);
211 /* free all buffers + clear queue */
212 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
213 if (NULL
== q
->bufs
[i
])
215 q
->ops
->buf_release(q
, q
->bufs
[i
]);
217 INIT_LIST_HEAD(&q
->stream
);
220 /* --------------------------------------------------------------------- */
222 /* Locking: Caller holds q->vb_lock */
223 enum v4l2_field
videobuf_next_field(struct videobuf_queue
*q
)
225 enum v4l2_field field
= q
->field
;
227 BUG_ON(V4L2_FIELD_ANY
== field
);
229 if (V4L2_FIELD_ALTERNATE
== field
) {
230 if (V4L2_FIELD_TOP
== q
->last
) {
231 field
= V4L2_FIELD_BOTTOM
;
232 q
->last
= V4L2_FIELD_BOTTOM
;
234 field
= V4L2_FIELD_TOP
;
235 q
->last
= V4L2_FIELD_TOP
;
241 /* Locking: Caller holds q->vb_lock */
242 static void videobuf_status(struct videobuf_queue
*q
, struct v4l2_buffer
*b
,
243 struct videobuf_buffer
*vb
, enum v4l2_buf_type type
)
245 MAGIC_CHECK(vb
->magic
, MAGIC_BUFFER
);
246 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
251 b
->memory
= vb
->memory
;
253 case V4L2_MEMORY_MMAP
:
254 b
->m
.offset
= vb
->boff
;
255 b
->length
= vb
->bsize
;
257 case V4L2_MEMORY_USERPTR
:
258 b
->m
.userptr
= vb
->baddr
;
259 b
->length
= vb
->bsize
;
261 case V4L2_MEMORY_OVERLAY
:
262 b
->m
.offset
= vb
->boff
;
268 b
->flags
|= V4L2_BUF_FLAG_MAPPED
;
271 case VIDEOBUF_PREPARED
:
272 case VIDEOBUF_QUEUED
:
273 case VIDEOBUF_ACTIVE
:
274 b
->flags
|= V4L2_BUF_FLAG_QUEUED
;
278 b
->flags
|= V4L2_BUF_FLAG_DONE
;
280 case VIDEOBUF_NEEDS_INIT
:
286 if (vb
->input
!= UNSET
) {
287 b
->flags
|= V4L2_BUF_FLAG_INPUT
;
288 b
->input
= vb
->input
;
291 b
->field
= vb
->field
;
292 b
->timestamp
= vb
->ts
;
293 b
->bytesused
= vb
->size
;
294 b
->sequence
= vb
->field_count
>> 1;
297 /* Locking: Caller holds q->vb_lock */
298 static int __videobuf_mmap_free(struct videobuf_queue
*q
)
306 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
309 rc
= CALL(q
, mmap_free
, q
);
316 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
317 if (NULL
== q
->bufs
[i
])
319 q
->ops
->buf_release(q
, q
->bufs
[i
]);
327 int videobuf_mmap_free(struct videobuf_queue
*q
)
330 mutex_lock(&q
->vb_lock
);
331 ret
= __videobuf_mmap_free(q
);
332 mutex_unlock(&q
->vb_lock
);
336 /* Locking: Caller holds q->vb_lock */
337 int __videobuf_mmap_setup(struct videobuf_queue
*q
,
338 unsigned int bcount
, unsigned int bsize
,
339 enum v4l2_memory memory
)
344 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
346 err
= __videobuf_mmap_free(q
);
350 /* Allocate and initialize buffers */
351 for (i
= 0; i
< bcount
; i
++) {
352 q
->bufs
[i
] = videobuf_alloc(q
);
354 if (q
->bufs
[i
] == NULL
)
358 q
->bufs
[i
]->input
= UNSET
;
359 q
->bufs
[i
]->memory
= memory
;
360 q
->bufs
[i
]->bsize
= bsize
;
362 case V4L2_MEMORY_MMAP
:
363 q
->bufs
[i
]->boff
= PAGE_ALIGN(bsize
) * i
;
365 case V4L2_MEMORY_USERPTR
:
366 case V4L2_MEMORY_OVERLAY
:
375 dprintk(1, "mmap setup: %d buffers, %d bytes each\n",
381 int videobuf_mmap_setup(struct videobuf_queue
*q
,
382 unsigned int bcount
, unsigned int bsize
,
383 enum v4l2_memory memory
)
386 mutex_lock(&q
->vb_lock
);
387 ret
= __videobuf_mmap_setup(q
, bcount
, bsize
, memory
);
388 mutex_unlock(&q
->vb_lock
);
392 int videobuf_reqbufs(struct videobuf_queue
*q
,
393 struct v4l2_requestbuffers
*req
)
395 unsigned int size
, count
;
398 if (req
->count
< 1) {
399 dprintk(1, "reqbufs: count invalid (%d)\n", req
->count
);
403 if (req
->memory
!= V4L2_MEMORY_MMAP
&&
404 req
->memory
!= V4L2_MEMORY_USERPTR
&&
405 req
->memory
!= V4L2_MEMORY_OVERLAY
) {
406 dprintk(1, "reqbufs: memory type invalid\n");
410 mutex_lock(&q
->vb_lock
);
411 if (req
->type
!= q
->type
) {
412 dprintk(1, "reqbufs: queue type invalid\n");
418 dprintk(1, "reqbufs: streaming already exists\n");
422 if (!list_empty(&q
->stream
)) {
423 dprintk(1, "reqbufs: stream running\n");
429 if (count
> VIDEO_MAX_FRAME
)
430 count
= VIDEO_MAX_FRAME
;
432 q
->ops
->buf_setup(q
, &count
, &size
);
433 dprintk(1, "reqbufs: bufs=%d, size=0x%x [%d pages total]\n",
434 count
, size
, (count
*PAGE_ALIGN(size
))>>PAGE_SHIFT
);
436 retval
= __videobuf_mmap_setup(q
, count
, size
, req
->memory
);
438 dprintk(1, "reqbufs: mmap setup returned %d\n", retval
);
446 mutex_unlock(&q
->vb_lock
);
450 int videobuf_querybuf(struct videobuf_queue
*q
, struct v4l2_buffer
*b
)
454 mutex_lock(&q
->vb_lock
);
455 if (unlikely(b
->type
!= q
->type
)) {
456 dprintk(1, "querybuf: Wrong type.\n");
459 if (unlikely(b
->index
>= VIDEO_MAX_FRAME
)) {
460 dprintk(1, "querybuf: index out of range.\n");
463 if (unlikely(NULL
== q
->bufs
[b
->index
])) {
464 dprintk(1, "querybuf: buffer is null.\n");
468 videobuf_status(q
, b
, q
->bufs
[b
->index
], q
->type
);
472 mutex_unlock(&q
->vb_lock
);
476 int videobuf_qbuf(struct videobuf_queue
*q
,
477 struct v4l2_buffer
*b
)
479 struct videobuf_buffer
*buf
;
480 enum v4l2_field field
;
481 unsigned long flags
= 0;
484 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
486 if (b
->memory
== V4L2_MEMORY_MMAP
)
487 down_read(¤t
->mm
->mmap_sem
);
489 mutex_lock(&q
->vb_lock
);
492 dprintk(1, "qbuf: Reading running...\n");
496 if (b
->type
!= q
->type
) {
497 dprintk(1, "qbuf: Wrong type.\n");
500 if (b
->index
>= VIDEO_MAX_FRAME
) {
501 dprintk(1, "qbuf: index out of range.\n");
504 buf
= q
->bufs
[b
->index
];
506 dprintk(1, "qbuf: buffer is null.\n");
509 MAGIC_CHECK(buf
->magic
, MAGIC_BUFFER
);
510 if (buf
->memory
!= b
->memory
) {
511 dprintk(1, "qbuf: memory type is wrong.\n");
514 if (buf
->state
!= VIDEOBUF_NEEDS_INIT
&& buf
->state
!= VIDEOBUF_IDLE
) {
515 dprintk(1, "qbuf: buffer is already queued or active.\n");
519 if (b
->flags
& V4L2_BUF_FLAG_INPUT
) {
520 if (b
->input
>= q
->inputs
) {
521 dprintk(1, "qbuf: wrong input.\n");
524 buf
->input
= b
->input
;
530 case V4L2_MEMORY_MMAP
:
531 if (0 == buf
->baddr
) {
532 dprintk(1, "qbuf: mmap requested "
533 "but buffer addr is zero!\n");
537 case V4L2_MEMORY_USERPTR
:
538 if (b
->length
< buf
->bsize
) {
539 dprintk(1, "qbuf: buffer length is not enough\n");
542 if (VIDEOBUF_NEEDS_INIT
!= buf
->state
&&
543 buf
->baddr
!= b
->m
.userptr
)
544 q
->ops
->buf_release(q
, buf
);
545 buf
->baddr
= b
->m
.userptr
;
547 case V4L2_MEMORY_OVERLAY
:
548 buf
->boff
= b
->m
.offset
;
551 dprintk(1, "qbuf: wrong memory type\n");
555 dprintk(1, "qbuf: requesting next field\n");
556 field
= videobuf_next_field(q
);
557 retval
= q
->ops
->buf_prepare(q
, buf
, field
);
559 dprintk(1, "qbuf: buffer_prepare returned %d\n", retval
);
563 list_add_tail(&buf
->stream
, &q
->stream
);
565 spin_lock_irqsave(q
->irqlock
, flags
);
566 q
->ops
->buf_queue(q
, buf
);
567 spin_unlock_irqrestore(q
->irqlock
, flags
);
569 dprintk(1, "qbuf: succeded\n");
571 wake_up_interruptible_sync(&q
->wait
);
574 mutex_unlock(&q
->vb_lock
);
576 if (b
->memory
== V4L2_MEMORY_MMAP
)
577 up_read(¤t
->mm
->mmap_sem
);
583 /* Locking: Caller holds q->vb_lock */
584 static int stream_next_buffer_check_queue(struct videobuf_queue
*q
, int noblock
)
590 dprintk(1, "next_buffer: Not streaming\n");
595 if (list_empty(&q
->stream
)) {
598 dprintk(2, "next_buffer: no buffers to dequeue\n");
601 dprintk(2, "next_buffer: waiting on buffer\n");
603 /* Drop lock to avoid deadlock with qbuf */
604 mutex_unlock(&q
->vb_lock
);
606 /* Checking list_empty and streaming is safe without
607 * locks because we goto checks to validate while
608 * holding locks before proceeding */
609 retval
= wait_event_interruptible(q
->wait
,
610 !list_empty(&q
->stream
) || !q
->streaming
);
611 mutex_lock(&q
->vb_lock
);
627 /* Locking: Caller holds q->vb_lock */
628 static int stream_next_buffer(struct videobuf_queue
*q
,
629 struct videobuf_buffer
**vb
, int nonblocking
)
632 struct videobuf_buffer
*buf
= NULL
;
634 retval
= stream_next_buffer_check_queue(q
, nonblocking
);
638 buf
= list_entry(q
->stream
.next
, struct videobuf_buffer
, stream
);
639 retval
= videobuf_waiton(buf
, nonblocking
, 1);
648 int videobuf_dqbuf(struct videobuf_queue
*q
,
649 struct v4l2_buffer
*b
, int nonblocking
)
651 struct videobuf_buffer
*buf
= NULL
;
654 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
656 mutex_lock(&q
->vb_lock
);
658 retval
= stream_next_buffer(q
, &buf
, nonblocking
);
660 dprintk(1, "dqbuf: next_buffer error: %i\n", retval
);
664 switch (buf
->state
) {
666 dprintk(1, "dqbuf: state is error\n");
668 CALL(q
, sync
, q
, buf
);
669 buf
->state
= VIDEOBUF_IDLE
;
672 dprintk(1, "dqbuf: state is done\n");
673 CALL(q
, sync
, q
, buf
);
674 buf
->state
= VIDEOBUF_IDLE
;
677 dprintk(1, "dqbuf: state invalid\n");
681 list_del(&buf
->stream
);
682 memset(b
, 0, sizeof(*b
));
683 videobuf_status(q
, b
, buf
, q
->type
);
686 mutex_unlock(&q
->vb_lock
);
690 int videobuf_streamon(struct videobuf_queue
*q
)
692 struct videobuf_buffer
*buf
;
693 unsigned long flags
= 0;
696 mutex_lock(&q
->vb_lock
);
704 spin_lock_irqsave(q
->irqlock
, flags
);
705 list_for_each_entry(buf
, &q
->stream
, stream
)
706 if (buf
->state
== VIDEOBUF_PREPARED
)
707 q
->ops
->buf_queue(q
, buf
);
708 spin_unlock_irqrestore(q
->irqlock
, flags
);
710 wake_up_interruptible_sync(&q
->wait
);
712 mutex_unlock(&q
->vb_lock
);
716 /* Locking: Caller holds q->vb_lock */
717 static int __videobuf_streamoff(struct videobuf_queue
*q
)
722 videobuf_queue_cancel(q
);
727 int videobuf_streamoff(struct videobuf_queue
*q
)
731 mutex_lock(&q
->vb_lock
);
732 retval
= __videobuf_streamoff(q
);
733 mutex_unlock(&q
->vb_lock
);
738 /* Locking: Caller holds q->vb_lock */
739 static ssize_t
videobuf_read_zerocopy(struct videobuf_queue
*q
,
741 size_t count
, loff_t
*ppos
)
743 enum v4l2_field field
;
744 unsigned long flags
= 0;
747 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
750 q
->read_buf
= videobuf_alloc(q
);
751 if (NULL
== q
->read_buf
)
754 q
->read_buf
->memory
= V4L2_MEMORY_USERPTR
;
755 q
->read_buf
->baddr
= (unsigned long)data
;
756 q
->read_buf
->bsize
= count
;
758 field
= videobuf_next_field(q
);
759 retval
= q
->ops
->buf_prepare(q
, q
->read_buf
, field
);
763 /* start capture & wait */
764 spin_lock_irqsave(q
->irqlock
, flags
);
765 q
->ops
->buf_queue(q
, q
->read_buf
);
766 spin_unlock_irqrestore(q
->irqlock
, flags
);
767 retval
= videobuf_waiton(q
->read_buf
, 0, 0);
769 CALL(q
, sync
, q
, q
->read_buf
);
770 if (VIDEOBUF_ERROR
== q
->read_buf
->state
)
773 retval
= q
->read_buf
->size
;
778 q
->ops
->buf_release(q
, q
->read_buf
);
784 ssize_t
videobuf_read_one(struct videobuf_queue
*q
,
785 char __user
*data
, size_t count
, loff_t
*ppos
,
788 enum v4l2_field field
;
789 unsigned long flags
= 0;
790 unsigned size
= 0, nbufs
= 1;
793 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
795 mutex_lock(&q
->vb_lock
);
797 q
->ops
->buf_setup(q
, &nbufs
, &size
);
799 if (NULL
== q
->read_buf
&&
802 retval
= videobuf_read_zerocopy(q
, data
, count
, ppos
);
803 if (retval
>= 0 || retval
== -EIO
)
806 /* fallback to kernel bounce buffer on failures */
809 if (NULL
== q
->read_buf
) {
810 /* need to capture a new frame */
812 q
->read_buf
= videobuf_alloc(q
);
814 dprintk(1, "video alloc=0x%p\n", q
->read_buf
);
815 if (NULL
== q
->read_buf
)
817 q
->read_buf
->memory
= V4L2_MEMORY_USERPTR
;
818 q
->read_buf
->bsize
= count
; /* preferred size */
819 field
= videobuf_next_field(q
);
820 retval
= q
->ops
->buf_prepare(q
, q
->read_buf
, field
);
828 spin_lock_irqsave(q
->irqlock
, flags
);
829 q
->ops
->buf_queue(q
, q
->read_buf
);
830 spin_unlock_irqrestore(q
->irqlock
, flags
);
835 /* wait until capture is done */
836 retval
= videobuf_waiton(q
->read_buf
, nonblocking
, 1);
840 CALL(q
, sync
, q
, q
->read_buf
);
842 if (VIDEOBUF_ERROR
== q
->read_buf
->state
) {
843 /* catch I/O errors */
844 q
->ops
->buf_release(q
, q
->read_buf
);
851 /* Copy to userspace */
852 retval
= CALL(q
, video_copy_to_user
, q
, data
, count
, nonblocking
);
856 q
->read_off
+= retval
;
857 if (q
->read_off
== q
->read_buf
->size
) {
858 /* all data copied, cleanup */
859 q
->ops
->buf_release(q
, q
->read_buf
);
865 mutex_unlock(&q
->vb_lock
);
869 /* Locking: Caller holds q->vb_lock */
870 static int __videobuf_read_start(struct videobuf_queue
*q
)
872 enum v4l2_field field
;
873 unsigned long flags
= 0;
874 unsigned int count
= 0, size
= 0;
877 q
->ops
->buf_setup(q
, &count
, &size
);
880 if (count
> VIDEO_MAX_FRAME
)
881 count
= VIDEO_MAX_FRAME
;
882 size
= PAGE_ALIGN(size
);
884 err
= __videobuf_mmap_setup(q
, count
, size
, V4L2_MEMORY_USERPTR
);
890 for (i
= 0; i
< count
; i
++) {
891 field
= videobuf_next_field(q
);
892 err
= q
->ops
->buf_prepare(q
, q
->bufs
[i
], field
);
895 list_add_tail(&q
->bufs
[i
]->stream
, &q
->stream
);
897 spin_lock_irqsave(q
->irqlock
, flags
);
898 for (i
= 0; i
< count
; i
++)
899 q
->ops
->buf_queue(q
, q
->bufs
[i
]);
900 spin_unlock_irqrestore(q
->irqlock
, flags
);
905 static void __videobuf_read_stop(struct videobuf_queue
*q
)
909 videobuf_queue_cancel(q
);
910 __videobuf_mmap_free(q
);
911 INIT_LIST_HEAD(&q
->stream
);
912 for (i
= 0; i
< VIDEO_MAX_FRAME
; i
++) {
913 if (NULL
== q
->bufs
[i
])
922 int videobuf_read_start(struct videobuf_queue
*q
)
926 mutex_lock(&q
->vb_lock
);
927 rc
= __videobuf_read_start(q
);
928 mutex_unlock(&q
->vb_lock
);
933 void videobuf_read_stop(struct videobuf_queue
*q
)
935 mutex_lock(&q
->vb_lock
);
936 __videobuf_read_stop(q
);
937 mutex_unlock(&q
->vb_lock
);
940 void videobuf_stop(struct videobuf_queue
*q
)
942 mutex_lock(&q
->vb_lock
);
945 __videobuf_streamoff(q
);
948 __videobuf_read_stop(q
);
950 mutex_unlock(&q
->vb_lock
);
954 ssize_t
videobuf_read_stream(struct videobuf_queue
*q
,
955 char __user
*data
, size_t count
, loff_t
*ppos
,
956 int vbihack
, int nonblocking
)
959 unsigned long flags
= 0;
961 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
963 dprintk(2, "%s\n", __func__
);
964 mutex_lock(&q
->vb_lock
);
969 retval
= __videobuf_read_start(q
);
976 /* get / wait for data */
977 if (NULL
== q
->read_buf
) {
978 q
->read_buf
= list_entry(q
->stream
.next
,
979 struct videobuf_buffer
,
981 list_del(&q
->read_buf
->stream
);
984 rc
= videobuf_waiton(q
->read_buf
, nonblocking
, 1);
991 if (q
->read_buf
->state
== VIDEOBUF_DONE
) {
992 rc
= CALL(q
, copy_stream
, q
, data
+ retval
, count
,
993 retval
, vbihack
, nonblocking
);
1003 q
->read_off
= q
->read_buf
->size
;
1008 /* requeue buffer when done with copying */
1009 if (q
->read_off
== q
->read_buf
->size
) {
1010 list_add_tail(&q
->read_buf
->stream
,
1012 spin_lock_irqsave(q
->irqlock
, flags
);
1013 q
->ops
->buf_queue(q
, q
->read_buf
);
1014 spin_unlock_irqrestore(q
->irqlock
, flags
);
1022 mutex_unlock(&q
->vb_lock
);
1026 unsigned int videobuf_poll_stream(struct file
*file
,
1027 struct videobuf_queue
*q
,
1030 struct videobuf_buffer
*buf
= NULL
;
1031 unsigned int rc
= 0;
1033 mutex_lock(&q
->vb_lock
);
1035 if (!list_empty(&q
->stream
))
1036 buf
= list_entry(q
->stream
.next
,
1037 struct videobuf_buffer
, stream
);
1040 __videobuf_read_start(q
);
1043 } else if (NULL
== q
->read_buf
) {
1044 q
->read_buf
= list_entry(q
->stream
.next
,
1045 struct videobuf_buffer
,
1047 list_del(&q
->read_buf
->stream
);
1056 poll_wait(file
, &buf
->done
, wait
);
1057 if (buf
->state
== VIDEOBUF_DONE
||
1058 buf
->state
== VIDEOBUF_ERROR
)
1059 rc
= POLLIN
|POLLRDNORM
;
1061 mutex_unlock(&q
->vb_lock
);
1065 int videobuf_mmap_mapper(struct videobuf_queue
*q
,
1066 struct vm_area_struct
*vma
)
1070 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
1072 mutex_lock(&q
->vb_lock
);
1073 retval
= CALL(q
, mmap_mapper
, q
, vma
);
1075 mutex_unlock(&q
->vb_lock
);
1080 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1081 int videobuf_cgmbuf(struct videobuf_queue
*q
,
1082 struct video_mbuf
*mbuf
, int count
)
1084 struct v4l2_requestbuffers req
;
1087 MAGIC_CHECK(q
->int_ops
->magic
, MAGIC_QTYPE_OPS
);
1089 memset(&req
, 0, sizeof(req
));
1092 req
.memory
= V4L2_MEMORY_MMAP
;
1093 rc
= videobuf_reqbufs(q
, &req
);
1097 mbuf
->frames
= req
.count
;
1099 for (i
= 0; i
< mbuf
->frames
; i
++) {
1100 mbuf
->offsets
[i
] = q
->bufs
[i
]->boff
;
1101 mbuf
->size
+= PAGE_ALIGN(q
->bufs
[i
]->bsize
);
1106 EXPORT_SYMBOL_GPL(videobuf_cgmbuf
);
1109 /* --------------------------------------------------------------------- */
1111 EXPORT_SYMBOL_GPL(videobuf_waiton
);
1112 EXPORT_SYMBOL_GPL(videobuf_iolock
);
1114 EXPORT_SYMBOL_GPL(videobuf_alloc
);
1116 EXPORT_SYMBOL_GPL(videobuf_queue_core_init
);
1117 EXPORT_SYMBOL_GPL(videobuf_queue_cancel
);
1118 EXPORT_SYMBOL_GPL(videobuf_queue_is_busy
);
1120 EXPORT_SYMBOL_GPL(videobuf_next_field
);
1121 EXPORT_SYMBOL_GPL(videobuf_reqbufs
);
1122 EXPORT_SYMBOL_GPL(videobuf_querybuf
);
1123 EXPORT_SYMBOL_GPL(videobuf_qbuf
);
1124 EXPORT_SYMBOL_GPL(videobuf_dqbuf
);
1125 EXPORT_SYMBOL_GPL(videobuf_streamon
);
1126 EXPORT_SYMBOL_GPL(videobuf_streamoff
);
1128 EXPORT_SYMBOL_GPL(videobuf_read_start
);
1129 EXPORT_SYMBOL_GPL(videobuf_read_stop
);
1130 EXPORT_SYMBOL_GPL(videobuf_stop
);
1131 EXPORT_SYMBOL_GPL(videobuf_read_stream
);
1132 EXPORT_SYMBOL_GPL(videobuf_read_one
);
1133 EXPORT_SYMBOL_GPL(videobuf_poll_stream
);
1135 EXPORT_SYMBOL_GPL(__videobuf_mmap_setup
);
1136 EXPORT_SYMBOL_GPL(videobuf_mmap_setup
);
1137 EXPORT_SYMBOL_GPL(videobuf_mmap_free
);
1138 EXPORT_SYMBOL_GPL(videobuf_mmap_mapper
);