drm_mode.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
/*
 * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
 * Copyright (c) 2007 Jakob Bornecrantz <wallbraker@gmail.com>
 * Copyright (c) 2008 Red Hat Inc.
 * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, TX., USA
 * Copyright (c) 2007-2008 Intel Corporation
 */
 
#ifndef _DRM_MODE_H
#define _DRM_MODE_H
 
#include <linux/bits.h>
#include <linux/const.h>
 
#include "drm.h"
 
#if defined(__cplusplus)
extern "C" {
#endif
 
#define DRM_CONNECTOR_NAME_LEN  32
#define DRM_DISPLAY_MODE_LEN    32
#define DRM_PROP_NAME_LEN   32
 
#define DRM_MODE_TYPE_BUILTIN   (1<<0) /* deprecated */
#define DRM_MODE_TYPE_CLOCK_C   ((1<<1) | DRM_MODE_TYPE_BUILTIN) /* deprecated */
#define DRM_MODE_TYPE_CRTC_C    ((1<<2) | DRM_MODE_TYPE_BUILTIN) /* deprecated */
#define DRM_MODE_TYPE_PREFERRED (1<<3)
#define DRM_MODE_TYPE_DEFAULT   (1<<4) /* deprecated */
#define DRM_MODE_TYPE_USERDEF   (1<<5)
#define DRM_MODE_TYPE_DRIVER    (1<<6)
 
#define DRM_MODE_TYPE_ALL   (DRM_MODE_TYPE_PREFERRED |  \
                 DRM_MODE_TYPE_USERDEF |    \
                 DRM_MODE_TYPE_DRIVER)
 
/* Video mode flags */
/* bit compatible with the xrandr RR_ definitions (bits 0-13)
 *
 * ABI warning: Existing userspace really expects
 * the mode flags to match the xrandr definitions. Any
 * changes that don't match the xrandr definitions will
 * likely need a new client cap or some other mechanism
 * to avoid breaking existing userspace. This includes
 * allocating new flags in the previously unused bits!
 */
#define DRM_MODE_FLAG_PHSYNC            (1<<0)
#define DRM_MODE_FLAG_NHSYNC            (1<<1)
#define DRM_MODE_FLAG_PVSYNC            (1<<2)
#define DRM_MODE_FLAG_NVSYNC            (1<<3)
#define DRM_MODE_FLAG_INTERLACE         (1<<4)
#define DRM_MODE_FLAG_DBLSCAN           (1<<5)
#define DRM_MODE_FLAG_CSYNC         (1<<6)
#define DRM_MODE_FLAG_PCSYNC            (1<<7)
#define DRM_MODE_FLAG_NCSYNC            (1<<8)
#define DRM_MODE_FLAG_HSKEW         (1<<9) /* hskew provided */
#define DRM_MODE_FLAG_BCAST         (1<<10) /* deprecated */
#define DRM_MODE_FLAG_PIXMUX            (1<<11) /* deprecated */
#define DRM_MODE_FLAG_DBLCLK            (1<<12)
#define DRM_MODE_FLAG_CLKDIV2           (1<<13)
 /*
  * When adding a new stereo mode don't forget to adjust DRM_MODE_FLAGS_3D_MAX
  * (define not exposed to user space).
  */
#define DRM_MODE_FLAG_3D_MASK           (0x1f<<14)
#define  DRM_MODE_FLAG_3D_NONE      (0<<14)
#define  DRM_MODE_FLAG_3D_FRAME_PACKING     (1<<14)
#define  DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE (2<<14)
#define  DRM_MODE_FLAG_3D_LINE_ALTERNATIVE  (3<<14)
#define  DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL (4<<14)
#define  DRM_MODE_FLAG_3D_L_DEPTH       (5<<14)
#define  DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH (6<<14)
#define  DRM_MODE_FLAG_3D_TOP_AND_BOTTOM    (7<<14)
#define  DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF (8<<14)
 
/* Picture aspect ratio options */
#define DRM_MODE_PICTURE_ASPECT_NONE        0
#define DRM_MODE_PICTURE_ASPECT_4_3     1
#define DRM_MODE_PICTURE_ASPECT_16_9        2
#define DRM_MODE_PICTURE_ASPECT_64_27       3
#define DRM_MODE_PICTURE_ASPECT_256_135     4
 
/* Content type options */
#define DRM_MODE_CONTENT_TYPE_NO_DATA       0
#define DRM_MODE_CONTENT_TYPE_GRAPHICS      1
#define DRM_MODE_CONTENT_TYPE_PHOTO     2
#define DRM_MODE_CONTENT_TYPE_CINEMA        3
#define DRM_MODE_CONTENT_TYPE_GAME      4
 
