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_crtc_state *state);
  void (*atomic_begin)(struct drm_crtc *crtc, struct drm_crtc_state *old_crtc_state);
  void (*atomic_flush)(struct drm_crtc *crtc, struct drm_crtc_state *old_crtc_state);
  void (*atomic_enable)(struct drm_crtc *crtc, struct drm_crtc_state *old_crtc_state);
  void (*atomic_disable)(struct drm_crtc *crtc, struct drm_crtc_state *old_crtc_state);
};

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 in drm_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 and drm_bridge_funcs.mode_fixup vfunc. If the CRTC cannot support the requested conversion from mode to adjusted_mode it should reject the modeset. See also drm_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 from drm_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 using for_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 in drm_atomic_helper_check_modeset(). Therefore drivers that want to check output routing and display mode constraints in this callback must ensure that drm_atomic_helper_check_modeset() has been called beforehand. This is calling order used by the default helper implementation in drm_atomic_helper_check().

When using drm_atomic_helper_check_planes() this hook is called after the drm_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 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 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 using for_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.

Drivers can use the old_crtc_state input parameter if the operations needed to enable the CRTC don’t depend solely on the new state but also on the transition between the old state and the new state.

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 using for_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.

Comparing to disable, this one provides the additional input parameter old_crtc_state which could be used to access the old state. Atomic drivers should consider to use this one instead of disable.

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);
  struct drm_crtc *(*get_crtc)(struct drm_encoder *encoder);
  enum drm_connector_status (*detect)(struct drm_encoder *encoder, struct drm_connector *connector);
  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 in drm_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 a drm_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 also drm_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.

get_crtc

This callback is used by the legacy CRTC helpers to work around deficiencies in its own book-keeping.

Do not use, use atomic helpers instead, which get the book keeping right.

FIXME:

Currently only nouveau is using this, and as soon as nouveau is atomic we can ditch this hook.

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.

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 using for_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.

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 using for_each_encoder_on_crtc().

This hook is used only by atomic helpers, for symmetry with 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);
  struct drm_encoder *(*best_encoder)(struct drm_connector *connector);
  struct drm_encoder *(*atomic_best_encoder)(struct drm_connector *connector, struct drm_connector_state *connector_state);
  int (*atomic_check)(struct drm_connector *connector, struct drm_connector_state *state);
  void (*atomic_commit)(struct drm_connector *connector, struct drm_connector_state *state);
};

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 calling drm_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 driver a fixed panel can also manually add specific modes using drm_mode_probed_add(). Drivers which manually add modes should also make sure that the drm_connector.display_info, drm_connector.width_mm and drm_connector.height_mm fields are filled in.

Virtual drivers that just want some standard VESA mode with a given resolution can call drm_add_modes_noedid(), and mark the preferred one using drm_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 inspect drm_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 by drm_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 and drm_bridge_funcs.mode_valid, which are also called by the atomic helpers from drm_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 inspect drm_connector->state.

RETURNS:

Either drm_mode_status.MODE_OK or one of the failure reasons in enum drm_mode_status.

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 and you are using the atomic helpers. In this case, the core will call drm_atomic_helper_best_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 (or drm_atomic_helper_best_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 free-standing state objects passed-in or assembled in the overall drm_atomic_state update tracking structure.

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 drm_connector_state.writeback_job.

This hook 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_plane_state *state);
  void (*atomic_update)(struct drm_plane *plane, struct drm_plane_state *old_state);
  void (*atomic_disable)(struct drm_plane *plane, struct drm_plane_state *old_state);
  int (*atomic_async_check)(struct drm_plane *plane, struct drm_plane_state *state);
  void (*atomic_async_update)(struct drm_plane *plane, struct drm_plane_state *new_state);
};

Members

prepare_fb

This hook is to prepare a framebuffer for scanout by e.g. pinning it’s 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-in drm_plane_state. If the driver doesn’t support native fences then equivalent functionality should be implemented through private members in the plane structure.

Drivers which always have their buffers pinned should use drm_gem_fb_prepare_fb() for this 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 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_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 the drm_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 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.

Note that unlike drm_plane_helper_funcs.atomic_update this hook takes the new drm_plane_state as parameter. 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.

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);
};

Members

atomic_commit_tail

This hook is used by the default atomic_commit() hook implemented in drm_atomic_helper_commit() together with the nonblocking commit helpers (see drm_atomic_helper_setup_commit() for a starting point) to implement blocking and nonblocking commits easily. It is not used by the atomic helpers

This 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 upate to be executed by the hardware, for example using drm_atomic_helper_wait_for_vblanks() or drm_atomic_helper_wait_for_flip_done(), and then clean up the old framebuffers using drm_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().

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(), 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 have to be implemented in the following sequence:

1. Run drm_atomic_helper_prepare_planes() first. This is the only function which commit needs to call which can fail, so we want to run it first and synchronously.

2. Synchronize with any outstanding nonblocking commit worker threads which might be affected the new state update. This can be done by either cancelling or flushing the work items, depending upon whether the driver can deal with cancelled updates. Note that it is important to ensure that the framebuffer cleanup is still done when cancelling.

Asynchronous workers need to have sufficient parallelism to be able to run different atomic commits on different CRTCs in parallel. The simplest way to achive 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.

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. And doing this while it’s guaranteed that no relevant nonblocking worker runs means that nonblocking workers do not need grab any locks. Actually they must not grab locks, for otherwise the work flushing will deadlock.

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 above scheme is implemented in the atomic helper libraries in drm_atomic_helper_commit() using a bunch of helper functions. See drm_atomic_helper_setup_commit() for a starting point.

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:

  1. drm_connector_helper_funcs.atomic_best_encoder for determining the new encoder.
  2. drm_connector_helper_funcs.atomic_check to validate the connector state.
  3. If it’s determined a modeset is needed then all connectors on the affected crtc crtc are added and drm_connector_helper_funcs.atomic_check is run on them.
  4. drm_encoder_helper_funcs.mode_valid, drm_bridge_funcs.mode_valid and drm_crtc_helper_funcs.mode_valid are called on the affected components.
  5. drm_bridge_funcs.mode_fixup is called on all encoder bridges.
  6. 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.
  7. 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. 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 afterwards 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_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. It also updates the timestamping constants used for precise vblank timestamps by calling drm_calc_timestamping_constants().

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_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 effected 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 effected 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 of 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 commited 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 commited 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.

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 it’s 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.

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 it’s 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 fake 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().

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 depencies. Callers need to ensure that either no such depencies 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 preceeding 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:

  1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
  2. Do any other steps that might fail.
  3. Put the staged state into the current state pointers with this function.
  4. 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_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.

Atomic State Reset and Initialization

Both the drm core and the atomic helpers assume that there is always the full and correct atomic software state for all connectors, CRTCs and planes available. Which is a bit a problem on driver load and also after system suspend. One way to solve this is to have a hardware state read-out infrastructure which reconstructs the full software state (e.g. the i915 driver).

The simpler solution is to just reset the software state to everything off, which is easiest to do by calling drm_mode_config_reset(). To facilitate this the atomic helpers provide default reset implementations for all hooks.

On the upside the precise state tracking of atomic simplifies system suspend and resume a lot. For drivers using drm_mode_config_reset() a complete recipe is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume(). For other drivers the building blocks are split out, see the documentation for these functions.

Atomic State Helper Reference

void drm_atomic_helper_crtc_reset(struct drm_crtc * crtc)

default drm_crtc_funcs.reset hook for CRTCs

Parameters

struct drm_crtc * crtc
drm CRTC

Description

Resets the atomic state for crtc by freeing the state pointer (which might be NULL, e.g. at driver load time) and allocating a new empty state object.

void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc * crtc, struct drm_crtc_state * state)

copy atomic CRTC state

Parameters

struct drm_crtc * crtc
CRTC object
struct drm_crtc_state * state
atomic CRTC state

Description

Copies atomic state from a CRTC’s current state and resets inferred values. This is useful for drivers that subclass the CRTC state.

struct drm_crtc_state * drm_atomic_helper_crtc_duplicate_state(struct drm_crtc * crtc)

default state duplicate hook

Parameters

struct drm_crtc * crtc
drm CRTC

Description

Default CRTC state duplicate hook for drivers which don’t have their own subclassed CRTC state structure.

void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state * state)

release CRTC state

Parameters

struct drm_crtc_state * state
CRTC state object to release

Description

Releases all resources stored in the CRTC state without actually freeing the memory of the CRTC state. This is useful for drivers that subclass the CRTC state.

void drm_atomic_helper_crtc_destroy_state(struct drm_crtc * crtc, struct drm_crtc_state * state)

default state destroy hook

Parameters

struct drm_crtc * crtc
drm CRTC
struct drm_crtc_state * state
CRTC state object to release

Description

Default CRTC state destroy hook for drivers which don’t have their own subclassed CRTC state structure.

void __drm_atomic_helper_plane_reset(struct drm_plane * plane, struct drm_plane_state * state)

resets planes state to default values

Parameters

struct drm_plane * plane
plane object, must not be NULL
struct drm_plane_state * state
atomic plane state, must not be NULL

Description

Initializes plane state to default. This is useful for drivers that subclass the plane state.

void drm_atomic_helper_plane_reset(struct drm_plane * plane)

default drm_plane_funcs.reset hook for planes

Parameters

struct drm_plane * plane
drm plane

Description

Resets the atomic state for plane by freeing the state pointer (which might be NULL, e.g. at driver load time) and allocating a new empty state object.

void __drm_atomic_helper_plane_duplicate_state(struct drm_plane * plane, struct drm_plane_state * state)

copy atomic plane state

Parameters

struct drm_plane * plane
plane object
struct drm_plane_state * state
atomic plane state

Description

Copies atomic state from a plane’s current state. This is useful for drivers that subclass the plane state.

