vidioc-g-edid.rst 4.82 KB
Newer Older
1 2
.. -*- coding: utf-8; mode: rst -*-

3
.. _VIDIOC_G_EDID:
4 5 6 7 8

******************************************************************************
ioctl VIDIOC_G_EDID, VIDIOC_S_EDID, VIDIOC_SUBDEV_G_EDID, VIDIOC_SUBDEV_S_EDID
******************************************************************************

9
Name
10
====
11

12
VIDIOC_G_EDID - VIDIOC_S_EDID - VIDIOC_SUBDEV_G_EDID - VIDIOC_SUBDEV_S_EDID - Get or set the EDID of a video receiver/transmitter
13

14 15

Synopsis
16 17
========

18
.. cpp:function:: int ioctl( int fd, int request, struct v4l2_edid *argp )
19

20

21
Arguments
22 23 24 25 26 27 28 29 30 31 32 33
=========

``fd``
    File descriptor returned by :ref:`open() <func-open>`.

``request``
    VIDIOC_G_EDID, VIDIOC_S_EDID, VIDIOC_SUBDEV_G_EDID,
    VIDIOC_SUBDEV_S_EDID

``argp``


34
Description
35 36 37 38 39 40 41 42 43
===========

These ioctls can be used to get or set an EDID associated with an input
from a receiver or an output of a transmitter device. They can be used
with subdevice nodes (/dev/v4l-subdevX) or with video nodes
(/dev/videoX).

When used with video nodes the ``pad`` field represents the input (for
video capture devices) or output (for video output devices) index as is
44 45
returned by :ref:`VIDIOC_ENUMINPUT` and
:ref:`VIDIOC_ENUMOUTPUT` respectively. When used
46 47
with subdevice nodes the ``pad`` field represents the input or output
pad of the subdevice. If there is no EDID support for the given ``pad``
48
value, then the ``EINVAL`` error code will be returned.
49 50 51

To get the EDID data the application has to fill in the ``pad``,
``start_block``, ``blocks`` and ``edid`` fields, zero the ``reserved``
52
array and call :ref:`VIDIOC_G_EDID <VIDIOC_G_EDID>`. The current EDID from block
53 54 55 56 57 58
``start_block`` and of size ``blocks`` will be placed in the memory
``edid`` points to. The ``edid`` pointer must point to memory at least
``blocks`` * 128 bytes large (the size of one block is 128 bytes).

If there are fewer blocks than specified, then the driver will set
``blocks`` to the actual number of blocks. If there are no EDID blocks
59
available at all, then the error code ``ENODATA`` is set.
60 61 62 63 64

If blocks have to be retrieved from the sink, then this call will block
until they have been read.

If ``start_block`` and ``blocks`` are both set to 0 when
65
:ref:`VIDIOC_G_EDID <VIDIOC_G_EDID>` is called, then the driver will set ``blocks`` to the
66 67
total number of available EDID blocks and it will return 0 without
copying any data. This is an easy way to discover how many EDID blocks
68 69 70 71
there are.

.. note:: If there are no EDID blocks available at all, then
   the driver will set ``blocks`` to 0 and it returns 0.
72 73 74 75 76 77 78 79 80

To set the EDID blocks of a receiver the application has to fill in the
``pad``, ``blocks`` and ``edid`` fields, set ``start_block`` to 0 and
zero the ``reserved`` array. It is not possible to set part of an EDID,
it is always all or nothing. Setting the EDID data is only valid for
receivers as it makes no sense for a transmitter.

The driver assumes that the full EDID is passed in. If there are more
EDID blocks than the hardware can handle then the EDID is not written,
81
but instead the error code ``E2BIG`` is set and ``blocks`` is set to the
82
maximum that the hardware supports. If ``start_block`` is any value
83
other than 0 then the error code ``EINVAL`` is set.
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105

To disable an EDID you set ``blocks`` to 0. Depending on the hardware
this will drive the hotplug pin low and/or block the source from reading
the EDID data in some way. In any case, the end result is the same: the
EDID is no longer available.


.. _v4l2-edid:

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


    -  .. row 1

       -  __u32

       -  ``pad``

       -  Pad for which to get/set the EDID blocks. When used with a video
106 107 108
	  device node the pad represents the input or output index as
	  returned by :ref:`VIDIOC_ENUMINPUT` and
	  :ref:`VIDIOC_ENUMOUTPUT` respectively.
109 110 111 112 113 114 115 116

    -  .. row 2

       -  __u32

       -  ``start_block``

       -  Read the EDID from starting with this block. Must be 0 when
117
	  setting the EDID.
118 119 120 121 122 123 124 125

    -  .. row 3

       -  __u32

       -  ``blocks``

       -  The number of blocks to get or set. Must be less or equal to 256
126 127 128
	  (the maximum number of blocks as defined by the standard). When
	  you set the EDID and ``blocks`` is 0, then the EDID is disabled or
	  erased.
129 130 131 132 133 134 135 136

    -  .. row 4

       -  __u32

       -  ``reserved``\ [5]

       -  Reserved for future extensions. Applications and drivers must set
137
	  the array to zero.
138 139 140 141 142 143 144 145

    -  .. row 5

       -  __u8 *

       -  ``edid``

       -  Pointer to memory that contains the EDID. The minimum size is
146
	  ``blocks`` * 128.
147 148


149
Return Value
150 151 152 153 154 155
============

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.

156
``ENODATA``
157 158
    The EDID data is not available.

159
``E2BIG``
160
    The EDID data you provided is more than the hardware can handle.