projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[media] vb2: simplify a confusing condition
[deliverable/linux.git] / drivers / media / v4l2-core / videobuf-core.c
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 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/mm.h>
20 #include <linux/sched.h>
21 #include <linux/slab.h>
22 #include <linux/interrupt.h>
23
24 #include <media/videobuf-core.h>
25
26 #define MAGIC_BUFFER 0x20070728
27 #define MAGIC_CHECK(is, should) \
28 do { \
29 if (unlikely((is) != (should))) { \
30 printk(KERN_ERR \
31 "magic mismatch: %x (expected %x)\n", \
32 is, should); \
33 BUG(); \
34 } \
35 } while (0)
36
37 static int debug;
38 module_param(debug, int, 0644);
39
40 MODULE_DESCRIPTION("helper module to manage video4linux buffers");
41 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
42 MODULE_LICENSE("GPL");
43
44 #define dprintk(level, fmt, arg...) \
45 do { \
46 if (debug >= level) \
47 printk(KERN_DEBUG "vbuf: " fmt, ## arg); \
48 } while (0)
49
50 /* --------------------------------------------------------------------- */
51
52 #define CALL(q, f, arg...) \
53 ((q->int_ops->f) ? q->int_ops->f(arg) : 0)
54
55 struct videobuf_buffer *videobuf_alloc_vb(struct videobuf_queue *q)
56 {
57 struct videobuf_buffer *vb;
58
59 BUG_ON(q->msize < sizeof(*vb));
60
61 if (!q->int_ops || !q->int_ops->alloc_vb) {
62 printk(KERN_ERR "No specific ops defined!\n");
63 BUG();
64 }
65
66 vb = q->int_ops->alloc_vb(q->msize);
67 if (NULL != vb) {
68 init_waitqueue_head(&vb->done);
69 vb->magic = MAGIC_BUFFER;
70 }
71
72 return vb;
73 }
74 EXPORT_SYMBOL_GPL(videobuf_alloc_vb);
75
76 static int is_state_active_or_queued(struct videobuf_queue *q, struct videobuf_buffer *vb)
77 {
78 unsigned long flags;
79 bool rc;
80
81 spin_lock_irqsave(q->irqlock, flags);
82 rc = vb->state != VIDEOBUF_ACTIVE && vb->state != VIDEOBUF_QUEUED;
83 spin_unlock_irqrestore(q->irqlock, flags);
84 return rc;
85 };
86
87 int videobuf_waiton(struct videobuf_queue *q, struct videobuf_buffer *vb,
88 int non_blocking, int intr)
89 {
90 bool is_ext_locked;
91 int ret = 0;
92
93 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);
94
95 if (non_blocking) {
96 if (is_state_active_or_queued(q, vb))
97 return 0;
98 return -EAGAIN;
99 }
100
101 is_ext_locked = q->ext_lock && mutex_is_locked(q->ext_lock);
102
103 /* Release vdev lock to prevent this wait from blocking outside access to
104 the device. */
105 if (is_ext_locked)
106 mutex_unlock(q->ext_lock);
107 if (intr)
108 ret = wait_event_interruptible(vb->done, is_state_active_or_queued(q, vb));
109 else
110 wait_event(vb->done, is_state_active_or_queued(q, vb));
111 /* Relock */
112 if (is_ext_locked)
113 mutex_lock(q->ext_lock);
114
115 return ret;
116 }
117 EXPORT_SYMBOL_GPL(videobuf_waiton);
118
119 int videobuf_iolock(struct videobuf_queue *q, struct videobuf_buffer *vb,
120 struct v4l2_framebuffer *fbuf)
121 {
122 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);
123 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
124
125 return CALL(q, iolock, q, vb, fbuf);
126 }
127 EXPORT_SYMBOL_GPL(videobuf_iolock);
128
129 void *videobuf_queue_to_vaddr(struct videobuf_queue *q,
130 struct videobuf_buffer *buf)
131 {
132 if (q->int_ops->vaddr)
133 return q->int_ops->vaddr(buf);
134 return NULL;
135 }
136 EXPORT_SYMBOL_GPL(videobuf_queue_to_vaddr);
137
138 /* --------------------------------------------------------------------- */
139
140
141 void videobuf_queue_core_init(struct videobuf_queue *q,
142 const struct videobuf_queue_ops *ops,
143 struct device *dev,
144 spinlock_t *irqlock,
145 enum v4l2_buf_type type,
146 enum v4l2_field field,
147 unsigned int msize,
148 void *priv,
149 struct videobuf_qtype_ops *int_ops,
150 struct mutex *ext_lock)
151 {
152 BUG_ON(!q);
153 memset(q, 0, sizeof(*q));
154 q->irqlock = irqlock;
155 q->ext_lock = ext_lock;
156 q->dev = dev;
157 q->type = type;
158 q->field = field;
159 q->msize = msize;
160 q->ops = ops;
161 q->priv_data = priv;
162 q->int_ops = int_ops;
163
164 /* All buffer operations are mandatory */
165 BUG_ON(!q->ops->buf_setup);
166 BUG_ON(!q->ops->buf_prepare);
167 BUG_ON(!q->ops->buf_queue);
168 BUG_ON(!q->ops->buf_release);
169
170 /* Lock is mandatory for queue_cancel to work */
171 BUG_ON(!irqlock);
172
173 /* Having implementations for abstract methods are mandatory */
174 BUG_ON(!q->int_ops);
175
176 mutex_init(&q->vb_lock);
177 init_waitqueue_head(&q->wait);
178 INIT_LIST_HEAD(&q->stream);
179 }
180 EXPORT_SYMBOL_GPL(videobuf_queue_core_init);
181
182 /* Locking: Only usage in bttv unsafe find way to remove */
183 int videobuf_queue_is_busy(struct videobuf_queue *q)
184 {
185 int i;
186
187 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
188
189 if (q->streaming) {
190 dprintk(1, "busy: streaming active\n");
191 return 1;
192 }
193 if (q->reading) {
194 dprintk(1, "busy: pending read #1\n");
195 return 1;
196 }
197 if (q->read_buf) {
198 dprintk(1, "busy: pending read #2\n");
199 return 1;
200 }
201 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
202 if (NULL == q->bufs[i])
203 continue;
204 if (q->bufs[i]->map) {
205 dprintk(1, "busy: buffer #%d mapped\n", i);
206 return 1;
207 }
208 if (q->bufs[i]->state == VIDEOBUF_QUEUED) {
209 dprintk(1, "busy: buffer #%d queued\n", i);
210 return 1;
211 }
212 if (q->bufs[i]->state == VIDEOBUF_ACTIVE) {
213 dprintk(1, "busy: buffer #%d avtive\n", i);
214 return 1;
215 }
216 }
217 return 0;
218 }
219 EXPORT_SYMBOL_GPL(videobuf_queue_is_busy);
220
221 /**
222 * __videobuf_free() - free all the buffers and their control structures
223 *
224 * This function can only be called if streaming/reading is off, i.e. no buffers
225 * are under control of the driver.
226 */
227 /* Locking: Caller holds q->vb_lock */
228 static int __videobuf_free(struct videobuf_queue *q)
229 {
230 int i;
231
232 dprintk(1, "%s\n", __func__);
233 if (!q)
234 return 0;
235
236 if (q->streaming || q->reading) {
237 dprintk(1, "Cannot free buffers when streaming or reading\n");
238 return -EBUSY;
239 }
240
241 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
242
243 for (i = 0; i < VIDEO_MAX_FRAME; i++)
244 if (q->bufs[i] && q->bufs[i]->map) {
245 dprintk(1, "Cannot free mmapped buffers\n");
246 return -EBUSY;
247 }
248
249 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
250 if (NULL == q->bufs[i])
251 continue;
252 q->ops->buf_release(q, q->bufs[i]);
253 kfree(q->bufs[i]);
254 q->bufs[i] = NULL;
255 }
256
257 return 0;
258 }
259
260 /* Locking: Caller holds q->vb_lock */
261 void videobuf_queue_cancel(struct videobuf_queue *q)
262 {
263 unsigned long flags = 0;
264 int i;
265
266 q->streaming = 0;
267 q->reading = 0;
268 wake_up_interruptible_sync(&q->wait);
269
270 /* remove queued buffers from list */
271 spin_lock_irqsave(q->irqlock, flags);
272 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
273 if (NULL == q->bufs[i])
274 continue;
275 if (q->bufs[i]->state == VIDEOBUF_QUEUED) {
276 list_del(&q->bufs[i]->queue);
277 q->bufs[i]->state = VIDEOBUF_ERROR;
278 wake_up_all(&q->bufs[i]->done);
279 }
280 }
281 spin_unlock_irqrestore(q->irqlock, flags);
282
283 /* free all buffers + clear queue */
284 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
285 if (NULL == q->bufs[i])
286 continue;
287 q->ops->buf_release(q, q->bufs[i]);
288 }
289 INIT_LIST_HEAD(&q->stream);
290 }
291 EXPORT_SYMBOL_GPL(videobuf_queue_cancel);
292
293 /* --------------------------------------------------------------------- */
294
295 /* Locking: Caller holds q->vb_lock */
296 enum v4l2_field videobuf_next_field(struct videobuf_queue *q)
297 {
298 enum v4l2_field field = q->field;
299
300 BUG_ON(V4L2_FIELD_ANY == field);
301
302 if (V4L2_FIELD_ALTERNATE == field) {
303 if (V4L2_FIELD_TOP == q->last) {
304 field = V4L2_FIELD_BOTTOM;
305 q->last = V4L2_FIELD_BOTTOM;
306 } else {
307 field = V4L2_FIELD_TOP;
308 q->last = V4L2_FIELD_TOP;
309 }
310 }
311 return field;
312 }
313 EXPORT_SYMBOL_GPL(videobuf_next_field);
314
315 /* Locking: Caller holds q->vb_lock */
316 static void videobuf_status(struct videobuf_queue *q, struct v4l2_buffer *b,
317 struct videobuf_buffer *vb, enum v4l2_buf_type type)
318 {
319 MAGIC_CHECK(vb->magic, MAGIC_BUFFER);
320 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
321
322 b->index = vb->i;
323 b->type = type;
324
325 b->memory = vb->memory;
326 switch (b->memory) {
327 case V4L2_MEMORY_MMAP:
328 b->m.offset = vb->boff;
329 b->length = vb->bsize;
330 break;
331 case V4L2_MEMORY_USERPTR:
332 b->m.userptr = vb->baddr;
333 b->length = vb->bsize;
334 break;
335 case V4L2_MEMORY_OVERLAY:
336 b->m.offset = vb->boff;
337 break;
338 case V4L2_MEMORY_DMABUF:
339 /* DMABUF is not handled in videobuf framework */
340 break;
341 }
342
343 b->flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
344 if (vb->map)
345 b->flags |= V4L2_BUF_FLAG_MAPPED;
346
347 switch (vb->state) {
348 case VIDEOBUF_PREPARED:
349 case VIDEOBUF_QUEUED:
350 case VIDEOBUF_ACTIVE:
351 b->flags |= V4L2_BUF_FLAG_QUEUED;
352 break;
353 case VIDEOBUF_ERROR:
354 b->flags |= V4L2_BUF_FLAG_ERROR;
355 /* fall through */
356 case VIDEOBUF_DONE:
357 b->flags |= V4L2_BUF_FLAG_DONE;
358 break;
359 case VIDEOBUF_NEEDS_INIT:
360 case VIDEOBUF_IDLE:
361 /* nothing */
362 break;
363 }
364
365 b->field = vb->field;
366 b->timestamp = vb->ts;
367 b->bytesused = vb->size;
368 b->sequence = vb->field_count >> 1;
369 }
370
371 int videobuf_mmap_free(struct videobuf_queue *q)
372 {
373 int ret;
374 videobuf_queue_lock(q);
375 ret = __videobuf_free(q);
376 videobuf_queue_unlock(q);
377 return ret;
378 }
379 EXPORT_SYMBOL_GPL(videobuf_mmap_free);
380
381 /* Locking: Caller holds q->vb_lock */
382 int __videobuf_mmap_setup(struct videobuf_queue *q,
383 unsigned int bcount, unsigned int bsize,
384 enum v4l2_memory memory)
385 {
386 unsigned int i;
387 int err;
388
389 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
390
391 err = __videobuf_free(q);
392 if (0 != err)
393 return err;
394
395 /* Allocate and initialize buffers */
396 for (i = 0; i < bcount; i++) {
397 q->bufs[i] = videobuf_alloc_vb(q);
398
399 if (NULL == q->bufs[i])
400 break;
401
402 q->bufs[i]->i = i;
403 q->bufs[i]->memory = memory;
404 q->bufs[i]->bsize = bsize;
405 switch (memory) {
406 case V4L2_MEMORY_MMAP:
407 q->bufs[i]->boff = PAGE_ALIGN(bsize) * i;
408 break;
409 case V4L2_MEMORY_USERPTR:
410 case V4L2_MEMORY_OVERLAY:
411 case V4L2_MEMORY_DMABUF:
412 /* nothing */
413 break;
414 }
415 }
416
417 if (!i)
418 return -ENOMEM;
419
420 dprintk(1, "mmap setup: %d buffers, %d bytes each\n", i, bsize);
421
422 return i;
423 }
424 EXPORT_SYMBOL_GPL(__videobuf_mmap_setup);
425
426 int videobuf_mmap_setup(struct videobuf_queue *q,
427 unsigned int bcount, unsigned int bsize,
428 enum v4l2_memory memory)
429 {
430 int ret;
431 videobuf_queue_lock(q);
432 ret = __videobuf_mmap_setup(q, bcount, bsize, memory);
433 videobuf_queue_unlock(q);
434 return ret;
435 }
436 EXPORT_SYMBOL_GPL(videobuf_mmap_setup);
437
438 int videobuf_reqbufs(struct videobuf_queue *q,
439 struct v4l2_requestbuffers *req)
440 {
441 unsigned int size, count;
442 int retval;
443
444 if (req->count < 1) {
445 dprintk(1, "reqbufs: count invalid (%d)\n", req->count);
446 return -EINVAL;
447 }
448
449 if (req->memory != V4L2_MEMORY_MMAP &&
450 req->memory != V4L2_MEMORY_USERPTR &&
451 req->memory != V4L2_MEMORY_OVERLAY) {
452 dprintk(1, "reqbufs: memory type invalid\n");
453 return -EINVAL;
454 }
455
456 videobuf_queue_lock(q);
457 if (req->type != q->type) {
458 dprintk(1, "reqbufs: queue type invalid\n");
459 retval = -EINVAL;
460 goto done;
461 }
462
463 if (q->streaming) {
464 dprintk(1, "reqbufs: streaming already exists\n");
465 retval = -EBUSY;
466 goto done;
467 }
468 if (!list_empty(&q->stream)) {
469 dprintk(1, "reqbufs: stream running\n");
470 retval = -EBUSY;
471 goto done;
472 }
473
474 count = req->count;
475 if (count > VIDEO_MAX_FRAME)
476 count = VIDEO_MAX_FRAME;
477 size = 0;
478 q->ops->buf_setup(q, &count, &size);
479 dprintk(1, "reqbufs: bufs=%d, size=0x%x [%u pages total]\n",
480 count, size,
481 (unsigned int)((count * PAGE_ALIGN(size)) >> PAGE_SHIFT));
482
483 retval = __videobuf_mmap_setup(q, count, size, req->memory);
484 if (retval < 0) {
485 dprintk(1, "reqbufs: mmap setup returned %d\n", retval);
486 goto done;
487 }
488
489 req->count = retval;
490 retval = 0;
491
492 done:
493 videobuf_queue_unlock(q);
494 return retval;
495 }
496 EXPORT_SYMBOL_GPL(videobuf_reqbufs);
497
498 int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b)
499 {
500 int ret = -EINVAL;
501
502 videobuf_queue_lock(q);
503 if (unlikely(b->type != q->type)) {
504 dprintk(1, "querybuf: Wrong type.\n");
505 goto done;
506 }
507 if (unlikely(b->index >= VIDEO_MAX_FRAME)) {
508 dprintk(1, "querybuf: index out of range.\n");
509 goto done;
510 }
511 if (unlikely(NULL == q->bufs[b->index])) {
512 dprintk(1, "querybuf: buffer is null.\n");
513 goto done;
514 }
515
516 videobuf_status(q, b, q->bufs[b->index], q->type);
517
518 ret = 0;
519 done:
520 videobuf_queue_unlock(q);
521 return ret;
522 }
523 EXPORT_SYMBOL_GPL(videobuf_querybuf);
524
525 int videobuf_qbuf(struct videobuf_queue *q, struct v4l2_buffer *b)
526 {
527 struct videobuf_buffer *buf;
528 enum v4l2_field field;
529 unsigned long flags = 0;
530 int retval;
531
532 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
533
534 if (b->memory == V4L2_MEMORY_MMAP)
535 down_read(&current->mm->mmap_sem);
536
537 videobuf_queue_lock(q);
538 retval = -EBUSY;
539 if (q->reading) {
540 dprintk(1, "qbuf: Reading running...\n");
541 goto done;
542 }
543 retval = -EINVAL;
544 if (b->type != q->type) {
545 dprintk(1, "qbuf: Wrong type.\n");
546 goto done;
547 }
548 if (b->index >= VIDEO_MAX_FRAME) {
549 dprintk(1, "qbuf: index out of range.\n");
550 goto done;
551 }
552 buf = q->bufs[b->index];
553 if (NULL == buf) {
554 dprintk(1, "qbuf: buffer is null.\n");
555 goto done;
556 }
557 MAGIC_CHECK(buf->magic, MAGIC_BUFFER);
558 if (buf->memory != b->memory) {
559 dprintk(1, "qbuf: memory type is wrong.\n");
560 goto done;
561 }
562 if (buf->state != VIDEOBUF_NEEDS_INIT && buf->state != VIDEOBUF_IDLE) {
563 dprintk(1, "qbuf: buffer is already queued or active.\n");
564 goto done;
565 }
566
567 switch (b->memory) {
568 case V4L2_MEMORY_MMAP:
569 if (0 == buf->baddr) {
570 dprintk(1, "qbuf: mmap requested "
571 "but buffer addr is zero!\n");
572 goto done;
573 }
574 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT
575 || q->type == V4L2_BUF_TYPE_VBI_OUTPUT
576 || q->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT) {
577 buf->size = b->bytesused;
578 buf->field = b->field;
579 buf->ts = b->timestamp;
580 }
581 break;
582 case V4L2_MEMORY_USERPTR:
583 if (b->length < buf->bsize) {
584 dprintk(1, "qbuf: buffer length is not enough\n");
585 goto done;
586 }
587 if (VIDEOBUF_NEEDS_INIT != buf->state &&
588 buf->baddr != b->m.userptr)
589 q->ops->buf_release(q, buf);
590 buf->baddr = b->m.userptr;
591 break;
592 case V4L2_MEMORY_OVERLAY:
593 buf->boff = b->m.offset;
594 break;
595 default:
596 dprintk(1, "qbuf: wrong memory type\n");
597 goto done;
598 }
599
600 dprintk(1, "qbuf: requesting next field\n");
601 field = videobuf_next_field(q);
602 retval = q->ops->buf_prepare(q, buf, field);
603 if (0 != retval) {
604 dprintk(1, "qbuf: buffer_prepare returned %d\n", retval);
605 goto done;
606 }
607
608 list_add_tail(&buf->stream, &q->stream);
609 if (q->streaming) {
610 spin_lock_irqsave(q->irqlock, flags);
611 q->ops->buf_queue(q, buf);
612 spin_unlock_irqrestore(q->irqlock, flags);
613 }
614 dprintk(1, "qbuf: succeeded\n");
615 retval = 0;
616 wake_up_interruptible_sync(&q->wait);
617
618 done:
619 videobuf_queue_unlock(q);
620
621 if (b->memory == V4L2_MEMORY_MMAP)
622 up_read(&current->mm->mmap_sem);
623
624 return retval;
625 }
626 EXPORT_SYMBOL_GPL(videobuf_qbuf);
627
628 /* Locking: Caller holds q->vb_lock */
629 static int stream_next_buffer_check_queue(struct videobuf_queue *q, int noblock)
630 {
631 int retval;
632
633 checks:
634 if (!q->streaming) {
635 dprintk(1, "next_buffer: Not streaming\n");
636 retval = -EINVAL;
637 goto done;
638 }
639
640 if (list_empty(&q->stream)) {
641 if (noblock) {
642 retval = -EAGAIN;
643 dprintk(2, "next_buffer: no buffers to dequeue\n");
644 goto done;
645 } else {
646 dprintk(2, "next_buffer: waiting on buffer\n");
647
648 /* Drop lock to avoid deadlock with qbuf */
649 videobuf_queue_unlock(q);
650
651 /* Checking list_empty and streaming is safe without
652 * locks because we goto checks to validate while
653 * holding locks before proceeding */
654 retval = wait_event_interruptible(q->wait,
655 !list_empty(&q->stream) || !q->streaming);
656 videobuf_queue_lock(q);
657
658 if (retval)
659 goto done;
660
661 goto checks;
662 }
663 }
664
665 retval = 0;
666
667 done:
668 return retval;
669 }
670
671 /* Locking: Caller holds q->vb_lock */
672 static int stream_next_buffer(struct videobuf_queue *q,
673 struct videobuf_buffer **vb, int nonblocking)
674 {
675 int retval;
676 struct videobuf_buffer *buf = NULL;
677
678 retval = stream_next_buffer_check_queue(q, nonblocking);
679 if (retval)
680 goto done;
681
682 buf = list_entry(q->stream.next, struct videobuf_buffer, stream);
683 retval = videobuf_waiton(q, buf, nonblocking, 1);
684 if (retval < 0)
685 goto done;
686
687 *vb = buf;
688 done:
689 return retval;
690 }
691
692 int videobuf_dqbuf(struct videobuf_queue *q,
693 struct v4l2_buffer *b, int nonblocking)
694 {
695 struct videobuf_buffer *buf = NULL;
696 int retval;
697
698 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
699
700 memset(b, 0, sizeof(*b));
701 videobuf_queue_lock(q);
702
703 retval = stream_next_buffer(q, &buf, nonblocking);
704 if (retval < 0) {
705 dprintk(1, "dqbuf: next_buffer error: %i\n", retval);
706 goto done;
707 }
708
709 switch (buf->state) {
710 case VIDEOBUF_ERROR:
711 dprintk(1, "dqbuf: state is error\n");
712 break;
713 case VIDEOBUF_DONE:
714 dprintk(1, "dqbuf: state is done\n");
715 break;
716 default:
717 dprintk(1, "dqbuf: state invalid\n");
718 retval = -EINVAL;
719 goto done;
720 }
721 CALL(q, sync, q, buf);
722 videobuf_status(q, b, buf, q->type);
723 list_del(&buf->stream);
724 buf->state = VIDEOBUF_IDLE;
725 b->flags &= ~V4L2_BUF_FLAG_DONE;
726 done:
727 videobuf_queue_unlock(q);
728 return retval;
729 }
730 EXPORT_SYMBOL_GPL(videobuf_dqbuf);
731
732 int videobuf_streamon(struct videobuf_queue *q)
733 {
734 struct videobuf_buffer *buf;
735 unsigned long flags = 0;
736 int retval;
737
738 videobuf_queue_lock(q);
739 retval = -EBUSY;
740 if (q->reading)
741 goto done;
742 retval = 0;
743 if (q->streaming)
744 goto done;
745 q->streaming = 1;
746 spin_lock_irqsave(q->irqlock, flags);
747 list_for_each_entry(buf, &q->stream, stream)
748 if (buf->state == VIDEOBUF_PREPARED)
749 q->ops->buf_queue(q, buf);
750 spin_unlock_irqrestore(q->irqlock, flags);
751
752 wake_up_interruptible_sync(&q->wait);
753 done:
754 videobuf_queue_unlock(q);
755 return retval;
756 }
757 EXPORT_SYMBOL_GPL(videobuf_streamon);
758
759 /* Locking: Caller holds q->vb_lock */
760 static int __videobuf_streamoff(struct videobuf_queue *q)
761 {
762 if (!q->streaming)
763 return -EINVAL;
764
765 videobuf_queue_cancel(q);
766
767 return 0;
768 }
769
770 int videobuf_streamoff(struct videobuf_queue *q)
771 {
772 int retval;
773
774 videobuf_queue_lock(q);
775 retval = __videobuf_streamoff(q);
776 videobuf_queue_unlock(q);
777
778 return retval;
779 }
780 EXPORT_SYMBOL_GPL(videobuf_streamoff);
781
782 /* Locking: Caller holds q->vb_lock */
783 static ssize_t videobuf_read_zerocopy(struct videobuf_queue *q,
784 char __user *data,
785 size_t count, loff_t *ppos)
786 {
787 enum v4l2_field field;
788 unsigned long flags = 0;
789 int retval;
790
791 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
792
793 /* setup stuff */
794 q->read_buf = videobuf_alloc_vb(q);
795 if (NULL == q->read_buf)
796 return -ENOMEM;
797
798 q->read_buf->memory = V4L2_MEMORY_USERPTR;
799 q->read_buf->baddr = (unsigned long)data;
800 q->read_buf->bsize = count;
801
802 field = videobuf_next_field(q);
803 retval = q->ops->buf_prepare(q, q->read_buf, field);
804 if (0 != retval)
805 goto done;
806
807 /* start capture & wait */
808 spin_lock_irqsave(q->irqlock, flags);
809 q->ops->buf_queue(q, q->read_buf);
810 spin_unlock_irqrestore(q->irqlock, flags);
811 retval = videobuf_waiton(q, q->read_buf, 0, 0);
812 if (0 == retval) {
813 CALL(q, sync, q, q->read_buf);
814 if (VIDEOBUF_ERROR == q->read_buf->state)
815 retval = -EIO;
816 else
817 retval = q->read_buf->size;
818 }
819
820 done:
821 /* cleanup */
822 q->ops->buf_release(q, q->read_buf);
823 kfree(q->read_buf);
824 q->read_buf = NULL;
825 return retval;
826 }
827
828 static int __videobuf_copy_to_user(struct videobuf_queue *q,
829 struct videobuf_buffer *buf,
830 char __user *data, size_t count,
831 int nonblocking)
832 {
833 void *vaddr = CALL(q, vaddr, buf);
834
835 /* copy to userspace */
836 if (count > buf->size - q->read_off)
837 count = buf->size - q->read_off;
838
839 if (copy_to_user(data, vaddr + q->read_off, count))
840 return -EFAULT;
841
842 return count;
843 }
844
845 static int __videobuf_copy_stream(struct videobuf_queue *q,
846 struct videobuf_buffer *buf,
847 char __user *data, size_t count, size_t pos,
848 int vbihack, int nonblocking)
849 {
850 unsigned int *fc = CALL(q, vaddr, buf);
851
852 if (vbihack) {
853 /* dirty, undocumented hack -- pass the frame counter
854 * within the last four bytes of each vbi data block.
855 * We need that one to maintain backward compatibility
856 * to all vbi decoding software out there ... */
857 fc += (buf->size >> 2) - 1;
858 *fc = buf->field_count >> 1;
859 dprintk(1, "vbihack: %d\n", *fc);
860 }
861
862 /* copy stuff using the common method */
863 count = __videobuf_copy_to_user(q, buf, data, count, nonblocking);
864
865 if ((count == -EFAULT) && (pos == 0))
866 return -EFAULT;
867
868 return count;
869 }
870
871 ssize_t videobuf_read_one(struct videobuf_queue *q,
872 char __user *data, size_t count, loff_t *ppos,
873 int nonblocking)
874 {
875 enum v4l2_field field;
876 unsigned long flags = 0;
877 unsigned size = 0, nbufs = 1;
878 int retval;
879
880 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
881
882 videobuf_queue_lock(q);
883
884 q->ops->buf_setup(q, &nbufs, &size);
885
886 if (NULL == q->read_buf &&
887 count >= size &&
888 !nonblocking) {
889 retval = videobuf_read_zerocopy(q, data, count, ppos);
890 if (retval >= 0 || retval == -EIO)
891 /* ok, all done */
892 goto done;
893 /* fallback to kernel bounce buffer on failures */
894 }
895
896 if (NULL == q->read_buf) {
897 /* need to capture a new frame */
898 retval = -ENOMEM;
899 q->read_buf = videobuf_alloc_vb(q);
900
901 dprintk(1, "video alloc=0x%p\n", q->read_buf);
902 if (NULL == q->read_buf)
903 goto done;
904 q->read_buf->memory = V4L2_MEMORY_USERPTR;
905 q->read_buf->bsize = count; /* preferred size */
906 field = videobuf_next_field(q);
907 retval = q->ops->buf_prepare(q, q->read_buf, field);
908
909 if (0 != retval) {
910 kfree(q->read_buf);
911 q->read_buf = NULL;
912 goto done;
913 }
914
915 spin_lock_irqsave(q->irqlock, flags);
916 q->ops->buf_queue(q, q->read_buf);
917 spin_unlock_irqrestore(q->irqlock, flags);
918
919 q->read_off = 0;
920 }
921
922 /* wait until capture is done */
923 retval = videobuf_waiton(q, q->read_buf, nonblocking, 1);
924 if (0 != retval)
925 goto done;
926
927 CALL(q, sync, q, q->read_buf);
928
929 if (VIDEOBUF_ERROR == q->read_buf->state) {
930 /* catch I/O errors */
931 q->ops->buf_release(q, q->read_buf);
932 kfree(q->read_buf);
933 q->read_buf = NULL;
934 retval = -EIO;
935 goto done;
936 }
937
938 /* Copy to userspace */
939 retval = __videobuf_copy_to_user(q, q->read_buf, data, count, nonblocking);
940 if (retval < 0)
941 goto done;
942
943 q->read_off += retval;
944 if (q->read_off == q->read_buf->size) {
945 /* all data copied, cleanup */
946 q->ops->buf_release(q, q->read_buf);
947 kfree(q->read_buf);
948 q->read_buf = NULL;
949 }
950
951 done:
952 videobuf_queue_unlock(q);
953 return retval;
954 }
955 EXPORT_SYMBOL_GPL(videobuf_read_one);
956
957 /* Locking: Caller holds q->vb_lock */
958 static int __videobuf_read_start(struct videobuf_queue *q)
959 {
960 enum v4l2_field field;
961 unsigned long flags = 0;
962 unsigned int count = 0, size = 0;
963 int err, i;
964
965 q->ops->buf_setup(q, &count, &size);
966 if (count < 2)
967 count = 2;
968 if (count > VIDEO_MAX_FRAME)
969 count = VIDEO_MAX_FRAME;
970 size = PAGE_ALIGN(size);
971
972 err = __videobuf_mmap_setup(q, count, size, V4L2_MEMORY_USERPTR);
973 if (err < 0)
974 return err;
975
976 count = err;
977
978 for (i = 0; i < count; i++) {
979 field = videobuf_next_field(q);
980 err = q->ops->buf_prepare(q, q->bufs[i], field);
981 if (err)
982 return err;
983 list_add_tail(&q->bufs[i]->stream, &q->stream);
984 }
985 spin_lock_irqsave(q->irqlock, flags);
986 for (i = 0; i < count; i++)
987 q->ops->buf_queue(q, q->bufs[i]);
988 spin_unlock_irqrestore(q->irqlock, flags);
989 q->reading = 1;
990 return 0;
991 }
992
993 static void __videobuf_read_stop(struct videobuf_queue *q)
994 {
995 int i;
996
997 videobuf_queue_cancel(q);
998 __videobuf_free(q);
999 INIT_LIST_HEAD(&q->stream);
1000 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1001 if (NULL == q->bufs[i])
1002 continue;
1003 kfree(q->bufs[i]);
1004 q->bufs[i] = NULL;
1005 }
1006 q->read_buf = NULL;
1007 }
1008
1009 int videobuf_read_start(struct videobuf_queue *q)
1010 {
1011 int rc;
1012
1013 videobuf_queue_lock(q);
1014 rc = __videobuf_read_start(q);
1015 videobuf_queue_unlock(q);
1016
1017 return rc;
1018 }
1019 EXPORT_SYMBOL_GPL(videobuf_read_start);
1020
1021 void videobuf_read_stop(struct videobuf_queue *q)
1022 {
1023 videobuf_queue_lock(q);
1024 __videobuf_read_stop(q);
1025 videobuf_queue_unlock(q);
1026 }
1027 EXPORT_SYMBOL_GPL(videobuf_read_stop);
1028
1029 void videobuf_stop(struct videobuf_queue *q)
1030 {
1031 videobuf_queue_lock(q);
1032
1033 if (q->streaming)
1034 __videobuf_streamoff(q);
1035
1036 if (q->reading)
1037 __videobuf_read_stop(q);
1038
1039 videobuf_queue_unlock(q);
1040 }
1041 EXPORT_SYMBOL_GPL(videobuf_stop);
1042
1043 ssize_t videobuf_read_stream(struct videobuf_queue *q,
1044 char __user *data, size_t count, loff_t *ppos,
1045 int vbihack, int nonblocking)
1046 {
1047 int rc, retval;
1048 unsigned long flags = 0;
1049
1050 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
1051
1052 dprintk(2, "%s\n", __func__);
1053 videobuf_queue_lock(q);
1054 retval = -EBUSY;
1055 if (q->streaming)
1056 goto done;
1057 if (!q->reading) {
1058 retval = __videobuf_read_start(q);
1059 if (retval < 0)
1060 goto done;
1061 }
1062
1063 retval = 0;
1064 while (count > 0) {
1065 /* get / wait for data */
1066 if (NULL == q->read_buf) {
1067 q->read_buf = list_entry(q->stream.next,
1068 struct videobuf_buffer,
1069 stream);
1070 list_del(&q->read_buf->stream);
1071 q->read_off = 0;
1072 }
1073 rc = videobuf_waiton(q, q->read_buf, nonblocking, 1);
1074 if (rc < 0) {
1075 if (0 == retval)
1076 retval = rc;
1077 break;
1078 }
1079
1080 if (q->read_buf->state == VIDEOBUF_DONE) {
1081 rc = __videobuf_copy_stream(q, q->read_buf, data + retval, count,
1082 retval, vbihack, nonblocking);
1083 if (rc < 0) {
1084 retval = rc;
1085 break;
1086 }
1087 retval += rc;
1088 count -= rc;
1089 q->read_off += rc;
1090 } else {
1091 /* some error */
1092 q->read_off = q->read_buf->size;
1093 if (0 == retval)
1094 retval = -EIO;
1095 }
1096
1097 /* requeue buffer when done with copying */
1098 if (q->read_off == q->read_buf->size) {
1099 list_add_tail(&q->read_buf->stream,
1100 &q->stream);
1101 spin_lock_irqsave(q->irqlock, flags);
1102 q->ops->buf_queue(q, q->read_buf);
1103 spin_unlock_irqrestore(q->irqlock, flags);
1104 q->read_buf = NULL;
1105 }
1106 if (retval < 0)
1107 break;
1108 }
1109
1110 done:
1111 videobuf_queue_unlock(q);
1112 return retval;
1113 }
1114 EXPORT_SYMBOL_GPL(videobuf_read_stream);
1115
1116 unsigned int videobuf_poll_stream(struct file *file,
1117 struct videobuf_queue *q,
1118 poll_table *wait)
1119 {
1120 unsigned long req_events = poll_requested_events(wait);
1121 struct videobuf_buffer *buf = NULL;
1122 unsigned int rc = 0;
1123
1124 videobuf_queue_lock(q);
1125 if (q->streaming) {
1126 if (!list_empty(&q->stream))
1127 buf = list_entry(q->stream.next,
1128 struct videobuf_buffer, stream);
1129 } else if (req_events & (POLLIN | POLLRDNORM)) {
1130 if (!q->reading)
1131 __videobuf_read_start(q);
1132 if (!q->reading) {
1133 rc = POLLERR;
1134 } else if (NULL == q->read_buf) {
1135 q->read_buf = list_entry(q->stream.next,
1136 struct videobuf_buffer,
1137 stream);
1138 list_del(&q->read_buf->stream);
1139 q->read_off = 0;
1140 }
1141 buf = q->read_buf;
1142 }
1143 if (!buf)
1144 rc = POLLERR;
1145
1146 if (0 == rc) {
1147 poll_wait(file, &buf->done, wait);
1148 if (buf->state == VIDEOBUF_DONE ||
1149 buf->state == VIDEOBUF_ERROR) {
1150 switch (q->type) {
1151 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1152 case V4L2_BUF_TYPE_VBI_OUTPUT:
1153 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1154 rc = POLLOUT | POLLWRNORM;
1155 break;
1156 default:
1157 rc = POLLIN | POLLRDNORM;
1158 break;
1159 }
1160 }
1161 }
1162 videobuf_queue_unlock(q);
1163 return rc;
1164 }
1165 EXPORT_SYMBOL_GPL(videobuf_poll_stream);
1166
1167 int videobuf_mmap_mapper(struct videobuf_queue *q, struct vm_area_struct *vma)
1168 {
1169 int rc = -EINVAL;
1170 int i;
1171
1172 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
1173
1174 if (!(vma->vm_flags & VM_WRITE) || !(vma->vm_flags & VM_SHARED)) {
1175 dprintk(1, "mmap appl bug: PROT_WRITE and MAP_SHARED are required\n");
1176 return -EINVAL;
1177 }
1178
1179 videobuf_queue_lock(q);
1180 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
1181 struct videobuf_buffer *buf = q->bufs[i];
1182
1183 if (buf && buf->memory == V4L2_MEMORY_MMAP &&
1184 buf->boff == (vma->vm_pgoff << PAGE_SHIFT)) {
1185 rc = CALL(q, mmap_mapper, q, buf, vma);
1186 break;
1187 }
1188 }
1189 videobuf_queue_unlock(q);
1190
1191 return rc;
1192 }
1193 EXPORT_SYMBOL_GPL(videobuf_mmap_mapper);
Linux kernel - Deliverables
This page took 0.056097 seconds and 5 git commands to generate.