struct drm_plane_state * drm_atomic_helper_plane_duplicate_state(struct drm_plane * plane)

default state duplicate hook

Parameters

struct drm_plane * plane
drm plane

Description

Default plane state duplicate hook for drivers which don’t have their own subclassed plane state structure.

void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state * state)

release plane state

Parameters

struct drm_plane_state * state
plane state object to release

Description

Releases all resources stored in the plane state without actually freeing the memory of the plane state. This is useful for drivers that subclass the plane state.

void drm_atomic_helper_plane_destroy_state(struct drm_plane * plane, struct drm_plane_state * state)

default state destroy hook

Parameters

struct drm_plane * plane
drm plane
struct drm_plane_state * state
plane state object to release

Description

Default plane state destroy hook for drivers which don’t have their own subclassed plane state structure.

void __drm_atomic_helper_connector_reset(struct drm_connector * connector, struct drm_connector_state * conn_state)

reset state on connector

Parameters

struct drm_connector * connector
drm connector
struct drm_connector_state * conn_state
connector state to assign

Description

Initializes the newly allocated conn_state and assigns it to the drm_conector->state pointer of connector, usually required when initializing the drivers or when called from the drm_connector_funcs.reset hook.

This is useful for drivers that subclass the connector state.

void drm_atomic_helper_connector_reset(struct drm_connector * connector)

default drm_connector_funcs.reset hook for connectors

Parameters

struct drm_connector * connector
drm connector

Description

Resets the atomic state for connector by freeing the state pointer (which might be NULL, e.g. at driver load time) and allocating a new empty state object.

void __drm_atomic_helper_connector_duplicate_state(struct drm_connector * connector, struct drm_connector_state * state)

copy atomic connector state

Parameters

struct drm_connector * connector
connector object
struct drm_connector_state * state
atomic connector state

Description

Copies atomic state from a connector’s current state. This is useful for drivers that subclass the connector state.

struct drm_connector_state * drm_atomic_helper_connector_duplicate_state(struct drm_connector * connector)

default state duplicate hook

Parameters

struct drm_connector * connector
drm connector

Description

Default connector state duplicate hook for drivers which don’t have their own subclassed connector state structure.

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()

void __drm_atomic_helper_connector_destroy_state(struct drm_connector_state * state)

release connector state

Parameters

struct drm_connector_state * state
connector state object to release

Description

Releases all resources stored in the connector state without actually freeing the memory of the connector state. This is useful for drivers that subclass the connector state.

void drm_atomic_helper_connector_destroy_state(struct drm_connector * connector, struct drm_connector_state * state)

default state destroy hook

Parameters

struct drm_connector * connector
drm connector
struct drm_connector_state * state
connector state object to release

Description

Default connector state destroy hook for drivers which don’t have their own subclassed connector state structure.

int drm_atomic_helper_legacy_gamma_set(struct drm_crtc * crtc, u16 * red, u16 * green, u16 * blue, uint32_t size, struct drm_modeset_acquire_ctx * ctx)

set the legacy gamma correction table

Parameters

struct drm_crtc * crtc
CRTC object
u16 * red
red correction table
u16 * green
green correction table
u16 * blue
green correction table
uint32_t size
size of the tables
struct drm_modeset_acquire_ctx * ctx
lock acquire context

Description

Implements support for legacy gamma correction table for drivers that support color management through the DEGAMMA_LUT/GAMMA_LUT properties. See drm_crtc_enable_color_mgmt() and the containing chapter for how the atomic color management and gamma tables work.

void __drm_atomic_helper_private_obj_duplicate_state(struct drm_private_obj * obj, struct drm_private_state * state)

copy atomic private state

Parameters

struct drm_private_obj * obj
CRTC object
struct drm_private_state * state
new private object state

Description

Copies atomic state from a private objects’s current state and resets inferred values. This is useful for drivers that subclass the private state.

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.

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_crtc *crtc, 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);
};

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 in drm_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 either drm_crtc_arm_vblank_event(), when the driver supports vblank interrupt handling, or drm_crtc_send_vblank_event() directly in case the hardware lacks vblank support entirely.

prepare_fb

Optional, called by drm_plane_helper_funcs.prepare_fb. Please read the documentation for the drm_plane_helper_funcs.prepare_fb hook for more details.

Drivers which always have their buffers pinned should use drm_gem_fb_simple_display_pipe_prepare_fb() for this hook.

cleanup_fb
Optional, called by drm_plane_helper_funcs.cleanup_fb. Please read the documentation for the drm_plane_helper_funcs.cleanup_fb hook for more details.
enable_vblank
Optional, called by drm_crtc_funcs.enable_vblank. Please read the documentation for the drm_crtc_funcs.enable_vblank hook for more details.
disable_vblank
Optional, called by drm_crtc_funcs.disable_vblank. Please read the documentation for the drm_crtc_funcs.disable_vblank 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().

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().

Setup fbdev emulation by calling drm_fb_helper_fbdev_setup() and tear it down by calling drm_fb_helper_fbdev_teardown().

Drivers that need to handle connector hotplugging (e.g. dp mst) can’t use the setup helper and will need to do the whole four-step setup process with drm_fb_helper_prepare(), drm_fb_helper_init(), drm_fb_helper_single_add_all_connectors(), enable hotplugging and drm_fb_helper_initial_config() to avoid a possible race window.

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_single_add_all_connectors() followed by 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. Drivers can use drm_fb_helper_defio_init() to setup deferred I/O (coupled with drm_fb_helper_fbdev_teardown()).

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.

So what is passed to drm_fb_helper_fill_var() should be fb_width/fb_height, rather than the surface size.

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);
  bool (*initial_config)(struct drm_fb_helper *fb_helper,struct drm_fb_helper_crtc **crtcs,struct drm_display_mode **modes,struct drm_fb_offset *offsets, bool *enabled, int width, int height);
};

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.

initial_config

Driver callback to setup an initial fbdev display configuration. Drivers can use this callback to tell the fbdev emulation what the preferred initial configuration is. This is useful to implement smooth booting where the fbdev (and subsequently all userspace) never changes the mode, but always inherits the existing configuration.

This callback is optional.

RETURNS:

The driver should return true if a suitable initial configuration has been filled out and false when the fbdev helper should fall back to the default probing logic.

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;
  int crtc_count;
  struct drm_fb_helper_crtc *crtc_info;
  int connector_count;
  int connector_info_alloc_count;
  int sw_rotations;
  struct drm_fb_helper_connector **connector_info;
  const struct drm_fb_helper_funcs *funcs;
  struct fb_info *fbdev;
  u32 pseudo_palette[17];
  struct drm_clip_rect dirty_clip;
  spinlock_t dirty_lock;
  struct work_struct dirty_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
crtc_count
number of possible CRTCs
crtc_info
per-CRTC helper state (mode, x/y offset, etc)
connector_count
number of connected connectors
connector_info_alloc_count
size of connector_info
sw_rotations
Bitmask of all rotations requested for panel-orientation which could not be handled in hardware. If only one bit is set fbdev->fbcon_rotate_hint gets set to the requested rotation.
connector_info
Array of per-connector information. Do not iterate directly, but use drm_fb_helper_for_each_connector.
funcs
driver callbacks for fb helper
fbdev
emulated fbdev device info struct
pseudo_palette
fake palette of 16 colors
dirty_clip
clip rectangle used with deferred_io to accumulate damage to the screen buffer
dirty_lock
spinlock protecting dirty_clip
dirty_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_remove_conflicting_framebuffers(struct apertures_struct * a, const char * name, bool primary)

remove firmware-configured framebuffers

Parameters

struct apertures_struct * a
memory range, users of which are to be removed
const char * name
requesting driver name
bool primary
also kick vga16fb if present

Description

This function removes framebuffer devices (initialized by firmware/bootloader) which use memory range described by a. If a is NULL all such devices are removed.

int drm_fb_helper_remove_conflicting_pci_framebuffers(struct pci_dev * pdev, int resource_id, const char * name)

remove firmware-configured framebuffers for PCI devices

Parameters

struct pci_dev * pdev
PCI device
int resource_id
index of PCI BAR configuring framebuffer memory
const char * name
requesting driver name

Description

This function removes framebuffer devices (eg. initialized by firmware) using memory range configured for pdev’s BAR resource_id.

The function assumes that PCI device with shadowed ROM drives a primary display and so kicks out vga16fb.

int drm_fb_helper_single_add_all_connectors(struct drm_fb_helper * fb_helper)

add all connectors to fbdev emulation helper

Parameters

struct drm_fb_helper * fb_helper
fbdev initialized with drm_fb_helper_init, can be NULL

Description

This functions adds all the available connectors for use with the given fb_helper. This is a separate step to allow drivers to freely assign connectors to the fbdev, e.g. if some are reserved for special purposes or not adequate to be used for the fbcon.

This function is protected against concurrent connector hotadds/removals using drm_fb_helper_add_one_connector() and drm_fb_helper_remove_one_connector().

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, int max_conn_count)

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
int max_conn_count
max connector count

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. Must be called after drm_fb_helper_unlink_fbi() was called.

wrapper around unlink_framebuffer

Parameters

struct drm_fb_helper * fb_helper
driver-allocated fbdev helper, can be NULL

Description

A wrapper around unlink_framebuffer implemented by fbdev core

void drm_fb_helper_deferred_io(struct fb_info * info, struct list_head * pagelist)

fbdev deferred_io callback function

Parameters

struct fb_info * info
fb_info struct pointer
struct list_head * pagelist
list of dirty mmap framebuffer pages

Description

This function is used as the fb_deferred_io.deferred_io callback function for flushing the fbdev mmap writes.

int drm_fb_helper_defio_init(struct drm_fb_helper * fb_helper)

fbdev deferred I/O initialization

Parameters

struct drm_fb_helper * fb_helper
driver-allocated fbdev helper

Description

