1 /* 2 * videobuf2-core.c - video buffer 2 core framework 3 * 4 * Copyright (C) 2010 Samsung Electronics 5 * 6 * Author: Pawel Osciak <pawel@osciak.com> 7 * Marek Szyprowski <m.szyprowski@samsung.com> 8 * 9 * The vb2_thread implementation was based on code from videobuf-dvb.c: 10 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SUSE Labs] 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation. 15 */ 16 17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 18 19 #include <linux/err.h> 20 #include <linux/kernel.h> 21 #include <linux/module.h> 22 #include <linux/mm.h> 23 #include <linux/poll.h> 24 #include <linux/slab.h> 25 #include <linux/sched.h> 26 #include <linux/freezer.h> 27 #include <linux/kthread.h> 28 29 #include <media/videobuf2-core.h> 30 #include <media/v4l2-mc.h> 31 32 #include <trace/events/vb2.h> 33 34 static int debug; 35 module_param(debug, int, 0644); 36 37 #define dprintk(level, fmt, arg...) \ 38 do { \ 39 if (debug >= level) \ 40 pr_info("%s: " fmt, __func__, ## arg); \ 41 } while (0) 42 43 #ifdef CONFIG_VIDEO_ADV_DEBUG 44 45 /* 46 * If advanced debugging is on, then count how often each op is called 47 * successfully, which can either be per-buffer or per-queue. 48 * 49 * This makes it easy to check that the 'init' and 'cleanup' 50 * (and variations thereof) stay balanced. 51 */ 52 53 #define log_memop(vb, op) \ 54 dprintk(2, "call_memop(%p, %d, %s)%s\n", \ 55 (vb)->vb2_queue, (vb)->index, #op, \ 56 (vb)->vb2_queue->mem_ops->op ? "" : " (nop)") 57 58 #define call_memop(vb, op, args...) \ 59 ({ \ 60 struct vb2_queue *_q = (vb)->vb2_queue; \ 61 int err; \ 62 \ 63 log_memop(vb, op); \ 64 err = _q->mem_ops->op ? _q->mem_ops->op(args) : 0; \ 65 if (!err) \ 66 (vb)->cnt_mem_ ## op++; \ 67 err; \ 68 }) 69 70 #define call_ptr_memop(vb, op, args...) \ 71 ({ \ 72 struct vb2_queue *_q = (vb)->vb2_queue; \ 73 void *ptr; \ 74 \ 75 log_memop(vb, op); \ 76 ptr = _q->mem_ops->op ? _q->mem_ops->op(args) : NULL; \ 77 if (!IS_ERR_OR_NULL(ptr)) \ 78 (vb)->cnt_mem_ ## op++; \ 79 ptr; \ 80 }) 81 82 #define call_void_memop(vb, op, args...) \ 83 ({ \ 84 struct vb2_queue *_q = (vb)->vb2_queue; \ 85 \ 86 log_memop(vb, op); \ 87 if (_q->mem_ops->op) \ 88 _q->mem_ops->op(args); \ 89 (vb)->cnt_mem_ ## op++; \ 90 }) 91 92 #define log_qop(q, op) \ 93 dprintk(2, "call_qop(%p, %s)%s\n", q, #op, \ 94 (q)->ops->op ? "" : " (nop)") 95 96 #define call_qop(q, op, args...) \ 97 ({ \ 98 int err; \ 99 \ 100 log_qop(q, op); \ 101 err = (q)->ops->op ? (q)->ops->op(args) : 0; \ 102 if (!err) \ 103 (q)->cnt_ ## op++; \ 104 err; \ 105 }) 106 107 #define call_void_qop(q, op, args...) \ 108 ({ \ 109 log_qop(q, op); \ 110 if ((q)->ops->op) \ 111 (q)->ops->op(args); \ 112 (q)->cnt_ ## op++; \ 113 }) 114 115 #define log_vb_qop(vb, op, args...) \ 116 dprintk(2, "call_vb_qop(%p, %d, %s)%s\n", \ 117 (vb)->vb2_queue, (vb)->index, #op, \ 118 (vb)->vb2_queue->ops->op ? "" : " (nop)") 119 120 #define call_vb_qop(vb, op, args...) \ 121 ({ \ 122 int err; \ 123 \ 124 log_vb_qop(vb, op); \ 125 err = (vb)->vb2_queue->ops->op ? \ 126 (vb)->vb2_queue->ops->op(args) : 0; \ 127 if (!err) \ 128 (vb)->cnt_ ## op++; \ 129 err; \ 130 }) 131 132 #define call_void_vb_qop(vb, op, args...) \ 133 ({ \ 134 log_vb_qop(vb, op); \ 135 if ((vb)->vb2_queue->ops->op) \ 136 (vb)->vb2_queue->ops->op(args); \ 137 (vb)->cnt_ ## op++; \ 138 }) 139 140 #else 141 142 #define call_memop(vb, op, args...) \ 143 ((vb)->vb2_queue->mem_ops->op ? \ 144 (vb)->vb2_queue->mem_ops->op(args) : 0) 145 146 #define call_ptr_memop(vb, op, args...) \ 147 ((vb)->vb2_queue->mem_ops->op ? \ 148 (vb)->vb2_queue->mem_ops->op(args) : NULL) 149 150 #define call_void_memop(vb, op, args...) \ 151 do { \ 152 if ((vb)->vb2_queue->mem_ops->op) \ 153 (vb)->vb2_queue->mem_ops->op(args); \ 154 } while (0) 155 156 #define call_qop(q, op, args...) \ 157 ((q)->ops->op ? (q)->ops->op(args) : 0) 158 159 #define call_void_qop(q, op, args...) \ 160 do { \ 161 if ((q)->ops->op) \ 162 (q)->ops->op(args); \ 163 } while (0) 164 165 #define call_vb_qop(vb, op, args...) \ 166 ((vb)->vb2_queue->ops->op ? (vb)->vb2_queue->ops->op(args) : 0) 167 168 #define call_void_vb_qop(vb, op, args...) \ 169 do { \ 170 if ((vb)->vb2_queue->ops->op) \ 171 (vb)->vb2_queue->ops->op(args); \ 172 } while (0) 173 174 #endif 175 176 #define call_bufop(q, op, args...) \ 177 ({ \ 178 int ret = 0; \ 179 if (q && q->buf_ops && q->buf_ops->op) \ 180 ret = q->buf_ops->op(args); \ 181 ret; \ 182 }) 183 184 #define call_void_bufop(q, op, args...) \ 185 ({ \ 186 if (q && q->buf_ops && q->buf_ops->op) \ 187 q->buf_ops->op(args); \ 188 }) 189 190 static void __vb2_queue_cancel(struct vb2_queue *q); 191 static void __enqueue_in_driver(struct vb2_buffer *vb); 192 193 /* 194 * __vb2_buf_mem_alloc() - allocate video memory for the given buffer 195 */ 196 static int __vb2_buf_mem_alloc(struct vb2_buffer *vb) 197 { 198 struct vb2_queue *q = vb->vb2_queue; 199 void *mem_priv; 200 int plane; 201 int ret = -ENOMEM; 202 203 /* 204 * Allocate memory for all planes in this buffer 205 * NOTE: mmapped areas should be page aligned 206 */ 207 for (plane = 0; plane < vb->num_planes; ++plane) { 208 unsigned long size = PAGE_ALIGN(vb->planes[plane].length); 209 210 mem_priv = call_ptr_memop(vb, alloc, 211 q->alloc_devs[plane] ? : q->dev, 212 q->dma_attrs, size, q->dma_dir, q->gfp_flags); 213 if (IS_ERR_OR_NULL(mem_priv)) { 214 if (mem_priv) 215 ret = PTR_ERR(mem_priv); 216 goto free; 217 } 218 219 /* Associate allocator private data with this plane */ 220 vb->planes[plane].mem_priv = mem_priv; 221 } 222 223 return 0; 224 free: 225 /* Free already allocated memory if one of the allocations failed */ 226 for (; plane > 0; --plane) { 227 call_void_memop(vb, put, vb->planes[plane - 1].mem_priv); 228 vb->planes[plane - 1].mem_priv = NULL; 229 } 230 231 return ret; 232 } 233 234 /* 235 * __vb2_buf_mem_free() - free memory of the given buffer 236 */ 237 static void __vb2_buf_mem_free(struct vb2_buffer *vb) 238 { 239 unsigned int plane; 240 241 for (plane = 0; plane < vb->num_planes; ++plane) { 242 call_void_memop(vb, put, vb->planes[plane].mem_priv); 243 vb->planes[plane].mem_priv = NULL; 244 dprintk(3, "freed plane %d of buffer %d\n", plane, vb->index); 245 } 246 } 247 248 /* 249 * __vb2_buf_userptr_put() - release userspace memory associated with 250 * a USERPTR buffer 251 */ 252 static void __vb2_buf_userptr_put(struct vb2_buffer *vb) 253 { 254 unsigned int plane; 255 256 for (plane = 0; plane < vb->num_planes; ++plane) { 257 if (vb->planes[plane].mem_priv) 258 call_void_memop(vb, put_userptr, vb->planes[plane].mem_priv); 259 vb->planes[plane].mem_priv = NULL; 260 } 261 } 262 263 /* 264 * __vb2_plane_dmabuf_put() - release memory associated with 265 * a DMABUF shared plane 266 */ 267 static void __vb2_plane_dmabuf_put(struct vb2_buffer *vb, struct vb2_plane *p) 268 { 269 if (!p->mem_priv) 270 return; 271 272 if (p->dbuf_mapped) 273 call_void_memop(vb, unmap_dmabuf, p->mem_priv); 274 275 call_void_memop(vb, detach_dmabuf, p->mem_priv); 276 dma_buf_put(p->dbuf); 277 p->mem_priv = NULL; 278 p->dbuf = NULL; 279 p->dbuf_mapped = 0; 280 } 281 282 /* 283 * __vb2_buf_dmabuf_put() - release memory associated with 284 * a DMABUF shared buffer 285 */ 286 static void __vb2_buf_dmabuf_put(struct vb2_buffer *vb) 287 { 288 unsigned int plane; 289 290 for (plane = 0; plane < vb->num_planes; ++plane) 291 __vb2_plane_dmabuf_put(vb, &vb->planes[plane]); 292 } 293 294 /* 295 * __setup_offsets() - setup unique offsets ("cookies") for every plane in 296 * the buffer. 297 */ 298 static void __setup_offsets(struct vb2_buffer *vb) 299 { 300 struct vb2_queue *q = vb->vb2_queue; 301 unsigned int plane; 302 unsigned long off = 0; 303 304 if (vb->index) { 305 struct vb2_buffer *prev = q->bufs[vb->index - 1]; 306 struct vb2_plane *p = &prev->planes[prev->num_planes - 1]; 307 308 off = PAGE_ALIGN(p->m.offset + p->length); 309 } 310 311 for (plane = 0; plane < vb->num_planes; ++plane) { 312 vb->planes[plane].m.offset = off; 313 314 dprintk(3, "buffer %d, plane %d offset 0x%08lx\n", 315 vb->index, plane, off); 316 317 off += vb->planes[plane].length; 318 off = PAGE_ALIGN(off); 319 } 320 } 321 322 /* 323 * __vb2_queue_alloc() - allocate videobuf buffer structures and (for MMAP type) 324 * video buffer memory for all buffers/planes on the queue and initializes the 325 * queue 326 * 327 * Returns the number of buffers successfully allocated. 328 */ 329 static int __vb2_queue_alloc(struct vb2_queue *q, enum vb2_memory memory, 330 unsigned int num_buffers, unsigned int num_planes, 331 const unsigned plane_sizes[VB2_MAX_PLANES]) 332 { 333 unsigned int buffer, plane; 334 struct vb2_buffer *vb; 335 int ret; 336 337 /* Ensure that q->num_buffers+num_buffers is below VB2_MAX_FRAME */ 338 num_buffers = min_t(unsigned int, num_buffers, 339 VB2_MAX_FRAME - q->num_buffers); 340 341 for (buffer = 0; buffer < num_buffers; ++buffer) { 342 /* Allocate videobuf buffer structures */ 343 vb = kzalloc(q->buf_struct_size, GFP_KERNEL); 344 if (!vb) { 345 dprintk(1, "memory alloc for buffer struct failed\n"); 346 break; 347 } 348 349 vb->state = VB2_BUF_STATE_DEQUEUED; 350 vb->vb2_queue = q; 351 vb->num_planes = num_planes; 352 vb->index = q->num_buffers + buffer; 353 vb->type = q->type; 354 vb->memory = memory; 355 for (plane = 0; plane < num_planes; ++plane) { 356 vb->planes[plane].length = plane_sizes[plane]; 357 vb->planes[plane].min_length = plane_sizes[plane]; 358 } 359 call_void_bufop(q, init_buffer, vb); 360 361 q->bufs[vb->index] = vb; 362 363 /* Allocate video buffer memory for the MMAP type */ 364 if (memory == VB2_MEMORY_MMAP) { 365 ret = __vb2_buf_mem_alloc(vb); 366 if (ret) { 367 dprintk(1, "failed allocating memory for buffer %d\n", 368 buffer); 369 q->bufs[vb->index] = NULL; 370 kfree(vb); 371 break; 372 } 373 __setup_offsets(vb); 374 /* 375 * Call the driver-provided buffer initialization 376 * callback, if given. An error in initialization 377 * results in queue setup failure. 378 */ 379 ret = call_vb_qop(vb, buf_init, vb); 380 if (ret) { 381 dprintk(1, "buffer %d %p initialization failed\n", 382 buffer, vb); 383 __vb2_buf_mem_free(vb); 384 q->bufs[vb->index] = NULL; 385 kfree(vb); 386 break; 387 } 388 } 389 } 390 391 dprintk(1, "allocated %d buffers, %d plane(s) each\n", 392 buffer, num_planes); 393 394 return buffer; 395 } 396 397 /* 398 * __vb2_free_mem() - release all video buffer memory for a given queue 399 */ 400 static void __vb2_free_mem(struct vb2_queue *q, unsigned int buffers) 401 { 402 unsigned int buffer; 403 struct vb2_buffer *vb; 404 405 for (buffer = q->num_buffers - buffers; buffer < q->num_buffers; 406 ++buffer) { 407 vb = q->bufs[buffer]; 408 if (!vb) 409 continue; 410 411 /* Free MMAP buffers or release USERPTR buffers */ 412 if (q->memory == VB2_MEMORY_MMAP) 413 __vb2_buf_mem_free(vb); 414 else if (q->memory == VB2_MEMORY_DMABUF) 415 __vb2_buf_dmabuf_put(vb); 416 else 417 __vb2_buf_userptr_put(vb); 418 } 419 } 420 421 /* 422 * __vb2_queue_free() - free buffers at the end of the queue - video memory and 423 * related information, if no buffers are left return the queue to an 424 * uninitialized state. Might be called even if the queue has already been freed. 425 */ 426 static int __vb2_queue_free(struct vb2_queue *q, unsigned int buffers) 427 { 428 unsigned int buffer; 429 430 /* 431 * Sanity check: when preparing a buffer the queue lock is released for 432 * a short while (see __buf_prepare for the details), which would allow 433 * a race with a reqbufs which can call this function. Removing the 434 * buffers from underneath __buf_prepare is obviously a bad idea, so we 435 * check if any of the buffers is in the state PREPARING, and if so we 436 * just return -EAGAIN. 437 */ 438 for (buffer = q->num_buffers - buffers; buffer < q->num_buffers; 439 ++buffer) { 440 if (q->bufs[buffer] == NULL) 441 continue; 442 if (q->bufs[buffer]->state == VB2_BUF_STATE_PREPARING) { 443 dprintk(1, "preparing buffers, cannot free\n"); 444 return -EAGAIN; 445 } 446 } 447 448 /* Call driver-provided cleanup function for each buffer, if provided */ 449 for (buffer = q->num_buffers - buffers; buffer < q->num_buffers; 450 ++buffer) { 451 struct vb2_buffer *vb = q->bufs[buffer]; 452 453 if (vb && vb->planes[0].mem_priv) 454 call_void_vb_qop(vb, buf_cleanup, vb); 455 } 456 457 /* Release video buffer memory */ 458 __vb2_free_mem(q, buffers); 459 460 #ifdef CONFIG_VIDEO_ADV_DEBUG 461 /* 462 * Check that all the calls were balances during the life-time of this 463 * queue. If not (or if the debug level is 1 or up), then dump the 464 * counters to the kernel log. 465 */ 466 if (q->num_buffers) { 467 bool unbalanced = q->cnt_start_streaming != q->cnt_stop_streaming || 468 q->cnt_wait_prepare != q->cnt_wait_finish; 469 470 if (unbalanced || debug) { 471 pr_info("counters for queue %p:%s\n", q, 472 unbalanced ? " UNBALANCED!" : ""); 473 pr_info(" setup: %u start_streaming: %u stop_streaming: %u\n", 474 q->cnt_queue_setup, q->cnt_start_streaming, 475 q->cnt_stop_streaming); 476 pr_info(" wait_prepare: %u wait_finish: %u\n", 477 q->cnt_wait_prepare, q->cnt_wait_finish); 478 } 479 q->cnt_queue_setup = 0; 480 q->cnt_wait_prepare = 0; 481 q->cnt_wait_finish = 0; 482 q->cnt_start_streaming = 0; 483 q->cnt_stop_streaming = 0; 484 } 485 for (buffer = 0; buffer < q->num_buffers; ++buffer) { 486 struct vb2_buffer *vb = q->bufs[buffer]; 487 bool unbalanced = vb->cnt_mem_alloc != vb->cnt_mem_put || 488 vb->cnt_mem_prepare != vb->cnt_mem_finish || 489 vb->cnt_mem_get_userptr != vb->cnt_mem_put_userptr || 490 vb->cnt_mem_attach_dmabuf != vb->cnt_mem_detach_dmabuf || 491 vb->cnt_mem_map_dmabuf != vb->cnt_mem_unmap_dmabuf || 492 vb->cnt_buf_queue != vb->cnt_buf_done || 493 vb->cnt_buf_prepare != vb->cnt_buf_finish || 494 vb->cnt_buf_init != vb->cnt_buf_cleanup; 495 496 if (unbalanced || debug) { 497 pr_info(" counters for queue %p, buffer %d:%s\n", 498 q, buffer, unbalanced ? " UNBALANCED!" : ""); 499 pr_info(" buf_init: %u buf_cleanup: %u buf_prepare: %u buf_finish: %u\n", 500 vb->cnt_buf_init, vb->cnt_buf_cleanup, 501 vb->cnt_buf_prepare, vb->cnt_buf_finish); 502 pr_info(" buf_out_validate: %u buf_queue: %u buf_done: %u buf_request_complete: %u\n", 503 vb->cnt_buf_out_validate, vb->cnt_buf_queue, 504 vb->cnt_buf_done, vb->cnt_buf_request_complete); 505 pr_info(" alloc: %u put: %u prepare: %u finish: %u mmap: %u\n", 506 vb->cnt_mem_alloc, vb->cnt_mem_put, 507 vb->cnt_mem_prepare, vb->cnt_mem_finish, 508 vb->cnt_mem_mmap); 509 pr_info(" get_userptr: %u put_userptr: %u\n", 510 vb->cnt_mem_get_userptr, vb->cnt_mem_put_userptr); 511 pr_info(" attach_dmabuf: %u detach_dmabuf: %u map_dmabuf: %u unmap_dmabuf: %u\n", 512 vb->cnt_mem_attach_dmabuf, vb->cnt_mem_detach_dmabuf, 513 vb->cnt_mem_map_dmabuf, vb->cnt_mem_unmap_dmabuf); 514 pr_info(" get_dmabuf: %u num_users: %u vaddr: %u cookie: %u\n", 515 vb->cnt_mem_get_dmabuf, 516 vb->cnt_mem_num_users, 517 vb->cnt_mem_vaddr, 518 vb->cnt_mem_cookie); 519 } 520 } 521 #endif 522 523 /* Free videobuf buffers */ 524 for (buffer = q->num_buffers - buffers; buffer < q->num_buffers; 525 ++buffer) { 526 kfree(q->bufs[buffer]); 527 q->bufs[buffer] = NULL; 528 } 529 530 q->num_buffers -= buffers; 531 if (!q->num_buffers) { 532 q->memory = VB2_MEMORY_UNKNOWN; 533 INIT_LIST_HEAD(&q->queued_list); 534 } 535 return 0; 536 } 537 538 bool vb2_buffer_in_use(struct vb2_queue *q, struct vb2_buffer *vb) 539 { 540 unsigned int plane; 541 for (plane = 0; plane < vb->num_planes; ++plane) { 542 void *mem_priv = vb->planes[plane].mem_priv; 543 /* 544 * If num_users() has not been provided, call_memop 545 * will return 0, apparently nobody cares about this 546 * case anyway. If num_users() returns more than 1, 547 * we are not the only user of the plane's memory. 548 */ 549 if (mem_priv && call_memop(vb, num_users, mem_priv) > 1) 550 return true; 551 } 552 return false; 553 } 554 EXPORT_SYMBOL(vb2_buffer_in_use); 555 556 /* 557 * __buffers_in_use() - return true if any buffers on the queue are in use and 558 * the queue cannot be freed (by the means of REQBUFS(0)) call 559 */ 560 static bool __buffers_in_use(struct vb2_queue *q) 561 { 562 unsigned int buffer; 563 for (buffer = 0; buffer < q->num_buffers; ++buffer) { 564 if (vb2_buffer_in_use(q, q->bufs[buffer])) 565 return true; 566 } 567 return false; 568 } 569 570 void vb2_core_querybuf(struct vb2_queue *q, unsigned int index, void *pb) 571 { 572 call_void_bufop(q, fill_user_buffer, q->bufs[index], pb); 573 } 574 EXPORT_SYMBOL_GPL(vb2_core_querybuf); 575 576 /* 577 * __verify_userptr_ops() - verify that all memory operations required for 578 * USERPTR queue type have been provided 579 */ 580 static int __verify_userptr_ops(struct vb2_queue *q) 581 { 582 if (!(q->io_modes & VB2_USERPTR) || !q->mem_ops->get_userptr || 583 !q->mem_ops->put_userptr) 584 return -EINVAL; 585 586 return 0; 587 } 588 589 /* 590 * __verify_mmap_ops() - verify that all memory operations required for 591 * MMAP queue type have been provided 592 */ 593 static int __verify_mmap_ops(struct vb2_queue *q) 594 { 595 if (!(q->io_modes & VB2_MMAP) || !q->mem_ops->alloc || 596 !q->mem_ops->put || !q->mem_ops->mmap) 597 return -EINVAL; 598 599 return 0; 600 } 601 602 /* 603 * __verify_dmabuf_ops() - verify that all memory operations required for 604 * DMABUF queue type have been provided 605 */ 606 static int __verify_dmabuf_ops(struct vb2_queue *q) 607 { 608 if (!(q->io_modes & VB2_DMABUF) || !q->mem_ops->attach_dmabuf || 609 !q->mem_ops->detach_dmabuf || !q->mem_ops->map_dmabuf || 610 !q->mem_ops->unmap_dmabuf) 611 return -EINVAL; 612 613 return 0; 614 } 615 616 int vb2_verify_memory_type(struct vb2_queue *q, 617 enum vb2_memory memory, unsigned int type) 618 { 619 if (memory != VB2_MEMORY_MMAP && memory != VB2_MEMORY_USERPTR && 620 memory != VB2_MEMORY_DMABUF) { 621 dprintk(1, "unsupported memory type\n"); 622 return -EINVAL; 623 } 624 625 if (type != q->type) { 626 dprintk(1, "requested type is incorrect\n"); 627 return -EINVAL; 628 } 629 630 /* 631 * Make sure all the required memory ops for given memory type 632 * are available. 633 */ 634 if (memory == VB2_MEMORY_MMAP && __verify_mmap_ops(q)) { 635 dprintk(1, "MMAP for current setup unsupported\n"); 636 return -EINVAL; 637 } 638 639 if (memory == VB2_MEMORY_USERPTR && __verify_userptr_ops(q)) { 640 dprintk(1, "USERPTR for current setup unsupported\n"); 641 return -EINVAL; 642 } 643 644 if (memory == VB2_MEMORY_DMABUF && __verify_dmabuf_ops(q)) { 645 dprintk(1, "DMABUF for current setup unsupported\n"); 646 return -EINVAL; 647 } 648 649 /* 650 * Place the busy tests at the end: -EBUSY can be ignored when 651 * create_bufs is called with count == 0, but count == 0 should still 652 * do the memory and type validation. 653 */ 654 if (vb2_fileio_is_active(q)) { 655 dprintk(1, "file io in progress\n"); 656 return -EBUSY; 657 } 658 return 0; 659 } 660 EXPORT_SYMBOL(vb2_verify_memory_type); 661 662 int vb2_core_reqbufs(struct vb2_queue *q, enum vb2_memory memory, 663 unsigned int *count) 664 { 665 unsigned int num_buffers, allocated_buffers, num_planes = 0; 666 unsigned plane_sizes[VB2_MAX_PLANES] = { }; 667 unsigned int i; 668 int ret; 669 670 if (q->streaming) { 671 dprintk(1, "streaming active\n"); 672 return -EBUSY; 673 } 674 675 if (*count == 0 || q->num_buffers != 0 || 676 (q->memory != VB2_MEMORY_UNKNOWN && q->memory != memory)) { 677 /* 678 * We already have buffers allocated, so first check if they 679 * are not in use and can be freed. 680 */ 681 mutex_lock(&q->mmap_lock); 682 if (debug && q->memory == VB2_MEMORY_MMAP && 683 __buffers_in_use(q)) 684 dprintk(1, "memory in use, orphaning buffers\n"); 685 686 /* 687 * Call queue_cancel to clean up any buffers in the 688 * QUEUED state which is possible if buffers were prepared or 689 * queued without ever calling STREAMON. 690 */ 691 __vb2_queue_cancel(q); 692 ret = __vb2_queue_free(q, q->num_buffers); 693 mutex_unlock(&q->mmap_lock); 694 if (ret) 695 return ret; 696 697 /* 698 * In case of REQBUFS(0) return immediately without calling 699 * driver's queue_setup() callback and allocating resources. 700 */ 701 if (*count == 0) 702 return 0; 703 } 704 705 /* 706 * Make sure the requested values and current defaults are sane. 707 */ 708 WARN_ON(q->min_buffers_needed > VB2_MAX_FRAME); 709 num_buffers = max_t(unsigned int, *count, q->min_buffers_needed); 710 num_buffers = min_t(unsigned int, num_buffers, VB2_MAX_FRAME); 711 memset(q->alloc_devs, 0, sizeof(q->alloc_devs)); 712 q->memory = memory; 713 714 /* 715 * Ask the driver how many buffers and planes per buffer it requires. 716 * Driver also sets the size and allocator context for each plane. 717 */ 718 ret = call_qop(q, queue_setup, q, &num_buffers, &num_planes, 719 plane_sizes, q->alloc_devs); 720 if (ret) 721 return ret; 722 723 /* Check that driver has set sane values */ 724 if (WARN_ON(!num_planes)) 725 return -EINVAL; 726 727 for (i = 0; i < num_planes; i++) 728 if (WARN_ON(!plane_sizes[i])) 729 return -EINVAL; 730 731 /* Finally, allocate buffers and video memory */ 732 allocated_buffers = 733 __vb2_queue_alloc(q, memory, num_buffers, num_planes, plane_sizes); 734 if (allocated_buffers == 0) { 735 dprintk(1, "memory allocation failed\n"); 736 return -ENOMEM; 737 } 738 739 /* 740 * There is no point in continuing if we can't allocate the minimum 741 * number of buffers needed by this vb2_queue. 742 */ 743 if (allocated_buffers < q->min_buffers_needed) 744 ret = -ENOMEM; 745 746 /* 747 * Check if driver can handle the allocated number of buffers. 748 */ 749 if (!ret && allocated_buffers < num_buffers) { 750 num_buffers = allocated_buffers; 751 /* 752 * num_planes is set by the previous queue_setup(), but since it 753 * signals to queue_setup() whether it is called from create_bufs() 754 * vs reqbufs() we zero it here to signal that queue_setup() is 755 * called for the reqbufs() case. 756 */ 757 num_planes = 0; 758 759 ret = call_qop(q, queue_setup, q, &num_buffers, 760 &num_planes, plane_sizes, q->alloc_devs); 761 762 if (!ret && allocated_buffers < num_buffers) 763 ret = -ENOMEM; 764 765 /* 766 * Either the driver has accepted a smaller number of buffers, 767 * or .queue_setup() returned an error 768 */ 769 } 770 771 mutex_lock(&q->mmap_lock); 772 q->num_buffers = allocated_buffers; 773 774 if (ret < 0) { 775 /* 776 * Note: __vb2_queue_free() will subtract 'allocated_buffers' 777 * from q->num_buffers. 778 */ 779 __vb2_queue_free(q, allocated_buffers); 780 mutex_unlock(&q->mmap_lock); 781 return ret; 782 } 783 mutex_unlock(&q->mmap_lock); 784 785 /* 786 * Return the number of successfully allocated buffers 787 * to the userspace. 788 */ 789 *count = allocated_buffers; 790 q->waiting_for_buffers = !q->is_output; 791 792 return 0; 793 } 794 EXPORT_SYMBOL_GPL(vb2_core_reqbufs); 795 796 int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory, 797 unsigned int *count, unsigned requested_planes, 798 const unsigned requested_sizes[]) 799 { 800 unsigned int num_planes = 0, num_buffers, allocated_buffers; 801 unsigned plane_sizes[VB2_MAX_PLANES] = { }; 802 int ret; 803 804 if (q->num_buffers == VB2_MAX_FRAME) { 805 dprintk(1, "maximum number of buffers already allocated\n"); 806 return -ENOBUFS; 807 } 808 809 if (!q->num_buffers) { 810 memset(q->alloc_devs, 0, sizeof(q->alloc_devs)); 811 q->memory = memory; 812 q->waiting_for_buffers = !q->is_output; 813 } else if (q->memory != memory) { 814 dprintk(1, "memory model mismatch\n"); 815 return -EINVAL; 816 } 817 818 num_buffers = min(*count, VB2_MAX_FRAME - q->num_buffers); 819 820 if (requested_planes && requested_sizes) { 821 num_planes = requested_planes; 822 memcpy(plane_sizes, requested_sizes, sizeof(plane_sizes)); 823 } 824 825 /* 826 * Ask the driver, whether the requested number of buffers, planes per 827 * buffer and their sizes are acceptable 828 */ 829 ret = call_qop(q, queue_setup, q, &num_buffers, 830 &num_planes, plane_sizes, q->alloc_devs); 831 if (ret) 832 return ret; 833 834 /* Finally, allocate buffers and video memory */ 835 allocated_buffers = __vb2_queue_alloc(q, memory, num_buffers, 836 num_planes, plane_sizes); 837 if (allocated_buffers == 0) { 838 dprintk(1, "memory allocation failed\n"); 839 return -ENOMEM; 840 } 841 842 /* 843 * Check if driver can handle the so far allocated number of buffers. 844 */ 845 if (allocated_buffers < num_buffers) { 846 num_buffers = allocated_buffers; 847 848 /* 849 * q->num_buffers contains the total number of buffers, that the 850 * queue driver has set up 851 */ 852 ret = call_qop(q, queue_setup, q, &num_buffers, 853 &num_planes, plane_sizes, q->alloc_devs); 854 855 if (!ret && allocated_buffers < num_buffers) 856 ret = -ENOMEM; 857 858 /* 859 * Either the driver has accepted a smaller number of buffers, 860 * or .queue_setup() returned an error 861 */ 862 } 863 864 mutex_lock(&q->mmap_lock); 865 q->num_buffers += allocated_buffers; 866 867 if (ret < 0) { 868 /* 869 * Note: __vb2_queue_free() will subtract 'allocated_buffers' 870 * from q->num_buffers. 871 */ 872 __vb2_queue_free(q, allocated_buffers); 873 mutex_unlock(&q->mmap_lock); 874 return -ENOMEM; 875 } 876 mutex_unlock(&q->mmap_lock); 877 878 /* 879 * Return the number of successfully allocated buffers 880 * to the userspace. 881 */ 882 *count = allocated_buffers; 883 884 return 0; 885 } 886 EXPORT_SYMBOL_GPL(vb2_core_create_bufs); 887 888 void *vb2_plane_vaddr(struct vb2_buffer *vb, unsigned int plane_no) 889 { 890 if (plane_no >= vb->num_planes || !vb->planes[plane_no].mem_priv) 891 return NULL; 892 893 return call_ptr_memop(vb, vaddr, vb->planes[plane_no].mem_priv); 894 895 } 896 EXPORT_SYMBOL_GPL(vb2_plane_vaddr); 897 898 void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no) 899 { 900 if (plane_no >= vb->num_planes || !vb->planes[plane_no].mem_priv) 901 return NULL; 902 903 return call_ptr_memop(vb, cookie, vb->planes[plane_no].mem_priv); 904 } 905 EXPORT_SYMBOL_GPL(vb2_plane_cookie); 906 907 void vb2_buffer_done(struct vb2_buffer *vb, enum vb2_buffer_state state) 908 { 909 struct vb2_queue *q = vb->vb2_queue; 910 unsigned long flags; 911 unsigned int plane; 912 913 if (WARN_ON(vb->state != VB2_BUF_STATE_ACTIVE)) 914 return; 915 916 if (WARN_ON(state != VB2_BUF_STATE_DONE && 917 state != VB2_BUF_STATE_ERROR && 918 state != VB2_BUF_STATE_QUEUED && 919 state != VB2_BUF_STATE_REQUEUEING)) 920 state = VB2_BUF_STATE_ERROR; 921 922 #ifdef CONFIG_VIDEO_ADV_DEBUG 923 /* 924 * Although this is not a callback, it still does have to balance 925 * with the buf_queue op. So update this counter manually. 926 */ 927 vb->cnt_buf_done++; 928 #endif 929 dprintk(4, "done processing on buffer %d, state: %d\n", 930 vb->index, state); 931 932 if (state != VB2_BUF_STATE_QUEUED && 933 state != VB2_BUF_STATE_REQUEUEING) { 934 /* sync buffers */ 935 for (plane = 0; plane < vb->num_planes; ++plane) 936 call_void_memop(vb, finish, vb->planes[plane].mem_priv); 937 vb->synced = 0; 938 } 939 940 spin_lock_irqsave(&q->done_lock, flags); 941 if (state == VB2_BUF_STATE_QUEUED || 942 state == VB2_BUF_STATE_REQUEUEING) { 943 vb->state = VB2_BUF_STATE_QUEUED; 944 } else { 945 /* Add the buffer to the done buffers list */ 946 list_add_tail(&vb->done_entry, &q->done_list); 947 vb->state = state; 948 } 949 atomic_dec(&q->owned_by_drv_count); 950 951 if (state != VB2_BUF_STATE_QUEUED && vb->req_obj.req) { 952 /* This is not supported at the moment */ 953 WARN_ON(state == VB2_BUF_STATE_REQUEUEING); 954 media_request_object_unbind(&vb->req_obj); 955 media_request_object_put(&vb->req_obj); 956 } 957 958 spin_unlock_irqrestore(&q->done_lock, flags); 959 960 trace_vb2_buf_done(q, vb); 961 962 switch (state) { 963 case VB2_BUF_STATE_QUEUED: 964 return; 965 case VB2_BUF_STATE_REQUEUEING: 966 if (q->start_streaming_called) 967 __enqueue_in_driver(vb); 968 return; 969 default: 970 /* Inform any processes that may be waiting for buffers */ 971 wake_up(&q->done_wq); 972 break; 973 } 974 } 975 EXPORT_SYMBOL_GPL(vb2_buffer_done); 976 977 void vb2_discard_done(struct vb2_queue *q) 978 { 979 struct vb2_buffer *vb; 980 unsigned long flags; 981 982 spin_lock_irqsave(&q->done_lock, flags); 983 list_for_each_entry(vb, &q->done_list, done_entry) 984 vb->state = VB2_BUF_STATE_ERROR; 985 spin_unlock_irqrestore(&q->done_lock, flags); 986 } 987 EXPORT_SYMBOL_GPL(vb2_discard_done); 988 989 /* 990 * __prepare_mmap() - prepare an MMAP buffer 991 */ 992 static int __prepare_mmap(struct vb2_buffer *vb) 993 { 994 int ret = 0; 995 996 ret = call_bufop(vb->vb2_queue, fill_vb2_buffer, 997 vb, vb->planes); 998 return ret ? ret : call_vb_qop(vb, buf_prepare, vb); 999 } 1000 1001 /* 1002 * __prepare_userptr() - prepare a USERPTR buffer 1003 */ 1004 static int __prepare_userptr(struct vb2_buffer *vb) 1005 { 1006 struct vb2_plane planes[VB2_MAX_PLANES]; 1007 struct vb2_queue *q = vb->vb2_queue; 1008 void *mem_priv; 1009 unsigned int plane; 1010 int ret = 0; 1011 bool reacquired = vb->planes[0].mem_priv == NULL; 1012 1013 memset(planes, 0, sizeof(planes[0]) * vb->num_planes); 1014 /* Copy relevant information provided by the userspace */ 1015 ret = call_bufop(vb->vb2_queue, fill_vb2_buffer, 1016 vb, planes); 1017 if (ret) 1018 return ret; 1019 1020 for (plane = 0; plane < vb->num_planes; ++plane) { 1021 /* Skip the plane if already verified */ 1022 if (vb->planes[plane].m.userptr && 1023 vb->planes[plane].m.userptr == planes[plane].m.userptr 1024 && vb->planes[plane].length == planes[plane].length) 1025 continue; 1026 1027 dprintk(3, "userspace address for plane %d changed, reacquiring memory\n", 1028 plane); 1029 1030 /* Check if the provided plane buffer is large enough */ 1031 if (planes[plane].length < vb->planes[plane].min_length) { 1032 dprintk(1, "provided buffer size %u is less than setup size %u for plane %d\n", 1033 planes[plane].length, 1034 vb->planes[plane].min_length, 1035 plane); 1036 ret = -EINVAL; 1037 goto err; 1038 } 1039 1040 /* Release previously acquired memory if present */ 1041 if (vb->planes[plane].mem_priv) { 1042 if (!reacquired) { 1043 reacquired = true; 1044 vb->copied_timestamp = 0; 1045 call_void_vb_qop(vb, buf_cleanup, vb); 1046 } 1047 call_void_memop(vb, put_userptr, vb->planes[plane].mem_priv); 1048 } 1049 1050 vb->planes[plane].mem_priv = NULL; 1051 vb->planes[plane].bytesused = 0; 1052 vb->planes[plane].length = 0; 1053 vb->planes[plane].m.userptr = 0; 1054 vb->planes[plane].data_offset = 0; 1055 1056 /* Acquire each plane's memory */ 1057 mem_priv = call_ptr_memop(vb, get_userptr, 1058 q->alloc_devs[plane] ? : q->dev, 1059 planes[plane].m.userptr, 1060 planes[plane].length, q->dma_dir); 1061 if (IS_ERR(mem_priv)) { 1062 dprintk(1, "failed acquiring userspace memory for plane %d\n", 1063 plane); 1064 ret = PTR_ERR(mem_priv); 1065 goto err; 1066 } 1067 vb->planes[plane].mem_priv = mem_priv; 1068 } 1069 1070 /* 1071 * Now that everything is in order, copy relevant information 1072 * provided by userspace. 1073 */ 1074 for (plane = 0; plane < vb->num_planes; ++plane) { 1075 vb->planes[plane].bytesused = planes[plane].bytesused; 1076 vb->planes[plane].length = planes[plane].length; 1077 vb->planes[plane].m.userptr = planes[plane].m.userptr; 1078 vb->planes[plane].data_offset = planes[plane].data_offset; 1079 } 1080 1081 if (reacquired) { 1082 /* 1083 * One or more planes changed, so we must call buf_init to do 1084 * the driver-specific initialization on the newly acquired 1085 * buffer, if provided. 1086 */ 1087 ret = call_vb_qop(vb, buf_init, vb); 1088 if (ret) { 1089 dprintk(1, "buffer initialization failed\n"); 1090 goto err; 1091 } 1092 } 1093 1094 ret = call_vb_qop(vb, buf_prepare, vb); 1095 if (ret) { 1096 dprintk(1, "buffer preparation failed\n"); 1097 call_void_vb_qop(vb, buf_cleanup, vb); 1098 goto err; 1099 } 1100 1101 return 0; 1102 err: 1103 /* In case of errors, release planes that were already acquired */ 1104 for (plane = 0; plane < vb->num_planes; ++plane) { 1105 if (vb->planes[plane].mem_priv) 1106 call_void_memop(vb, put_userptr, 1107 vb->planes[plane].mem_priv); 1108 vb->planes[plane].mem_priv = NULL; 1109 vb->planes[plane].m.userptr = 0; 1110 vb->planes[plane].length = 0; 1111 } 1112 1113 return ret; 1114 } 1115 1116 /* 1117 * __prepare_dmabuf() - prepare a DMABUF buffer 1118 */ 1119 static int __prepare_dmabuf(struct vb2_buffer *vb) 1120 { 1121 struct vb2_plane planes[VB2_MAX_PLANES]; 1122 struct vb2_queue *q = vb->vb2_queue; 1123 void *mem_priv; 1124 unsigned int plane; 1125 int ret = 0; 1126 bool reacquired = vb->planes[0].mem_priv == NULL; 1127 1128 memset(planes, 0, sizeof(planes[0]) * vb->num_planes); 1129 /* Copy relevant information provided by the userspace */ 1130 ret = call_bufop(vb->vb2_queue, fill_vb2_buffer, 1131 vb, planes); 1132 if (ret) 1133 return ret; 1134 1135 for (plane = 0; plane < vb->num_planes; ++plane) { 1136 struct dma_buf *dbuf = dma_buf_get(planes[plane].m.fd); 1137 1138 if (IS_ERR_OR_NULL(dbuf)) { 1139 dprintk(1, "invalid dmabuf fd for plane %d\n", 1140 plane); 1141 ret = -EINVAL; 1142 goto err; 1143 } 1144 1145 /* use DMABUF size if length is not provided */ 1146 if (planes[plane].length == 0) 1147 planes[plane].length = dbuf->size; 1148 1149 if (planes[plane].length < vb->planes[plane].min_length) { 1150 dprintk(1, "invalid dmabuf length %u for plane %d, minimum length %u\n", 1151 planes[plane].length, plane, 1152 vb->planes[plane].min_length); 1153 dma_buf_put(dbuf); 1154 ret = -EINVAL; 1155 goto err; 1156 } 1157 1158 /* Skip the plane if already verified */ 1159 if (dbuf == vb->planes[plane].dbuf && 1160 vb->planes[plane].length == planes[plane].length) { 1161 dma_buf_put(dbuf); 1162 continue; 1163 } 1164 1165 dprintk(3, "buffer for plane %d changed\n", plane); 1166 1167 if (!reacquired) { 1168 reacquired = true; 1169 vb->copied_timestamp = 0; 1170 call_void_vb_qop(vb, buf_cleanup, vb); 1171 } 1172 1173 /* Release previously acquired memory if present */ 1174 __vb2_plane_dmabuf_put(vb, &vb->planes[plane]); 1175 vb->planes[plane].bytesused = 0; 1176 vb->planes[plane].length = 0; 1177 vb->planes[plane].m.fd = 0; 1178 vb->planes[plane].data_offset = 0; 1179 1180 /* Acquire each plane's memory */ 1181 mem_priv = call_ptr_memop(vb, attach_dmabuf, 1182 q->alloc_devs[plane] ? : q->dev, 1183 dbuf, planes[plane].length, q->dma_dir); 1184 if (IS_ERR(mem_priv)) { 1185 dprintk(1, "failed to attach dmabuf\n"); 1186 ret = PTR_ERR(mem_priv); 1187 dma_buf_put(dbuf); 1188 goto err; 1189 } 1190 1191 vb->planes[plane].dbuf = dbuf; 1192 vb->planes[plane].mem_priv = mem_priv; 1193 } 1194 1195 /* 1196 * This pins the buffer(s) with dma_buf_map_attachment()). It's done 1197 * here instead just before the DMA, while queueing the buffer(s) so 1198 * userspace knows sooner rather than later if the dma-buf map fails. 1199 */ 1200 for (plane = 0; plane < vb->num_planes; ++plane) { 1201 if (vb->planes[plane].dbuf_mapped) 1202 continue; 1203 1204 ret = call_memop(vb, map_dmabuf, vb->planes[plane].mem_priv); 1205 if (ret) { 1206 dprintk(1, "failed to map dmabuf for plane %d\n", 1207 plane); 1208 goto err; 1209 } 1210 vb->planes[plane].dbuf_mapped = 1; 1211 } 1212 1213 /* 1214 * Now that everything is in order, copy relevant information 1215 * provided by userspace. 1216 */ 1217 for (plane = 0; plane < vb->num_planes; ++plane) { 1218 vb->planes[plane].bytesused = planes[plane].bytesused; 1219 vb->planes[plane].length = planes[plane].length; 1220 vb->planes[plane].m.fd = planes[plane].m.fd; 1221 vb->planes[plane].data_offset = planes[plane].data_offset; 1222 } 1223 1224 if (reacquired) { 1225 /* 1226 * Call driver-specific initialization on the newly acquired buffer, 1227 * if provided. 1228 */ 1229 ret = call_vb_qop(vb, buf_init, vb); 1230 if (ret) { 1231 dprintk(1, "buffer initialization failed\n"); 1232 goto err; 1233 } 1234 } 1235 1236 ret = call_vb_qop(vb, buf_prepare, vb); 1237 if (ret) { 1238 dprintk(1, "buffer preparation failed\n"); 1239 call_void_vb_qop(vb, buf_cleanup, vb); 1240 goto err; 1241 } 1242 1243 return 0; 1244 err: 1245 /* In case of errors, release planes that were already acquired */ 1246 __vb2_buf_dmabuf_put(vb); 1247 1248 return ret; 1249 } 1250 1251 /* 1252 * __enqueue_in_driver() - enqueue a vb2_buffer in driver for processing 1253 */ 1254 static void __enqueue_in_driver(struct vb2_buffer *vb) 1255 { 1256 struct vb2_queue *q = vb->vb2_queue; 1257 1258 vb->state = VB2_BUF_STATE_ACTIVE; 1259 atomic_inc(&q->owned_by_drv_count); 1260 1261 trace_vb2_buf_queue(q, vb); 1262 1263 call_void_vb_qop(vb, buf_queue, vb); 1264 } 1265 1266 static int __buf_prepare(struct vb2_buffer *vb) 1267 { 1268 struct vb2_queue *q = vb->vb2_queue; 1269 enum vb2_buffer_state orig_state = vb->state; 1270 unsigned int plane; 1271 int ret; 1272 1273 if (q->error) { 1274 dprintk(1, "fatal error occurred on queue\n"); 1275 return -EIO; 1276 } 1277 1278 if (vb->prepared) 1279 return 0; 1280 WARN_ON(vb->synced); 1281 1282 if (q->is_output) { 1283 ret = call_vb_qop(vb, buf_out_validate, vb); 1284 if (ret) { 1285 dprintk(1, "buffer validation failed\n"); 1286 return ret; 1287 } 1288 } 1289 1290 vb->state = VB2_BUF_STATE_PREPARING; 1291 1292 switch (q->memory) { 1293 case VB2_MEMORY_MMAP: 1294 ret = __prepare_mmap(vb); 1295 break; 1296 case VB2_MEMORY_USERPTR: 1297 ret = __prepare_userptr(vb); 1298 break; 1299 case VB2_MEMORY_DMABUF: 1300 ret = __prepare_dmabuf(vb); 1301 break; 1302 default: 1303 WARN(1, "Invalid queue type\n"); 1304 ret = -EINVAL; 1305 break; 1306 } 1307 1308 if (ret) { 1309 dprintk(1, "buffer preparation failed: %d\n", ret); 1310 vb->state = orig_state; 1311 return ret; 1312 } 1313 1314 /* sync buffers */ 1315 for (plane = 0; plane < vb->num_planes; ++plane) 1316 call_void_memop(vb, prepare, vb->planes[plane].mem_priv); 1317 1318 vb->synced = 1; 1319 vb->prepared = 1; 1320 vb->state = orig_state; 1321 1322 return 0; 1323 } 1324 1325 static int vb2_req_prepare(struct media_request_object *obj) 1326 { 1327 struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj); 1328 int ret; 1329 1330 if (WARN_ON(vb->state != VB2_BUF_STATE_IN_REQUEST)) 1331 return -EINVAL; 1332 1333 mutex_lock(vb->vb2_queue->lock); 1334 ret = __buf_prepare(vb); 1335 mutex_unlock(vb->vb2_queue->lock); 1336 return ret; 1337 } 1338 1339 static void __vb2_dqbuf(struct vb2_buffer *vb); 1340 1341 static void vb2_req_unprepare(struct media_request_object *obj) 1342 { 1343 struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj); 1344 1345 mutex_lock(vb->vb2_queue->lock); 1346 __vb2_dqbuf(vb); 1347 vb->state = VB2_BUF_STATE_IN_REQUEST; 1348 mutex_unlock(vb->vb2_queue->lock); 1349 WARN_ON(!vb->req_obj.req); 1350 } 1351 1352 int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb, 1353 struct media_request *req); 1354 1355 static void vb2_req_queue(struct media_request_object *obj) 1356 { 1357 struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj); 1358 1359 mutex_lock(vb->vb2_queue->lock); 1360 vb2_core_qbuf(vb->vb2_queue, vb->index, NULL, NULL); 1361 mutex_unlock(vb->vb2_queue->lock); 1362 } 1363 1364 static void vb2_req_unbind(struct media_request_object *obj) 1365 { 1366 struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj); 1367 1368 if (vb->state == VB2_BUF_STATE_IN_REQUEST) 1369 call_void_bufop(vb->vb2_queue, init_buffer, vb); 1370 } 1371 1372 static void vb2_req_release(struct media_request_object *obj) 1373 { 1374 struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj); 1375 1376 if (vb->state == VB2_BUF_STATE_IN_REQUEST) { 1377 vb->state = VB2_BUF_STATE_DEQUEUED; 1378 if (vb->request) 1379 media_request_put(vb->request); 1380 vb->request = NULL; 1381 } 1382 } 1383 1384 static const struct media_request_object_ops vb2_core_req_ops = { 1385 .prepare = vb2_req_prepare, 1386 .unprepare = vb2_req_unprepare, 1387 .queue = vb2_req_queue, 1388 .unbind = vb2_req_unbind, 1389 .release = vb2_req_release, 1390 }; 1391 1392 bool vb2_request_object_is_buffer(struct media_request_object *obj) 1393 { 1394 return obj->ops == &vb2_core_req_ops; 1395 } 1396 EXPORT_SYMBOL_GPL(vb2_request_object_is_buffer); 1397 1398 unsigned int vb2_request_buffer_cnt(struct media_request *req) 1399 { 1400 struct media_request_object *obj; 1401 unsigned long flags; 1402 unsigned int buffer_cnt = 0; 1403 1404 spin_lock_irqsave(&req->lock, flags); 1405 list_for_each_entry(obj, &req->objects, list) 1406 if (vb2_request_object_is_buffer(obj)) 1407 buffer_cnt++; 1408 spin_unlock_irqrestore(&req->lock, flags); 1409 1410 return buffer_cnt; 1411 } 1412 EXPORT_SYMBOL_GPL(vb2_request_buffer_cnt); 1413 1414 int vb2_core_prepare_buf(struct vb2_queue *q, unsigned int index, void *pb) 1415 { 1416 struct vb2_buffer *vb; 1417 int ret; 1418 1419 vb = q->bufs[index]; 1420 if (vb->state != VB2_BUF_STATE_DEQUEUED) { 1421 dprintk(1, "invalid buffer state %d\n", 1422 vb->state); 1423 return -EINVAL; 1424 } 1425 if (vb->prepared) { 1426 dprintk(1, "buffer already prepared\n"); 1427 return -EINVAL; 1428 } 1429 1430 ret = __buf_prepare(vb); 1431 if (ret) 1432 return ret; 1433 1434 /* Fill buffer information for the userspace */ 1435 call_void_bufop(q, fill_user_buffer, vb, pb); 1436 1437 dprintk(2, "prepare of buffer %d succeeded\n", vb->index); 1438 1439 return 0; 1440 } 1441 EXPORT_SYMBOL_GPL(vb2_core_prepare_buf); 1442 1443 /* 1444 * vb2_start_streaming() - Attempt to start streaming. 1445 * @q: videobuf2 queue 1446 * 1447 * Attempt to start streaming. When this function is called there must be 1448 * at least q->min_buffers_needed buffers queued up (i.e. the minimum 1449 * number of buffers required for the DMA engine to function). If the 1450 * @start_streaming op fails it is supposed to return all the driver-owned 1451 * buffers back to vb2 in state QUEUED. Check if that happened and if 1452 * not warn and reclaim them forcefully. 1453 */ 1454 static int vb2_start_streaming(struct vb2_queue *q) 1455 { 1456 struct vb2_buffer *vb; 1457 int ret; 1458 1459 /* 1460 * If any buffers were queued before streamon, 1461 * we can now pass them to driver for processing. 1462 */ 1463 list_for_each_entry(vb, &q->queued_list, queued_entry) 1464 __enqueue_in_driver(vb); 1465 1466 /* Tell the driver to start streaming */ 1467 q->start_streaming_called = 1; 1468 ret = call_qop(q, start_streaming, q, 1469 atomic_read(&q->owned_by_drv_count)); 1470 if (!ret) 1471 return 0; 1472 1473 q->start_streaming_called = 0; 1474 1475 dprintk(1, "driver refused to start streaming\n"); 1476 /* 1477 * If you see this warning, then the driver isn't cleaning up properly 1478 * after a failed start_streaming(). See the start_streaming() 1479 * documentation in videobuf2-core.h for more information how buffers 1480 * should be returned to vb2 in start_streaming(). 1481 */ 1482 if (WARN_ON(atomic_read(&q->owned_by_drv_count))) { 1483 unsigned i; 1484 1485 /* 1486 * Forcefully reclaim buffers if the driver did not 1487 * correctly return them to vb2. 1488 */ 1489 for (i = 0; i < q->num_buffers; ++i) { 1490 vb = q->bufs[i]; 1491 if (vb->state == VB2_BUF_STATE_ACTIVE) 1492 vb2_buffer_done(vb, VB2_BUF_STATE_QUEUED); 1493 } 1494 /* Must be zero now */ 1495 WARN_ON(atomic_read(&q->owned_by_drv_count)); 1496 } 1497 /* 1498 * If done_list is not empty, then start_streaming() didn't call 1499 * vb2_buffer_done(vb, VB2_BUF_STATE_QUEUED) but STATE_ERROR or 1500 * STATE_DONE. 1501 */ 1502 WARN_ON(!list_empty(&q->done_list)); 1503 return ret; 1504 } 1505 1506 int vb2_core_qbuf(struct vb2_queue *q, unsigned int index, void *pb, 1507 struct media_request *req) 1508 { 1509 struct vb2_buffer *vb; 1510 int ret; 1511 1512 if (q->error) { 1513 dprintk(1, "fatal error occurred on queue\n"); 1514 return -EIO; 1515 } 1516 1517 vb = q->bufs[index]; 1518 1519 if ((req && q->uses_qbuf) || 1520 (!req && vb->state != VB2_BUF_STATE_IN_REQUEST && 1521 q->uses_requests)) { 1522 dprintk(1, "queue in wrong mode (qbuf vs requests)\n"); 1523 return -EBUSY; 1524 } 1525 1526 if (req) { 1527 int ret; 1528 1529 q->uses_requests = 1; 1530 if (vb->state != VB2_BUF_STATE_DEQUEUED) { 1531 dprintk(1, "buffer %d not in dequeued state\n", 1532 vb->index); 1533 return -EINVAL; 1534 } 1535 1536 if (q->is_output && !vb->prepared) { 1537 ret = call_vb_qop(vb, buf_out_validate, vb); 1538 if (ret) { 1539 dprintk(1, "buffer validation failed\n"); 1540 return ret; 1541 } 1542 } 1543 1544 media_request_object_init(&vb->req_obj); 1545 1546 /* Make sure the request is in a safe state for updating. */ 1547 ret = media_request_lock_for_update(req); 1548 if (ret) 1549 return ret; 1550 ret = media_request_object_bind(req, &vb2_core_req_ops, 1551 q, true, &vb->req_obj); 1552 media_request_unlock_for_update(req); 1553 if (ret) 1554 return ret; 1555 1556 vb->state = VB2_BUF_STATE_IN_REQUEST; 1557 1558 /* 1559 * Increment the refcount and store the request. 1560 * The request refcount is decremented again when the 1561 * buffer is dequeued. This is to prevent vb2_buffer_done() 1562 * from freeing the request from interrupt context, which can 1563 * happen if the application closed the request fd after 1564 * queueing the request. 1565 */ 1566 media_request_get(req); 1567 vb->request = req; 1568 1569 /* Fill buffer information for the userspace */ 1570 if (pb) { 1571 call_void_bufop(q, copy_timestamp, vb, pb); 1572 call_void_bufop(q, fill_user_buffer, vb, pb); 1573 } 1574 1575 dprintk(2, "qbuf of buffer %d succeeded\n", vb->index); 1576 return 0; 1577 } 1578 1579 if (vb->state != VB2_BUF_STATE_IN_REQUEST) 1580 q->uses_qbuf = 1; 1581 1582 switch (vb->state) { 1583 case VB2_BUF_STATE_DEQUEUED: 1584 case VB2_BUF_STATE_IN_REQUEST: 1585 if (!vb->prepared) { 1586 ret = __buf_prepare(vb); 1587 if (ret) 1588 return ret; 1589 } 1590 break; 1591 case VB2_BUF_STATE_PREPARING: 1592 dprintk(1, "buffer still being prepared\n"); 1593 return -EINVAL; 1594 default: 1595 dprintk(1, "invalid buffer state %d\n", vb->state); 1596 return -EINVAL; 1597 } 1598 1599 /* 1600 * Add to the queued buffers list, a buffer will stay on it until 1601 * dequeued in dqbuf. 1602 */ 1603 list_add_tail(&vb->queued_entry, &q->queued_list); 1604 q->queued_count++; 1605 q->waiting_for_buffers = false; 1606 vb->state = VB2_BUF_STATE_QUEUED; 1607 1608 if (pb) 1609 call_void_bufop(q, copy_timestamp, vb, pb); 1610 1611 trace_vb2_qbuf(q, vb); 1612 1613 /* 1614 * If already streaming, give the buffer to driver for processing. 1615 * If not, the buffer will be given to driver on next streamon. 1616 */ 1617 if (q->start_streaming_called) 1618 __enqueue_in_driver(vb); 1619 1620 /* Fill buffer information for the userspace */ 1621 if (pb) 1622 call_void_bufop(q, fill_user_buffer, vb, pb); 1623 1624 /* 1625 * If streamon has been called, and we haven't yet called 1626 * start_streaming() since not enough buffers were queued, and 1627 * we now have reached the minimum number of queued buffers, 1628 * then we can finally call start_streaming(). 1629 */ 1630 if (q->streaming && !q->start_streaming_called && 1631 q->queued_count >= q->min_buffers_needed) { 1632 ret = vb2_start_streaming(q); 1633 if (ret) 1634 return ret; 1635 } 1636 1637 dprintk(2, "qbuf of buffer %d succeeded\n", vb->index); 1638 return 0; 1639 } 1640 EXPORT_SYMBOL_GPL(vb2_core_qbuf); 1641 1642 /* 1643 * __vb2_wait_for_done_vb() - wait for a buffer to become available 1644 * for dequeuing 1645 * 1646 * Will sleep if required for nonblocking == false. 1647 */ 1648 static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking) 1649 { 1650 /* 1651 * All operations on vb_done_list are performed under done_lock 1652 * spinlock protection. However, buffers may be removed from 1653 * it and returned to userspace only while holding both driver's 1654 * lock and the done_lock spinlock. Thus we can be sure that as 1655 * long as we hold the driver's lock, the list will remain not 1656 * empty if list_empty() check succeeds. 1657 */ 1658 1659 for (;;) { 1660 int ret; 1661 1662 if (!q->streaming) { 1663 dprintk(1, "streaming off, will not wait for buffers\n"); 1664 return -EINVAL; 1665 } 1666 1667 if (q->error) { 1668 dprintk(1, "Queue in error state, will not wait for buffers\n"); 1669 return -EIO; 1670 } 1671 1672 if (q->last_buffer_dequeued) { 1673 dprintk(3, "last buffer dequeued already, will not wait for buffers\n"); 1674 return -EPIPE; 1675 } 1676 1677 if (!list_empty(&q->done_list)) { 1678 /* 1679 * Found a buffer that we were waiting for. 1680 */ 1681 break; 1682 } 1683 1684 if (nonblocking) { 1685 dprintk(3, "nonblocking and no buffers to dequeue, will not wait\n"); 1686 return -EAGAIN; 1687 } 1688 1689 /* 1690 * We are streaming and blocking, wait for another buffer to 1691 * become ready or for streamoff. Driver's lock is released to 1692 * allow streamoff or qbuf to be called while waiting. 1693 */ 1694 call_void_qop(q, wait_prepare, q); 1695 1696 /* 1697 * All locks have been released, it is safe to sleep now. 1698 */ 1699 dprintk(3, "will sleep waiting for buffers\n"); 1700 ret = wait_event_interruptible(q->done_wq, 1701 !list_empty(&q->done_list) || !q->streaming || 1702 q->error); 1703 1704 /* 1705 * We need to reevaluate both conditions again after reacquiring 1706 * the locks or return an error if one occurred. 1707 */ 1708 call_void_qop(q, wait_finish, q); 1709 if (ret) { 1710 dprintk(1, "sleep was interrupted\n"); 1711 return ret; 1712 } 1713 } 1714 return 0; 1715 } 1716 1717 /* 1718 * __vb2_get_done_vb() - get a buffer ready for dequeuing 1719 * 1720 * Will sleep if required for nonblocking == false. 1721 */ 1722 static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb, 1723 void *pb, int nonblocking) 1724 { 1725 unsigned long flags; 1726 int ret = 0; 1727 1728 /* 1729 * Wait for at least one buffer to become available on the done_list. 1730 */ 1731 ret = __vb2_wait_for_done_vb(q, nonblocking); 1732 if (ret) 1733 return ret; 1734 1735 /* 1736 * Driver's lock has been held since we last verified that done_list 1737 * is not empty, so no need for another list_empty(done_list) check. 1738 */ 1739 spin_lock_irqsave(&q->done_lock, flags); 1740 *vb = list_first_entry(&q->done_list, struct vb2_buffer, done_entry); 1741 /* 1742 * Only remove the buffer from done_list if all planes can be 1743 * handled. Some cases such as V4L2 file I/O and DVB have pb 1744 * == NULL; skip the check then as there's nothing to verify. 1745 */ 1746 if (pb) 1747 ret = call_bufop(q, verify_planes_array, *vb, pb); 1748 if (!ret) 1749 list_del(&(*vb)->done_entry); 1750 spin_unlock_irqrestore(&q->done_lock, flags); 1751 1752 return ret; 1753 } 1754 1755 int vb2_wait_for_all_buffers(struct vb2_queue *q) 1756 { 1757 if (!q->streaming) { 1758 dprintk(1, "streaming off, will not wait for buffers\n"); 1759 return -EINVAL; 1760 } 1761 1762 if (q->start_streaming_called) 1763 wait_event(q->done_wq, !atomic_read(&q->owned_by_drv_count)); 1764 return 0; 1765 } 1766 EXPORT_SYMBOL_GPL(vb2_wait_for_all_buffers); 1767 1768 /* 1769 * __vb2_dqbuf() - bring back the buffer to the DEQUEUED state 1770 */ 1771 static void __vb2_dqbuf(struct vb2_buffer *vb) 1772 { 1773 struct vb2_queue *q = vb->vb2_queue; 1774 1775 /* nothing to do if the buffer is already dequeued */ 1776 if (vb->state == VB2_BUF_STATE_DEQUEUED) 1777 return; 1778 1779 vb->state = VB2_BUF_STATE_DEQUEUED; 1780 1781 call_void_bufop(q, init_buffer, vb); 1782 } 1783 1784 int vb2_core_dqbuf(struct vb2_queue *q, unsigned int *pindex, void *pb, 1785 bool nonblocking) 1786 { 1787 struct vb2_buffer *vb = NULL; 1788 int ret; 1789 1790 ret = __vb2_get_done_vb(q, &vb, pb, nonblocking); 1791 if (ret < 0) 1792 return ret; 1793 1794 switch (vb->state) { 1795 case VB2_BUF_STATE_DONE: 1796 dprintk(3, "returning done buffer\n"); 1797 break; 1798 case VB2_BUF_STATE_ERROR: 1799 dprintk(3, "returning done buffer with errors\n"); 1800 break; 1801 default: 1802 dprintk(1, "invalid buffer state\n"); 1803 return -EINVAL; 1804 } 1805 1806 call_void_vb_qop(vb, buf_finish, vb); 1807 vb->prepared = 0; 1808 1809 if (pindex) 1810 *pindex = vb->index; 1811 1812 /* Fill buffer information for the userspace */ 1813 if (pb) 1814 call_void_bufop(q, fill_user_buffer, vb, pb); 1815 1816 /* Remove from videobuf queue */ 1817 list_del(&vb->queued_entry); 1818 q->queued_count--; 1819 1820 trace_vb2_dqbuf(q, vb); 1821 1822 /* go back to dequeued state */ 1823 __vb2_dqbuf(vb); 1824 1825 if (WARN_ON(vb->req_obj.req)) { 1826 media_request_object_unbind(&vb->req_obj); 1827 media_request_object_put(&vb->req_obj); 1828 } 1829 if (vb->request) 1830 media_request_put(vb->request); 1831 vb->request = NULL; 1832 1833 dprintk(2, "dqbuf of buffer %d, with state %d\n", 1834 vb->index, vb->state); 1835 1836 return 0; 1837 1838 } 1839 EXPORT_SYMBOL_GPL(vb2_core_dqbuf); 1840 1841 /* 1842 * __vb2_queue_cancel() - cancel and stop (pause) streaming 1843 * 1844 * Removes all queued buffers from driver's queue and all buffers queued by 1845 * userspace from videobuf's queue. Returns to state after reqbufs. 1846 */ 1847 static void __vb2_queue_cancel(struct vb2_queue *q) 1848 { 1849 unsigned int i; 1850 1851 /* 1852 * Tell driver to stop all transactions and release all queued 1853 * buffers. 1854 */ 1855 if (q->start_streaming_called) 1856 call_void_qop(q, stop_streaming, q); 1857 1858 /* 1859 * If you see this warning, then the driver isn't cleaning up properly 1860 * in stop_streaming(). See the stop_streaming() documentation in 1861 * videobuf2-core.h for more information how buffers should be returned 1862 * to vb2 in stop_streaming(). 1863 */ 1864 if (WARN_ON(atomic_read(&q->owned_by_drv_count))) { 1865 for (i = 0; i < q->num_buffers; ++i) 1866 if (q->bufs[i]->state == VB2_BUF_STATE_ACTIVE) { 1867 pr_warn("driver bug: stop_streaming operation is leaving buf %p in active state\n", 1868 q->bufs[i]); 1869 vb2_buffer_done(q->bufs[i], VB2_BUF_STATE_ERROR); 1870 } 1871 /* Must be zero now */ 1872 WARN_ON(atomic_read(&q->owned_by_drv_count)); 1873 } 1874 1875 q->streaming = 0; 1876 q->start_streaming_called = 0; 1877 q->queued_count = 0; 1878 q->error = 0; 1879 q->uses_requests = 0; 1880 q->uses_qbuf = 0; 1881 1882 /* 1883 * Remove all buffers from videobuf's list... 1884 */ 1885 INIT_LIST_HEAD(&q->queued_list); 1886 /* 1887 * ...and done list; userspace will not receive any buffers it 1888 * has not already dequeued before initiating cancel. 1889 */ 1890 INIT_LIST_HEAD(&q->done_list); 1891 atomic_set(&q->owned_by_drv_count, 0); 1892 wake_up_all(&q->done_wq); 1893 1894 /* 1895 * Reinitialize all buffers for next use. 1896 * Make sure to call buf_finish for any queued buffers. Normally 1897 * that's done in dqbuf, but that's not going to happen when we 1898 * cancel the whole queue. Note: this code belongs here, not in 1899 * __vb2_dqbuf() since in vb2_core_dqbuf() there is a critical 1900 * call to __fill_user_buffer() after buf_finish(). That order can't 1901 * be changed, so we can't move the buf_finish() to __vb2_dqbuf(). 1902 */ 1903 for (i = 0; i < q->num_buffers; ++i) { 1904 struct vb2_buffer *vb = q->bufs[i]; 1905 struct media_request *req = vb->req_obj.req; 1906 1907 /* 1908 * If a request is associated with this buffer, then 1909 * call buf_request_cancel() to give the driver to complete() 1910 * related request objects. Otherwise those objects would 1911 * never complete. 1912 */ 1913 if (req) { 1914 enum media_request_state state; 1915 unsigned long flags; 1916 1917 spin_lock_irqsave(&req->lock, flags); 1918 state = req->state; 1919 spin_unlock_irqrestore(&req->lock, flags); 1920 1921 if (state == MEDIA_REQUEST_STATE_QUEUED) 1922 call_void_vb_qop(vb, buf_request_complete, vb); 1923 } 1924 1925 if (vb->synced) { 1926 unsigned int plane; 1927 1928 for (plane = 0; plane < vb->num_planes; ++plane) 1929 call_void_memop(vb, finish, 1930 vb->planes[plane].mem_priv); 1931 vb->synced = 0; 1932 } 1933 1934 if (vb->prepared) { 1935 call_void_vb_qop(vb, buf_finish, vb); 1936 vb->prepared = 0; 1937 } 1938 __vb2_dqbuf(vb); 1939 1940 if (vb->req_obj.req) { 1941 media_request_object_unbind(&vb->req_obj); 1942 media_request_object_put(&vb->req_obj); 1943 } 1944 if (vb->request) 1945 media_request_put(vb->request); 1946 vb->request = NULL; 1947 vb->copied_timestamp = 0; 1948 } 1949 } 1950 1951 int vb2_core_streamon(struct vb2_queue *q, unsigned int type) 1952 { 1953 int ret; 1954 1955 if (type != q->type) { 1956 dprintk(1, "invalid stream type\n"); 1957 return -EINVAL; 1958 } 1959 1960 if (q->streaming) { 1961 dprintk(3, "already streaming\n"); 1962 return 0; 1963 } 1964 1965 if (!q->num_buffers) { 1966 dprintk(1, "no buffers have been allocated\n"); 1967 return -EINVAL; 1968 } 1969 1970 if (q->num_buffers < q->min_buffers_needed) { 1971 dprintk(1, "need at least %u allocated buffers\n", 1972 q->min_buffers_needed); 1973 return -EINVAL; 1974 } 1975 1976 /* 1977 * Tell driver to start streaming provided sufficient buffers 1978 * are available. 1979 */ 1980 if (q->queued_count >= q->min_buffers_needed) { 1981 ret = v4l_vb2q_enable_media_source(q); 1982 if (ret) 1983 return ret; 1984 ret = vb2_start_streaming(q); 1985 if (ret) 1986 return ret; 1987 } 1988 1989 q->streaming = 1; 1990 1991 dprintk(3, "successful\n"); 1992 return 0; 1993 } 1994 EXPORT_SYMBOL_GPL(vb2_core_streamon); 1995 1996 void vb2_queue_error(struct vb2_queue *q) 1997 { 1998 q->error = 1; 1999 2000 wake_up_all(&q->done_wq); 2001 } 2002 EXPORT_SYMBOL_GPL(vb2_queue_error); 2003 2004 int vb2_core_streamoff(struct vb2_queue *q, unsigned int type) 2005 { 2006 if (type != q->type) { 2007 dprintk(1, "invalid stream type\n"); 2008 return -EINVAL; 2009 } 2010 2011 /* 2012 * Cancel will pause streaming and remove all buffers from the driver 2013 * and videobuf, effectively returning control over them to userspace. 2014 * 2015 * Note that we do this even if q->streaming == 0: if you prepare or 2016 * queue buffers, and then call streamoff without ever having called 2017 * streamon, you would still expect those buffers to be returned to 2018 * their normal dequeued state. 2019 */ 2020 __vb2_queue_cancel(q); 2021 q->waiting_for_buffers = !q->is_output; 2022 q->last_buffer_dequeued = false; 2023 2024 dprintk(3, "successful\n"); 2025 return 0; 2026 } 2027 EXPORT_SYMBOL_GPL(vb2_core_streamoff); 2028 2029 /* 2030 * __find_plane_by_offset() - find plane associated with the given offset off 2031 */ 2032 static int __find_plane_by_offset(struct vb2_queue *q, unsigned long off, 2033 unsigned int *_buffer, unsigned int *_plane) 2034 { 2035 struct vb2_buffer *vb; 2036 unsigned int buffer, plane; 2037 2038 /* 2039 * Go over all buffers and their planes, comparing the given offset 2040 * with an offset assigned to each plane. If a match is found, 2041 * return its buffer and plane numbers. 2042 */ 2043 for (buffer = 0; buffer < q->num_buffers; ++buffer) { 2044 vb = q->bufs[buffer]; 2045 2046 for (plane = 0; plane < vb->num_planes; ++plane) { 2047 if (vb->planes[plane].m.offset == off) { 2048 *_buffer = buffer; 2049 *_plane = plane; 2050 return 0; 2051 } 2052 } 2053 } 2054 2055 return -EINVAL; 2056 } 2057 2058 int vb2_core_expbuf(struct vb2_queue *q, int *fd, unsigned int type, 2059 unsigned int index, unsigned int plane, unsigned int flags) 2060 { 2061 struct vb2_buffer *vb = NULL; 2062 struct vb2_plane *vb_plane; 2063 int ret; 2064 struct dma_buf *dbuf; 2065 2066 if (q->memory != VB2_MEMORY_MMAP) { 2067 dprintk(1, "queue is not currently set up for mmap\n"); 2068 return -EINVAL; 2069 } 2070 2071 if (!q->mem_ops->get_dmabuf) { 2072 dprintk(1, "queue does not support DMA buffer exporting\n"); 2073 return -EINVAL; 2074 } 2075 2076 if (flags & ~(O_CLOEXEC | O_ACCMODE)) { 2077 dprintk(1, "queue does support only O_CLOEXEC and access mode flags\n"); 2078 return -EINVAL; 2079 } 2080 2081 if (type != q->type) { 2082 dprintk(1, "invalid buffer type\n"); 2083 return -EINVAL; 2084 } 2085 2086 if (index >= q->num_buffers) { 2087 dprintk(1, "buffer index out of range\n"); 2088 return -EINVAL; 2089 } 2090 2091 vb = q->bufs[index]; 2092 2093 if (plane >= vb->num_planes) { 2094 dprintk(1, "buffer plane out of range\n"); 2095 return -EINVAL; 2096 } 2097 2098 if (vb2_fileio_is_active(q)) { 2099 dprintk(1, "expbuf: file io in progress\n"); 2100 return -EBUSY; 2101 } 2102 2103 vb_plane = &vb->planes[plane]; 2104 2105 dbuf = call_ptr_memop(vb, get_dmabuf, vb_plane->mem_priv, 2106 flags & O_ACCMODE); 2107 if (IS_ERR_OR_NULL(dbuf)) { 2108 dprintk(1, "failed to export buffer %d, plane %d\n", 2109 index, plane); 2110 return -EINVAL; 2111 } 2112 2113 ret = dma_buf_fd(dbuf, flags & ~O_ACCMODE); 2114 if (ret < 0) { 2115 dprintk(3, "buffer %d, plane %d failed to export (%d)\n", 2116 index, plane, ret); 2117 dma_buf_put(dbuf); 2118 return ret; 2119 } 2120 2121 dprintk(3, "buffer %d, plane %d exported as %d descriptor\n", 2122 index, plane, ret); 2123 *fd = ret; 2124 2125 return 0; 2126 } 2127 EXPORT_SYMBOL_GPL(vb2_core_expbuf); 2128 2129 int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma) 2130 { 2131 unsigned long off = vma->vm_pgoff << PAGE_SHIFT; 2132 struct vb2_buffer *vb; 2133 unsigned int buffer = 0, plane = 0; 2134 int ret; 2135 unsigned long length; 2136 2137 if (q->memory != VB2_MEMORY_MMAP) { 2138 dprintk(1, "queue is not currently set up for mmap\n"); 2139 return -EINVAL; 2140 } 2141 2142 /* 2143 * Check memory area access mode. 2144 */ 2145 if (!(vma->vm_flags & VM_SHARED)) { 2146 dprintk(1, "invalid vma flags, VM_SHARED needed\n"); 2147 return -EINVAL; 2148 } 2149 if (q->is_output) { 2150 if (!(vma->vm_flags & VM_WRITE)) { 2151 dprintk(1, "invalid vma flags, VM_WRITE needed\n"); 2152 return -EINVAL; 2153 } 2154 } else { 2155 if (!(vma->vm_flags & VM_READ)) { 2156 dprintk(1, "invalid vma flags, VM_READ needed\n"); 2157 return -EINVAL; 2158 } 2159 } 2160 2161 mutex_lock(&q->mmap_lock); 2162 2163 if (vb2_fileio_is_active(q)) { 2164 dprintk(1, "mmap: file io in progress\n"); 2165 ret = -EBUSY; 2166 goto unlock; 2167 } 2168 2169 /* 2170 * Find the plane corresponding to the offset passed by userspace. 2171 */ 2172 ret = __find_plane_by_offset(q, off, &buffer, &plane); 2173 if (ret) 2174 goto unlock; 2175 2176 vb = q->bufs[buffer]; 2177 2178 /* 2179 * MMAP requires page_aligned buffers. 2180 * The buffer length was page_aligned at __vb2_buf_mem_alloc(), 2181 * so, we need to do the same here. 2182 */ 2183 length = PAGE_ALIGN(vb->planes[plane].length); 2184 if (length < (vma->vm_end - vma->vm_start)) { 2185 dprintk(1, 2186 "MMAP invalid, as it would overflow buffer length\n"); 2187 ret = -EINVAL; 2188 goto unlock; 2189 } 2190 2191 ret = call_memop(vb, mmap, vb->planes[plane].mem_priv, vma); 2192 2193 unlock: 2194 mutex_unlock(&q->mmap_lock); 2195 if (ret) 2196 return ret; 2197 2198 dprintk(3, "buffer %d, plane %d successfully mapped\n", buffer, plane); 2199 return 0; 2200 } 2201 EXPORT_SYMBOL_GPL(vb2_mmap); 2202 2203 #ifndef CONFIG_MMU 2204 unsigned long vb2_get_unmapped_area(struct vb2_queue *q, 2205 unsigned long addr, 2206 unsigned long len, 2207 unsigned long pgoff, 2208 unsigned long flags) 2209 { 2210 unsigned long off = pgoff << PAGE_SHIFT; 2211 struct vb2_buffer *vb; 2212 unsigned int buffer, plane; 2213 void *vaddr; 2214 int ret; 2215 2216 if (q->memory != VB2_MEMORY_MMAP) { 2217 dprintk(1, "queue is not currently set up for mmap\n"); 2218 return -EINVAL; 2219 } 2220 2221 /* 2222 * Find the plane corresponding to the offset passed by userspace. 2223 */ 2224 ret = __find_plane_by_offset(q, off, &buffer, &plane); 2225 if (ret) 2226 return ret; 2227 2228 vb = q->bufs[buffer]; 2229 2230 vaddr = vb2_plane_vaddr(vb, plane); 2231 return vaddr ? (unsigned long)vaddr : -EINVAL; 2232 } 2233 EXPORT_SYMBOL_GPL(vb2_get_unmapped_area); 2234 #endif 2235 2236 int vb2_core_queue_init(struct vb2_queue *q) 2237 { 2238 /* 2239 * Sanity check 2240 */ 2241 if (WARN_ON(!q) || 2242 WARN_ON(!q->ops) || 2243 WARN_ON(!q->mem_ops) || 2244 WARN_ON(!q->type) || 2245 WARN_ON(!q->io_modes) || 2246 WARN_ON(!q->ops->queue_setup) || 2247 WARN_ON(!q->ops->buf_queue)) 2248 return -EINVAL; 2249 2250 INIT_LIST_HEAD(&q->queued_list); 2251 INIT_LIST_HEAD(&q->done_list); 2252 spin_lock_init(&q->done_lock); 2253 mutex_init(&q->mmap_lock); 2254 init_waitqueue_head(&q->done_wq); 2255 2256 q->memory = VB2_MEMORY_UNKNOWN; 2257 2258 if (q->buf_struct_size == 0) 2259 q->buf_struct_size = sizeof(struct vb2_buffer); 2260 2261 if (q->bidirectional) 2262 q->dma_dir = DMA_BIDIRECTIONAL; 2263 else 2264 q->dma_dir = q->is_output ? DMA_TO_DEVICE : DMA_FROM_DEVICE; 2265 2266 return 0; 2267 } 2268 EXPORT_SYMBOL_GPL(vb2_core_queue_init); 2269 2270 static int __vb2_init_fileio(struct vb2_queue *q, int read); 2271 static int __vb2_cleanup_fileio(struct vb2_queue *q); 2272 void vb2_core_queue_release(struct vb2_queue *q) 2273 { 2274 __vb2_cleanup_fileio(q); 2275 __vb2_queue_cancel(q); 2276 mutex_lock(&q->mmap_lock); 2277 __vb2_queue_free(q, q->num_buffers); 2278 mutex_unlock(&q->mmap_lock); 2279 } 2280 EXPORT_SYMBOL_GPL(vb2_core_queue_release); 2281 2282 __poll_t vb2_core_poll(struct vb2_queue *q, struct file *file, 2283 poll_table *wait) 2284 { 2285 __poll_t req_events = poll_requested_events(wait); 2286 struct vb2_buffer *vb = NULL; 2287 unsigned long flags; 2288 2289 if (!q->is_output && !(req_events & (EPOLLIN | EPOLLRDNORM))) 2290 return 0; 2291 if (q->is_output && !(req_events & (EPOLLOUT | EPOLLWRNORM))) 2292 return 0; 2293 2294 poll_wait(file, &q->done_wq, wait); 2295 2296 /* 2297 * Start file I/O emulator only if streaming API has not been used yet. 2298 */ 2299 if (q->num_buffers == 0 && !vb2_fileio_is_active(q)) { 2300 if (!q->is_output && (q->io_modes & VB2_READ) && 2301 (req_events & (EPOLLIN | EPOLLRDNORM))) { 2302 if (__vb2_init_fileio(q, 1)) 2303 return EPOLLERR; 2304 } 2305 if (q->is_output && (q->io_modes & VB2_WRITE) && 2306 (req_events & (EPOLLOUT | EPOLLWRNORM))) { 2307 if (__vb2_init_fileio(q, 0)) 2308 return EPOLLERR; 2309 /* 2310 * Write to OUTPUT queue can be done immediately. 2311 */ 2312 return EPOLLOUT | EPOLLWRNORM; 2313 } 2314 } 2315 2316 /* 2317 * There is nothing to wait for if the queue isn't streaming, or if the 2318 * error flag is set. 2319 */ 2320 if (!vb2_is_streaming(q) || q->error) 2321 return EPOLLERR; 2322 2323 /* 2324 * If this quirk is set and QBUF hasn't been called yet then 2325 * return EPOLLERR as well. This only affects capture queues, output 2326 * queues will always initialize waiting_for_buffers to false. 2327 * This quirk is set by V4L2 for backwards compatibility reasons. 2328 */ 2329 if (q->quirk_poll_must_check_waiting_for_buffers && 2330 q->waiting_for_buffers && (req_events & (EPOLLIN | EPOLLRDNORM))) 2331 return EPOLLERR; 2332 2333 /* 2334 * For output streams you can call write() as long as there are fewer 2335 * buffers queued than there are buffers available. 2336 */ 2337 if (q->is_output && q->fileio && q->queued_count < q->num_buffers) 2338 return EPOLLOUT | EPOLLWRNORM; 2339 2340 if (list_empty(&q->done_list)) { 2341 /* 2342 * If the last buffer was dequeued from a capture queue, 2343 * return immediately. DQBUF will return -EPIPE. 2344 */ 2345 if (q->last_buffer_dequeued) 2346 return EPOLLIN | EPOLLRDNORM; 2347 } 2348 2349 /* 2350 * Take first buffer available for dequeuing. 2351 */ 2352 spin_lock_irqsave(&q->done_lock, flags); 2353 if (!list_empty(&q->done_list)) 2354 vb = list_first_entry(&q->done_list, struct vb2_buffer, 2355 done_entry); 2356 spin_unlock_irqrestore(&q->done_lock, flags); 2357 2358 if (vb && (vb->state == VB2_BUF_STATE_DONE 2359 || vb->state == VB2_BUF_STATE_ERROR)) { 2360 return (q->is_output) ? 2361 EPOLLOUT | EPOLLWRNORM : 2362 EPOLLIN | EPOLLRDNORM; 2363 } 2364 return 0; 2365 } 2366 EXPORT_SYMBOL_GPL(vb2_core_poll); 2367 2368 /* 2369 * struct vb2_fileio_buf - buffer context used by file io emulator 2370 * 2371 * vb2 provides a compatibility layer and emulator of file io (read and 2372 * write) calls on top of streaming API. This structure is used for 2373 * tracking context related to the buffers. 2374 */ 2375 struct vb2_fileio_buf { 2376 void *vaddr; 2377 unsigned int size; 2378 unsigned int pos; 2379 unsigned int queued:1; 2380 }; 2381 2382 /* 2383 * struct vb2_fileio_data - queue context used by file io emulator 2384 * 2385 * @cur_index: the index of the buffer currently being read from or 2386 * written to. If equal to q->num_buffers then a new buffer 2387 * must be dequeued. 2388 * @initial_index: in the read() case all buffers are queued up immediately 2389 * in __vb2_init_fileio() and __vb2_perform_fileio() just cycles 2390 * buffers. However, in the write() case no buffers are initially 2391 * queued, instead whenever a buffer is full it is queued up by 2392 * __vb2_perform_fileio(). Only once all available buffers have 2393 * been queued up will __vb2_perform_fileio() start to dequeue 2394 * buffers. This means that initially __vb2_perform_fileio() 2395 * needs to know what buffer index to use when it is queuing up 2396 * the buffers for the first time. That initial index is stored 2397 * in this field. Once it is equal to q->num_buffers all 2398 * available buffers have been queued and __vb2_perform_fileio() 2399 * should start the normal dequeue/queue cycle. 2400 * 2401 * vb2 provides a compatibility layer and emulator of file io (read and 2402 * write) calls on top of streaming API. For proper operation it required 2403 * this structure to save the driver state between each call of the read 2404 * or write function. 2405 */ 2406 struct vb2_fileio_data { 2407 unsigned int count; 2408 unsigned int type; 2409 unsigned int memory; 2410 struct vb2_fileio_buf bufs[VB2_MAX_FRAME]; 2411 unsigned int cur_index; 2412 unsigned int initial_index; 2413 unsigned int q_count; 2414 unsigned int dq_count; 2415 unsigned read_once:1; 2416 unsigned write_immediately:1; 2417 }; 2418 2419 /* 2420 * __vb2_init_fileio() - initialize file io emulator 2421 * @q: videobuf2 queue 2422 * @read: mode selector (1 means read, 0 means write) 2423 */ 2424 static int __vb2_init_fileio(struct vb2_queue *q, int read) 2425 { 2426 struct vb2_fileio_data *fileio; 2427 int i, ret; 2428 unsigned int count = 0; 2429 2430 /* 2431 * Sanity check 2432 */ 2433 if (WARN_ON((read && !(q->io_modes & VB2_READ)) || 2434 (!read && !(q->io_modes & VB2_WRITE)))) 2435 return -EINVAL; 2436 2437 /* 2438 * Check if device supports mapping buffers to kernel virtual space. 2439 */ 2440 if (!q->mem_ops->vaddr) 2441 return -EBUSY; 2442 2443 /* 2444 * Check if streaming api has not been already activated. 2445 */ 2446 if (q->streaming || q->num_buffers > 0) 2447 return -EBUSY; 2448 2449 /* 2450 * Start with count 1, driver can increase it in queue_setup() 2451 */ 2452 count = 1; 2453 2454 dprintk(3, "setting up file io: mode %s, count %d, read_once %d, write_immediately %d\n", 2455 (read) ? "read" : "write", count, q->fileio_read_once, 2456 q->fileio_write_immediately); 2457 2458 fileio = kzalloc(sizeof(*fileio), GFP_KERNEL); 2459 if (fileio == NULL) 2460 return -ENOMEM; 2461 2462 fileio->read_once = q->fileio_read_once; 2463 fileio->write_immediately = q->fileio_write_immediately; 2464 2465 /* 2466 * Request buffers and use MMAP type to force driver 2467 * to allocate buffers by itself. 2468 */ 2469 fileio->count = count; 2470 fileio->memory = VB2_MEMORY_MMAP; 2471 fileio->type = q->type; 2472 q->fileio = fileio; 2473 ret = vb2_core_reqbufs(q, fileio->memory, &fileio->count); 2474 if (ret) 2475 goto err_kfree; 2476 2477 /* 2478 * Check if plane_count is correct 2479 * (multiplane buffers are not supported). 2480 */ 2481 if (q->bufs[0]->num_planes != 1) { 2482 ret = -EBUSY; 2483 goto err_reqbufs; 2484 } 2485 2486 /* 2487 * Get kernel address of each buffer. 2488 */ 2489 for (i = 0; i < q->num_buffers; i++) { 2490 fileio->bufs[i].vaddr = vb2_plane_vaddr(q->bufs[i], 0); 2491 if (fileio->bufs[i].vaddr == NULL) { 2492 ret = -EINVAL; 2493 goto err_reqbufs; 2494 } 2495 fileio->bufs[i].size = vb2_plane_size(q->bufs[i], 0); 2496 } 2497 2498 /* 2499 * Read mode requires pre queuing of all buffers. 2500 */ 2501 if (read) { 2502 /* 2503 * Queue all buffers. 2504 */ 2505 for (i = 0; i < q->num_buffers; i++) { 2506 ret = vb2_core_qbuf(q, i, NULL, NULL); 2507 if (ret) 2508 goto err_reqbufs; 2509 fileio->bufs[i].queued = 1; 2510 } 2511 /* 2512 * All buffers have been queued, so mark that by setting 2513 * initial_index to q->num_buffers 2514 */ 2515 fileio->initial_index = q->num_buffers; 2516 fileio->cur_index = q->num_buffers; 2517 } 2518 2519 /* 2520 * Start streaming. 2521 */ 2522 ret = vb2_core_streamon(q, q->type); 2523 if (ret) 2524 goto err_reqbufs; 2525 2526 return ret; 2527 2528 err_reqbufs: 2529 fileio->count = 0; 2530 vb2_core_reqbufs(q, fileio->memory, &fileio->count); 2531 2532 err_kfree: 2533 q->fileio = NULL; 2534 kfree(fileio); 2535 return ret; 2536 } 2537 2538 /* 2539 * __vb2_cleanup_fileio() - free resourced used by file io emulator 2540 * @q: videobuf2 queue 2541 */ 2542 static int __vb2_cleanup_fileio(struct vb2_queue *q) 2543 { 2544 struct vb2_fileio_data *fileio = q->fileio; 2545 2546 if (fileio) { 2547 vb2_core_streamoff(q, q->type); 2548 q->fileio = NULL; 2549 fileio->count = 0; 2550 vb2_core_reqbufs(q, fileio->memory, &fileio->count); 2551 kfree(fileio); 2552 dprintk(3, "file io emulator closed\n"); 2553 } 2554 return 0; 2555 } 2556 2557 /* 2558 * __vb2_perform_fileio() - perform a single file io (read or write) operation 2559 * @q: videobuf2 queue 2560 * @data: pointed to target userspace buffer 2561 * @count: number of bytes to read or write 2562 * @ppos: file handle position tracking pointer 2563 * @nonblock: mode selector (1 means blocking calls, 0 means nonblocking) 2564 * @read: access mode selector (1 means read, 0 means write) 2565 */ 2566 static size_t __vb2_perform_fileio(struct vb2_queue *q, char __user *data, size_t count, 2567 loff_t *ppos, int nonblock, int read) 2568 { 2569 struct vb2_fileio_data *fileio; 2570 struct vb2_fileio_buf *buf; 2571 bool is_multiplanar = q->is_multiplanar; 2572 /* 2573 * When using write() to write data to an output video node the vb2 core 2574 * should copy timestamps if V4L2_BUF_FLAG_TIMESTAMP_COPY is set. Nobody 2575 * else is able to provide this information with the write() operation. 2576 */ 2577 bool copy_timestamp = !read && q->copy_timestamp; 2578 unsigned index; 2579 int ret; 2580 2581 dprintk(3, "mode %s, offset %ld, count %zd, %sblocking\n", 2582 read ? "read" : "write", (long)*ppos, count, 2583 nonblock ? "non" : ""); 2584 2585 if (!data) 2586 return -EINVAL; 2587 2588 /* 2589 * Initialize emulator on first call. 2590 */ 2591 if (!vb2_fileio_is_active(q)) { 2592 ret = __vb2_init_fileio(q, read); 2593 dprintk(3, "vb2_init_fileio result: %d\n", ret); 2594 if (ret) 2595 return ret; 2596 } 2597 fileio = q->fileio; 2598 2599 /* 2600 * Check if we need to dequeue the buffer. 2601 */ 2602 index = fileio->cur_index; 2603 if (index >= q->num_buffers) { 2604 struct vb2_buffer *b; 2605 2606 /* 2607 * Call vb2_dqbuf to get buffer back. 2608 */ 2609 ret = vb2_core_dqbuf(q, &index, NULL, nonblock); 2610 dprintk(5, "vb2_dqbuf result: %d\n", ret); 2611 if (ret) 2612 return ret; 2613 fileio->dq_count += 1; 2614 2615 fileio->cur_index = index; 2616 buf = &fileio->bufs[index]; 2617 b = q->bufs[index]; 2618 2619 /* 2620 * Get number of bytes filled by the driver 2621 */ 2622 buf->pos = 0; 2623 buf->queued = 0; 2624 buf->size = read ? vb2_get_plane_payload(q->bufs[index], 0) 2625 : vb2_plane_size(q->bufs[index], 0); 2626 /* Compensate for data_offset on read in the multiplanar case. */ 2627 if (is_multiplanar && read && 2628 b->planes[0].data_offset < buf->size) { 2629 buf->pos = b->planes[0].data_offset; 2630 buf->size -= buf->pos; 2631 } 2632 } else { 2633 buf = &fileio->bufs[index]; 2634 } 2635 2636 /* 2637 * Limit count on last few bytes of the buffer. 2638 */ 2639 if (buf->pos + count > buf->size) { 2640 count = buf->size - buf->pos; 2641 dprintk(5, "reducing read count: %zd\n", count); 2642 } 2643 2644 /* 2645 * Transfer data to userspace. 2646 */ 2647 dprintk(3, "copying %zd bytes - buffer %d, offset %u\n", 2648 count, index, buf->pos); 2649 if (read) 2650 ret = copy_to_user(data, buf->vaddr + buf->pos, count); 2651 else 2652 ret = copy_from_user(buf->vaddr + buf->pos, data, count); 2653 if (ret) { 2654 dprintk(3, "error copying data\n"); 2655 return -EFAULT; 2656 } 2657 2658 /* 2659 * Update counters. 2660 */ 2661 buf->pos += count; 2662 *ppos += count; 2663 2664 /* 2665 * Queue next buffer if required. 2666 */ 2667 if (buf->pos == buf->size || (!read && fileio->write_immediately)) { 2668 struct vb2_buffer *b = q->bufs[index]; 2669 2670 /* 2671 * Check if this is the last buffer to read. 2672 */ 2673 if (read && fileio->read_once && fileio->dq_count == 1) { 2674 dprintk(3, "read limit reached\n"); 2675 return __vb2_cleanup_fileio(q); 2676 } 2677 2678 /* 2679 * Call vb2_qbuf and give buffer to the driver. 2680 */ 2681 b->planes[0].bytesused = buf->pos; 2682 2683 if (copy_timestamp) 2684 b->timestamp = ktime_get_ns(); 2685 ret = vb2_core_qbuf(q, index, NULL, NULL); 2686 dprintk(5, "vb2_dbuf result: %d\n", ret); 2687 if (ret) 2688 return ret; 2689 2690 /* 2691 * Buffer has been queued, update the status 2692 */ 2693 buf->pos = 0; 2694 buf->queued = 1; 2695 buf->size = vb2_plane_size(q->bufs[index], 0); 2696 fileio->q_count += 1; 2697 /* 2698 * If we are queuing up buffers for the first time, then 2699 * increase initial_index by one. 2700 */ 2701 if (fileio->initial_index < q->num_buffers) 2702 fileio->initial_index++; 2703 /* 2704 * The next buffer to use is either a buffer that's going to be 2705 * queued for the first time (initial_index < q->num_buffers) 2706 * or it is equal to q->num_buffers, meaning that the next 2707 * time we need to dequeue a buffer since we've now queued up 2708 * all the 'first time' buffers. 2709 */ 2710 fileio->cur_index = fileio->initial_index; 2711 } 2712 2713 /* 2714 * Return proper number of bytes processed. 2715 */ 2716 if (ret == 0) 2717 ret = count; 2718 return ret; 2719 } 2720 2721 size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count, 2722 loff_t *ppos, int nonblocking) 2723 { 2724 return __vb2_perform_fileio(q, data, count, ppos, nonblocking, 1); 2725 } 2726 EXPORT_SYMBOL_GPL(vb2_read); 2727 2728 size_t vb2_write(struct vb2_queue *q, const char __user *data, size_t count, 2729 loff_t *ppos, int nonblocking) 2730 { 2731 return __vb2_perform_fileio(q, (char __user *) data, count, 2732 ppos, nonblocking, 0); 2733 } 2734 EXPORT_SYMBOL_GPL(vb2_write); 2735 2736 struct vb2_threadio_data { 2737 struct task_struct *thread; 2738 vb2_thread_fnc fnc; 2739 void *priv; 2740 bool stop; 2741 }; 2742 2743 static int vb2_thread(void *data) 2744 { 2745 struct vb2_queue *q = data; 2746 struct vb2_threadio_data *threadio = q->threadio; 2747 bool copy_timestamp = false; 2748 unsigned prequeue = 0; 2749 unsigned index = 0; 2750 int ret = 0; 2751 2752 if (q->is_output) { 2753 prequeue = q->num_buffers; 2754 copy_timestamp = q->copy_timestamp; 2755 } 2756 2757 set_freezable(); 2758 2759 for (;;) { 2760 struct vb2_buffer *vb; 2761 2762 /* 2763 * Call vb2_dqbuf to get buffer back. 2764 */ 2765 if (prequeue) { 2766 vb = q->bufs[index++]; 2767 prequeue--; 2768 } else { 2769 call_void_qop(q, wait_finish, q); 2770 if (!threadio->stop) 2771 ret = vb2_core_dqbuf(q, &index, NULL, 0); 2772 call_void_qop(q, wait_prepare, q); 2773 dprintk(5, "file io: vb2_dqbuf result: %d\n", ret); 2774 if (!ret) 2775 vb = q->bufs[index]; 2776 } 2777 if (ret || threadio->stop) 2778 break; 2779 try_to_freeze(); 2780 2781 if (vb->state != VB2_BUF_STATE_ERROR) 2782 if (threadio->fnc(vb, threadio->priv)) 2783 break; 2784 call_void_qop(q, wait_finish, q); 2785 if (copy_timestamp) 2786 vb->timestamp = ktime_get_ns(); 2787 if (!threadio->stop) 2788 ret = vb2_core_qbuf(q, vb->index, NULL, NULL); 2789 call_void_qop(q, wait_prepare, q); 2790 if (ret || threadio->stop) 2791 break; 2792 } 2793 2794 /* Hmm, linux becomes *very* unhappy without this ... */ 2795 while (!kthread_should_stop()) { 2796 set_current_state(TASK_INTERRUPTIBLE); 2797 schedule(); 2798 } 2799 return 0; 2800 } 2801 2802 /* 2803 * This function should not be used for anything else but the videobuf2-dvb 2804 * support. If you think you have another good use-case for this, then please 2805 * contact the linux-media mailinglist first. 2806 */ 2807 int vb2_thread_start(struct vb2_queue *q, vb2_thread_fnc fnc, void *priv, 2808 const char *thread_name) 2809 { 2810 struct vb2_threadio_data *threadio; 2811 int ret = 0; 2812 2813 if (q->threadio) 2814 return -EBUSY; 2815 if (vb2_is_busy(q)) 2816 return -EBUSY; 2817 if (WARN_ON(q->fileio)) 2818 return -EBUSY; 2819 2820 threadio = kzalloc(sizeof(*threadio), GFP_KERNEL); 2821 if (threadio == NULL) 2822 return -ENOMEM; 2823 threadio->fnc = fnc; 2824 threadio->priv = priv; 2825 2826 ret = __vb2_init_fileio(q, !q->is_output); 2827 dprintk(3, "file io: vb2_init_fileio result: %d\n", ret); 2828 if (ret) 2829 goto nomem; 2830 q->threadio = threadio; 2831 threadio->thread = kthread_run(vb2_thread, q, "vb2-%s", thread_name); 2832 if (IS_ERR(threadio->thread)) { 2833 ret = PTR_ERR(threadio->thread); 2834 threadio->thread = NULL; 2835 goto nothread; 2836 } 2837 return 0; 2838 2839 nothread: 2840 __vb2_cleanup_fileio(q); 2841 nomem: 2842 kfree(threadio); 2843 return ret; 2844 } 2845 EXPORT_SYMBOL_GPL(vb2_thread_start); 2846 2847 int vb2_thread_stop(struct vb2_queue *q) 2848 { 2849 struct vb2_threadio_data *threadio = q->threadio; 2850 int err; 2851 2852 if (threadio == NULL) 2853 return 0; 2854 threadio->stop = true; 2855 /* Wake up all pending sleeps in the thread */ 2856 vb2_queue_error(q); 2857 err = kthread_stop(threadio->thread); 2858 __vb2_cleanup_fileio(q); 2859 threadio->thread = NULL; 2860 kfree(threadio); 2861 q->threadio = NULL; 2862 return err; 2863 } 2864 EXPORT_SYMBOL_GPL(vb2_thread_stop); 2865 2866 MODULE_DESCRIPTION("Media buffer core framework"); 2867 MODULE_AUTHOR("Pawel Osciak <pawel@osciak.com>, Marek Szyprowski"); 2868 MODULE_LICENSE("GPL"); 2869