1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2021 Intel Corporation 4 */ 5 6 #include "g4x_dp.h" 7 #include "i915_drv.h" 8 #include "i915_reg.h" 9 #include "intel_crt.h" 10 #include "intel_crt_regs.h" 11 #include "intel_de.h" 12 #include "intel_display_types.h" 13 #include "intel_dpll.h" 14 #include "intel_fdi.h" 15 #include "intel_fdi_regs.h" 16 #include "intel_lvds.h" 17 #include "intel_lvds_regs.h" 18 #include "intel_pch_display.h" 19 #include "intel_pch_refclk.h" 20 #include "intel_pps.h" 21 #include "intel_sdvo.h" 22 23 bool intel_has_pch_trancoder(struct intel_display *display, 24 enum pipe pch_transcoder) 25 { 26 struct drm_i915_private *i915 = to_i915(display->drm); 27 28 return HAS_PCH_IBX(i915) || HAS_PCH_CPT(i915) || 29 (HAS_PCH_LPT_H(i915) && pch_transcoder == PIPE_A); 30 } 31 32 enum pipe intel_crtc_pch_transcoder(struct intel_crtc *crtc) 33 { 34 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 35 36 if (HAS_PCH_LPT(i915)) 37 return PIPE_A; 38 else 39 return crtc->pipe; 40 } 41 42 static void assert_pch_dp_disabled(struct intel_display *display, 43 enum pipe pipe, enum port port, 44 i915_reg_t dp_reg) 45 { 46 struct drm_i915_private *dev_priv = to_i915(display->drm); 47 enum pipe port_pipe; 48 bool state; 49 50 state = g4x_dp_port_enabled(display, dp_reg, port, &port_pipe); 51 52 INTEL_DISPLAY_STATE_WARN(display, state && port_pipe == pipe, 53 "PCH DP %c enabled on transcoder %c, should be disabled\n", 54 port_name(port), pipe_name(pipe)); 55 56 INTEL_DISPLAY_STATE_WARN(display, 57 HAS_PCH_IBX(dev_priv) && !state && port_pipe == PIPE_B, 58 "IBX PCH DP %c still using transcoder B\n", 59 port_name(port)); 60 } 61 62 static void assert_pch_hdmi_disabled(struct intel_display *display, 63 enum pipe pipe, enum port port, 64 i915_reg_t hdmi_reg) 65 { 66 struct drm_i915_private *dev_priv = to_i915(display->drm); 67 enum pipe port_pipe; 68 bool state; 69 70 state = intel_sdvo_port_enabled(display, hdmi_reg, &port_pipe); 71 72 INTEL_DISPLAY_STATE_WARN(display, state && port_pipe == pipe, 73 "PCH HDMI %c enabled on transcoder %c, should be disabled\n", 74 port_name(port), pipe_name(pipe)); 75 76 INTEL_DISPLAY_STATE_WARN(display, 77 HAS_PCH_IBX(dev_priv) && !state && port_pipe == PIPE_B, 78 "IBX PCH HDMI %c still using transcoder B\n", 79 port_name(port)); 80 } 81 82 static void assert_pch_ports_disabled(struct intel_display *display, 83 enum pipe pipe) 84 { 85 enum pipe port_pipe; 86 87 assert_pch_dp_disabled(display, pipe, PORT_B, PCH_DP_B); 88 assert_pch_dp_disabled(display, pipe, PORT_C, PCH_DP_C); 89 assert_pch_dp_disabled(display, pipe, PORT_D, PCH_DP_D); 90 91 INTEL_DISPLAY_STATE_WARN(display, 92 intel_crt_port_enabled(display, PCH_ADPA, &port_pipe) && port_pipe == pipe, 93 "PCH VGA enabled on transcoder %c, should be disabled\n", 94 pipe_name(pipe)); 95 96 INTEL_DISPLAY_STATE_WARN(display, 97 intel_lvds_port_enabled(display, PCH_LVDS, &port_pipe) && port_pipe == pipe, 98 "PCH LVDS enabled on transcoder %c, should be disabled\n", 99 pipe_name(pipe)); 100 101 /* PCH SDVOB multiplex with HDMIB */ 102 assert_pch_hdmi_disabled(display, pipe, PORT_B, PCH_HDMIB); 103 assert_pch_hdmi_disabled(display, pipe, PORT_C, PCH_HDMIC); 104 assert_pch_hdmi_disabled(display, pipe, PORT_D, PCH_HDMID); 105 } 106 107 static void assert_pch_transcoder_disabled(struct intel_display *display, 108 enum pipe pipe) 109 { 110 u32 val; 111 bool enabled; 112 113 val = intel_de_read(display, PCH_TRANSCONF(pipe)); 114 enabled = !!(val & TRANS_ENABLE); 115 INTEL_DISPLAY_STATE_WARN(display, enabled, 116 "transcoder assertion failed, should be off on pipe %c but is still active\n", 117 pipe_name(pipe)); 118 } 119 120 static void ibx_sanitize_pch_hdmi_port(struct intel_display *display, 121 enum port port, i915_reg_t hdmi_reg) 122 { 123 u32 val = intel_de_read(display, hdmi_reg); 124 125 if (val & SDVO_ENABLE || 126 (val & SDVO_PIPE_SEL_MASK) == SDVO_PIPE_SEL(PIPE_A)) 127 return; 128 129 drm_dbg_kms(display->drm, 130 "Sanitizing transcoder select for HDMI %c\n", 131 port_name(port)); 132 133 val &= ~SDVO_PIPE_SEL_MASK; 134 val |= SDVO_PIPE_SEL(PIPE_A); 135 136 intel_de_write(display, hdmi_reg, val); 137 } 138 139 static void ibx_sanitize_pch_dp_port(struct intel_display *display, 140 enum port port, i915_reg_t dp_reg) 141 { 142 u32 val = intel_de_read(display, dp_reg); 143 144 if (val & DP_PORT_EN || 145 (val & DP_PIPE_SEL_MASK) == DP_PIPE_SEL(PIPE_A)) 146 return; 147 148 drm_dbg_kms(display->drm, 149 "Sanitizing transcoder select for DP %c\n", 150 port_name(port)); 151 152 val &= ~DP_PIPE_SEL_MASK; 153 val |= DP_PIPE_SEL(PIPE_A); 154 155 intel_de_write(display, dp_reg, val); 156 } 157 158 static void ibx_sanitize_pch_ports(struct intel_display *display) 159 { 160 /* 161 * The BIOS may select transcoder B on some of the PCH 162 * ports even it doesn't enable the port. This would trip 163 * assert_pch_dp_disabled() and assert_pch_hdmi_disabled(). 164 * Sanitize the transcoder select bits to prevent that. We 165 * assume that the BIOS never actually enabled the port, 166 * because if it did we'd actually have to toggle the port 167 * on and back off to make the transcoder A select stick 168 * (see. intel_dp_link_down(), intel_disable_hdmi(), 169 * intel_disable_sdvo()). 170 */ 171 ibx_sanitize_pch_dp_port(display, PORT_B, PCH_DP_B); 172 ibx_sanitize_pch_dp_port(display, PORT_C, PCH_DP_C); 173 ibx_sanitize_pch_dp_port(display, PORT_D, PCH_DP_D); 174 175 /* PCH SDVOB multiplex with HDMIB */ 176 ibx_sanitize_pch_hdmi_port(display, PORT_B, PCH_HDMIB); 177 ibx_sanitize_pch_hdmi_port(display, PORT_C, PCH_HDMIC); 178 ibx_sanitize_pch_hdmi_port(display, PORT_D, PCH_HDMID); 179 } 180 181 static void intel_pch_transcoder_set_m1_n1(struct intel_crtc *crtc, 182 const struct intel_link_m_n *m_n) 183 { 184 struct intel_display *display = to_intel_display(crtc); 185 enum pipe pipe = crtc->pipe; 186 187 intel_set_m_n(display, m_n, 188 PCH_TRANS_DATA_M1(pipe), PCH_TRANS_DATA_N1(pipe), 189 PCH_TRANS_LINK_M1(pipe), PCH_TRANS_LINK_N1(pipe)); 190 } 191 192 static void intel_pch_transcoder_set_m2_n2(struct intel_crtc *crtc, 193 const struct intel_link_m_n *m_n) 194 { 195 struct intel_display *display = to_intel_display(crtc); 196 enum pipe pipe = crtc->pipe; 197 198 intel_set_m_n(display, m_n, 199 PCH_TRANS_DATA_M2(pipe), PCH_TRANS_DATA_N2(pipe), 200 PCH_TRANS_LINK_M2(pipe), PCH_TRANS_LINK_N2(pipe)); 201 } 202 203 void intel_pch_transcoder_get_m1_n1(struct intel_crtc *crtc, 204 struct intel_link_m_n *m_n) 205 { 206 struct intel_display *display = to_intel_display(crtc); 207 enum pipe pipe = crtc->pipe; 208 209 intel_get_m_n(display, m_n, 210 PCH_TRANS_DATA_M1(pipe), PCH_TRANS_DATA_N1(pipe), 211 PCH_TRANS_LINK_M1(pipe), PCH_TRANS_LINK_N1(pipe)); 212 } 213 214 void intel_pch_transcoder_get_m2_n2(struct intel_crtc *crtc, 215 struct intel_link_m_n *m_n) 216 { 217 struct intel_display *display = to_intel_display(crtc); 218 enum pipe pipe = crtc->pipe; 219 220 intel_get_m_n(display, m_n, 221 PCH_TRANS_DATA_M2(pipe), PCH_TRANS_DATA_N2(pipe), 222 PCH_TRANS_LINK_M2(pipe), PCH_TRANS_LINK_N2(pipe)); 223 } 224 225 static void ilk_pch_transcoder_set_timings(const struct intel_crtc_state *crtc_state, 226 enum pipe pch_transcoder) 227 { 228 struct intel_display *display = to_intel_display(crtc_state); 229 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder; 230 231 intel_de_write(display, PCH_TRANS_HTOTAL(pch_transcoder), 232 intel_de_read(display, TRANS_HTOTAL(display, cpu_transcoder))); 233 intel_de_write(display, PCH_TRANS_HBLANK(pch_transcoder), 234 intel_de_read(display, TRANS_HBLANK(display, cpu_transcoder))); 235 intel_de_write(display, PCH_TRANS_HSYNC(pch_transcoder), 236 intel_de_read(display, TRANS_HSYNC(display, cpu_transcoder))); 237 238 intel_de_write(display, PCH_TRANS_VTOTAL(pch_transcoder), 239 intel_de_read(display, TRANS_VTOTAL(display, cpu_transcoder))); 240 intel_de_write(display, PCH_TRANS_VBLANK(pch_transcoder), 241 intel_de_read(display, TRANS_VBLANK(display, cpu_transcoder))); 242 intel_de_write(display, PCH_TRANS_VSYNC(pch_transcoder), 243 intel_de_read(display, TRANS_VSYNC(display, cpu_transcoder))); 244 intel_de_write(display, PCH_TRANS_VSYNCSHIFT(pch_transcoder), 245 intel_de_read(display, TRANS_VSYNCSHIFT(display, cpu_transcoder))); 246 } 247 248 static void ilk_enable_pch_transcoder(const struct intel_crtc_state *crtc_state) 249 { 250 struct intel_display *display = to_intel_display(crtc_state); 251 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 252 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 253 enum pipe pipe = crtc->pipe; 254 i915_reg_t reg; 255 u32 val, pipeconf_val; 256 257 /* Make sure PCH DPLL is enabled */ 258 assert_shared_dpll_enabled(display, crtc_state->shared_dpll); 259 260 /* FDI must be feeding us bits for PCH ports */ 261 assert_fdi_tx_enabled(display, pipe); 262 assert_fdi_rx_enabled(display, pipe); 263 264 if (HAS_PCH_CPT(dev_priv)) { 265 reg = TRANS_CHICKEN2(pipe); 266 val = intel_de_read(display, reg); 267 /* 268 * Workaround: Set the timing override bit 269 * before enabling the pch transcoder. 270 */ 271 val |= TRANS_CHICKEN2_TIMING_OVERRIDE; 272 /* Configure frame start delay to match the CPU */ 273 val &= ~TRANS_CHICKEN2_FRAME_START_DELAY_MASK; 274 val |= TRANS_CHICKEN2_FRAME_START_DELAY(crtc_state->framestart_delay - 1); 275 intel_de_write(display, reg, val); 276 } 277 278 reg = PCH_TRANSCONF(pipe); 279 val = intel_de_read(display, reg); 280 pipeconf_val = intel_de_read(display, TRANSCONF(display, pipe)); 281 282 if (HAS_PCH_IBX(dev_priv)) { 283 /* Configure frame start delay to match the CPU */ 284 val &= ~TRANS_FRAME_START_DELAY_MASK; 285 val |= TRANS_FRAME_START_DELAY(crtc_state->framestart_delay - 1); 286 287 /* 288 * Make the BPC in transcoder be consistent with 289 * that in pipeconf reg. For HDMI we must use 8bpc 290 * here for both 8bpc and 12bpc. 291 */ 292 val &= ~TRANSCONF_BPC_MASK; 293 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) 294 val |= TRANSCONF_BPC_8; 295 else 296 val |= pipeconf_val & TRANSCONF_BPC_MASK; 297 } 298 299 val &= ~TRANS_INTERLACE_MASK; 300 if ((pipeconf_val & TRANSCONF_INTERLACE_MASK_ILK) == TRANSCONF_INTERLACE_IF_ID_ILK) { 301 if (HAS_PCH_IBX(dev_priv) && 302 intel_crtc_has_type(crtc_state, INTEL_OUTPUT_SDVO)) 303 val |= TRANS_INTERLACE_LEGACY_VSYNC_IBX; 304 else 305 val |= TRANS_INTERLACE_INTERLACED; 306 } else { 307 val |= TRANS_INTERLACE_PROGRESSIVE; 308 } 309 310 intel_de_write(display, reg, val | TRANS_ENABLE); 311 if (intel_de_wait_for_set(display, reg, TRANS_STATE_ENABLE, 100)) 312 drm_err(display->drm, "failed to enable transcoder %c\n", 313 pipe_name(pipe)); 314 } 315 316 static void ilk_disable_pch_transcoder(struct intel_crtc *crtc) 317 { 318 struct intel_display *display = to_intel_display(crtc); 319 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 320 enum pipe pipe = crtc->pipe; 321 i915_reg_t reg; 322 323 /* FDI relies on the transcoder */ 324 assert_fdi_tx_disabled(display, pipe); 325 assert_fdi_rx_disabled(display, pipe); 326 327 /* Ports must be off as well */ 328 assert_pch_ports_disabled(display, pipe); 329 330 reg = PCH_TRANSCONF(pipe); 331 intel_de_rmw(display, reg, TRANS_ENABLE, 0); 332 /* wait for PCH transcoder off, transcoder state */ 333 if (intel_de_wait_for_clear(display, reg, TRANS_STATE_ENABLE, 50)) 334 drm_err(display->drm, "failed to disable transcoder %c\n", 335 pipe_name(pipe)); 336 337 if (HAS_PCH_CPT(dev_priv)) 338 /* Workaround: Clear the timing override chicken bit again. */ 339 intel_de_rmw(display, TRANS_CHICKEN2(pipe), 340 TRANS_CHICKEN2_TIMING_OVERRIDE, 0); 341 } 342 343 void ilk_pch_pre_enable(struct intel_atomic_state *state, 344 struct intel_crtc *crtc) 345 { 346 const struct intel_crtc_state *crtc_state = 347 intel_atomic_get_new_crtc_state(state, crtc); 348 349 /* 350 * Note: FDI PLL enabling _must_ be done before we enable the 351 * cpu pipes, hence this is separate from all the other fdi/pch 352 * enabling. 353 */ 354 ilk_fdi_pll_enable(crtc_state); 355 } 356 357 /* 358 * Enable PCH resources required for PCH ports: 359 * - PCH PLLs 360 * - FDI training & RX/TX 361 * - update transcoder timings 362 * - DP transcoding bits 363 * - transcoder 364 */ 365 void ilk_pch_enable(struct intel_atomic_state *state, 366 struct intel_crtc *crtc) 367 { 368 struct intel_display *display = to_intel_display(crtc); 369 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 370 const struct intel_crtc_state *crtc_state = 371 intel_atomic_get_new_crtc_state(state, crtc); 372 enum pipe pipe = crtc->pipe; 373 u32 temp; 374 375 assert_pch_transcoder_disabled(display, pipe); 376 377 /* For PCH output, training FDI link */ 378 intel_fdi_link_train(crtc, crtc_state); 379 380 /* 381 * We need to program the right clock selection 382 * before writing the pixel multiplier into the DPLL. 383 */ 384 if (HAS_PCH_CPT(dev_priv)) { 385 u32 sel; 386 387 temp = intel_de_read(display, PCH_DPLL_SEL); 388 temp |= TRANS_DPLL_ENABLE(pipe); 389 sel = TRANS_DPLLB_SEL(pipe); 390 if (crtc_state->shared_dpll == 391 intel_get_shared_dpll_by_id(display, DPLL_ID_PCH_PLL_B)) 392 temp |= sel; 393 else 394 temp &= ~sel; 395 intel_de_write(display, PCH_DPLL_SEL, temp); 396 } 397 398 /* 399 * XXX: pch pll's can be enabled any time before we enable the PCH 400 * transcoder, and we actually should do this to not upset any PCH 401 * transcoder that already use the clock when we share it. 402 * 403 * Note that enable_shared_dpll tries to do the right thing, but 404 * get_shared_dpll unconditionally resets the pll - we need that 405 * to have the right LVDS enable sequence. 406 */ 407 intel_enable_shared_dpll(crtc_state); 408 409 /* set transcoder timing, panel must allow it */ 410 assert_pps_unlocked(display, pipe); 411 if (intel_crtc_has_dp_encoder(crtc_state)) { 412 intel_pch_transcoder_set_m1_n1(crtc, &crtc_state->dp_m_n); 413 intel_pch_transcoder_set_m2_n2(crtc, &crtc_state->dp_m2_n2); 414 } 415 ilk_pch_transcoder_set_timings(crtc_state, pipe); 416 417 intel_fdi_normal_train(crtc); 418 419 /* For PCH DP, enable TRANS_DP_CTL */ 420 if (HAS_PCH_CPT(dev_priv) && 421 intel_crtc_has_dp_encoder(crtc_state)) { 422 const struct drm_display_mode *adjusted_mode = 423 &crtc_state->hw.adjusted_mode; 424 u32 bpc = (intel_de_read(display, TRANSCONF(display, pipe)) 425 & TRANSCONF_BPC_MASK) >> 5; 426 i915_reg_t reg = TRANS_DP_CTL(pipe); 427 enum port port; 428 429 temp = intel_de_read(display, reg); 430 temp &= ~(TRANS_DP_PORT_SEL_MASK | 431 TRANS_DP_VSYNC_ACTIVE_HIGH | 432 TRANS_DP_HSYNC_ACTIVE_HIGH | 433 TRANS_DP_BPC_MASK); 434 temp |= TRANS_DP_OUTPUT_ENABLE; 435 temp |= bpc << 9; /* same format but at 11:9 */ 436 437 if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC) 438 temp |= TRANS_DP_HSYNC_ACTIVE_HIGH; 439 if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC) 440 temp |= TRANS_DP_VSYNC_ACTIVE_HIGH; 441 442 port = intel_get_crtc_new_encoder(state, crtc_state)->port; 443 drm_WARN_ON(display->drm, port < PORT_B || port > PORT_D); 444 temp |= TRANS_DP_PORT_SEL(port); 445 446 intel_de_write(display, reg, temp); 447 } 448 449 ilk_enable_pch_transcoder(crtc_state); 450 } 451 452 void ilk_pch_disable(struct intel_atomic_state *state, 453 struct intel_crtc *crtc) 454 { 455 ilk_fdi_disable(crtc); 456 } 457 458 void ilk_pch_post_disable(struct intel_atomic_state *state, 459 struct intel_crtc *crtc) 460 { 461 struct intel_display *display = to_intel_display(crtc); 462 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 463 const struct intel_crtc_state *old_crtc_state = 464 intel_atomic_get_old_crtc_state(state, crtc); 465 enum pipe pipe = crtc->pipe; 466 467 ilk_disable_pch_transcoder(crtc); 468 469 if (HAS_PCH_CPT(dev_priv)) { 470 /* disable TRANS_DP_CTL */ 471 intel_de_rmw(display, TRANS_DP_CTL(pipe), 472 TRANS_DP_OUTPUT_ENABLE | TRANS_DP_PORT_SEL_MASK, 473 TRANS_DP_PORT_SEL_NONE); 474 475 /* disable DPLL_SEL */ 476 intel_de_rmw(display, PCH_DPLL_SEL, 477 TRANS_DPLL_ENABLE(pipe) | TRANS_DPLLB_SEL(pipe), 0); 478 } 479 480 ilk_fdi_pll_disable(crtc); 481 482 intel_disable_shared_dpll(old_crtc_state); 483 } 484 485 static void ilk_pch_clock_get(struct intel_crtc_state *crtc_state) 486 { 487 struct intel_display *display = to_intel_display(crtc_state); 488 489 /* read out port_clock from the DPLL */ 490 i9xx_crtc_clock_get(crtc_state); 491 492 /* 493 * In case there is an active pipe without active ports, 494 * we may need some idea for the dotclock anyway. 495 * Calculate one based on the FDI configuration. 496 */ 497 crtc_state->hw.adjusted_mode.crtc_clock = 498 intel_dotclock_calculate(intel_fdi_link_freq(display, crtc_state), 499 &crtc_state->fdi_m_n); 500 } 501 502 void ilk_pch_get_config(struct intel_crtc_state *crtc_state) 503 { 504 struct intel_display *display = to_intel_display(crtc_state); 505 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 506 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 507 struct intel_shared_dpll *pll; 508 enum pipe pipe = crtc->pipe; 509 enum intel_dpll_id pll_id; 510 bool pll_active; 511 u32 tmp; 512 513 if ((intel_de_read(display, PCH_TRANSCONF(pipe)) & TRANS_ENABLE) == 0) 514 return; 515 516 crtc_state->has_pch_encoder = true; 517 518 tmp = intel_de_read(display, FDI_RX_CTL(pipe)); 519 crtc_state->fdi_lanes = ((FDI_DP_PORT_WIDTH_MASK & tmp) >> 520 FDI_DP_PORT_WIDTH_SHIFT) + 1; 521 522 intel_cpu_transcoder_get_m1_n1(crtc, crtc_state->cpu_transcoder, 523 &crtc_state->fdi_m_n); 524 525 if (HAS_PCH_IBX(dev_priv)) { 526 /* 527 * The pipe->pch transcoder and pch transcoder->pll 528 * mapping is fixed. 529 */ 530 pll_id = (enum intel_dpll_id) pipe; 531 } else { 532 tmp = intel_de_read(display, PCH_DPLL_SEL); 533 if (tmp & TRANS_DPLLB_SEL(pipe)) 534 pll_id = DPLL_ID_PCH_PLL_B; 535 else 536 pll_id = DPLL_ID_PCH_PLL_A; 537 } 538 539 crtc_state->shared_dpll = intel_get_shared_dpll_by_id(display, pll_id); 540 pll = crtc_state->shared_dpll; 541 542 pll_active = intel_dpll_get_hw_state(display, pll, 543 &crtc_state->dpll_hw_state); 544 drm_WARN_ON(display->drm, !pll_active); 545 546 tmp = crtc_state->dpll_hw_state.i9xx.dpll; 547 crtc_state->pixel_multiplier = 548 ((tmp & PLL_REF_SDVO_HDMI_MULTIPLIER_MASK) 549 >> PLL_REF_SDVO_HDMI_MULTIPLIER_SHIFT) + 1; 550 551 ilk_pch_clock_get(crtc_state); 552 } 553 554 static void lpt_enable_pch_transcoder(const struct intel_crtc_state *crtc_state) 555 { 556 struct intel_display *display = to_intel_display(crtc_state); 557 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder; 558 u32 val, pipeconf_val; 559 560 /* FDI must be feeding us bits for PCH ports */ 561 assert_fdi_tx_enabled(display, (enum pipe)cpu_transcoder); 562 assert_fdi_rx_enabled(display, PIPE_A); 563 564 val = intel_de_read(display, TRANS_CHICKEN2(PIPE_A)); 565 /* Workaround: set timing override bit. */ 566 val |= TRANS_CHICKEN2_TIMING_OVERRIDE; 567 /* Configure frame start delay to match the CPU */ 568 val &= ~TRANS_CHICKEN2_FRAME_START_DELAY_MASK; 569 val |= TRANS_CHICKEN2_FRAME_START_DELAY(crtc_state->framestart_delay - 1); 570 intel_de_write(display, TRANS_CHICKEN2(PIPE_A), val); 571 572 val = TRANS_ENABLE; 573 pipeconf_val = intel_de_read(display, 574 TRANSCONF(display, cpu_transcoder)); 575 576 if ((pipeconf_val & TRANSCONF_INTERLACE_MASK_HSW) == TRANSCONF_INTERLACE_IF_ID_ILK) 577 val |= TRANS_INTERLACE_INTERLACED; 578 else 579 val |= TRANS_INTERLACE_PROGRESSIVE; 580 581 intel_de_write(display, LPT_TRANSCONF, val); 582 if (intel_de_wait_for_set(display, LPT_TRANSCONF, 583 TRANS_STATE_ENABLE, 100)) 584 drm_err(display->drm, "Failed to enable PCH transcoder\n"); 585 } 586 587 static void lpt_disable_pch_transcoder(struct intel_display *display) 588 { 589 intel_de_rmw(display, LPT_TRANSCONF, TRANS_ENABLE, 0); 590 /* wait for PCH transcoder off, transcoder state */ 591 if (intel_de_wait_for_clear(display, LPT_TRANSCONF, 592 TRANS_STATE_ENABLE, 50)) 593 drm_err(display->drm, "Failed to disable PCH transcoder\n"); 594 595 /* Workaround: clear timing override bit. */ 596 intel_de_rmw(display, TRANS_CHICKEN2(PIPE_A), TRANS_CHICKEN2_TIMING_OVERRIDE, 0); 597 } 598 599 void lpt_pch_enable(struct intel_atomic_state *state, 600 struct intel_crtc *crtc) 601 { 602 struct intel_display *display = to_intel_display(crtc); 603 const struct intel_crtc_state *crtc_state = 604 intel_atomic_get_new_crtc_state(state, crtc); 605 606 assert_pch_transcoder_disabled(display, PIPE_A); 607 608 lpt_program_iclkip(crtc_state); 609 610 /* Set transcoder timing. */ 611 ilk_pch_transcoder_set_timings(crtc_state, PIPE_A); 612 613 lpt_enable_pch_transcoder(crtc_state); 614 } 615 616 void lpt_pch_disable(struct intel_atomic_state *state, 617 struct intel_crtc *crtc) 618 { 619 struct intel_display *display = to_intel_display(crtc); 620 621 lpt_disable_pch_transcoder(display); 622 623 lpt_disable_iclkip(display); 624 } 625 626 void lpt_pch_get_config(struct intel_crtc_state *crtc_state) 627 { 628 struct intel_display *display = to_intel_display(crtc_state); 629 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 630 u32 tmp; 631 632 if ((intel_de_read(display, LPT_TRANSCONF) & TRANS_ENABLE) == 0) 633 return; 634 635 crtc_state->has_pch_encoder = true; 636 637 tmp = intel_de_read(display, FDI_RX_CTL(PIPE_A)); 638 crtc_state->fdi_lanes = ((FDI_DP_PORT_WIDTH_MASK & tmp) >> 639 FDI_DP_PORT_WIDTH_SHIFT) + 1; 640 641 intel_cpu_transcoder_get_m1_n1(crtc, crtc_state->cpu_transcoder, 642 &crtc_state->fdi_m_n); 643 644 crtc_state->hw.adjusted_mode.crtc_clock = lpt_get_iclkip(display); 645 } 646 647 void intel_pch_sanitize(struct intel_display *display) 648 { 649 struct drm_i915_private *i915 = to_i915(display->drm); 650 651 if (HAS_PCH_IBX(i915)) 652 ibx_sanitize_pch_ports(display); 653 } 654