1.. SPDX-License-Identifier: GFDL-1.1-no-invariants-or-later 2.. c:namespace:: V4L 3 4.. _VIDIOC_G_EDID: 5 6****************************************************************************** 7ioctl VIDIOC_G_EDID, VIDIOC_S_EDID, VIDIOC_SUBDEV_G_EDID, VIDIOC_SUBDEV_S_EDID 8****************************************************************************** 9 10Name 11==== 12 13VIDIOC_G_EDID - VIDIOC_S_EDID - VIDIOC_SUBDEV_G_EDID - VIDIOC_SUBDEV_S_EDID - Get or set the EDID of a video receiver/transmitter 14 15Synopsis 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 34Arguments 35========= 36 37``fd`` 38 File descriptor returned by :c:func:`open()`. 39 40``argp`` 41 Pointer to struct :c:type:`v4l2_edid`. 42 43Description 44=========== 45 46These ioctls can be used to get or set an EDID associated with an input 47from a receiver or an output of a transmitter device. They can be used 48with subdevice nodes (/dev/v4l-subdevX) or with video nodes 49(/dev/videoX). 50 51When used with video nodes the ``pad`` field represents the input (for 52video capture devices) or output (for video output devices) index as is 53returned by :ref:`VIDIOC_ENUMINPUT` and 54:ref:`VIDIOC_ENUMOUTPUT` respectively. When used 55with subdevice nodes the ``pad`` field represents the input or output 56pad of the subdevice. If there is no EDID support for the given ``pad`` 57value, then the ``EINVAL`` error code will be returned. 58 59To get the EDID data the application has to fill in the ``pad``, 60``start_block``, ``blocks`` and ``edid`` fields, zero the ``reserved`` 61array 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 66If 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 68available at all, then the error code ``ENODATA`` is set. 69 70If blocks have to be retrieved from the sink, then this call will block 71until they have been read. 72 73If ``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 75total number of available EDID blocks and it will return 0 without 76copying any data. This is an easy way to discover how many EDID blocks 77there 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 84To 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 86zero the ``reserved`` array. It is not possible to set part of an EDID, 87it is always all or nothing. Setting the EDID data is only valid for 88receivers as it makes no sense for a transmitter. 89 90The driver assumes that the full EDID is passed in. If there are more 91EDID blocks than the hardware can handle then the EDID is not written, 92but instead the error code ``E2BIG`` is set and ``blocks`` is set to the 93maximum that the hardware supports. If ``start_block`` is any value 94other than 0 then the error code ``EINVAL`` is set. 95 96To disable an EDID you set ``blocks`` to 0. Depending on the hardware 97this will drive the hotplug pin low and/or block the source from reading 98the EDID data in some way. In any case, the end result is the same: the 99EDID 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 135Return Value 136============ 137 138On success 0 is returned, on error -1 and the ``errno`` variable is set 139appropriately. 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. 147