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 #define CALLPTR(q, f, arg...) \ 55 ((q->int_ops->f) ? q->int_ops->f(arg) : NULL) 56 57 struct videobuf_buffer *videobuf_alloc_vb(struct videobuf_queue *q) 58 { 59 struct videobuf_buffer *vb; 60 61 BUG_ON(q->msize < sizeof(*vb)); 62 63 if (!q->int_ops || !q->int_ops->alloc_vb) { 64 printk(KERN_ERR "No specific ops defined!\n"); 65 BUG(); 66 } 67 68 vb = q->int_ops->alloc_vb(q->msize); 69 if (NULL != vb) { 70 init_waitqueue_head(&vb->done); 71 vb->magic = MAGIC_BUFFER; 72 } 73 74 return vb; 75 } 76 EXPORT_SYMBOL_GPL(videobuf_alloc_vb); 77 78 static int is_state_active_or_queued(struct videobuf_queue *q, struct videobuf_buffer *vb) 79 { 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 89 int 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 95 MAGIC_CHECK(vb->magic, MAGIC_BUFFER); 96 97 if (non_blocking) { 98 if (is_state_active_or_queued(q, vb)) 99 return 0; 100 return -EAGAIN; 101 } 102 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); 109 if (intr) 110 ret = wait_event_interruptible(vb->done, is_state_active_or_queued(q, vb)); 111 else 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); 116 117 return ret; 118 } 119 EXPORT_SYMBOL_GPL(videobuf_waiton); 120 121 int videobuf_iolock(struct videobuf_queue *q, struct videobuf_buffer *vb, 122 struct v4l2_framebuffer *fbuf) 123 { 124 MAGIC_CHECK(vb->magic, MAGIC_BUFFER); 125 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 126 127 return CALL(q, iolock, q, vb, fbuf); 128 } 129 EXPORT_SYMBOL_GPL(videobuf_iolock); 130 131 void *videobuf_queue_to_vaddr(struct videobuf_queue *q, 132 struct videobuf_buffer *buf) 133 { 134 if (q->int_ops->vaddr) 135 return q->int_ops->vaddr(buf); 136 return NULL; 137 } 138 EXPORT_SYMBOL_GPL(videobuf_queue_to_vaddr); 139 140 /* --------------------------------------------------------------------- */ 141 142 143 void videobuf_queue_core_init(struct videobuf_queue *q, 144 const struct videobuf_queue_ops *ops, 145 struct device *dev, 146 spinlock_t *irqlock, 147 enum v4l2_buf_type type, 148 enum v4l2_field field, 149 unsigned int msize, 150 void *priv, 151 struct videobuf_qtype_ops *int_ops, 152 struct mutex *ext_lock) 153 { 154 BUG_ON(!q); 155 memset(q, 0, sizeof(*q)); 156 q->irqlock = irqlock; 157 q->ext_lock = ext_lock; 158 q->dev = dev; 159 q->type = type; 160 q->field = field; 161 q->msize = msize; 162 q->ops = ops; 163 q->priv_data = priv; 164 q->int_ops = int_ops; 165 166 /* All buffer operations are mandatory */ 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); 171 172 /* Lock is mandatory for queue_cancel to work */ 173 BUG_ON(!irqlock); 174 175 /* Having implementations for abstract methods are mandatory */ 176 BUG_ON(!q->int_ops); 177 178 mutex_init(&q->vb_lock); 179 init_waitqueue_head(&q->wait); 180 INIT_LIST_HEAD(&q->stream); 181 } 182 EXPORT_SYMBOL_GPL(videobuf_queue_core_init); 183 184 /* Locking: Only usage in bttv unsafe find way to remove */ 185 int videobuf_queue_is_busy(struct videobuf_queue *q) 186 { 187 int i; 188 189 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 190 191 if (q->streaming) { 192 dprintk(1, "busy: streaming active\n"); 193 return 1; 194 } 195 if (q->reading) { 196 dprintk(1, "busy: pending read #1\n"); 197 return 1; 198 } 199 if (q->read_buf) { 200 dprintk(1, "busy: pending read #2\n"); 201 return 1; 202 } 203 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 204 if (NULL == q->bufs[i]) 205 continue; 206 if (q->bufs[i]->map) { 207 dprintk(1, "busy: buffer #%d mapped\n", i); 208 return 1; 209 } 210 if (q->bufs[i]->state == VIDEOBUF_QUEUED) { 211 dprintk(1, "busy: buffer #%d queued\n", i); 212 return 1; 213 } 214 if (q->bufs[i]->state == VIDEOBUF_ACTIVE) { 215 dprintk(1, "busy: buffer #%d avtive\n", i); 216 return 1; 217 } 218 } 219 return 0; 220 } 221 EXPORT_SYMBOL_GPL(videobuf_queue_is_busy); 222 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 */ 230 static 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 262 /* Locking: Caller holds q->vb_lock */ 263 void videobuf_queue_cancel(struct videobuf_queue *q) 264 { 265 unsigned long flags = 0; 266 int i; 267 268 q->streaming = 0; 269 q->reading = 0; 270 wake_up_interruptible_sync(&q->wait); 271 272 /* remove queued buffers from list */ 273 spin_lock_irqsave(q->irqlock, flags); 274 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 275 if (NULL == q->bufs[i]) 276 continue; 277 if (q->bufs[i]->state == VIDEOBUF_QUEUED) { 278 list_del(&q->bufs[i]->queue); 279 q->bufs[i]->state = VIDEOBUF_ERROR; 280 wake_up_all(&q->bufs[i]->done); 281 } 282 } 283 spin_unlock_irqrestore(q->irqlock, flags); 284 285 /* free all buffers + clear queue */ 286 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 287 if (NULL == q->bufs[i]) 288 continue; 289 q->ops->buf_release(q, q->bufs[i]); 290 } 291 INIT_LIST_HEAD(&q->stream); 292 } 293 EXPORT_SYMBOL_GPL(videobuf_queue_cancel); 294 295 /* --------------------------------------------------------------------- */ 296 297 /* Locking: Caller holds q->vb_lock */ 298 enum 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 } 315 EXPORT_SYMBOL_GPL(videobuf_next_field); 316 317 /* Locking: Caller holds q->vb_lock */ 318 static void videobuf_status(struct videobuf_queue *q, struct v4l2_buffer *b, 319 struct videobuf_buffer *vb, enum v4l2_buf_type type) 320 { 321 MAGIC_CHECK(vb->magic, MAGIC_BUFFER); 322 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 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; 340 case V4L2_MEMORY_DMABUF: 341 /* DMABUF is not handled in videobuf framework */ 342 break; 343 } 344 345 b->flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 346 if (vb->map) 347 b->flags |= V4L2_BUF_FLAG_MAPPED; 348 349 switch (vb->state) { 350 case VIDEOBUF_PREPARED: 351 case VIDEOBUF_QUEUED: 352 case VIDEOBUF_ACTIVE: 353 b->flags |= V4L2_BUF_FLAG_QUEUED; 354 break; 355 case VIDEOBUF_ERROR: 356 b->flags |= V4L2_BUF_FLAG_ERROR; 357 /* fall through */ 358 case VIDEOBUF_DONE: 359 b->flags |= V4L2_BUF_FLAG_DONE; 360 break; 361 case VIDEOBUF_NEEDS_INIT: 362 case VIDEOBUF_IDLE: 363 /* nothing */ 364 break; 365 } 366 367 b->field = vb->field; 368 b->timestamp = vb->ts; 369 b->bytesused = vb->size; 370 b->sequence = vb->field_count >> 1; 371 } 372 373 int videobuf_mmap_free(struct videobuf_queue *q) 374 { 375 int ret; 376 videobuf_queue_lock(q); 377 ret = __videobuf_free(q); 378 videobuf_queue_unlock(q); 379 return ret; 380 } 381 EXPORT_SYMBOL_GPL(videobuf_mmap_free); 382 383 /* Locking: Caller holds q->vb_lock */ 384 int __videobuf_mmap_setup(struct videobuf_queue *q, 385 unsigned int bcount, unsigned int bsize, 386 enum v4l2_memory memory) 387 { 388 unsigned int i; 389 int err; 390 391 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 392 393 err = __videobuf_free(q); 394 if (0 != err) 395 return err; 396 397 /* Allocate and initialize buffers */ 398 for (i = 0; i < bcount; i++) { 399 q->bufs[i] = videobuf_alloc_vb(q); 400 401 if (NULL == q->bufs[i]) 402 break; 403 404 q->bufs[i]->i = i; 405 q->bufs[i]->memory = memory; 406 q->bufs[i]->bsize = bsize; 407 switch (memory) { 408 case V4L2_MEMORY_MMAP: 409 q->bufs[i]->boff = PAGE_ALIGN(bsize) * i; 410 break; 411 case V4L2_MEMORY_USERPTR: 412 case V4L2_MEMORY_OVERLAY: 413 case V4L2_MEMORY_DMABUF: 414 /* nothing */ 415 break; 416 } 417 } 418 419 if (!i) 420 return -ENOMEM; 421 422 dprintk(1, "mmap setup: %d buffers, %d bytes each\n", i, bsize); 423 424 return i; 425 } 426 EXPORT_SYMBOL_GPL(__videobuf_mmap_setup); 427 428 int videobuf_mmap_setup(struct videobuf_queue *q, 429 unsigned int bcount, unsigned int bsize, 430 enum v4l2_memory memory) 431 { 432 int ret; 433 videobuf_queue_lock(q); 434 ret = __videobuf_mmap_setup(q, bcount, bsize, memory); 435 videobuf_queue_unlock(q); 436 return ret; 437 } 438 EXPORT_SYMBOL_GPL(videobuf_mmap_setup); 439 440 int videobuf_reqbufs(struct videobuf_queue *q, 441 struct v4l2_requestbuffers *req) 442 { 443 unsigned int size, count; 444 int retval; 445 446 if (req->memory != V4L2_MEMORY_MMAP && 447 req->memory != V4L2_MEMORY_USERPTR && 448 req->memory != V4L2_MEMORY_OVERLAY) { 449 dprintk(1, "reqbufs: memory type invalid\n"); 450 return -EINVAL; 451 } 452 453 videobuf_queue_lock(q); 454 if (req->type != q->type) { 455 dprintk(1, "reqbufs: queue type invalid\n"); 456 retval = -EINVAL; 457 goto done; 458 } 459 460 if (q->streaming) { 461 dprintk(1, "reqbufs: streaming already exists\n"); 462 retval = -EBUSY; 463 goto done; 464 } 465 if (!list_empty(&q->stream)) { 466 dprintk(1, "reqbufs: stream running\n"); 467 retval = -EBUSY; 468 goto done; 469 } 470 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 477 count = req->count; 478 if (count > VIDEO_MAX_FRAME) 479 count = VIDEO_MAX_FRAME; 480 size = 0; 481 q->ops->buf_setup(q, &count, &size); 482 dprintk(1, "reqbufs: bufs=%d, size=0x%x [%u pages total]\n", 483 count, size, 484 (unsigned int)((count * PAGE_ALIGN(size)) >> PAGE_SHIFT)); 485 486 retval = __videobuf_mmap_setup(q, count, size, req->memory); 487 if (retval < 0) { 488 dprintk(1, "reqbufs: mmap setup returned %d\n", retval); 489 goto done; 490 } 491 492 req->count = retval; 493 retval = 0; 494 495 done: 496 videobuf_queue_unlock(q); 497 return retval; 498 } 499 EXPORT_SYMBOL_GPL(videobuf_reqbufs); 500 501 int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b) 502 { 503 int ret = -EINVAL; 504 505 videobuf_queue_lock(q); 506 if (unlikely(b->type != q->type)) { 507 dprintk(1, "querybuf: Wrong type.\n"); 508 goto done; 509 } 510 if (unlikely(b->index >= VIDEO_MAX_FRAME)) { 511 dprintk(1, "querybuf: index out of range.\n"); 512 goto done; 513 } 514 if (unlikely(NULL == q->bufs[b->index])) { 515 dprintk(1, "querybuf: buffer is null.\n"); 516 goto done; 517 } 518 519 videobuf_status(q, b, q->bufs[b->index], q->type); 520 521 ret = 0; 522 done: 523 videobuf_queue_unlock(q); 524 return ret; 525 } 526 EXPORT_SYMBOL_GPL(videobuf_querybuf); 527 528 int videobuf_qbuf(struct videobuf_queue *q, struct v4l2_buffer *b) 529 { 530 struct videobuf_buffer *buf; 531 enum v4l2_field field; 532 unsigned long flags = 0; 533 int retval; 534 535 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 536 537 if (b->memory == V4L2_MEMORY_MMAP) 538 down_read(¤t->mm->mmap_sem); 539 540 videobuf_queue_lock(q); 541 retval = -EBUSY; 542 if (q->reading) { 543 dprintk(1, "qbuf: Reading running...\n"); 544 goto done; 545 } 546 retval = -EINVAL; 547 if (b->type != q->type) { 548 dprintk(1, "qbuf: Wrong type.\n"); 549 goto done; 550 } 551 if (b->index >= VIDEO_MAX_FRAME) { 552 dprintk(1, "qbuf: index out of range.\n"); 553 goto done; 554 } 555 buf = q->bufs[b->index]; 556 if (NULL == buf) { 557 dprintk(1, "qbuf: buffer is null.\n"); 558 goto done; 559 } 560 MAGIC_CHECK(buf->magic, MAGIC_BUFFER); 561 if (buf->memory != b->memory) { 562 dprintk(1, "qbuf: memory type is wrong.\n"); 563 goto done; 564 } 565 if (buf->state != VIDEOBUF_NEEDS_INIT && buf->state != VIDEOBUF_IDLE) { 566 dprintk(1, "qbuf: buffer is already queued or active.\n"); 567 goto done; 568 } 569 570 switch (b->memory) { 571 case V4L2_MEMORY_MMAP: 572 if (0 == buf->baddr) { 573 dprintk(1, "qbuf: mmap requested " 574 "but buffer addr is zero!\n"); 575 goto done; 576 } 577 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT 578 || q->type == V4L2_BUF_TYPE_VBI_OUTPUT 579 || q->type == V4L2_BUF_TYPE_SLICED_VBI_OUTPUT 580 || q->type == V4L2_BUF_TYPE_SDR_OUTPUT) { 581 buf->size = b->bytesused; 582 buf->field = b->field; 583 buf->ts = b->timestamp; 584 } 585 break; 586 case V4L2_MEMORY_USERPTR: 587 if (b->length < buf->bsize) { 588 dprintk(1, "qbuf: buffer length is not enough\n"); 589 goto done; 590 } 591 if (VIDEOBUF_NEEDS_INIT != buf->state && 592 buf->baddr != b->m.userptr) 593 q->ops->buf_release(q, buf); 594 buf->baddr = b->m.userptr; 595 break; 596 case V4L2_MEMORY_OVERLAY: 597 buf->boff = b->m.offset; 598 break; 599 default: 600 dprintk(1, "qbuf: wrong memory type\n"); 601 goto done; 602 } 603 604 dprintk(1, "qbuf: requesting next field\n"); 605 field = videobuf_next_field(q); 606 retval = q->ops->buf_prepare(q, buf, field); 607 if (0 != retval) { 608 dprintk(1, "qbuf: buffer_prepare returned %d\n", retval); 609 goto done; 610 } 611 612 list_add_tail(&buf->stream, &q->stream); 613 if (q->streaming) { 614 spin_lock_irqsave(q->irqlock, flags); 615 q->ops->buf_queue(q, buf); 616 spin_unlock_irqrestore(q->irqlock, flags); 617 } 618 dprintk(1, "qbuf: succeeded\n"); 619 retval = 0; 620 wake_up_interruptible_sync(&q->wait); 621 622 done: 623 videobuf_queue_unlock(q); 624 625 if (b->memory == V4L2_MEMORY_MMAP) 626 up_read(¤t->mm->mmap_sem); 627 628 return retval; 629 } 630 EXPORT_SYMBOL_GPL(videobuf_qbuf); 631 632 /* Locking: Caller holds q->vb_lock */ 633 static int stream_next_buffer_check_queue(struct videobuf_queue *q, int noblock) 634 { 635 int retval; 636 637 checks: 638 if (!q->streaming) { 639 dprintk(1, "next_buffer: Not streaming\n"); 640 retval = -EINVAL; 641 goto done; 642 } 643 644 if (list_empty(&q->stream)) { 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 */ 653 videobuf_queue_unlock(q); 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); 660 videobuf_queue_lock(q); 661 662 if (retval) 663 goto done; 664 665 goto checks; 666 } 667 } 668 669 retval = 0; 670 671 done: 672 return retval; 673 } 674 675 /* Locking: Caller holds q->vb_lock */ 676 static 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 686 buf = list_entry(q->stream.next, struct videobuf_buffer, stream); 687 retval = videobuf_waiton(q, buf, nonblocking, 1); 688 if (retval < 0) 689 goto done; 690 691 *vb = buf; 692 done: 693 return retval; 694 } 695 696 int videobuf_dqbuf(struct videobuf_queue *q, 697 struct v4l2_buffer *b, int nonblocking) 698 { 699 struct videobuf_buffer *buf = NULL; 700 int retval; 701 702 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 703 704 memset(b, 0, sizeof(*b)); 705 videobuf_queue_lock(q); 706 707 retval = stream_next_buffer(q, &buf, nonblocking); 708 if (retval < 0) { 709 dprintk(1, "dqbuf: next_buffer error: %i\n", retval); 710 goto done; 711 } 712 713 switch (buf->state) { 714 case VIDEOBUF_ERROR: 715 dprintk(1, "dqbuf: state is error\n"); 716 break; 717 case VIDEOBUF_DONE: 718 dprintk(1, "dqbuf: state is done\n"); 719 break; 720 default: 721 dprintk(1, "dqbuf: state invalid\n"); 722 retval = -EINVAL; 723 goto done; 724 } 725 CALL(q, sync, q, buf); 726 videobuf_status(q, b, buf, q->type); 727 list_del(&buf->stream); 728 buf->state = VIDEOBUF_IDLE; 729 b->flags &= ~V4L2_BUF_FLAG_DONE; 730 done: 731 videobuf_queue_unlock(q); 732 return retval; 733 } 734 EXPORT_SYMBOL_GPL(videobuf_dqbuf); 735 736 int videobuf_streamon(struct videobuf_queue *q) 737 { 738 struct videobuf_buffer *buf; 739 unsigned long flags = 0; 740 int retval; 741 742 videobuf_queue_lock(q); 743 retval = -EBUSY; 744 if (q->reading) 745 goto done; 746 retval = 0; 747 if (q->streaming) 748 goto done; 749 q->streaming = 1; 750 spin_lock_irqsave(q->irqlock, flags); 751 list_for_each_entry(buf, &q->stream, stream) 752 if (buf->state == VIDEOBUF_PREPARED) 753 q->ops->buf_queue(q, buf); 754 spin_unlock_irqrestore(q->irqlock, flags); 755 756 wake_up_interruptible_sync(&q->wait); 757 done: 758 videobuf_queue_unlock(q); 759 return retval; 760 } 761 EXPORT_SYMBOL_GPL(videobuf_streamon); 762 763 /* Locking: Caller holds q->vb_lock */ 764 static int __videobuf_streamoff(struct videobuf_queue *q) 765 { 766 if (!q->streaming) 767 return -EINVAL; 768 769 videobuf_queue_cancel(q); 770 771 return 0; 772 } 773 774 int videobuf_streamoff(struct videobuf_queue *q) 775 { 776 int retval; 777 778 videobuf_queue_lock(q); 779 retval = __videobuf_streamoff(q); 780 videobuf_queue_unlock(q); 781 782 return retval; 783 } 784 EXPORT_SYMBOL_GPL(videobuf_streamoff); 785 786 /* Locking: Caller holds q->vb_lock */ 787 static 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; 792 unsigned long flags = 0; 793 int retval; 794 795 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 796 797 /* setup stuff */ 798 q->read_buf = videobuf_alloc_vb(q); 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); 807 retval = q->ops->buf_prepare(q, q->read_buf, field); 808 if (0 != retval) 809 goto done; 810 811 /* start capture & wait */ 812 spin_lock_irqsave(q->irqlock, flags); 813 q->ops->buf_queue(q, q->read_buf); 814 spin_unlock_irqrestore(q->irqlock, flags); 815 retval = videobuf_waiton(q, q->read_buf, 0, 0); 816 if (0 == retval) { 817 CALL(q, sync, q, q->read_buf); 818 if (VIDEOBUF_ERROR == q->read_buf->state) 819 retval = -EIO; 820 else 821 retval = q->read_buf->size; 822 } 823 824 done: 825 /* cleanup */ 826 q->ops->buf_release(q, q->read_buf); 827 kfree(q->read_buf); 828 q->read_buf = NULL; 829 return retval; 830 } 831 832 static 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 { 837 void *vaddr = CALLPTR(q, vaddr, buf); 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 849 static 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 { 854 unsigned int *fc = CALLPTR(q, vaddr, buf); 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 875 ssize_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; 880 unsigned long flags = 0; 881 unsigned size = 0, nbufs = 1; 882 int retval; 883 884 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 885 886 videobuf_queue_lock(q); 887 888 q->ops->buf_setup(q, &nbufs, &size); 889 890 if (NULL == q->read_buf && 891 count >= size && 892 !nonblocking) { 893 retval = videobuf_read_zerocopy(q, data, count, ppos); 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; 903 q->read_buf = videobuf_alloc_vb(q); 904 905 dprintk(1, "video alloc=0x%p\n", q->read_buf); 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); 911 retval = q->ops->buf_prepare(q, q->read_buf, field); 912 913 if (0 != retval) { 914 kfree(q->read_buf); 915 q->read_buf = NULL; 916 goto done; 917 } 918 919 spin_lock_irqsave(q->irqlock, flags); 920 q->ops->buf_queue(q, q->read_buf); 921 spin_unlock_irqrestore(q->irqlock, flags); 922 923 q->read_off = 0; 924 } 925 926 /* wait until capture is done */ 927 retval = videobuf_waiton(q, q->read_buf, nonblocking, 1); 928 if (0 != retval) 929 goto done; 930 931 CALL(q, sync, q, q->read_buf); 932 933 if (VIDEOBUF_ERROR == q->read_buf->state) { 934 /* catch I/O errors */ 935 q->ops->buf_release(q, q->read_buf); 936 kfree(q->read_buf); 937 q->read_buf = NULL; 938 retval = -EIO; 939 goto done; 940 } 941 942 /* Copy to userspace */ 943 retval = __videobuf_copy_to_user(q, q->read_buf, data, count, nonblocking); 944 if (retval < 0) 945 goto done; 946 947 q->read_off += retval; 948 if (q->read_off == q->read_buf->size) { 949 /* all data copied, cleanup */ 950 q->ops->buf_release(q, q->read_buf); 951 kfree(q->read_buf); 952 q->read_buf = NULL; 953 } 954 955 done: 956 videobuf_queue_unlock(q); 957 return retval; 958 } 959 EXPORT_SYMBOL_GPL(videobuf_read_one); 960 961 /* Locking: Caller holds q->vb_lock */ 962 static int __videobuf_read_start(struct videobuf_queue *q) 963 { 964 enum v4l2_field field; 965 unsigned long flags = 0; 966 unsigned int count = 0, size = 0; 967 int err, i; 968 969 q->ops->buf_setup(q, &count, &size); 970 if (count < 2) 971 count = 2; 972 if (count > VIDEO_MAX_FRAME) 973 count = VIDEO_MAX_FRAME; 974 size = PAGE_ALIGN(size); 975 976 err = __videobuf_mmap_setup(q, count, size, V4L2_MEMORY_USERPTR); 977 if (err < 0) 978 return err; 979 980 count = err; 981 982 for (i = 0; i < count; i++) { 983 field = videobuf_next_field(q); 984 err = q->ops->buf_prepare(q, q->bufs[i], field); 985 if (err) 986 return err; 987 list_add_tail(&q->bufs[i]->stream, &q->stream); 988 } 989 spin_lock_irqsave(q->irqlock, flags); 990 for (i = 0; i < count; i++) 991 q->ops->buf_queue(q, q->bufs[i]); 992 spin_unlock_irqrestore(q->irqlock, flags); 993 q->reading = 1; 994 return 0; 995 } 996 997 static void __videobuf_read_stop(struct videobuf_queue *q) 998 { 999 int i; 1000 1001 videobuf_queue_cancel(q); 1002 __videobuf_free(q); 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; 1011 } 1012 1013 int videobuf_read_start(struct videobuf_queue *q) 1014 { 1015 int rc; 1016 1017 videobuf_queue_lock(q); 1018 rc = __videobuf_read_start(q); 1019 videobuf_queue_unlock(q); 1020 1021 return rc; 1022 } 1023 EXPORT_SYMBOL_GPL(videobuf_read_start); 1024 1025 void videobuf_read_stop(struct videobuf_queue *q) 1026 { 1027 videobuf_queue_lock(q); 1028 __videobuf_read_stop(q); 1029 videobuf_queue_unlock(q); 1030 } 1031 EXPORT_SYMBOL_GPL(videobuf_read_stop); 1032 1033 void videobuf_stop(struct videobuf_queue *q) 1034 { 1035 videobuf_queue_lock(q); 1036 1037 if (q->streaming) 1038 __videobuf_streamoff(q); 1039 1040 if (q->reading) 1041 __videobuf_read_stop(q); 1042 1043 videobuf_queue_unlock(q); 1044 } 1045 EXPORT_SYMBOL_GPL(videobuf_stop); 1046 1047 ssize_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; 1052 unsigned long flags = 0; 1053 1054 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 1055 1056 dprintk(2, "%s\n", __func__); 1057 videobuf_queue_lock(q); 1058 retval = -EBUSY; 1059 if (q->streaming) 1060 goto done; 1061 if (!q->reading) { 1062 retval = __videobuf_read_start(q); 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 } 1077 rc = videobuf_waiton(q, q->read_buf, nonblocking, 1); 1078 if (rc < 0) { 1079 if (0 == retval) 1080 retval = rc; 1081 break; 1082 } 1083 1084 if (q->read_buf->state == VIDEOBUF_DONE) { 1085 rc = __videobuf_copy_stream(q, q->read_buf, data + retval, count, 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); 1105 spin_lock_irqsave(q->irqlock, flags); 1106 q->ops->buf_queue(q, q->read_buf); 1107 spin_unlock_irqrestore(q->irqlock, flags); 1108 q->read_buf = NULL; 1109 } 1110 if (retval < 0) 1111 break; 1112 } 1113 1114 done: 1115 videobuf_queue_unlock(q); 1116 return retval; 1117 } 1118 EXPORT_SYMBOL_GPL(videobuf_read_stream); 1119 1120 unsigned int videobuf_poll_stream(struct file *file, 1121 struct videobuf_queue *q, 1122 poll_table *wait) 1123 { 1124 unsigned long req_events = poll_requested_events(wait); 1125 struct videobuf_buffer *buf = NULL; 1126 unsigned int rc = 0; 1127 1128 videobuf_queue_lock(q); 1129 if (q->streaming) { 1130 if (!list_empty(&q->stream)) 1131 buf = list_entry(q->stream.next, 1132 struct videobuf_buffer, stream); 1133 } else if (req_events & (POLLIN | POLLRDNORM)) { 1134 if (!q->reading) 1135 __videobuf_read_start(q); 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); 1152 if (buf->state == VIDEOBUF_DONE || 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: 1158 case V4L2_BUF_TYPE_SDR_OUTPUT: 1159 rc = POLLOUT | POLLWRNORM; 1160 break; 1161 default: 1162 rc = POLLIN | POLLRDNORM; 1163 break; 1164 } 1165 } 1166 } 1167 videobuf_queue_unlock(q); 1168 return rc; 1169 } 1170 EXPORT_SYMBOL_GPL(videobuf_poll_stream); 1171 1172 int videobuf_mmap_mapper(struct videobuf_queue *q, struct vm_area_struct *vma) 1173 { 1174 int rc = -EINVAL; 1175 int i; 1176 1177 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS); 1178 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 1184 videobuf_queue_lock(q); 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 } 1194 videobuf_queue_unlock(q); 1195 1196 return rc; 1197 } 1198 EXPORT_SYMBOL_GPL(videobuf_mmap_mapper); 1199