drivers/media/video/videobuf-core.c

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