/* Aspect ratio flag bitmask (4 bits 22:19) */
#define DRM_MODE_FLAG_PIC_AR_MASK       (0x0F<<19)
#define  DRM_MODE_FLAG_PIC_AR_NONE \
            (DRM_MODE_PICTURE_ASPECT_NONE<<19)
#define  DRM_MODE_FLAG_PIC_AR_4_3 \
            (DRM_MODE_PICTURE_ASPECT_4_3<<19)
#define  DRM_MODE_FLAG_PIC_AR_16_9 \
            (DRM_MODE_PICTURE_ASPECT_16_9<<19)
#define  DRM_MODE_FLAG_PIC_AR_64_27 \
            (DRM_MODE_PICTURE_ASPECT_64_27<<19)
#define  DRM_MODE_FLAG_PIC_AR_256_135 \
            (DRM_MODE_PICTURE_ASPECT_256_135<<19)
 
#define  DRM_MODE_FLAG_ALL  (DRM_MODE_FLAG_PHSYNC |     \
                 DRM_MODE_FLAG_NHSYNC |     \
                 DRM_MODE_FLAG_PVSYNC |     \
                 DRM_MODE_FLAG_NVSYNC |     \
                 DRM_MODE_FLAG_INTERLACE |  \
                 DRM_MODE_FLAG_DBLSCAN |    \
                 DRM_MODE_FLAG_CSYNC |      \
                 DRM_MODE_FLAG_PCSYNC |     \
                 DRM_MODE_FLAG_NCSYNC |     \
                 DRM_MODE_FLAG_HSKEW |      \
                 DRM_MODE_FLAG_DBLCLK |     \
                 DRM_MODE_FLAG_CLKDIV2 |    \
                 DRM_MODE_FLAG_3D_MASK)
 
/* DPMS flags */
/* bit compatible with the xorg definitions. */
#define DRM_MODE_DPMS_ON    0
#define DRM_MODE_DPMS_STANDBY   1
#define DRM_MODE_DPMS_SUSPEND   2
#define DRM_MODE_DPMS_OFF   3
 
/* Scaling mode options */
#define DRM_MODE_SCALE_NONE     0 /* Unmodified timing (display or
                         software can still scale) */
#define DRM_MODE_SCALE_FULLSCREEN   1 /* Full screen, ignore aspect */
#define DRM_MODE_SCALE_CENTER       2 /* Centered, no scaling */
#define DRM_MODE_SCALE_ASPECT       3 /* Full screen, preserve aspect */
 
/* Dithering mode options */
#define DRM_MODE_DITHERING_OFF  0
#define DRM_MODE_DITHERING_ON   1
#define DRM_MODE_DITHERING_AUTO 2
 
/* Dirty info options */
#define DRM_MODE_DIRTY_OFF      0
#define DRM_MODE_DIRTY_ON       1
#define DRM_MODE_DIRTY_ANNOTATE 2
 
/* Link Status options */
#define DRM_MODE_LINK_STATUS_GOOD   0
#define DRM_MODE_LINK_STATUS_BAD    1
 
/* Panel type property */
#define DRM_MODE_PANEL_TYPE_UNKNOWN 0
#define DRM_MODE_PANEL_TYPE_OLED    1
 
/*
 * DRM_MODE_ROTATE_<degrees>
 *
 * Signals that a drm plane is been rotated <degrees> degrees in counter
 * clockwise direction.
 *
 * This define is provided as a convenience, looking up the property id
 * using the name->prop id lookup is the preferred method.
 */
#define DRM_MODE_ROTATE_0       (1<<0)
#define DRM_MODE_ROTATE_90      (1<<1)
#define DRM_MODE_ROTATE_180     (1<<2)
#define DRM_MODE_ROTATE_270     (1<<3)
 
/*
 * DRM_MODE_ROTATE_MASK
 *
 * Bitmask used to look for drm plane rotations.
 */
#define DRM_MODE_ROTATE_MASK (\
        DRM_MODE_ROTATE_0  | \
        DRM_MODE_ROTATE_90  | \
        DRM_MODE_ROTATE_180 | \
        DRM_MODE_ROTATE_270)
 
/*
 * DRM_MODE_REFLECT_<axis>
 *
 * Signals that the contents of a drm plane is reflected along the <axis> axis,
 * in the same way as mirroring.
 * See kerneldoc chapter "Plane Composition Properties" for more details.
 *
 * This define is provided as a convenience, looking up the property id
 * using the name->prop id lookup is the preferred method.
 */
