mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Ville Syrjälä](/assets/img/avatar_default.png)
Allow drivers to provide a device wide .mode_valid() hook in addition to the already existing crtc/encoder/bridge/connector hooks. This can be used to validate device/driver wide constraings without having to add those to the other hooks. And since we call this hook also for user modes later on in the modeset we don't have to worry about anything the hook has already rejected. I also have some further ideas for this hook. Eg. we could replace the drm_mode_set_crtcinfo(HALVE_V) call in drm_mode_convert_umode()/etc. with a driver specific variant via this hook. At least on i915 we would like to pass CRTC_STEREO_DOUBLE to that function instead, and then we could safely use the crtc_ timings in all our .mode_valid() hooks, which would allow us to reuse those hooks for validating the adjusted_mode during a modeset. v2: Fix the language fails in the kernel docs (Daniel) Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com> Link: https://patchwork.freedesktop.org/patch/msgid/20171114183258.16976-10-ville.syrjala@linux.intel.com Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
522 lines
18 KiB
C
522 lines
18 KiB
C
/*
|
|
* 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__
|
|
|
|
#include <linux/hdmi.h>
|
|
|
|
#include <drm/drm_mode_object.h>
|
|
#include <drm/drm_connector.h>
|
|
|
|
struct videomode;
|
|
|
|
/*
|
|
* 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).
|
|
*/
|
|
|
|
/**
|
|
* 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
|
|
* @MODE_V_ILLEGAL: mode has illegal horizontal timings
|
|
* @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
|
|
* @MODE_NO_420: ycbcr 420 modes not supported
|
|
* @MODE_STALE: mode has become stale
|
|
* @MODE_BAD: unspecified reason
|
|
* @MODE_ERROR: error condition
|
|
*
|
|
* This enum is used to filter out modes not supported by the driver/hardware
|
|
* combination.
|
|
*/
|
|
enum drm_mode_status {
|
|
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,
|
|
MODE_NO_420,
|
|
MODE_STALE = -3,
|
|
MODE_BAD = -2,
|
|
MODE_ERROR = -1
|
|
};
|
|
|
|
#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), \
|
|
.vscan = (vs), .flags = (f), \
|
|
.base.type = DRM_MODE_OBJECT_MODE
|
|
|
|
#define CRTC_INTERLACE_HALVE_V (1 << 0) /* halve V values for interlacing */
|
|
#define CRTC_STEREO_DOUBLE (1 << 1) /* adjust timings for stereo modes */
|
|
#define CRTC_NO_DBLSCAN (1 << 2) /* don't adjust doublescan */
|
|
#define CRTC_NO_VSCAN (1 << 3) /* don't adjust doublescan */
|
|
#define CRTC_STEREO_DOUBLE_ONLY (CRTC_STEREO_DOUBLE | CRTC_NO_DBLSCAN | CRTC_NO_VSCAN)
|
|
|
|
#define DRM_MODE_FLAG_3D_MAX DRM_MODE_FLAG_3D_SIDE_BY_SIDE_HALF
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* ::
|
|
*
|
|
*
|
|
* 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().
|
|
*
|
|
* For printing you can use %DRM_MODE_FMT and DRM_MODE_ARG().
|
|
*/
|
|
struct drm_display_mode {
|
|
/**
|
|
* @head:
|
|
*
|
|
* struct list_head for mode lists.
|
|
*/
|
|
struct list_head head;
|
|
|
|
/**
|
|
* @base:
|
|
*
|
|
* A display mode is a normal modeset object, possibly including public
|
|
* userspace id.
|
|
*
|
|
* FIXME:
|
|
*
|
|
* This can probably be removed since the entire concept of userspace
|
|
* managing modes explicitly has never landed in upstream kernel mode
|
|
* setting support.
|
|
*/
|
|
struct drm_mode_object base;
|
|
|
|
/**
|
|
* @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;
|
|
|
|
/**
|
|
* @type:
|
|
*
|
|
* A bitmask of flags, mostly about the source of a mode. Possible flags
|
|
* are:
|
|
*
|
|
* - 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 via kernel command line
|
|
*
|
|
* 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.
|
|
*/
|
|
unsigned int type;
|
|
|
|
/**
|
|
* @clock:
|
|
*
|
|
* Pixel clock in kHz.
|
|
*/
|
|
int clock; /* in kHz */
|
|
int hdisplay;
|
|
int hsync_start;
|
|
int hsync_end;
|
|
int htotal;
|
|
int hskew;
|
|
int vdisplay;
|
|
int vsync_start;
|
|
int vsync_end;
|
|
int vtotal;
|
|
int vscan;
|
|
/**
|
|
* @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?).
|
|
* - DRM_MODE_FLAG_BCAST: <deprecated>
|
|
* - DRM_MODE_FLAG_PIXMUX: <deprecated>
|
|
* - 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.
|
|
*/
|
|
unsigned int flags;
|
|
|
|
/**
|
|
* @width_mm:
|
|
*
|
|
* Addressable size of the output in mm, projectors should set this to
|
|
* 0.
|
|
*/
|
|
int width_mm;
|
|
|
|
/**
|
|
* @height_mm:
|
|
*
|
|
* Addressable size of the output in mm, projectors should set this to
|
|
* 0.
|
|
*/
|
|
int height_mm;
|
|
|
|
/**
|
|
* @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;
|
|
int crtc_hdisplay;
|
|
int crtc_hblank_start;
|
|
int crtc_hblank_end;
|
|
int crtc_hsync_start;
|
|
int crtc_hsync_end;
|
|
int crtc_htotal;
|
|
int crtc_hskew;
|
|
int crtc_vdisplay;
|
|
int crtc_vblank_start;
|
|
int crtc_vblank_end;
|
|
int crtc_vsync_start;
|
|
int crtc_vsync_end;
|
|
int crtc_vtotal;
|
|
|
|
/**
|
|
* @private:
|
|
*
|
|
* Pointer for driver private data. This can only be used for mode
|
|
* 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.
|
|
*/
|
|
int *private;
|
|
|
|
/**
|
|
* @private_flags:
|
|
*
|
|
* Similar to @private, but just an integer.
|
|
*/
|
|
int private_flags;
|
|
|
|
/**
|
|
* @vrefresh:
|
|
*
|
|
* Vertical refresh rate, for debug output in human readable form. Not
|
|
* used in a functional way.
|
|
*
|
|
* This value is in Hz.
|
|
*/
|
|
int vrefresh;
|
|
|
|
/**
|
|
* @hsync:
|
|
*
|
|
* Horizontal refresh rate, for debug output in human readable form. Not
|
|
* used in a functional way.
|
|
*
|
|
* This value is in kHz.
|
|
*/
|
|
int hsync;
|
|
|
|
/**
|
|
* @picture_aspect_ratio:
|
|
*
|
|
* Field for setting the HDMI picture aspect ratio of a mode.
|
|
*/
|
|
enum hdmi_picture_aspect picture_aspect_ratio;
|
|
};
|
|
|
|
/**
|
|
* DRM_MODE_FMT - printf string for &struct drm_display_mode
|
|
*/
|
|
#define DRM_MODE_FMT "%d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x"
|
|
|
|
/**
|
|
* DRM_MODE_ARG - printf arguments for &struct drm_display_mode
|
|
* @m: display mode
|
|
*/
|
|
#define DRM_MODE_ARG(m) \
|
|
(m)->base.id, (m)->name, (m)->vrefresh, (m)->clock, \
|
|
(m)->hdisplay, (m)->hsync_start, (m)->hsync_end, (m)->htotal, \
|
|
(m)->vdisplay, (m)->vsync_start, (m)->vsync_end, (m)->vtotal, \
|
|
(m)->type, (m)->flags
|
|
|
|
#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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);
|
|
void drm_mode_convert_to_umode(struct drm_mode_modeinfo *out,
|
|
const struct drm_display_mode *in);
|
|
int drm_mode_convert_umode(struct drm_device *dev,
|
|
struct drm_display_mode *out,
|
|
const struct drm_mode_modeinfo *in);
|
|
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);
|
|
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);
|
|
|
|
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);
|
|
void drm_display_mode_from_videomode(const struct videomode *vm,
|
|
struct drm_display_mode *dmode);
|
|
void drm_display_mode_to_videomode(const struct drm_display_mode *dmode,
|
|
struct videomode *vm);
|
|
void drm_bus_flags_from_videomode(const struct videomode *vm, u32 *bus_flags);
|
|
int of_get_drm_display_mode(struct device_node *np,
|
|
struct drm_display_mode *dmode, u32 *bus_flags,
|
|
int index);
|
|
|
|
void drm_mode_set_name(struct drm_display_mode *mode);
|
|
int drm_mode_hsync(const struct drm_display_mode *mode);
|
|
int drm_mode_vrefresh(const struct drm_display_mode *mode);
|
|
void drm_mode_get_hv_timing(const struct drm_display_mode *mode,
|
|
int *hdisplay, int *vdisplay);
|
|
|
|
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);
|
|
bool drm_mode_equal(const struct drm_display_mode *mode1,
|
|
const struct drm_display_mode *mode2);
|
|
bool drm_mode_equal_no_clocks(const struct drm_display_mode *mode1,
|
|
const struct drm_display_mode *mode2);
|
|
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 */
|
|
enum drm_mode_status drm_mode_validate_driver(struct drm_device *dev,
|
|
const struct drm_display_mode *mode);
|
|
enum drm_mode_status drm_mode_validate_size(const struct drm_display_mode *mode,
|
|
int maxX, int maxY);
|
|
enum drm_mode_status
|
|
drm_mode_validate_ycbcr420(const struct drm_display_mode *mode,
|
|
struct drm_connector *connector);
|
|
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);
|
|
void drm_mode_connector_list_update(struct drm_connector *connector);
|
|
|
|
/* parsing cmdline modes */
|
|
bool
|
|
drm_mode_parse_command_line_for_connector(const char *mode_option,
|
|
struct drm_connector *connector,
|
|
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__ */
|