This function allocates fb_deferred_io, sets callback to drm_fb_helper_deferred_io(), delay to 50ms and calls fb_deferred_io_init(). It should be called from the drm_fb_helper_funcs->fb_probe callback. drm_fb_helper_fbdev_teardown() cleans up deferred I/O.

NOTE

A copy of fb_ops is made and assigned to info->fbops. This is done because fb_deferred_io_cleanup() clears fbops->fb_mmap and would thereby affect other instances of that fb_ops.

Return

0 on success or a negative error code on failure.

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_fix(struct fb_info * info, uint32_t pitch, uint32_t depth)

initializes fixed fbdev information

Parameters

struct fb_info * info
fbdev registered by the helper
uint32_t pitch
desired pitch
uint32_t depth
desired depth

Description

Helper to fill in the fixed fbdev information useful for a non-accelerated fbdev emulations. Drivers which support acceleration methods which impose additional constraints need to set up their own limits.

Drivers should call this (or their equivalent setup code) from their drm_fb_helper_funcs.fb_probe callback.

void drm_fb_helper_fill_var(struct fb_info * info, struct drm_fb_helper * fb_helper, uint32_t fb_width, uint32_t fb_height)

initalizes variable 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
uint32_t fb_width
desired fb width
uint32_t fb_height
desired fb height

Description

Sets up the variable 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_var() and drm_fb_helper_fill_fix() are provided as helpers 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.

int drm_fb_helper_fbdev_setup(struct drm_device * dev, struct drm_fb_helper * fb_helper, const struct drm_fb_helper_funcs * funcs, unsigned int preferred_bpp, unsigned int max_conn_count)

Setup fbdev emulation

Parameters

struct drm_device * dev
DRM device
struct drm_fb_helper * fb_helper
fbdev helper structure to set up
const struct drm_fb_helper_funcs * funcs
fbdev helper functions
unsigned int preferred_bpp
Preferred bits per pixel for the device. dev->mode_config.preferred_depth is used if this is zero.
unsigned int max_conn_count
Maximum number of connectors. dev->mode_config.num_connector is used if this is zero.

Description

This function sets up fbdev emulation and registers fbdev for access by userspace. If all connectors are disconnected, setup is deferred to the next time drm_fb_helper_hotplug_event() is called. The caller must to provide a drm_fb_helper_funcs->fb_probe callback function.

Use drm_fb_helper_fbdev_teardown() to destroy the fbdev.

See also: drm_fb_helper_initial_config(), drm_fbdev_generic_setup().

Return

Zero on success or negative error code on failure.

void drm_fb_helper_fbdev_teardown(struct drm_device * dev)

Tear down fbdev emulation

Parameters

struct drm_device * dev
DRM device

Description

This function unregisters fbdev if not already done and cleans up the associated resources including the drm_framebuffer. The driver is responsible for freeing the drm_fb_helper structure which is stored in drm_device->fb_helper. Do note that this pointer has been cleared when this function returns.

In order to support device removal/unplug while file handles are still open, drm_fb_helper_unregister_fbi() should be called on device removal and drm_fb_helper_fbdev_teardown() in the drm_driver->release callback when file handles are closed.

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().

int drm_fb_helper_generic_probe(struct drm_fb_helper * fb_helper, struct drm_fb_helper_surface_size * sizes)

Generic fbdev emulation probe helper

Parameters

struct drm_fb_helper * fb_helper
fbdev helper structure
struct drm_fb_helper_surface_size * sizes
describes fbdev size and scanout surface size

Description

This function uses the client API to create a framebuffer backed by a dumb buffer.

The _sys_ versions are used for fb_ops.fb_read, fb_write, fb_fillrect, fb_copyarea, fb_imageblit.

Return

Zero on success or negative error code on failure.

int 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. If the driver does not support these functions, it could use drm_fb_helper_fbdev_setup().

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.

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().

Return

Zero on success or negative error code on failure.

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.

An fbdev framebuffer backed by cma is also available by calling drm_fb_cma_fbdev_init(). drm_fb_cma_fbdev_fini() tears it down.

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.

int drm_fb_cma_fbdev_init(struct drm_device * dev, unsigned int preferred_bpp, unsigned int max_conn_count)

Allocate and initialize 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.
unsigned int max_conn_count
Maximum number of connectors. dev->mode_config.num_connector is used if this is zero.

Return

Zero on success or negative error code on failure.

void drm_fb_cma_fbdev_fini(struct drm_device * dev)

Teardown fbdev emulation

Parameters

struct drm_device * dev
DRM device
struct drm_fbdev_cma * drm_fbdev_cma_init(struct drm_device * dev, unsigned int preferred_bpp, unsigned int max_conn_count)

Allocate and initializes a drm_fbdev_cma struct

Parameters

struct drm_device * dev
DRM device
unsigned int preferred_bpp
Preferred bits per pixel for the device
unsigned int max_conn_count
Maximum number of connectors

Description

Returns a newly allocated drm_fbdev_cma struct or a ERR_PTR.

void drm_fbdev_cma_fini(struct drm_fbdev_cma * fbdev_cma)

Free drm_fbdev_cma struct

Parameters

struct drm_fbdev_cma * fbdev_cma
The drm_fbdev_cma struct
void drm_fbdev_cma_restore_mode(struct drm_fbdev_cma * fbdev_cma)

Restores initial framebuffer mode

Parameters

struct drm_fbdev_cma * fbdev_cma
The drm_fbdev_cma struct, may be NULL

Description

This function is usually called from the drm_driver.lastclose callback.

void drm_fbdev_cma_hotplug_event(struct drm_fbdev_cma * fbdev_cma)

Poll for hotpulug events

Parameters

struct drm_fbdev_cma * fbdev_cma
The drm_fbdev_cma struct, may be NULL

Description

This function is usually called from the drm_mode_config.output_poll_changed callback.

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.

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 can be used to set drm_framebuffer_funcs for drivers that need the drm_framebuffer_funcs.dirty callback. 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_funcs() if you need to set drm_framebuffer_funcs.dirty.

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_prepare_fb(struct drm_plane * plane, struct drm_plane_state * state)

Prepare a GEM backed framebuffer

Parameters

struct drm_plane * plane
Plane
struct drm_plane_state * state
Plane state the fence will be attached to

Description

This function prepares a GEM backed framebuffer for scanout by checking if the plane framebuffer has a DMA-BUF attached. If it does, it extracts the exclusive fence and attaches it to the plane state for the atomic helper to wait on. This function can be used as the drm_plane_helper_funcs.prepare_fb callback.

There is no need for drm_plane_helper_funcs.cleanup_fb hook for simple gem based framebuffer drivers which have their buffers always pinned in memory.

int drm_gem_fb_simple_display_pipe_prepare_fb(struct drm_simple_display_pipe * pipe, struct drm_plane_state * plane_state)

prepare_fb helper for drm_simple_display_pipe

Parameters

struct drm_simple_display_pipe * pipe
Simple display pipe
struct drm_plane_state * plane_state
Plane state

Description

This function uses drm_gem_fb_prepare_fb() to check if the plane FB has a dma_buf attached, extracts the exclusive fence and attaches it to plane state for the atomic helper to wait on. Drivers can use this as their drm_simple_display_pipe_funcs.prepare_fb callback.

struct drm_framebuffer * drm_gem_fbdev_fb_create(struct drm_device * dev, struct drm_fb_helper_surface_size * sizes, unsigned int pitch_align, struct drm_gem_object * obj, const struct drm_framebuffer_funcs * funcs)

Create a GEM backed drm_framebuffer for fbdev emulation

Parameters

struct drm_device * dev
DRM device
struct drm_fb_helper_surface_size * sizes
fbdev size description
unsigned int pitch_align
Optional pitch alignment
struct drm_gem_object * obj
GEM object backing the framebuffer
const struct drm_framebuffer_funcs * funcs
Optional vtable to be used for the new framebuffer object when the dirty callback is needed.

Description

This function creates a framebuffer from a drm_fb_helper_surface_size description for use in the drm_fb_helper_funcs.fb_probe callback.

Return

Pointer to a drm_framebuffer on success or an error pointer on failure.

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 an intermediate bridge:

encoder ---> bridge B ---> bridge A

Here, the output of the encoder feeds to bridge B, and that furthers feeds to bridge A.

The driver using the bridge is responsible to make the associations between the encoder and bridges. Once these links are made, the bridges will participate along with encoder functions to perform mode_set/enable/disable through the ops provided in drm_bridge_funcs.

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.

Bridges can also be chained up using the drm_bridge.next pointer.

Both legacy CRTC helpers and the new atomic modeset helpers support bridges.

Default bridge callback sequence

The drm_bridge_funcs ops are populated by the bridge driver. The DRM internals (atomic and CRTC helpers) use the helpers defined in drm_bridge.c These helpers call a specific drm_bridge_funcs op for all the bridges during encoder configuration.

For detailed specification of the bridge callbacks see drm_bridge_funcs.

Bridge Helper Reference

struct drm_bridge_funcs

drm_bridge control functions

Definition

struct drm_bridge_funcs {
  int (*attach)(struct drm_bridge *bridge);
  void (*detach)(struct drm_bridge *bridge);
  enum drm_mode_status (*mode_valid)(struct drm_bridge *bridge, 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,struct drm_display_mode *mode, struct drm_display_mode *adjusted_mode);
  void (*pre_enable)(struct drm_bridge *bridge);
  void (*enable)(struct drm_bridge *bridge);
};

Members

attach

This callback is invoked whenever our bridge is being attached to a drm_encoder.

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 in drm_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.

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 next drm_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 also drm_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.

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 the drm_encoder_helper_funcs.disable, drm_encoder_helper_funcs.prepare or drm_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.

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’s drm_encoder_helper_funcs.disable, drm_encoder_helper_funcs.prepare or drm_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.

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:

If a need arises to store and access modes adjusted for other locations than the connection between the CRTC and the first bridge, the DRM framework will have to be extended with DRM bridge states.

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’s drm_encoder_helper_funcs.enable, drm_encoder_helper_funcs.commit or drm_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.

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’s drm_encoder_helper_funcs.enable, drm_encoder_helper_funcs.commit or drm_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.

struct drm_bridge_timings

timing information for the bridge

Definition

struct drm_bridge_timings {
  u32 sampling_edge;
  u32 setup_time_ps;
  u32 hold_time_ps;
};

Members

sampling_edge
Tells whether the bridge samples the digital input signal from the display engine on the positive or negative edge of the clock, this should reuse the DRM_BUS_FLAG_PIXDATA_[POS|NEG]EDGE bitwise flags from the DRM connector (bit 2 and 3 valid).
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.
struct drm_bridge

central DRM bridge control structure

Definition

struct drm_bridge {
  struct drm_device *dev;
  struct drm_encoder *encoder;
  struct drm_bridge *next;
#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;
};

Members

dev
DRM device this bridge belongs to
encoder
encoder to which this bridge is connected
next
the next bridge in the encoder 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
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
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)

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)

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_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_mode_valid(struct drm_bridge * bridge, 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_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_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_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_mode_set(struct drm_bridge * bridge, struct drm_display_mode * mode, struct drm_display_mode * adjusted_mode)

set proposed mode for all bridges in the encoder chain

Parameters

struct drm_bridge * bridge
bridge control structure
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_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_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_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

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

struct drm_bridge * drm_panel_bridge_add(struct drm_panel * panel, u32 connector_type)

Creates a drm_bridge and drm_connector that just calls the appropriate functions from drm_panel.

Parameters

struct drm_panel * panel
The drm_panel being wrapped. Must be non-NULL.
u32 connector_type
The DRM_MODE_CONNECTOR_* for the connector to be created.

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, drm_bridge_detach() should be called as normal, then drm_panel_bridge_remove() to free it.

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.

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.

struct drm_panel_funcs

perform operations on a given panel

Definition

struct drm_panel_funcs {
  int (*disable)(struct drm_panel *panel);
  int (*unprepare)(struct drm_panel *panel);
  int (*prepare)(struct drm_panel *panel);
  int (*enable)(struct drm_panel *panel);
  int (*get_modes)(struct drm_panel *panel);
  int (*get_timings)(struct drm_panel *panel, unsigned int num_timings, struct display_timing *timings);
};

Members

disable
disable panel (turn off back light, etc.)
unprepare
turn off panel
prepare
turn on panel and perform set up
enable
enable panel (turn on back light, etc.)
get_modes
add modes to the connector that the panel is attached to and return the number of modes added
get_timings
copy display timings into the provided array and return the number of display timings available

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.

struct drm_panel

DRM panel object

Definition

struct drm_panel {
  struct drm_device *drm;
  struct drm_connector *connector;
  struct device *dev;
  const struct drm_panel_funcs *funcs;
  struct list_head list;
};

Members

drm
DRM device owning the panel
connector
DRM connector that the panel is attached to
dev
parent device of the panel
funcs
operations that can be performed on the panel
list
panel entry in registry
int drm_panel_unprepare(struct drm_panel * panel)

power off a panel

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.

int drm_panel_disable(struct drm_panel * panel)

disable a panel

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_prepare(struct drm_panel * panel)

power on a panel

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.

int drm_panel_enable(struct drm_panel * panel)

enable a panel

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.

int drm_panel_get_modes(struct drm_panel * panel)

probe the available display modes of a panel

Parameters

struct drm_panel * panel
DRM panel

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.

void drm_panel_init(struct drm_panel * panel)

initialize a panel

Parameters

struct drm_panel * panel
DRM panel

Description

Sets up internal fields of the panel so that it can subsequently be added to the registry.

int drm_panel_add(struct drm_panel * panel)

add a panel to the global registry

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.

Return

0 on success or a negative error code on failure.

void drm_panel_remove(struct drm_panel * panel)

remove a panel from the global registry

Parameters

struct drm_panel * panel
DRM panel

Description

Removes a panel from the global registry.

int drm_panel_attach(struct drm_panel * panel, struct drm_connector * connector)

attach a panel to a connector

Parameters

struct drm_panel * panel
DRM panel
struct drm_connector * connector
DRM connector

Description

After obtaining a pointer to a DRM panel a display driver calls this function to attach a panel to a connector.

An error is returned if the panel is already attached to another connector.

When unloading, the driver should detach from the panel by calling drm_panel_detach().

Return

0 on success or a negative error code on failure.

int drm_panel_detach(struct drm_panel * panel)

detach a panel from a connector

Parameters

struct drm_panel * panel
DRM panel

Description

Detaches a panel from the connector it is attached to. If a panel is not attached to any connector this is effectively a no-op.

This function should not be called by the panel device itself. It is only for the drm device that called drm_panel_attach().

Return

0 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 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

These functions contain some common logic and helpers at various abstraction levels to deal with Display Port sink devices and related things like DP aux channel transfers, EDID reading over DP aux channels, decoding certain DPCD blocks, …

The DisplayPort AUX channel is an abstraction to allow generic, driver- independent access to AUX functionality. Drivers can take advantage of this by filling in the fields of the drm_dp_aux structure.

Transactions are described using a hardware-independent drm_dp_aux_msg structure, which is passed into a driver’s .:c:func:transfer() implementation. Both native and I2C-over-AUX transactions are supported.

struct drm_dp_aux_msg

DisplayPort AUX channel transaction

Definition

struct drm_dp_aux_msg {
  unsigned int address;
  u8 request;
  u8 reply;
  void *buffer;
  size_t size;
};

Members

address
address of the (first) register to access
request
contains the type of transaction (see DP_AUX_* macros)
reply
upon completion, contains the reply type of the transaction
buffer
pointer to a transmission or reception buffer
size
size of buffer
struct drm_dp_aux_cec

DisplayPort CEC-Tunneling-over-AUX

Definition

struct drm_dp_aux_cec {
  struct mutex lock;
  struct cec_adapter *adap;
  const char *name;
  struct device *parent;
  struct delayed_work unregister_work;
};

Members

lock
mutex protecting this struct
adap
the CEC adapter for CEC-Tunneling-over-AUX support.
name
name of the CEC adapter
parent
parent device of the CEC adapter
unregister_work
unregister the CEC adapter
struct drm_dp_aux

DisplayPort AUX channel

Definition

struct drm_dp_aux {
  const char *name;
  struct i2c_adapter ddc;
  struct device *dev;
  struct drm_crtc *crtc;
  struct mutex hw_mutex;
  struct work_struct crc_work;
  u8 crc_count;
  ssize_t (*transfer)(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg);
  unsigned i2c_nack_count;
  unsigned i2c_defer_count;
  struct drm_dp_aux_cec cec;
};

Members

name
user-visible name of this AUX channel and the I2C-over-AUX adapter
ddc
I2C adapter that can be used for I2C-over-AUX communication
dev
pointer to struct device that is the parent for this AUX channel
crtc
backpointer to the crtc that is currently using this AUX channel
hw_mutex
internal mutex used for locking transfers
crc_work
worker that captures CRCs for each frame
crc_count
counter of captured frame CRCs
transfer
transfers a message representing a single AUX transaction
i2c_nack_count
Counts I2C NACKs, used for DP validation.
i2c_defer_count
Counts I2C DEFERs, used for DP validation.
cec
struct containing fields used for CEC-Tunneling-over-AUX.

Description

The .dev field should be set to a pointer to the device that implements the AUX channel.

The .name field may be used to specify the name of the I2C adapter. If set to NULL, dev_name() of .dev will be used.

Drivers provide a hardware-specific implementation of how transactions are executed via the .:c:func:transfer() function. A pointer to a drm_dp_aux_msg structure describing the transaction is passed into this function. Upon success, the implementation should return the number of payload bytes that were transferred, or a negative error-code on failure. Helpers propagate errors from the .:c:func:transfer() function, with the exception of the -EBUSY error, which causes a transaction to be retried. On a short, helpers will return -EPROTO to make it simpler to check for failure.

An AUX channel can also be used to transport I2C messages to a sink. A typical application of that is to access an EDID that’s present in the sink device. The .:c:func:transfer() function can also be used to execute such transactions. The drm_dp_aux_register() function registers an I2C adapter that can be passed to drm_probe_ddc(). Upon removal, drivers should call drm_dp_aux_unregister() to remove the I2C adapter. The I2C adapter uses long transfers by default; if a partial response is received, the adapter will drop down to the size given by the partial response for this transaction only.

Note that the aux helper code assumes that the .:c:func:transfer() function only modifies the reply field of the drm_dp_aux_msg structure. The retry logic and i2c helpers assume this is the case.

ssize_t drm_dp_dpcd_readb(struct drm_dp_aux * aux, unsigned int offset, u8 * valuep)

read a single byte from the DPCD

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
unsigned int offset
address of the register to read
u8 * valuep
location where the value of the register will be stored

Description

Returns the number of bytes transferred (1) on success, or a negative error code on failure.

ssize_t drm_dp_dpcd_writeb(struct drm_dp_aux * aux, unsigned int offset, u8 value)

write a single byte to the DPCD

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
unsigned int offset
address of the register to write
u8 value
value to write to the register

Description

Returns the number of bytes transferred (1) on success, or a negative error code on failure.

struct drm_dp_desc

DP branch/sink device descriptor

Definition

struct drm_dp_desc {
  struct drm_dp_dpcd_ident ident;
  u32 quirks;
};

Members

ident
DP device identification from DPCD 0x400 (sink) or 0x500 (branch).
quirks
Quirks; use drm_dp_has_quirk() to query for the quirks.
enum drm_dp_quirk

Display Port sink/branch device specific quirks

Constants

DP_DPCD_QUIRK_CONSTANT_N
The device requires main link attributes Mvid and Nvid to be limited to 16 bits. So will give a constant value (0x8000) for compatability.

Description

Display Port sink and branch devices in the wild have a variety of bugs, try to collect them here. The quirks are shared, but it’s up to the drivers to implement workarounds for them.

bool drm_dp_has_quirk(const struct drm_dp_desc * desc, enum drm_dp_quirk quirk)

does the DP device have a specific quirk

Parameters

const struct drm_dp_desc * desc
Device decriptor filled by drm_dp_read_desc()
enum drm_dp_quirk quirk
Quirk to query for

Description

Return true if DP device identified by desc has quirk.

ssize_t drm_dp_dpcd_read(struct drm_dp_aux * aux, unsigned int offset, void * buffer, size_t size)

read a series of bytes from the DPCD

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
unsigned int offset
address of the (first) register to read
void * buffer
buffer to store the register values
size_t size
number of bytes in buffer

Description

Returns the number of bytes transferred on success, or a negative error code on failure. -EIO is returned if the request was NAKed by the sink or if the retry count was exceeded. If not all bytes were transferred, this function returns -EPROTO. Errors from the underlying AUX channel transfer function, with the exception of -EBUSY (which causes the transaction to be retried), are propagated to the caller.

ssize_t drm_dp_dpcd_write(struct drm_dp_aux * aux, unsigned int offset, void * buffer, size_t size)

write a series of bytes to the DPCD

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
unsigned int offset
address of the (first) register to write
void * buffer
buffer containing the values to write
size_t size
number of bytes in buffer

Description

Returns the number of bytes transferred on success, or a negative error code on failure. -EIO is returned if the request was NAKed by the sink or if the retry count was exceeded. If not all bytes were transferred, this function returns -EPROTO. Errors from the underlying AUX channel transfer function, with the exception of -EBUSY (which causes the transaction to be retried), are propagated to the caller.

read DPCD link status (bytes 0x202-0x207)

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
u8 status
buffer to store the link status in (must be at least 6 bytes)

Description

Returns the number of bytes transferred on success or a negative error code on failure.

probe a DisplayPort link for capabilities

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
struct drm_dp_link * link
pointer to structure in which to return link capabilities

Description

The structure filled in by this function can usually be passed directly into drm_dp_link_power_up() and drm_dp_link_configure() to power up and configure the link based on the link’s capabilities.

Returns 0 on success or a negative error code on failure.

power up a DisplayPort link

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
struct drm_dp_link * link
pointer to a structure containing the link configuration

Description

Returns 0 on success or a negative error code on failure.

power down a DisplayPort link

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
struct drm_dp_link * link
pointer to a structure containing the link configuration

Description

Returns 0 on success or a negative error code on failure.

configure a DisplayPort link

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
struct drm_dp_link * link
pointer to a structure containing the link configuration

Description

Returns 0 on success or a negative error code on failure.

int drm_dp_downstream_max_clock(const u8 dpcd, const u8 port_cap)

extract branch device max pixel rate for legacy VGA converter or max TMDS clock rate for others

Parameters

const u8 dpcd
DisplayPort configuration data
const u8 port_cap
port capabilities

Description

Returns max clock in kHz on success or 0 if max clock not defined

int drm_dp_downstream_max_bpc(const u8 dpcd, const u8 port_cap)

extract branch device max bits per component

Parameters

const u8 dpcd
DisplayPort configuration data
const u8 port_cap
port capabilities

Description

Returns max bpc on success or 0 if max bpc not defined

int drm_dp_downstream_id(struct drm_dp_aux * aux, char id)

identify branch device

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
char id
DisplayPort branch device id

Description

Returns branch device id on success or NULL on failure

void drm_dp_downstream_debug(struct seq_file * m, const u8 dpcd, const u8 port_cap, struct drm_dp_aux * aux)

debug DP branch devices

Parameters

struct seq_file * m
pointer for debugfs file
const u8 dpcd
DisplayPort configuration data
const u8 port_cap
port capabilities
struct drm_dp_aux * aux
DisplayPort AUX channel
void drm_dp_aux_init(struct drm_dp_aux * aux)

minimally initialise an aux channel

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel

Description

If you need to use the drm_dp_aux’s i2c adapter prior to registering it with the outside world, call drm_dp_aux_init() first. You must still call drm_dp_aux_register() once the connector has been registered to allow userspace access to the auxiliary DP channel.

int drm_dp_aux_register(struct drm_dp_aux * aux)

initialise and register aux channel

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel

Description

Automatically calls drm_dp_aux_init() if this hasn’t been done yet.

Returns 0 on success or a negative error code on failure.

void drm_dp_aux_unregister(struct drm_dp_aux * aux)

unregister an AUX adapter

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
int drm_dp_psr_setup_time(const u8 psr_cap)

PSR setup in time usec

Parameters

const u8 psr_cap
PSR capabilities from DPCD

Return

PSR setup time for the panel in microseconds, negative error code on failure.

int drm_dp_start_crc(struct drm_dp_aux * aux, struct drm_crtc * crtc)

start capture of frame CRCs

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
struct drm_crtc * crtc
CRTC displaying the frames whose CRCs are to be captured

Description

Returns 0 on success or a negative error code on failure.

int drm_dp_stop_crc(struct drm_dp_aux * aux)

stop capture of frame CRCs

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel

Description

Returns 0 on success or a negative error code on failure.

int drm_dp_read_desc(struct drm_dp_aux * aux, struct drm_dp_desc * desc, bool is_branch)

read sink/branch descriptor from DPCD

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
struct drm_dp_desc * desc
Device decriptor to fill from DPCD
bool is_branch
true for branch devices, false for sink devices

Description

Read DPCD 0x400 (sink) or 0x500 (branch) into desc. Also debug log the identification.

Returns 0 on success or a negative error code on failure.

u8 drm_dp_dsc_sink_max_slice_count(const u8 dsc_dpcd, bool is_edp)

Parameters

const u8 dsc_dpcd
undescribed
bool is_edp
undescribed

Display Port CEC Helper Functions Reference

These functions take care of supporting the CEC-Tunneling-over-AUX feature of DisplayPort-to-HDMI adapters.

void drm_dp_cec_irq(struct drm_dp_aux * aux)

handle CEC interrupt, if any

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel

Description

Should be called when handling an IRQ_HPD request. If CEC-tunneling-over-AUX is present, then it will check for a CEC_IRQ and handle it accordingly.

void drm_dp_cec_register_connector(struct drm_dp_aux * aux, const char * name, struct device * parent)

register a new connector

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel
const char * name
name of the CEC device
struct device * parent
parent device

Description

A new connector was registered with associated CEC adapter name and CEC adapter parent device. After registering the name and parent drm_dp_cec_set_edid() is called to check if the connector supports CEC and to register a CEC adapter if that is the case.

void drm_dp_cec_unregister_connector(struct drm_dp_aux * aux)

unregister the CEC adapter, if any

Parameters

struct drm_dp_aux * aux
DisplayPort AUX channel

Display Port Dual Mode Adaptor Helper Functions Reference

Helper functions to deal with DP dual mode (aka. DP++) adaptors.

Type 1: Adaptor registers (if any) and the sink DDC bus may be accessed via I2C.

Type 2: Adaptor registers and sink DDC bus can be accessed either via I2C or I2C-over-AUX. Source devices may choose to implement either of these access methods.

enum drm_lspcon_mode

Constants

DRM_LSPCON_MODE_INVALID
No LSPCON.
DRM_LSPCON_MODE_LS
Level shifter mode of LSPCON which drives DP++ to HDMI 1.4 conversion.
DRM_LSPCON_MODE_PCON
Protocol converter mode of LSPCON which drives DP++ to HDMI 2.0 active conversion.
enum drm_dp_dual_mode_type

Type of the DP dual mode adaptor

Constants

DRM_DP_DUAL_MODE_NONE
No DP dual mode adaptor
DRM_DP_DUAL_MODE_UNKNOWN
Could be either none or type 1 DVI adaptor
DRM_DP_DUAL_MODE_TYPE1_DVI
Type 1 DVI adaptor
DRM_DP_DUAL_MODE_TYPE1_HDMI
Type 1 HDMI adaptor
DRM_DP_DUAL_MODE_TYPE2_DVI
Type 2 DVI adaptor
DRM_DP_DUAL_MODE_TYPE2_HDMI
Type 2 HDMI adaptor
DRM_DP_DUAL_MODE_LSPCON
Level shifter / protocol converter
ssize_t drm_dp_dual_mode_read(struct i2c_adapter * adapter, u8 offset, void * buffer, size_t size)

Read from the DP dual mode adaptor register(s)

Parameters

struct i2c_adapter * adapter
I2C adapter for the DDC bus
u8 offset
register offset
void * buffer
buffer for return data
size_t size
sizo of the buffer

Description

Reads size bytes from the DP dual mode adaptor registers starting at offset.

Return

0 on success, negative error code on failure

ssize_t drm_dp_dual_mode_write(struct i2c_adapter * adapter, u8 offset, const void * buffer, size_t size)

Write to the DP dual mode adaptor register(s)

Parameters

struct i2c_adapter * adapter
I2C adapter for the DDC bus
u8 offset
register offset
const void * buffer
buffer for write data
size_t size
sizo of the buffer

Description

Writes size bytes to the DP dual mode adaptor registers starting at offset.

Return

0 on success, negative error code on failure

enum drm_dp_dual_mode_type drm_dp_dual_mode_detect(struct i2c_adapter * adapter)

Identify the DP dual mode adaptor

Parameters

struct i2c_adapter * adapter
I2C adapter for the DDC bus

Description

Attempt to identify the type of the DP dual mode adaptor used.

Note that when the answer is DRM_DP_DUAL_MODE_UNKNOWN it’s not certain whether we’re dealing with a native HDMI port or a type 1 DVI dual mode adaptor. The driver will have to use some other hardware/driver specific mechanism to make that distinction.

Return

The type of the DP dual mode adaptor used

int drm_dp_dual_mode_max_tmds_clock(enum drm_dp_dual_mode_type type, struct i2c_adapter * adapter)

Max TMDS clock for DP dual mode adaptor

Parameters

enum drm_dp_dual_mode_type type
DP dual mode adaptor type
struct i2c_adapter * adapter
I2C adapter for the DDC bus

Description

Determine the max TMDS clock the adaptor supports based on the type of the dual mode adaptor and the DP_DUAL_MODE_MAX_TMDS_CLOCK register (on type2 adaptors). As some type 1 adaptors have problems with registers (see comments in drm_dp_dual_mode_detect()) we don’t read the register on those, instead we simply assume a 165 MHz limit based on the specification.

Return

Maximum supported TMDS clock rate for the DP dual mode adaptor in kHz.

int drm_dp_dual_mode_get_tmds_output(enum drm_dp_dual_mode_type type, struct i2c_adapter * adapter, bool * enabled)

Get the state of the TMDS output buffers in the DP dual mode adaptor

Parameters

enum drm_dp_dual_mode_type type
DP dual mode adaptor type
struct i2c_adapter * adapter
I2C adapter for the DDC bus
bool * enabled
current state of the TMDS output buffers

Description

Get the state of the TMDS output buffers in the adaptor. For type2 adaptors this is queried from the DP_DUAL_MODE_TMDS_OEN register. As some type 1 adaptors have problems with registers (see comments in drm_dp_dual_mode_detect()) we don’t read the register on those, instead we simply assume that the buffers are always enabled.

Return

0 on success, negative error code on failure

int drm_dp_dual_mode_set_tmds_output(enum drm_dp_dual_mode_type type, struct i2c_adapter * adapter, bool enable)

Enable/disable TMDS output buffers in the DP dual mode adaptor

Parameters

enum drm_dp_dual_mode_type type
DP dual mode adaptor type
struct i2c_adapter * adapter
I2C adapter for the DDC bus
bool enable
enable (as opposed to disable) the TMDS output buffers

Description

Set the state of the TMDS output buffers in the adaptor. For type2 this is set via the DP_DUAL_MODE_TMDS_OEN register. As some type 1 adaptors have problems with registers (see comments in drm_dp_dual_mode_detect()) we avoid touching the register, making this function a no-op on type 1 adaptors.

Return

0 on success, negative error code on failure

const char * drm_dp_get_dual_mode_type_name(enum drm_dp_dual_mode_type type)

Get the name of the DP dual mode adaptor type as a string

Parameters

enum drm_dp_dual_mode_type type
DP dual mode adaptor type

Return

String representation of the DP dual mode adaptor type

int drm_lspcon_get_mode(struct i2c_adapter * adapter, enum drm_lspcon_mode * mode)

Parameters

struct i2c_adapter * adapter
I2C-over-aux adapter
enum drm_lspcon_mode * mode
current lspcon mode of operation output variable

Description

reading offset (0x80, 0x41)

Return

0 on success, sets the current_mode value to appropriate mode -error on failure

int drm_lspcon_set_mode(struct i2c_adapter * adapter, enum drm_lspcon_mode mode)

Parameters

struct i2c_adapter * adapter
I2C-over-aux adapter
enum drm_lspcon_mode mode
required mode of operation

Description

writing offset (0x80, 0x40)

Return

0 on success, -error on failure/timeout

Display Port MST Helper Functions Reference

These functions contain parts of the DisplayPort 1.2a MultiStream Transport protocol. The helpers contain a topology manager and bandwidth manager. The helpers encapsulate the sending and received of sideband msgs.

struct drm_dp_vcpi

Virtual Channel Payload Identifier

Definition

struct drm_dp_vcpi {
  int vcpi;
  int pbn;
  int aligned_pbn;
  int num_slots;
};

Members

vcpi
Virtual channel ID.
pbn
Payload Bandwidth Number for this channel
aligned_pbn
PBN aligned with slot size
num_slots
number of slots for this PBN
struct drm_dp_mst_port

MST port

Definition

struct drm_dp_mst_port {
  struct kref kref;
  u8 port_num;
  bool input;
  bool mcs;
  bool ddps;
  u8 pdt;
  bool ldps;
  u8 dpcd_rev;
  u8 num_sdp_streams;
  u8 num_sdp_stream_sinks;
  uint16_t available_pbn;
  struct list_head next;
  struct drm_dp_mst_branch *mstb;
  struct drm_dp_aux aux;
  struct drm_dp_mst_branch *parent;
  struct drm_dp_vcpi vcpi;
  struct drm_connector *connector;
  struct drm_dp_mst_topology_mgr *mgr;
  struct edid *cached_edid;
  bool has_audio;
};

Members

kref
reference count for this port.
port_num
port number
input
if this port is an input port.
mcs
message capability status - DP 1.2 spec.
ddps
DisplayPort Device Plug Status - DP 1.2
pdt
Peer Device Type
ldps
Legacy Device Plug Status
dpcd_rev
DPCD revision of device on this port
num_sdp_streams
Number of simultaneous streams
num_sdp_stream_sinks
Number of stream sinks
available_pbn
Available bandwidth for this port.
next
link to next port on this branch device
mstb
branch device attach below this port
aux
i2c aux transport to talk to device connected to this port.
parent
branch device parent of this port
vcpi
Virtual Channel Payload info for this port.
connector
DRM connector this port is connected to.
mgr
topology manager this port lives under.
cached_edid
for DP logical ports - make tiling work by ensuring that the EDID for all connectors is read immediately.
has_audio
Tracks whether the sink connector to this port is audio-capable.

Description

This structure represents an MST port endpoint on a device somewhere in the MST topology.

struct drm_dp_mst_branch

MST branch device.

Definition

struct drm_dp_mst_branch {
  struct kref kref;
  u8 rad[8];
  u8 lct;
  int num_ports;
  int msg_slots;
  struct list_head ports;
  struct drm_dp_mst_port *port_parent;
  struct drm_dp_mst_topology_mgr *mgr;
  struct drm_dp_sideband_msg_tx *tx_slots[2];
  int last_seqno;
  bool link_address_sent;
  u8 guid[16];
};

Members

kref
reference count for this port.
rad
Relative Address to talk to this branch device.
lct
Link count total to talk to this branch device.
num_ports
number of ports on the branch.
msg_slots
one bit per transmitted msg slot.
ports
linked list of ports on this branch.
port_parent
pointer to the port parent, NULL if toplevel.
mgr
topology manager for this branch device.
tx_slots
transmission slots for this device.
last_seqno
last sequence number used to talk to this.
link_address_sent
if a link address message has been sent to this device yet.
guid
guid for DP 1.2 branch device. port under this branch can be identified by port #.

Description

This structure represents an MST branch device, there is one primary branch device at the root, along with any other branches connected to downstream port of parent branches.

struct drm_dp_mst_topology_mgr

DisplayPort MST manager

Definition

struct drm_dp_mst_topology_mgr {
  struct drm_private_obj base;
  struct drm_device *dev;
  const struct drm_dp_mst_topology_cbs *cbs;
  int max_dpcd_transaction_bytes;
  struct drm_dp_aux *aux;
  int max_payloads;
  int conn_base_id;
  struct drm_dp_sideband_msg_rx down_rep_recv;
  struct drm_dp_sideband_msg_rx up_req_recv;
  struct mutex lock;
  bool mst_state;
  struct drm_dp_mst_branch *mst_primary;
  u8 dpcd[DP_RECEIVER_CAP_SIZE];
  u8 sink_count;
  int pbn_div;
  const struct drm_private_state_funcs *funcs;
  struct mutex qlock;
  struct list_head tx_msg_downq;
  struct mutex payload_lock;
  struct drm_dp_vcpi **proposed_vcpis;
  struct drm_dp_payload *payloads;
  unsigned long payload_mask;
  unsigned long vcpi_mask;
  wait_queue_head_t tx_waitq;
  struct work_struct work;
  struct work_struct tx_work;
  struct list_head destroy_connector_list;
  struct mutex destroy_connector_lock;
  struct work_struct destroy_connector_work;
};

Members

base
Base private object for atomic
dev
device pointer for adding i2c devices etc.
cbs
callbacks for connector addition and destruction.
max_dpcd_transaction_bytes
maximum number of bytes to read/write in one go.
aux
AUX channel for the DP MST connector this topolgy mgr is controlling.
max_payloads
maximum number of payloads the GPU can generate.
conn_base_id
DRM connector ID this mgr is connected to. Only used to build the MST connector path value.
down_rep_recv
Message receiver state for down replies. This and up_req_recv are only ever access from the work item, which is serialised.
up_req_recv
Message receiver state for up requests. This and down_rep_recv are only ever access from the work item, which is serialised.
lock
protects mst state, primary, dpcd.
mst_state
If this manager is enabled for an MST capable port. False if no MST sink/branch devices is connected.
mst_primary
Pointer to the primary/first branch device.
dpcd
Cache of DPCD for primary port.
sink_count
Sink count from DEVICE_SERVICE_IRQ_VECTOR_ESI0.
pbn_div
PBN to slots divisor.
funcs
Atomic helper callbacks
qlock
protects tx_msg_downq, the drm_dp_mst_branch.txslost and drm_dp_sideband_msg_tx.state once they are queued
tx_msg_downq
List of pending down replies.
payload_lock
Protect payload information.
proposed_vcpis
Array of pointers for the new VCPI allocation. The VCPI structure itself is drm_dp_mst_port.vcpi.
payloads
Array of payloads.
payload_mask
Elements of payloads actually in use. Since reallocation of active outputs isn’t possible gaps can be created by disabling outputs out of order compared to how they’ve been enabled.
vcpi_mask
Similar to payload_mask, but for proposed_vcpis.
tx_waitq
Wait to queue stall for the tx worker.
work
Probe work.
tx_work
Sideband transmit worker. This can nest within the main work worker for each transaction work launches.
destroy_connector_list
List of to be destroyed connectors.
destroy_connector_lock
Protects connector_list.
destroy_connector_work
Work item to destroy connectors. Needed to avoid locking inversion.

Description

This struct represents the toplevel displayport MST topology manager. There should be one instance of this for every MST capable DP connector on the GPU.

int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr * mgr)