#define DRM_MODE_REFLECT_X      (1<<4)
#define DRM_MODE_REFLECT_Y      (1<<5)
 
/*
 * DRM_MODE_REFLECT_MASK
 *
 * Bitmask used to look for drm plane reflections.
 */
#define DRM_MODE_REFLECT_MASK (\
        DRM_MODE_REFLECT_X | \
        DRM_MODE_REFLECT_Y)
 
/* Content Protection Flags */
#define DRM_MODE_CONTENT_PROTECTION_UNDESIRED   0
#define DRM_MODE_CONTENT_PROTECTION_DESIRED     1
#define DRM_MODE_CONTENT_PROTECTION_ENABLED     2
 
struct drm_mode_modeinfo {
    __u32 clock;
    __u16 hdisplay;
    __u16 hsync_start;
    __u16 hsync_end;
    __u16 htotal;
    __u16 hskew;
    __u16 vdisplay;
    __u16 vsync_start;
    __u16 vsync_end;
    __u16 vtotal;
    __u16 vscan;
 
    __u32 vrefresh;
 
    __u32 flags;
    __u32 type;
    char name[DRM_DISPLAY_MODE_LEN];
};
 
struct drm_mode_card_res {
    __u64 fb_id_ptr;
    __u64 crtc_id_ptr;
    __u64 connector_id_ptr;
    __u64 encoder_id_ptr;
    __u32 count_fbs;
    __u32 count_crtcs;
    __u32 count_connectors;
    __u32 count_encoders;
    __u32 min_width;
    __u32 max_width;
    __u32 min_height;
    __u32 max_height;
};
 
struct drm_mode_crtc {
    __u64 set_connectors_ptr;
    __u32 count_connectors;
 
    __u32 crtc_id; 
    __u32 fb_id; 
    __u32 x; 
    __u32 y; 
    __u32 gamma_size;
    __u32 mode_valid;
    struct drm_mode_modeinfo mode;
};
 
#define DRM_MODE_PRESENT_TOP_FIELD  (1<<0)
#define DRM_MODE_PRESENT_BOTTOM_FIELD   (1<<1)
 
/* Planes blend with or override other bits on the CRTC */
struct drm_mode_set_plane {
    __u32 plane_id;
    __u32 crtc_id;
    __u32 fb_id; /* fb object contains surface format type */
    __u32 flags; /* see above flags */
 
    /* Signed dest location allows it to be partially off screen */
    __s32 crtc_x;
    __s32 crtc_y;
    __u32 crtc_w;
    __u32 crtc_h;
 
    /* Source values are 16.16 fixed point */
    __u32 src_x;
    __u32 src_y;
    __u32 src_h;
    __u32 src_w;
};
 
struct drm_mode_get_plane {
    __u32 plane_id;
 
    __u32 crtc_id;
    __u32 fb_id;
 
    __u32 possible_crtcs;
    __u32 gamma_size;
 
    __u32 count_format_types;
    __u64 format_type_ptr;
};
 
struct drm_mode_get_plane_res {
    __u64 plane_id_ptr;
    __u32 count_planes;
};
 
#define DRM_MODE_ENCODER_NONE   0
#define DRM_MODE_ENCODER_DAC    1
#define DRM_MODE_ENCODER_TMDS   2
#define DRM_MODE_ENCODER_LVDS   3
#define DRM_MODE_ENCODER_TVDAC  4
#define DRM_MODE_ENCODER_VIRTUAL 5
#define DRM_MODE_ENCODER_DSI    6
#define DRM_MODE_ENCODER_DPMST  7
#define DRM_MODE_ENCODER_DPI    8
 
struct drm_mode_get_encoder {
    __u32 encoder_id;
    __u32 encoder_type;
 
    __u32 crtc_id; 
    __u32 possible_crtcs;
    __u32 possible_clones;
};
 
/* This is for connectors with multiple signal types. */
/* Try to match DRM_MODE_CONNECTOR_X as closely as possible. */
enum drm_mode_subconnector {
    DRM_MODE_SUBCONNECTOR_Automatic   = 0,  /* DVI-I, TV     */
    DRM_MODE_SUBCONNECTOR_Unknown     = 0,  /* DVI-I, TV, DP */
    DRM_MODE_SUBCONNECTOR_VGA     = 1,  /*            DP */
    DRM_MODE_SUBCONNECTOR_DVID    = 3,  /* DVI-I      DP */
    DRM_MODE_SUBCONNECTOR_DVIA    = 4,  /* DVI-I         */
    DRM_MODE_SUBCONNECTOR_Composite   = 5,  /*        TV     */
    DRM_MODE_SUBCONNECTOR_SVIDEO      = 6,  /*        TV     */
    DRM_MODE_SUBCONNECTOR_Component   = 8,  /*        TV     */
    DRM_MODE_SUBCONNECTOR_SCART   = 9,  /*        TV     */
    DRM_MODE_SUBCONNECTOR_DisplayPort = 10, /*            DP */
    DRM_MODE_SUBCONNECTOR_HDMIA       = 11, /*            DP */
    DRM_MODE_SUBCONNECTOR_Native      = 15, /*            DP */
    DRM_MODE_SUBCONNECTOR_Wireless    = 18, /*            DP */
};
 
