1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2022 Intel Corporation 4 * 5 * Read out the current hardware modeset state, and sanitize it to the current 6 * state. 7 */ 8 9 #include <drm/drm_atomic_uapi.h> 10 #include <drm/drm_atomic_state_helper.h> 11 12 #include "i915_drv.h" 13 #include "i915_reg.h" 14 #include "i9xx_wm.h" 15 #include "intel_atomic.h" 16 #include "intel_bw.h" 17 #include "intel_color.h" 18 #include "intel_crtc.h" 19 #include "intel_crtc_state_dump.h" 20 #include "intel_ddi.h" 21 #include "intel_de.h" 22 #include "intel_display.h" 23 #include "intel_display_power.h" 24 #include "intel_display_types.h" 25 #include "intel_dmc.h" 26 #include "intel_fifo_underrun.h" 27 #include "intel_modeset_setup.h" 28 #include "intel_pch_display.h" 29 #include "intel_pmdemand.h" 30 #include "intel_tc.h" 31 #include "intel_vblank.h" 32 #include "intel_wm.h" 33 #include "skl_watermark.h" 34 intel_crtc_disable_noatomic_begin(struct intel_crtc * crtc,struct drm_modeset_acquire_ctx * ctx)35 static void intel_crtc_disable_noatomic_begin(struct intel_crtc *crtc, 36 struct drm_modeset_acquire_ctx *ctx) 37 { 38 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 39 struct intel_crtc_state *crtc_state = 40 to_intel_crtc_state(crtc->base.state); 41 struct intel_plane *plane; 42 struct drm_atomic_state *state; 43 struct intel_crtc *temp_crtc; 44 enum pipe pipe = crtc->pipe; 45 46 if (!crtc_state->hw.active) 47 return; 48 49 for_each_intel_plane_on_crtc(&i915->drm, crtc, plane) { 50 const struct intel_plane_state *plane_state = 51 to_intel_plane_state(plane->base.state); 52 53 if (plane_state->uapi.visible) 54 intel_plane_disable_noatomic(crtc, plane); 55 } 56 57 state = drm_atomic_state_alloc(&i915->drm); 58 if (!state) { 59 drm_dbg_kms(&i915->drm, 60 "failed to disable [CRTC:%d:%s], out of memory", 61 crtc->base.base.id, crtc->base.name); 62 return; 63 } 64 65 state->acquire_ctx = ctx; 66 to_intel_atomic_state(state)->internal = true; 67 68 /* Everything's already locked, -EDEADLK can't happen. */ 69 for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, 70 BIT(pipe) | 71 intel_crtc_bigjoiner_slave_pipes(crtc_state)) { 72 struct intel_crtc_state *temp_crtc_state = 73 intel_atomic_get_crtc_state(state, temp_crtc); 74 int ret; 75 76 ret = drm_atomic_add_affected_connectors(state, &temp_crtc->base); 77 78 drm_WARN_ON(&i915->drm, IS_ERR(temp_crtc_state) || ret); 79 } 80 81 i915->display.funcs.display->crtc_disable(to_intel_atomic_state(state), crtc); 82 83 drm_atomic_state_put(state); 84 85 drm_dbg_kms(&i915->drm, 86 "[CRTC:%d:%s] hw state adjusted, was enabled, now disabled\n", 87 crtc->base.base.id, crtc->base.name); 88 89 crtc->active = false; 90 crtc->base.enabled = false; 91 92 if (crtc_state->shared_dpll) 93 intel_unreference_shared_dpll_crtc(crtc, 94 crtc_state->shared_dpll, 95 &crtc_state->shared_dpll->state); 96 } 97 set_encoder_for_connector(struct intel_connector * connector,struct intel_encoder * encoder)98 static void set_encoder_for_connector(struct intel_connector *connector, 99 struct intel_encoder *encoder) 100 { 101 struct drm_connector_state *conn_state = connector->base.state; 102 103 if (conn_state->crtc) 104 drm_connector_put(&connector->base); 105 106 if (encoder) { 107 conn_state->best_encoder = &encoder->base; 108 conn_state->crtc = encoder->base.crtc; 109 drm_connector_get(&connector->base); 110 } else { 111 conn_state->best_encoder = NULL; 112 conn_state->crtc = NULL; 113 } 114 } 115 reset_encoder_connector_state(struct intel_encoder * encoder)116 static void reset_encoder_connector_state(struct intel_encoder *encoder) 117 { 118 struct drm_i915_private *i915 = to_i915(encoder->base.dev); 119 struct intel_pmdemand_state *pmdemand_state = 120 to_intel_pmdemand_state(i915->display.pmdemand.obj.state); 121 struct intel_connector *connector; 122 struct drm_connector_list_iter conn_iter; 123 124 drm_connector_list_iter_begin(&i915->drm, &conn_iter); 125 for_each_intel_connector_iter(connector, &conn_iter) { 126 if (connector->base.encoder != &encoder->base) 127 continue; 128 129 /* Clear the corresponding bit in pmdemand active phys mask */ 130 intel_pmdemand_update_phys_mask(i915, encoder, 131 pmdemand_state, false); 132 133 set_encoder_for_connector(connector, NULL); 134 135 connector->base.dpms = DRM_MODE_DPMS_OFF; 136 connector->base.encoder = NULL; 137 } 138 drm_connector_list_iter_end(&conn_iter); 139 } 140 reset_crtc_encoder_state(struct intel_crtc * crtc)141 static void reset_crtc_encoder_state(struct intel_crtc *crtc) 142 { 143 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 144 struct intel_encoder *encoder; 145 146 for_each_encoder_on_crtc(&i915->drm, &crtc->base, encoder) { 147 reset_encoder_connector_state(encoder); 148 encoder->base.crtc = NULL; 149 } 150 } 151 intel_crtc_disable_noatomic_complete(struct intel_crtc * crtc)152 static void intel_crtc_disable_noatomic_complete(struct intel_crtc *crtc) 153 { 154 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 155 struct intel_bw_state *bw_state = 156 to_intel_bw_state(i915->display.bw.obj.state); 157 struct intel_cdclk_state *cdclk_state = 158 to_intel_cdclk_state(i915->display.cdclk.obj.state); 159 struct intel_dbuf_state *dbuf_state = 160 to_intel_dbuf_state(i915->display.dbuf.obj.state); 161 struct intel_pmdemand_state *pmdemand_state = 162 to_intel_pmdemand_state(i915->display.pmdemand.obj.state); 163 struct intel_crtc_state *crtc_state = 164 to_intel_crtc_state(crtc->base.state); 165 enum pipe pipe = crtc->pipe; 166 167 __drm_atomic_helper_crtc_destroy_state(&crtc_state->uapi); 168 intel_crtc_free_hw_state(crtc_state); 169 intel_crtc_state_reset(crtc_state, crtc); 170 171 reset_crtc_encoder_state(crtc); 172 173 intel_fbc_disable(crtc); 174 intel_update_watermarks(i915); 175 176 intel_display_power_put_all_in_set(i915, &crtc->enabled_power_domains); 177 178 cdclk_state->min_cdclk[pipe] = 0; 179 cdclk_state->min_voltage_level[pipe] = 0; 180 cdclk_state->active_pipes &= ~BIT(pipe); 181 182 dbuf_state->active_pipes &= ~BIT(pipe); 183 184 bw_state->data_rate[pipe] = 0; 185 bw_state->num_active_planes[pipe] = 0; 186 187 intel_pmdemand_update_port_clock(i915, pmdemand_state, pipe, 0); 188 } 189 190 /* 191 * Return all the pipes using a transcoder in @transcoder_mask. 192 * For bigjoiner configs return only the bigjoiner master. 193 */ get_transcoder_pipes(struct drm_i915_private * i915,u8 transcoder_mask)194 static u8 get_transcoder_pipes(struct drm_i915_private *i915, 195 u8 transcoder_mask) 196 { 197 struct intel_crtc *temp_crtc; 198 u8 pipes = 0; 199 200 for_each_intel_crtc(&i915->drm, temp_crtc) { 201 struct intel_crtc_state *temp_crtc_state = 202 to_intel_crtc_state(temp_crtc->base.state); 203 204 if (temp_crtc_state->cpu_transcoder == INVALID_TRANSCODER) 205 continue; 206 207 if (intel_crtc_is_bigjoiner_slave(temp_crtc_state)) 208 continue; 209 210 if (transcoder_mask & BIT(temp_crtc_state->cpu_transcoder)) 211 pipes |= BIT(temp_crtc->pipe); 212 } 213 214 return pipes; 215 } 216 217 /* 218 * Return the port sync master and slave pipes linked to @crtc. 219 * For bigjoiner configs return only the bigjoiner master pipes. 220 */ get_portsync_pipes(struct intel_crtc * crtc,u8 * master_pipe_mask,u8 * slave_pipes_mask)221 static void get_portsync_pipes(struct intel_crtc *crtc, 222 u8 *master_pipe_mask, u8 *slave_pipes_mask) 223 { 224 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 225 struct intel_crtc_state *crtc_state = 226 to_intel_crtc_state(crtc->base.state); 227 struct intel_crtc *master_crtc; 228 struct intel_crtc_state *master_crtc_state; 229 enum transcoder master_transcoder; 230 231 if (!is_trans_port_sync_mode(crtc_state)) { 232 *master_pipe_mask = BIT(crtc->pipe); 233 *slave_pipes_mask = 0; 234 235 return; 236 } 237 238 if (is_trans_port_sync_master(crtc_state)) 239 master_transcoder = crtc_state->cpu_transcoder; 240 else 241 master_transcoder = crtc_state->master_transcoder; 242 243 *master_pipe_mask = get_transcoder_pipes(i915, BIT(master_transcoder)); 244 drm_WARN_ON(&i915->drm, !is_power_of_2(*master_pipe_mask)); 245 246 master_crtc = intel_crtc_for_pipe(i915, ffs(*master_pipe_mask) - 1); 247 master_crtc_state = to_intel_crtc_state(master_crtc->base.state); 248 *slave_pipes_mask = get_transcoder_pipes(i915, master_crtc_state->sync_mode_slaves_mask); 249 } 250 get_bigjoiner_slave_pipes(struct drm_i915_private * i915,u8 master_pipes_mask)251 static u8 get_bigjoiner_slave_pipes(struct drm_i915_private *i915, u8 master_pipes_mask) 252 { 253 struct intel_crtc *master_crtc; 254 u8 pipes = 0; 255 256 for_each_intel_crtc_in_pipe_mask(&i915->drm, master_crtc, master_pipes_mask) { 257 struct intel_crtc_state *master_crtc_state = 258 to_intel_crtc_state(master_crtc->base.state); 259 260 pipes |= intel_crtc_bigjoiner_slave_pipes(master_crtc_state); 261 } 262 263 return pipes; 264 } 265 intel_crtc_disable_noatomic(struct intel_crtc * crtc,struct drm_modeset_acquire_ctx * ctx)266 static void intel_crtc_disable_noatomic(struct intel_crtc *crtc, 267 struct drm_modeset_acquire_ctx *ctx) 268 { 269 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 270 u8 portsync_master_mask; 271 u8 portsync_slaves_mask; 272 u8 bigjoiner_slaves_mask; 273 struct intel_crtc *temp_crtc; 274 275 /* TODO: Add support for MST */ 276 get_portsync_pipes(crtc, &portsync_master_mask, &portsync_slaves_mask); 277 bigjoiner_slaves_mask = get_bigjoiner_slave_pipes(i915, 278 portsync_master_mask | 279 portsync_slaves_mask); 280 281 drm_WARN_ON(&i915->drm, 282 portsync_master_mask & portsync_slaves_mask || 283 portsync_master_mask & bigjoiner_slaves_mask || 284 portsync_slaves_mask & bigjoiner_slaves_mask); 285 286 for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, bigjoiner_slaves_mask) 287 intel_crtc_disable_noatomic_begin(temp_crtc, ctx); 288 289 for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, portsync_slaves_mask) 290 intel_crtc_disable_noatomic_begin(temp_crtc, ctx); 291 292 for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, portsync_master_mask) 293 intel_crtc_disable_noatomic_begin(temp_crtc, ctx); 294 295 for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, 296 bigjoiner_slaves_mask | 297 portsync_slaves_mask | 298 portsync_master_mask) 299 intel_crtc_disable_noatomic_complete(temp_crtc); 300 } 301 intel_modeset_update_connector_atomic_state(struct drm_i915_private * i915)302 static void intel_modeset_update_connector_atomic_state(struct drm_i915_private *i915) 303 { 304 struct intel_connector *connector; 305 struct drm_connector_list_iter conn_iter; 306 307 drm_connector_list_iter_begin(&i915->drm, &conn_iter); 308 for_each_intel_connector_iter(connector, &conn_iter) { 309 struct drm_connector_state *conn_state = connector->base.state; 310 struct intel_encoder *encoder = 311 to_intel_encoder(connector->base.encoder); 312 313 set_encoder_for_connector(connector, encoder); 314 315 if (encoder) { 316 struct intel_crtc *crtc = 317 to_intel_crtc(encoder->base.crtc); 318 const struct intel_crtc_state *crtc_state = 319 to_intel_crtc_state(crtc->base.state); 320 321 conn_state->max_bpc = (crtc_state->pipe_bpp ?: 24) / 3; 322 } 323 } 324 drm_connector_list_iter_end(&conn_iter); 325 } 326 intel_crtc_copy_hw_to_uapi_state(struct intel_crtc_state * crtc_state)327 static void intel_crtc_copy_hw_to_uapi_state(struct intel_crtc_state *crtc_state) 328 { 329 if (intel_crtc_is_bigjoiner_slave(crtc_state)) 330 return; 331 332 crtc_state->uapi.enable = crtc_state->hw.enable; 333 crtc_state->uapi.active = crtc_state->hw.active; 334 drm_WARN_ON(crtc_state->uapi.crtc->dev, 335 drm_atomic_set_mode_for_crtc(&crtc_state->uapi, &crtc_state->hw.mode) < 0); 336 337 crtc_state->uapi.adjusted_mode = crtc_state->hw.adjusted_mode; 338 crtc_state->uapi.scaling_filter = crtc_state->hw.scaling_filter; 339 340 /* assume 1:1 mapping */ 341 drm_property_replace_blob(&crtc_state->hw.degamma_lut, 342 crtc_state->pre_csc_lut); 343 drm_property_replace_blob(&crtc_state->hw.gamma_lut, 344 crtc_state->post_csc_lut); 345 346 drm_property_replace_blob(&crtc_state->uapi.degamma_lut, 347 crtc_state->hw.degamma_lut); 348 drm_property_replace_blob(&crtc_state->uapi.gamma_lut, 349 crtc_state->hw.gamma_lut); 350 drm_property_replace_blob(&crtc_state->uapi.ctm, 351 crtc_state->hw.ctm); 352 } 353 354 static void intel_sanitize_plane_mapping(struct drm_i915_private * i915)355 intel_sanitize_plane_mapping(struct drm_i915_private *i915) 356 { 357 struct intel_crtc *crtc; 358 359 if (DISPLAY_VER(i915) >= 4) 360 return; 361 362 for_each_intel_crtc(&i915->drm, crtc) { 363 struct intel_plane *plane = 364 to_intel_plane(crtc->base.primary); 365 struct intel_crtc *plane_crtc; 366 enum pipe pipe; 367 368 if (!plane->get_hw_state(plane, &pipe)) 369 continue; 370 371 if (pipe == crtc->pipe) 372 continue; 373 374 drm_dbg_kms(&i915->drm, 375 "[PLANE:%d:%s] attached to the wrong pipe, disabling plane\n", 376 plane->base.base.id, plane->base.name); 377 378 plane_crtc = intel_crtc_for_pipe(i915, pipe); 379 intel_plane_disable_noatomic(plane_crtc, plane); 380 } 381 } 382 intel_crtc_has_encoders(struct intel_crtc * crtc)383 static bool intel_crtc_has_encoders(struct intel_crtc *crtc) 384 { 385 struct drm_device *dev = crtc->base.dev; 386 struct intel_encoder *encoder; 387 388 for_each_encoder_on_crtc(dev, &crtc->base, encoder) 389 return true; 390 391 return false; 392 } 393 intel_crtc_needs_link_reset(struct intel_crtc * crtc)394 static bool intel_crtc_needs_link_reset(struct intel_crtc *crtc) 395 { 396 struct drm_device *dev = crtc->base.dev; 397 struct intel_encoder *encoder; 398 399 for_each_encoder_on_crtc(dev, &crtc->base, encoder) { 400 struct intel_digital_port *dig_port = enc_to_dig_port(encoder); 401 402 if (dig_port && intel_tc_port_link_needs_reset(dig_port)) 403 return true; 404 } 405 406 return false; 407 } 408 intel_encoder_find_connector(struct intel_encoder * encoder)409 static struct intel_connector *intel_encoder_find_connector(struct intel_encoder *encoder) 410 { 411 struct drm_i915_private *i915 = to_i915(encoder->base.dev); 412 struct drm_connector_list_iter conn_iter; 413 struct intel_connector *connector; 414 struct intel_connector *found_connector = NULL; 415 416 drm_connector_list_iter_begin(&i915->drm, &conn_iter); 417 for_each_intel_connector_iter(connector, &conn_iter) { 418 if (&encoder->base == connector->base.encoder) { 419 found_connector = connector; 420 break; 421 } 422 } 423 drm_connector_list_iter_end(&conn_iter); 424 425 return found_connector; 426 } 427 intel_sanitize_fifo_underrun_reporting(const struct intel_crtc_state * crtc_state)428 static void intel_sanitize_fifo_underrun_reporting(const struct intel_crtc_state *crtc_state) 429 { 430 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 431 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 432 433 /* 434 * We start out with underrun reporting disabled on active 435 * pipes to avoid races. 436 * 437 * Also on gmch platforms we dont have any hardware bits to 438 * disable the underrun reporting. Which means we need to start 439 * out with underrun reporting disabled also on inactive pipes, 440 * since otherwise we'll complain about the garbage we read when 441 * e.g. coming up after runtime pm. 442 * 443 * No protection against concurrent access is required - at 444 * worst a fifo underrun happens which also sets this to false. 445 */ 446 intel_init_fifo_underrun_reporting(i915, crtc, 447 !crtc_state->hw.active && 448 !HAS_GMCH(i915)); 449 } 450 intel_sanitize_crtc(struct intel_crtc * crtc,struct drm_modeset_acquire_ctx * ctx)451 static bool intel_sanitize_crtc(struct intel_crtc *crtc, 452 struct drm_modeset_acquire_ctx *ctx) 453 { 454 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 455 struct intel_crtc_state *crtc_state = to_intel_crtc_state(crtc->base.state); 456 bool needs_link_reset; 457 458 if (crtc_state->hw.active) { 459 struct intel_plane *plane; 460 461 /* Disable everything but the primary plane */ 462 for_each_intel_plane_on_crtc(&i915->drm, crtc, plane) { 463 const struct intel_plane_state *plane_state = 464 to_intel_plane_state(plane->base.state); 465 466 if (plane_state->uapi.visible && 467 plane->base.type != DRM_PLANE_TYPE_PRIMARY) 468 intel_plane_disable_noatomic(crtc, plane); 469 } 470 471 /* Disable any background color/etc. set by the BIOS */ 472 intel_color_commit_noarm(crtc_state); 473 intel_color_commit_arm(crtc_state); 474 } 475 476 if (!crtc_state->hw.active || 477 intel_crtc_is_bigjoiner_slave(crtc_state)) 478 return false; 479 480 needs_link_reset = intel_crtc_needs_link_reset(crtc); 481 482 /* 483 * Adjust the state of the output pipe according to whether we have 484 * active connectors/encoders. 485 */ 486 if (!needs_link_reset && intel_crtc_has_encoders(crtc)) 487 return false; 488 489 intel_crtc_disable_noatomic(crtc, ctx); 490 491 /* 492 * The HPD state on other active/disconnected TC ports may be stuck in 493 * the connected state until this port is disabled and a ~10ms delay has 494 * passed, wait here for that so that sanitizing other CRTCs will see the 495 * up-to-date HPD state. 496 */ 497 if (needs_link_reset) 498 msleep(20); 499 500 return true; 501 } 502 intel_sanitize_all_crtcs(struct drm_i915_private * i915,struct drm_modeset_acquire_ctx * ctx)503 static void intel_sanitize_all_crtcs(struct drm_i915_private *i915, 504 struct drm_modeset_acquire_ctx *ctx) 505 { 506 struct intel_crtc *crtc; 507 u32 crtcs_forced_off = 0; 508 509 /* 510 * An active and disconnected TypeC port prevents the HPD live state 511 * to get updated on other active/disconnected TypeC ports, so after 512 * a port gets disabled the CRTCs using other TypeC ports must be 513 * rechecked wrt. their link status. 514 */ 515 for (;;) { 516 u32 old_mask = crtcs_forced_off; 517 518 for_each_intel_crtc(&i915->drm, crtc) { 519 u32 crtc_mask = drm_crtc_mask(&crtc->base); 520 521 if (crtcs_forced_off & crtc_mask) 522 continue; 523 524 if (intel_sanitize_crtc(crtc, ctx)) 525 crtcs_forced_off |= crtc_mask; 526 } 527 if (crtcs_forced_off == old_mask) 528 break; 529 } 530 531 for_each_intel_crtc(&i915->drm, crtc) { 532 struct intel_crtc_state *crtc_state = 533 to_intel_crtc_state(crtc->base.state); 534 535 intel_crtc_state_dump(crtc_state, NULL, "setup_hw_state"); 536 } 537 } 538 has_bogus_dpll_config(const struct intel_crtc_state * crtc_state)539 static bool has_bogus_dpll_config(const struct intel_crtc_state *crtc_state) 540 { 541 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev); 542 543 /* 544 * Some SNB BIOSen (eg. ASUS K53SV) are known to misprogram 545 * the hardware when a high res displays plugged in. DPLL P 546 * divider is zero, and the pipe timings are bonkers. We'll 547 * try to disable everything in that case. 548 * 549 * FIXME would be nice to be able to sanitize this state 550 * without several WARNs, but for now let's take the easy 551 * road. 552 */ 553 return IS_SANDYBRIDGE(i915) && 554 crtc_state->hw.active && 555 crtc_state->shared_dpll && 556 crtc_state->port_clock == 0; 557 } 558 intel_sanitize_encoder(struct intel_encoder * encoder)559 static void intel_sanitize_encoder(struct intel_encoder *encoder) 560 { 561 struct drm_i915_private *i915 = to_i915(encoder->base.dev); 562 struct intel_connector *connector; 563 struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc); 564 struct intel_crtc_state *crtc_state = crtc ? 565 to_intel_crtc_state(crtc->base.state) : NULL; 566 struct intel_pmdemand_state *pmdemand_state = 567 to_intel_pmdemand_state(i915->display.pmdemand.obj.state); 568 569 /* 570 * We need to check both for a crtc link (meaning that the encoder is 571 * active and trying to read from a pipe) and the pipe itself being 572 * active. 573 */ 574 bool has_active_crtc = crtc_state && 575 crtc_state->hw.active; 576 577 if (crtc_state && has_bogus_dpll_config(crtc_state)) { 578 drm_dbg_kms(&i915->drm, 579 "BIOS has misprogrammed the hardware. Disabling pipe %c\n", 580 pipe_name(crtc->pipe)); 581 has_active_crtc = false; 582 } 583 584 connector = intel_encoder_find_connector(encoder); 585 if (connector && !has_active_crtc) { 586 drm_dbg_kms(&i915->drm, 587 "[ENCODER:%d:%s] has active connectors but no active pipe!\n", 588 encoder->base.base.id, 589 encoder->base.name); 590 591 /* Clear the corresponding bit in pmdemand active phys mask */ 592 intel_pmdemand_update_phys_mask(i915, encoder, 593 pmdemand_state, false); 594 595 /* 596 * Connector is active, but has no active pipe. This is fallout 597 * from our resume register restoring. Disable the encoder 598 * manually again. 599 */ 600 if (crtc_state) { 601 struct drm_encoder *best_encoder; 602 603 drm_dbg_kms(&i915->drm, 604 "[ENCODER:%d:%s] manually disabled\n", 605 encoder->base.base.id, 606 encoder->base.name); 607 608 /* avoid oopsing in case the hooks consult best_encoder */ 609 best_encoder = connector->base.state->best_encoder; 610 connector->base.state->best_encoder = &encoder->base; 611 612 /* FIXME NULL atomic state passed! */ 613 if (encoder->disable) 614 encoder->disable(NULL, encoder, crtc_state, 615 connector->base.state); 616 if (encoder->post_disable) 617 encoder->post_disable(NULL, encoder, crtc_state, 618 connector->base.state); 619 620 connector->base.state->best_encoder = best_encoder; 621 } 622 encoder->base.crtc = NULL; 623 624 /* 625 * Inconsistent output/port/pipe state happens presumably due to 626 * a bug in one of the get_hw_state functions. Or someplace else 627 * in our code, like the register restore mess on resume. Clamp 628 * things to off as a safer default. 629 */ 630 connector->base.dpms = DRM_MODE_DPMS_OFF; 631 connector->base.encoder = NULL; 632 } 633 634 /* notify opregion of the sanitized encoder state */ 635 intel_opregion_notify_encoder(encoder, connector && has_active_crtc); 636 637 if (HAS_DDI(i915)) 638 intel_ddi_sanitize_encoder_pll_mapping(encoder); 639 } 640 641 /* FIXME read out full plane state for all planes */ readout_plane_state(struct drm_i915_private * i915)642 static void readout_plane_state(struct drm_i915_private *i915) 643 { 644 struct intel_plane *plane; 645 struct intel_crtc *crtc; 646 647 for_each_intel_plane(&i915->drm, plane) { 648 struct intel_plane_state *plane_state = 649 to_intel_plane_state(plane->base.state); 650 struct intel_crtc_state *crtc_state; 651 enum pipe pipe = PIPE_A; 652 bool visible; 653 654 visible = plane->get_hw_state(plane, &pipe); 655 656 crtc = intel_crtc_for_pipe(i915, pipe); 657 crtc_state = to_intel_crtc_state(crtc->base.state); 658 659 intel_set_plane_visible(crtc_state, plane_state, visible); 660 661 drm_dbg_kms(&i915->drm, 662 "[PLANE:%d:%s] hw state readout: %s, pipe %c\n", 663 plane->base.base.id, plane->base.name, 664 str_enabled_disabled(visible), pipe_name(pipe)); 665 } 666 667 for_each_intel_crtc(&i915->drm, crtc) { 668 struct intel_crtc_state *crtc_state = 669 to_intel_crtc_state(crtc->base.state); 670 671 intel_plane_fixup_bitmasks(crtc_state); 672 } 673 } 674 intel_modeset_readout_hw_state(struct drm_i915_private * i915)675 static void intel_modeset_readout_hw_state(struct drm_i915_private *i915) 676 { 677 struct intel_cdclk_state *cdclk_state = 678 to_intel_cdclk_state(i915->display.cdclk.obj.state); 679 struct intel_dbuf_state *dbuf_state = 680 to_intel_dbuf_state(i915->display.dbuf.obj.state); 681 struct intel_pmdemand_state *pmdemand_state = 682 to_intel_pmdemand_state(i915->display.pmdemand.obj.state); 683 enum pipe pipe; 684 struct intel_crtc *crtc; 685 struct intel_encoder *encoder; 686 struct intel_connector *connector; 687 struct drm_connector_list_iter conn_iter; 688 u8 active_pipes = 0; 689 690 for_each_intel_crtc(&i915->drm, crtc) { 691 struct intel_crtc_state *crtc_state = 692 to_intel_crtc_state(crtc->base.state); 693 694 __drm_atomic_helper_crtc_destroy_state(&crtc_state->uapi); 695 intel_crtc_free_hw_state(crtc_state); 696 intel_crtc_state_reset(crtc_state, crtc); 697 698 intel_crtc_get_pipe_config(crtc_state); 699 700 crtc_state->hw.enable = crtc_state->hw.active; 701 702 crtc->base.enabled = crtc_state->hw.enable; 703 crtc->active = crtc_state->hw.active; 704 705 if (crtc_state->hw.active) 706 active_pipes |= BIT(crtc->pipe); 707 708 drm_dbg_kms(&i915->drm, 709 "[CRTC:%d:%s] hw state readout: %s\n", 710 crtc->base.base.id, crtc->base.name, 711 str_enabled_disabled(crtc_state->hw.active)); 712 } 713 714 cdclk_state->active_pipes = active_pipes; 715 dbuf_state->active_pipes = active_pipes; 716 717 readout_plane_state(i915); 718 719 for_each_intel_encoder(&i915->drm, encoder) { 720 struct intel_crtc_state *crtc_state = NULL; 721 722 pipe = 0; 723 724 if (encoder->get_hw_state(encoder, &pipe)) { 725 crtc = intel_crtc_for_pipe(i915, pipe); 726 crtc_state = to_intel_crtc_state(crtc->base.state); 727 728 encoder->base.crtc = &crtc->base; 729 intel_encoder_get_config(encoder, crtc_state); 730 731 /* read out to slave crtc as well for bigjoiner */ 732 if (crtc_state->bigjoiner_pipes) { 733 struct intel_crtc *slave_crtc; 734 735 /* encoder should read be linked to bigjoiner master */ 736 WARN_ON(intel_crtc_is_bigjoiner_slave(crtc_state)); 737 738 for_each_intel_crtc_in_pipe_mask(&i915->drm, slave_crtc, 739 intel_crtc_bigjoiner_slave_pipes(crtc_state)) { 740 struct intel_crtc_state *slave_crtc_state; 741 742 slave_crtc_state = to_intel_crtc_state(slave_crtc->base.state); 743 intel_encoder_get_config(encoder, slave_crtc_state); 744 } 745 } 746 747 intel_pmdemand_update_phys_mask(i915, encoder, 748 pmdemand_state, 749 true); 750 } else { 751 intel_pmdemand_update_phys_mask(i915, encoder, 752 pmdemand_state, 753 false); 754 755 encoder->base.crtc = NULL; 756 } 757 758 if (encoder->sync_state) 759 encoder->sync_state(encoder, crtc_state); 760 761 drm_dbg_kms(&i915->drm, 762 "[ENCODER:%d:%s] hw state readout: %s, pipe %c\n", 763 encoder->base.base.id, encoder->base.name, 764 str_enabled_disabled(encoder->base.crtc), 765 pipe_name(pipe)); 766 } 767 768 intel_dpll_readout_hw_state(i915); 769 770 drm_connector_list_iter_begin(&i915->drm, &conn_iter); 771 for_each_intel_connector_iter(connector, &conn_iter) { 772 if (connector->get_hw_state(connector)) { 773 struct intel_crtc_state *crtc_state; 774 struct intel_crtc *crtc; 775 776 connector->base.dpms = DRM_MODE_DPMS_ON; 777 778 encoder = intel_attached_encoder(connector); 779 connector->base.encoder = &encoder->base; 780 781 crtc = to_intel_crtc(encoder->base.crtc); 782 crtc_state = crtc ? to_intel_crtc_state(crtc->base.state) : NULL; 783 784 if (crtc_state && crtc_state->hw.active) { 785 /* 786 * This has to be done during hardware readout 787 * because anything calling .crtc_disable may 788 * rely on the connector_mask being accurate. 789 */ 790 crtc_state->uapi.connector_mask |= 791 drm_connector_mask(&connector->base); 792 crtc_state->uapi.encoder_mask |= 793 drm_encoder_mask(&encoder->base); 794 } 795 } else { 796 connector->base.dpms = DRM_MODE_DPMS_OFF; 797 connector->base.encoder = NULL; 798 } 799 drm_dbg_kms(&i915->drm, 800 "[CONNECTOR:%d:%s] hw state readout: %s\n", 801 connector->base.base.id, connector->base.name, 802 str_enabled_disabled(connector->base.encoder)); 803 } 804 drm_connector_list_iter_end(&conn_iter); 805 806 for_each_intel_crtc(&i915->drm, crtc) { 807 struct intel_bw_state *bw_state = 808 to_intel_bw_state(i915->display.bw.obj.state); 809 struct intel_crtc_state *crtc_state = 810 to_intel_crtc_state(crtc->base.state); 811 struct intel_plane *plane; 812 int min_cdclk = 0; 813 814 if (crtc_state->hw.active) { 815 /* 816 * The initial mode needs to be set in order to keep 817 * the atomic core happy. It wants a valid mode if the 818 * crtc's enabled, so we do the above call. 819 * 820 * But we don't set all the derived state fully, hence 821 * set a flag to indicate that a full recalculation is 822 * needed on the next commit. 823 */ 824 crtc_state->inherited = true; 825 826 intel_crtc_update_active_timings(crtc_state, 827 crtc_state->vrr.enable); 828 829 intel_crtc_copy_hw_to_uapi_state(crtc_state); 830 } 831 832 for_each_intel_plane_on_crtc(&i915->drm, crtc, plane) { 833 const struct intel_plane_state *plane_state = 834 to_intel_plane_state(plane->base.state); 835 836 /* 837 * FIXME don't have the fb yet, so can't 838 * use intel_plane_data_rate() :( 839 */ 840 if (plane_state->uapi.visible) 841 crtc_state->data_rate[plane->id] = 842 4 * crtc_state->pixel_rate; 843 /* 844 * FIXME don't have the fb yet, so can't 845 * use plane->min_cdclk() :( 846 */ 847 if (plane_state->uapi.visible && plane->min_cdclk) { 848 if (crtc_state->double_wide || DISPLAY_VER(i915) >= 10) 849 crtc_state->min_cdclk[plane->id] = 850 DIV_ROUND_UP(crtc_state->pixel_rate, 2); 851 else 852 crtc_state->min_cdclk[plane->id] = 853 crtc_state->pixel_rate; 854 } 855 drm_dbg_kms(&i915->drm, 856 "[PLANE:%d:%s] min_cdclk %d kHz\n", 857 plane->base.base.id, plane->base.name, 858 crtc_state->min_cdclk[plane->id]); 859 } 860 861 if (crtc_state->hw.active) { 862 min_cdclk = intel_crtc_compute_min_cdclk(crtc_state); 863 if (drm_WARN_ON(&i915->drm, min_cdclk < 0)) 864 min_cdclk = 0; 865 } 866 867 cdclk_state->min_cdclk[crtc->pipe] = min_cdclk; 868 cdclk_state->min_voltage_level[crtc->pipe] = 869 crtc_state->min_voltage_level; 870 871 intel_pmdemand_update_port_clock(i915, pmdemand_state, pipe, 872 crtc_state->port_clock); 873 874 intel_bw_crtc_update(bw_state, crtc_state); 875 } 876 877 intel_pmdemand_init_pmdemand_params(i915, pmdemand_state); 878 } 879 880 static void get_encoder_power_domains(struct drm_i915_private * i915)881 get_encoder_power_domains(struct drm_i915_private *i915) 882 { 883 struct intel_encoder *encoder; 884 885 for_each_intel_encoder(&i915->drm, encoder) { 886 struct intel_crtc_state *crtc_state; 887 888 if (!encoder->get_power_domains) 889 continue; 890 891 /* 892 * MST-primary and inactive encoders don't have a crtc state 893 * and neither of these require any power domain references. 894 */ 895 if (!encoder->base.crtc) 896 continue; 897 898 crtc_state = to_intel_crtc_state(encoder->base.crtc->state); 899 encoder->get_power_domains(encoder, crtc_state); 900 } 901 } 902 intel_early_display_was(struct drm_i915_private * i915)903 static void intel_early_display_was(struct drm_i915_private *i915) 904 { 905 /* 906 * Display WA #1185 WaDisableDARBFClkGating:glk,icl,ehl,tgl 907 * Also known as Wa_14010480278. 908 */ 909 if (IS_DISPLAY_VER(i915, 10, 12)) 910 intel_de_rmw(i915, GEN9_CLKGATE_DIS_0, 0, DARBF_GATING_DIS); 911 912 /* 913 * WaRsPkgCStateDisplayPMReq:hsw 914 * System hang if this isn't done before disabling all planes! 915 */ 916 if (IS_HASWELL(i915)) 917 intel_de_rmw(i915, CHICKEN_PAR1_1, 0, FORCE_ARB_IDLE_PLANES); 918 919 if (IS_KABYLAKE(i915) || IS_COFFEELAKE(i915) || IS_COMETLAKE(i915)) { 920 /* Display WA #1142:kbl,cfl,cml */ 921 intel_de_rmw(i915, CHICKEN_PAR1_1, 922 KBL_ARB_FILL_SPARE_22, KBL_ARB_FILL_SPARE_22); 923 intel_de_rmw(i915, CHICKEN_MISC_2, 924 KBL_ARB_FILL_SPARE_13 | KBL_ARB_FILL_SPARE_14, 925 KBL_ARB_FILL_SPARE_14); 926 } 927 } 928 intel_modeset_setup_hw_state(struct drm_i915_private * i915,struct drm_modeset_acquire_ctx * ctx)929 void intel_modeset_setup_hw_state(struct drm_i915_private *i915, 930 struct drm_modeset_acquire_ctx *ctx) 931 { 932 struct intel_encoder *encoder; 933 struct intel_crtc *crtc; 934 intel_wakeref_t wakeref; 935 936 wakeref = intel_display_power_get(i915, POWER_DOMAIN_INIT); 937 938 intel_early_display_was(i915); 939 intel_modeset_readout_hw_state(i915); 940 941 /* HW state is read out, now we need to sanitize this mess. */ 942 get_encoder_power_domains(i915); 943 944 intel_pch_sanitize(i915); 945 946 /* 947 * intel_sanitize_plane_mapping() may need to do vblank 948 * waits, so we need vblank interrupts restored beforehand. 949 */ 950 for_each_intel_crtc(&i915->drm, crtc) { 951 struct intel_crtc_state *crtc_state = 952 to_intel_crtc_state(crtc->base.state); 953 954 intel_sanitize_fifo_underrun_reporting(crtc_state); 955 956 drm_crtc_vblank_reset(&crtc->base); 957 958 if (crtc_state->hw.active) { 959 intel_dmc_enable_pipe(i915, crtc->pipe); 960 intel_crtc_vblank_on(crtc_state); 961 } 962 } 963 964 intel_fbc_sanitize(i915); 965 966 intel_sanitize_plane_mapping(i915); 967 968 for_each_intel_encoder(&i915->drm, encoder) 969 intel_sanitize_encoder(encoder); 970 971 /* 972 * Sanitizing CRTCs needs their connector atomic state to be 973 * up-to-date, so ensure that already here. 974 */ 975 intel_modeset_update_connector_atomic_state(i915); 976 977 intel_sanitize_all_crtcs(i915, ctx); 978 979 intel_dpll_sanitize_state(i915); 980 981 intel_wm_get_hw_state(i915); 982 983 for_each_intel_crtc(&i915->drm, crtc) { 984 struct intel_crtc_state *crtc_state = 985 to_intel_crtc_state(crtc->base.state); 986 struct intel_power_domain_mask put_domains; 987 988 intel_modeset_get_crtc_power_domains(crtc_state, &put_domains); 989 if (drm_WARN_ON(&i915->drm, !bitmap_empty(put_domains.bits, POWER_DOMAIN_NUM))) 990 intel_modeset_put_crtc_power_domains(crtc, &put_domains); 991 } 992 993 intel_display_power_put(i915, POWER_DOMAIN_INIT, wakeref); 994 995 intel_power_domains_sanitize_state(i915); 996 } 997