Execute payload update part 1

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to use.

Description

This iterates over all proposed virtual channels, and tries to allocate space in the link for them. For 0->slots transitions, this step just writes the VCPI to the MST device. For slots->0 transitions, this writes the updated VCPIs and removes the remote VC payloads.

after calling this the driver should generate ACT and payload packets.

int drm_dp_update_payload_part2(struct drm_dp_mst_topology_mgr * mgr)

Execute payload update part 2

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to use.

Description

This iterates over all proposed virtual channels, and tries to allocate space in the link for them. For 0->slots transitions, this step writes the remote VC payload commands. For slots->0 this just resets some internal state.

int drm_dp_mst_topology_mgr_set_mst(struct drm_dp_mst_topology_mgr * mgr, bool mst_state)

Set the MST state for a topology manager

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to set state for
bool mst_state
true to enable MST on this connector - false to disable.

Description

This is called by the driver when it detects an MST capable device plugged into a DP MST capable port, or when a DP MST capable device is unplugged.

void drm_dp_mst_topology_mgr_suspend(struct drm_dp_mst_topology_mgr * mgr)

suspend the MST manager

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to suspend

Description

This function tells the MST device that we can’t handle UP messages anymore. This should stop it from sending any since we are suspended.

int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr * mgr)

resume the MST manager

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to resume

