2016-08-12 20:48:50 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2016 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
|
|
* the above copyright notice appear in all copies and that both that copyright
|
|
|
|
* notice and this permission notice appear in supporting documentation, and
|
|
|
|
* that the name of the copyright holders not be used in advertising or
|
|
|
|
* publicity pertaining to distribution of the software without specific,
|
|
|
|
* written prior permission. The copyright holders make no representations
|
|
|
|
* about the suitability of this software for any purpose. It is provided "as
|
|
|
|
* is" without express or implied warranty.
|
|
|
|
*
|
|
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
|
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|
|
|
* EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|
|
|
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|
|
|
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
|
|
* OF THIS SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __DRM_CONNECTOR_H__
|
|
|
|
#define __DRM_CONNECTOR_H__
|
|
|
|
|
|
|
|
#include <linux/list.h>
|
2017-12-13 12:49:36 +00:00
|
|
|
#include <linux/llist.h>
|
2016-08-12 20:48:50 +00:00
|
|
|
#include <linux/ctype.h>
|
2017-05-01 13:37:53 +00:00
|
|
|
#include <linux/hdmi.h>
|
2016-08-29 08:27:51 +00:00
|
|
|
#include <drm/drm_mode_object.h>
|
2016-08-12 20:48:50 +00:00
|
|
|
|
2016-08-31 16:09:05 +00:00
|
|
|
#include <uapi/drm/drm_mode.h>
|
|
|
|
|
2016-08-12 20:48:50 +00:00
|
|
|
struct drm_connector_helper_funcs;
|
2017-04-06 18:55:20 +00:00
|
|
|
struct drm_modeset_acquire_ctx;
|
2016-08-12 20:48:50 +00:00
|
|
|
struct drm_device;
|
|
|
|
struct drm_crtc;
|
|
|
|
struct drm_encoder;
|
|
|
|
struct drm_property;
|
|
|
|
struct drm_property_blob;
|
2016-11-05 15:08:09 +00:00
|
|
|
struct drm_printer;
|
2016-08-12 20:48:50 +00:00
|
|
|
struct edid;
|
|
|
|
|
|
|
|
enum drm_connector_force {
|
|
|
|
DRM_FORCE_UNSPECIFIED,
|
|
|
|
DRM_FORCE_OFF,
|
|
|
|
DRM_FORCE_ON, /* force on analog part normally */
|
|
|
|
DRM_FORCE_ON_DIGITAL, /* for DVI-I use digital connector */
|
|
|
|
};
|
|
|
|
|
2016-08-12 20:48:53 +00:00
|
|
|
/**
|
|
|
|
* enum drm_connector_status - status for a &drm_connector
|
|
|
|
*
|
|
|
|
* This enum is used to track the connector status. There are no separate
|
|
|
|
* #defines for the uapi!
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
enum drm_connector_status {
|
2016-08-12 20:48:53 +00:00
|
|
|
/**
|
|
|
|
* @connector_status_connected: The connector is definitely connected to
|
|
|
|
* a sink device, and can be enabled.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
connector_status_connected = 1,
|
2016-08-12 20:48:53 +00:00
|
|
|
/**
|
|
|
|
* @connector_status_disconnected: The connector isn't connected to a
|
|
|
|
* sink device which can be autodetect. For digital outputs like DP or
|
|
|
|
* HDMI (which can be realiable probed) this means there's really
|
|
|
|
* nothing there. It is driver-dependent whether a connector with this
|
|
|
|
* status can be lit up or not.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
connector_status_disconnected = 2,
|
2016-08-12 20:48:53 +00:00
|
|
|
/**
|
|
|
|
* @connector_status_unknown: The connector's status could not be
|
|
|
|
* reliably detected. This happens when probing would either cause
|
|
|
|
* flicker (like load-detection when the connector is in use), or when a
|
|
|
|
* hardware resource isn't available (like when load-detection needs a
|
|
|
|
* free CRTC). It should be possible to light up the connector with one
|
|
|
|
* of the listed fallback modes. For default configuration userspace
|
|
|
|
* should only try to light up connectors with unknown status when
|
|
|
|
* there's not connector with @connector_status_connected.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
connector_status_unknown = 3,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum subpixel_order {
|
|
|
|
SubPixelUnknown = 0,
|
|
|
|
SubPixelHorizontalRGB,
|
|
|
|
SubPixelHorizontalBGR,
|
|
|
|
SubPixelVerticalRGB,
|
|
|
|
SubPixelVerticalBGR,
|
|
|
|
SubPixelNone,
|
2017-03-13 11:24:01 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
2017-03-13 11:24:02 +00:00
|
|
|
/**
|
|
|
|
* struct drm_scrambling: sink's scrambling support.
|
|
|
|
*/
|
|
|
|
struct drm_scrambling {
|
|
|
|
/**
|
|
|
|
* @supported: scrambling supported for rates > 340 Mhz.
|
|
|
|
*/
|
|
|
|
bool supported;
|
|
|
|
/**
|
|
|
|
* @low_rates: scrambling supported for rates <= 340 Mhz.
|
|
|
|
*/
|
|
|
|
bool low_rates;
|
|
|
|
};
|
|
|
|
|
2017-03-13 11:24:01 +00:00
|
|
|
/*
|
|
|
|
* struct drm_scdc - Information about scdc capabilities of a HDMI 2.0 sink
|
|
|
|
*
|
|
|
|
* Provides SCDC register support and capabilities related information on a
|
|
|
|
* HDMI 2.0 sink. In case of a HDMI 1.4 sink, all parameter must be 0.
|
|
|
|
*/
|
|
|
|
struct drm_scdc {
|
|
|
|
/**
|
|
|
|
* @supported: status control & data channel present.
|
|
|
|
*/
|
|
|
|
bool supported;
|
|
|
|
/**
|
|
|
|
* @read_request: sink is capable of generating scdc read request.
|
|
|
|
*/
|
|
|
|
bool read_request;
|
2017-03-13 11:24:02 +00:00
|
|
|
/**
|
|
|
|
* @scrambling: sink's scrambling capabilities
|
|
|
|
*/
|
|
|
|
struct drm_scrambling scrambling;
|
2017-03-13 11:24:01 +00:00
|
|
|
};
|
|
|
|
|
2017-03-13 11:24:02 +00:00
|
|
|
|
2017-03-13 11:24:01 +00:00
|
|
|
/**
|
|
|
|
* struct drm_hdmi_info - runtime information about the connected HDMI sink
|
|
|
|
*
|
|
|
|
* Describes if a given display supports advanced HDMI 2.0 features.
|
|
|
|
* This information is available in CEA-861-F extension blocks (like HF-VSDB).
|
|
|
|
*/
|
|
|
|
struct drm_hdmi_info {
|
2017-03-28 07:06:19 +00:00
|
|
|
/** @scdc: sink's scdc support and capabilities */
|
2017-03-13 11:24:01 +00:00
|
|
|
struct drm_scdc scdc;
|
2017-07-13 15:33:11 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @y420_vdb_modes: bitmap of modes which can support ycbcr420
|
|
|
|
* output only (not normal RGB/YCBCR444/422 outputs). There are total
|
|
|
|
* 107 VICs defined by CEA-861-F spec, so the size is 128 bits to map
|
|
|
|
* upto 128 VICs;
|
|
|
|
*/
|
|
|
|
unsigned long y420_vdb_modes[BITS_TO_LONGS(128)];
|
drm/edid: parse YCBCR420 videomodes from EDID
HDMI 2.0 spec adds support for YCBCR420 sub-sampled output.
CEA-861-F adds two new blocks in EDID's CEA extension blocks,
to provide information about sink's YCBCR420 output capabilities.
These blocks are:
- YCBCR420vdb(YCBCR 420 video data block):
This block contains VICs of video modes, which can be sopported only
in YCBCR420 output mode (Not in RGB/YCBCR444/422. Its like a normal
SVD block, valid for YCBCR420 modes only.
- YCBCR420cmdb(YCBCR 420 capability map data block):
This block gives information about video modes which can support
YCBCR420 output mode also (along with RGB,YCBCR444/422 etc) This
block contains a bitmap index of normal svd videomodes, which can
support YCBCR420 output too.
So if bit 0 from first vcb byte is set, first video mode in the svd
list can support YCBCR420 output too. Bit 1 means second video mode
from svd list can support YCBCR420 output too, and so on.
This patch adds two bitmaps in display's hdmi_info structure, one each
for VCB and VDB modes. If the source is HDMI 2.0 capable, this patch
adds:
- VDB modes (YCBCR 420 only modes) in connector's mode list, also makes
an entry in the vdb_bitmap per vic.
- VCB modes (YCBCR 420 also modes) only entry in the vcb_bitmap.
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Jose Abreu <joabreu@synopsys.com>
Cc: Emil Velikov <emil.l.velikov@gmail.com>
V2: Addressed
Review comments from Emil:
- Use 1ULL<<i instead of 1<<i to make sure the output is 64bit.
- Use the suggested method for updating dbmap.
- Add documentation for YCBCR420_vcb_map to fix kbuild warning.
Review comments from Ville:
- Do not expose the YCBCR420 flags in uabi layer, keep it internal.
- Save a map of YCBCR420 modes for future reference.
- Check db length before trying to parse extended tag.
- Add a warning if there are > 64 modes in capability map block.
- Use y420cmdb in function names and macros while dealing with vcb
to be aligned with spec.
- Move the display information parsing block ahead of mode parsing
blocks.
V3: Addressed design/review comments from Ville
- Do not add flags in video modes, else we have to expose them to user
- There should not be a UABI change, and kernel should detect the
choice of the output based on type of mode, and the bitmaps.
- Use standard bitops from kernel bitmap header, instead of calculating
bit positions manually.
V4: Addressed review comments from Ville:
- s/ycbcr_420_vdb/y420vdb
- s/ycbcr_420_vcb/y420cmdb
- Be less verbose on description of do_y420vdb_modes
- Move newmode variable in the loop scope.
- Use svd_to_vic() to get a VIC, instead of 0x7f
- Remove bitmap description for CMDB modes & VDB modes
- Dont add connector->ycbcr_420_allowed check for cmdb modes
- Remove 'len' variable, in is_y420cmdb function, which is used
only once
- Add length check in is_y420vdb function
- Remove unnecessary if (!db) check in function parse_y420cmdb_bitmap
- Do not add print about YCBCR 420 modes
- Fix indentation in few places
- Move ycbcr420_dc_modes in next patch, where its used
- Add a separate patch for movement of drm_add_display_info()
V5: Addressed review comments from Ville:
- Add the patch which cleans up the current EXTENDED_TAG usage
- Make y420_cmdb_map u64
- Do not block ycbcr420 modes while parsing the EDID, rather
add a separate helper function to prune ycbcr420-only modes from
connector's probed modes.
V6: Rebase
V7: Move this patch after the 420_only validation patch (Ville)
V8: Addressed review comments from Ville
- use cea_vic_valid check before adding cmdb/vdb modes
- add check for i < 64 while adding cmdb modes
- use 1ULL while checking bitmap
Signed-off-by: Shashank Sharma <shashank.sharma@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1500028426-14883-1-git-send-email-shashank.sharma@intel.com
[vsyrjala: Fix checkpatch complaints and indentation]
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
2017-07-14 10:33:46 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @y420_cmdb_modes: bitmap of modes which can support ycbcr420
|
|
|
|
* output also, along with normal HDMI outputs. There are total 107
|
|
|
|
* VICs defined by CEA-861-F spec, so the size is 128 bits to map upto
|
|
|
|
* 128 VICs;
|
|
|
|
*/
|
|
|
|
unsigned long y420_cmdb_modes[BITS_TO_LONGS(128)];
|
|
|
|
|
|
|
|
/** @y420_cmdb_map: bitmap of SVD index, to extraxt vcb modes */
|
|
|
|
u64 y420_cmdb_map;
|
2017-07-13 15:33:13 +00:00
|
|
|
|
|
|
|
/** @y420_dc_modes: bitmap of deep color support index */
|
|
|
|
u8 y420_dc_modes;
|
2016-08-12 20:48:50 +00:00
|
|
|
};
|
|
|
|
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 10:29:06 +00:00
|
|
|
/**
|
|
|
|
* enum drm_link_status - connector's link_status property value
|
|
|
|
*
|
|
|
|
* This enum is used as the connector's link status property value.
|
|
|
|
* It is set to the values defined in uapi.
|
2017-03-01 14:45:10 +00:00
|
|
|
*
|
|
|
|
* @DRM_LINK_STATUS_GOOD: DP Link is Good as a result of successful
|
|
|
|
* link training
|
|
|
|
* @DRM_LINK_STATUS_BAD: DP Link is BAD as a result of link training
|
|
|
|
* failure
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 10:29:06 +00:00
|
|
|
*/
|
|
|
|
enum drm_link_status {
|
|
|
|
DRM_LINK_STATUS_GOOD = DRM_MODE_LINK_STATUS_GOOD,
|
|
|
|
DRM_LINK_STATUS_BAD = DRM_MODE_LINK_STATUS_BAD,
|
|
|
|
};
|
|
|
|
|
2017-11-25 19:35:49 +00:00
|
|
|
/**
|
|
|
|
* enum drm_panel_orientation - panel_orientation info for &drm_display_info
|
|
|
|
*
|
|
|
|
* This enum is used to track the (LCD) panel orientation. There are no
|
|
|
|
* separate #defines for the uapi!
|
|
|
|
*
|
|
|
|
* @DRM_MODE_PANEL_ORIENTATION_UNKNOWN: The drm driver has not provided any
|
|
|
|
* panel orientation information (normal
|
|
|
|
* for non panels) in this case the "panel
|
|
|
|
* orientation" connector prop will not be
|
|
|
|
* attached.
|
|
|
|
* @DRM_MODE_PANEL_ORIENTATION_NORMAL: The top side of the panel matches the
|
|
|
|
* top side of the device's casing.
|
|
|
|
* @DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP: The top side of the panel matches the
|
|
|
|
* bottom side of the device's casing, iow
|
|
|
|
* the panel is mounted upside-down.
|
|
|
|
* @DRM_MODE_PANEL_ORIENTATION_LEFT_UP: The left side of the panel matches the
|
|
|
|
* top side of the device's casing.
|
|
|
|
* @DRM_MODE_PANEL_ORIENTATION_RIGHT_UP: The right side of the panel matches the
|
|
|
|
* top side of the device's casing.
|
|
|
|
*/
|
|
|
|
enum drm_panel_orientation {
|
|
|
|
DRM_MODE_PANEL_ORIENTATION_UNKNOWN = -1,
|
|
|
|
DRM_MODE_PANEL_ORIENTATION_NORMAL = 0,
|
|
|
|
DRM_MODE_PANEL_ORIENTATION_BOTTOM_UP,
|
|
|
|
DRM_MODE_PANEL_ORIENTATION_LEFT_UP,
|
|
|
|
DRM_MODE_PANEL_ORIENTATION_RIGHT_UP,
|
|
|
|
};
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* struct drm_display_info - runtime data about the connected sink
|
|
|
|
*
|
|
|
|
* Describes a given display (e.g. CRT or flat panel) and its limitations. For
|
|
|
|
* fixed display sinks like built-in panels there's not much difference between
|
2016-12-29 20:48:26 +00:00
|
|
|
* this and &struct drm_connector. But for sinks with a real cable this
|
2016-08-12 20:48:55 +00:00
|
|
|
* structure is meant to describe all the things at the other end of the cable.
|
|
|
|
*
|
|
|
|
* For sinks which provide an EDID this can be filled out by calling
|
|
|
|
* drm_add_edid_modes().
|
2016-08-12 20:48:50 +00:00
|
|
|
*/
|
|
|
|
struct drm_display_info {
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @name: Name of the display.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
char name[DRM_DISPLAY_INFO_LEN];
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @width_mm: Physical width in mm.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
unsigned int width_mm;
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @height_mm: Physical height in mm.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
unsigned int height_mm;
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @pixel_clock: Maximum pixel clock supported by the sink, in units of
|
2016-12-16 13:24:23 +00:00
|
|
|
* 100Hz. This mismatches the clock in &drm_display_mode (which is in
|
2016-08-12 20:48:55 +00:00
|
|
|
* kHZ), because that's what the EDID uses as base unit.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
unsigned int pixel_clock;
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @bpc: Maximum bits per color channel. Used by HDMI and DP outputs.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
unsigned int bpc;
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @subpixel_order: Subpixel order of LCD panels.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
enum subpixel_order subpixel_order;
|
|
|
|
|
|
|
|
#define DRM_COLOR_FORMAT_RGB444 (1<<0)
|
|
|
|
#define DRM_COLOR_FORMAT_YCRCB444 (1<<1)
|
|
|
|
#define DRM_COLOR_FORMAT_YCRCB422 (1<<2)
|
drm/edid: parse YCBCR420 videomodes from EDID
HDMI 2.0 spec adds support for YCBCR420 sub-sampled output.
CEA-861-F adds two new blocks in EDID's CEA extension blocks,
to provide information about sink's YCBCR420 output capabilities.
These blocks are:
- YCBCR420vdb(YCBCR 420 video data block):
This block contains VICs of video modes, which can be sopported only
in YCBCR420 output mode (Not in RGB/YCBCR444/422. Its like a normal
SVD block, valid for YCBCR420 modes only.
- YCBCR420cmdb(YCBCR 420 capability map data block):
This block gives information about video modes which can support
YCBCR420 output mode also (along with RGB,YCBCR444/422 etc) This
block contains a bitmap index of normal svd videomodes, which can
support YCBCR420 output too.
So if bit 0 from first vcb byte is set, first video mode in the svd
list can support YCBCR420 output too. Bit 1 means second video mode
from svd list can support YCBCR420 output too, and so on.
This patch adds two bitmaps in display's hdmi_info structure, one each
for VCB and VDB modes. If the source is HDMI 2.0 capable, this patch
adds:
- VDB modes (YCBCR 420 only modes) in connector's mode list, also makes
an entry in the vdb_bitmap per vic.
- VCB modes (YCBCR 420 also modes) only entry in the vcb_bitmap.
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Jose Abreu <joabreu@synopsys.com>
Cc: Emil Velikov <emil.l.velikov@gmail.com>
V2: Addressed
Review comments from Emil:
- Use 1ULL<<i instead of 1<<i to make sure the output is 64bit.
- Use the suggested method for updating dbmap.
- Add documentation for YCBCR420_vcb_map to fix kbuild warning.
Review comments from Ville:
- Do not expose the YCBCR420 flags in uabi layer, keep it internal.
- Save a map of YCBCR420 modes for future reference.
- Check db length before trying to parse extended tag.
- Add a warning if there are > 64 modes in capability map block.
- Use y420cmdb in function names and macros while dealing with vcb
to be aligned with spec.
- Move the display information parsing block ahead of mode parsing
blocks.
V3: Addressed design/review comments from Ville
- Do not add flags in video modes, else we have to expose them to user
- There should not be a UABI change, and kernel should detect the
choice of the output based on type of mode, and the bitmaps.
- Use standard bitops from kernel bitmap header, instead of calculating
bit positions manually.
V4: Addressed review comments from Ville:
- s/ycbcr_420_vdb/y420vdb
- s/ycbcr_420_vcb/y420cmdb
- Be less verbose on description of do_y420vdb_modes
- Move newmode variable in the loop scope.
- Use svd_to_vic() to get a VIC, instead of 0x7f
- Remove bitmap description for CMDB modes & VDB modes
- Dont add connector->ycbcr_420_allowed check for cmdb modes
- Remove 'len' variable, in is_y420cmdb function, which is used
only once
- Add length check in is_y420vdb function
- Remove unnecessary if (!db) check in function parse_y420cmdb_bitmap
- Do not add print about YCBCR 420 modes
- Fix indentation in few places
- Move ycbcr420_dc_modes in next patch, where its used
- Add a separate patch for movement of drm_add_display_info()
V5: Addressed review comments from Ville:
- Add the patch which cleans up the current EXTENDED_TAG usage
- Make y420_cmdb_map u64
- Do not block ycbcr420 modes while parsing the EDID, rather
add a separate helper function to prune ycbcr420-only modes from
connector's probed modes.
V6: Rebase
V7: Move this patch after the 420_only validation patch (Ville)
V8: Addressed review comments from Ville
- use cea_vic_valid check before adding cmdb/vdb modes
- add check for i < 64 while adding cmdb modes
- use 1ULL while checking bitmap
Signed-off-by: Shashank Sharma <shashank.sharma@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/1500028426-14883-1-git-send-email-shashank.sharma@intel.com
[vsyrjala: Fix checkpatch complaints and indentation]
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
2017-07-14 10:33:46 +00:00
|
|
|
#define DRM_COLOR_FORMAT_YCRCB420 (1<<3)
|
2016-08-12 20:48:50 +00:00
|
|
|
|
2017-11-25 19:35:49 +00:00
|
|
|
/**
|
|
|
|
* @panel_orientation: Read only connector property for built-in panels,
|
|
|
|
* indicating the orientation of the panel vs the device's casing.
|
|
|
|
* drm_connector_init() sets this to DRM_MODE_PANEL_ORIENTATION_UNKNOWN.
|
|
|
|
* When not UNKNOWN this gets used by the drm_fb_helpers to rotate the
|
|
|
|
* fb to compensate and gets exported as prop to userspace.
|
|
|
|
*/
|
|
|
|
int panel_orientation;
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @color_formats: HDMI Color formats, selects between RGB and YCrCb
|
|
|
|
* modes. Used DRM_COLOR_FORMAT\_ defines, which are _not_ the same ones
|
|
|
|
* as used to describe the pixel format in framebuffers, and also don't
|
|
|
|
* match the formats in @bus_formats which are shared with v4l.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
u32 color_formats;
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @bus_formats: Pixel data format on the wire, somewhat redundant with
|
|
|
|
* @color_formats. Array of size @num_bus_formats encoded using
|
|
|
|
* MEDIA_BUS_FMT\_ defines shared with v4l and media drivers.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
const u32 *bus_formats;
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @num_bus_formats: Size of @bus_formats array.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
unsigned int num_bus_formats;
|
|
|
|
|
|
|
|
#define DRM_BUS_FLAG_DE_LOW (1<<0)
|
|
|
|
#define DRM_BUS_FLAG_DE_HIGH (1<<1)
|
|
|
|
/* drive data on pos. edge */
|
|
|
|
#define DRM_BUS_FLAG_PIXDATA_POSEDGE (1<<2)
|
|
|
|
/* drive data on neg. edge */
|
|
|
|
#define DRM_BUS_FLAG_PIXDATA_NEGEDGE (1<<3)
|
2016-11-18 14:55:48 +00:00
|
|
|
/* data is transmitted MSB to LSB on the bus */
|
|
|
|
#define DRM_BUS_FLAG_DATA_MSB_TO_LSB (1<<4)
|
|
|
|
/* data is transmitted LSB to MSB on the bus */
|
|
|
|
#define DRM_BUS_FLAG_DATA_LSB_TO_MSB (1<<5)
|
2016-08-12 20:48:50 +00:00
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @bus_flags: Additional information (like pixel signal polarity) for
|
|
|
|
* the pixel data on the bus, using DRM_BUS_FLAGS\_ defines.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
u32 bus_flags;
|
|
|
|
|
2016-09-28 13:51:37 +00:00
|
|
|
/**
|
|
|
|
* @max_tmds_clock: Maximum TMDS clock rate supported by the
|
|
|
|
* sink in kHz. 0 means undefined.
|
|
|
|
*/
|
|
|
|
int max_tmds_clock;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @dvi_dual: Dual-link DVI sink?
|
|
|
|
*/
|
|
|
|
bool dvi_dual;
|
|
|
|
|
2017-11-13 17:04:19 +00:00
|
|
|
/**
|
|
|
|
* @has_hdmi_infoframe: Does the sink support the HDMI infoframe?
|
|
|
|
*/
|
|
|
|
bool has_hdmi_infoframe;
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @edid_hdmi_dc_modes: Mask of supported hdmi deep color modes. Even
|
|
|
|
* more stuff redundant with @bus_formats.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
u8 edid_hdmi_dc_modes;
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
/**
|
|
|
|
* @cea_rev: CEA revision of the HDMI sink.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
u8 cea_rev;
|
2017-03-13 11:24:01 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @hdmi: advance features of a HDMI sink.
|
|
|
|
*/
|
|
|
|
struct drm_hdmi_info hdmi;
|
2017-10-16 04:08:09 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @non_desktop: Non desktop display (HMD).
|
|
|
|
*/
|
|
|
|
bool non_desktop;
|
2016-08-12 20:48:50 +00:00
|
|
|
};
|
|
|
|
|
2016-08-12 20:48:55 +00:00
|
|
|
int drm_display_info_set_bus_formats(struct drm_display_info *info,
|
|
|
|
const u32 *formats,
|
|
|
|
unsigned int num_formats);
|
|
|
|
|
2016-12-02 13:48:09 +00:00
|
|
|
/**
|
|
|
|
* struct drm_tv_connector_state - TV connector related states
|
|
|
|
* @subconnector: selected subconnector
|
2018-02-19 10:40:09 +00:00
|
|
|
* @margins: margins
|
|
|
|
* @margins.left: left margin
|
|
|
|
* @margins.right: right margin
|
|
|
|
* @margins.top: top margin
|
|
|
|
* @margins.bottom: bottom margin
|
2016-12-02 13:48:09 +00:00
|
|
|
* @mode: TV mode
|
|
|
|
* @brightness: brightness in percent
|
|
|
|
* @contrast: contrast in percent
|
|
|
|
* @flicker_reduction: flicker reduction in percent
|
|
|
|
* @overscan: overscan in percent
|
|
|
|
* @saturation: saturation in percent
|
|
|
|
* @hue: hue in percent
|
|
|
|
*/
|
|
|
|
struct drm_tv_connector_state {
|
|
|
|
enum drm_mode_subconnector subconnector;
|
|
|
|
struct {
|
|
|
|
unsigned int left;
|
|
|
|
unsigned int right;
|
|
|
|
unsigned int top;
|
|
|
|
unsigned int bottom;
|
|
|
|
} margins;
|
|
|
|
unsigned int mode;
|
|
|
|
unsigned int brightness;
|
|
|
|
unsigned int contrast;
|
|
|
|
unsigned int flicker_reduction;
|
|
|
|
unsigned int overscan;
|
|
|
|
unsigned int saturation;
|
|
|
|
unsigned int hue;
|
|
|
|
};
|
|
|
|
|
2016-08-12 20:48:50 +00:00
|
|
|
/**
|
|
|
|
* struct drm_connector_state - mutable connector state
|
|
|
|
* @connector: backpointer to the connector
|
|
|
|
* @best_encoder: can be used by helpers and drivers to select the encoder
|
|
|
|
* @state: backpointer to global drm_atomic_state
|
2016-12-02 13:48:09 +00:00
|
|
|
* @tv: TV connector state
|
2016-08-12 20:48:50 +00:00
|
|
|
*/
|
|
|
|
struct drm_connector_state {
|
|
|
|
struct drm_connector *connector;
|
|
|
|
|
2016-08-31 16:09:04 +00:00
|
|
|
/**
|
|
|
|
* @crtc: CRTC to connect connector to, NULL if disabled.
|
|
|
|
*
|
|
|
|
* Do not change this directly, use drm_atomic_set_crtc_for_connector()
|
|
|
|
* instead.
|
|
|
|
*/
|
|
|
|
struct drm_crtc *crtc;
|
2016-08-12 20:48:50 +00:00
|
|
|
|
|
|
|
struct drm_encoder *best_encoder;
|
|
|
|
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 10:29:06 +00:00
|
|
|
/**
|
|
|
|
* @link_status: Connector link_status to keep track of whether link is
|
|
|
|
* GOOD or BAD to notify userspace if retraining is necessary.
|
|
|
|
*/
|
|
|
|
enum drm_link_status link_status;
|
|
|
|
|
2016-08-12 20:48:50 +00:00
|
|
|
struct drm_atomic_state *state;
|
2016-12-02 13:48:09 +00:00
|
|
|
|
2017-09-04 10:48:37 +00:00
|
|
|
/**
|
|
|
|
* @commit: Tracks the pending commit to prevent use-after-free conditions.
|
|
|
|
*
|
|
|
|
* Is only set when @crtc is NULL.
|
|
|
|
*/
|
|
|
|
struct drm_crtc_commit *commit;
|
|
|
|
|
2016-12-02 13:48:09 +00:00
|
|
|
struct drm_tv_connector_state tv;
|
2017-05-01 13:37:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @picture_aspect_ratio: Connector property to control the
|
|
|
|
* HDMI infoframe aspect ratio setting.
|
|
|
|
*
|
2017-05-01 13:37:54 +00:00
|
|
|
* The %DRM_MODE_PICTURE_ASPECT_\* values much match the
|
2017-05-01 13:37:53 +00:00
|
|
|
* values for &enum hdmi_picture_aspect
|
|
|
|
*/
|
|
|
|
enum hdmi_picture_aspect picture_aspect_ratio;
|
2017-05-01 13:37:54 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @scaling_mode: Connector property to control the
|
|
|
|
* upscaling, mostly used for built-in panels.
|
|
|
|
*/
|
|
|
|
unsigned int scaling_mode;
|
2018-01-08 19:55:37 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @content_protection: Connector property to request content
|
|
|
|
* protection. This is most commonly used for HDCP.
|
|
|
|
*/
|
|
|
|
unsigned int content_protection;
|
2016-08-12 20:48:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct drm_connector_funcs - control connectors on a given device
|
|
|
|
*
|
|
|
|
* Each CRTC may have one or more connectors attached to it. The functions
|
|
|
|
* below allow the core DRM code to control connectors, enumerate available modes,
|
|
|
|
* etc.
|
|
|
|
*/
|
|
|
|
struct drm_connector_funcs {
|
|
|
|
/**
|
|
|
|
* @dpms:
|
|
|
|
*
|
|
|
|
* Legacy entry point to set the per-connector DPMS state. Legacy DPMS
|
|
|
|
* is exposed as a standard property on the connector, but diverted to
|
|
|
|
* this callback in the drm core. Note that atomic drivers don't
|
|
|
|
* implement the 4 level DPMS support on the connector any more, but
|
|
|
|
* instead only have an on/off "ACTIVE" property on the CRTC object.
|
|
|
|
*
|
2017-07-25 12:02:04 +00:00
|
|
|
* This hook is not used by atomic drivers, remapping of the legacy DPMS
|
|
|
|
* property is entirely handled in the DRM core.
|
2016-08-12 20:48:50 +00:00
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int (*dpms)(struct drm_connector *connector, int mode);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @reset:
|
|
|
|
*
|
|
|
|
* Reset connector hardware and software state to off. This function isn't
|
|
|
|
* called by the core directly, only through drm_mode_config_reset().
|
|
|
|
* It's not a helper hook only for historical reasons.
|
|
|
|
*
|
|
|
|
* Atomic drivers can use drm_atomic_helper_connector_reset() to reset
|
|
|
|
* atomic state using this hook.
|
|
|
|
*/
|
|
|
|
void (*reset)(struct drm_connector *connector);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @detect:
|
|
|
|
*
|
|
|
|
* Check to see if anything is attached to the connector. The parameter
|
|
|
|
* force is set to false whilst polling, true when checking the
|
|
|
|
* connector due to a user request. force can be used by the driver to
|
|
|
|
* avoid expensive, destructive operations during automated probing.
|
|
|
|
*
|
2016-11-29 20:56:30 +00:00
|
|
|
* This callback is optional, if not implemented the connector will be
|
|
|
|
* considered as always being attached.
|
|
|
|
*
|
2016-08-12 20:48:50 +00:00
|
|
|
* FIXME:
|
|
|
|
*
|
|
|
|
* Note that this hook is only called by the probe helper. It's not in
|
|
|
|
* the helper library vtable purely for historical reasons. The only DRM
|
|
|
|
* core entry point to probe connector state is @fill_modes.
|
|
|
|
*
|
2017-04-06 18:55:20 +00:00
|
|
|
* Note that the helper library will already hold
|
|
|
|
* &drm_mode_config.connection_mutex. Drivers which need to grab additional
|
|
|
|
* locks to avoid races with concurrent modeset changes need to use
|
|
|
|
* &drm_connector_helper_funcs.detect_ctx instead.
|
|
|
|
*
|
2016-08-12 20:48:50 +00:00
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* drm_connector_status indicating the connector's status.
|
|
|
|
*/
|
|
|
|
enum drm_connector_status (*detect)(struct drm_connector *connector,
|
|
|
|
bool force);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @force:
|
|
|
|
*
|
|
|
|
* This function is called to update internal encoder state when the
|
|
|
|
* connector is forced to a certain state by userspace, either through
|
|
|
|
* the sysfs interfaces or on the kernel cmdline. In that case the
|
|
|
|
* @detect callback isn't called.
|
|
|
|
*
|
|
|
|
* FIXME:
|
|
|
|
*
|
|
|
|
* Note that this hook is only called by the probe helper. It's not in
|
|
|
|
* the helper library vtable purely for historical reasons. The only DRM
|
|
|
|
* core entry point to probe connector state is @fill_modes.
|
|
|
|
*/
|
|
|
|
void (*force)(struct drm_connector *connector);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @fill_modes:
|
|
|
|
*
|
|
|
|
* Entry point for output detection and basic mode validation. The
|
|
|
|
* driver should reprobe the output if needed (e.g. when hotplug
|
2017-01-25 06:26:45 +00:00
|
|
|
* handling is unreliable), add all detected modes to &drm_connector.modes
|
2016-08-12 20:48:50 +00:00
|
|
|
* and filter out any the device can't support in any configuration. It
|
|
|
|
* also needs to filter out any modes wider or higher than the
|
|
|
|
* parameters max_width and max_height indicate.
|
|
|
|
*
|
|
|
|
* The drivers must also prune any modes no longer valid from
|
2017-01-25 06:26:45 +00:00
|
|
|
* &drm_connector.modes. Furthermore it must update
|
|
|
|
* &drm_connector.status and &drm_connector.edid. If no EDID has been
|
|
|
|
* received for this output connector->edid must be NULL.
|
2016-08-12 20:48:50 +00:00
|
|
|
*
|
|
|
|
* Drivers using the probe helpers should use
|
|
|
|
* drm_helper_probe_single_connector_modes() or
|
|
|
|
* drm_helper_probe_single_connector_modes_nomerge() to implement this
|
|
|
|
* function.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
2017-01-25 06:26:45 +00:00
|
|
|
* The number of modes detected and filled into &drm_connector.modes.
|
2016-08-12 20:48:50 +00:00
|
|
|
*/
|
|
|
|
int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @set_property:
|
|
|
|
*
|
|
|
|
* This is the legacy entry point to update a property attached to the
|
|
|
|
* connector.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any legacy
|
2017-07-25 12:02:04 +00:00
|
|
|
* driver-private properties. For atomic drivers it is not used because
|
|
|
|
* property handling is done entirely in the DRM core.
|
2016-08-12 20:48:50 +00:00
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int (*set_property)(struct drm_connector *connector, struct drm_property *property,
|
|
|
|
uint64_t val);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @late_register:
|
|
|
|
*
|
|
|
|
* This optional hook can be used to register additional userspace
|
|
|
|
* interfaces attached to the connector, light backlight control, i2c,
|
|
|
|
* DP aux or similar interfaces. It is called late in the driver load
|
|
|
|
* sequence from drm_connector_register() when registering all the
|
|
|
|
* core drm connector interfaces. Everything added from this callback
|
|
|
|
* should be unregistered in the early_unregister callback.
|
|
|
|
*
|
2017-01-25 06:26:45 +00:00
|
|
|
* This is called while holding &drm_connector.mutex.
|
2016-12-18 13:35:45 +00:00
|
|
|
*
|
2016-08-12 20:48:50 +00:00
|
|
|
* Returns:
|
|
|
|
*
|
|
|
|
* 0 on success, or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int (*late_register)(struct drm_connector *connector);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @early_unregister:
|
|
|
|
*
|
|
|
|
* This optional hook should be used to unregister the additional
|
|
|
|
* userspace interfaces attached to the connector from
|
2016-10-09 17:07:00 +00:00
|
|
|
* late_register(). It is called from drm_connector_unregister(),
|
2016-08-12 20:48:50 +00:00
|
|
|
* early in the driver unload sequence to disable userspace access
|
|
|
|
* before data structures are torndown.
|
2016-12-18 13:35:45 +00:00
|
|
|
*
|
2017-01-25 06:26:45 +00:00
|
|
|
* This is called while holding &drm_connector.mutex.
|
2016-08-12 20:48:50 +00:00
|
|
|
*/
|
|
|
|
void (*early_unregister)(struct drm_connector *connector);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @destroy:
|
|
|
|
*
|
|
|
|
* Clean up connector resources. This is called at driver unload time
|
|
|
|
* through drm_mode_config_cleanup(). It can also be called at runtime
|
|
|
|
* when a connector is being hot-unplugged for drivers that support
|
|
|
|
* connector hotplugging (e.g. DisplayPort MST).
|
|
|
|
*/
|
|
|
|
void (*destroy)(struct drm_connector *connector);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_duplicate_state:
|
|
|
|
*
|
|
|
|
* Duplicate the current atomic state for this connector and return it.
|
2016-10-09 17:07:00 +00:00
|
|
|
* The core and helpers guarantee that any atomic state duplicated with
|
2016-08-12 20:48:50 +00:00
|
|
|
* this hook and still owned by the caller (i.e. not transferred to the
|
2017-01-25 06:26:45 +00:00
|
|
|
* driver by calling &drm_mode_config_funcs.atomic_commit) will be
|
|
|
|
* cleaned up by calling the @atomic_destroy_state hook in this
|
|
|
|
* structure.
|
2016-08-12 20:48:50 +00:00
|
|
|
*
|
2016-12-29 20:48:26 +00:00
|
|
|
* Atomic drivers which don't subclass &struct drm_connector_state should use
|
2016-08-12 20:48:50 +00:00
|
|
|
* drm_atomic_helper_connector_duplicate_state(). Drivers that subclass the
|
|
|
|
* state structure to extend it with driver-private state should use
|
|
|
|
* __drm_atomic_helper_connector_duplicate_state() to make sure shared state is
|
|
|
|
* duplicated in a consistent fashion across drivers.
|
|
|
|
*
|
2017-01-25 06:26:45 +00:00
|
|
|
* It is an error to call this hook before &drm_connector.state has been
|
2016-08-12 20:48:50 +00:00
|
|
|
* initialized correctly.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* If the duplicate state references refcounted resources this hook must
|
|
|
|
* acquire a reference for each of them. The driver must release these
|
|
|
|
* references again in @atomic_destroy_state.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* Duplicated atomic state or NULL when the allocation failed.
|
|
|
|
*/
|
|
|
|
struct drm_connector_state *(*atomic_duplicate_state)(struct drm_connector *connector);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_destroy_state:
|
|
|
|
*
|
|
|
|
* Destroy a state duplicated with @atomic_duplicate_state and release
|
|
|
|
* or unreference all resources it references
|
|
|
|
*/
|
|
|
|
void (*atomic_destroy_state)(struct drm_connector *connector,
|
|
|
|
struct drm_connector_state *state);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_set_property:
|
|
|
|
*
|
|
|
|
* Decode a driver-private property value and store the decoded value
|
|
|
|
* into the passed-in state structure. Since the atomic core decodes all
|
|
|
|
* standardized properties (even for extensions beyond the core set of
|
|
|
|
* properties which might not be implemented by all drivers) this
|
|
|
|
* requires drivers to subclass the state structure.
|
|
|
|
*
|
|
|
|
* Such driver-private properties should really only be implemented for
|
|
|
|
* truly hardware/vendor specific state. Instead it is preferred to
|
|
|
|
* standardize atomic extension and decode the properties used to expose
|
|
|
|
* such an extension in the core.
|
|
|
|
*
|
|
|
|
* Do not call this function directly, use
|
|
|
|
* drm_atomic_connector_set_property() instead.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any
|
|
|
|
* driver-private atomic properties.
|
|
|
|
*
|
|
|
|
* NOTE:
|
|
|
|
*
|
|
|
|
* This function is called in the state assembly phase of atomic
|
|
|
|
* modesets, which can be aborted for any reason (including on
|
|
|
|
* userspace's request to just check whether a configuration would be
|
|
|
|
* possible). Drivers MUST NOT touch any persistent state (hardware or
|
|
|
|
* software) or data structures except the passed in @state parameter.
|
|
|
|
*
|
|
|
|
* Also since userspace controls in which order properties are set this
|
|
|
|
* function must not do any input validation (since the state update is
|
|
|
|
* incomplete and hence likely inconsistent). Instead any such input
|
|
|
|
* validation must be done in the various atomic_check callbacks.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 if the property has been found, -EINVAL if the property isn't
|
|
|
|
* implemented by the driver (which shouldn't ever happen, the core only
|
|
|
|
* asks for properties attached to this connector). No other validation
|
|
|
|
* is allowed by the driver. The core already checks that the property
|
|
|
|
* value is within the range (integer, valid enum value, ...) the driver
|
|
|
|
* set when registering the property.
|
|
|
|
*/
|
|
|
|
int (*atomic_set_property)(struct drm_connector *connector,
|
|
|
|
struct drm_connector_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t val);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_get_property:
|
|
|
|
*
|
|
|
|
* Reads out the decoded driver-private property. This is used to
|
|
|
|
* implement the GETCONNECTOR IOCTL.
|
|
|
|
*
|
|
|
|
* Do not call this function directly, use
|
|
|
|
* drm_atomic_connector_get_property() instead.
|
|
|
|
*
|
|
|
|
* This callback is optional if the driver does not support any
|
|
|
|
* driver-private atomic properties.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
*
|
|
|
|
* 0 on success, -EINVAL if the property isn't implemented by the
|
|
|
|
* driver (which shouldn't ever happen, the core only asks for
|
|
|
|
* properties attached to this connector).
|
|
|
|
*/
|
|
|
|
int (*atomic_get_property)(struct drm_connector *connector,
|
|
|
|
const struct drm_connector_state *state,
|
|
|
|
struct drm_property *property,
|
|
|
|
uint64_t *val);
|
2016-11-05 15:08:09 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @atomic_print_state:
|
|
|
|
*
|
2016-12-29 20:48:26 +00:00
|
|
|
* If driver subclasses &struct drm_connector_state, it should implement
|
2016-11-05 15:08:09 +00:00
|
|
|
* this optional hook for printing additional driver specific state.
|
|
|
|
*
|
|
|
|
* Do not call this directly, use drm_atomic_connector_print_state()
|
|
|
|
* instead.
|
|
|
|
*/
|
|
|
|
void (*atomic_print_state)(struct drm_printer *p,
|
|
|
|
const struct drm_connector_state *state);
|
2016-08-12 20:48:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* mode specified on the command line */
|
|
|
|
struct drm_cmdline_mode {
|
|
|
|
bool specified;
|
|
|
|
bool refresh_specified;
|
|
|
|
bool bpp_specified;
|
|
|
|
int xres, yres;
|
|
|
|
int bpp;
|
|
|
|
int refresh;
|
|
|
|
bool rb;
|
|
|
|
bool interlace;
|
|
|
|
bool cvt;
|
|
|
|
bool margins;
|
|
|
|
enum drm_connector_force force;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct drm_connector - central DRM connector control structure
|
|
|
|
* @dev: parent DRM device
|
|
|
|
* @kdev: kernel device for sysfs attributes
|
|
|
|
* @attr: sysfs attributes
|
|
|
|
* @head: list management
|
|
|
|
* @base: base KMS object
|
|
|
|
* @name: human readable name, can be overwritten by the driver
|
|
|
|
* @connector_type: one of the DRM_MODE_CONNECTOR_<foo> types from drm_mode.h
|
|
|
|
* @connector_type_id: index into connector type enum
|
|
|
|
* @interlace_allowed: can this connector handle interlaced modes?
|
|
|
|
* @doublescan_allowed: can this connector handle doublescan?
|
|
|
|
* @stereo_allowed: can this connector handle stereo modes?
|
|
|
|
* @funcs: connector control functions
|
|
|
|
* @edid_blob_ptr: DRM property containing EDID if present
|
|
|
|
* @properties: property tracking for this connector
|
|
|
|
* @dpms: current dpms state
|
|
|
|
* @helper_private: mid-layer private data
|
|
|
|
* @cmdline_mode: mode line parsed from the kernel cmdline for this connector
|
|
|
|
* @force: a DRM_FORCE_<foo> state for forced mode sets
|
|
|
|
* @override_edid: has the EDID been overwritten through debugfs for testing?
|
|
|
|
* @encoder_ids: valid encoders for this connector
|
|
|
|
* @eld: EDID-like data, if present
|
|
|
|
* @latency_present: AV delay info from ELD, if found
|
|
|
|
* @video_latency: video latency info from ELD, if found
|
|
|
|
* @audio_latency: audio latency info from ELD, if found
|
|
|
|
* @null_edid_counter: track sinks that give us all zeros for the EDID
|
|
|
|
* @bad_edid_counter: track sinks that give us an EDID with invalid checksum
|
|
|
|
* @edid_corrupt: indicates whether the last read EDID was corrupt
|
|
|
|
* @debugfs_entry: debugfs directory for this connector
|
|
|
|
* @has_tile: is this connector connected to a tiled monitor
|
|
|
|
* @tile_group: tile group for the connected monitor
|
|
|
|
* @tile_is_single_monitor: whether the tile is one monitor housing
|
|
|
|
* @num_h_tile: number of horizontal tiles in the tile group
|
|
|
|
* @num_v_tile: number of vertical tiles in the tile group
|
|
|
|
* @tile_h_loc: horizontal location of this tile
|
|
|
|
* @tile_v_loc: vertical location of this tile
|
|
|
|
* @tile_h_size: horizontal size of this tile.
|
|
|
|
* @tile_v_size: vertical size of this tile.
|
2017-05-01 13:37:54 +00:00
|
|
|
* @scaling_mode_property: Optional atomic property to control the upscaling.
|
2018-01-08 19:55:37 +00:00
|
|
|
* @content_protection_property: Optional property to control content protection
|
2016-08-12 20:48:50 +00:00
|
|
|
*
|
|
|
|
* Each connector may be connected to one or more CRTCs, or may be clonable by
|
|
|
|
* another connector if they can share a CRTC. Each connector also has a specific
|
|
|
|
* position in the broader display (referred to as a 'screen' though it could
|
|
|
|
* span multiple monitors).
|
|
|
|
*/
|
|
|
|
struct drm_connector {
|
|
|
|
struct drm_device *dev;
|
|
|
|
struct device *kdev;
|
|
|
|
struct device_attribute *attr;
|
|
|
|
struct list_head head;
|
|
|
|
|
|
|
|
struct drm_mode_object base;
|
|
|
|
|
|
|
|
char *name;
|
|
|
|
|
2016-12-18 13:35:45 +00:00
|
|
|
/**
|
|
|
|
* @mutex: Lock for general connector state, but currently only protects
|
2017-01-25 06:26:45 +00:00
|
|
|
* @registered. Most of the connector state is still protected by
|
|
|
|
* &drm_mode_config.mutex.
|
2016-12-18 13:35:45 +00:00
|
|
|
*/
|
|
|
|
struct mutex mutex;
|
|
|
|
|
2016-08-12 20:48:50 +00:00
|
|
|
/**
|
|
|
|
* @index: Compacted connector index, which matches the position inside
|
|
|
|
* the mode_config.list for drivers not supporting hot-add/removing. Can
|
|
|
|
* be used as an array index. It is invariant over the lifetime of the
|
|
|
|
* connector.
|
|
|
|
*/
|
|
|
|
unsigned index;
|
|
|
|
|
|
|
|
int connector_type;
|
|
|
|
int connector_type_id;
|
|
|
|
bool interlace_allowed;
|
|
|
|
bool doublescan_allowed;
|
|
|
|
bool stereo_allowed;
|
2017-07-13 15:33:11 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @ycbcr_420_allowed : This bool indicates if this connector is
|
|
|
|
* capable of handling YCBCR 420 output. While parsing the EDID
|
|
|
|
* blocks, its very helpful to know, if the source is capable of
|
|
|
|
* handling YCBCR 420 outputs.
|
|
|
|
*/
|
|
|
|
bool ycbcr_420_allowed;
|
|
|
|
|
2016-12-18 13:35:45 +00:00
|
|
|
/**
|
|
|
|
* @registered: Is this connector exposed (registered) with userspace?
|
|
|
|
* Protected by @mutex.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
bool registered;
|
2016-12-13 23:08:10 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @modes:
|
|
|
|
* Modes available on this connector (from fill_modes() + user).
|
2017-01-25 06:26:45 +00:00
|
|
|
* Protected by &drm_mode_config.mutex.
|
2016-12-13 23:08:10 +00:00
|
|
|
*/
|
2017-01-25 06:26:45 +00:00
|
|
|
struct list_head modes;
|
2016-08-12 20:48:50 +00:00
|
|
|
|
2016-12-13 23:08:10 +00:00
|
|
|
/**
|
|
|
|
* @status:
|
|
|
|
* One of the drm_connector_status enums (connected, not, or unknown).
|
2017-01-25 06:26:45 +00:00
|
|
|
* Protected by &drm_mode_config.mutex.
|
2016-12-13 23:08:10 +00:00
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
enum drm_connector_status status;
|
|
|
|
|
2016-12-13 23:08:10 +00:00
|
|
|
/**
|
|
|
|
* @probed_modes:
|
|
|
|
* These are modes added by probing with DDC or the BIOS, before
|
2017-01-25 06:26:45 +00:00
|
|
|
* filtering is applied. Used by the probe helpers. Protected by
|
|
|
|
* &drm_mode_config.mutex.
|
2016-12-13 23:08:10 +00:00
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
struct list_head probed_modes;
|
|
|
|
|
2016-08-12 20:48:53 +00:00
|
|
|
/**
|
|
|
|
* @display_info: Display information is filled from EDID information
|
|
|
|
* when a display is detected. For non hot-pluggable displays such as
|
|
|
|
* flat panels in embedded systems, the driver should initialize the
|
2017-01-25 06:26:45 +00:00
|
|
|
* &drm_display_info.width_mm and &drm_display_info.height_mm fields
|
|
|
|
* with the physical size of the display.
|
2016-12-13 23:08:10 +00:00
|
|
|
*
|
2017-01-25 06:26:45 +00:00
|
|
|
* Protected by &drm_mode_config.mutex.
|
2016-08-12 20:48:53 +00:00
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
struct drm_display_info display_info;
|
|
|
|
const struct drm_connector_funcs *funcs;
|
|
|
|
|
|
|
|
struct drm_property_blob *edid_blob_ptr;
|
|
|
|
struct drm_object_properties properties;
|
|
|
|
|
2017-05-01 13:37:54 +00:00
|
|
|
struct drm_property *scaling_mode_property;
|
|
|
|
|
2018-01-08 19:55:37 +00:00
|
|
|
/**
|
|
|
|
* @content_protection_property: DRM ENUM property for content
|
|
|
|
* protection
|
|
|
|
*/
|
|
|
|
struct drm_property *content_protection_property;
|
|
|
|
|
2016-08-12 20:48:50 +00:00
|
|
|
/**
|
|
|
|
* @path_blob_ptr:
|
|
|
|
*
|
|
|
|
* DRM blob property data for the DP MST path property.
|
|
|
|
*/
|
|
|
|
struct drm_property_blob *path_blob_ptr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @tile_blob_ptr:
|
|
|
|
*
|
|
|
|
* DRM blob property data for the tile property (used mostly by DP MST).
|
|
|
|
* This is meant for screens which are driven through separate display
|
|
|
|
* pipelines represented by &drm_crtc, which might not be running with
|
|
|
|
* genlocked clocks. For tiled panels which are genlocked, like
|
|
|
|
* dual-link LVDS or dual-link DSI, the driver should try to not expose
|
|
|
|
* the tiling and virtualize both &drm_crtc and &drm_plane if needed.
|
|
|
|
*/
|
|
|
|
struct drm_property_blob *tile_blob_ptr;
|
|
|
|
|
|
|
|
/* should we poll this connector for connects and disconnects */
|
|
|
|
/* hot plug detectable */
|
|
|
|
#define DRM_CONNECTOR_POLL_HPD (1 << 0)
|
|
|
|
/* poll for connections */
|
|
|
|
#define DRM_CONNECTOR_POLL_CONNECT (1 << 1)
|
|
|
|
/* can cleanly poll for disconnections without flickering the screen */
|
|
|
|
/* DACs should rarely do this without a lot of testing */
|
|
|
|
#define DRM_CONNECTOR_POLL_DISCONNECT (1 << 2)
|
|
|
|
|
2016-08-12 20:48:53 +00:00
|
|
|
/**
|
|
|
|
* @polled:
|
|
|
|
*
|
|
|
|
* Connector polling mode, a combination of
|
|
|
|
*
|
|
|
|
* DRM_CONNECTOR_POLL_HPD
|
|
|
|
* The connector generates hotplug events and doesn't need to be
|
|
|
|
* periodically polled. The CONNECT and DISCONNECT flags must not
|
|
|
|
* be set together with the HPD flag.
|
|
|
|
*
|
|
|
|
* DRM_CONNECTOR_POLL_CONNECT
|
|
|
|
* Periodically poll the connector for connection.
|
|
|
|
*
|
|
|
|
* DRM_CONNECTOR_POLL_DISCONNECT
|
|
|
|
* Periodically poll the connector for disconnection.
|
|
|
|
*
|
|
|
|
* Set to 0 for connectors that don't support connection status
|
|
|
|
* discovery.
|
|
|
|
*/
|
|
|
|
uint8_t polled;
|
2016-08-12 20:48:50 +00:00
|
|
|
|
|
|
|
/* requested DPMS state */
|
|
|
|
int dpms;
|
|
|
|
|
|
|
|
const struct drm_connector_helper_funcs *helper_private;
|
|
|
|
|
|
|
|
/* forced on connector */
|
|
|
|
struct drm_cmdline_mode cmdline_mode;
|
|
|
|
enum drm_connector_force force;
|
|
|
|
bool override_edid;
|
|
|
|
|
|
|
|
#define DRM_CONNECTOR_MAX_ENCODER 3
|
|
|
|
uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
|
2017-11-08 20:30:07 +00:00
|
|
|
/**
|
|
|
|
* @encoder: Currently bound encoder driving this connector, if any.
|
|
|
|
* Only really meaningful for non-atomic drivers. Atomic drivers should
|
|
|
|
* instead look at &drm_connector_state.best_encoder, and in case they
|
|
|
|
* need the CRTC driving this output, &drm_connector_state.crtc.
|
|
|
|
*/
|
|
|
|
struct drm_encoder *encoder;
|
2016-08-12 20:48:50 +00:00
|
|
|
|
|
|
|
#define MAX_ELD_BYTES 128
|
|
|
|
/* EDID bits */
|
|
|
|
uint8_t eld[MAX_ELD_BYTES];
|
|
|
|
bool latency_present[2];
|
|
|
|
int video_latency[2]; /* [0]: progressive, [1]: interlaced */
|
|
|
|
int audio_latency[2];
|
|
|
|
int null_edid_counter; /* needed to workaround some HW bugs where we get all 0s */
|
|
|
|
unsigned bad_edid_counter;
|
|
|
|
|
|
|
|
/* Flag for raw EDID header corruption - used in Displayport
|
|
|
|
* compliance testing - * Displayport Link CTS Core 1.2 rev1.1 4.2.2.6
|
|
|
|
*/
|
|
|
|
bool edid_corrupt;
|
|
|
|
|
|
|
|
struct dentry *debugfs_entry;
|
|
|
|
|
2017-03-28 15:53:48 +00:00
|
|
|
/**
|
|
|
|
* @state:
|
|
|
|
*
|
|
|
|
* Current atomic state for this connector.
|
|
|
|
*
|
|
|
|
* This is protected by @drm_mode_config.connection_mutex. Note that
|
|
|
|
* nonblocking atomic commits access the current connector state without
|
|
|
|
* taking locks. Either by going through the &struct drm_atomic_state
|
2017-07-19 14:39:20 +00:00
|
|
|
* pointers, see for_each_oldnew_connector_in_state(),
|
2017-03-28 15:53:48 +00:00
|
|
|
* for_each_old_connector_in_state() and
|
|
|
|
* for_each_new_connector_in_state(). Or through careful ordering of
|
|
|
|
* atomic commit operations as implemented in the atomic helpers, see
|
|
|
|
* &struct drm_crtc_commit.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
struct drm_connector_state *state;
|
|
|
|
|
|
|
|
/* DisplayID bits */
|
|
|
|
bool has_tile;
|
|
|
|
struct drm_tile_group *tile_group;
|
|
|
|
bool tile_is_single_monitor;
|
|
|
|
|
|
|
|
uint8_t num_h_tile, num_v_tile;
|
|
|
|
uint8_t tile_h_loc, tile_v_loc;
|
|
|
|
uint16_t tile_h_size, tile_v_size;
|
2017-12-04 20:48:18 +00:00
|
|
|
|
|
|
|
/**
|
2017-12-13 12:49:36 +00:00
|
|
|
* @free_node:
|
2017-12-04 20:48:18 +00:00
|
|
|
*
|
2017-12-13 12:49:36 +00:00
|
|
|
* List used only by &drm_connector_iter to be able to clean up a
|
|
|
|
* connector from any context, in conjunction with
|
|
|
|
* &drm_mode_config.connector_free_work.
|
2017-12-04 20:48:18 +00:00
|
|
|
*/
|
2017-12-13 12:49:36 +00:00
|
|
|
struct llist_node free_node;
|
2016-08-12 20:48:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define obj_to_connector(x) container_of(x, struct drm_connector, base)
|
|
|
|
|
|
|
|
int drm_connector_init(struct drm_device *dev,
|
|
|
|
struct drm_connector *connector,
|
|
|
|
const struct drm_connector_funcs *funcs,
|
|
|
|
int connector_type);
|
|
|
|
int drm_connector_register(struct drm_connector *connector);
|
|
|
|
void drm_connector_unregister(struct drm_connector *connector);
|
|
|
|
int drm_mode_connector_attach_encoder(struct drm_connector *connector,
|
|
|
|
struct drm_encoder *encoder);
|
|
|
|
|
|
|
|
void drm_connector_cleanup(struct drm_connector *connector);
|
|
|
|
static inline unsigned drm_connector_index(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
return connector->index;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_lookup - lookup connector object
|
|
|
|
* @dev: DRM device
|
2017-11-08 23:35:04 +00:00
|
|
|
* @file_priv: drm file to check for lease against.
|
2016-08-12 20:48:50 +00:00
|
|
|
* @id: connector object id
|
|
|
|
*
|
|
|
|
* This function looks up the connector object specified by id
|
|
|
|
* add takes a reference to it.
|
|
|
|
*/
|
|
|
|
static inline struct drm_connector *drm_connector_lookup(struct drm_device *dev,
|
2017-03-15 06:25:07 +00:00
|
|
|
struct drm_file *file_priv,
|
2016-08-12 20:48:50 +00:00
|
|
|
uint32_t id)
|
|
|
|
{
|
|
|
|
struct drm_mode_object *mo;
|
2017-03-15 06:25:07 +00:00
|
|
|
mo = drm_mode_object_find(dev, file_priv, id, DRM_MODE_OBJECT_CONNECTOR);
|
2016-08-12 20:48:50 +00:00
|
|
|
return mo ? obj_to_connector(mo) : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-02-28 14:46:39 +00:00
|
|
|
* drm_connector_get - acquire a connector reference
|
|
|
|
* @connector: DRM connector
|
2016-08-12 20:48:50 +00:00
|
|
|
*
|
|
|
|
* This function increments the connector's refcount.
|
|
|
|
*/
|
2017-02-28 14:46:39 +00:00
|
|
|
static inline void drm_connector_get(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
drm_mode_object_get(&connector->base);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_put - release a connector reference
|
|
|
|
* @connector: DRM connector
|
|
|
|
*
|
|
|
|
* This function decrements the connector's reference count and frees the
|
|
|
|
* object if the reference count drops to zero.
|
|
|
|
*/
|
|
|
|
static inline void drm_connector_put(struct drm_connector *connector)
|
|
|
|
{
|
|
|
|
drm_mode_object_put(&connector->base);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_connector_reference - acquire a connector reference
|
|
|
|
* @connector: DRM connector
|
|
|
|
*
|
|
|
|
* This is a compatibility alias for drm_connector_get() and should not be
|
|
|
|
* used by new code.
|
|
|
|
*/
|
2016-08-12 20:48:50 +00:00
|
|
|
static inline void drm_connector_reference(struct drm_connector *connector)
|
|
|
|
{
|
2017-02-28 14:46:39 +00:00
|
|
|
drm_connector_get(connector);
|
2016-08-12 20:48:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-02-28 14:46:39 +00:00
|
|
|
* drm_connector_unreference - release a connector reference
|
|
|
|
* @connector: DRM connector
|
2016-08-12 20:48:50 +00:00
|
|
|
*
|
2017-02-28 14:46:39 +00:00
|
|
|
* This is a compatibility alias for drm_connector_put() and should not be
|
|
|
|
* used by new code.
|
2016-08-12 20:48:50 +00:00
|
|
|
*/
|
|
|
|
static inline void drm_connector_unreference(struct drm_connector *connector)
|
|
|
|
{
|
2017-02-28 14:46:39 +00:00
|
|
|
drm_connector_put(connector);
|
2016-08-12 20:48:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const char *drm_get_connector_status_name(enum drm_connector_status status);
|
|
|
|
const char *drm_get_subpixel_order_name(enum subpixel_order order);
|
|
|
|
const char *drm_get_dpms_name(int val);
|
|
|
|
const char *drm_get_dvi_i_subconnector_name(int val);
|
|
|
|
const char *drm_get_dvi_i_select_name(int val);
|
|
|
|
const char *drm_get_tv_subconnector_name(int val);
|
|
|
|
const char *drm_get_tv_select_name(int val);
|
2018-01-08 19:55:37 +00:00
|
|
|
const char *drm_get_content_protection_name(int val);
|
2016-08-12 20:48:50 +00:00
|
|
|
|
|
|
|
int drm_mode_create_dvi_i_properties(struct drm_device *dev);
|
|
|
|
int drm_mode_create_tv_properties(struct drm_device *dev,
|
|
|
|
unsigned int num_modes,
|
|
|
|
const char * const modes[]);
|
|
|
|
int drm_mode_create_scaling_mode_property(struct drm_device *dev);
|
2017-05-01 13:37:54 +00:00
|
|
|
int drm_connector_attach_scaling_mode_property(struct drm_connector *connector,
|
|
|
|
u32 scaling_mode_mask);
|
2018-01-08 19:55:37 +00:00
|
|
|
int drm_connector_attach_content_protection_property(
|
|
|
|
struct drm_connector *connector);
|
2016-08-12 20:48:50 +00:00
|
|
|
int drm_mode_create_aspect_ratio_property(struct drm_device *dev);
|
|
|
|
int drm_mode_create_suggested_offset_properties(struct drm_device *dev);
|
|
|
|
|
|
|
|
int drm_mode_connector_set_path_property(struct drm_connector *connector,
|
|
|
|
const char *path);
|
|
|
|
int drm_mode_connector_set_tile_property(struct drm_connector *connector);
|
|
|
|
int drm_mode_connector_update_edid_property(struct drm_connector *connector,
|
|
|
|
const struct edid *edid);
|
drm: Add a new connector atomic property for link status
At the time userspace does setcrtc, we've already promised the mode
would work. The promise is based on the theoretical capabilities of
the link, but it's possible we can't reach this in practice. The DP
spec describes how the link should be reduced, but we can't reduce
the link below the requirements of the mode. Black screen follows.
One idea would be to have setcrtc return a failure. However, it
already should not fail as the atomic checks have passed. It would
also conflict with the idea of making setcrtc asynchronous in the
future, returning before the actual mode setting and link training.
Another idea is to train the link "upfront" at hotplug time, before
pruning the mode list, so that we can do the pruning based on
practical not theoretical capabilities. However, the changes for link
training are pretty drastic, all for the sake of error handling and
DP compliance, when the most common happy day scenario is the current
approach of link training at mode setting time, using the optimal
parameters for the mode. It is also not certain all hardware could do
this without the pipe on; not even all our hardware can do this. Some
of this can be solved, but not trivially.
Both of the above ideas also fail to address link degradation *during*
operation.
The solution is to add a new "link-status" connector property in order
to address link training failure in a way that:
a) changes the current happy day scenario as little as possible, to
avoid regressions, b) can be implemented the same way by all drm
drivers, c) is still opt-in for the drivers and userspace, and opting
out doesn't regress the user experience, d) doesn't prevent drivers
from implementing better or alternate approaches, possibly without
userspace involvement. And, of course, handles all the issues presented.
In the usual happy day scenario, this is always "good". If something
fails during or after a mode set, the kernel driver can set the link
status to "bad" and issue a hotplug uevent for userspace to have it
re-check the valid modes through GET_CONNECTOR IOCTL, and try modeset
again. If the theoretical capabilities of the link can't be reached,
the mode list is trimmed based on that.
v7 by Jani:
* Rebase, simplify set property while at it, checkpatch fix
v6:
* Fix a typo in kernel doc (Sean Paul)
v5:
* Clarify doc for silent rejection of atomic properties by driver (Daniel Vetter)
v4:
* Add comments in kernel-doc format (Daniel Vetter)
* Update the kernel-doc for link-status (Sean Paul)
v3:
* Fixed a build error (Jani Saarinen)
v2:
* Removed connector->link_status (Daniel Vetter)
* Set connector->state->link_status in drm_mode_connector_set_link_status_property
(Daniel Vetter)
* Set the connector_changed flag to true if connector->state->link_status changed.
* Reset link_status to GOOD in update_output_state (Daniel Vetter)
* Never allow userspace to set link status from Good To Bad (Daniel Vetter)
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Tony Cheng <tony.cheng@amd.com>
Acked-by: Harry Wentland <harry.wentland@amd.com>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Daniel Vetter <daniel.vetter@intel.com>
Cc: Ville Syrjala <ville.syrjala@linux.intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Manasi Navare <manasi.d.navare@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
Acked-by: Eric Anholt <eric@anholt.net> (for the -modesetting patch)
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: http://patchwork.freedesktop.org/patch/msgid/0182487051aa9f1594820e35a4853de2f8747b4e.1481883920.git.jani.nikula@intel.com
2016-12-16 10:29:06 +00:00
|
|
|
void drm_mode_connector_set_link_status_property(struct drm_connector *connector,
|
|
|
|
uint64_t link_status);
|
2017-11-25 19:35:49 +00:00
|
|
|
int drm_connector_init_panel_orientation_property(
|
|
|
|
struct drm_connector *connector, int width, int height);
|
2016-08-31 16:09:04 +00:00
|
|
|
|
2016-11-14 11:58:24 +00:00
|
|
|
/**
|
|
|
|
* struct drm_tile_group - Tile group metadata
|
|
|
|
* @refcount: reference count
|
|
|
|
* @dev: DRM device
|
|
|
|
* @id: tile group id exposed to userspace
|
|
|
|
* @group_data: Sink-private data identifying this group
|
|
|
|
*
|
|
|
|
* @group_data corresponds to displayid vend/prod/serial for external screens
|
|
|
|
* with an EDID.
|
|
|
|
*/
|
|
|
|
struct drm_tile_group {
|
|
|
|
struct kref refcount;
|
|
|
|
struct drm_device *dev;
|
|
|
|
int id;
|
|
|
|
u8 group_data[8];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct drm_tile_group *drm_mode_create_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8]);
|
|
|
|
struct drm_tile_group *drm_mode_get_tile_group(struct drm_device *dev,
|
|
|
|
char topology[8]);
|
|
|
|
void drm_mode_put_tile_group(struct drm_device *dev,
|
|
|
|
struct drm_tile_group *tg);
|
|
|
|
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 23:08:06 +00:00
|
|
|
/**
|
|
|
|
* struct drm_connector_list_iter - connector_list iterator
|
|
|
|
*
|
|
|
|
* This iterator tracks state needed to be able to walk the connector_list
|
|
|
|
* within struct drm_mode_config. Only use together with
|
2017-02-28 14:46:43 +00:00
|
|
|
* drm_connector_list_iter_begin(), drm_connector_list_iter_end() and
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 23:08:06 +00:00
|
|
|
* drm_connector_list_iter_next() respectively the convenience macro
|
|
|
|
* drm_for_each_connector_iter().
|
|
|
|
*/
|
|
|
|
struct drm_connector_list_iter {
|
|
|
|
/* private: */
|
|
|
|
struct drm_device *dev;
|
|
|
|
struct drm_connector *conn;
|
|
|
|
};
|
|
|
|
|
2017-02-28 14:46:43 +00:00
|
|
|
void drm_connector_list_iter_begin(struct drm_device *dev,
|
|
|
|
struct drm_connector_list_iter *iter);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 23:08:06 +00:00
|
|
|
struct drm_connector *
|
|
|
|
drm_connector_list_iter_next(struct drm_connector_list_iter *iter);
|
2017-02-28 14:46:43 +00:00
|
|
|
void drm_connector_list_iter_end(struct drm_connector_list_iter *iter);
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 23:08:06 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* drm_for_each_connector_iter - connector_list iterator macro
|
2016-12-29 20:48:26 +00:00
|
|
|
* @connector: &struct drm_connector pointer used as cursor
|
|
|
|
* @iter: &struct drm_connector_list_iter
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 23:08:06 +00:00
|
|
|
*
|
|
|
|
* Note that @connector is only valid within the list body, if you want to use
|
2017-02-28 14:46:43 +00:00
|
|
|
* @connector after calling drm_connector_list_iter_end() then you need to grab
|
2017-04-21 00:38:19 +00:00
|
|
|
* your own reference first using drm_connector_get().
|
drm: locking&new iterators for connector_list
The requirements for connector_list locking are a bit tricky:
- We need to be able to jump over zombie conectors (i.e. with refcount
== 0, but not yet removed from the list). If instead we require that
there's no zombies on the list then the final kref_put must happen
under the list protection lock, which means that locking context
leaks all over the place. Not pretty - better to deal with zombies
and wrap the locking just around the list_del in the destructor.
- When we walk the list we must _not_ hold the connector list lock. We
walk the connector list at an absolutely massive amounts of places,
if all those places can't ever call drm_connector_unreference the
code would get unecessarily complicated.
- connector_list needs it own lock, again too many places that walk it
that we could reuse e.g. mode_config.mutex without resulting in
inversions.
- Lots of code uses these loops to look-up a connector, i.e. they want
to be able to call drm_connector_reference. But on the other hand we
want connectors to stay on that list until they're dead (i.e.
connector_list can't hold a full reference), which means despite the
"can't hold lock for the loop body" rule we need to make sure a
connector doesn't suddenly become a zombie.
At first Dave&I discussed various horror-show approaches using srcu,
but turns out it's fairly easy:
- For the loop body we always hold an additional reference to the
current connector. That means it can't zombify, and it also means
it'll stay on the list, which means we can use it as our iterator to
find the next connector.
- When we try to find the next connector we only have to jump over
zombies. To make sure we don't chase bad pointers that entire loop
is protected with the new connect_list_lock spinlock. And because we
know that we're starting out with a non-zombie (need to drop our
reference for the old connector only after we have our new one),
we're guranteed to still be on the connector_list and either find
the next non-zombie or complete the iteration.
- Only downside is that we need to make sure that the temporary
reference for the loop body doesn't leak. iter_get/put() functions +
lockdep make sure that's the case.
- To avoid a flag day the new iterator macro has an _iter postfix. We
can rename it back once all the users of the unsafe version are gone
(there's about 100 list walkers for the connector_list).
For now this patch only converts all the list walking in the core,
leaving helpers and drivers for later patches. The nice thing is that
we can now finally remove 2 FIXME comments from the
register/unregister functions.
v2:
- use irqsafe spinlocks, so that we can use this in drm_state_dump
too.
- nuke drm_modeset_lock_all from drm_connector_init, now entirely
cargo-culted nonsense.
v3:
- do {} while (!kref_get_unless_zero), makes for a tidier loop (Dave).
- pretty kerneldoc
- add EXPORT_SYMBOL, helpers&drivers are supposed to use this.
v4: Change lockdep annotations to only check whether we release the
iter fake lock again (i.e. make sure that iter_put is called), but
not check any locking dependecies itself. That seams to require a
recursive read lock in trylock mode.
Cc: Dave Airlie <airlied@gmail.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Chris Wilson <chris@chris-wilson.co.uk>
Reviewed-by: Sean Paul <seanpaul@chromium.org>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Link: http://patchwork.freedesktop.org/patch/msgid/20161213230814.19598-6-daniel.vetter@ffwll.ch
2016-12-13 23:08:06 +00:00
|
|
|
*/
|
|
|
|
#define drm_for_each_connector_iter(connector, iter) \
|
|
|
|
while ((connector = drm_connector_list_iter_next(iter)))
|
|
|
|
|
2016-08-12 20:48:50 +00:00
|
|
|
#endif
|