drm/kms-helpers: Use recommened kerneldoc for struct member refs

 * 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 and calls

 * down into ->mode_fixup functions of the driver backend.

 *

 * crtc_state->mode_changed is set when the input mode is changed.

 * crtc_state->connectors_changed is set when a connector is added or

 * removed from the crtc.

 * crtc_state->active_changed is set when crtc_state->active changes,

 * which is used for dpms.

 * down into &drm_crtc_helper_funcs.mode_fixup and

 * &drm_encoder_helper_funcs.mode_fixup or

 * &drm_encoder_helper_funcs.atomic_check functions of the driver backend.

 *

 * &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 ->mode_changed (e.g. in their ->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 ->atomic_check functions depend upon

 * the adjusted dotclock for fifo space allocation and watermark computation.

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

 *

 * RETURNS:

 * Zero for success or -errno

 *

 * 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

 * ->atomic_check hooks provided by the driver.

 * &drm_crtc_helper_funcs.atomic_check and &drm_plane_helper_funcs.atomic_check

 * hooks provided by the driver.

 *

 * It also sets crtc_state->planes_changed to indicate that a crtc has

 * It also sets &drm_crtc_state.planes_changed to indicate that a crtc has

 * updated planes.

 *

 * RETURNS:

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

 * callback.

 * 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

 * ->atomic_check functions depend upon an updated adjusted_mode.clock to

 * e.g. properly compute watermarks.

 * @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.

 *

 * RETURNS:

 * Zero for success or -errno

 * drm_atomic_helper_commit_tail - commit atomic update to hardware

 * @old_state: atomic state object with old state structures

 *

 * This is the default implemenation for the ->atomic_commit_tail() hook of the

 * &drm_mode_config_helper_funcs vtable.

 * This is the default implementation for the

 * &drm_mode_config_helper_funcs.atomic_commit_tail hook.

 *

 * Note that the default ordering of how the various stages are called is to

 * match the legacy modeset helper library closest. One peculiarity of that is

 * drm_atomic_helper_setup_commit() and related functions.

 *

 * Committing the actual hardware state is done through the

 * ->atomic_commit_tail() callback of the &drm_mode_config_helper_funcs vtable,

 * or it's default implementation drm_atomic_helper_commit_tail().

 * &drm_mode_config_helper_funcs.atomic_commit_tail callback, or it's default

 * implementation drm_atomic_helper_commit_tail().

 *

 * RETURNS:

 * Zero for success or -errno.

 *

 * 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 ->atomic_commit hook.

 * 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

 * ->state pointers of &struct drm_crtc, &drm_plane or &drm_connector directly.

 * &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

 * 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_vblank_send_event on the event member of

 * &drm_crtc_state).

 * by calling drm_crtc_vblank_send_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.

 * @state: atomic state object with new state structures

 *

 * This function prepares plane state, specifically framebuffers, for the new

 * configuration. If any failure is encountered this function will call

 * ->cleanup_fb on any already successfully prepared framebuffer.

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

 *

 * Returns:

 * 0 on success, negative error code on failure.

 *

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

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

 * planes.

 *

 * It is a bug to call this function without having implemented the

 * ->atomic_disable() plane hook.

 * &drm_plane_helper_funcs.atomic_disable plane hook.

 */

void

drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,

 * 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 ->state pointer of &drm_plane, &drm_crtc or &drm_connector. With the

 * current atomic helpers this is almost always the case, since the helpers

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

 */

