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