Lines Matching +full:disable +full:- +full:state
3 * Copyright © 2007-2008 Dave Airlie
4 * Copyright © 2007-2008 Intel Corporation
6 * Copyright © 2011-2013 Intel Corporation
61 * struct drm_crtc_helper_funcs - helper operations for CRTCs
75 * This callback is also used to disable a CRTC by calling it with
76 * DRM_MODE_DPMS_OFF if the @disable hook isn't used.
89 * in practice means the driver should disable the CRTC if it is
137 * to look at anything else but the passed-in mode, and validate it
138 * against configuration-invariant hardware constraints. Any further
168 * MUST NOT touch any persistent state (hardware or software) or data
174 * Atomic drivers which need to inspect and adjust more state should
241 * optimized fast-path instead of a full mode set operation with all the
275 * @disable:
277 * This callback should be used to disable the CRTC. With the atomic
280 * &drm_encoder_helper_funcs.disable hook. If that sequence is too
287 * disable anything at the CRTC level. To ensure that runtime PM
289 * @disable must be the inverse of @atomic_enable for atomic drivers.
296 * @disable and other hooks (like @prepare or @dpms) used to shut down a
297 * CRTC: @disable is only called when also logically disabling the
301 * Therefore @disable must be the inverse of @mode_set plus @commit for
305 void (*disable)(struct drm_crtc *crtc); member
310 * Drivers should check plane-update related CRTC constraints in this
325 * the provided check helpers multiple times until the computed state
328 * This function is also allowed to inspect any other object's state and
329 * can add more state objects to the atomic commit if needed. Care must
330 * be taken though to ensure that state check and compute functions for
331 * these added states are all called, and derived state in other objects
341 * driver is not allowed to change anything outside of the free-standing
342 * state object passed-in.
352 * 0 on success, -EINVAL if the state or the transition can't be
353 * supported, -ENOMEM on memory allocation failure and -EDEADLK if an
354 * attempt to obtain another state object ran into a &drm_modeset_lock
358 struct drm_atomic_state *state);
370 * Note that the power state of the display pipe when this function is
379 struct drm_atomic_state *state);
394 * Note that the power state of the display pipe when this function is
403 struct drm_atomic_state *state);
425 struct drm_atomic_state *state);
430 * This callback should be used to disable the CRTC. With the atomic
433 * &drm_encoder_helper_funcs.disable hook. If that sequence is too
439 * need to implement it if there's no need to disable anything at the
445 struct drm_atomic_state *state);
464 * need to apply some workarounds for gpu-specific vblank irq
481 * of scanlines to go until end of vblank, e.g., -1 means "one scanline
496 * drm_crtc_helper_add - sets the helper vtable for a crtc
503 crtc->helper_private = funcs; in drm_crtc_helper_add()
507 * struct drm_encoder_helper_funcs - helper operations for encoders
521 * This callback is also used to disable an encoder by calling it with
522 * DRM_MODE_DPMS_OFF if the @disable hook isn't used.
527 * @enable and @disable should be used.
553 * to look at anything else but the passed-in mode, and validate it
554 * against configuration-invariant hardware constraints. Any further
583 * MUST NOT touch any persistent state (hardware or software) or data
589 * Atomic drivers which need to inspect and adjust more state should
613 * which in practice means the driver should disable the encoder if it
619 * transitions to atomic, but it is deprecated. Instead @disable should
658 * the connector state or connector display info during mode setting,
681 * connector state or display info, since there is no direct way to
694 * It is not used by any helper and therefore has purely driver-specific
709 * This callback should be used to disable the encoder. With the atomic
716 * This callback is a variant of @disable that provides the atomic state
717 * to the driver. If @atomic_disable is implemented, @disable is not
721 * to implement it if there's no need to disable anything at the encoder
727 struct drm_atomic_state *state);
739 * This callback is a variant of @enable that provides the atomic state
750 struct drm_atomic_state *state);
753 * @disable:
755 * This callback should be used to disable the encoder. With the atomic
757 * using their own &drm_crtc_helper_funcs.disable hook. If that
764 * disable anything at the encoder level. To ensure that runtime PM
766 * @disable must be the inverse of @enable for atomic drivers.
774 * @disable and other hooks (like @prepare or @dpms) used to shut down a
775 * encoder: @disable is only called when also logically disabling the
779 * Therefore @disable must be the inverse of @mode_set plus @commit for
783 void (*disable)(struct drm_encoder *encoder); member
796 * @disable. Atomic drivers don't need to implement it if there's no
799 * works @enable must be the inverse of @disable for atomic drivers.
806 * This callback is used to validate encoder state for atomic drivers.
822 * driver is not allowed to change anything outside of the free-standing
823 * state objects passed-in or assembled in the overall &drm_atomic_state
834 * 0 on success, -EINVAL if the state or the transition can't be
835 * supported, -ENOMEM on memory allocation failure and -EDEADLK if an
836 * attempt to obtain another state object ran into a &drm_modeset_lock
845 * drm_encoder_helper_add - sets the helper vtable for an encoder
852 encoder->helper_private = funcs; in drm_encoder_helper_add()
856 * struct drm_connector_helper_funcs - helper operations for connectors
870 * probe callback somewhere in the driver-private connector structure.
896 * To avoid races with concurrent connector state updates, the helper
898 * held. Because of this it's safe to inspect &drm_connector->state.
920 * To avoid races against concurrent connector state updates, the
929 * or the error code returned by drm_modeset_lock(), -EDEADLK.
960 * To avoid races with concurrent connector state updates, the helper
962 * held. Because of this it's safe to inspect &drm_connector->state.
985 * To allow for accessing the atomic state of modesetting objects, the
993 * be influenced by the currently set display state - such constraints
1000 * display state.
1026 * anything outside of arguments passed-in. Atomic drivers which need to
1027 * inspect dynamic configuration state should instead use
1037 * state, or NULL if no suitable encoder exists. Note that the helpers
1063 * state, or NULL if no suitable encoder exists. Note that the helpers
1068 struct drm_atomic_state *state);
1073 * This hook is used to validate connector state. This function is
1080 * This function is also allowed to inspect any other object's state and
1081 * can add more state objects to the atomic commit if needed. Care must
1082 * be taken though to ensure that state check and compute functions for
1083 * these added states are all called, and derived state in other objects
1090 * driver is not allowed to change anything outside of the free-standing
1091 * state objects passed-in or assembled in the overall &drm_atomic_state
1096 * 0 on success, -EINVAL if the state or the transition can't be
1097 * supported, -ENOMEM on memory allocation failure and -EDEADLK if an
1098 * attempt to obtain another state object ran into a &drm_modeset_lock
1102 struct drm_atomic_state *state);
1109 * The writeback_job to commit is available in the new connector state,
1117 struct drm_atomic_state *state);
1154 * Enable hot-plug detection for the connector.
1160 * This operation does not need to perform any hpd state tracking as
1162 * and disable hpd are balanced.
1170 * Disable hot-plug detection for the connector.
1176 * This operation does not need to perform any hpd state tracking as
1178 * and disable hpd are balanced.
1185 * drm_connector_helper_add - sets the helper vtable for a connector
1192 connector->helper_private = funcs; in drm_connector_helper_add()
1196 * struct drm_plane_helper_funcs - helper operations for planes
1211 * way is to fill out the &drm_plane_state.fence of the passed-in
1227 * shadow-plane helpers belongs into @begin_fb_access, so that atomic
1234 * optional. See @begin_fb_access for preparing per-commit resources.
1264 * For example, with shadow-plane helpers, the GEM buffer's vmap
1283 * at the end of a commit for the new plane state.
1296 * multiple times until the computed state has a final configuration and
1299 * This function is also allowed to inspect any other object's state and
1300 * can add more state objects to the atomic commit if needed. Care must
1301 * be taken though to ensure that state check and compute functions for
1302 * these added states are all called, and derived state in other objects
1317 * 0 on success, -EINVAL if the state or the transition can't be
1318 * supported, -ENOMEM on memory allocation failure and -EDEADLK if an
1319 * attempt to obtain another state object ran into a &drm_modeset_lock
1323 struct drm_atomic_state *state);
1328 * Drivers should use this function to update the plane state. This
1329 * hook is called in-between the &drm_crtc_helper_funcs.atomic_begin and
1332 * Note that the power state of the display pipe when this function is
1340 struct drm_atomic_state *state);
1346 * This hook is called in-between the &drm_crtc_helper_funcs.atomic_begin
1354 * Note that the power state of the display pipe when this function is
1365 struct drm_atomic_state *state);
1370 * Drivers should use this function to unconditionally disable a plane.
1371 * This hook is called in-between the
1377 * This hook is also useful to disable planes in preparation of a modeset,
1379 * &drm_crtc_helper_funcs.disable hook.
1381 * Note that the power state of the display pipe when this function is
1390 struct drm_atomic_state *state);
1396 * atomic state can be updated in a async fashion. Here async means
1401 * jump ahead of the state currently queued for update.
1409 struct drm_atomic_state *state);
1416 * state and update the plane. Here async means "not vblank
1430 * state (&drm_plane.state) and new_state.
1432 * the new state, rather than old state like for traditional commits.
1438 * - It only works for single plane updates
1439 * - Async Pageflips are not supported yet
1440 * - Some hw might still scan out the old buffer until the next
1446 struct drm_atomic_state *state);
1454 * buffers are supported. Non-linear buffer support is on the TODO list.
1456 * function, so you can safely access the &plane.state
1458 * Please look the documentation at drm_panic_trylock() for an in-depth
1481 * Please look the documentation at drm_panic_trylock() for an in-depth
1488 * drm_plane_helper_add - sets the helper vtable for a plane
1495 plane->helper_private = funcs; in drm_plane_helper_add()
1499 * struct drm_mode_config_helper_funcs - global modeset helper operations
1513 * This function is called when the new atomic state has already been
1514 * swapped into the various state pointers. The passed in state
1515 * therefore contains copies of the old/previous state. This hook should
1516 * commit the new state into hardware. Note that the helpers have
1519 * to wait for driver-internal request for implicit syncing, before
1539 void (*atomic_commit_tail)(struct drm_atomic_state *state);
1560 int (*atomic_commit_setup)(struct drm_atomic_state *state);