Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

media: vb2: videobuf -> videobuf2

It is confusing to use the term 'videobuf' or 'video-buf' since that
usually refers to the old videobuf version 1 framework. Rename to
'videobuf2' or vb2.

Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab@kernel.org>

authored by

Hans Verkuil and committed by
Mauro Carvalho Chehab
3e947c36 b02c4a52

+20 -20
+7 -7
drivers/media/common/videobuf2/videobuf2-core.c
··· 398 398 } 399 399 400 400 /* 401 - * __vb2_queue_alloc() - allocate videobuf buffer structures and (for MMAP type) 401 + * __vb2_queue_alloc() - allocate vb2 buffer structures and (for MMAP type) 402 402 * video buffer memory for all buffers/planes on the queue and initializes the 403 403 * queue 404 404 * ··· 417 417 VB2_MAX_FRAME - q->num_buffers); 418 418 419 419 for (buffer = 0; buffer < num_buffers; ++buffer) { 420 - /* Allocate videobuf buffer structures */ 420 + /* Allocate vb2 buffer structures */ 421 421 vb = kzalloc(q->buf_struct_size, GFP_KERNEL); 422 422 if (!vb) { 423 423 dprintk(q, 1, "memory alloc for buffer struct failed\n"); ··· 599 599 } 600 600 #endif 601 601 602 - /* Free videobuf buffers */ 602 + /* Free vb2 buffers */ 603 603 for (buffer = q->num_buffers - buffers; buffer < q->num_buffers; 604 604 ++buffer) { 605 605 kfree(q->bufs[buffer]); ··· 1949 1949 if (pb) 1950 1950 call_void_bufop(q, fill_user_buffer, vb, pb); 1951 1951 1952 - /* Remove from videobuf queue */ 1952 + /* Remove from vb2 queue */ 1953 1953 list_del(&vb->queued_entry); 1954 1954 q->queued_count--; 1955 1955 ··· 1978 1978 * __vb2_queue_cancel() - cancel and stop (pause) streaming 1979 1979 * 1980 1980 * Removes all queued buffers from driver's queue and all buffers queued by 1981 - * userspace from videobuf's queue. Returns to state after reqbufs. 1981 + * userspace from vb2's queue. Returns to state after reqbufs. 1982 1982 */ 1983 1983 static void __vb2_queue_cancel(struct vb2_queue *q) 1984 1984 { ··· 2016 2016 q->uses_qbuf = 0; 2017 2017 2018 2018 /* 2019 - * Remove all buffers from videobuf's list... 2019 + * Remove all buffers from vb2's list... 2020 2020 */ 2021 2021 INIT_LIST_HEAD(&q->queued_list); 2022 2022 /* ··· 2139 2139 2140 2140 /* 2141 2141 * Cancel will pause streaming and remove all buffers from the driver 2142 - * and videobuf, effectively returning control over them to userspace. 2142 + * and vb2, effectively returning control over them to userspace. 2143 2143 * 2144 2144 * Note that we do this even if q->streaming == 0: if you prepare or 2145 2145 * queue buffers, and then call streamoff without ever having called
+2 -2
drivers/media/common/videobuf2/videobuf2-dvb.c
··· 3 3 * 4 4 * some helper function for simple DVB cards which simply DMA the 5 5 * complete transport stream and let the computer sort everything else 6 - * (i.e. we are using the software demux, ...). Also uses the 7 - * video-buf to manage DMA buffers. 6 + * (i.e. we are using the software demux, ...). Also uses vb2 7 + * to manage DMA buffers. 8 8 * 9 9 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SUSE Labs] 10 10 */
+2 -2
drivers/media/common/videobuf2/videobuf2-v4l2.c
··· 268 268 /* 269 269 * Single-planar buffers do not use planes array, 270 270 * so fill in relevant v4l2_buffer struct fields instead. 271 - * In videobuf we use our internal V4l2_planes struct for 271 + * In vb2 we use our internal V4l2_planes struct for 272 272 * single-planar buffers as well, for simplicity. 273 273 * 274 274 * If bytesused == 0 for the output buffer, then fall back ··· 652 652 653 653 /* 654 654 * vb2_querybuf() - query video buffer information 655 - * @q: videobuf queue 655 + * @q: vb2 queue 656 656 * @b: buffer struct passed from userspace to vidioc_querybuf handler 657 657 * in driver 658 658 *
+8 -8
include/media/videobuf2-core.h
··· 65 65 * DMABUF memory types. 66 66 * @get_userptr: acquire userspace memory for a hardware operation; used for 67 67 * USERPTR memory types; vaddr is the address passed to the 68 - * videobuf layer when queuing a video buffer of USERPTR type; 68 + * videobuf2 layer when queuing a video buffer of USERPTR type; 69 69 * should return an allocator private per-buffer structure 70 70 * associated with the buffer on success, ERR_PTR() on failure; 71 71 * the returned private structure will then be passed as @buf_priv ··· 97 97 * associated with the passed private structure or NULL if not 98 98 * available. 99 99 * @num_users: return the current number of users of a memory buffer; 100 - * return 1 if the videobuf layer (or actually the driver using 100 + * return 1 if the videobuf2 layer (or actually the driver using 101 101 * it) is the only user. 102 102 * @mmap: setup a userspace mapping for a given memory buffer under 103 103 * the provided virtual memory region. ··· 210 210 * enum vb2_buffer_state - current video buffer state. 211 211 * @VB2_BUF_STATE_DEQUEUED: buffer under userspace control. 212 212 * @VB2_BUF_STATE_IN_REQUEST: buffer is queued in media request. 213 - * @VB2_BUF_STATE_PREPARING: buffer is being prepared in videobuf. 214 - * @VB2_BUF_STATE_QUEUED: buffer queued in videobuf, but not in driver. 213 + * @VB2_BUF_STATE_PREPARING: buffer is being prepared in videobuf2. 214 + * @VB2_BUF_STATE_QUEUED: buffer queued in videobuf2, but not in driver. 215 215 * @VB2_BUF_STATE_ACTIVE: buffer queued in driver and possibly used 216 216 * in a hardware operation. 217 - * @VB2_BUF_STATE_DONE: buffer returned from driver to videobuf, but 217 + * @VB2_BUF_STATE_DONE: buffer returned from driver to videobuf2, but 218 218 * not yet dequeued to userspace. 219 219 * @VB2_BUF_STATE_ERROR: same as above, but the operation on the buffer 220 220 * has ended with an error, which will be reported ··· 466 466 }; 467 467 468 468 /** 469 - * struct vb2_queue - a videobuf queue. 469 + * struct vb2_queue - a videobuf2 queue. 470 470 * 471 471 * @type: private buffer type whose content is defined by the vb2-core 472 472 * caller. For example, for V4L2, it should match ··· 544 544 * @mmap_lock: private mutex used when buffers are allocated/freed/mmapped 545 545 * @memory: current memory type used 546 546 * @dma_dir: DMA mapping direction. 547 - * @bufs: videobuf buffer structures 547 + * @bufs: videobuf2 buffer structures 548 548 * @num_buffers: number of allocated/used buffers 549 549 * @queued_list: list of buffers currently queued from userspace 550 550 * @queued_count: number of buffers queued and ready for streaming. ··· 683 683 void *vb2_plane_cookie(struct vb2_buffer *vb, unsigned int plane_no); 684 684 685 685 /** 686 - * vb2_buffer_done() - inform videobuf that an operation on a buffer 686 + * vb2_buffer_done() - inform videobuf2 that an operation on a buffer 687 687 * is finished. 688 688 * @vb: pointer to &struct vb2_buffer to be used. 689 689 * @state: state of the buffer, as defined by &enum vb2_buffer_state.
+1 -1
include/media/videobuf2-dvb.h
··· 24 24 struct dvb_frontend *frontend; 25 25 struct vb2_queue dvbq; 26 26 27 - /* video-buf-dvb state info */ 27 + /* vb2-dvb state info */ 28 28 struct mutex lock; 29 29 int nfeeds; 30 30