#define DRM_MODE_CONNECTOR_Unknown  0
#define DRM_MODE_CONNECTOR_VGA      1
#define DRM_MODE_CONNECTOR_DVII     2
#define DRM_MODE_CONNECTOR_DVID     3
#define DRM_MODE_CONNECTOR_DVIA     4
#define DRM_MODE_CONNECTOR_Composite    5
#define DRM_MODE_CONNECTOR_SVIDEO   6
#define DRM_MODE_CONNECTOR_LVDS     7
#define DRM_MODE_CONNECTOR_Component    8
#define DRM_MODE_CONNECTOR_9PinDIN  9
#define DRM_MODE_CONNECTOR_DisplayPort  10
#define DRM_MODE_CONNECTOR_HDMIA    11
#define DRM_MODE_CONNECTOR_HDMIB    12
#define DRM_MODE_CONNECTOR_TV       13
#define DRM_MODE_CONNECTOR_eDP      14
#define DRM_MODE_CONNECTOR_VIRTUAL      15
#define DRM_MODE_CONNECTOR_DSI      16
#define DRM_MODE_CONNECTOR_DPI      17
#define DRM_MODE_CONNECTOR_WRITEBACK    18
#define DRM_MODE_CONNECTOR_SPI      19
#define DRM_MODE_CONNECTOR_USB      20
 
struct drm_mode_get_connector {
    __u64 encoders_ptr;
    __u64 modes_ptr;
    __u64 props_ptr;
    __u64 prop_values_ptr;
 
    __u32 count_modes;
    __u32 count_props;
    __u32 count_encoders;
 
    __u32 encoder_id;
    __u32 connector_id;
    __u32 connector_type;
    __u32 connector_type_id;
 
    __u32 connection;
    __u32 mm_width;
    __u32 mm_height;
    __u32 subpixel;
 
    __u32 pad;
};
 
#define DRM_MODE_PROP_PENDING   (1<<0) /* deprecated, do not use */
#define DRM_MODE_PROP_RANGE (1<<1)
#define DRM_MODE_PROP_IMMUTABLE (1<<2)
#define DRM_MODE_PROP_ENUM  (1<<3) /* enumerated type with text strings */
#define DRM_MODE_PROP_BLOB  (1<<4)
#define DRM_MODE_PROP_BITMASK   (1<<5) /* bitmask of enumerated types */
 
/* non-extended types: legacy bitmask, one bit per type: */
#define DRM_MODE_PROP_LEGACY_TYPE  ( \
        DRM_MODE_PROP_RANGE | \
        DRM_MODE_PROP_ENUM | \
        DRM_MODE_PROP_BLOB | \
        DRM_MODE_PROP_BITMASK)
 
/* extended-types: rather than continue to consume a bit per type,
 * grab a chunk of the bits to use as integer type id.
 */
#define DRM_MODE_PROP_EXTENDED_TYPE 0x0000ffc0
#define DRM_MODE_PROP_TYPE(n)       ((n) << 6)
#define DRM_MODE_PROP_OBJECT        DRM_MODE_PROP_TYPE(1)
#define DRM_MODE_PROP_SIGNED_RANGE  DRM_MODE_PROP_TYPE(2)
 
/* the PROP_ATOMIC flag is used to hide properties from userspace that
 * is not aware of atomic properties.  This is mostly to work around
 * older userspace (DDX drivers) that read/write each prop they find,
 * without being aware that this could be triggering a lengthy modeset.
 */
#define DRM_MODE_PROP_ATOMIC        0x80000000
 
struct drm_mode_property_enum {
    __u64 value;
    char name[DRM_PROP_NAME_LEN];
};
 
struct drm_mode_get_property {
    __u64 values_ptr;
    __u64 enum_blob_ptr;
 
    __u32 prop_id;
    __u32 flags;
    char name[DRM_PROP_NAME_LEN];
 
    __u32 count_values;
    __u32 count_enum_blobs;
};
 
