Documentation/linux_tv/media/v4l/vidioc-g-edid.rst

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