drivers/media/v4l2-core/videobuf-core.c

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

DEFINITIONS
