drivers/gpu/drm/i915/display/intel_modeset_verify.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2022 Intel Corporation
   4  *
   5  * High level crtc/connector/encoder modeset state verification.
   6  */
   7
   8 #include <drm/drm_atomic_state_helper.h>
   9
  10 #include "i915_drv.h"
  11 #include "intel_atomic.h"
  12 #include "intel_crtc.h"
  13 #include "intel_crtc_state_dump.h"
  14 #include "intel_display.h"
  15 #include "intel_display_types.h"
  16 #include "intel_fdi.h"
  17 #include "intel_modeset_verify.h"
  18 #include "intel_snps_phy.h"
  19 #include "skl_watermark.h"
  20
  21 /*
  22  * Cross check the actual hw state with our own modeset state tracking (and its
  23  * internal consistency).
  24  */
  25 static void intel_connector_verify_state(struct intel_crtc_state *crtc_state,
  26                                          struct drm_connector_state *conn_state)
  27 {
  28         struct intel_connector *connector = to_intel_connector(conn_state->connector);
  29         struct drm_i915_private *i915 = to_i915(connector->base.dev);
  30
  31         drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s]\n",
  32                     connector->base.base.id, connector->base.name);
  33
  34         if (connector->get_hw_state(connector)) {
  35                 struct intel_encoder *encoder = intel_attached_encoder(connector);
  36
  37                 I915_STATE_WARN(!crtc_state,
  38                                 "connector enabled without attached crtc\n");
  39
  40                 if (!crtc_state)
  41                         return;
  42
  43                 I915_STATE_WARN(!crtc_state->hw.active,
  44                                 "connector is active, but attached crtc isn't\n");
  45
  46                 if (!encoder || encoder->type == INTEL_OUTPUT_DP_MST)
  47                         return;
  48
  49                 I915_STATE_WARN(conn_state->best_encoder != &encoder->base,
  50                                 "atomic encoder doesn't match attached encoder\n");
  51
  52                 I915_STATE_WARN(conn_state->crtc != encoder->base.crtc,
  53                                 "attached encoder crtc differs from connector crtc\n");
  54         } else {
  55                 I915_STATE_WARN(crtc_state && crtc_state->hw.active,
  56                                 "attached crtc is active, but connector isn't\n");
  57                 I915_STATE_WARN(!crtc_state && conn_state->best_encoder,
  58                                 "best encoder set without crtc!\n");
  59         }
  60 }
  61
  62 static void
  63 verify_connector_state(struct intel_atomic_state *state,
  64                        struct intel_crtc *crtc)
  65 {
  66         struct drm_connector *connector;
  67         struct drm_connector_state *new_conn_state;
  68         int i;
  69
  70         for_each_new_connector_in_state(&state->base, connector, new_conn_state, i) {
  71                 struct drm_encoder *encoder = connector->encoder;
  72                 struct intel_crtc_state *crtc_state = NULL;
  73
  74                 if (new_conn_state->crtc != &crtc->base)
  75                         continue;
  76
  77                 if (crtc)
  78                         crtc_state = intel_atomic_get_new_crtc_state(state, crtc);
  79
  80                 intel_connector_verify_state(crtc_state, new_conn_state);
  81
  82                 I915_STATE_WARN(new_conn_state->best_encoder != encoder,
  83                                 "connector's atomic encoder doesn't match legacy encoder\n");
  84         }
  85 }
  86
  87 static void intel_pipe_config_sanity_check(struct drm_i915_private *dev_priv,
  88                                            const struct intel_crtc_state *pipe_config)
  89 {
  90         if (pipe_config->has_pch_encoder) {
  91                 int fdi_dotclock = intel_dotclock_calculate(intel_fdi_link_freq(dev_priv, pipe_config),
  92                                                             &pipe_config->fdi_m_n);
  93                 int dotclock = pipe_config->hw.adjusted_mode.crtc_clock;
  94
  95                 /*
  96                  * FDI already provided one idea for the dotclock.
  97                  * Yell if the encoder disagrees. Allow for slight
  98                  * rounding differences.
  99                  */
 100                 drm_WARN(&dev_priv->drm, abs(fdi_dotclock - dotclock) > 1,
 101                          "FDI dotclock and encoder dotclock mismatch, fdi: %i, encoder: %i\n",
 102                          fdi_dotclock, dotclock);
 103         }
 104 }
 105
 106 static void
 107 verify_encoder_state(struct drm_i915_private *dev_priv, struct intel_atomic_state *state)
 108 {
 109         struct intel_encoder *encoder;
 110         struct drm_connector *connector;
 111         struct drm_connector_state *old_conn_state, *new_conn_state;
 112         int i;
 113
 114         for_each_intel_encoder(&dev_priv->drm, encoder) {
 115                 bool enabled = false, found = false;
 116                 enum pipe pipe;
 117
 118                 drm_dbg_kms(&dev_priv->drm, "[ENCODER:%d:%s]\n",
 119                             encoder->base.base.id,
 120                             encoder->base.name);
 121
 122                 for_each_oldnew_connector_in_state(&state->base, connector, old_conn_state,
 123                                                    new_conn_state, i) {
 124                         if (old_conn_state->best_encoder == &encoder->base)
 125                                 found = true;
 126
 127                         if (new_conn_state->best_encoder != &encoder->base)
 128                                 continue;
 129
 130                         found = true;
 131                         enabled = true;
 132
 133                         I915_STATE_WARN(new_conn_state->crtc !=
 134                                         encoder->base.crtc,
 135                                         "connector's crtc doesn't match encoder crtc\n");
 136                 }
 137
 138                 if (!found)
 139                         continue;
 140
 141                 I915_STATE_WARN(!!encoder->base.crtc != enabled,
 142                                 "encoder's enabled state mismatch (expected %i, found %i)\n",
 143                                 !!encoder->base.crtc, enabled);
 144
 145                 if (!encoder->base.crtc) {
 146                         bool active;
 147
 148                         active = encoder->get_hw_state(encoder, &pipe);
 149                         I915_STATE_WARN(active,
 150                                         "encoder detached but still enabled on pipe %c.\n",
 151                                         pipe_name(pipe));
 152                 }
 153         }
 154 }
 155
 156 static void
 157 verify_crtc_state(struct intel_crtc *crtc,
 158                   struct intel_crtc_state *old_crtc_state,
 159                   struct intel_crtc_state *new_crtc_state)
 160 {
 161         struct drm_device *dev = crtc->base.dev;
 162         struct drm_i915_private *dev_priv = to_i915(dev);
 163         struct intel_encoder *encoder;
 164         struct intel_crtc_state *pipe_config = old_crtc_state;
 165         struct drm_atomic_state *state = old_crtc_state->uapi.state;
 166         struct intel_crtc *master_crtc;
 167
 168         __drm_atomic_helper_crtc_destroy_state(&old_crtc_state->uapi);
 169         intel_crtc_free_hw_state(old_crtc_state);
 170         intel_crtc_state_reset(old_crtc_state, crtc);
 171         old_crtc_state->uapi.state = state;
 172
 173         drm_dbg_kms(&dev_priv->drm, "[CRTC:%d:%s]\n", crtc->base.base.id,
 174                     crtc->base.name);
 175
 176         pipe_config->hw.enable = new_crtc_state->hw.enable;
 177
 178         intel_crtc_get_pipe_config(pipe_config);
 179
 180         /* we keep both pipes enabled on 830 */
 181         if (IS_I830(dev_priv) && pipe_config->hw.active)
 182                 pipe_config->hw.active = new_crtc_state->hw.active;
 183
 184         I915_STATE_WARN(new_crtc_state->hw.active != pipe_config->hw.active,
 185                         "crtc active state doesn't match with hw state (expected %i, found %i)\n",
 186                         new_crtc_state->hw.active, pipe_config->hw.active);
 187
 188         I915_STATE_WARN(crtc->active != new_crtc_state->hw.active,
 189                         "transitional active state does not match atomic hw state (expected %i, found %i)\n",
 190                         new_crtc_state->hw.active, crtc->active);
 191
 192         master_crtc = intel_master_crtc(new_crtc_state);
 193
 194         for_each_encoder_on_crtc(dev, &master_crtc->base, encoder) {
 195                 enum pipe pipe;
 196                 bool active;
 197
 198                 active = encoder->get_hw_state(encoder, &pipe);
 199                 I915_STATE_WARN(active != new_crtc_state->hw.active,
 200                                 "[ENCODER:%i] active %i with crtc active %i\n",
 201                                 encoder->base.base.id, active,
 202                                 new_crtc_state->hw.active);
 203
 204                 I915_STATE_WARN(active && master_crtc->pipe != pipe,
 205                                 "Encoder connected to wrong pipe %c\n",
 206                                 pipe_name(pipe));
 207
 208                 if (active)
 209                         intel_encoder_get_config(encoder, pipe_config);
 210         }
 211
 212         if (!new_crtc_state->hw.active)
 213                 return;
 214
 215         intel_pipe_config_sanity_check(dev_priv, pipe_config);
 216
 217         if (!intel_pipe_config_compare(new_crtc_state,
 218                                        pipe_config, false)) {
 219                 I915_STATE_WARN(1, "pipe state doesn't match!\n");
 220                 intel_crtc_state_dump(pipe_config, NULL, "hw state");
 221                 intel_crtc_state_dump(new_crtc_state, NULL, "sw state");
 222         }
 223 }
 224
 225 void intel_modeset_verify_crtc(struct intel_crtc *crtc,
 226                                struct intel_atomic_state *state,
 227                                struct intel_crtc_state *old_crtc_state,
 228                                struct intel_crtc_state *new_crtc_state)
 229 {
 230         if (!intel_crtc_needs_modeset(new_crtc_state) && !new_crtc_state->update_pipe)
 231                 return;
 232
 233         intel_wm_state_verify(crtc, new_crtc_state);
 234         verify_connector_state(state, crtc);
 235         verify_crtc_state(crtc, old_crtc_state, new_crtc_state);
 236         intel_shared_dpll_state_verify(crtc, old_crtc_state, new_crtc_state);
 237         intel_mpllb_state_verify(state, new_crtc_state);
 238 }
 239
 240 void intel_modeset_verify_disabled(struct drm_i915_private *dev_priv,
 241                                    struct intel_atomic_state *state)
 242 {
 243         verify_encoder_state(dev_priv, state);
 244         verify_connector_state(state, NULL);
 245         intel_shared_dpll_verify_disabled(dev_priv);
 246 }