struct drm_mode_connector_set_property {
    __u64 value;
    __u32 prop_id;
    __u32 connector_id;
};
 
#define DRM_MODE_OBJECT_CRTC 0xcccccccc
#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
#define DRM_MODE_OBJECT_MODE 0xdededede
#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
#define DRM_MODE_OBJECT_PLANE 0xeeeeeeee
#define DRM_MODE_OBJECT_COLOROP 0xfafafafa
#define DRM_MODE_OBJECT_ANY 0
 
struct drm_mode_obj_get_properties {
    __u64 props_ptr;
    __u64 prop_values_ptr;
    __u32 count_props;
    __u32 obj_id;
    __u32 obj_type;
};
 
struct drm_mode_obj_set_property {
    __u64 value;
    __u32 prop_id;
    __u32 obj_id;
    __u32 obj_type;
};
 
struct drm_mode_get_blob {
    __u32 blob_id;
    __u32 length;
    __u64 data;
};
 
struct drm_mode_fb_cmd {
    __u32 fb_id;
    __u32 width;
    __u32 height;
    __u32 pitch;
    __u32 bpp;
    __u32 depth;
    /* driver specific handle */
    __u32 handle;
};
 
#define DRM_MODE_FB_INTERLACED  (1<<0) /* for interlaced framebuffers */
#define DRM_MODE_FB_MODIFIERS   (1<<1) /* enables ->modifier[] */
 
struct drm_mode_fb_cmd2 {
    __u32 fb_id;
    __u32 width;
    __u32 height;
    __u32 pixel_format;
    __u32 flags;
 
    __u32 handles[4];
    __u32 pitches[4];
    __u32 offsets[4];
    __u64 modifier[4];
};
 
#define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01
#define DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02
#define DRM_MODE_FB_DIRTY_FLAGS         0x03
 
#define DRM_MODE_FB_DIRTY_MAX_CLIPS     256
 
/*
 * Mark a region of a framebuffer as dirty.
 *
 * Some hardware does not automatically update display contents
 * as a hardware or software draw to a framebuffer. This ioctl
 * allows userspace to tell the kernel and the hardware what
 * regions of the framebuffer have changed.
 *
 * The kernel or hardware is free to update more then just the
 * region specified by the clip rects. The kernel or hardware
 * may also delay and/or coalesce several calls to dirty into a
 * single update.
 *
 * Userspace may annotate the updates, the annotates are a
 * promise made by the caller that the change is either a copy
 * of pixels or a fill of a single color in the region specified.
 *
 * If the DRM_MODE_FB_DIRTY_ANNOTATE_COPY flag is given then
 * the number of updated regions are half of num_clips given,
 * where the clip rects are paired in src and dst. The width and
 * height of each one of the pairs must match.
 *
 * If the DRM_MODE_FB_DIRTY_ANNOTATE_FILL flag is given the caller
 * promises that the region specified of the clip rects is filled
 * completely with a single color as given in the color argument.
 */
 
struct drm_mode_fb_dirty_cmd {
    __u32 fb_id;
    __u32 flags;
    __u32 color;
    __u32 num_clips;
    __u64 clips_ptr;
};
 
struct drm_mode_mode_cmd {
    __u32 connector_id;
    struct drm_mode_modeinfo mode;
};
 
#define DRM_MODE_CURSOR_BO  0x01
#define DRM_MODE_CURSOR_MOVE    0x02
#define DRM_MODE_CURSOR_FLAGS   0x03
 
/*
 * depending on the value in flags different members are used.
 *
 * CURSOR_BO uses
 *    crtc_id
 *    width
 *    height
 *    handle - if 0 turns the cursor off
 *
 * CURSOR_MOVE uses
 *    crtc_id
 *    x
 *    y
 */
struct drm_mode_cursor {
    __u32 flags;
    __u32 crtc_id;
    __s32 x;
    __s32 y;
    __u32 width;
    __u32 height;
    /* driver specific handle */
    __u32 handle;
};
 
struct drm_mode_cursor2 {
    __u32 flags;
    __u32 crtc_id;
    __s32 x;
    __s32 y;
    __u32 width;
    __u32 height;
    /* driver specific handle */
    __u32 handle;
    __s32 hot_x;
    __s32 hot_y;
};
 
struct drm_mode_crtc_lut {
    __u32 crtc_id;
    __u32 gamma_size;
 
    /* pointers to arrays */
    __u64 red;
    __u64 green;
    __u64 blue;
};
 
