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