1 /* 2 * Copyright © 2006-2016 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 */ 23 24 #include "intel_display_types.h" 25 #include "intel_dpio_phy.h" 26 #include "intel_dpll_mgr.h" 27 28 /** 29 * DOC: Display PLLs 30 * 31 * Display PLLs used for driving outputs vary by platform. While some have 32 * per-pipe or per-encoder dedicated PLLs, others allow the use of any PLL 33 * from a pool. In the latter scenario, it is possible that multiple pipes 34 * share a PLL if their configurations match. 35 * 36 * This file provides an abstraction over display PLLs. The function 37 * intel_shared_dpll_init() initializes the PLLs for the given platform. The 38 * users of a PLL are tracked and that tracking is integrated with the atomic 39 * modset interface. During an atomic operation, required PLLs can be reserved 40 * for a given CRTC and encoder configuration by calling 41 * intel_reserve_shared_dplls() and previously reserved PLLs can be released 42 * with intel_release_shared_dplls(). 43 * Changes to the users are first staged in the atomic state, and then made 44 * effective by calling intel_shared_dpll_swap_state() during the atomic 45 * commit phase. 46 */ 47 48 struct intel_dpll_mgr { 49 const struct dpll_info *dpll_info; 50 51 bool (*get_dplls)(struct intel_atomic_state *state, 52 struct intel_crtc *crtc, 53 struct intel_encoder *encoder); 54 void (*put_dplls)(struct intel_atomic_state *state, 55 struct intel_crtc *crtc); 56 void (*update_active_dpll)(struct intel_atomic_state *state, 57 struct intel_crtc *crtc, 58 struct intel_encoder *encoder); 59 void (*update_ref_clks)(struct drm_i915_private *i915); 60 void (*dump_hw_state)(struct drm_i915_private *dev_priv, 61 const struct intel_dpll_hw_state *hw_state); 62 }; 63 64 static void 65 intel_atomic_duplicate_dpll_state(struct drm_i915_private *dev_priv, 66 struct intel_shared_dpll_state *shared_dpll) 67 { 68 enum intel_dpll_id i; 69 70 /* Copy shared dpll state */ 71 for (i = 0; i < dev_priv->dpll.num_shared_dpll; i++) { 72 struct intel_shared_dpll *pll = &dev_priv->dpll.shared_dplls[i]; 73 74 shared_dpll[i] = pll->state; 75 } 76 } 77 78 static struct intel_shared_dpll_state * 79 intel_atomic_get_shared_dpll_state(struct drm_atomic_state *s) 80 { 81 struct intel_atomic_state *state = to_intel_atomic_state(s); 82 83 drm_WARN_ON(s->dev, !drm_modeset_is_locked(&s->dev->mode_config.connection_mutex)); 84 85 if (!state->dpll_set) { 86 state->dpll_set = true; 87 88 intel_atomic_duplicate_dpll_state(to_i915(s->dev), 89 state->shared_dpll); 90 } 91 92 return state->shared_dpll; 93 } 94 95 /** 96 * intel_get_shared_dpll_by_id - get a DPLL given its id 97 * @dev_priv: i915 device instance 98 * @id: pll id 99 * 100 * Returns: 101 * A pointer to the DPLL with @id 102 */ 103 struct intel_shared_dpll * 104 intel_get_shared_dpll_by_id(struct drm_i915_private *dev_priv, 105 enum intel_dpll_id id) 106 { 107 return &dev_priv->dpll.shared_dplls[id]; 108 } 109 110 /** 111 * intel_get_shared_dpll_id - get the id of a DPLL 112 * @dev_priv: i915 device instance 113 * @pll: the DPLL 114 * 115 * Returns: 116 * The id of @pll 117 */ 118 enum intel_dpll_id 119 intel_get_shared_dpll_id(struct drm_i915_private *dev_priv, 120 struct intel_shared_dpll *pll) 121 { 122 long pll_idx = pll - dev_priv->dpll.shared_dplls; 123 124 if (drm_WARN_ON(&dev_priv->drm, 125 pll_idx < 0 || 126 pll_idx >= dev_priv->dpll.num_shared_dpll)) 127 return -1; 128 129 return pll_idx; 130 } 131 132 /* For ILK+ */ 133 void assert_shared_dpll(struct drm_i915_private *dev_priv, 134 struct intel_shared_dpll *pll, 135 bool state) 136 { 137 bool cur_state; 138 struct intel_dpll_hw_state hw_state; 139 140 if (drm_WARN(&dev_priv->drm, !pll, 141 "asserting DPLL %s with no DPLL\n", onoff(state))) 142 return; 143 144 cur_state = pll->info->funcs->get_hw_state(dev_priv, pll, &hw_state); 145 I915_STATE_WARN(cur_state != state, 146 "%s assertion failure (expected %s, current %s)\n", 147 pll->info->name, onoff(state), onoff(cur_state)); 148 } 149 150 /** 151 * intel_prepare_shared_dpll - call a dpll's prepare hook 152 * @crtc_state: CRTC, and its state, which has a shared dpll 153 * 154 * This calls the PLL's prepare hook if it has one and if the PLL is not 155 * already enabled. The prepare hook is platform specific. 156 */ 157 void intel_prepare_shared_dpll(const struct intel_crtc_state *crtc_state) 158 { 159 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 160 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 161 struct intel_shared_dpll *pll = crtc_state->shared_dpll; 162 163 if (drm_WARN_ON(&dev_priv->drm, pll == NULL)) 164 return; 165 166 mutex_lock(&dev_priv->dpll.lock); 167 drm_WARN_ON(&dev_priv->drm, !pll->state.crtc_mask); 168 if (!pll->active_mask) { 169 drm_dbg(&dev_priv->drm, "setting up %s\n", pll->info->name); 170 drm_WARN_ON(&dev_priv->drm, pll->on); 171 assert_shared_dpll_disabled(dev_priv, pll); 172 173 pll->info->funcs->prepare(dev_priv, pll); 174 } 175 mutex_unlock(&dev_priv->dpll.lock); 176 } 177 178 /** 179 * intel_enable_shared_dpll - enable a CRTC's shared DPLL 180 * @crtc_state: CRTC, and its state, which has a shared DPLL 181 * 182 * Enable the shared DPLL used by @crtc. 183 */ 184 void intel_enable_shared_dpll(const struct intel_crtc_state *crtc_state) 185 { 186 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 187 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 188 struct intel_shared_dpll *pll = crtc_state->shared_dpll; 189 unsigned int crtc_mask = drm_crtc_mask(&crtc->base); 190 unsigned int old_mask; 191 192 if (drm_WARN_ON(&dev_priv->drm, pll == NULL)) 193 return; 194 195 mutex_lock(&dev_priv->dpll.lock); 196 old_mask = pll->active_mask; 197 198 if (drm_WARN_ON(&dev_priv->drm, !(pll->state.crtc_mask & crtc_mask)) || 199 drm_WARN_ON(&dev_priv->drm, pll->active_mask & crtc_mask)) 200 goto out; 201 202 pll->active_mask |= crtc_mask; 203 204 drm_dbg_kms(&dev_priv->drm, 205 "enable %s (active %x, on? %d) for crtc %d\n", 206 pll->info->name, pll->active_mask, pll->on, 207 crtc->base.base.id); 208 209 if (old_mask) { 210 drm_WARN_ON(&dev_priv->drm, !pll->on); 211 assert_shared_dpll_enabled(dev_priv, pll); 212 goto out; 213 } 214 drm_WARN_ON(&dev_priv->drm, pll->on); 215 216 drm_dbg_kms(&dev_priv->drm, "enabling %s\n", pll->info->name); 217 pll->info->funcs->enable(dev_priv, pll); 218 pll->on = true; 219 220 out: 221 mutex_unlock(&dev_priv->dpll.lock); 222 } 223 224 /** 225 * intel_disable_shared_dpll - disable a CRTC's shared DPLL 226 * @crtc_state: CRTC, and its state, which has a shared DPLL 227 * 228 * Disable the shared DPLL used by @crtc. 229 */ 230 void intel_disable_shared_dpll(const struct intel_crtc_state *crtc_state) 231 { 232 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 233 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 234 struct intel_shared_dpll *pll = crtc_state->shared_dpll; 235 unsigned int crtc_mask = drm_crtc_mask(&crtc->base); 236 237 /* PCH only available on ILK+ */ 238 if (INTEL_GEN(dev_priv) < 5) 239 return; 240 241 if (pll == NULL) 242 return; 243 244 mutex_lock(&dev_priv->dpll.lock); 245 if (drm_WARN_ON(&dev_priv->drm, !(pll->active_mask & crtc_mask))) 246 goto out; 247 248 drm_dbg_kms(&dev_priv->drm, 249 "disable %s (active %x, on? %d) for crtc %d\n", 250 pll->info->name, pll->active_mask, pll->on, 251 crtc->base.base.id); 252 253 assert_shared_dpll_enabled(dev_priv, pll); 254 drm_WARN_ON(&dev_priv->drm, !pll->on); 255 256 pll->active_mask &= ~crtc_mask; 257 if (pll->active_mask) 258 goto out; 259 260 drm_dbg_kms(&dev_priv->drm, "disabling %s\n", pll->info->name); 261 pll->info->funcs->disable(dev_priv, pll); 262 pll->on = false; 263 264 out: 265 mutex_unlock(&dev_priv->dpll.lock); 266 } 267 268 static struct intel_shared_dpll * 269 intel_find_shared_dpll(struct intel_atomic_state *state, 270 const struct intel_crtc *crtc, 271 const struct intel_dpll_hw_state *pll_state, 272 unsigned long dpll_mask) 273 { 274 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 275 struct intel_shared_dpll *pll, *unused_pll = NULL; 276 struct intel_shared_dpll_state *shared_dpll; 277 enum intel_dpll_id i; 278 279 shared_dpll = intel_atomic_get_shared_dpll_state(&state->base); 280 281 drm_WARN_ON(&dev_priv->drm, dpll_mask & ~(BIT(I915_NUM_PLLS) - 1)); 282 283 for_each_set_bit(i, &dpll_mask, I915_NUM_PLLS) { 284 pll = &dev_priv->dpll.shared_dplls[i]; 285 286 /* Only want to check enabled timings first */ 287 if (shared_dpll[i].crtc_mask == 0) { 288 if (!unused_pll) 289 unused_pll = pll; 290 continue; 291 } 292 293 if (memcmp(pll_state, 294 &shared_dpll[i].hw_state, 295 sizeof(*pll_state)) == 0) { 296 drm_dbg_kms(&dev_priv->drm, 297 "[CRTC:%d:%s] sharing existing %s (crtc mask 0x%08x, active %x)\n", 298 crtc->base.base.id, crtc->base.name, 299 pll->info->name, 300 shared_dpll[i].crtc_mask, 301 pll->active_mask); 302 return pll; 303 } 304 } 305 306 /* Ok no matching timings, maybe there's a free one? */ 307 if (unused_pll) { 308 drm_dbg_kms(&dev_priv->drm, "[CRTC:%d:%s] allocated %s\n", 309 crtc->base.base.id, crtc->base.name, 310 unused_pll->info->name); 311 return unused_pll; 312 } 313 314 return NULL; 315 } 316 317 static void 318 intel_reference_shared_dpll(struct intel_atomic_state *state, 319 const struct intel_crtc *crtc, 320 const struct intel_shared_dpll *pll, 321 const struct intel_dpll_hw_state *pll_state) 322 { 323 struct drm_i915_private *i915 = to_i915(state->base.dev); 324 struct intel_shared_dpll_state *shared_dpll; 325 const enum intel_dpll_id id = pll->info->id; 326 327 shared_dpll = intel_atomic_get_shared_dpll_state(&state->base); 328 329 if (shared_dpll[id].crtc_mask == 0) 330 shared_dpll[id].hw_state = *pll_state; 331 332 drm_dbg(&i915->drm, "using %s for pipe %c\n", pll->info->name, 333 pipe_name(crtc->pipe)); 334 335 shared_dpll[id].crtc_mask |= 1 << crtc->pipe; 336 } 337 338 static void intel_unreference_shared_dpll(struct intel_atomic_state *state, 339 const struct intel_crtc *crtc, 340 const struct intel_shared_dpll *pll) 341 { 342 struct intel_shared_dpll_state *shared_dpll; 343 344 shared_dpll = intel_atomic_get_shared_dpll_state(&state->base); 345 shared_dpll[pll->info->id].crtc_mask &= ~(1 << crtc->pipe); 346 } 347 348 static void intel_put_dpll(struct intel_atomic_state *state, 349 struct intel_crtc *crtc) 350 { 351 const struct intel_crtc_state *old_crtc_state = 352 intel_atomic_get_old_crtc_state(state, crtc); 353 struct intel_crtc_state *new_crtc_state = 354 intel_atomic_get_new_crtc_state(state, crtc); 355 356 new_crtc_state->shared_dpll = NULL; 357 358 if (!old_crtc_state->shared_dpll) 359 return; 360 361 intel_unreference_shared_dpll(state, crtc, old_crtc_state->shared_dpll); 362 } 363 364 /** 365 * intel_shared_dpll_swap_state - make atomic DPLL configuration effective 366 * @state: atomic state 367 * 368 * This is the dpll version of drm_atomic_helper_swap_state() since the 369 * helper does not handle driver-specific global state. 370 * 371 * For consistency with atomic helpers this function does a complete swap, 372 * i.e. it also puts the current state into @state, even though there is no 373 * need for that at this moment. 374 */ 375 void intel_shared_dpll_swap_state(struct intel_atomic_state *state) 376 { 377 struct drm_i915_private *dev_priv = to_i915(state->base.dev); 378 struct intel_shared_dpll_state *shared_dpll = state->shared_dpll; 379 enum intel_dpll_id i; 380 381 if (!state->dpll_set) 382 return; 383 384 for (i = 0; i < dev_priv->dpll.num_shared_dpll; i++) { 385 struct intel_shared_dpll *pll = 386 &dev_priv->dpll.shared_dplls[i]; 387 388 swap(pll->state, shared_dpll[i]); 389 } 390 } 391 392 static bool ibx_pch_dpll_get_hw_state(struct drm_i915_private *dev_priv, 393 struct intel_shared_dpll *pll, 394 struct intel_dpll_hw_state *hw_state) 395 { 396 const enum intel_dpll_id id = pll->info->id; 397 intel_wakeref_t wakeref; 398 u32 val; 399 400 wakeref = intel_display_power_get_if_enabled(dev_priv, 401 POWER_DOMAIN_DISPLAY_CORE); 402 if (!wakeref) 403 return false; 404 405 val = intel_de_read(dev_priv, PCH_DPLL(id)); 406 hw_state->dpll = val; 407 hw_state->fp0 = intel_de_read(dev_priv, PCH_FP0(id)); 408 hw_state->fp1 = intel_de_read(dev_priv, PCH_FP1(id)); 409 410 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 411 412 return val & DPLL_VCO_ENABLE; 413 } 414 415 static void ibx_pch_dpll_prepare(struct drm_i915_private *dev_priv, 416 struct intel_shared_dpll *pll) 417 { 418 const enum intel_dpll_id id = pll->info->id; 419 420 intel_de_write(dev_priv, PCH_FP0(id), pll->state.hw_state.fp0); 421 intel_de_write(dev_priv, PCH_FP1(id), pll->state.hw_state.fp1); 422 } 423 424 static void ibx_assert_pch_refclk_enabled(struct drm_i915_private *dev_priv) 425 { 426 u32 val; 427 bool enabled; 428 429 I915_STATE_WARN_ON(!(HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv))); 430 431 val = intel_de_read(dev_priv, PCH_DREF_CONTROL); 432 enabled = !!(val & (DREF_SSC_SOURCE_MASK | DREF_NONSPREAD_SOURCE_MASK | 433 DREF_SUPERSPREAD_SOURCE_MASK)); 434 I915_STATE_WARN(!enabled, "PCH refclk assertion failure, should be active but is disabled\n"); 435 } 436 437 static void ibx_pch_dpll_enable(struct drm_i915_private *dev_priv, 438 struct intel_shared_dpll *pll) 439 { 440 const enum intel_dpll_id id = pll->info->id; 441 442 /* PCH refclock must be enabled first */ 443 ibx_assert_pch_refclk_enabled(dev_priv); 444 445 intel_de_write(dev_priv, PCH_DPLL(id), pll->state.hw_state.dpll); 446 447 /* Wait for the clocks to stabilize. */ 448 intel_de_posting_read(dev_priv, PCH_DPLL(id)); 449 udelay(150); 450 451 /* The pixel multiplier can only be updated once the 452 * DPLL is enabled and the clocks are stable. 453 * 454 * So write it again. 455 */ 456 intel_de_write(dev_priv, PCH_DPLL(id), pll->state.hw_state.dpll); 457 intel_de_posting_read(dev_priv, PCH_DPLL(id)); 458 udelay(200); 459 } 460 461 static void ibx_pch_dpll_disable(struct drm_i915_private *dev_priv, 462 struct intel_shared_dpll *pll) 463 { 464 const enum intel_dpll_id id = pll->info->id; 465 466 intel_de_write(dev_priv, PCH_DPLL(id), 0); 467 intel_de_posting_read(dev_priv, PCH_DPLL(id)); 468 udelay(200); 469 } 470 471 static bool ibx_get_dpll(struct intel_atomic_state *state, 472 struct intel_crtc *crtc, 473 struct intel_encoder *encoder) 474 { 475 struct intel_crtc_state *crtc_state = 476 intel_atomic_get_new_crtc_state(state, crtc); 477 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 478 struct intel_shared_dpll *pll; 479 enum intel_dpll_id i; 480 481 if (HAS_PCH_IBX(dev_priv)) { 482 /* Ironlake PCH has a fixed PLL->PCH pipe mapping. */ 483 i = (enum intel_dpll_id) crtc->pipe; 484 pll = &dev_priv->dpll.shared_dplls[i]; 485 486 drm_dbg_kms(&dev_priv->drm, 487 "[CRTC:%d:%s] using pre-allocated %s\n", 488 crtc->base.base.id, crtc->base.name, 489 pll->info->name); 490 } else { 491 pll = intel_find_shared_dpll(state, crtc, 492 &crtc_state->dpll_hw_state, 493 BIT(DPLL_ID_PCH_PLL_B) | 494 BIT(DPLL_ID_PCH_PLL_A)); 495 } 496 497 if (!pll) 498 return false; 499 500 /* reference the pll */ 501 intel_reference_shared_dpll(state, crtc, 502 pll, &crtc_state->dpll_hw_state); 503 504 crtc_state->shared_dpll = pll; 505 506 return true; 507 } 508 509 static void ibx_dump_hw_state(struct drm_i915_private *dev_priv, 510 const struct intel_dpll_hw_state *hw_state) 511 { 512 drm_dbg_kms(&dev_priv->drm, 513 "dpll_hw_state: dpll: 0x%x, dpll_md: 0x%x, " 514 "fp0: 0x%x, fp1: 0x%x\n", 515 hw_state->dpll, 516 hw_state->dpll_md, 517 hw_state->fp0, 518 hw_state->fp1); 519 } 520 521 static const struct intel_shared_dpll_funcs ibx_pch_dpll_funcs = { 522 .prepare = ibx_pch_dpll_prepare, 523 .enable = ibx_pch_dpll_enable, 524 .disable = ibx_pch_dpll_disable, 525 .get_hw_state = ibx_pch_dpll_get_hw_state, 526 }; 527 528 static const struct dpll_info pch_plls[] = { 529 { "PCH DPLL A", &ibx_pch_dpll_funcs, DPLL_ID_PCH_PLL_A, 0 }, 530 { "PCH DPLL B", &ibx_pch_dpll_funcs, DPLL_ID_PCH_PLL_B, 0 }, 531 { }, 532 }; 533 534 static const struct intel_dpll_mgr pch_pll_mgr = { 535 .dpll_info = pch_plls, 536 .get_dplls = ibx_get_dpll, 537 .put_dplls = intel_put_dpll, 538 .dump_hw_state = ibx_dump_hw_state, 539 }; 540 541 static void hsw_ddi_wrpll_enable(struct drm_i915_private *dev_priv, 542 struct intel_shared_dpll *pll) 543 { 544 const enum intel_dpll_id id = pll->info->id; 545 546 intel_de_write(dev_priv, WRPLL_CTL(id), pll->state.hw_state.wrpll); 547 intel_de_posting_read(dev_priv, WRPLL_CTL(id)); 548 udelay(20); 549 } 550 551 static void hsw_ddi_spll_enable(struct drm_i915_private *dev_priv, 552 struct intel_shared_dpll *pll) 553 { 554 intel_de_write(dev_priv, SPLL_CTL, pll->state.hw_state.spll); 555 intel_de_posting_read(dev_priv, SPLL_CTL); 556 udelay(20); 557 } 558 559 static void hsw_ddi_wrpll_disable(struct drm_i915_private *dev_priv, 560 struct intel_shared_dpll *pll) 561 { 562 const enum intel_dpll_id id = pll->info->id; 563 u32 val; 564 565 val = intel_de_read(dev_priv, WRPLL_CTL(id)); 566 intel_de_write(dev_priv, WRPLL_CTL(id), val & ~WRPLL_PLL_ENABLE); 567 intel_de_posting_read(dev_priv, WRPLL_CTL(id)); 568 569 /* 570 * Try to set up the PCH reference clock once all DPLLs 571 * that depend on it have been shut down. 572 */ 573 if (dev_priv->pch_ssc_use & BIT(id)) 574 intel_init_pch_refclk(dev_priv); 575 } 576 577 static void hsw_ddi_spll_disable(struct drm_i915_private *dev_priv, 578 struct intel_shared_dpll *pll) 579 { 580 enum intel_dpll_id id = pll->info->id; 581 u32 val; 582 583 val = intel_de_read(dev_priv, SPLL_CTL); 584 intel_de_write(dev_priv, SPLL_CTL, val & ~SPLL_PLL_ENABLE); 585 intel_de_posting_read(dev_priv, SPLL_CTL); 586 587 /* 588 * Try to set up the PCH reference clock once all DPLLs 589 * that depend on it have been shut down. 590 */ 591 if (dev_priv->pch_ssc_use & BIT(id)) 592 intel_init_pch_refclk(dev_priv); 593 } 594 595 static bool hsw_ddi_wrpll_get_hw_state(struct drm_i915_private *dev_priv, 596 struct intel_shared_dpll *pll, 597 struct intel_dpll_hw_state *hw_state) 598 { 599 const enum intel_dpll_id id = pll->info->id; 600 intel_wakeref_t wakeref; 601 u32 val; 602 603 wakeref = intel_display_power_get_if_enabled(dev_priv, 604 POWER_DOMAIN_DISPLAY_CORE); 605 if (!wakeref) 606 return false; 607 608 val = intel_de_read(dev_priv, WRPLL_CTL(id)); 609 hw_state->wrpll = val; 610 611 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 612 613 return val & WRPLL_PLL_ENABLE; 614 } 615 616 static bool hsw_ddi_spll_get_hw_state(struct drm_i915_private *dev_priv, 617 struct intel_shared_dpll *pll, 618 struct intel_dpll_hw_state *hw_state) 619 { 620 intel_wakeref_t wakeref; 621 u32 val; 622 623 wakeref = intel_display_power_get_if_enabled(dev_priv, 624 POWER_DOMAIN_DISPLAY_CORE); 625 if (!wakeref) 626 return false; 627 628 val = intel_de_read(dev_priv, SPLL_CTL); 629 hw_state->spll = val; 630 631 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 632 633 return val & SPLL_PLL_ENABLE; 634 } 635 636 #define LC_FREQ 2700 637 #define LC_FREQ_2K U64_C(LC_FREQ * 2000) 638 639 #define P_MIN 2 640 #define P_MAX 64 641 #define P_INC 2 642 643 /* Constraints for PLL good behavior */ 644 #define REF_MIN 48 645 #define REF_MAX 400 646 #define VCO_MIN 2400 647 #define VCO_MAX 4800 648 649 struct hsw_wrpll_rnp { 650 unsigned p, n2, r2; 651 }; 652 653 static unsigned hsw_wrpll_get_budget_for_freq(int clock) 654 { 655 unsigned budget; 656 657 switch (clock) { 658 case 25175000: 659 case 25200000: 660 case 27000000: 661 case 27027000: 662 case 37762500: 663 case 37800000: 664 case 40500000: 665 case 40541000: 666 case 54000000: 667 case 54054000: 668 case 59341000: 669 case 59400000: 670 case 72000000: 671 case 74176000: 672 case 74250000: 673 case 81000000: 674 case 81081000: 675 case 89012000: 676 case 89100000: 677 case 108000000: 678 case 108108000: 679 case 111264000: 680 case 111375000: 681 case 148352000: 682 case 148500000: 683 case 162000000: 684 case 162162000: 685 case 222525000: 686 case 222750000: 687 case 296703000: 688 case 297000000: 689 budget = 0; 690 break; 691 case 233500000: 692 case 245250000: 693 case 247750000: 694 case 253250000: 695 case 298000000: 696 budget = 1500; 697 break; 698 case 169128000: 699 case 169500000: 700 case 179500000: 701 case 202000000: 702 budget = 2000; 703 break; 704 case 256250000: 705 case 262500000: 706 case 270000000: 707 case 272500000: 708 case 273750000: 709 case 280750000: 710 case 281250000: 711 case 286000000: 712 case 291750000: 713 budget = 4000; 714 break; 715 case 267250000: 716 case 268500000: 717 budget = 5000; 718 break; 719 default: 720 budget = 1000; 721 break; 722 } 723 724 return budget; 725 } 726 727 static void hsw_wrpll_update_rnp(u64 freq2k, unsigned int budget, 728 unsigned int r2, unsigned int n2, 729 unsigned int p, 730 struct hsw_wrpll_rnp *best) 731 { 732 u64 a, b, c, d, diff, diff_best; 733 734 /* No best (r,n,p) yet */ 735 if (best->p == 0) { 736 best->p = p; 737 best->n2 = n2; 738 best->r2 = r2; 739 return; 740 } 741 742 /* 743 * Output clock is (LC_FREQ_2K / 2000) * N / (P * R), which compares to 744 * freq2k. 745 * 746 * delta = 1e6 * 747 * abs(freq2k - (LC_FREQ_2K * n2/(p * r2))) / 748 * freq2k; 749 * 750 * and we would like delta <= budget. 751 * 752 * If the discrepancy is above the PPM-based budget, always prefer to 753 * improve upon the previous solution. However, if you're within the 754 * budget, try to maximize Ref * VCO, that is N / (P * R^2). 755 */ 756 a = freq2k * budget * p * r2; 757 b = freq2k * budget * best->p * best->r2; 758 diff = abs_diff(freq2k * p * r2, LC_FREQ_2K * n2); 759 diff_best = abs_diff(freq2k * best->p * best->r2, 760 LC_FREQ_2K * best->n2); 761 c = 1000000 * diff; 762 d = 1000000 * diff_best; 763 764 if (a < c && b < d) { 765 /* If both are above the budget, pick the closer */ 766 if (best->p * best->r2 * diff < p * r2 * diff_best) { 767 best->p = p; 768 best->n2 = n2; 769 best->r2 = r2; 770 } 771 } else if (a >= c && b < d) { 772 /* If A is below the threshold but B is above it? Update. */ 773 best->p = p; 774 best->n2 = n2; 775 best->r2 = r2; 776 } else if (a >= c && b >= d) { 777 /* Both are below the limit, so pick the higher n2/(r2*r2) */ 778 if (n2 * best->r2 * best->r2 > best->n2 * r2 * r2) { 779 best->p = p; 780 best->n2 = n2; 781 best->r2 = r2; 782 } 783 } 784 /* Otherwise a < c && b >= d, do nothing */ 785 } 786 787 static void 788 hsw_ddi_calculate_wrpll(int clock /* in Hz */, 789 unsigned *r2_out, unsigned *n2_out, unsigned *p_out) 790 { 791 u64 freq2k; 792 unsigned p, n2, r2; 793 struct hsw_wrpll_rnp best = { 0, 0, 0 }; 794 unsigned budget; 795 796 freq2k = clock / 100; 797 798 budget = hsw_wrpll_get_budget_for_freq(clock); 799 800 /* Special case handling for 540 pixel clock: bypass WR PLL entirely 801 * and directly pass the LC PLL to it. */ 802 if (freq2k == 5400000) { 803 *n2_out = 2; 804 *p_out = 1; 805 *r2_out = 2; 806 return; 807 } 808 809 /* 810 * Ref = LC_FREQ / R, where Ref is the actual reference input seen by 811 * the WR PLL. 812 * 813 * We want R so that REF_MIN <= Ref <= REF_MAX. 814 * Injecting R2 = 2 * R gives: 815 * REF_MAX * r2 > LC_FREQ * 2 and 816 * REF_MIN * r2 < LC_FREQ * 2 817 * 818 * Which means the desired boundaries for r2 are: 819 * LC_FREQ * 2 / REF_MAX < r2 < LC_FREQ * 2 / REF_MIN 820 * 821 */ 822 for (r2 = LC_FREQ * 2 / REF_MAX + 1; 823 r2 <= LC_FREQ * 2 / REF_MIN; 824 r2++) { 825 826 /* 827 * VCO = N * Ref, that is: VCO = N * LC_FREQ / R 828 * 829 * Once again we want VCO_MIN <= VCO <= VCO_MAX. 830 * Injecting R2 = 2 * R and N2 = 2 * N, we get: 831 * VCO_MAX * r2 > n2 * LC_FREQ and 832 * VCO_MIN * r2 < n2 * LC_FREQ) 833 * 834 * Which means the desired boundaries for n2 are: 835 * VCO_MIN * r2 / LC_FREQ < n2 < VCO_MAX * r2 / LC_FREQ 836 */ 837 for (n2 = VCO_MIN * r2 / LC_FREQ + 1; 838 n2 <= VCO_MAX * r2 / LC_FREQ; 839 n2++) { 840 841 for (p = P_MIN; p <= P_MAX; p += P_INC) 842 hsw_wrpll_update_rnp(freq2k, budget, 843 r2, n2, p, &best); 844 } 845 } 846 847 *n2_out = best.n2; 848 *p_out = best.p; 849 *r2_out = best.r2; 850 } 851 852 static struct intel_shared_dpll * 853 hsw_ddi_wrpll_get_dpll(struct intel_atomic_state *state, 854 struct intel_crtc *crtc) 855 { 856 struct intel_crtc_state *crtc_state = 857 intel_atomic_get_new_crtc_state(state, crtc); 858 struct intel_shared_dpll *pll; 859 u32 val; 860 unsigned int p, n2, r2; 861 862 hsw_ddi_calculate_wrpll(crtc_state->port_clock * 1000, &r2, &n2, &p); 863 864 val = WRPLL_PLL_ENABLE | WRPLL_REF_LCPLL | 865 WRPLL_DIVIDER_REFERENCE(r2) | WRPLL_DIVIDER_FEEDBACK(n2) | 866 WRPLL_DIVIDER_POST(p); 867 868 crtc_state->dpll_hw_state.wrpll = val; 869 870 pll = intel_find_shared_dpll(state, crtc, 871 &crtc_state->dpll_hw_state, 872 BIT(DPLL_ID_WRPLL2) | 873 BIT(DPLL_ID_WRPLL1)); 874 875 if (!pll) 876 return NULL; 877 878 return pll; 879 } 880 881 static int hsw_ddi_wrpll_get_freq(struct drm_i915_private *dev_priv, 882 const struct intel_shared_dpll *pll) 883 { 884 int refclk; 885 int n, p, r; 886 u32 wrpll = pll->state.hw_state.wrpll; 887 888 switch (wrpll & WRPLL_REF_MASK) { 889 case WRPLL_REF_SPECIAL_HSW: 890 /* Muxed-SSC for BDW, non-SSC for non-ULT HSW. */ 891 if (IS_HASWELL(dev_priv) && !IS_HSW_ULT(dev_priv)) { 892 refclk = dev_priv->dpll.ref_clks.nssc; 893 break; 894 } 895 fallthrough; 896 case WRPLL_REF_PCH_SSC: 897 /* 898 * We could calculate spread here, but our checking 899 * code only cares about 5% accuracy, and spread is a max of 900 * 0.5% downspread. 901 */ 902 refclk = dev_priv->dpll.ref_clks.ssc; 903 break; 904 case WRPLL_REF_LCPLL: 905 refclk = 2700000; 906 break; 907 default: 908 MISSING_CASE(wrpll); 909 return 0; 910 } 911 912 r = wrpll & WRPLL_DIVIDER_REF_MASK; 913 p = (wrpll & WRPLL_DIVIDER_POST_MASK) >> WRPLL_DIVIDER_POST_SHIFT; 914 n = (wrpll & WRPLL_DIVIDER_FB_MASK) >> WRPLL_DIVIDER_FB_SHIFT; 915 916 /* Convert to KHz, p & r have a fixed point portion */ 917 return (refclk * n / 10) / (p * r) * 2; 918 } 919 920 static struct intel_shared_dpll * 921 hsw_ddi_lcpll_get_dpll(struct intel_crtc_state *crtc_state) 922 { 923 struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev); 924 struct intel_shared_dpll *pll; 925 enum intel_dpll_id pll_id; 926 int clock = crtc_state->port_clock; 927 928 switch (clock / 2) { 929 case 81000: 930 pll_id = DPLL_ID_LCPLL_810; 931 break; 932 case 135000: 933 pll_id = DPLL_ID_LCPLL_1350; 934 break; 935 case 270000: 936 pll_id = DPLL_ID_LCPLL_2700; 937 break; 938 default: 939 drm_dbg_kms(&dev_priv->drm, "Invalid clock for DP: %d\n", 940 clock); 941 return NULL; 942 } 943 944 pll = intel_get_shared_dpll_by_id(dev_priv, pll_id); 945 946 if (!pll) 947 return NULL; 948 949 return pll; 950 } 951 952 static int hsw_ddi_lcpll_get_freq(struct drm_i915_private *i915, 953 const struct intel_shared_dpll *pll) 954 { 955 int link_clock = 0; 956 957 switch (pll->info->id) { 958 case DPLL_ID_LCPLL_810: 959 link_clock = 81000; 960 break; 961 case DPLL_ID_LCPLL_1350: 962 link_clock = 135000; 963 break; 964 case DPLL_ID_LCPLL_2700: 965 link_clock = 270000; 966 break; 967 default: 968 drm_WARN(&i915->drm, 1, "bad port clock sel\n"); 969 break; 970 } 971 972 return link_clock * 2; 973 } 974 975 static struct intel_shared_dpll * 976 hsw_ddi_spll_get_dpll(struct intel_atomic_state *state, 977 struct intel_crtc *crtc) 978 { 979 struct intel_crtc_state *crtc_state = 980 intel_atomic_get_new_crtc_state(state, crtc); 981 982 if (drm_WARN_ON(crtc->base.dev, crtc_state->port_clock / 2 != 135000)) 983 return NULL; 984 985 crtc_state->dpll_hw_state.spll = SPLL_PLL_ENABLE | SPLL_FREQ_1350MHz | 986 SPLL_REF_MUXED_SSC; 987 988 return intel_find_shared_dpll(state, crtc, &crtc_state->dpll_hw_state, 989 BIT(DPLL_ID_SPLL)); 990 } 991 992 static int hsw_ddi_spll_get_freq(struct drm_i915_private *i915, 993 const struct intel_shared_dpll *pll) 994 { 995 int link_clock = 0; 996 997 switch (pll->state.hw_state.spll & SPLL_FREQ_MASK) { 998 case SPLL_FREQ_810MHz: 999 link_clock = 81000; 1000 break; 1001 case SPLL_FREQ_1350MHz: 1002 link_clock = 135000; 1003 break; 1004 case SPLL_FREQ_2700MHz: 1005 link_clock = 270000; 1006 break; 1007 default: 1008 drm_WARN(&i915->drm, 1, "bad spll freq\n"); 1009 break; 1010 } 1011 1012 return link_clock * 2; 1013 } 1014 1015 static bool hsw_get_dpll(struct intel_atomic_state *state, 1016 struct intel_crtc *crtc, 1017 struct intel_encoder *encoder) 1018 { 1019 struct intel_crtc_state *crtc_state = 1020 intel_atomic_get_new_crtc_state(state, crtc); 1021 struct intel_shared_dpll *pll; 1022 1023 memset(&crtc_state->dpll_hw_state, 0, 1024 sizeof(crtc_state->dpll_hw_state)); 1025 1026 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) 1027 pll = hsw_ddi_wrpll_get_dpll(state, crtc); 1028 else if (intel_crtc_has_dp_encoder(crtc_state)) 1029 pll = hsw_ddi_lcpll_get_dpll(crtc_state); 1030 else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_ANALOG)) 1031 pll = hsw_ddi_spll_get_dpll(state, crtc); 1032 else 1033 return false; 1034 1035 if (!pll) 1036 return false; 1037 1038 intel_reference_shared_dpll(state, crtc, 1039 pll, &crtc_state->dpll_hw_state); 1040 1041 crtc_state->shared_dpll = pll; 1042 1043 return true; 1044 } 1045 1046 static void hsw_update_dpll_ref_clks(struct drm_i915_private *i915) 1047 { 1048 i915->dpll.ref_clks.ssc = 135000; 1049 /* Non-SSC is only used on non-ULT HSW. */ 1050 if (intel_de_read(i915, FUSE_STRAP3) & HSW_REF_CLK_SELECT) 1051 i915->dpll.ref_clks.nssc = 24000; 1052 else 1053 i915->dpll.ref_clks.nssc = 135000; 1054 } 1055 1056 static void hsw_dump_hw_state(struct drm_i915_private *dev_priv, 1057 const struct intel_dpll_hw_state *hw_state) 1058 { 1059 drm_dbg_kms(&dev_priv->drm, "dpll_hw_state: wrpll: 0x%x spll: 0x%x\n", 1060 hw_state->wrpll, hw_state->spll); 1061 } 1062 1063 static const struct intel_shared_dpll_funcs hsw_ddi_wrpll_funcs = { 1064 .enable = hsw_ddi_wrpll_enable, 1065 .disable = hsw_ddi_wrpll_disable, 1066 .get_hw_state = hsw_ddi_wrpll_get_hw_state, 1067 .get_freq = hsw_ddi_wrpll_get_freq, 1068 }; 1069 1070 static const struct intel_shared_dpll_funcs hsw_ddi_spll_funcs = { 1071 .enable = hsw_ddi_spll_enable, 1072 .disable = hsw_ddi_spll_disable, 1073 .get_hw_state = hsw_ddi_spll_get_hw_state, 1074 .get_freq = hsw_ddi_spll_get_freq, 1075 }; 1076 1077 static void hsw_ddi_lcpll_enable(struct drm_i915_private *dev_priv, 1078 struct intel_shared_dpll *pll) 1079 { 1080 } 1081 1082 static void hsw_ddi_lcpll_disable(struct drm_i915_private *dev_priv, 1083 struct intel_shared_dpll *pll) 1084 { 1085 } 1086 1087 static bool hsw_ddi_lcpll_get_hw_state(struct drm_i915_private *dev_priv, 1088 struct intel_shared_dpll *pll, 1089 struct intel_dpll_hw_state *hw_state) 1090 { 1091 return true; 1092 } 1093 1094 static const struct intel_shared_dpll_funcs hsw_ddi_lcpll_funcs = { 1095 .enable = hsw_ddi_lcpll_enable, 1096 .disable = hsw_ddi_lcpll_disable, 1097 .get_hw_state = hsw_ddi_lcpll_get_hw_state, 1098 .get_freq = hsw_ddi_lcpll_get_freq, 1099 }; 1100 1101 static const struct dpll_info hsw_plls[] = { 1102 { "WRPLL 1", &hsw_ddi_wrpll_funcs, DPLL_ID_WRPLL1, 0 }, 1103 { "WRPLL 2", &hsw_ddi_wrpll_funcs, DPLL_ID_WRPLL2, 0 }, 1104 { "SPLL", &hsw_ddi_spll_funcs, DPLL_ID_SPLL, 0 }, 1105 { "LCPLL 810", &hsw_ddi_lcpll_funcs, DPLL_ID_LCPLL_810, INTEL_DPLL_ALWAYS_ON }, 1106 { "LCPLL 1350", &hsw_ddi_lcpll_funcs, DPLL_ID_LCPLL_1350, INTEL_DPLL_ALWAYS_ON }, 1107 { "LCPLL 2700", &hsw_ddi_lcpll_funcs, DPLL_ID_LCPLL_2700, INTEL_DPLL_ALWAYS_ON }, 1108 { }, 1109 }; 1110 1111 static const struct intel_dpll_mgr hsw_pll_mgr = { 1112 .dpll_info = hsw_plls, 1113 .get_dplls = hsw_get_dpll, 1114 .put_dplls = intel_put_dpll, 1115 .update_ref_clks = hsw_update_dpll_ref_clks, 1116 .dump_hw_state = hsw_dump_hw_state, 1117 }; 1118 1119 struct skl_dpll_regs { 1120 i915_reg_t ctl, cfgcr1, cfgcr2; 1121 }; 1122 1123 /* this array is indexed by the *shared* pll id */ 1124 static const struct skl_dpll_regs skl_dpll_regs[4] = { 1125 { 1126 /* DPLL 0 */ 1127 .ctl = LCPLL1_CTL, 1128 /* DPLL 0 doesn't support HDMI mode */ 1129 }, 1130 { 1131 /* DPLL 1 */ 1132 .ctl = LCPLL2_CTL, 1133 .cfgcr1 = DPLL_CFGCR1(SKL_DPLL1), 1134 .cfgcr2 = DPLL_CFGCR2(SKL_DPLL1), 1135 }, 1136 { 1137 /* DPLL 2 */ 1138 .ctl = WRPLL_CTL(0), 1139 .cfgcr1 = DPLL_CFGCR1(SKL_DPLL2), 1140 .cfgcr2 = DPLL_CFGCR2(SKL_DPLL2), 1141 }, 1142 { 1143 /* DPLL 3 */ 1144 .ctl = WRPLL_CTL(1), 1145 .cfgcr1 = DPLL_CFGCR1(SKL_DPLL3), 1146 .cfgcr2 = DPLL_CFGCR2(SKL_DPLL3), 1147 }, 1148 }; 1149 1150 static void skl_ddi_pll_write_ctrl1(struct drm_i915_private *dev_priv, 1151 struct intel_shared_dpll *pll) 1152 { 1153 const enum intel_dpll_id id = pll->info->id; 1154 u32 val; 1155 1156 val = intel_de_read(dev_priv, DPLL_CTRL1); 1157 1158 val &= ~(DPLL_CTRL1_HDMI_MODE(id) | 1159 DPLL_CTRL1_SSC(id) | 1160 DPLL_CTRL1_LINK_RATE_MASK(id)); 1161 val |= pll->state.hw_state.ctrl1 << (id * 6); 1162 1163 intel_de_write(dev_priv, DPLL_CTRL1, val); 1164 intel_de_posting_read(dev_priv, DPLL_CTRL1); 1165 } 1166 1167 static void skl_ddi_pll_enable(struct drm_i915_private *dev_priv, 1168 struct intel_shared_dpll *pll) 1169 { 1170 const struct skl_dpll_regs *regs = skl_dpll_regs; 1171 const enum intel_dpll_id id = pll->info->id; 1172 1173 skl_ddi_pll_write_ctrl1(dev_priv, pll); 1174 1175 intel_de_write(dev_priv, regs[id].cfgcr1, pll->state.hw_state.cfgcr1); 1176 intel_de_write(dev_priv, regs[id].cfgcr2, pll->state.hw_state.cfgcr2); 1177 intel_de_posting_read(dev_priv, regs[id].cfgcr1); 1178 intel_de_posting_read(dev_priv, regs[id].cfgcr2); 1179 1180 /* the enable bit is always bit 31 */ 1181 intel_de_write(dev_priv, regs[id].ctl, 1182 intel_de_read(dev_priv, regs[id].ctl) | LCPLL_PLL_ENABLE); 1183 1184 if (intel_de_wait_for_set(dev_priv, DPLL_STATUS, DPLL_LOCK(id), 5)) 1185 drm_err(&dev_priv->drm, "DPLL %d not locked\n", id); 1186 } 1187 1188 static void skl_ddi_dpll0_enable(struct drm_i915_private *dev_priv, 1189 struct intel_shared_dpll *pll) 1190 { 1191 skl_ddi_pll_write_ctrl1(dev_priv, pll); 1192 } 1193 1194 static void skl_ddi_pll_disable(struct drm_i915_private *dev_priv, 1195 struct intel_shared_dpll *pll) 1196 { 1197 const struct skl_dpll_regs *regs = skl_dpll_regs; 1198 const enum intel_dpll_id id = pll->info->id; 1199 1200 /* the enable bit is always bit 31 */ 1201 intel_de_write(dev_priv, regs[id].ctl, 1202 intel_de_read(dev_priv, regs[id].ctl) & ~LCPLL_PLL_ENABLE); 1203 intel_de_posting_read(dev_priv, regs[id].ctl); 1204 } 1205 1206 static void skl_ddi_dpll0_disable(struct drm_i915_private *dev_priv, 1207 struct intel_shared_dpll *pll) 1208 { 1209 } 1210 1211 static bool skl_ddi_pll_get_hw_state(struct drm_i915_private *dev_priv, 1212 struct intel_shared_dpll *pll, 1213 struct intel_dpll_hw_state *hw_state) 1214 { 1215 u32 val; 1216 const struct skl_dpll_regs *regs = skl_dpll_regs; 1217 const enum intel_dpll_id id = pll->info->id; 1218 intel_wakeref_t wakeref; 1219 bool ret; 1220 1221 wakeref = intel_display_power_get_if_enabled(dev_priv, 1222 POWER_DOMAIN_DISPLAY_CORE); 1223 if (!wakeref) 1224 return false; 1225 1226 ret = false; 1227 1228 val = intel_de_read(dev_priv, regs[id].ctl); 1229 if (!(val & LCPLL_PLL_ENABLE)) 1230 goto out; 1231 1232 val = intel_de_read(dev_priv, DPLL_CTRL1); 1233 hw_state->ctrl1 = (val >> (id * 6)) & 0x3f; 1234 1235 /* avoid reading back stale values if HDMI mode is not enabled */ 1236 if (val & DPLL_CTRL1_HDMI_MODE(id)) { 1237 hw_state->cfgcr1 = intel_de_read(dev_priv, regs[id].cfgcr1); 1238 hw_state->cfgcr2 = intel_de_read(dev_priv, regs[id].cfgcr2); 1239 } 1240 ret = true; 1241 1242 out: 1243 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 1244 1245 return ret; 1246 } 1247 1248 static bool skl_ddi_dpll0_get_hw_state(struct drm_i915_private *dev_priv, 1249 struct intel_shared_dpll *pll, 1250 struct intel_dpll_hw_state *hw_state) 1251 { 1252 const struct skl_dpll_regs *regs = skl_dpll_regs; 1253 const enum intel_dpll_id id = pll->info->id; 1254 intel_wakeref_t wakeref; 1255 u32 val; 1256 bool ret; 1257 1258 wakeref = intel_display_power_get_if_enabled(dev_priv, 1259 POWER_DOMAIN_DISPLAY_CORE); 1260 if (!wakeref) 1261 return false; 1262 1263 ret = false; 1264 1265 /* DPLL0 is always enabled since it drives CDCLK */ 1266 val = intel_de_read(dev_priv, regs[id].ctl); 1267 if (drm_WARN_ON(&dev_priv->drm, !(val & LCPLL_PLL_ENABLE))) 1268 goto out; 1269 1270 val = intel_de_read(dev_priv, DPLL_CTRL1); 1271 hw_state->ctrl1 = (val >> (id * 6)) & 0x3f; 1272 1273 ret = true; 1274 1275 out: 1276 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 1277 1278 return ret; 1279 } 1280 1281 struct skl_wrpll_context { 1282 u64 min_deviation; /* current minimal deviation */ 1283 u64 central_freq; /* chosen central freq */ 1284 u64 dco_freq; /* chosen dco freq */ 1285 unsigned int p; /* chosen divider */ 1286 }; 1287 1288 static void skl_wrpll_context_init(struct skl_wrpll_context *ctx) 1289 { 1290 memset(ctx, 0, sizeof(*ctx)); 1291 1292 ctx->min_deviation = U64_MAX; 1293 } 1294 1295 /* DCO freq must be within +1%/-6% of the DCO central freq */ 1296 #define SKL_DCO_MAX_PDEVIATION 100 1297 #define SKL_DCO_MAX_NDEVIATION 600 1298 1299 static void skl_wrpll_try_divider(struct skl_wrpll_context *ctx, 1300 u64 central_freq, 1301 u64 dco_freq, 1302 unsigned int divider) 1303 { 1304 u64 deviation; 1305 1306 deviation = div64_u64(10000 * abs_diff(dco_freq, central_freq), 1307 central_freq); 1308 1309 /* positive deviation */ 1310 if (dco_freq >= central_freq) { 1311 if (deviation < SKL_DCO_MAX_PDEVIATION && 1312 deviation < ctx->min_deviation) { 1313 ctx->min_deviation = deviation; 1314 ctx->central_freq = central_freq; 1315 ctx->dco_freq = dco_freq; 1316 ctx->p = divider; 1317 } 1318 /* negative deviation */ 1319 } else if (deviation < SKL_DCO_MAX_NDEVIATION && 1320 deviation < ctx->min_deviation) { 1321 ctx->min_deviation = deviation; 1322 ctx->central_freq = central_freq; 1323 ctx->dco_freq = dco_freq; 1324 ctx->p = divider; 1325 } 1326 } 1327 1328 static void skl_wrpll_get_multipliers(unsigned int p, 1329 unsigned int *p0 /* out */, 1330 unsigned int *p1 /* out */, 1331 unsigned int *p2 /* out */) 1332 { 1333 /* even dividers */ 1334 if (p % 2 == 0) { 1335 unsigned int half = p / 2; 1336 1337 if (half == 1 || half == 2 || half == 3 || half == 5) { 1338 *p0 = 2; 1339 *p1 = 1; 1340 *p2 = half; 1341 } else if (half % 2 == 0) { 1342 *p0 = 2; 1343 *p1 = half / 2; 1344 *p2 = 2; 1345 } else if (half % 3 == 0) { 1346 *p0 = 3; 1347 *p1 = half / 3; 1348 *p2 = 2; 1349 } else if (half % 7 == 0) { 1350 *p0 = 7; 1351 *p1 = half / 7; 1352 *p2 = 2; 1353 } 1354 } else if (p == 3 || p == 9) { /* 3, 5, 7, 9, 15, 21, 35 */ 1355 *p0 = 3; 1356 *p1 = 1; 1357 *p2 = p / 3; 1358 } else if (p == 5 || p == 7) { 1359 *p0 = p; 1360 *p1 = 1; 1361 *p2 = 1; 1362 } else if (p == 15) { 1363 *p0 = 3; 1364 *p1 = 1; 1365 *p2 = 5; 1366 } else if (p == 21) { 1367 *p0 = 7; 1368 *p1 = 1; 1369 *p2 = 3; 1370 } else if (p == 35) { 1371 *p0 = 7; 1372 *p1 = 1; 1373 *p2 = 5; 1374 } 1375 } 1376 1377 struct skl_wrpll_params { 1378 u32 dco_fraction; 1379 u32 dco_integer; 1380 u32 qdiv_ratio; 1381 u32 qdiv_mode; 1382 u32 kdiv; 1383 u32 pdiv; 1384 u32 central_freq; 1385 }; 1386 1387 static void skl_wrpll_params_populate(struct skl_wrpll_params *params, 1388 u64 afe_clock, 1389 int ref_clock, 1390 u64 central_freq, 1391 u32 p0, u32 p1, u32 p2) 1392 { 1393 u64 dco_freq; 1394 1395 switch (central_freq) { 1396 case 9600000000ULL: 1397 params->central_freq = 0; 1398 break; 1399 case 9000000000ULL: 1400 params->central_freq = 1; 1401 break; 1402 case 8400000000ULL: 1403 params->central_freq = 3; 1404 } 1405 1406 switch (p0) { 1407 case 1: 1408 params->pdiv = 0; 1409 break; 1410 case 2: 1411 params->pdiv = 1; 1412 break; 1413 case 3: 1414 params->pdiv = 2; 1415 break; 1416 case 7: 1417 params->pdiv = 4; 1418 break; 1419 default: 1420 WARN(1, "Incorrect PDiv\n"); 1421 } 1422 1423 switch (p2) { 1424 case 5: 1425 params->kdiv = 0; 1426 break; 1427 case 2: 1428 params->kdiv = 1; 1429 break; 1430 case 3: 1431 params->kdiv = 2; 1432 break; 1433 case 1: 1434 params->kdiv = 3; 1435 break; 1436 default: 1437 WARN(1, "Incorrect KDiv\n"); 1438 } 1439 1440 params->qdiv_ratio = p1; 1441 params->qdiv_mode = (params->qdiv_ratio == 1) ? 0 : 1; 1442 1443 dco_freq = p0 * p1 * p2 * afe_clock; 1444 1445 /* 1446 * Intermediate values are in Hz. 1447 * Divide by MHz to match bsepc 1448 */ 1449 params->dco_integer = div_u64(dco_freq, ref_clock * KHz(1)); 1450 params->dco_fraction = 1451 div_u64((div_u64(dco_freq, ref_clock / KHz(1)) - 1452 params->dco_integer * MHz(1)) * 0x8000, MHz(1)); 1453 } 1454 1455 static bool 1456 skl_ddi_calculate_wrpll(int clock /* in Hz */, 1457 int ref_clock, 1458 struct skl_wrpll_params *wrpll_params) 1459 { 1460 u64 afe_clock = clock * 5; /* AFE Clock is 5x Pixel clock */ 1461 u64 dco_central_freq[3] = { 8400000000ULL, 1462 9000000000ULL, 1463 9600000000ULL }; 1464 static const int even_dividers[] = { 4, 6, 8, 10, 12, 14, 16, 18, 20, 1465 24, 28, 30, 32, 36, 40, 42, 44, 1466 48, 52, 54, 56, 60, 64, 66, 68, 1467 70, 72, 76, 78, 80, 84, 88, 90, 1468 92, 96, 98 }; 1469 static const int odd_dividers[] = { 3, 5, 7, 9, 15, 21, 35 }; 1470 static const struct { 1471 const int *list; 1472 int n_dividers; 1473 } dividers[] = { 1474 { even_dividers, ARRAY_SIZE(even_dividers) }, 1475 { odd_dividers, ARRAY_SIZE(odd_dividers) }, 1476 }; 1477 struct skl_wrpll_context ctx; 1478 unsigned int dco, d, i; 1479 unsigned int p0, p1, p2; 1480 1481 skl_wrpll_context_init(&ctx); 1482 1483 for (d = 0; d < ARRAY_SIZE(dividers); d++) { 1484 for (dco = 0; dco < ARRAY_SIZE(dco_central_freq); dco++) { 1485 for (i = 0; i < dividers[d].n_dividers; i++) { 1486 unsigned int p = dividers[d].list[i]; 1487 u64 dco_freq = p * afe_clock; 1488 1489 skl_wrpll_try_divider(&ctx, 1490 dco_central_freq[dco], 1491 dco_freq, 1492 p); 1493 /* 1494 * Skip the remaining dividers if we're sure to 1495 * have found the definitive divider, we can't 1496 * improve a 0 deviation. 1497 */ 1498 if (ctx.min_deviation == 0) 1499 goto skip_remaining_dividers; 1500 } 1501 } 1502 1503 skip_remaining_dividers: 1504 /* 1505 * If a solution is found with an even divider, prefer 1506 * this one. 1507 */ 1508 if (d == 0 && ctx.p) 1509 break; 1510 } 1511 1512 if (!ctx.p) { 1513 DRM_DEBUG_DRIVER("No valid divider found for %dHz\n", clock); 1514 return false; 1515 } 1516 1517 /* 1518 * gcc incorrectly analyses that these can be used without being 1519 * initialized. To be fair, it's hard to guess. 1520 */ 1521 p0 = p1 = p2 = 0; 1522 skl_wrpll_get_multipliers(ctx.p, &p0, &p1, &p2); 1523 skl_wrpll_params_populate(wrpll_params, afe_clock, ref_clock, 1524 ctx.central_freq, p0, p1, p2); 1525 1526 return true; 1527 } 1528 1529 static bool skl_ddi_hdmi_pll_dividers(struct intel_crtc_state *crtc_state) 1530 { 1531 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev); 1532 u32 ctrl1, cfgcr1, cfgcr2; 1533 struct skl_wrpll_params wrpll_params = { 0, }; 1534 1535 /* 1536 * See comment in intel_dpll_hw_state to understand why we always use 0 1537 * as the DPLL id in this function. 1538 */ 1539 ctrl1 = DPLL_CTRL1_OVERRIDE(0); 1540 1541 ctrl1 |= DPLL_CTRL1_HDMI_MODE(0); 1542 1543 if (!skl_ddi_calculate_wrpll(crtc_state->port_clock * 1000, 1544 i915->dpll.ref_clks.nssc, 1545 &wrpll_params)) 1546 return false; 1547 1548 cfgcr1 = DPLL_CFGCR1_FREQ_ENABLE | 1549 DPLL_CFGCR1_DCO_FRACTION(wrpll_params.dco_fraction) | 1550 wrpll_params.dco_integer; 1551 1552 cfgcr2 = DPLL_CFGCR2_QDIV_RATIO(wrpll_params.qdiv_ratio) | 1553 DPLL_CFGCR2_QDIV_MODE(wrpll_params.qdiv_mode) | 1554 DPLL_CFGCR2_KDIV(wrpll_params.kdiv) | 1555 DPLL_CFGCR2_PDIV(wrpll_params.pdiv) | 1556 wrpll_params.central_freq; 1557 1558 memset(&crtc_state->dpll_hw_state, 0, 1559 sizeof(crtc_state->dpll_hw_state)); 1560 1561 crtc_state->dpll_hw_state.ctrl1 = ctrl1; 1562 crtc_state->dpll_hw_state.cfgcr1 = cfgcr1; 1563 crtc_state->dpll_hw_state.cfgcr2 = cfgcr2; 1564 return true; 1565 } 1566 1567 static int skl_ddi_wrpll_get_freq(struct drm_i915_private *i915, 1568 const struct intel_shared_dpll *pll) 1569 { 1570 const struct intel_dpll_hw_state *pll_state = &pll->state.hw_state; 1571 int ref_clock = i915->dpll.ref_clks.nssc; 1572 u32 p0, p1, p2, dco_freq; 1573 1574 p0 = pll_state->cfgcr2 & DPLL_CFGCR2_PDIV_MASK; 1575 p2 = pll_state->cfgcr2 & DPLL_CFGCR2_KDIV_MASK; 1576 1577 if (pll_state->cfgcr2 & DPLL_CFGCR2_QDIV_MODE(1)) 1578 p1 = (pll_state->cfgcr2 & DPLL_CFGCR2_QDIV_RATIO_MASK) >> 8; 1579 else 1580 p1 = 1; 1581 1582 1583 switch (p0) { 1584 case DPLL_CFGCR2_PDIV_1: 1585 p0 = 1; 1586 break; 1587 case DPLL_CFGCR2_PDIV_2: 1588 p0 = 2; 1589 break; 1590 case DPLL_CFGCR2_PDIV_3: 1591 p0 = 3; 1592 break; 1593 case DPLL_CFGCR2_PDIV_7: 1594 p0 = 7; 1595 break; 1596 } 1597 1598 switch (p2) { 1599 case DPLL_CFGCR2_KDIV_5: 1600 p2 = 5; 1601 break; 1602 case DPLL_CFGCR2_KDIV_2: 1603 p2 = 2; 1604 break; 1605 case DPLL_CFGCR2_KDIV_3: 1606 p2 = 3; 1607 break; 1608 case DPLL_CFGCR2_KDIV_1: 1609 p2 = 1; 1610 break; 1611 } 1612 1613 dco_freq = (pll_state->cfgcr1 & DPLL_CFGCR1_DCO_INTEGER_MASK) * 1614 ref_clock; 1615 1616 dco_freq += ((pll_state->cfgcr1 & DPLL_CFGCR1_DCO_FRACTION_MASK) >> 9) * 1617 ref_clock / 0x8000; 1618 1619 if (drm_WARN_ON(&i915->drm, p0 == 0 || p1 == 0 || p2 == 0)) 1620 return 0; 1621 1622 return dco_freq / (p0 * p1 * p2 * 5); 1623 } 1624 1625 static bool 1626 skl_ddi_dp_set_dpll_hw_state(struct intel_crtc_state *crtc_state) 1627 { 1628 u32 ctrl1; 1629 1630 /* 1631 * See comment in intel_dpll_hw_state to understand why we always use 0 1632 * as the DPLL id in this function. 1633 */ 1634 ctrl1 = DPLL_CTRL1_OVERRIDE(0); 1635 switch (crtc_state->port_clock / 2) { 1636 case 81000: 1637 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_810, 0); 1638 break; 1639 case 135000: 1640 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1350, 0); 1641 break; 1642 case 270000: 1643 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_2700, 0); 1644 break; 1645 /* eDP 1.4 rates */ 1646 case 162000: 1647 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1620, 0); 1648 break; 1649 case 108000: 1650 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_1080, 0); 1651 break; 1652 case 216000: 1653 ctrl1 |= DPLL_CTRL1_LINK_RATE(DPLL_CTRL1_LINK_RATE_2160, 0); 1654 break; 1655 } 1656 1657 memset(&crtc_state->dpll_hw_state, 0, 1658 sizeof(crtc_state->dpll_hw_state)); 1659 1660 crtc_state->dpll_hw_state.ctrl1 = ctrl1; 1661 1662 return true; 1663 } 1664 1665 static int skl_ddi_lcpll_get_freq(struct drm_i915_private *i915, 1666 const struct intel_shared_dpll *pll) 1667 { 1668 int link_clock = 0; 1669 1670 switch ((pll->state.hw_state.ctrl1 & 1671 DPLL_CTRL1_LINK_RATE_MASK(0)) >> 1672 DPLL_CTRL1_LINK_RATE_SHIFT(0)) { 1673 case DPLL_CTRL1_LINK_RATE_810: 1674 link_clock = 81000; 1675 break; 1676 case DPLL_CTRL1_LINK_RATE_1080: 1677 link_clock = 108000; 1678 break; 1679 case DPLL_CTRL1_LINK_RATE_1350: 1680 link_clock = 135000; 1681 break; 1682 case DPLL_CTRL1_LINK_RATE_1620: 1683 link_clock = 162000; 1684 break; 1685 case DPLL_CTRL1_LINK_RATE_2160: 1686 link_clock = 216000; 1687 break; 1688 case DPLL_CTRL1_LINK_RATE_2700: 1689 link_clock = 270000; 1690 break; 1691 default: 1692 drm_WARN(&i915->drm, 1, "Unsupported link rate\n"); 1693 break; 1694 } 1695 1696 return link_clock * 2; 1697 } 1698 1699 static bool skl_get_dpll(struct intel_atomic_state *state, 1700 struct intel_crtc *crtc, 1701 struct intel_encoder *encoder) 1702 { 1703 struct intel_crtc_state *crtc_state = 1704 intel_atomic_get_new_crtc_state(state, crtc); 1705 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 1706 struct intel_shared_dpll *pll; 1707 bool bret; 1708 1709 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) { 1710 bret = skl_ddi_hdmi_pll_dividers(crtc_state); 1711 if (!bret) { 1712 drm_dbg_kms(&i915->drm, 1713 "Could not get HDMI pll dividers.\n"); 1714 return false; 1715 } 1716 } else if (intel_crtc_has_dp_encoder(crtc_state)) { 1717 bret = skl_ddi_dp_set_dpll_hw_state(crtc_state); 1718 if (!bret) { 1719 drm_dbg_kms(&i915->drm, 1720 "Could not set DP dpll HW state.\n"); 1721 return false; 1722 } 1723 } else { 1724 return false; 1725 } 1726 1727 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_EDP)) 1728 pll = intel_find_shared_dpll(state, crtc, 1729 &crtc_state->dpll_hw_state, 1730 BIT(DPLL_ID_SKL_DPLL0)); 1731 else 1732 pll = intel_find_shared_dpll(state, crtc, 1733 &crtc_state->dpll_hw_state, 1734 BIT(DPLL_ID_SKL_DPLL3) | 1735 BIT(DPLL_ID_SKL_DPLL2) | 1736 BIT(DPLL_ID_SKL_DPLL1)); 1737 if (!pll) 1738 return false; 1739 1740 intel_reference_shared_dpll(state, crtc, 1741 pll, &crtc_state->dpll_hw_state); 1742 1743 crtc_state->shared_dpll = pll; 1744 1745 return true; 1746 } 1747 1748 static int skl_ddi_pll_get_freq(struct drm_i915_private *i915, 1749 const struct intel_shared_dpll *pll) 1750 { 1751 /* 1752 * ctrl1 register is already shifted for each pll, just use 0 to get 1753 * the internal shift for each field 1754 */ 1755 if (pll->state.hw_state.ctrl1 & DPLL_CTRL1_HDMI_MODE(0)) 1756 return skl_ddi_wrpll_get_freq(i915, pll); 1757 else 1758 return skl_ddi_lcpll_get_freq(i915, pll); 1759 } 1760 1761 static void skl_update_dpll_ref_clks(struct drm_i915_private *i915) 1762 { 1763 /* No SSC ref */ 1764 i915->dpll.ref_clks.nssc = i915->cdclk.hw.ref; 1765 } 1766 1767 static void skl_dump_hw_state(struct drm_i915_private *dev_priv, 1768 const struct intel_dpll_hw_state *hw_state) 1769 { 1770 drm_dbg_kms(&dev_priv->drm, "dpll_hw_state: " 1771 "ctrl1: 0x%x, cfgcr1: 0x%x, cfgcr2: 0x%x\n", 1772 hw_state->ctrl1, 1773 hw_state->cfgcr1, 1774 hw_state->cfgcr2); 1775 } 1776 1777 static const struct intel_shared_dpll_funcs skl_ddi_pll_funcs = { 1778 .enable = skl_ddi_pll_enable, 1779 .disable = skl_ddi_pll_disable, 1780 .get_hw_state = skl_ddi_pll_get_hw_state, 1781 .get_freq = skl_ddi_pll_get_freq, 1782 }; 1783 1784 static const struct intel_shared_dpll_funcs skl_ddi_dpll0_funcs = { 1785 .enable = skl_ddi_dpll0_enable, 1786 .disable = skl_ddi_dpll0_disable, 1787 .get_hw_state = skl_ddi_dpll0_get_hw_state, 1788 .get_freq = skl_ddi_pll_get_freq, 1789 }; 1790 1791 static const struct dpll_info skl_plls[] = { 1792 { "DPLL 0", &skl_ddi_dpll0_funcs, DPLL_ID_SKL_DPLL0, INTEL_DPLL_ALWAYS_ON }, 1793 { "DPLL 1", &skl_ddi_pll_funcs, DPLL_ID_SKL_DPLL1, 0 }, 1794 { "DPLL 2", &skl_ddi_pll_funcs, DPLL_ID_SKL_DPLL2, 0 }, 1795 { "DPLL 3", &skl_ddi_pll_funcs, DPLL_ID_SKL_DPLL3, 0 }, 1796 { }, 1797 }; 1798 1799 static const struct intel_dpll_mgr skl_pll_mgr = { 1800 .dpll_info = skl_plls, 1801 .get_dplls = skl_get_dpll, 1802 .put_dplls = intel_put_dpll, 1803 .update_ref_clks = skl_update_dpll_ref_clks, 1804 .dump_hw_state = skl_dump_hw_state, 1805 }; 1806 1807 static void bxt_ddi_pll_enable(struct drm_i915_private *dev_priv, 1808 struct intel_shared_dpll *pll) 1809 { 1810 u32 temp; 1811 enum port port = (enum port)pll->info->id; /* 1:1 port->PLL mapping */ 1812 enum dpio_phy phy; 1813 enum dpio_channel ch; 1814 1815 bxt_port_to_phy_channel(dev_priv, port, &phy, &ch); 1816 1817 /* Non-SSC reference */ 1818 temp = intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1819 temp |= PORT_PLL_REF_SEL; 1820 intel_de_write(dev_priv, BXT_PORT_PLL_ENABLE(port), temp); 1821 1822 if (IS_GEMINILAKE(dev_priv)) { 1823 temp = intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1824 temp |= PORT_PLL_POWER_ENABLE; 1825 intel_de_write(dev_priv, BXT_PORT_PLL_ENABLE(port), temp); 1826 1827 if (wait_for_us((intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)) & 1828 PORT_PLL_POWER_STATE), 200)) 1829 drm_err(&dev_priv->drm, 1830 "Power state not set for PLL:%d\n", port); 1831 } 1832 1833 /* Disable 10 bit clock */ 1834 temp = intel_de_read(dev_priv, BXT_PORT_PLL_EBB_4(phy, ch)); 1835 temp &= ~PORT_PLL_10BIT_CLK_ENABLE; 1836 intel_de_write(dev_priv, BXT_PORT_PLL_EBB_4(phy, ch), temp); 1837 1838 /* Write P1 & P2 */ 1839 temp = intel_de_read(dev_priv, BXT_PORT_PLL_EBB_0(phy, ch)); 1840 temp &= ~(PORT_PLL_P1_MASK | PORT_PLL_P2_MASK); 1841 temp |= pll->state.hw_state.ebb0; 1842 intel_de_write(dev_priv, BXT_PORT_PLL_EBB_0(phy, ch), temp); 1843 1844 /* Write M2 integer */ 1845 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 0)); 1846 temp &= ~PORT_PLL_M2_MASK; 1847 temp |= pll->state.hw_state.pll0; 1848 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 0), temp); 1849 1850 /* Write N */ 1851 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 1)); 1852 temp &= ~PORT_PLL_N_MASK; 1853 temp |= pll->state.hw_state.pll1; 1854 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 1), temp); 1855 1856 /* Write M2 fraction */ 1857 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 2)); 1858 temp &= ~PORT_PLL_M2_FRAC_MASK; 1859 temp |= pll->state.hw_state.pll2; 1860 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 2), temp); 1861 1862 /* Write M2 fraction enable */ 1863 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 3)); 1864 temp &= ~PORT_PLL_M2_FRAC_ENABLE; 1865 temp |= pll->state.hw_state.pll3; 1866 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 3), temp); 1867 1868 /* Write coeff */ 1869 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 6)); 1870 temp &= ~PORT_PLL_PROP_COEFF_MASK; 1871 temp &= ~PORT_PLL_INT_COEFF_MASK; 1872 temp &= ~PORT_PLL_GAIN_CTL_MASK; 1873 temp |= pll->state.hw_state.pll6; 1874 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 6), temp); 1875 1876 /* Write calibration val */ 1877 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 8)); 1878 temp &= ~PORT_PLL_TARGET_CNT_MASK; 1879 temp |= pll->state.hw_state.pll8; 1880 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 8), temp); 1881 1882 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 9)); 1883 temp &= ~PORT_PLL_LOCK_THRESHOLD_MASK; 1884 temp |= pll->state.hw_state.pll9; 1885 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 9), temp); 1886 1887 temp = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 10)); 1888 temp &= ~PORT_PLL_DCO_AMP_OVR_EN_H; 1889 temp &= ~PORT_PLL_DCO_AMP_MASK; 1890 temp |= pll->state.hw_state.pll10; 1891 intel_de_write(dev_priv, BXT_PORT_PLL(phy, ch, 10), temp); 1892 1893 /* Recalibrate with new settings */ 1894 temp = intel_de_read(dev_priv, BXT_PORT_PLL_EBB_4(phy, ch)); 1895 temp |= PORT_PLL_RECALIBRATE; 1896 intel_de_write(dev_priv, BXT_PORT_PLL_EBB_4(phy, ch), temp); 1897 temp &= ~PORT_PLL_10BIT_CLK_ENABLE; 1898 temp |= pll->state.hw_state.ebb4; 1899 intel_de_write(dev_priv, BXT_PORT_PLL_EBB_4(phy, ch), temp); 1900 1901 /* Enable PLL */ 1902 temp = intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1903 temp |= PORT_PLL_ENABLE; 1904 intel_de_write(dev_priv, BXT_PORT_PLL_ENABLE(port), temp); 1905 intel_de_posting_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1906 1907 if (wait_for_us((intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)) & PORT_PLL_LOCK), 1908 200)) 1909 drm_err(&dev_priv->drm, "PLL %d not locked\n", port); 1910 1911 if (IS_GEMINILAKE(dev_priv)) { 1912 temp = intel_de_read(dev_priv, BXT_PORT_TX_DW5_LN0(phy, ch)); 1913 temp |= DCC_DELAY_RANGE_2; 1914 intel_de_write(dev_priv, BXT_PORT_TX_DW5_GRP(phy, ch), temp); 1915 } 1916 1917 /* 1918 * While we write to the group register to program all lanes at once we 1919 * can read only lane registers and we pick lanes 0/1 for that. 1920 */ 1921 temp = intel_de_read(dev_priv, BXT_PORT_PCS_DW12_LN01(phy, ch)); 1922 temp &= ~LANE_STAGGER_MASK; 1923 temp &= ~LANESTAGGER_STRAP_OVRD; 1924 temp |= pll->state.hw_state.pcsdw12; 1925 intel_de_write(dev_priv, BXT_PORT_PCS_DW12_GRP(phy, ch), temp); 1926 } 1927 1928 static void bxt_ddi_pll_disable(struct drm_i915_private *dev_priv, 1929 struct intel_shared_dpll *pll) 1930 { 1931 enum port port = (enum port)pll->info->id; /* 1:1 port->PLL mapping */ 1932 u32 temp; 1933 1934 temp = intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1935 temp &= ~PORT_PLL_ENABLE; 1936 intel_de_write(dev_priv, BXT_PORT_PLL_ENABLE(port), temp); 1937 intel_de_posting_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1938 1939 if (IS_GEMINILAKE(dev_priv)) { 1940 temp = intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1941 temp &= ~PORT_PLL_POWER_ENABLE; 1942 intel_de_write(dev_priv, BXT_PORT_PLL_ENABLE(port), temp); 1943 1944 if (wait_for_us(!(intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)) & 1945 PORT_PLL_POWER_STATE), 200)) 1946 drm_err(&dev_priv->drm, 1947 "Power state not reset for PLL:%d\n", port); 1948 } 1949 } 1950 1951 static bool bxt_ddi_pll_get_hw_state(struct drm_i915_private *dev_priv, 1952 struct intel_shared_dpll *pll, 1953 struct intel_dpll_hw_state *hw_state) 1954 { 1955 enum port port = (enum port)pll->info->id; /* 1:1 port->PLL mapping */ 1956 intel_wakeref_t wakeref; 1957 enum dpio_phy phy; 1958 enum dpio_channel ch; 1959 u32 val; 1960 bool ret; 1961 1962 bxt_port_to_phy_channel(dev_priv, port, &phy, &ch); 1963 1964 wakeref = intel_display_power_get_if_enabled(dev_priv, 1965 POWER_DOMAIN_DISPLAY_CORE); 1966 if (!wakeref) 1967 return false; 1968 1969 ret = false; 1970 1971 val = intel_de_read(dev_priv, BXT_PORT_PLL_ENABLE(port)); 1972 if (!(val & PORT_PLL_ENABLE)) 1973 goto out; 1974 1975 hw_state->ebb0 = intel_de_read(dev_priv, BXT_PORT_PLL_EBB_0(phy, ch)); 1976 hw_state->ebb0 &= PORT_PLL_P1_MASK | PORT_PLL_P2_MASK; 1977 1978 hw_state->ebb4 = intel_de_read(dev_priv, BXT_PORT_PLL_EBB_4(phy, ch)); 1979 hw_state->ebb4 &= PORT_PLL_10BIT_CLK_ENABLE; 1980 1981 hw_state->pll0 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 0)); 1982 hw_state->pll0 &= PORT_PLL_M2_MASK; 1983 1984 hw_state->pll1 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 1)); 1985 hw_state->pll1 &= PORT_PLL_N_MASK; 1986 1987 hw_state->pll2 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 2)); 1988 hw_state->pll2 &= PORT_PLL_M2_FRAC_MASK; 1989 1990 hw_state->pll3 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 3)); 1991 hw_state->pll3 &= PORT_PLL_M2_FRAC_ENABLE; 1992 1993 hw_state->pll6 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 6)); 1994 hw_state->pll6 &= PORT_PLL_PROP_COEFF_MASK | 1995 PORT_PLL_INT_COEFF_MASK | 1996 PORT_PLL_GAIN_CTL_MASK; 1997 1998 hw_state->pll8 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 8)); 1999 hw_state->pll8 &= PORT_PLL_TARGET_CNT_MASK; 2000 2001 hw_state->pll9 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 9)); 2002 hw_state->pll9 &= PORT_PLL_LOCK_THRESHOLD_MASK; 2003 2004 hw_state->pll10 = intel_de_read(dev_priv, BXT_PORT_PLL(phy, ch, 10)); 2005 hw_state->pll10 &= PORT_PLL_DCO_AMP_OVR_EN_H | 2006 PORT_PLL_DCO_AMP_MASK; 2007 2008 /* 2009 * While we write to the group register to program all lanes at once we 2010 * can read only lane registers. We configure all lanes the same way, so 2011 * here just read out lanes 0/1 and output a note if lanes 2/3 differ. 2012 */ 2013 hw_state->pcsdw12 = intel_de_read(dev_priv, 2014 BXT_PORT_PCS_DW12_LN01(phy, ch)); 2015 if (intel_de_read(dev_priv, BXT_PORT_PCS_DW12_LN23(phy, ch)) != hw_state->pcsdw12) 2016 drm_dbg(&dev_priv->drm, 2017 "lane stagger config different for lane 01 (%08x) and 23 (%08x)\n", 2018 hw_state->pcsdw12, 2019 intel_de_read(dev_priv, 2020 BXT_PORT_PCS_DW12_LN23(phy, ch))); 2021 hw_state->pcsdw12 &= LANE_STAGGER_MASK | LANESTAGGER_STRAP_OVRD; 2022 2023 ret = true; 2024 2025 out: 2026 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 2027 2028 return ret; 2029 } 2030 2031 /* bxt clock parameters */ 2032 struct bxt_clk_div { 2033 int clock; 2034 u32 p1; 2035 u32 p2; 2036 u32 m2_int; 2037 u32 m2_frac; 2038 bool m2_frac_en; 2039 u32 n; 2040 2041 int vco; 2042 }; 2043 2044 /* pre-calculated values for DP linkrates */ 2045 static const struct bxt_clk_div bxt_dp_clk_val[] = { 2046 {162000, 4, 2, 32, 1677722, 1, 1}, 2047 {270000, 4, 1, 27, 0, 0, 1}, 2048 {540000, 2, 1, 27, 0, 0, 1}, 2049 {216000, 3, 2, 32, 1677722, 1, 1}, 2050 {243000, 4, 1, 24, 1258291, 1, 1}, 2051 {324000, 4, 1, 32, 1677722, 1, 1}, 2052 {432000, 3, 1, 32, 1677722, 1, 1} 2053 }; 2054 2055 static bool 2056 bxt_ddi_hdmi_pll_dividers(struct intel_crtc_state *crtc_state, 2057 struct bxt_clk_div *clk_div) 2058 { 2059 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev); 2060 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 2061 struct dpll best_clock; 2062 2063 /* Calculate HDMI div */ 2064 /* 2065 * FIXME: tie the following calculation into 2066 * i9xx_crtc_compute_clock 2067 */ 2068 if (!bxt_find_best_dpll(crtc_state, &best_clock)) { 2069 drm_dbg(&i915->drm, "no PLL dividers found for clock %d pipe %c\n", 2070 crtc_state->port_clock, 2071 pipe_name(crtc->pipe)); 2072 return false; 2073 } 2074 2075 clk_div->p1 = best_clock.p1; 2076 clk_div->p2 = best_clock.p2; 2077 drm_WARN_ON(&i915->drm, best_clock.m1 != 2); 2078 clk_div->n = best_clock.n; 2079 clk_div->m2_int = best_clock.m2 >> 22; 2080 clk_div->m2_frac = best_clock.m2 & ((1 << 22) - 1); 2081 clk_div->m2_frac_en = clk_div->m2_frac != 0; 2082 2083 clk_div->vco = best_clock.vco; 2084 2085 return true; 2086 } 2087 2088 static void bxt_ddi_dp_pll_dividers(struct intel_crtc_state *crtc_state, 2089 struct bxt_clk_div *clk_div) 2090 { 2091 int clock = crtc_state->port_clock; 2092 int i; 2093 2094 *clk_div = bxt_dp_clk_val[0]; 2095 for (i = 0; i < ARRAY_SIZE(bxt_dp_clk_val); ++i) { 2096 if (bxt_dp_clk_val[i].clock == clock) { 2097 *clk_div = bxt_dp_clk_val[i]; 2098 break; 2099 } 2100 } 2101 2102 clk_div->vco = clock * 10 / 2 * clk_div->p1 * clk_div->p2; 2103 } 2104 2105 static bool bxt_ddi_set_dpll_hw_state(struct intel_crtc_state *crtc_state, 2106 const struct bxt_clk_div *clk_div) 2107 { 2108 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev); 2109 struct intel_dpll_hw_state *dpll_hw_state = &crtc_state->dpll_hw_state; 2110 int clock = crtc_state->port_clock; 2111 int vco = clk_div->vco; 2112 u32 prop_coef, int_coef, gain_ctl, targ_cnt; 2113 u32 lanestagger; 2114 2115 memset(dpll_hw_state, 0, sizeof(*dpll_hw_state)); 2116 2117 if (vco >= 6200000 && vco <= 6700000) { 2118 prop_coef = 4; 2119 int_coef = 9; 2120 gain_ctl = 3; 2121 targ_cnt = 8; 2122 } else if ((vco > 5400000 && vco < 6200000) || 2123 (vco >= 4800000 && vco < 5400000)) { 2124 prop_coef = 5; 2125 int_coef = 11; 2126 gain_ctl = 3; 2127 targ_cnt = 9; 2128 } else if (vco == 5400000) { 2129 prop_coef = 3; 2130 int_coef = 8; 2131 gain_ctl = 1; 2132 targ_cnt = 9; 2133 } else { 2134 drm_err(&i915->drm, "Invalid VCO\n"); 2135 return false; 2136 } 2137 2138 if (clock > 270000) 2139 lanestagger = 0x18; 2140 else if (clock > 135000) 2141 lanestagger = 0x0d; 2142 else if (clock > 67000) 2143 lanestagger = 0x07; 2144 else if (clock > 33000) 2145 lanestagger = 0x04; 2146 else 2147 lanestagger = 0x02; 2148 2149 dpll_hw_state->ebb0 = PORT_PLL_P1(clk_div->p1) | PORT_PLL_P2(clk_div->p2); 2150 dpll_hw_state->pll0 = clk_div->m2_int; 2151 dpll_hw_state->pll1 = PORT_PLL_N(clk_div->n); 2152 dpll_hw_state->pll2 = clk_div->m2_frac; 2153 2154 if (clk_div->m2_frac_en) 2155 dpll_hw_state->pll3 = PORT_PLL_M2_FRAC_ENABLE; 2156 2157 dpll_hw_state->pll6 = prop_coef | PORT_PLL_INT_COEFF(int_coef); 2158 dpll_hw_state->pll6 |= PORT_PLL_GAIN_CTL(gain_ctl); 2159 2160 dpll_hw_state->pll8 = targ_cnt; 2161 2162 dpll_hw_state->pll9 = 5 << PORT_PLL_LOCK_THRESHOLD_SHIFT; 2163 2164 dpll_hw_state->pll10 = 2165 PORT_PLL_DCO_AMP(PORT_PLL_DCO_AMP_DEFAULT) 2166 | PORT_PLL_DCO_AMP_OVR_EN_H; 2167 2168 dpll_hw_state->ebb4 = PORT_PLL_10BIT_CLK_ENABLE; 2169 2170 dpll_hw_state->pcsdw12 = LANESTAGGER_STRAP_OVRD | lanestagger; 2171 2172 return true; 2173 } 2174 2175 static bool 2176 bxt_ddi_dp_set_dpll_hw_state(struct intel_crtc_state *crtc_state) 2177 { 2178 struct bxt_clk_div clk_div = {}; 2179 2180 bxt_ddi_dp_pll_dividers(crtc_state, &clk_div); 2181 2182 return bxt_ddi_set_dpll_hw_state(crtc_state, &clk_div); 2183 } 2184 2185 static bool 2186 bxt_ddi_hdmi_set_dpll_hw_state(struct intel_crtc_state *crtc_state) 2187 { 2188 struct bxt_clk_div clk_div = {}; 2189 2190 bxt_ddi_hdmi_pll_dividers(crtc_state, &clk_div); 2191 2192 return bxt_ddi_set_dpll_hw_state(crtc_state, &clk_div); 2193 } 2194 2195 static int bxt_ddi_pll_get_freq(struct drm_i915_private *i915, 2196 const struct intel_shared_dpll *pll) 2197 { 2198 const struct intel_dpll_hw_state *pll_state = &pll->state.hw_state; 2199 struct dpll clock; 2200 2201 clock.m1 = 2; 2202 clock.m2 = (pll_state->pll0 & PORT_PLL_M2_MASK) << 22; 2203 if (pll_state->pll3 & PORT_PLL_M2_FRAC_ENABLE) 2204 clock.m2 |= pll_state->pll2 & PORT_PLL_M2_FRAC_MASK; 2205 clock.n = (pll_state->pll1 & PORT_PLL_N_MASK) >> PORT_PLL_N_SHIFT; 2206 clock.p1 = (pll_state->ebb0 & PORT_PLL_P1_MASK) >> PORT_PLL_P1_SHIFT; 2207 clock.p2 = (pll_state->ebb0 & PORT_PLL_P2_MASK) >> PORT_PLL_P2_SHIFT; 2208 2209 return chv_calc_dpll_params(i915->dpll.ref_clks.nssc, &clock); 2210 } 2211 2212 static bool bxt_get_dpll(struct intel_atomic_state *state, 2213 struct intel_crtc *crtc, 2214 struct intel_encoder *encoder) 2215 { 2216 struct intel_crtc_state *crtc_state = 2217 intel_atomic_get_new_crtc_state(state, crtc); 2218 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 2219 struct intel_shared_dpll *pll; 2220 enum intel_dpll_id id; 2221 2222 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI) && 2223 !bxt_ddi_hdmi_set_dpll_hw_state(crtc_state)) 2224 return false; 2225 2226 if (intel_crtc_has_dp_encoder(crtc_state) && 2227 !bxt_ddi_dp_set_dpll_hw_state(crtc_state)) 2228 return false; 2229 2230 /* 1:1 mapping between ports and PLLs */ 2231 id = (enum intel_dpll_id) encoder->port; 2232 pll = intel_get_shared_dpll_by_id(dev_priv, id); 2233 2234 drm_dbg_kms(&dev_priv->drm, "[CRTC:%d:%s] using pre-allocated %s\n", 2235 crtc->base.base.id, crtc->base.name, pll->info->name); 2236 2237 intel_reference_shared_dpll(state, crtc, 2238 pll, &crtc_state->dpll_hw_state); 2239 2240 crtc_state->shared_dpll = pll; 2241 2242 return true; 2243 } 2244 2245 static void bxt_update_dpll_ref_clks(struct drm_i915_private *i915) 2246 { 2247 i915->dpll.ref_clks.ssc = 100000; 2248 i915->dpll.ref_clks.nssc = 100000; 2249 /* DSI non-SSC ref 19.2MHz */ 2250 } 2251 2252 static void bxt_dump_hw_state(struct drm_i915_private *dev_priv, 2253 const struct intel_dpll_hw_state *hw_state) 2254 { 2255 drm_dbg_kms(&dev_priv->drm, "dpll_hw_state: ebb0: 0x%x, ebb4: 0x%x," 2256 "pll0: 0x%x, pll1: 0x%x, pll2: 0x%x, pll3: 0x%x, " 2257 "pll6: 0x%x, pll8: 0x%x, pll9: 0x%x, pll10: 0x%x, pcsdw12: 0x%x\n", 2258 hw_state->ebb0, 2259 hw_state->ebb4, 2260 hw_state->pll0, 2261 hw_state->pll1, 2262 hw_state->pll2, 2263 hw_state->pll3, 2264 hw_state->pll6, 2265 hw_state->pll8, 2266 hw_state->pll9, 2267 hw_state->pll10, 2268 hw_state->pcsdw12); 2269 } 2270 2271 static const struct intel_shared_dpll_funcs bxt_ddi_pll_funcs = { 2272 .enable = bxt_ddi_pll_enable, 2273 .disable = bxt_ddi_pll_disable, 2274 .get_hw_state = bxt_ddi_pll_get_hw_state, 2275 .get_freq = bxt_ddi_pll_get_freq, 2276 }; 2277 2278 static const struct dpll_info bxt_plls[] = { 2279 { "PORT PLL A", &bxt_ddi_pll_funcs, DPLL_ID_SKL_DPLL0, 0 }, 2280 { "PORT PLL B", &bxt_ddi_pll_funcs, DPLL_ID_SKL_DPLL1, 0 }, 2281 { "PORT PLL C", &bxt_ddi_pll_funcs, DPLL_ID_SKL_DPLL2, 0 }, 2282 { }, 2283 }; 2284 2285 static const struct intel_dpll_mgr bxt_pll_mgr = { 2286 .dpll_info = bxt_plls, 2287 .get_dplls = bxt_get_dpll, 2288 .put_dplls = intel_put_dpll, 2289 .update_ref_clks = bxt_update_dpll_ref_clks, 2290 .dump_hw_state = bxt_dump_hw_state, 2291 }; 2292 2293 static void cnl_ddi_pll_enable(struct drm_i915_private *dev_priv, 2294 struct intel_shared_dpll *pll) 2295 { 2296 const enum intel_dpll_id id = pll->info->id; 2297 u32 val; 2298 2299 /* 1. Enable DPLL power in DPLL_ENABLE. */ 2300 val = intel_de_read(dev_priv, CNL_DPLL_ENABLE(id)); 2301 val |= PLL_POWER_ENABLE; 2302 intel_de_write(dev_priv, CNL_DPLL_ENABLE(id), val); 2303 2304 /* 2. Wait for DPLL power state enabled in DPLL_ENABLE. */ 2305 if (intel_de_wait_for_set(dev_priv, CNL_DPLL_ENABLE(id), 2306 PLL_POWER_STATE, 5)) 2307 drm_err(&dev_priv->drm, "PLL %d Power not enabled\n", id); 2308 2309 /* 2310 * 3. Configure DPLL_CFGCR0 to set SSC enable/disable, 2311 * select DP mode, and set DP link rate. 2312 */ 2313 val = pll->state.hw_state.cfgcr0; 2314 intel_de_write(dev_priv, CNL_DPLL_CFGCR0(id), val); 2315 2316 /* 4. Reab back to ensure writes completed */ 2317 intel_de_posting_read(dev_priv, CNL_DPLL_CFGCR0(id)); 2318 2319 /* 3. Configure DPLL_CFGCR0 */ 2320 /* Avoid touch CFGCR1 if HDMI mode is not enabled */ 2321 if (pll->state.hw_state.cfgcr0 & DPLL_CFGCR0_HDMI_MODE) { 2322 val = pll->state.hw_state.cfgcr1; 2323 intel_de_write(dev_priv, CNL_DPLL_CFGCR1(id), val); 2324 /* 4. Reab back to ensure writes completed */ 2325 intel_de_posting_read(dev_priv, CNL_DPLL_CFGCR1(id)); 2326 } 2327 2328 /* 2329 * 5. If the frequency will result in a change to the voltage 2330 * requirement, follow the Display Voltage Frequency Switching 2331 * Sequence Before Frequency Change 2332 * 2333 * Note: DVFS is actually handled via the cdclk code paths, 2334 * hence we do nothing here. 2335 */ 2336 2337 /* 6. Enable DPLL in DPLL_ENABLE. */ 2338 val = intel_de_read(dev_priv, CNL_DPLL_ENABLE(id)); 2339 val |= PLL_ENABLE; 2340 intel_de_write(dev_priv, CNL_DPLL_ENABLE(id), val); 2341 2342 /* 7. Wait for PLL lock status in DPLL_ENABLE. */ 2343 if (intel_de_wait_for_set(dev_priv, CNL_DPLL_ENABLE(id), PLL_LOCK, 5)) 2344 drm_err(&dev_priv->drm, "PLL %d not locked\n", id); 2345 2346 /* 2347 * 8. If the frequency will result in a change to the voltage 2348 * requirement, follow the Display Voltage Frequency Switching 2349 * Sequence After Frequency Change 2350 * 2351 * Note: DVFS is actually handled via the cdclk code paths, 2352 * hence we do nothing here. 2353 */ 2354 2355 /* 2356 * 9. turn on the clock for the DDI and map the DPLL to the DDI 2357 * Done at intel_ddi_clk_select 2358 */ 2359 } 2360 2361 static void cnl_ddi_pll_disable(struct drm_i915_private *dev_priv, 2362 struct intel_shared_dpll *pll) 2363 { 2364 const enum intel_dpll_id id = pll->info->id; 2365 u32 val; 2366 2367 /* 2368 * 1. Configure DPCLKA_CFGCR0 to turn off the clock for the DDI. 2369 * Done at intel_ddi_post_disable 2370 */ 2371 2372 /* 2373 * 2. If the frequency will result in a change to the voltage 2374 * requirement, follow the Display Voltage Frequency Switching 2375 * Sequence Before Frequency Change 2376 * 2377 * Note: DVFS is actually handled via the cdclk code paths, 2378 * hence we do nothing here. 2379 */ 2380 2381 /* 3. Disable DPLL through DPLL_ENABLE. */ 2382 val = intel_de_read(dev_priv, CNL_DPLL_ENABLE(id)); 2383 val &= ~PLL_ENABLE; 2384 intel_de_write(dev_priv, CNL_DPLL_ENABLE(id), val); 2385 2386 /* 4. Wait for PLL not locked status in DPLL_ENABLE. */ 2387 if (intel_de_wait_for_clear(dev_priv, CNL_DPLL_ENABLE(id), PLL_LOCK, 5)) 2388 drm_err(&dev_priv->drm, "PLL %d locked\n", id); 2389 2390 /* 2391 * 5. If the frequency will result in a change to the voltage 2392 * requirement, follow the Display Voltage Frequency Switching 2393 * Sequence After Frequency Change 2394 * 2395 * Note: DVFS is actually handled via the cdclk code paths, 2396 * hence we do nothing here. 2397 */ 2398 2399 /* 6. Disable DPLL power in DPLL_ENABLE. */ 2400 val = intel_de_read(dev_priv, CNL_DPLL_ENABLE(id)); 2401 val &= ~PLL_POWER_ENABLE; 2402 intel_de_write(dev_priv, CNL_DPLL_ENABLE(id), val); 2403 2404 /* 7. Wait for DPLL power state disabled in DPLL_ENABLE. */ 2405 if (intel_de_wait_for_clear(dev_priv, CNL_DPLL_ENABLE(id), 2406 PLL_POWER_STATE, 5)) 2407 drm_err(&dev_priv->drm, "PLL %d Power not disabled\n", id); 2408 } 2409 2410 static bool cnl_ddi_pll_get_hw_state(struct drm_i915_private *dev_priv, 2411 struct intel_shared_dpll *pll, 2412 struct intel_dpll_hw_state *hw_state) 2413 { 2414 const enum intel_dpll_id id = pll->info->id; 2415 intel_wakeref_t wakeref; 2416 u32 val; 2417 bool ret; 2418 2419 wakeref = intel_display_power_get_if_enabled(dev_priv, 2420 POWER_DOMAIN_DISPLAY_CORE); 2421 if (!wakeref) 2422 return false; 2423 2424 ret = false; 2425 2426 val = intel_de_read(dev_priv, CNL_DPLL_ENABLE(id)); 2427 if (!(val & PLL_ENABLE)) 2428 goto out; 2429 2430 val = intel_de_read(dev_priv, CNL_DPLL_CFGCR0(id)); 2431 hw_state->cfgcr0 = val; 2432 2433 /* avoid reading back stale values if HDMI mode is not enabled */ 2434 if (val & DPLL_CFGCR0_HDMI_MODE) { 2435 hw_state->cfgcr1 = intel_de_read(dev_priv, 2436 CNL_DPLL_CFGCR1(id)); 2437 } 2438 ret = true; 2439 2440 out: 2441 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 2442 2443 return ret; 2444 } 2445 2446 static void cnl_wrpll_get_multipliers(int bestdiv, int *pdiv, 2447 int *qdiv, int *kdiv) 2448 { 2449 /* even dividers */ 2450 if (bestdiv % 2 == 0) { 2451 if (bestdiv == 2) { 2452 *pdiv = 2; 2453 *qdiv = 1; 2454 *kdiv = 1; 2455 } else if (bestdiv % 4 == 0) { 2456 *pdiv = 2; 2457 *qdiv = bestdiv / 4; 2458 *kdiv = 2; 2459 } else if (bestdiv % 6 == 0) { 2460 *pdiv = 3; 2461 *qdiv = bestdiv / 6; 2462 *kdiv = 2; 2463 } else if (bestdiv % 5 == 0) { 2464 *pdiv = 5; 2465 *qdiv = bestdiv / 10; 2466 *kdiv = 2; 2467 } else if (bestdiv % 14 == 0) { 2468 *pdiv = 7; 2469 *qdiv = bestdiv / 14; 2470 *kdiv = 2; 2471 } 2472 } else { 2473 if (bestdiv == 3 || bestdiv == 5 || bestdiv == 7) { 2474 *pdiv = bestdiv; 2475 *qdiv = 1; 2476 *kdiv = 1; 2477 } else { /* 9, 15, 21 */ 2478 *pdiv = bestdiv / 3; 2479 *qdiv = 1; 2480 *kdiv = 3; 2481 } 2482 } 2483 } 2484 2485 static void cnl_wrpll_params_populate(struct skl_wrpll_params *params, 2486 u32 dco_freq, u32 ref_freq, 2487 int pdiv, int qdiv, int kdiv) 2488 { 2489 u32 dco; 2490 2491 switch (kdiv) { 2492 case 1: 2493 params->kdiv = 1; 2494 break; 2495 case 2: 2496 params->kdiv = 2; 2497 break; 2498 case 3: 2499 params->kdiv = 4; 2500 break; 2501 default: 2502 WARN(1, "Incorrect KDiv\n"); 2503 } 2504 2505 switch (pdiv) { 2506 case 2: 2507 params->pdiv = 1; 2508 break; 2509 case 3: 2510 params->pdiv = 2; 2511 break; 2512 case 5: 2513 params->pdiv = 4; 2514 break; 2515 case 7: 2516 params->pdiv = 8; 2517 break; 2518 default: 2519 WARN(1, "Incorrect PDiv\n"); 2520 } 2521 2522 WARN_ON(kdiv != 2 && qdiv != 1); 2523 2524 params->qdiv_ratio = qdiv; 2525 params->qdiv_mode = (qdiv == 1) ? 0 : 1; 2526 2527 dco = div_u64((u64)dco_freq << 15, ref_freq); 2528 2529 params->dco_integer = dco >> 15; 2530 params->dco_fraction = dco & 0x7fff; 2531 } 2532 2533 static bool 2534 __cnl_ddi_calculate_wrpll(struct intel_crtc_state *crtc_state, 2535 struct skl_wrpll_params *wrpll_params, 2536 int ref_clock) 2537 { 2538 u32 afe_clock = crtc_state->port_clock * 5; 2539 u32 dco_min = 7998000; 2540 u32 dco_max = 10000000; 2541 u32 dco_mid = (dco_min + dco_max) / 2; 2542 static const int dividers[] = { 2, 4, 6, 8, 10, 12, 14, 16, 2543 18, 20, 24, 28, 30, 32, 36, 40, 2544 42, 44, 48, 50, 52, 54, 56, 60, 2545 64, 66, 68, 70, 72, 76, 78, 80, 2546 84, 88, 90, 92, 96, 98, 100, 102, 2547 3, 5, 7, 9, 15, 21 }; 2548 u32 dco, best_dco = 0, dco_centrality = 0; 2549 u32 best_dco_centrality = U32_MAX; /* Spec meaning of 999999 MHz */ 2550 int d, best_div = 0, pdiv = 0, qdiv = 0, kdiv = 0; 2551 2552 for (d = 0; d < ARRAY_SIZE(dividers); d++) { 2553 dco = afe_clock * dividers[d]; 2554 2555 if ((dco <= dco_max) && (dco >= dco_min)) { 2556 dco_centrality = abs(dco - dco_mid); 2557 2558 if (dco_centrality < best_dco_centrality) { 2559 best_dco_centrality = dco_centrality; 2560 best_div = dividers[d]; 2561 best_dco = dco; 2562 } 2563 } 2564 } 2565 2566 if (best_div == 0) 2567 return false; 2568 2569 cnl_wrpll_get_multipliers(best_div, &pdiv, &qdiv, &kdiv); 2570 cnl_wrpll_params_populate(wrpll_params, best_dco, ref_clock, 2571 pdiv, qdiv, kdiv); 2572 2573 return true; 2574 } 2575 2576 static bool 2577 cnl_ddi_calculate_wrpll(struct intel_crtc_state *crtc_state, 2578 struct skl_wrpll_params *wrpll_params) 2579 { 2580 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev); 2581 2582 return __cnl_ddi_calculate_wrpll(crtc_state, wrpll_params, 2583 i915->dpll.ref_clks.nssc); 2584 } 2585 2586 static bool cnl_ddi_hdmi_pll_dividers(struct intel_crtc_state *crtc_state) 2587 { 2588 u32 cfgcr0, cfgcr1; 2589 struct skl_wrpll_params wrpll_params = { 0, }; 2590 2591 cfgcr0 = DPLL_CFGCR0_HDMI_MODE; 2592 2593 if (!cnl_ddi_calculate_wrpll(crtc_state, &wrpll_params)) 2594 return false; 2595 2596 cfgcr0 |= DPLL_CFGCR0_DCO_FRACTION(wrpll_params.dco_fraction) | 2597 wrpll_params.dco_integer; 2598 2599 cfgcr1 = DPLL_CFGCR1_QDIV_RATIO(wrpll_params.qdiv_ratio) | 2600 DPLL_CFGCR1_QDIV_MODE(wrpll_params.qdiv_mode) | 2601 DPLL_CFGCR1_KDIV(wrpll_params.kdiv) | 2602 DPLL_CFGCR1_PDIV(wrpll_params.pdiv) | 2603 DPLL_CFGCR1_CENTRAL_FREQ; 2604 2605 memset(&crtc_state->dpll_hw_state, 0, 2606 sizeof(crtc_state->dpll_hw_state)); 2607 2608 crtc_state->dpll_hw_state.cfgcr0 = cfgcr0; 2609 crtc_state->dpll_hw_state.cfgcr1 = cfgcr1; 2610 return true; 2611 } 2612 2613 static int __cnl_ddi_wrpll_get_freq(struct drm_i915_private *dev_priv, 2614 const struct intel_shared_dpll *pll, 2615 int ref_clock) 2616 { 2617 const struct intel_dpll_hw_state *pll_state = &pll->state.hw_state; 2618 u32 p0, p1, p2, dco_freq; 2619 2620 p0 = pll_state->cfgcr1 & DPLL_CFGCR1_PDIV_MASK; 2621 p2 = pll_state->cfgcr1 & DPLL_CFGCR1_KDIV_MASK; 2622 2623 if (pll_state->cfgcr1 & DPLL_CFGCR1_QDIV_MODE(1)) 2624 p1 = (pll_state->cfgcr1 & DPLL_CFGCR1_QDIV_RATIO_MASK) >> 2625 DPLL_CFGCR1_QDIV_RATIO_SHIFT; 2626 else 2627 p1 = 1; 2628 2629 2630 switch (p0) { 2631 case DPLL_CFGCR1_PDIV_2: 2632 p0 = 2; 2633 break; 2634 case DPLL_CFGCR1_PDIV_3: 2635 p0 = 3; 2636 break; 2637 case DPLL_CFGCR1_PDIV_5: 2638 p0 = 5; 2639 break; 2640 case DPLL_CFGCR1_PDIV_7: 2641 p0 = 7; 2642 break; 2643 } 2644 2645 switch (p2) { 2646 case DPLL_CFGCR1_KDIV_1: 2647 p2 = 1; 2648 break; 2649 case DPLL_CFGCR1_KDIV_2: 2650 p2 = 2; 2651 break; 2652 case DPLL_CFGCR1_KDIV_3: 2653 p2 = 3; 2654 break; 2655 } 2656 2657 dco_freq = (pll_state->cfgcr0 & DPLL_CFGCR0_DCO_INTEGER_MASK) * 2658 ref_clock; 2659 2660 dco_freq += (((pll_state->cfgcr0 & DPLL_CFGCR0_DCO_FRACTION_MASK) >> 2661 DPLL_CFGCR0_DCO_FRACTION_SHIFT) * ref_clock) / 0x8000; 2662 2663 if (drm_WARN_ON(&dev_priv->drm, p0 == 0 || p1 == 0 || p2 == 0)) 2664 return 0; 2665 2666 return dco_freq / (p0 * p1 * p2 * 5); 2667 } 2668 2669 static int cnl_ddi_wrpll_get_freq(struct drm_i915_private *i915, 2670 const struct intel_shared_dpll *pll) 2671 { 2672 return __cnl_ddi_wrpll_get_freq(i915, pll, i915->dpll.ref_clks.nssc); 2673 } 2674 2675 static bool 2676 cnl_ddi_dp_set_dpll_hw_state(struct intel_crtc_state *crtc_state) 2677 { 2678 u32 cfgcr0; 2679 2680 cfgcr0 = DPLL_CFGCR0_SSC_ENABLE; 2681 2682 switch (crtc_state->port_clock / 2) { 2683 case 81000: 2684 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_810; 2685 break; 2686 case 135000: 2687 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_1350; 2688 break; 2689 case 270000: 2690 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_2700; 2691 break; 2692 /* eDP 1.4 rates */ 2693 case 162000: 2694 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_1620; 2695 break; 2696 case 108000: 2697 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_1080; 2698 break; 2699 case 216000: 2700 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_2160; 2701 break; 2702 case 324000: 2703 /* Some SKUs may require elevated I/O voltage to support this */ 2704 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_3240; 2705 break; 2706 case 405000: 2707 /* Some SKUs may require elevated I/O voltage to support this */ 2708 cfgcr0 |= DPLL_CFGCR0_LINK_RATE_4050; 2709 break; 2710 } 2711 2712 memset(&crtc_state->dpll_hw_state, 0, 2713 sizeof(crtc_state->dpll_hw_state)); 2714 2715 crtc_state->dpll_hw_state.cfgcr0 = cfgcr0; 2716 2717 return true; 2718 } 2719 2720 static int cnl_ddi_lcpll_get_freq(struct drm_i915_private *i915, 2721 const struct intel_shared_dpll *pll) 2722 { 2723 int link_clock = 0; 2724 2725 switch (pll->state.hw_state.cfgcr0 & DPLL_CFGCR0_LINK_RATE_MASK) { 2726 case DPLL_CFGCR0_LINK_RATE_810: 2727 link_clock = 81000; 2728 break; 2729 case DPLL_CFGCR0_LINK_RATE_1080: 2730 link_clock = 108000; 2731 break; 2732 case DPLL_CFGCR0_LINK_RATE_1350: 2733 link_clock = 135000; 2734 break; 2735 case DPLL_CFGCR0_LINK_RATE_1620: 2736 link_clock = 162000; 2737 break; 2738 case DPLL_CFGCR0_LINK_RATE_2160: 2739 link_clock = 216000; 2740 break; 2741 case DPLL_CFGCR0_LINK_RATE_2700: 2742 link_clock = 270000; 2743 break; 2744 case DPLL_CFGCR0_LINK_RATE_3240: 2745 link_clock = 324000; 2746 break; 2747 case DPLL_CFGCR0_LINK_RATE_4050: 2748 link_clock = 405000; 2749 break; 2750 default: 2751 drm_WARN(&i915->drm, 1, "Unsupported link rate\n"); 2752 break; 2753 } 2754 2755 return link_clock * 2; 2756 } 2757 2758 static bool cnl_get_dpll(struct intel_atomic_state *state, 2759 struct intel_crtc *crtc, 2760 struct intel_encoder *encoder) 2761 { 2762 struct intel_crtc_state *crtc_state = 2763 intel_atomic_get_new_crtc_state(state, crtc); 2764 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev); 2765 struct intel_shared_dpll *pll; 2766 bool bret; 2767 2768 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) { 2769 bret = cnl_ddi_hdmi_pll_dividers(crtc_state); 2770 if (!bret) { 2771 drm_dbg_kms(&i915->drm, 2772 "Could not get HDMI pll dividers.\n"); 2773 return false; 2774 } 2775 } else if (intel_crtc_has_dp_encoder(crtc_state)) { 2776 bret = cnl_ddi_dp_set_dpll_hw_state(crtc_state); 2777 if (!bret) { 2778 drm_dbg_kms(&i915->drm, 2779 "Could not set DP dpll HW state.\n"); 2780 return false; 2781 } 2782 } else { 2783 drm_dbg_kms(&i915->drm, 2784 "Skip DPLL setup for output_types 0x%x\n", 2785 crtc_state->output_types); 2786 return false; 2787 } 2788 2789 pll = intel_find_shared_dpll(state, crtc, 2790 &crtc_state->dpll_hw_state, 2791 BIT(DPLL_ID_SKL_DPLL2) | 2792 BIT(DPLL_ID_SKL_DPLL1) | 2793 BIT(DPLL_ID_SKL_DPLL0)); 2794 if (!pll) { 2795 drm_dbg_kms(&i915->drm, "No PLL selected\n"); 2796 return false; 2797 } 2798 2799 intel_reference_shared_dpll(state, crtc, 2800 pll, &crtc_state->dpll_hw_state); 2801 2802 crtc_state->shared_dpll = pll; 2803 2804 return true; 2805 } 2806 2807 static int cnl_ddi_pll_get_freq(struct drm_i915_private *i915, 2808 const struct intel_shared_dpll *pll) 2809 { 2810 if (pll->state.hw_state.cfgcr0 & DPLL_CFGCR0_HDMI_MODE) 2811 return cnl_ddi_wrpll_get_freq(i915, pll); 2812 else 2813 return cnl_ddi_lcpll_get_freq(i915, pll); 2814 } 2815 2816 static void cnl_update_dpll_ref_clks(struct drm_i915_private *i915) 2817 { 2818 /* No SSC reference */ 2819 i915->dpll.ref_clks.nssc = i915->cdclk.hw.ref; 2820 } 2821 2822 static void cnl_dump_hw_state(struct drm_i915_private *dev_priv, 2823 const struct intel_dpll_hw_state *hw_state) 2824 { 2825 drm_dbg_kms(&dev_priv->drm, "dpll_hw_state: " 2826 "cfgcr0: 0x%x, cfgcr1: 0x%x\n", 2827 hw_state->cfgcr0, 2828 hw_state->cfgcr1); 2829 } 2830 2831 static const struct intel_shared_dpll_funcs cnl_ddi_pll_funcs = { 2832 .enable = cnl_ddi_pll_enable, 2833 .disable = cnl_ddi_pll_disable, 2834 .get_hw_state = cnl_ddi_pll_get_hw_state, 2835 .get_freq = cnl_ddi_pll_get_freq, 2836 }; 2837 2838 static const struct dpll_info cnl_plls[] = { 2839 { "DPLL 0", &cnl_ddi_pll_funcs, DPLL_ID_SKL_DPLL0, 0 }, 2840 { "DPLL 1", &cnl_ddi_pll_funcs, DPLL_ID_SKL_DPLL1, 0 }, 2841 { "DPLL 2", &cnl_ddi_pll_funcs, DPLL_ID_SKL_DPLL2, 0 }, 2842 { }, 2843 }; 2844 2845 static const struct intel_dpll_mgr cnl_pll_mgr = { 2846 .dpll_info = cnl_plls, 2847 .get_dplls = cnl_get_dpll, 2848 .put_dplls = intel_put_dpll, 2849 .update_ref_clks = cnl_update_dpll_ref_clks, 2850 .dump_hw_state = cnl_dump_hw_state, 2851 }; 2852 2853 struct icl_combo_pll_params { 2854 int clock; 2855 struct skl_wrpll_params wrpll; 2856 }; 2857 2858 /* 2859 * These values alrea already adjusted: they're the bits we write to the 2860 * registers, not the logical values. 2861 */ 2862 static const struct icl_combo_pll_params icl_dp_combo_pll_24MHz_values[] = { 2863 { 540000, 2864 { .dco_integer = 0x151, .dco_fraction = 0x4000, /* [0]: 5.4 */ 2865 .pdiv = 0x2 /* 3 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2866 { 270000, 2867 { .dco_integer = 0x151, .dco_fraction = 0x4000, /* [1]: 2.7 */ 2868 .pdiv = 0x2 /* 3 */, .kdiv = 2, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2869 { 162000, 2870 { .dco_integer = 0x151, .dco_fraction = 0x4000, /* [2]: 1.62 */ 2871 .pdiv = 0x4 /* 5 */, .kdiv = 2, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2872 { 324000, 2873 { .dco_integer = 0x151, .dco_fraction = 0x4000, /* [3]: 3.24 */ 2874 .pdiv = 0x4 /* 5 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2875 { 216000, 2876 { .dco_integer = 0x168, .dco_fraction = 0x0000, /* [4]: 2.16 */ 2877 .pdiv = 0x1 /* 2 */, .kdiv = 2, .qdiv_mode = 1, .qdiv_ratio = 2, }, }, 2878 { 432000, 2879 { .dco_integer = 0x168, .dco_fraction = 0x0000, /* [5]: 4.32 */ 2880 .pdiv = 0x1 /* 2 */, .kdiv = 2, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2881 { 648000, 2882 { .dco_integer = 0x195, .dco_fraction = 0x0000, /* [6]: 6.48 */ 2883 .pdiv = 0x2 /* 3 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2884 { 810000, 2885 { .dco_integer = 0x151, .dco_fraction = 0x4000, /* [7]: 8.1 */ 2886 .pdiv = 0x1 /* 2 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2887 }; 2888 2889 2890 /* Also used for 38.4 MHz values. */ 2891 static const struct icl_combo_pll_params icl_dp_combo_pll_19_2MHz_values[] = { 2892 { 540000, 2893 { .dco_integer = 0x1A5, .dco_fraction = 0x7000, /* [0]: 5.4 */ 2894 .pdiv = 0x2 /* 3 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2895 { 270000, 2896 { .dco_integer = 0x1A5, .dco_fraction = 0x7000, /* [1]: 2.7 */ 2897 .pdiv = 0x2 /* 3 */, .kdiv = 2, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2898 { 162000, 2899 { .dco_integer = 0x1A5, .dco_fraction = 0x7000, /* [2]: 1.62 */ 2900 .pdiv = 0x4 /* 5 */, .kdiv = 2, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2901 { 324000, 2902 { .dco_integer = 0x1A5, .dco_fraction = 0x7000, /* [3]: 3.24 */ 2903 .pdiv = 0x4 /* 5 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2904 { 216000, 2905 { .dco_integer = 0x1C2, .dco_fraction = 0x0000, /* [4]: 2.16 */ 2906 .pdiv = 0x1 /* 2 */, .kdiv = 2, .qdiv_mode = 1, .qdiv_ratio = 2, }, }, 2907 { 432000, 2908 { .dco_integer = 0x1C2, .dco_fraction = 0x0000, /* [5]: 4.32 */ 2909 .pdiv = 0x1 /* 2 */, .kdiv = 2, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2910 { 648000, 2911 { .dco_integer = 0x1FA, .dco_fraction = 0x2000, /* [6]: 6.48 */ 2912 .pdiv = 0x2 /* 3 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2913 { 810000, 2914 { .dco_integer = 0x1A5, .dco_fraction = 0x7000, /* [7]: 8.1 */ 2915 .pdiv = 0x1 /* 2 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, }, }, 2916 }; 2917 2918 static const struct skl_wrpll_params icl_tbt_pll_24MHz_values = { 2919 .dco_integer = 0x151, .dco_fraction = 0x4000, 2920 .pdiv = 0x4 /* 5 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, 2921 }; 2922 2923 static const struct skl_wrpll_params icl_tbt_pll_19_2MHz_values = { 2924 .dco_integer = 0x1A5, .dco_fraction = 0x7000, 2925 .pdiv = 0x4 /* 5 */, .kdiv = 1, .qdiv_mode = 0, .qdiv_ratio = 0, 2926 }; 2927 2928 static const struct skl_wrpll_params tgl_tbt_pll_19_2MHz_values = { 2929 .dco_integer = 0x54, .dco_fraction = 0x3000, 2930 /* the following params are unused */ 2931 .pdiv = 0, .kdiv = 0, .qdiv_mode = 0, .qdiv_ratio = 0, 2932 }; 2933 2934 static const struct skl_wrpll_params tgl_tbt_pll_24MHz_values = { 2935 .dco_integer = 0x43, .dco_fraction = 0x4000, 2936 /* the following params are unused */ 2937 }; 2938 2939 /* 2940 * Display WA #22010492432: tgl 2941 * Divide the nominal .dco_fraction value by 2. 2942 */ 2943 static const struct skl_wrpll_params tgl_tbt_pll_38_4MHz_values = { 2944 .dco_integer = 0x54, .dco_fraction = 0x1800, 2945 /* the following params are unused */ 2946 .pdiv = 0, .kdiv = 0, .qdiv_mode = 0, .qdiv_ratio = 0, 2947 }; 2948 2949 static bool icl_calc_dp_combo_pll(struct intel_crtc_state *crtc_state, 2950 struct skl_wrpll_params *pll_params) 2951 { 2952 struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev); 2953 const struct icl_combo_pll_params *params = 2954 dev_priv->dpll.ref_clks.nssc == 24000 ? 2955 icl_dp_combo_pll_24MHz_values : 2956 icl_dp_combo_pll_19_2MHz_values; 2957 int clock = crtc_state->port_clock; 2958 int i; 2959 2960 for (i = 0; i < ARRAY_SIZE(icl_dp_combo_pll_24MHz_values); i++) { 2961 if (clock == params[i].clock) { 2962 *pll_params = params[i].wrpll; 2963 return true; 2964 } 2965 } 2966 2967 MISSING_CASE(clock); 2968 return false; 2969 } 2970 2971 static bool icl_calc_tbt_pll(struct intel_crtc_state *crtc_state, 2972 struct skl_wrpll_params *pll_params) 2973 { 2974 struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev); 2975 2976 if (INTEL_GEN(dev_priv) >= 12) { 2977 switch (dev_priv->dpll.ref_clks.nssc) { 2978 default: 2979 MISSING_CASE(dev_priv->dpll.ref_clks.nssc); 2980 fallthrough; 2981 case 19200: 2982 *pll_params = tgl_tbt_pll_19_2MHz_values; 2983 break; 2984 case 24000: 2985 *pll_params = tgl_tbt_pll_24MHz_values; 2986 break; 2987 case 38400: 2988 *pll_params = tgl_tbt_pll_38_4MHz_values; 2989 break; 2990 } 2991 } else { 2992 switch (dev_priv->dpll.ref_clks.nssc) { 2993 default: 2994 MISSING_CASE(dev_priv->dpll.ref_clks.nssc); 2995 fallthrough; 2996 case 19200: 2997 case 38400: 2998 *pll_params = icl_tbt_pll_19_2MHz_values; 2999 break; 3000 case 24000: 3001 *pll_params = icl_tbt_pll_24MHz_values; 3002 break; 3003 } 3004 } 3005 3006 return true; 3007 } 3008 3009 static int icl_ddi_tbt_pll_get_freq(struct drm_i915_private *i915, 3010 const struct intel_shared_dpll *pll) 3011 { 3012 /* 3013 * The PLL outputs multiple frequencies at the same time, selection is 3014 * made at DDI clock mux level. 3015 */ 3016 drm_WARN_ON(&i915->drm, 1); 3017 3018 return 0; 3019 } 3020 3021 static int icl_wrpll_ref_clock(struct drm_i915_private *i915) 3022 { 3023 int ref_clock = i915->dpll.ref_clks.nssc; 3024 3025 /* 3026 * For ICL+, the spec states: if reference frequency is 38.4, 3027 * use 19.2 because the DPLL automatically divides that by 2. 3028 */ 3029 if (ref_clock == 38400) 3030 ref_clock = 19200; 3031 3032 return ref_clock; 3033 } 3034 3035 static bool 3036 icl_calc_wrpll(struct intel_crtc_state *crtc_state, 3037 struct skl_wrpll_params *wrpll_params) 3038 { 3039 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev); 3040 3041 return __cnl_ddi_calculate_wrpll(crtc_state, wrpll_params, 3042 icl_wrpll_ref_clock(i915)); 3043 } 3044 3045 static int icl_ddi_combo_pll_get_freq(struct drm_i915_private *i915, 3046 const struct intel_shared_dpll *pll) 3047 { 3048 return __cnl_ddi_wrpll_get_freq(i915, pll, 3049 icl_wrpll_ref_clock(i915)); 3050 } 3051 3052 static void icl_calc_dpll_state(struct drm_i915_private *i915, 3053 const struct skl_wrpll_params *pll_params, 3054 struct intel_dpll_hw_state *pll_state) 3055 { 3056 memset(pll_state, 0, sizeof(*pll_state)); 3057 3058 pll_state->cfgcr0 = DPLL_CFGCR0_DCO_FRACTION(pll_params->dco_fraction) | 3059 pll_params->dco_integer; 3060 3061 pll_state->cfgcr1 = DPLL_CFGCR1_QDIV_RATIO(pll_params->qdiv_ratio) | 3062 DPLL_CFGCR1_QDIV_MODE(pll_params->qdiv_mode) | 3063 DPLL_CFGCR1_KDIV(pll_params->kdiv) | 3064 DPLL_CFGCR1_PDIV(pll_params->pdiv); 3065 3066 if (INTEL_GEN(i915) >= 12) 3067 pll_state->cfgcr1 |= TGL_DPLL_CFGCR1_CFSELOVRD_NORMAL_XTAL; 3068 else 3069 pll_state->cfgcr1 |= DPLL_CFGCR1_CENTRAL_FREQ_8400; 3070 } 3071 3072 static enum tc_port icl_pll_id_to_tc_port(enum intel_dpll_id id) 3073 { 3074 return id - DPLL_ID_ICL_MGPLL1; 3075 } 3076 3077 enum intel_dpll_id icl_tc_port_to_pll_id(enum tc_port tc_port) 3078 { 3079 return tc_port + DPLL_ID_ICL_MGPLL1; 3080 } 3081 3082 static bool icl_mg_pll_find_divisors(int clock_khz, bool is_dp, bool use_ssc, 3083 u32 *target_dco_khz, 3084 struct intel_dpll_hw_state *state, 3085 bool is_dkl) 3086 { 3087 u32 dco_min_freq, dco_max_freq; 3088 int div1_vals[] = {7, 5, 3, 2}; 3089 unsigned int i; 3090 int div2; 3091 3092 dco_min_freq = is_dp ? 8100000 : use_ssc ? 8000000 : 7992000; 3093 dco_max_freq = is_dp ? 8100000 : 10000000; 3094 3095 for (i = 0; i < ARRAY_SIZE(div1_vals); i++) { 3096 int div1 = div1_vals[i]; 3097 3098 for (div2 = 10; div2 > 0; div2--) { 3099 int dco = div1 * div2 * clock_khz * 5; 3100 int a_divratio, tlinedrv, inputsel; 3101 u32 hsdiv; 3102 3103 if (dco < dco_min_freq || dco > dco_max_freq) 3104 continue; 3105 3106 if (div2 >= 2) { 3107 /* 3108 * Note: a_divratio not matching TGL BSpec 3109 * algorithm but matching hardcoded values and 3110 * working on HW for DP alt-mode at least 3111 */ 3112 a_divratio = is_dp ? 10 : 5; 3113 tlinedrv = is_dkl ? 1 : 2; 3114 } else { 3115 a_divratio = 5; 3116 tlinedrv = 0; 3117 } 3118 inputsel = is_dp ? 0 : 1; 3119 3120 switch (div1) { 3121 default: 3122 MISSING_CASE(div1); 3123 fallthrough; 3124 case 2: 3125 hsdiv = MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_2; 3126 break; 3127 case 3: 3128 hsdiv = MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_3; 3129 break; 3130 case 5: 3131 hsdiv = MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_5; 3132 break; 3133 case 7: 3134 hsdiv = MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_7; 3135 break; 3136 } 3137 3138 *target_dco_khz = dco; 3139 3140 state->mg_refclkin_ctl = MG_REFCLKIN_CTL_OD_2_MUX(1); 3141 3142 state->mg_clktop2_coreclkctl1 = 3143 MG_CLKTOP2_CORECLKCTL1_A_DIVRATIO(a_divratio); 3144 3145 state->mg_clktop2_hsclkctl = 3146 MG_CLKTOP2_HSCLKCTL_TLINEDRV_CLKSEL(tlinedrv) | 3147 MG_CLKTOP2_HSCLKCTL_CORE_INPUTSEL(inputsel) | 3148 hsdiv | 3149 MG_CLKTOP2_HSCLKCTL_DSDIV_RATIO(div2); 3150 3151 return true; 3152 } 3153 } 3154 3155 return false; 3156 } 3157 3158 /* 3159 * The specification for this function uses real numbers, so the math had to be 3160 * adapted to integer-only calculation, that's why it looks so different. 3161 */ 3162 static bool icl_calc_mg_pll_state(struct intel_crtc_state *crtc_state, 3163 struct intel_dpll_hw_state *pll_state) 3164 { 3165 struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev); 3166 int refclk_khz = dev_priv->dpll.ref_clks.nssc; 3167 int clock = crtc_state->port_clock; 3168 u32 dco_khz, m1div, m2div_int, m2div_rem, m2div_frac; 3169 u32 iref_ndiv, iref_trim, iref_pulse_w; 3170 u32 prop_coeff, int_coeff; 3171 u32 tdc_targetcnt, feedfwgain; 3172 u64 ssc_stepsize, ssc_steplen, ssc_steplog; 3173 u64 tmp; 3174 bool use_ssc = false; 3175 bool is_dp = !intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI); 3176 bool is_dkl = INTEL_GEN(dev_priv) >= 12; 3177 3178 memset(pll_state, 0, sizeof(*pll_state)); 3179 3180 if (!icl_mg_pll_find_divisors(clock, is_dp, use_ssc, &dco_khz, 3181 pll_state, is_dkl)) { 3182 drm_dbg_kms(&dev_priv->drm, 3183 "Failed to find divisors for clock %d\n", clock); 3184 return false; 3185 } 3186 3187 m1div = 2; 3188 m2div_int = dco_khz / (refclk_khz * m1div); 3189 if (m2div_int > 255) { 3190 if (!is_dkl) { 3191 m1div = 4; 3192 m2div_int = dco_khz / (refclk_khz * m1div); 3193 } 3194 3195 if (m2div_int > 255) { 3196 drm_dbg_kms(&dev_priv->drm, 3197 "Failed to find mdiv for clock %d\n", 3198 clock); 3199 return false; 3200 } 3201 } 3202 m2div_rem = dco_khz % (refclk_khz * m1div); 3203 3204 tmp = (u64)m2div_rem * (1 << 22); 3205 do_div(tmp, refclk_khz * m1div); 3206 m2div_frac = tmp; 3207 3208 switch (refclk_khz) { 3209 case 19200: 3210 iref_ndiv = 1; 3211 iref_trim = 28; 3212 iref_pulse_w = 1; 3213 break; 3214 case 24000: 3215 iref_ndiv = 1; 3216 iref_trim = 25; 3217 iref_pulse_w = 2; 3218 break; 3219 case 38400: 3220 iref_ndiv = 2; 3221 iref_trim = 28; 3222 iref_pulse_w = 1; 3223 break; 3224 default: 3225 MISSING_CASE(refclk_khz); 3226 return false; 3227 } 3228 3229 /* 3230 * tdc_res = 0.000003 3231 * tdc_targetcnt = int(2 / (tdc_res * 8 * 50 * 1.1) / refclk_mhz + 0.5) 3232 * 3233 * The multiplication by 1000 is due to refclk MHz to KHz conversion. It 3234 * was supposed to be a division, but we rearranged the operations of 3235 * the formula to avoid early divisions so we don't multiply the 3236 * rounding errors. 3237 * 3238 * 0.000003 * 8 * 50 * 1.1 = 0.00132, also known as 132 / 100000, which 3239 * we also rearrange to work with integers. 3240 * 3241 * The 0.5 transformed to 5 results in a multiplication by 10 and the 3242 * last division by 10. 3243 */ 3244 tdc_targetcnt = (2 * 1000 * 100000 * 10 / (132 * refclk_khz) + 5) / 10; 3245 3246 /* 3247 * Here we divide dco_khz by 10 in order to allow the dividend to fit in 3248 * 32 bits. That's not a problem since we round the division down 3249 * anyway. 3250 */ 3251 feedfwgain = (use_ssc || m2div_rem > 0) ? 3252 m1div * 1000000 * 100 / (dco_khz * 3 / 10) : 0; 3253 3254 if (dco_khz >= 9000000) { 3255 prop_coeff = 5; 3256 int_coeff = 10; 3257 } else { 3258 prop_coeff = 4; 3259 int_coeff = 8; 3260 } 3261 3262 if (use_ssc) { 3263 tmp = mul_u32_u32(dco_khz, 47 * 32); 3264 do_div(tmp, refclk_khz * m1div * 10000); 3265 ssc_stepsize = tmp; 3266 3267 tmp = mul_u32_u32(dco_khz, 1000); 3268 ssc_steplen = DIV_ROUND_UP_ULL(tmp, 32 * 2 * 32); 3269 } else { 3270 ssc_stepsize = 0; 3271 ssc_steplen = 0; 3272 } 3273 ssc_steplog = 4; 3274 3275 /* write pll_state calculations */ 3276 if (is_dkl) { 3277 pll_state->mg_pll_div0 = DKL_PLL_DIV0_INTEG_COEFF(int_coeff) | 3278 DKL_PLL_DIV0_PROP_COEFF(prop_coeff) | 3279 DKL_PLL_DIV0_FBPREDIV(m1div) | 3280 DKL_PLL_DIV0_FBDIV_INT(m2div_int); 3281 3282 pll_state->mg_pll_div1 = DKL_PLL_DIV1_IREF_TRIM(iref_trim) | 3283 DKL_PLL_DIV1_TDC_TARGET_CNT(tdc_targetcnt); 3284 3285 pll_state->mg_pll_ssc = DKL_PLL_SSC_IREF_NDIV_RATIO(iref_ndiv) | 3286 DKL_PLL_SSC_STEP_LEN(ssc_steplen) | 3287 DKL_PLL_SSC_STEP_NUM(ssc_steplog) | 3288 (use_ssc ? DKL_PLL_SSC_EN : 0); 3289 3290 pll_state->mg_pll_bias = (m2div_frac ? DKL_PLL_BIAS_FRAC_EN_H : 0) | 3291 DKL_PLL_BIAS_FBDIV_FRAC(m2div_frac); 3292 3293 pll_state->mg_pll_tdc_coldst_bias = 3294 DKL_PLL_TDC_SSC_STEP_SIZE(ssc_stepsize) | 3295 DKL_PLL_TDC_FEED_FWD_GAIN(feedfwgain); 3296 3297 } else { 3298 pll_state->mg_pll_div0 = 3299 (m2div_rem > 0 ? MG_PLL_DIV0_FRACNEN_H : 0) | 3300 MG_PLL_DIV0_FBDIV_FRAC(m2div_frac) | 3301 MG_PLL_DIV0_FBDIV_INT(m2div_int); 3302 3303 pll_state->mg_pll_div1 = 3304 MG_PLL_DIV1_IREF_NDIVRATIO(iref_ndiv) | 3305 MG_PLL_DIV1_DITHER_DIV_2 | 3306 MG_PLL_DIV1_NDIVRATIO(1) | 3307 MG_PLL_DIV1_FBPREDIV(m1div); 3308 3309 pll_state->mg_pll_lf = 3310 MG_PLL_LF_TDCTARGETCNT(tdc_targetcnt) | 3311 MG_PLL_LF_AFCCNTSEL_512 | 3312 MG_PLL_LF_GAINCTRL(1) | 3313 MG_PLL_LF_INT_COEFF(int_coeff) | 3314 MG_PLL_LF_PROP_COEFF(prop_coeff); 3315 3316 pll_state->mg_pll_frac_lock = 3317 MG_PLL_FRAC_LOCK_TRUELOCK_CRIT_32 | 3318 MG_PLL_FRAC_LOCK_EARLYLOCK_CRIT_32 | 3319 MG_PLL_FRAC_LOCK_LOCKTHRESH(10) | 3320 MG_PLL_FRAC_LOCK_DCODITHEREN | 3321 MG_PLL_FRAC_LOCK_FEEDFWRDGAIN(feedfwgain); 3322 if (use_ssc || m2div_rem > 0) 3323 pll_state->mg_pll_frac_lock |= 3324 MG_PLL_FRAC_LOCK_FEEDFWRDCAL_EN; 3325 3326 pll_state->mg_pll_ssc = 3327 (use_ssc ? MG_PLL_SSC_EN : 0) | 3328 MG_PLL_SSC_TYPE(2) | 3329 MG_PLL_SSC_STEPLENGTH(ssc_steplen) | 3330 MG_PLL_SSC_STEPNUM(ssc_steplog) | 3331 MG_PLL_SSC_FLLEN | 3332 MG_PLL_SSC_STEPSIZE(ssc_stepsize); 3333 3334 pll_state->mg_pll_tdc_coldst_bias = 3335 MG_PLL_TDC_COLDST_COLDSTART | 3336 MG_PLL_TDC_COLDST_IREFINT_EN | 3337 MG_PLL_TDC_COLDST_REFBIAS_START_PULSE_W(iref_pulse_w) | 3338 MG_PLL_TDC_TDCOVCCORR_EN | 3339 MG_PLL_TDC_TDCSEL(3); 3340 3341 pll_state->mg_pll_bias = 3342 MG_PLL_BIAS_BIAS_GB_SEL(3) | 3343 MG_PLL_BIAS_INIT_DCOAMP(0x3F) | 3344 MG_PLL_BIAS_BIAS_BONUS(10) | 3345 MG_PLL_BIAS_BIASCAL_EN | 3346 MG_PLL_BIAS_CTRIM(12) | 3347 MG_PLL_BIAS_VREF_RDAC(4) | 3348 MG_PLL_BIAS_IREFTRIM(iref_trim); 3349 3350 if (refclk_khz == 38400) { 3351 pll_state->mg_pll_tdc_coldst_bias_mask = 3352 MG_PLL_TDC_COLDST_COLDSTART; 3353 pll_state->mg_pll_bias_mask = 0; 3354 } else { 3355 pll_state->mg_pll_tdc_coldst_bias_mask = -1U; 3356 pll_state->mg_pll_bias_mask = -1U; 3357 } 3358 3359 pll_state->mg_pll_tdc_coldst_bias &= 3360 pll_state->mg_pll_tdc_coldst_bias_mask; 3361 pll_state->mg_pll_bias &= pll_state->mg_pll_bias_mask; 3362 } 3363 3364 return true; 3365 } 3366 3367 static int icl_ddi_mg_pll_get_freq(struct drm_i915_private *dev_priv, 3368 const struct intel_shared_dpll *pll) 3369 { 3370 const struct intel_dpll_hw_state *pll_state = &pll->state.hw_state; 3371 u32 m1, m2_int, m2_frac, div1, div2, ref_clock; 3372 u64 tmp; 3373 3374 ref_clock = dev_priv->dpll.ref_clks.nssc; 3375 3376 if (INTEL_GEN(dev_priv) >= 12) { 3377 m1 = pll_state->mg_pll_div0 & DKL_PLL_DIV0_FBPREDIV_MASK; 3378 m1 = m1 >> DKL_PLL_DIV0_FBPREDIV_SHIFT; 3379 m2_int = pll_state->mg_pll_div0 & DKL_PLL_DIV0_FBDIV_INT_MASK; 3380 3381 if (pll_state->mg_pll_bias & DKL_PLL_BIAS_FRAC_EN_H) { 3382 m2_frac = pll_state->mg_pll_bias & 3383 DKL_PLL_BIAS_FBDIV_FRAC_MASK; 3384 m2_frac = m2_frac >> DKL_PLL_BIAS_FBDIV_SHIFT; 3385 } else { 3386 m2_frac = 0; 3387 } 3388 } else { 3389 m1 = pll_state->mg_pll_div1 & MG_PLL_DIV1_FBPREDIV_MASK; 3390 m2_int = pll_state->mg_pll_div0 & MG_PLL_DIV0_FBDIV_INT_MASK; 3391 3392 if (pll_state->mg_pll_div0 & MG_PLL_DIV0_FRACNEN_H) { 3393 m2_frac = pll_state->mg_pll_div0 & 3394 MG_PLL_DIV0_FBDIV_FRAC_MASK; 3395 m2_frac = m2_frac >> MG_PLL_DIV0_FBDIV_FRAC_SHIFT; 3396 } else { 3397 m2_frac = 0; 3398 } 3399 } 3400 3401 switch (pll_state->mg_clktop2_hsclkctl & 3402 MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_MASK) { 3403 case MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_2: 3404 div1 = 2; 3405 break; 3406 case MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_3: 3407 div1 = 3; 3408 break; 3409 case MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_5: 3410 div1 = 5; 3411 break; 3412 case MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_7: 3413 div1 = 7; 3414 break; 3415 default: 3416 MISSING_CASE(pll_state->mg_clktop2_hsclkctl); 3417 return 0; 3418 } 3419 3420 div2 = (pll_state->mg_clktop2_hsclkctl & 3421 MG_CLKTOP2_HSCLKCTL_DSDIV_RATIO_MASK) >> 3422 MG_CLKTOP2_HSCLKCTL_DSDIV_RATIO_SHIFT; 3423 3424 /* div2 value of 0 is same as 1 means no div */ 3425 if (div2 == 0) 3426 div2 = 1; 3427 3428 /* 3429 * Adjust the original formula to delay the division by 2^22 in order to 3430 * minimize possible rounding errors. 3431 */ 3432 tmp = (u64)m1 * m2_int * ref_clock + 3433 (((u64)m1 * m2_frac * ref_clock) >> 22); 3434 tmp = div_u64(tmp, 5 * div1 * div2); 3435 3436 return tmp; 3437 } 3438 3439 /** 3440 * icl_set_active_port_dpll - select the active port DPLL for a given CRTC 3441 * @crtc_state: state for the CRTC to select the DPLL for 3442 * @port_dpll_id: the active @port_dpll_id to select 3443 * 3444 * Select the given @port_dpll_id instance from the DPLLs reserved for the 3445 * CRTC. 3446 */ 3447 void icl_set_active_port_dpll(struct intel_crtc_state *crtc_state, 3448 enum icl_port_dpll_id port_dpll_id) 3449 { 3450 struct icl_port_dpll *port_dpll = 3451 &crtc_state->icl_port_dplls[port_dpll_id]; 3452 3453 crtc_state->shared_dpll = port_dpll->pll; 3454 crtc_state->dpll_hw_state = port_dpll->hw_state; 3455 } 3456 3457 static void icl_update_active_dpll(struct intel_atomic_state *state, 3458 struct intel_crtc *crtc, 3459 struct intel_encoder *encoder) 3460 { 3461 struct intel_crtc_state *crtc_state = 3462 intel_atomic_get_new_crtc_state(state, crtc); 3463 struct intel_digital_port *primary_port; 3464 enum icl_port_dpll_id port_dpll_id = ICL_PORT_DPLL_DEFAULT; 3465 3466 primary_port = encoder->type == INTEL_OUTPUT_DP_MST ? 3467 enc_to_mst(encoder)->primary : 3468 enc_to_dig_port(encoder); 3469 3470 if (primary_port && 3471 (primary_port->tc_mode == TC_PORT_DP_ALT || 3472 primary_port->tc_mode == TC_PORT_LEGACY)) 3473 port_dpll_id = ICL_PORT_DPLL_MG_PHY; 3474 3475 icl_set_active_port_dpll(crtc_state, port_dpll_id); 3476 } 3477 3478 static bool icl_get_combo_phy_dpll(struct intel_atomic_state *state, 3479 struct intel_crtc *crtc, 3480 struct intel_encoder *encoder) 3481 { 3482 struct intel_crtc_state *crtc_state = 3483 intel_atomic_get_new_crtc_state(state, crtc); 3484 struct skl_wrpll_params pll_params = { }; 3485 struct icl_port_dpll *port_dpll = 3486 &crtc_state->icl_port_dplls[ICL_PORT_DPLL_DEFAULT]; 3487 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 3488 enum port port = encoder->port; 3489 unsigned long dpll_mask; 3490 int ret; 3491 3492 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI) || 3493 intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DSI)) 3494 ret = icl_calc_wrpll(crtc_state, &pll_params); 3495 else 3496 ret = icl_calc_dp_combo_pll(crtc_state, &pll_params); 3497 3498 if (!ret) { 3499 drm_dbg_kms(&dev_priv->drm, 3500 "Could not calculate combo PHY PLL state.\n"); 3501 3502 return false; 3503 } 3504 3505 icl_calc_dpll_state(dev_priv, &pll_params, &port_dpll->hw_state); 3506 3507 if (IS_ELKHARTLAKE(dev_priv) && port != PORT_A) 3508 dpll_mask = 3509 BIT(DPLL_ID_EHL_DPLL4) | 3510 BIT(DPLL_ID_ICL_DPLL1) | 3511 BIT(DPLL_ID_ICL_DPLL0); 3512 else 3513 dpll_mask = BIT(DPLL_ID_ICL_DPLL1) | BIT(DPLL_ID_ICL_DPLL0); 3514 3515 port_dpll->pll = intel_find_shared_dpll(state, crtc, 3516 &port_dpll->hw_state, 3517 dpll_mask); 3518 if (!port_dpll->pll) { 3519 drm_dbg_kms(&dev_priv->drm, 3520 "No combo PHY PLL found for [ENCODER:%d:%s]\n", 3521 encoder->base.base.id, encoder->base.name); 3522 return false; 3523 } 3524 3525 intel_reference_shared_dpll(state, crtc, 3526 port_dpll->pll, &port_dpll->hw_state); 3527 3528 icl_update_active_dpll(state, crtc, encoder); 3529 3530 return true; 3531 } 3532 3533 static bool icl_get_tc_phy_dplls(struct intel_atomic_state *state, 3534 struct intel_crtc *crtc, 3535 struct intel_encoder *encoder) 3536 { 3537 struct drm_i915_private *dev_priv = to_i915(state->base.dev); 3538 struct intel_crtc_state *crtc_state = 3539 intel_atomic_get_new_crtc_state(state, crtc); 3540 struct skl_wrpll_params pll_params = { }; 3541 struct icl_port_dpll *port_dpll; 3542 enum intel_dpll_id dpll_id; 3543 3544 port_dpll = &crtc_state->icl_port_dplls[ICL_PORT_DPLL_DEFAULT]; 3545 if (!icl_calc_tbt_pll(crtc_state, &pll_params)) { 3546 drm_dbg_kms(&dev_priv->drm, 3547 "Could not calculate TBT PLL state.\n"); 3548 return false; 3549 } 3550 3551 icl_calc_dpll_state(dev_priv, &pll_params, &port_dpll->hw_state); 3552 3553 port_dpll->pll = intel_find_shared_dpll(state, crtc, 3554 &port_dpll->hw_state, 3555 BIT(DPLL_ID_ICL_TBTPLL)); 3556 if (!port_dpll->pll) { 3557 drm_dbg_kms(&dev_priv->drm, "No TBT-ALT PLL found\n"); 3558 return false; 3559 } 3560 intel_reference_shared_dpll(state, crtc, 3561 port_dpll->pll, &port_dpll->hw_state); 3562 3563 3564 port_dpll = &crtc_state->icl_port_dplls[ICL_PORT_DPLL_MG_PHY]; 3565 if (!icl_calc_mg_pll_state(crtc_state, &port_dpll->hw_state)) { 3566 drm_dbg_kms(&dev_priv->drm, 3567 "Could not calculate MG PHY PLL state.\n"); 3568 goto err_unreference_tbt_pll; 3569 } 3570 3571 dpll_id = icl_tc_port_to_pll_id(intel_port_to_tc(dev_priv, 3572 encoder->port)); 3573 port_dpll->pll = intel_find_shared_dpll(state, crtc, 3574 &port_dpll->hw_state, 3575 BIT(dpll_id)); 3576 if (!port_dpll->pll) { 3577 drm_dbg_kms(&dev_priv->drm, "No MG PHY PLL found\n"); 3578 goto err_unreference_tbt_pll; 3579 } 3580 intel_reference_shared_dpll(state, crtc, 3581 port_dpll->pll, &port_dpll->hw_state); 3582 3583 icl_update_active_dpll(state, crtc, encoder); 3584 3585 return true; 3586 3587 err_unreference_tbt_pll: 3588 port_dpll = &crtc_state->icl_port_dplls[ICL_PORT_DPLL_DEFAULT]; 3589 intel_unreference_shared_dpll(state, crtc, port_dpll->pll); 3590 3591 return false; 3592 } 3593 3594 static bool icl_get_dplls(struct intel_atomic_state *state, 3595 struct intel_crtc *crtc, 3596 struct intel_encoder *encoder) 3597 { 3598 struct drm_i915_private *dev_priv = to_i915(state->base.dev); 3599 enum phy phy = intel_port_to_phy(dev_priv, encoder->port); 3600 3601 if (intel_phy_is_combo(dev_priv, phy)) 3602 return icl_get_combo_phy_dpll(state, crtc, encoder); 3603 else if (intel_phy_is_tc(dev_priv, phy)) 3604 return icl_get_tc_phy_dplls(state, crtc, encoder); 3605 3606 MISSING_CASE(phy); 3607 3608 return false; 3609 } 3610 3611 static void icl_put_dplls(struct intel_atomic_state *state, 3612 struct intel_crtc *crtc) 3613 { 3614 const struct intel_crtc_state *old_crtc_state = 3615 intel_atomic_get_old_crtc_state(state, crtc); 3616 struct intel_crtc_state *new_crtc_state = 3617 intel_atomic_get_new_crtc_state(state, crtc); 3618 enum icl_port_dpll_id id; 3619 3620 new_crtc_state->shared_dpll = NULL; 3621 3622 for (id = ICL_PORT_DPLL_DEFAULT; id < ICL_PORT_DPLL_COUNT; id++) { 3623 const struct icl_port_dpll *old_port_dpll = 3624 &old_crtc_state->icl_port_dplls[id]; 3625 struct icl_port_dpll *new_port_dpll = 3626 &new_crtc_state->icl_port_dplls[id]; 3627 3628 new_port_dpll->pll = NULL; 3629 3630 if (!old_port_dpll->pll) 3631 continue; 3632 3633 intel_unreference_shared_dpll(state, crtc, old_port_dpll->pll); 3634 } 3635 } 3636 3637 static bool mg_pll_get_hw_state(struct drm_i915_private *dev_priv, 3638 struct intel_shared_dpll *pll, 3639 struct intel_dpll_hw_state *hw_state) 3640 { 3641 const enum intel_dpll_id id = pll->info->id; 3642 enum tc_port tc_port = icl_pll_id_to_tc_port(id); 3643 intel_wakeref_t wakeref; 3644 bool ret = false; 3645 u32 val; 3646 3647 wakeref = intel_display_power_get_if_enabled(dev_priv, 3648 POWER_DOMAIN_DISPLAY_CORE); 3649 if (!wakeref) 3650 return false; 3651 3652 val = intel_de_read(dev_priv, MG_PLL_ENABLE(tc_port)); 3653 if (!(val & PLL_ENABLE)) 3654 goto out; 3655 3656 hw_state->mg_refclkin_ctl = intel_de_read(dev_priv, 3657 MG_REFCLKIN_CTL(tc_port)); 3658 hw_state->mg_refclkin_ctl &= MG_REFCLKIN_CTL_OD_2_MUX_MASK; 3659 3660 hw_state->mg_clktop2_coreclkctl1 = 3661 intel_de_read(dev_priv, MG_CLKTOP2_CORECLKCTL1(tc_port)); 3662 hw_state->mg_clktop2_coreclkctl1 &= 3663 MG_CLKTOP2_CORECLKCTL1_A_DIVRATIO_MASK; 3664 3665 hw_state->mg_clktop2_hsclkctl = 3666 intel_de_read(dev_priv, MG_CLKTOP2_HSCLKCTL(tc_port)); 3667 hw_state->mg_clktop2_hsclkctl &= 3668 MG_CLKTOP2_HSCLKCTL_TLINEDRV_CLKSEL_MASK | 3669 MG_CLKTOP2_HSCLKCTL_CORE_INPUTSEL_MASK | 3670 MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_MASK | 3671 MG_CLKTOP2_HSCLKCTL_DSDIV_RATIO_MASK; 3672 3673 hw_state->mg_pll_div0 = intel_de_read(dev_priv, MG_PLL_DIV0(tc_port)); 3674 hw_state->mg_pll_div1 = intel_de_read(dev_priv, MG_PLL_DIV1(tc_port)); 3675 hw_state->mg_pll_lf = intel_de_read(dev_priv, MG_PLL_LF(tc_port)); 3676 hw_state->mg_pll_frac_lock = intel_de_read(dev_priv, 3677 MG_PLL_FRAC_LOCK(tc_port)); 3678 hw_state->mg_pll_ssc = intel_de_read(dev_priv, MG_PLL_SSC(tc_port)); 3679 3680 hw_state->mg_pll_bias = intel_de_read(dev_priv, MG_PLL_BIAS(tc_port)); 3681 hw_state->mg_pll_tdc_coldst_bias = 3682 intel_de_read(dev_priv, MG_PLL_TDC_COLDST_BIAS(tc_port)); 3683 3684 if (dev_priv->dpll.ref_clks.nssc == 38400) { 3685 hw_state->mg_pll_tdc_coldst_bias_mask = MG_PLL_TDC_COLDST_COLDSTART; 3686 hw_state->mg_pll_bias_mask = 0; 3687 } else { 3688 hw_state->mg_pll_tdc_coldst_bias_mask = -1U; 3689 hw_state->mg_pll_bias_mask = -1U; 3690 } 3691 3692 hw_state->mg_pll_tdc_coldst_bias &= hw_state->mg_pll_tdc_coldst_bias_mask; 3693 hw_state->mg_pll_bias &= hw_state->mg_pll_bias_mask; 3694 3695 ret = true; 3696 out: 3697 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 3698 return ret; 3699 } 3700 3701 static bool dkl_pll_get_hw_state(struct drm_i915_private *dev_priv, 3702 struct intel_shared_dpll *pll, 3703 struct intel_dpll_hw_state *hw_state) 3704 { 3705 const enum intel_dpll_id id = pll->info->id; 3706 enum tc_port tc_port = icl_pll_id_to_tc_port(id); 3707 intel_wakeref_t wakeref; 3708 bool ret = false; 3709 u32 val; 3710 3711 wakeref = intel_display_power_get_if_enabled(dev_priv, 3712 POWER_DOMAIN_DISPLAY_CORE); 3713 if (!wakeref) 3714 return false; 3715 3716 val = intel_de_read(dev_priv, MG_PLL_ENABLE(tc_port)); 3717 if (!(val & PLL_ENABLE)) 3718 goto out; 3719 3720 /* 3721 * All registers read here have the same HIP_INDEX_REG even though 3722 * they are on different building blocks 3723 */ 3724 intel_de_write(dev_priv, HIP_INDEX_REG(tc_port), 3725 HIP_INDEX_VAL(tc_port, 0x2)); 3726 3727 hw_state->mg_refclkin_ctl = intel_de_read(dev_priv, 3728 DKL_REFCLKIN_CTL(tc_port)); 3729 hw_state->mg_refclkin_ctl &= MG_REFCLKIN_CTL_OD_2_MUX_MASK; 3730 3731 hw_state->mg_clktop2_hsclkctl = 3732 intel_de_read(dev_priv, DKL_CLKTOP2_HSCLKCTL(tc_port)); 3733 hw_state->mg_clktop2_hsclkctl &= 3734 MG_CLKTOP2_HSCLKCTL_TLINEDRV_CLKSEL_MASK | 3735 MG_CLKTOP2_HSCLKCTL_CORE_INPUTSEL_MASK | 3736 MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_MASK | 3737 MG_CLKTOP2_HSCLKCTL_DSDIV_RATIO_MASK; 3738 3739 hw_state->mg_clktop2_coreclkctl1 = 3740 intel_de_read(dev_priv, DKL_CLKTOP2_CORECLKCTL1(tc_port)); 3741 hw_state->mg_clktop2_coreclkctl1 &= 3742 MG_CLKTOP2_CORECLKCTL1_A_DIVRATIO_MASK; 3743 3744 hw_state->mg_pll_div0 = intel_de_read(dev_priv, DKL_PLL_DIV0(tc_port)); 3745 hw_state->mg_pll_div0 &= (DKL_PLL_DIV0_INTEG_COEFF_MASK | 3746 DKL_PLL_DIV0_PROP_COEFF_MASK | 3747 DKL_PLL_DIV0_FBPREDIV_MASK | 3748 DKL_PLL_DIV0_FBDIV_INT_MASK); 3749 3750 hw_state->mg_pll_div1 = intel_de_read(dev_priv, DKL_PLL_DIV1(tc_port)); 3751 hw_state->mg_pll_div1 &= (DKL_PLL_DIV1_IREF_TRIM_MASK | 3752 DKL_PLL_DIV1_TDC_TARGET_CNT_MASK); 3753 3754 hw_state->mg_pll_ssc = intel_de_read(dev_priv, DKL_PLL_SSC(tc_port)); 3755 hw_state->mg_pll_ssc &= (DKL_PLL_SSC_IREF_NDIV_RATIO_MASK | 3756 DKL_PLL_SSC_STEP_LEN_MASK | 3757 DKL_PLL_SSC_STEP_NUM_MASK | 3758 DKL_PLL_SSC_EN); 3759 3760 hw_state->mg_pll_bias = intel_de_read(dev_priv, DKL_PLL_BIAS(tc_port)); 3761 hw_state->mg_pll_bias &= (DKL_PLL_BIAS_FRAC_EN_H | 3762 DKL_PLL_BIAS_FBDIV_FRAC_MASK); 3763 3764 hw_state->mg_pll_tdc_coldst_bias = 3765 intel_de_read(dev_priv, DKL_PLL_TDC_COLDST_BIAS(tc_port)); 3766 hw_state->mg_pll_tdc_coldst_bias &= (DKL_PLL_TDC_SSC_STEP_SIZE_MASK | 3767 DKL_PLL_TDC_FEED_FWD_GAIN_MASK); 3768 3769 ret = true; 3770 out: 3771 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 3772 return ret; 3773 } 3774 3775 static bool icl_pll_get_hw_state(struct drm_i915_private *dev_priv, 3776 struct intel_shared_dpll *pll, 3777 struct intel_dpll_hw_state *hw_state, 3778 i915_reg_t enable_reg) 3779 { 3780 const enum intel_dpll_id id = pll->info->id; 3781 intel_wakeref_t wakeref; 3782 bool ret = false; 3783 u32 val; 3784 3785 wakeref = intel_display_power_get_if_enabled(dev_priv, 3786 POWER_DOMAIN_DISPLAY_CORE); 3787 if (!wakeref) 3788 return false; 3789 3790 val = intel_de_read(dev_priv, enable_reg); 3791 if (!(val & PLL_ENABLE)) 3792 goto out; 3793 3794 if (INTEL_GEN(dev_priv) >= 12) { 3795 hw_state->cfgcr0 = intel_de_read(dev_priv, 3796 TGL_DPLL_CFGCR0(id)); 3797 hw_state->cfgcr1 = intel_de_read(dev_priv, 3798 TGL_DPLL_CFGCR1(id)); 3799 } else { 3800 if (IS_ELKHARTLAKE(dev_priv) && id == DPLL_ID_EHL_DPLL4) { 3801 hw_state->cfgcr0 = intel_de_read(dev_priv, 3802 ICL_DPLL_CFGCR0(4)); 3803 hw_state->cfgcr1 = intel_de_read(dev_priv, 3804 ICL_DPLL_CFGCR1(4)); 3805 } else { 3806 hw_state->cfgcr0 = intel_de_read(dev_priv, 3807 ICL_DPLL_CFGCR0(id)); 3808 hw_state->cfgcr1 = intel_de_read(dev_priv, 3809 ICL_DPLL_CFGCR1(id)); 3810 } 3811 } 3812 3813 ret = true; 3814 out: 3815 intel_display_power_put(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref); 3816 return ret; 3817 } 3818 3819 static bool combo_pll_get_hw_state(struct drm_i915_private *dev_priv, 3820 struct intel_shared_dpll *pll, 3821 struct intel_dpll_hw_state *hw_state) 3822 { 3823 i915_reg_t enable_reg = CNL_DPLL_ENABLE(pll->info->id); 3824 3825 if (IS_ELKHARTLAKE(dev_priv) && 3826 pll->info->id == DPLL_ID_EHL_DPLL4) { 3827 enable_reg = MG_PLL_ENABLE(0); 3828 } 3829 3830 return icl_pll_get_hw_state(dev_priv, pll, hw_state, enable_reg); 3831 } 3832 3833 static bool tbt_pll_get_hw_state(struct drm_i915_private *dev_priv, 3834 struct intel_shared_dpll *pll, 3835 struct intel_dpll_hw_state *hw_state) 3836 { 3837 return icl_pll_get_hw_state(dev_priv, pll, hw_state, TBT_PLL_ENABLE); 3838 } 3839 3840 static void icl_dpll_write(struct drm_i915_private *dev_priv, 3841 struct intel_shared_dpll *pll) 3842 { 3843 struct intel_dpll_hw_state *hw_state = &pll->state.hw_state; 3844 const enum intel_dpll_id id = pll->info->id; 3845 i915_reg_t cfgcr0_reg, cfgcr1_reg; 3846 3847 if (INTEL_GEN(dev_priv) >= 12) { 3848 cfgcr0_reg = TGL_DPLL_CFGCR0(id); 3849 cfgcr1_reg = TGL_DPLL_CFGCR1(id); 3850 } else { 3851 if (IS_ELKHARTLAKE(dev_priv) && id == DPLL_ID_EHL_DPLL4) { 3852 cfgcr0_reg = ICL_DPLL_CFGCR0(4); 3853 cfgcr1_reg = ICL_DPLL_CFGCR1(4); 3854 } else { 3855 cfgcr0_reg = ICL_DPLL_CFGCR0(id); 3856 cfgcr1_reg = ICL_DPLL_CFGCR1(id); 3857 } 3858 } 3859 3860 intel_de_write(dev_priv, cfgcr0_reg, hw_state->cfgcr0); 3861 intel_de_write(dev_priv, cfgcr1_reg, hw_state->cfgcr1); 3862 intel_de_posting_read(dev_priv, cfgcr1_reg); 3863 } 3864 3865 static void icl_mg_pll_write(struct drm_i915_private *dev_priv, 3866 struct intel_shared_dpll *pll) 3867 { 3868 struct intel_dpll_hw_state *hw_state = &pll->state.hw_state; 3869 enum tc_port tc_port = icl_pll_id_to_tc_port(pll->info->id); 3870 u32 val; 3871 3872 /* 3873 * Some of the following registers have reserved fields, so program 3874 * these with RMW based on a mask. The mask can be fixed or generated 3875 * during the calc/readout phase if the mask depends on some other HW 3876 * state like refclk, see icl_calc_mg_pll_state(). 3877 */ 3878 val = intel_de_read(dev_priv, MG_REFCLKIN_CTL(tc_port)); 3879 val &= ~MG_REFCLKIN_CTL_OD_2_MUX_MASK; 3880 val |= hw_state->mg_refclkin_ctl; 3881 intel_de_write(dev_priv, MG_REFCLKIN_CTL(tc_port), val); 3882 3883 val = intel_de_read(dev_priv, MG_CLKTOP2_CORECLKCTL1(tc_port)); 3884 val &= ~MG_CLKTOP2_CORECLKCTL1_A_DIVRATIO_MASK; 3885 val |= hw_state->mg_clktop2_coreclkctl1; 3886 intel_de_write(dev_priv, MG_CLKTOP2_CORECLKCTL1(tc_port), val); 3887 3888 val = intel_de_read(dev_priv, MG_CLKTOP2_HSCLKCTL(tc_port)); 3889 val &= ~(MG_CLKTOP2_HSCLKCTL_TLINEDRV_CLKSEL_MASK | 3890 MG_CLKTOP2_HSCLKCTL_CORE_INPUTSEL_MASK | 3891 MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_MASK | 3892 MG_CLKTOP2_HSCLKCTL_DSDIV_RATIO_MASK); 3893 val |= hw_state->mg_clktop2_hsclkctl; 3894 intel_de_write(dev_priv, MG_CLKTOP2_HSCLKCTL(tc_port), val); 3895 3896 intel_de_write(dev_priv, MG_PLL_DIV0(tc_port), hw_state->mg_pll_div0); 3897 intel_de_write(dev_priv, MG_PLL_DIV1(tc_port), hw_state->mg_pll_div1); 3898 intel_de_write(dev_priv, MG_PLL_LF(tc_port), hw_state->mg_pll_lf); 3899 intel_de_write(dev_priv, MG_PLL_FRAC_LOCK(tc_port), 3900 hw_state->mg_pll_frac_lock); 3901 intel_de_write(dev_priv, MG_PLL_SSC(tc_port), hw_state->mg_pll_ssc); 3902 3903 val = intel_de_read(dev_priv, MG_PLL_BIAS(tc_port)); 3904 val &= ~hw_state->mg_pll_bias_mask; 3905 val |= hw_state->mg_pll_bias; 3906 intel_de_write(dev_priv, MG_PLL_BIAS(tc_port), val); 3907 3908 val = intel_de_read(dev_priv, MG_PLL_TDC_COLDST_BIAS(tc_port)); 3909 val &= ~hw_state->mg_pll_tdc_coldst_bias_mask; 3910 val |= hw_state->mg_pll_tdc_coldst_bias; 3911 intel_de_write(dev_priv, MG_PLL_TDC_COLDST_BIAS(tc_port), val); 3912 3913 intel_de_posting_read(dev_priv, MG_PLL_TDC_COLDST_BIAS(tc_port)); 3914 } 3915 3916 static void dkl_pll_write(struct drm_i915_private *dev_priv, 3917 struct intel_shared_dpll *pll) 3918 { 3919 struct intel_dpll_hw_state *hw_state = &pll->state.hw_state; 3920 enum tc_port tc_port = icl_pll_id_to_tc_port(pll->info->id); 3921 u32 val; 3922 3923 /* 3924 * All registers programmed here have the same HIP_INDEX_REG even 3925 * though on different building block 3926 */ 3927 intel_de_write(dev_priv, HIP_INDEX_REG(tc_port), 3928 HIP_INDEX_VAL(tc_port, 0x2)); 3929 3930 /* All the registers are RMW */ 3931 val = intel_de_read(dev_priv, DKL_REFCLKIN_CTL(tc_port)); 3932 val &= ~MG_REFCLKIN_CTL_OD_2_MUX_MASK; 3933 val |= hw_state->mg_refclkin_ctl; 3934 intel_de_write(dev_priv, DKL_REFCLKIN_CTL(tc_port), val); 3935 3936 val = intel_de_read(dev_priv, DKL_CLKTOP2_CORECLKCTL1(tc_port)); 3937 val &= ~MG_CLKTOP2_CORECLKCTL1_A_DIVRATIO_MASK; 3938 val |= hw_state->mg_clktop2_coreclkctl1; 3939 intel_de_write(dev_priv, DKL_CLKTOP2_CORECLKCTL1(tc_port), val); 3940 3941 val = intel_de_read(dev_priv, DKL_CLKTOP2_HSCLKCTL(tc_port)); 3942 val &= ~(MG_CLKTOP2_HSCLKCTL_TLINEDRV_CLKSEL_MASK | 3943 MG_CLKTOP2_HSCLKCTL_CORE_INPUTSEL_MASK | 3944 MG_CLKTOP2_HSCLKCTL_HSDIV_RATIO_MASK | 3945 MG_CLKTOP2_HSCLKCTL_DSDIV_RATIO_MASK); 3946 val |= hw_state->mg_clktop2_hsclkctl; 3947 intel_de_write(dev_priv, DKL_CLKTOP2_HSCLKCTL(tc_port), val); 3948 3949 val = intel_de_read(dev_priv, DKL_PLL_DIV0(tc_port)); 3950 val &= ~(DKL_PLL_DIV0_INTEG_COEFF_MASK | 3951 DKL_PLL_DIV0_PROP_COEFF_MASK | 3952 DKL_PLL_DIV0_FBPREDIV_MASK | 3953 DKL_PLL_DIV0_FBDIV_INT_MASK); 3954 val |= hw_state->mg_pll_div0; 3955 intel_de_write(dev_priv, DKL_PLL_DIV0(tc_port), val); 3956 3957 val = intel_de_read(dev_priv, DKL_PLL_DIV1(tc_port)); 3958 val &= ~(DKL_PLL_DIV1_IREF_TRIM_MASK | 3959 DKL_PLL_DIV1_TDC_TARGET_CNT_MASK); 3960 val |= hw_state->mg_pll_div1; 3961 intel_de_write(dev_priv, DKL_PLL_DIV1(tc_port), val); 3962 3963 val = intel_de_read(dev_priv, DKL_PLL_SSC(tc_port)); 3964 val &= ~(DKL_PLL_SSC_IREF_NDIV_RATIO_MASK | 3965 DKL_PLL_SSC_STEP_LEN_MASK | 3966 DKL_PLL_SSC_STEP_NUM_MASK | 3967 DKL_PLL_SSC_EN); 3968 val |= hw_state->mg_pll_ssc; 3969 intel_de_write(dev_priv, DKL_PLL_SSC(tc_port), val); 3970 3971 val = intel_de_read(dev_priv, DKL_PLL_BIAS(tc_port)); 3972 val &= ~(DKL_PLL_BIAS_FRAC_EN_H | 3973 DKL_PLL_BIAS_FBDIV_FRAC_MASK); 3974 val |= hw_state->mg_pll_bias; 3975 intel_de_write(dev_priv, DKL_PLL_BIAS(tc_port), val); 3976 3977 val = intel_de_read(dev_priv, DKL_PLL_TDC_COLDST_BIAS(tc_port)); 3978 val &= ~(DKL_PLL_TDC_SSC_STEP_SIZE_MASK | 3979 DKL_PLL_TDC_FEED_FWD_GAIN_MASK); 3980 val |= hw_state->mg_pll_tdc_coldst_bias; 3981 intel_de_write(dev_priv, DKL_PLL_TDC_COLDST_BIAS(tc_port), val); 3982 3983 intel_de_posting_read(dev_priv, DKL_PLL_TDC_COLDST_BIAS(tc_port)); 3984 } 3985 3986 static void icl_pll_power_enable(struct drm_i915_private *dev_priv, 3987 struct intel_shared_dpll *pll, 3988 i915_reg_t enable_reg) 3989 { 3990 u32 val; 3991 3992 val = intel_de_read(dev_priv, enable_reg); 3993 val |= PLL_POWER_ENABLE; 3994 intel_de_write(dev_priv, enable_reg, val); 3995 3996 /* 3997 * The spec says we need to "wait" but it also says it should be 3998 * immediate. 3999 */ 4000 if (intel_de_wait_for_set(dev_priv, enable_reg, PLL_POWER_STATE, 1)) 4001 drm_err(&dev_priv->drm, "PLL %d Power not enabled\n", 4002 pll->info->id); 4003 } 4004 4005 static void icl_pll_enable(struct drm_i915_private *dev_priv, 4006 struct intel_shared_dpll *pll, 4007 i915_reg_t enable_reg) 4008 { 4009 u32 val; 4010 4011 val = intel_de_read(dev_priv, enable_reg); 4012 val |= PLL_ENABLE; 4013 intel_de_write(dev_priv, enable_reg, val); 4014 4015 /* Timeout is actually 600us. */ 4016 if (intel_de_wait_for_set(dev_priv, enable_reg, PLL_LOCK, 1)) 4017 drm_err(&dev_priv->drm, "PLL %d not locked\n", pll->info->id); 4018 } 4019 4020 static void combo_pll_enable(struct drm_i915_private *dev_priv, 4021 struct intel_shared_dpll *pll) 4022 { 4023 i915_reg_t enable_reg = CNL_DPLL_ENABLE(pll->info->id); 4024 4025 if (IS_ELKHARTLAKE(dev_priv) && 4026 pll->info->id == DPLL_ID_EHL_DPLL4) { 4027 enable_reg = MG_PLL_ENABLE(0); 4028 4029 /* 4030 * We need to disable DC states when this DPLL is enabled. 4031 * This can be done by taking a reference on DPLL4 power 4032 * domain. 4033 */ 4034 pll->wakeref = intel_display_power_get(dev_priv, 4035 POWER_DOMAIN_DPLL_DC_OFF); 4036 } 4037 4038 icl_pll_power_enable(dev_priv, pll, enable_reg); 4039 4040 icl_dpll_write(dev_priv, pll); 4041 4042 /* 4043 * DVFS pre sequence would be here, but in our driver the cdclk code 4044 * paths should already be setting the appropriate voltage, hence we do 4045 * nothing here. 4046 */ 4047 4048 icl_pll_enable(dev_priv, pll, enable_reg); 4049 4050 /* DVFS post sequence would be here. See the comment above. */ 4051 } 4052 4053 static void tbt_pll_enable(struct drm_i915_private *dev_priv, 4054 struct intel_shared_dpll *pll) 4055 { 4056 icl_pll_power_enable(dev_priv, pll, TBT_PLL_ENABLE); 4057 4058 icl_dpll_write(dev_priv, pll); 4059 4060 /* 4061 * DVFS pre sequence would be here, but in our driver the cdclk code 4062 * paths should already be setting the appropriate voltage, hence we do 4063 * nothing here. 4064 */ 4065 4066 icl_pll_enable(dev_priv, pll, TBT_PLL_ENABLE); 4067 4068 /* DVFS post sequence would be here. See the comment above. */ 4069 } 4070 4071 static void mg_pll_enable(struct drm_i915_private *dev_priv, 4072 struct intel_shared_dpll *pll) 4073 { 4074 i915_reg_t enable_reg = 4075 MG_PLL_ENABLE(icl_pll_id_to_tc_port(pll->info->id)); 4076 4077 icl_pll_power_enable(dev_priv, pll, enable_reg); 4078 4079 if (INTEL_GEN(dev_priv) >= 12) 4080 dkl_pll_write(dev_priv, pll); 4081 else 4082 icl_mg_pll_write(dev_priv, pll); 4083 4084 /* 4085 * DVFS pre sequence would be here, but in our driver the cdclk code 4086 * paths should already be setting the appropriate voltage, hence we do 4087 * nothing here. 4088 */ 4089 4090 icl_pll_enable(dev_priv, pll, enable_reg); 4091 4092 /* DVFS post sequence would be here. See the comment above. */ 4093 } 4094 4095 static void icl_pll_disable(struct drm_i915_private *dev_priv, 4096 struct intel_shared_dpll *pll, 4097 i915_reg_t enable_reg) 4098 { 4099 u32 val; 4100 4101 /* The first steps are done by intel_ddi_post_disable(). */ 4102 4103 /* 4104 * DVFS pre sequence would be here, but in our driver the cdclk code 4105 * paths should already be setting the appropriate voltage, hence we do 4106 * nothign here. 4107 */ 4108 4109 val = intel_de_read(dev_priv, enable_reg); 4110 val &= ~PLL_ENABLE; 4111 intel_de_write(dev_priv, enable_reg, val); 4112 4113 /* Timeout is actually 1us. */ 4114 if (intel_de_wait_for_clear(dev_priv, enable_reg, PLL_LOCK, 1)) 4115 drm_err(&dev_priv->drm, "PLL %d locked\n", pll->info->id); 4116 4117 /* DVFS post sequence would be here. See the comment above. */ 4118 4119 val = intel_de_read(dev_priv, enable_reg); 4120 val &= ~PLL_POWER_ENABLE; 4121 intel_de_write(dev_priv, enable_reg, val); 4122 4123 /* 4124 * The spec says we need to "wait" but it also says it should be 4125 * immediate. 4126 */ 4127 if (intel_de_wait_for_clear(dev_priv, enable_reg, PLL_POWER_STATE, 1)) 4128 drm_err(&dev_priv->drm, "PLL %d Power not disabled\n", 4129 pll->info->id); 4130 } 4131 4132 static void combo_pll_disable(struct drm_i915_private *dev_priv, 4133 struct intel_shared_dpll *pll) 4134 { 4135 i915_reg_t enable_reg = CNL_DPLL_ENABLE(pll->info->id); 4136 4137 if (IS_ELKHARTLAKE(dev_priv) && 4138 pll->info->id == DPLL_ID_EHL_DPLL4) { 4139 enable_reg = MG_PLL_ENABLE(0); 4140 icl_pll_disable(dev_priv, pll, enable_reg); 4141 4142 intel_display_power_put(dev_priv, POWER_DOMAIN_DPLL_DC_OFF, 4143 pll->wakeref); 4144 return; 4145 } 4146 4147 icl_pll_disable(dev_priv, pll, enable_reg); 4148 } 4149 4150 static void tbt_pll_disable(struct drm_i915_private *dev_priv, 4151 struct intel_shared_dpll *pll) 4152 { 4153 icl_pll_disable(dev_priv, pll, TBT_PLL_ENABLE); 4154 } 4155 4156 static void mg_pll_disable(struct drm_i915_private *dev_priv, 4157 struct intel_shared_dpll *pll) 4158 { 4159 i915_reg_t enable_reg = 4160 MG_PLL_ENABLE(icl_pll_id_to_tc_port(pll->info->id)); 4161 4162 icl_pll_disable(dev_priv, pll, enable_reg); 4163 } 4164 4165 static void icl_update_dpll_ref_clks(struct drm_i915_private *i915) 4166 { 4167 /* No SSC ref */ 4168 i915->dpll.ref_clks.nssc = i915->cdclk.hw.ref; 4169 } 4170 4171 static void icl_dump_hw_state(struct drm_i915_private *dev_priv, 4172 const struct intel_dpll_hw_state *hw_state) 4173 { 4174 drm_dbg_kms(&dev_priv->drm, 4175 "dpll_hw_state: cfgcr0: 0x%x, cfgcr1: 0x%x, " 4176 "mg_refclkin_ctl: 0x%x, hg_clktop2_coreclkctl1: 0x%x, " 4177 "mg_clktop2_hsclkctl: 0x%x, mg_pll_div0: 0x%x, " 4178 "mg_pll_div2: 0x%x, mg_pll_lf: 0x%x, " 4179 "mg_pll_frac_lock: 0x%x, mg_pll_ssc: 0x%x, " 4180 "mg_pll_bias: 0x%x, mg_pll_tdc_coldst_bias: 0x%x\n", 4181 hw_state->cfgcr0, hw_state->cfgcr1, 4182 hw_state->mg_refclkin_ctl, 4183 hw_state->mg_clktop2_coreclkctl1, 4184 hw_state->mg_clktop2_hsclkctl, 4185 hw_state->mg_pll_div0, 4186 hw_state->mg_pll_div1, 4187 hw_state->mg_pll_lf, 4188 hw_state->mg_pll_frac_lock, 4189 hw_state->mg_pll_ssc, 4190 hw_state->mg_pll_bias, 4191 hw_state->mg_pll_tdc_coldst_bias); 4192 } 4193 4194 static const struct intel_shared_dpll_funcs combo_pll_funcs = { 4195 .enable = combo_pll_enable, 4196 .disable = combo_pll_disable, 4197 .get_hw_state = combo_pll_get_hw_state, 4198 .get_freq = icl_ddi_combo_pll_get_freq, 4199 }; 4200 4201 static const struct intel_shared_dpll_funcs tbt_pll_funcs = { 4202 .enable = tbt_pll_enable, 4203 .disable = tbt_pll_disable, 4204 .get_hw_state = tbt_pll_get_hw_state, 4205 .get_freq = icl_ddi_tbt_pll_get_freq, 4206 }; 4207 4208 static const struct intel_shared_dpll_funcs mg_pll_funcs = { 4209 .enable = mg_pll_enable, 4210 .disable = mg_pll_disable, 4211 .get_hw_state = mg_pll_get_hw_state, 4212 .get_freq = icl_ddi_mg_pll_get_freq, 4213 }; 4214 4215 static const struct dpll_info icl_plls[] = { 4216 { "DPLL 0", &combo_pll_funcs, DPLL_ID_ICL_DPLL0, 0 }, 4217 { "DPLL 1", &combo_pll_funcs, DPLL_ID_ICL_DPLL1, 0 }, 4218 { "TBT PLL", &tbt_pll_funcs, DPLL_ID_ICL_TBTPLL, 0 }, 4219 { "MG PLL 1", &mg_pll_funcs, DPLL_ID_ICL_MGPLL1, 0 }, 4220 { "MG PLL 2", &mg_pll_funcs, DPLL_ID_ICL_MGPLL2, 0 }, 4221 { "MG PLL 3", &mg_pll_funcs, DPLL_ID_ICL_MGPLL3, 0 }, 4222 { "MG PLL 4", &mg_pll_funcs, DPLL_ID_ICL_MGPLL4, 0 }, 4223 { }, 4224 }; 4225 4226 static const struct intel_dpll_mgr icl_pll_mgr = { 4227 .dpll_info = icl_plls, 4228 .get_dplls = icl_get_dplls, 4229 .put_dplls = icl_put_dplls, 4230 .update_active_dpll = icl_update_active_dpll, 4231 .update_ref_clks = icl_update_dpll_ref_clks, 4232 .dump_hw_state = icl_dump_hw_state, 4233 }; 4234 4235 static const struct dpll_info ehl_plls[] = { 4236 { "DPLL 0", &combo_pll_funcs, DPLL_ID_ICL_DPLL0, 0 }, 4237 { "DPLL 1", &combo_pll_funcs, DPLL_ID_ICL_DPLL1, 0 }, 4238 { "DPLL 4", &combo_pll_funcs, DPLL_ID_EHL_DPLL4, 0 }, 4239 { }, 4240 }; 4241 4242 static const struct intel_dpll_mgr ehl_pll_mgr = { 4243 .dpll_info = ehl_plls, 4244 .get_dplls = icl_get_dplls, 4245 .put_dplls = icl_put_dplls, 4246 .update_ref_clks = icl_update_dpll_ref_clks, 4247 .dump_hw_state = icl_dump_hw_state, 4248 }; 4249 4250 static const struct intel_shared_dpll_funcs dkl_pll_funcs = { 4251 .enable = mg_pll_enable, 4252 .disable = mg_pll_disable, 4253 .get_hw_state = dkl_pll_get_hw_state, 4254 .get_freq = icl_ddi_mg_pll_get_freq, 4255 }; 4256 4257 static const struct dpll_info tgl_plls[] = { 4258 { "DPLL 0", &combo_pll_funcs, DPLL_ID_ICL_DPLL0, 0 }, 4259 { "DPLL 1", &combo_pll_funcs, DPLL_ID_ICL_DPLL1, 0 }, 4260 { "TBT PLL", &tbt_pll_funcs, DPLL_ID_ICL_TBTPLL, 0 }, 4261 { "TC PLL 1", &dkl_pll_funcs, DPLL_ID_ICL_MGPLL1, 0 }, 4262 { "TC PLL 2", &dkl_pll_funcs, DPLL_ID_ICL_MGPLL2, 0 }, 4263 { "TC PLL 3", &dkl_pll_funcs, DPLL_ID_ICL_MGPLL3, 0 }, 4264 { "TC PLL 4", &dkl_pll_funcs, DPLL_ID_ICL_MGPLL4, 0 }, 4265 { "TC PLL 5", &dkl_pll_funcs, DPLL_ID_TGL_MGPLL5, 0 }, 4266 { "TC PLL 6", &dkl_pll_funcs, DPLL_ID_TGL_MGPLL6, 0 }, 4267 { }, 4268 }; 4269 4270 static const struct intel_dpll_mgr tgl_pll_mgr = { 4271 .dpll_info = tgl_plls, 4272 .get_dplls = icl_get_dplls, 4273 .put_dplls = icl_put_dplls, 4274 .update_active_dpll = icl_update_active_dpll, 4275 .update_ref_clks = icl_update_dpll_ref_clks, 4276 .dump_hw_state = icl_dump_hw_state, 4277 }; 4278 4279 /** 4280 * intel_shared_dpll_init - Initialize shared DPLLs 4281 * @dev: drm device 4282 * 4283 * Initialize shared DPLLs for @dev. 4284 */ 4285 void intel_shared_dpll_init(struct drm_device *dev) 4286 { 4287 struct drm_i915_private *dev_priv = to_i915(dev); 4288 const struct intel_dpll_mgr *dpll_mgr = NULL; 4289 const struct dpll_info *dpll_info; 4290 int i; 4291 4292 if (INTEL_GEN(dev_priv) >= 12) 4293 dpll_mgr = &tgl_pll_mgr; 4294 else if (IS_ELKHARTLAKE(dev_priv)) 4295 dpll_mgr = &ehl_pll_mgr; 4296 else if (INTEL_GEN(dev_priv) >= 11) 4297 dpll_mgr = &icl_pll_mgr; 4298 else if (IS_CANNONLAKE(dev_priv)) 4299 dpll_mgr = &cnl_pll_mgr; 4300 else if (IS_GEN9_BC(dev_priv)) 4301 dpll_mgr = &skl_pll_mgr; 4302 else if (IS_GEN9_LP(dev_priv)) 4303 dpll_mgr = &bxt_pll_mgr; 4304 else if (HAS_DDI(dev_priv)) 4305 dpll_mgr = &hsw_pll_mgr; 4306 else if (HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv)) 4307 dpll_mgr = &pch_pll_mgr; 4308 4309 if (!dpll_mgr) { 4310 dev_priv->dpll.num_shared_dpll = 0; 4311 return; 4312 } 4313 4314 dpll_info = dpll_mgr->dpll_info; 4315 4316 for (i = 0; dpll_info[i].name; i++) { 4317 drm_WARN_ON(dev, i != dpll_info[i].id); 4318 dev_priv->dpll.shared_dplls[i].info = &dpll_info[i]; 4319 } 4320 4321 dev_priv->dpll.mgr = dpll_mgr; 4322 dev_priv->dpll.num_shared_dpll = i; 4323 mutex_init(&dev_priv->dpll.lock); 4324 4325 BUG_ON(dev_priv->dpll.num_shared_dpll > I915_NUM_PLLS); 4326 } 4327 4328 /** 4329 * intel_reserve_shared_dplls - reserve DPLLs for CRTC and encoder combination 4330 * @state: atomic state 4331 * @crtc: CRTC to reserve DPLLs for 4332 * @encoder: encoder 4333 * 4334 * This function reserves all required DPLLs for the given CRTC and encoder 4335 * combination in the current atomic commit @state and the new @crtc atomic 4336 * state. 4337 * 4338 * The new configuration in the atomic commit @state is made effective by 4339 * calling intel_shared_dpll_swap_state(). 4340 * 4341 * The reserved DPLLs should be released by calling 4342 * intel_release_shared_dplls(). 4343 * 4344 * Returns: 4345 * True if all required DPLLs were successfully reserved. 4346 */ 4347 bool intel_reserve_shared_dplls(struct intel_atomic_state *state, 4348 struct intel_crtc *crtc, 4349 struct intel_encoder *encoder) 4350 { 4351 struct drm_i915_private *dev_priv = to_i915(state->base.dev); 4352 const struct intel_dpll_mgr *dpll_mgr = dev_priv->dpll.mgr; 4353 4354 if (drm_WARN_ON(&dev_priv->drm, !dpll_mgr)) 4355 return false; 4356 4357 return dpll_mgr->get_dplls(state, crtc, encoder); 4358 } 4359 4360 /** 4361 * intel_release_shared_dplls - end use of DPLLs by CRTC in atomic state 4362 * @state: atomic state 4363 * @crtc: crtc from which the DPLLs are to be released 4364 * 4365 * This function releases all DPLLs reserved by intel_reserve_shared_dplls() 4366 * from the current atomic commit @state and the old @crtc atomic state. 4367 * 4368 * The new configuration in the atomic commit @state is made effective by 4369 * calling intel_shared_dpll_swap_state(). 4370 */ 4371 void intel_release_shared_dplls(struct intel_atomic_state *state, 4372 struct intel_crtc *crtc) 4373 { 4374 struct drm_i915_private *dev_priv = to_i915(state->base.dev); 4375 const struct intel_dpll_mgr *dpll_mgr = dev_priv->dpll.mgr; 4376 4377 /* 4378 * FIXME: this function is called for every platform having a 4379 * compute_clock hook, even though the platform doesn't yet support 4380 * the shared DPLL framework and intel_reserve_shared_dplls() is not 4381 * called on those. 4382 */ 4383 if (!dpll_mgr) 4384 return; 4385 4386 dpll_mgr->put_dplls(state, crtc); 4387 } 4388 4389 /** 4390 * intel_update_active_dpll - update the active DPLL for a CRTC/encoder 4391 * @state: atomic state 4392 * @crtc: the CRTC for which to update the active DPLL 4393 * @encoder: encoder determining the type of port DPLL 4394 * 4395 * Update the active DPLL for the given @crtc/@encoder in @crtc's atomic state, 4396 * from the port DPLLs reserved previously by intel_reserve_shared_dplls(). The 4397 * DPLL selected will be based on the current mode of the encoder's port. 4398 */ 4399 void intel_update_active_dpll(struct intel_atomic_state *state, 4400 struct intel_crtc *crtc, 4401 struct intel_encoder *encoder) 4402 { 4403 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); 4404 const struct intel_dpll_mgr *dpll_mgr = dev_priv->dpll.mgr; 4405 4406 if (drm_WARN_ON(&dev_priv->drm, !dpll_mgr)) 4407 return; 4408 4409 dpll_mgr->update_active_dpll(state, crtc, encoder); 4410 } 4411 4412 /** 4413 * intel_dpll_get_freq - calculate the DPLL's output frequency 4414 * @i915: i915 device 4415 * @pll: DPLL for which to calculate the output frequency 4416 * 4417 * Return the output frequency corresponding to @pll's current state. 4418 */ 4419 int intel_dpll_get_freq(struct drm_i915_private *i915, 4420 const struct intel_shared_dpll *pll) 4421 { 4422 if (drm_WARN_ON(&i915->drm, !pll->info->funcs->get_freq)) 4423 return 0; 4424 4425 return pll->info->funcs->get_freq(i915, pll); 4426 } 4427 4428 static void readout_dpll_hw_state(struct drm_i915_private *i915, 4429 struct intel_shared_dpll *pll) 4430 { 4431 struct intel_crtc *crtc; 4432 4433 pll->on = pll->info->funcs->get_hw_state(i915, pll, 4434 &pll->state.hw_state); 4435 4436 if (IS_ELKHARTLAKE(i915) && pll->on && 4437 pll->info->id == DPLL_ID_EHL_DPLL4) { 4438 pll->wakeref = intel_display_power_get(i915, 4439 POWER_DOMAIN_DPLL_DC_OFF); 4440 } 4441 4442 pll->state.crtc_mask = 0; 4443 for_each_intel_crtc(&i915->drm, crtc) { 4444 struct intel_crtc_state *crtc_state = 4445 to_intel_crtc_state(crtc->base.state); 4446 4447 if (crtc_state->hw.active && crtc_state->shared_dpll == pll) 4448 pll->state.crtc_mask |= 1 << crtc->pipe; 4449 } 4450 pll->active_mask = pll->state.crtc_mask; 4451 4452 drm_dbg_kms(&i915->drm, 4453 "%s hw state readout: crtc_mask 0x%08x, on %i\n", 4454 pll->info->name, pll->state.crtc_mask, pll->on); 4455 } 4456 4457 void intel_dpll_readout_hw_state(struct drm_i915_private *i915) 4458 { 4459 int i; 4460 4461 if (i915->dpll.mgr && i915->dpll.mgr->update_ref_clks) 4462 i915->dpll.mgr->update_ref_clks(i915); 4463 4464 for (i = 0; i < i915->dpll.num_shared_dpll; i++) 4465 readout_dpll_hw_state(i915, &i915->dpll.shared_dplls[i]); 4466 } 4467 4468 static void sanitize_dpll_state(struct drm_i915_private *i915, 4469 struct intel_shared_dpll *pll) 4470 { 4471 if (!pll->on || pll->active_mask) 4472 return; 4473 4474 drm_dbg_kms(&i915->drm, 4475 "%s enabled but not in use, disabling\n", 4476 pll->info->name); 4477 4478 pll->info->funcs->disable(i915, pll); 4479 pll->on = false; 4480 } 4481 4482 void intel_dpll_sanitize_state(struct drm_i915_private *i915) 4483 { 4484 int i; 4485 4486 for (i = 0; i < i915->dpll.num_shared_dpll; i++) 4487 sanitize_dpll_state(i915, &i915->dpll.shared_dplls[i]); 4488 } 4489 4490 /** 4491 * intel_shared_dpll_dump_hw_state - write hw_state to dmesg 4492 * @dev_priv: i915 drm device 4493 * @hw_state: hw state to be written to the log 4494 * 4495 * Write the relevant values in @hw_state to dmesg using drm_dbg_kms. 4496 */ 4497 void intel_dpll_dump_hw_state(struct drm_i915_private *dev_priv, 4498 const struct intel_dpll_hw_state *hw_state) 4499 { 4500 if (dev_priv->dpll.mgr) { 4501 dev_priv->dpll.mgr->dump_hw_state(dev_priv, hw_state); 4502 } else { 4503 /* fallback for platforms that don't use the shared dpll 4504 * infrastructure 4505 */ 4506 drm_dbg_kms(&dev_priv->drm, 4507 "dpll_hw_state: dpll: 0x%x, dpll_md: 0x%x, " 4508 "fp0: 0x%x, fp1: 0x%x\n", 4509 hw_state->dpll, 4510 hw_state->dpll_md, 4511 hw_state->fp0, 4512 hw_state->fp1); 4513 } 4514 } 4515