struct drm_color_ctm {
    /*
     * Conversion matrix in S31.32 sign-magnitude
     * (not two's complement!) format.
     *
     * out   matrix    in
     * |R|   |0 1 2|   |R|
     * |G| = |3 4 5| x |G|
     * |B|   |6 7 8|   |B|
     */
    __u64 matrix[9];
};
 
struct drm_color_ctm_3x4 {
    /*
     * Conversion matrix with 3x4 dimensions in S31.32 sign-magnitude
     * (not two's complement!) format.
     *
     * out   matrix          in
     * |R|   |0  1  2  3 |   | R |
     * |G| = |4  5  6  7 | x | G |
     * |B|   |8  9  10 11|   | B |
     *                       |1.0|
     */
    __u64 matrix[12];
};
 
struct drm_color_lut {
    /*
     * Values are mapped linearly to 0.0 - 1.0 range, with 0x0 == 0.0 and
     * 0xffff == 1.0.
     */
    __u16 red;
    __u16 green;
    __u16 blue;
    __u16 reserved;
};
 
/*
 * struct drm_color_lut32
 *
 * 32-bit per channel color LUT entry, similar to drm_color_lut.
 */
struct drm_color_lut32 {
    __u32 red;
    __u32 green;
    __u32 blue;
    __u32 reserved;
};
 
enum drm_colorop_type {
    DRM_COLOROP_1D_CURVE,
 
    DRM_COLOROP_1D_LUT,
 
    DRM_COLOROP_CTM_3X4,
 
    DRM_COLOROP_MULTIPLIER,
 
    DRM_COLOROP_3D_LUT,
};
 
enum drm_colorop_lut3d_interpolation_type {
    DRM_COLOROP_LUT3D_INTERPOLATION_TETRAHEDRAL,
};
 
enum drm_colorop_lut1d_interpolation_type {
    DRM_COLOROP_LUT1D_INTERPOLATION_LINEAR,
};
 
struct drm_plane_size_hint {
    __u16 width;
    __u16 height;
};
 
struct hdr_metadata_infoframe {
    __u8 eotf;
    __u8 metadata_type;
    struct {
        __u16 x, y;
    } display_primaries[3];
    struct {
        __u16 x, y;
    } white_point;
    __u16 max_display_mastering_luminance;
    __u16 min_display_mastering_luminance;
    __u16 max_cll;
    __u16 max_fall;
};
 
struct hdr_output_metadata {
    __u32 metadata_type;
    union {
        struct hdr_metadata_infoframe hdmi_metadata_type1;
    };
};
 
#define DRM_MODE_PAGE_FLIP_EVENT 0x01
#define DRM_MODE_PAGE_FLIP_ASYNC 0x02
#define DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE 0x4
#define DRM_MODE_PAGE_FLIP_TARGET_RELATIVE 0x8
#define DRM_MODE_PAGE_FLIP_TARGET (DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE | \
                   DRM_MODE_PAGE_FLIP_TARGET_RELATIVE)
#define DRM_MODE_PAGE_FLIP_FLAGS (DRM_MODE_PAGE_FLIP_EVENT | \
                  DRM_MODE_PAGE_FLIP_ASYNC | \
                  DRM_MODE_PAGE_FLIP_TARGET)
 
/*
 * Request a page flip on the specified crtc.
 *
 * This ioctl will ask KMS to schedule a page flip for the specified
 * crtc.  Once any pending rendering targeting the specified fb (as of
 * ioctl time) has completed, the crtc will be reprogrammed to display
 * that fb after the next vertical refresh.  The ioctl returns
 * immediately, but subsequent rendering to the current fb will block
 * in the execbuffer ioctl until the page flip happens.  If a page
 * flip is already pending as the ioctl is called, EBUSY will be
 * returned.
 *
 * Flag DRM_MODE_PAGE_FLIP_EVENT requests that drm sends back a vblank
 * event (see drm.h: struct drm_event_vblank) when the page flip is
 * done.  The user_data field passed in with this ioctl will be
 * returned as the user_data field in the vblank event struct.
 *
 * Flag DRM_MODE_PAGE_FLIP_ASYNC requests that the flip happen
 * 'as soon as possible', meaning that it not delay waiting for vblank.
 * This may cause tearing on the screen.
 *
 * The reserved field must be zero.
 */
 
struct drm_mode_crtc_page_flip {
    __u32 crtc_id;
    __u32 fb_id;
    __u32 flags;
    __u32 reserved;
    __u64 user_data;
};
 
