VIDIOC_REQBUFS ioctl

목적, 호출 형식과 인자

`VIDIOC_REQBUFS`는 MMAP, USERPTR 또는 DMABUF 기반 I/O를 시작하고 `struct v4l2_requestbuffers`로 queue의 memory 방식을 구성합니다.

.. SPDX-License-Identifier: GFDL-1.1-no-invariants-or-later
.. c:namespace:: V4L

.. _VIDIOC_REQBUFS:

********************
ioctl VIDIOC_REQBUFS
********************

Name
====

VIDIOC_REQBUFS - Initiate Memory Mapping, User Pointer I/O or DMA buffer I/O

Synopsis
========

.. c:macro:: VIDIOC_REQBUFS

``int ioctl(int fd, VIDIOC_REQBUFS, struct v4l2_requestbuffers *argp)``

Arguments
=========

``fd``
    File descriptor returned by :c:func:`open()`.

``argp``
    Pointer to struct :c:type:`v4l2_requestbuffers`.

Memory 방식과 buffer 할당

호출자는 `type`, 원하는 `count`, `memory`를 지정하고 `reserved`를 0으로 만듭니다. 드라이버는 실제 확보한 수를 `count`에 되돌립니다.

실제 count는 memory 부족으로 요청보다 작거나 0일 수 있고, 정상 동작에 더 많은 buffer가 필요하면 요청보다 클 수도 있습니다. 예를 들어 video output은 표시 중인 buffer와 애플리케이션이 채울 buffer, 최소 두 개가 필요합니다.

요청한 I/O 방식을 지원하지 않으면 `EINVAL`입니다. 애플리케이션은 다시 REQBUFS를 호출해 buffer 수를 바꿀 수 있습니다.

Buffer가 아직 mmap됐거나 DMABUF로 export된 상태에서 재호출하려면 `V4L2_BUF_CAP_SUPPORTS_ORPHANED_BUFS`가 필요합니다. 없으면 `EBUSY`, 있으면 기존 buffer를 orphan으로 남겨 unmap 또는 exported fd close 시 해제합니다.

`count = 0`은 진행 중 DMA를 중단하거나 끝낸 뒤 implicit `VIDIOC_STREAMOFF`를 수행하고 모든 buffer를 즉시 해제하거나 orphan으로 전환합니다.

Description
===========

This ioctl is used to initiate :ref:`memory mapped <mmap>`,
:ref:`user pointer <userp>` or :ref:`DMABUF <dmabuf>` based I/O.
Memory mapped buffers are located in device memory and must be allocated
with this ioctl before they can be mapped into the application's address
space. User buffers are allocated by applications themselves, and this
ioctl is merely used to switch the driver into user pointer I/O mode and
to setup some internal structures. Similarly, DMABUF buffers are
allocated by applications through a device driver, and this ioctl only
configures the driver into DMABUF I/O mode without performing any direct
allocation.

To allocate device buffers applications initialize all fields of the
struct :c:type:`v4l2_requestbuffers` structure. They set the ``type``
field to the respective stream or buffer type, the ``count`` field to
the desired number of buffers, ``memory`` must be set to the requested
I/O method and the ``reserved`` array must be zeroed. When the ioctl is
called with a pointer to this structure the driver will attempt to
allocate the requested number of buffers and it stores the actual number
allocated in the ``count`` field. It can be smaller than the number
requested, even zero, when the driver runs out of free memory. A larger
number is also possible when the driver requires more buffers to
function correctly. For example video output requires at least two
buffers, one displayed and one filled by the application.

When the I/O method is not supported the ioctl returns an ``EINVAL`` error
code.

Applications can call :ref:`VIDIOC_REQBUFS` again to change the number of
buffers. Note that if any buffers are still mapped or exported via DMABUF,
then :ref:`VIDIOC_REQBUFS` can only succeed if the
``V4L2_BUF_CAP_SUPPORTS_ORPHANED_BUFS`` capability is set. Otherwise
:ref:`VIDIOC_REQBUFS` will return the ``EBUSY`` error code.
If ``V4L2_BUF_CAP_SUPPORTS_ORPHANED_BUFS`` is set, then these buffers are
orphaned and will be freed when they are unmapped or when the exported DMABUF
fds are closed. A ``count`` value of zero frees or orphans all buffers, after
aborting or finishing any DMA in progress, an implicit
:ref:`VIDIOC_STREAMOFF <VIDIOC_STREAMON>`.