Description

This will fetch DPCD and see if the device is still there, if it is, it will rewrite the MSTM control bits, and return.

if the device fails this returns -1, and the driver should do a full MST reprobe, in case we were undocked.

int drm_dp_mst_hpd_irq(struct drm_dp_mst_topology_mgr * mgr, u8 * esi, bool * handled)

MST hotplug IRQ notify

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to notify irq for.
u8 * esi
4 bytes from SINK_COUNT_ESI
bool * handled
whether the hpd interrupt was consumed or not

Description

This should be called from the driver when it detects a short IRQ, along with the value of the DEVICE_SERVICE_IRQ_VECTOR_ESI0. The topology manager will process the sideband messages received as a result of this.

enum drm_connector_status drm_dp_mst_detect_port(struct drm_connector * connector, struct drm_dp_mst_topology_mgr * mgr, struct drm_dp_mst_port * port)

get connection status for an MST port

Parameters

struct drm_connector * connector
DRM connector for this port
struct drm_dp_mst_topology_mgr * mgr
manager for this port
struct drm_dp_mst_port * port
unverified pointer to a port

Description

This returns the current connection state for a port. It validates the port pointer still exists so the caller doesn’t require a reference

bool drm_dp_mst_port_has_audio(struct drm_dp_mst_topology_mgr * mgr, struct drm_dp_mst_port * port)

