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