AuxXxilium/linux_dsm_epyc7002
1
0
Fork 0
mirror of https://github.com/AuxXxilium/linux_dsm_epyc7002.git synced 2024-12-19 04:27:07 +07:00
Code Issues Actions Packages Projects Releases Wiki Activity

drm/i915: Read hw state into an atomic state struct, v2.

Browse Source 
To make this work we load the new hardware state into the
atomic_state, then swap it with the sw state.

This lets us change the force restore path in setup_hw_state()
to use a single call to intel_mode_set() to restore all the
previous state.

As a nice bonus this kills off encoder->new_encoder,
connector->new_enabled and crtc->new_enabled. They were used only
to restore the state after a modeset.

Changes since v1:
- Make sure all possible planes are added with their crtc set,
  so they will be turned off on first modeset.

Signed-off-by: Ander Conselvan de Oliveira <ander.conselvan.de.oliveira@intel.com>
Signed-off-by: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Reviewed-by: Matt Roper <matthew.d.roper@intel.com>
Signed-off-by: Jani Nikula <jani.nikula@intel.com>
This commit is contained in:
Ander Conselvan de Oliveira 2015-06-01 12:50:03 +02:00 committed by Jani Nikula
parent c347a6768d
commit 37ade41794
3 changed files with 248 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/gpu/drm/i915/intel_atomic.c
View File