Check whether port has audio capability or not

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager for this port
struct drm_dp_mst_port * port
unverified pointer to a port.

Description

This returns whether the port supports audio or not.

struct edid * drm_dp_mst_get_edid(struct drm_connector * connector, struct drm_dp_mst_topology_mgr * mgr, struct drm_dp_mst_port * port)

get EDID for an MST port

Parameters

struct drm_connector * connector
toplevel connector to get EDID for
struct drm_dp_mst_topology_mgr * mgr
manager for this port
struct drm_dp_mst_port * port
unverified pointer to a port.

Description

This returns an EDID for the port connected to a connector, It validates the pointer still exists so the caller doesn’t require a reference.

int drm_dp_find_vcpi_slots(struct drm_dp_mst_topology_mgr * mgr, int pbn)

Find VCPI slots for this PBN value

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to use
int pbn
payload bandwidth to convert into slots.

Description

Calculate the number of VCPI slots that will be required for the given PBN value. This function is deprecated, and should not be used in atomic drivers.

Return

The total slots required for this port, or error.

int drm_dp_atomic_find_vcpi_slots(struct drm_atomic_state * state, struct drm_dp_mst_topology_mgr * mgr, struct drm_dp_mst_port * port, int pbn)

Find and add vcpi slots to the state

Parameters

struct drm_atomic_state * state
global atomic state
struct drm_dp_mst_topology_mgr * mgr
MST topology manager for the port
struct drm_dp_mst_port * port
port to find vcpi slots for
int pbn
bandwidth required for the mode in PBN

Return

Total slots in the atomic state assigned for this port or error

int drm_dp_atomic_release_vcpi_slots(struct drm_atomic_state * state, struct drm_dp_mst_topology_mgr * mgr, int slots)

Release allocated vcpi slots

Parameters

struct drm_atomic_state * state
global atomic state
struct drm_dp_mst_topology_mgr * mgr
MST topology manager for the port
int slots
number of vcpi slots to release

Return

0 if slots were added back to drm_dp_mst_topology_state->avail_slots or negative error code

bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr * mgr, struct drm_dp_mst_port * port, int pbn, int slots)

Allocate a virtual channel

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager for this port
struct drm_dp_mst_port * port
port to allocate a virtual channel for.
int pbn
payload bandwidth number to request
int slots
returned number of slots for this PBN.
void drm_dp_mst_reset_vcpi_slots(struct drm_dp_mst_topology_mgr * mgr, struct drm_dp_mst_port * port)

Reset number of slots to 0 for VCPI

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager for this port
struct drm_dp_mst_port * port
unverified pointer to a port.

Description

This just resets the number of slots for the ports VCPI for later programming.

void drm_dp_mst_deallocate_vcpi(struct drm_dp_mst_topology_mgr * mgr, struct drm_dp_mst_port * port)

deallocate a VCPI

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager for this port
struct drm_dp_mst_port * port
unverified port to deallocate vcpi for
int drm_dp_check_act_status(struct drm_dp_mst_topology_mgr * mgr)

Check ACT handled status.

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to use

Description

Check the payload status bits in the DPCD for ACT handled completion.

int drm_dp_calc_pbn_mode(int clock, int bpp)

Calculate the PBN for a mode.

Parameters

int clock
dot clock for the mode
int bpp
bpp for the mode.

Description

This uses the formula in the spec to calculate the PBN value for a mode.

void drm_dp_mst_dump_topology(struct seq_file * m, struct drm_dp_mst_topology_mgr * mgr)

Parameters

struct seq_file * m
seq_file to dump output to
struct drm_dp_mst_topology_mgr * mgr
manager to dump current topology for.

Description

helper to dump MST topology to a seq file for debugfs.

struct drm_dp_mst_topology_state * drm_atomic_get_mst_topology_state(struct drm_atomic_state * state, struct drm_dp_mst_topology_mgr * mgr)

Parameters

struct drm_atomic_state * state
global atomic state
struct drm_dp_mst_topology_mgr * mgr
MST topology manager, also the private object in this case

Description

This function wraps drm_atomic_get_priv_obj_state() passing in the MST atomic state vtable so that the private object state returned is that of a MST topology object. Also, drm_atomic_get_private_obj_state() expects the caller to care of the locking, so warn if don’t hold the connection_mutex.

Return

The MST topology state or error pointer.

int drm_dp_mst_topology_mgr_init(struct drm_dp_mst_topology_mgr * mgr, struct drm_device * dev, struct drm_dp_aux * aux, int max_dpcd_transaction_bytes, int max_payloads, int conn_base_id)

initialise a topology manager

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager struct to initialise
struct drm_device * dev
device providing this structure - for i2c addition.
struct drm_dp_aux * aux
DP helper aux channel to talk to this device
int max_dpcd_transaction_bytes
hw specific DPCD transaction limit
int max_payloads
maximum number of payloads this GPU can source
int conn_base_id
the connector object ID the MST device is connected to.

Description

Return 0 for success, or negative error code on failure

void drm_dp_mst_topology_mgr_destroy(struct drm_dp_mst_topology_mgr * mgr)

destroy topology manager.

Parameters

struct drm_dp_mst_topology_mgr * mgr
manager to destroy

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.

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
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_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
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_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

  1. All modes currently on the connector’s modes list are marked as stale

  2. 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.

    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.

  3. 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.

  4. Any non-stale mode on the modes list then undergoes validation

  5. 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.

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 intializes 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_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 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.

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.

int drm_edid_header_is_valid(const u8 * raw_edid)

sanity check the header of the base EDID block

Parameters

const u8 * raw_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_block_valid(u8 * raw_edid, int block, bool print_bad_edid, bool * edid_corrupt)

Sanity check the EDID block (base or extension)

Parameters

u8 * raw_edid
pointer to raw EDID block
int block
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.

struct edid * drm_do_get_edid(struct drm_connector * connector, int (*get_edid_block) (void *data, u8 *buf, unsigned int block, size_t len, void * data)

get EDID data using a custom EDID block read function

Parameters

struct drm_connector * connector
connector we’re probing
int (*)(void *data, u8 *buf, unsigned int block, size_t len) get_edid_block
EDID block read function
void * data
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 firmare 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.

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.

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.

enum hdmi_picture_aspect drm_get_cea_aspect_ratio(const u8 video_code)

get the picture aspect ratio corresponding to the input VIC from the CEA mode list

Parameters

const u8 video_code
ID given to each of the CEA modes

Description

Returns picture aspect ratio

void drm_edid_get_monitor_name(struct edid * edid, char * name, int bufsize)

fetch the monitor name from the edid

Parameters

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(struct edid * edid, struct cea_sad ** sads)

extracts SADs from EDID

Parameters

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(struct edid * edid, u8 ** sadb)

extracts Speaker Allocation Data Blocks from EDID

Parameters

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(struct edid * edid)

detect whether monitor is HDMI

Parameters

struct edid * edid
monitor EDID information

Description

Parse the CEA extension according to CEA-861-B.

Return

True if the monitor is HDMI, false if not or unknown.

bool drm_detect_monitor_audio(struct edid * edid)

check monitor audio capability

Parameters

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.

bool drm_rgb_quant_range_selectable(struct edid * edid)

is RGB quantization range selectable?

Parameters

struct edid * edid
EDID block to scan

Description

Check whether the monitor reports the RGB quantization range selection as supported. The AVI infoframe can then be used to inform the monitor which quantization range (full or limited) is used.

Return

True if the RGB quantization range is selectable, 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_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.

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_display_mode * mode, bool is_hdmi2_sink)

