Mode Setting Helper Functions¶
The DRM subsystem aims for a strong separation between core code and helper libraries. Core code takes care of general setup and teardown and decoding userspace requests to kernel internal objects. Everything else is handled by a large set of helper libraries, which can be combined freely to pick and choose for each driver what fits, and avoid shared code where special behaviour is needed.
This distinction between core code and helpers is especially strong in the modesetting code, where there’s a shared userspace ABI for all drivers. This is in contrast to the render side, where pretty much everything (with very few exceptions) can be considered optional helper code.
There are a few areas these helpers can grouped into:
- Helpers to implement modesetting. The important ones here are the atomic helpers. Old drivers still often use the legacy CRTC helpers. They both share the same set of common helper vtables. For really simple drivers (anything that would have been a great fit in the deprecated fbdev subsystem) there’s also the simple display pipe helpers.
- There’s a big pile of helpers for handling outputs. First the generic bridge helpers for handling encoder and transcoder IP blocks. Second the panel helpers for handling panel-related information and logic. Plus then a big set of helpers for the various sink standards (DisplayPort, HDMI, MIPI DSI). Finally there’s also generic helpers for handling output probing, and for dealing with EDIDs.
- The last group of helpers concerns itself with the frontend side of a display pipeline: Planes, handling rectangles for visibility checking and scissoring, flip queues and assorted bits.
Modeset Helper Reference for Common Vtables¶
The DRM mode setting helper functions are common code for drivers to use if they wish. Drivers are not forced to use this code in their implementations but it would be useful if the code they do use at least provides a consistent interface and operation to userspace. Therefore it is highly recommended to use the provided helpers as much as possible.
Because there is only one pointer per modeset object to hold a vfunc table for helper libraries they are by necessity shared among the different helpers.
To make this clear all the helper vtables are pulled together in this location here.
-
struct
drm_crtc_helper_funcs
¶ helper operations for CRTCs
Definition
struct drm_crtc_helper_funcs {
void (*dpms)(struct drm_crtc *crtc, int mode);
void (*prepare)(struct drm_crtc *crtc);
void (*commit)(struct drm_crtc *crtc);
enum drm_mode_status (*mode_valid)(struct drm_crtc *crtc, const struct drm_display_mode *mode);
bool (*mode_fixup)(struct drm_crtc *crtc,const struct drm_display_mode *mode, struct drm_display_mode *adjusted_mode);
int (*mode_set)(struct drm_crtc *crtc, struct drm_display_mode *mode,struct drm_display_mode *adjusted_mode, int x, int y, struct drm_framebuffer *old_fb);
void (*mode_set_nofb)(struct drm_crtc *crtc);
int (*mode_set_base)(struct drm_crtc *crtc, int x, int y, struct drm_framebuffer *old_fb);
int (*mode_set_base_atomic)(struct drm_crtc *crtc,struct drm_framebuffer *fb, int x, int y, enum mode_set_atomic);
void (*disable)(struct drm_crtc *crtc);
int (*atomic_check)(struct drm_crtc *crtc, struct drm_atomic_state *state);
void (*atomic_begin)(struct drm_crtc *crtc, struct drm_atomic_state *state);
void (*atomic_flush)(struct drm_crtc *crtc, struct drm_atomic_state *state);
void (*atomic_enable)(struct drm_crtc *crtc, struct drm_atomic_state *state);
void (*atomic_disable)(struct drm_crtc *crtc, struct drm_atomic_state *state);
bool (*get_scanout_position)(struct drm_crtc *crtc,bool in_vblank_irq, int *vpos, int *hpos,ktime_t *stime, ktime_t *etime, const struct drm_display_mode *mode);
};
Members
dpms
Callback to control power levels on the CRTC. If the mode passed in is unsupported, the provider must use the next lowest power level. This is used by the legacy CRTC helpers to implement DPMS functionality in
drm_helper_connector_dpms()
.This callback is also used to disable a CRTC by calling it with DRM_MODE_DPMS_OFF if the disable hook isn’t used.
This callback is used by the legacy CRTC helpers. Atomic helpers also support using this hook for enabling and disabling a CRTC to facilitate transitions to atomic, but it is deprecated. Instead atomic_enable and atomic_disable should be used.
prepare
This callback should prepare the CRTC for a subsequent modeset, which in practice means the driver should disable the CRTC if it is running. Most drivers ended up implementing this by calling their dpms hook with DRM_MODE_DPMS_OFF.
This callback is used by the legacy CRTC helpers. Atomic helpers also support using this hook for disabling a CRTC to facilitate transitions to atomic, but it is deprecated. Instead atomic_disable should be used.
commit
This callback should commit the new mode on the CRTC after a modeset, which in practice means the driver should enable the CRTC. Most drivers ended up implementing this by calling their dpms hook with DRM_MODE_DPMS_ON.
This callback is used by the legacy CRTC helpers. Atomic helpers also support using this hook for enabling a CRTC to facilitate transitions to atomic, but it is deprecated. Instead atomic_enable should be used.
mode_valid
This callback is used to check if a specific mode is valid in this crtc. This should be implemented if the crtc has some sort of restriction in the modes it can display. For example, a given crtc may be responsible to set a clock value. If the clock can not produce all the values for the available modes then this callback can be used to restrict the number of modes to only the ones that can be displayed.
This hook is used by the probe helpers to filter the mode list in
drm_helper_probe_single_connector_modes()
, and it is used by the atomic helpers to validate modes supplied by userspace indrm_atomic_helper_check_modeset()
.This function is optional.
NOTE:
Since this function is both called from the check phase of an atomic commit, and the mode validation in the probe paths it is not allowed to look at anything else but the passed-in mode, and validate it against configuration-invariant hardward constraints. Any further limits which depend upon the configuration can only be checked in mode_fixup or atomic_check.
RETURNS:
drm_mode_status Enum
mode_fixup
This callback is used to validate a mode. The parameter mode is the display mode that userspace requested, adjusted_mode is the mode the encoders need to be fed with. Note that this is the inverse semantics of the meaning for the
drm_encoder
anddrm_bridge_funcs.mode_fixup
vfunc. If the CRTC cannot support the requested conversion from mode to adjusted_mode it should reject the modeset. See alsodrm_crtc_state.adjusted_mode
for more details.This function is used by both legacy CRTC helpers and atomic helpers. With atomic helpers it is optional.
NOTE:
This function is called in the check 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). Atomic drivers MUST NOT touch any persistent state (hardware or software) or data structures except the passed in adjusted_mode parameter.
This is in contrast to the legacy CRTC helpers where this was allowed.
Atomic drivers which need to inspect and adjust more state should instead use the atomic_check callback, but note that they’re not perfectly equivalent: mode_valid is called from
drm_atomic_helper_check_modeset()
, but atomic_check is called fromdrm_atomic_helper_check_planes()
, because originally it was meant for plane update checks only.Also beware that userspace can request its own custom modes, neither core nor helpers filter modes to the list of probe modes reported by the GETCONNECTOR IOCTL and stored in
drm_connector.modes
. To ensure that modes are filtered consistently put any CRTC constraints and limits checks into mode_valid.RETURNS:
True if an acceptable configuration is possible, false if the modeset operation should be rejected.
mode_set
This callback is used by the legacy CRTC helpers to set a new mode, position and framebuffer. Since it ties the primary plane to every mode change it is incompatible with universal plane support. And since it can’t update other planes it’s incompatible with atomic modeset support.
This callback is only used by CRTC helpers and deprecated.
RETURNS:
0 on success or a negative error code on failure.
mode_set_nofb
This callback is used to update the display mode of a CRTC without changing anything of the primary plane configuration. This fits the requirement of atomic and hence is used by the atomic helpers. It is also used by the transitional plane helpers to implement a mode_set hook in
drm_helper_crtc_mode_set()
.Note that the display pipe is completely off when this function is called. Atomic drivers which need hardware to be running before they program the new display mode (e.g. because they implement runtime PM) should not use this hook. This is because the helper library calls this hook only once per mode change and not every time the display pipeline is suspended using either DPMS or the new “ACTIVE” property. Which means register values set in this callback might get reset when the CRTC is suspended, but not restored. Such drivers should instead move all their CRTC setup into the atomic_enable callback.
This callback is optional.
mode_set_base
This callback is used by the legacy CRTC helpers to set a new framebuffer and scanout position. It is optional and used as an optimized fast-path instead of a full mode set operation with all the resulting flickering. If it is not present
drm_crtc_helper_set_config()
will fall back to a full modeset, using the mode_set callback. Since it can’t update other planes it’s incompatible with atomic modeset support.This callback is only used by the CRTC helpers and deprecated.
RETURNS:
0 on success or a negative error code on failure.
mode_set_base_atomic
This callback is used by the fbdev helpers to set a new framebuffer and scanout without sleeping, i.e. from an atomic calling context. It is only used to implement kgdb support.
This callback is optional and only needed for kgdb support in the fbdev helpers.
RETURNS:
0 on success or a negative error code on failure.
disable
This callback should be used to disable the CRTC. With the atomic drivers it is called after all encoders connected to this CRTC have been shut off already using their own
drm_encoder_helper_funcs.disable
hook. If that sequence is too simple drivers can just add their own hooks and call it from this CRTC callback here by looping over all encoders connected to it usingfor_each_encoder_on_crtc()
.This hook is used both by legacy CRTC helpers and atomic helpers. Atomic drivers don’t need to implement it if there’s no need to disable anything at the CRTC level. To ensure that runtime PM handling (using either DPMS or the new “ACTIVE” property) works disable must be the inverse of atomic_enable for atomic drivers. Atomic drivers should consider to use atomic_disable instead of this one.
NOTE:
With legacy CRTC helpers there’s a big semantic difference between disable and other hooks (like prepare or dpms) used to shut down a CRTC: disable is only called when also logically disabling the display pipeline and needs to release any resources acquired in mode_set (like shared PLLs, or again release pinned framebuffers).
Therefore disable must be the inverse of mode_set plus commit for drivers still using legacy CRTC helpers, which is different from the rules under atomic.
atomic_check
Drivers should check plane-update related CRTC constraints in this hook. They can also check mode related limitations but need to be aware of the calling order, since this hook is used by
drm_atomic_helper_check_planes()
whereas the preparations needed to check output routing and the display mode is done indrm_atomic_helper_check_modeset()
. Therefore drivers that want to check output routing and display mode constraints in this callback must ensure thatdrm_atomic_helper_check_modeset()
has been called beforehand. This is calling order used by the default helper implementation indrm_atomic_helper_check()
.When using
drm_atomic_helper_check_planes()
this hook is called after thedrm_plane_helper_funcs.atomic_check
hook for planes, which allows drivers to assign shared resources requested by planes in this callback here. For more complicated dependencies the driver can call the provided check helpers multiple times until the computed state has a final configuration and everything has been checked.This function is also allowed to inspect any other object’s state and can add more state objects to the atomic commit if needed. Care must be taken though to ensure that state check and compute functions for these added states are all called, and derived state in other objects all updated. Again the recommendation is to just call check helpers until a maximal configuration is reached.
This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
NOTE:
This function is called in the check phase of an atomic update. The driver is not allowed to change anything outside of the free-standing state object passed-in.
Also beware that userspace can request its own custom modes, neither core nor helpers filter modes to the list of probe modes reported by the GETCONNECTOR IOCTL and stored in
drm_connector.modes
. To ensure that modes are filtered consistently put any CRTC constraints and limits checks into mode_valid.RETURNS:
0 on success, -EINVAL if the state or the transition can’t be supported, -ENOMEM on memory allocation failure and -EDEADLK if an attempt to obtain another state object ran into a
drm_modeset_lock
deadlock.atomic_begin
Drivers should prepare for an atomic update of multiple planes on a CRTC in this hook. Depending upon hardware this might be vblank evasion, blocking updates by setting bits or doing preparatory work for e.g. manual update display.
This hook is called before any plane commit functions are called.
Note that the power state of the display pipe when this function is called depends upon the exact helpers and calling sequence the driver has picked. See
drm_atomic_helper_commit_planes()
for a discussion of the tradeoffs and variants of plane commit helpers.This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
atomic_flush
Drivers should finalize an atomic update of multiple planes on a CRTC in this hook. Depending upon hardware this might include checking that vblank evasion was successful, unblocking updates by setting bits or setting the GO bit to flush out all updates.
Simple hardware or hardware with special requirements can commit and flush out all updates for all planes from this hook and forgo all the other commit hooks for plane updates.
This hook is called after any plane commit functions are called.
Note that the power state of the display pipe when this function is called depends upon the exact helpers and calling sequence the driver has picked. See
drm_atomic_helper_commit_planes()
for a discussion of the tradeoffs and variants of plane commit helpers.This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
atomic_enable
This callback should be used to enable the CRTC. With the atomic drivers it is called before all encoders connected to this CRTC are enabled through the encoder’s own
drm_encoder_helper_funcs.enable
hook. If that sequence is too simple drivers can just add their own hooks and call it from this CRTC callback here by looping over all encoders connected to it usingfor_each_encoder_on_crtc()
.This hook is used only by atomic helpers, for symmetry with atomic_disable. Atomic drivers don’t need to implement it if there’s no need to enable anything at the CRTC level. To ensure that runtime PM handling (using either DPMS or the new “ACTIVE” property) works atomic_enable must be the inverse of atomic_disable for atomic drivers.
This function is optional.
atomic_disable
This callback should be used to disable the CRTC. With the atomic drivers it is called after all encoders connected to this CRTC have been shut off already using their own
drm_encoder_helper_funcs.disable
hook. If that sequence is too simple drivers can just add their own hooks and call it from this CRTC callback here by looping over all encoders connected to it usingfor_each_encoder_on_crtc()
.This hook is used only by atomic helpers. Atomic drivers don’t need to implement it if there’s no need to disable anything at the CRTC level.
This function is optional.
get_scanout_position
Called by vblank timestamping code.
Returns the current display scanout position from a CRTC and an optional accurate
ktime_get()
timestamp of when the position was measured. Note that this is a helper callback which is only used if a driver usesdrm_crtc_vblank_helper_get_vblank_timestamp()
for the drm_crtc_funcs.get_vblank_timestamp callback.Parameters:
- crtc:
- The CRTC.
- in_vblank_irq:
- True when called from
drm_crtc_handle_vblank()
. Some drivers need to apply some workarounds for gpu-specific vblank irq quirks if the flag is set. - vpos:
- Target location for current vertical scanout position.
- hpos:
- Target location for current horizontal scanout position.
- stime:
- Target location for timestamp taken immediately before scanout position query. Can be NULL to skip timestamp.
- etime:
- Target location for timestamp taken immediately after scanout position query. Can be NULL to skip timestamp.
- mode:
- Current display timings.
Returns vpos as a positive number while in active scanout area. Returns vpos as a negative number inside vblank, counting the number of scanlines to go until end of vblank, e.g., -1 means “one scanline until start of active scanout / end of vblank.”
Returns:
True on success, false if a reliable scanout position counter could not be read out.
Description
These hooks are used by the legacy CRTC helpers, the transitional plane helpers and the new atomic modesetting helpers.
-
void
drm_crtc_helper_add
(struct drm_crtc * crtc, const struct drm_crtc_helper_funcs * funcs)¶ sets the helper vtable for a crtc
Parameters
struct drm_crtc * crtc
- DRM CRTC
const struct drm_crtc_helper_funcs * funcs
- helper vtable to set for crtc
-
struct
drm_encoder_helper_funcs
¶ helper operations for encoders
Definition
struct drm_encoder_helper_funcs {
void (*dpms)(struct drm_encoder *encoder, int mode);
enum drm_mode_status (*mode_valid)(struct drm_encoder *crtc, const struct drm_display_mode *mode);
bool (*mode_fixup)(struct drm_encoder *encoder,const struct drm_display_mode *mode, struct drm_display_mode *adjusted_mode);
void (*prepare)(struct drm_encoder *encoder);
void (*commit)(struct drm_encoder *encoder);
void (*mode_set)(struct drm_encoder *encoder,struct drm_display_mode *mode, struct drm_display_mode *adjusted_mode);
void (*atomic_mode_set)(struct drm_encoder *encoder,struct drm_crtc_state *crtc_state, struct drm_connector_state *conn_state);
enum drm_connector_status (*detect)(struct drm_encoder *encoder, struct drm_connector *connector);
void (*atomic_disable)(struct drm_encoder *encoder, struct drm_atomic_state *state);
void (*atomic_enable)(struct drm_encoder *encoder, struct drm_atomic_state *state);
void (*disable)(struct drm_encoder *encoder);
void (*enable)(struct drm_encoder *encoder);
int (*atomic_check)(struct drm_encoder *encoder,struct drm_crtc_state *crtc_state, struct drm_connector_state *conn_state);
};
Members
dpms
Callback to control power levels on the encoder. If the mode passed in is unsupported, the provider must use the next lowest power level. This is used by the legacy encoder helpers to implement DPMS functionality in
drm_helper_connector_dpms()
.This callback is also used to disable an encoder by calling it with DRM_MODE_DPMS_OFF if the disable hook isn’t used.
This callback is used by the legacy CRTC helpers. Atomic helpers also support using this hook for enabling and disabling an encoder to facilitate transitions to atomic, but it is deprecated. Instead enable and disable should be used.
mode_valid
This callback is used to check if a specific mode is valid in this encoder. This should be implemented if the encoder has some sort of restriction in the modes it can display. For example, a given encoder may be responsible to set a clock value. If the clock can not produce all the values for the available modes then this callback can be used to restrict the number of modes to only the ones that can be displayed.
This hook is used by the probe helpers to filter the mode list in
drm_helper_probe_single_connector_modes()
, and it is used by the atomic helpers to validate modes supplied by userspace indrm_atomic_helper_check_modeset()
.This function is optional.
NOTE:
Since this function is both called from the check phase of an atomic commit, and the mode validation in the probe paths it is not allowed to look at anything else but the passed-in mode, and validate it against configuration-invariant hardward constraints. Any further limits which depend upon the configuration can only be checked in mode_fixup or atomic_check.
RETURNS:
drm_mode_status Enum
mode_fixup
This callback is used to validate and adjust a mode. The parameter mode is the display mode that should be fed to the next element in the display chain, either the final
drm_connector
or adrm_bridge
. The parameter adjusted_mode is the input mode the encoder requires. It can be modified by this callback and does not need to match mode. See alsodrm_crtc_state.adjusted_mode
for more details.This function is used by both legacy CRTC helpers and atomic helpers. This hook is optional.
NOTE:
This function is called in the check 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). Atomic drivers MUST NOT touch any persistent state (hardware or software) or data structures except the passed in adjusted_mode parameter.
This is in contrast to the legacy CRTC helpers where this was allowed.
Atomic drivers which need to inspect and adjust more state should instead use the atomic_check callback. If atomic_check is used, this hook isn’t called since atomic_check allows a strict superset of the functionality of mode_fixup.
Also beware that userspace can request its own custom modes, neither core nor helpers filter modes to the list of probe modes reported by the GETCONNECTOR IOCTL and stored in
drm_connector.modes
. To ensure that modes are filtered consistently put any encoder constraints and limits checks into mode_valid.RETURNS:
True if an acceptable configuration is possible, false if the modeset operation should be rejected.
prepare
This callback should prepare the encoder for a subsequent modeset, which in practice means the driver should disable the encoder if it is running. Most drivers ended up implementing this by calling their dpms hook with DRM_MODE_DPMS_OFF.
This callback is used by the legacy CRTC helpers. Atomic helpers also support using this hook for disabling an encoder to facilitate transitions to atomic, but it is deprecated. Instead disable should be used.
commit
This callback should commit the new mode on the encoder after a modeset, which in practice means the driver should enable the encoder. Most drivers ended up implementing this by calling their dpms hook with DRM_MODE_DPMS_ON.
This callback is used by the legacy CRTC helpers. Atomic helpers also support using this hook for enabling an encoder to facilitate transitions to atomic, but it is deprecated. Instead enable should be used.
mode_set
This callback is used to update the display mode of an encoder.
Note that the display pipe is completely off when this function is called. Drivers which need hardware to be running before they program the new display mode (because they implement runtime PM) should not use this hook, because the helper library calls it only once and not every time the display pipeline is suspend using either DPMS or the new “ACTIVE” property. Such drivers should instead move all their encoder setup into the enable callback.
This callback is used both by the legacy CRTC helpers and the atomic modeset helpers. It is optional in the atomic helpers.
NOTE:
If the driver uses the atomic modeset helpers and needs to inspect the connector state or connector display info during mode setting, atomic_mode_set can be used instead.
atomic_mode_set
This callback is used to update the display mode of an encoder.
Note that the display pipe is completely off when this function is called. Drivers which need hardware to be running before they program the new display mode (because they implement runtime PM) should not use this hook, because the helper library calls it only once and not every time the display pipeline is suspended using either DPMS or the new “ACTIVE” property. Such drivers should instead move all their encoder setup into the enable callback.
This callback is used by the atomic modeset helpers in place of the mode_set callback, if set by the driver. It is optional and should be used instead of mode_set if the driver needs to inspect the connector state or display info, since there is no direct way to go from the encoder to the current connector.
detect
This callback can be used by drivers who want to do detection on the encoder object instead of in connector functions.
It is not used by any helper and therefore has purely driver-specific semantics. New drivers shouldn’t use this and instead just implement their own private callbacks.
FIXME:
This should just be converted into a pile of driver vfuncs. Currently radeon, amdgpu and nouveau are using it.
atomic_disable
This callback should be used to disable the encoder. With the atomic drivers it is called before this encoder’s CRTC has been shut off using their own
drm_crtc_helper_funcs.atomic_disable
hook. If that sequence is too simple drivers can just add their own driver private encoder hooks and call them from CRTC’s callback by looping over all encoders connected to it usingfor_each_encoder_on_crtc()
.This callback is a variant of disable that provides the atomic state to the driver. If atomic_disable is implemented, disable is not called by the helpers.
This hook is only used by atomic helpers. Atomic drivers don’t need to implement it if there’s no need to disable anything at the encoder level. To ensure that runtime PM handling (using either DPMS or the new “ACTIVE” property) works atomic_disable must be the inverse of atomic_enable.
atomic_enable
This callback should be used to enable the encoder. It is called after this encoder’s CRTC has been enabled using their own
drm_crtc_helper_funcs.atomic_enable
hook. If that sequence is too simple drivers can just add their own driver private encoder hooks and call them from CRTC’s callback by looping over all encoders connected to it usingfor_each_encoder_on_crtc()
.This callback is a variant of enable that provides the atomic state to the driver. If atomic_enable is implemented, enable is not called by the helpers.
This hook is only used by atomic helpers, it is the opposite of atomic_disable. Atomic drivers don’t need to implement it if there’s no need to enable anything at the encoder level. To ensure that runtime PM handling works atomic_enable must be the inverse of atomic_disable.
disable
This callback should be used to disable the encoder. With the atomic drivers it is called before this encoder’s CRTC has been shut off using their own
drm_crtc_helper_funcs.disable
hook. If that sequence is too simple drivers can just add their own driver private encoder hooks and call them from CRTC’s callback by looping over all encoders connected to it usingfor_each_encoder_on_crtc()
.This hook is used both by legacy CRTC helpers and atomic helpers. Atomic drivers don’t need to implement it if there’s no need to disable anything at the encoder level. To ensure that runtime PM handling (using either DPMS or the new “ACTIVE” property) works disable must be the inverse of enable for atomic drivers.
For atomic drivers also consider atomic_disable and save yourself from having to read the NOTE below!
NOTE:
With legacy CRTC helpers there’s a big semantic difference between disable and other hooks (like prepare or dpms) used to shut down a encoder: disable is only called when also logically disabling the display pipeline and needs to release any resources acquired in mode_set (like shared PLLs, or again release pinned framebuffers).
Therefore disable must be the inverse of mode_set plus commit for drivers still using legacy CRTC helpers, which is different from the rules under atomic.
enable
This callback should be used to enable the encoder. With the atomic drivers it is called after this encoder’s CRTC has been enabled using their own
drm_crtc_helper_funcs.enable
hook. If that sequence is too simple drivers can just add their own driver private encoder hooks and call them from CRTC’s callback by looping over all encoders connected to it usingfor_each_encoder_on_crtc()
.This hook is only used by atomic helpers, it is the opposite of disable. Atomic drivers don’t need to implement it if there’s no need to enable anything at the encoder level. To ensure that runtime PM handling (using either DPMS or the new “ACTIVE” property) works enable must be the inverse of disable for atomic drivers.
atomic_check
This callback is used to validate encoder state for atomic drivers. Since the encoder is the object connecting the CRTC and connector it gets passed both states, to be able to validate interactions and update the CRTC to match what the encoder needs for the requested connector.
Since this provides a strict superset of the functionality of mode_fixup (the requested and adjusted modes are both available through the passed in
struct drm_crtc_state
) mode_fixup is not called when atomic_check is implemented.This function is used by the atomic helpers, but it is optional.
NOTE:
This function is called in the check phase of an atomic update. The driver is not allowed to change anything outside of the free-standing state objects passed-in or assembled in the overall
drm_atomic_state
update tracking structure.Also beware that userspace can request its own custom modes, neither core nor helpers filter modes to the list of probe modes reported by the GETCONNECTOR IOCTL and stored in
drm_connector.modes
. To ensure that modes are filtered consistently put any encoder constraints and limits checks into mode_valid.RETURNS:
0 on success, -EINVAL if the state or the transition can’t be supported, -ENOMEM on memory allocation failure and -EDEADLK if an attempt to obtain another state object ran into a
drm_modeset_lock
deadlock.
Description
These hooks are used by the legacy CRTC helpers, the transitional plane helpers and the new atomic modesetting helpers.
-
void
drm_encoder_helper_add
(struct drm_encoder * encoder, const struct drm_encoder_helper_funcs * funcs)¶ sets the helper vtable for an encoder
Parameters
struct drm_encoder * encoder
- DRM encoder
const struct drm_encoder_helper_funcs * funcs
- helper vtable to set for encoder
-
struct
drm_connector_helper_funcs
¶ helper operations for connectors
Definition
struct drm_connector_helper_funcs {
int (*get_modes)(struct drm_connector *connector);
int (*detect_ctx)(struct drm_connector *connector,struct drm_modeset_acquire_ctx *ctx, bool force);
enum drm_mode_status (*mode_valid)(struct drm_connector *connector, struct drm_display_mode *mode);
int (*mode_valid_ctx)(struct drm_connector *connector,struct drm_display_mode *mode,struct drm_modeset_acquire_ctx *ctx, enum drm_mode_status *status);
struct drm_encoder *(*best_encoder)(struct drm_connector *connector);
struct drm_encoder *(*atomic_best_encoder)(struct drm_connector *connector, struct drm_atomic_state *state);
int (*atomic_check)(struct drm_connector *connector, struct drm_atomic_state *state);
void (*atomic_commit)(struct drm_connector *connector, struct drm_atomic_state *state);
int (*prepare_writeback_job)(struct drm_writeback_connector *connector, struct drm_writeback_job *job);
void (*cleanup_writeback_job)(struct drm_writeback_connector *connector, struct drm_writeback_job *job);
};
Members
get_modes
This function should fill in all modes currently valid for the sink into the
drm_connector.probed_modes
list. It should also update the EDID property by callingdrm_connector_update_edid_property()
.The usual way to implement this is to cache the EDID retrieved in the probe callback somewhere in the driver-private connector structure. In this function drivers then parse the modes in the EDID and add them by calling
drm_add_edid_modes()
. But connectors that drive a fixed panel can also manually add specific modes usingdrm_mode_probed_add()
. Drivers which manually add modes should also make sure that thedrm_connector.display_info
,drm_connector.width_mm
anddrm_connector.height_mm
fields are filled in.Note that the caller function will automatically add standard VESA DMT modes up to 1024x768 if the .:c:func:get_modes() helper operation returns no mode and if the connector status is connector_status_connected or connector_status_unknown. There is no need to call
drm_add_modes_noedid()
manually in that case.Virtual drivers that just want some standard VESA mode with a given resolution can call
drm_add_modes_noedid()
, and mark the preferred one usingdrm_set_preferred_mode()
.This function is only called after the detect hook has indicated that a sink is connected and when the EDID isn’t overridden through sysfs or the kernel commandline.
This callback is used by the probe helpers in e.g.
drm_helper_probe_single_connector_modes()
.To avoid races with concurrent connector state updates, the helper libraries always call this with the
drm_mode_config.connection_mutex
held. Because of this it’s safe to inspectdrm_connector->state
.RETURNS:
The number of modes added by calling
drm_mode_probed_add()
.detect_ctx
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.
This callback is optional, if not implemented the connector will be considered as always being attached.
This is the atomic version of
drm_connector_funcs.detect
.To avoid races against concurrent connector state updates, the helper libraries always call this with ctx set to a valid context, and
drm_mode_config.connection_mutex
will always be locked with the ctx parameter set to this ctx. This allows taking additional locks as required.RETURNS:
drm_connector_status
indicating the connector’s status, or the error code returned bydrm_modeset_lock()
, -EDEADLK.mode_valid
Callback to validate a mode for a connector, irrespective of the specific display configuration.
This callback is used by the probe helpers to filter the mode list (which is usually derived from the EDID data block from the sink). See e.g.
drm_helper_probe_single_connector_modes()
.This function is optional.
NOTE:
This only filters the mode list supplied to userspace in the GETCONNECTOR IOCTL. Compared to
drm_encoder_helper_funcs.mode_valid
,drm_crtc_helper_funcs.mode_valid
anddrm_bridge_funcs.mode_valid
, which are also called by the atomic helpers fromdrm_atomic_helper_check_modeset()
. This allows userspace to force and ignore sink constraint (like the pixel clock limits in the screen’s EDID), which is useful for e.g. testing, or working around a broken EDID. Any source hardware constraint (which always need to be enforced) therefore should be checked in one of the above callbacks, and not this one here.To avoid races with concurrent connector state updates, the helper libraries always call this with the
drm_mode_config.connection_mutex
held. Because of this it’s safe to inspectdrm_connector->state
.RETURNS:
Either
drm_mode_status.MODE_OK
or one of the failure reasons inenum drm_mode_status
.mode_valid_ctx
Callback to validate a mode for a connector, irrespective of the specific display configuration.
This callback is used by the probe helpers to filter the mode list (which is usually derived from the EDID data block from the sink). See e.g.
drm_helper_probe_single_connector_modes()
.This function is optional, and is the atomic version of
drm_connector_helper_funcs.mode_valid
.To allow for accessing the atomic state of modesetting objects, the helper libraries always call this with ctx set to a valid context, and
drm_mode_config.connection_mutex
will always be locked with the ctx parameter set to ctx. This allows for taking additional locks as required.Even though additional locks may be acquired, this callback is still expected not to take any constraints into account which would be influenced by the currently set display state - such constraints should be handled in the driver’s atomic check. For example, if a connector shares display bandwidth with other connectors then it would be ok to validate the minimum bandwidth requirement of a mode against the maximum possible bandwidth of the connector. But it wouldn’t be ok to take the current bandwidth usage of other connectors into account, as this would change depending on the display state.
Returns: 0 if
drm_connector_helper_funcs.mode_valid_ctx
succeeded and wrote theenum drm_mode_status
value to status, or a negative error code otherwise.best_encoder
This function should select the best encoder for the given connector.
This function is used by both the atomic helpers (in the
drm_atomic_helper_check_modeset()
function) and in the legacy CRTC helpers.NOTE:
In atomic drivers this function is called in the check phase of an atomic update. The driver is not allowed to change or inspect anything outside of arguments passed-in. Atomic drivers which need to inspect dynamic configuration state should instead use atomic_best_encoder.
You can leave this function to NULL if the connector is only attached to a single encoder. In this case, the core will call
drm_connector_get_single_encoder()
for you.RETURNS:
Encoder that should be used for the given connector and connector state, or NULL if no suitable encoder exists. Note that the helpers will ensure that encoders aren’t used twice, drivers should not check for this.
atomic_best_encoder
This is the atomic version of best_encoder for atomic drivers which need to select the best encoder depending upon the desired configuration and can’t select it statically.
This function is used by
drm_atomic_helper_check_modeset()
. If it is not implemented, the core will fallback to best_encoder (ordrm_connector_get_single_encoder()
if best_encoder is NULL).NOTE:
This function is called in the check phase of an atomic update. The driver is not allowed to change anything outside of the
drm_atomic_state
update tracking structure passed in.RETURNS:
Encoder that should be used for the given connector and connector state, or NULL if no suitable encoder exists. Note that the helpers will ensure that encoders aren’t used twice, drivers should not check for this.
atomic_check
This hook is used to validate connector state. This function is called from
drm_atomic_helper_check_modeset
, and is called when a connector property is set, or a modeset on the crtc is forced.Because
drm_atomic_helper_check_modeset
may be called multiple times, this function should handle being called multiple times as well.This function is also allowed to inspect any other object’s state and can add more state objects to the atomic commit if needed. Care must be taken though to ensure that state check and compute functions for these added states are all called, and derived state in other objects all updated. Again the recommendation is to just call check helpers until a maximal configuration is reached.
NOTE:
This function is called in the check phase of an atomic update. The driver is not allowed to change anything outside of the free-standing state objects passed-in or assembled in the overall
drm_atomic_state
update tracking structure.RETURNS:
0 on success, -EINVAL if the state or the transition can’t be supported, -ENOMEM on memory allocation failure and -EDEADLK if an attempt to obtain another state object ran into a
drm_modeset_lock
deadlock.atomic_commit
This hook is to be used by drivers implementing writeback connectors that need a point when to commit the writeback job to the hardware. The writeback_job to commit is available in the new connector state, in
drm_connector_state.writeback_job
.This hook is optional.
This callback is used by the atomic modeset helpers.
prepare_writeback_job
As writeback jobs contain a framebuffer, drivers may need to prepare and clean them up the same way they can prepare and clean up framebuffers for planes. This optional connector operation is used to support the preparation of writeback jobs. The job prepare operation is called from
drm_atomic_helper_prepare_planes()
for structdrm_writeback_connector
connectors only.This operation is optional.
This callback is used by the atomic modeset helpers.
cleanup_writeback_job
This optional connector operation is used to support the cleanup of writeback jobs. The job cleanup operation is called from the existing
drm_writeback_cleanup_job()
function, invoked both when destroying the job as part of an aborted commit, or when the job completes.This operation is optional.
This callback is used by the atomic modeset helpers.
Description
These functions are used by the atomic and legacy modeset helpers and by the probe helpers.
-
void
drm_connector_helper_add
(struct drm_connector * connector, const struct drm_connector_helper_funcs * funcs)¶ sets the helper vtable for a connector
Parameters
struct drm_connector * connector
- DRM connector
const struct drm_connector_helper_funcs * funcs
- helper vtable to set for connector
-
struct
drm_plane_helper_funcs
¶ helper operations for planes
Definition
struct drm_plane_helper_funcs {
int (*prepare_fb)(struct drm_plane *plane, struct drm_plane_state *new_state);
void (*cleanup_fb)(struct drm_plane *plane, struct drm_plane_state *old_state);
int (*atomic_check)(struct drm_plane *plane, struct drm_atomic_state *state);
void (*atomic_update)(struct drm_plane *plane, struct drm_atomic_state *state);
void (*atomic_disable)(struct drm_plane *plane, struct drm_atomic_state *state);
int (*atomic_async_check)(struct drm_plane *plane, struct drm_atomic_state *state);
void (*atomic_async_update)(struct drm_plane *plane, struct drm_atomic_state *state);
};
Members
prepare_fb
This hook is to prepare a framebuffer for scanout by e.g. pinning its backing storage or relocating it into a contiguous block of VRAM. Other possible preparatory work includes flushing caches.
This function must not block for outstanding rendering, since it is called in the context of the atomic IOCTL even for async commits to be able to return any errors to userspace. Instead the recommended way is to fill out the
drm_plane_state.fence
of the passed-indrm_plane_state
. If the driver doesn’t support native fences then equivalent functionality should be implemented through private members in the plane structure.For GEM drivers who neither have a prepare_fb nor cleanup_fb hook set
drm_gem_plane_helper_prepare_fb()
is called automatically to implement this. Other drivers which need additional plane processing can calldrm_gem_plane_helper_prepare_fb()
from their prepare_fb hook.The helpers will call cleanup_fb with matching arguments for every successful call to this hook.
This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
RETURNS:
0 on success or one of the following negative error codes allowed by the
drm_mode_config_funcs.atomic_commit
vfunc. When using helpers this callback is the only one which can fail an atomic commit, everything else must complete successfully.cleanup_fb
This hook is called to clean up any resources allocated for the given framebuffer and plane configuration in prepare_fb.
This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
atomic_check
Drivers should check plane specific constraints in this hook.
When using
drm_atomic_helper_check_planes()
plane’s atomic_check hooks are called before the ones for CRTCs, which allows drivers to request shared resources that the CRTC controls here. For more complicated dependencies the driver can call the provided check helpers multiple times until the computed state has a final configuration and everything has been checked.This function is also allowed to inspect any other object’s state and can add more state objects to the atomic commit if needed. Care must be taken though to ensure that state check and compute functions for these added states are all called, and derived state in other objects all updated. Again the recommendation is to just call check helpers until a maximal configuration is reached.
This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
NOTE:
This function is called in the check phase of an atomic update. The driver is not allowed to change anything outside of the
drm_atomic_state
update tracking structure.RETURNS:
0 on success, -EINVAL if the state or the transition can’t be supported, -ENOMEM on memory allocation failure and -EDEADLK if an attempt to obtain another state object ran into a
drm_modeset_lock
deadlock.atomic_update
Drivers should use this function to update the plane state. This hook is called in-between the
drm_crtc_helper_funcs.atomic_begin
and drm_crtc_helper_funcs.atomic_flush callbacks.Note that the power state of the display pipe when this function is called depends upon the exact helpers and calling sequence the driver has picked. See
drm_atomic_helper_commit_planes()
for a discussion of the tradeoffs and variants of plane commit helpers.This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
atomic_disable
Drivers should use this function to unconditionally disable a plane. This hook is called in-between the
drm_crtc_helper_funcs.atomic_begin
and drm_crtc_helper_funcs.atomic_flush callbacks. It is an alternative to atomic_update, which will be called for disabling planes, too, if the atomic_disable hook isn’t implemented.This hook is also useful to disable planes in preparation of a modeset, by calling
drm_atomic_helper_disable_planes_on_crtc()
from thedrm_crtc_helper_funcs.disable
hook.Note that the power state of the display pipe when this function is called depends upon the exact helpers and calling sequence the driver has picked. See
drm_atomic_helper_commit_planes()
for a discussion of the tradeoffs and variants of plane commit helpers.This callback is used by the atomic modeset helpers and by the transitional plane helpers, but it is optional.
atomic_async_check
Drivers should set this function pointer to check if the plane’s atomic state can be updated in a async fashion. Here async means “not vblank synchronized”.
This hook is called by
drm_atomic_async_check()
to establish if a given update can be committed asynchronously, that is, if it can jump ahead of the state currently queued for update.RETURNS:
Return 0 on success and any error returned indicates that the update can not be applied in asynchronous manner.
atomic_async_update
Drivers should set this function pointer to perform asynchronous updates of planes, that is, jump ahead of the currently queued state and update the plane. Here async means “not vblank synchronized”.
This hook is called by
drm_atomic_helper_async_commit()
.An async update will happen on legacy cursor updates. An async update won’t happen if there is an outstanding commit modifying the same plane.
When doing async_update drivers shouldn’t replace the
drm_plane_state
but update the current one with the new plane configurations in the new plane_state.Drivers should also swap the framebuffers between current plane state (
drm_plane.state
) and new_state. This is required since cleanup for async commits is performed on the new state, rather than old state like for traditional commits. Since we want to give up the reference on the current (old) fb instead of our brand new one, swap them in the driver during the async commit.- FIXME:
- It only works for single plane updates
- Async Pageflips are not supported yet
- Some hw might still scan out the old buffer until the next vblank, however we let go of the fb references as soon as we run this hook. For now drivers must implement their own workers for deferring if needed, until a common solution is created.
Description
These functions are used by the atomic helpers and by the transitional plane helpers.
-
void
drm_plane_helper_add
(struct drm_plane * plane, const struct drm_plane_helper_funcs * funcs)¶ sets the helper vtable for a plane
Parameters
struct drm_plane * plane
- DRM plane
const struct drm_plane_helper_funcs * funcs
- helper vtable to set for plane
-
struct
drm_mode_config_helper_funcs
¶ global modeset helper operations
Definition
struct drm_mode_config_helper_funcs {
void (*atomic_commit_tail)(struct drm_atomic_state *state);
int (*atomic_commit_setup)(struct drm_atomic_state *state);
};
Members
atomic_commit_tail
This hook is used by the default
atomic_commit()
hook implemented indrm_atomic_helper_commit()
together with the nonblocking commit helpers (seedrm_atomic_helper_setup_commit()
for a starting point) to implement blocking and nonblocking commits easily. It is not used by the atomic helpersThis function is called when the new atomic state has already been swapped into the various state pointers. The passed in state therefore contains copies of the old/previous state. This hook should commit the new state into hardware. Note that the helpers have already waited for preceeding atomic commits and fences, but drivers can add more waiting calls at the start of their implementation, e.g. to wait for driver-internal request for implicit syncing, before starting to commit the update to the hardware.
After the atomic update is committed to the hardware this hook needs to call
drm_atomic_helper_commit_hw_done()
. Then wait for the update to be executed by the hardware, for example usingdrm_atomic_helper_wait_for_vblanks()
ordrm_atomic_helper_wait_for_flip_done()
, and then clean up the old framebuffers usingdrm_atomic_helper_cleanup_planes()
.When disabling a CRTC this hook _must_ stall for the commit to complete. Vblank waits don’t work on disabled CRTC, hence the core can’t take care of this. And it also can’t rely on the vblank event, since that can be signalled already when the screen shows black, which can happen much earlier than the last hardware access needed to shut off the display pipeline completely.
This hook is optional, the default implementation is
drm_atomic_helper_commit_tail()
.atomic_commit_setup
This hook is used by the default
atomic_commit()
hook implemented indrm_atomic_helper_commit()
together with the nonblocking helpers (seedrm_atomic_helper_setup_commit()
) to extend the DRM commit setup. It is not used by the atomic helpers.This function is called at the end of
drm_atomic_helper_setup_commit()
, so once the commit has been properly setup across the generic DRM object states. It allows drivers to do some additional commit tracking that isn’t related to a CRTC, plane or connector, tracked in adrm_private_obj
structure.Note that the documentation of
drm_private_obj
has more details on how one should implement this.This hook is optional.
Description
These helper functions are used by the atomic helpers.
Atomic Modeset Helper Functions Reference¶
Overview¶
This helper library provides implementations of check and commit functions on top of the CRTC modeset helper callbacks and the plane helper callbacks. It also provides convenience implementations for the atomic state handling callbacks for drivers which don’t need to subclass the drm core structures to add their own additional internal state.
This library also provides default implementations for the check callback in
drm_atomic_helper_check()
and for the commit callback with
drm_atomic_helper_commit()
. But the individual stages and callbacks are
exposed to allow drivers to mix and match and e.g. use the plane helpers only
together with a driver private modeset implementation.
This library also provides implementations for all the legacy driver
interfaces on top of the atomic interface. See drm_atomic_helper_set_config()
,
drm_atomic_helper_disable_plane()
, and the various functions to implement
set_property callbacks. New drivers must not implement these functions
themselves but must use the provided helpers.
The atomic helper uses the same function table structures as all other
modesetting helpers. See the documentation for struct drm_crtc_helper_funcs
,
struct drm_encoder_helper_funcs
and struct drm_connector_helper_funcs
. It
also shares the struct drm_plane_helper_funcs
function table with the plane
helpers.
Implementing Asynchronous Atomic Commit¶
Nonblocking atomic commits should use struct drm_crtc_commit
to sequence
different operations against each another. Locks, especially struct
drm_modeset_lock
, should not be held in worker threads or any other
asynchronous context used to commit the hardware state.
drm_atomic_helper_commit()
implements the recommended sequence for
nonblocking commits, using drm_atomic_helper_setup_commit()
internally:
1. Run drm_atomic_helper_prepare_planes()
. Since this can fail and we
need to propagate out of memory/VRAM errors to userspace, it must be called
synchronously.
2. Synchronize with any outstanding nonblocking commit worker threads which
might be affected by the new state update. This is handled by
drm_atomic_helper_setup_commit()
.
Asynchronous workers need to have sufficient parallelism to be able to run
different atomic commits on different CRTCs in parallel. The simplest way to
achieve this is by running them on the system_unbound_wq
work queue. Note
that drivers are not required to split up atomic commits and run an
individual commit in parallel - userspace is supposed to do that if it cares.
But it might be beneficial to do that for modesets, since those necessarily
must be done as one global operation, and enabling or disabling a CRTC can
take a long time. But even that is not required.
IMPORTANT: A drm_atomic_state
update for multiple CRTCs is sequenced
against all CRTCs therein. Therefore for atomic state updates which only flip
planes the driver must not get the struct drm_crtc_state
of unrelated CRTCs
in its atomic check code: This would prevent committing of atomic updates to
multiple CRTCs in parallel. In general, adding additional state structures
should be avoided as much as possible, because this reduces parallelism in
(nonblocking) commits, both due to locking and due to commit sequencing
requirements.
3. The software state is updated synchronously with
drm_atomic_helper_swap_state()
. Doing this under the protection of all modeset
locks means concurrent callers never see inconsistent state. Note that commit
workers do not hold any locks; their access is only coordinated through
ordering. If workers would access state only through the pointers in the
free-standing state objects (currently not the case for any driver) then even
multiple pending commits could be in-flight at the same time.
4. Schedule a work item to do all subsequent steps, using the split-out
commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
then cleaning up the framebuffers after the old framebuffer is no longer
being displayed. The scheduled work should synchronize against other workers
using the drm_crtc_commit
infrastructure as needed. See
drm_atomic_helper_setup_commit()
for more details.
Atomic State Reset and Initialization¶
Helper Functions Reference¶
-
drm_atomic_crtc_for_each_plane
(plane, crtc)¶ iterate over planes currently attached to CRTC
Parameters
plane
- the loop cursor
crtc
- the CRTC whose planes are iterated
Description
This iterates over the current state, useful (for example) when applying
atomic state after it has been checked and swapped. To iterate over the
planes which will be attached (more useful in code called from
drm_mode_config_funcs.atomic_check
) see
drm_atomic_crtc_state_for_each_plane()
.
-
drm_atomic_crtc_state_for_each_plane
(plane, crtc_state)¶ iterate over attached planes in new state
Parameters
plane
- the loop cursor
crtc_state
- the incoming CRTC state
Description
Similar to drm_crtc_for_each_plane()
, but iterates the planes that will be
attached if the specified state is applied. Useful during for example
in code called from drm_mode_config_funcs.atomic_check
operations, to
validate the incoming state.
-
drm_atomic_crtc_state_for_each_plane_state
(plane, plane_state, crtc_state)¶ iterate over attached planes in new state
Parameters
plane
- the loop cursor
plane_state
- loop cursor for the plane’s state, must be const
crtc_state
- the incoming CRTC state
Description
Similar to drm_crtc_for_each_plane()
, but iterates the planes that will be
attached if the specified state is applied. Useful during for example
in code called from drm_mode_config_funcs.atomic_check
operations, to
validate the incoming state.
Compared to just drm_atomic_crtc_state_for_each_plane()
this also fills in a
const plane_state. This is useful when a driver just wants to peek at other
active planes on this CRTC, but does not need to change it.
-
bool
drm_atomic_plane_disabling
(struct drm_plane_state * old_plane_state, struct drm_plane_state * new_plane_state)¶ check whether a plane is being disabled
Parameters
struct drm_plane_state * old_plane_state
- old atomic plane state
struct drm_plane_state * new_plane_state
- new atomic plane state
Description
Checks the atomic state of a plane to determine whether it’s being disabled or not. This also WARNs if it detects an invalid state (both CRTC and FB need to either both be NULL or both be non-NULL).
Return
True if the plane is being disabled, false otherwise.
-
int
drm_atomic_helper_check_modeset
(struct drm_device * dev, struct drm_atomic_state * state)¶ validate state object for modeset changes
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- the driver state object
Description
Check the state object to see if the requested state is physically possible. This does all the CRTC and connector related computations for an atomic update and adds any additional connectors needed for full modesets. It calls the various per-object callbacks in the follow order:
drm_connector_helper_funcs.atomic_best_encoder
for determining the new encoder.drm_connector_helper_funcs.atomic_check
to validate the connector state.- If it’s determined a modeset is needed then all connectors on the affected
CRTC are added and
drm_connector_helper_funcs.atomic_check
is run on them. drm_encoder_helper_funcs.mode_valid
,drm_bridge_funcs.mode_valid
anddrm_crtc_helper_funcs.mode_valid
are called on the affected components.drm_bridge_funcs.mode_fixup
is called on all encoder bridges.drm_encoder_helper_funcs.atomic_check
is called to validate any encoder state. This function is only called when the encoder will be part of a configured CRTC, it must not be used for implementing connector property validation. If this function is NULL,drm_atomic_encoder_helper_funcs.mode_fixup
is called instead.drm_crtc_helper_funcs.mode_fixup
is called last, to fix up the mode with CRTC constraints.
drm_crtc_state.mode_changed
is set when the input mode is changed.
drm_crtc_state.connectors_changed
is set when a connector is added or
removed from the CRTC. drm_crtc_state.active_changed
is set when
drm_crtc_state.active
changes, which is used for DPMS.
drm_crtc_state.no_vblank
is set from the result of drm_dev_has_vblank()
.
See also: drm_atomic_crtc_needs_modeset()
IMPORTANT:
Drivers which set drm_crtc_state.mode_changed
(e.g. in their
drm_plane_helper_funcs.atomic_check
hooks if a plane update can’t be done
without a full modeset) _must_ call this function after that change. It is
permitted to call this function multiple times for the same update, e.g.
when the drm_crtc_helper_funcs.atomic_check
functions depend upon the
adjusted dotclock for fifo space allocation and watermark computation.
Return
Zero for success or -errno
-
int
drm_atomic_helper_check_plane_state
(struct drm_plane_state * plane_state, const struct drm_crtc_state * crtc_state, int min_scale, int max_scale, bool can_position, bool can_update_disabled)¶ Check plane state for validity
Parameters
struct drm_plane_state * plane_state
- plane state to check
const struct drm_crtc_state * crtc_state
- CRTC state to check
int min_scale
- minimum src:dest scaling factor in 16.16 fixed point
int max_scale
- maximum src:dest scaling factor in 16.16 fixed point
bool can_position
- is it legal to position the plane such that it doesn’t cover the entire CRTC? This will generally only be false for primary planes.
bool can_update_disabled
- can the plane be updated while the CRTC is disabled?
Description
Checks that a desired plane update is valid, and updates various bits of derived state (clipped coordinates etc.). Drivers that provide their own plane handling rather than helper-provided implementations may still wish to call this function to avoid duplication of error checking code.
Return
Zero if update appears valid, error code on failure
-
int
drm_atomic_helper_check_crtc_state
(struct drm_crtc_state * crtc_state, bool can_disable_primary_planes)¶ Check CRTC state for validity
Parameters
struct drm_crtc_state * crtc_state
- CRTC state to check
bool can_disable_primary_planes
- can the CRTC be enabled without a primary plane?
Description
Checks that a desired CRTC update is valid. Drivers that provide their own CRTC handling rather than helper-provided implementations may still wish to call this function to avoid duplication of error checking code.
Note that can_disable_primary_planes only tests if the CRTC can be
enabled without a primary plane. To test if a primary plane can be updated
without a CRTC, use drm_atomic_helper_check_plane_state()
in the plane’s
atomic check.
Return
Zero if update appears valid, error code on failure
-
int
drm_atomic_helper_check_planes
(struct drm_device * dev, struct drm_atomic_state * state)¶ validate state object for planes changes
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- the driver state object
Description
Check the state object to see if the requested state is physically possible.
This does all the plane update related checks using by calling into the
drm_crtc_helper_funcs.atomic_check
and drm_plane_helper_funcs.atomic_check
hooks provided by the driver.
It also sets drm_crtc_state.planes_changed
to indicate that a CRTC has
updated planes.
Return
Zero for success or -errno
-
int
drm_atomic_helper_check
(struct drm_device * dev, struct drm_atomic_state * state)¶ validate state object
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- the driver state object
Description
Check the state object to see if the requested state is physically possible.
Only CRTCs and planes have check callbacks, so for any additional (global)
checking that a driver needs it can simply wrap that around this function.
Drivers without such needs can directly use this as their
drm_mode_config_funcs.atomic_check
callback.
This just wraps the two parts of the state checking for planes and modeset
state in the default order: First it calls drm_atomic_helper_check_modeset()
and then drm_atomic_helper_check_planes()
. The assumption is that the
drm_plane_helper_funcs.atomic_check and drm_crtc_helper_funcs.atomic_check
functions depend upon an updated adjusted_mode.clock to e.g. properly compute
watermarks.
Note that zpos normalization will add all enable planes to the state which might not desired for some drivers. For example enable/disable of a cursor plane which have fixed zpos value would trigger all other enabled planes to be forced to the state change.
Return
Zero for success or -errno
-
void
drm_atomic_helper_update_legacy_modeset_state
(struct drm_device * dev, struct drm_atomic_state * old_state)¶ update legacy modeset state
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This function updates all the various legacy modeset state pointers in connectors, encoders and CRTCs.
Drivers can use this for building their own atomic commit if they don’t have a pure helper-based modeset implementation.
Since these updates are not synchronized with lockings, only code paths
called from drm_mode_config_helper_funcs.atomic_commit_tail
can look at the
legacy state filled out by this helper. Defacto this means this helper and
the legacy state pointers are only really useful for transitioning an
existing driver to the atomic world.
-
void
drm_atomic_helper_calc_timestamping_constants
(struct drm_atomic_state * state)¶ update vblank timestamping constants
Parameters
struct drm_atomic_state * state
- atomic state object
Description
Updates the timestamping constants used for precise vblank timestamps
by calling drm_calc_timestamping_constants()
for all enabled crtcs in state.
-
void
drm_atomic_helper_commit_modeset_disables
(struct drm_device * dev, struct drm_atomic_state * old_state)¶ modeset commit to disable outputs
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This function shuts down all the outputs that need to be shut down and prepares them (if required) with the new mode.
For compatibility with legacy CRTC helpers this should be called before
drm_atomic_helper_commit_planes()
, which is what the default commit function
does. But drivers with different needs can group the modeset commits together
and do the plane commits at the end. This is useful for drivers doing runtime
PM since planes updates then only happen when the CRTC is actually enabled.
-
void
drm_atomic_helper_commit_modeset_enables
(struct drm_device * dev, struct drm_atomic_state * old_state)¶ modeset commit to enable outputs
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This function enables all the outputs with the new configuration which had to be turned off for the update.
For compatibility with legacy CRTC helpers this should be called after
drm_atomic_helper_commit_planes()
, which is what the default commit function
does. But drivers with different needs can group the modeset commits together
and do the plane commits at the end. This is useful for drivers doing runtime
PM since planes updates then only happen when the CRTC is actually enabled.
-
int
drm_atomic_helper_wait_for_fences
(struct drm_device * dev, struct drm_atomic_state * state, bool pre_swap)¶ wait for fences stashed in plane state
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- atomic state object with old state structures
bool pre_swap
- If true, do an interruptible wait, and state is the new state. Otherwise state is the old state.
Description
For implicit sync, driver should fish the exclusive fence out from the
incoming fb’s and stash it in the drm_plane_state. This is called after
drm_atomic_helper_swap_state()
so it uses the current plane state (and
just uses the atomic state to find the changed planes)
Note that pre_swap is needed since the point where we block for fences moves
around depending upon whether an atomic commit is blocking or
non-blocking. For non-blocking commit all waiting needs to happen after
drm_atomic_helper_swap_state()
is called, but for blocking commits we want
to wait before we do anything that can’t be easily rolled back. That is
before we call drm_atomic_helper_swap_state()
.
Returns zero if success or < 0 if dma_fence_wait()
fails.
-
void
drm_atomic_helper_wait_for_vblanks
(struct drm_device * dev, struct drm_atomic_state * old_state)¶ wait for vblank on CRTCs
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
Helper to, after atomic commit, wait for vblanks on all affected
CRTCs (ie. before cleaning up old framebuffers using
drm_atomic_helper_cleanup_planes()
). It will only wait on CRTCs where the
framebuffers have actually changed to optimize for the legacy cursor and
plane update use-case.
Drivers using the nonblocking commit tracking support initialized by calling
drm_atomic_helper_setup_commit()
should look at
drm_atomic_helper_wait_for_flip_done()
as an alternative.
-
void
drm_atomic_helper_wait_for_flip_done
(struct drm_device * dev, struct drm_atomic_state * old_state)¶ wait for all page flips to be done
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
Helper to, after atomic commit, wait for page flips on all affected
crtcs (ie. before cleaning up old framebuffers using
drm_atomic_helper_cleanup_planes()
). Compared to
drm_atomic_helper_wait_for_vblanks()
this waits for the completion on all
CRTCs, assuming that cursors-only updates are signalling their completion
immediately (or using a different path).
This requires that drivers use the nonblocking commit tracking support
initialized using drm_atomic_helper_setup_commit()
.
-
void
drm_atomic_helper_commit_tail
(struct drm_atomic_state * old_state)¶ commit atomic update to hardware
Parameters
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This is the default implementation for the
drm_mode_config_helper_funcs.atomic_commit_tail
hook, for drivers
that do not support runtime_pm or do not need the CRTC to be
enabled to perform a commit. Otherwise, see
drm_atomic_helper_commit_tail_rpm()
.
Note that the default ordering of how the various stages are called is to match the legacy modeset helper library closest.
-
void
drm_atomic_helper_commit_tail_rpm
(struct drm_atomic_state * old_state)¶ commit atomic update to hardware
Parameters
struct drm_atomic_state * old_state
- new modeset state to be committed
Description
This is an alternative implementation for the
drm_mode_config_helper_funcs.atomic_commit_tail
hook, for drivers
that support runtime_pm or need the CRTC to be enabled to perform a
commit. Otherwise, one should use the default implementation
drm_atomic_helper_commit_tail()
.
-
int
drm_atomic_helper_async_check
(struct drm_device * dev, struct drm_atomic_state * state)¶ check if state can be committed asynchronously
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- the driver state object
Description
This helper will check if it is possible to commit the state asynchronously. Async commits are not supposed to swap the states like normal sync commits but just do in-place changes on the current state.
It will return 0 if the commit can happen in an asynchronous fashion or error if not. Note that error just mean it can’t be committed asynchronously, if it fails the commit should be treated like a normal synchronous commit.
-
void
drm_atomic_helper_async_commit
(struct drm_device * dev, struct drm_atomic_state * state)¶ commit state asynchronously
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- the driver state object
Description
This function commits a state asynchronously, i.e., not vblank
synchronized. It should be used on a state only when
drm_atomic_async_check()
succeeds. Async commits are not supposed to swap
the states like normal sync commits, but just do in-place changes on the
current state.
TODO: Implement full swap instead of doing in-place changes.
-
int
drm_atomic_helper_commit
(struct drm_device * dev, struct drm_atomic_state * state, bool nonblock)¶ commit validated state object
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- the driver state object
bool nonblock
- whether nonblocking behavior is requested.
Description
This function commits a with drm_atomic_helper_check()
pre-validated state
object. This can still fail when e.g. the framebuffer reservation fails. This
function implements nonblocking commits, using
drm_atomic_helper_setup_commit()
and related functions.
Committing the actual hardware state is done through the
drm_mode_config_helper_funcs.atomic_commit_tail
callback, or its default
implementation drm_atomic_helper_commit_tail()
.
Return
Zero for success or -errno.
-
int
drm_atomic_helper_setup_commit
(struct drm_atomic_state * state, bool nonblock)¶ setup possibly nonblocking commit
Parameters
struct drm_atomic_state * state
- new modeset state to be committed
bool nonblock
- whether nonblocking behavior is requested.
Description
This function prepares state to be used by the atomic helper’s support for
nonblocking commits. Drivers using the nonblocking commit infrastructure
should always call this function from their
drm_mode_config_funcs.atomic_commit
hook.
Drivers that need to extend the commit setup to private objects can use the
drm_mode_config_helper_funcs.atomic_commit_setup
hook.
To be able to use this support drivers need to use a few more helper
functions. drm_atomic_helper_wait_for_dependencies()
must be called before
actually committing the hardware state, and for nonblocking commits this call
must be placed in the async worker. See also drm_atomic_helper_swap_state()
and its stall parameter, for when a driver’s commit hooks look at the
drm_crtc.state
, drm_plane.state
or drm_connector.state
pointer directly.
Completion of the hardware commit step must be signalled using
drm_atomic_helper_commit_hw_done()
. After this step the driver is not allowed
to read or change any permanent software or hardware modeset state. The only
exception is state protected by other means than drm_modeset_lock
locks.
Only the free standing state with pointers to the old state structures can
be inspected, e.g. to clean up old buffers using
drm_atomic_helper_cleanup_planes()
.
At the very end, before cleaning up state drivers must call
drm_atomic_helper_commit_cleanup_done()
.
This is all implemented by in drm_atomic_helper_commit()
, giving drivers a
complete and easy-to-use default implementation of the atomic_commit()
hook.
The tracking of asynchronously executed and still pending commits is done
using the core structure drm_crtc_commit
.
By default there’s no need to clean up resources allocated by this function
explicitly: drm_atomic_state_default_clear()
will take care of that
automatically.
Return
0 on success. -EBUSY when userspace schedules nonblocking commits too fast, -ENOMEM on allocation failures and -EINTR when a signal is pending.
-
void
drm_atomic_helper_wait_for_dependencies
(struct drm_atomic_state * old_state)¶ wait for required preceeding commits
Parameters
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This function waits for all preceeding commits that touch the same CRTC as
old_state to both be committed to the hardware (as signalled by
drm_atomic_helper_commit_hw_done()
) and executed by the hardware (as signalled
by calling drm_crtc_send_vblank_event()
on the drm_crtc_state.event
).
This is part of the atomic helper support for nonblocking commits, see
drm_atomic_helper_setup_commit()
for an overview.
-
void
drm_atomic_helper_fake_vblank
(struct drm_atomic_state * old_state)¶ fake VBLANK events if needed
Parameters
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This function walks all CRTCs and fakes VBLANK events on those with
drm_crtc_state.no_vblank
set to true and drm_crtc_state.event
!= NULL.
The primary use of this function is writeback connectors working in oneshot
mode and faking VBLANK events. In this case they only fake the VBLANK event
when a job is queued, and any change to the pipeline that does not touch the
connector is leading to timeouts when calling
drm_atomic_helper_wait_for_vblanks()
or
drm_atomic_helper_wait_for_flip_done()
. In addition to writeback
connectors, this function can also fake VBLANK events for CRTCs without
VBLANK interrupt.
This is part of the atomic helper support for nonblocking commits, see
drm_atomic_helper_setup_commit()
for an overview.
-
void
drm_atomic_helper_commit_hw_done
(struct drm_atomic_state * old_state)¶ setup possible nonblocking commit
Parameters
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This function is used to signal completion of the hardware commit step. After
this step the driver is not allowed to read or change any permanent software
or hardware modeset state. The only exception is state protected by other
means than drm_modeset_lock
locks.
Drivers should try to postpone any expensive or delayed cleanup work after this function is called.
This is part of the atomic helper support for nonblocking commits, see
drm_atomic_helper_setup_commit()
for an overview.
-
void
drm_atomic_helper_commit_cleanup_done
(struct drm_atomic_state * old_state)¶ signal completion of commit
Parameters
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This signals completion of the atomic update old_state, including any
cleanup work. If used, it must be called right before calling
drm_atomic_state_put()
.
This is part of the atomic helper support for nonblocking commits, see
drm_atomic_helper_setup_commit()
for an overview.
-
int
drm_atomic_helper_prepare_planes
(struct drm_device * dev, struct drm_atomic_state * state)¶ prepare plane resources before commit
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- atomic state object with new state structures
Description
This function prepares plane state, specifically framebuffers, for the new
configuration, by calling drm_plane_helper_funcs.prepare_fb
. If any failure
is encountered this function will call drm_plane_helper_funcs.cleanup_fb
on
any already successfully prepared framebuffer.
Return
0 on success, negative error code on failure.
-
void
drm_atomic_helper_commit_planes
(struct drm_device * dev, struct drm_atomic_state * old_state, uint32_t flags)¶ commit plane state
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * old_state
- atomic state object with old state structures
uint32_t flags
- flags for committing plane state
Description
This function commits the new plane state using the plane and atomic helper functions for planes and CRTCs. It assumes that the atomic state has already been pushed into the relevant object state pointers, since this step can no longer fail.
It still requires the global state object old_state to know which planes and crtcs need to be updated though.
Note that this function does all plane updates across all CRTCs in one step.
If the hardware can’t support this approach look at
drm_atomic_helper_commit_planes_on_crtc()
instead.
Plane parameters can be updated by applications while the associated CRTC is disabled. The DRM/KMS core will store the parameters in the plane state, which will be available to the driver when the CRTC is turned on. As a result most drivers don’t need to be immediately notified of plane updates for a disabled CRTC.
Unless otherwise needed, drivers are advised to set the ACTIVE_ONLY flag in flags in order not to receive plane update notifications related to a disabled CRTC. This avoids the need to manually ignore plane updates in driver code when the driver and/or hardware can’t or just don’t need to deal with updates on disabled CRTCs, for example when supporting runtime PM.
Drivers may set the NO_DISABLE_AFTER_MODESET flag in flags if the relevant
display controllers require to disable a CRTC’s planes when the CRTC is
disabled. This function would skip the drm_plane_helper_funcs.atomic_disable
call for a plane if the CRTC of the old plane state needs a modesetting
operation. Of course, the drivers need to disable the planes in their CRTC
disable callbacks since no one else would do that.
The drm_atomic_helper_commit()
default implementation doesn’t set the
ACTIVE_ONLY flag to most closely match the behaviour of the legacy helpers.
This should not be copied blindly by drivers.
-
void
drm_atomic_helper_commit_planes_on_crtc
(struct drm_crtc_state * old_crtc_state)¶ commit plane state for a CRTC
Parameters
struct drm_crtc_state * old_crtc_state
- atomic state object with the old CRTC state
Description
This function commits the new plane state using the plane and atomic helper functions for planes on the specific CRTC. It assumes that the atomic state has already been pushed into the relevant object state pointers, since this step can no longer fail.
This function is useful when plane updates should be done CRTC-by-CRTC
instead of one global step like drm_atomic_helper_commit_planes()
does.
This function can only be savely used when planes are not allowed to move between different CRTCs because this function doesn’t handle inter-CRTC dependencies. Callers need to ensure that either no such dependencies exist, resolve them through ordering of commit calls or through some other means.
-
void
drm_atomic_helper_disable_planes_on_crtc
(struct drm_crtc_state * old_crtc_state, bool atomic)¶ helper to disable CRTC’s planes
Parameters
struct drm_crtc_state * old_crtc_state
- atomic state object with the old CRTC state
bool atomic
- if set, synchronize with CRTC’s atomic_begin/flush hooks
Description
Disables all planes associated with the given CRTC. This can be used for instance in the CRTC helper atomic_disable callback to disable all planes.
If the atomic-parameter is set the function calls the CRTC’s atomic_begin hook before and atomic_flush hook after disabling the planes.
It is a bug to call this function without having implemented the
drm_plane_helper_funcs.atomic_disable
plane hook.
-
void
drm_atomic_helper_cleanup_planes
(struct drm_device * dev, struct drm_atomic_state * old_state)¶ cleanup plane resources after commit
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * old_state
- atomic state object with old state structures
Description
This function cleans up plane state, specifically framebuffers, from the old configuration. Hence the old configuration must be perserved in old_state to be able to call this function.
This function must also be called on the new state when the atomic update
fails at any point after calling drm_atomic_helper_prepare_planes()
.
-
int
drm_atomic_helper_swap_state
(struct drm_atomic_state * state, bool stall)¶ store atomic state into current sw state
Parameters
struct drm_atomic_state * state
- atomic state
bool stall
- stall for preceding commits
Description
This function stores the atomic state into the current state pointers in all driver objects. It should be called after all failing steps have been done and succeeded, but before the actual hardware state is committed.
For cleanup and error recovery the current state for all changed objects will be swapped into state.
With that sequence it fits perfectly into the plane prepare/cleanup sequence:
- Call
drm_atomic_helper_prepare_planes()
with the staged atomic state. - Do any other steps that might fail.
- Put the staged state into the current state pointers with this function.
- Actually commit the hardware state.
5. Call drm_atomic_helper_cleanup_planes()
with state, which since step 3
contains the old state. Also do any other cleanup required with that state.
stall must be set when nonblocking commits for this driver directly access
the drm_plane.state
, drm_crtc.state
or drm_connector.state
pointer. With
the current atomic helpers this is almost always the case, since the helpers
don’t pass the right state structures to the callbacks.
Return
Returns 0 on success. Can return -ERESTARTSYS when stall is true and the waiting for the previous commits has been interrupted.
-
int
drm_atomic_helper_update_plane
(struct drm_plane * plane, struct drm_crtc * crtc, struct drm_framebuffer * fb, int crtc_x, int crtc_y, unsigned int crtc_w, unsigned int crtc_h, uint32_t src_x, uint32_t src_y, uint32_t src_w, uint32_t src_h, struct drm_modeset_acquire_ctx * ctx)¶ Helper for primary plane update using atomic
Parameters
struct drm_plane * plane
- plane object to update
struct drm_crtc * crtc
- owning CRTC of owning plane
struct drm_framebuffer * fb
- framebuffer to flip onto plane
int crtc_x
- x offset of primary plane on crtc
int crtc_y
- y offset of primary plane on crtc
unsigned int crtc_w
- width of primary plane rectangle on crtc
unsigned int crtc_h
- height of primary plane rectangle on crtc
uint32_t src_x
- x offset of fb for panning
uint32_t src_y
- y offset of fb for panning
uint32_t src_w
- width of source rectangle in fb
uint32_t src_h
- height of source rectangle in fb
struct drm_modeset_acquire_ctx * ctx
- lock acquire context
Description
Provides a default plane update handler using the atomic driver interface.
Return
Zero on success, error code on failure
-
int
drm_atomic_helper_disable_plane
(struct drm_plane * plane, struct drm_modeset_acquire_ctx * ctx)¶ Helper for primary plane disable using * atomic
Parameters
struct drm_plane * plane
- plane to disable
struct drm_modeset_acquire_ctx * ctx
- lock acquire context
Description
Provides a default plane disable handler using the atomic driver interface.
Return
Zero on success, error code on failure
-
int
drm_atomic_helper_set_config
(struct drm_mode_set * set, struct drm_modeset_acquire_ctx * ctx)¶ set a new config from userspace
Parameters
struct drm_mode_set * set
- mode set configuration
struct drm_modeset_acquire_ctx * ctx
- lock acquisition context
Description
Provides a default CRTC set_config handler using the atomic driver interface.
NOTE
For backwards compatibility with old userspace this automatically
resets the “link-status” property to GOOD, to force any link
re-training. The SETCRTC ioctl does not define whether an update does
need a full modeset or just a plane update, hence we’re allowed to do
that. See also drm_connector_set_link_status_property()
.
Return
Returns 0 on success, negative errno numbers on failure.
-
int
drm_atomic_helper_disable_all
(struct drm_device * dev, struct drm_modeset_acquire_ctx * ctx)¶ disable all currently active outputs
Parameters
struct drm_device * dev
- DRM device
struct drm_modeset_acquire_ctx * ctx
- lock acquisition context
Description
Loops through all connectors, finding those that aren’t turned off and then turns them off by setting their DPMS mode to OFF and deactivating the CRTC that they are connected to.
This is used for example in suspend/resume to disable all currently active
functions when suspending. If you just want to shut down everything at e.g.
driver unload, look at drm_atomic_helper_shutdown()
.
Note that if callers haven’t already acquired all modeset locks this might
return -EDEADLK, which must be handled by calling drm_modeset_backoff()
.
Return
0 on success or a negative error code on failure.
See also:
drm_atomic_helper_suspend()
, drm_atomic_helper_resume()
and
drm_atomic_helper_shutdown()
.
-
void
drm_atomic_helper_shutdown
(struct drm_device * dev)¶ shutdown all CRTC
Parameters
struct drm_device * dev
- DRM device
Description
This shuts down all CRTC, which is useful for driver unloading. Shutdown on
suspend should instead be handled with drm_atomic_helper_suspend()
, since
that also takes a snapshot of the modeset state to be restored on resume.
This is just a convenience wrapper around drm_atomic_helper_disable_all()
,
and it is the atomic version of drm_crtc_force_disable_all()
.
-
struct drm_atomic_state *
drm_atomic_helper_duplicate_state
(struct drm_device * dev, struct drm_modeset_acquire_ctx * ctx)¶ duplicate an atomic state object
Parameters
struct drm_device * dev
- DRM device
struct drm_modeset_acquire_ctx * ctx
- lock acquisition context
Description
Makes a copy of the current atomic state by looping over all objects and duplicating their respective states. This is used for example by suspend/ resume support code to save the state prior to suspend such that it can be restored upon resume.
Note that this treats atomic state as persistent between save and restore. Drivers must make sure that this is possible and won’t result in confusion or erroneous behaviour.
Note that if callers haven’t already acquired all modeset locks this might
return -EDEADLK, which must be handled by calling drm_modeset_backoff()
.
Return
A pointer to the copy of the atomic state object on success or an
ERR_PTR()
-encoded error code on failure.
See also:
drm_atomic_helper_suspend()
, drm_atomic_helper_resume()
-
struct drm_atomic_state *
drm_atomic_helper_suspend
(struct drm_device * dev)¶ subsystem-level suspend helper
Parameters
struct drm_device * dev
- DRM device
Description
Duplicates the current atomic state, disables all active outputs and then
returns a pointer to the original atomic state to the caller. Drivers can
pass this pointer to the drm_atomic_helper_resume()
helper upon resume to
restore the output configuration that was active at the time the system
entered suspend.
Note that it is potentially unsafe to use this. The atomic state object returned by this function is assumed to be persistent. Drivers must ensure that this holds true. Before calling this function, drivers must make sure to suspend fbdev emulation so that nothing can be using the device.
Return
A pointer to a copy of the state before suspend on success or an ERR_PTR()
-
encoded error code on failure. Drivers should store the returned atomic
state object and pass it to the drm_atomic_helper_resume()
helper upon
resume.
See also:
drm_atomic_helper_duplicate_state()
, drm_atomic_helper_disable_all()
,
drm_atomic_helper_resume()
, drm_atomic_helper_commit_duplicated_state()
-
int
drm_atomic_helper_commit_duplicated_state
(struct drm_atomic_state * state, struct drm_modeset_acquire_ctx * ctx)¶ commit duplicated state
Parameters
struct drm_atomic_state * state
- duplicated atomic state to commit
struct drm_modeset_acquire_ctx * ctx
- pointer to acquire_ctx to use for commit.
Description
The state returned by drm_atomic_helper_duplicate_state()
and
drm_atomic_helper_suspend()
is partially invalid, and needs to
be fixed up before commit.
Return
0 on success or a negative error code on failure.
See also:
drm_atomic_helper_suspend()
-
int
drm_atomic_helper_resume
(struct drm_device * dev, struct drm_atomic_state * state)¶ subsystem-level resume helper
Parameters
struct drm_device * dev
- DRM device
struct drm_atomic_state * state
- atomic state to resume to
Description
Calls drm_mode_config_reset()
to synchronize hardware and software states,
grabs all modeset locks and commits the atomic state object. This can be
used in conjunction with the drm_atomic_helper_suspend()
helper to
implement suspend/resume for drivers that support atomic mode-setting.
Return
0 on success or a negative error code on failure.
See also:
drm_atomic_helper_suspend()
-
int
drm_atomic_helper_page_flip
(struct drm_crtc * crtc, struct drm_framebuffer * fb, struct drm_pending_vblank_event * event, uint32_t flags, struct drm_modeset_acquire_ctx * ctx)¶ execute a legacy page flip
Parameters
struct drm_crtc * crtc
- DRM CRTC
struct drm_framebuffer * fb
- DRM framebuffer
struct drm_pending_vblank_event * event
- optional DRM event to signal upon completion
uint32_t flags
- flip flags for non-vblank sync’ed updates
struct drm_modeset_acquire_ctx * ctx
- lock acquisition context
Description
Provides a default drm_crtc_funcs.page_flip
implementation
using the atomic driver interface.
Return
Returns 0 on success, negative errno numbers on failure.
See also:
drm_atomic_helper_page_flip_target()
-
int
drm_atomic_helper_page_flip_target
(struct drm_crtc * crtc, struct drm_framebuffer * fb, struct drm_pending_vblank_event * event, uint32_t flags, uint32_t target, struct drm_modeset_acquire_ctx * ctx)¶ do page flip on target vblank period.
Parameters
struct drm_crtc * crtc
- DRM CRTC
struct drm_framebuffer * fb
- DRM framebuffer
struct drm_pending_vblank_event * event
- optional DRM event to signal upon completion
uint32_t flags
- flip flags for non-vblank sync’ed updates
uint32_t target
- specifying the target vblank period when the flip to take effect
struct drm_modeset_acquire_ctx * ctx
- lock acquisition context
Description
Provides a default drm_crtc_funcs.page_flip_target
implementation.
Similar to drm_atomic_helper_page_flip()
with extra parameter to specify
target vblank period to flip.
Return
Returns 0 on success, negative errno numbers on failure.
-
u32 *
drm_atomic_helper_bridge_propagate_bus_fmt
(struct drm_bridge * bridge, struct drm_bridge_state * bridge_state, struct drm_crtc_state * crtc_state, struct drm_connector_state * conn_state, u32 output_fmt, unsigned int * num_input_fmts)¶ Propagate output format to the input end of a bridge
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_bridge_state * bridge_state
- new bridge state
struct drm_crtc_state * crtc_state
- new CRTC state
struct drm_connector_state * conn_state
- new connector state
u32 output_fmt
- tested output bus format
unsigned int * num_input_fmts
- will contain the size of the returned array
Description
This helper is a pluggable implementation of the
drm_bridge_funcs.atomic_get_input_bus_fmts
operation for bridges that don’t
modify the bus configuration between their input and their output. It
returns an array of input formats with a single element set to output_fmt.
Return
a valid format array of size num_input_fmts, or NULL if the allocation failed
Simple KMS Helper Reference¶
This helper library provides helpers for drivers for simple display hardware.
drm_simple_display_pipe_init()
initializes a simple display pipeline
which has only one full-screen scanout buffer feeding one output. The
pipeline is represented by struct drm_simple_display_pipe
and binds
together drm_plane
, drm_crtc
and drm_encoder
structures into one fixed
entity. Some flexibility for code reuse is provided through a separately
allocated drm_connector
object and supporting optional drm_bridge
encoder drivers.
Many drivers require only a very simple encoder that fulfills the minimum
requirements of the display pipeline and does not add additional
functionality. The function drm_simple_encoder_init()
provides an
implementation of such an encoder.
-
struct
drm_simple_display_pipe_funcs
¶ helper operations for a simple display pipeline
Definition
struct drm_simple_display_pipe_funcs {
enum drm_mode_status (*mode_valid)(struct drm_simple_display_pipe *pipe, const struct drm_display_mode *mode);
void (*enable)(struct drm_simple_display_pipe *pipe,struct drm_crtc_state *crtc_state, struct drm_plane_state *plane_state);
void (*disable)(struct drm_simple_display_pipe *pipe);
int (*check)(struct drm_simple_display_pipe *pipe,struct drm_plane_state *plane_state, struct drm_crtc_state *crtc_state);
void (*update)(struct drm_simple_display_pipe *pipe, struct drm_plane_state *old_plane_state);
int (*prepare_fb)(struct drm_simple_display_pipe *pipe, struct drm_plane_state *plane_state);
void (*cleanup_fb)(struct drm_simple_display_pipe *pipe, struct drm_plane_state *plane_state);
int (*enable_vblank)(struct drm_simple_display_pipe *pipe);
void (*disable_vblank)(struct drm_simple_display_pipe *pipe);
void (*reset_crtc)(struct drm_simple_display_pipe *pipe);
struct drm_crtc_state * (*duplicate_crtc_state)(struct drm_simple_display_pipe *pipe);
void (*destroy_crtc_state)(struct drm_simple_display_pipe *pipe, struct drm_crtc_state *crtc_state);
void (*reset_plane)(struct drm_simple_display_pipe *pipe);
struct drm_plane_state * (*duplicate_plane_state)(struct drm_simple_display_pipe *pipe);
void (*destroy_plane_state)(struct drm_simple_display_pipe *pipe, struct drm_plane_state *plane_state);
};
Members
mode_valid
This callback is used to check if a specific mode is valid in the crtc used in this simple display pipe. This should be implemented if the display pipe has some sort of restriction in the modes it can display. For example, a given display pipe may be responsible to set a clock value. If the clock can not produce all the values for the available modes then this callback can be used to restrict the number of modes to only the ones that can be displayed. Another reason can be bandwidth mitigation: the memory port on the display controller can have bandwidth limitations not allowing pixel data to be fetched at any rate.
This hook is used by the probe helpers to filter the mode list in
drm_helper_probe_single_connector_modes()
, and it is used by the atomic helpers to validate modes supplied by userspace indrm_atomic_helper_check_modeset()
.This function is optional.
NOTE:
Since this function is both called from the check phase of an atomic commit, and the mode validation in the probe paths it is not allowed to look at anything else but the passed-in mode, and validate it against configuration-invariant hardware constraints.
RETURNS:
drm_mode_status Enum
enable
- This function should be used to enable the pipeline. It is called when the underlying crtc is enabled. This hook is optional.
disable
- This function should be used to disable the pipeline. It is called when the underlying crtc is disabled. This hook is optional.
check
This function is called in the check phase of an atomic update, specifically when the underlying plane is checked. The simple display pipeline helpers already check that the plane is not scaled, fills the entire visible area and is always enabled when the crtc is also enabled. This hook is optional.
RETURNS:
0 on success, -EINVAL if the state or the transition can’t be supported, -ENOMEM on memory allocation failure and -EDEADLK if an attempt to obtain another state object ran into a
drm_modeset_lock
deadlock.update
This function is called when the underlying plane state is updated. This hook is optional.
This is the function drivers should submit the
drm_pending_vblank_event
from. Using eitherdrm_crtc_arm_vblank_event()
, when the driver supports vblank interrupt handling, ordrm_crtc_send_vblank_event()
for more complex case. In case the hardware lacks vblank support entirely, drivers can setstruct drm_crtc_state
.no_vblank instruct drm_simple_display_pipe_funcs
.check and let DRM’s atomic helper fake a vblank event.prepare_fb
Optional, called by
drm_plane_helper_funcs.prepare_fb
. Please read the documentation for thedrm_plane_helper_funcs.prepare_fb
hook for more details.For GEM drivers who neither have a prepare_fb nor cleanup_fb hook set
drm_gem_simple_display_pipe_prepare_fb()
is called automatically to implement this. Other drivers which need additional plane processing can calldrm_gem_simple_display_pipe_prepare_fb()
from their prepare_fb hook.cleanup_fb
- Optional, called by
drm_plane_helper_funcs.cleanup_fb
. Please read the documentation for thedrm_plane_helper_funcs.cleanup_fb
hook for more details. enable_vblank
- Optional, called by
drm_crtc_funcs.enable_vblank
. Please read the documentation for thedrm_crtc_funcs.enable_vblank
hook for more details. disable_vblank
- Optional, called by
drm_crtc_funcs.disable_vblank
. Please read the documentation for thedrm_crtc_funcs.disable_vblank
hook for more details. reset_crtc
- Optional, called by
drm_crtc_funcs.reset
. Please read the documentation for thedrm_crtc_funcs.reset
hook for more details. duplicate_crtc_state
- Optional, called by
drm_crtc_funcs.atomic_duplicate_state
. Please read the documentation for thedrm_crtc_funcs.atomic_duplicate_state
hook for more details. destroy_crtc_state
- Optional, called by
drm_crtc_funcs.atomic_destroy_state
. Please read the documentation for thedrm_crtc_funcs.atomic_destroy_state
hook for more details. reset_plane
- Optional, called by
drm_plane_funcs.reset
. Please read the documentation for thedrm_plane_funcs.reset
hook for more details. duplicate_plane_state
- Optional, called by
drm_plane_funcs.atomic_duplicate_state
. Please read the documentation for thedrm_plane_funcs.atomic_duplicate_state
hook for more details. destroy_plane_state
- Optional, called by
drm_plane_funcs.atomic_destroy_state
. Please read the documentation for thedrm_plane_funcs.atomic_destroy_state
hook for more details.
-
struct
drm_simple_display_pipe
¶ simple display pipeline
Definition
struct drm_simple_display_pipe {
struct drm_crtc crtc;
struct drm_plane plane;
struct drm_encoder encoder;
struct drm_connector *connector;
const struct drm_simple_display_pipe_funcs *funcs;
};
Members
crtc
- CRTC control structure
plane
- Plane control structure
encoder
- Encoder control structure
connector
- Connector control structure
funcs
- Pipeline control functions (optional)
Description
Simple display pipeline with plane, crtc and encoder collapsed into one
entity. It should be initialized by calling drm_simple_display_pipe_init()
.
-
drmm_simple_encoder_alloc
(dev, type, member, encoder_type)¶ Allocate and initialize an encoder with basic functionality.
Parameters
dev
- drm device
type
- the type of the struct which contains struct
drm_encoder
member
- the name of the
drm_encoder
within type. encoder_type
- user visible type of the encoder
Description
Allocates and initializes an encoder that has no further functionality.
Settings for possible CRTC and clones are left to their initial values.
Cleanup is automatically handled through registering drm_encoder_cleanup()
with drmm_add_action()
.
Return
Pointer to new encoder, or ERR_PTR on failure.
-
int
drm_simple_encoder_init
(struct drm_device * dev, struct drm_encoder * encoder, int encoder_type)¶ Initialize a preallocated encoder with basic functionality.
Parameters
struct drm_device * dev
- drm device
struct drm_encoder * encoder
- the encoder to initialize
int encoder_type
- user visible type of the encoder
Description
Initialises a preallocated encoder that has no further functionality. Settings for possible CRTC and clones are left to their initial values. The encoder will be cleaned up automatically as part of the mode-setting cleanup.
The caller of drm_simple_encoder_init()
is responsible for freeing
the encoder’s memory after the encoder has been cleaned up. At the
moment this only works reliably if the encoder data structure is
stored in the device structure. Free the encoder’s memory as part of
the device release function.
Note
consider using drmm_simple_encoder_alloc()
instead of
drm_simple_encoder_init()
to let the DRM managed resource infrastructure
take care of cleanup and deallocation.
Return
Zero on success, error code on failure.
-
int
drm_simple_display_pipe_attach_bridge
(struct drm_simple_display_pipe * pipe, struct drm_bridge * bridge)¶ Attach a bridge to the display pipe
Parameters
struct drm_simple_display_pipe * pipe
- simple display pipe object
struct drm_bridge * bridge
- bridge to attach
Description
Makes it possible to still use the drm_simple_display_pipe helpers when a DRM bridge has to be used.
Note that you probably want to initialize the pipe by passing a NULL
connector to drm_simple_display_pipe_init()
.
Return
Zero on success, negative error code on failure.
-
int
drm_simple_display_pipe_init
(struct drm_device * dev, struct drm_simple_display_pipe * pipe, const struct drm_simple_display_pipe_funcs * funcs, const uint32_t * formats, unsigned int format_count, const uint64_t * format_modifiers, struct drm_connector * connector)¶ Initialize a simple display pipeline
Parameters
struct drm_device * dev
- DRM device
struct drm_simple_display_pipe * pipe
- simple display pipe object to initialize
const struct drm_simple_display_pipe_funcs * funcs
- callbacks for the display pipe (optional)
const uint32_t * formats
- array of supported formats (DRM_FORMAT_*)
unsigned int format_count
- number of elements in formats
const uint64_t * format_modifiers
- array of formats modifiers
struct drm_connector * connector
- connector to attach and register (optional)
Description
Sets up a display pipeline which consist of a really simple plane-crtc-encoder pipe.
If a connector is supplied, the pipe will be coupled with the provided
connector. You may supply a NULL connector when using drm bridges, that
handle connectors themselves (see drm_simple_display_pipe_attach_bridge()
).
Teardown of a simple display pipe is all handled automatically by the drm
core through calling drm_mode_config_cleanup()
. Drivers afterwards need to
release the memory for the structure themselves.
Return
Zero on success, negative error code on failure.
fbdev Helper Functions Reference¶
The fb helper functions are useful to provide an fbdev on top of a drm kernel mode setting driver. They can be used mostly independently from the crtc helper functions used by many drivers to implement the kernel mode setting interfaces.
Drivers that support a dumb buffer with a virtual address and mmap support,
should try out the generic fbdev emulation using drm_fbdev_generic_setup()
.
It will automatically set up deferred I/O if the driver requires a shadow
buffer.
At runtime drivers should restore the fbdev console by using
drm_fb_helper_lastclose()
as their drm_driver.lastclose
callback.
They should also notify the fb helper code from updates to the output
configuration by using drm_fb_helper_output_poll_changed()
as their
drm_mode_config_funcs.output_poll_changed
callback.
For suspend/resume consider using drm_mode_config_helper_suspend()
and
drm_mode_config_helper_resume()
which takes care of fbdev as well.
All other functions exported by the fb helper library can be used to implement the fbdev driver interface by the driver.
It is possible, though perhaps somewhat tricky, to implement race-free
hotplug detection using the fbdev helpers. The drm_fb_helper_prepare()
helper must be called first to initialize the minimum required to make
hotplug detection work. Drivers also need to make sure to properly set up
the drm_mode_config.funcs
member. After calling drm_kms_helper_poll_init()
it is safe to enable interrupts and start processing hotplug events. At the
same time, drivers should initialize all modeset objects such as CRTCs,
encoders and connectors. To finish up the fbdev helper initialization, the
drm_fb_helper_init()
function is called. To probe for all attached displays
and set up an initial configuration using the detected hardware, drivers
should call drm_fb_helper_initial_config()
.
If drm_framebuffer_funcs.dirty
is set, the
drm_fb_helper_{cfb,sys}_{write,fillrect,copyarea,imageblit} functions will
accumulate changes and schedule drm_fb_helper.dirty_work
to run right
away. This worker then calls the dirty()
function ensuring that it will
always run in process context since the fb_*() function could be running in
atomic context. If drm_fb_helper_deferred_io()
is used as the deferred_io
callback it will also schedule dirty_work with the damage collected from the
mmap page writes.
Deferred I/O is not compatible with SHMEM. Such drivers should request an
fbdev shadow buffer and call drm_fbdev_generic_setup()
instead.
-
struct
drm_fb_helper_surface_size
¶ describes fbdev size and scanout surface size
Definition
struct drm_fb_helper_surface_size {
u32 fb_width;
u32 fb_height;
u32 surface_width;
u32 surface_height;
u32 surface_bpp;
u32 surface_depth;
};
Members
fb_width
- fbdev width
fb_height
- fbdev height
surface_width
- scanout buffer width
surface_height
- scanout buffer height
surface_bpp
- scanout buffer bpp
surface_depth
- scanout buffer depth
Description
Note that the scanout surface width/height may be larger than the fbdev
width/height. In case of multiple displays, the scanout surface is sized
according to the largest width/height (so it is large enough for all CRTCs
to scanout). But the fbdev width/height is sized to the minimum width/
height of all the displays. This ensures that fbcon fits on the smallest
of the attached displays. fb_width/fb_height is used by
drm_fb_helper_fill_info()
to fill out the fb_info.var
structure.
-
struct
drm_fb_helper_funcs
¶ driver callbacks for the fbdev emulation library
Definition
struct drm_fb_helper_funcs {
int (*fb_probe)(struct drm_fb_helper *helper, struct drm_fb_helper_surface_size *sizes);
};
Members
fb_probe
Driver callback to allocate and initialize the fbdev info structure. Furthermore it also needs to allocate the DRM framebuffer used to back the fbdev.
This callback is mandatory.
RETURNS:
The driver should return 0 on success and a negative error code on failure.
Description
Driver callbacks used by the fbdev emulation helper library.
-
struct
drm_fb_helper
¶ main structure to emulate fbdev on top of KMS
Definition
struct drm_fb_helper {
struct drm_client_dev client;
struct drm_client_buffer *buffer;
struct drm_framebuffer *fb;
struct drm_device *dev;
const struct drm_fb_helper_funcs *funcs;
struct fb_info *fbdev;
u32 pseudo_palette[17];
struct drm_clip_rect damage_clip;
spinlock_t damage_lock;
struct work_struct damage_work;
struct work_struct resume_work;
struct mutex lock;
struct list_head kernel_fb_list;
bool delayed_hotplug;
bool deferred_setup;
int preferred_bpp;
};
Members
client
- DRM client used by the generic fbdev emulation.
buffer
- Framebuffer used by the generic fbdev emulation.
fb
- Scanout framebuffer object
dev
- DRM device
funcs
- driver callbacks for fb helper
fbdev
- emulated fbdev device info struct
pseudo_palette
- fake palette of 16 colors
damage_clip
- clip rectangle used with deferred_io to accumulate damage to the screen buffer
damage_lock
- spinlock protecting damage_clip
damage_work
- worker used to flush the framebuffer
resume_work
- worker used during resume if the console lock is already taken
lock
Top-level FBDEV helper lock. This protects all internal data structures and lists, such as connector_info and crtc_info.
FIXME: fbdev emulation locking is a mess and long term we want to protect all helper internal state with this lock as well as reduce core KMS locking as much as possible.
kernel_fb_list
- Entry on the global kernel_fb_helper_list, used for kgdb entry/exit.
delayed_hotplug
- A hotplug was received while fbdev wasn’t in control of the DRM device, i.e. another KMS master was active. The output configuration needs to be reprobe when fbdev is in control again.
deferred_setup
If no outputs are connected (disconnected or unknown) the FB helper code will defer setup until at least one of the outputs shows up. This field keeps track of the status so that setup can be retried at every hotplug event until it succeeds eventually.
Protected by lock.
preferred_bpp
Temporary storage for the driver’s preferred BPP setting passed to FB helper initialization. This needs to be tracked so that deferred FB helper setup can pass this on.
See also: deferred_setup
Description
This is the main structure used by the fbdev helpers. Drivers supporting
fbdev emulation should embedded this into their overall driver structure.
Drivers must also fill out a struct drm_fb_helper_funcs
with a few
operations.
-
DRM_FB_HELPER_DEFAULT_OPS
()¶ helper define for drm drivers
Parameters
Description
Helper define to register default implementations of drm_fb_helper functions. To be used in struct fb_ops of drm drivers.
-
int
drm_fb_helper_debug_enter
(struct fb_info * info)¶ implementation for
fb_ops.fb_debug_enter
Parameters
struct fb_info * info
- fbdev registered by the helper
-
int
drm_fb_helper_debug_leave
(struct fb_info * info)¶ implementation for
fb_ops.fb_debug_leave
Parameters
struct fb_info * info
- fbdev registered by the helper
-
int
drm_fb_helper_restore_fbdev_mode_unlocked
(struct drm_fb_helper * fb_helper)¶ restore fbdev configuration
Parameters
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper, can be NULL
Description
This should be called from driver’s drm drm_driver.lastclose
callback
when implementing an fbcon on top of kms using this helper. This ensures that
the user isn’t greeted with a black screen when e.g. X dies.
Return
Zero if everything went ok, negative error code otherwise.
-
int
drm_fb_helper_blank
(int blank, struct fb_info * info)¶ implementation for
fb_ops.fb_blank
Parameters
int blank
- desired blanking state
struct fb_info * info
- fbdev registered by the helper
-
void
drm_fb_helper_prepare
(struct drm_device * dev, struct drm_fb_helper * helper, const struct drm_fb_helper_funcs * funcs)¶ setup a drm_fb_helper structure
Parameters
struct drm_device * dev
- DRM device
struct drm_fb_helper * helper
- driver-allocated fbdev helper structure to set up
const struct drm_fb_helper_funcs * funcs
- pointer to structure of functions associate with this helper
Description
Sets up the bare minimum to make the framebuffer helper usable. This is useful to implement race-free initialization of the polling helpers.
-
int
drm_fb_helper_init
(struct drm_device * dev, struct drm_fb_helper * fb_helper)¶ initialize a
struct drm_fb_helper
Parameters
struct drm_device * dev
- drm device
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper structure to initialize
Description
This allocates the structures for the fbdev helper with the given limits.
Note that this won’t yet touch the hardware (through the driver interfaces)
nor register the fbdev. This is only done in drm_fb_helper_initial_config()
to allow driver writes more control over the exact init sequence.
Drivers must call drm_fb_helper_prepare()
before calling this function.
Return
Zero if everything went ok, nonzero otherwise.
-
struct fb_info *
drm_fb_helper_alloc_fbi
(struct drm_fb_helper * fb_helper)¶ allocate fb_info and some of its members
Parameters
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper
Description
A helper to alloc fb_info and the members cmap and apertures. Called
by the driver within the fb_probe fb_helper callback function. Drivers do not
need to release the allocated fb_info structure themselves, this is
automatically done when calling drm_fb_helper_fini()
.
Return
fb_info pointer if things went okay, pointer containing error code otherwise
-
void
drm_fb_helper_unregister_fbi
(struct drm_fb_helper * fb_helper)¶ unregister fb_info framebuffer device
Parameters
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper, can be NULL
Description
A wrapper around unregister_framebuffer, to release the fb_info
framebuffer device. This must be called before releasing all resources for
fb_helper by calling drm_fb_helper_fini()
.
-
void
drm_fb_helper_fini
(struct drm_fb_helper * fb_helper)¶ finialize a
struct drm_fb_helper
Parameters
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper, can be NULL
Description
This cleans up all remaining resources associated with fb_helper.
-
void
drm_fb_helper_deferred_io
(struct fb_info * info, struct list_head * pagereflist)¶ fbdev deferred_io callback function
Parameters
struct fb_info * info
- fb_info struct pointer
struct list_head * pagereflist
- list of mmap framebuffer pages that have to be flushed
Description
This function is used as the fb_deferred_io.deferred_io
callback function for flushing the fbdev mmap writes.
-
ssize_t
drm_fb_helper_sys_read
(struct fb_info * info, char __user * buf, size_t count, loff_t * ppos)¶ wrapper around fb_sys_read
Parameters
struct fb_info * info
- fb_info struct pointer
char __user * buf
- userspace buffer to read from framebuffer memory
size_t count
- number of bytes to read from framebuffer memory
loff_t * ppos
- read offset within framebuffer memory
Description
A wrapper around fb_sys_read implemented by fbdev core
-
ssize_t
drm_fb_helper_sys_write
(struct fb_info * info, const char __user * buf, size_t count, loff_t * ppos)¶ wrapper around fb_sys_write
Parameters
struct fb_info * info
- fb_info struct pointer
const char __user * buf
- userspace buffer to write to framebuffer memory
size_t count
- number of bytes to write to framebuffer memory
loff_t * ppos
- write offset within framebuffer memory
Description
A wrapper around fb_sys_write implemented by fbdev core
-
void
drm_fb_helper_sys_fillrect
(struct fb_info * info, const struct fb_fillrect * rect)¶ wrapper around sys_fillrect
Parameters
struct fb_info * info
- fbdev registered by the helper
const struct fb_fillrect * rect
- info about rectangle to fill
Description
A wrapper around sys_fillrect implemented by fbdev core
-
void
drm_fb_helper_sys_copyarea
(struct fb_info * info, const struct fb_copyarea * area)¶ wrapper around sys_copyarea
Parameters
struct fb_info * info
- fbdev registered by the helper
const struct fb_copyarea * area
- info about area to copy
Description
A wrapper around sys_copyarea implemented by fbdev core
-
void
drm_fb_helper_sys_imageblit
(struct fb_info * info, const struct fb_image * image)¶ wrapper around sys_imageblit
Parameters
struct fb_info * info
- fbdev registered by the helper
const struct fb_image * image
- info about image to blit
Description
A wrapper around sys_imageblit implemented by fbdev core
-
void
drm_fb_helper_cfb_fillrect
(struct fb_info * info, const struct fb_fillrect * rect)¶ wrapper around cfb_fillrect
Parameters
struct fb_info * info
- fbdev registered by the helper
const struct fb_fillrect * rect
- info about rectangle to fill
Description
A wrapper around cfb_fillrect implemented by fbdev core
-
void
drm_fb_helper_cfb_copyarea
(struct fb_info * info, const struct fb_copyarea * area)¶ wrapper around cfb_copyarea
Parameters
struct fb_info * info
- fbdev registered by the helper
const struct fb_copyarea * area
- info about area to copy
Description
A wrapper around cfb_copyarea implemented by fbdev core
-
void
drm_fb_helper_cfb_imageblit
(struct fb_info * info, const struct fb_image * image)¶ wrapper around cfb_imageblit
Parameters
struct fb_info * info
- fbdev registered by the helper
const struct fb_image * image
- info about image to blit
Description
A wrapper around cfb_imageblit implemented by fbdev core
-
void
drm_fb_helper_set_suspend
(struct drm_fb_helper * fb_helper, bool suspend)¶ wrapper around fb_set_suspend
Parameters
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper, can be NULL
bool suspend
- whether to suspend or resume
Description
A wrapper around fb_set_suspend implemented by fbdev core.
Use drm_fb_helper_set_suspend_unlocked()
if you don’t need to take
the lock yourself
-
void
drm_fb_helper_set_suspend_unlocked
(struct drm_fb_helper * fb_helper, bool suspend)¶ wrapper around fb_set_suspend that also takes the console lock
Parameters
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper, can be NULL
bool suspend
- whether to suspend or resume
Description
A wrapper around fb_set_suspend()
that takes the console lock. If the lock
isn’t available on resume, a worker is tasked with waiting for the lock
to become available. The console lock can be pretty contented on resume
due to all the printk activity.
This function can be called multiple times with the same state since
fb_info.state
is checked to see if fbdev is running or not before locking.
Use drm_fb_helper_set_suspend()
if you need to take the lock yourself.
-
int
drm_fb_helper_setcmap
(struct fb_cmap * cmap, struct fb_info * info)¶ implementation for
fb_ops.fb_setcmap
Parameters
struct fb_cmap * cmap
- cmap to set
struct fb_info * info
- fbdev registered by the helper
-
int
drm_fb_helper_ioctl
(struct fb_info * info, unsigned int cmd, unsigned long arg)¶ legacy ioctl implementation
Parameters
struct fb_info * info
- fbdev registered by the helper
unsigned int cmd
- ioctl command
unsigned long arg
- ioctl argument
Description
A helper to implement the standard fbdev ioctl. Only FBIO_WAITFORVSYNC is implemented for now.
-
int
drm_fb_helper_check_var
(struct fb_var_screeninfo * var, struct fb_info * info)¶ implementation for
fb_ops.fb_check_var
Parameters
struct fb_var_screeninfo * var
- screeninfo to check
struct fb_info * info
- fbdev registered by the helper
-
int
drm_fb_helper_set_par
(struct fb_info * info)¶ implementation for
fb_ops.fb_set_par
Parameters
struct fb_info * info
- fbdev registered by the helper
Description
This will let fbcon do the mode init and is called at initialization time by the fbdev core when registering the driver, and later on through the hotplug callback.
-
int
drm_fb_helper_pan_display
(struct fb_var_screeninfo * var, struct fb_info * info)¶ implementation for
fb_ops.fb_pan_display
Parameters
struct fb_var_screeninfo * var
- updated screen information
struct fb_info * info
- fbdev registered by the helper
-
void
drm_fb_helper_fill_info
(struct fb_info * info, struct drm_fb_helper * fb_helper, struct drm_fb_helper_surface_size * sizes)¶ initializes fbdev information
Parameters
struct fb_info * info
- fbdev instance to set up
struct drm_fb_helper * fb_helper
- fb helper instance to use as template
struct drm_fb_helper_surface_size * sizes
- describes fbdev size and scanout surface size
Description
Sets up the variable and fixed fbdev metainformation from the given fb helper
instance and the drm framebuffer allocated in drm_fb_helper.fb
.
Drivers should call this (or their equivalent setup code) from their
drm_fb_helper_funcs.fb_probe
callback after having allocated the fbdev
backing storage framebuffer.
-
int
drm_fb_helper_initial_config
(struct drm_fb_helper * fb_helper, int bpp_sel)¶ setup a sane initial connector configuration
Parameters
struct drm_fb_helper * fb_helper
- fb_helper device struct
int bpp_sel
- bpp value to use for the framebuffer configuration
Description
Scans the CRTCs and connectors and tries to put together an initial setup. At the moment, this is a cloned configuration across all heads with a new framebuffer object as the backing store.
Note that this also registers the fbdev and so allows userspace to call into the driver through the fbdev interfaces.
This function will call down into the drm_fb_helper_funcs.fb_probe
callback
to let the driver allocate and initialize the fbdev info structure and the
drm framebuffer used to back the fbdev. drm_fb_helper_fill_info()
is provided
as a helper to setup simple default values for the fbdev info structure.
HANG DEBUGGING:
When you have fbcon support built-in or already loaded, this function will do
a full modeset to setup the fbdev console. Due to locking misdesign in the
VT/fbdev subsystem that entire modeset sequence has to be done while holding
console_lock. Until console_unlock is called no dmesg lines will be sent out
to consoles, not even serial console. This means when your driver crashes,
you will see absolutely nothing else but a system stuck in this function,
with no further output. Any kind of printk()
you place within your own driver
or in the drm core modeset code will also never show up.
Standard debug practice is to run the fbcon setup without taking the console_lock as a hack, to be able to see backtraces and crashes on the serial line. This can be done by setting the fb.lockless_register_fb=1 kernel cmdline option.
The other option is to just disable fbdev emulation since very likely the first modeset from userspace will crash in the same way, and is even easier to debug. This can be done by setting the drm_kms_helper.fbdev_emulation=0 kernel cmdline option.
Return
Zero if everything went ok, nonzero otherwise.
-
int
drm_fb_helper_hotplug_event
(struct drm_fb_helper * fb_helper)¶ respond to a hotplug notification by probing all the outputs attached to the fb
Parameters
struct drm_fb_helper * fb_helper
- driver-allocated fbdev helper, can be NULL
Description
Scan the connectors attached to the fb_helper and try to put together a setup after notification of a change in output configuration.
Called at runtime, takes the mode config locks to be able to check/change the modeset configuration. Must be run from process context (which usually means either the output polling work or a work item launched from the driver’s hotplug interrupt).
Note that drivers may call this even before calling drm_fb_helper_initial_config but only after drm_fb_helper_init. This allows for a race-free fbcon setup and will make sure that the fbdev emulation will not miss any hotplug events.
Return
0 on success and a non-zero error code otherwise.
-
void
drm_fb_helper_lastclose
(struct drm_device * dev)¶ DRM driver lastclose helper for fbdev emulation
Parameters
struct drm_device * dev
- DRM device
Description
This function can be used as the drm_driver->lastclose
callback for drivers
that only need to call drm_fb_helper_restore_fbdev_mode_unlocked()
.
-
void
drm_fb_helper_output_poll_changed
(struct drm_device * dev)¶ DRM mode config .output_poll_changed helper for fbdev emulation
Parameters
struct drm_device * dev
- DRM device
Description
This function can be used as the
drm_mode_config_funcs.output_poll_changed
callback for drivers that only
need to call drm_fb_helper_hotplug_event()
.
-
void
drm_fbdev_generic_setup
(struct drm_device * dev, unsigned int preferred_bpp)¶ Setup generic fbdev emulation
Parameters
struct drm_device * dev
- DRM device
unsigned int preferred_bpp
- Preferred bits per pixel for the device. dev->mode_config.preferred_depth is used if this is zero.
Description
This function sets up generic fbdev emulation for drivers that supports
dumb buffers with a virtual address and that can be mmap’ed.
drm_fbdev_generic_setup()
shall be called after the DRM driver registered
the new DRM device with drm_dev_register()
.
Restore, hotplug events and teardown are all taken care of. Drivers that do
suspend/resume need to call drm_fb_helper_set_suspend_unlocked()
themselves.
Simple drivers might use drm_mode_config_helper_suspend()
.
Drivers that set the dirty callback on their framebuffer will get a shadow fbdev buffer that is blitted onto the real buffer. This is done in order to make deferred I/O work with all kinds of buffers. A shadow buffer can be requested explicitly by setting struct drm_mode_config.prefer_shadow or struct drm_mode_config.prefer_shadow_fbdev to true beforehand. This is required to use generic fbdev emulation with SHMEM helpers.
This function is safe to call even when there are no connectors present. Setup will be retried on the next hotplug event.
The fbdev is destroyed by drm_dev_unregister()
.
Framebuffer CMA Helper Functions Reference¶
Provides helper functions for creating a cma (contiguous memory allocator) backed framebuffer.
drm_gem_fb_create()
is used in the drm_mode_config_funcs.fb_create
callback function to create a cma backed framebuffer.
-
struct drm_gem_cma_object *
drm_fb_cma_get_gem_obj
(struct drm_framebuffer * fb, unsigned int plane)¶ Get CMA GEM object for framebuffer
Parameters
struct drm_framebuffer * fb
- The framebuffer
unsigned int plane
- Which plane
Description
Return the CMA GEM object for given framebuffer.
This function will usually be called from the CRTC callback functions.
-
dma_addr_t
drm_fb_cma_get_gem_addr
(struct drm_framebuffer * fb, struct drm_plane_state * state, unsigned int plane)¶ Get physical address for framebuffer, for pixel formats where values are grouped in blocks this will get you the beginning of the block
Parameters
struct drm_framebuffer * fb
- The framebuffer
struct drm_plane_state * state
- Which state of drm plane
unsigned int plane
- Which plane Return the CMA GEM address for given framebuffer.
Description
This function will usually be called from the PLANE callback functions.
-
void
drm_fb_cma_sync_non_coherent
(struct drm_device * drm, struct drm_plane_state * old_state, struct drm_plane_state * state)¶ Sync GEM object to non-coherent backing memory
Parameters
struct drm_device * drm
- DRM device
struct drm_plane_state * old_state
- Old plane state
struct drm_plane_state * state
- New plane state
Description
This function can be used by drivers that use damage clips and have CMA GEM objects backed by non-coherent memory. Calling this function in a plane’s .atomic_update ensures that all the data in the backing memory have been written to RAM.
Bridges¶
Overview¶
struct drm_bridge
represents a device that hangs on to an encoder. These are
handy when a regular drm_encoder
entity isn’t enough to represent the entire
encoder chain.
A bridge is always attached to a single drm_encoder
at a time, but can be
either connected to it directly, or through a chain of bridges:
[ CRTC ---> ] Encoder ---> Bridge A ---> Bridge B
Here, the output of the encoder feeds to bridge A, and that furthers feeds to bridge B. Bridge chains can be arbitrarily long, and shall be fully linear: Chaining multiple bridges to the output of a bridge, or the same bridge to the output of different bridges, is not supported.
drm_bridge
, like drm_panel
, aren’t drm_mode_object
entities like planes,
CRTCs, encoders or connectors and hence are not visible to userspace. They
just provide additional hooks to get the desired output at the end of the
encoder chain.
Default bridge callback sequence¶
Bridge Helper Reference¶
-
enum
drm_bridge_attach_flags
¶ Flags for
drm_bridge_funcs.attach
Constants
DRM_BRIDGE_ATTACH_NO_CONNECTOR
- When this flag is set the bridge shall not create a drm_connector.
-
struct
drm_bridge_funcs
¶ drm_bridge control functions
Definition
struct drm_bridge_funcs {
int (*attach)(struct drm_bridge *bridge, enum drm_bridge_attach_flags flags);
void (*detach)(struct drm_bridge *bridge);
enum drm_mode_status (*mode_valid)(struct drm_bridge *bridge,const struct drm_display_info *info, const struct drm_display_mode *mode);
bool (*mode_fixup)(struct drm_bridge *bridge,const struct drm_display_mode *mode, struct drm_display_mode *adjusted_mode);
void (*disable)(struct drm_bridge *bridge);
void (*post_disable)(struct drm_bridge *bridge);
void (*mode_set)(struct drm_bridge *bridge,const struct drm_display_mode *mode, const struct drm_display_mode *adjusted_mode);
void (*pre_enable)(struct drm_bridge *bridge);
void (*enable)(struct drm_bridge *bridge);
void (*atomic_pre_enable)(struct drm_bridge *bridge, struct drm_bridge_state *old_bridge_state);
void (*atomic_enable)(struct drm_bridge *bridge, struct drm_bridge_state *old_bridge_state);
void (*atomic_disable)(struct drm_bridge *bridge, struct drm_bridge_state *old_bridge_state);
void (*atomic_post_disable)(struct drm_bridge *bridge, struct drm_bridge_state *old_bridge_state);
struct drm_bridge_state *(*atomic_duplicate_state)(struct drm_bridge *bridge);
void (*atomic_destroy_state)(struct drm_bridge *bridge, struct drm_bridge_state *state);
u32 *(*atomic_get_output_bus_fmts)(struct drm_bridge *bridge,struct drm_bridge_state *bridge_state,struct drm_crtc_state *crtc_state,struct drm_connector_state *conn_state, unsigned int *num_output_fmts);
u32 *(*atomic_get_input_bus_fmts)(struct drm_bridge *bridge,struct drm_bridge_state *bridge_state,struct drm_crtc_state *crtc_state,struct drm_connector_state *conn_state,u32 output_fmt, unsigned int *num_input_fmts);
int (*atomic_check)(struct drm_bridge *bridge,struct drm_bridge_state *bridge_state,struct drm_crtc_state *crtc_state, struct drm_connector_state *conn_state);
struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge);
enum drm_connector_status (*detect)(struct drm_bridge *bridge);
int (*get_modes)(struct drm_bridge *bridge, struct drm_connector *connector);
struct edid *(*get_edid)(struct drm_bridge *bridge, struct drm_connector *connector);
void (*hpd_notify)(struct drm_bridge *bridge, enum drm_connector_status status);
void (*hpd_enable)(struct drm_bridge *bridge);
void (*hpd_disable)(struct drm_bridge *bridge);
void (*debugfs_init)(struct drm_bridge *bridge, struct dentry *root);
};
Members
attach
This callback is invoked whenever our bridge is being attached to a
drm_encoder
. The flags argument tunes the behaviour of the attach operation (see DRM_BRIDGE_ATTACH_*).The attach callback is optional.
RETURNS:
Zero on success, error code on failure.
detach
This callback is invoked whenever our bridge is being detached from a
drm_encoder
.The detach callback is optional.
mode_valid
This callback is used to check if a specific mode is valid in this bridge. This should be implemented if the bridge has some sort of restriction in the modes it can display. For example, a given bridge may be responsible to set a clock value. If the clock can not produce all the values for the available modes then this callback can be used to restrict the number of modes to only the ones that can be displayed.
This hook is used by the probe helpers to filter the mode list in
drm_helper_probe_single_connector_modes()
, and it is used by the atomic helpers to validate modes supplied by userspace indrm_atomic_helper_check_modeset()
.The mode_valid callback is optional.
NOTE:
Since this function is both called from the check phase of an atomic commit, and the mode validation in the probe paths it is not allowed to look at anything else but the passed-in mode, and validate it against configuration-invariant hardward constraints. Any further limits which depend upon the configuration can only be checked in mode_fixup.
RETURNS:
drm_mode_status Enum
mode_fixup
This callback is used to validate and adjust a mode. The parameter mode is the display mode that should be fed to the next element in the display chain, either the final
drm_connector
or the nextdrm_bridge
. The parameter adjusted_mode is the input mode the bridge requires. It can be modified by this callback and does not need to match mode. See alsodrm_crtc_state.adjusted_mode
for more details.This is the only hook that allows a bridge to reject a modeset. If this function passes all other callbacks must succeed for this configuration.
The mode_fixup callback is optional.
drm_bridge_funcs.mode_fixup()
is not called whendrm_bridge_funcs.atomic_check()
is implemented, so only one of them should be provided.NOTE:
This function is called in the check 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 beware that userspace can request its own custom modes, neither core nor helpers filter modes to the list of probe modes reported by the GETCONNECTOR IOCTL and stored in
drm_connector.modes
. To ensure that modes are filtered consistently put any bridge constraints and limits checks into mode_valid.RETURNS:
True if an acceptable configuration is possible, false if the modeset operation should be rejected.
disable
This callback should disable the bridge. It is called right before the preceding element in the display pipe is disabled. If the preceding element is a bridge this means it’s called before that bridge’s disable vfunc. If the preceding element is a
drm_encoder
it’s called right before thedrm_encoder_helper_funcs.disable
,drm_encoder_helper_funcs.prepare
ordrm_encoder_helper_funcs.dpms
hook.The bridge can assume that the display pipe (i.e. clocks and timing signals) feeding it is still running when this callback is called.
The disable callback is optional.
NOTE:
This is deprecated, do not use! New drivers shall use
drm_bridge_funcs.atomic_disable
.post_disable
This callback should disable the bridge. It is called right after the preceding element in the display pipe is disabled. If the preceding element is a bridge this means it’s called after that bridge’s post_disable function. If the preceding element is a
drm_encoder
it’s called right after the encoder’sdrm_encoder_helper_funcs.disable
,drm_encoder_helper_funcs.prepare
ordrm_encoder_helper_funcs.dpms
hook.The bridge must assume that the display pipe (i.e. clocks and timing singals) feeding it is no longer running when this callback is called.
The post_disable callback is optional.
NOTE:
This is deprecated, do not use! New drivers shall use
drm_bridge_funcs.atomic_post_disable
.mode_set
This callback should set the given mode on the bridge. It is called after the mode_set callback for the preceding element in the display pipeline has been called already. If the bridge is the first element then this would be
drm_encoder_helper_funcs.mode_set
. The display pipe (i.e. clocks and timing signals) is off when this function is called.The adjusted_mode parameter is the mode output by the CRTC for the first bridge in the chain. It can be different from the mode parameter that contains the desired mode for the connector at the end of the bridges chain, for instance when the first bridge in the chain performs scaling. The adjusted mode is mostly useful for the first bridge in the chain and is likely irrelevant for the other bridges.
For atomic drivers the adjusted_mode is the mode stored in
drm_crtc_state.adjusted_mode
.NOTE:
This is deprecated, do not use! New drivers shall set their mode in the
drm_bridge_funcs.atomic_enable
operation.pre_enable
This callback should enable the bridge. It is called right before the preceding element in the display pipe is enabled. If the preceding element is a bridge this means it’s called before that bridge’s pre_enable function. If the preceding element is a
drm_encoder
it’s called right before the encoder’sdrm_encoder_helper_funcs.enable
,drm_encoder_helper_funcs.commit
ordrm_encoder_helper_funcs.dpms
hook.The display pipe (i.e. clocks and timing signals) feeding this bridge will not yet be running when this callback is called. The bridge must not enable the display link feeding the next bridge in the chain (if there is one) when this callback is called.
The pre_enable callback is optional.
NOTE:
This is deprecated, do not use! New drivers shall use
drm_bridge_funcs.atomic_pre_enable
.enable
This callback should enable the bridge. It is called right after the preceding element in the display pipe is enabled. If the preceding element is a bridge this means it’s called after that bridge’s enable function. If the preceding element is a
drm_encoder
it’s called right after the encoder’sdrm_encoder_helper_funcs.enable
,drm_encoder_helper_funcs.commit
ordrm_encoder_helper_funcs.dpms
hook.The bridge can assume that the display pipe (i.e. clocks and timing signals) feeding it is running when this callback is called. This callback must enable the display link feeding the next bridge in the chain if there is one.
The enable callback is optional.
NOTE:
This is deprecated, do not use! New drivers shall use
drm_bridge_funcs.atomic_enable
.atomic_pre_enable
This callback should enable the bridge. It is called right before the preceding element in the display pipe is enabled. If the preceding element is a bridge this means it’s called before that bridge’s atomic_pre_enable or pre_enable function. If the preceding element is a
drm_encoder
it’s called right before the encoder’sdrm_encoder_helper_funcs.atomic_enable
hook.The display pipe (i.e. clocks and timing signals) feeding this bridge will not yet be running when this callback is called. The bridge must not enable the display link feeding the next bridge in the chain (if there is one) when this callback is called.
Note that this function will only be invoked in the context of an atomic commit. It will not be invoked from
drm_bridge_chain_pre_enable
. It would be prudent to also provide an implementation of pre_enable if you are expecting driver calls intodrm_bridge_chain_pre_enable
.The atomic_pre_enable callback is optional.
atomic_enable
This callback should enable the bridge. It is called right after the preceding element in the display pipe is enabled. If the preceding element is a bridge this means it’s called after that bridge’s atomic_enable or enable function. If the preceding element is a
drm_encoder
it’s called right after the encoder’sdrm_encoder_helper_funcs.atomic_enable
hook.The bridge can assume that the display pipe (i.e. clocks and timing signals) feeding it is running when this callback is called. This callback must enable the display link feeding the next bridge in the chain if there is one.
Note that this function will only be invoked in the context of an atomic commit. It will not be invoked from
drm_bridge_chain_enable
. It would be prudent to also provide an implementation of enable if you are expecting driver calls intodrm_bridge_chain_enable
.The atomic_enable callback is optional.
atomic_disable
This callback should disable the bridge. It is called right before the preceding element in the display pipe is disabled. If the preceding element is a bridge this means it’s called before that bridge’s atomic_disable or disable vfunc. If the preceding element is a
drm_encoder
it’s called right before thedrm_encoder_helper_funcs.atomic_disable
hook.The bridge can assume that the display pipe (i.e. clocks and timing signals) feeding it is still running when this callback is called.
Note that this function will only be invoked in the context of an atomic commit. It will not be invoked from
drm_bridge_chain_disable
. It would be prudent to also provide an implementation of disable if you are expecting driver calls intodrm_bridge_chain_disable
.The atomic_disable callback is optional.
atomic_post_disable
This callback should disable the bridge. It is called right after the preceding element in the display pipe is disabled. If the preceding element is a bridge this means it’s called after that bridge’s atomic_post_disable or post_disable function. If the preceding element is a
drm_encoder
it’s called right after the encoder’sdrm_encoder_helper_funcs.atomic_disable
hook.The bridge must assume that the display pipe (i.e. clocks and timing signals) feeding it is no longer running when this callback is called.
Note that this function will only be invoked in the context of an atomic commit. It will not be invoked from
drm_bridge_chain_post_disable
. It would be prudent to also provide an implementation of post_disable if you are expecting driver calls intodrm_bridge_chain_post_disable
.The atomic_post_disable callback is optional.
atomic_duplicate_state
Duplicate the current bridge state object (which is guaranteed to be non-NULL).
The atomic_duplicate_state hook is mandatory if the bridge implements any of the atomic hooks, and should be left unassigned otherwise. For bridges that don’t subclass
drm_bridge_state
, thedrm_atomic_helper_bridge_duplicate_state()
helper function shall be used to implement this hook.RETURNS: A valid drm_bridge_state object or NULL if the allocation fails.
atomic_destroy_state
Destroy a bridge state object previously allocated by
drm_bridge_funcs.atomic_duplicate_state()
.The atomic_destroy_state hook is mandatory if the bridge implements any of the atomic hooks, and should be left unassigned otherwise. For bridges that don’t subclass
drm_bridge_state
, thedrm_atomic_helper_bridge_destroy_state()
helper function shall be used to implement this hook.atomic_get_output_bus_fmts
Return the supported bus formats on the output end of a bridge. The returned array must be allocated with
kmalloc()
and will be freed by the caller. If the allocation fails, NULL should be returned. num_output_fmts must be set to the returned array size. Formats listed in the returned array should be listed in decreasing preference order (the core will try all formats until it finds one that works).This method is only called on the last element of the bridge chain as part of the bus format negotiation process that happens in &:c:func:drm_atomic_bridge_chain_select_bus_fmts(). This method is optional. When not implemented, the core will fall back to
drm_connector.display_info
.bus_formats[0] ifdrm_connector.display_info
.num_bus_formats > 0, or to MEDIA_BUS_FMT_FIXED otherwise.atomic_get_input_bus_fmts
Return the supported bus formats on the input end of a bridge for a specific output bus format.
The returned array must be allocated with
kmalloc()
and will be freed by the caller. If the allocation fails, NULL should be returned. num_output_fmts must be set to the returned array size. Formats listed in the returned array should be listed in decreasing preference order (the core will try all formats until it finds one that works). When the format is not supported NULL should be returned and num_output_fmts should be set to 0.This method is called on all elements of the bridge chain as part of the bus format negotiation process that happens in
drm_atomic_bridge_chain_select_bus_fmts()
. This method is optional. When not implemented, the core will bypass bus format negotiation on this element of the bridge without failing, and the previous element in the chain will be passed MEDIA_BUS_FMT_FIXED as its output bus format.Bridge drivers that need to support being linked to bridges that are not supporting bus format negotiation should handle the output_fmt == MEDIA_BUS_FMT_FIXED case appropriately, by selecting a sensible default value or extracting this information from somewhere else (FW property,
drm_display_mode
,drm_display_info
, …)Note: Even if input format selection on the first bridge has no impact on the negotiation process (bus format negotiation stops once we reach the first element of the chain), drivers are expected to return accurate input formats as the input format may be used to configure the CRTC output appropriately.
atomic_check
This method is responsible for checking bridge state correctness. It can also check the state of the surrounding components in chain to make sure the whole pipeline can work properly.
drm_bridge_funcs.atomic_check()
hooks are called in reverse order (from the last to the first bridge).This method is optional.
drm_bridge_funcs.mode_fixup()
is not called whendrm_bridge_funcs.atomic_check()
is implemented, so only one of them should be provided.If drivers need to tweak
drm_bridge_state.input_bus_cfg
.flags ordrm_bridge_state.output_bus_cfg
.flags it should happen in this function. By default thedrm_bridge_state.output_bus_cfg
.flags field is set to the next bridgedrm_bridge_state.input_bus_cfg
.flags value ordrm_connector.display_info
.bus_flags if the bridge is the last element in the chain.RETURNS: zero if the check passed, a negative error code otherwise.
atomic_reset
Reset the bridge to a predefined state (or retrieve its current state) and return a
drm_bridge_state
object matching this state. This function is called at attach time.The atomic_reset hook is mandatory if the bridge implements any of the atomic hooks, and should be left unassigned otherwise. For bridges that don’t subclass
drm_bridge_state
, thedrm_atomic_helper_bridge_reset()
helper function shall be used to implement this hook.Note that the
atomic_reset()
semantics is not exactly matching thereset()
semantics found on other components (connector, plane, …).- The reset operation happens when the bridge is attached, not when
drm_mode_config_reset()
is called - It’s meant to be used exclusively on bridges that have been converted to the ATOMIC API
RETURNS: A valid drm_bridge_state object in case of success, an
ERR_PTR()
giving the reason of the failure otherwise.- The reset operation happens when the bridge is attached, not when
detect
Check if anything is attached to the bridge output.
This callback is optional, if not implemented the bridge will be considered as always having a component attached to its output. Bridges that implement this callback shall set the DRM_BRIDGE_OP_DETECT flag in their
drm_bridge->ops
.RETURNS:
drm_connector_status indicating the bridge output status.
get_modes
Fill all modes currently valid for the sink into the
drm_connector
withdrm_mode_probed_add()
.The get_modes callback is mostly intended to support non-probeable displays such as many fixed panels. Bridges that support reading EDID shall leave get_modes unimplemented and implement the
drm_bridge_funcs->get_edid
callback instead.This callback is optional. Bridges that implement it shall set the DRM_BRIDGE_OP_MODES flag in their
drm_bridge->ops
.The connector parameter shall be used for the sole purpose of filling modes, and shall not be stored internally by bridge drivers for future usage.
RETURNS:
The number of modes added by calling
drm_mode_probed_add()
.get_edid
Read and parse the EDID data of the connected display.
The get_edid callback is the preferred way of reporting mode information for a display connected to the bridge output. Bridges that support reading EDID shall implement this callback and leave the get_modes callback unimplemented.
The caller of this operation shall first verify the output connection status and refrain from reading EDID from a disconnected output.
This callback is optional. Bridges that implement it shall set the DRM_BRIDGE_OP_EDID flag in their
drm_bridge->ops
.The connector parameter shall be used for the sole purpose of EDID retrieval and parsing, and shall not be stored internally by bridge drivers for future usage.
RETURNS:
An edid structure newly allocated with
kmalloc()
(or similar) on success, or NULL otherwise. The caller is responsible for freeing the returned edid structure withkfree()
.hpd_notify
Notify the bridge of hot plug detection.
This callback is optional, it may be implemented by bridges that need to be notified of display connection or disconnection for internal reasons. One use case is to reset the internal state of CEC controllers for HDMI bridges.
hpd_enable
Enable hot plug detection. From now on the bridge shall call
drm_bridge_hpd_notify()
each time a change is detected in the output connection status, until hot plug detection gets disabled with hpd_disable.This callback is optional and shall only be implemented by bridges that support hot-plug notification without polling. Bridges that implement it shall also implement the hpd_disable callback and set the DRM_BRIDGE_OP_HPD flag in their
drm_bridge->ops
.hpd_disable
Disable hot plug detection. Once this function returns the bridge shall not call
drm_bridge_hpd_notify()
when a change in the output connection status occurs.This callback is optional and shall only be implemented by bridges that support hot-plug notification without polling. Bridges that implement it shall also implement the hpd_enable callback and set the DRM_BRIDGE_OP_HPD flag in their
drm_bridge->ops
.debugfs_init
- Allows bridges to create bridge-specific debugfs files.
-
struct
drm_bridge_timings
¶ timing information for the bridge
Definition
struct drm_bridge_timings {
u32 input_bus_flags;
u32 setup_time_ps;
u32 hold_time_ps;
bool dual_link;
};
Members
input_bus_flags
- Tells what additional settings for the pixel data on the bus
this bridge requires (like pixel signal polarity). See also
drm_display_info->bus_flags
. setup_time_ps
- Defines the time in picoseconds the input data lines must be stable before the clock edge.
hold_time_ps
- Defines the time in picoseconds taken for the bridge to sample the input signal after the clock edge.
dual_link
- True if the bus operates in dual-link mode. The exact meaning is dependent on the bus type. For LVDS buses, this indicates that even- and odd-numbered pixels are received on separate links.
-
enum
drm_bridge_ops
¶ Bitmask of operations supported by the bridge
Constants
DRM_BRIDGE_OP_DETECT
- The bridge can detect displays connected to
its output. Bridges that set this flag shall implement the
drm_bridge_funcs->detect
callback. DRM_BRIDGE_OP_EDID
- The bridge can retrieve the EDID of the display
connected to its output. Bridges that set this flag shall implement
the
drm_bridge_funcs->get_edid
callback. DRM_BRIDGE_OP_HPD
- The bridge can detect hot-plug and hot-unplug
without requiring polling. Bridges that set this flag shall
implement the
drm_bridge_funcs->hpd_enable
anddrm_bridge_funcs->hpd_disable
callbacks if they support enabling and disabling hot-plug detection dynamically. DRM_BRIDGE_OP_MODES
- The bridge can retrieve the modes supported
by the display at its output. This does not include reading EDID
which is separately covered by DRM_BRIDGE_OP_EDID. Bridges that set
this flag shall implement the
drm_bridge_funcs->get_modes
callback.
-
struct
drm_bridge
¶ central DRM bridge control structure
Definition
struct drm_bridge {
struct drm_private_obj base;
struct drm_device *dev;
struct drm_encoder *encoder;
struct list_head chain_node;
#ifdef CONFIG_OF;
struct device_node *of_node;
#endif;
struct list_head list;
const struct drm_bridge_timings *timings;
const struct drm_bridge_funcs *funcs;
void *driver_private;
enum drm_bridge_ops ops;
int type;
bool interlace_allowed;
struct i2c_adapter *ddc;
struct mutex hpd_mutex;
void (*hpd_cb)(void *data, enum drm_connector_status status);
void *hpd_data;
};
Members
base
- inherit from
drm_private_object
dev
- DRM device this bridge belongs to
encoder
- encoder to which this bridge is connected
chain_node
- used to form a bridge chain
of_node
- device node pointer to the bridge
list
- to keep track of all added bridges
timings
- the timing specification for the bridge, if any (may be NULL)
funcs
- control functions
driver_private
- pointer to the bridge driver’s internal context
ops
- bitmask of operations supported by the bridge
type
- Type of the connection at the bridge output (DRM_MODE_CONNECTOR_*). For bridges at the end of this chain this identifies the type of connected display.
interlace_allowed
- Indicate that the bridge can handle interlaced modes.
ddc
- Associated I2C adapter for DDC access, if any.
hpd_mutex
- Protects the hpd_cb and hpd_data fields.
hpd_cb
- Hot plug detection callback, registered with
drm_bridge_hpd_enable()
. hpd_data
- Private data passed to the Hot plug detection callback hpd_cb.
-
struct drm_bridge *
drm_bridge_get_next_bridge
(struct drm_bridge * bridge)¶ Get the next bridge in the chain
Parameters
struct drm_bridge * bridge
- bridge object
Return
the next bridge in the chain after bridge, or NULL if bridge is the last.
-
struct drm_bridge *
drm_bridge_get_prev_bridge
(struct drm_bridge * bridge)¶ Get the previous bridge in the chain
Parameters
struct drm_bridge * bridge
- bridge object
Return
the previous bridge in the chain, or NULL if bridge is the first.
-
struct drm_bridge *
drm_bridge_chain_get_first_bridge
(struct drm_encoder * encoder)¶ Get the first bridge in the chain
Parameters
struct drm_encoder * encoder
- encoder object
Return
the first bridge in the chain, or NULL if encoder has no bridge attached to it.
-
drm_for_each_bridge_in_chain
(encoder, bridge)¶ Iterate over all bridges present in a chain
Parameters
encoder
- the encoder to iterate bridges on
bridge
- a bridge pointer updated to point to the current bridge at each iteration
Description
Iterate over all bridges present in the bridge chain attached to encoder.
-
void
drm_bridge_add
(struct drm_bridge * bridge)¶ add the given bridge to the global bridge list
Parameters
struct drm_bridge * bridge
- bridge control structure
-
int
devm_drm_bridge_add
(struct device * dev, struct drm_bridge * bridge)¶ devm managed version of
drm_bridge_add()
Parameters
struct device * dev
- device to tie the bridge lifetime to
struct drm_bridge * bridge
- bridge control structure
Description
This is the managed version of drm_bridge_add()
which automatically
calls drm_bridge_remove()
when dev is unbound.
Return
0 if no error or negative error code.
-
void
drm_bridge_remove
(struct drm_bridge * bridge)¶ remove the given bridge from the global bridge list
Parameters
struct drm_bridge * bridge
- bridge control structure
-
int
drm_bridge_attach
(struct drm_encoder * encoder, struct drm_bridge * bridge, struct drm_bridge * previous, enum drm_bridge_attach_flags flags)¶ attach the bridge to an encoder’s chain
Parameters
struct drm_encoder * encoder
- DRM encoder
struct drm_bridge * bridge
- bridge to attach
struct drm_bridge * previous
- previous bridge in the chain (optional)
enum drm_bridge_attach_flags flags
- DRM_BRIDGE_ATTACH_* flags
Description
Called by a kms driver to link the bridge to an encoder’s chain. The previous argument specifies the previous bridge in the chain. If NULL, the bridge is linked directly at the encoder’s output. Otherwise it is linked at the previous bridge’s output.
If non-NULL the previous bridge must be already attached by a call to this function.
Note that bridges attached to encoders are auto-detached during encoder
cleanup in drm_encoder_cleanup()
, so drm_bridge_attach()
should generally
not be balanced with a drm_bridge_detach()
in driver code.
Return
Zero on success, error code on failure
-
bool
drm_bridge_chain_mode_fixup
(struct drm_bridge * bridge, const struct drm_display_mode * mode, struct drm_display_mode * adjusted_mode)¶ fixup proposed mode for all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
const struct drm_display_mode * mode
- desired mode to be set for the bridge
struct drm_display_mode * adjusted_mode
- updated mode that works for this bridge
Description
Calls drm_bridge_funcs.mode_fixup
for all the bridges in the
encoder chain, starting from the first bridge to the last.
Note
the bridge passed should be the one closest to the encoder
Return
true on success, false on failure
-
enum drm_mode_status
drm_bridge_chain_mode_valid
(struct drm_bridge * bridge, const struct drm_display_info * info, const struct drm_display_mode * mode)¶ validate the mode against all bridges in the encoder chain.
Parameters
struct drm_bridge * bridge
- bridge control structure
const struct drm_display_info * info
- display info against which the mode shall be validated
const struct drm_display_mode * mode
- desired mode to be validated
Description
Calls drm_bridge_funcs.mode_valid
for all the bridges in the encoder
chain, starting from the first bridge to the last. If at least one bridge
does not accept the mode the function returns the error code.
Note
the bridge passed should be the one closest to the encoder.
Return
MODE_OK on success, drm_mode_status Enum error code on failure
-
void
drm_bridge_chain_disable
(struct drm_bridge * bridge)¶ disables all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
Description
Calls drm_bridge_funcs.disable
op for all the bridges in the encoder
chain, starting from the last bridge to the first. These are called before
calling the encoder’s prepare op.
Note
the bridge passed should be the one closest to the encoder
-
void
drm_bridge_chain_post_disable
(struct drm_bridge * bridge)¶ cleans up after disabling all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
Description
Calls drm_bridge_funcs.post_disable
op for all the bridges in the
encoder chain, starting from the first bridge to the last. These are called
after completing the encoder’s prepare op.
Note
the bridge passed should be the one closest to the encoder
-
void
drm_bridge_chain_mode_set
(struct drm_bridge * bridge, const struct drm_display_mode * mode, const struct drm_display_mode * adjusted_mode)¶ set proposed mode for all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
const struct drm_display_mode * mode
- desired mode to be set for the encoder chain
const struct drm_display_mode * adjusted_mode
- updated mode that works for this encoder chain
Description
Calls drm_bridge_funcs.mode_set
op for all the bridges in the
encoder chain, starting from the first bridge to the last.
Note
the bridge passed should be the one closest to the encoder
-
void
drm_bridge_chain_pre_enable
(struct drm_bridge * bridge)¶ prepares for enabling all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
Description
Calls drm_bridge_funcs.pre_enable
op for all the bridges in the encoder
chain, starting from the last bridge to the first. These are called
before calling the encoder’s commit op.
Note
the bridge passed should be the one closest to the encoder
-
void
drm_bridge_chain_enable
(struct drm_bridge * bridge)¶ enables all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
Description
Calls drm_bridge_funcs.enable
op for all the bridges in the encoder
chain, starting from the first bridge to the last. These are called
after completing the encoder’s commit op.
Note that the bridge passed should be the one closest to the encoder
-
void
drm_atomic_bridge_chain_disable
(struct drm_bridge * bridge, struct drm_atomic_state * old_state)¶ disables all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_atomic_state * old_state
- old atomic state
Description
Calls drm_bridge_funcs.atomic_disable
(falls back on
drm_bridge_funcs.disable
) op for all the bridges in the encoder chain,
starting from the last bridge to the first. These are called before calling
drm_encoder_helper_funcs.atomic_disable
Note
the bridge passed should be the one closest to the encoder
-
void
drm_atomic_bridge_chain_post_disable
(struct drm_bridge * bridge, struct drm_atomic_state * old_state)¶ cleans up after disabling all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_atomic_state * old_state
- old atomic state
Description
Calls drm_bridge_funcs.atomic_post_disable
(falls back on
drm_bridge_funcs.post_disable
) op for all the bridges in the encoder chain,
starting from the first bridge to the last. These are called after completing
drm_encoder_helper_funcs.atomic_disable
Note
the bridge passed should be the one closest to the encoder
-
void
drm_atomic_bridge_chain_pre_enable
(struct drm_bridge * bridge, struct drm_atomic_state * old_state)¶ prepares for enabling all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_atomic_state * old_state
- old atomic state
Description
Calls drm_bridge_funcs.atomic_pre_enable
(falls back on
drm_bridge_funcs.pre_enable
) op for all the bridges in the encoder chain,
starting from the last bridge to the first. These are called before calling
drm_encoder_helper_funcs.atomic_enable
Note
the bridge passed should be the one closest to the encoder
-
void
drm_atomic_bridge_chain_enable
(struct drm_bridge * bridge, struct drm_atomic_state * old_state)¶ enables all bridges in the encoder chain
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_atomic_state * old_state
- old atomic state
Description
Calls drm_bridge_funcs.atomic_enable
(falls back on
drm_bridge_funcs.enable
) op for all the bridges in the encoder chain,
starting from the first bridge to the last. These are called after completing
drm_encoder_helper_funcs.atomic_enable
Note
the bridge passed should be the one closest to the encoder
-
int
drm_atomic_bridge_chain_check
(struct drm_bridge * bridge, struct drm_crtc_state * crtc_state, struct drm_connector_state * conn_state)¶ Do an atomic check on the bridge chain
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_crtc_state * crtc_state
- new CRTC state
struct drm_connector_state * conn_state
- new connector state
Description
First trigger a bus format negotiation before calling
drm_bridge_funcs.atomic_check()
(falls back on
drm_bridge_funcs.mode_fixup()
) op for all the bridges in the encoder chain,
starting from the last bridge to the first. These are called before calling
drm_encoder_helper_funcs.atomic_check()
Return
0 on success, a negative error code on failure
-
enum drm_connector_status
drm_bridge_detect
(struct drm_bridge * bridge)¶ check if anything is attached to the bridge output
Parameters
struct drm_bridge * bridge
- bridge control structure
Description
If the bridge supports output detection, as reported by the
DRM_BRIDGE_OP_DETECT bridge ops flag, call drm_bridge_funcs.detect
for the
bridge and return the connection status. Otherwise return
connector_status_unknown.
Return
The detection status on success, or connector_status_unknown if the bridge doesn’t support output detection.
-
int
drm_bridge_get_modes
(struct drm_bridge * bridge, struct drm_connector * connector)¶ fill all modes currently valid for the sink into the connector
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_connector * connector
- the connector to fill with modes
Description
If the bridge supports output modes retrieval, as reported by the
DRM_BRIDGE_OP_MODES bridge ops flag, call drm_bridge_funcs.get_modes
to
fill the connector with all valid modes and return the number of modes
added. Otherwise return 0.
Return
The number of modes added to the connector.
-
struct edid *
drm_bridge_get_edid
(struct drm_bridge * bridge, struct drm_connector * connector)¶ get the EDID data of the connected display
Parameters
struct drm_bridge * bridge
- bridge control structure
struct drm_connector * connector
- the connector to read EDID for
Description
If the bridge supports output EDID retrieval, as reported by the
DRM_BRIDGE_OP_EDID bridge ops flag, call drm_bridge_funcs.get_edid
to
get the EDID and return it. Otherwise return NULL.
Return
The retrieved EDID on success, or NULL otherwise.
-
void
drm_bridge_hpd_enable
(struct drm_bridge * bridge, void (*cb) (void *data, enum drm_connector_status status, void * data)¶ enable hot plug detection for the bridge
Parameters
struct drm_bridge * bridge
- bridge control structure
void (*)(void *data, enum drm_connector_status status) cb
- hot-plug detection callback
void * data
- data to be passed to the hot-plug detection callback
Description
Call drm_bridge_funcs.hpd_enable
if implemented and register the given cb
and data as hot plug notification callback. From now on the cb will be
called with data when an output status change is detected by the bridge,
until hot plug notification gets disabled with drm_bridge_hpd_disable()
.
Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in bridge->ops. This function shall not be called when the flag is not set.
Only one hot plug detection callback can be registered at a time, it is an error to call this function when hot plug detection is already enabled for the bridge.
-
void
drm_bridge_hpd_disable
(struct drm_bridge * bridge)¶ disable hot plug detection for the bridge
Parameters
struct drm_bridge * bridge
- bridge control structure
Description
Call drm_bridge_funcs.hpd_disable
if implemented and unregister the hot
plug detection callback previously registered with drm_bridge_hpd_enable()
.
Once this function returns the callback will not be called by the bridge
when an output status change occurs.
Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in bridge->ops. This function shall not be called when the flag is not set.
-
void
drm_bridge_hpd_notify
(struct drm_bridge * bridge, enum drm_connector_status status)¶ notify hot plug detection events
Parameters
struct drm_bridge * bridge
- bridge control structure
enum drm_connector_status status
- output connection status
Description
Bridge drivers shall call this function to report hot plug events when they
detect a change in the output status, when hot plug detection has been
enabled by drm_bridge_hpd_enable()
.
This function shall be called in a context that can sleep.
-
struct drm_bridge *
of_drm_find_bridge
(struct device_node * np)¶ find the bridge corresponding to the device node in the global bridge list
Parameters
struct device_node * np
- device node
Return
drm_bridge control struct on success, NULL on failure
Panel-Bridge Helper Reference¶
-
bool
drm_bridge_is_panel
(const struct drm_bridge * bridge)¶ Checks if a drm_bridge is a panel_bridge.
Parameters
const struct drm_bridge * bridge
- The drm_bridge to be checked.
Description
Returns true if the bridge is a panel bridge, or false otherwise.
-
struct drm_bridge *
drm_panel_bridge_add
(struct drm_panel * panel)¶ Creates a
drm_bridge
anddrm_connector
that just calls the appropriate functions fromdrm_panel
.
Parameters
struct drm_panel * panel
- The drm_panel being wrapped. Must be non-NULL.
Description
For drivers converting from directly using drm_panel: The expected
usage pattern is that during either encoder module probe or DSI
host attach, a drm_panel will be looked up through
drm_of_find_panel_or_bridge()
. drm_panel_bridge_add()
is used to
wrap that panel in the new bridge, and the result can then be
passed to drm_bridge_attach()
. The drm_panel_prepare()
and related
functions can be dropped from the encoder driver (they’re now
called by the KMS helpers before calling into the encoder), along
with connector creation. When done with the bridge (after
drm_mode_config_cleanup()
if the bridge has already been attached), then
drm_panel_bridge_remove()
to free it.
The connector type is set to panel->connector_type, which must be set to a known type. Calling this function with a panel whose connector type is DRM_MODE_CONNECTOR_Unknown will return ERR_PTR(-EINVAL).
See devm_drm_panel_bridge_add()
for an automatically managed version of this
function.
-
struct drm_bridge *
drm_panel_bridge_add_typed
(struct drm_panel * panel, u32 connector_type)¶ Creates a
drm_bridge
anddrm_connector
with an explicit connector type.
Parameters
struct drm_panel * panel
- The drm_panel being wrapped. Must be non-NULL.
u32 connector_type
- The connector type (DRM_MODE_CONNECTOR_*)
Description
This is just like drm_panel_bridge_add()
, but forces the connector type to
connector_type instead of infering it from the panel.
This function is deprecated and should not be used in new drivers. Use
drm_panel_bridge_add()
instead, and fix panel drivers as necessary if they
don’t report a connector type.
-
void
drm_panel_bridge_remove
(struct drm_bridge * bridge)¶ Unregisters and frees a drm_bridge created by
drm_panel_bridge_add()
.
Parameters
struct drm_bridge * bridge
- The drm_bridge being freed.
-
int
drm_panel_bridge_set_orientation
(struct drm_connector * connector, struct drm_bridge * bridge)¶ Set the connector’s panel orientation from the bridge that can be transformed to panel bridge.
Parameters
struct drm_connector * connector
- The connector to be set panel orientation.
struct drm_bridge * bridge
- The drm_bridge to be transformed to panel bridge.
Description
Returns 0 on success, negative errno on failure.
-
struct drm_bridge *
devm_drm_panel_bridge_add
(struct device * dev, struct drm_panel * panel)¶ Creates a managed
drm_bridge
anddrm_connector
that just calls the appropriate functions fromdrm_panel
.
Parameters
struct device * dev
- device to tie the bridge lifetime to
struct drm_panel * panel
- The drm_panel being wrapped. Must be non-NULL.
Description
This is the managed version of drm_panel_bridge_add()
which automatically
calls drm_panel_bridge_remove()
when dev is unbound.
-
struct drm_bridge *
devm_drm_panel_bridge_add_typed
(struct device * dev, struct drm_panel * panel, u32 connector_type)¶ Creates a managed
drm_bridge
anddrm_connector
with an explicit connector type.
Parameters
struct device * dev
- device to tie the bridge lifetime to
struct drm_panel * panel
- The drm_panel being wrapped. Must be non-NULL.
u32 connector_type
- The connector type (DRM_MODE_CONNECTOR_*)
Description
This is just like devm_drm_panel_bridge_add()
, but forces the connector type
to connector_type instead of infering it from the panel.
This function is deprecated and should not be used in new drivers. Use
devm_drm_panel_bridge_add()
instead, and fix panel drivers as necessary if
they don’t report a connector type.
-
struct drm_connector *
drm_panel_bridge_connector
(struct drm_bridge * bridge)¶ return the connector for the panel bridge
Parameters
struct drm_bridge * bridge
- The drm_bridge.
Description
drm_panel_bridge creates the connector. This function gives external access to the connector.
Return
Pointer to drm_connector
-
struct drm_bridge *
devm_drm_of_get_bridge
(struct device * dev, struct device_node * np, u32 port, u32 endpoint)¶ Return next bridge in the chain
Parameters
struct device * dev
- device to tie the bridge lifetime to
struct device_node * np
- device tree node containing encoder output ports
u32 port
- port in the device tree node
u32 endpoint
- endpoint in the device tree node
Description
Given a DT node’s port and endpoint number, finds the connected node and returns the associated bridge if any, or creates and returns a drm panel bridge instance if a panel is connected.
Returns a pointer to the bridge if successful, or an error pointer otherwise.
Panel Helper Reference¶
The DRM panel helpers allow drivers to register panel objects with a central registry and provide functions to retrieve those panels in display drivers.
For easy integration into drivers using the drm_bridge
infrastructure please
take look at drm_panel_bridge_add()
and devm_drm_panel_bridge_add()
.
-
struct
drm_panel_funcs
¶ perform operations on a given panel
Definition
struct drm_panel_funcs {
int (*prepare)(struct drm_panel *panel);
int (*enable)(struct drm_panel *panel);
int (*disable)(struct drm_panel *panel);
int (*unprepare)(struct drm_panel *panel);
int (*get_modes)(struct drm_panel *panel, struct drm_connector *connector);
enum drm_panel_orientation (*get_orientation)(struct drm_panel *panel);
int (*get_timings)(struct drm_panel *panel, unsigned int num_timings, struct display_timing *timings);
void (*debugfs_init)(struct drm_panel *panel, struct dentry *root);
};
Members
prepare
Turn on panel and perform set up.
This function is optional.
enable
Enable panel (turn on back light, etc.).
This function is optional.
disable
Disable panel (turn off back light, etc.).
This function is optional.
unprepare
Turn off panel.
This function is optional.
get_modes
Add modes to the connector that the panel is attached to and returns the number of modes added.
This function is mandatory.
get_orientation
Return the panel orientation set by device tree or EDID.
This function is optional.
get_timings
Copy display timings into the provided array and return the number of display timings available.
This function is optional.
debugfs_init
- Allows panels to create panels-specific debugfs files.
Description
The .:c:func:prepare() function is typically called before the display controller starts to transmit video data. Panel drivers can use this to turn the panel on and wait for it to become ready. If additional configuration is required (via a control bus such as I2C, SPI or DSI for example) this is a good time to do that.
After the display controller has started transmitting video data, it’s safe to call the .:c:func:enable() function. This will typically enable the backlight to make the image on screen visible. Some panels require a certain amount of time or frames before the image is displayed. This function is responsible for taking this into account before enabling the backlight to avoid visual glitches.
Before stopping video transmission from the display controller it can be necessary to turn off the panel to avoid visual glitches. This is done in the .:c:func:disable() function. Analogously to .:c:func:enable() this typically involves turning off the backlight and waiting for some time to make sure no image is visible on the panel. It is then safe for the display controller to cease transmission of video data.
To save power when no video data is transmitted, a driver can power down the panel. This is the job of the .:c:func:unprepare() function.
Backlight can be handled automatically if configured using
drm_panel_of_backlight()
or drm_panel_dp_aux_backlight()
. Then the driver
does not need to implement the functionality to enable/disable backlight.
-
struct
drm_panel
¶ DRM panel object
Definition
struct drm_panel {
struct device *dev;
struct backlight_device *backlight;
const struct drm_panel_funcs *funcs;
int connector_type;
struct list_head list;
struct drm_dsc_config *dsc;
};
Members
dev
- Parent device of the panel.
backlight
- Backlight device, used to turn on backlight after the call
to
enable()
, and to turn off backlight before the call todisable()
. backlight is set bydrm_panel_of_backlight()
ordrm_panel_dp_aux_backlight()
and drivers shall not assign it. funcs
- Operations that can be performed on the panel.
connector_type
- Type of the panel as a DRM_MODE_CONNECTOR_* value. This is used to initialise the drm_connector corresponding to the panel with the correct connector type.
list
- Panel entry in registry.
dsc
- Panel DSC pps payload to be sent
-
void
drm_panel_init
(struct drm_panel * panel, struct device * dev, const struct drm_panel_funcs * funcs, int connector_type)¶ initialize a panel
Parameters
struct drm_panel * panel
- DRM panel
struct device * dev
- parent device of the panel
const struct drm_panel_funcs * funcs
- panel operations
int connector_type
- the connector type (DRM_MODE_CONNECTOR_*) corresponding to the panel interface
Description
Initialize the panel structure for subsequent registration with
drm_panel_add()
.
Parameters
struct drm_panel * panel
- panel to add
Description
Add a panel to the global registry so that it can be looked up by display drivers.
Parameters
struct drm_panel * panel
- DRM panel
Description
Removes a panel from the global registry.
Parameters
struct drm_panel * panel
- DRM panel
Description
Calling this function will enable power and deassert any reset signals to the panel. After this has completed it is possible to communicate with any integrated circuitry via a command bus.
Return
0 on success or a negative error code on failure.
Parameters
struct drm_panel * panel
- DRM panel
Description
Calling this function will completely power off a panel (assert the panel’s
reset, turn off power supplies, …). After this function has completed, it
is usually no longer possible to communicate with the panel until another
call to drm_panel_prepare()
.
Return
0 on success or a negative error code on failure.
Parameters
struct drm_panel * panel
- DRM panel
Description
Calling this function will cause the panel display drivers to be turned on and the backlight to be enabled. Content will be visible on screen after this call completes.
Return
0 on success or a negative error code on failure.
Parameters
struct drm_panel * panel
- DRM panel
Description
This will typically turn off the panel’s backlight or disable the display drivers. For smart panels it should still be possible to communicate with the integrated circuitry via any command bus after this call.
Return
0 on success or a negative error code on failure.
-
int
drm_panel_get_modes
(struct drm_panel * panel, struct drm_connector * connector)¶ probe the available display modes of a panel
Parameters
struct drm_panel * panel
- DRM panel
struct drm_connector * connector
- DRM connector
Description
The modes probed from the panel are automatically added to the connector that the panel is attached to.
Return
The number of modes available from the panel on success or a negative error code on failure.
-
struct drm_panel *
of_drm_find_panel
(const struct device_node * np)¶ look up a panel using a device tree node
Parameters
const struct device_node * np
- device tree node of the panel
Description
Searches the set of registered panels for one that matches the given device tree node. If a matching panel is found, return a pointer to it.
Return
A pointer to the panel registered for the specified device tree
node or an ERR_PTR()
if no panel matching the device tree node can be found.
Possible error codes returned by this function:
- EPROBE_DEFER: the panel device has not been probed yet, and the caller should retry later
- ENODEV: the device is not available (status != “okay” or “ok”)
-
int
of_drm_get_panel_orientation
(const struct device_node * np, enum drm_panel_orientation * orientation)¶ look up the orientation of the panel through the “rotation” binding from a device tree node
Parameters
const struct device_node * np
- device tree node of the panel
enum drm_panel_orientation * orientation
- orientation enum to be filled in
Description
Looks up the rotation of a panel in the device tree. The orientation of the panel is expressed as a property name “rotation” in the device tree. The rotation in the device tree is counter clockwise.
Return
0 when a valid rotation value (0, 90, 180, or 270) is read or the rotation property doesn’t exist. Return a negative error code on failure.
Parameters
struct drm_panel * panel
- DRM panel
Description
Use this function to enable backlight handling if your panel uses device tree and has a backlight phandle.
When the panel is enabled backlight will be enabled after a
successful call to drm_panel_funcs.enable()
When the panel is disabled backlight will be disabled before the
call to drm_panel_funcs.disable()
.
A typical implementation for a panel driver supporting device tree
will call this function at probe time. Backlight will then be handled
transparently without requiring any intervention from the driver.
drm_panel_of_backlight()
must be called after the call to drm_panel_init()
.
Return
0 on success or a negative error code on failure.
-
int
drm_get_panel_orientation_quirk
(int width, int height)¶ Check for panel orientation quirks
Parameters
int width
- width in pixels of the panel
int height
- height in pixels of the panel
Description
This function checks for platform specific (e.g. DMI based) quirks providing info on panel_orientation for systems where this cannot be probed from the hard-/firm-ware. To avoid false-positive this function takes the panel resolution as argument and checks that against the resolution expected by the quirk-table entry.
Note this function is also used outside of the drm-subsys, by for example the efifb code. Because of this this function gets compiled into its own kernel-module when built as a module.
Return
A DRM_MODE_PANEL_ORIENTATION_* value if there is a quirk for this system, or DRM_MODE_PANEL_ORIENTATION_UNKNOWN if there is no quirk.
Display Port Helper Functions Reference¶
Error
kernel-doc missing
Error
kernel-doc missing
Error
kernel-doc missing
Display Port Dual Mode Adaptor Helper Functions Reference¶
Error
kernel-doc missing
Error
kernel-doc missing
Error
kernel-doc missing
Display Port MST Helper Functions Reference¶
Error
kernel-doc missing
Error
kernel-doc missing
Error
kernel-doc missing
MIPI DSI Helper Functions Reference¶
These functions contain some common logic and helpers to deal with MIPI DSI peripherals.
Helpers are provided for a number of standard MIPI DSI command as well as a subset of the MIPI DCS command set.
-
struct
mipi_dsi_msg
¶ read/write DSI buffer
Definition
struct mipi_dsi_msg {
u8 channel;
u8 type;
u16 flags;
size_t tx_len;
const void *tx_buf;
size_t rx_len;
void *rx_buf;
};
Members
channel
- virtual channel id
type
- payload data type
flags
- flags controlling this message transmission
tx_len
- length of tx_buf
tx_buf
- data to be written
rx_len
- length of rx_buf
rx_buf
- data to be read, or NULL
-
struct
mipi_dsi_packet
¶ represents a MIPI DSI packet in protocol format
Definition
struct mipi_dsi_packet {
size_t size;
u8 header[4];
size_t payload_length;
const u8 *payload;
};
Members
size
- size (in bytes) of the packet
header
- the four bytes that make up the header (Data ID, Word Count or Packet Data, and ECC)
payload_length
- number of bytes in the payload
payload
- a pointer to a buffer containing the payload, if any
-
struct
mipi_dsi_host_ops
¶ DSI bus operations
Definition
struct mipi_dsi_host_ops {
int (*attach)(struct mipi_dsi_host *host, struct mipi_dsi_device *dsi);
int (*detach)(struct mipi_dsi_host *host, struct mipi_dsi_device *dsi);
ssize_t (*transfer)(struct mipi_dsi_host *host, const struct mipi_dsi_msg *msg);
};
Members
attach
- attach DSI device to DSI host
detach
- detach DSI device from DSI host
transfer
- transmit a DSI packet
Description
DSI packets transmitted by .:c:func:transfer() are passed in as mipi_dsi_msg structures. This structure contains information about the type of packet being transmitted as well as the transmit and receive buffers. When an error is encountered during transmission, this function will return a negative error code. On success it shall return the number of bytes transmitted for write packets or the number of bytes received for read packets.
Note that typically DSI packet transmission is atomic, so the .:c:func:transfer() function will seldomly return anything other than the number of bytes contained in the transmit buffer on success.
Also note that those callbacks can be called no matter the state the host is in. Drivers that need the underlying device to be powered to perform these operations will first need to make sure it’s been properly enabled.
-
struct
mipi_dsi_host
¶ DSI host device
Definition
struct mipi_dsi_host {
struct device *dev;
const struct mipi_dsi_host_ops *ops;
struct list_head list;
};
Members
dev
- driver model device node for this DSI host
ops
- DSI host operations
list
- list management
-
struct
mipi_dsi_device_info
¶ template for creating a mipi_dsi_device
Definition
struct mipi_dsi_device_info {
char type[DSI_DEV_NAME_SIZE];
u32 channel;
struct device_node *node;
};
Members
type
- DSI peripheral chip type
channel
- DSI virtual channel assigned to peripheral
node
- pointer to OF device node or NULL
Description
This is populated and passed to mipi_dsi_device_new to create a new DSI device
-
struct
mipi_dsi_device
¶ DSI peripheral device
Definition
struct mipi_dsi_device {
struct mipi_dsi_host *host;
struct device dev;
char name[DSI_DEV_NAME_SIZE];
unsigned int channel;
unsigned int lanes;
enum mipi_dsi_pixel_format format;
unsigned long mode_flags;
unsigned long hs_rate;
unsigned long lp_rate;
};
Members
host
- DSI host for this peripheral
dev
- driver model device node for this peripheral
name
- DSI peripheral chip type
channel
- virtual channel assigned to the peripheral
lanes
- number of active data lanes
format
- pixel format for video mode
mode_flags
- DSI operation mode related flags
hs_rate
- maximum lane frequency for high speed mode in hertz, this should be set to the real limits of the hardware, zero is only accepted for legacy drivers
lp_rate
- maximum lane frequency for low power mode in hertz, this should be set to the real limits of the hardware, zero is only accepted for legacy drivers
-
int
mipi_dsi_pixel_format_to_bpp
(enum mipi_dsi_pixel_format fmt)¶ obtain the number of bits per pixel for any given pixel format defined by the MIPI DSI specification
Parameters
enum mipi_dsi_pixel_format fmt
- MIPI DSI pixel format
Return
The number of bits per pixel of the given pixel format.
-
enum
mipi_dsi_dcs_tear_mode
¶ Tearing Effect Output Line mode
Constants
MIPI_DSI_DCS_TEAR_MODE_VBLANK
- the TE output line consists of V-Blanking information only
MIPI_DSI_DCS_TEAR_MODE_VHBLANK
- the TE output line consists of both V-Blanking and H-Blanking information
-
mipi_dsi_dcs_write_seq
(dsi, cmd, seq…)¶ transmit a DCS command with payload
Parameters
dsi
- DSI peripheral device
cmd
- Command
seq...
- variable arguments
-
struct
mipi_dsi_driver
¶ DSI driver
Definition
struct mipi_dsi_driver {
struct device_driver driver;
int(*probe)(struct mipi_dsi_device *dsi);
int(*remove)(struct mipi_dsi_device *dsi);
void (*shutdown)(struct mipi_dsi_device *dsi);
};
Members
driver
- device driver model driver
probe
- callback for device binding
remove
- callback for device unbinding
shutdown
- called at shutdown time to quiesce the device
-
struct mipi_dsi_device *
of_find_mipi_dsi_device_by_node
(struct device_node * np)¶ find the MIPI DSI device matching a device tree node
Parameters
struct device_node * np
- device tree node
Return
- A pointer to the MIPI DSI device corresponding to np or NULL if no
- such device exists (or has not been registered yet).
-
struct mipi_dsi_device *
mipi_dsi_device_register_full
(struct mipi_dsi_host * host, const struct mipi_dsi_device_info * info)¶ create a MIPI DSI device
Parameters
struct mipi_dsi_host * host
- DSI host to which this device is connected
const struct mipi_dsi_device_info * info
- pointer to template containing DSI device information
Description
Create a MIPI DSI device by using the device information provided by mipi_dsi_device_info template
Return
A pointer to the newly created MIPI DSI device, or, a pointer encoded with an error
-
void
mipi_dsi_device_unregister
(struct mipi_dsi_device * dsi)¶ unregister MIPI DSI device
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
-
struct mipi_dsi_device *
devm_mipi_dsi_device_register_full
(struct device * dev, struct mipi_dsi_host * host, const struct mipi_dsi_device_info * info)¶ create a managed MIPI DSI device
Parameters
struct device * dev
- device to tie the MIPI-DSI device lifetime to
struct mipi_dsi_host * host
- DSI host to which this device is connected
const struct mipi_dsi_device_info * info
- pointer to template containing DSI device information
Description
Create a MIPI DSI device by using the device information provided by mipi_dsi_device_info template
This is the managed version of mipi_dsi_device_register_full()
which
automatically calls mipi_dsi_device_unregister()
when dev is
unbound.
Return
A pointer to the newly created MIPI DSI device, or, a pointer encoded with an error
-
struct mipi_dsi_host *
of_find_mipi_dsi_host_by_node
(struct device_node * node)¶ find the MIPI DSI host matching a device tree node
Parameters
struct device_node * node
- device tree node
Return
A pointer to the MIPI DSI host corresponding to node or NULL if no such device exists (or has not been registered yet).
-
int
mipi_dsi_attach
(struct mipi_dsi_device * dsi)¶ attach a DSI device to its DSI host
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral
-
int
mipi_dsi_detach
(struct mipi_dsi_device * dsi)¶ detach a DSI device from its DSI host
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral
-
int
devm_mipi_dsi_attach
(struct device * dev, struct mipi_dsi_device * dsi)¶ Attach a MIPI-DSI device to its DSI Host
Parameters
struct device * dev
- device to tie the MIPI-DSI device attachment lifetime to
struct mipi_dsi_device * dsi
- DSI peripheral
Description
This is the managed version of mipi_dsi_attach()
which automatically
calls mipi_dsi_detach()
when dev is unbound.
Return
0 on success, a negative error code on failure.
-
bool
mipi_dsi_packet_format_is_short
(u8 type)¶ check if a packet is of the short format
Parameters
u8 type
- MIPI DSI data type of the packet
Return
true if the packet for the given data type is a short packet, false otherwise.
-
bool
mipi_dsi_packet_format_is_long
(u8 type)¶ check if a packet is of the long format
Parameters
u8 type
- MIPI DSI data type of the packet
Return
true if the packet for the given data type is a long packet, false otherwise.
-
int
mipi_dsi_create_packet
(struct mipi_dsi_packet * packet, const struct mipi_dsi_msg * msg)¶ create a packet from a message according to the DSI protocol
Parameters
struct mipi_dsi_packet * packet
- pointer to a DSI packet structure
const struct mipi_dsi_msg * msg
- message to translate into a packet
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_shutdown_peripheral
(struct mipi_dsi_device * dsi)¶ sends a Shutdown Peripheral command
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_turn_on_peripheral
(struct mipi_dsi_device * dsi)¶ sends a Turn On Peripheral command
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure.
-
ssize_t
mipi_dsi_compression_mode
(struct mipi_dsi_device * dsi, bool enable)¶ enable/disable DSC on the peripheral
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
bool enable
- Whether to enable or disable the DSC
Description
Enable or disable Display Stream Compression on the peripheral using the default Picture Parameter Set and VESA DSC 1.1 algorithm.
Return
0 on success or a negative error code on failure.
-
ssize_t
mipi_dsi_picture_parameter_set
(struct mipi_dsi_device * dsi, const struct drm_dsc_picture_parameter_set * pps)¶ transmit the DSC PPS to the peripheral
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
const struct drm_dsc_picture_parameter_set * pps
- VESA DSC 1.1 Picture Parameter Set
Description
Transmit the VESA DSC 1.1 Picture Parameter Set to the peripheral.
Return
0 on success or a negative error code on failure.
-
ssize_t
mipi_dsi_generic_write
(struct mipi_dsi_device * dsi, const void * payload, size_t size)¶ transmit data using a generic write packet
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
const void * payload
- buffer containing the payload
size_t size
- size of payload buffer
Description
This function will automatically choose the right data type depending on the payload length.
Return
The number of bytes transmitted on success or a negative error code on failure.
-
ssize_t
mipi_dsi_generic_read
(struct mipi_dsi_device * dsi, const void * params, size_t num_params, void * data, size_t size)¶ receive data using a generic read packet
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
const void * params
- buffer containing the request parameters
size_t num_params
- number of request parameters
void * data
- buffer in which to return the received data
size_t size
- size of receive buffer
Description
This function will automatically choose the right data type depending on the number of parameters passed in.
Return
The number of bytes successfully read or a negative error code on failure.
-
ssize_t
mipi_dsi_dcs_write_buffer
(struct mipi_dsi_device * dsi, const void * data, size_t len)¶ transmit a DCS command with payload
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
const void * data
- buffer containing data to be transmitted
size_t len
- size of transmission buffer
Description
This function will automatically choose the right data type depending on the command payload length.
Return
The number of bytes successfully transmitted or a negative error code on failure.
-
ssize_t
mipi_dsi_dcs_write
(struct mipi_dsi_device * dsi, u8 cmd, const void * data, size_t len)¶ send DCS write command
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u8 cmd
- DCS command
const void * data
- buffer containing the command payload
size_t len
- command payload length
Description
This function will automatically choose the right data type depending on the command payload length.
Return
The number of bytes successfully transmitted or a negative error code on failure.
-
ssize_t
mipi_dsi_dcs_read
(struct mipi_dsi_device * dsi, u8 cmd, void * data, size_t len)¶ send DCS read request command
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u8 cmd
- DCS command
void * data
- buffer in which to receive data
size_t len
- size of receive buffer
Return
The number of bytes read or a negative error code on failure.
-
int
mipi_dsi_dcs_nop
(struct mipi_dsi_device * dsi)¶ send DCS nop packet
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_soft_reset
(struct mipi_dsi_device * dsi)¶ perform a software reset of the display module
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_get_power_mode
(struct mipi_dsi_device * dsi, u8 * mode)¶ query the display module’s current power mode
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u8 * mode
- return location for the current power mode
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_get_pixel_format
(struct mipi_dsi_device * dsi, u8 * format)¶ gets the pixel format for the RGB image data used by the interface
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u8 * format
- return location for the pixel format
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_enter_sleep_mode
(struct mipi_dsi_device * dsi)¶ disable all unnecessary blocks inside the display module except interface communication
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_exit_sleep_mode
(struct mipi_dsi_device * dsi)¶ enable all blocks inside the display module
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_set_display_off
(struct mipi_dsi_device * dsi)¶ stop displaying the image data on the display device
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_set_display_on
(struct mipi_dsi_device * dsi)¶ start displaying the image data on the display device
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure
-
int
mipi_dsi_dcs_set_column_address
(struct mipi_dsi_device * dsi, u16 start, u16 end)¶ define the column extent of the frame memory accessed by the host processor
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u16 start
- first column of frame memory
u16 end
- last column of frame memory
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_set_page_address
(struct mipi_dsi_device * dsi, u16 start, u16 end)¶ define the page extent of the frame memory accessed by the host processor
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u16 start
- first page of frame memory
u16 end
- last page of frame memory
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_set_tear_off
(struct mipi_dsi_device * dsi)¶ turn off the display module’s Tearing Effect output signal on the TE signal line
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
Return
0 on success or a negative error code on failure
-
int
mipi_dsi_dcs_set_tear_on
(struct mipi_dsi_device * dsi, enum mipi_dsi_dcs_tear_mode mode)¶ turn on the display module’s Tearing Effect output signal on the TE signal line.
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
enum mipi_dsi_dcs_tear_mode mode
- the Tearing Effect Output Line mode
Return
0 on success or a negative error code on failure
-
int
mipi_dsi_dcs_set_pixel_format
(struct mipi_dsi_device * dsi, u8 format)¶ sets the pixel format for the RGB image data used by the interface
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u8 format
- pixel format
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_set_tear_scanline
(struct mipi_dsi_device * dsi, u16 scanline)¶ set the scanline to use as trigger for the Tearing Effect output signal of the display module
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u16 scanline
- scanline to use as trigger
Return
0 on success or a negative error code on failure
-
int
mipi_dsi_dcs_set_display_brightness
(struct mipi_dsi_device * dsi, u16 brightness)¶ sets the brightness value of the display
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u16 brightness
- brightness value
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_dcs_get_display_brightness
(struct mipi_dsi_device * dsi, u16 * brightness)¶ gets the current brightness value of the display
Parameters
struct mipi_dsi_device * dsi
- DSI peripheral device
u16 * brightness
- brightness value
Return
0 on success or a negative error code on failure.
-
int
mipi_dsi_driver_register_full
(struct mipi_dsi_driver * drv, struct module * owner)¶ register a driver for DSI devices
Parameters
struct mipi_dsi_driver * drv
- DSI driver structure
struct module * owner
- owner module
Return
0 on success or a negative error code on failure.
-
void
mipi_dsi_driver_unregister
(struct mipi_dsi_driver * drv)¶ unregister a driver for DSI devices
Parameters
struct mipi_dsi_driver * drv
- DSI driver structure
Return
0 on success or a negative error code on failure.
Output Probing Helper Functions Reference¶
This library provides some helper code for output probing. It provides an
implementation of the core drm_connector_funcs.fill_modes
interface with
drm_helper_probe_single_connector_modes()
.
It also provides support for polling connectors with a work item and for generic hotplug interrupt handling where the driver doesn’t or cannot keep track of a per-connector hpd interrupt.
This helper library can be used independently of the modeset helper library. Drivers can also overwrite different parts e.g. use their own hotplug handling code to avoid probing unrelated outputs.
The probe helpers share the function table structures with other display
helper libraries. See struct drm_connector_helper_funcs
for the details.
-
void
drm_kms_helper_poll_enable
(struct drm_device * dev)¶ re-enable output polling.
Parameters
struct drm_device * dev
- drm_device
Description
This function re-enables the output polling work, after it has been
temporarily disabled using drm_kms_helper_poll_disable()
, for example over
suspend/resume.
Drivers can call this helper from their device resume implementation. It is not an error to call this even when output polling isn’t enabled.
Note that calls to enable and disable polling must be strictly ordered, which is automatically the case when they’re only call from suspend/resume callbacks.
-
int
drm_helper_probe_detect
(struct drm_connector * connector, struct drm_modeset_acquire_ctx * ctx, bool force)¶ probe connector status
Parameters
struct drm_connector * connector
- connector to probe
struct drm_modeset_acquire_ctx * ctx
- acquire_ctx, or NULL to let this function handle locking.
bool force
- Whether destructive probe operations should be performed.
Description
This function calls the detect callbacks of the connector.
This function returns drm_connector_status
, or
if ctx is set, it might also return -EDEADLK.
-
int
drm_helper_probe_single_connector_modes
(struct drm_connector * connector, uint32_t maxX, uint32_t maxY)¶ get complete set of display modes
Parameters
struct drm_connector * connector
- connector to probe
uint32_t maxX
- max width for modes
uint32_t maxY
- max height for modes
Description
Based on the helper callbacks implemented by connector in struct
drm_connector_helper_funcs
try to detect all valid modes. Modes will first
be added to the connector’s probed_modes list, then culled (based on validity
and the maxX, maxY parameters) and put into the normal modes list.
Intended to be used as a generic implementation of the
drm_connector_funcs.fill_modes()
vfunc for drivers that use the CRTC helpers
for output mode filtering and detection.
The basic procedure is as follows
All modes currently on the connector’s modes list are marked as stale
New modes are added to the connector’s probed_modes list with
drm_mode_probed_add()
. New modes start their life with status as OK. Modes are added from a single source using the following priority order.drm_connector_helper_funcs.get_modes
vfunc- if the connector status is connector_status_connected, standard
VESA DMT modes up to 1024x768 are automatically added
(
drm_add_modes_noedid()
)
Finally modes specified via the kernel command line (video=…) are added in addition to what the earlier probes produced (
drm_helper_probe_add_cmdline_mode()
). These modes are generated using the VESA GTF/CVT formulas.Modes are moved from the probed_modes list to the modes list. Potential duplicates are merged together (see
drm_connector_list_update()
). After this step the probed_modes list will be empty again.Any non-stale mode on the modes list then undergoes validation
drm_mode_validate_basic()
performs basic sanity checksdrm_mode_validate_size()
filters out modes larger than maxX and maxY (if specified)drm_mode_validate_flag()
checks the modes against basic connector capabilities (interlace_allowed,doublescan_allowed,stereo_allowed)- the optional
drm_connector_helper_funcs.mode_valid
ordrm_connector_helper_funcs.mode_valid_ctx
helpers can perform driver and/or sink specific checks - the optional
drm_crtc_helper_funcs.mode_valid
,drm_bridge_funcs.mode_valid
anddrm_encoder_helper_funcs.mode_valid
helpers can perform driver and/or source specific checks which are also enforced by the modeset/atomic helpers
Any mode whose status is not OK is pruned from the connector’s modes list, accompanied by a debug message indicating the reason for the mode’s rejection (see
drm_mode_prune_invalid()
).
Return
The number of modes found on connector.
-
void
drm_kms_helper_hotplug_event
(struct drm_device * dev)¶ fire off KMS hotplug events
Parameters
struct drm_device * dev
- drm_device whose connector state changed
Description
This function fires off the uevent for userspace and also calls the output_poll_changed function, which is most commonly used to inform the fbdev emulation code and allow it to update the fbcon output configuration.
Drivers should call this from their hotplug handling code when a change is
detected. Note that this function does not do any output detection of its
own, like drm_helper_hpd_irq_event()
does - this is assumed to be done by the
driver already.
This function must be called from process context with no mode setting locks held.
If only a single connector has changed, consider calling
drm_kms_helper_connector_hotplug_event()
instead.
-
void
drm_kms_helper_connector_hotplug_event
(struct drm_connector * connector)¶ fire off a KMS connector hotplug event
Parameters
struct drm_connector * connector
- drm_connector which has changed
Description
This is the same as drm_kms_helper_hotplug_event()
, except it fires a more
fine-grained uevent for a single connector.
-
bool
drm_kms_helper_is_poll_worker
(void)¶ is
current
task an output poll worker?
Parameters
void
- no arguments
Description
Determine if current
task is an output poll worker. This can be used
to select distinct code paths for output polling versus other contexts.
One use case is to avoid a deadlock between the output poll worker and
the autosuspend worker wherein the latter waits for polling to finish
upon calling drm_kms_helper_poll_disable()
, while the former waits for
runtime suspend to finish upon calling pm_runtime_get_sync()
in a
connector ->detect hook.
-
void
drm_kms_helper_poll_disable
(struct drm_device * dev)¶ disable output polling
Parameters
struct drm_device * dev
- drm_device
Description
This function disables the output polling work.
Drivers can call this helper from their device suspend implementation. It is
not an error to call this even when output polling isn’t enabled or already
disabled. Polling is re-enabled by calling drm_kms_helper_poll_enable()
.
Note that calls to enable and disable polling must be strictly ordered, which is automatically the case when they’re only call from suspend/resume callbacks.
-
void
drm_kms_helper_poll_init
(struct drm_device * dev)¶ initialize and enable output polling
Parameters
struct drm_device * dev
- drm_device
Description
This function initializes and then also enables output polling support for dev. Drivers which do not have reliable hotplug support in hardware can use this helper infrastructure to regularly poll such connectors for changes in their connection state.
Drivers can control which connectors are polled by setting the DRM_CONNECTOR_POLL_CONNECT and DRM_CONNECTOR_POLL_DISCONNECT flags. On connectors where probing live outputs can result in visual distortion drivers should not set the DRM_CONNECTOR_POLL_DISCONNECT flag to avoid this. Connectors which have no flag or only DRM_CONNECTOR_POLL_HPD set are completely ignored by the polling logic.
Note that a connector can be both polled and probed from the hotplug handler, in case the hotplug interrupt is known to be unreliable.
-
void
drm_kms_helper_poll_fini
(struct drm_device * dev)¶ disable output polling and clean it up
Parameters
struct drm_device * dev
- drm_device
-
bool
drm_connector_helper_hpd_irq_event
(struct drm_connector * connector)¶ hotplug processing
Parameters
struct drm_connector * connector
- drm_connector
Description
Drivers can use this helper function to run a detect cycle on a connector
which has the DRM_CONNECTOR_POLL_HPD flag set in its polled
member.
This helper function is useful for drivers which can track hotplug
interrupts for a single connector. Drivers that want to send a
hotplug event for all connectors or can’t track hotplug interrupts
per connector need to use drm_helper_hpd_irq_event()
.
This function must be called from process context with no mode setting locks held.
Note that a connector can be both polled and probed from the hotplug handler, in case the hotplug interrupt is known to be unreliable.
Return
A boolean indicating whether the connector status changed or not
-
bool
drm_helper_hpd_irq_event
(struct drm_device * dev)¶ hotplug processing
Parameters
struct drm_device * dev
- drm_device
Description
Drivers can use this helper function to run a detect cycle on all connectors
which have the DRM_CONNECTOR_POLL_HPD flag set in their polled
member. All
other connectors are ignored, which is useful to avoid reprobing fixed
panels.
This helper function is useful for drivers which can’t or don’t track hotplug interrupts for each connector.
Drivers which support hotplug interrupts for each connector individually and
which have a more fine-grained detect logic can use
drm_connector_helper_hpd_irq_event()
. Alternatively, they should bypass this
code and directly call drm_kms_helper_hotplug_event()
in case the connector
state changed.
This function must be called from process context with no mode setting locks held.
Note that a connector can be both polled and probed from the hotplug handler, in case the hotplug interrupt is known to be unreliable.
Return
A boolean indicating whether the connector status changed or not
-
int
drm_connector_helper_get_modes_from_ddc
(struct drm_connector * connector)¶ Updates the connector’s EDID property from the connector’s DDC channel
Parameters
struct drm_connector * connector
- The connector
Return
The number of detected display modes.
Uses a connector’s DDC channel to retrieve EDID data and update the
connector’s EDID property and display modes. Drivers can use this
function to implement struct drm_connector_helper_funcs.get_modes
for connectors with a DDC channel.
-
int
drm_connector_helper_get_modes
(struct drm_connector * connector)¶ Read EDID and update connector.
Parameters
struct drm_connector * connector
- The connector
Description
Read the EDID using drm_edid_read()
(which requires that connector->ddc is
set), and update the connector using the EDID.
This can be used as the “default” connector helper .:c:func:get_modes() hook if the driver does not need any special processing. This is sets the example what custom .:c:func:get_modes() hooks should do regarding EDID read and connector update.
Return
Number of modes.
EDID Helper Functions Reference¶
-
int
drm_eld_mnl
(const uint8_t * eld)¶ Get ELD monitor name length in bytes.
Parameters
const uint8_t * eld
- pointer to an eld memory structure with mnl set
-
const uint8_t *
drm_eld_sad
(const uint8_t * eld)¶ Get ELD SAD structures.
Parameters
const uint8_t * eld
- pointer to an eld memory structure with sad_count set
-
int
drm_eld_sad_count
(const uint8_t * eld)¶ Get ELD SAD count.
Parameters
const uint8_t * eld
- pointer to an eld memory structure with sad_count set
-
int
drm_eld_calc_baseline_block_size
(const uint8_t * eld)¶ Calculate baseline block size in bytes
Parameters
const uint8_t * eld
- pointer to an eld memory structure with mnl and sad_count set
Description
This is a helper for determining the payload size of the baseline block, in bytes, for e.g. setting the Baseline_ELD_Len field in the ELD header block.
-
int
drm_eld_size
(const uint8_t * eld)¶ Get ELD size in bytes
Parameters
const uint8_t * eld
- pointer to a complete eld memory structure
Description
The returned value does not include the vendor block. It’s vendor specific,
and comprises of the remaining bytes in the ELD memory buffer after
drm_eld_size()
bytes of header and baseline block.
The returned value is guaranteed to be a multiple of 4.
-
u8
drm_eld_get_spk_alloc
(const uint8_t * eld)¶ Get speaker allocation
Parameters
const uint8_t * eld
- pointer to an ELD memory structure
Description
The returned value is the speakers mask. User has to use DRM_ELD_SPEAKER
field definitions to identify speakers.
-
u8
drm_eld_get_conn_type
(const uint8_t * eld)¶ Get device type hdmi/dp connected
Parameters
const uint8_t * eld
- pointer to an ELD memory structure
Description
The caller need to use DRM_ELD_CONN_TYPE_HDMI
or DRM_ELD_CONN_TYPE_DP
to
identify the display type connected.
-
const char *
drm_edid_decode_mfg_id
(u16 mfg_id, char vend)¶ Decode the manufacturer ID
Parameters
u16 mfg_id
- The manufacturer ID
char vend
- A 4-byte buffer to store the 3-letter vendor string plus a ‘0’ termination
-
drm_edid_encode_panel_id
(vend_chr_0, vend_chr_1, vend_chr_2, product_id)¶ Encode an ID for matching against
drm_edid_get_panel_id()
Parameters
vend_chr_0
- First character of the vendor string.
vend_chr_1
- Second character of the vendor string.
vend_chr_2
- Third character of the vendor string.
product_id
- The 16-bit product ID.
Description
This is a macro so that it can be calculated at compile time and used as an initializer.
- For instance:
- drm_edid_encode_panel_id(‘B’, ‘O’, ‘E’, 0x2d08) => 0x09e52d08
Return
a 32-bit ID per panel.
-
void
drm_edid_decode_panel_id
(u32 panel_id, char vend, u16 * product_id)¶ Decode a panel ID from
drm_edid_encode_panel_id()
Parameters
u32 panel_id
- The panel ID to decode.
char vend
- A 4-byte buffer to store the 3-letter vendor string plus a ‘0’ termination
u16 * product_id
- The product ID will be returned here.
Description
- For instance, after:
- drm_edid_decode_panel_id(0x09e52d08, vend,
product_id
) - These will be true:
- vend[0] = ‘B’ vend[1] = ‘O’ vend[2] = ‘E’ vend[3] = ‘0’ product_id = 0x2d08
-
int
drm_edid_header_is_valid
(const void * _edid)¶ sanity check the header of the base EDID block
Parameters
const void * _edid
- pointer to raw base EDID block
Description
Sanity check the header of the base EDID block.
Return
8 if the header is perfect, down to 0 if it’s totally wrong.
-
bool
drm_edid_are_equal
(const struct edid * edid1, const struct edid * edid2)¶ compare two edid blobs.
Parameters
const struct edid * edid1
- pointer to first blob
const struct edid * edid2
- pointer to second blob This helper can be used during probing to determine if edid had changed.
-
bool
drm_edid_block_valid
(u8 * _block, int block_num, bool print_bad_edid, bool * edid_corrupt)¶ Sanity check the EDID block (base or extension)
Parameters
u8 * _block
- pointer to raw EDID block
int block_num
- type of block to validate (0 for base, extension otherwise)
bool print_bad_edid
- if true, dump bad EDID blocks to the console
bool * edid_corrupt
- if true, the header or checksum is invalid
Description
Validate a base or extension EDID block and optionally dump bad blocks to the console.
Return
True if the block is valid, false otherwise.
-
bool
drm_edid_is_valid
(struct edid * edid)¶ sanity check EDID data
Parameters
struct edid * edid
- EDID data
Description
Sanity-check an entire EDID record (including extensions)
Return
True if the EDID data is valid, false otherwise.
-
int
drm_add_override_edid_modes
(struct drm_connector * connector)¶ add modes from override/firmware EDID
Parameters
struct drm_connector * connector
- connector we’re probing
Description
Add modes from the override/firmware EDID, if available. Only to be used from
drm_helper_probe_single_connector_modes()
as a fallback for when DDC probe
failed during drm_get_edid()
and caused the override/firmware EDID to be
skipped.
Return
The number of modes added or 0 if we couldn’t find any.
-
struct edid *
drm_do_get_edid
(struct drm_connector * connector, read_block_fn read_block, void * context)¶ get EDID data using a custom EDID block read function
Parameters
struct drm_connector * connector
- connector we’re probing
read_block_fn read_block
- EDID block read function
void * context
- private data passed to the block read function
Description
When the I2C adapter connected to the DDC bus is hidden behind a device that exposes a different interface to read EDID blocks this function can be used to get EDID data using a custom block read function.
As in the general case the DDC bus is accessible by the kernel at the I2C
level, drivers must make all reasonable efforts to expose it as an I2C
adapter and use drm_get_edid()
instead of abusing this function.
The EDID may be overridden using debugfs override_edid or firmware EDID
(drm_load_edid_firmware()
and drm.edid_firmware parameter), in this priority
order. Having either of them bypasses actual EDID reads.
Return
Pointer to valid EDID or NULL if we couldn’t find any.
-
const struct edid *
drm_edid_raw
(const struct drm_edid * drm_edid)¶ Get a pointer to the raw EDID data.
Parameters
const struct drm_edid * drm_edid
- drm_edid container
Description
Get a pointer to the raw EDID data.
This is for transition only. Avoid using this like the plague.
Return
Pointer to raw EDID data.
-
const struct drm_edid *
drm_edid_alloc
(const void * edid, size_t size)¶ Allocate a new drm_edid container
Parameters
const void * edid
- Pointer to raw EDID data
size_t size
- Size of memory allocated for EDID
Description
Allocate a new drm_edid container. Do not calculate edid size from edid, pass the actual size that has been allocated for the data. There is no validation of the raw EDID data against the size, but at least the EDID base block must fit in the buffer.
The returned pointer must be freed using drm_edid_free()
.
Return
drm_edid container, or NULL on errors
-
const struct drm_edid *
drm_edid_dup
(const struct drm_edid * drm_edid)¶ Duplicate a drm_edid container
Parameters
const struct drm_edid * drm_edid
- EDID to duplicate
Description
The returned pointer must be freed using drm_edid_free()
.
Return
drm_edid container copy, or NULL on errors
-
void
drm_edid_free
(const struct drm_edid * drm_edid)¶ Free the drm_edid container
Parameters
const struct drm_edid * drm_edid
- EDID to free
-
bool
drm_probe_ddc
(struct i2c_adapter * adapter)¶ probe DDC presence
Parameters
struct i2c_adapter * adapter
- I2C adapter to probe
Return
True on success, false on failure.
-
struct edid *
drm_get_edid
(struct drm_connector * connector, struct i2c_adapter * adapter)¶ get EDID data, if available
Parameters
struct drm_connector * connector
- connector we’re probing
struct i2c_adapter * adapter
- I2C adapter to use for DDC
Description
Poke the given I2C channel to grab EDID data if possible. If found, attach it to the connector.
Return
Pointer to valid EDID or NULL if we couldn’t find any.
-
const struct drm_edid *
drm_edid_read_custom
(struct drm_connector * connector, read_block_fn read_block, void * context)¶ Read EDID data using given EDID block read function
Parameters
struct drm_connector * connector
- Connector to use
read_block_fn read_block
- EDID block read function
void * context
- Private data passed to the block read function
Description
When the I2C adapter connected to the DDC bus is hidden behind a device that exposes a different interface to read EDID blocks this function can be used to get EDID data using a custom block read function.
As in the general case the DDC bus is accessible by the kernel at the I2C
level, drivers must make all reasonable efforts to expose it as an I2C
adapter and use drm_edid_read()
or drm_edid_read_ddc()
instead of abusing
this function.
The EDID may be overridden using debugfs override_edid or firmware EDID
(drm_load_edid_firmware()
and drm.edid_firmware parameter), in this priority
order. Having either of them bypasses actual EDID reads.
The returned pointer must be freed using drm_edid_free()
.
Return
Pointer to EDID, or NULL if probe/read failed.
-
const struct drm_edid *
drm_edid_read_ddc
(struct drm_connector * connector, struct i2c_adapter * adapter)¶ Read EDID data using given I2C adapter
Parameters
struct drm_connector * connector
- Connector to use
struct i2c_adapter * adapter
- I2C adapter to use for DDC
Description
Read EDID using the given I2C adapter.
The EDID may be overridden using debugfs override_edid or firmware EDID
(drm_load_edid_firmware()
and drm.edid_firmware parameter), in this priority
order. Having either of them bypasses actual EDID reads.
Prefer initializing connector->ddc with drm_connector_init_with_ddc()
and
using drm_edid_read()
instead of this function.
The returned pointer must be freed using drm_edid_free()
.
Return
Pointer to EDID, or NULL if probe/read failed.
-
const struct drm_edid *
drm_edid_read
(struct drm_connector * connector)¶ Read EDID data using connector’s I2C adapter
Parameters
struct drm_connector * connector
- Connector to use
Description
Read EDID using the connector’s I2C adapter.
The EDID may be overridden using debugfs override_edid or firmware EDID
(drm_load_edid_firmware()
and drm.edid_firmware parameter), in this priority
order. Having either of them bypasses actual EDID reads.
The returned pointer must be freed using drm_edid_free()
.
Return
Pointer to EDID, or NULL if probe/read failed.
-
u32
drm_edid_get_panel_id
(struct i2c_adapter * adapter)¶ Get a panel’s ID through DDC
Parameters
struct i2c_adapter * adapter
- I2C adapter to use for DDC
Description
This function reads the first block of the EDID of a panel and (assuming that the EDID is valid) extracts the ID out of it. The ID is a 32-bit value (16 bits of manufacturer ID and 16 bits of per-manufacturer ID) that’s supposed to be different for each different modem of panel.
This function is intended to be used during early probing on devices where more than one panel might be present. Because of its intended use it must assume that the EDID of the panel is correct, at least as far as the ID is concerned (in other words, we don’t process any overrides here).
NOTE
it’s expected that this function and drm_do_get_edid()
will both
be read the EDID, but there is no caching between them. Since we’re only
reading the first block, hopefully this extra overhead won’t be too big.
Return
- A 32-bit ID that should be different for each make/model of panel.
- See the functions
drm_edid_encode_panel_id()
anddrm_edid_decode_panel_id()
for some details on the structure of this ID.
-
struct edid *
drm_get_edid_switcheroo
(struct drm_connector * connector, struct i2c_adapter * adapter)¶ get EDID data for a vga_switcheroo output
Parameters
struct drm_connector * connector
- connector we’re probing
struct i2c_adapter * adapter
- I2C adapter to use for DDC
Description
Wrapper around drm_get_edid()
for laptops with dual GPUs using one set of
outputs. The wrapper adds the requisite vga_switcheroo calls to temporarily
switch DDC to the GPU which is retrieving EDID.
Return
Pointer to valid EDID or NULL
if we couldn’t find any.
-
struct edid *
drm_edid_duplicate
(const struct edid * edid)¶ duplicate an EDID and the extensions
Parameters
const struct edid * edid
- EDID to duplicate
Return
Pointer to duplicated EDID or NULL on allocation failure.
-
u8
drm_match_cea_mode
(const struct drm_display_mode * to_match)¶ look for a CEA mode matching given mode
Parameters
const struct drm_display_mode * to_match
- display mode
Return
The CEA Video ID (VIC) of the mode or 0 if it isn’t a CEA-861 mode.
-
struct drm_display_mode *
drm_display_mode_from_cea_vic
(struct drm_device * dev, u8 video_code)¶ return a mode for CEA VIC
Parameters
struct drm_device * dev
- DRM device
u8 video_code
- CEA VIC of the mode
Description
Creates a new mode matching the specified CEA VIC.
Return
A new drm_display_mode on success or NULL on failure
-
void
drm_edid_get_monitor_name
(const struct edid * edid, char * name, int bufsize)¶ fetch the monitor name from the edid
Parameters
const struct edid * edid
- monitor EDID information
char * name
- pointer to a character array to hold the name of the monitor
int bufsize
- The size of the name buffer (should be at least 14 chars.)
-
int
drm_edid_to_sad
(const struct edid * edid, struct cea_sad ** sads)¶ extracts SADs from EDID
Parameters
const struct edid * edid
- EDID to parse
struct cea_sad ** sads
- pointer that will be set to the extracted SADs
Description
Looks for CEA EDID block and extracts SADs (Short Audio Descriptors) from it.
Note
The returned pointer needs to be freed using kfree()
.
Return
The number of found SADs or negative number on error.
-
int
drm_edid_to_speaker_allocation
(const struct edid * edid, u8 ** sadb)¶ extracts Speaker Allocation Data Blocks from EDID
Parameters
const struct edid * edid
- EDID to parse
u8 ** sadb
- pointer to the speaker block
Description
Looks for CEA EDID block and extracts the Speaker Allocation Data Block from it.
Note
The returned pointer needs to be freed using kfree()
.
Return
The number of found Speaker Allocation Blocks or negative number on error.
-
int
drm_av_sync_delay
(struct drm_connector * connector, const struct drm_display_mode * mode)¶ compute the HDMI/DP sink audio-video sync delay
Parameters
struct drm_connector * connector
- connector associated with the HDMI/DP sink
const struct drm_display_mode * mode
- the display mode
Return
The HDMI/DP sink’s audio-video sync delay in milliseconds or 0 if the sink doesn’t support audio or video.
-
bool
drm_detect_hdmi_monitor
(const struct edid * edid)¶ detect whether monitor is HDMI
Parameters
const struct edid * edid
- monitor EDID information
Description
Parse the CEA extension according to CEA-861-B.
Drivers that have added the modes parsed from EDID to drm_display_info
should use drm_display_info.is_hdmi
instead of calling this function.
Return
True if the monitor is HDMI, false if not or unknown.
-
bool
drm_detect_monitor_audio
(const struct edid * edid)¶ check monitor audio capability
Parameters
const struct edid * edid
- EDID block to scan
Description
Monitor should have CEA extension block. If monitor has ‘basic audio’, but no CEA audio blocks, it’s ‘basic audio’ only. If there is any audio extension block and supported audio format, assume at least ‘basic audio’ support, even if ‘basic audio’ is not defined in EDID.
Return
True if the monitor supports audio, false otherwise.
-
enum hdmi_quantization_range
drm_default_rgb_quant_range
(const struct drm_display_mode * mode)¶ default RGB quantization range
Parameters
const struct drm_display_mode * mode
- display mode
Description
Determine the default RGB quantization range for the mode, as specified in CEA-861.
Return
The default RGB quantization range for the mode
-
int
drm_edid_connector_update
(struct drm_connector * connector, const struct drm_edid * drm_edid)¶ Update connector information from EDID
Parameters
struct drm_connector * connector
- Connector
const struct drm_edid * drm_edid
- EDID
Description
Update the connector mode list, display info, ELD, HDR metadata, relevant properties, etc. from the passed in EDID.
If EDID is NULL, reset the information.
Return
The number of modes added or 0 if we couldn’t find any.
-
int
drm_connector_update_edid_property
(struct drm_connector * connector, const struct edid * edid)¶ update the edid property of a connector
Parameters
struct drm_connector * connector
- drm connector
const struct edid * edid
- new value of the edid property
Description
This function creates a new blob modeset object and assigns its id to the
connector’s edid property.
Since we also parse tile information from EDID’s displayID block, we also
set the connector’s tile property here. See drm_connector_set_tile_property()
for more details.
This function is deprecated. Use drm_edid_connector_update()
instead.
Return
Zero on success, negative errno on failure.
-
int
drm_add_edid_modes
(struct drm_connector * connector, struct edid * edid)¶ add modes from EDID data, if available
Parameters
struct drm_connector * connector
- connector we’re probing
struct edid * edid
- EDID data
Description
Add the specified modes to the connector’s mode list. Also fills out the
drm_display_info
structure and ELD in connector with any information which
can be derived from the edid.
This function is deprecated. Use drm_edid_connector_update()
instead.
Return
The number of modes added or 0 if we couldn’t find any.
-
int
drm_add_modes_noedid
(struct drm_connector * connector, int hdisplay, int vdisplay)¶ add modes for the connectors without EDID
Parameters
struct drm_connector * connector
- connector we’re probing
int hdisplay
- the horizontal display limit
int vdisplay
- the vertical display limit
Description
Add the specified modes to the connector’s mode list. Only when the hdisplay/vdisplay is not beyond the given limit, it will be added.
Return
The number of modes added or 0 if we couldn’t find any.
-
void
drm_set_preferred_mode
(struct drm_connector * connector, int hpref, int vpref)¶ Sets the preferred mode of a connector
Parameters
struct drm_connector * connector
- connector whose mode list should be processed
int hpref
- horizontal resolution of preferred mode
int vpref
- vertical resolution of preferred mode
Description
Marks a mode as preferred if it matches the resolution specified by hpref and vpref.
-
int
drm_hdmi_avi_infoframe_from_display_mode
(struct hdmi_avi_infoframe * frame, const struct drm_connector * connector, const struct drm_display_mode * mode)¶ fill an HDMI AVI infoframe with data from a DRM display mode
Parameters
struct hdmi_avi_infoframe * frame
- HDMI AVI infoframe
const struct drm_connector * connector
- the connector
const struct drm_display_mode * mode
- DRM display mode
Return
0 on success or a negative error code on failure.
-
void
drm_hdmi_avi_infoframe_quant_range
(struct hdmi_avi_infoframe * frame, const struct drm_connector * connector, const struct drm_display_mode * mode, enum hdmi_quantization_range rgb_quant_range)¶ fill the HDMI AVI infoframe quantization range information
Parameters
struct hdmi_avi_infoframe * frame
- HDMI AVI infoframe
const struct drm_connector * connector
- the connector
const struct drm_display_mode * mode
- DRM display mode
enum hdmi_quantization_range rgb_quant_range
- RGB quantization range (Q)
-
int
drm_hdmi_vendor_infoframe_from_display_mode
(struct hdmi_vendor_infoframe * frame, const struct drm_connector * connector, const struct drm_display_mode * mode)¶ fill an HDMI infoframe with data from a DRM display mode
Parameters
struct hdmi_vendor_infoframe * frame
- HDMI vendor infoframe
const struct drm_connector * connector
- the connector
const struct drm_display_mode * mode
- DRM display mode
Description
Note that there’s is a need to send HDMI vendor infoframes only when using a 4k or stereoscopic 3D mode. So when giving any other mode as input this function will return -EINVAL, error that can be safely ignored.
Return
0 on success or a negative error code on failure.
SCDC Helper Functions Reference¶
Error
kernel-doc missing
Error
kernel-doc missing
Error
kernel-doc missing
Rectangle Utilities Reference¶
Utility functions to help manage rectangular areas for clipping, scaling, etc. calculations.
-
struct
drm_rect
¶ two dimensional rectangle
Definition
struct drm_rect {
int x1, y1, x2, y2;
};
Members
x1
- horizontal starting coordinate (inclusive)
y1
- vertical starting coordinate (inclusive)
x2
- horizontal ending coordinate (exclusive)
y2
- vertical ending coordinate (exclusive)
Description
Note that this must match the layout of struct drm_mode_rect or the damage
helpers like drm_atomic_helper_damage_iter_init()
break.
-
DRM_RECT_INIT
(x, y, w, h)¶ initialize a rectangle from x/y/w/h
Parameters
x
- x coordinate
y
- y coordinate
w
- width
h
- height
Return
A new rectangle of the specified size.
-
DRM_RECT_FMT
()¶ printf string for
struct drm_rect
Parameters
-
DRM_RECT_ARG
(r)¶ printf arguments for
struct drm_rect
Parameters
r
- rectangle struct
-
DRM_RECT_FP_FMT
()¶ printf string for
struct drm_rect
in 16.16 fixed point
Parameters
-
DRM_RECT_FP_ARG
(r)¶ printf arguments for
struct drm_rect
in 16.16 fixed point
Parameters
r
- rectangle struct
Description
This is useful for e.g. printing plane source rectangles, which are in 16.16 fixed point.
-
void
drm_rect_init
(struct drm_rect * r, int x, int y, int width, int height)¶ initialize the rectangle from x/y/w/h
Parameters
struct drm_rect * r
- rectangle
int x
- x coordinate
int y
- y coordinate
int width
- width
int height
- height
Parameters
struct drm_rect * r
- rectangle to be adjusted
int dw
- horizontal adjustment
int dh
- vertical adjustment
Description
Change the size of rectangle r by dw in the horizontal direction, and by dh in the vertical direction, while keeping the center of r stationary.
Positive dw and dh increase the size, negative values decrease it.
Parameters
struct drm_rect * r
- rectangle to be tranlated
int dx
- horizontal translation
int dy
- vertical translation
Description
Move rectangle r by dx in the horizontal direction, and by dy in the vertical direction.
-
void
drm_rect_translate_to
(struct drm_rect * r, int x, int y)¶ translate the rectangle to an absolute position
Parameters
struct drm_rect * r
- rectangle to be tranlated
int x
- horizontal position
int y
- vertical position
Description
Move rectangle r to x in the horizontal direction, and to y in the vertical direction.
Parameters
struct drm_rect * r
- rectangle to be downscaled
int horz
- horizontal downscale factor
int vert
- vertical downscale factor
Description
Divide the coordinates of rectangle r by horz and vert.
Parameters
const struct drm_rect * r
- rectangle whose width is returned
Return
The width of the rectangle.
Parameters
const struct drm_rect * r
- rectangle whose height is returned
Return
The height of the rectangle.
Parameters
const struct drm_rect * r
- rectangle whose visibility is returned
Return
true
if the rectangle is visible, false
otherwise.
-
bool
drm_rect_equals
(const struct drm_rect * r1, const struct drm_rect * r2)¶ determine if two rectangles are equal
Parameters
const struct drm_rect * r1
- first rectangle
const struct drm_rect * r2
- second rectangle
Return
true
if the rectangles are equal, false
otherwise.
-
void
drm_rect_fp_to_int
(struct drm_rect * dst, const struct drm_rect * src)¶ Convert a rect in 16.16 fixed point form to int form.
Parameters
struct drm_rect * dst
- rect to be stored the converted value
const struct drm_rect * src
- rect in 16.16 fixed point form
Parameters
struct drm_rect * r1
- first rectangle
const struct drm_rect * r2
- second rectangle
Description
Calculate the intersection of rectangles r1 and r2. r1 will be overwritten with the intersection.
Return
true
if rectangle r1 is still visible after the operation,
false
otherwise.
-
bool
drm_rect_clip_scaled
(struct drm_rect * src, struct drm_rect * dst, const struct drm_rect * clip)¶ perform a scaled clip operation
Parameters
struct drm_rect * src
- source window rectangle
struct drm_rect * dst
- destination window rectangle
const struct drm_rect * clip
- clip rectangle
Description
Clip rectangle dst by rectangle clip. Clip rectangle src by the the corresponding amounts, retaining the vertical and horizontal scaling factors from src to dst.
Return
true
if rectangle dst is still visible after being clipped,
false
otherwise.
-
int
drm_rect_calc_hscale
(const struct drm_rect * src, const struct drm_rect * dst, int min_hscale, int max_hscale)¶ calculate the horizontal scaling factor
Parameters
const struct drm_rect * src
- source window rectangle
const struct drm_rect * dst
- destination window rectangle
int min_hscale
- minimum allowed horizontal scaling factor
int max_hscale
- maximum allowed horizontal scaling factor
Description
Calculate the horizontal scaling factor as (src width) / (dst width).
If the scale is below 1 << 16, round down. If the scale is above 1 << 16, round up. This will calculate the scale with the most pessimistic limit calculation.
Return
The horizontal scaling factor, or errno of out of limits.
-
int
drm_rect_calc_vscale
(const struct drm_rect * src, const struct drm_rect * dst, int min_vscale, int max_vscale)¶ calculate the vertical scaling factor
Parameters
const struct drm_rect * src
- source window rectangle
const struct drm_rect * dst
- destination window rectangle
int min_vscale
- minimum allowed vertical scaling factor
int max_vscale
- maximum allowed vertical scaling factor
Description
Calculate the vertical scaling factor as (src height) / (dst height).
If the scale is below 1 << 16, round down. If the scale is above 1 << 16, round up. This will calculate the scale with the most pessimistic limit calculation.
Return
The vertical scaling factor, or errno of out of limits.
-
void
drm_rect_debug_print
(const char * prefix, const struct drm_rect * r, bool fixed_point)¶ print the rectangle information
Parameters
const char * prefix
- prefix string
const struct drm_rect * r
- rectangle to print
bool fixed_point
- rectangle is in 16.16 fixed point format
-
void
drm_rect_rotate
(struct drm_rect * r, int width, int height, unsigned int rotation)¶ Rotate the rectangle
Parameters
struct drm_rect * r
- rectangle to be rotated
int width
- Width of the coordinate space
int height
- Height of the coordinate space
unsigned int rotation
- Transformation to be applied
Description
Apply rotation to the coordinates of rectangle r.
width and height combined with rotation define the location of the new origin.
width correcsponds to the horizontal and height to the vertical axis of the untransformed coordinate space.
-
void
drm_rect_rotate_inv
(struct drm_rect * r, int width, int height, unsigned int rotation)¶ Inverse rotate the rectangle
Parameters
struct drm_rect * r
- rectangle to be rotated
int width
- Width of the coordinate space
int height
- Height of the coordinate space
unsigned int rotation
- Transformation whose inverse is to be applied
Description
Apply the inverse of rotation to the coordinates of rectangle r.
width and height combined with rotation define the location of the new origin.
width correcsponds to the horizontal and height to the vertical axis of the original untransformed coordinate space, so that you never have to flip them when doing a rotatation and its inverse. That is, if you do
drm_rect_rotate(&r, width, height, rotation);
drm_rect_rotate_inv(&r, width, height, rotation);
you will always get back the original rectangle.
HDMI Infoframes Helper Reference¶
Strictly speaking this is not a DRM helper library but generally useable by any driver interfacing with HDMI outputs like v4l or alsa drivers. But it nicely fits into the overall topic of mode setting helper libraries and hence is also included here.
-
struct
hdr_sink_metadata
¶ HDR sink metadata
Definition
struct hdr_sink_metadata {
__u32 metadata_type;
union {
struct hdr_static_metadata hdmi_type1;
};
};
Members
metadata_type
- Static_Metadata_Descriptor_ID.
{unnamed_union}
- anonymous
hdmi_type1
- HDR Metadata Infoframe.
Description
Metadata Information read from Sink’s EDID
-
union
hdmi_infoframe
¶ overall union of all abstract infoframe representations
Definition
union hdmi_infoframe {
struct hdmi_any_infoframe any;
struct hdmi_avi_infoframe avi;
struct hdmi_spd_infoframe spd;
union hdmi_vendor_any_infoframe vendor;
struct hdmi_audio_infoframe audio;
struct hdmi_drm_infoframe drm;
};
Members
any
- generic infoframe
avi
- avi infoframe
spd
- spd infoframe
vendor
- union of all vendor infoframes
audio
- audio infoframe
drm
- Dynamic Range and Mastering infoframe
Description
This is used by the generic pack function. This works since all infoframes have the same header which also indicates which type of infoframe should be packed.
-
void
hdmi_avi_infoframe_init
(struct hdmi_avi_infoframe * frame)¶ initialize an HDMI AVI infoframe
Parameters
struct hdmi_avi_infoframe * frame
- HDMI AVI infoframe
-
int
hdmi_avi_infoframe_check
(struct hdmi_avi_infoframe * frame)¶ check a HDMI AVI infoframe
Parameters
struct hdmi_avi_infoframe * frame
- HDMI AVI infoframe
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields.
Returns 0 on success or a negative error code on failure.
-
ssize_t
hdmi_avi_infoframe_pack_only
(const struct hdmi_avi_infoframe * frame, void * buffer, size_t size)¶ write HDMI AVI infoframe to binary buffer
Parameters
const struct hdmi_avi_infoframe * frame
- HDMI AVI infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. Also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
ssize_t
hdmi_avi_infoframe_pack
(struct hdmi_avi_infoframe * frame, void * buffer, size_t size)¶ check a HDMI AVI infoframe, and write it to binary buffer
Parameters
struct hdmi_avi_infoframe * frame
- HDMI AVI infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields, after which it packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. This function also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
int
hdmi_spd_infoframe_init
(struct hdmi_spd_infoframe * frame, const char * vendor, const char * product)¶ initialize an HDMI SPD infoframe
Parameters
struct hdmi_spd_infoframe * frame
- HDMI SPD infoframe
const char * vendor
- vendor string
const char * product
- product string
Description
Returns 0 on success or a negative error code on failure.
-
int
hdmi_spd_infoframe_check
(struct hdmi_spd_infoframe * frame)¶ check a HDMI SPD infoframe
Parameters
struct hdmi_spd_infoframe * frame
- HDMI SPD infoframe
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields.
Returns 0 on success or a negative error code on failure.
-
ssize_t
hdmi_spd_infoframe_pack_only
(const struct hdmi_spd_infoframe * frame, void * buffer, size_t size)¶ write HDMI SPD infoframe to binary buffer
Parameters
const struct hdmi_spd_infoframe * frame
- HDMI SPD infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. Also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
ssize_t
hdmi_spd_infoframe_pack
(struct hdmi_spd_infoframe * frame, void * buffer, size_t size)¶ check a HDMI SPD infoframe, and write it to binary buffer
Parameters
struct hdmi_spd_infoframe * frame
- HDMI SPD infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields, after which it packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. This function also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
int
hdmi_audio_infoframe_init
(struct hdmi_audio_infoframe * frame)¶ initialize an HDMI audio infoframe
Parameters
struct hdmi_audio_infoframe * frame
- HDMI audio infoframe
Description
Returns 0 on success or a negative error code on failure.
-
int
hdmi_audio_infoframe_check
(struct hdmi_audio_infoframe * frame)¶ check a HDMI audio infoframe
Parameters
struct hdmi_audio_infoframe * frame
- HDMI audio infoframe
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields.
Returns 0 on success or a negative error code on failure.
-
ssize_t
hdmi_audio_infoframe_pack_only
(const struct hdmi_audio_infoframe * frame, void * buffer, size_t size)¶ write HDMI audio infoframe to binary buffer
Parameters
const struct hdmi_audio_infoframe * frame
- HDMI audio infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. Also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
ssize_t
hdmi_audio_infoframe_pack
(struct hdmi_audio_infoframe * frame, void * buffer, size_t size)¶ check a HDMI Audio infoframe, and write it to binary buffer
Parameters
struct hdmi_audio_infoframe * frame
- HDMI Audio infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields, after which it packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. This function also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
int
hdmi_vendor_infoframe_init
(struct hdmi_vendor_infoframe * frame)¶ initialize an HDMI vendor infoframe
Parameters
struct hdmi_vendor_infoframe * frame
- HDMI vendor infoframe
Description
Returns 0 on success or a negative error code on failure.
-
int
hdmi_vendor_infoframe_check
(struct hdmi_vendor_infoframe * frame)¶ check a HDMI vendor infoframe
Parameters
struct hdmi_vendor_infoframe * frame
- HDMI infoframe
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields.
Returns 0 on success or a negative error code on failure.
-
ssize_t
hdmi_vendor_infoframe_pack_only
(const struct hdmi_vendor_infoframe * frame, void * buffer, size_t size)¶ write a HDMI vendor infoframe to binary buffer
Parameters
const struct hdmi_vendor_infoframe * frame
- HDMI infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. Also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
ssize_t
hdmi_vendor_infoframe_pack
(struct hdmi_vendor_infoframe * frame, void * buffer, size_t size)¶ check a HDMI Vendor infoframe, and write it to binary buffer
Parameters
struct hdmi_vendor_infoframe * frame
- HDMI Vendor infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields, after which it packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. This function also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
int
hdmi_drm_infoframe_init
(struct hdmi_drm_infoframe * frame)¶ initialize an HDMI Dynaminc Range and mastering infoframe
Parameters
struct hdmi_drm_infoframe * frame
- HDMI DRM infoframe
Description
Returns 0 on success or a negative error code on failure.
-
int
hdmi_drm_infoframe_check
(struct hdmi_drm_infoframe * frame)¶ check a HDMI DRM infoframe
Parameters
struct hdmi_drm_infoframe * frame
- HDMI DRM infoframe
Description
Validates that the infoframe is consistent. Returns 0 on success or a negative error code on failure.
-
ssize_t
hdmi_drm_infoframe_pack_only
(const struct hdmi_drm_infoframe * frame, void * buffer, size_t size)¶ write HDMI DRM infoframe to binary buffer
Parameters
const struct hdmi_drm_infoframe * frame
- HDMI DRM infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. Also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
ssize_t
hdmi_drm_infoframe_pack
(struct hdmi_drm_infoframe * frame, void * buffer, size_t size)¶ check a HDMI DRM infoframe, and write it to binary buffer
Parameters
struct hdmi_drm_infoframe * frame
- HDMI DRM infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields, after which it packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. This function also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
int
hdmi_infoframe_check
(union hdmi_infoframe * frame)¶ check a HDMI infoframe
Parameters
union hdmi_infoframe * frame
- HDMI infoframe
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields.
Returns 0 on success or a negative error code on failure.
-
ssize_t
hdmi_infoframe_pack_only
(const union hdmi_infoframe * frame, void * buffer, size_t size)¶ write a HDMI infoframe to binary buffer
Parameters
const union hdmi_infoframe * frame
- HDMI infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. Also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
ssize_t
hdmi_infoframe_pack
(union hdmi_infoframe * frame, void * buffer, size_t size)¶ check a HDMI infoframe, and write it to binary buffer
Parameters
union hdmi_infoframe * frame
- HDMI infoframe
void * buffer
- destination buffer
size_t size
- size of buffer
Description
Validates that the infoframe is consistent and updates derived fields (eg. length) based on other fields, after which it packs the information contained in the frame structure into a binary representation that can be written into the corresponding controller registers. This function also computes the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns the number of bytes packed into the binary buffer or a negative error code on failure.
-
void
hdmi_infoframe_log
(const char * level, struct device * dev, const union hdmi_infoframe * frame)¶ log info of HDMI infoframe
Parameters
const char * level
- logging level
struct device * dev
- device
const union hdmi_infoframe * frame
- HDMI infoframe
-
int
hdmi_drm_infoframe_unpack_only
(struct hdmi_drm_infoframe * frame, const void * buffer, size_t size)¶ unpack binary buffer of CTA-861-G DRM infoframe DataBytes to a HDMI DRM infoframe
Parameters
struct hdmi_drm_infoframe * frame
- HDMI DRM infoframe
const void * buffer
- source buffer
size_t size
- size of buffer
Description
Unpacks CTA-861-G DRM infoframe DataBytes contained in the binary buffer into a structured frame of the HDMI Dynamic Range and Mastering (DRM) infoframe.
Returns 0 on success or a negative error code on failure.
-
int
hdmi_infoframe_unpack
(union hdmi_infoframe * frame, const void * buffer, size_t size)¶ unpack binary buffer to a HDMI infoframe
Parameters
union hdmi_infoframe * frame
- HDMI infoframe
const void * buffer
- source buffer
size_t size
- size of buffer
Description
Unpacks the information contained in binary buffer buffer into a structured frame of a HDMI infoframe. Also verifies the checksum as required by section 5.3.5 of the HDMI 1.4 specification.
Returns 0 on success or a negative error code on failure.
Flip-work Helper Reference¶
Util to queue up work to run from work-queue context after flip/vblank. Typically this can be used to defer unref of framebuffer’s, cursor bo’s, etc until after vblank. The APIs are all thread-safe. Moreover, drm_flip_work_queue_task and drm_flip_work_queue can be called in atomic context.
-
struct
drm_flip_task
¶ flip work task
Definition
struct drm_flip_task {
struct list_head node;
void *data;
};
Members
node
- list entry element
data
- data to pass to
drm_flip_work.func
-
struct
drm_flip_work
¶ flip work queue
Definition
struct drm_flip_work {
const char *name;
drm_flip_func_t func;
struct work_struct worker;
struct list_head queued;
struct list_head commited;
spinlock_t lock;
};
Members
name
- debug name
func
- callback fxn called for each committed item
worker
- worker which calls func
queued
- queued tasks
commited
- commited tasks
lock
- lock to access queued and commited lists
-
struct drm_flip_task *
drm_flip_work_allocate_task
(void * data, gfp_t flags)¶ allocate a flip-work task
Parameters
void * data
- data associated to the task
gfp_t flags
- allocator flags
Description
Allocate a drm_flip_task object and attach private data to it.
-
void
drm_flip_work_queue_task
(struct drm_flip_work * work, struct drm_flip_task * task)¶ queue a specific task
Parameters
struct drm_flip_work * work
- the flip-work
struct drm_flip_task * task
- the task to handle
Description
Queues task, that will later be run (passed back to drm_flip_func_t
func) on a work queue after drm_flip_work_commit()
is called.
-
void
drm_flip_work_queue
(struct drm_flip_work * work, void * val)¶ queue work
Parameters
struct drm_flip_work * work
- the flip-work
void * val
- the value to queue
Description
Queues work, that will later be run (passed back to drm_flip_func_t
func) on a work queue after drm_flip_work_commit()
is called.
-
void
drm_flip_work_commit
(struct drm_flip_work * work, struct workqueue_struct * wq)¶ commit queued work
Parameters
struct drm_flip_work * work
- the flip-work
struct workqueue_struct * wq
- the work-queue to run the queued work on
Description
Trigger work previously queued by drm_flip_work_queue()
to run
on a workqueue. The typical usage would be to queue work (via
drm_flip_work_queue()
) at any point (from vblank irq and/or
prior), and then from vblank irq commit the queued work.
-
void
drm_flip_work_init
(struct drm_flip_work * work, const char * name, drm_flip_func_t func)¶ initialize flip-work
Parameters
struct drm_flip_work * work
- the flip-work to initialize
const char * name
- debug name
drm_flip_func_t func
- the callback work function
Description
Initializes/allocates resources for the flip-work
-
void
drm_flip_work_cleanup
(struct drm_flip_work * work)¶ cleans up flip-work
Parameters
struct drm_flip_work * work
- the flip-work to cleanup
Description
Destroy resources allocated for the flip-work
Auxiliary Modeset Helpers¶
This helper library contains various one-off functions which don’t really fit anywhere else in the DRM modeset helper library.
-
void
drm_helper_move_panel_connectors_to_head
(struct drm_device * dev)¶ move panels to the front in the connector list
Parameters
struct drm_device * dev
- drm device to operate on
Description
Some userspace presumes that the first connected connector is the main display, where it’s supposed to display e.g. the login screen. For laptops, this should be the main panel. Use this function to sort all (eDP/LVDS/DSI) panels to the front of the connector list, instead of painstakingly trying to initialize them in the right order.
-
void
drm_helper_mode_fill_fb_struct
(struct drm_device * dev, struct drm_framebuffer * fb, const struct drm_mode_fb_cmd2 * mode_cmd)¶ fill out framebuffer metadata
Parameters
struct drm_device * dev
- DRM device
struct drm_framebuffer * fb
- drm_framebuffer object to fill out
const struct drm_mode_fb_cmd2 * mode_cmd
- metadata from the userspace fb creation request
Description
This helper can be used in a drivers fb_create callback to pre-fill the fb’s metadata fields.
-
int
drm_crtc_init
(struct drm_device * dev, struct drm_crtc * crtc, const struct drm_crtc_funcs * funcs)¶ Legacy CRTC initialization function
Parameters
struct drm_device * dev
- DRM device
struct drm_crtc * crtc
- CRTC object to init
const struct drm_crtc_funcs * funcs
- callbacks for the new CRTC
Description
Initialize a CRTC object with a default helper-provided primary plane and no cursor plane.
Note that we make some assumptions about hardware limitations that may not be true for all hardware:
- Primary plane cannot be repositioned.
- Primary plane cannot be scaled.
- Primary plane must cover the entire CRTC.
- Subpixel positioning is not supported.
- The primary plane must always be on if the CRTC is enabled.
This is purely a backwards compatibility helper for old drivers. Drivers
should instead implement their own primary plane. Atomic drivers must do so.
Drivers with the above hardware restriction can look into using struct
drm_simple_display_pipe
, which encapsulates the above limitations into a nice
interface.
Return
Zero on success, error code on failure.
-
int
drm_mode_config_helper_suspend
(struct drm_device * dev)¶ Modeset suspend helper
Parameters
struct drm_device * dev
- DRM device
Description
This helper function takes care of suspending the modeset side. It disables
output polling if initialized, suspends fbdev if used and finally calls
drm_atomic_helper_suspend()
.
If suspending fails, fbdev and polling is re-enabled.
Return
Zero on success, negative error code on error.
See also:
drm_kms_helper_poll_disable()
and drm_fb_helper_set_suspend_unlocked()
.
-
int
drm_mode_config_helper_resume
(struct drm_device * dev)¶ Modeset resume helper
Parameters
struct drm_device * dev
- DRM device
Description
This helper function takes care of resuming the modeset side. It calls
drm_atomic_helper_resume()
, resumes fbdev if used and enables output polling
if initiaized.
Return
Zero on success, negative error code on error.
See also:
drm_fb_helper_set_suspend_unlocked()
and drm_kms_helper_poll_enable()
.
Framebuffer GEM Helper Reference¶
This library provides helpers for drivers that don’t subclass
drm_framebuffer
and use drm_gem_object
for their backing storage.
Drivers without additional needs to validate framebuffers can simply use
drm_gem_fb_create()
and everything is wired up automatically. Other drivers
can use all parts independently.
-
struct drm_gem_object *
drm_gem_fb_get_obj
(struct drm_framebuffer * fb, unsigned int plane)¶ Get GEM object backing the framebuffer
Parameters
struct drm_framebuffer * fb
- Framebuffer
unsigned int plane
- Plane index
Description
No additional reference is taken beyond the one that the drm_frambuffer
already holds.
Return
Pointer to drm_gem_object
for the given framebuffer and plane index or NULL
if it does not exist.
-
void
drm_gem_fb_destroy
(struct drm_framebuffer * fb)¶ Free GEM backed framebuffer
Parameters
struct drm_framebuffer * fb
- Framebuffer
Description
Frees a GEM backed framebuffer with its backing buffer(s) and the structure
itself. Drivers can use this as their drm_framebuffer_funcs->destroy
callback.
-
int
drm_gem_fb_create_handle
(struct drm_framebuffer * fb, struct drm_file * file, unsigned int * handle)¶ Create handle for GEM backed framebuffer
Parameters
struct drm_framebuffer * fb
- Framebuffer
struct drm_file * file
- DRM file to register the handle for
unsigned int * handle
- Pointer to return the created handle
Description
This function creates a handle for the GEM object backing the framebuffer.
Drivers can use this as their drm_framebuffer_funcs->create_handle
callback. The GETFB IOCTL calls into this callback.
Return
0 on success or a negative error code on failure.
-
int
drm_gem_fb_init_with_funcs
(struct drm_device * dev, struct drm_framebuffer * fb, struct drm_file * file, const struct drm_mode_fb_cmd2 * mode_cmd, const struct drm_framebuffer_funcs * funcs)¶ Helper function for implementing
drm_mode_config_funcs.fb_create
callback in cases when the driver allocates a subclass of struct drm_framebuffer
Parameters
struct drm_device * dev
- DRM device
struct drm_framebuffer * fb
- framebuffer object
struct drm_file * file
- DRM file that holds the GEM handle(s) backing the framebuffer
const struct drm_mode_fb_cmd2 * mode_cmd
- Metadata from the userspace framebuffer creation request
const struct drm_framebuffer_funcs * funcs
- vtable to be used for the new framebuffer object
Description
This function can be used to set drm_framebuffer_funcs
for drivers that need
custom framebuffer callbacks. Use drm_gem_fb_create()
if you don’t need to
change drm_framebuffer_funcs
. The function does buffer size validation.
The buffer size validation is for a general case, though, so users should
pay attention to the checks being appropriate for them or, at least,
non-conflicting.
Return
Zero or a negative error code.
-
struct drm_framebuffer *
drm_gem_fb_create_with_funcs
(struct drm_device * dev, struct drm_file * file, const struct drm_mode_fb_cmd2 * mode_cmd, const struct drm_framebuffer_funcs * funcs)¶ Helper function for the
drm_mode_config_funcs.fb_create
callback
Parameters
struct drm_device * dev
- DRM device
struct drm_file * file
- DRM file that holds the GEM handle(s) backing the framebuffer
const struct drm_mode_fb_cmd2 * mode_cmd
- Metadata from the userspace framebuffer creation request
const struct drm_framebuffer_funcs * funcs
- vtable to be used for the new framebuffer object
Description
This function can be used to set drm_framebuffer_funcs
for drivers that need
custom framebuffer callbacks. Use drm_gem_fb_create()
if you don’t need to
change drm_framebuffer_funcs
. The function does buffer size validation.
Return
Pointer to a drm_framebuffer
on success or an error pointer on failure.
-
struct drm_framebuffer *
drm_gem_fb_create
(struct drm_device * dev, struct drm_file * file, const struct drm_mode_fb_cmd2 * mode_cmd)¶ Helper function for the
drm_mode_config_funcs.fb_create
callback
Parameters
struct drm_device * dev
- DRM device
struct drm_file * file
- DRM file that holds the GEM handle(s) backing the framebuffer
const struct drm_mode_fb_cmd2 * mode_cmd
- Metadata from the userspace framebuffer creation request
Description
This function creates a new framebuffer object described by
drm_mode_fb_cmd2
. This description includes handles for the buffer(s)
backing the framebuffer.
If your hardware has special alignment or pitch requirements these should be
checked before calling this function. The function does buffer size
validation. Use drm_gem_fb_create_with_dirty()
if you need framebuffer
flushing.
Drivers can use this as their drm_mode_config_funcs.fb_create
callback.
The ADDFB2 IOCTL calls into this callback.
Return
Pointer to a drm_framebuffer
on success or an error pointer on failure.
-
struct drm_framebuffer *
drm_gem_fb_create_with_dirty
(struct drm_device * dev, struct drm_file * file, const struct drm_mode_fb_cmd2 * mode_cmd)¶ Helper function for the
drm_mode_config_funcs.fb_create
callback
Parameters
struct drm_device * dev
- DRM device
struct drm_file * file
- DRM file that holds the GEM handle(s) backing the framebuffer
const struct drm_mode_fb_cmd2 * mode_cmd
- Metadata from the userspace framebuffer creation request
Description
This function creates a new framebuffer object described by
drm_mode_fb_cmd2
. This description includes handles for the buffer(s)
backing the framebuffer. drm_atomic_helper_dirtyfb()
is used for the dirty
callback giving framebuffer flushing through the atomic machinery. Use
drm_gem_fb_create()
if you don’t need the dirty callback.
The function does buffer size validation.
Drivers should also call drm_plane_enable_fb_damage_clips()
on all planes
to enable userspace to use damage clips also with the ATOMIC IOCTL.
Drivers can use this as their drm_mode_config_funcs.fb_create
callback.
The ADDFB2 IOCTL calls into this callback.
Return
Pointer to a drm_framebuffer
on success or an error pointer on failure.
-
int
drm_gem_fb_vmap
(struct drm_framebuffer * fb, struct iosys_map * map, struct iosys_map * data)¶ maps all framebuffer BOs into kernel address space
Parameters
struct drm_framebuffer * fb
- the framebuffer
struct iosys_map * map
- returns the mapping’s address for each BO
struct iosys_map * data
- returns the data address for each BO, can be NULL
Description
This function maps all buffer objects of the given framebuffer into kernel address space and stores them in struct iosys_map. If the mapping operation fails for one of the BOs, the function unmaps the already established mappings automatically.
Callers that want to access a BO’s stored data should pass data. The argument returns the addresses of the data stored in each BO. This is different from map if the framebuffer’s offsets field is non-zero.
Both, map and data, must each refer to arrays with at least fb->format->num_planes elements.
See drm_gem_fb_vunmap()
for unmapping.
Return
0 on success, or a negative errno code otherwise.
-
void
drm_gem_fb_vunmap
(struct drm_framebuffer * fb, struct iosys_map * map)¶ unmaps framebuffer BOs from kernel address space
Parameters
struct drm_framebuffer * fb
- the framebuffer
struct iosys_map * map
- mapping addresses as returned by
drm_gem_fb_vmap()
Description
This function unmaps all buffer objects of the given framebuffer.
See drm_gem_fb_vmap()
for more information.
-
int
drm_gem_fb_begin_cpu_access
(struct drm_framebuffer * fb, enum dma_data_direction dir)¶ prepares GEM buffer objects for CPU access
Parameters
struct drm_framebuffer * fb
- the framebuffer
enum dma_data_direction dir
- access mode
Description
Prepares a framebuffer’s GEM buffer objects for CPU access. This function
must be called before accessing the BO data within the kernel. For imported
BOs, the function calls dma_buf_begin_cpu_access()
.
See drm_gem_fb_end_cpu_access()
for signalling the end of CPU access.
Return
0 on success, or a negative errno code otherwise.
-
void
drm_gem_fb_end_cpu_access
(struct drm_framebuffer * fb, enum dma_data_direction dir)¶ signals end of CPU access to GEM buffer objects
Parameters
struct drm_framebuffer * fb
- the framebuffer
enum dma_data_direction dir
- access mode
Description
Signals the end of CPU access to the given framebuffer’s GEM buffer objects. This
function must be paired with a corresponding call to drm_gem_fb_begin_cpu_access()
.
For imported BOs, the function calls dma_buf_end_cpu_access()
.
See also drm_gem_fb_begin_cpu_access()
.
-
int
drm_gem_fb_afbc_init
(struct drm_device * dev, const struct drm_mode_fb_cmd2 * mode_cmd, struct drm_afbc_framebuffer * afbc_fb)¶ Helper function for drivers using afbc to fill and validate all the afbc-specific struct drm_afbc_framebuffer members
Parameters
struct drm_device * dev
- DRM device
const struct drm_mode_fb_cmd2 * mode_cmd
- Metadata from the userspace framebuffer creation request
struct drm_afbc_framebuffer * afbc_fb
- afbc framebuffer
Description
This function can be used by drivers which support afbc to complete
the preparation of struct drm_afbc_framebuffer. It must be called after
allocating the said struct and calling drm_gem_fb_init_with_funcs()
.
It is caller’s responsibility to put afbc_fb->base.obj objects in case
the call is unsuccessful.
Return
Zero on success or a negative error value on failure.
Legacy Plane Helper Reference¶
This helper library has two parts. The first part has support to implement
primary plane support on top of the normal CRTC configuration interface.
Since the legacy drm_mode_config_funcs.set_config
interface ties the primary
plane together with the CRTC state this does not allow userspace to disable
the primary plane itself. The default primary plane only expose XRBG8888 and
ARGB8888 as valid pixel formats for the attached framebuffer.
Drivers are highly recommended to implement proper support for primary planes, and newly merged drivers must not rely upon these transitional helpers.
The second part also implements transitional helpers which allow drivers to gradually switch to the atomic helper infrastructure for plane updates. Once that switch is complete drivers shouldn’t use these any longer, instead using the proper legacy implementations for update and disable plane hooks provided by the atomic helpers.
Again drivers are strongly urged to switch to the new interfaces.
The plane helpers share the function table structures with other helpers,
specifically also the atomic helpers. See struct drm_plane_helper_funcs
for
the details.
Parameters
struct drm_plane * plane
- plane to destroy
Description
Provides a default plane destroy handler for primary planes. This handler is called during CRTC destruction. We disable the primary plane, remove it from the DRM plane list, and deallocate the plane structure.
Legacy CRTC/Modeset Helper Functions Reference¶
The CRTC modeset helper library provides a default set_config implementation
in drm_crtc_helper_set_config()
. Plus a few other convenience functions using
the same callbacks which drivers can use to e.g. restore the modeset
configuration on resume with drm_helper_resume_force_mode()
.
Note that this helper library doesn’t track the current power state of CRTCs
and encoders. It can call callbacks like drm_encoder_helper_funcs.dpms
even
though the hardware is already in the desired state. This deficiency has been
fixed in the atomic helpers.
The driver callbacks are mostly compatible with the atomic modeset helpers, except for the handling of the primary plane: Atomic helpers require that the primary plane is implemented as a real standalone plane and not directly tied to the CRTC state. For easier transition this library provides functions to implement the old semantics required by the CRTC helpers using the new plane and atomic helper callbacks.
Drivers are strongly urged to convert to the atomic helpers (by way of first converting to the plane helpers). New drivers must not use these functions but need to implement the atomic interface instead, potentially using the atomic helpers for that.
These legacy modeset helpers use the same function table structures as
all other modesetting helpers. See the documentation for struct
drm_crtc_helper_funcs
, struct drm_encoder_helper_funcs
and struct
drm_connector_helper_funcs
.
-
bool
drm_helper_encoder_in_use
(struct drm_encoder * encoder)¶ check if a given encoder is in use
Parameters
struct drm_encoder * encoder
- encoder to check
Description
Checks whether encoder is with the current mode setting output configuration in use by any connector. This doesn’t mean that it is actually enabled since the DPMS state is tracked separately.
Return
True if encoder is used, false otherwise.
Parameters
struct drm_crtc * crtc
- CRTC to check
Description
Checks whether crtc is with the current mode setting output configuration in use by any connector. This doesn’t mean that it is actually enabled since the DPMS state is tracked separately.
Return
True if crtc is used, false otherwise.
-
void
drm_helper_disable_unused_functions
(struct drm_device * dev)¶ disable unused objects
Parameters
struct drm_device * dev
- DRM device
Description
This function walks through the entire mode setting configuration of dev. It will remove any CRTC links of unused encoders and encoder links of disconnected connectors. Then it will disable all unused encoders and CRTCs either by calling their disable callback if available or by calling their dpms callback with DRM_MODE_DPMS_OFF.
NOTE
This function is part of the legacy modeset helper library and will cause
major confusion with atomic drivers. This is because atomic helpers guarantee
to never call ->:c:func:disable() hooks on a disabled function, or ->:c:func:enable() hooks
on an enabled functions. drm_helper_disable_unused_functions()
on the other
hand throws such guarantees into the wind and calls disable hooks
unconditionally on unused functions.
-
bool
drm_crtc_helper_set_mode
(struct drm_crtc * crtc, struct drm_display_mode * mode, int x, int y, struct drm_framebuffer * old_fb)¶ internal helper to set a mode
Parameters
struct drm_crtc * crtc
- CRTC to program
struct drm_display_mode * mode
- mode to use
int x
- horizontal offset into the surface
int y
- vertical offset into the surface
struct drm_framebuffer * old_fb
- old framebuffer, for cleanup
Description
Try to set mode on crtc. Give crtc and its associated connectors a chance
to fixup or reject the mode prior to trying to set it. This is an internal
helper that drivers could e.g. use to update properties that require the
entire output pipe to be disabled and re-enabled in a new configuration. For
example for changing whether audio is enabled on a hdmi link or for changing
panel fitter or dither attributes. It is also called by the
drm_crtc_helper_set_config()
helper function to drive the mode setting
sequence.
Return
True if the mode was set successfully, false otherwise.
-
int
drm_crtc_helper_set_config
(struct drm_mode_set * set, struct drm_modeset_acquire_ctx * ctx)¶ set a new config from userspace
Parameters
struct drm_mode_set * set
- mode set configuration
struct drm_modeset_acquire_ctx * ctx
- lock acquire context, not used here
Description
The drm_crtc_helper_set_config()
helper function implements the of
drm_crtc_funcs.set_config
callback for drivers using the legacy CRTC
helpers.
It first tries to locate the best encoder for each connector by calling the connector drm_connector_helper_funcs.best_encoder helper operation.
After locating the appropriate encoders, the helper function will call the mode_fixup encoder and CRTC helper operations to adjust the requested mode, or reject it completely in which case an error will be returned to the application. If the new configuration after mode adjustment is identical to the current configuration the helper function will return without performing any other operation.
If the adjusted mode is identical to the current mode but changes to the
frame buffer need to be applied, the drm_crtc_helper_set_config()
function
will call the CRTC drm_crtc_helper_funcs.mode_set_base
helper operation.
If the adjusted mode differs from the current mode, or if the
->:c:func:mode_set_base() helper operation is not provided, the helper function
performs a full mode set sequence by calling the ->:c:func:prepare(), ->:c:func:mode_set()
and ->:c:func:commit() CRTC and encoder helper operations, in that order.
Alternatively it can also use the dpms and disable helper operations. For
details see struct drm_crtc_helper_funcs
and struct
drm_encoder_helper_funcs
.
This function is deprecated. New drivers must implement atomic modeset
support, for which this function is unsuitable. Instead drivers should use
drm_atomic_helper_set_config()
.
Return
Returns 0 on success, negative errno numbers on failure.
-
int
drm_helper_connector_dpms
(struct drm_connector * connector, int mode)¶ connector dpms helper implementation
Parameters
struct drm_connector * connector
- affected connector
int mode
- DPMS mode
Description
The drm_helper_connector_dpms()
helper function implements the
drm_connector_funcs.dpms
callback for drivers using the legacy CRTC
helpers.
This is the main helper function provided by the CRTC helper framework for
implementing the DPMS connector attribute. It computes the new desired DPMS
state for all encoders and CRTCs in the output mesh and calls the
drm_crtc_helper_funcs.dpms
and drm_encoder_helper_funcs.dpms
callbacks
provided by the driver.
This function is deprecated. New drivers must implement atomic modeset support, where DPMS is handled in the DRM core.
Return
Always returns 0.
-
void
drm_helper_resume_force_mode
(struct drm_device * dev)¶ force-restore mode setting configuration
Parameters
struct drm_device * dev
- drm_device which should be restored
Description
Drivers which use the mode setting helpers can use this function to force-restore the mode setting configuration e.g. on resume or when something else might have trampled over the hw state (like some overzealous old BIOSen tended to do).
This helper doesn’t provide a error return value since restoring the old config should never fail due to resource allocation issues since the driver has successfully set the restored configuration already. Hence this should boil down to the equivalent of a few dpms on calls, which also don’t provide an error code.
Drivers where simply restoring an old configuration again might fail (e.g. due to slight differences in allocating shared resources when the configuration is restored in a different order than when userspace set it up) need to use their own restore logic.
This function is deprecated. New drivers should implement atomic mode- setting and use the atomic suspend/resume helpers.
See also:
drm_atomic_helper_suspend()
, drm_atomic_helper_resume()
-
int
drm_helper_force_disable_all
(struct drm_device * dev)¶ Forcibly turn off all enabled CRTCs
Parameters
struct drm_device * dev
- DRM device whose CRTCs to turn off
Description
Drivers may want to call this on unload to ensure that all displays are unlit and the GPU is in a consistent, low power state. Takes modeset locks.
Note
This should only be used by non-atomic legacy drivers. For an atomic
version look at drm_atomic_helper_shutdown()
.
Return
Zero on success, error code on failure.