void drm_atomic_helper_swap_state(struct drm_atomic_state *state,

 *

 * This is the main helper function provided by the atomic helper framework for

 * implementing the legacy DPMS connector interface. It computes the new desired

 * ->active state for the corresponding CRTC (if the connector is enabled) and

 * updates it.

 * &drm_crtc_state.active state for the corresponding CRTC (if the connector is

 * enabled) and updates it.

 *

 * Returns:

 * Returns 0 on success, negative errno numbers on failure.

EXPORT_SYMBOL(drm_atomic_helper_connector_dpms);

/**

 * drm_atomic_helper_best_encoder - Helper for &drm_connector_helper_funcs

 *                                  ->best_encoder callback

 * drm_atomic_helper_best_encoder - Helper for

 * 	&drm_connector_helper_funcs.best_encoder callback

 * @connector: Connector control structure

 *

 * This is a &drm_connector_helper_funcs ->best_encoder callback helper for

 * This is a &drm_connector_helper_funcs.best_encoder callback helper for

 * connectors that support exactly 1 encoder, statically determined at driver

 * init time.

 */

 */

/**

 * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs

 * drm_atomic_helper_crtc_reset - default &drm_crtc_funcs.reset hook for CRTCs

 * @crtc: drm CRTC

 *

 * Resets the atomic state for @crtc by freeing the state pointer (which might

EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);

/**

 * drm_atomic_helper_plane_reset - default ->reset hook for planes

 * drm_atomic_helper_plane_reset - default &drm_plane_funcs.reset hook for planes

 * @plane: drm plane

 *

 * Resets the atomic state for @plane by freeing the state pointer (which might

 * @conn_state: connector state to assign

 *

 * Initializes the newly allocated @conn_state and assigns it to

 * #connector ->state, usually required when initializing the drivers

 * or when called from the ->reset hook.

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

 */

EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);

/**

 * drm_atomic_helper_connector_reset - default ->reset hook for connectors

 * drm_atomic_helper_connector_reset - default &drm_connector_funcs.reset hook for connectors

 * @connector: drm connector

 *

 * Resets the atomic state for @connector by freeing the state pointer (which

 * 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 ->dpms() even though the hardware is

 * already in the desired state. This deficiency has been fixed in the atomic

 * helpers.

 * 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

 * drm_crtc_helper_set_config - set a new config from userspace

 * @set: mode set configuration

 *

 * The drm_crtc_helper_set_config() helper function implements the set_config

 * callback of &struct drm_crtc_funcs for drivers using the legacy CRTC helpers.

 * 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 ->best_encoder() (&struct drm_connector_helper_funcs) helper

 * operation.

 * 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,

 *

 * 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 ->mode_set_base() (&struct drm_crtc_helper_funcs) helper

 * operation.

 * 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

 * ->mode_set_base() helper operation is not provided, the helper function

 * @connector: affected connector

 * @mode: DPMS mode

 *

 * The drm_helper_connector_dpms() helper function implements the ->dpms()

 * callback of &struct drm_connector_funcs for drivers using the legacy CRTC helpers.

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

 * callbacks provided by the driver in &struct drm_crtc_helper_funcs and struct

 * &drm_encoder_helper_funcs appropriately.

 * 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, for which this function is unsuitable. Instead drivers should use

/*

 * Transfer a single I2C-over-AUX message and handle various error conditions,

 * retrying the transaction as appropriate.  It is assumed that the

 * aux->transfer function does not modify anything in the msg other than the

 * &drm_dp_aux.transfer function does not modify anything in the msg other than the

 * reply field.

 *

 * Returns bytes transferred on success, or a negative error code on failure.

 * Teardown is done with drm_fb_helper_fini().

 *

 * At runtime drivers should restore the fbdev console by calling

 * drm_fb_helper_restore_fbdev_mode_unlocked() from their ->lastclose callback.

 * They should also notify the fb helper code from updates to the output

 * configuration by calling drm_fb_helper_hotplug_event(). For easier

 * drm_fb_helper_restore_fbdev_mode_unlocked() from their &drm_driver.lastclose

 * callback.  They should also notify the fb helper code from updates to the

 * output configuration by calling drm_fb_helper_hotplug_event(). For easier

 * integration with the output polling code in drm_crtc_helper.c the modeset

 * code provides a ->output_poll_changed callback.

 * code provides a &drm_mode_config_funcs.output_poll_changed callback.

 *

 * All other functions exported by the fb helper library can be used to

 * implement the fbdev driver interface by the driver.

 * 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 dev->mode_config.funcs member. After calling drm_kms_helper_poll_init()

 * 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

 * should call drm_fb_helper_single_add_all_connectors() followed by

 * drm_fb_helper_initial_config().

 *

 * If &drm_framebuffer_funcs ->dirty is set, the

 * 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

 * 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

}

/**

 * drm_fb_helper_debug_enter - implementation for ->fb_debug_enter

 * drm_fb_helper_debug_enter - implementation for &fb_ops.fb_debug_enter

 * @info: fbdev registered by the helper

 */