fill an HDMI AVI infoframe with data from a DRM display mode

Parameters

struct hdmi_avi_infoframe * frame
HDMI AVI infoframe
const struct drm_display_mode * mode
DRM display mode
bool is_hdmi2_sink
Sink is HDMI 2.0 compliant

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_display_mode * mode, enum hdmi_quantization_range rgb_quant_range, bool rgb_quant_range_selectable, bool is_hdmi2_sink)

fill the HDMI AVI infoframe quantization range information

Parameters

struct hdmi_avi_infoframe * frame
HDMI AVI infoframe
const struct drm_display_mode * mode
DRM display mode
enum hdmi_quantization_range rgb_quant_range
RGB quantization range (Q)
bool rgb_quant_range_selectable
Sink support selectable RGB quantization range (QS)
bool is_hdmi2_sink
HDMI 2.0 sink, which has different default recommendations

Description

Note that is_hdmi2_sink can be derived by looking at the drm_scdc.supported flag stored in drm_hdmi_info.scdc, drm_display_info.hdmi, which can be found in drm_connector.display_info.

int drm_hdmi_vendor_infoframe_from_display_mode(struct hdmi_vendor_infoframe * frame, 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
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

Status and Control Data Channel (SCDC) is a mechanism introduced by the HDMI 2.0 specification. It is a point-to-point protocol that allows the HDMI source and HDMI sink to exchange data. The same I2C interface that is used to access EDID serves as the transport mechanism for SCDC.

int drm_scdc_readb(struct i2c_adapter * adapter, u8 offset, u8 * value)

read a single byte from SCDC

Parameters

struct i2c_adapter * adapter
I2C adapter
u8 offset
offset of register to read
u8 * value
return location for the register value

Description

Reads a single byte from SCDC. This is a convenience wrapper around the drm_scdc_read() function.

Return

0 on success or a negative error code on failure.

int drm_scdc_writeb(struct i2c_adapter * adapter, u8 offset, u8 value)

write a single byte to SCDC

Parameters

struct i2c_adapter * adapter
I2C adapter
u8 offset
offset of register to read
u8 value
return location for the register value

Description

Writes a single byte to SCDC. This is a convenience wrapper around the drm_scdc_write() function.

Return

0 on success or a negative error code on failure.

ssize_t drm_scdc_read(struct i2c_adapter * adapter, u8 offset, void * buffer, size_t size)

read a block of data from SCDC

Parameters

struct i2c_adapter * adapter
I2C controller
u8 offset
start offset of block to read
void * buffer
return location for the block to read
size_t size
size of the block to read

Description

Reads a block of data from SCDC, starting at a given offset.

Return

0 on success, negative error code on failure.

ssize_t drm_scdc_write(struct i2c_adapter * adapter, u8 offset, const void * buffer, size_t size)

write a block of data to SCDC

Parameters

struct i2c_adapter * adapter
I2C controller
u8 offset
start offset of block to write
const void * buffer
block of data to write
size_t size
size of the block to write

Description

Writes a block of data to SCDC, starting at a given offset.

Return

0 on success, negative error code on failure.

bool drm_scdc_get_scrambling_status(struct i2c_adapter * adapter)

what is status of scrambling?

Parameters

struct i2c_adapter * adapter
I2C adapter for DDC channel

Description

Reads the scrambler status over SCDC, and checks the scrambling status.

Return

True if the scrambling is enabled, false otherwise.

bool drm_scdc_set_scrambling(struct i2c_adapter * adapter, bool enable)

enable scrambling

Parameters

struct i2c_adapter * adapter
I2C adapter for DDC channel
bool enable
bool to indicate if scrambling is to be enabled/disabled

Description

Writes the TMDS config register over SCDC channel, and: enables scrambling when enable = 1 disables scrambling when enable = 0

Return

True if scrambling is set/reset successfully, false otherwise.

bool drm_scdc_set_high_tmds_clock_ratio(struct i2c_adapter * adapter, bool set)

set TMDS clock ratio

Parameters

struct i2c_adapter * adapter
I2C adapter for DDC channel
bool set
ret or reset the high clock ratio

Description

TMDS clock ratio calculations go like this:

TMDS character = 10 bit TMDS encoded value

TMDS character rate = The rate at which TMDS characters are transmitted (Mcsc)

TMDS bit rate = 10x TMDS character rate

As per the spec:

TMDS clock rate for pixel clock < 340 MHz = 1x the character rate = 1/10 pixel clock rate

TMDS clock rate for pixel clock > 340 MHz = 0.25x the character rate = 1/40 pixel clock rate

Writes to the TMDS config register over SCDC channel, and:

sets TMDS clock ratio to 1/40 when set = 1

sets TMDS clock ratio to 1/10 when set = 0

Return

True if write is successful, false otherwise.

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)
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_adjust_size(struct drm_rect * r, int dw, int dh)

adjust the size of the rectangle

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.

void drm_rect_translate(struct drm_rect * r, int dx, int dy)

translate the rectangle

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_downscale(struct drm_rect * r, int horz, int vert)

downscale a rectangle

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.

int drm_rect_width(const struct drm_rect * r)

determine the rectangle width

Parameters

const struct drm_rect * r
rectangle whose width is returned

Return

The width of the rectangle.

int drm_rect_height(const struct drm_rect * r)

determine the rectangle height

Parameters

const struct drm_rect * r
rectangle whose height is returned

Return

The height of the rectangle.

bool drm_rect_visible(const struct drm_rect * r)

determine if the the rectangle is visible

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.

bool drm_rect_intersect(struct drm_rect * r1, const struct drm_rect * r2)

intersect two rectangles

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 same amounts multiplied by hscale and vscale.

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.

int drm_rect_calc_hscale_relaxed(struct drm_rect * src, struct drm_rect * dst, int min_hscale, int max_hscale)

calculate the horizontal scaling factor

Parameters

struct drm_rect * src
source window rectangle
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 calculated scaling factor is below min_vscale, decrease the height of rectangle dst to compensate.

If the calculated scaling factor is above max_vscale, decrease the height of rectangle src to compensate.

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.

int drm_rect_calc_vscale_relaxed(struct drm_rect * src, struct drm_rect * dst, int min_vscale, int max_vscale)

calculate the vertical scaling factor

Parameters

struct drm_rect * src
source window rectangle
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 calculated scaling factor is below min_vscale, decrease the height of rectangle dst to compensate.

If the calculated scaling factor is above max_vscale, decrease the height of rectangle src to compensate.

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.

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.

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;
};

Members

any
generic infoframe
avi
avi infoframe
spd
spd infoframe
vendor
union of all vendor infoframes
audio
audio 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.

int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe * frame)

initialize an HDMI AVI infoframe

Parameters

struct hdmi_avi_infoframe * frame
HDMI AVI infoframe

Description

Returns 0 on success or a negative error code on failure.

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_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_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:

  1. Primary plane cannot be repositioned.
  2. Primary plane cannot be scaled.
  3. Primary plane must cover the entire CRTC.
  4. Subpixel positioning is not supported.
  5. 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().

OF/DT Helpers

A set of helper functions to aid DRM drivers in parsing standard DT properties.

uint32_t drm_of_crtc_port_mask(struct drm_device * dev, struct device_node * port)

find the mask of a registered CRTC by port OF node

Parameters

struct drm_device * dev
DRM device
struct device_node * port
port OF node

Description

Given a port OF node, return the possible mask of the corresponding CRTC within a device’s list of CRTCs. Returns zero if not found.

uint32_t drm_of_find_possible_crtcs(struct drm_device * dev, struct device_node * port)

find the possible CRTCs for an encoder port

Parameters

struct drm_device * dev
DRM device
struct device_node * port
encoder port to scan for endpoints

Description

Scan all endpoints attached to a port, locate their attached CRTCs, and generate the DRM mask of CRTCs which may be attached to this encoder.

See Documentation/devicetree/bindings/graph.txt for the bindings.

void drm_of_component_match_add(struct device * master, struct component_match ** matchptr, int (*compare) (struct device *, void *, struct device_node * node)

Add a component helper OF node match rule

Parameters

struct device * master
master device
struct component_match ** matchptr
component match pointer
int (*)(struct device *, void *) compare
compare function used for matching component
struct device_node * node
of_node
int drm_of_component_probe(struct device * dev, int (*compare_of) (struct device *, void *, const struct component_master_ops * m_ops)

Generic probe function for a component based master

Parameters

struct device * dev
master device containing the OF node
int (*)(struct device *, void *) compare_of
compare function used for matching components
const struct component_master_ops * m_ops
component master ops to be used

Description

Parse the platform device OF node and bind all the components associated with the master. Interface ports are added before the encoders in order to satisfy their .bind requirements See Documentation/devicetree/bindings/graph.txt for the bindings.

Returns zero if successful, or one of the standard error codes if it fails.

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.

void drm_primary_helper_destroy(struct drm_plane * plane)

Helper for primary plane destruction

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.

bool drm_helper_crtc_in_use(struct drm_crtc * crtc)

check if a given CRTC is in a mode_config

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()