@ -395,7 +395,7 @@ int intel_atomic_setup_scalers(struct drm_device *dev,
return 0;
}
static void
void
intel_atomic_duplicate_dpll_state(struct drm_i915_private *dev_priv,
struct intel_shared_dpll_config *shared_dpll)
{

389
drivers/gpu/drm/i915/intel_display.c
View File

@ -10312,7 +10312,7 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
retry:
ret = drm_modeset_lock(&config->connection_mutex, ctx);
if (ret)
goto fail_unlock;
goto fail;
/*
* Algorithm gets a little messy:
@ -10330,10 +10330,10 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
ret = drm_modeset_lock(&crtc->mutex, ctx);
if (ret)
goto fail_unlock;
goto fail;
ret = drm_modeset_lock(&crtc->primary->mutex, ctx);
if (ret)
goto fail_unlock;
goto fail;
old->dpms_mode = connector->dpms;
old->load_detect_temp = false;
@ -10352,9 +10352,6 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
continue;
if (possible_crtc->state->enable)
continue;
/* This can occur when applying the pipe A quirk on resume. */
if (to_intel_crtc(possible_crtc)->new_enabled)
continue;
crtc = possible_crtc;
break;
@ -10365,20 +10362,17 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
*/
if (!crtc) {
DRM_DEBUG_KMS("no pipe available for load-detect\n");
goto fail_unlock;
goto fail;
}
ret = drm_modeset_lock(&crtc->mutex, ctx);
if (ret)
goto fail_unlock;
goto fail;
ret = drm_modeset_lock(&crtc->primary->mutex, ctx);
if (ret)
goto fail_unlock;
intel_encoder->new_crtc = to_intel_crtc(crtc);
to_intel_connector(connector)->new_encoder = intel_encoder;
goto fail;
intel_crtc = to_intel_crtc(crtc);
intel_crtc->new_enabled = true;
old->dpms_mode = connector->dpms;
old->load_detect_temp = true;
old->release_fb = NULL;
@ -10446,9 +10440,7 @@ bool intel_get_load_detect_pipe(struct drm_connector *connector,
intel_wait_for_vblank(dev, intel_crtc->pipe);
return true;
fail:
intel_crtc->new_enabled = crtc->state->enable;
fail_unlock:
fail:
drm_atomic_state_free(state);
state = NULL;
@ -10494,10 +10486,6 @@ void intel_release_load_detect_pipe(struct drm_connector *connector,
if (IS_ERR(crtc_state))
goto fail;
to_intel_connector(connector)->new_encoder = NULL;
intel_encoder->new_crtc = NULL;
intel_crtc->new_enabled = false;
connector_state->best_encoder = NULL;
connector_state->crtc = NULL;
@ -11644,33 +11632,6 @@ static const struct drm_crtc_helper_funcs intel_helper_funcs = {
.atomic_flush = intel_finish_crtc_commit,
};
/**
* intel_modeset_update_staged_output_state
*
* Updates the staged output configuration state, e.g. after we've read out the
* current hw state.
*/
static void intel_modeset_update_staged_output_state(struct drm_device *dev)
{
struct intel_crtc *crtc;
struct intel_encoder *encoder;
struct intel_connector *connector;
for_each_intel_connector(dev, connector) {
connector->new_encoder =
to_intel_encoder(connector->base.encoder);
}
for_each_intel_encoder(dev, encoder) {
encoder->new_crtc =
to_intel_crtc(encoder->base.crtc);
}
for_each_intel_crtc(dev, crtc) {
crtc->new_enabled = crtc->base.state->enable;
}
}
/* Transitional helper to copy current connector/encoder state to
* connector->state. This is needed so that code that is partially
* converted to atomic does the right thing.
@ -12201,7 +12162,6 @@ intel_modeset_update_state(struct drm_atomic_state *state)
}
drm_atomic_helper_update_legacy_modeset_state(state->dev, state);
intel_modeset_update_staged_output_state(state->dev);
/* Double check state. */
for_each_crtc(dev, crtc) {
@ -12505,11 +12465,14 @@ check_connector_state(struct drm_device *dev)
struct intel_connector *connector;
for_each_intel_connector(dev, connector) {
struct drm_encoder *encoder = connector->base.encoder;
struct drm_connector_state *state = connector->base.state;
/* This also checks the encoder/connector hw state with the
* ->get_hw_state callbacks. */
intel_connector_check_state(connector);
I915_STATE_WARN(&connector->new_encoder->base != connector->base.encoder,
I915_STATE_WARN(state->best_encoder != encoder,
"connector's staged encoder doesn't match current encoder\n");
}
}
@ -12529,8 +12492,6 @@ check_encoder_state(struct drm_device *dev)
encoder->base.base.id,
encoder->base.name);
I915_STATE_WARN(&encoder->new_crtc->base != encoder->base.crtc,
"encoder's stage crtc doesn't match current crtc\n");
I915_STATE_WARN(encoder->connectors_active && !encoder->base.crtc,
"encoder's active_connectors set, but no crtc\n");
@ -12540,6 +12501,9 @@ check_encoder_state(struct drm_device *dev)
enabled = true;
if (connector->base.dpms != DRM_MODE_DPMS_OFF)
active = true;
I915_STATE_WARN(connector->base.state->crtc != encoder->base.crtc,
"encoder's stage crtc doesn't match current crtc\n");
}
/*
* for MST connectors if we unplug the connector is gone
@ -12969,11 +12933,11 @@ void intel_crtc_restore_mode(struct drm_crtc *crtc)
* need to copy the staged config to the atomic state, otherwise the
* mode set will just reapply the state the HW is already in. */
for_each_intel_encoder(dev, encoder) {
if (&encoder->new_crtc->base != crtc)
if (encoder->base.crtc != crtc)
continue;
for_each_intel_connector(dev, connector) {
if (connector->new_encoder != encoder)
if (connector->base.state->best_encoder != &encoder->base)
continue;
connector_state = drm_atomic_get_connector_state(state, &connector->base);
@ -12986,14 +12950,10 @@ void intel_crtc_restore_mode(struct drm_crtc *crtc)
}
connector_state->crtc = crtc;
connector_state->best_encoder = &encoder->base;
}
}
for_each_intel_crtc(dev, intel_crtc) {
if (intel_crtc->new_enabled == intel_crtc->base.enabled)
continue;
crtc_state = intel_atomic_get_crtc_state(state, intel_crtc);
if (IS_ERR(crtc_state)) {
DRM_DEBUG_KMS("Failed to add [CRTC:%d] to state: %ld\n",
@ -13002,9 +12962,6 @@ void intel_crtc_restore_mode(struct drm_crtc *crtc)
continue;
}
crtc_state->base.active = crtc_state->base.enable =
intel_crtc->new_enabled;
if (&intel_crtc->base == crtc)
drm_mode_copy(&crtc_state->base.mode, &crtc->mode);
}
@ -15080,6 +15037,7 @@ static void intel_sanitize_crtc(struct intel_crtc *crtc)
* ... */
plane = crtc->plane;
to_intel_plane_state(crtc->base.primary->state)->visible = true;
crtc->base.primary->crtc = &crtc->base;
crtc->plane = !plane;
intel_crtc_control(&crtc->base, false);
crtc->plane = plane;
@ -15243,78 +15201,182 @@ static bool primary_get_hw_state(struct intel_crtc *crtc)
{
struct drm_i915_private *dev_priv = crtc->base.dev->dev_private;
if (!crtc->active)
if (!crtc->base.enabled)
return false;
return I915_READ(DSPCNTR(crtc->plane)) & DISPLAY_PLANE_ENABLE;
}
static void intel_modeset_readout_hw_state(struct drm_device *dev)
static int readout_hw_crtc_state(struct drm_atomic_state *state,
struct intel_crtc *crtc)
{
struct drm_i915_private *dev_priv = dev->dev_private;
enum pipe pipe;
struct drm_i915_private *dev_priv = to_i915(state->dev);
struct intel_crtc_state *crtc_state;
struct drm_plane *primary = crtc->base.primary;
struct drm_plane_state *drm_plane_state;
struct intel_plane_state *plane_state;
int ret;
crtc_state = intel_atomic_get_crtc_state(state, crtc);
if (IS_ERR(crtc_state))
return PTR_ERR(crtc_state);
ret = drm_atomic_add_affected_planes(state, &crtc->base);
if (ret)
return ret;
memset(crtc_state, 0, sizeof(*crtc_state));
crtc_state->base.crtc = &crtc->base;
crtc_state->base.state = state;
crtc_state->quirks |= PIPE_CONFIG_QUIRK_INHERITED_MODE;
crtc_state->base.enable = crtc_state->base.active =
crtc->base.enabled = dev_priv->display.get_pipe_config(crtc, crtc_state);
/* update transitional state */
crtc->active = crtc_state->base.active;
crtc->config = crtc_state;
drm_plane_state = drm_atomic_get_plane_state(state, primary);
if (IS_ERR(drm_plane_state))
return PTR_ERR(drm_plane_state);
plane_state = to_intel_plane_state(drm_plane_state);
plane_state->visible = primary_get_hw_state(crtc);
if (plane_state->visible) {
primary->crtc = &crtc->base;
crtc_state->base.plane_mask |= 1 << drm_plane_index(primary);
} else
crtc_state->base.plane_mask &= ~(1 << drm_plane_index(primary));
DRM_DEBUG_KMS("[CRTC:%d] hw state readout: %s\n",
crtc->base.base.id,
crtc_state->base.active ? "enabled" : "disabled");
return 0;
}
static int readout_hw_pll_state(struct drm_atomic_state *state)
{
struct drm_i915_private *dev_priv = to_i915(state->dev);
struct intel_shared_dpll_config *shared_dpll;
struct intel_crtc *crtc;
struct intel_encoder *encoder;
struct intel_connector *connector;
struct intel_crtc_state *crtc_state;
int i;
for_each_intel_crtc(dev, crtc) {
struct drm_plane *primary = crtc->base.primary;
struct intel_plane_state *plane_state;
memset(crtc->config, 0, sizeof(*crtc->config));
crtc->config->base.crtc = &crtc->base;
crtc->config->quirks |= PIPE_CONFIG_QUIRK_INHERITED_MODE;
crtc->active = dev_priv->display.get_pipe_config(crtc,
crtc->config);
crtc->base.state->enable = crtc->active;
crtc->base.state->active = crtc->active;
crtc->base.enabled = crtc->active;
plane_state = to_intel_plane_state(primary->state);
plane_state->visible = primary_get_hw_state(crtc);
DRM_DEBUG_KMS("[CRTC:%d] hw state readout: %s\n",
crtc->base.base.id,
crtc->active ? "enabled" : "disabled");
}
shared_dpll = intel_atomic_get_shared_dpll_state(state);
for (i = 0; i < dev_priv->num_shared_dpll; i++) {
struct intel_shared_dpll *pll = &dev_priv->shared_dplls[i];
pll->on = pll->get_hw_state(dev_priv, pll,
&pll->config.hw_state);
&shared_dpll[i].hw_state);
pll->active = 0;
pll->config.crtc_mask = 0;
for_each_intel_crtc(dev, crtc) {
if (crtc->active && intel_crtc_to_shared_dpll(crtc) == pll) {
shared_dpll[i].crtc_mask = 0;
for_each_intel_crtc(state->dev, crtc) {
crtc_state = intel_atomic_get_crtc_state(state, crtc);
if (IS_ERR(crtc_state))
return PTR_ERR(crtc_state);
if (crtc_state->base.active &&
crtc_state->shared_dpll == i) {
pll->active++;
pll->config.crtc_mask |= 1 << crtc->pipe;
shared_dpll[i].crtc_mask |=
1 << crtc->pipe;
}
}
DRM_DEBUG_KMS("%s hw state readout: crtc_mask 0x%08x, on %i\n",
pll->name, pll->config.crtc_mask, pll->on);
pll->name, shared_dpll[i].crtc_mask,
pll->on);
if (pll->config.crtc_mask)
if (shared_dpll[i].crtc_mask)
intel_display_power_get(dev_priv, POWER_DOMAIN_PLLS);
}
return 0;
}
static struct drm_connector_state *
get_connector_state_for_encoder(struct drm_atomic_state *state,
struct intel_encoder *encoder)
{
struct drm_connector *connector;
struct drm_connector_state *connector_state;
int i;
for_each_connector_in_state(state, connector, connector_state, i)
if (connector_state->best_encoder == &encoder->base)
return connector_state;
return NULL;
}
static int readout_hw_connector_encoder_state(struct drm_atomic_state *state)
{
struct drm_device *dev = state->dev;
struct drm_i915_private *dev_priv = to_i915(state->dev);
struct intel_crtc *crtc;
struct drm_crtc_state *drm_crtc_state;
struct intel_crtc_state *crtc_state;
struct intel_encoder *encoder;
struct intel_connector *connector;
struct drm_connector_state *connector_state;
enum pipe pipe;
for_each_intel_connector(dev, connector) {
connector_state =
drm_atomic_get_connector_state(state, &connector->base);
if (IS_ERR(connector_state))
return PTR_ERR(connector_state);
if (connector->get_hw_state(connector)) {
connector->base.dpms = DRM_MODE_DPMS_ON;
connector->base.encoder = &connector->encoder->base;
} else {
connector->base.dpms = DRM_MODE_DPMS_OFF;
connector->base.encoder = NULL;
}
/* We'll update the crtc field when reading encoder state */
connector_state->crtc = NULL;
connector_state->best_encoder = connector->base.encoder;
DRM_DEBUG_KMS("[CONNECTOR:%d:%s] hw state readout: %s\n",
connector->base.base.id,
connector->base.name,
connector->base.encoder ? "enabled" : "disabled");
}
for_each_intel_encoder(dev, encoder) {
pipe = 0;
connector_state =
get_connector_state_for_encoder(state, encoder);
encoder->connectors_active = !!connector_state;
if (encoder->get_hw_state(encoder, &pipe)) {
crtc = to_intel_crtc(dev_priv->pipe_to_crtc_mapping[pipe]);
encoder->base.crtc = &crtc->base;
encoder->get_config(encoder, crtc->config);
encoder->base.crtc =
dev_priv->pipe_to_crtc_mapping[pipe];
crtc = to_intel_crtc(encoder->base.crtc);
drm_crtc_state =
state->crtc_states[drm_crtc_index(&crtc->base)];
crtc_state = to_intel_crtc_state(drm_crtc_state);
encoder->get_config(encoder, crtc_state);
if (connector_state)
connector_state->crtc = &crtc->base;
} else {
encoder->base.crtc = NULL;
}
encoder->connectors_active = false;
DRM_DEBUG_KMS("[ENCODER:%d:%s] hw state readout: %s, pipe %c\n",
encoder->base.base.id,
encoder->base.name,
@ -15322,20 +15384,42 @@ static void intel_modeset_readout_hw_state(struct drm_device *dev)
pipe_name(pipe));
}
for_each_intel_connector(dev, connector) {
if (connector->get_hw_state(connector)) {
connector->base.dpms = DRM_MODE_DPMS_ON;
connector->encoder->connectors_active = true;
connector->base.encoder = &connector->encoder->base;
} else {
connector->base.dpms = DRM_MODE_DPMS_OFF;
connector->base.encoder = NULL;
}
DRM_DEBUG_KMS("[CONNECTOR:%d:%s] hw state readout: %s\n",
connector->base.base.id,
connector->base.name,
connector->base.encoder ? "enabled" : "disabled");
return 0;
}
static struct drm_atomic_state *
intel_modeset_readout_hw_state(struct drm_device *dev)
{
struct intel_crtc *crtc;
int ret = 0;
struct drm_atomic_state *state;
state = drm_atomic_state_alloc(dev);
if (!state)
return ERR_PTR(-ENOMEM);
state->acquire_ctx = dev->mode_config.acquire_ctx;
for_each_intel_crtc(dev, crtc) {
ret = readout_hw_crtc_state(state, crtc);
if (ret)
goto err_free;
}
ret = readout_hw_pll_state(state);
if (ret)
goto err_free;
ret = readout_hw_connector_encoder_state(state);
if (ret)
goto err_free;
return state;
err_free:
drm_atomic_state_free(state);
return ERR_PTR(ret);
}
/* Scan out the current hw modeset state, sanitizes it and maps it into the drm
@ -15344,37 +15428,57 @@ void intel_modeset_setup_hw_state(struct drm_device *dev,
bool force_restore)
{
struct drm_i915_private *dev_priv = dev->dev_private;
enum pipe pipe;
struct intel_crtc *crtc;
struct drm_crtc *crtc;
struct drm_crtc_state *crtc_state;
struct intel_encoder *encoder;
struct drm_atomic_state *state;
struct intel_shared_dpll_config shared_dplls[I915_NUM_PLLS];
int i;
intel_modeset_readout_hw_state(dev);
/*
* Now that we have the config, copy it to each CRTC struct
* Note that this could go away if we move to using crtc_config
* checking everywhere.
*/
for_each_intel_crtc(dev, crtc) {
if (crtc->active && i915.fastboot) {
intel_mode_from_pipe_config(&crtc->base.mode,
crtc->config);
DRM_DEBUG_KMS("[CRTC:%d] found active mode: ",
crtc->base.base.id);
drm_mode_debug_printmodeline(&crtc->base.mode);
}
state = intel_modeset_readout_hw_state(dev);
if (IS_ERR(state)) {
DRM_ERROR("Failed to read out hw state\n");
return;
}
drm_atomic_helper_swap_state(dev, state);
/* swap sw/hw dpll state */
intel_atomic_duplicate_dpll_state(dev_priv, shared_dplls);
intel_shared_dpll_commit(state);
memcpy(to_intel_atomic_state(state)->shared_dpll,
shared_dplls, sizeof(*shared_dplls) * dev_priv->num_shared_dpll);
/* HW state is read out, now we need to sanitize this mess. */
for_each_intel_encoder(dev, encoder) {
intel_sanitize_encoder(encoder);
}
for_each_pipe(dev_priv, pipe) {
crtc = to_intel_crtc(dev_priv->pipe_to_crtc_mapping[pipe]);
intel_sanitize_crtc(crtc);
intel_dump_pipe_config(crtc, crtc->config,
for_each_crtc_in_state(state, crtc, crtc_state, i) {
struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
/* prevent unnneeded restores with force_restore */
crtc_state->active_changed =
crtc_state->mode_changed =
crtc_state->planes_changed = false;
if (crtc->enabled) {
intel_mode_from_pipe_config(&crtc->state->mode,
to_intel_crtc_state(crtc->state));
drm_mode_copy(&crtc->mode, &crtc->state->mode);
drm_mode_copy(&crtc->hwmode,
&crtc->state->adjusted_mode);
}
intel_sanitize_crtc(intel_crtc);
/*
* sanitize_crtc may have forced an update of crtc->state,
* so reload in intel_dump_pipe_config
*/
intel_dump_pipe_config(intel_crtc,
to_intel_crtc_state(crtc->state),
"[setup_hw_state]");
}
@ -15398,20 +15502,17 @@ void intel_modeset_setup_hw_state(struct drm_device *dev,
ilk_wm_get_hw_state(dev);
if (force_restore) {
int ret;
i915_redisable_vga(dev);
/*
* We need to use raw interfaces for restoring state to avoid
* checking (bogus) intermediate states.
*/
for_each_pipe(dev_priv, pipe) {
struct drm_crtc *crtc =
dev_priv->pipe_to_crtc_mapping[pipe];
intel_crtc_restore_mode(crtc);
ret = intel_set_mode(state);
if (ret) {
DRM_ERROR("Failed to restore previous mode\n");
drm_atomic_state_free(state);
}
} else {
intel_modeset_update_staged_output_state(dev);
drm_atomic_state_free(state);
}
intel_modeset_check_state(dev);

14
drivers/gpu/drm/i915/intel_drv.h
View File

@ -130,11 +130,6 @@ struct intel_fbdev {
struct intel_encoder {
struct drm_encoder base;
/*
* The new crtc this encoder will be driven from. Only differs from
* base->crtc while a modeset is in progress.
*/
struct intel_crtc *new_crtc;
enum intel_output_type type;
unsigned int cloneable;
@ -195,12 +190,6 @@ struct intel_connector {
*/
struct intel_encoder *encoder;
/*
* The new encoder this connector will be driven. Only differs from
* encoder while a modeset is in progress.
*/
struct intel_encoder *new_encoder;
/* Reads out the current hw, returning true if the connector is enabled
* and active (i.e. dpms ON state). */
bool (*get_hw_state)(struct intel_connector *);
@ -535,7 +524,6 @@ struct intel_crtc {
struct intel_initial_plane_config plane_config;
struct intel_crtc_state *config;
bool new_enabled;
/* reset counter value when the last flip was submitted */
unsigned int reset_counter;
@ -1416,6 +1404,8 @@ struct drm_atomic_state *intel_atomic_state_alloc(struct drm_device *dev);
void intel_atomic_state_clear(struct drm_atomic_state *);
struct intel_shared_dpll_config *
intel_atomic_get_shared_dpll_state(struct drm_atomic_state *s);
void intel_atomic_duplicate_dpll_state(struct drm_i915_private *,
struct intel_shared_dpll_config *);
static inline struct intel_crtc_state *
intel_atomic_get_crtc_state(struct drm_atomic_state *state,