1 /* 2 * Copyright © 2006-2010 Intel Corporation 3 * Copyright (c) 2006 Dave Airlie <airlied@linux.ie> 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 * 24 * Authors: 25 * Eric Anholt <eric@anholt.net> 26 * Dave Airlie <airlied@linux.ie> 27 * Jesse Barnes <jesse.barnes@intel.com> 28 * Chris Wilson <chris@chris-wilson.co.uk> 29 */ 30 31 #include <linux/kernel.h> 32 #include <linux/pwm.h> 33 34 #include "intel_backlight.h" 35 #include "intel_connector.h" 36 #include "intel_de.h" 37 #include "intel_display_types.h" 38 #include "intel_drrs.h" 39 #include "intel_panel.h" 40 41 bool intel_panel_use_ssc(struct drm_i915_private *i915) 42 { 43 if (i915->params.panel_use_ssc >= 0) 44 return i915->params.panel_use_ssc != 0; 45 return i915->vbt.lvds_use_ssc 46 && !(i915->quirks & QUIRK_LVDS_SSC_DISABLE); 47 } 48 49 const struct drm_display_mode * 50 intel_panel_preferred_fixed_mode(struct intel_connector *connector) 51 { 52 return list_first_entry_or_null(&connector->panel.fixed_modes, 53 struct drm_display_mode, head); 54 } 55 56 const struct drm_display_mode * 57 intel_panel_fixed_mode(struct intel_connector *connector, 58 const struct drm_display_mode *mode) 59 { 60 const struct drm_display_mode *fixed_mode, *best_mode = NULL; 61 int vrefresh = drm_mode_vrefresh(mode); 62 63 /* pick the fixed_mode that is closest in terms of vrefresh */ 64 list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) { 65 if (!best_mode || 66 abs(drm_mode_vrefresh(fixed_mode) - vrefresh) < 67 abs(drm_mode_vrefresh(best_mode) - vrefresh)) 68 best_mode = fixed_mode; 69 } 70 71 return best_mode; 72 } 73 74 static bool is_alt_drrs_mode(const struct drm_display_mode *mode, 75 const struct drm_display_mode *preferred_mode) 76 { 77 return drm_mode_match(mode, preferred_mode, 78 DRM_MODE_MATCH_TIMINGS | 79 DRM_MODE_MATCH_FLAGS | 80 DRM_MODE_MATCH_3D_FLAGS) && 81 mode->clock != preferred_mode->clock; 82 } 83 84 static bool is_alt_vrr_mode(const struct drm_display_mode *mode, 85 const struct drm_display_mode *preferred_mode) 86 { 87 return drm_mode_match(mode, preferred_mode, 88 DRM_MODE_MATCH_FLAGS | 89 DRM_MODE_MATCH_3D_FLAGS) && 90 mode->hdisplay == preferred_mode->hdisplay && 91 mode->vdisplay == preferred_mode->vdisplay && 92 mode->clock != preferred_mode->clock; 93 } 94 95 const struct drm_display_mode * 96 intel_panel_downclock_mode(struct intel_connector *connector, 97 const struct drm_display_mode *adjusted_mode) 98 { 99 const struct drm_display_mode *fixed_mode, *best_mode = NULL; 100 int min_vrefresh = connector->panel.vbt.seamless_drrs_min_refresh_rate; 101 int max_vrefresh = drm_mode_vrefresh(adjusted_mode); 102 103 /* pick the fixed_mode with the lowest refresh rate */ 104 list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) { 105 int vrefresh = drm_mode_vrefresh(fixed_mode); 106 107 if (is_alt_drrs_mode(fixed_mode, adjusted_mode) && 108 vrefresh >= min_vrefresh && vrefresh < max_vrefresh) { 109 max_vrefresh = vrefresh; 110 best_mode = fixed_mode; 111 } 112 } 113 114 return best_mode; 115 } 116 117 int intel_panel_get_modes(struct intel_connector *connector) 118 { 119 const struct drm_display_mode *fixed_mode; 120 int num_modes = 0; 121 122 list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) { 123 struct drm_display_mode *mode; 124 125 mode = drm_mode_duplicate(connector->base.dev, fixed_mode); 126 if (mode) { 127 drm_mode_probed_add(&connector->base, mode); 128 num_modes++; 129 } 130 } 131 132 return num_modes; 133 } 134 135 enum drrs_type intel_panel_drrs_type(struct intel_connector *connector) 136 { 137 if (list_empty(&connector->panel.fixed_modes) || 138 list_is_singular(&connector->panel.fixed_modes)) 139 return DRRS_TYPE_NONE; 140 141 return connector->panel.vbt.drrs_type; 142 } 143 144 int intel_panel_compute_config(struct intel_connector *connector, 145 struct drm_display_mode *adjusted_mode) 146 { 147 const struct drm_display_mode *fixed_mode = 148 intel_panel_fixed_mode(connector, adjusted_mode); 149 150 if (!fixed_mode) 151 return 0; 152 153 /* 154 * We don't want to lie too much to the user about the refresh 155 * rate they're going to get. But we have to allow a bit of latitude 156 * for Xorg since it likes to automagically cook up modes with slightly 157 * off refresh rates. 158 */ 159 if (abs(drm_mode_vrefresh(adjusted_mode) - drm_mode_vrefresh(fixed_mode)) > 1) { 160 drm_dbg_kms(connector->base.dev, 161 "[CONNECTOR:%d:%s] Requested mode vrefresh (%d Hz) does not match fixed mode vrefresh (%d Hz)\n", 162 connector->base.base.id, connector->base.name, 163 drm_mode_vrefresh(adjusted_mode), drm_mode_vrefresh(fixed_mode)); 164 165 return -EINVAL; 166 } 167 168 drm_mode_copy(adjusted_mode, fixed_mode); 169 170 drm_mode_set_crtcinfo(adjusted_mode, 0); 171 172 return 0; 173 } 174 175 static bool is_alt_fixed_mode(const struct drm_display_mode *mode, 176 const struct drm_display_mode *preferred_mode, 177 bool has_vrr) 178 { 179 /* is_alt_drrs_mode() is a subset of is_alt_vrr_mode() */ 180 if (has_vrr) 181 return is_alt_vrr_mode(mode, preferred_mode); 182 else 183 return is_alt_drrs_mode(mode, preferred_mode); 184 } 185 186 static void intel_panel_add_edid_alt_fixed_modes(struct intel_connector *connector, 187 bool has_vrr) 188 { 189 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 190 const struct drm_display_mode *preferred_mode = 191 intel_panel_preferred_fixed_mode(connector); 192 struct drm_display_mode *mode, *next; 193 194 list_for_each_entry_safe(mode, next, &connector->base.probed_modes, head) { 195 if (!is_alt_fixed_mode(mode, preferred_mode, has_vrr)) 196 continue; 197 198 drm_dbg_kms(&dev_priv->drm, 199 "[CONNECTOR:%d:%s] using alternate EDID fixed mode: " DRM_MODE_FMT "\n", 200 connector->base.base.id, connector->base.name, 201 DRM_MODE_ARG(mode)); 202 203 list_move_tail(&mode->head, &connector->panel.fixed_modes); 204 } 205 } 206 207 static void intel_panel_add_edid_preferred_mode(struct intel_connector *connector) 208 { 209 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 210 struct drm_display_mode *scan, *fixed_mode = NULL; 211 212 if (list_empty(&connector->base.probed_modes)) 213 return; 214 215 /* make sure the preferred mode is first */ 216 list_for_each_entry(scan, &connector->base.probed_modes, head) { 217 if (scan->type & DRM_MODE_TYPE_PREFERRED) { 218 fixed_mode = scan; 219 break; 220 } 221 } 222 223 if (!fixed_mode) 224 fixed_mode = list_first_entry(&connector->base.probed_modes, 225 typeof(*fixed_mode), head); 226 227 drm_dbg_kms(&dev_priv->drm, 228 "[CONNECTOR:%d:%s] using %s EDID fixed mode: " DRM_MODE_FMT "\n", 229 connector->base.base.id, connector->base.name, 230 fixed_mode->type & DRM_MODE_TYPE_PREFERRED ? "preferred" : "first", 231 DRM_MODE_ARG(fixed_mode)); 232 233 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED; 234 235 list_move_tail(&fixed_mode->head, &connector->panel.fixed_modes); 236 } 237 238 static void intel_panel_destroy_probed_modes(struct intel_connector *connector) 239 { 240 struct drm_i915_private *i915 = to_i915(connector->base.dev); 241 struct drm_display_mode *mode, *next; 242 243 list_for_each_entry_safe(mode, next, &connector->base.probed_modes, head) { 244 drm_dbg_kms(&i915->drm, 245 "[CONNECTOR:%d:%s] not using EDID mode: " DRM_MODE_FMT "\n", 246 connector->base.base.id, connector->base.name, 247 DRM_MODE_ARG(mode)); 248 list_del(&mode->head); 249 drm_mode_destroy(&i915->drm, mode); 250 } 251 } 252 253 void intel_panel_add_edid_fixed_modes(struct intel_connector *connector, 254 bool has_drrs, bool has_vrr) 255 { 256 intel_panel_add_edid_preferred_mode(connector); 257 if (intel_panel_preferred_fixed_mode(connector) && (has_drrs || has_vrr)) 258 intel_panel_add_edid_alt_fixed_modes(connector, has_vrr); 259 intel_panel_destroy_probed_modes(connector); 260 } 261 262 static void intel_panel_add_fixed_mode(struct intel_connector *connector, 263 struct drm_display_mode *fixed_mode, 264 const char *type) 265 { 266 struct drm_i915_private *i915 = to_i915(connector->base.dev); 267 struct drm_display_info *info = &connector->base.display_info; 268 269 if (!fixed_mode) 270 return; 271 272 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER; 273 274 info->width_mm = fixed_mode->width_mm; 275 info->height_mm = fixed_mode->height_mm; 276 277 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] using %s fixed mode: " DRM_MODE_FMT "\n", 278 connector->base.base.id, connector->base.name, type, 279 DRM_MODE_ARG(fixed_mode)); 280 281 list_add_tail(&fixed_mode->head, &connector->panel.fixed_modes); 282 } 283 284 void intel_panel_add_vbt_lfp_fixed_mode(struct intel_connector *connector) 285 { 286 struct drm_i915_private *i915 = to_i915(connector->base.dev); 287 const struct drm_display_mode *mode; 288 289 mode = connector->panel.vbt.lfp_lvds_vbt_mode; 290 if (!mode) 291 return; 292 293 intel_panel_add_fixed_mode(connector, 294 drm_mode_duplicate(&i915->drm, mode), 295 "VBT LFP"); 296 } 297 298 void intel_panel_add_vbt_sdvo_fixed_mode(struct intel_connector *connector) 299 { 300 struct drm_i915_private *i915 = to_i915(connector->base.dev); 301 const struct drm_display_mode *mode; 302 303 mode = connector->panel.vbt.sdvo_lvds_vbt_mode; 304 if (!mode) 305 return; 306 307 intel_panel_add_fixed_mode(connector, 308 drm_mode_duplicate(&i915->drm, mode), 309 "VBT SDVO"); 310 } 311 312 void intel_panel_add_encoder_fixed_mode(struct intel_connector *connector, 313 struct intel_encoder *encoder) 314 { 315 intel_panel_add_fixed_mode(connector, 316 intel_encoder_current_mode(encoder), 317 "current (BIOS)"); 318 } 319 320 /* adjusted_mode has been preset to be the panel's fixed mode */ 321 static int pch_panel_fitting(struct intel_crtc_state *crtc_state, 322 const struct drm_connector_state *conn_state) 323 { 324 const struct drm_display_mode *adjusted_mode = 325 &crtc_state->hw.adjusted_mode; 326 int pipe_src_w = drm_rect_width(&crtc_state->pipe_src); 327 int pipe_src_h = drm_rect_height(&crtc_state->pipe_src); 328 int x, y, width, height; 329 330 /* Native modes don't need fitting */ 331 if (adjusted_mode->crtc_hdisplay == pipe_src_w && 332 adjusted_mode->crtc_vdisplay == pipe_src_h && 333 crtc_state->output_format != INTEL_OUTPUT_FORMAT_YCBCR420) 334 return 0; 335 336 switch (conn_state->scaling_mode) { 337 case DRM_MODE_SCALE_CENTER: 338 width = pipe_src_w; 339 height = pipe_src_h; 340 x = (adjusted_mode->crtc_hdisplay - width + 1)/2; 341 y = (adjusted_mode->crtc_vdisplay - height + 1)/2; 342 break; 343 344 case DRM_MODE_SCALE_ASPECT: 345 /* Scale but preserve the aspect ratio */ 346 { 347 u32 scaled_width = adjusted_mode->crtc_hdisplay * pipe_src_h; 348 u32 scaled_height = pipe_src_w * adjusted_mode->crtc_vdisplay; 349 if (scaled_width > scaled_height) { /* pillar */ 350 width = scaled_height / pipe_src_h; 351 if (width & 1) 352 width++; 353 x = (adjusted_mode->crtc_hdisplay - width + 1) / 2; 354 y = 0; 355 height = adjusted_mode->crtc_vdisplay; 356 } else if (scaled_width < scaled_height) { /* letter */ 357 height = scaled_width / pipe_src_w; 358 if (height & 1) 359 height++; 360 y = (adjusted_mode->crtc_vdisplay - height + 1) / 2; 361 x = 0; 362 width = adjusted_mode->crtc_hdisplay; 363 } else { 364 x = y = 0; 365 width = adjusted_mode->crtc_hdisplay; 366 height = adjusted_mode->crtc_vdisplay; 367 } 368 } 369 break; 370 371 case DRM_MODE_SCALE_NONE: 372 WARN_ON(adjusted_mode->crtc_hdisplay != pipe_src_w); 373 WARN_ON(adjusted_mode->crtc_vdisplay != pipe_src_h); 374 fallthrough; 375 case DRM_MODE_SCALE_FULLSCREEN: 376 x = y = 0; 377 width = adjusted_mode->crtc_hdisplay; 378 height = adjusted_mode->crtc_vdisplay; 379 break; 380 381 default: 382 MISSING_CASE(conn_state->scaling_mode); 383 return -EINVAL; 384 } 385 386 drm_rect_init(&crtc_state->pch_pfit.dst, 387 x, y, width, height); 388 crtc_state->pch_pfit.enabled = true; 389 390 return 0; 391 } 392 393 static void 394 centre_horizontally(struct drm_display_mode *adjusted_mode, 395 int width) 396 { 397 u32 border, sync_pos, blank_width, sync_width; 398 399 /* keep the hsync and hblank widths constant */ 400 sync_width = adjusted_mode->crtc_hsync_end - adjusted_mode->crtc_hsync_start; 401 blank_width = adjusted_mode->crtc_hblank_end - adjusted_mode->crtc_hblank_start; 402 sync_pos = (blank_width - sync_width + 1) / 2; 403 404 border = (adjusted_mode->crtc_hdisplay - width + 1) / 2; 405 border += border & 1; /* make the border even */ 406 407 adjusted_mode->crtc_hdisplay = width; 408 adjusted_mode->crtc_hblank_start = width + border; 409 adjusted_mode->crtc_hblank_end = adjusted_mode->crtc_hblank_start + blank_width; 410 411 adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hblank_start + sync_pos; 412 adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_start + sync_width; 413 } 414 415 static void 416 centre_vertically(struct drm_display_mode *adjusted_mode, 417 int height) 418 { 419 u32 border, sync_pos, blank_width, sync_width; 420 421 /* keep the vsync and vblank widths constant */ 422 sync_width = adjusted_mode->crtc_vsync_end - adjusted_mode->crtc_vsync_start; 423 blank_width = adjusted_mode->crtc_vblank_end - adjusted_mode->crtc_vblank_start; 424 sync_pos = (blank_width - sync_width + 1) / 2; 425 426 border = (adjusted_mode->crtc_vdisplay - height + 1) / 2; 427 428 adjusted_mode->crtc_vdisplay = height; 429 adjusted_mode->crtc_vblank_start = height + border; 430 adjusted_mode->crtc_vblank_end = adjusted_mode->crtc_vblank_start + blank_width; 431 432 adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vblank_start + sync_pos; 433 adjusted_mode->crtc_vsync_end = adjusted_mode->crtc_vsync_start + sync_width; 434 } 435 436 static u32 panel_fitter_scaling(u32 source, u32 target) 437 { 438 /* 439 * Floating point operation is not supported. So the FACTOR 440 * is defined, which can avoid the floating point computation 441 * when calculating the panel ratio. 442 */ 443 #define ACCURACY 12 444 #define FACTOR (1 << ACCURACY) 445 u32 ratio = source * FACTOR / target; 446 return (FACTOR * ratio + FACTOR/2) / FACTOR; 447 } 448 449 static void i965_scale_aspect(struct intel_crtc_state *crtc_state, 450 u32 *pfit_control) 451 { 452 const struct drm_display_mode *adjusted_mode = 453 &crtc_state->hw.adjusted_mode; 454 int pipe_src_w = drm_rect_width(&crtc_state->pipe_src); 455 int pipe_src_h = drm_rect_height(&crtc_state->pipe_src); 456 u32 scaled_width = adjusted_mode->crtc_hdisplay * pipe_src_h; 457 u32 scaled_height = pipe_src_w * adjusted_mode->crtc_vdisplay; 458 459 /* 965+ is easy, it does everything in hw */ 460 if (scaled_width > scaled_height) 461 *pfit_control |= PFIT_ENABLE | 462 PFIT_SCALING_PILLAR; 463 else if (scaled_width < scaled_height) 464 *pfit_control |= PFIT_ENABLE | 465 PFIT_SCALING_LETTER; 466 else if (adjusted_mode->crtc_hdisplay != pipe_src_w) 467 *pfit_control |= PFIT_ENABLE | PFIT_SCALING_AUTO; 468 } 469 470 static void i9xx_scale_aspect(struct intel_crtc_state *crtc_state, 471 u32 *pfit_control, u32 *pfit_pgm_ratios, 472 u32 *border) 473 { 474 struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode; 475 int pipe_src_w = drm_rect_width(&crtc_state->pipe_src); 476 int pipe_src_h = drm_rect_height(&crtc_state->pipe_src); 477 u32 scaled_width = adjusted_mode->crtc_hdisplay * pipe_src_h; 478 u32 scaled_height = pipe_src_w * adjusted_mode->crtc_vdisplay; 479 u32 bits; 480 481 /* 482 * For earlier chips we have to calculate the scaling 483 * ratio by hand and program it into the 484 * PFIT_PGM_RATIO register 485 */ 486 if (scaled_width > scaled_height) { /* pillar */ 487 centre_horizontally(adjusted_mode, 488 scaled_height / pipe_src_h); 489 490 *border = LVDS_BORDER_ENABLE; 491 if (pipe_src_h != adjusted_mode->crtc_vdisplay) { 492 bits = panel_fitter_scaling(pipe_src_h, 493 adjusted_mode->crtc_vdisplay); 494 495 *pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT | 496 bits << PFIT_VERT_SCALE_SHIFT); 497 *pfit_control |= (PFIT_ENABLE | 498 VERT_INTERP_BILINEAR | 499 HORIZ_INTERP_BILINEAR); 500 } 501 } else if (scaled_width < scaled_height) { /* letter */ 502 centre_vertically(adjusted_mode, 503 scaled_width / pipe_src_w); 504 505 *border = LVDS_BORDER_ENABLE; 506 if (pipe_src_w != adjusted_mode->crtc_hdisplay) { 507 bits = panel_fitter_scaling(pipe_src_w, 508 adjusted_mode->crtc_hdisplay); 509 510 *pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT | 511 bits << PFIT_VERT_SCALE_SHIFT); 512 *pfit_control |= (PFIT_ENABLE | 513 VERT_INTERP_BILINEAR | 514 HORIZ_INTERP_BILINEAR); 515 } 516 } else { 517 /* Aspects match, Let hw scale both directions */ 518 *pfit_control |= (PFIT_ENABLE | 519 VERT_AUTO_SCALE | HORIZ_AUTO_SCALE | 520 VERT_INTERP_BILINEAR | 521 HORIZ_INTERP_BILINEAR); 522 } 523 } 524 525 static int gmch_panel_fitting(struct intel_crtc_state *crtc_state, 526 const struct drm_connector_state *conn_state) 527 { 528 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 529 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); 530 u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0; 531 struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode; 532 int pipe_src_w = drm_rect_width(&crtc_state->pipe_src); 533 int pipe_src_h = drm_rect_height(&crtc_state->pipe_src); 534 535 /* Native modes don't need fitting */ 536 if (adjusted_mode->crtc_hdisplay == pipe_src_w && 537 adjusted_mode->crtc_vdisplay == pipe_src_h) 538 goto out; 539 540 switch (conn_state->scaling_mode) { 541 case DRM_MODE_SCALE_CENTER: 542 /* 543 * For centered modes, we have to calculate border widths & 544 * heights and modify the values programmed into the CRTC. 545 */ 546 centre_horizontally(adjusted_mode, pipe_src_w); 547 centre_vertically(adjusted_mode, pipe_src_h); 548 border = LVDS_BORDER_ENABLE; 549 break; 550 case DRM_MODE_SCALE_ASPECT: 551 /* Scale but preserve the aspect ratio */ 552 if (DISPLAY_VER(dev_priv) >= 4) 553 i965_scale_aspect(crtc_state, &pfit_control); 554 else 555 i9xx_scale_aspect(crtc_state, &pfit_control, 556 &pfit_pgm_ratios, &border); 557 break; 558 case DRM_MODE_SCALE_FULLSCREEN: 559 /* 560 * Full scaling, even if it changes the aspect ratio. 561 * Fortunately this is all done for us in hw. 562 */ 563 if (pipe_src_h != adjusted_mode->crtc_vdisplay || 564 pipe_src_w != adjusted_mode->crtc_hdisplay) { 565 pfit_control |= PFIT_ENABLE; 566 if (DISPLAY_VER(dev_priv) >= 4) 567 pfit_control |= PFIT_SCALING_AUTO; 568 else 569 pfit_control |= (VERT_AUTO_SCALE | 570 VERT_INTERP_BILINEAR | 571 HORIZ_AUTO_SCALE | 572 HORIZ_INTERP_BILINEAR); 573 } 574 break; 575 default: 576 MISSING_CASE(conn_state->scaling_mode); 577 return -EINVAL; 578 } 579 580 /* 965+ wants fuzzy fitting */ 581 /* FIXME: handle multiple panels by failing gracefully */ 582 if (DISPLAY_VER(dev_priv) >= 4) 583 pfit_control |= PFIT_PIPE(crtc->pipe) | PFIT_FILTER_FUZZY; 584 585 out: 586 if ((pfit_control & PFIT_ENABLE) == 0) { 587 pfit_control = 0; 588 pfit_pgm_ratios = 0; 589 } 590 591 /* Make sure pre-965 set dither correctly for 18bpp panels. */ 592 if (DISPLAY_VER(dev_priv) < 4 && crtc_state->pipe_bpp == 18) 593 pfit_control |= PANEL_8TO6_DITHER_ENABLE; 594 595 crtc_state->gmch_pfit.control = pfit_control; 596 crtc_state->gmch_pfit.pgm_ratios = pfit_pgm_ratios; 597 crtc_state->gmch_pfit.lvds_border_bits = border; 598 599 return 0; 600 } 601 602 int intel_panel_fitting(struct intel_crtc_state *crtc_state, 603 const struct drm_connector_state *conn_state) 604 { 605 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc); 606 struct drm_i915_private *i915 = to_i915(crtc->base.dev); 607 608 if (HAS_GMCH(i915)) 609 return gmch_panel_fitting(crtc_state, conn_state); 610 else 611 return pch_panel_fitting(crtc_state, conn_state); 612 } 613 614 enum drm_connector_status 615 intel_panel_detect(struct drm_connector *connector, bool force) 616 { 617 struct drm_i915_private *i915 = to_i915(connector->dev); 618 619 if (!INTEL_DISPLAY_ENABLED(i915)) 620 return connector_status_disconnected; 621 622 return connector_status_connected; 623 } 624 625 enum drm_mode_status 626 intel_panel_mode_valid(struct intel_connector *connector, 627 const struct drm_display_mode *mode) 628 { 629 const struct drm_display_mode *fixed_mode = 630 intel_panel_fixed_mode(connector, mode); 631 632 if (!fixed_mode) 633 return MODE_OK; 634 635 if (mode->hdisplay != fixed_mode->hdisplay) 636 return MODE_PANEL; 637 638 if (mode->vdisplay != fixed_mode->vdisplay) 639 return MODE_PANEL; 640 641 if (drm_mode_vrefresh(mode) != drm_mode_vrefresh(fixed_mode)) 642 return MODE_PANEL; 643 644 return MODE_OK; 645 } 646 647 int intel_panel_init(struct intel_connector *connector) 648 { 649 struct intel_panel *panel = &connector->panel; 650 651 intel_backlight_init_funcs(panel); 652 653 drm_dbg_kms(connector->base.dev, 654 "[CONNECTOR:%d:%s] DRRS type: %s\n", 655 connector->base.base.id, connector->base.name, 656 intel_drrs_type_str(intel_panel_drrs_type(connector))); 657 658 return 0; 659 } 660 661 void intel_panel_fini(struct intel_connector *connector) 662 { 663 struct intel_panel *panel = &connector->panel; 664 struct drm_display_mode *fixed_mode, *next; 665 666 intel_backlight_destroy(panel); 667 668 intel_bios_fini_panel(panel); 669 670 list_for_each_entry_safe(fixed_mode, next, &panel->fixed_modes, head) { 671 list_del(&fixed_mode->head); 672 drm_mode_destroy(connector->base.dev, fixed_mode); 673 } 674 } 675