| 1 |
.. SPDX-License-Identifier: GFDL-1.1-no-invariants-or-later |
| 2 |
.. c:namespace:: V4L |
| 3 |
|
| 4 |
.. _VIDIOC_G_EDID: |
| 5 |
|
| 6 |
****************************************************************************** |
| 7 |
ioctl VIDIOC_G_EDID, VIDIOC_S_EDID, VIDIOC_SUBDEV_G_EDID, VIDIOC_SUBDEV_S_EDID |
| 8 |
****************************************************************************** |
| 9 |
|
| 10 |
Name |
| 11 |
==== |
| 12 |
|
| 13 |
VIDIOC_G_EDID - VIDIOC_S_EDID - VIDIOC_SUBDEV_G_EDID - VIDIOC_SUBDEV_S_EDID - Get or set the EDID of a video receiver/transmitter |
| 14 |
|
| 15 |
Synopsis |
| 16 |
======== |
| 17 |
|
| 18 |
.. c:macro:: VIDIOC_G_EDID |
| 19 |
|
| 20 |
``int ioctl(int fd, VIDIOC_G_EDID, struct v4l2_edid *argp)`` |
| 21 |
|
| 22 |
.. c:macro:: VIDIOC_S_EDID |
| 23 |
|
| 24 |
``int ioctl(int fd, VIDIOC_S_EDID, struct v4l2_edid *argp)`` |
| 25 |
|
| 26 |
.. c:macro:: VIDIOC_SUBDEV_G_EDID |
| 27 |
|
| 28 |
``int ioctl(int fd, VIDIOC_SUBDEV_G_EDID, struct v4l2_edid *argp)`` |
| 29 |
|
| 30 |
.. c:macro:: VIDIOC_SUBDEV_S_EDID |
| 31 |
|
| 32 |
``int ioctl(int fd, VIDIOC_SUBDEV_S_EDID, struct v4l2_edid *argp)`` |
| 33 |
|
| 34 |
Arguments |
| 35 |
========= |
| 36 |
|
| 37 |
``fd`` |
| 38 |
File descriptor returned by :c:func:`open()`. |
| 39 |
|
| 40 |
``argp`` |
| 41 |
Pointer to struct :c:type:`v4l2_edid`. |
| 42 |
|
| 43 |
Description |
| 44 |
=========== |
| 45 |
|
| 46 |
These ioctls can be used to get or set an EDID associated with an input |
| 47 |
from a receiver or an output of a transmitter device. They can be used |
| 48 |
with subdevice nodes (/dev/v4l-subdevX) or with video nodes |
| 49 |
(/dev/videoX). |
| 50 |
|
| 51 |
When used with video nodes the ``pad`` field represents the input (for |
| 52 |
video capture devices) or output (for video output devices) index as is |
| 53 |
returned by :ref:`VIDIOC_ENUMINPUT` and |
| 54 |
:ref:`VIDIOC_ENUMOUTPUT` respectively. When used |
| 55 |
with subdevice nodes the ``pad`` field represents the input or output |
| 56 |
pad of the subdevice. If there is no EDID support for the given ``pad`` |
| 57 |
value, then the ``EINVAL`` error code will be returned. |
| 58 |
|
| 59 |
To get the EDID data the application has to fill in the ``pad``, |
| 60 |
``start_block``, ``blocks`` and ``edid`` fields, zero the ``reserved`` |
| 61 |
array and call :ref:`VIDIOC_G_EDID <VIDIOC_G_EDID>`. The current EDID from block |
| 62 |
``start_block`` and of size ``blocks`` will be placed in the memory |
| 63 |
``edid`` points to. The ``edid`` pointer must point to memory at least |
| 64 |
``blocks`` * 128 bytes large (the size of one block is 128 bytes). |
| 65 |
|
| 66 |
If there are fewer blocks than specified, then the driver will set |
| 67 |
``blocks`` to the actual number of blocks. If there are no EDID blocks |
| 68 |
available at all, then the error code ``ENODATA`` is set. |
| 69 |
|
| 70 |
If blocks have to be retrieved from the sink, then this call will block |
| 71 |
until they have been read. |
| 72 |
|
| 73 |
If ``start_block`` and ``blocks`` are both set to 0 when |
| 74 |
:ref:`VIDIOC_G_EDID <VIDIOC_G_EDID>` is called, then the driver will set ``blocks`` to the |
| 75 |
total number of available EDID blocks and it will return 0 without |
| 76 |
copying any data. This is an easy way to discover how many EDID blocks |
| 77 |
there are. |
| 78 |
|
| 79 |
.. note:: |
| 80 |
|
| 81 |
If there are no EDID blocks available at all, then |
| 82 |
the driver will set ``blocks`` to 0 and it returns 0. |
| 83 |
|
| 84 |
To set the EDID blocks of a receiver the application has to fill in the |
| 85 |
``pad``, ``blocks`` and ``edid`` fields, set ``start_block`` to 0 and |
| 86 |
zero the ``reserved`` array. It is not possible to set part of an EDID, |
| 87 |
it is always all or nothing. Setting the EDID data is only valid for |
| 88 |
receivers as it makes no sense for a transmitter. |
| 89 |
|
| 90 |
The driver assumes that the full EDID is passed in. If there are more |
| 91 |
EDID blocks than the hardware can handle then the EDID is not written, |
| 92 |
but instead the error code ``E2BIG`` is set and ``blocks`` is set to the |
| 93 |
maximum that the hardware supports. If ``start_block`` is any value |
| 94 |
other than 0 then the error code ``EINVAL`` is set. |
| 95 |
|
| 96 |
To disable an EDID you set ``blocks`` to 0. Depending on the hardware |
| 97 |
this will drive the hotplug pin low and/or block the source from reading |
| 98 |
the EDID data in some way. In any case, the end result is the same: the |
| 99 |
EDID is no longer available. |
| 100 |
|
| 101 |
.. c:type:: v4l2_edid |
| 102 |
|
| 103 |
.. tabularcolumns:: |p{4.4cm}|p{4.4cm}|p{8.5cm}| |
| 104 |
|
| 105 |
.. flat-table:: struct v4l2_edid |
| 106 |
:header-rows: 0 |
| 107 |
:stub-columns: 0 |
| 108 |
:widths: 1 1 2 |
| 109 |
|
| 110 |
* - __u32 |
| 111 |
- ``pad`` |
| 112 |
- Pad for which to get/set the EDID blocks. When used with a video |
| 113 |
device node the pad represents the input or output index as |
| 114 |
returned by :ref:`VIDIOC_ENUMINPUT` and |
| 115 |
:ref:`VIDIOC_ENUMOUTPUT` respectively. |
| 116 |
* - __u32 |
| 117 |
- ``start_block`` |
| 118 |
- Read the EDID from starting with this block. Must be 0 when |
| 119 |
setting the EDID. |
| 120 |
* - __u32 |
| 121 |
- ``blocks`` |
| 122 |
- The number of blocks to get or set. Must be less or equal to 256 |
| 123 |
(the maximum number of blocks as defined by the standard). When |
| 124 |
you set the EDID and ``blocks`` is 0, then the EDID is disabled or |
| 125 |
erased. |
| 126 |
* - __u32 |
| 127 |
- ``reserved``\ [5] |
| 128 |
- Reserved for future extensions. Applications and drivers must set |
| 129 |
the array to zero. |
| 130 |
* - __u8 * |
| 131 |
- ``edid`` |
| 132 |
- Pointer to memory that contains the EDID. The minimum size is |
| 133 |
``blocks`` * 128. |
| 134 |
|
| 135 |
Return Value |
| 136 |
============ |
| 137 |
|
| 138 |
On success 0 is returned, on error -1 and the ``errno`` variable is set |
| 139 |
appropriately. The generic error codes are described at the |
| 140 |
:ref:`Generic Error Codes <gen-errors>` chapter. |
| 141 |
|
| 142 |
``ENODATA`` |
| 143 |
The EDID data is not available. |
| 144 |
|
| 145 |
``E2BIG`` |
| 146 |
The EDID data you provided is more than the hardware can handle. |