2014-01-23 07:52:20 -07:00
|
|
|
/*
|
|
|
|
* Copyright © 2006 Keith Packard
|
|
|
|
* Copyright © 2007-2008 Dave Airlie
|
|
|
|
* Copyright © 2007-2008 Intel Corporation
|
|
|
|
* Jesse Barnes <jesse.barnes@intel.com>
|
|
|
|
* Copyright © 2014 Intel Corporation
|
|
|
|
* Daniel Vetter <daniel.vetter@ffwll.ch>
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
#ifndef __DRM_MODES_H__
|
|
|
|
#define __DRM_MODES_H__
|
|
|
|
|
2016-08-31 10:09:05 -06:00
|
|
|
#include <linux/hdmi.h>
|
|
|
|
|
2016-08-29 02:27:51 -06:00
|
|
|
#include <drm/drm_mode_object.h>
|
2016-08-12 14:48:50 -06:00
|
|
|
#include <drm/drm_connector.h>
|
2016-08-15 08:07:02 -06:00
|
|
|
|
2016-08-31 10:09:05 -06:00
|
|
|
struct videomode;
|
|
|
|
|
2014-01-23 07:52:20 -07:00
|
|
|
/*
|
|
|
|
* Note on terminology: here, for brevity and convenience, we refer to connector
|
|
|
|
* control chips as 'CRTCs'. They can control any type of connector, VGA, LVDS,
|
|
|
|
* DVI, etc. And 'screen' refers to the whole of the visible display, which
|
|
|
|
* may span multiple monitors (and therefore multiple CRTC and connector
|
|
|
|
* structures).
|
|
|
|
*/
|
|
|
|
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
|
|
|
* enum drm_mode_status - hardware support status of a mode
|
|
|
|
* @MODE_OK: Mode OK
|
|
|
|
* @MODE_HSYNC: hsync out of range
|
|
|
|
* @MODE_VSYNC: vsync out of range
|
|
|
|
* @MODE_H_ILLEGAL: mode has illegal horizontal timings
|
2020-05-11 11:48:53 -06:00
|
|
|
* @MODE_V_ILLEGAL: mode has illegal vertical timings
|
2015-12-09 01:29:36 -07:00
|
|
|
* @MODE_BAD_WIDTH: requires an unsupported linepitch
|
|
|
|
* @MODE_NOMODE: no mode with a matching name
|
|
|
|
* @MODE_NO_INTERLACE: interlaced mode not supported
|
|
|
|
* @MODE_NO_DBLESCAN: doublescan mode not supported
|
|
|
|
* @MODE_NO_VSCAN: multiscan mode not supported
|
|
|
|
* @MODE_MEM: insufficient video memory
|
|
|
|
* @MODE_VIRTUAL_X: mode width too large for specified virtual size
|
|
|
|
* @MODE_VIRTUAL_Y: mode height too large for specified virtual size
|
|
|
|
* @MODE_MEM_VIRT: insufficient video memory given virtual size
|
|
|
|
* @MODE_NOCLOCK: no fixed clock available
|
|
|
|
* @MODE_CLOCK_HIGH: clock required is too high
|
|
|
|
* @MODE_CLOCK_LOW: clock required is too low
|
|
|
|
* @MODE_CLOCK_RANGE: clock/mode isn't in a ClockRange
|
|
|
|
* @MODE_BAD_HVALUE: horizontal timing was out of range
|
|
|
|
* @MODE_BAD_VVALUE: vertical timing was out of range
|
|
|
|
* @MODE_BAD_VSCAN: VScan value out of range
|
|
|
|
* @MODE_HSYNC_NARROW: horizontal sync too narrow
|
|
|
|
* @MODE_HSYNC_WIDE: horizontal sync too wide
|
|
|
|
* @MODE_HBLANK_NARROW: horizontal blanking too narrow
|
|
|
|
* @MODE_HBLANK_WIDE: horizontal blanking too wide
|
|
|
|
* @MODE_VSYNC_NARROW: vertical sync too narrow
|
|
|
|
* @MODE_VSYNC_WIDE: vertical sync too wide
|
|
|
|
* @MODE_VBLANK_NARROW: vertical blanking too narrow
|
|
|
|
* @MODE_VBLANK_WIDE: vertical blanking too wide
|
|
|
|
* @MODE_PANEL: exceeds panel dimensions
|
|
|
|
* @MODE_INTERLACE_WIDTH: width too large for interlaced mode
|
|
|
|
* @MODE_ONE_WIDTH: only one width is supported
|
|
|
|
* @MODE_ONE_HEIGHT: only one height is supported
|
|
|
|
* @MODE_ONE_SIZE: only one resolution is supported
|
|
|
|
* @MODE_NO_REDUCED: monitor doesn't accept reduced blanking
|
|
|
|
* @MODE_NO_STEREO: stereo modes not supported
|
2017-07-13 09:33:11 -06:00
|
|
|
* @MODE_NO_420: ycbcr 420 modes not supported
|
2015-12-10 13:39:08 -07:00
|
|
|
* @MODE_STALE: mode has become stale
|
2015-12-09 01:29:36 -07:00
|
|
|
* @MODE_BAD: unspecified reason
|
|
|
|
* @MODE_ERROR: error condition
|
|
|
|
*
|
|
|
|
* This enum is used to filter out modes not supported by the driver/hardware
|
|
|
|
* combination.
|
|
|
|
*/
|
2014-01-23 07:52:20 -07:00
|
|
|
enum drm_mode_status {
|
2015-12-09 01:29:36 -07:00
|
|
|
MODE_OK = 0,
|
|
|
|
MODE_HSYNC,
|
|
|
|
MODE_VSYNC,
|
|
|
|
MODE_H_ILLEGAL,
|
|
|
|
MODE_V_ILLEGAL,
|
|
|
|
MODE_BAD_WIDTH,
|
|
|
|
MODE_NOMODE,
|
|
|
|
MODE_NO_INTERLACE,
|
|
|
|
MODE_NO_DBLESCAN,
|
|
|
|
MODE_NO_VSCAN,
|
|
|
|
MODE_MEM,
|
|
|
|
MODE_VIRTUAL_X,
|
|
|
|
MODE_VIRTUAL_Y,
|
|
|
|
MODE_MEM_VIRT,
|
|
|
|
MODE_NOCLOCK,
|
|
|
|
MODE_CLOCK_HIGH,
|
|
|
|
MODE_CLOCK_LOW,
|
|
|
|
MODE_CLOCK_RANGE,
|
|
|
|
MODE_BAD_HVALUE,
|
|
|
|
MODE_BAD_VVALUE,
|
|
|
|
MODE_BAD_VSCAN,
|
|
|
|
MODE_HSYNC_NARROW,
|
|
|
|
MODE_HSYNC_WIDE,
|
|
|
|
MODE_HBLANK_NARROW,
|
|
|
|
MODE_HBLANK_WIDE,
|
|
|
|
MODE_VSYNC_NARROW,
|
|
|
|
MODE_VSYNC_WIDE,
|
|
|
|
MODE_VBLANK_NARROW,
|
|
|
|
MODE_VBLANK_WIDE,
|
|
|
|
MODE_PANEL,
|
|
|
|
MODE_INTERLACE_WIDTH,
|
|
|
|
MODE_ONE_WIDTH,
|
|
|
|
MODE_ONE_HEIGHT,
|
|
|
|
MODE_ONE_SIZE,
|
|
|
|
MODE_NO_REDUCED,
|
|
|
|
MODE_NO_STEREO,
|
2017-07-13 09:33:11 -06:00
|
|
|
MODE_NO_420,
|
2015-12-10 13:39:08 -07:00
|
|
|
MODE_STALE = -3,
|
2015-12-09 01:29:36 -07:00
|
|
|
MODE_BAD = -2,
|
|
|
|
MODE_ERROR = -1
|
2014-01-23 07:52:20 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
#define DRM_MODE(nm, t, c, hd, hss, hse, ht, hsk, vd, vss, vse, vt, vs, f) \
|
|
|
|
.name = nm, .status = 0, .type = (t), .clock = (c), \
|
|
|
|
.hdisplay = (hd), .hsync_start = (hss), .hsync_end = (hse), \
|
|
|
|
.htotal = (ht), .hskew = (hsk), .vdisplay = (vd), \
|
|
|
|
.vsync_start = (vss), .vsync_end = (vse), .vtotal = (vt), \
|
2019-01-11 07:47:29 -07:00
|
|
|
.vscan = (vs), .flags = (f)
|
2014-01-23 07:52:20 -07:00
|
|
|
|
2019-02-10 06:10:31 -07:00
|
|
|
/**
|
|
|
|
* DRM_SIMPLE_MODE - Simple display mode
|
|
|
|
* @hd: Horizontal resolution, width
|
|
|
|
* @vd: Vertical resolution, height
|
|
|
|
* @hd_mm: Display width in millimeters
|
|
|
|
* @vd_mm: Display height in millimeters
|
|
|
|
*
|
|
|
|
* This macro initializes a &drm_display_mode that only contains info about
|
|
|
|
* resolution and physical size.
|
|
|
|
*/
|
|
|
|
#define DRM_SIMPLE_MODE(hd, vd, hd_mm, vd_mm) \
|
|
|
|
.type = DRM_MODE_TYPE_DRIVER, .clock = 1 /* pass validation */, \
|
|
|
|
.hdisplay = (hd), .hsync_start = (hd), .hsync_end = (hd), \
|
|
|
|
.htotal = (hd), .vdisplay = (vd), .vsync_start = (vd), \
|
|
|
|
.vsync_end = (vd), .vtotal = (vd), .width_mm = (hd_mm), \
|
|
|
|
.height_mm = (vd_mm)
|
|
|
|
|
2014-01-23 07:52:20 -07:00
|
|
|
#define CRTC_INTERLACE_HALVE_V (1 << 0) /* halve V values for interlacing */
|
|
|
|
#define CRTC_STEREO_DOUBLE (1 << 1) /* adjust timings for stereo modes */
|
2014-12-01 16:40:09 -07:00
|
|
|
#define CRTC_NO_DBLSCAN (1 << 2) /* don't adjust doublescan */
|
|
|
|
#define CRTC_NO_VSCAN (1 << 3) /* don't adjust doublescan */
|
2015-02-16 08:12:31 -07:00
|
|
|
#define CRTC_STEREO_DOUBLE_ONLY (CRTC_STEREO_DOUBLE | CRTC_NO_DBLSCAN | CRTC_NO_VSCAN)
|
2014-01-23 07:52:20 -07:00
|
|
|
|
|
|
|
#define DRM_MODE_FLAG_3D_MAX DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF
|
|
|
|
|
2018-05-08 05:09:36 -06:00
|
|
|
#define DRM_MODE_MATCH_TIMINGS (1 << 0)
|
|
|
|
#define DRM_MODE_MATCH_CLOCK (1 << 1)
|
|
|
|
#define DRM_MODE_MATCH_FLAGS (1 << 2)
|
|
|
|
#define DRM_MODE_MATCH_3D_FLAGS (1 << 3)
|
|
|
|
#define DRM_MODE_MATCH_ASPECT_RATIO (1 << 4)
|
|
|
|
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
|
|
|
* struct drm_display_mode - DRM kernel-internal display mode structure
|
|
|
|
* @hdisplay: horizontal display size
|
|
|
|
* @hsync_start: horizontal sync start
|
|
|
|
* @hsync_end: horizontal sync end
|
|
|
|
* @htotal: horizontal total size
|
|
|
|
* @hskew: horizontal skew?!
|
|
|
|
* @vdisplay: vertical display size
|
|
|
|
* @vsync_start: vertical sync start
|
|
|
|
* @vsync_end: vertical sync end
|
|
|
|
* @vtotal: vertical total size
|
|
|
|
* @vscan: vertical scan?!
|
|
|
|
* @crtc_hdisplay: hardware mode horizontal display size
|
|
|
|
* @crtc_hblank_start: hardware mode horizontal blank start
|
|
|
|
* @crtc_hblank_end: hardware mode horizontal blank end
|
|
|
|
* @crtc_hsync_start: hardware mode horizontal sync start
|
|
|
|
* @crtc_hsync_end: hardware mode horizontal sync end
|
|
|
|
* @crtc_htotal: hardware mode horizontal total size
|
|
|
|
* @crtc_hskew: hardware mode horizontal skew?!
|
|
|
|
* @crtc_vdisplay: hardware mode vertical display size
|
|
|
|
* @crtc_vblank_start: hardware mode vertical blank start
|
|
|
|
* @crtc_vblank_end: hardware mode vertical blank end
|
|
|
|
* @crtc_vsync_start: hardware mode vertical sync start
|
|
|
|
* @crtc_vsync_end: hardware mode vertical sync end
|
|
|
|
* @crtc_vtotal: hardware mode vertical total size
|
|
|
|
*
|
|
|
|
* The horizontal and vertical timings are defined per the following diagram.
|
|
|
|
*
|
2016-05-31 14:55:13 -06:00
|
|
|
* ::
|
|
|
|
*
|
2015-12-09 01:29:36 -07:00
|
|
|
*
|
|
|
|
* Active Front Sync Back
|
|
|
|
* Region Porch Porch
|
|
|
|
* <-----------------------><----------------><-------------><-------------->
|
|
|
|
* //////////////////////|
|
|
|
|
* ////////////////////// |
|
|
|
|
* ////////////////////// |.................. ................
|
|
|
|
* _______________
|
|
|
|
* <----- [hv]display ----->
|
|
|
|
* <------------- [hv]sync_start ------------>
|
|
|
|
* <--------------------- [hv]sync_end --------------------->
|
|
|
|
* <-------------------------------- [hv]total ----------------------------->*
|
|
|
|
*
|
|
|
|
* This structure contains two copies of timings. First are the plain timings,
|
|
|
|
* which specify the logical mode, as it would be for a progressive 1:1 scanout
|
|
|
|
* at the refresh rate userspace can observe through vblank timestamps. Then
|
|
|
|
* there's the hardware timings, which are corrected for interlacing,
|
|
|
|
* double-clocking and similar things. They are provided as a convenience, and
|
|
|
|
* can be appropriately computed using drm_mode_set_crtcinfo().
|
2017-05-24 08:51:36 -06:00
|
|
|
*
|
|
|
|
* For printing you can use %DRM_MODE_FMT and DRM_MODE_ARG().
|
2015-12-09 01:29:36 -07:00
|
|
|
*/
|
2014-01-23 07:52:20 -07:00
|
|
|
struct drm_display_mode {
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
|
|
|
* @clock:
|
|
|
|
*
|
|
|
|
* Pixel clock in kHz.
|
|
|
|
*/
|
2014-01-23 07:52:20 -07:00
|
|
|
int clock; /* in kHz */
|
2020-04-28 11:19:32 -06:00
|
|
|
u16 hdisplay;
|
|
|
|
u16 hsync_start;
|
|
|
|
u16 hsync_end;
|
|
|
|
u16 htotal;
|
|
|
|
u16 hskew;
|
|
|
|
u16 vdisplay;
|
|
|
|
u16 vsync_start;
|
|
|
|
u16 vsync_end;
|
|
|
|
u16 vtotal;
|
|
|
|
u16 vscan;
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
|
|
|
* @flags:
|
|
|
|
*
|
|
|
|
* Sync and timing flags:
|
|
|
|
*
|
|
|
|
* - DRM_MODE_FLAG_PHSYNC: horizontal sync is active high.
|
|
|
|
* - DRM_MODE_FLAG_NHSYNC: horizontal sync is active low.
|
|
|
|
* - DRM_MODE_FLAG_PVSYNC: vertical sync is active high.
|
|
|
|
* - DRM_MODE_FLAG_NVSYNC: vertical sync is active low.
|
|
|
|
* - DRM_MODE_FLAG_INTERLACE: mode is interlaced.
|
|
|
|
* - DRM_MODE_FLAG_DBLSCAN: mode uses doublescan.
|
|
|
|
* - DRM_MODE_FLAG_CSYNC: mode uses composite sync.
|
|
|
|
* - DRM_MODE_FLAG_PCSYNC: composite sync is active high.
|
|
|
|
* - DRM_MODE_FLAG_NCSYNC: composite sync is active low.
|
|
|
|
* - DRM_MODE_FLAG_HSKEW: hskew provided (not used?).
|
2017-11-14 11:32:52 -07:00
|
|
|
* - DRM_MODE_FLAG_BCAST: <deprecated>
|
2017-11-14 11:32:51 -07:00
|
|
|
* - DRM_MODE_FLAG_PIXMUX: <deprecated>
|
2015-12-09 01:29:36 -07:00
|
|
|
* - DRM_MODE_FLAG_DBLCLK: double-clocked mode.
|
|
|
|
* - DRM_MODE_FLAG_CLKDIV2: half-clocked mode.
|
|
|
|
*
|
|
|
|
* Additionally there's flags to specify how 3D modes are packed:
|
|
|
|
*
|
|
|
|
* - DRM_MODE_FLAG_3D_NONE: normal, non-3D mode.
|
|
|
|
* - DRM_MODE_FLAG_3D_FRAME_PACKING: 2 full frames for left and right.
|
|
|
|
* - DRM_MODE_FLAG_3D_FIELD_ALTERNATIVE: interleaved like fields.
|
|
|
|
* - DRM_MODE_FLAG_3D_LINE_ALTERNATIVE: interleaved lines.
|
|
|
|
* - DRM_MODE_FLAG_3D_SIDE_BY_SIDE_FULL: side-by-side full frames.
|
|
|
|
* - DRM_MODE_FLAG_3D_L_DEPTH: ?
|
|
|
|
* - DRM_MODE_FLAG_3D_L_DEPTH_GFX_GFX_DEPTH: ?
|
|
|
|
* - DRM_MODE_FLAG_3D_TOP_AND_BOTTOM: frame split into top and bottom
|
|
|
|
* parts.
|
|
|
|
* - DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF: frame split into left and
|
|
|
|
* right parts.
|
|
|
|
*/
|
2020-04-28 11:19:31 -06:00
|
|
|
u32 flags;
|
2014-01-23 07:52:20 -07:00
|
|
|
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
|
|
|
* @crtc_clock:
|
|
|
|
*
|
|
|
|
* Actual pixel or dot clock in the hardware. This differs from the
|
|
|
|
* logical @clock when e.g. using interlacing, double-clocking, stereo
|
|
|
|
* modes or other fancy stuff that changes the timings and signals
|
|
|
|
* actually sent over the wire.
|
|
|
|
*
|
|
|
|
* This is again in kHz.
|
|
|
|
*
|
|
|
|
* Note that with digital outputs like HDMI or DP there's usually a
|
|
|
|
* massive confusion between the dot clock and the signal clock at the
|
|
|
|
* bit encoding level. Especially when a 8b/10b encoding is used and the
|
|
|
|
* difference is exactly a factor of 10.
|
|
|
|
*/
|
|
|
|
int crtc_clock;
|
2020-04-28 11:19:32 -06:00
|
|
|
u16 crtc_hdisplay;
|
|
|
|
u16 crtc_hblank_start;
|
|
|
|
u16 crtc_hblank_end;
|
|
|
|
u16 crtc_hsync_start;
|
|
|
|
u16 crtc_hsync_end;
|
|
|
|
u16 crtc_htotal;
|
|
|
|
u16 crtc_hskew;
|
|
|
|
u16 crtc_vdisplay;
|
|
|
|
u16 crtc_vblank_start;
|
|
|
|
u16 crtc_vblank_end;
|
|
|
|
u16 crtc_vsync_start;
|
|
|
|
u16 crtc_vsync_end;
|
|
|
|
u16 crtc_vtotal;
|
2014-01-23 07:52:20 -07:00
|
|
|
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
|
|
|
* @width_mm:
|
|
|
|
*
|
|
|
|
* Addressable size of the output in mm, projectors should set this to
|
|
|
|
* 0.
|
|
|
|
*/
|
2020-04-28 11:19:34 -06:00
|
|
|
u16 width_mm;
|
2015-12-09 01:29:36 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @height_mm:
|
|
|
|
*
|
|
|
|
* Addressable size of the output in mm, projectors should set this to
|
|
|
|
* 0.
|
|
|
|
*/
|
2020-04-28 11:19:34 -06:00
|
|
|
u16 height_mm;
|
2014-01-23 07:52:20 -07:00
|
|
|
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
2020-04-28 11:19:34 -06:00
|
|
|
* @type:
|
2015-12-09 01:29:36 -07:00
|
|
|
*
|
2020-04-28 11:19:34 -06:00
|
|
|
* A bitmask of flags, mostly about the source of a mode. Possible flags
|
|
|
|
* are:
|
2015-12-09 01:29:36 -07:00
|
|
|
*
|
2020-04-28 11:19:34 -06:00
|
|
|
* - DRM_MODE_TYPE_PREFERRED: Preferred mode, usually the native
|
|
|
|
* resolution of an LCD panel. There should only be one preferred
|
|
|
|
* mode per connector at any given time.
|
|
|
|
* - DRM_MODE_TYPE_DRIVER: Mode created by the driver, which is all of
|
|
|
|
* them really. Drivers must set this bit for all modes they create
|
|
|
|
* and expose to userspace.
|
|
|
|
* - DRM_MODE_TYPE_USERDEF: Mode defined or selected via the kernel
|
|
|
|
* command line.
|
2015-12-09 01:29:36 -07:00
|
|
|
*
|
2020-04-28 11:19:34 -06:00
|
|
|
* Plus a big list of flags which shouldn't be used at all, but are
|
|
|
|
* still around since these flags are also used in the userspace ABI.
|
|
|
|
* We no longer accept modes with these types though:
|
|
|
|
*
|
|
|
|
* - DRM_MODE_TYPE_BUILTIN: Meant for hard-coded modes, unused.
|
|
|
|
* Use DRM_MODE_TYPE_DRIVER instead.
|
|
|
|
* - DRM_MODE_TYPE_DEFAULT: Again a leftover, use
|
|
|
|
* DRM_MODE_TYPE_PREFERRED instead.
|
|
|
|
* - DRM_MODE_TYPE_CLOCK_C and DRM_MODE_TYPE_CRTC_C: Define leftovers
|
|
|
|
* which are stuck around for hysterical raisins only. No one has an
|
|
|
|
* idea what they were meant for. Don't use.
|
2015-12-09 01:29:36 -07:00
|
|
|
*/
|
2020-04-28 11:19:34 -06:00
|
|
|
u8 type;
|
2014-01-23 07:52:20 -07:00
|
|
|
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
2020-02-15 11:35:03 -07:00
|
|
|
* @private_flags:
|
2015-12-09 01:29:36 -07:00
|
|
|
*
|
2020-02-15 11:35:03 -07:00
|
|
|
* Driver private flags. private_flags can only be used for mode
|
2015-12-09 01:29:36 -07:00
|
|
|
* objects passed to drivers in modeset operations. It shouldn't be used
|
|
|
|
* by atomic drivers since they can store any additional data by
|
|
|
|
* subclassing state structures.
|
|
|
|
*/
|
2014-01-23 07:52:20 -07:00
|
|
|
int private_flags;
|
|
|
|
|
2015-12-09 01:29:36 -07:00
|
|
|
/**
|
2020-04-28 11:19:34 -06:00
|
|
|
* @head:
|
2015-12-09 01:29:36 -07:00
|
|
|
*
|
2020-04-28 11:19:34 -06:00
|
|
|
* struct list_head for mode lists.
|
2015-12-09 01:29:36 -07:00
|
|
|
*/
|
2020-04-28 11:19:34 -06:00
|
|
|
struct list_head head;
|
drm: Expose modes with aspect ratio, only if requested
We parse the EDID and add all the modes in the connector's modelist.
This adds CEA modes with aspect ratio information too, regardless of
whether user space requested this information or not.
This patch:
-prunes the modes with aspect-ratio information, from the
drm_mode_get_connector modelist supplied to the user, if the
user-space has not set the aspect ratio DRM client cap. However if
such a mode is unique in the list, it is kept in the list, with
aspect-ratio flags reset.
-prepares a list of exposed modes, which is used to find unique modes
if aspect-ratio is not allowed.
-adds a new list_head 'exposed_head' in drm_mode_display, to traverse
the list of exposed modes.
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Shashank Sharma <shashank.sharma@intel.com>
Cc: Jose Abreu <jose.abreu@synopsys.com>
Signed-off-by: Ankit Nautiyal <ankit.k.nautiyal@intel.com>
V3: As suggested by Ville, modified the mechanism of pruning of modes
with aspect-ratio, if the aspect-ratio is not supported. Instead
of straight away pruning such a mode, the mode is retained with
aspect ratio bits set to zero, provided it is unique.
V4: rebase
V5: Addressed review comments from Ville:
-used a pointer to store last valid mode.
-avoided, modifying of picture_aspect_ratio in kernel mode,
instead only flags bits of user mode are reset (if aspect-ratio
is not supported).
V6: As suggested by Ville, corrected the mode pruning logic and
elaborated the mode pruning logic and the assumptions taken.
V7: rebase
V8: rebase
V9: rebase
V10: rebase
V11: Fixed the issue caused in kms_3d test, and enhanced the pruning
logic to correctly identify and prune modes with aspect-ratio,
if aspect-ratio cap is not set.
V12: As suggested by Ville, added another list_head in
drm_mode_display to traverse the list of exposed modes and
avoided duplication of modes.
V13: Minor modifications, as suggested by Ville.
v14: As suggested by Daniel Vetter and Ville Syrjala, corrected the
pruning logic to avoid any dependency in the order of mode with
aspect-ratio.
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/1525777785-9740-9-git-send-email-ankit.k.nautiyal@intel.com
2018-05-08 05:09:43 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @export_head:
|
|
|
|
*
|
|
|
|
* struct list_head for modes to be exposed to the userspace.
|
|
|
|
* This is to maintain a list of exposed modes while preparing
|
|
|
|
* user-mode's list in drm_mode_getconnector ioctl. The purpose of this
|
|
|
|
* list_head only lies in the ioctl function, and is not expected to be
|
|
|
|
* used outside the function.
|
|
|
|
* Once used, the stale pointers are not reset, but left as it is, to
|
|
|
|
* avoid overhead of protecting it by mode_config.mutex.
|
|
|
|
*/
|
|
|
|
struct list_head export_head;
|
2020-04-28 11:19:34 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @name:
|
|
|
|
*
|
|
|
|
* Human-readable name of the mode, filled out with drm_mode_set_name().
|
|
|
|
*/
|
|
|
|
char name[DRM_DISPLAY_MODE_LEN];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @status:
|
|
|
|
*
|
|
|
|
* Status of the mode, used to filter out modes not supported by the
|
|
|
|
* hardware. See enum &drm_mode_status.
|
|
|
|
*/
|
|
|
|
enum drm_mode_status status;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @picture_aspect_ratio:
|
|
|
|
*
|
|
|
|
* Field for setting the HDMI picture aspect ratio of a mode.
|
|
|
|
*/
|
|
|
|
enum hdmi_picture_aspect picture_aspect_ratio;
|
|
|
|
|
2014-01-23 07:52:20 -07:00
|
|
|
};
|
|
|
|
|
2017-05-24 08:51:36 -06:00
|
|
|
/**
|
|
|
|
* DRM_MODE_FMT - printf string for &struct drm_display_mode
|
|
|
|
*/
|
2019-01-11 07:47:29 -07:00
|
|
|
#define DRM_MODE_FMT "\"%s\": %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x"
|
2017-05-24 08:51:36 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* DRM_MODE_ARG - printf arguments for &struct drm_display_mode
|
|
|
|
* @m: display mode
|
|
|
|
*/
|
|
|
|
#define DRM_MODE_ARG(m) \
|
2020-04-28 11:19:27 -06:00
|
|
|
(m)->name, drm_mode_vrefresh(m), (m)->clock, \
|
2017-05-24 08:51:36 -06:00
|
|
|
(m)->hdisplay, (m)->hsync_start, (m)->hsync_end, (m)->htotal, \
|
|
|
|
(m)->vdisplay, (m)->vsync_start, (m)->vsync_end, (m)->vtotal, \
|
|
|
|
(m)->type, (m)->flags
|
|
|
|
|
2016-08-31 10:09:04 -06:00
|
|
|
#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
|
|
|
|
|
2014-01-23 12:05:00 -07:00
|
|
|
/**
|
|
|
|
* drm_mode_is_stereo - check for stereo mode flags
|
|
|
|
* @mode: drm_display_mode to check
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* True if the mode is one of the stereo modes (like side-by-side), false if
|
|
|
|
* not.
|
|
|
|
*/
|
2014-01-23 07:52:20 -07:00
|
|
|
static inline bool drm_mode_is_stereo(const struct drm_display_mode *mode)
|
|
|
|
{
|
|
|
|
return mode->flags & DRM_MODE_FLAG_3D_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct drm_connector;
|
|
|
|
struct drm_cmdline_mode;
|
|
|
|
|
|
|
|
struct drm_display_mode *drm_mode_create(struct drm_device *dev);
|
|
|
|
void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode);
|
2015-05-22 06:34:48 -06:00
|
|
|
void drm_mode_convert_to_umode(struct drm_mode_modeinfo *out,
|
2016-07-12 07:30:02 -06:00
|
|
|
const struct drm_display_mode *in);
|
2017-11-14 11:32:57 -07:00
|
|
|
int drm_mode_convert_umode(struct drm_device *dev,
|
|
|
|
struct drm_display_mode *out,
|
2015-05-22 06:34:48 -06:00
|
|
|
const struct drm_mode_modeinfo *in);
|
2014-01-23 07:52:20 -07:00
|
|
|
void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
|
|
|
|
void drm_mode_debug_printmodeline(const struct drm_display_mode *mode);
|
2017-07-13 09:33:14 -06:00
|
|
|
bool drm_mode_is_420_only(const struct drm_display_info *display,
|
|
|
|
const struct drm_display_mode *mode);
|
|
|
|
bool drm_mode_is_420_also(const struct drm_display_info *display,
|
|
|
|
const struct drm_display_mode *mode);
|
|
|
|
bool drm_mode_is_420(const struct drm_display_info *display,
|
|
|
|
const struct drm_display_mode *mode);
|
2014-01-23 07:52:20 -07:00
|
|
|
|
|
|
|
struct drm_display_mode *drm_cvt_mode(struct drm_device *dev,
|
|
|
|
int hdisplay, int vdisplay, int vrefresh,
|
|
|
|
bool reduced, bool interlaced,
|
|
|
|
bool margins);
|
|
|
|
struct drm_display_mode *drm_gtf_mode(struct drm_device *dev,
|
|
|
|
int hdisplay, int vdisplay, int vrefresh,
|
|
|
|
bool interlaced, int margins);
|
|
|
|
struct drm_display_mode *drm_gtf_mode_complex(struct drm_device *dev,
|
|
|
|
int hdisplay, int vdisplay,
|
|
|
|
int vrefresh, bool interlaced,
|
|
|
|
int margins,
|
|
|
|
int GTF_M, int GTF_2C,
|
|
|
|
int GTF_K, int GTF_2J);
|
2014-01-23 08:28:50 -07:00
|
|
|
void drm_display_mode_from_videomode(const struct videomode *vm,
|
|
|
|
struct drm_display_mode *dmode);
|
2014-12-18 19:00:22 -07:00
|
|
|
void drm_display_mode_to_videomode(const struct drm_display_mode *dmode,
|
|
|
|
struct videomode *vm);
|
2016-07-12 07:30:02 -06:00
|
|
|
void drm_bus_flags_from_videomode(const struct videomode *vm, u32 *bus_flags);
|
2014-01-23 07:52:20 -07:00
|
|
|
int of_get_drm_display_mode(struct device_node *np,
|
2016-07-12 07:30:03 -06:00
|
|
|
struct drm_display_mode *dmode, u32 *bus_flags,
|
2014-01-23 07:52:20 -07:00
|
|
|
int index);
|
|
|
|
|
|
|
|
void drm_mode_set_name(struct drm_display_mode *mode);
|
|
|
|
int drm_mode_vrefresh(const struct drm_display_mode *mode);
|
2017-01-24 23:26:56 -07:00
|
|
|
void drm_mode_get_hv_timing(const struct drm_display_mode *mode,
|
|
|
|
int *hdisplay, int *vdisplay);
|
2014-01-23 07:52:20 -07:00
|
|
|
|
|
|
|
void drm_mode_set_crtcinfo(struct drm_display_mode *p,
|
|
|
|
int adjust_flags);
|
|
|
|
void drm_mode_copy(struct drm_display_mode *dst,
|
|
|
|
const struct drm_display_mode *src);
|
|
|
|
struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev,
|
|
|
|
const struct drm_display_mode *mode);
|
2018-05-08 05:09:36 -06:00
|
|
|
bool drm_mode_match(const struct drm_display_mode *mode1,
|
|
|
|
const struct drm_display_mode *mode2,
|
|
|
|
unsigned int match_flags);
|
2014-01-23 07:52:20 -07:00
|
|
|
bool drm_mode_equal(const struct drm_display_mode *mode1,
|
|
|
|
const struct drm_display_mode *mode2);
|
2015-11-16 12:05:12 -07:00
|
|
|
bool drm_mode_equal_no_clocks(const struct drm_display_mode *mode1,
|
|
|
|
const struct drm_display_mode *mode2);
|
2014-01-23 07:52:20 -07:00
|
|
|
bool drm_mode_equal_no_clocks_no_stereo(const struct drm_display_mode *mode1,
|
|
|
|
const struct drm_display_mode *mode2);
|
|
|
|
|
|
|
|
/* for use by the crtc helper probe functions */
|
2017-11-14 11:32:57 -07:00
|
|
|
enum drm_mode_status drm_mode_validate_driver(struct drm_device *dev,
|
|
|
|
const struct drm_display_mode *mode);
|
2014-12-17 04:56:22 -07:00
|
|
|
enum drm_mode_status drm_mode_validate_size(const struct drm_display_mode *mode,
|
|
|
|
int maxX, int maxY);
|
2017-07-13 09:33:11 -06:00
|
|
|
enum drm_mode_status
|
|
|
|
drm_mode_validate_ycbcr420(const struct drm_display_mode *mode,
|
|
|
|
struct drm_connector *connector);
|
2014-01-23 07:52:20 -07:00
|
|
|
void drm_mode_prune_invalid(struct drm_device *dev,
|
|
|
|
struct list_head *mode_list, bool verbose);
|
|
|
|
void drm_mode_sort(struct list_head *mode_list);
|
2018-07-09 02:40:08 -06:00
|
|
|
void drm_connector_list_update(struct drm_connector *connector);
|
2014-01-23 07:52:20 -07:00
|
|
|
|
|
|
|
/* parsing cmdline modes */
|
|
|
|
bool
|
|
|
|
drm_mode_parse_command_line_for_connector(const char *mode_option,
|
2019-06-28 06:16:45 -06:00
|
|
|
const struct drm_connector *connector,
|
2014-01-23 07:52:20 -07:00
|
|
|
struct drm_cmdline_mode *mode);
|
|
|
|
struct drm_display_mode *
|
|
|
|
drm_mode_create_from_cmdline_mode(struct drm_device *dev,
|
|
|
|
struct drm_cmdline_mode *cmd);
|
|
|
|
|
|
|
|
#endif /* __DRM_MODES_H__ */
|