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