/*
 * Request a page flip on the specified crtc.
 *
 * Same as struct drm_mode_crtc_page_flip, but supports new flags and
 * re-purposes the reserved field:
 *
 * The sequence field must be zero unless either of the
 * DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags is specified. When
 * the ABSOLUTE flag is specified, the sequence field denotes the absolute
 * vblank sequence when the flip should take effect. When the RELATIVE
 * flag is specified, the sequence field denotes the relative (to the
 * current one when the ioctl is called) vblank sequence when the flip
 * should take effect. NOTE: DRM_IOCTL_WAIT_VBLANK must still be used to
 * make sure the vblank sequence before the target one has passed before
 * calling this ioctl. The purpose of the
 * DRM_MODE_PAGE_FLIP_TARGET_ABSOLUTE/RELATIVE flags is merely to clarify
 * the target for when code dealing with a page flip runs during a
 * vertical blank period.
 */
 
struct drm_mode_crtc_page_flip_target {
    __u32 crtc_id;
    __u32 fb_id;
    __u32 flags;
    __u32 sequence;
    __u64 user_data;
};
 
struct drm_mode_create_dumb {
    __u32 height;
    __u32 width;
    __u32 bpp;
    __u32 flags;
 
    __u32 handle;
    __u32 pitch;
    __u64 size;
};
 
/* set up for mmap of a dumb scanout buffer */
struct drm_mode_map_dumb {
    __u32 handle;
    __u32 pad;
    __u64 offset;
};
 
struct drm_mode_destroy_dumb {
    __u32 handle;
};
 
#define DRM_MODE_ATOMIC_TEST_ONLY 0x0100
#define DRM_MODE_ATOMIC_NONBLOCK  0x0200
#define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400
 
#define DRM_MODE_ATOMIC_FLAGS (\
        DRM_MODE_PAGE_FLIP_EVENT |\
        DRM_MODE_PAGE_FLIP_ASYNC |\
        DRM_MODE_ATOMIC_TEST_ONLY |\
        DRM_MODE_ATOMIC_NONBLOCK |\
        DRM_MODE_ATOMIC_ALLOW_MODESET)
 
struct drm_mode_atomic {
    __u32 flags;
    __u32 count_objs;
    __u64 objs_ptr;
    __u64 count_props_ptr;
    __u64 props_ptr;
    __u64 prop_values_ptr;
    __u64 reserved;
    __u64 user_data;
};
 
struct drm_format_modifier_blob {
#define FORMAT_BLOB_CURRENT 1
    /* Version of this blob format */
    __u32 version;
 
    /* Flags */
    __u32 flags;
 
    /* Number of fourcc formats supported */
    __u32 count_formats;
 
    /* Where in this blob the formats exist (in bytes) */
    __u32 formats_offset;
 
    /* Number of drm_format_modifiers */
    __u32 count_modifiers;
 
    /* Where in this blob the modifiers exist (in bytes) */
    __u32 modifiers_offset;
 
    /* __u32 formats[] */
    /* struct drm_format_modifier modifiers[] */
};
 
struct drm_format_modifier {
    /* Bitmask of formats in get_plane format list this info applies to. The
     * offset allows a sliding window of which 64 formats (bits).
     *
     * Some examples:
     * In today's world with < 65 formats, and formats 0, and 2 are
     * supported
     * 0x0000000000000005
     *        ^-offset = 0, formats = 5
     *
     * If the number formats grew to 128, and formats 98-102 are
     * supported with the modifier:
     *
     * 0x0000007c00000000 0000000000000000
     *        ^
     *        |__offset = 64, formats = 0x7c00000000
     *
     */
    __u64 formats;
    __u32 offset;
    __u32 pad;
 
    /* The modifier that applies to the >get_plane format list bitmask. */
    __u64 modifier;
};
 
struct drm_mode_create_blob {
    __u64 data;
    __u32 length;
    __u32 blob_id;
};
 
struct drm_mode_destroy_blob {
    __u32 blob_id;
};
 
struct drm_mode_create_lease {
    __u64 object_ids;
    __u32 object_count;
    __u32 flags;
 
    __u32 lessee_id;
    __u32 fd;
};
 
struct drm_mode_list_lessees {
    __u32 count_lessees;
    __u32 pad;
 
    __u64 lessees_ptr;
};
 
struct drm_mode_get_lease {
    __u32 count_objects;
    __u32 pad;
 
    __u64 objects_ptr;
};
 
struct drm_mode_revoke_lease {
    __u32 lessee_id;
};
 
struct drm_mode_rect {
    __s32 x1;
    __s32 y1;
    __s32 x2;
    __s32 y2;
};
 
struct drm_mode_closefb {
    __u32 fb_id;
    __u32 pad;
};
 