int drm_fb_helper_debug_enter(struct fb_info *info)

}

/**

 * drm_fb_helper_debug_leave - implementation for ->fb_debug_leave

 * drm_fb_helper_debug_leave - implementation for &fb_ops.fb_debug_leave

 * @info: fbdev registered by the helper

 */

int drm_fb_helper_debug_leave(struct fb_info *info)

 * drm_fb_helper_restore_fbdev_mode_unlocked - restore fbdev configuration

 * @fb_helper: fbcon to restore

 *

 * This should be called from driver's drm ->lastclose callback

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

 *

}

/**

 * drm_fb_helper_blank - implementation for ->fb_blank

 * drm_fb_helper_blank - implementation for &fb_ops.fb_blank

 * @blank: desired blanking state

 * @info: fbdev registered by the helper

 */

 * @info: fb_info struct pointer

 * @pagelist: list of dirty mmap framebuffer pages

 *

 * This function is used as the &fb_deferred_io ->deferred_io

 * This function is used as the &fb_deferred_io.deferred_io

 * callback function for flushing the fbdev mmap writes.

 */

void drm_fb_helper_deferred_io(struct fb_info *info,

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

 * &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.

 */

}

/**

 * drm_fb_helper_setcmap - implementation for ->fb_setcmap

 * drm_fb_helper_setcmap - implementation for &fb_ops.fb_setcmap

 * @cmap: cmap to set

 * @info: fbdev registered by the helper

 */

EXPORT_SYMBOL(drm_fb_helper_setcmap);

/**

 * drm_fb_helper_check_var - implementation for ->fb_check_var

 * drm_fb_helper_check_var - implementation for &fb_ops.fb_check_var

 * @var: screeninfo to check

 * @info: fbdev registered by the helper

 */

EXPORT_SYMBOL(drm_fb_helper_check_var);

/**

 * drm_fb_helper_set_par - implementation for ->fb_set_par

 * drm_fb_helper_set_par - implementation for &fb_ops.fb_set_par

 * @info: fbdev registered by the helper

 *

 * This will let fbcon do the mode init and is called at initialization time by

}

/**

 * drm_fb_helper_pan_display - implementation for ->fb_pan_display

 * drm_fb_helper_pan_display - implementation for &fb_ops.fb_pan_display

 * @var: updated screen information

 * @info: fbdev registered by the helper

 */

 * additional constraints need to set up their own limits.

 *

 * Drivers should call this (or their equivalent setup code) from their

 * ->fb_probe callback.

 * &drm_fb_helper_funcs.fb_probe callback.

 */

void drm_fb_helper_fill_fix(struct fb_info *info, uint32_t pitch,

			    uint32_t depth)

 * @fb_height: desired fb height

 *

 * Sets up the variable fbdev metainformation from the given fb helper instance

 * and the drm framebuffer allocated in fb_helper->fb.

 * and the drm framebuffer allocated in &drm_fb_helper.fb.

 *

 * Drivers should call this (or their equivalent setup code) from their

 * ->fb_probe callback after having allocated the fbdev backing

 * storage framebuffer.

 * &drm_fb_helper_funcs.fb_probe callback after having allocated the fbdev

 * backing storage framebuffer.

 */

void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helper,

			    uint32_t fb_width, uint32_t fb_height)

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

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

 *

 *

 * 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 ->set_config interface ties the primary plane together with

 * the CRTC state this does not allow userspace to disable the primary plane

 * itself.  To avoid too much duplicated code use

 * 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.  To avoid too much duplicated code use

 * drm_plane_helper_check_update() which can be used to enforce the same

 * restrictions as primary planes had thus. The default primary plane only

 * expose XRBG8888 and ARGB8888 as valid pixel formats for the attached

 * is called in response to a userspace SetPlane operation on the plane with a

 * NULL framebuffer parameter.  It unconditionally fails the disable call with

 * -EINVAL the only way to disable the primary plane without driver support is

 * to disable the entier CRTC. Which does not match the plane ->disable hook.

 * to disable the entire CRTC. Which does not match the plane

 * &drm_plane_funcs.disable_plane hook.

 *

 * Note that some hardware may be able to disable the primary plane without

 * disabling the whole CRTC.  Drivers for such hardware should provide their