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
 443  done:
 444         mutex_unlock(&q->vb_lock);
 445         return retval;
 446 }
 447
 448 int videobuf_querybuf(struct videobuf_queue *q, struct v4l2_buffer *b)
 449 {
 450         int ret = -EINVAL;
 451
 452         mutex_lock(&q->vb_lock);
 453         if (unlikely(b->type != q->type)) {
 454                 dprintk(1, "querybuf: Wrong type.\n");
 455                 goto done;
 456         }
 457         if (unlikely(b->index < 0 || b->index >= VIDEO_MAX_FRAME)) {
 458                 dprintk(1, "querybuf: index out of range.\n");
 459                 goto done;
 460         }
 461         if (unlikely(NULL == q->bufs[b->index])) {
 462                 dprintk(1, "querybuf: buffer is null.\n");
 463                 goto done;
 464         }
 465
 466         videobuf_status(q, b, q->bufs[b->index], q->type);
 467
 468         ret = 0;
 469 done:
 470         mutex_unlock(&q->vb_lock);
 471         return ret;
 472 }
 473
 474 int videobuf_qbuf(struct videobuf_queue *q,
 475               struct v4l2_buffer *b)
 476 {
 477         struct videobuf_buffer *buf;
 478         enum v4l2_field field;
 479         unsigned long flags = 0;
 480         int retval;
 481
 482         MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
 483
 484         if (b->memory == V4L2_MEMORY_MMAP)
 485                 down_read(&current->mm->mmap_sem);
 486
 487         mutex_lock(&q->vb_lock);
 488         retval = -EBUSY;
 489         if (q->reading) {
 490                 dprintk(1, "qbuf: Reading running...\n");
 491                 goto done;
 492         }
 493         retval = -EINVAL;
 494         if (b->type != q->type) {
 495                 dprintk(1, "qbuf: Wrong type.\n");
 496                 goto done;
 497         }
 498         if (b->index < 0 || b->index >= VIDEO_MAX_FRAME) {
 499                 dprintk(1, "qbuf: index out of range.\n");
 500                 goto done;
 501         }
 502         buf = q->bufs[b->index];
 503         if (NULL == buf) {
 504                 dprintk(1, "qbuf: buffer is null.\n");
 505                 goto done;
 506         }
 507         MAGIC_CHECK(buf->magic, MAGIC_BUFFER);
 508         if (buf->memory != b->memory) {
 509                 dprintk(1, "qbuf: memory type is wrong.\n");
 510                 goto done;
 511         }
 512         if (buf->state != VIDEOBUF_NEEDS_INIT && buf->state != VIDEOBUF_IDLE) {
 513                 dprintk(1, "qbuf: buffer is already queued or active.\n");
 514                 goto done;
 515         }
 516
 517         if (b->flags & V4L2_BUF_FLAG_INPUT) {
 518                 if (b->input >= q->inputs) {
 519                         dprintk(1, "qbuf: wrong input.\n");
 520                         goto done;
 521                 }
 522                 buf->input = b->input;
 523         } else {
 524                 buf->input = UNSET;
 525         }
 526
 527         switch (b->memory) {
 528         case V4L2_MEMORY_MMAP:
 529                 if (0 == buf->baddr) {
 530                         dprintk(1, "qbuf: mmap requested "
 531                                    "but buffer addr is zero!\n");
 532                         goto done;
 533                 }
 534                 break;
 535         case V4L2_MEMORY_USERPTR:
 536                 if (b->length < buf->bsize) {
 537                         dprintk(1, "qbuf: buffer length is not enough\n");
 538                         goto done;
 539                 }
 540                 if (VIDEOBUF_NEEDS_INIT != buf->state &&
 541                     buf->baddr != b->m.userptr)
 542                         q->ops->buf_release(q, buf);
 543                 buf->baddr = b->m.userptr;
 544                 break;
 545         case V4L2_MEMORY_OVERLAY:
 546                 buf->boff = b->m.offset;
 547                 break;
 548         default:
 549                 dprintk(1, "qbuf: wrong memory type\n");
 550                 goto done;
 551         }
 552
 553         dprintk(1, "qbuf: requesting next field\n");
 554         field = videobuf_next_field(q);
 555         retval = q->ops->buf_prepare(q, buf, field);
 556         if (0 != retval) {
 557                 dprintk(1, "qbuf: buffer_prepare returned %d\n", retval);
 558                 goto done;
 559         }
 560
 561         list_add_tail(&buf->stream, &q->stream);
 562         if (q->streaming) {
 563                 spin_lock_irqsave(q->irqlock, flags);
 564                 q->ops->buf_queue(q, buf);
 565                 spin_unlock_irqrestore(q->irqlock, flags);
 566         }
 567         dprintk(1, "qbuf: succeded\n");
 568         retval = 0;
 569         wake_up_interruptible_sync(&q->wait);
 570
 571  done:
 572         mutex_unlock(&q->vb_lock);
 573
 574         if (b->memory == V4L2_MEMORY_MMAP)
 575                 up_read(&current->mm->mmap_sem);
 576
 577         return retval;
 578 }
 579
 580
 581 /* Locking: Caller holds q->vb_lock */
 582 static int stream_next_buffer_check_queue(struct videobuf_queue *q, int noblock)
 583 {
 584         int retval;
 585
 586 checks:
 587         if (!q->streaming) {
 588                 dprintk(1, "next_buffer: Not streaming\n");
 589                 retval = -EINVAL;
 590                 goto done;
 591         }
 592
 593         if (list_empty(&q->stream)) {
 594                 if (noblock) {
 595                         retval = -EAGAIN;
 596                         dprintk(2, "next_buffer: no buffers to dequeue\n");
 597                         goto done;
 598                 } else {
 599                         dprintk(2, "next_buffer: waiting on buffer\n");
 600
 601                         /* Drop lock to avoid deadlock with qbuf */
 602                         mutex_unlock(&q->vb_lock);
 603
 604                         /* Checking list_empty and streaming is safe without
 605                          * locks because we goto checks to validate while
 606                          * holding locks before proceeding */
 607                         retval = wait_event_interruptible(q->wait,
 608                                 !list_empty(&q->stream) || !q->streaming);
 609                         mutex_lock(&q->vb_lock);
 610
 611                         if (retval)
 612                                 goto done;
 613
 614                         goto checks;
 615                 }
 616         }
 617
 618         retval = 0;
 619
 620 done:
 621         return retval;
 622 }
 623
 624
 625 /* Locking: Caller holds q->vb_lock */
 626 static int stream_next_buffer(struct videobuf_queue *q,
 627                         struct videobuf_buffer **vb, int nonblocking)
 628 {
 629         int retval;
 630         struct videobuf_buffer *buf = NULL;
 631
 632         retval = stream_next_buffer_check_queue(q, nonblocking);
 633         if (retval)
 634                 goto done;
 635
 636         buf = list_entry(q->stream.next, struct videobuf_buffer, stream);
 637         retval = videobuf_waiton(buf, nonblocking, 1);
 638         if (retval < 0)
 639                 goto done;
 640
 641         *vb = buf;
 642 done:
 643         return retval;
 644 }
 645
 646 int videobuf_dqbuf(struct videobuf_queue *q,
 647                struct v4l2_buffer *b, int nonblocking)
 648 {
 649         struct videobuf_buffer *buf = NULL;
 650         int retval;
 651
 652         MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
 653
 654         mutex_lock(&q->vb_lock);
 655
 656         retval = stream_next_buffer(q, &buf, nonblocking);
 657         if (retval < 0) {
 658                 dprintk(1, "dqbuf: next_buffer error: %i\n", retval);
 659                 goto done;
 660         }
 661
 662         switch (buf->state) {
 663         case VIDEOBUF_ERROR:
 664                 dprintk(1, "dqbuf: state is error\n");
 665                 retval = -EIO;
 666                 CALL(q, sync, q, buf);
 667                 buf->state = VIDEOBUF_IDLE;
 668                 break;
 669         case VIDEOBUF_DONE:
 670                 dprintk(1, "dqbuf: state is done\n");
 671                 CALL(q, sync, q, buf);
 672                 buf->state = VIDEOBUF_IDLE;
 673                 break;
 674         default:
 675                 dprintk(1, "dqbuf: state invalid\n");
 676                 retval = -EINVAL;
 677                 goto done;
 678         }
 679         list_del(&buf->stream);
 680         memset(b, 0, sizeof(*b));
 681         videobuf_status(q, b, buf, q->type);
 682
 683  done:
 684         mutex_unlock(&q->vb_lock);
 685         return retval;
 686 }
 687
 688 int videobuf_streamon(struct videobuf_queue *q)
 689 {
 690         struct videobuf_buffer *buf;
 691         unsigned long flags = 0;
 692         int retval;
 693
 694         mutex_lock(&q->vb_lock);
 695         retval = -EBUSY;
 696         if (q->reading)
 697                 goto done;
 698         retval = 0;
 699         if (q->streaming)
 700                 goto done;
 701         q->streaming = 1;
 702         spin_lock_irqsave(q->irqlock, flags);
 703         list_for_each_entry(buf, &q->stream, stream)
 704                 if (buf->state == VIDEOBUF_PREPARED)
 705                         q->ops->buf_queue(q, buf);
 706         spin_unlock_irqrestore(q->irqlock, flags);
 707
 708         wake_up_interruptible_sync(&q->wait);
 709  done:
 710         mutex_unlock(&q->vb_lock);
 711         return retval;
 712 }
 713
 714 /* Locking: Caller holds q->vb_lock */
 715 static int __videobuf_streamoff(struct videobuf_queue *q)
 716 {
 717         if (!q->streaming)
 718                 return -EINVAL;
 719
 720         videobuf_queue_cancel(q);
 721
 722         return 0;
 723 }
 724
 725 int videobuf_streamoff(struct videobuf_queue *q)
 726 {
 727         int retval;
 728
 729         mutex_lock(&q->vb_lock);
 730         retval = __videobuf_streamoff(q);
 731         mutex_unlock(&q->vb_lock);
 732
 733         return retval;
 734 }
 735
 736 /* Locking: Caller holds q->vb_lock */
 737 static ssize_t videobuf_read_zerocopy(struct videobuf_queue *q,
 738                                       char __user *data,
 739                                       size_t count, loff_t *ppos)
 740 {
 741         enum v4l2_field field;
 742         unsigned long flags = 0;
 743         int retval;
 744
 745         MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
 746
 747         /* setup stuff */
 748         q->read_buf = videobuf_alloc(q);
 749         if (NULL == q->read_buf)
 750                 return -ENOMEM;
 751
 752         q->read_buf->memory = V4L2_MEMORY_USERPTR;
 753         q->read_buf->baddr  = (unsigned long)data;
 754         q->read_buf->bsize  = count;
 755
 756         field = videobuf_next_field(q);
 757         retval = q->ops->buf_prepare(q, q->read_buf, field);
 758         if (0 != retval)
 759                 goto done;
 760
 761         /* start capture & wait */
 762         spin_lock_irqsave(q->irqlock, flags);
 763         q->ops->buf_queue(q, q->read_buf);
 764         spin_unlock_irqrestore(q->irqlock, flags);
 765         retval = videobuf_waiton(q->read_buf, 0, 0);
 766         if (0 == retval) {
 767                 CALL(q, sync, q, q->read_buf);
 768                 if (VIDEOBUF_ERROR == q->read_buf->state)
 769                         retval = -EIO;
 770                 else
 771                         retval = q->read_buf->size;
 772         }
 773
 774  done:
 775         /* cleanup */
 776         q->ops->buf_release(q, q->read_buf);
 777         kfree(q->read_buf);
 778         q->read_buf = NULL;
 779         return retval;
 780 }
 781
 782 ssize_t videobuf_read_one(struct videobuf_queue *q,
 783                           char __user *data, size_t count, loff_t *ppos,
 784                           int nonblocking)
 785 {
 786         enum v4l2_field field;
 787         unsigned long flags = 0;
 788         unsigned size = 0, nbufs = 1;
 789         int retval;
 790
 791         MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
 792
 793         mutex_lock(&q->vb_lock);
 794
 795         q->ops->buf_setup(q, &nbufs, &size);
 796
 797         if (NULL == q->read_buf  &&
 798             count >= size        &&
 799             !nonblocking) {
 800                 retval = videobuf_read_zerocopy(q, data, count, ppos);
 801                 if (retval >= 0  ||  retval == -EIO)
 802                         /* ok, all done */
 803                         goto done;
 804                 /* fallback to kernel bounce buffer on failures */
 805         }
 806
 807         if (NULL == q->read_buf) {
 808                 /* need to capture a new frame */
 809                 retval = -ENOMEM;
 810                 q->read_buf = videobuf_alloc(q);
 811
 812                 dprintk(1, "video alloc=0x%p\n", q->read_buf);
 813                 if (NULL == q->read_buf)
 814                         goto done;
 815                 q->read_buf->memory = V4L2_MEMORY_USERPTR;
 816                 q->read_buf->bsize = count; /* preferred size */
 817                 field = videobuf_next_field(q);
 818                 retval = q->ops->buf_prepare(q, q->read_buf, field);
 819
 820                 if (0 != retval) {
 821                         kfree(q->read_buf);
 822                         q->read_buf = NULL;
 823                         goto done;
 824                 }
 825
 826                 spin_lock_irqsave(q->irqlock, flags);
 827                 q->ops->buf_queue(q, q->read_buf);
 828                 spin_unlock_irqrestore(q->irqlock, flags);
 829
 830                 q->read_off = 0;
 831         }
 832
 833         /* wait until capture is done */
 834         retval = videobuf_waiton(q->read_buf, nonblocking, 1);
 835         if (0 != retval)
 836                 goto done;
 837
 838         CALL(q, sync, q, q->read_buf);
 839
 840         if (VIDEOBUF_ERROR == q->read_buf->state) {
 841                 /* catch I/O errors */
 842                 q->ops->buf_release(q, q->read_buf);
 843                 kfree(q->read_buf);
 844                 q->read_buf = NULL;
 845                 retval = -EIO;
 846                 goto done;
 847         }
 848
 849         /* Copy to userspace */
 850         retval = CALL(q, video_copy_to_user, q, data, count, nonblocking);
 851         if (retval < 0)
 852                 goto done;
 853
 854         q->read_off += retval;
 855         if (q->read_off == q->read_buf->size) {
 856                 /* all data copied, cleanup */
 857                 q->ops->buf_release(q, q->read_buf);
 858                 kfree(q->read_buf);
 859                 q->read_buf = NULL;
 860         }
 861
 862  done:
 863         mutex_unlock(&q->vb_lock);
 864         return retval;
 865 }
 866
 867 /* Locking: Caller holds q->vb_lock */
 868 static int __videobuf_read_start(struct videobuf_queue *q)
 869 {
 870         enum v4l2_field field;
 871         unsigned long flags = 0;
 872         unsigned int count = 0, size = 0;
 873         int err, i;
 874
 875         q->ops->buf_setup(q, &count, &size);
 876         if (count < 2)
 877                 count = 2;
 878         if (count > VIDEO_MAX_FRAME)
 879                 count = VIDEO_MAX_FRAME;
 880         size = PAGE_ALIGN(size);
 881
 882         err = __videobuf_mmap_setup(q, count, size, V4L2_MEMORY_USERPTR);
 883         if (err < 0)
 884                 return err;
 885
 886         count = err;
 887
 888         for (i = 0; i < count; i++) {
 889                 field = videobuf_next_field(q);
 890                 err = q->ops->buf_prepare(q, q->bufs[i], field);
 891                 if (err)
 892                         return err;
 893                 list_add_tail(&q->bufs[i]->stream, &q->stream);
 894         }
 895         spin_lock_irqsave(q->irqlock, flags);
 896         for (i = 0; i < count; i++)
 897                 q->ops->buf_queue(q, q->bufs[i]);
 898         spin_unlock_irqrestore(q->irqlock, flags);
 899         q->reading = 1;
 900         return 0;
 901 }
 902
 903 static void __videobuf_read_stop(struct videobuf_queue *q)
 904 {
 905         int i;
 906
 907         videobuf_queue_cancel(q);
 908         __videobuf_mmap_free(q);
 909         INIT_LIST_HEAD(&q->stream);
 910         for (i = 0; i < VIDEO_MAX_FRAME; i++) {
 911                 if (NULL == q->bufs[i])
 912                         continue;
 913                 kfree(q->bufs[i]);
 914                 q->bufs[i] = NULL;
 915         }
 916         q->read_buf = NULL;
 917
 918 }
 919
 920 int videobuf_read_start(struct videobuf_queue *q)
 921 {
 922         int rc;
 923
 924         mutex_lock(&q->vb_lock);
 925         rc = __videobuf_read_start(q);
 926         mutex_unlock(&q->vb_lock);
 927
 928         return rc;
 929 }
 930
 931 void videobuf_read_stop(struct videobuf_queue *q)
 932 {
 933         mutex_lock(&q->vb_lock);
 934         __videobuf_read_stop(q);
 935         mutex_unlock(&q->vb_lock);
 936 }
 937
 938 void videobuf_stop(struct videobuf_queue *q)
 939 {
 940         mutex_lock(&q->vb_lock);
 941
 942         if (q->streaming)
 943                 __videobuf_streamoff(q);
 944
 945         if (q->reading)
 946                 __videobuf_read_stop(q);
 947
 948         mutex_unlock(&q->vb_lock);
 949 }
 950
 951
 952 ssize_t videobuf_read_stream(struct videobuf_queue *q,
 953                              char __user *data, size_t count, loff_t *ppos,
 954                              int vbihack, int nonblocking)
 955 {
 956         int rc, retval;
 957         unsigned long flags = 0;
 958
 959         MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
 960
 961         dprintk(2, "%s\n", __func__);
 962         mutex_lock(&q->vb_lock);
 963         retval = -EBUSY;
 964         if (q->streaming)
 965                 goto done;
 966         if (!q->reading) {
 967                 retval = __videobuf_read_start(q);
 968                 if (retval < 0)
 969                         goto done;
 970         }
 971
 972         retval = 0;
 973         while (count > 0) {
 974                 /* get / wait for data */
 975                 if (NULL == q->read_buf) {
 976                         q->read_buf = list_entry(q->stream.next,
 977                                                  struct videobuf_buffer,
 978                                                  stream);
 979                         list_del(&q->read_buf->stream);
 980                         q->read_off = 0;
 981                 }
 982                 rc = videobuf_waiton(q->read_buf, nonblocking, 1);
 983                 if (rc < 0) {
 984                         if (0 == retval)
 985                                 retval = rc;
 986                         break;
 987                 }
 988
 989                 if (q->read_buf->state == VIDEOBUF_DONE) {
 990                         rc = CALL(q, copy_stream, q, data + retval, count,
 991                                         retval, vbihack, nonblocking);
 992                         if (rc < 0) {
 993                                 retval = rc;
 994                                 break;
 995                         }
 996                         retval      += rc;
 997                         count       -= rc;
 998                         q->read_off += rc;
 999                 } else {
1000                         /* some error */
1001                         q->read_off = q->read_buf->size;
1002                         if (0 == retval)
1003                                 retval = -EIO;
1004                 }
1005
1006                 /* requeue buffer when done with copying */
1007                 if (q->read_off == q->read_buf->size) {
1008                         list_add_tail(&q->read_buf->stream,
1009                                       &q->stream);
1010                         spin_lock_irqsave(q->irqlock, flags);
1011                         q->ops->buf_queue(q, q->read_buf);
1012                         spin_unlock_irqrestore(q->irqlock, flags);
1013                         q->read_buf = NULL;
1014                 }
1015                 if (retval < 0)
1016                         break;
1017         }
1018
1019  done:
1020         mutex_unlock(&q->vb_lock);
1021         return retval;
1022 }
1023
1024 unsigned int videobuf_poll_stream(struct file *file,
1025                                   struct videobuf_queue *q,
1026                                   poll_table *wait)
1027 {
1028         struct videobuf_buffer *buf = NULL;
1029         unsigned int rc = 0;
1030
1031         mutex_lock(&q->vb_lock);
1032         if (q->streaming) {
1033                 if (!list_empty(&q->stream))
1034                         buf = list_entry(q->stream.next,
1035                                          struct videobuf_buffer, stream);
1036         } else {
1037                 if (!q->reading)
1038                         __videobuf_read_start(q);
1039                 if (!q->reading) {
1040                         rc = POLLERR;
1041                 } else if (NULL == q->read_buf) {
1042                         q->read_buf = list_entry(q->stream.next,
1043                                                  struct videobuf_buffer,
1044                                                  stream);
1045                         list_del(&q->read_buf->stream);
1046                         q->read_off = 0;
1047                 }
1048                 buf = q->read_buf;
1049         }
1050         if (!buf)
1051                 rc = POLLERR;
1052
1053         if (0 == rc) {
1054                 poll_wait(file, &buf->done, wait);
1055                 if (buf->state == VIDEOBUF_DONE ||
1056                     buf->state == VIDEOBUF_ERROR)
1057                         rc = POLLIN|POLLRDNORM;
1058         }
1059         mutex_unlock(&q->vb_lock);
1060         return rc;
1061 }
1062
1063 int videobuf_mmap_mapper(struct videobuf_queue *q,
1064                          struct vm_area_struct *vma)
1065 {
1066         int retval;
1067
1068         MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
1069
1070         mutex_lock(&q->vb_lock);
1071         retval = CALL(q, mmap_mapper, q, vma);
1072         q->is_mmapped = 1;
1073         mutex_unlock(&q->vb_lock);
1074
1075         return retval;
1076 }
1077
1078 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1079 int videobuf_cgmbuf(struct videobuf_queue *q,
1080                     struct video_mbuf *mbuf, int count)
1081 {
1082         struct v4l2_requestbuffers req;
1083         int rc, i;
1084
1085         MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
1086
1087         memset(&req, 0, sizeof(req));
1088         req.type   = q->type;
1089         req.count  = count;
1090         req.memory = V4L2_MEMORY_MMAP;
1091         rc = videobuf_reqbufs(q, &req);
1092         if (rc < 0)
1093                 return rc;
1094
1095         mbuf->frames = req.count;
1096         mbuf->size   = 0;
1097         for (i = 0; i < mbuf->frames; i++) {
1098                 mbuf->offsets[i]  = q->bufs[i]->boff;
1099                 mbuf->size       += q->bufs[i]->bsize;
1100         }
1101
1102         return 0;
1103 }
1104 EXPORT_SYMBOL_GPL(videobuf_cgmbuf);
1105 #endif
1106
1107 /* --------------------------------------------------------------------- */
1108
1109 EXPORT_SYMBOL_GPL(videobuf_waiton);
1110 EXPORT_SYMBOL_GPL(videobuf_iolock);
1111
1112 EXPORT_SYMBOL_GPL(videobuf_alloc);
1113
1114 EXPORT_SYMBOL_GPL(videobuf_queue_core_init);
1115 EXPORT_SYMBOL_GPL(videobuf_queue_cancel);
1116 EXPORT_SYMBOL_GPL(videobuf_queue_is_busy);
1117
1118 EXPORT_SYMBOL_GPL(videobuf_next_field);
1119 EXPORT_SYMBOL_GPL(videobuf_reqbufs);
1120 EXPORT_SYMBOL_GPL(videobuf_querybuf);
1121 EXPORT_SYMBOL_GPL(videobuf_qbuf);
1122 EXPORT_SYMBOL_GPL(videobuf_dqbuf);
1123 EXPORT_SYMBOL_GPL(videobuf_streamon);
1124 EXPORT_SYMBOL_GPL(videobuf_streamoff);
1125
1126 EXPORT_SYMBOL_GPL(videobuf_read_start);
1127 EXPORT_SYMBOL_GPL(videobuf_read_stop);
1128 EXPORT_SYMBOL_GPL(videobuf_stop);
1129 EXPORT_SYMBOL_GPL(videobuf_read_stream);
1130 EXPORT_SYMBOL_GPL(videobuf_read_one);
1131 EXPORT_SYMBOL_GPL(videobuf_poll_stream);
1132
1133 EXPORT_SYMBOL_GPL(__videobuf_mmap_setup);
1134 EXPORT_SYMBOL_GPL(videobuf_mmap_setup);
1135 EXPORT_SYMBOL_GPL(videobuf_mmap_free);
1136 EXPORT_SYMBOL_GPL(videobuf_mmap_mapper);