style=dashed
label="Free-standing state"
- "drm_atomic_state" -> "duplicated drm_plane_state A"
- "drm_atomic_state" -> "duplicated drm_plane_state B"
- "drm_atomic_state" -> "duplicated drm_crtc_state"
- "drm_atomic_state" -> "duplicated drm_connector_state"
- "drm_atomic_state" -> "duplicated driver private state"
+ "drm_atomic_commit" -> "duplicated drm_plane_state A"
+ "drm_atomic_commit" -> "duplicated drm_plane_state B"
+ "drm_atomic_commit" -> "duplicated drm_crtc_state"
+ "drm_atomic_commit" -> "duplicated drm_connector_state"
+ "drm_atomic_commit" -> "duplicated driver private state"
}
subgraph cluster_current {
"driver private object" -> "driver private state"
}
- "drm_atomic_state" -> "drm_device" [label="atomic_commit"]
+ "drm_atomic_commit" -> "drm_device" [label="atomic_commit"]
"duplicated drm_plane_state A" -> "drm_device"[style=invis]
}
drm_private_state<drm_private_state>`.
- An atomic update is assembled and validated as an entirely free-standing pile
- of structures within the :c:type:`drm_atomic_state <drm_atomic_state>`
+ of structures within the :c:type:`drm_atomic_commit <drm_atomic_commit>`
container. Driver private state structures are also tracked in the same
structure; see the next chapter. Only when a state is committed is it applied
to the driver and modeset objects. This way rolling back an update boils down
So, for komeda, we treat KMS crtc/plane/connector as users of pipeline and
component, and at any one time a pipeline/component only can be used by one
user. And pipeline/component will be treated as private object of DRM-KMS; the
-state will be managed by drm_atomic_state as well.
+state will be managed by drm_atomic_commit as well.
How to map plane to Layer(input) pipeline
-----------------------------------------
...
}
-Tracking component_state/pipeline_state by drm_atomic_state
------------------------------------------------------------
+Tracking component_state/pipeline_state by drm_atomic_commit
+------------------------------------------------------------
Add :c:type:`drm_private_state` and user to :c:type:`komeda_component_state`,
:c:type:`komeda_pipeline_state`
put the data flow into next stage.
Setup 2: check user_state with component features and capabilities to see
if requirements can be met; if not, return fail.
- Setup 3: get component_state from drm_atomic_state, and try set to set
+ Setup 3: get component_state from drm_atomic_commit, and try set to set
user to component; fail if component has been assigned to another
user already.
Setup 3: configure the component_state, like set its input component,
Level: Advanced
-Rename drm_atomic_state
+Rename drm_atomic_commit
-----------------------
The KMS framework uses two slightly different definitions for the ``state``
concept. For a given object (plane, CRTC, encoder, etc., so
``drm_$OBJECT_state``), the state is the entire state of that object. However,
-at the device level, ``drm_atomic_state`` refers to a state update for a
+at the device level, ``drm_atomic_commit`` refers to a state update for a
limited number of objects.
The state isn't the entire device state, but only the full state of some
objects in that device. This is confusing to newcomers, and
-``drm_atomic_state`` should be renamed to something clearer like
+``drm_atomic_commit`` should be renamed to something clearer like
``drm_atomic_commit``.
In addition to renaming the structure itself, it would also imply renaming some
-related functions (``drm_atomic_state_alloc``, ``drm_atomic_state_get``,
-``drm_atomic_state_put``, ``drm_atomic_state_init``,
-``__drm_atomic_state_free``, etc.).
+related functions (``drm_atomic_commit_alloc``, ``drm_atomic_commit_get``,
+``drm_atomic_commit_put``, ``drm_atomic_commit_init``,
+``__drm_atomic_commit_free``, etc.).
Contact: Maxime Ripard <mripard@kernel.org>
#define crtc_to_adp(x) container_of(x, struct adp_drv_private, crtc)
static int adp_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state;
struct drm_crtc_state *crtc_state;
}
static void adp_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct adp_drv_private *adp;
struct drm_rect src_rect;
}
static void adp_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct adp_drv_private *adp = to_adp(plane->dev);
}
static void adp_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct adp_drv_private *adp = crtc_to_adp(crtc);
}
static void adp_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct adp_drv_private *adp = crtc_to_adp(crtc);
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state, crtc);
}
static void adp_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
u32 frame_num = 1;
unsigned long flags;
};
static void amdgpu_vkms_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(crtc);
}
static void amdgpu_vkms_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_off(crtc);
}
static void amdgpu_vkms_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
unsigned long flags;
if (crtc->state->event) {
};
static void amdgpu_vkms_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
return;
}
static int amdgpu_vkms_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
static int amdgpu_dm_connector_get_modes(struct drm_connector *connector);
-static int amdgpu_dm_atomic_setup_commit(struct drm_atomic_state *state);
-static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_state *state);
+static int amdgpu_dm_atomic_setup_commit(struct drm_atomic_commit *state);
+static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_commit *state);
static int amdgpu_dm_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
static void handle_hpd_irq_helper(struct amdgpu_dm_connector *aconnector);
static void handle_hpd_rx_irq(void *param);
}
struct drm_connector *
-amdgpu_dm_find_first_crtc_matching_connector(struct drm_atomic_state *state,
+amdgpu_dm_find_first_crtc_matching_connector(struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
u32 i;
*
* This should only be called during atomic check.
*/
-int dm_atomic_get_state(struct drm_atomic_state *state,
+int dm_atomic_get_state(struct drm_atomic_commit *state,
struct dm_atomic_state **dm_state)
{
struct drm_device *dev = state->dev;
}
static struct dm_atomic_state *
-dm_atomic_get_new_state(struct drm_atomic_state *state)
+dm_atomic_get_new_state(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct amdgpu_device *adev = drm_to_adev(dev);
static int
amdgpu_dm_connector_atomic_check(struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *new_con_state =
drm_atomic_get_new_connector_state(state, conn);
struct drm_crtc_state *crtc_state,
struct drm_connector_state *conn_state)
{
- struct drm_atomic_state *state = crtc_state->state;
+ struct drm_atomic_commit *state = crtc_state->state;
struct drm_connector *connector = conn_state->connector;
struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
struct dm_connector_state *dm_new_connector_state = to_dm_connector_state(conn_state);
.atomic_check = dm_encoder_helper_atomic_check
};
-static int dm_update_mst_vcpi_slots_for_dsc(struct drm_atomic_state *state,
+static int dm_update_mst_vcpi_slots_for_dsc(struct drm_atomic_commit *state,
struct dc_state *dc_state,
struct dsc_mst_fairness_vars *vars)
{
}
}
-static void amdgpu_dm_commit_cursors(struct drm_atomic_state *state)
+static void amdgpu_dm_commit_cursors(struct drm_atomic_commit *state)
{
struct drm_plane *plane;
struct drm_plane_state *old_plane_state;
}
}
-static void amdgpu_dm_commit_planes(struct drm_atomic_state *state,
+static void amdgpu_dm_commit_planes(struct drm_atomic_commit *state,
struct drm_device *dev,
struct amdgpu_display_manager *dm,
struct drm_crtc *pcrtc,
}
static void amdgpu_dm_commit_audio(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct amdgpu_device *adev = drm_to_adev(dev);
struct amdgpu_dm_connector *aconnector;
dc_stream_remove_writeback(dm->dc, crtc_state->stream, 0);
}
-static void amdgpu_dm_commit_streams(struct drm_atomic_state *state,
+static void amdgpu_dm_commit_streams(struct drm_atomic_commit *state,
struct dc_state *dc_state)
{
struct drm_device *dev = state->dev;
drm_writeback_queue_job(wb_conn, new_con_state);
}
-static void amdgpu_dm_update_hdcp(struct drm_atomic_state *state)
+static void amdgpu_dm_update_hdcp(struct drm_atomic_commit *state)
{
struct drm_connector_state *old_con_state, *new_con_state;
struct drm_device *dev = state->dev;
}
}
-static int amdgpu_dm_atomic_setup_commit(struct drm_atomic_state *state)
+static int amdgpu_dm_atomic_setup_commit(struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state, *new_crtc_state;
* programming the hardware. Any failures here implies a hardware failure, since
* atomic check should have filtered anything non-kosher.
*/
-static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_state *state)
+static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct amdgpu_device *adev = drm_to_adev(dev);
{
int ret = 0;
struct drm_device *ddev = connector->dev;
- struct drm_atomic_state *state = drm_atomic_state_alloc(ddev);
+ struct drm_atomic_commit *state = drm_atomic_commit_alloc(ddev);
struct amdgpu_crtc *disconnected_acrtc = to_amdgpu_crtc(connector->encoder->crtc);
struct drm_plane *plane = disconnected_acrtc->base.primary;
struct drm_connector_state *conn_state;
/* Construct an atomic state to restore previous display setting */
/*
- * Attach connectors to drm_atomic_state
+ * Attach connectors to drm_atomic_commit
*/
conn_state = drm_atomic_get_connector_state(state, connector);
goto out;
}
- /* Attach crtc to drm_atomic_state*/
+ /* Attach crtc to drm_atomic_commit*/
crtc_state = drm_atomic_get_crtc_state(state, &disconnected_acrtc->base);
/* Check for error in getting crtc state */
/* force a restore */
crtc_state->mode_changed = true;
- /* Attach plane to drm_atomic_state */
+ /* Attach plane to drm_atomic_commit */
plane_state = drm_atomic_get_plane_state(state, plane);
/* Check for error in getting plane state */
ret = drm_atomic_commit(state);
out:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
if (ret)
drm_err(ddev, "Restoring old state failed with %i\n", ret);
* Waits for completion of all non blocking commits.
*/
static int do_aquire_global_lock(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_commit *commit;
}
static int dm_update_crtc_state(struct amdgpu_display_manager *dm,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_crtc *crtc,
struct drm_crtc_state *old_crtc_state,
struct drm_crtc_state *new_crtc_state,
return ret;
}
-static bool should_reset_plane(struct drm_atomic_state *state,
+static bool should_reset_plane(struct drm_atomic_commit *state,
struct drm_plane *plane,
struct drm_plane_state *old_plane_state,
struct drm_plane_state *new_plane_state)
return 0;
}
-static bool dm_should_update_native_cursor(struct drm_atomic_state *state,
+static bool dm_should_update_native_cursor(struct drm_atomic_commit *state,
struct drm_crtc *old_plane_crtc,
struct drm_crtc *new_plane_crtc,
bool enable)
}
static int dm_update_plane_state(struct dc *dc,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_plane *plane,
struct drm_plane_state *old_plane_state,
struct drm_plane_state *new_plane_state,
* indefinitely.
*/
static inline struct __drm_planes_state *__get_next_zpos(
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct __drm_planes_state *prev)
{
unsigned int highest_zpos = 0, prev_zpos = 256;
(old_plane_state) = __i->old_state, \
(new_plane_state) = __i->new_state, 1))
-static int add_affected_mst_dsc_crtcs(struct drm_atomic_state *state, struct drm_crtc *crtc)
+static int add_affected_mst_dsc_crtcs(struct drm_atomic_commit *state, struct drm_crtc *crtc)
{
struct drm_connector *connector;
struct drm_connector_state *conn_state, *old_conn_state;
*
* Return: true if the pipeline modifies pixels, false otherwise.
*/
-static bool dm_plane_color_pipeline_active(struct drm_atomic_state *state,
+static bool dm_plane_color_pipeline_active(struct drm_atomic_commit *state,
struct drm_plane *plane,
bool use_old)
{
* failed.
*/
static int dm_crtc_get_cursor_mode(struct amdgpu_device *adev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct dm_crtc_state *dm_crtc_state,
enum amdgpu_dm_cursor_mode *cursor_mode)
{
}
static bool amdgpu_dm_crtc_mem_type_changed(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_crtc_state *crtc_state)
{
struct drm_plane *plane;
* Return: -Error code if validation failed.
*/
static int amdgpu_dm_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct amdgpu_device *adev = drm_to_adev(dev);
struct dm_atomic_state *dm_state = NULL;
*/
struct idle_workqueue *idle_workqueue;
- struct drm_atomic_state *cached_state;
+ struct drm_atomic_commit *cached_state;
struct dc_state *cached_dc_state;
struct dm_compressor_info compressor;
const struct dm_connector_state *dm_state,
const struct dc_stream_state *old_stream);
-int dm_atomic_get_state(struct drm_atomic_state *state,
+int dm_atomic_get_state(struct drm_atomic_commit *state,
struct dm_atomic_state **dm_state);
struct drm_connector *
-amdgpu_dm_find_first_crtc_matching_connector(struct drm_atomic_state *state,
+amdgpu_dm_find_first_crtc_matching_connector(struct drm_atomic_commit *state,
struct drm_crtc *crtc);
int convert_dc_color_depth_into_bpc(enum dc_color_depth display_color_depth);
{
struct drm_colorop *old_colorop;
struct drm_colorop_state *colorop_state = NULL, *new_colorop_state;
- struct drm_atomic_state *state = plane_state->state;
+ struct drm_atomic_commit *state = plane_state->state;
int i = 0;
old_colorop = colorop;
{
struct drm_colorop *old_colorop;
struct drm_colorop_state *colorop_state = NULL, *new_colorop_state;
- struct drm_atomic_state *state = plane_state->state;
+ struct drm_atomic_commit *state = plane_state->state;
const struct drm_device *dev = colorop->dev;
const struct drm_property_blob *blob;
struct drm_color_ctm_3x4 *ctm = NULL;
{
struct drm_colorop *old_colorop;
struct drm_colorop_state *colorop_state = NULL, *new_colorop_state;
- struct drm_atomic_state *state = plane_state->state;
+ struct drm_atomic_commit *state = plane_state->state;
const struct drm_device *dev = colorop->dev;
int i = 0;
{
struct drm_colorop *old_colorop;
struct drm_colorop_state *colorop_state = NULL, *new_colorop_state;
- struct drm_atomic_state *state = plane_state->state;
+ struct drm_atomic_commit *state = plane_state->state;
enum dc_transfer_func_predefined default_tf = TRANSFER_FUNCTION_LINEAR;
struct dc_transfer_func *tf = &dc_plane_state->in_shaper_func;
const struct drm_color_lut32 *shaper_lut;
struct drm_colorop *old_colorop;
struct drm_colorop_state *colorop_state = NULL, *new_colorop_state;
struct dc_transfer_func *tf = &dc_plane_state->in_shaper_func;
- struct drm_atomic_state *state = plane_state->state;
+ struct drm_atomic_commit *state = plane_state->state;
const struct amdgpu_device *adev = drm_to_adev(colorop->dev);
bool has_3dlut = adev->dm.dc->caps.color.dpp.hw_3d_lut || adev->dm.dc->caps.color.mpc.preblend;
const struct drm_device *dev = colorop->dev;
{
struct drm_colorop *old_colorop;
struct drm_colorop_state *colorop_state = NULL, *new_colorop_state;
- struct drm_atomic_state *state = plane_state->state;
+ struct drm_atomic_commit *state = plane_state->state;
enum dc_transfer_func_predefined default_tf = TRANSFER_FUNCTION_LINEAR;
struct dc_transfer_func *tf = &dc_plane_state->blend_tf;
const struct drm_color_lut32 *blend_lut = NULL;
static int amdgpu_dm_crtc_count_crtc_active_planes(struct drm_crtc_state *new_crtc_state)
{
- struct drm_atomic_state *state = new_crtc_state->state;
+ struct drm_atomic_commit *state = new_crtc_state->state;
struct drm_plane *plane;
int num_active = 0;
}
static int amdgpu_dm_crtc_helper_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
static struct drm_encoder *
dm_mst_atomic_best_encoder(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *connector_state = drm_atomic_get_new_connector_state(state,
connector);
}
static int dm_dp_mst_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct amdgpu_dm_connector *aconnector = to_amdgpu_dm_connector(connector);
struct drm_dp_mst_topology_mgr *mst_mgr = &aconnector->mst_root->mst_mgr;
return dsc_config.bits_per_pixel;
}
-static int increase_dsc_bpp(struct drm_atomic_state *state,
+static int increase_dsc_bpp(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_state *mst_state,
struct dc_link *dc_link,
struct dsc_mst_fairness_params *params,
return 0;
}
-static int try_disable_dsc(struct drm_atomic_state *state,
+static int try_disable_dsc(struct drm_atomic_commit *state,
struct dc_link *dc_link,
struct dsc_mst_fairness_params *params,
struct dsc_mst_fairness_vars *vars,
i, vars[i + k].dsc_enabled, vars[i + k].bpp_x16, vars[i + k].pbn);
}
-static int compute_mst_dsc_configs_for_link(struct drm_atomic_state *state,
+static int compute_mst_dsc_configs_for_link(struct drm_atomic_commit *state,
struct dc_state *dc_state,
struct dc_link *dc_link,
struct dsc_mst_fairness_vars *vars,
}
static bool is_dsc_need_re_compute(
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct dc_state *dc_state,
struct dc_link *dc_link)
{
return is_dsc_need_re_compute;
}
-int compute_mst_dsc_configs_for_state(struct drm_atomic_state *state,
+int compute_mst_dsc_configs_for_state(struct drm_atomic_commit *state,
struct dc_state *dc_state,
struct dsc_mst_fairness_vars *vars)
{
return ret;
}
-static int pre_compute_mst_dsc_configs_for_state(struct drm_atomic_state *state,
+static int pre_compute_mst_dsc_configs_for_state(struct drm_atomic_commit *state,
struct dc_state *dc_state,
struct dsc_mst_fairness_vars *vars)
{
return ret;
}
-static int find_crtc_index_in_state_by_stream(struct drm_atomic_state *state,
+static int find_crtc_index_in_state_by_stream(struct drm_atomic_commit *state,
struct dc_stream_state *stream)
{
int i;
return true;
}
-static bool is_dsc_precompute_needed(struct drm_atomic_state *state)
+static bool is_dsc_precompute_needed(struct drm_atomic_commit *state)
{
int i;
struct drm_crtc *crtc;
return ret;
}
-int pre_validate_dsc(struct drm_atomic_state *state,
+int pre_validate_dsc(struct drm_atomic_commit *state,
struct dm_atomic_state **dm_state_ptr,
struct dsc_mst_fairness_vars *vars)
{
struct amdgpu_dm_connector *aconnector;
};
-int compute_mst_dsc_configs_for_state(struct drm_atomic_state *state,
+int compute_mst_dsc_configs_for_state(struct drm_atomic_commit *state,
struct dc_state *dc_state,
struct dsc_mst_fairness_vars *vars);
bool needs_dsc_aux_workaround(struct dc_link *link);
-int pre_validate_dsc(struct drm_atomic_state *state,
+int pre_validate_dsc(struct drm_atomic_commit *state,
struct dm_atomic_state **dm_state_ptr,
struct dsc_mst_fairness_vars *vars);
}
static int amdgpu_dm_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static int amdgpu_dm_plane_atomic_async_check(struct drm_plane *plane,
- struct drm_atomic_state *state, bool flip)
+ struct drm_atomic_commit *state, bool flip)
{
struct drm_crtc_state *new_crtc_state;
struct drm_plane_state *new_plane_state;
}
static void amdgpu_dm_plane_atomic_async_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
TP_STRUCT__entry(
__field(uint32_t, conn_id)
__field(const struct drm_connector_state *, conn_state)
- __field(const struct drm_atomic_state *, state)
+ __field(const struct drm_atomic_commit *, state)
__field(const struct drm_crtc_commit *, commit)
__field(uint32_t, crtc_id)
__field(uint32_t, best_encoder_id)
TP_ARGS(state),
TP_STRUCT__entry(
- __field(const struct drm_atomic_state *, state)
+ __field(const struct drm_atomic_commit *, state)
__field(const struct drm_crtc_state *, crtc_state)
__field(const struct drm_crtc_commit *, commit)
__field(uint32_t, crtc_id)
__field(uint32_t, plane_id)
__field(enum drm_plane_type, plane_type)
__field(const struct drm_plane_state *, plane_state)
- __field(const struct drm_atomic_state *, state)
+ __field(const struct drm_atomic_commit *, state)
__field(uint32_t, crtc_id)
__field(uint32_t, fb_id)
__field(uint32_t, fb_format)
TP_ARGS(state));
TRACE_EVENT(amdgpu_dm_atomic_state_template,
- TP_PROTO(const struct drm_atomic_state *state),
+ TP_PROTO(const struct drm_atomic_commit *state),
TP_ARGS(state),
TP_STRUCT__entry(
- __field(const struct drm_atomic_state *, state)
+ __field(const struct drm_atomic_commit *, state)
__field(bool, allow_modeset)
__field(bool, legacy_cursor_update)
__field(bool, async_update)
);
DEFINE_EVENT(amdgpu_dm_atomic_state_template, amdgpu_dm_atomic_commit_tail_begin,
- TP_PROTO(const struct drm_atomic_state *state),
+ TP_PROTO(const struct drm_atomic_commit *state),
TP_ARGS(state));
DEFINE_EVENT(amdgpu_dm_atomic_state_template, amdgpu_dm_atomic_commit_tail_finish,
- TP_PROTO(const struct drm_atomic_state *state),
+ TP_PROTO(const struct drm_atomic_commit *state),
TP_ARGS(state));
DEFINE_EVENT(amdgpu_dm_atomic_state_template, amdgpu_dm_atomic_check_begin,
- TP_PROTO(const struct drm_atomic_state *state),
+ TP_PROTO(const struct drm_atomic_commit *state),
TP_ARGS(state));
TRACE_EVENT(amdgpu_dm_atomic_check_finish,
- TP_PROTO(const struct drm_atomic_state *state, int res),
+ TP_PROTO(const struct drm_atomic_commit *state, int res),
TP_ARGS(state, res),
TP_STRUCT__entry(
- __field(const struct drm_atomic_state *, state)
+ __field(const struct drm_atomic_commit *, state)
__field(int, res)
__field(bool, async_update)
__field(bool, allow_modeset)
*/
static int
komeda_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
static void
komeda_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old = drm_atomic_get_old_crtc_state(state,
crtc);
static void
komeda_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old = drm_atomic_get_old_crtc_state(state,
crtc);
static void
komeda_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
.minor = 1,
};
-static void komeda_kms_atomic_commit_hw_done(struct drm_atomic_state *state)
+static void komeda_kms_atomic_commit_hw_done(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct komeda_kms_dev *kms = to_kdev(dev);
drm_atomic_helper_commit_hw_done(state);
}
-static void komeda_kms_commit_tail(struct drm_atomic_state *old_state)
+static void komeda_kms_commit_tail(struct drm_atomic_commit *old_state)
{
struct drm_device *dev = old_state->dev;
bool fence_cookie = dma_fence_begin_signalling();
static int komeda_crtc_normalize_zpos(struct drm_crtc *crtc,
struct drm_crtc_state *crtc_st)
{
- struct drm_atomic_state *state = crtc_st->state;
+ struct drm_atomic_commit *state = crtc_st->state;
struct komeda_crtc *kcrtc = to_kcrtc(crtc);
struct komeda_crtc_state *kcrtc_st = to_kcrtc_st(crtc_st);
struct komeda_plane_state *kplane_st;
}
static int komeda_kms_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_st;
/* Komeda need to re-calculate resource assumption in every commit
* so need to add all affected_planes (even unchanged) to
- * drm_atomic_state.
+ * drm_atomic_commit.
*/
for_each_new_crtc_in_state(state, crtc, new_crtc_st, i) {
err = drm_atomic_add_affected_planes(state, crtc);
* @komeda_scaler_state
*/
struct komeda_component_state {
- /** @obj: tracking component_state by drm_atomic_state */
+ /** @obj: tracking component_state by drm_atomic_commit */
struct drm_private_state obj;
/** @component: backpointer to the component */
struct komeda_component *component;
* Represent a complete display pipeline and hold all functional components.
*/
struct komeda_pipeline {
- /** @obj: link pipeline as private obj of drm_atomic_state */
+ /** @obj: link pipeline as private obj of drm_atomic_commit */
struct drm_private_obj obj;
/** @mdev: the parent komeda_dev */
struct komeda_dev *mdev;
*
* NOTE:
* Unlike the pipeline, pipeline_state doesn’t gather any component_state
- * into it. It because all component will be managed by drm_atomic_state.
+ * into it. It because all component will be managed by drm_atomic_commit.
*/
struct komeda_pipeline_state {
- /** @obj: tracking pipeline_state by drm_atomic_state */
+ /** @obj: tracking pipeline_state by drm_atomic_commit */
struct drm_private_state obj;
/** @pipe: backpointer to the pipeline */
struct komeda_pipeline *pipe;
struct komeda_pipeline_state *
komeda_pipeline_get_old_state(struct komeda_pipeline *pipe,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
bool komeda_pipeline_disable(struct komeda_pipeline *pipe,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
void komeda_pipeline_update(struct komeda_pipeline *pipe,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
void komeda_complete_data_flow_cfg(struct komeda_layer *layer,
struct komeda_data_flow_cfg *dflow,
static struct komeda_pipeline_state *
komeda_pipeline_get_state(struct komeda_pipeline *pipe,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_private_state *priv_st;
struct komeda_pipeline_state *
komeda_pipeline_get_old_state(struct komeda_pipeline *pipe,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_private_state *priv_st;
static struct komeda_pipeline_state *
komeda_pipeline_get_new_state(struct komeda_pipeline *pipe,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_private_state *priv_st;
/* Assign pipeline for crtc */
static struct komeda_pipeline_state *
komeda_pipeline_get_state_and_set_crtc(struct komeda_pipeline *pipe,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
struct komeda_pipeline_state *st;
static struct komeda_component_state *
komeda_component_get_state(struct komeda_component *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_private_state *priv_st;
static struct komeda_component_state *
komeda_component_get_old_state(struct komeda_component *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_private_state *priv_st;
*/
static struct komeda_component_state *
komeda_component_get_state_and_set_user(struct komeda_component *c,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
void *user,
struct drm_crtc *crtc)
{
/* Get current available scaler from the component->supported_outputs */
static struct komeda_scaler *
komeda_component_get_avail_scaler(struct komeda_component *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct komeda_pipeline_state *pipe_st;
u32 avail_scalers;
struct komeda_crtc_state *kcrtc_st,
struct komeda_data_flow_cfg *dflow)
{
- struct drm_atomic_state *drm_st = kcrtc_st->base.state;
+ struct drm_atomic_commit *drm_st = kcrtc_st->base.state;
struct komeda_component_state *c_st;
struct komeda_scaler_state *st;
struct komeda_scaler *scaler;
struct komeda_crtc_state *kcrtc_st,
struct komeda_data_flow_cfg *dflow)
{
- struct drm_atomic_state *drm_st = kcrtc_st->base.state;
+ struct drm_atomic_commit *drm_st = kcrtc_st->base.state;
struct komeda_component_state *c_st, *old_st;
struct komeda_compiz_input_cfg *cin;
u16 compiz_w, compiz_h;
komeda_pipeline_unbound_components(struct komeda_pipeline *pipe,
struct komeda_pipeline_state *new)
{
- struct drm_atomic_state *drm_st = new->obj.state;
+ struct drm_atomic_commit *drm_st = new->obj.state;
struct komeda_pipeline_state *old = priv_to_pipe_st(pipe->obj.state);
struct komeda_component_state *c_st;
struct komeda_component *c;
int komeda_release_unclaimed_resources(struct komeda_pipeline *pipe,
struct komeda_crtc_state *kcrtc_st)
{
- struct drm_atomic_state *drm_st = kcrtc_st->base.state;
+ struct drm_atomic_commit *drm_st = kcrtc_st->base.state;
struct komeda_pipeline_state *st;
/* ignore the pipeline which is not affected */
* false: disable is complete.
*/
bool komeda_pipeline_disable(struct komeda_pipeline *pipe,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct komeda_pipeline_state *old;
struct komeda_component *c;
}
void komeda_pipeline_update(struct komeda_pipeline *pipe,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct komeda_pipeline_state *new = priv_to_pipe_st(pipe->obj.state);
struct komeda_pipeline_state *old;
*/
static int
komeda_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
*/
static void
komeda_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
}
}
static void hdlcd_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hdlcd_drm_private *hdlcd = crtc_to_hdlcd_priv(crtc);
}
static void hdlcd_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hdlcd_drm_private *hdlcd = crtc_to_hdlcd_priv(crtc);
}
static void hdlcd_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_pending_vblank_event *event = crtc->state->event;
};
static int hdlcd_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void hdlcd_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void malidp_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct malidp_drm *malidp = crtc_to_malidp_device(crtc);
struct malidp_hw_device *hwdev = malidp->dev;
}
static void malidp_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static int malidp_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
return (ret > 0) ? 0 : -ETIMEDOUT;
}
-static void malidp_atomic_commit_hw_done(struct drm_atomic_state *state)
+static void malidp_atomic_commit_hw_done(struct drm_atomic_commit *state)
{
struct drm_device *drm = state->dev;
struct malidp_drm *malidp = drm_to_malidp(drm);
drm_atomic_helper_commit_hw_done(state);
}
-static void malidp_atomic_commit_tail(struct drm_atomic_state *state)
+static void malidp_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *drm = state->dev;
struct malidp_drm *malidp = drm_to_malidp(drm);
}
void malidp_mw_atomic_commit(struct drm_device *drm,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct malidp_drm *malidp = drm_to_malidp(drm);
struct drm_writeback_connector *mw_conn = &malidp->mw_connector;
int malidp_mw_connector_init(struct drm_device *drm);
void malidp_mw_atomic_commit(struct drm_device *drm,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
#endif
}
static int malidp_de_plane_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void malidp_de_plane_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void malidp_de_plane_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct malidp_plane *mp = to_malidp_plane(plane);
}
static int armada_drm_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void armada_drm_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void armada_drm_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void armada_drm_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void armada_drm_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
/* === Plane support === */
static void armada_drm_overlay_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void armada_drm_overlay_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
uint32_t src_x, uint32_t src_y, uint32_t src_w, uint32_t src_h,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_plane_state *plane_state;
int ret = 0;
crtc_x, crtc_y, crtc_w, crtc_h,
src_x, src_y, src_w, src_h);
- state = drm_atomic_state_alloc(plane->dev);
+ state = drm_atomic_commit_alloc(plane->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_nonblocking_commit(state);
fail:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
}
int armada_drm_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void armada_drm_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void armada_drm_primary_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
void armada_drm_plane_cleanup_fb(struct drm_plane *plane,
struct drm_plane_state *old_state);
int armada_drm_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void armada_plane_reset(struct drm_plane *plane);
struct drm_plane_state *armada_plane_duplicate_state(struct drm_plane *plane);
void armada_plane_destroy_state(struct drm_plane *plane,
};
static int ast_cursor_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_framebuffer *new_fb = new_plane_state->fb;
}
static void ast_cursor_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ast_cursor_plane *ast_cursor_plane = to_ast_cursor_plane(plane);
struct ast_plane *ast_plane = to_ast_plane(plane);
}
static void ast_cursor_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(plane->dev);
}
static void ast_astdp_encoder_helper_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(encoder->dev);
struct ast_connector *ast_connector = &ast->output.astdp.connector;
}
static void ast_astdp_encoder_helper_atomic_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(encoder->dev);
};
static void ast_dp501_encoder_helper_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(encoder->dev);
}
static void ast_dp501_encoder_helper_atomic_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(encoder->dev);
};
static int ast_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
}
static void ast_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct ast_device *ast = to_ast_device(dev);
}
static void ast_primary_plane_helper_atomic_enable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(plane->dev);
struct ast_plane *ast_plane = to_ast_plane(plane);
}
static void ast_primary_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
/*
* Keep this empty function to avoid calling
}
static int ast_crtc_helper_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
struct drm_display_mode *adjusted_mode = &crtc_state->adjusted_mode;
static void
ast_crtc_helper_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
}
-static void ast_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *state)
+static void ast_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(crtc->dev);
u8 vgacr17 = 0x00;
ast_set_index_reg_mask(ast, AST_IO_VGACRI, 0xb6, 0xfc, vgacrb6);
}
-static void ast_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_state *state)
+static void ast_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state, crtc);
struct ast_device *ast = to_ast_device(crtc->dev);
* Mode config
*/
-static void ast_mode_config_helper_atomic_commit_tail(struct drm_atomic_state *state)
+static void ast_mode_config_helper_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct ast_device *ast = to_ast_device(state->dev);
}
static void atmel_hlcdc_crtc_atomic_disable(struct drm_crtc *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = c->dev;
struct atmel_hlcdc_crtc *crtc = drm_crtc_to_atmel_hlcdc_crtc(c);
}
static void atmel_hlcdc_crtc_atomic_enable(struct drm_crtc *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = c->dev;
struct atmel_hlcdc_crtc *crtc = drm_crtc_to_atmel_hlcdc_crtc(c);
}
static int atmel_hlcdc_crtc_atomic_check(struct drm_crtc *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *s = drm_atomic_get_new_crtc_state(state, c);
int ret;
}
static void atmel_hlcdc_crtc_atomic_begin(struct drm_crtc *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(c);
}
static void atmel_hlcdc_crtc_atomic_flush(struct drm_crtc *c,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct atmel_hlcdc_crtc *crtc = drm_crtc_to_atmel_hlcdc_crtc(c);
unsigned long flags;
struct drm_device *drm_dev = dev_get_drvdata(dev);
struct atmel_hlcdc_dc *dc = drm_dev->dev_private;
struct regmap *regmap = dc->hlcdc->regmap;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
state = drm_atomic_helper_suspend(drm_dev);
if (IS_ERR(state))
struct atmel_hlcdc_layer *layers[ATMEL_HLCDC_MAX_LAYERS];
struct {
u32 imr;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
} suspend;
};
}
static int atmel_hlcdc_plane_atomic_check(struct drm_plane *p,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *s = drm_atomic_get_new_plane_state(state, p);
struct atmel_hlcdc_plane *plane = drm_plane_to_atmel_hlcdc_plane(p);
}
static void atmel_hlcdc_plane_atomic_disable(struct drm_plane *p,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct atmel_hlcdc_plane *plane = drm_plane_to_atmel_hlcdc_plane(p);
struct atmel_hlcdc_dc *dc = plane->base.dev->dev_private;
}
static void atmel_hlcdc_plane_atomic_update(struct drm_plane *p,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_s = drm_atomic_get_new_plane_state(state,
p);
}
static void adv7511_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct adv7511 *adv = bridge_to_adv7511(bridge);
struct drm_connector *connector;
}
static void adv7511_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct adv7511 *adv = bridge_to_adv7511(bridge);
static int analogix_dp_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct analogix_dp_device *dp = to_dp(connector);
struct drm_connector_state *conn_state;
static
struct drm_crtc *analogix_dp_get_old_crtc(struct analogix_dp_device *dp,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder = dp->encoder;
struct drm_connector *connector;
static
struct drm_crtc *analogix_dp_get_new_crtc(struct analogix_dp_device *dp,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder = dp->encoder;
struct drm_connector *connector;
}
static void analogix_dp_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct analogix_dp_device *dp = to_dp(bridge);
struct drm_crtc *crtc;
}
static void analogix_dp_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct analogix_dp_device *dp = to_dp(bridge);
struct drm_crtc *crtc;
}
static void analogix_dp_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct analogix_dp_device *dp = to_dp(bridge);
struct drm_crtc *old_crtc, *new_crtc;
}
static void analogix_dp_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct analogix_dp_device *dp = to_dp(bridge);
struct drm_crtc *crtc;
}
static void anx7625_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct anx7625_data *ctx = bridge_to_anx7625(bridge);
struct device *dev = ctx->dev;
}
static void anx7625_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct anx7625_data *ctx = bridge_to_anx7625(bridge);
struct device *dev = ctx->dev;
}
static void cdns_dsi_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct cdns_dsi_input *input = bridge_to_cdns_dsi_input(bridge);
struct cdns_dsi *dsi = input_to_dsi(input);
}
static void cdns_dsi_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct cdns_dsi_input *input = bridge_to_cdns_dsi_input(bridge);
struct cdns_dsi *dsi = input_to_dsi(input);
}
static void cdns_mhdp_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
struct cdns_mhdp_bridge_state *mhdp_state;
}
static void cdns_mhdp_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
u32 resp;
struct cdns_mhdp_device *mhdp = bridge_to_mhdp(bridge);
const struct drm_display_mode *mode = &crtc_state->adjusted_mode;
struct drm_connector_state *old_state, *new_state;
- struct drm_atomic_state *state = crtc_state->state;
+ struct drm_atomic_commit *state = crtc_state->state;
struct drm_connector *conn = mhdp->connector;
u64 old_cp, new_cp;
}
static void chipone_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct chipone *icn = bridge_to_chipone(bridge);
struct drm_display_mode *mode = &icn->mode;
}
static void chipone_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct chipone *icn = bridge_to_chipone(bridge);
int ret;
}
static void chipone_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct chipone *icn = bridge_to_chipone(bridge);
}
static void fsl_ldb_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct fsl_ldb *fsl_ldb = to_fsl_ldb(bridge);
const struct drm_bridge_state *bridge_state;
}
static void fsl_ldb_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct fsl_ldb *fsl_ldb = to_fsl_ldb(bridge);
}
static void imx8mp_hdmi_pvi_bridge_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct imx8mp_hdmi_pvi *pvi = to_imx8mp_hdmi_pvi(bridge);
struct drm_connector_state *conn_state;
}
static void imx8mp_hdmi_pvi_bridge_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct imx8mp_hdmi_pvi *pvi = to_imx8mp_hdmi_pvi(bridge);
}
static void imx8qm_ldb_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ldb_channel *ldb_ch = bridge->driver_private;
struct ldb *ldb = ldb_ch->ldb;
}
static void imx8qm_ldb_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ldb_channel *ldb_ch = bridge->driver_private;
struct ldb *ldb = ldb_ch->ldb;
}
static void imx8qxp_ldb_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ldb_channel *ldb_ch = bridge->driver_private;
struct ldb *ldb = ldb_ch->ldb;
}
static void imx8qxp_ldb_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ldb_channel *ldb_ch = bridge->driver_private;
struct ldb *ldb = ldb_ch->ldb;
}
static void imx8qxp_ldb_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ldb_channel *ldb_ch = bridge->driver_private;
struct ldb *ldb = ldb_ch->ldb;
}
static void imx8qxp_pc_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct imx8qxp_pc_channel *ch = bridge->driver_private;
struct imx8qxp_pc *pc = ch->pc;
}
static void imx8qxp_pixel_link_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct imx8qxp_pixel_link *pl = bridge->driver_private;
}
static void imx8qxp_pixel_link_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct imx8qxp_pixel_link *pl = bridge->driver_private;
}
static void imx8qxp_pxl2dpi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct imx8qxp_pxl2dpi *p2d = bridge->driver_private;
return 0;
}
-static int inno_hdmi_setup(struct inno_hdmi *hdmi, struct drm_atomic_state *state)
+static int inno_hdmi_setup(struct inno_hdmi *hdmi, struct drm_atomic_commit *state)
{
struct drm_bridge *bridge = &hdmi->bridge;
struct drm_connector *connector;
}
static void inno_hdmi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct inno_hdmi *hdmi = bridge_to_inno_hdmi(bridge);
}
static void inno_hdmi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct inno_hdmi *hdmi = bridge_to_inno_hdmi(bridge);
}
static void it6263_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it6263 *it = bridge_to_it6263(bridge);
}
static void it6263_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it6263 *it = bridge_to_it6263(bridge);
const struct drm_crtc_state *crtc_state;
}
static void it6505_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it6505 *it6505 = bridge_to_it6505(bridge);
struct device *dev = it6505->dev;
}
static void it6505_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it6505 *it6505 = bridge_to_it6505(bridge);
struct device *dev = it6505->dev;
}
static void it6505_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it6505 *it6505 = bridge_to_it6505(bridge);
struct device *dev = it6505->dev;
}
static void it6505_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it6505 *it6505 = bridge_to_it6505(bridge);
struct device *dev = it6505->dev;
}
static void it66121_bridge_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge);
}
static void it66121_bridge_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct it66121_ctx *ctx = container_of(bridge, struct it66121_ctx, bridge);
}
static void lt9211_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lt9211 *ctx = bridge_to_lt9211(bridge);
const struct drm_bridge_state *bridge_state;
}
static void lt9211_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lt9211 *ctx = bridge_to_lt9211(bridge);
int ret;
/* bridge funcs */
static void lt9611_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
struct drm_connector *connector;
}
static void lt9611_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
int ret;
}
static void lt9611_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
static const struct reg_sequence reg_cfg[] = {
}
static void lt9611_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lt9611 *lt9611 = bridge_to_lt9611(bridge);
}
static void nwl_dsi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct nwl_dsi *dsi = bridge_to_dsi(bridge);
int ret;
}
static void nwl_dsi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct nwl_dsi *dsi = bridge_to_dsi(bridge);
int ret;
}
static void panel_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
struct drm_encoder *encoder = bridge->encoder;
}
static void panel_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
struct drm_encoder *encoder = bridge->encoder;
}
static void panel_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
struct drm_encoder *encoder = bridge->encoder;
}
static void panel_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge);
struct drm_encoder *encoder = bridge->encoder;
};
static void ps8640_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ps8640 *ps_bridge = bridge_to_ps8640(bridge);
struct regmap *map = ps_bridge->regmap[PAGE2_TOP_CNTL];
}
static void ps8640_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ps8640 *ps_bridge = bridge_to_ps8640(bridge);
}
static void samsung_dsim_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct samsung_dsim *dsi = bridge_to_dsi(bridge);
int ret;
}
static void samsung_dsim_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct samsung_dsim *dsi = bridge_to_dsi(bridge);
}
static void samsung_dsim_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct samsung_dsim *dsi = bridge_to_dsi(bridge);
}
static void samsung_dsim_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct samsung_dsim *dsi = bridge_to_dsi(bridge);
};
static void sii902x_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sii902x *sii902x = bridge_to_sii902x(bridge);
}
static void sii902x_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sii902x *sii902x = bridge_to_sii902x(bridge);
struct drm_connector *connector;
}
static void ssd2825_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ssd2825_priv *priv = bridge_to_ssd2825(bridge);
struct mipi_dsi_device *dsi_dev = priv->output.dev;
}
static void ssd2825_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ssd2825_priv *priv = bridge_to_ssd2825(bridge);
struct mipi_dsi_device *dsi_dev = priv->output.dev;
}
static void ssd2825_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ssd2825_priv *priv = bridge_to_ssd2825(bridge);
int ret;
}
static void dw_dp_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_dp *dp = bridge_to_dp(bridge);
struct drm_connector *connector;
}
static void dw_dp_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_dp *dp = bridge_to_dp(bridge);
}
static void dw_hdmi_qp_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_hdmi_qp *hdmi = bridge->driver_private;
struct drm_connector_state *conn_state;
}
static void dw_hdmi_qp_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_hdmi_qp *hdmi = bridge->driver_private;
}
static int dw_hdmi_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *old_state =
drm_atomic_get_old_connector_state(state, connector);
}
static void dw_hdmi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_hdmi *hdmi = bridge->driver_private;
}
static void dw_hdmi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_hdmi *hdmi = bridge->driver_private;
struct drm_connector *connector;
}
static void dw_mipi_dsi_bridge_post_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_mipi_dsi *dsi = bridge_to_dsi(bridge);
const struct dw_mipi_dsi_phy_ops *phy_ops = dsi->plat_data->phy_ops;
}
static void dw_mipi_dsi_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_mipi_dsi *dsi = bridge_to_dsi(bridge);
}
static void dw_mipi_dsi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_mipi_dsi *dsi = bridge_to_dsi(bridge);
}
static void dw_mipi_dsi2_bridge_post_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_mipi_dsi2 *dsi2 = bridge_to_dsi2(bridge);
const struct dw_mipi_dsi2_phy_ops *phy_ops = dsi2->plat_data->phy_ops;
}
static void dw_mipi_dsi2_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_mipi_dsi2 *dsi2 = bridge_to_dsi2(bridge);
}
static void dw_mipi_dsi2_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_mipi_dsi2 *dsi2 = bridge_to_dsi2(bridge);
}
static void tc358762_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc358762 *ctx = bridge_to_tc358762(bridge);
int ret;
}
static void tc358762_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc358762 *ctx = bridge_to_tc358762(bridge);
int ret;
}
static void tc358762_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc358762 *ctx = bridge_to_tc358762(bridge);
int ret;
}
static void tc_dpi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc_data *tc = bridge_to_tc(bridge);
}
static void tc_dpi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc_data *tc = bridge_to_tc(bridge);
int ret;
}
static void tc_edp_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc_data *tc = bridge_to_tc(bridge);
int ret;
}
static void tc_edp_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc_data *tc = bridge_to_tc(bridge);
int ret;
}
static void tc358768_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc358768_priv *priv = bridge_to_tc358768(bridge);
int ret;
}
static void tc358768_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc358768_priv *priv = bridge_to_tc358768(bridge);
}
static void tc358768_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc358768_priv *priv = bridge_to_tc358768(bridge);
struct mipi_dsi_device *dsi_dev = priv->output.dev;
}
static void tc358768_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc358768_priv *priv = bridge_to_tc358768(bridge);
int ret;
}
static void tc_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc_data *tc = bridge_to_tc(bridge);
struct device *dev = &tc->dsi->dev;
}
static void tc_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc_data *tc = bridge_to_tc(bridge);
struct device *dev = &tc->dsi->dev;
}
static void tc_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tc_data *tc = bridge_to_tc(bridge);
u32 hback_porch, hsync_len, hfront_porch, hactive, htime1, htime2;
};
static void dlpc_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dlpc *dlpc = bridge_to_dlpc(bridge);
struct device *dev = dlpc->dev;
}
static void dlpc_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dlpc *dlpc = bridge_to_dlpc(bridge);
int ret;
}
static void dlpc_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dlpc *dlpc = bridge_to_dlpc(bridge);
}
static void sn65dsi83_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sn65dsi83 *ctx = bridge_to_sn65dsi83(bridge);
const unsigned int dual_factor = ctx->lvds_dual_link ? 2 : 1;
}
static void sn65dsi83_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sn65dsi83 *ctx = bridge_to_sn65dsi83(bridge);
unsigned int pval;
}
static void sn65dsi83_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sn65dsi83 *ctx = bridge_to_sn65dsi83(bridge);
int idx;
static struct drm_display_mode *
get_new_adjusted_display_mode(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector *connector =
drm_atomic_get_new_connector_for_encoder(state, bridge->encoder);
}
static u32 ti_sn_bridge_get_dsi_freq(struct ti_sn65dsi86 *pdata,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
u32 bit_rate_khz, clk_freq_khz;
struct drm_display_mode *mode =
};
static void ti_sn_bridge_set_refclk_freq(struct ti_sn65dsi86 *pdata,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int i;
u32 refclk_rate;
}
static void ti_sn65dsi86_enable_comms(struct ti_sn65dsi86 *pdata,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
mutex_lock(&pdata->comms_mutex);
}
static void ti_sn_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ti_sn65dsi86 *pdata = bridge_to_ti_sn65dsi86(bridge);
}
static void ti_sn_bridge_set_dsi_rate(struct ti_sn65dsi86 *pdata,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
unsigned int bit_rate_mhz, clk_freq_mhz;
unsigned int val;
};
static int ti_sn_bridge_calc_min_dp_rate_idx(struct ti_sn65dsi86 *pdata,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
unsigned int bpp)
{
unsigned int bit_rate_khz, dp_rate_mhz;
}
static void ti_sn_bridge_set_video_timings(struct ti_sn65dsi86 *pdata,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_display_mode *mode =
get_new_adjusted_display_mode(&pdata->bridge, state);
}
static void ti_sn_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ti_sn65dsi86 *pdata = bridge_to_ti_sn65dsi86(bridge);
struct drm_connector *connector;
}
static void ti_sn_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ti_sn65dsi86 *pdata = bridge_to_ti_sn65dsi86(bridge);
}
static void ti_sn_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ti_sn65dsi86 *pdata = bridge_to_ti_sn65dsi86(bridge);
};
static void tdp158_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int err;
struct tdp158 *tdp158 = bridge->driver_private;
}
static void tdp158_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tdp158 *tdp158 = bridge->driver_private;
# ? __pfx_drm_property_free_blob+0x10/0x10
# ? vkms_atomic_crtc_destroy_state+0x31/0x40 [vkms]
# ? vkms_atomic_crtc_destroy_state+0x10/0x40 [vkms]
-# drm_atomic_state_default_clear+0x137/0x2f0
-# __drm_atomic_state_free+0x6c/0xb0
+# drm_atomic_commit_default_clear+0x137/0x2f0
+# __drm_atomic_commit_free+0x6c/0xb0
# drm_atomic_helper_update_plane+0x100/0x150
# drm_mode_cursor_universal+0x10e/0x270
# drm_mode_cursor_common+0x115/0x240
# ? __pfx_drm_property_free_blob+0x10/0x10
# ? vkms_atomic_crtc_destroy_state+0x31/0x40 [vkms]
# ? vkms_atomic_crtc_destroy_state+0x10/0x40 [vkms]
-# drm_atomic_state_default_clear+0x137/0x2f0
-# __drm_atomic_state_free+0x6c/0xb0
+# drm_atomic_commit_default_clear+0x137/0x2f0
+# __drm_atomic_commit_free+0x6c/0xb0
# drm_atomic_helper_update_plane+0x100/0x150
# drm_mode_cursor_universal+0x10e/0x270
# drm_mode_cursor_common+0x115/0x240
# ? __pfx_drm_property_free_blob+0x10/0x10
# ? vkms_atomic_crtc_destroy_state+0x31/0x40 [vkms]
# ? vkms_atomic_crtc_destroy_state+0x10/0x40 [vkms]
-# drm_atomic_state_default_clear+0x137/0x2f0
-# __drm_atomic_state_free+0x6c/0xb0
+# drm_atomic_commit_default_clear+0x137/0x2f0
+# __drm_atomic_commit_free+0x6c/0xb0
# drm_atomic_helper_update_plane+0x100/0x150
# drm_mode_cursor_universal+0x10e/0x270
# drm_mode_cursor_common+0x115/0x240
# ? __pfx_drm_property_free_blob+0x10/0x10
# ? vkms_atomic_crtc_destroy_state+0x31/0x40 [vkms]
# ? vkms_atomic_crtc_destroy_state+0x10/0x40 [vkms]
-# drm_atomic_state_default_clear+0x137/0x2f0
-# __drm_atomic_state_free+0x6c/0xb0
+# drm_atomic_commit_default_clear+0x137/0x2f0
+# __drm_atomic_commit_free+0x6c/0xb0
# drm_atomic_helper_update_plane+0x100/0x150
# drm_mode_cursor_universal+0x10e/0x270
# drm_mode_cursor_common+0x115/0x240
# ? __pfx_drm_property_free_blob+0x10/0x10
# ? vkms_atomic_crtc_destroy_state+0x31/0x40 [vkms]
# ? vkms_atomic_crtc_destroy_state+0x10/0x40 [vkms]
-# drm_atomic_state_default_clear+0x137/0x2f0
-# __drm_atomic_state_free+0x6c/0xb0
+# drm_atomic_commit_default_clear+0x137/0x2f0
+# __drm_atomic_commit_free+0x6c/0xb0
# drm_atomic_helper_update_plane+0x100/0x150
# drm_mode_cursor_universal+0x10e/0x270
# drm_mode_cursor_common+0x115/0x240
}
static int drm_bridge_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_bridge_connector *bridge_connector =
to_drm_bridge_connector(connector);
* Total slots in the atomic state assigned for this port, or a negative error
* code if the port no longer exists
*/
-int drm_dp_atomic_find_time_slots(struct drm_atomic_state *state,
+int drm_dp_atomic_find_time_slots(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_port *port, int pbn)
{
* Returns:
* 0 on success, negative error code otherwise
*/
-int drm_dp_atomic_release_time_slots(struct drm_atomic_state *state,
+int drm_dp_atomic_release_time_slots(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_port *port)
{
* Returns:
* 0 if all CRTC commits were retrieved successfully, negative error code otherwise
*/
-int drm_dp_mst_atomic_setup_commit(struct drm_atomic_state *state)
+int drm_dp_mst_atomic_setup_commit(struct drm_atomic_commit *state)
{
struct drm_dp_mst_topology_mgr *mgr;
struct drm_dp_mst_topology_state *mst_state;
* All MST drivers must call this function after calling drm_atomic_helper_wait_for_dependencies(),
* or whatever their equivalent of that is.
*/
-void drm_dp_mst_atomic_wait_for_dependencies(struct drm_atomic_state *state)
+void drm_dp_mst_atomic_wait_for_dependencies(struct drm_atomic_commit *state)
{
struct drm_dp_mst_topology_state *old_mst_state, *new_mst_state;
struct drm_dp_mst_topology_mgr *mgr;
int drm_dp_mst_root_conn_atomic_check(struct drm_connector_state *new_conn_state,
struct drm_dp_mst_topology_mgr *mgr)
{
- struct drm_atomic_state *state = new_conn_state->state;
+ struct drm_atomic_commit *state = new_conn_state->state;
struct drm_connector_state *old_conn_state =
drm_atomic_get_old_connector_state(state, new_conn_state->connector);
struct drm_crtc_state *crtc_state;
* See also:
* drm_dp_mst_atomic_enable_dsc()
*/
-int drm_dp_mst_add_affected_dsc_crtcs(struct drm_atomic_state *state, struct drm_dp_mst_topology_mgr *mgr)
+int drm_dp_mst_add_affected_dsc_crtcs(struct drm_atomic_commit *state, struct drm_dp_mst_topology_mgr *mgr)
{
struct drm_dp_mst_topology_state *mst_state;
struct drm_dp_mst_atomic_payload *pos;
/**
* drm_dp_mst_atomic_enable_dsc - Set DSC Enable Flag to On/Off
- * @state: Pointer to the new drm_atomic_state
+ * @state: Pointer to the new drm_atomic_commit
* @port: Pointer to the affected MST Port
* @pbn: Newly recalculated bw required for link with DSC enabled
* @enable: Boolean flag to enable or disable DSC on the port
* ports have DSC enabled
*
*/
-int drm_dp_mst_atomic_enable_dsc(struct drm_atomic_state *state,
+int drm_dp_mst_atomic_enable_dsc(struct drm_atomic_commit *state,
struct drm_dp_mst_port *port,
int pbn, bool enable)
{
* - %-EINVAL, if the new state is invalid, because the root port has
* too many payloads.
*/
-int drm_dp_mst_atomic_check_mgr(struct drm_atomic_state *state,
+int drm_dp_mst_atomic_check_mgr(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_topology_state *mst_state,
struct drm_dp_mst_port **failing_port)
* Returns:
* 0 if the new state is valid, negative error code otherwise.
*/
-int drm_dp_mst_atomic_check(struct drm_atomic_state *state)
+int drm_dp_mst_atomic_check(struct drm_atomic_commit *state)
{
struct drm_dp_mst_topology_mgr *mgr;
struct drm_dp_mst_topology_state *mst_state;
* RETURNS:
* The MST topology state or error pointer.
*/
-struct drm_dp_mst_topology_state *drm_atomic_get_mst_topology_state(struct drm_atomic_state *state,
+struct drm_dp_mst_topology_state *drm_atomic_get_mst_topology_state(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr)
{
return to_dp_mst_topology_state(drm_atomic_get_private_obj_state(state, &mgr->base));
* in the global atomic state
*/
struct drm_dp_mst_topology_state *
-drm_atomic_get_old_mst_topology_state(struct drm_atomic_state *state,
+drm_atomic_get_old_mst_topology_state(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr)
{
struct drm_private_state *old_priv_state =
* in the global atomic state
*/
struct drm_dp_mst_topology_state *
-drm_atomic_get_new_mst_topology_state(struct drm_atomic_state *state,
+drm_atomic_get_new_mst_topology_state(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr)
{
struct drm_private_state *new_priv_state =
EXPORT_SYMBOL(drm_dp_tunnel_available_bw);
static struct drm_dp_tunnel_group_state *
-drm_dp_tunnel_atomic_get_group_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_group_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel)
{
return (struct drm_dp_tunnel_group_state *)
* Return the state or an ERR_PTR() error on failure.
*/
struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_state(struct drm_atomic_commit *state,
struct drm_dp_tunnel *tunnel)
{
struct drm_dp_tunnel_group_state *group_state;
* Return the old state or NULL if the tunnel's atomic state is not in @state.
*/
struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_old_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_old_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel)
{
struct drm_dp_tunnel_group_state *old_group_state;
* Return the new state or NULL if the tunnel's atomic state is not in @state.
*/
struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_new_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_new_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel)
{
struct drm_dp_tunnel_group_state *new_group_state;
*
* Returns 0 in case of success, a negative error code otherwise.
*/
-int drm_dp_tunnel_atomic_set_stream_bw(struct drm_atomic_state *state,
+int drm_dp_tunnel_atomic_set_stream_bw(struct drm_atomic_commit *state,
struct drm_dp_tunnel *tunnel,
u8 stream_id, int bw)
{
* Return 0 in case of success - with the stream IDs in @stream_mask - or a
* negative error code in case of failure.
*/
-int drm_dp_tunnel_atomic_get_group_streams_in_state(struct drm_atomic_state *state,
+int drm_dp_tunnel_atomic_get_group_streams_in_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel,
u32 *stream_mask)
{
* check failed - with @failed_stream_mask containing the streams failing the
* check - or a negative error code otherwise.
*/
-int drm_dp_tunnel_atomic_check_stream_bws(struct drm_atomic_state *state,
+int drm_dp_tunnel_atomic_check_stream_bws(struct drm_atomic_commit *state,
u32 *failed_stream_mask)
{
struct drm_dp_tunnel_group_state *new_group_state;
static const struct drm_display_mode *
connector_state_get_mode(const struct drm_connector_state *conn_state)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc_state *crtc_state;
struct drm_crtc *crtc;
* Zero on success, or an errno code otherwise.
*/
int drm_atomic_helper_connector_hdmi_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *old_conn_state =
drm_atomic_get_old_connector_state(state, connector);
* Zero on success, error code on failure.
*/
int drm_atomic_helper_connector_hdmi_update_infoframes(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
const struct drm_connector_hdmi_funcs *funcs = connector->hdmi.funcs;
struct drm_connector_state *old_conn_state =
EXPORT_SYMBOL(drm_crtc_commit_wait);
/**
- * drm_atomic_state_default_release -
- * release memory initialized by drm_atomic_state_init
+ * drm_atomic_commit_default_release -
+ * release memory initialized by drm_atomic_commit_init
* @state: atomic state
*
- * Free all the memory allocated by drm_atomic_state_init.
+ * Free all the memory allocated by drm_atomic_commit_init.
* This should only be used by drivers which are still subclassing
- * &drm_atomic_state and haven't switched to &drm_private_state yet.
+ * &drm_atomic_commit and haven't switched to &drm_private_state yet.
*/
-void drm_atomic_state_default_release(struct drm_atomic_state *state)
+void drm_atomic_commit_default_release(struct drm_atomic_commit *state)
{
kfree(state->connectors);
kfree(state->crtcs);
kfree(state->colorops);
kfree(state->private_objs);
}
-EXPORT_SYMBOL(drm_atomic_state_default_release);
+EXPORT_SYMBOL(drm_atomic_commit_default_release);
/**
- * drm_atomic_state_init - init new atomic state
+ * drm_atomic_commit_init - init new atomic state
* @dev: DRM device
* @state: atomic state
*
* Default implementation for filling in a new atomic state.
* This should only be used by drivers which are still subclassing
- * &drm_atomic_state and haven't switched to &drm_private_state yet.
+ * &drm_atomic_commit and haven't switched to &drm_private_state yet.
*/
int
-drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
+drm_atomic_commit_init(struct drm_device *dev, struct drm_atomic_commit *state)
{
kref_init(&state->ref);
goto fail;
/*
- * Because drm_atomic_state can be committed asynchronously we need our
+ * Because drm_atomic_commit can be committed asynchronously we need our
* own reference and cannot rely on the on implied by drm_file in the
* ioctl call.
*/
return 0;
fail:
- drm_atomic_state_default_release(state);
+ drm_atomic_commit_default_release(state);
return -ENOMEM;
}
-EXPORT_SYMBOL(drm_atomic_state_init);
+EXPORT_SYMBOL(drm_atomic_commit_init);
/**
- * drm_atomic_state_alloc - allocate atomic state
+ * drm_atomic_commit_alloc - allocate atomic state
* @dev: DRM device
*
* This allocates an empty atomic state to track updates.
*/
-struct drm_atomic_state *
-drm_atomic_state_alloc(struct drm_device *dev)
+struct drm_atomic_commit *
+drm_atomic_commit_alloc(struct drm_device *dev)
{
struct drm_mode_config *config = &dev->mode_config;
if (!config->funcs->atomic_state_alloc) {
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
state = kzalloc_obj(*state);
if (!state)
return NULL;
- if (drm_atomic_state_init(dev, state) < 0) {
+ if (drm_atomic_commit_init(dev, state) < 0) {
kfree(state);
return NULL;
}
return config->funcs->atomic_state_alloc(dev);
}
-EXPORT_SYMBOL(drm_atomic_state_alloc);
+EXPORT_SYMBOL(drm_atomic_commit_alloc);
/**
- * drm_atomic_state_default_clear - clear base atomic state
+ * drm_atomic_commit_default_clear - clear base atomic state
* @state: atomic state
*
* Default implementation for clearing atomic state.
* This should only be used by drivers which are still subclassing
- * &drm_atomic_state and haven't switched to &drm_private_state yet.
+ * &drm_atomic_commit and haven't switched to &drm_private_state yet.
*/
-void drm_atomic_state_default_clear(struct drm_atomic_state *state)
+void drm_atomic_commit_default_clear(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct drm_mode_config *config = &dev->mode_config;
state->fake_commit = NULL;
}
}
-EXPORT_SYMBOL(drm_atomic_state_default_clear);
+EXPORT_SYMBOL(drm_atomic_commit_default_clear);
/**
- * drm_atomic_state_clear - clear state object
+ * drm_atomic_commit_clear - clear state object
* @state: atomic state
*
* When the w/w mutex algorithm detects a deadlock we need to back off and drop
* Hence we must clear all cached state and completely start over, using this
* function.
*/
-void drm_atomic_state_clear(struct drm_atomic_state *state)
+void drm_atomic_commit_clear(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct drm_mode_config *config = &dev->mode_config;
if (config->funcs->atomic_state_clear)
config->funcs->atomic_state_clear(state);
else
- drm_atomic_state_default_clear(state);
+ drm_atomic_commit_default_clear(state);
}
-EXPORT_SYMBOL(drm_atomic_state_clear);
+EXPORT_SYMBOL(drm_atomic_commit_clear);
/**
- * __drm_atomic_state_free - free all memory for an atomic state
+ * __drm_atomic_commit_free - free all memory for an atomic state
* @ref: This atomic state to deallocate
*
* This frees all memory associated with an atomic state, including all the
* per-object state for planes, CRTCs and connectors.
*/
-void __drm_atomic_state_free(struct kref *ref)
+void __drm_atomic_commit_free(struct kref *ref)
{
- struct drm_atomic_state *state = container_of(ref, typeof(*state), ref);
+ struct drm_atomic_commit *state = container_of(ref, typeof(*state), ref);
struct drm_device *dev = state->dev;
struct drm_mode_config *config = &dev->mode_config;
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_dbg_atomic(state->dev, "Freeing atomic state %p\n", state);
if (config->funcs->atomic_state_free) {
config->funcs->atomic_state_free(state);
} else {
- drm_atomic_state_default_release(state);
+ drm_atomic_commit_default_release(state);
kfree(state);
}
drm_dev_put(dev);
}
-EXPORT_SYMBOL(__drm_atomic_state_free);
+EXPORT_SYMBOL(__drm_atomic_commit_free);
/**
* drm_atomic_get_crtc_state - get CRTC state
* is consistent.
*
* WARNING: Drivers may only add new CRTC states to a @state if
- * drm_atomic_state.allow_modeset is set, or if it's a driver-internal commit
+ * drm_atomic_commit.allow_modeset is set, or if it's a driver-internal commit
* not created by userspace through an IOCTL call.
*
* Returns:
* entire atomic sequence must be restarted. All other errors are fatal.
*/
struct drm_crtc_state *
-drm_atomic_get_crtc_state(struct drm_atomic_state *state,
+drm_atomic_get_crtc_state(struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
int ret, index = drm_crtc_index(crtc);
* entire atomic sequence must be restarted. All other errors are fatal.
*/
struct drm_plane_state *
-drm_atomic_get_plane_state(struct drm_atomic_state *state,
+drm_atomic_get_plane_state(struct drm_atomic_commit *state,
struct drm_plane *plane)
{
int ret, index = drm_plane_index(plane);
* entire atomic sequence must be restarted. All other errors are fatal.
*/
struct drm_colorop_state *
-drm_atomic_get_colorop_state(struct drm_atomic_state *state,
+drm_atomic_get_colorop_state(struct drm_atomic_commit *state,
struct drm_colorop *colorop)
{
int ret, index = drm_colorop_index(colorop);
* NULL if the colorop is not part of the global atomic state.
*/
struct drm_colorop_state *
-drm_atomic_get_old_colorop_state(struct drm_atomic_state *state,
+drm_atomic_get_old_colorop_state(struct drm_atomic_commit *state,
struct drm_colorop *colorop)
{
return state->colorops[drm_colorop_index(colorop)].old_state;
* NULL if the colorop is not part of the global atomic state.
*/
struct drm_colorop_state *
-drm_atomic_get_new_colorop_state(struct drm_atomic_state *state,
+drm_atomic_get_new_colorop_state(struct drm_atomic_commit *state,
struct drm_colorop *colorop)
{
return state->colorops[drm_colorop_index(colorop)].new_state;
* directly. Sequence of the actual hardware state commit is not handled,
* drivers might need to keep track of struct drm_crtc_commit within subclassed
* structure of &drm_private_state as necessary, e.g. similar to
- * &drm_plane_state.commit. See also &drm_atomic_state.fake_commit.
+ * &drm_plane_state.commit. See also &drm_atomic_commit.fake_commit.
*
- * All private state structures contained in a &drm_atomic_state update can be
+ * All private state structures contained in a &drm_atomic_commit update can be
* iterated using for_each_oldnew_private_obj_in_state(),
* for_each_new_private_obj_in_state() and for_each_old_private_obj_in_state().
* Drivers are recommended to wrap these for each type of driver private state
* least if they want to iterate over all objects of a given type.
*
* An earlier way to handle driver private state was by subclassing struct
- * &drm_atomic_state. But since that encourages non-standard ways to implement
+ * &drm_atomic_commit. But since that encourages non-standard ways to implement
* the check/commit split atomic requires (by using e.g. "check and rollback or
* commit instead" of "duplicate state, check, then either commit or release
* duplicated state) it is deprecated in favour of using &drm_private_state.
* Either the allocated state or the error code encoded into a pointer.
*/
struct drm_private_state *
-drm_atomic_get_private_obj_state(struct drm_atomic_state *state,
+drm_atomic_get_private_obj_state(struct drm_atomic_commit *state,
struct drm_private_obj *obj)
{
int index, num_objs, ret;
* or NULL if the private_obj is not part of the global atomic state.
*/
struct drm_private_state *
-drm_atomic_get_old_private_obj_state(const struct drm_atomic_state *state,
+drm_atomic_get_old_private_obj_state(const struct drm_atomic_commit *state,
struct drm_private_obj *obj)
{
int i;
* or NULL if the private_obj is not part of the global atomic state.
*/
struct drm_private_state *
-drm_atomic_get_new_private_obj_state(const struct drm_atomic_state *state,
+drm_atomic_get_new_private_obj_state(const struct drm_atomic_commit *state,
struct drm_private_obj *obj)
{
int i;
* not connected.
*/
struct drm_connector *
-drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_state *state,
+drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_commit *state,
struct drm_encoder *encoder)
{
struct drm_connector_state *conn_state;
* not connected.
*/
struct drm_connector *
-drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_state *state,
+drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_commit *state,
struct drm_encoder *encoder)
{
struct drm_connector_state *conn_state;
* not connected.
*/
struct drm_crtc *
-drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_state *state,
+drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_commit *state,
struct drm_encoder *encoder)
{
struct drm_connector *connector;
* not connected.
*/
struct drm_crtc *
-drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_state *state,
+drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_commit *state,
struct drm_encoder *encoder)
{
struct drm_connector *connector;
* entire atomic sequence must be restarted. All other errors are fatal.
*/
struct drm_connector_state *
-drm_atomic_get_connector_state(struct drm_atomic_state *state,
+drm_atomic_get_connector_state(struct drm_atomic_commit *state,
struct drm_connector *connector)
{
int ret, index;
* entire atomic sequence must be restarted.
*/
struct drm_bridge_state *
-drm_atomic_get_bridge_state(struct drm_atomic_state *state,
+drm_atomic_get_bridge_state(struct drm_atomic_commit *state,
struct drm_bridge *bridge)
{
struct drm_private_state *obj_state;
* the bridge is not part of the global atomic state.
*/
struct drm_bridge_state *
-drm_atomic_get_old_bridge_state(const struct drm_atomic_state *state,
+drm_atomic_get_old_bridge_state(const struct drm_atomic_commit *state,
struct drm_bridge *bridge)
{
struct drm_private_state *obj_state;
* the bridge is not part of the global atomic state.
*/
struct drm_bridge_state *
-drm_atomic_get_new_bridge_state(const struct drm_atomic_state *state,
+drm_atomic_get_new_bridge_state(const struct drm_atomic_commit *state,
struct drm_bridge *bridge)
{
struct drm_private_state *obj_state;
* sequence must be restarted. All other errors are fatal.
*/
int
-drm_atomic_add_encoder_bridges(struct drm_atomic_state *state,
+drm_atomic_add_encoder_bridges(struct drm_atomic_commit *state,
struct drm_encoder *encoder)
{
struct drm_bridge_state *bridge_state;
* sequence must be restarted. All other errors are fatal.
*/
int
-drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
+drm_atomic_add_affected_connectors(struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
struct drm_mode_config *config = &state->dev->mode_config;
* sequence must be restarted. All other errors are fatal.
*/
int
-drm_atomic_add_affected_planes(struct drm_atomic_state *state,
+drm_atomic_add_affected_planes(struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
const struct drm_crtc_state *old_crtc_state =
* sequence must be restarted. All other errors are fatal.
*/
int
-drm_atomic_add_affected_colorops(struct drm_atomic_state *state,
+drm_atomic_add_affected_colorops(struct drm_atomic_commit *state,
struct drm_plane *plane)
{
struct drm_colorop *colorop;
* Returns:
* 0 on success, negative error code on failure.
*/
-int drm_atomic_check_only(struct drm_atomic_state *state)
+int drm_atomic_check_only(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct drm_mode_config *config = &dev->mode_config;
* backoff dance and restart. All other errors are fatal.
*
* This function will take its own reference on @state.
- * Callers should always release their reference with drm_atomic_state_put().
+ * Callers should always release their reference with drm_atomic_commit_put().
*
* Returns:
* 0 on success, negative error code on failure.
*/
-int drm_atomic_commit(struct drm_atomic_state *state)
+int drm_atomic_commit(struct drm_atomic_commit *state)
{
struct drm_mode_config *config = &state->dev->mode_config;
struct drm_printer p = drm_info_printer(state->dev->dev);
* backoff dance and restart. All other errors are fatal.
*
* This function will take its own reference on @state.
- * Callers should always release their reference with drm_atomic_state_put().
+ * Callers should always release their reference with drm_atomic_commit_put().
*
* Returns:
* 0 on success, negative error code on failure.
*/
-int drm_atomic_nonblocking_commit(struct drm_atomic_state *state)
+int drm_atomic_nonblocking_commit(struct drm_atomic_commit *state)
{
struct drm_mode_config *config = &state->dev->mode_config;
int ret;
}
EXPORT_SYMBOL(__drm_atomic_helper_disable_plane);
-static int update_output_state(struct drm_atomic_state *state,
+static int update_output_state(struct drm_atomic_commit *state,
struct drm_mode_set *set)
{
struct drm_device *dev = set->crtc->dev;
/* just used from drm-client and atomic-helper: */
int __drm_atomic_helper_set_config(struct drm_mode_set *set,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state;
struct drm_plane_state *primary_state;
* Note that this function looks into the new state objects and hence its not
* safe to be used after the call to drm_atomic_helper_commit_hw_done().
*/
-void drm_atomic_print_new_state(const struct drm_atomic_state *state,
+void drm_atomic_print_new_state(const struct drm_atomic_commit *state,
struct drm_printer *p)
{
struct drm_plane *plane;
* helpers.
*/
static void
-drm_atomic_helper_plane_changed(struct drm_atomic_state *state,
+drm_atomic_helper_plane_changed(struct drm_atomic_commit *state,
struct drm_plane_state *old_plane_state,
struct drm_plane_state *plane_state,
struct drm_plane *plane)
}
}
-static int handle_conflicting_encoders(struct drm_atomic_state *state,
+static int handle_conflicting_encoders(struct drm_atomic_commit *state,
bool disable_conflicting_encoders)
{
struct drm_connector_state *new_conn_state;
}
static void
-set_best_encoder(struct drm_atomic_state *state,
+set_best_encoder(struct drm_atomic_commit *state,
struct drm_connector_state *conn_state,
struct drm_encoder *encoder)
{
}
static void
-steal_encoder(struct drm_atomic_state *state,
+steal_encoder(struct drm_atomic_commit *state,
struct drm_encoder *encoder)
{
struct drm_crtc_state *crtc_state;
}
static int
-update_connector_routing(struct drm_atomic_state *state,
+update_connector_routing(struct drm_atomic_commit *state,
struct drm_connector *connector,
struct drm_connector_state *old_connector_state,
struct drm_connector_state *new_connector_state,
}
static int
-mode_fixup(struct drm_atomic_state *state)
+mode_fixup(struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state;
}
static int
-mode_valid(struct drm_atomic_state *state)
+mode_valid(struct drm_atomic_commit *state)
{
struct drm_connector_state *conn_state;
struct drm_connector *connector;
return 0;
}
-static int drm_atomic_check_valid_clones(struct drm_atomic_state *state,
+static int drm_atomic_check_valid_clones(struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
struct drm_encoder *drm_enc;
*/
int
drm_atomic_helper_check_modeset(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state, *new_crtc_state;
*/
int
drm_atomic_helper_check_wb_connector_state(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *conn_state =
drm_atomic_get_new_connector_state(state, connector);
*/
int
drm_atomic_helper_check_planes(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state;
* Zero for success or -errno
*/
int drm_atomic_helper_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int ret;
*/
void
drm_atomic_helper_commit_encoder_bridge_disable(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *old_conn_state, *new_conn_state;
* it, disables it.
*/
void
-drm_atomic_helper_commit_crtc_disable(struct drm_device *dev, struct drm_atomic_state *state)
+drm_atomic_helper_commit_crtc_disable(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state, *new_crtc_state;
* it, post-disables all encoder bridges.
*/
void
-drm_atomic_helper_commit_encoder_bridge_post_disable(struct drm_device *dev, struct drm_atomic_state *state)
+drm_atomic_helper_commit_encoder_bridge_post_disable(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *old_conn_state, *new_conn_state;
EXPORT_SYMBOL(drm_atomic_helper_commit_encoder_bridge_post_disable);
static void
-disable_outputs(struct drm_device *dev, struct drm_atomic_state *state)
+disable_outputs(struct drm_device *dev, struct drm_atomic_commit *state)
{
drm_atomic_helper_commit_encoder_bridge_disable(dev, state);
*/
void
drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *old_conn_state, *new_conn_state;
* Updates the timestamping constants used for precise vblank timestamps
* by calling drm_calc_timestamping_constants() for all enabled crtcs in @state.
*/
-void drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_state *state)
+void drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state;
struct drm_crtc *crtc;
* chain and change the mode in all bridges as well.
*/
void
-drm_atomic_helper_commit_crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *state)
+drm_atomic_helper_commit_crtc_set_mode(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state;
* PM since planes updates then only happen when the CRTC is actually enabled.
*/
void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
disable_outputs(dev, state);
* commit on each connector.
*/
void drm_atomic_helper_commit_writebacks(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *new_conn_state;
* the entire bridge chain.
*/
void
-drm_atomic_helper_commit_encoder_bridge_pre_enable(struct drm_device *dev, struct drm_atomic_state *state)
+drm_atomic_helper_commit_encoder_bridge_pre_enable(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *new_conn_state;
* it, enables it.
*/
void
-drm_atomic_helper_commit_crtc_enable(struct drm_device *dev, struct drm_atomic_state *state)
+drm_atomic_helper_commit_crtc_enable(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state;
* it, enables the entire bridge chain.
*/
void
-drm_atomic_helper_commit_encoder_bridge_enable(struct drm_device *dev, struct drm_atomic_state *state)
+drm_atomic_helper_commit_encoder_bridge_enable(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *new_conn_state;
* 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 *state)
+ struct drm_atomic_commit *state)
{
drm_atomic_helper_commit_crtc_enable(dev, state);
* next vblank, and inform all the fences of the deadline.
*/
static void set_fence_deadline(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state;
* Returns zero if success or < 0 if dma_fence_wait() fails.
*/
int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
bool pre_swap)
{
struct drm_plane *plane;
*/
void
drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state, *new_crtc_state;
* initialized using drm_atomic_helper_setup_commit().
*/
void drm_atomic_helper_wait_for_flip_done(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
int i;
* 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(struct drm_atomic_state *state)
+void drm_atomic_helper_commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
* commit. Otherwise, one should use the default implementation
* drm_atomic_helper_commit_tail().
*/
-void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *state)
+void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
}
EXPORT_SYMBOL(drm_atomic_helper_commit_tail_rpm);
-static void commit_tail(struct drm_atomic_state *state)
+static void commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
const struct drm_mode_config_helper_funcs *funcs;
drm_atomic_helper_commit_cleanup_done(state);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
}
static void commit_work(struct work_struct *work)
{
- struct drm_atomic_state *state = container_of(work,
- struct drm_atomic_state,
+ struct drm_atomic_commit *state = container_of(work,
+ struct drm_atomic_commit,
commit_work);
commit_tail(state);
}
* fails the commit should be treated like a normal synchronous commit.
*/
int drm_atomic_helper_async_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state;
* TODO: Implement full swap instead of doing in-place changes.
*/
void drm_atomic_helper_async_commit(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane *plane;
struct drm_plane_state *plane_state;
* Zero for success or -errno.
*/
int drm_atomic_helper_commit(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
bool nonblock)
{
int ret;
* make sure work items don't artificially stall on each another.
*/
- drm_atomic_state_get(state);
+ drm_atomic_commit_get(state);
if (nonblock)
queue_work(system_dfl_wq, &state->commit_work);
else
* must be done as one global operation, and enabling or disabling a CRTC can
* take a long time. But even that is not required.
*
- * IMPORTANT: A &drm_atomic_state update for multiple CRTCs is sequenced
+ * IMPORTANT: A &drm_atomic_commit update for multiple CRTCs is sequenced
* against all CRTCs therein. Therefore for atomic state updates which only flip
* planes the driver must not get the struct &drm_crtc_state of unrelated CRTCs
* in its atomic check code: This would prevent committing of atomic updates to
}
static struct drm_crtc_commit *
-crtc_or_fake_commit(struct drm_atomic_state *state, struct drm_crtc *crtc)
+crtc_or_fake_commit(struct drm_atomic_commit *state, struct drm_crtc *crtc)
{
if (crtc) {
struct drm_crtc_state *new_crtc_state;
* 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
+ * explicitly: drm_atomic_commit_default_clear() will take care of that
* automatically.
*
* Returns:
* 0 on success. -EBUSY when userspace schedules nonblocking commits too fast,
* -ENOMEM on allocation failures and -EINTR when a signal is pending.
*/
-int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
+int drm_atomic_helper_setup_commit(struct drm_atomic_commit *state,
bool nonblock)
{
struct drm_crtc *crtc;
* This is part of the atomic helper support for nonblocking commits, see
* drm_atomic_helper_setup_commit() for an overview.
*/
-void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *state)
+void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state;
* 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 *state)
+void drm_atomic_helper_fake_vblank(struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state;
struct drm_crtc *crtc;
* 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 *state)
+void drm_atomic_helper_commit_hw_done(struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state, *new_crtc_state;
*
* This signals completion of the atomic update @state, including any
* cleanup work. If used, it must be called right before calling
- * drm_atomic_state_put().
+ * drm_atomic_commit_put().
*
* 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 *state)
+void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state;
* 0 on success, negative error code on failure.
*/
int drm_atomic_helper_prepare_planes(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *new_conn_state;
* use drm_atomic_helper_cleanup_planes().
*/
void drm_atomic_helper_unprepare_planes(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane *plane;
struct drm_plane_state *new_plane_state;
* This should not be copied blindly by drivers.
*/
void drm_atomic_helper_commit_planes(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
uint32_t flags)
{
struct drm_crtc *crtc;
{
const struct drm_crtc_helper_funcs *crtc_funcs;
struct drm_crtc *crtc = old_crtc_state->crtc;
- struct drm_atomic_state *old_state = old_crtc_state->state;
+ struct drm_atomic_commit *old_state = old_crtc_state->state;
struct drm_crtc_state *new_crtc_state =
drm_atomic_get_new_crtc_state(old_state, crtc);
struct drm_plane *plane;
* drm_atomic_helper_unprepare_planes() in this case.
*/
void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane *plane;
struct drm_plane_state *old_plane_state;
* 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_swap_state(struct drm_atomic_state *state,
+int drm_atomic_helper_swap_state(struct drm_atomic_commit *state,
bool stall)
{
int i, ret;
uint32_t src_w, uint32_t src_h,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_plane_state *plane_state;
int ret = 0;
- state = drm_atomic_state_alloc(plane->dev);
+ state = drm_atomic_commit_alloc(plane->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_commit(state);
fail:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
EXPORT_SYMBOL(drm_atomic_helper_update_plane);
int drm_atomic_helper_disable_plane(struct drm_plane *plane,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_plane_state *plane_state;
int ret = 0;
- state = drm_atomic_state_alloc(plane->dev);
+ state = drm_atomic_commit_alloc(plane->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_commit(state);
fail:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
int drm_atomic_helper_set_config(struct drm_mode_set *set,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc *crtc = set->crtc;
int ret = 0;
- state = drm_atomic_state_alloc(crtc->dev);
+ state = drm_atomic_commit_alloc(crtc->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_commit(state);
fail:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
EXPORT_SYMBOL(drm_atomic_helper_set_config);
int drm_atomic_helper_disable_all(struct drm_device *dev,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector_state *conn_state;
struct drm_connector *conn;
struct drm_plane_state *plane_state;
struct drm_crtc *crtc;
int ret, i;
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_commit(state);
free:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
EXPORT_SYMBOL(drm_atomic_helper_disable_all);
int drm_atomic_helper_reset_crtc(struct drm_crtc *crtc,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc_state *crtc_state;
int ret;
- state = drm_atomic_state_alloc(crtc->dev);
+ state = drm_atomic_commit_alloc(crtc->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_commit(state);
out:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
* See also:
* drm_atomic_helper_suspend(), drm_atomic_helper_resume()
*/
-struct drm_atomic_state *
+struct drm_atomic_commit *
drm_atomic_helper_duplicate_state(struct drm_device *dev,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector *conn;
struct drm_connector_list_iter conn_iter;
struct drm_plane *plane;
struct drm_crtc *crtc;
int err = 0;
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state)
return ERR_PTR(-ENOMEM);
free:
if (err < 0) {
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
state = ERR_PTR(err);
}
* drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
* drm_atomic_helper_resume(), drm_atomic_helper_commit_duplicated_state()
*/
-struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
+struct drm_atomic_commit *drm_atomic_helper_suspend(struct drm_device *dev)
{
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
int err;
/* This can never be returned, but it makes the compiler happy */
err = drm_atomic_helper_disable_all(dev, &ctx);
if (err < 0) {
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
state = ERR_PTR(err);
goto unlock;
}
* See also:
* drm_atomic_helper_suspend()
*/
-int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
+int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_commit *state,
struct drm_modeset_acquire_ctx *ctx)
{
int i, ret;
* drm_atomic_helper_suspend()
*/
int drm_atomic_helper_resume(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_modeset_acquire_ctx ctx;
int err;
err = drm_atomic_helper_commit_duplicated_state(state, &ctx);
DRM_MODESET_LOCK_ALL_END(dev, ctx, err);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return err;
}
EXPORT_SYMBOL(drm_atomic_helper_resume);
-static int page_flip_common(struct drm_atomic_state *state,
+static int page_flip_common(struct drm_atomic_commit *state,
struct drm_crtc *crtc,
struct drm_framebuffer *fb,
struct drm_pending_vblank_event *event,
struct drm_modeset_acquire_ctx *ctx)
{
struct drm_plane *plane = crtc->primary;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
int ret = 0;
- state = drm_atomic_state_alloc(plane->dev);
+ state = drm_atomic_commit_alloc(plane->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_nonblocking_commit(state);
fail:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
EXPORT_SYMBOL(drm_atomic_helper_page_flip);
struct drm_modeset_acquire_ctx *ctx)
{
struct drm_plane *plane = crtc->primary;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc_state *crtc_state;
int ret = 0;
- state = drm_atomic_state_alloc(plane->dev);
+ state = drm_atomic_commit_alloc(plane->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_nonblocking_commit(state);
fail:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
EXPORT_SYMBOL(drm_atomic_helper_page_flip_target);
* %0 for success, a negative error code on error.
*/
int drm_atomic_helper_connector_tv_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *old_conn_state =
drm_atomic_get_old_connector_state(state, connector);
}
EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
-static void set_out_fence_for_crtc(struct drm_atomic_state *state,
+static void set_out_fence_for_crtc(struct drm_atomic_commit *state,
struct drm_crtc *crtc, s32 __user *fence_ptr)
{
state->crtcs[drm_crtc_index(crtc)].out_fence_ptr = fence_ptr;
}
-static s32 __user *get_out_fence_for_crtc(struct drm_atomic_state *state,
+static s32 __user *get_out_fence_for_crtc(struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
s32 __user *fence_ptr;
return fence_ptr;
}
-static int set_out_fence_for_connector(struct drm_atomic_state *state,
+static int set_out_fence_for_connector(struct drm_atomic_commit *state,
struct drm_connector *connector,
s32 __user *fence_ptr)
{
return 0;
}
-static s32 __user *get_out_fence_for_connector(struct drm_atomic_state *state,
+static s32 __user *get_out_fence_for_connector(struct drm_atomic_commit *state,
struct drm_connector *connector)
{
unsigned int index = drm_connector_index(connector);
return e;
}
-int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state,
+int drm_atomic_connector_commit_dpms(struct drm_atomic_commit *state,
struct drm_connector *connector,
int mode)
{
return 0;
}
-int drm_atomic_set_property(struct drm_atomic_state *state,
+int drm_atomic_set_property(struct drm_atomic_commit *state,
struct drm_file *file_priv,
struct drm_mode_object *obj,
struct drm_property *prop,
}
static int prepare_signaling(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_mode_atomic *arg,
struct drm_file *file_priv,
struct drm_out_fence_state **fence_state,
}
static void complete_signaling(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_out_fence_state *fence_state,
unsigned int num_fences,
bool install_fds)
/*
* Free the allocated event. drm_atomic_helper_setup_commit
* can allocate an event too, so only free it if it's ours
- * to prevent a double free in drm_atomic_state_clear.
+ * to prevent a double free in drm_atomic_commit_clear.
*/
if (event && (event->base.fence || event->base.file_priv)) {
drm_event_cancel_free(dev, &event->base);
}
static void
-set_async_flip(struct drm_atomic_state *state)
+set_async_flip(struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state;
uint32_t __user *props_ptr = (uint32_t __user *)(unsigned long)(arg->props_ptr);
uint64_t __user *prop_values_ptr = (uint64_t __user *)(unsigned long)(arg->prop_values_ptr);
unsigned int copied_objs, copied_props;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_modeset_acquire_ctx ctx;
struct drm_out_fence_state *fence_state;
int ret = 0;
return -EINVAL;
}
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state)
return -ENOMEM;
complete_signaling(dev, state, fence_state, num_fences, !ret);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
}
EXPORT_SYMBOL(drm_plane_create_zpos_immutable_property);
-static int drm_atomic_state_zpos_cmp(const void *a, const void *b)
+static int drm_atomic_commit_zpos_cmp(const void *a, const void *b)
{
const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
static int drm_atomic_helper_crtc_normalize_zpos(struct drm_crtc *crtc,
struct drm_crtc_state *crtc_state)
{
- struct drm_atomic_state *state = crtc_state->state;
+ struct drm_atomic_commit *state = crtc_state->state;
struct drm_device *dev = crtc->dev;
int total_planes = dev->mode_config.num_total_plane;
struct drm_plane_state **states;
plane->base.id, plane->name, plane_state->zpos);
}
- sort(states, n, sizeof(*states), drm_atomic_state_zpos_cmp, NULL);
+ sort(states, n, sizeof(*states), drm_atomic_commit_zpos_cmp, NULL);
for (i = 0; i < n; i++) {
plane = states[i]->plane;
* Zero for success or -errno
*/
int drm_atomic_normalize_zpos(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state, *new_crtc_state;
* Note: the bridge passed should be the one closest to the encoder
*/
void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder;
struct drm_bridge *iter;
EXPORT_SYMBOL(drm_atomic_bridge_chain_disable);
static void drm_atomic_bridge_call_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
if (state && bridge->funcs->atomic_post_disable)
bridge->funcs->atomic_post_disable(bridge, state);
* Note: the bridge passed should be the one closest to the encoder
*/
void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder;
struct drm_bridge *next, *limit;
EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable);
static void drm_atomic_bridge_call_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
if (state && bridge->funcs->atomic_pre_enable)
bridge->funcs->atomic_pre_enable(bridge, state);
* Note: the bridge passed should be the one closest to the encoder
*/
void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder;
struct drm_bridge *iter, *next, *limit;
* Note: the bridge passed should be the one closest to the encoder
*/
void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder;
static void
drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge,
struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_bridge_state *bridge_state, *next_bridge_state;
u32 output_flags = 0;
{
struct drm_device *dev = client->dev;
struct drm_plane *plane;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_modeset_acquire_ctx ctx;
struct drm_mode_set *mode_set;
int ret;
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state) {
ret = -ENOMEM;
goto out_ctx;
if (ret == -EDEADLK)
goto backoff;
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
out_ctx:
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
return ret;
backoff:
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
struct drm_modeset_acquire_ctx *ctx)
{
struct drm_device *dev = crtc->dev;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc_state *crtc_state;
struct drm_property_blob *blob;
struct drm_color_lut *blob_data;
else
return -ENODEV;
- state = drm_atomic_state_alloc(crtc->dev);
+ state = drm_atomic_commit_alloc(crtc->dev);
if (!state)
return -ENOMEM;
ret = drm_atomic_commit(state);
fail:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_property_blob_put(blob);
return ret;
}
* RETURNS:
* Zero on success, or an errno code otherwise.
*/
-int drm_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state)
+int drm_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
enum drm_mode_status;
struct cea_sad;
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_bridge;
struct drm_connector;
struct drm_crtc;
int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
struct drm_plane_state *plane_state);
int __drm_atomic_helper_set_config(struct drm_mode_set *set,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
-void drm_atomic_print_new_state(const struct drm_atomic_state *state,
+void drm_atomic_print_new_state(const struct drm_atomic_commit *state,
struct drm_printer *p);
/* drm_atomic_uapi.c */
-int drm_atomic_connector_commit_dpms(struct drm_atomic_state *state,
+int drm_atomic_connector_commit_dpms(struct drm_atomic_commit *state,
struct drm_connector *connector,
int mode);
-int drm_atomic_set_property(struct drm_atomic_state *state,
+int drm_atomic_set_property(struct drm_atomic_commit *state,
struct drm_file *file_priv,
struct drm_mode_object *obj,
struct drm_property *prop,
* full plane update should happen. It also ensure helper iterator will return
* &drm_plane_state.src as damage.
*/
-void drm_atomic_helper_check_plane_damage(struct drm_atomic_state *state,
+void drm_atomic_helper_check_plane_damage(struct drm_atomic_commit *state,
struct drm_plane_state *plane_state)
{
struct drm_crtc_state *crtc_state;
struct drm_modeset_acquire_ctx ctx;
struct drm_property_blob *damage = NULL;
struct drm_mode_rect *rects = NULL;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_plane *plane;
int ret = 0;
drm_modeset_acquire_init(&ctx,
file_priv ? DRM_MODESET_ACQUIRE_INTERRUPTIBLE : 0);
- state = drm_atomic_state_alloc(fb->dev);
+ state = drm_atomic_commit_alloc(fb->dev);
if (!state) {
ret = -ENOMEM;
goto out_drop_locks;
out:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
drm_property_blob_put(damage);
kfree(rects);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
out_drop_locks:
drm_modeset_drop_locks(&ctx);
struct drm_property_blob *gamma_lut = NULL;
struct drm_modeset_acquire_ctx ctx;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_mode_set *modeset;
struct drm_crtc *crtc;
u16 *r, *g, *b;
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state) {
ret = -ENOMEM;
goto out_ctx;
goto backoff;
drm_property_blob_put(gamma_lut);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
out_ctx:
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
return ret;
backoff:
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
{
struct drm_modeset_acquire_ctx ctx;
struct drm_device *dev = fb->dev;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_plane *plane;
struct drm_connector *conn __maybe_unused;
struct drm_connector_state *conn_state;
retry_disable:
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state) {
ret = -ENOMEM;
goto out;
unlock:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
out:
drm_modeset_drop_locks(&ctx);
* 0 on success, or a negative errno code otherwise.
*/
int drm_mipi_dbi_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc_state *new_crtc_state = NULL;
* this as their struct &drm_plane_helper_funcs.atomic_update callback.
*/
void drm_mipi_dbi_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = plane->state;
struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
* Returns:
* 0 on success, or a negative errno code otherwise.
*/
-int drm_mipi_dbi_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state)
+int drm_mipi_dbi_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
int ret;
* struct &drm_crtc_helper_funcs.atomic_disable callback.
*/
void drm_mipi_dbi_crtc_helper_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mipi_dbi_dev *dbidev = drm_to_mipi_dbi_dev(crtc->dev);
uint64_t prop_value)
{
struct drm_device *dev = prop->dev;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_modeset_acquire_ctx ctx;
int ret;
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state)
return -ENOMEM;
}
out:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
*/
int drm_mode_config_helper_suspend(struct drm_device *dev)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
if (!dev)
return 0;
struct drm_crtc *crtc = sr_data->crtc;
struct drm_device *dev = crtc->dev;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector *conn;
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state) {
ret = -ENOMEM;
goto out_drop_locks;
out:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
out_drop_locks:
drm_modeset_drop_locks(&ctx);
* entering self refresh mode after activity.
*/
void
-drm_self_refresh_helper_update_avg_times(struct drm_atomic_state *state,
+drm_self_refresh_helper_update_avg_times(struct drm_atomic_commit *state,
unsigned int commit_time_ms,
unsigned int new_self_refresh_mask)
{
* At the end, we queue up the self refresh entry work so we can enter PSR after
* the desired delay.
*/
-void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state)
+void drm_self_refresh_helper_alter_state(struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state;
}
static int drm_simple_kms_crtc_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
int ret;
}
static void drm_simple_kms_crtc_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane *plane;
struct drm_simple_display_pipe *pipe;
}
static void drm_simple_kms_crtc_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_simple_display_pipe *pipe;
};
static int drm_simple_kms_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void drm_simple_kms_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_pstate = drm_atomic_get_old_plane_state(state,
plane);
* See also struct &drm_crtc_helper_funcs.atomic_flush.
*/
void drm_crtc_vblank_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
* See also struct &drm_crtc_helper_funcs.atomic_enable.
*/
void drm_crtc_vblank_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(crtc);
}
* See also struct &drm_crtc_funcs.atomic_disable.
*/
void drm_crtc_vblank_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_off(crtc);
}
#include "exynos_drm_plane.h"
static void exynos_drm_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);
}
static void exynos_drm_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);
}
static int exynos_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void exynos_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);
}
static void exynos_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct exynos_drm_crtc *exynos_crtc = to_exynos_crtc(crtc);
}
static int exynos_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void exynos_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void exynos_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct exynos_drm_plane *exynos_plane = to_exynos_plane(plane);
#include "fsl_dcu_drm_plane.h"
static void fsl_dcu_drm_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct fsl_dcu_drm_device *fsl_dev = dev->dev_private;
}
static void fsl_dcu_drm_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void fsl_dcu_drm_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct fsl_dcu_drm_device *fsl_dev = dev->dev_private;
}
static int fsl_dcu_drm_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void fsl_dcu_drm_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct fsl_dcu_drm_device *fsl_dev = plane->dev->dev_private;
unsigned int value;
}
static void fsl_dcu_drm_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct fsl_dcu_drm_device *fsl_dev = plane->dev->dev_private;
struct drm_connector_state *connector_state;
struct drm_device *drm = connector->dev;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
int idx, ret;
if (!drm_dev_enter(drm, &idx))
return;
- state = drm_atomic_state_alloc(drm);
+ state = drm_atomic_commit_alloc(drm);
if (!state) {
ret = -ENOMEM;
goto exit;
ret = drm_atomic_commit(state);
out:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
}
static int gud_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *new_state;
struct drm_crtc_state *new_crtc_state;
void gud_clear_damage(struct gud_device *gdrm);
void gud_flush_work(struct work_struct *work);
void gud_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void gud_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int gud_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void gud_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *atomic_state);
+ struct drm_atomic_commit *atomic_state);
int gud_connector_fill_properties(struct drm_connector_state *connector_state,
struct gud_property_req *properties);
int gud_get_connectors(struct gud_device *gdrm);
}
int gud_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct gud_device *gdrm = to_gud_device(plane->dev);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
void gud_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct gud_device *gdrm = to_gud_device(drm);
}
void gud_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct gud_device *gdrm = to_gud_device(drm);
}
void gud_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct drm_device *drm = plane->dev;
struct gud_device *gdrm = to_gud_device(drm);
};
static int hibmc_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void hibmc_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void hibmc_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
u32 reg;
struct hibmc_drm_private *priv = to_hibmc_drm_private(crtc->dev);
}
static void hibmc_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
u32 reg;
struct hibmc_drm_private *priv = to_hibmc_drm_private(crtc->dev);
}
static void hibmc_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
u32 reg;
struct drm_device *dev = crtc->dev;
}
static void hibmc_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
unsigned long flags;
}
static void hibmc_dp_encoder_enable(struct drm_encoder *drm_encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hibmc_dp *dp = container_of(drm_encoder, struct hibmc_dp, encoder);
struct drm_display_mode *mode = &drm_encoder->crtc->state->mode;
}
static void hibmc_dp_encoder_disable(struct drm_encoder *drm_encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hibmc_dp *dp = container_of(drm_encoder, struct hibmc_dp, encoder);
#endif
static void ade_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
}
static void ade_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
}
static void ade_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
struct ade_hw_ctx *ctx = kcrtc->hw_ctx;
}
static void ade_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kirin_crtc *kcrtc = to_kirin_crtc(crtc);
}
static int ade_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void ade_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void ade_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kirin_plane *kplane = to_kirin_plane(plane);
};
static void hyperv_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hyperv_drm_device *hv = to_hv(crtc->dev);
struct drm_plane *plane = &hv->plane;
};
static int hyperv_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct hyperv_drm_device *hv = to_hv(plane->dev);
}
static void hyperv_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hyperv_drm_device *hv = to_hv(plane->dev);
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
}
int g4x_hdmi_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct intel_display *display = to_intel_display(connector->dev);
struct drm_connector_list_iter conn_iter;
#include "i915_reg_defs.h"
enum port;
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_connector;
struct intel_display;
bool g4x_hdmi_init(struct intel_display *display,
i915_reg_t hdmi_reg, enum port port);
int g4x_hdmi_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
#else
static inline bool g4x_hdmi_init(struct intel_display *display,
i915_reg_t hdmi_reg, int port)
return false;
}
static inline int g4x_hdmi_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
return 0;
}
crtc->wm.active.ilk = *active;
}
-static int ilk_sanitize_watermarks_add_affected(struct drm_atomic_state *state)
+static int ilk_sanitize_watermarks_add_affected(struct drm_atomic_commit *state)
{
struct drm_plane *plane;
struct intel_crtc *crtc;
*/
void ilk_wm_sanitize(struct intel_display *display)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct intel_atomic_state *intel_state;
struct intel_crtc *crtc;
struct intel_crtc_state *crtc_state;
if (drm_WARN_ON(display->drm, DISPLAY_VER(display) >= 9))
return;
- state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
if (drm_WARN_ON(display->drm, !state))
return;
fail:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
drm_WARN(display->drm, ret,
"Could not determine valid watermarks for inherited state\n");
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
}
int intel_digital_connector_atomic_check(struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *new_state =
drm_atomic_get_new_connector_state(state, conn);
kfree(crtc_state);
}
-struct drm_atomic_state *
+struct drm_atomic_commit *
intel_atomic_state_alloc(struct drm_device *dev)
{
struct intel_atomic_state *state = kzalloc_obj(*state);
- if (!state || drm_atomic_state_init(dev, &state->base) < 0) {
+ if (!state || drm_atomic_commit_init(dev, &state->base) < 0) {
kfree(state);
return NULL;
}
return &state->base;
}
-void intel_atomic_state_free(struct drm_atomic_state *_state)
+void intel_atomic_state_free(struct drm_atomic_commit *_state)
{
struct intel_atomic_state *state = to_intel_atomic_state(_state);
- drm_atomic_state_default_release(&state->base);
+ drm_atomic_commit_default_release(&state->base);
kfree(state->global_objs);
kfree(state);
}
-void intel_atomic_state_clear(struct drm_atomic_state *s)
+void intel_atomic_state_clear(struct drm_atomic_commit *s)
{
struct intel_atomic_state *state = to_intel_atomic_state(s);
- drm_atomic_state_default_clear(&state->base);
+ drm_atomic_commit_default_clear(&state->base);
intel_atomic_clear_global_state(state);
/* state->internal not reset on purpose */
}
struct intel_crtc_state *
-intel_atomic_get_crtc_state(struct drm_atomic_state *state,
+intel_atomic_get_crtc_state(struct drm_atomic_commit *state,
struct intel_crtc *crtc)
{
struct drm_crtc_state *crtc_state;
#include <linux/types.h>
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_connector;
struct drm_connector_state;
struct drm_crtc;
struct drm_property *property,
u64 val);
int intel_digital_connector_atomic_check(struct drm_connector *conn,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
struct drm_connector_state *
intel_digital_connector_duplicate_state(struct drm_connector *connector);
bool intel_connector_needs_modeset(struct intel_atomic_state *state,
void intel_crtc_destroy_state(struct drm_crtc *crtc,
struct drm_crtc_state *state);
void intel_crtc_free_hw_state(struct intel_crtc_state *crtc_state);
-struct drm_atomic_state *intel_atomic_state_alloc(struct drm_device *dev);
-void intel_atomic_state_free(struct drm_atomic_state *state);
-void intel_atomic_state_clear(struct drm_atomic_state *state);
+struct drm_atomic_commit *intel_atomic_state_alloc(struct drm_device *dev);
+void intel_atomic_state_free(struct drm_atomic_commit *state);
+void intel_atomic_state_clear(struct drm_atomic_commit *state);
struct intel_crtc_state *
-intel_atomic_get_crtc_state(struct drm_atomic_state *state,
+intel_atomic_get_crtc_state(struct drm_atomic_commit *state,
struct intel_crtc *crtc);
#endif /* __INTEL_ATOMIC_H__ */
bool enable)
{
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct intel_crtc *crtc;
int ret;
return;
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
if (drm_WARN_ON(display->drm, !state))
return;
ret = glk_force_audio_cdclk_commit(to_intel_atomic_state(state), crtc,
enable);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
drm_WARN_ON(display->drm, ret);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
struct intel_display *display = to_intel_display(connector->dev);
struct intel_crt *crt = intel_attached_crt(to_intel_connector(connector));
struct intel_encoder *encoder = &crt->base;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct ref_tracker *wakeref;
int status;
u8 pipe_mask,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct intel_crtc *crtc;
int ret;
- state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
if (!state)
return -ENOMEM;
ret = drm_atomic_commit(state);
out:
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return ret;
}
* @_state: state to validate
*/
int intel_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *_state)
+ struct drm_atomic_commit *_state)
{
struct intel_display *display = to_intel_display(dev);
struct intel_atomic_state *state = to_intel_atomic_state(_state);
drm_atomic_helper_cleanup_planes(display->drm, &state->base);
drm_atomic_helper_commit_cleanup_done(&state->base);
- drm_atomic_state_put(&state->base);
+ drm_atomic_commit_put(&state->base);
}
static void intel_atomic_prepare_plane_clear_colors(struct intel_atomic_state *state)
return 0;
}
-int intel_atomic_commit(struct drm_device *dev, struct drm_atomic_state *_state,
+int intel_atomic_commit(struct drm_device *dev, struct drm_atomic_commit *_state,
bool nonblock)
{
struct intel_display *display = to_intel_display(dev);
return ret;
}
- drm_atomic_state_get(&state->base);
+ drm_atomic_commit_get(&state->base);
INIT_WORK(&state->base.commit_work, intel_atomic_commit_work);
if (nonblock && state->modeset) {
int intel_initial_commit(struct intel_display *display)
{
- struct drm_atomic_state *state = NULL;
+ struct drm_atomic_commit *state = NULL;
struct drm_modeset_acquire_ctx ctx;
struct intel_crtc *crtc;
int ret = 0;
- state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
if (!state)
return -ENOMEM;
out:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
#include "i915_reg_defs.h"
#include "intel_display_limits.h"
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_device;
struct drm_display_mode;
struct drm_encoder;
_intel_modeset_secondary_pipes(crtc_state), \
i)
-int intel_atomic_check(struct drm_device *dev, struct drm_atomic_state *state);
+int intel_atomic_check(struct drm_device *dev, struct drm_atomic_commit *state);
u8 intel_calc_enabled_pipes(struct intel_atomic_state *state,
u8 enabled_pipes);
u8 intel_calc_active_pipes(struct intel_atomic_state *state,
void intel_panel_sanitize_ssc(struct intel_display *display);
enum drm_mode_status intel_mode_valid(struct drm_device *dev,
const struct drm_display_mode *mode);
-int intel_atomic_commit(struct drm_device *dev, struct drm_atomic_state *_state,
+int intel_atomic_commit(struct drm_device *dev, struct drm_atomic_commit *_state,
bool nonblock);
/* modesetting asserts */
struct {
/* restore state for suspend/resume and display reset */
- struct drm_atomic_state *modeset_state;
+ struct drm_atomic_commit *modeset_state;
struct drm_modeset_acquire_ctx reset_ctx;
/* modeset stuck tracking for reset */
atomic_t pending_fb_pin;
*/
int intel_display_driver_suspend(struct intel_display *display)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
int ret;
if (!HAS_DISPLAY(display))
int
__intel_display_driver_resume(struct intel_display *display,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_modeset_acquire_ctx *ctx)
{
struct drm_crtc_state *crtc_state;
void intel_display_driver_resume(struct intel_display *display)
{
- struct drm_atomic_state *state = display->restore.modeset_state;
+ struct drm_atomic_commit *state = display->restore.modeset_state;
struct drm_modeset_acquire_ctx ctx;
int ret;
drm_err(display->drm,
"Restoring old state failed with %i\n", ret);
if (state)
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
}
#include <linux/types.h>
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_modeset_acquire_ctx;
struct intel_display;
struct pci_dev;
/* interface for intel_display_reset.c */
int __intel_display_driver_resume(struct intel_display *display,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_modeset_acquire_ctx *ctx);
void intel_display_driver_enable_user_access(struct intel_display *display);
modeset_stuck_fn modeset_stuck, void *context)
{
struct drm_modeset_acquire_ctx *ctx = &display->restore.reset_ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
int ret;
if (!HAS_DISPLAY(display))
if (ret) {
drm_err(display->drm, "Suspending crtc's failed with %i\n",
ret);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return true;
}
void intel_display_reset_finish(struct intel_display *display, bool test_only)
{
struct drm_modeset_acquire_ctx *ctx = &display->restore.reset_ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
int ret;
if (!HAS_DISPLAY(display))
intel_hpd_poll_disable(display);
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
unlock:
drm_modeset_drop_locks(ctx);
drm_modeset_acquire_fini(ctx);
};
struct intel_atomic_state {
- struct drm_atomic_state base;
+ struct drm_atomic_commit base;
struct ref_tracker *wakeref;
}
static int intel_dp_connector_atomic_check(struct drm_connector *_connector,
- struct drm_atomic_state *_state)
+ struct drm_atomic_commit *_state)
{
struct intel_connector *connector = to_intel_connector(_connector);
struct intel_display *display = to_intel_display(connector);
int min_bpp_x16, int max_bpp_x16, int bpp_step_x16, bool dsc)
{
struct intel_display *display = to_intel_display(intel_dp);
- struct drm_atomic_state *state = crtc_state->uapi.state;
+ struct drm_atomic_commit *state = crtc_state->uapi.state;
struct drm_dp_mst_topology_state *mst_state = NULL;
struct intel_connector *connector =
to_intel_connector(conn_state->connector);
static int
mst_connector_atomic_check(struct drm_connector *_connector,
- struct drm_atomic_state *_state)
+ struct drm_atomic_commit *_state)
{
struct intel_atomic_state *state = to_intel_atomic_state(_state);
struct intel_connector *connector = to_intel_connector(_connector);
static struct drm_encoder *
mst_connector_atomic_best_encoder(struct drm_connector *_connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct intel_connector *connector = to_intel_connector(_connector);
struct drm_connector_state *connector_state =
}
static struct intel_dpll_state *
-intel_atomic_get_dpll_state(struct drm_atomic_state *s)
+intel_atomic_get_dpll_state(struct drm_atomic_commit *s)
{
struct intel_atomic_state *state = to_intel_atomic_state(s);
struct intel_display *display = to_intel_display(state);
struct intel_crtc_state *pipe_config,
enum pipe *pipe_to_reduce)
{
- struct drm_atomic_state *state = pipe_config->uapi.state;
+ struct drm_atomic_commit *state = pipe_config->uapi.state;
struct intel_crtc *other_crtc;
struct intel_crtc_state *other_crtc_state;
};
static int intel_hdmi_connector_atomic_check(struct drm_connector *_connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct intel_connector *connector = to_intel_connector(_connector);
struct intel_display *display = to_intel_display(connector);
704, 832, 0, 480, 489, 491, 520, 0, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
};
-static int intel_modeset_disable_planes(struct drm_atomic_state *state,
+static int intel_modeset_disable_planes(struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
struct drm_plane *plane;
return 0;
}
-struct drm_atomic_state *
+struct drm_atomic_commit *
intel_load_detect_get_pipe(struct drm_connector *connector,
struct drm_modeset_acquire_ctx *ctx)
{
struct intel_crtc *possible_crtc;
struct intel_crtc *crtc = NULL;
struct drm_mode_config *config = &display->drm->mode_config;
- struct drm_atomic_state *state = NULL, *restore_state = NULL;
+ struct drm_atomic_commit *state = NULL, *restore_state = NULL;
struct drm_connector_state *connector_state;
struct intel_crtc_state *crtc_state;
int ret;
}
found:
- state = drm_atomic_state_alloc(display->drm);
- restore_state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
+ restore_state = drm_atomic_commit_alloc(display->drm);
if (!state || !restore_state) {
ret = -ENOMEM;
goto fail;
goto fail;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
/* let the connector get through one full cycle before testing */
intel_crtc_wait_for_next_vblank(crtc);
fail:
if (state) {
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
state = NULL;
}
if (restore_state) {
- drm_atomic_state_put(restore_state);
+ drm_atomic_commit_put(restore_state);
restore_state = NULL;
}
}
void intel_load_detect_release_pipe(struct drm_connector *connector,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_modeset_acquire_ctx *ctx)
{
struct intel_display *display = to_intel_display(connector->dev);
if (ret)
drm_dbg_kms(display->drm,
"Couldn't release load detect pipe: %i\n", ret);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
}
#ifndef __INTEL_LOAD_DETECT_H__
#define __INTEL_LOAD_DETECT_H__
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_connector;
struct drm_modeset_acquire_ctx;
-struct drm_atomic_state *
+struct drm_atomic_commit *
intel_load_detect_get_pipe(struct drm_connector *connector,
struct drm_modeset_acquire_ctx *ctx);
void intel_load_detect_release_pipe(struct drm_connector *connector,
- struct drm_atomic_state *old,
+ struct drm_atomic_commit *old,
struct drm_modeset_acquire_ctx *ctx);
#endif /* __INTEL_LOAD_DETECT_H__ */
{
if (*ret == -EDEADLK) {
if (state)
- drm_atomic_state_clear(&state->base);
+ drm_atomic_commit_clear(&state->base);
*ret = drm_modeset_backoff(ctx);
if (*ret == 0) {
struct intel_crtc_state *crtc_state =
to_intel_crtc_state(crtc->base.state);
struct intel_plane *plane;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct intel_crtc *temp_crtc;
enum pipe pipe = crtc->pipe;
intel_plane_disable_noatomic(crtc, plane);
}
- state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
if (!state) {
drm_dbg_kms(display->drm,
"failed to disable [CRTC:%d:%s], out of memory",
display->funcs.display->crtc_disable(to_intel_atomic_state(state), crtc);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
drm_dbg_kms(display->drm,
"[CRTC:%d:%s] hw state adjusted, was enabled, now disabled\n",
{
struct intel_display *display = to_intel_display(crtc);
struct intel_crtc_state *pipe_config;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_modeset_acquire_ctx ctx;
int ret;
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
if (!state) {
ret = -ENOMEM;
goto unlock;
put_state:
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
unlock:
drm_WARN(display->drm, ret,
"Toggling workaround to %i returns %i\n", enable, ret);
{
struct drm_colorop *iter_colorop, *colorop;
struct drm_colorop_state *new_colorop_state;
- struct drm_atomic_state *state = plane_state->uapi.state;
+ struct drm_atomic_commit *state = plane_state->uapi.state;
struct intel_colorop *intel_colorop;
struct drm_property_blob *blob;
struct intel_atomic_state *intel_atomic_state = to_intel_atomic_state(state);
{
struct drm_connector_list_iter conn_iter;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector *conn;
int err = 0;
- state = drm_atomic_state_alloc(display->drm);
+ state = drm_atomic_commit_alloc(display->drm);
if (!state)
return -ENOMEM;
err = drm_atomic_commit(state);
if (err == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
err = drm_modeset_backoff(&ctx);
if (!err)
goto retry;
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
return err;
}
};
static int intel_sdvo_atomic_check(struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *new_conn_state =
drm_atomic_get_new_connector_state(state, conn);
struct drm_intel_sprite_colorkey *set = data;
struct drm_plane *plane;
struct drm_plane_state *plane_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_modeset_acquire_ctx ctx;
int ret = 0;
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(plane->dev);
+ state = drm_atomic_commit_alloc(plane->dev);
if (!state) {
ret = -ENOMEM;
goto out;
if (ret != -EDEADLK)
break;
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
out:
drm_modeset_drop_locks(&ctx);
drm_modeset_acquire_fini(&ctx);
{
struct intel_display *display = to_intel_display(tc->dig_port);
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *_state;
+ struct drm_atomic_commit *_state;
struct intel_atomic_state *state;
int ret;
- _state = drm_atomic_state_alloc(display->drm);
+ _state = drm_atomic_commit_alloc(display->drm);
if (!_state)
return -ENOMEM;
intel_modeset_lock_ctx_retry(&ctx, state, 0, ret)
ret = reset_link_commit(tc, state, &ctx);
- drm_atomic_state_put(&state->base);
+ drm_atomic_commit_put(&state->base);
return ret;
}
return connector->status;
if (force) {
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
state = intel_load_detect_get_pipe(connector, ctx);
if (IS_ERR(state))
};
static int intel_tv_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *new_state;
struct drm_crtc_state *new_crtc_state;
}
static int
-dc_crtc_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state)
+dc_crtc_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state =
drm_atomic_get_new_crtc_state(state, crtc);
}
static void
-dc_crtc_atomic_begin(struct drm_crtc *crtc, struct drm_atomic_state *state)
+dc_crtc_atomic_begin(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state =
drm_atomic_get_new_crtc_state(state, crtc);
}
static void
-dc_crtc_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_state *state)
+dc_crtc_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state =
drm_atomic_get_old_crtc_state(state, crtc);
}
static void
-dc_crtc_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *state)
+dc_crtc_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state =
drm_atomic_get_new_crtc_state(state, crtc);
}
static void
-dc_crtc_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_state *state)
+dc_crtc_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state =
drm_atomic_get_new_crtc_state(state, crtc);
}
static int
-dc_plane_atomic_check(struct drm_plane *plane, struct drm_atomic_state *state)
+dc_plane_atomic_check(struct drm_plane *plane, struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state =
drm_atomic_get_new_plane_state(state, plane);
}
static void
-dc_plane_atomic_update(struct drm_plane *plane, struct drm_atomic_state *state)
+dc_plane_atomic_update(struct drm_plane *plane, struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state =
drm_atomic_get_new_plane_state(state, plane);
}
static void dc_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dc_plane *dplane = to_dc_plane(plane);
const struct dc_fu_ops *fu_ops;
};
static void dcss_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(crtc);
}
static void dcss_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dcss_crtc *dcss_crtc = container_of(crtc, struct dcss_crtc,
base);
}
static void dcss_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void dcss_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static int dcss_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void dcss_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void dcss_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dcss_plane *dcss_plane = to_dcss_plane(plane);
struct dcss_dev *dcss = plane->dev->dev_private;
DEFINE_DRM_GEM_DMA_FOPS(imx_drm_driver_fops);
static int imx_drm_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int ret;
.atomic_commit = drm_atomic_helper_commit,
};
-static void imx_drm_atomic_commit_tail(struct drm_atomic_state *state)
+static void imx_drm_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct drm_plane *plane;
struct drm_encoder *encoder, struct device_node *np);
int ipu_planes_assign_pre(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
#endif /* _IMX_DRM_H_ */
}
static void ipu_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ipu_crtc *ipu_crtc = to_ipu_crtc(crtc);
struct ipu_soc *ipu = dev_get_drvdata(ipu_crtc->dev->parent);
}
static void ipu_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static int ipu_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void ipu_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(crtc);
}
static void ipu_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
spin_lock_irq(&crtc->dev->event_lock);
if (crtc->state->event) {
};
static int ipu_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void ipu_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ipu_plane *ipu_plane = to_ipu_plane(plane);
}
static void ipu_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
return false;
}
int ipu_planes_assign_pre(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state, *crtc_state;
struct drm_plane_state *plane_state;
}
static struct ingenic_drm_private_state *
-ingenic_drm_get_priv_state(struct ingenic_drm *priv, struct drm_atomic_state *state)
+ingenic_drm_get_priv_state(struct ingenic_drm *priv, struct drm_atomic_commit *state)
{
struct drm_private_state *priv_state;
}
static struct ingenic_drm_private_state *
-ingenic_drm_get_new_priv_state(struct ingenic_drm *priv, struct drm_atomic_state *state)
+ingenic_drm_get_new_priv_state(struct ingenic_drm *priv, struct drm_atomic_commit *state)
{
struct drm_private_state *priv_state;
}
static void ingenic_drm_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_drm *priv = drm_device_get_priv(bridge->dev);
}
static void ingenic_drm_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_drm *priv = drm_crtc_get_priv(crtc);
struct ingenic_drm_private_state *priv_state;
}
static void ingenic_drm_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_drm *priv = drm_device_get_priv(bridge->dev);
unsigned int var;
}
static void ingenic_drm_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_off(crtc);
}
}
static int ingenic_drm_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void ingenic_drm_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void ingenic_drm_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_drm *priv = drm_crtc_get_priv(crtc);
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
}
static int ingenic_drm_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void ingenic_drm_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_drm *priv = drm_device_get_priv(plane->dev);
}
static void ingenic_drm_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_drm *priv = drm_device_get_priv(plane->dev);
struct drm_plane_state *newstate = drm_atomic_get_new_plane_state(state, plane);
}
static struct ingenic_ipu_private_state *
-ingenic_ipu_get_priv_state(struct ingenic_ipu *priv, struct drm_atomic_state *state)
+ingenic_ipu_get_priv_state(struct ingenic_ipu *priv, struct drm_atomic_commit *state)
{
struct drm_private_state *priv_state;
}
static struct ingenic_ipu_private_state *
-ingenic_ipu_get_new_priv_state(struct ingenic_ipu *priv, struct drm_atomic_state *state)
+ingenic_ipu_get_new_priv_state(struct ingenic_ipu *priv, struct drm_atomic_commit *state)
{
struct drm_private_state *priv_state;
}
static void ingenic_ipu_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_ipu *ipu = plane_to_ingenic_ipu(plane);
struct drm_plane_state *newstate = drm_atomic_get_new_plane_state(state, plane);
}
static int ingenic_ipu_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void ingenic_ipu_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ingenic_ipu *ipu = plane_to_ingenic_ipu(plane);
};
static void kmb_crtc_set_mode(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct drm_display_mode *m = &crtc->state->adjusted_mode;
}
static void kmb_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kmb_drm_private *kmb = crtc_to_kmb_priv(crtc);
}
static void kmb_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kmb_drm_private *kmb = crtc_to_kmb_priv(crtc);
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state, crtc);
}
static void kmb_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct kmb_drm_private *kmb = to_kmb(dev);
}
static void kmb_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct kmb_drm_private *kmb = to_kmb(dev);
struct kmb_clock kmb_clk;
struct drm_crtc crtc;
struct kmb_plane *plane;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
spinlock_t irq_lock;
int irq_lcd;
int sys_clk_mhz;
}
static void connect_lcd_to_mipi(struct kmb_dsi *kmb_dsi,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct regmap *msscam;
}
int kmb_dsi_mode_set(struct kmb_dsi *kmb_dsi, struct drm_display_mode *mode,
- int sys_clk_mhz, struct drm_atomic_state *old_state)
+ int sys_clk_mhz, struct drm_atomic_commit *old_state)
{
u64 data_rate;
struct kmb_dsi *kmb_dsi_init(struct platform_device *pdev);
void kmb_dsi_host_unregister(struct kmb_dsi *kmb_dsi);
int kmb_dsi_mode_set(struct kmb_dsi *kmb_dsi, struct drm_display_mode *mode,
- int sys_clk_mhz, struct drm_atomic_state *old_state);
+ int sys_clk_mhz, struct drm_atomic_commit *old_state);
int kmb_dsi_map_mmio(struct kmb_dsi *kmb_dsi);
int kmb_dsi_clk_init(struct kmb_dsi *kmb_dsi);
int kmb_dsi_encoder_init(struct drm_device *dev, struct kmb_dsi *kmb_dsi);
}
static int kmb_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void kmb_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct kmb_plane *kmb_plane = to_kmb_plane(plane);
int plane_id = kmb_plane->id;
}
static void kmb_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void logicvc_crtc_atomic_begin(struct drm_crtc *drm_crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct logicvc_crtc *crtc = logicvc_crtc(drm_crtc);
struct drm_crtc_state *old_state =
}
static void logicvc_crtc_atomic_enable(struct drm_crtc *drm_crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct logicvc_crtc *crtc = logicvc_crtc(drm_crtc);
struct logicvc_drm *logicvc = logicvc_drm(drm_crtc->dev);
}
static void logicvc_crtc_atomic_disable(struct drm_crtc *drm_crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct logicvc_drm *logicvc = logicvc_drm(drm_crtc->dev);
struct drm_device *drm_dev = drm_crtc->dev;
}
static int logicvc_plane_atomic_check(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm_dev = drm_plane->dev;
struct logicvc_layer *layer = logicvc_layer(drm_plane);
}
static void logicvc_plane_atomic_update(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct logicvc_layer *layer = logicvc_layer(drm_plane);
struct logicvc_drm *logicvc = logicvc_drm(drm_plane->dev);
}
static void logicvc_plane_atomic_disable(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct logicvc_layer *layer = logicvc_layer(drm_plane);
struct logicvc_drm *logicvc = logicvc_drm(drm_plane->dev);
}
static int lsdc_crtc_helper_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
}
static void lsdc_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
}
static void lsdc_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_crtc *lcrtc = to_lsdc_crtc(crtc);
}
static void lsdc_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
spin_lock_irq(&crtc->dev->event_lock);
if (crtc->state->event) {
static struct drm_encoder *
ls7a1000_dpi_connector_get_best_encoder(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_output *output = connector_to_lsdc_output(connector);
static struct drm_encoder *
ls7a2000_connector_get_best_encoder(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_output *output = connector_to_lsdc_output(connector);
}
static void ls7a2000_hdmi_atomic_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_output *output = encoder_to_lsdc_output(encoder);
struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
}
static void ls7a2000_hdmi_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *ddev = encoder->dev;
struct lsdc_device *ldev = to_lsdc(ddev);
}
static int lsdc_primary_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc *crtc = new_plane_state->crtc;
}
static void lsdc_primary_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_primary *primary = to_lsdc_primary(plane);
const struct lsdc_primary_plane_ops *ops = primary->ops;
}
static void lsdc_primary_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
/*
* Do nothing, just prevent call into atomic_update().
};
static int lsdc_cursor_plane_atomic_async_check(struct drm_plane *plane,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
bool flip)
{
struct drm_plane_state *new_state;
}
static void lsdc_cursor_plane_atomic_async_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_cursor *cursor = to_lsdc_cursor(plane);
const struct lsdc_cursor_plane_ops *ops = cursor->ops;
/* ls7a1000 cursor plane helpers */
static int ls7a1000_cursor_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state;
struct drm_crtc_state *new_crtc_state;
}
static void ls7a1000_cursor_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_cursor *cursor = to_lsdc_cursor(plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
static void ls7a1000_cursor_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_cursor *cursor = to_lsdc_cursor(plane);
const struct lsdc_cursor_plane_ops *ops = cursor->ops;
/* ls7a2000 cursor plane helpers */
static int ls7a2000_cursor_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state;
struct drm_crtc_state *new_crtc_state;
/* Update the format, size and location of the cursor */
static void ls7a2000_cursor_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_cursor *cursor = to_lsdc_cursor(plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
static void ls7a2000_cursor_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lsdc_cursor *cursor = to_lsdc_cursor(plane);
const struct lsdc_cursor_plane_ops *hw_ops = cursor->ops;
}
static void mtk_crtc_update_output(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int crtc_index = drm_crtc_index(crtc);
int i;
}
void mtk_crtc_async_update(struct drm_crtc *crtc, struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_crtc *mtk_crtc = to_mtk_crtc(crtc);
}
static void mtk_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_crtc *mtk_crtc = to_mtk_crtc(crtc);
struct mtk_ddp_comp *comp = mtk_crtc->ddp_comp[0];
}
static void mtk_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_crtc *mtk_crtc = to_mtk_crtc(crtc);
struct mtk_ddp_comp *comp = mtk_crtc->ddp_comp[0];
}
static void mtk_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void mtk_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_crtc *mtk_crtc = to_mtk_crtc(crtc);
int i;
struct mtk_plane_state *state);
void mtk_crtc_plane_disable(struct drm_crtc *crtc, struct drm_plane *plane);
void mtk_crtc_async_update(struct drm_crtc *crtc, struct drm_plane *plane,
- struct drm_atomic_state *plane_state);
+ struct drm_atomic_commit *plane_state);
struct device *mtk_crtc_dma_dev_get(struct drm_crtc *crtc);
#endif /* MTK_CRTC_H */
}
static void mtk_dp_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_dp *mtk_dp = mtk_dp_from_bridge(bridge);
int ret;
}
static void mtk_dp_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_dp *mtk_dp = mtk_dp_from_bridge(bridge);
struct device_node *comp_node[DDP_COMPONENT_DRM_ID_MAX];
struct mtk_ddp_comp ddp_comp[DDP_COMPONENT_DRM_ID_MAX];
struct mtk_mmsys_driver_data *data;
- struct drm_atomic_state *suspend_state;
+ struct drm_atomic_commit *suspend_state;
unsigned int mbox_index;
struct mtk_drm_private **all_drm_private;
};
}
static void mtk_dsi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_dsi *dsi = bridge_to_dsi(bridge);
}
static void mtk_dsi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_dsi *dsi = bridge_to_dsi(bridge);
}
static void mtk_dsi_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_dsi *dsi = bridge_to_dsi(bridge);
int ret;
}
static void mtk_dsi_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_dsi *dsi = bridge_to_dsi(bridge);
}
static void mtk_hdmi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
}
static void mtk_hdmi_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
}
static void mtk_hdmi_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
}
static void mtk_hdmi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
}
static void mtk_hdmi_v2_bridge_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
struct drm_connector_state *conn_state;
}
static void mtk_hdmi_v2_bridge_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
int ret;
}
static void mtk_hdmi_v2_bridge_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
}
static void mtk_hdmi_v2_bridge_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mtk_hdmi *hdmi = hdmi_ctx_from_bridge(bridge);
}
static int mtk_plane_atomic_async_check(struct drm_plane *plane,
- struct drm_atomic_state *state, bool flip)
+ struct drm_atomic_commit *state, bool flip)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void mtk_plane_atomic_async_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
};
static int mtk_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void mtk_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void mtk_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
};
static void meson_g12a_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
struct drm_crtc_state *crtc_state = crtc->state;
}
static void meson_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
struct drm_crtc_state *crtc_state = crtc->state;
}
static void meson_g12a_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
struct meson_drm *priv = meson_crtc->priv;
}
static void meson_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
struct meson_drm *priv = meson_crtc->priv;
}
static void meson_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
unsigned long flags;
}
static void meson_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
struct meson_drm *priv = meson_crtc->priv;
}
static void meson_encoder_cvbs_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_encoder_cvbs *encoder_cvbs = bridge_to_meson_encoder_cvbs(bridge);
struct meson_drm *priv = encoder_cvbs->priv;
}
static void meson_encoder_cvbs_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_encoder_cvbs *meson_encoder_cvbs =
bridge_to_meson_encoder_cvbs(bridge);
}
static void meson_encoder_dsi_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_encoder_dsi *encoder_dsi = bridge_to_meson_encoder_dsi(bridge);
struct meson_drm *priv = encoder_dsi->priv;
}
static void meson_encoder_dsi_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_encoder_dsi *meson_encoder_dsi =
bridge_to_meson_encoder_dsi(bridge);
}
static void meson_encoder_hdmi_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_encoder_hdmi *encoder_hdmi = bridge_to_meson_encoder_hdmi(bridge);
unsigned int ycrcb_map = VPU_HDMI_OUTPUT_CBYCR;
}
static void meson_encoder_hdmi_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_encoder_hdmi *encoder_hdmi = bridge_to_meson_encoder_hdmi(bridge);
struct meson_drm *priv = encoder_hdmi->priv;
#define FRAC_16_16(mult, div) (((mult) << 16) / (div))
static int meson_overlay_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void meson_overlay_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_overlay *meson_overlay = to_meson_overlay(plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
}
static void meson_overlay_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_overlay *meson_overlay = to_meson_overlay(plane);
struct meson_drm *priv = meson_overlay->priv;
#define FRAC_16_16(mult, div) (((mult) << 16) / (div))
static int meson_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void meson_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_plane *meson_plane = to_meson_plane(plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
}
static void meson_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct meson_plane *meson_plane = to_meson_plane(plane);
struct meson_drm *priv = meson_plane->priv;
* success, the calculated parameters should be stored in the CRTC's
* state in struct @mgag200_crtc_state.pixpllc.
*/
- int (*pixpllc_atomic_check)(struct drm_crtc *crtc, struct drm_atomic_state *new_state);
+ int (*pixpllc_atomic_check)(struct drm_crtc *crtc, struct drm_atomic_commit *new_state);
/*
* Program PIXPLLC from the CRTC state. The parameters should have been
* stored in struct @mgag200_crtc_state.pixpllc by the corresponding
* implementation of @pixpllc_atomic_check.
*/
- void (*pixpllc_atomic_update)(struct drm_crtc *crtc, struct drm_atomic_state *old_state);
+ void (*pixpllc_atomic_update)(struct drm_crtc *crtc, struct drm_atomic_commit *old_state);
};
struct mga_device {
struct mga_device *mgag200_g200se_device_create(struct pci_dev *pdev, const struct drm_driver *drv,
enum mga_type type);
void mgag200_g200wb_init_registers(struct mga_device *mdev);
-void mgag200_g200wb_pixpllc_atomic_update(struct drm_crtc *crtc, struct drm_atomic_state *old_state);
+void mgag200_g200wb_pixpllc_atomic_update(struct drm_crtc *crtc, struct drm_atomic_commit *old_state);
struct mga_device *mgag200_g200wb_device_create(struct pci_dev *pdev, const struct drm_driver *drv);
struct mga_device *mgag200_g200ev_device_create(struct pci_dev *pdev, const struct drm_driver *drv);
void mgag200_g200eh_init_registers(struct mga_device *mdev);
-void mgag200_g200eh_pixpllc_atomic_update(struct drm_crtc *crtc, struct drm_atomic_state *old_state);
+void mgag200_g200eh_pixpllc_atomic_update(struct drm_crtc *crtc, struct drm_atomic_commit *old_state);
struct mga_device *mgag200_g200eh_device_create(struct pci_dev *pdev,
const struct drm_driver *drv);
struct mga_device *mgag200_g200eh3_device_create(struct pci_dev *pdev,
struct drm_crtc_state;
struct drm_display_mode;
struct drm_plane;
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_scanout_buffer;
extern const uint32_t mgag200_primary_plane_formats[];
extern const uint64_t mgag200_primary_plane_fmtmods[];
int mgag200_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *new_state);
+ struct drm_atomic_commit *new_state);
void mgag200_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
void mgag200_primary_plane_helper_atomic_enable(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void mgag200_primary_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
int mgag200_primary_plane_helper_get_scanout_buffer(struct drm_plane *plane,
struct drm_scanout_buffer *sb);
enum drm_mode_status mgag200_crtc_helper_mode_valid(struct drm_crtc *crtc,
const struct drm_display_mode *mode);
-int mgag200_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *new_state);
-void mgag200_crtc_helper_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_state *old_state);
-void mgag200_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *old_state);
-void mgag200_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_state *old_state);
+int mgag200_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *new_state);
+void mgag200_crtc_helper_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_commit *old_state);
+void mgag200_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_commit *old_state);
+void mgag200_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_commit *old_state);
#define MGAG200_CRTC_HELPER_FUNCS \
.mode_valid = mgag200_crtc_helper_mode_valid, \
* PIXPLLC
*/
-static int mgag200_g200_pixpllc_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *new_state)
+static int mgag200_g200_pixpllc_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *new_state)
{
static const int post_div_max = 7;
static const int in_div_min = 1;
}
static void mgag200_g200_pixpllc_atomic_update(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
*/
static int mgag200_g200eh_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 800000;
static const unsigned int vcomin = 400000;
}
void mgag200_g200eh_pixpllc_atomic_update(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
*/
static int mgag200_g200eh3_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 3000000;
static const unsigned int vcomin = 1500000;
*/
static int mgag200_g200eh5_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
const unsigned long long VCO_MAX = 10 * GIGA; // Hz
const unsigned long long VCO_MIN = 2500 * MEGA; // Hz
*/
static int mgag200_g200er_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 1488000;
static const unsigned int vcomin = 1056000;
}
static void mgag200_g200er_pixpllc_atomic_update(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
};
static void mgag200_g200er_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
*/
static int mgag200_g200ev_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 550000;
static const unsigned int vcomin = 150000;
}
static void mgag200_g200ev_pixpllc_atomic_update(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
};
static void mgag200_g200ev_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
*/
static int mgag200_g200ew3_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 800000;
static const unsigned int vcomin = 400000;
*/
static int mgag200_g200se_00_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 320000;
static const unsigned int vcomin = 160000;
}
static void mgag200_g200se_00_pixpllc_atomic_update(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
}
static int mgag200_g200se_04_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 1600000;
static const unsigned int vcomin = 800000;
}
static void mgag200_g200se_04_pixpllc_atomic_update(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
};
static void mgag200_g200se_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
*/
static int mgag200_g200wb_pixpllc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
static const unsigned int vcomax = 550000;
static const unsigned int vcomin = 150000;
}
void mgag200_g200wb_pixpllc_atomic_update(struct drm_crtc *crtc,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
};
int mgag200_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane);
struct drm_framebuffer *new_fb = new_plane_state->fb;
}
void mgag200_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = plane->dev;
struct mga_device *mdev = to_mga_device(dev);
}
void mgag200_primary_plane_helper_atomic_enable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct mga_device *mdev = to_mga_device(dev);
}
void mgag200_primary_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_device *dev = plane->dev;
struct mga_device *mdev = to_mga_device(dev);
return MODE_OK;
}
-int mgag200_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *new_state)
+int mgag200_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *new_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
return 0;
}
-void mgag200_crtc_helper_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_state *old_state)
+void mgag200_crtc_helper_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_commit *old_state)
{
struct drm_crtc_state *crtc_state = crtc->state;
struct mgag200_crtc_state *mgag200_crtc_state = to_mgag200_crtc_state(crtc_state);
}
}
-void mgag200_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *old_state)
+void mgag200_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_commit *old_state)
{
struct drm_device *dev = crtc->dev;
struct mga_device *mdev = to_mga_device(dev);
mgag200_enable_display(mdev);
}
-void mgag200_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_state *old_state)
+void mgag200_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_commit *old_state)
{
struct mga_device *mdev = to_mga_device(crtc->dev);
* Mode config
*/
-static void mgag200_mode_config_helper_atomic_commit_tail(struct drm_atomic_state *state)
+static void mgag200_mode_config_helper_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct mga_device *mdev = to_mga_device(state->dev);
#include "mgag200_drv.h"
static void mgag200_vga_bmc_encoder_atomic_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mga_device *mdev = to_mga_device(encoder->dev);
}
static void mgag200_vga_bmc_encoder_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mga_device *mdev = to_mga_device(encoder->dev);
}
static void dpu_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dpu_crtc_state *cstate = to_dpu_crtc_state(crtc->state);
struct drm_encoder *encoder;
}
static void dpu_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dpu_crtc *dpu_crtc;
struct drm_device *dev;
}
static void dpu_crtc_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void dpu_crtc_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc);
struct drm_encoder *encoder;
static int dpu_crtc_assign_planes(struct drm_crtc *crtc, struct drm_crtc_state *crtc_state)
{
int total_planes = crtc->dev->mode_config.num_total_plane;
- struct drm_atomic_state *state = crtc_state->state;
+ struct drm_atomic_commit *state = crtc_state->state;
struct dpu_global_state *global_state;
struct drm_plane_state **states;
struct drm_plane *plane;
}
static int dpu_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
void dpu_encoder_update_topology(struct drm_encoder *drm_enc,
struct msm_display_topology *topology,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
const struct drm_display_mode *adj_mode)
{
struct dpu_encoder_virt *dpu_enc = to_dpu_encoder_virt(drm_enc);
}
}
-bool dpu_encoder_needs_modeset(struct drm_encoder *drm_enc, struct drm_atomic_state *state)
+bool dpu_encoder_needs_modeset(struct drm_encoder *drm_enc, struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *conn_state;
}
static void dpu_encoder_virt_atomic_enable(struct drm_encoder *drm_enc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dpu_encoder_virt *dpu_enc = NULL;
int ret = 0;
}
static void dpu_encoder_virt_atomic_disable(struct drm_encoder *drm_enc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dpu_encoder_virt *dpu_enc = NULL;
struct drm_crtc *crtc;
void dpu_encoder_update_topology(struct drm_encoder *drm_enc,
struct msm_display_topology *topology,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
const struct drm_display_mode *adj_mode);
-bool dpu_encoder_needs_modeset(struct drm_encoder *drm_enc, struct drm_atomic_state *state);
+bool dpu_encoder_needs_modeset(struct drm_encoder *drm_enc, struct drm_atomic_commit *state);
void dpu_encoder_prepare_wb_job(struct drm_encoder *drm_enc,
struct drm_writeback_job *job);
* This acquires the modeset lock set aside for global state, creates
* a new duplicated private object state.
*/
-struct dpu_global_state *dpu_kms_get_global_state(struct drm_atomic_state *s)
+struct dpu_global_state *dpu_kms_get_global_state(struct drm_atomic_commit *s)
{
struct msm_drm_private *priv = s->dev->dev_private;
struct dpu_kms *dpu_kms = to_dpu_kms(priv->kms);
pm_runtime_put_sync(&dpu_kms->pdev->dev);
}
-static int dpu_kms_check_mode_changed(struct msm_kms *kms, struct drm_atomic_state *state)
+static int dpu_kms_check_mode_changed(struct msm_kms *kms, struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state;
struct drm_crtc_state *old_crtc_state;
struct dpu_global_state
*dpu_kms_get_existing_global_state(struct dpu_kms *dpu_kms);
struct dpu_global_state
- *__must_check dpu_kms_get_global_state(struct drm_atomic_state *s);
+ *__must_check dpu_kms_get_global_state(struct drm_atomic_commit *s);
/**
* Debugfs functions - extra helper functions for debugfs support
}
static int dpu_plane_atomic_check_sspp(struct drm_plane *plane,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
const struct drm_crtc_state *crtc_state)
{
struct drm_plane_state *new_plane_state =
}
static int dpu_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state =
drm_atomic_get_plane_state(state, plane);
static int dpu_plane_virtual_assign_resources(struct drm_crtc *crtc,
struct dpu_global_state *global_state,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_plane_state *plane_state,
const struct drm_crtc_state *crtc_state,
struct drm_plane_state **prev_adjacent_plane_state)
static int dpu_plane_assign_resources(struct drm_crtc *crtc,
struct dpu_global_state *global_state,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_plane_state *plane_state,
const struct drm_crtc_state *crtc_state)
{
}
int dpu_assign_plane_resources(struct dpu_global_state *global_state,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_crtc *crtc,
struct drm_plane_state **states,
unsigned int num_planes)
}
static void dpu_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dpu_plane *pdpu = to_dpu_plane(plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
#endif
int dpu_assign_plane_resources(struct dpu_global_state *global_state,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_crtc *crtc,
struct drm_plane_state **states,
unsigned int num_planes);
}
static int dpu_wb_conn_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_writeback_connector *wb_conn = drm_connector_to_writeback(connector);
struct dpu_wb_connector *dpu_wb_conn = to_dpu_wb_conn(wb_conn);
}
static void mdp4_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
struct mdp4_kms *mdp4_kms = get_kms(crtc);
}
static void mdp4_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
struct mdp4_kms *mdp4_kms = get_kms(crtc);
}
static int mdp4_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
DBG("%s: check", mdp4_crtc->name);
}
static void mdp4_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
DBG("%s: begin", mdp4_crtc->name);
}
static void mdp4_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp4_crtc *mdp4_crtc = to_mdp4_crtc(crtc);
struct drm_device *dev = crtc->dev;
static int mdp4_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
return 0;
}
static void mdp4_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void mdp5_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
struct mdp5_crtc_state *mdp5_cstate = to_mdp5_crtc_state(crtc->state);
}
static void mdp5_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
struct mdp5_crtc_state *mdp5_cstate = to_mdp5_crtc_state(crtc->state);
}
static int mdp5_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void mdp5_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
DBG("%s: begin", crtc->name);
}
static void mdp5_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mdp5_crtc *mdp5_crtc = to_mdp5_crtc(crtc);
struct mdp5_crtc_state *mdp5_cstate = to_mdp5_crtc_state(crtc->state);
* This acquires the modeset lock set aside for global state, creates
* a new duplicated private object state.
*/
-struct mdp5_global_state *mdp5_get_global_state(struct drm_atomic_state *s)
+struct mdp5_global_state *mdp5_get_global_state(struct drm_atomic_commit *s)
{
struct msm_drm_private *priv = s->dev->dev_private;
struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms));
pm_runtime_put_sync(&mdp5_kms->pdev->dev);
}
-static void mdp5_prepare_commit(struct msm_kms *kms, struct drm_atomic_state *state)
+static void mdp5_prepare_commit(struct msm_kms *kms, struct drm_atomic_commit *state)
{
struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms));
struct mdp5_global_state *global_state;
struct mdp5_global_state {
struct drm_private_state base;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct mdp5_kms *mdp5_kms;
struct mdp5_hw_pipe_state hwpipe;
};
struct mdp5_global_state * mdp5_get_existing_global_state(struct mdp5_kms *mdp5_kms);
-struct mdp5_global_state *__must_check mdp5_get_global_state(struct drm_atomic_state *s);
+struct mdp5_global_state *__must_check mdp5_get_global_state(struct drm_atomic_commit *s);
/* Atomic plane state. Subclasses the base drm_plane_state in order to
* track assigned hwpipe and hw specific state.
return -1;
}
-int mdp5_mixer_assign(struct drm_atomic_state *s, struct drm_crtc *crtc,
+int mdp5_mixer_assign(struct drm_atomic_commit *s, struct drm_crtc *crtc,
uint32_t caps, struct mdp5_hw_mixer **mixer,
struct mdp5_hw_mixer **r_mixer)
{
return 0;
}
-int mdp5_mixer_release(struct drm_atomic_state *s, struct mdp5_hw_mixer *mixer)
+int mdp5_mixer_release(struct drm_atomic_commit *s, struct mdp5_hw_mixer *mixer)
{
struct mdp5_global_state *global_state = mdp5_get_global_state(s);
struct mdp5_hw_mixer_state *new_state;
struct mdp5_hw_mixer *mdp5_mixer_init(struct drm_device *dev,
const struct mdp5_lm_instance *lm);
-int mdp5_mixer_assign(struct drm_atomic_state *s, struct drm_crtc *crtc,
+int mdp5_mixer_assign(struct drm_atomic_commit *s, struct drm_crtc *crtc,
uint32_t caps, struct mdp5_hw_mixer **mixer,
struct mdp5_hw_mixer **r_mixer);
-int mdp5_mixer_release(struct drm_atomic_state *s,
+int mdp5_mixer_release(struct drm_atomic_commit *s,
struct mdp5_hw_mixer *mixer);
#endif /* __MDP5_LM_H__ */
#include "mdp5_kms.h"
-int mdp5_pipe_assign(struct drm_atomic_state *s, struct drm_plane *plane,
+int mdp5_pipe_assign(struct drm_atomic_commit *s, struct drm_plane *plane,
uint32_t caps, uint32_t blkcfg,
struct mdp5_hw_pipe **hwpipe,
struct mdp5_hw_pipe **r_hwpipe)
return 0;
}
-int mdp5_pipe_release(struct drm_atomic_state *s, struct mdp5_hw_pipe *hwpipe)
+int mdp5_pipe_release(struct drm_atomic_commit *s, struct mdp5_hw_pipe *hwpipe)
{
struct msm_drm_private *priv = s->dev->dev_private;
struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(priv->kms));
struct drm_plane *hwpipe_to_plane[SSPP_MAX];
};
-int mdp5_pipe_assign(struct drm_atomic_state *s, struct drm_plane *plane,
+int mdp5_pipe_assign(struct drm_atomic_commit *s, struct drm_plane *plane,
uint32_t caps, uint32_t blkcfg,
struct mdp5_hw_pipe **hwpipe,
struct mdp5_hw_pipe **r_hwpipe);
-int mdp5_pipe_release(struct drm_atomic_state *s, struct mdp5_hw_pipe *hwpipe);
+int mdp5_pipe_release(struct drm_atomic_commit *s, struct mdp5_hw_pipe *hwpipe);
struct mdp5_hw_pipe *mdp5_pipe_init(struct drm_device *dev,
enum mdp5_pipe pipe,
}
static int mdp5_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void mdp5_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static int mdp5_plane_atomic_async_check(struct drm_plane *plane,
- struct drm_atomic_state *state, bool flip)
+ struct drm_atomic_commit *state, bool flip)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void mdp5_plane_atomic_async_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
struct list_head blocks;
- struct drm_atomic_state *atomic_state;
+ struct drm_atomic_commit *atomic_state;
struct timespec64 time;
};
struct msm_disp_state_block *block, *tmp;
if (disp_state->atomic_state) {
- drm_atomic_state_put(disp_state->atomic_state);
+ drm_atomic_commit_put(disp_state->atomic_state);
disp_state->atomic_state = NULL;
}
}
void msm_dp_bridge_atomic_enable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge);
struct msm_dp *dp = msm_dp_bridge->msm_dp_display;
}
void msm_dp_bridge_atomic_disable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge);
struct msm_dp *dp = msm_dp_bridge->msm_dp_display;
}
void msm_dp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge);
struct msm_dp *dp = msm_dp_bridge->msm_dp_display;
}
static void msm_edp_bridge_atomic_enable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_crtc_state;
}
static void msm_edp_bridge_atomic_disable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state = NULL, *old_crtc_state = NULL;
}
static void msm_edp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state = NULL;
bool yuv_supported);
void msm_dp_bridge_atomic_enable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void msm_dp_bridge_atomic_disable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void msm_dp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
enum drm_mode_status msm_dp_bridge_mode_valid(struct drm_bridge *bridge,
const struct drm_display_info *info,
const struct drm_display_mode *mode);
const struct drm_display_mode *mode);
static void msm_hdmi_bridge_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
struct hdmi *hdmi = hdmi_bridge->hdmi;
}
static void msm_hdmi_bridge_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
struct hdmi *hdmi = hdmi_bridge->hdmi;
kthread_destroy_worker(timer->worker);
}
-static bool can_do_async(struct drm_atomic_state *state,
+static bool can_do_async(struct drm_atomic_commit *state,
struct drm_crtc **async_crtc)
{
struct drm_connector_state *connector_state;
* can be used with for_each_crtc_mask() iterator, to iterate
* effected crtcs without needing to preserve the atomic state.
*/
-static unsigned get_crtc_mask(struct drm_atomic_state *state)
+static unsigned get_crtc_mask(struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state;
struct drm_crtc *crtc;
return mask;
}
-int msm_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
+int msm_atomic_check(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct msm_drm_private *priv = dev->dev_private;
struct msm_kms *kms = priv->kms;
return drm_atomic_helper_check(dev, state);
}
-void msm_atomic_commit_tail(struct drm_atomic_state *state)
+void msm_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct msm_drm_private *priv = dev->dev_private;
int msm_atomic_init_pending_timer(struct msm_pending_timer *timer,
struct msm_kms *kms, int crtc_idx);
void msm_atomic_destroy_pending_timer(struct msm_pending_timer *timer);
-void msm_atomic_commit_tail(struct drm_atomic_state *state);
-int msm_atomic_check(struct drm_device *dev, struct drm_atomic_state *state);
-struct drm_atomic_state *msm_atomic_state_alloc(struct drm_device *dev);
+void msm_atomic_commit_tail(struct drm_atomic_commit *state);
+int msm_atomic_check(struct drm_device *dev, struct drm_atomic_commit *state);
+struct drm_atomic_commit *msm_atomic_state_alloc(struct drm_device *dev);
int msm_crtc_enable_vblank(struct drm_crtc *crtc);
void msm_crtc_disable_vblank(struct drm_crtc *crtc);
*
* Verify if the commit requires a full modeset on one of CRTCs.
*/
- int (*check_mode_changed)(struct msm_kms *kms, struct drm_atomic_state *state);
+ int (*check_mode_changed)(struct msm_kms *kms, struct drm_atomic_commit *state);
/**
* Prepare for atomic commit. This is called after any previous
* (async or otherwise) commit has completed.
*/
- void (*prepare_commit)(struct msm_kms *kms, struct drm_atomic_state *state);
+ void (*prepare_commit)(struct msm_kms *kms, struct drm_atomic_commit *state);
/**
* Flush an atomic commit. This is called after the hardware
}
static int lcdif_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
}
static void lcdif_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
struct drm_pending_vblank_event *event;
}
static void lcdif_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
struct drm_crtc_state *new_cstate = drm_atomic_get_new_crtc_state(state, crtc);
}
static void lcdif_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lcdif_drm_private *lcdif = to_lcdif_drm_private(crtc->dev);
struct drm_device *drm = lcdif->drm;
*/
static int lcdif_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void lcdif_plane_primary_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct lcdif_drm_private *lcdif = to_lcdif_drm_private(plane->dev);
struct drm_plane_state *new_pstate = drm_atomic_get_new_plane_state(state,
}
static int mxsfb_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void mxsfb_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_pending_vblank_event *event;
}
static void mxsfb_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mxsfb_drm_private *mxsfb = to_mxsfb_drm_private(crtc->dev);
struct drm_plane_state *new_pstate = drm_atomic_get_new_plane_state(state,
}
static void mxsfb_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mxsfb_drm_private *mxsfb = to_mxsfb_drm_private(crtc->dev);
struct drm_device *drm = mxsfb->drm;
*/
static int mxsfb_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void mxsfb_plane_primary_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mxsfb_drm_private *mxsfb = to_mxsfb_drm_private(plane->dev);
struct drm_plane_state *new_pstate = drm_atomic_get_new_plane_state(state,
}
static void mxsfb_plane_overlay_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_pstate = drm_atomic_get_old_plane_state(state,
plane);
}
static void mxsfb_plane_overlay_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct mxsfb_drm_private *mxsfb = to_mxsfb_drm_private(plane->dev);
struct nouveau_encoder;
struct nv50_atom {
- struct drm_atomic_state state;
+ struct drm_atomic_commit state;
struct list_head outp;
bool lock_core;
};
static inline struct nv50_head_atom *
-nv50_head_atom_get(struct drm_atomic_state *state, struct drm_crtc *crtc)
+nv50_head_atom_get(struct drm_atomic_commit *state, struct drm_crtc *crtc)
{
struct drm_crtc_state *statec = drm_atomic_get_crtc_state(state, crtc);
}
static inline struct nv50_head_atom *
-nv50_head_atom_get_new(struct drm_atomic_state *state, struct drm_crtc *crtc)
+nv50_head_atom_get_new(struct drm_atomic_commit *state, struct drm_crtc *crtc)
{
struct drm_crtc_state *statec = drm_atomic_get_new_crtc_state(state, crtc);
head->base.index, ret);
}
-void nv50_crc_atomic_stop_reporting(struct drm_atomic_state *state)
+void nv50_crc_atomic_stop_reporting(struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state;
struct drm_crtc *crtc;
}
}
-void nv50_crc_atomic_init_notifier_contexts(struct drm_atomic_state *state)
+void nv50_crc_atomic_init_notifier_contexts(struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_crtc_state;
struct drm_crtc *crtc;
}
}
-void nv50_crc_atomic_release_notifier_contexts(struct drm_atomic_state *state)
+void nv50_crc_atomic_release_notifier_contexts(struct drm_atomic_commit *state)
{
const struct nv50_crc_func *func =
nv50_disp(state->dev)->core->func->crc;
}
}
-void nv50_crc_atomic_start_reporting(struct drm_atomic_state *state)
+void nv50_crc_atomic_start_reporting(struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state;
struct drm_crtc *crtc;
int nv50_crc_set_source(struct drm_crtc *crtc, const char *source_str)
{
struct drm_device *dev = crtc->dev;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_modeset_acquire_ctx ctx;
struct nv50_head *head = nv50_head(crtc);
struct nv50_crc *crc = &head->crc;
ctx_flags |= DRM_MODESET_ACQUIRE_INTERRUPTIBLE;
drm_modeset_acquire_init(&ctx, ctx_flags);
- state = drm_atomic_state_alloc(dev);
+ state = drm_atomic_commit_alloc(dev);
if (!state) {
ret = -ENOMEM;
goto out_acquire_fini;
for (i = 0; i < ARRAY_SIZE(crc->ctx); i++)
nv50_crc_ctx_fini(&crc->ctx[i]);
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
out_acquire_fini:
drm_modeset_acquire_fini(&ctx);
return ret;
deadlock:
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
int nv50_crc_atomic_check_head(struct nv50_head *, struct nv50_head_atom *,
struct nv50_head_atom *);
void nv50_crc_atomic_check_outp(struct nv50_atom *atom);
-void nv50_crc_atomic_stop_reporting(struct drm_atomic_state *);
-void nv50_crc_atomic_init_notifier_contexts(struct drm_atomic_state *);
-void nv50_crc_atomic_release_notifier_contexts(struct drm_atomic_state *);
-void nv50_crc_atomic_start_reporting(struct drm_atomic_state *);
+void nv50_crc_atomic_stop_reporting(struct drm_atomic_commit *);
+void nv50_crc_atomic_init_notifier_contexts(struct drm_atomic_commit *);
+void nv50_crc_atomic_release_notifier_contexts(struct drm_atomic_commit *);
+void nv50_crc_atomic_start_reporting(struct drm_atomic_commit *);
void nv50_crc_atomic_set(struct nv50_head *, struct nv50_head_atom *);
void nv50_crc_atomic_clr(struct nv50_head *);
struct nv50_head_atom *armh) { return 0; }
static inline void nv50_crc_atomic_check_outp(struct nv50_atom *atom) {}
static inline void
-nv50_crc_atomic_stop_reporting(struct drm_atomic_state *state) {}
+nv50_crc_atomic_stop_reporting(struct drm_atomic_commit *state) {}
static inline void
-nv50_crc_atomic_init_notifier_contexts(struct drm_atomic_state *state) {}
+nv50_crc_atomic_init_notifier_contexts(struct drm_atomic_commit *state) {}
static inline void
-nv50_crc_atomic_release_notifier_contexts(struct drm_atomic_state *state) {}
+nv50_crc_atomic_release_notifier_contexts(struct drm_atomic_commit *state) {}
static inline void
-nv50_crc_atomic_start_reporting(struct drm_atomic_state *state) {}
+nv50_crc_atomic_start_reporting(struct drm_atomic_commit *state) {}
static inline void
nv50_crc_atomic_set(struct nv50_head *head, struct nv50_head_atom *state) {}
static inline void
}
struct nouveau_connector *
-nv50_outp_get_new_connector(struct drm_atomic_state *state, struct nouveau_encoder *outp)
+nv50_outp_get_new_connector(struct drm_atomic_commit *state, struct nouveau_encoder *outp)
{
struct drm_connector *connector;
struct drm_connector_state *connector_state;
}
struct nouveau_connector *
-nv50_outp_get_old_connector(struct drm_atomic_state *state, struct nouveau_encoder *outp)
+nv50_outp_get_old_connector(struct drm_atomic_commit *state, struct nouveau_encoder *outp)
{
struct drm_connector *connector;
struct drm_connector_state *connector_state;
}
static struct nouveau_crtc *
-nv50_outp_get_new_crtc(const struct drm_atomic_state *state, const struct nouveau_encoder *outp)
+nv50_outp_get_new_crtc(const struct drm_atomic_commit *state, const struct nouveau_encoder *outp)
{
struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state;
* DAC
*****************************************************************************/
static void
-nv50_dac_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_dac_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
struct nv50_core *core = nv50_disp(encoder->dev)->core;
}
static void
-nv50_dac_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_dac_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
struct nouveau_crtc *nv_crtc = nv50_outp_get_new_crtc(state, nv_encoder);
static void
nv50_audio_enable(struct drm_encoder *encoder, struct nouveau_crtc *nv_crtc,
- struct nouveau_connector *nv_connector, struct drm_atomic_state *state,
+ struct nouveau_connector *nv_connector, struct drm_atomic_commit *state,
struct drm_display_mode *mode)
{
struct nouveau_drm *drm = nouveau_drm(encoder->dev);
*****************************************************************************/
static void
nv50_hdmi_enable(struct drm_encoder *encoder, struct nouveau_crtc *nv_crtc,
- struct nouveau_connector *nv_connector, struct drm_atomic_state *state,
+ struct nouveau_connector *nv_connector, struct drm_atomic_commit *state,
struct drm_display_mode *mode, bool hda)
{
struct nouveau_drm *drm = nouveau_drm(encoder->dev);
}
static void
-nv50_msto_cleanup(struct drm_atomic_state *state,
+nv50_msto_cleanup(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_state *new_mst_state,
struct drm_dp_mst_topology_mgr *mgr,
struct nv50_msto *msto)
}
static void
-nv50_msto_prepare(struct drm_atomic_state *state,
+nv50_msto_prepare(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_state *mst_state,
struct drm_dp_mst_topology_mgr *mgr,
struct nv50_msto *msto)
struct drm_crtc_state *crtc_state,
struct drm_connector_state *conn_state)
{
- struct drm_atomic_state *state = crtc_state->state;
+ struct drm_atomic_commit *state = crtc_state->state;
struct drm_connector *connector = conn_state->connector;
struct drm_dp_mst_topology_state *mst_state;
struct nv50_mstc *mstc = nv50_mstc(connector);
}
static void
-nv50_msto_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_msto_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nv50_msto *msto = nv50_msto(encoder);
struct nv50_head *head = msto->head;
}
static void
-nv50_msto_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_msto_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nv50_msto *msto = nv50_msto(encoder);
struct nv50_mstc *mstc = msto->mstc;
static struct drm_encoder *
nv50_mstc_atomic_best_encoder(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *connector_state = drm_atomic_get_new_connector_state(state,
connector);
static int
nv50_mstc_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct nv50_mstc *mstc = nv50_mstc(connector);
struct drm_dp_mst_topology_mgr *mgr = &mstc->mstm->mgr;
}
static void
-nv50_mstm_cleanup(struct drm_atomic_state *state,
+nv50_mstm_cleanup(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_state *mst_state,
struct nv50_mstm *mstm)
{
}
static void
-nv50_mstm_prepare(struct drm_atomic_state *state,
+nv50_mstm_prepare(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_state *mst_state,
struct nv50_mstm *mstm)
{
* fixed time delay from the vbios…
*/
static void
-nv50_sor_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_sor_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
struct nv50_head *head = nv50_head(nv_encoder->crtc);
}
static void
-nv50_sor_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_sor_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
struct nouveau_crtc *nv_crtc = nv50_outp_get_new_crtc(state, nv_encoder);
}
static void
-nv50_pior_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_pior_atomic_disable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
struct nv50_core *core = nv50_disp(encoder->dev)->core;
}
static void
-nv50_pior_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_state *state)
+nv50_pior_atomic_enable(struct drm_encoder *encoder, struct drm_atomic_commit *state)
{
struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
struct nouveau_crtc *nv_crtc = nv50_outp_get_new_crtc(state, nv_encoder);
*****************************************************************************/
static void
-nv50_disp_atomic_commit_core(struct drm_atomic_state *state, u32 *interlock)
+nv50_disp_atomic_commit_core(struct drm_atomic_commit *state, u32 *interlock)
{
struct drm_dp_mst_topology_mgr *mgr;
struct drm_dp_mst_topology_state *mst_state;
}
static void
-nv50_disp_atomic_commit_wndw(struct drm_atomic_state *state, u32 *interlock)
+nv50_disp_atomic_commit_wndw(struct drm_atomic_commit *state, u32 *interlock)
{
struct drm_plane_state *new_plane_state;
struct drm_plane *plane;
}
static void
-nv50_disp_atomic_commit_tail(struct drm_atomic_state *state)
+nv50_disp_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct drm_crtc_state *new_crtc_state, *old_crtc_state;
drm_atomic_helper_commit_hw_done(state);
drm_atomic_helper_cleanup_planes(dev, state);
drm_atomic_helper_commit_cleanup_done(state);
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
/* Drop the RPM ref we got from nv50_disp_atomic_commit() */
pm_runtime_mark_last_busy(dev->dev);
static void
nv50_disp_atomic_commit_work(struct work_struct *work)
{
- struct drm_atomic_state *state =
+ struct drm_atomic_commit *state =
container_of(work, typeof(*state), commit_work);
nv50_disp_atomic_commit_tail(state);
}
static int
nv50_disp_atomic_commit(struct drm_device *dev,
- struct drm_atomic_state *state, bool nonblock)
+ struct drm_atomic_commit *state, bool nonblock)
{
struct drm_plane_state *new_plane_state;
struct drm_plane *plane;
nv50_wndw_ntfy_enable(wndw, asyw);
}
- drm_atomic_state_get(state);
+ drm_atomic_commit_get(state);
/*
* Grab another RPM ref for the commit tail, which will release the
}
static int
-nv50_disp_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
+nv50_disp_atomic_check(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct nv50_atom *atom = nv50_atom(state);
struct nv50_core *core = nv50_disp(dev)->core;
}
static void
-nv50_disp_atomic_state_clear(struct drm_atomic_state *state)
+nv50_disp_atomic_state_clear(struct drm_atomic_commit *state)
{
struct nv50_atom *atom = nv50_atom(state);
struct nv50_outp_atom *outp, *outt;
kfree(outp);
}
- drm_atomic_state_default_clear(state);
+ drm_atomic_commit_default_clear(state);
}
static void
-nv50_disp_atomic_state_free(struct drm_atomic_state *state)
+nv50_disp_atomic_state_free(struct drm_atomic_commit *state)
{
struct nv50_atom *atom = nv50_atom(state);
- drm_atomic_state_default_release(&atom->state);
+ drm_atomic_commit_default_release(&atom->state);
kfree(atom);
}
-static struct drm_atomic_state *
+static struct drm_atomic_commit *
nv50_disp_atomic_state_alloc(struct drm_device *dev)
{
struct nv50_atom *atom;
if (!(atom = kzalloc_obj(*atom)) ||
- drm_atomic_state_init(dev, &atom->state) < 0) {
+ drm_atomic_commit_init(dev, &atom->state) < 0) {
kfree(atom);
return NULL;
}
}
static int
-nv50_head_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state)
+nv50_head_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
static int
nv50_wndw_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static int
-nouveau_connector_atomic_check(struct drm_connector *connector, struct drm_atomic_state *state)
+nouveau_connector_atomic_check(struct drm_connector *connector, struct drm_atomic_commit *state)
{
struct nouveau_connector *nv_conn = nouveau_connector(connector);
struct drm_connector_state *conn_state =
struct drm_property *vibrant_hue_property;
struct drm_property *color_vibrance_property;
- struct drm_atomic_state *suspend;
+ struct drm_atomic_commit *suspend;
const u64 *format_modifiers;
};
unsigned *clock);
struct nouveau_connector *
-nv50_outp_get_new_connector(struct drm_atomic_state *state, struct nouveau_encoder *outp);
+nv50_outp_get_new_connector(struct drm_atomic_commit *state, struct nouveau_encoder *outp);
struct nouveau_connector *
-nv50_outp_get_old_connector(struct drm_atomic_state *state, struct nouveau_encoder *outp);
+nv50_outp_get_old_connector(struct drm_atomic_commit *state, struct nouveau_encoder *outp);
int nv50_mstm_detect(struct nouveau_encoder *encoder);
void nv50_mstm_remove(struct nv50_mstm *mstm);
}
static void hdmi4_bridge_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
struct drm_connector_state *conn_state;
}
static void hdmi4_bridge_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
unsigned long flags;
}
static void hdmi5_bridge_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
struct drm_connector_state *conn_state;
}
static void hdmi5_bridge_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_hdmi *hdmi = drm_bridge_to_hdmi(bridge);
unsigned long flags;
}
static void omap_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_drm_private *priv = crtc->dev->dev_private;
struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
}
static void omap_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_drm_private *priv = crtc->dev->dev_private;
struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
}
static int omap_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void omap_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
}
static void omap_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_drm_private *priv = crtc->dev->dev_private;
struct omap_crtc *omap_crtc = to_omap_crtc(crtc);
*/
static void omap_atomic_wait_for_completion(struct drm_device *dev,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_crtc_state *new_crtc_state;
struct drm_crtc *crtc;
}
}
-static void omap_atomic_commit_tail(struct drm_atomic_state *old_state)
+static void omap_atomic_commit_tail(struct drm_atomic_commit *old_state)
{
struct drm_device *dev = old_state->dev;
struct omap_drm_private *priv = dev->dev_private;
dispc_runtime_put(priv->dispc);
}
-static int drm_atomic_state_normalized_zpos_cmp(const void *a, const void *b)
+static int drm_atomic_commit_normalized_zpos_cmp(const void *a, const void *b)
{
const struct drm_plane_state *sa = *(struct drm_plane_state **)a;
const struct drm_plane_state *sb = *(struct drm_plane_state **)b;
* planes zpos is consistent.
*/
static int omap_atomic_update_normalize_zpos(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *old_state, *new_state;
}
sort(states, n, sizeof(*states),
- drm_atomic_state_normalized_zpos_cmp, NULL);
+ drm_atomic_commit_normalized_zpos_cmp, NULL);
for (i = 0, inc = 0; i < n; i++) {
plane = states[i]->plane;
}
static int omap_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int ret;
* a new duplicated private object state.
*/
struct omap_global_state *__must_check
-omap_get_global_state(struct drm_atomic_state *s)
+omap_get_global_state(struct drm_atomic_commit *s)
{
struct omap_drm_private *priv = s->dev->dev_private;
struct drm_private_state *priv_state;
void omap_debugfs_init(struct drm_minor *minor);
-struct omap_global_state * __must_check omap_get_global_state(struct drm_atomic_state *s);
+struct omap_global_state * __must_check omap_get_global_state(struct drm_atomic_commit *s);
struct omap_global_state *omap_get_existing_global_state(struct omap_drm_private *priv);
* This should be called from the plane atomic_check() in order to prepare the
* next global overlay_map to be enabled when atomic transaction is valid.
*/
-int omap_overlay_assign(struct drm_atomic_state *s, struct drm_plane *plane,
+int omap_overlay_assign(struct drm_atomic_commit *s, struct drm_plane *plane,
u32 caps, u32 fourcc, struct omap_hw_overlay **overlay,
struct omap_hw_overlay **r_overlay)
{
* This should be called from the plane atomic_check() in order to prepare the
* next global overlay_map to be enabled when atomic transaction is valid.
*/
-void omap_overlay_release(struct drm_atomic_state *s, struct omap_hw_overlay *overlay)
+void omap_overlay_release(struct drm_atomic_commit *s, struct omap_hw_overlay *overlay)
{
/* Get the global state of the current atomic transaction */
struct omap_global_state *state = omap_get_global_state(s);
int omap_hwoverlays_init(struct omap_drm_private *priv);
void omap_hwoverlays_destroy(struct omap_drm_private *priv);
-int omap_overlay_assign(struct drm_atomic_state *s, struct drm_plane *plane,
+int omap_overlay_assign(struct drm_atomic_commit *s, struct drm_plane *plane,
u32 caps, u32 fourcc, struct omap_hw_overlay **overlay,
struct omap_hw_overlay **r_overlay);
-void omap_overlay_release(struct drm_atomic_state *s, struct omap_hw_overlay *overlay);
+void omap_overlay_release(struct drm_atomic_commit *s, struct omap_hw_overlay *overlay);
void omap_overlay_update_state(struct omap_drm_private *priv, struct omap_hw_overlay *overlay);
#endif /* __OMAPDRM_OVERLAY_H__ */
}
static void omap_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_drm_private *priv = plane->dev->dev_private;
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
}
static void omap_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct omap_drm_private *priv = plane->dev->dev_private;
struct omap_plane *omap_plane = to_omap_plane(plane);
#define FRAC_16_16(mult, div) (((mult) << 16) / (div))
static int omap_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void qxl_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
};
static void qxl_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
qxl_crtc_update_monitors_config(crtc, "enable");
}
static void qxl_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_off(crtc);
};
static int qxl_primary_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void qxl_primary_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void qxl_primary_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void qxl_cursor_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void qxl_cursor_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
*/
static int rcar_du_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void rcar_du_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
struct rcar_du_crtc_state *rstate = to_rcar_crtc_state(crtc->state);
}
static void rcar_du_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void rcar_du_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
}
static void rcar_du_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
struct drm_device *dev = rcrtc->crtc.dev;
struct rcar_du_crtc *rcrtc = to_rcar_crtc(crtc);
struct drm_modeset_acquire_ctx ctx;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
enum vsp1_du_crc_source source;
unsigned int index;
int ret;
/* Perform an atomic commit to set the CRC source. */
drm_modeset_acquire_init(&ctx, 0);
- state = drm_atomic_state_alloc(crtc->dev);
+ state = drm_atomic_commit_alloc(crtc->dev);
if (!state) {
ret = -ENOMEM;
goto unlock;
}
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry;
}
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
unlock:
drm_modeset_drop_locks(&ctx);
*/
static int rcar_du_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_du_device *rcdu = to_rcar_du_device(dev);
int ret;
return rcar_du_atomic_check_planes(dev, state);
}
-static void rcar_du_atomic_commit_tail(struct drm_atomic_state *old_state)
+static void rcar_du_atomic_commit_tail(struct drm_atomic_commit *old_state)
{
struct drm_device *dev = old_state->dev;
struct rcar_du_device *rcdu = to_rcar_du_device(dev);
}
int rcar_du_atomic_check_planes(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_du_device *rcdu = to_rcar_du_device(dev);
unsigned int group_freed_planes[RCAR_DU_MAX_GROUPS] = { 0, };
}
static int rcar_du_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void rcar_du_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
}
int rcar_du_atomic_check_planes(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int __rcar_du_plane_atomic_check(struct drm_plane *plane,
struct drm_plane_state *state,
}
static int rcar_du_vsp_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void rcar_du_vsp_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
}
static void rcar_lvds_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_crtc *crtc,
struct drm_connector *connector)
{
*/
static void rcar_lvds_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_crtc *crtc;
}
static void rcar_lvds_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_lvds *lvds = bridge_to_rcar_lvds(bridge);
}
static void rcar_mipi_dsi_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_mipi_dsi *dsi = bridge_to_rcar_mipi_dsi(bridge);
}
static void rcar_mipi_dsi_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_mipi_dsi *dsi = bridge_to_rcar_mipi_dsi(bridge);
}
void rcar_mipi_dsi_pclk_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rcar_mipi_dsi *dsi = bridge_to_rcar_mipi_dsi(bridge);
const struct drm_display_mode *mode;
#ifndef __RCAR_MIPI_DSI_H__
#define __RCAR_MIPI_DSI_H__
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_bridge;
#if IS_ENABLED(CONFIG_DRM_RCAR_MIPI_DSI)
void rcar_mipi_dsi_pclk_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void rcar_mipi_dsi_pclk_disable(struct drm_bridge *bridge);
#else
static inline void rcar_mipi_dsi_pclk_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
}
*/
static void rzg2l_du_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rzg2l_du_crtc *rcrtc = to_rzg2l_crtc(crtc);
}
static void rzg2l_du_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rzg2l_du_crtc *rcrtc = to_rzg2l_crtc(crtc);
}
static void rzg2l_du_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rzg2l_du_crtc *rcrtc = to_rzg2l_crtc(crtc);
struct drm_device *dev = rcrtc->crtc.dev;
}
static int rzg2l_du_vsp_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void rzg2l_du_vsp_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
}
static void rzg2l_mipi_dsi_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rzg2l_mipi_dsi *dsi = bridge_to_rzg2l_mipi_dsi(bridge);
const struct drm_display_mode *mode;
}
static void rzg2l_mipi_dsi_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rzg2l_mipi_dsi *dsi = bridge_to_rzg2l_mipi_dsi(bridge);
int ret;
}
static void rzg2l_mipi_dsi_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rzg2l_mipi_dsi *dsi = bridge_to_rzg2l_mipi_dsi(bridge);
}
static void rzg2l_mipi_dsi_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rzg2l_mipi_dsi *dsi = bridge_to_rzg2l_mipi_dsi(bridge);
}
static void shmob_drm_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct shmob_drm_crtc *scrtc = to_shmob_crtc(crtc);
struct shmob_drm_device *sdev = to_shmob_device(crtc->dev);
}
static void shmob_drm_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct shmob_drm_crtc *scrtc = to_shmob_crtc(crtc);
struct shmob_drm_device *sdev = to_shmob_device(crtc->dev);
}
static void shmob_drm_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_pending_vblank_event *event;
struct drm_device *dev = crtc->dev;
}
static int shmob_drm_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct shmob_drm_plane_state *sstate = to_shmob_plane_state(new_plane_state);
}
static void shmob_drm_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct shmob_drm_plane *splane = to_shmob_plane(plane);
}
static void shmob_drm_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct shmob_drm_device *sdev = to_shmob_device(plane->dev);
static
struct drm_crtc *rockchip_dp_drm_get_new_crtc(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector *connector;
struct drm_connector_state *conn_state;
}
static void rockchip_dp_drm_encoder_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rockchip_dp_device *dp = encoder_to_dp(encoder);
struct drm_crtc *crtc;
}
static void rockchip_dp_drm_encoder_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rockchip_dp_device *dp = encoder_to_dp(encoder);
struct drm_crtc *crtc;
}
}
-static void cdn_dp_bridge_atomic_enable(struct drm_bridge *bridge, struct drm_atomic_state *state)
+static void cdn_dp_bridge_atomic_enable(struct drm_bridge *bridge, struct drm_atomic_commit *state)
{
struct cdn_dp_device *dp = bridge_to_dp(bridge);
struct drm_connector *connector;
mutex_unlock(&dp->lock);
}
-static void cdn_dp_bridge_atomic_disable(struct drm_bridge *bridge, struct drm_atomic_state *state)
+static void cdn_dp_bridge_atomic_disable(struct drm_bridge *bridge, struct drm_atomic_commit *state)
{
struct cdn_dp_device *dp = bridge_to_dp(bridge);
int ret;
};
static void dw_mipi_dsi2_encoder_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct dw_mipi_dsi2_rockchip *dsi2 = to_dsi2(encoder);
u32 color_depth;
struct drm_connector_state *conn_state)
{
struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state);
- struct drm_atomic_state *state = conn_state->state;
+ struct drm_atomic_commit *state = conn_state->state;
struct drm_display_info *di = &conn_state->connector->display_info;
struct drm_bridge *bridge = drm_bridge_chain_get_first_bridge(encoder);
struct drm_bridge_state *bridge_state = drm_atomic_get_new_bridge_state(state, bridge);
}
static int rk3066_hdmi_setup(struct rk3066_hdmi *hdmi,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_bridge *bridge = &hdmi->bridge;
struct drm_connector *connector;
}
static void rk3066_hdmi_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rk3066_hdmi *hdmi = bridge_to_rk3066_hdmi(bridge);
struct drm_connector_state *conn_state;
}
static void rk3066_hdmi_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct rk3066_hdmi *hdmi = bridge_to_rk3066_hdmi(bridge);
}
static void vop_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vop *vop = to_vop(crtc);
}
static int vop_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void vop_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void vop_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static int vop_plane_atomic_async_check(struct drm_plane *plane,
- struct drm_atomic_state *state, bool flip)
+ struct drm_atomic_commit *state, bool flip)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void vop_plane_atomic_async_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void vop_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void vop_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static int vop_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void vop_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
- struct drm_atomic_state *old_state = old_crtc_state->state;
+ struct drm_atomic_commit *old_state = old_crtc_state->state;
struct drm_plane_state *old_plane_state, *new_plane_state;
struct vop *vop = to_vop(crtc);
struct drm_plane *plane;
}
static void vop2_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vop2_video_port *vp = to_vop2_video_port(crtc);
struct vop2 *vop2 = vp->vop2;
}
static int vop2_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *astate)
+ struct drm_atomic_commit *astate)
{
struct drm_plane_state *pstate = drm_atomic_get_new_plane_state(astate, plane);
struct drm_framebuffer *fb = pstate->fb;
}
static void vop2_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_pstate = NULL;
struct vop2_win *win = to_vop2_win(plane);
}
static void vop2_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *pstate = plane->state;
struct drm_crtc *crtc = pstate->crtc;
}
static void vop2_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vop2_video_port *vp = to_vop2_video_port(crtc);
struct vop2 *vop2 = vp->vop2;
static int vop2_crtc_atomic_check_gamma(struct vop2_video_port *vp,
struct drm_crtc *crtc,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
struct drm_crtc_state *crtc_state)
{
struct vop2 *vop2 = vp->vop2;
}
static int vop2_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vop2_video_port *vp = to_vop2_video_port(crtc);
struct drm_plane *plane;
}
static void vop2_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vop2_video_port *vp = to_vop2_video_port(crtc);
struct vop2 *vop2 = vp->vop2;
}
static void vop2_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
struct vop2_video_port *vp = to_vop2_video_port(crtc);
};
static int st7571_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc *new_crtc = new_plane_state->crtc;
}
static void st7571_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
}
static void st7571_primary_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct st7571_device *st7571 = drm_to_st7571(plane->dev);
*/
static void st7571_encoder_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct st7571_device *st7571 = drm_to_st7571(drm);
}
static void st7571_encoder_atomic_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct st7571_device *st7571 = drm_to_st7571(drm);
};
static void st7586_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = plane->state;
struct drm_shadow_plane_state *shadow_plane_state = to_drm_shadow_plane_state(plane_state);
};
static void st7586_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7586_device *st7586 = to_st7586_device(drm);
}
static void st7586_crtc_helper_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7586_device *st7586 = to_st7586_device(drm);
};
static void st7735r_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7735r_device *st7735r = to_st7735r_device(drm);
}
static int st7920_primary_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct st7920_device *st7920 = drm_to_st7920(drm);
}
static void st7920_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
static void st7920_primary_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct st7920_device *st7920 = drm_to_st7920(drm);
}
static int st7920_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
struct st7920_crtc_state *st7920_state = to_st7920_crtc_state(crtc_state);
}
static void st7920_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct st7920_device *st7920 = drm_to_st7920(drm);
}
static void st7920_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct spi7920_error err = {0};
struct drm_device *drm = crtc->dev;
}
static int ssd130x_primary_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static int ssd132x_primary_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static int ssd133x_primary_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc *crtc = plane_state->crtc;
}
static void ssd130x_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
static void ssd132x_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
static void ssd133x_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
static void ssd130x_primary_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static void ssd132x_primary_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static void ssd133x_primary_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static int ssd130x_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static int ssd132x_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static int ssd133x_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
};
static void ssd130x_encoder_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static void ssd132x_encoder_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static void ssd133x_encoder_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static void ssd130x_encoder_atomic_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct ssd130x_device *ssd130x = drm_to_ssd130x(drm);
}
static int sprd_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void sprd_plane_atomic_update(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
drm_plane);
}
static void sprd_plane_atomic_disable(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
drm_plane);
}
static void sprd_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sprd_dpu *dpu = to_sprd_crtc(crtc);
}
static void sprd_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sprd_dpu *dpu = to_sprd_crtc(crtc);
struct drm_device *drm = dpu->base.dev;
}
static void sprd_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sprd_dpu *dpu = to_sprd_crtc(crtc);
#include "sti_vtg.h"
static void sti_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
}
static void sti_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sti_mixer *mixer = to_sti_mixer(crtc);
}
static void sti_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm_dev = crtc->dev;
struct sti_mixer *mixer = to_sti_mixer(crtc);
}
static int sti_cursor_atomic_check(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
drm_plane);
}
static void sti_cursor_atomic_update(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *newstate = drm_atomic_get_new_plane_state(state,
drm_plane);
}
static void sti_cursor_atomic_disable(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *oldstate = drm_atomic_get_old_plane_state(state,
drm_plane);
}
static int sti_gdp_atomic_check(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
drm_plane);
}
static void sti_gdp_atomic_update(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *oldstate = drm_atomic_get_old_plane_state(state,
drm_plane);
}
static void sti_gdp_atomic_disable(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *oldstate = drm_atomic_get_old_plane_state(state,
drm_plane);
}
static int sti_hqvdp_atomic_check(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
drm_plane);
}
static void sti_hqvdp_atomic_update(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *oldstate = drm_atomic_get_old_plane_state(state,
drm_plane);
}
static void sti_hqvdp_atomic_disable(struct drm_plane *drm_plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *oldstate = drm_atomic_get_old_plane_state(state,
drm_plane);
{
struct drm_device *ddev = dev_get_drvdata(dev);
struct ltdc_device *ldev = ddev->dev_private;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
WARN_ON(ldev->suspend_state);
}
static void ltdc_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ltdc_device *ldev = crtc_to_ltdc(crtc);
struct drm_device *ddev = crtc->dev;
}
static void ltdc_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ltdc_device *ldev = crtc_to_ltdc(crtc);
struct drm_device *ddev = crtc->dev;
}
static void ltdc_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ltdc_device *ldev = crtc_to_ltdc(crtc);
struct drm_device *ddev = crtc->dev;
*/
static int ltdc_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void ltdc_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct ltdc_device *ldev = plane_to_ltdc(plane);
struct drm_plane_state *newstate = drm_atomic_get_new_plane_state(state,
}
static void ltdc_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *oldstate = drm_atomic_get_old_plane_state(state,
plane);
u32 fifo_threshold; /* fifo underrun threshold */
u32 transfer_err; /* transfer error counter */
struct fps_info plane_fpsi[LTDC_MAX_LAYER];
- struct drm_atomic_state *suspend_state;
+ struct drm_atomic_commit *suspend_state;
int crc_skip_count;
bool crc_active;
};
}
static int lvds_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
const struct drm_display_mode *panel_mode;
struct drm_connector_state *conn_state;
}
static void lvds_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct stm_lvds *lvds = bridge_to_stm_lvds(bridge);
struct drm_connector_state *conn_state;
}
static void lvds_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct stm_lvds *lvds = bridge_to_stm_lvds(bridge);
static void sun4i_backend_commit(struct sunxi_engine *engine,
struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
DRM_DEBUG_DRIVER("Committing changes\n");
{
struct drm_plane_state *plane_states[SUN4I_BACKEND_NUM_LAYERS] = { 0 };
struct sun4i_backend *backend = engine_to_sun4i_backend(engine);
- struct drm_atomic_state *state = crtc_state->state;
+ struct drm_atomic_commit *state = crtc_state->state;
struct drm_device *drm = state->dev;
struct drm_plane *plane;
unsigned int num_planes = 0;
}
static int sun4i_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void sun4i_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void sun4i_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
struct drm_pending_vblank_event *event = crtc->state->event;
}
static void sun4i_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
}
static void sun4i_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_encoder *encoder = sun4i_crtc_get_encoder(crtc);
struct sun4i_crtc *scrtc = drm_crtc_to_sun4i_crtc(crtc);
#include "sun4i_framebuffer.h"
static int sun4i_de_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int ret;
}
static void sun4i_hdmi_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sun4i_hdmi *hdmi = drm_encoder_to_sun4i_hdmi(encoder);
u32 val;
}
static void sun4i_hdmi_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
struct sun4i_hdmi *hdmi = drm_encoder_to_sun4i_hdmi(encoder);
}
static void sun4i_backend_layer_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void sun4i_backend_layer_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void sun4i_tv_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sun4i_tv *tv = drm_encoder_to_sun4i_tv(encoder);
struct sun4i_crtc *crtc = drm_crtc_to_sun4i_crtc(encoder->crtc);
}
static void sun4i_tv_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sun4i_tv *tv = drm_encoder_to_sun4i_tv(encoder);
struct sun4i_crtc *crtc = drm_crtc_to_sun4i_crtc(encoder->crtc);
static void sun8i_mixer_commit(struct sunxi_engine *engine,
struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sun8i_mixer *mixer = engine_to_sun8i_mixer(engine);
u32 bld_base = sun8i_blender_base(mixer);
}
static int sun8i_ui_layer_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
static void sun8i_ui_layer_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static int sun8i_vi_layer_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void sun8i_vi_layer_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
*/
void (*commit)(struct sunxi_engine *engine,
struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @layers_init:
static inline void
sunxi_engine_commit(struct sunxi_engine *engine,
struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
if (engine->ops && engine->ops->commit)
engine->ops->commit(engine, crtc, state);
int drm_sysfb_plane_helper_begin_fb_access(struct drm_plane *plane,
struct drm_plane_state *plane_state);
int drm_sysfb_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *new_state);
+ struct drm_atomic_commit *new_state);
void drm_sysfb_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_sysfb_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_sysfb_plane_helper_get_scanout_buffer(struct drm_plane *plane,
struct drm_scanout_buffer *sb);
enum drm_mode_status drm_sysfb_crtc_helper_mode_valid(struct drm_crtc *crtc,
const struct drm_display_mode *mode);
-int drm_sysfb_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *new_state);
+int drm_sysfb_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *new_state);
#define DRM_SYSFB_CRTC_HELPER_FUNCS \
.mode_valid = drm_sysfb_crtc_helper_mode_valid, \
EXPORT_SYMBOL(drm_sysfb_plane_helper_begin_fb_access);
int drm_sysfb_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
struct drm_sysfb_device *sysfb = to_drm_sysfb_device(plane->dev);
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane);
}
EXPORT_SYMBOL(drm_sysfb_plane_helper_atomic_check);
-void drm_sysfb_plane_helper_atomic_update(struct drm_plane *plane, struct drm_atomic_state *state)
+void drm_sysfb_plane_helper_atomic_update(struct drm_plane *plane, struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
EXPORT_SYMBOL(drm_sysfb_plane_helper_atomic_update);
void drm_sysfb_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
}
EXPORT_SYMBOL(drm_sysfb_crtc_helper_mode_valid);
-int drm_sysfb_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *new_state)
+int drm_sysfb_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *new_state)
{
struct drm_device *dev = crtc->dev;
struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
.destroy = drm_plane_cleanup,
};
-static void ofdrm_crtc_helper_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_state *state)
+static void ofdrm_crtc_helper_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct ofdrm_device *odev = ofdrm_device_of_dev(crtc->dev);
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
};
static int vesadrm_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *new_state)
+ struct drm_atomic_commit *new_state)
{
struct drm_sysfb_device *sysfb = to_drm_sysfb_device(plane->dev);
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(new_state, plane);
};
static void vesadrm_crtc_helper_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
};
static int tegra_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void tegra_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void tegra_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
};
static int tegra_cursor_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void tegra_cursor_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
}
static void tegra_cursor_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
tegra_dc_writel(dc, value, DC_DISP_DISP_WIN_OPTIONS);
}
-static int tegra_cursor_atomic_async_check(struct drm_plane *plane, struct drm_atomic_state *state,
+static int tegra_cursor_atomic_async_check(struct drm_plane *plane, struct drm_atomic_commit *state,
bool flip)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
}
static void tegra_cursor_atomic_async_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
struct tegra_dc *dc = to_tegra_dc(new_state->crtc);
static void
tegra_crtc_update_memory_bandwidth(struct drm_crtc *crtc,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
bool prepare_bandwidth_transition)
{
const struct tegra_plane_state *old_tegra_state, *new_tegra_state;
}
static void tegra_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tegra_dc *dc = to_tegra_dc(crtc);
u32 value;
}
static void tegra_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_display_mode *mode = &crtc->state->adjusted_mode;
struct tegra_dc_state *crtc_state = to_dc_state(crtc->state);
}
static void tegra_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
unsigned long flags;
}
static void tegra_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static int tegra_crtc_calculate_memory_bandwidth(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
ulong overlap_mask[TEGRA_DC_LEGACY_PLANES_NUM] = {}, mask;
u32 plane_peak_bw[TEGRA_DC_LEGACY_PLANES_NUM] = {};
}
static int tegra_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int err;
}
void tegra_crtc_atomic_post_commit(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
/*
* Display bandwidth is allowed to go down only once hardware state
struct clk *clk, unsigned long pclk,
unsigned int div);
void tegra_crtc_atomic_post_commit(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/* from rgb.c */
int tegra_dc_rgb_probe(struct tegra_dc *dc);
#define CDMA_GATHER_FETCHES_MAX_NB 16383
static int tegra_atomic_check(struct drm_device *drm,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int err;
};
static void tegra_atomic_post_commit(struct drm_device *drm,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct drm_crtc_state *old_crtc_state __maybe_unused;
struct drm_crtc *crtc;
tegra_crtc_atomic_post_commit(crtc, old_state);
}
-static void tegra_atomic_commit_tail(struct drm_atomic_state *old_state)
+static void tegra_atomic_commit_tail(struct drm_atomic_commit *old_state)
{
struct drm_device *drm = old_state->dev;
struct tegra_drm *tegra = drm->dev_private;
}
static int tegra_shared_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void tegra_shared_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void tegra_shared_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
static struct tegra_display_hub_state *
tegra_display_hub_get_state(struct tegra_display_hub *hub,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_private_state *priv;
}
int tegra_display_hub_atomic_check(struct drm_device *drm,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tegra_drm *tegra = drm->dev_private;
struct tegra_display_hub_state *hub_state;
}
void tegra_display_hub_atomic_commit(struct drm_device *drm,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tegra_drm *tegra = drm->dev_private;
struct tegra_display_hub *hub = tegra->hub;
enum drm_plane_type type);
int tegra_display_hub_atomic_check(struct drm_device *drm,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void tegra_display_hub_atomic_commit(struct drm_device *drm,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
#define DC_CMD_IHUB_COMMON_MISC_CTL 0x068
#define LATENCY_EVENT (1 << 3)
obj-$(CONFIG_DRM_KUNIT_TEST) += \
drm_atomic_test.o \
- drm_atomic_state_test.o \
+ drm_atomic_commit_test.o \
drm_bridge_test.o \
drm_cmdline_parser_test.o \
drm_connector_test.o \
// SPDX-License-Identifier: GPL-2.0
/*
- * Test cases for the drm_atomic_state helpers
+ * Test cases for the drm_atomic_commit helpers
*
* Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved.
*/
{
struct drm_device *drm = &priv->drm;
struct drm_crtc *crtc = priv->crtc;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
int ret;
struct drm_atomic_test_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector *old_conn, *new_conn;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_device *drm;
struct drm_connector_state *new_conn_state, *old_conn_state;
int ret, initial_modeset_count;
struct drm_atomic_test_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_device *drm;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc_state *crtc_state;
priv = drm_atomic_test_init_drm_components(test, false);
retry:
crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
ret = drm_atomic_helper_check_modeset(drm, state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
};
static void drm_test_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_bridge_priv *priv = bridge_to_priv(bridge);
}
static void drm_test_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_bridge_priv *priv = bridge_to_priv(bridge);
struct drm_bridge_init_priv *priv;
struct drm_bridge_state *curr_bridge_state;
struct drm_bridge_state *bridge_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_bridge *bridge;
struct drm_device *drm;
int ret;
ret = drm_atomic_commit(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
drm_modeset_backoff(&ctx);
goto retry_commit;
}
};
static void test_encoder_atomic_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_atomic_helper_connector_hdmi_priv *priv =
encoder_to_priv(encoder);
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *mode;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *mode;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *mode;
struct drm_connector *conn;
struct drm_device *drm;
enum drm_hdmi_broadcast_rgb broadcast_rgb;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *mode;
struct drm_connector *conn;
struct drm_device *drm;
retry_conn_state:
conn_state = drm_atomic_get_connector_state(state, conn);
if (PTR_ERR(conn_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
{
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_crtc_state *crtc_state;
struct drm_connector *conn;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_info *info;
struct drm_display_mode *preferred, *yuv420_only_mode;
struct drm_connector *conn;
retry_crtc_state:
crtc_state = drm_atomic_get_crtc_state(state, crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
struct drm_modeset_acquire_ctx ctx;
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
struct drm_crtc_state *crtc_state;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
struct drm_device *drm;
retry_crtc_state:
crtc_state = drm_atomic_get_crtc_state(state, crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
ret = drm_atomic_commit(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
{
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc_state *crtc_state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
retry_crtc_state:
crtc_state = drm_atomic_get_crtc_state(state, crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
ret = drm_atomic_commit(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
{
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector_state *new_conn_state;
struct drm_crtc_state *crtc_state;
struct drm_display_mode *preferred;
retry_conn_state:
new_conn_state = drm_atomic_get_connector_state(state, conn);
if (PTR_ERR(new_conn_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
crtc_state = drm_atomic_get_crtc_state(state, crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
ret = drm_atomic_commit(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
{
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector_state *new_conn_state;
struct drm_crtc_state *crtc_state;
struct drm_display_mode *preferred;
retry_conn_state:
new_conn_state = drm_atomic_get_connector_state(state, conn);
if (PTR_ERR(new_conn_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
crtc_state = drm_atomic_get_crtc_state(state, crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
ret = drm_atomic_commit(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_conn_state;
{
struct drm_atomic_helper_connector_hdmi_priv *priv;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_crtc_state *crtc_state;
struct drm_display_mode *preferred;
struct drm_connector *conn;
retry_crtc_state:
crtc_state = drm_atomic_get_crtc_state(state, crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
ret = drm_atomic_commit(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state;
retry_crtc_state_2:
crtc_state = drm_atomic_get_crtc_state(state, crtc);
if (PTR_ERR(crtc_state) == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state_2;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state_2;
ret = drm_atomic_commit(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_crtc_state_2;
}
EXPORT_SYMBOL_GPL(__drm_kunit_helper_alloc_drm_device_with_driver);
-static void kunit_action_drm_atomic_state_put(void *ptr)
+static void kunit_action_drm_atomic_commit_put(void *ptr)
{
- struct drm_atomic_state *state = ptr;
+ struct drm_atomic_commit *state = ptr;
- drm_atomic_state_put(state);
+ drm_atomic_commit_put(state);
}
/**
* Allocates a empty atomic state.
*
* The state is tied to the kunit test context, so we must not call
- * drm_atomic_state_put() on it, it will be done so automatically.
+ * drm_atomic_commit_put() on it, it will be done so automatically.
*
* Returns:
* An ERR_PTR on error, a pointer to the newly allocated state otherwise
*/
-struct drm_atomic_state *
+struct drm_atomic_commit *
drm_kunit_helper_atomic_state_alloc(struct kunit *test,
struct drm_device *drm,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
int ret;
- state = drm_atomic_state_alloc(drm);
+ state = drm_atomic_commit_alloc(drm);
if (!state)
return ERR_PTR(-ENOMEM);
ret = kunit_add_action_or_reset(test,
- kunit_action_drm_atomic_state_put,
+ kunit_action_drm_atomic_commit_put,
state);
if (ret)
return ERR_PTR(ret);
const struct drm_display_mode *mode,
struct drm_modeset_acquire_ctx *ctx)
{
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
int ret;
/* drm_crtc_helper_funcs */
static int tidss_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
struct drm_crtc_state *old_state,
bool newmodeset)
{
- struct drm_atomic_state *ostate = old_state->state;
+ struct drm_atomic_commit *ostate = old_state->state;
struct tidss_crtc *tcrtc = to_tidss_crtc(crtc);
struct drm_crtc_state *cstate = crtc->state;
int layer;
}
static void tidss_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void tidss_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void tidss_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tidss_crtc *tcrtc = to_tidss_crtc(crtc);
struct drm_device *ddev = crtc->dev;
#include "tidss_kms.h"
#include "tidss_plane.h"
-static void tidss_atomic_commit_tail(struct drm_atomic_state *old_state)
+static void tidss_atomic_commit_tail(struct drm_atomic_commit *old_state)
{
struct drm_device *ddev = old_state->dev;
struct tidss_device *tidss = to_tidss(ddev);
};
static int tidss_atomic_check(struct drm_device *ddev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *opstate;
struct drm_plane_state *npstate;
}
static void tidss_oldi_atomic_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tidss_oldi *oldi = drm_bridge_to_tidss_oldi(bridge);
struct drm_connector *connector;
}
static void tidss_oldi_atomic_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct tidss_oldi *oldi = drm_bridge_to_tidss_oldi(bridge);
/* drm_plane_helper_funcs */
static int tidss_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void tidss_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *ddev = plane->dev;
struct tidss_device *tidss = to_tidss(ddev);
}
static void tidss_plane_atomic_enable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *ddev = plane->dev;
struct tidss_device *tidss = to_tidss(ddev);
}
static void tidss_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *ddev = plane->dev;
struct tidss_device *tidss = to_tidss(ddev);
}
static void tilcdc_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
tilcdc_crtc_enable(crtc);
}
}
static void tilcdc_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
tilcdc_crtc_disable(crtc);
}
static void tilcdc_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
if (!crtc->state->event)
return;
}
static int tilcdc_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
DRM_FORMAT_XRGB8888 };
static int tilcdc_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
int ret;
};
static int tilcdc_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void tilcdc_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
};
static int appletbdrm_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_plane_state *old_plane_state = drm_atomic_get_old_plane_state(state, plane);
}
static void appletbdrm_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *old_state)
+ struct drm_atomic_commit *old_state)
{
struct appletbdrm_device *adev = drm_to_adev(plane->dev);
struct drm_device *drm = plane->dev;
}
static void appletbdrm_primary_plane_helper_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct appletbdrm_device *adev = drm_to_adev(dev);
};
static int bochs_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc *new_crtc = new_plane_state->crtc;
}
static void bochs_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct bochs_device *bochs = to_bochs_device(dev);
}
static int bochs_crtc_helper_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
}
static void bochs_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct bochs_device *bochs = to_bochs_device(crtc->dev);
}
static void bochs_crtc_helper_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *crtc_state)
+ struct drm_atomic_commit *crtc_state)
{
struct bochs_device *bochs = to_bochs_device(crtc->dev);
};
static int cirrus_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_framebuffer *fb = new_plane_state->fb;
}
static void cirrus_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct cirrus_device *cirrus = to_cirrus(plane->dev);
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
DRM_GEM_SHADOW_PLANE_FUNCS,
};
-static int cirrus_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state)
+static int cirrus_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
int ret;
}
static void cirrus_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct cirrus_device *cirrus = to_cirrus(crtc->dev);
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
};
static void hx8357d_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct hx8357d_device *hx8357d = to_hx8357d_device(drm);
};
static void ili9163_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ili9163_device *ili9163 = to_ili9163_device(drm);
};
static void ili9225_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = plane->dev;
struct drm_plane_state *plane_state = plane->state;
};
static void ili9225_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ili9225_device *ili9225 = to_ili9225_device(drm);
}
static void ili9225_crtc_helper_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ili9225_device *ili9225 = to_ili9225_device(drm);
};
static void ili9341_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ili9341_device *ili9341 = to_ili9341_device(drm);
};
static void ili9486_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct ili9486_device *ili9486 = to_ili9486_device(drm);
};
static void mi0283qt_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct mi0283qt_device *mi0283qt = to_mi0283qt_device(drm);
};
static void panel_mipi_dbi_crtc_helper_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = crtc->dev;
struct panel_mipi_dbi_device *panel_mipi_dbi = to_panel_mipi_dbi_device(drm);
}
static int pixpaper_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state =
drm_atomic_get_new_plane_state(state, plane);
}
static int pixpaper_crtc_helper_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state =
drm_atomic_get_new_crtc_state(state, crtc);
}
static void pixpaper_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct pixpaper_panel *panel = to_pixpaper_panel(crtc->dev);
struct drm_device *drm = &panel->drm;
}
static void pixpaper_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct pixpaper_panel *panel = to_pixpaper_panel(crtc->dev);
struct drm_device *drm = &panel->drm;
}
static void pixpaper_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state =
drm_atomic_get_new_plane_state(state, plane);
}
static int sharp_memory_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
struct sharp_memory_device *smd;
}
static void sharp_memory_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *plane_state = plane->state;
}
static int sharp_memory_crtc_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
int ret;
}
static void sharp_memory_crtc_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sharp_memory_device *smd = drm_to_sharp_memory_device(crtc->dev);
}
static void sharp_memory_crtc_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct sharp_memory_device *smd = drm_to_sharp_memory_device(crtc->dev);
};
static int udl_primary_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state, plane);
struct drm_crtc *new_crtc = new_plane_state->crtc;
}
static void udl_primary_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = plane->dev;
struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(state, plane);
* CRTC
*/
-static void udl_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *state)
+static void udl_crtc_helper_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct udl_device *udl = to_udl(dev);
drm_dev_exit(idx);
}
-static void udl_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_state *state)
+static void udl_crtc_helper_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct udl_device *udl = to_udl(dev);
}
static void vbox_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
}
static void vbox_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
}
static void vbox_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
}
};
static int vbox_primary_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void vbox_primary_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void vbox_primary_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static int vbox_cursor_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void vbox_cursor_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void vbox_cursor_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
struct vc4_dev *vc5_mock_device(struct kunit *test);
int vc4_mock_atomic_add_output(struct kunit *test,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
enum vc4_encoder_type type);
int vc4_mock_atomic_del_output(struct kunit *test,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
enum vc4_encoder_type type);
#endif // VC4_MOCK_H_
* errors are fatal.
*/
int vc4_mock_atomic_add_output(struct kunit *test,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
enum vc4_encoder_type type)
{
struct drm_device *drm = state->dev;
* errors are fatal.
*/
int vc4_mock_atomic_del_output(struct kunit *test,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
enum vc4_encoder_type type)
{
struct drm_device *drm = state->dev;
};
static bool check_fifo_conflict(struct kunit *test,
- const struct drm_atomic_state *state)
+ const struct drm_atomic_commit *state)
{
struct vc4_hvs_state *hvs_state;
unsigned int used_fifos = 0;
static struct vc4_crtc_state *
get_vc4_crtc_state_for_encoder(struct kunit *test,
- const struct drm_atomic_state *state,
+ const struct drm_atomic_commit *state,
enum vc4_encoder_type type)
{
struct drm_device *drm = state->dev;
}
static bool check_channel_for_encoder(struct kunit *test,
- const struct drm_atomic_state *state,
+ const struct drm_atomic_commit *state,
enum vc4_encoder_type type,
bool (*check_fn)(enum vc4_encoder_type type, unsigned int channel))
{
const struct pv_muxing_param *params = test->param_value;
const struct pv_muxing_priv *priv = test->priv;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_device *drm;
struct vc4_dev *vc4;
unsigned int i;
ret = vc4_mock_atomic_add_output(test, state, enc_type);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
const struct pv_muxing_param *params = test->param_value;
const struct pv_muxing_priv *priv = test->priv;
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct drm_device *drm;
struct vc4_dev *vc4;
unsigned int i;
ret = vc4_mock_atomic_add_output(test, state, enc_type);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry;
static void drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable(struct kunit *test)
{
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct vc4_crtc_state *new_vc4_crtc_state;
struct vc4_hvs_state *new_hvs_state;
unsigned int hdmi0_channel;
ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_first;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_first;
ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_second;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_second;
static void drm_test_vc5_pv_muxing_bugs_stable_fifo(struct kunit *test)
{
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct vc4_crtc_state *new_vc4_crtc_state;
struct vc4_hvs_state *new_hvs_state;
unsigned int old_hdmi0_channel;
ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_first;
ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_first;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_first;
ret = vc4_mock_atomic_del_output(test, state, VC4_ENCODER_TYPE_HDMI0);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_second;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_second;
drm_test_vc5_pv_muxing_bugs_subsequent_crtc_enable_too_many_crtc_state(struct kunit *test)
{
struct drm_modeset_acquire_ctx ctx;
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
struct vc4_crtc_state *new_vc4_crtc_state;
struct drm_device *drm;
struct vc4_dev *vc4;
ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI0);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_first;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_first;
ret = vc4_mock_atomic_add_output(test, state, VC4_ENCODER_TYPE_HDMI1);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_second;
ret = drm_atomic_check_only(state);
if (ret == -EDEADLK) {
- drm_atomic_state_clear(state);
+ drm_atomic_commit_clear(state);
ret = drm_modeset_backoff(&ctx);
if (!ret)
goto retry_second;
}
static void vc4_crtc_config_pv(struct drm_crtc *crtc, struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct vc4_dev *vc4 = to_vc4_dev(dev);
static int vc4_crtc_disable(struct drm_crtc *crtc,
struct drm_encoder *encoder,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
unsigned int channel)
{
struct vc4_encoder *vc4_encoder = to_vc4_encoder(encoder);
}
static void vc4_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
}
static void vc4_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *new_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
int vc4_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
#define to_vc4_hvs_state(_state) \
container_of_const(_state, struct vc4_hvs_state, base)
-struct vc4_hvs_state *vc4_hvs_get_global_state(struct drm_atomic_state *state);
-struct vc4_hvs_state *vc4_hvs_get_old_global_state(const struct drm_atomic_state *state);
-struct vc4_hvs_state *vc4_hvs_get_new_global_state(const struct drm_atomic_state *state);
+struct vc4_hvs_state *vc4_hvs_get_global_state(struct drm_atomic_commit *state);
+struct vc4_hvs_state *vc4_hvs_get_old_global_state(const struct drm_atomic_commit *state);
+struct vc4_hvs_state *vc4_hvs_get_new_global_state(const struct drm_atomic_commit *state);
struct vc4_plane {
struct drm_plane base;
enum vc4_encoder_type type;
u32 clock_select;
- void (*pre_crtc_configure)(struct drm_encoder *encoder, struct drm_atomic_state *state);
- void (*pre_crtc_enable)(struct drm_encoder *encoder, struct drm_atomic_state *state);
- void (*post_crtc_enable)(struct drm_encoder *encoder, struct drm_atomic_state *state);
+ void (*pre_crtc_configure)(struct drm_encoder *encoder, struct drm_atomic_commit *state);
+ void (*pre_crtc_enable)(struct drm_encoder *encoder, struct drm_atomic_commit *state);
+ void (*post_crtc_enable)(struct drm_encoder *encoder, struct drm_atomic_commit *state);
- void (*post_crtc_disable)(struct drm_encoder *encoder, struct drm_atomic_state *state);
- void (*post_crtc_powerdown)(struct drm_encoder *encoder, struct drm_atomic_state *state);
+ void (*post_crtc_disable)(struct drm_encoder *encoder, struct drm_atomic_commit *state);
+ void (*post_crtc_powerdown)(struct drm_encoder *encoder, struct drm_atomic_commit *state);
};
#define to_vc4_encoder(_encoder) \
uint32_t flags,
struct drm_modeset_acquire_ctx *ctx);
int vc4_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
struct drm_crtc_state *vc4_crtc_duplicate_state(struct drm_crtc *crtc);
void vc4_crtc_destroy_state(struct drm_crtc *crtc,
struct drm_crtc_state *state);
void vc4_hvs_stop_channel(struct vc4_hvs *hvs, unsigned int output);
int vc4_hvs_get_fifo_from_output(struct vc4_hvs *hvs, unsigned int output);
u8 vc4_hvs_get_fifo_frame_count(struct vc4_hvs *hvs, unsigned int fifo);
-int vc4_hvs_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state);
-void vc4_hvs_atomic_begin(struct drm_crtc *crtc, struct drm_atomic_state *state);
-void vc4_hvs_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_state *state);
-void vc4_hvs_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_state *state);
-void vc4_hvs_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_state *state);
+int vc4_hvs_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *state);
+void vc4_hvs_atomic_begin(struct drm_crtc *crtc, struct drm_atomic_commit *state);
+void vc4_hvs_atomic_enable(struct drm_crtc *crtc, struct drm_atomic_commit *state);
+void vc4_hvs_atomic_disable(struct drm_crtc *crtc, struct drm_atomic_commit *state);
+void vc4_hvs_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_commit *state);
void vc4_hvs_dump_state(struct vc4_hvs *hvs);
void vc4_hvs_unmask_underrun(struct vc4_hvs *hvs, int channel);
void vc4_hvs_mask_underrun(struct vc4_hvs *hvs, int channel);
}
static void vc4_dsi_bridge_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_dsi *dsi = bridge_to_vc4_dsi(bridge);
u32 disp0_ctrl;
}
static void vc4_dsi_bridge_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_dsi *dsi = bridge_to_vc4_dsi(bridge);
struct device *dev = &dsi->pdev->dev;
}
static void vc4_dsi_bridge_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_dsi *dsi = bridge_to_vc4_dsi(bridge);
const struct drm_crtc_state *crtc_state;
}
static void vc4_dsi_bridge_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_dsi *dsi = bridge_to_vc4_dsi(bridge);
bool debug_dump_regs = false;
}
static int vc4_hdmi_connector_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *old_state =
drm_atomic_get_old_connector_state(state, connector);
}
static void vc4_hdmi_encoder_post_crtc_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
struct drm_device *drm = vc4_hdmi->connector.dev;
}
static void vc4_hdmi_encoder_post_crtc_powerdown(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
struct drm_device *drm = vc4_hdmi->connector.dev;
}
static void vc4_hdmi_encoder_pre_crtc_configure(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
struct drm_device *drm = vc4_hdmi->connector.dev;
}
static void vc4_hdmi_encoder_pre_crtc_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
struct drm_device *drm = vc4_hdmi->connector.dev;
}
static void vc4_hdmi_encoder_post_crtc_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hdmi *vc4_hdmi = encoder_to_vc4_hdmi(encoder);
struct drm_connector *connector = &vc4_hdmi->connector;
__vc4_hvs_stop_channel(hvs, chan);
}
-int vc4_hvs_atomic_check(struct drm_crtc *crtc, struct drm_atomic_state *state)
+int vc4_hvs_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
struct vc4_crtc_state *vc4_state = to_vc4_crtc_state(crtc_state);
}
void vc4_hvs_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_crtc *vc4_crtc = to_vc4_crtc(crtc);
struct vc4_crtc_state *vc4_state = to_vc4_crtc_state(crtc->state);
}
void vc4_hvs_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct vc4_dev *vc4 = to_vc4_dev(dev);
}
void vc4_hvs_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct vc4_dev *vc4 = to_vc4_dev(dev);
}
void vc4_hvs_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_state = drm_atomic_get_old_crtc_state(state,
crtc);
#define to_vc4_load_tracker_state(_state) \
container_of_const(_state, struct vc4_load_tracker_state, base)
-static struct vc4_ctm_state *vc4_get_ctm_state(struct drm_atomic_state *state,
+static struct vc4_ctm_state *vc4_get_ctm_state(struct drm_atomic_commit *state,
struct drm_private_obj *manager)
{
struct drm_device *dev = state->dev;
}
static void
-vc4_ctm_commit(struct vc4_dev *vc4, struct drm_atomic_state *state)
+vc4_ctm_commit(struct vc4_dev *vc4, struct drm_atomic_commit *state)
{
struct vc4_hvs *hvs = vc4->hvs;
struct vc4_ctm_state *ctm_state = to_vc4_ctm_state(vc4->ctm_manager.state);
}
struct vc4_hvs_state *
-vc4_hvs_get_new_global_state(const struct drm_atomic_state *state)
+vc4_hvs_get_new_global_state(const struct drm_atomic_commit *state)
{
struct vc4_dev *vc4 = to_vc4_dev(state->dev);
struct drm_private_state *priv_state;
}
struct vc4_hvs_state *
-vc4_hvs_get_old_global_state(const struct drm_atomic_state *state)
+vc4_hvs_get_old_global_state(const struct drm_atomic_commit *state)
{
struct vc4_dev *vc4 = to_vc4_dev(state->dev);
struct drm_private_state *priv_state;
}
struct vc4_hvs_state *
-vc4_hvs_get_global_state(struct drm_atomic_state *state)
+vc4_hvs_get_global_state(struct drm_atomic_commit *state)
{
struct vc4_dev *vc4 = to_vc4_dev(state->dev);
struct drm_private_state *priv_state;
}
static void vc4_hvs_pv_muxing_commit(struct vc4_dev *vc4,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hvs *hvs = vc4->hvs;
struct drm_crtc_state *crtc_state;
}
static void vc5_hvs_pv_muxing_commit(struct vc4_dev *vc4,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hvs *hvs = vc4->hvs;
struct drm_crtc_state *crtc_state;
}
static void vc6_hvs_pv_muxing_commit(struct vc4_dev *vc4,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hvs *hvs = vc4->hvs;
struct drm_crtc_state *crtc_state;
}
}
-static void vc4_atomic_commit_tail(struct drm_atomic_state *state)
+static void vc4_atomic_commit_tail(struct drm_atomic_commit *state)
{
struct drm_device *dev = state->dev;
struct vc4_dev *vc4 = to_vc4_dev(dev);
}
}
-static int vc4_atomic_commit_setup(struct drm_atomic_state *state)
+static int vc4_atomic_commit_setup(struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state;
struct vc4_hvs_state *hvs_state;
* we don't allow userland to set a CTM that we have no hope of approximating.
*/
static int
-vc4_ctm_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
+vc4_ctm_atomic_check(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct vc4_dev *vc4 = to_vc4_dev(dev);
struct vc4_ctm_state *ctm_state = NULL;
return 0;
}
-static int vc4_load_tracker_atomic_check(struct drm_atomic_state *state)
+static int vc4_load_tracker_atomic_check(struct drm_atomic_commit *state)
{
struct drm_plane_state *old_plane_state, *new_plane_state;
struct vc4_dev *vc4 = to_vc4_dev(state->dev);
* single display, and changing the resolution down and then back up.
*/
static int vc4_pv_muxing_atomic_check(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_hvs_state *hvs_new_state;
struct drm_crtc **sorted_crtcs;
}
static int
-vc4_core_clock_atomic_check(struct drm_atomic_state *state)
+vc4_core_clock_atomic_check(struct drm_atomic_commit *state)
{
struct vc4_dev *vc4 = to_vc4_dev(state->dev);
struct drm_private_state *priv_state;
static int
-vc4_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
+vc4_atomic_check(struct drm_device *dev, struct drm_atomic_commit *state)
{
int ret;
* in the CRTC's flush.
*/
static int vc4_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vc4_dev *vc4 = to_vc4_dev(plane->dev);
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
}
static void vc4_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
/* No contents here. Since we don't know where in the CRTC's
* dlist we should be stored, our dlist is uploaded to the
}
static void vc4_plane_atomic_async_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static int vc4_plane_atomic_async_check(struct drm_plane *plane,
- struct drm_atomic_state *state, bool flip)
+ struct drm_atomic_commit *state, bool flip)
{
struct vc4_dev *vc4 = to_vc4_dev(plane->dev);
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
}
static int vc4_txp_connector_atomic_check(struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
}
static void vc4_txp_connector_atomic_commit(struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = conn->dev;
struct drm_connector_state *conn_state = drm_atomic_get_new_connector_state(state,
};
static int vc4_txp_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void vc4_txp_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(crtc);
vc4_hvs_atomic_enable(crtc, state);
}
static void vc4_txp_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
}
static void vc4_vec_encoder_disable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct vc4_vec *vec = encoder_to_vc4_vec(encoder);
}
static void vc4_vec_encoder_enable(struct drm_encoder *encoder,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *drm = encoder->dev;
struct vc4_vec *vec = encoder_to_vc4_vec(encoder);
}
static void vs_bridge_atomic_enable_dpi(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
struct drm_bridge_state *br_state =
}
static void vs_bridge_atomic_enable_dp(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
struct drm_bridge_state *br_state =
}
static void vs_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vs_bridge *vbridge = drm_bridge_to_vs_bridge(bridge);
struct vs_crtc *crtc = vbridge->crtc;
#include "vs_plane.h"
static void vs_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
struct vs_dc *dc = vcrtc->dc;
}
static void vs_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vs_crtc *vcrtc = drm_crtc_to_vs_crtc(crtc);
struct vs_dc *dc = vcrtc->dc;
#include "vs_primary_plane_regs.h"
static int vs_primary_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void vs_primary_plane_atomic_enable(struct drm_plane *plane,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct drm_plane_state *state = drm_atomic_get_new_plane_state(atomic_state,
plane);
}
static void vs_primary_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct drm_plane_state *state = drm_atomic_get_old_plane_state(atomic_state,
plane);
}
static void vs_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *atomic_state)
+ struct drm_atomic_commit *atomic_state)
{
struct drm_plane_state *state = drm_atomic_get_new_plane_state(atomic_state,
plane);
}
static void virtio_gpu_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(crtc);
}
static void virtio_gpu_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct virtio_gpu_device *vgdev = dev->dev_private;
}
static int virtio_gpu_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
return 0;
}
static void virtio_gpu_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_device *dev = crtc->dev;
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
};
static int virtio_gpu_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void virtio_gpu_primary_plane_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void virtio_gpu_cursor_plane_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
};
static int vkms_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state,
crtc);
}
static void vkms_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
__acquires(&vkms_output->lock)
{
struct vkms_output *vkms_output = drm_crtc_to_vkms_output(crtc);
}
static void vkms_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
__releases(&vkms_output->lock)
{
struct vkms_output *vkms_output = drm_crtc_to_vkms_output(crtc);
DEFINE_DRM_GEM_FOPS(vkms_driver_fops);
-static void vkms_atomic_commit_tail(struct drm_atomic_state *old_state)
+static void vkms_atomic_commit_tail(struct drm_atomic_commit *old_state)
{
struct drm_device *dev = old_state->dev;
struct drm_crtc *crtc;
.minor = DRIVER_MINOR,
};
-static int vkms_atomic_check(struct drm_device *dev, struct drm_atomic_state *state)
+static int vkms_atomic_check(struct drm_device *dev, struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state;
};
static void vkms_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
static int vkms_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
};
static int vkms_wb_atomic_check(struct drm_connector *connector,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *conn_state =
drm_atomic_get_new_connector_state(state, connector);
}
static void vkms_wb_atomic_commit(struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *connector_state = drm_atomic_get_new_connector_state(state,
conn);
* Returns 0 on success
*/
int vmw_cursor_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state =
drm_atomic_get_new_plane_state(state, plane);
void
vmw_cursor_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_bo *bo;
struct drm_plane_state *new_state =
void vmw_cursor_plane_destroy(struct drm_plane *plane);
int vmw_cursor_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void vmw_cursor_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int vmw_cursor_plane_prepare_fb(struct drm_plane *plane,
struct drm_plane_state *new_state);
void vmw_cursor_plane_cleanup_fb(struct drm_plane *plane,
struct drm_property *hotplug_mode_update_property;
struct drm_property *implicit_placement_property;
spinlock_t cursor_lock;
- struct drm_atomic_state *suspend_state;
+ struct drm_atomic_commit *suspend_state;
/*
* Context and surface management.
* Returns 0 on success
*/
int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
plane);
}
int vmw_du_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_private *vmw = vmw_priv(crtc->dev);
struct drm_crtc_state *new_state = drm_atomic_get_new_crtc_state(state,
void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
vmw_vkms_crtc_atomic_begin(crtc, state);
}
* pointer error, in particular -EDEADLK if locking needs to be rerun.
*/
static struct drm_crtc_state *
-vmw_crtc_state_and_lock(struct drm_atomic_state *state, struct drm_crtc *crtc)
+vmw_crtc_state_and_lock(struct drm_atomic_commit *state, struct drm_crtc *crtc)
{
struct drm_crtc_state *crtc_state;
* -EDEADLK if modeset locking needs to be rerun.
*/
static int vmw_kms_check_implicit(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_framebuffer *implicit_fb = NULL;
struct drm_crtc *crtc;
}
/**
- * vmw_kms_check_topology - Validates topology in drm_atomic_state
+ * vmw_kms_check_topology - Validates topology in drm_atomic_commit
* @dev: DRM device
* @state: the driver state object
*
* 0 on success otherwise negative error code
*/
static int vmw_kms_check_topology(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc_state *old_crtc_state, *new_crtc_state;
struct drm_rect *rects;
*/
static int
vmw_kms_atomic_check_modeset(struct drm_device *dev,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state;
}
static void
-vmw_atomic_commit_tail(struct drm_atomic_state *old_state)
+vmw_atomic_commit_tail(struct drm_atomic_commit *old_state)
{
struct vmw_private *vmw = vmw_priv(old_state->dev);
struct drm_crtc *crtc;
/* Atomic Helpers */
int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void vmw_du_plane_cleanup_fb(struct drm_plane *plane,
struct drm_plane_state *old_state);
void vmw_du_plane_reset(struct drm_plane *plane);
void vmw_du_plane_unpin_surf(struct vmw_plane_state *vps);
int vmw_du_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void vmw_du_crtc_reset(struct drm_crtc *crtc);
struct drm_crtc_state *vmw_du_crtc_duplicate_state(struct drm_crtc *crtc);
void vmw_du_crtc_destroy_state(struct drm_crtc *crtc,
static void
vmw_ldu_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
* @state: Unused
*/
static void vmw_sou_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_private *dev_priv;
struct vmw_screen_object_unit *sou;
static void
vmw_sou_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
}
static void vmw_stdu_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_private *dev_priv;
struct vmw_screen_target_display_unit *stdu;
* the same mode but its relative X,Y position in the topology will change.
*/
static int vmw_stdu_connector_atomic_check(struct drm_connector *conn,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_connector_state *conn_state;
struct vmw_screen_target_display_unit *du;
*/
static void
vmw_stdu_primary_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
static void
vmw_stdu_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_private *vmw = vmw_priv(crtc->dev);
struct vmw_screen_target_display_unit *stdu = vmw_crtc_to_stdu(crtc);
void
vmw_vkms_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_private *vmw = vmw_priv(crtc->dev);
void
vmw_vkms_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
unsigned long flags;
struct vmw_private *vmw = vmw_priv(crtc->dev);
void
vmw_vkms_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_private *vmw = vmw_priv(crtc->dev);
void
vmw_vkms_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct vmw_private *vmw = vmw_priv(crtc->dev);
#include <linux/hrtimer_types.h>
#include <linux/types.h>
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_crtc;
struct vmw_private;
struct vmw_surface;
void vmw_vkms_crtc_init(struct drm_crtc *crtc);
void vmw_vkms_crtc_cleanup(struct drm_crtc *crtc);
void vmw_vkms_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
-void vmw_vkms_crtc_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
+void vmw_vkms_crtc_atomic_flush(struct drm_crtc *crtc, struct drm_atomic_commit *state);
void vmw_vkms_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void vmw_vkms_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
const char *const *vmw_vkms_get_crc_sources(struct drm_crtc *crtc,
size_t *count);
}
static void zynqmp_dp_disp_enable(struct zynqmp_dp *dp,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct zynqmp_disp_layer *layer;
struct drm_bridge_state *bridge_state;
}
static void zynqmp_dp_bridge_atomic_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct zynqmp_dp *dp = bridge_to_dp(bridge);
const struct drm_crtc_state *crtc_state;
}
static void zynqmp_dp_bridge_atomic_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_bridge_state *old_bridge_state = drm_atomic_get_old_bridge_state(state,
bridge);
*/
static int zynqmp_dpsub_plane_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state,
plane);
}
static void zynqmp_dpsub_plane_atomic_disable(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
plane);
}
static void zynqmp_dpsub_plane_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, plane);
struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane);
}
static void zynqmp_dpsub_crtc_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct zynqmp_dpsub *dpsub = crtc_to_dpsub(crtc);
struct drm_display_mode *adjusted_mode = &crtc->state->adjusted_mode;
}
static void zynqmp_dpsub_crtc_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
struct zynqmp_dpsub *dpsub = crtc_to_dpsub(crtc);
struct drm_plane_state *old_plane_state;
}
static int zynqmp_dpsub_crtc_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
return drm_atomic_add_affected_planes(state, crtc);
}
static void zynqmp_dpsub_crtc_atomic_begin(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
drm_crtc_vblank_on(crtc);
}
static void zynqmp_dpsub_crtc_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state)
+ struct drm_atomic_commit *state)
{
if (crtc->state->event) {
struct drm_pending_vblank_event *event;
struct drm_dp_mst_port *port);
struct drm_dp_mst_topology_state *
-drm_atomic_get_mst_topology_state(struct drm_atomic_state *state,
+drm_atomic_get_mst_topology_state(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr);
struct drm_dp_mst_topology_state *
-drm_atomic_get_old_mst_topology_state(struct drm_atomic_state *state,
+drm_atomic_get_old_mst_topology_state(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr);
struct drm_dp_mst_topology_state *
-drm_atomic_get_new_mst_topology_state(struct drm_atomic_state *state,
+drm_atomic_get_new_mst_topology_state(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr);
struct drm_dp_mst_atomic_payload *
drm_atomic_get_mst_payload_state(struct drm_dp_mst_topology_state *state,
struct drm_dp_mst_port *port,
struct drm_dp_mst_port *parent);
int __must_check
-drm_dp_atomic_find_time_slots(struct drm_atomic_state *state,
+drm_dp_atomic_find_time_slots(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_port *port, int pbn);
-int drm_dp_mst_atomic_enable_dsc(struct drm_atomic_state *state,
+int drm_dp_mst_atomic_enable_dsc(struct drm_atomic_commit *state,
struct drm_dp_mst_port *port,
int pbn, bool enable);
int __must_check
-drm_dp_mst_add_affected_dsc_crtcs(struct drm_atomic_state *state,
+drm_dp_mst_add_affected_dsc_crtcs(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr);
int __must_check
-drm_dp_atomic_release_time_slots(struct drm_atomic_state *state,
+drm_dp_atomic_release_time_slots(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_port *port);
-void drm_dp_mst_atomic_wait_for_dependencies(struct drm_atomic_state *state);
-int __must_check drm_dp_mst_atomic_setup_commit(struct drm_atomic_state *state);
+void drm_dp_mst_atomic_wait_for_dependencies(struct drm_atomic_commit *state);
+int __must_check drm_dp_mst_atomic_setup_commit(struct drm_atomic_commit *state);
int drm_dp_send_power_updown_phy(struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_port *port, bool power_up);
int drm_dp_send_query_stream_enc_status(struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_port *port,
struct drm_dp_query_stream_enc_status_ack_reply *status);
-int __must_check drm_dp_mst_atomic_check_mgr(struct drm_atomic_state *state,
+int __must_check drm_dp_mst_atomic_check_mgr(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr *mgr,
struct drm_dp_mst_topology_state *mst_state,
struct drm_dp_mst_port **failing_port);
-int __must_check drm_dp_mst_atomic_check(struct drm_atomic_state *state);
+int __must_check drm_dp_mst_atomic_check(struct drm_atomic_commit *state);
int __must_check drm_dp_mst_root_conn_atomic_check(struct drm_connector_state *new_conn_state,
struct drm_dp_mst_topology_mgr *mgr);
/**
* __drm_dp_mst_state_iter_get - private atomic state iterator function for
* macro-internal use
- * @state: &struct drm_atomic_state pointer
+ * @state: &struct drm_atomic_commit pointer
* @mgr: pointer to the &struct drm_dp_mst_topology_mgr iteration cursor
* @old_state: optional pointer to the old &struct drm_dp_mst_topology_state
* iteration cursor
* drm_dp_mst_topology_mgr, false otherwise.
*/
static inline bool
-__drm_dp_mst_state_iter_get(struct drm_atomic_state *state,
+__drm_dp_mst_state_iter_get(struct drm_atomic_commit *state,
struct drm_dp_mst_topology_mgr **mgr,
struct drm_dp_mst_topology_state **old_state,
struct drm_dp_mst_topology_state **new_state,
/**
* for_each_oldnew_mst_mgr_in_state - iterate over all DP MST topology
* managers in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @mgr: &struct drm_dp_mst_topology_mgr iteration cursor
* @old_state: &struct drm_dp_mst_topology_state iteration cursor for the old
* state
/**
* for_each_old_mst_mgr_in_state - iterate over all DP MST topology managers
* in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @mgr: &struct drm_dp_mst_topology_mgr iteration cursor
* @old_state: &struct drm_dp_mst_topology_state iteration cursor for the old
* state
/**
* for_each_new_mst_mgr_in_state - iterate over all DP MST topology managers
* in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @mgr: &struct drm_dp_mst_topology_mgr iteration cursor
* @new_state: &struct drm_dp_mst_topology_state iteration cursor for the new
* state
struct drm_device;
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_dp_tunnel_mgr;
struct drm_dp_tunnel_state;
const char *drm_dp_tunnel_name(const struct drm_dp_tunnel *tunnel);
struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_state(struct drm_atomic_commit *state,
struct drm_dp_tunnel *tunnel);
struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_old_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_old_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel);
struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_new_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_new_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel);
-int drm_dp_tunnel_atomic_set_stream_bw(struct drm_atomic_state *state,
+int drm_dp_tunnel_atomic_set_stream_bw(struct drm_atomic_commit *state,
struct drm_dp_tunnel *tunnel,
u8 stream_id, int bw);
-int drm_dp_tunnel_atomic_get_group_streams_in_state(struct drm_atomic_state *state,
+int drm_dp_tunnel_atomic_get_group_streams_in_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel,
u32 *stream_mask);
-int drm_dp_tunnel_atomic_check_stream_bws(struct drm_atomic_state *state,
+int drm_dp_tunnel_atomic_check_stream_bws(struct drm_atomic_commit *state,
u32 *failed_stream_mask);
int drm_dp_tunnel_atomic_get_required_bw(const struct drm_dp_tunnel_state *tunnel_state);
}
static inline struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_state(struct drm_atomic_commit *state,
struct drm_dp_tunnel *tunnel)
{
return ERR_PTR(-EOPNOTSUPP);
}
static inline struct drm_dp_tunnel_state *
-drm_dp_tunnel_atomic_get_new_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_new_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel)
{
return ERR_PTR(-EOPNOTSUPP);
}
static inline int
-drm_dp_tunnel_atomic_set_stream_bw(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_set_stream_bw(struct drm_atomic_commit *state,
struct drm_dp_tunnel *tunnel,
u8 stream_id, int bw)
{
}
static inline int
-drm_dp_tunnel_atomic_get_group_streams_in_state(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_get_group_streams_in_state(struct drm_atomic_commit *state,
const struct drm_dp_tunnel *tunnel,
u32 *stream_mask)
{
}
static inline int
-drm_dp_tunnel_atomic_check_stream_bws(struct drm_atomic_state *state,
+drm_dp_tunnel_atomic_check_stream_bws(struct drm_atomic_commit *state,
u32 *failed_stream_mask)
{
return -EOPNOTSUPP;
#ifndef DRM_HDMI_STATE_HELPER_H_
#define DRM_HDMI_STATE_HELPER_H_
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_connector;
struct drm_connector_state;
struct drm_display_mode;
struct drm_connector_state *new_conn_state);
int drm_atomic_helper_connector_hdmi_check(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_atomic_helper_connector_hdmi_update_audio_infoframe(struct drm_connector *connector,
struct hdmi_audio_infoframe *frame);
int drm_atomic_helper_connector_hdmi_clear_audio_infoframe(struct drm_connector *connector);
int drm_atomic_helper_connector_hdmi_update_infoframes(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_connector_hdmi_hotplug(struct drm_connector *connector,
enum drm_connector_status status);
void drm_atomic_helper_connector_hdmi_force(struct drm_connector *connector);
* @state_to_destroy:
*
* Used to track the @drm_plane_state we will need to free when
- * tearing down the associated &drm_atomic_state in
+ * tearing down the associated &drm_atomic_commit in
* $drm_mode_config_funcs.atomic_state_clear or
- * drm_atomic_state_default_clear().
+ * drm_atomic_commit_default_clear().
*
* Before a commit, and the call to
* drm_atomic_helper_swap_state() in particular, it points to
* @state_to_destroy:
*
* Used to track the @drm_crtc_state we will need to free when
- * tearing down the associated &drm_atomic_state in
+ * tearing down the associated &drm_atomic_commit in
* $drm_mode_config_funcs.atomic_state_clear or
- * drm_atomic_state_default_clear().
+ * drm_atomic_commit_default_clear().
*
* Before a commit, and the call to
* drm_atomic_helper_swap_state() in particular, it points to
* @state_to_destroy:
*
* Used to track the @drm_connector_state we will need to free
- * when tearing down the associated &drm_atomic_state in
+ * when tearing down the associated &drm_atomic_commit in
* $drm_mode_config_funcs.atomic_state_clear or
- * drm_atomic_state_default_clear().
+ * drm_atomic_commit_default_clear().
*
* Before a commit, and the call to
* drm_atomic_helper_swap_state() in particular, it points to
*/
struct drm_private_state {
/**
- * @state: backpointer to global drm_atomic_state
+ * @state: backpointer to global drm_atomic_commit
*/
- struct drm_atomic_state *state;
+ struct drm_atomic_commit *state;
/**
* @obj: backpointer to the private object
* @state_to_destroy:
*
* Used to track the @drm_private_state we will need to free
- * when tearing down the associated &drm_atomic_state in
+ * when tearing down the associated &drm_atomic_commit in
* $drm_mode_config_funcs.atomic_state_clear or
- * drm_atomic_state_default_clear().
+ * drm_atomic_commit_default_clear().
*
* Before a commit, and the call to
* drm_atomic_helper_swap_state() in particular, it points to
};
/**
- * struct drm_atomic_state - Atomic commit structure
+ * struct drm_atomic_commit - Atomic commit structure
*
* This structure is the kernel counterpart of @drm_mode_atomic and represents
* an atomic commit that transitions from an old to a new display state. It
* drm_atomic_get_plane_state(), drm_atomic_get_connector_state(), or for
* private state structures, drm_atomic_get_private_obj_state().
*
- * NOTE: struct drm_atomic_state first started as a single collection of
+ * NOTE: struct drm_atomic_commit first started as a single collection of
* entities state pointers (drm_plane_state, drm_crtc_state, etc.).
*
* At atomic_check time, you could get the state about to be committed
- * from drm_atomic_state, and the one currently running from the
+ * from drm_atomic_commit, and the one currently running from the
* entities state pointer (drm_crtc.state, for example). After the call
* to drm_atomic_helper_swap_state(), the entities state pointer would
- * contain the state previously checked, and the drm_atomic_state
+ * contain the state previously checked, and the drm_atomic_commit
* structure the old state.
*
- * Over time, and in order to avoid confusion, drm_atomic_state has
+ * Over time, and in order to avoid confusion, drm_atomic_commit has
* grown to have both the old state (ie, the state we replace) and the
* new state (ie, the state we want to apply). Those names are stable
* during the commit process, which makes it easier to reason about.
*
* You can still find some traces of that evolution through some hooks
- * or callbacks taking a drm_atomic_state parameter called names like
+ * or callbacks taking a drm_atomic_commit parameter called names like
* "old_state". This doesn't necessarily mean that the previous
- * drm_atomic_state is passed, but rather that this used to be the state
+ * drm_atomic_commit is passed, but rather that this used to be the state
* collection we were replacing after drm_atomic_helper_swap_state(),
* but the variable name was never updated.
*
* first started to pass the entity state only. However, it was pretty
* cumbersome for drivers, and especially CRTCs, to retrieve the states
* of other components. Thus, we switched to passing the whole
- * drm_atomic_state as a parameter to those operations. Similarly, the
+ * drm_atomic_commit as a parameter to those operations. Similarly, the
* transition isn't complete yet, and one might still find atomic
- * operations taking a drm_atomic_state pointer, or a component state
+ * operations taking a drm_atomic_commit pointer, or a component state
* pointer. The former is the preferred form.
*/
-struct drm_atomic_state {
+struct drm_atomic_commit {
/**
* @ref:
*
int drm_crtc_commit_wait(struct drm_crtc_commit *commit);
-struct drm_atomic_state * __must_check
-drm_atomic_state_alloc(struct drm_device *dev);
-void drm_atomic_state_clear(struct drm_atomic_state *state);
+struct drm_atomic_commit * __must_check
+drm_atomic_commit_alloc(struct drm_device *dev);
+void drm_atomic_commit_clear(struct drm_atomic_commit *state);
/**
- * drm_atomic_state_get - acquire a reference to the atomic state
+ * drm_atomic_commit_get - acquire a reference to the atomic state
* @state: The atomic state
*
* Returns a new reference to the @state
*/
-static inline struct drm_atomic_state *
-drm_atomic_state_get(struct drm_atomic_state *state)
+static inline struct drm_atomic_commit *
+drm_atomic_commit_get(struct drm_atomic_commit *state)
{
kref_get(&state->ref);
return state;
}
-void __drm_atomic_state_free(struct kref *ref);
+void __drm_atomic_commit_free(struct kref *ref);
/**
- * drm_atomic_state_put - release a reference to the atomic state
+ * drm_atomic_commit_put - release a reference to the atomic state
* @state: The atomic state
*
* This releases a reference to @state which is freed after removing the
* final reference. No locking required and callable from any context.
*/
-static inline void drm_atomic_state_put(struct drm_atomic_state *state)
+static inline void drm_atomic_commit_put(struct drm_atomic_commit *state)
{
- kref_put(&state->ref, __drm_atomic_state_free);
+ kref_put(&state->ref, __drm_atomic_commit_free);
}
int __must_check
-drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
-void drm_atomic_state_default_clear(struct drm_atomic_state *state);
-void drm_atomic_state_default_release(struct drm_atomic_state *state);
+drm_atomic_commit_init(struct drm_device *dev, struct drm_atomic_commit *state);
+void drm_atomic_commit_default_clear(struct drm_atomic_commit *state);
+void drm_atomic_commit_default_release(struct drm_atomic_commit *state);
struct drm_crtc_state * __must_check
-drm_atomic_get_crtc_state(struct drm_atomic_state *state,
+drm_atomic_get_crtc_state(struct drm_atomic_commit *state,
struct drm_crtc *crtc);
struct drm_plane_state * __must_check
-drm_atomic_get_plane_state(struct drm_atomic_state *state,
+drm_atomic_get_plane_state(struct drm_atomic_commit *state,
struct drm_plane *plane);
struct drm_colorop_state *
-drm_atomic_get_colorop_state(struct drm_atomic_state *state,
+drm_atomic_get_colorop_state(struct drm_atomic_commit *state,
struct drm_colorop *colorop);
struct drm_colorop_state *
-drm_atomic_get_old_colorop_state(struct drm_atomic_state *state,
+drm_atomic_get_old_colorop_state(struct drm_atomic_commit *state,
struct drm_colorop *colorop);
struct drm_colorop_state *
-drm_atomic_get_new_colorop_state(struct drm_atomic_state *state,
+drm_atomic_get_new_colorop_state(struct drm_atomic_commit *state,
struct drm_colorop *colorop);
struct drm_connector_state * __must_check
-drm_atomic_get_connector_state(struct drm_atomic_state *state,
+drm_atomic_get_connector_state(struct drm_atomic_commit *state,
struct drm_connector *connector);
int drm_atomic_private_obj_init(struct drm_device *dev,
void drm_atomic_private_obj_fini(struct drm_private_obj *obj);
struct drm_private_state * __must_check
-drm_atomic_get_private_obj_state(struct drm_atomic_state *state,
+drm_atomic_get_private_obj_state(struct drm_atomic_commit *state,
struct drm_private_obj *obj);
struct drm_private_state *
-drm_atomic_get_old_private_obj_state(const struct drm_atomic_state *state,
+drm_atomic_get_old_private_obj_state(const struct drm_atomic_commit *state,
struct drm_private_obj *obj);
struct drm_private_state *
-drm_atomic_get_new_private_obj_state(const struct drm_atomic_state *state,
+drm_atomic_get_new_private_obj_state(const struct drm_atomic_commit *state,
struct drm_private_obj *obj);
struct drm_connector *
-drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_state *state,
+drm_atomic_get_old_connector_for_encoder(const struct drm_atomic_commit *state,
struct drm_encoder *encoder);
struct drm_connector *
-drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_state *state,
+drm_atomic_get_new_connector_for_encoder(const struct drm_atomic_commit *state,
struct drm_encoder *encoder);
struct drm_connector *
drm_atomic_get_connector_for_encoder(const struct drm_encoder *encoder,
struct drm_modeset_acquire_ctx *ctx);
struct drm_crtc *
-drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_state *state,
+drm_atomic_get_old_crtc_for_encoder(struct drm_atomic_commit *state,
struct drm_encoder *encoder);
struct drm_crtc *
-drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_state *state,
+drm_atomic_get_new_crtc_for_encoder(struct drm_atomic_commit *state,
struct drm_encoder *encoder);
/**
* NULL if the CRTC is not part of the global atomic state.
*/
static inline struct drm_crtc_state *
-drm_atomic_get_old_crtc_state(const struct drm_atomic_state *state,
+drm_atomic_get_old_crtc_state(const struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
return state->crtcs[drm_crtc_index(crtc)].old_state;
* NULL if the CRTC is not part of the global atomic state.
*/
static inline struct drm_crtc_state *
-drm_atomic_get_new_crtc_state(const struct drm_atomic_state *state,
+drm_atomic_get_new_crtc_state(const struct drm_atomic_commit *state,
struct drm_crtc *crtc)
{
return state->crtcs[drm_crtc_index(crtc)].new_state;
* NULL if the plane is not part of the global atomic state.
*/
static inline struct drm_plane_state *
-drm_atomic_get_old_plane_state(const struct drm_atomic_state *state,
+drm_atomic_get_old_plane_state(const struct drm_atomic_commit *state,
struct drm_plane *plane)
{
return state->planes[drm_plane_index(plane)].old_state;
* NULL if the plane is not part of the global atomic state.
*/
static inline struct drm_plane_state *
-drm_atomic_get_new_plane_state(const struct drm_atomic_state *state,
+drm_atomic_get_new_plane_state(const struct drm_atomic_commit *state,
struct drm_plane *plane)
{
return state->planes[drm_plane_index(plane)].new_state;
* or NULL if the connector is not part of the global atomic state.
*/
static inline struct drm_connector_state *
-drm_atomic_get_old_connector_state(const struct drm_atomic_state *state,
+drm_atomic_get_old_connector_state(const struct drm_atomic_commit *state,
struct drm_connector *connector)
{
int index = drm_connector_index(connector);
* or NULL if the connector is not part of the global atomic state.
*/
static inline struct drm_connector_state *
-drm_atomic_get_new_connector_state(const struct drm_atomic_state *state,
+drm_atomic_get_new_connector_state(const struct drm_atomic_commit *state,
struct drm_connector *connector)
{
int index = drm_connector_index(connector);
* Read-only pointer to the current plane state.
*/
static inline const struct drm_plane_state *
-__drm_atomic_get_current_plane_state(const struct drm_atomic_state *state,
+__drm_atomic_get_current_plane_state(const struct drm_atomic_commit *state,
struct drm_plane *plane)
{
struct drm_plane_state *plane_state;
}
int __must_check
-drm_atomic_add_encoder_bridges(struct drm_atomic_state *state,
+drm_atomic_add_encoder_bridges(struct drm_atomic_commit *state,
struct drm_encoder *encoder);
int __must_check
-drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
+drm_atomic_add_affected_connectors(struct drm_atomic_commit *state,
struct drm_crtc *crtc);
int __must_check
-drm_atomic_add_affected_planes(struct drm_atomic_state *state,
+drm_atomic_add_affected_planes(struct drm_atomic_commit *state,
struct drm_crtc *crtc);
int __must_check
-drm_atomic_add_affected_colorops(struct drm_atomic_state *state,
+drm_atomic_add_affected_colorops(struct drm_atomic_commit *state,
struct drm_plane *plane);
-int __must_check drm_atomic_check_only(struct drm_atomic_state *state);
-int __must_check drm_atomic_commit(struct drm_atomic_state *state);
-int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_state *state);
+int __must_check drm_atomic_check_only(struct drm_atomic_commit *state);
+int __must_check drm_atomic_commit(struct drm_atomic_commit *state);
+int __must_check drm_atomic_nonblocking_commit(struct drm_atomic_commit *state);
void drm_state_dump(struct drm_device *dev, struct drm_printer *p);
/**
* for_each_oldnew_connector_in_state - iterate over all connectors in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @connector: &struct drm_connector iteration cursor
* @old_connector_state: &struct drm_connector_state iteration cursor for the
* old state
/**
* for_each_old_connector_in_state - iterate over all connectors in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @connector: &struct drm_connector iteration cursor
* @old_connector_state: &struct drm_connector_state iteration cursor for the
* old state
/**
* for_each_new_connector_in_state - iterate over all connectors in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @connector: &struct drm_connector iteration cursor
* @new_connector_state: &struct drm_connector_state iteration cursor for the
* new state
/**
* for_each_oldnew_crtc_in_state - iterate over all CRTCs in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @crtc: &struct drm_crtc iteration cursor
* @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
* @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
/**
* for_each_old_crtc_in_state - iterate over all CRTCs in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @crtc: &struct drm_crtc iteration cursor
* @old_crtc_state: &struct drm_crtc_state iteration cursor for the old state
* @__i: int iteration cursor, for macro-internal use
/**
* for_each_new_crtc_in_state - iterate over all CRTCs in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @crtc: &struct drm_crtc iteration cursor
* @new_crtc_state: &struct drm_crtc_state iteration cursor for the new state
* @__i: int iteration cursor, for macro-internal use
/**
* for_each_oldnew_colorop_in_state - iterate over all colorops in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @colorop: &struct drm_colorop iteration cursor
* @old_colorop_state: &struct drm_colorop_state iteration cursor for the old state
* @new_colorop_state: &struct drm_colorop_state iteration cursor for the new state
/**
* for_each_new_colorop_in_state - iterate over all colorops in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @colorop: &struct drm_colorop iteration cursor
* @new_colorop_state: &struct drm_colorop_state iteration cursor for the new state
* @__i: int iteration cursor, for macro-internal use
/**
* for_each_oldnew_plane_in_state - iterate over all planes in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @plane: &struct drm_plane iteration cursor
* @old_plane_state: &struct drm_plane_state iteration cursor for the old state
* @new_plane_state: &struct drm_plane_state iteration cursor for the new state
/**
* for_each_oldnew_plane_in_state_reverse - iterate over all planes in an atomic
* update in reverse order
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @plane: &struct drm_plane iteration cursor
* @old_plane_state: &struct drm_plane_state iteration cursor for the old state
* @new_plane_state: &struct drm_plane_state iteration cursor for the new state
/**
* for_each_new_plane_in_state_reverse - other than only tracking new state,
* it's the same as for_each_oldnew_plane_in_state_reverse
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @plane: &struct drm_plane iteration cursor
* @new_plane_state: &struct drm_plane_state iteration cursor for the new state
* @__i: int iteration cursor, for macro-internal use
/**
* for_each_old_plane_in_state - iterate over all planes in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @plane: &struct drm_plane iteration cursor
* @old_plane_state: &struct drm_plane_state iteration cursor for the old state
* @__i: int iteration cursor, for macro-internal use
(old_plane_state) = (__state)->planes[__i].old_state, 1))
/**
* for_each_new_plane_in_state - iterate over all planes in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @plane: &struct drm_plane iteration cursor
* @new_plane_state: &struct drm_plane_state iteration cursor for the new state
* @__i: int iteration cursor, for macro-internal use
/**
* for_each_oldnew_private_obj_in_state - iterate over all private objects in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @obj: &struct drm_private_obj iteration cursor
* @old_obj_state: &struct drm_private_state iteration cursor for the old state
* @new_obj_state: &struct drm_private_state iteration cursor for the new state
/**
* for_each_old_private_obj_in_state - iterate over all private objects in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @obj: &struct drm_private_obj iteration cursor
* @old_obj_state: &struct drm_private_state iteration cursor for the old state
* @__i: int iteration cursor, for macro-internal use
/**
* for_each_new_private_obj_in_state - iterate over all private objects in an atomic update
- * @__state: &struct drm_atomic_state pointer
+ * @__state: &struct drm_atomic_commit pointer
* @obj: &struct drm_private_obj iteration cursor
* @new_obj_state: &struct drm_private_state iteration cursor for the new state
* @__i: int iteration cursor, for macro-internal use
}
struct drm_bridge_state *
-drm_atomic_get_bridge_state(struct drm_atomic_state *state,
+drm_atomic_get_bridge_state(struct drm_atomic_commit *state,
struct drm_bridge *bridge);
struct drm_bridge_state *
-drm_atomic_get_old_bridge_state(const struct drm_atomic_state *state,
+drm_atomic_get_old_bridge_state(const struct drm_atomic_commit *state,
struct drm_bridge *bridge);
struct drm_bridge_state *
-drm_atomic_get_new_bridge_state(const struct drm_atomic_state *state,
+drm_atomic_get_new_bridge_state(const struct drm_atomic_commit *state,
struct drm_bridge *bridge);
#endif /* DRM_ATOMIC_H_ */
*/
#define DRM_PLANE_NO_SCALING (1<<16)
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_private_obj;
struct drm_private_state;
int drm_atomic_helper_check_modeset(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_atomic_helper_check_wb_connector_state(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_atomic_helper_check_plane_state(struct drm_plane_state *plane_state,
const struct drm_crtc_state *crtc_state,
int min_scale,
bool can_position,
bool can_update_disabled);
int drm_atomic_helper_check_planes(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_atomic_helper_check_crtc_primary_plane(struct drm_crtc_state *crtc_state);
void drm_atomic_helper_commit_encoder_bridge_disable(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_crtc_disable(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_encoder_bridge_post_disable(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_atomic_helper_check(struct drm_device *dev,
- struct drm_atomic_state *state);
-void drm_atomic_helper_commit_tail(struct drm_atomic_state *state);
-void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
+void drm_atomic_helper_commit_tail(struct drm_atomic_commit *state);
+void drm_atomic_helper_commit_tail_rpm(struct drm_atomic_commit *state);
int drm_atomic_helper_commit(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
bool nonblock);
int drm_atomic_helper_async_check(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_async_commit(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_atomic_helper_wait_for_fences(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
bool pre_swap);
void drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
void drm_atomic_helper_wait_for_flip_done(struct drm_device *dev,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
void
drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
void
-drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_state *state);
+drm_atomic_helper_calc_timestamping_constants(struct drm_atomic_commit *state);
void drm_atomic_helper_commit_crtc_set_mode(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_writebacks(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_encoder_bridge_pre_enable(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_crtc_enable(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_encoder_bridge_enable(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
int drm_atomic_helper_prepare_planes(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_unprepare_planes(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
#define DRM_PLANE_COMMIT_ACTIVE_ONLY BIT(0)
#define DRM_PLANE_COMMIT_NO_DISABLE_AFTER_MODESET BIT(1)
void drm_atomic_helper_commit_planes(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
uint32_t flags);
void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
- struct drm_atomic_state *old_state);
+ struct drm_atomic_commit *old_state);
void drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state);
void
drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc_state *old_crtc_state,
bool atomic);
-int __must_check drm_atomic_helper_swap_state(struct drm_atomic_state *state,
+int __must_check drm_atomic_helper_swap_state(struct drm_atomic_commit *state,
bool stall);
/* nonblocking commit helpers */
-int drm_atomic_helper_setup_commit(struct drm_atomic_state *state,
+int drm_atomic_helper_setup_commit(struct drm_atomic_commit *state,
bool nonblock);
-void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_state *state);
-void drm_atomic_helper_fake_vblank(struct drm_atomic_state *state);
-void drm_atomic_helper_commit_hw_done(struct drm_atomic_state *state);
-void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_state *state);
+void drm_atomic_helper_wait_for_dependencies(struct drm_atomic_commit *state);
+void drm_atomic_helper_fake_vblank(struct drm_atomic_commit *state);
+void drm_atomic_helper_commit_hw_done(struct drm_atomic_commit *state);
+void drm_atomic_helper_commit_cleanup_done(struct drm_atomic_commit *state);
/* implementations for legacy interfaces */
int drm_atomic_helper_update_plane(struct drm_plane *plane,
int drm_atomic_helper_reset_crtc(struct drm_crtc *crtc,
struct drm_modeset_acquire_ctx *ctx);
void drm_atomic_helper_shutdown(struct drm_device *dev);
-struct drm_atomic_state *
+struct drm_atomic_commit *
drm_atomic_helper_duplicate_state(struct drm_device *dev,
struct drm_modeset_acquire_ctx *ctx);
-struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev);
-int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_state *state,
+struct drm_atomic_commit *drm_atomic_helper_suspend(struct drm_device *dev);
+int drm_atomic_helper_commit_duplicated_state(struct drm_atomic_commit *state,
struct drm_modeset_acquire_ctx *ctx);
int drm_atomic_helper_resume(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
struct drm_framebuffer *fb,
#include <linux/types.h>
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_bridge;
struct drm_bridge_state;
struct drm_crtc;
void drm_atomic_helper_connector_reset(struct drm_connector *connector);
void drm_atomic_helper_connector_tv_reset(struct drm_connector *connector);
int drm_atomic_helper_connector_tv_check(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_helper_connector_tv_margins_reset(struct drm_connector *connector);
void
__drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
#define DRM_MODE_BLEND_COVERAGE 1
#define DRM_MODE_BLEND_PIXEL_NONE 2
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_crtc;
struct drm_device;
struct drm_plane;
int drm_plane_create_zpos_immutable_property(struct drm_plane *plane,
unsigned int zpos);
int drm_atomic_normalize_zpos(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
int drm_plane_create_blend_mode_property(struct drm_plane *plane,
unsigned int supported_modes);
void drm_crtc_attach_background_color_property(struct drm_crtc *crtc);
* The @atomic_pre_enable callback is optional.
*/
void (*atomic_pre_enable)(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_enable:
* The @atomic_enable callback is optional.
*/
void (*atomic_enable)(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_disable:
*
* The @atomic_disable callback is optional.
*/
void (*atomic_disable)(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_post_disable:
* The @atomic_post_disable callback is optional.
*/
void (*atomic_post_disable)(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_duplicate_state:
struct drm_crtc_state *crtc_state,
struct drm_connector_state *conn_state);
void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
u32 *
drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
*/
struct drm_property_blob *data;
- /** @state: backpointer to global drm_atomic_state */
- struct drm_atomic_state *state;
+ /** @state: backpointer to global drm_atomic_commit */
+ struct drm_atomic_commit *state;
};
/**
*/
enum drm_link_status link_status;
- /** @state: backpointer to global drm_atomic_state */
- struct drm_atomic_state *state;
+ /** @state: backpointer to global drm_atomic_commit */
+ struct drm_atomic_commit *state;
/**
* @commit: Tracks the pending commit to prevent use-after-free conditions.
*
* This is protected by &drm_mode_config.connection_mutex. Note that
* nonblocking atomic commits access the current connector state without
- * taking locks. Either by going through the &struct drm_atomic_state
+ * taking locks. Either by going through the &struct drm_atomic_commit
* pointers, see for_each_oldnew_connector_in_state(),
* for_each_old_connector_in_state() and
* for_each_new_connector_in_state(). Or through careful ordering of
struct drm_pending_vblank_event;
struct drm_plane;
struct drm_bridge;
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_crtc_helper_funcs;
struct drm_plane_helper_funcs;
*/
struct drm_crtc_commit *commit;
- /** @state: backpointer to global drm_atomic_state */
- struct drm_atomic_state *state;
+ /** @state: backpointer to global drm_atomic_commit */
+ struct drm_atomic_commit *state;
};
/**
*
* This is protected by @mutex. Note that nonblocking atomic commits
* access the current CRTC state without taking locks. Either by going
- * through the &struct drm_atomic_state pointers, see
+ * through the &struct drm_atomic_commit pointers, see
* for_each_oldnew_crtc_in_state(), for_each_old_crtc_in_state() and
* for_each_new_crtc_in_state(). Or through careful ordering of atomic
* commit operations as implemented in the atomic helpers, see
* @num_connectors: size of @connectors array
*
* This represents a modeset configuration for the legacy SETCRTC ioctl and is
- * also used internally. Atomic drivers instead use &drm_atomic_state.
+ * also used internally. Atomic drivers instead use &drm_atomic_commit.
*/
struct drm_mode_set {
struct drm_framebuffer *fb;
#include <linux/types.h>
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_connector;
struct drm_crtc;
struct drm_device;
int x, int y,
struct drm_framebuffer *old_fb);
int drm_crtc_helper_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
bool drm_helper_crtc_in_use(struct drm_crtc *crtc);
bool drm_helper_encoder_in_use(struct drm_encoder *encoder);
bool full_update;
};
-void drm_atomic_helper_check_plane_damage(struct drm_atomic_state *state,
+void drm_atomic_helper_check_plane_damage(struct drm_atomic_commit *state,
struct drm_plane_state *plane_state);
int drm_atomic_helper_dirtyfb(struct drm_framebuffer *fb,
struct drm_file *file_priv, unsigned int flags,
offsetof(_type, _member), \
_feat))
-struct drm_atomic_state *
+struct drm_atomic_commit *
drm_kunit_helper_atomic_state_alloc(struct kunit *test,
struct drm_device *drm,
struct drm_modeset_acquire_ctx *ctx);
.disable_plane = drm_atomic_helper_disable_plane
int drm_mipi_dbi_plane_helper_atomic_check(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_mipi_dbi_plane_helper_atomic_update(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
#define DRM_MIPI_DBI_PLANE_HELPER_FUNCS \
DRM_GEM_SHADOW_PLANE_HELPER_FUNCS, \
enum drm_mode_status drm_mipi_dbi_crtc_helper_mode_valid(struct drm_crtc *crtc,
const struct drm_display_mode *mode);
int drm_mipi_dbi_crtc_helper_atomic_check(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_mipi_dbi_crtc_helper_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
#define DRM_MIPI_DBI_CRTC_HELPER_FUNCS \
.mode_valid = drm_mipi_dbi_crtc_helper_mode_valid, \
struct drm_file;
struct drm_device;
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_mode_fb_cmd2;
struct drm_format_info;
struct drm_display_mode;
* error conditions which don't have to be checked at the in this
* callback.
*
- * See the documentation for &struct drm_atomic_state for how exactly
+ * See the documentation for &struct drm_atomic_commit for how exactly
* an atomic modeset update is described.
*
* Drivers using the atomic helpers can implement this hook using
* treated equally.
*/
int (*atomic_check)(struct drm_device *dev,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_commit:
* calling this function, and that nothing has been changed in the
* interim.
*
- * See the documentation for &struct drm_atomic_state for how exactly
+ * See the documentation for &struct drm_atomic_commit for how exactly
* an atomic modeset update is described.
*
* Drivers using the atomic helpers can implement this hook using
* additional modeset locks).
*/
int (*atomic_commit)(struct drm_device *dev,
- struct drm_atomic_state *state,
+ struct drm_atomic_commit *state,
bool nonblock);
/**
* @atomic_state_alloc:
*
* This optional hook can be used by drivers that want to subclass struct
- * &drm_atomic_state to be able to track their own driver-private global
+ * &drm_atomic_commit to be able to track their own driver-private global
* state easily. If this hook is implemented, drivers must also
* implement @atomic_state_clear and @atomic_state_free.
*
- * Subclassing of &drm_atomic_state is deprecated in favour of using
+ * Subclassing of &drm_atomic_commit is deprecated in favour of using
* &drm_private_state and &drm_private_obj.
*
* RETURNS:
*
- * A new &drm_atomic_state on success or NULL on failure.
+ * A new &drm_atomic_commit on success or NULL on failure.
*/
- struct drm_atomic_state *(*atomic_state_alloc)(struct drm_device *dev);
+ struct drm_atomic_commit *(*atomic_state_alloc)(struct drm_device *dev);
/**
* @atomic_state_clear:
*
* This hook must clear any driver private state duplicated into the
- * passed-in &drm_atomic_state. This hook is called when the caller
+ * passed-in &drm_atomic_commit. This hook is called when the caller
* encountered a &drm_modeset_lock deadlock and needs to drop all
* already acquired locks as part of the deadlock avoidance dance
* implemented in drm_modeset_backoff().
* update might change it, and the drm atomic interfaces always apply
* updates as relative changes to the current state.
*
- * Drivers that implement this must call drm_atomic_state_default_clear()
+ * Drivers that implement this must call drm_atomic_commit_default_clear()
* to clear common state.
*
- * Subclassing of &drm_atomic_state is deprecated in favour of using
+ * Subclassing of &drm_atomic_commit is deprecated in favour of using
* &drm_private_state and &drm_private_obj.
*/
- void (*atomic_state_clear)(struct drm_atomic_state *state);
+ void (*atomic_state_clear)(struct drm_atomic_commit *state);
/**
* @atomic_state_free:
*
- * This hook needs driver private resources and the &drm_atomic_state
- * itself. Note that the core first calls drm_atomic_state_clear() to
+ * This hook needs driver private resources and the &drm_atomic_commit
+ * itself. Note that the core first calls drm_atomic_commit_clear() to
* avoid code duplicate between the clear and free hooks.
*
* Drivers that implement this must call
- * drm_atomic_state_default_release() to release common resources.
+ * drm_atomic_commit_default_release() to release common resources.
*
- * Subclassing of &drm_atomic_state is deprecated in favour of using
+ * Subclassing of &drm_atomic_commit is deprecated in favour of using
* &drm_private_state and &drm_private_obj.
*/
- void (*atomic_state_free)(struct drm_atomic_state *state);
+ void (*atomic_state_free)(struct drm_atomic_commit *state);
};
/**
* Set by drm_mode_config_helper_suspend() and cleared by
* drm_mode_config_helper_resume().
*/
- struct drm_atomic_state *suspend_state;
+ struct drm_atomic_commit *suspend_state;
const struct drm_mode_config_helper_funcs *helper_private;
};
* deadlock.
*/
int (*atomic_check)(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_begin:
* optional.
*/
void (*atomic_begin)(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_flush:
*
* optional.
*/
void (*atomic_flush)(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_enable:
* This function is optional.
*/
void (*atomic_enable)(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_disable:
* This function is optional.
*/
void (*atomic_disable)(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @get_scanout_position:
* @atomic_enable.
*/
void (*atomic_disable)(struct drm_encoder *encoder,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_enable:
* @atomic_disable.
*/
void (*atomic_enable)(struct drm_encoder *encoder,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @disable:
*
* 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
+ * state objects passed-in or assembled in the overall &drm_atomic_commit
* update tracking structure.
*
* Also beware that userspace can request its own custom modes, neither
*
* This function is called in the check phase of an atomic update. The
* driver is not allowed to change anything outside of the
- * &drm_atomic_state update tracking structure passed in.
+ * &drm_atomic_commit update tracking structure passed in.
*
* RETURNS:
*
* for this.
*/
struct drm_encoder *(*atomic_best_encoder)(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_check:
*
* 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
+ * state objects passed-in or assembled in the overall &drm_atomic_commit
* update tracking structure.
*
* RETURNS:
* deadlock.
*/
int (*atomic_check)(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_commit:
* This callback is used by the atomic modeset helpers.
*/
void (*atomic_commit)(struct drm_connector *connector,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @prepare_writeback_job:
*
* This function is called in the check phase of an atomic update. The
* driver is not allowed to change anything outside of the
- * &drm_atomic_state update tracking structure.
+ * &drm_atomic_commit update tracking structure.
*
* RETURNS:
*
* deadlock.
*/
int (*atomic_check)(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_update:
* This callback is used by the atomic modeset helpers, but it is optional.
*/
void (*atomic_update)(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_enable:
* implement the complete plane update in @atomic_update.
*/
void (*atomic_enable)(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_disable:
* optional. It's intended to reverse the effects of @atomic_enable.
*/
void (*atomic_disable)(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @atomic_async_check:
* can not be applied in asynchronous manner.
*/
int (*atomic_async_check)(struct drm_plane *plane,
- struct drm_atomic_state *state, bool flip);
+ struct drm_atomic_commit *state, bool flip);
/**
* @atomic_async_update:
* for deferring if needed, until a common solution is created.
*/
void (*atomic_async_update)(struct drm_plane *plane,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
/**
* @get_scanout_buffer:
* This hook is optional, the default implementation is
* drm_atomic_helper_commit_tail().
*/
- void (*atomic_commit_tail)(struct drm_atomic_state *state);
+ void (*atomic_commit_tail)(struct drm_atomic_commit *state);
/**
* @atomic_commit_setup:
*
* This hook is optional.
*/
- int (*atomic_commit_setup)(struct drm_atomic_state *state);
+ int (*atomic_commit_setup)(struct drm_atomic_commit *state);
};
#endif
*/
struct drm_crtc_commit *commit;
- /** @state: backpointer to global drm_atomic_state */
- struct drm_atomic_state *state;
+ /** @state: backpointer to global drm_atomic_commit */
+ struct drm_atomic_commit *state;
/**
* @color_mgmt_changed: Color management properties have changed. Used
*
* This is protected by @mutex. Note that nonblocking atomic commits
* access the current plane state without taking locks. Either by going
- * through the &struct drm_atomic_state pointers, see
+ * through the &struct drm_atomic_commit pointers, see
* for_each_oldnew_plane_in_state(), for_each_old_plane_in_state() and
* for_each_new_plane_in_state(). Or through careful ordering of atomic
* commit operations as implemented in the atomic helpers, see
#ifndef DRM_SELF_REFRESH_HELPER_H_
#define DRM_SELF_REFRESH_HELPER_H_
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_crtc;
-void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state);
-void drm_self_refresh_helper_update_avg_times(struct drm_atomic_state *state,
+void drm_self_refresh_helper_alter_state(struct drm_atomic_commit *state);
+void drm_self_refresh_helper_update_avg_times(struct drm_atomic_commit *state,
unsigned int commit_time_ms,
unsigned int new_self_refresh_mask);
#include <linux/hrtimer_types.h>
#include <linux/types.h>
-struct drm_atomic_state;
+struct drm_atomic_commit;
struct drm_crtc;
/*
*/
void drm_crtc_vblank_atomic_flush(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_crtc_vblank_atomic_enable(struct drm_crtc *crtc,
- struct drm_atomic_state *state);
+ struct drm_atomic_commit *state);
void drm_crtc_vblank_atomic_disable(struct drm_crtc *crtc,
- struct drm_atomic_state *crtc_state);
+ struct drm_atomic_commit *crtc_state);
/**
* DRM_CRTC_HELPER_VBLANK_FUNCS - Default implementation for VBLANK helpers
projects / thirdparty / kernel / linux.git / commitdiff