struct v4l2_requestbuffers

`capabilities == 0`이면 드라이버가 capability reporting을 지원하지 않는다는 뜻입니다. 이때 MMAP 지원만 보장되고 다른 memory type은 지원할 수도 있지만 추가 capability는 지원하지 않습니다.

부작용을 최소화해 capability를 조회하려면 시작 시 `count = 0`, `memory = V4L2_MEMORY_MMAP`, 원하는 `type`으로 호출할 수 있습니다. 다만 이전에 할당한 buffer를 해제하므로 애플리케이션 시작 단계에서 해야 합니다.

.. c:type:: v4l2_requestbuffers

.. tabularcolumns:: |p{4.4cm}|p{4.4cm}|p{8.5cm}|

.. cssclass:: longtable

.. flat-table:: struct v4l2_requestbuffers
    :header-rows:  0
    :stub-columns: 0
    :widths:       1 1 2

    * - __u32
      - ``count``
      - The number of buffers requested or granted.
    * - __u32
      - ``type``
      - Type of the stream or buffers, this is the same as the struct
	:c:type:`v4l2_format` ``type`` field. See
	:c:type:`v4l2_buf_type` for valid values.
    * - __u32
      - ``memory``
      - Applications set this field to ``V4L2_MEMORY_MMAP``,
	``V4L2_MEMORY_DMABUF`` or ``V4L2_MEMORY_USERPTR``. See
	:c:type:`v4l2_memory`.
    * - __u32
      - ``capabilities``
      - Set by the driver. If 0, then the driver doesn't support
        capabilities. In that case all you know is that the driver is
	guaranteed to support ``V4L2_MEMORY_MMAP`` and *might* support
	other :c:type:`v4l2_memory` types. It will not support any other
	capabilities.

	If you want to query the capabilities with a minimum of side-effects,
	then this can be called with ``count`` set to 0, ``memory`` set to
	``V4L2_MEMORY_MMAP`` and ``type`` set to the buffer type. This will
	free any previously allocated buffers, so this is typically something
	that will be done at the start of the application.
    * - __u8
      - ``flags``
      - Specifies additional buffer management attributes.
	See :ref:`memory-flags`.
    * - __u8
      - ``reserved``\ [3]
      - Reserved for future extensions.

V4L2 buffer capability flag

MMAP cache hint에는 `V4L2_BUF_FLAG_NO_CACHE_INVALIDATE`, `V4L2_BUF_FLAG_NO_CACHE_CLEAN`, `V4L2_MEMORY_FLAG_NON_COHERENT`가 포함됩니다.

.. _v4l2-buf-capabilities:
.. _V4L2-BUF-CAP-SUPPORTS-MMAP:
.. _V4L2-BUF-CAP-SUPPORTS-USERPTR:
.. _V4L2-BUF-CAP-SUPPORTS-DMABUF:
.. _V4L2-BUF-CAP-SUPPORTS-REQUESTS:
.. _V4L2-BUF-CAP-SUPPORTS-ORPHANED-BUFS:
.. _V4L2-BUF-CAP-SUPPORTS-M2M-HOLD-CAPTURE-BUF:
.. _V4L2-BUF-CAP-SUPPORTS-MMAP-CACHE-HINTS:
.. _V4L2-BUF-CAP-SUPPORTS-MAX-NUM-BUFFERS:
.. _V4L2-BUF-CAP-SUPPORTS-REMOVE-BUFS:

.. flat-table:: V4L2 Buffer Capabilities Flags
    :header-rows:  0
    :stub-columns: 0
    :widths:       3 1 4

    * - ``V4L2_BUF_CAP_SUPPORTS_MMAP``
      - 0x00000001
      - This buffer type supports the ``V4L2_MEMORY_MMAP`` streaming mode.
    * - ``V4L2_BUF_CAP_SUPPORTS_USERPTR``
      - 0x00000002
      - This buffer type supports the ``V4L2_MEMORY_USERPTR`` streaming mode.
    * - ``V4L2_BUF_CAP_SUPPORTS_DMABUF``
      - 0x00000004
      - This buffer type supports the ``V4L2_MEMORY_DMABUF`` streaming mode.
    * - ``V4L2_BUF_CAP_SUPPORTS_REQUESTS``
      - 0x00000008
      - This buffer type supports :ref:`requests <media-request-api>`.
    * - ``V4L2_BUF_CAP_SUPPORTS_ORPHANED_BUFS``
      - 0x00000010
      - The kernel allows calling :ref:`VIDIOC_REQBUFS` while buffers are still
        mapped or exported via DMABUF. These orphaned buffers will be freed
        when they are unmapped or when the exported DMABUF fds are closed.
    * - ``V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF``
      - 0x00000020
      - Only valid for stateless decoders. If set, then userspace can set the
        ``V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF`` flag to hold off on returning the
	capture buffer until the OUTPUT timestamp changes.
    * - ``V4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTS``
      - 0x00000040
      - This capability is set by the driver to indicate that the queue supports
        cache and memory management hints. However, it's only valid when the
        queue is used for :ref:`memory mapping <mmap>` streaming I/O. See
        :ref:`V4L2_BUF_FLAG_NO_CACHE_INVALIDATE <V4L2-BUF-FLAG-NO-CACHE-INVALIDATE>`,
        :ref:`V4L2_BUF_FLAG_NO_CACHE_CLEAN <V4L2-BUF-FLAG-NO-CACHE-CLEAN>` and
        :ref:`V4L2_MEMORY_FLAG_NON_COHERENT <V4L2-MEMORY-FLAG-NON-COHERENT>`.
    * - ``V4L2_BUF_CAP_SUPPORTS_MAX_NUM_BUFFERS``
      - 0x00000080
      - If set, then the ``max_num_buffers`` field in ``struct v4l2_create_buffers``
        is valid. If not set, then the maximum is ``VIDEO_MAX_FRAME`` buffers.
    * - ``V4L2_BUF_CAP_SUPPORTS_REMOVE_BUFS``
      - 0x00000100
      - If set, then ``VIDIOC_REMOVE_BUFS`` is supported.

Memory consistency flag

`V4L2_MEMORY_FLAG_NON_COHERENT`(`0x00000001`)는 가능한 경우 buffer를 non-coherent memory에 할당하도록 요청합니다. CPU와 bus 사이 자동 일관성을 제공하는 coherent memory와 달리 driver가 필요한 시점에 cache flush/sync로 일관성을 보장해야 합니다.

장치만 buffer에 접근하고 CPU가 읽고 쓰지 않는 경우 cache sync/flush를 생략해 성능을 높일 수 있지만, 올바른 일관성 관리가 전제입니다.

이 flag는 MMAP I/O에서 queue가 `V4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTS`를 보고할 때만 효력이 있습니다.

.. _memory-flags:
.. _V4L2-MEMORY-FLAG-NON-COHERENT:

.. flat-table:: Memory Consistency Flags
    :header-rows:  0
    :stub-columns: 0
    :widths:       3 1 4

    * - ``V4L2_MEMORY_FLAG_NON_COHERENT``
      - 0x00000001
      - A buffer is allocated either in coherent (it will be automatically
	coherent between the CPU and the bus) or non-coherent memory. The
	latter can provide performance gains, for instance the CPU cache
	sync/flush operations can be avoided if the buffer is accessed by the
	corresponding device only and the CPU does not read/write to/from that
	buffer. However, this requires extra care from the driver -- it must
	guarantee memory consistency by issuing a cache flush/sync when
	consistency is needed. If this flag is set V4L2 will attempt to
	allocate the buffer in non-coherent memory. The flag takes effect
	only if the buffer is used for :ref:`memory mapping <mmap>` I/O and the
	queue reports the :ref:`V4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTS
	<V4L2-BUF-CAP-SUPPORTS-MMAP-CACHE-HINTS>` capability.

.. raw:: latex

   \normalsize

반환값과 오류

성공하면 0, 오류이면 -1을 반환하고 `errno`를 설정합니다.

Return Value
============

On success 0 is returned, on error -1 and the ``errno`` variable is set
appropriately. The generic error codes are described at the
:ref:`Generic Error Codes <gen-errors>` chapter.

EINVAL
    The buffer type (``type`` field) or the requested I/O method
    (``memory``) is not supported.