/*
 * Put 16-bit ARGB values into a standard 64-bit representation that can be
 * used for ioctl parameters, inter-driver communication, etc.
 *
 * If the component values being provided contain less than 16 bits of
 * precision, use a conversion ratio to get a better color approximation.
 * The ratio is computed as (2^16 - 1) / (2^bpc - 1), where bpc and 16 are
 * the input and output precision, respectively.
 * Also note bpc must be greater than 0.
 */
#define __DRM_ARGB64_PREP(c, shift)                 \
    (((__u64)(c) & __GENMASK(15, 0)) << (shift))
 
#define __DRM_ARGB64_PREP_BPC(c, shift, bpc)                \
({                                  \
    __u16 mask = __GENMASK((bpc) - 1, 0);               \
    __u16 conv = __KERNEL_DIV_ROUND_CLOSEST((mask & (c)) *      \
                        __GENMASK(15, 0), mask);\
    __DRM_ARGB64_PREP(conv, shift);                 \
})
 
#define DRM_ARGB64_PREP(alpha, red, green, blue)            \
(                                   \
    __DRM_ARGB64_PREP(alpha, 48) |                  \
    __DRM_ARGB64_PREP(red,   32) |                  \
    __DRM_ARGB64_PREP(green, 16) |                  \
    __DRM_ARGB64_PREP(blue,   0)                    \
)
 
#define DRM_ARGB64_PREP_BPC(alpha, red, green, blue, bpc)       \
({                                  \
    __typeof__(bpc) __bpc = bpc;                    \
    __DRM_ARGB64_PREP_BPC(alpha, 48, __bpc) |           \
    __DRM_ARGB64_PREP_BPC(red,   32, __bpc) |           \
    __DRM_ARGB64_PREP_BPC(green, 16, __bpc) |           \
    __DRM_ARGB64_PREP_BPC(blue,   0, __bpc);            \
})
 
/*
 * Extract the specified color component from a standard 64-bit ARGB value.
 *
 * If the requested precision is less than 16 bits, make use of a conversion
 * ratio calculated as (2^bpc - 1) / (2^16 - 1), where bpc and 16 are the
 * output and input precision, respectively.
 *
 * If speed is more important than accuracy, use DRM_ARGB64_GET*_BPCS()
 * instead of DRM_ARGB64_GET*_BPC() in order to replace the expensive
 * division with a simple bit right-shift operation.
 */
#define __DRM_ARGB64_GET(c, shift)                  \
    ((__u16)(((__u64)(c) >> (shift)) & __GENMASK(15, 0)))
 
#define __DRM_ARGB64_GET_BPC(c, shift, bpc)             \
({                                  \
    __u16 comp = __DRM_ARGB64_GET(c, shift);            \
    __KERNEL_DIV_ROUND_CLOSEST(comp * __GENMASK((bpc) - 1, 0),  \
                   __GENMASK(15, 0));           \
})
 
#define __DRM_ARGB64_GET_BPCS(c, shift, bpc)                \
    (__DRM_ARGB64_GET(c, shift) >> (16 - (bpc)))
 
#define DRM_ARGB64_GETA(c)      __DRM_ARGB64_GET(c, 48)
#define DRM_ARGB64_GETR(c)      __DRM_ARGB64_GET(c, 32)
#define DRM_ARGB64_GETG(c)      __DRM_ARGB64_GET(c, 16)
#define DRM_ARGB64_GETB(c)      __DRM_ARGB64_GET(c, 0)
 
#define DRM_ARGB64_GETA_BPC(c, bpc) __DRM_ARGB64_GET_BPC(c, 48, bpc)
#define DRM_ARGB64_GETR_BPC(c, bpc) __DRM_ARGB64_GET_BPC(c, 32, bpc)
#define DRM_ARGB64_GETG_BPC(c, bpc) __DRM_ARGB64_GET_BPC(c, 16, bpc)
#define DRM_ARGB64_GETB_BPC(c, bpc) __DRM_ARGB64_GET_BPC(c, 0, bpc)
 
#define DRM_ARGB64_GETA_BPCS(c, bpc)    __DRM_ARGB64_GET_BPCS(c, 48, bpc)
#define DRM_ARGB64_GETR_BPCS(c, bpc)    __DRM_ARGB64_GET_BPCS(c, 32, bpc)
#define DRM_ARGB64_GETG_BPCS(c, bpc)    __DRM_ARGB64_GET_BPCS(c, 16, bpc)
#define DRM_ARGB64_GETB_BPCS(c, bpc)    __DRM_ARGB64_GET_BPCS(c, 0, bpc)
 
#if defined(__cplusplus)
}
#endif
 
#endif