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