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 <drm/drm_edid.h> 35 36 #include "i915_drv.h" 37 #include "intel_backlight.h" 38 #include "intel_connector.h" 39 #include "intel_display_core.h" 40 #include "intel_display_driver.h" 41 #include "intel_display_types.h" 42 #include "intel_drrs.h" 43 #include "intel_panel.h" 44 #include "intel_quirks.h" 45 #include "intel_vrr.h" 46 47 bool intel_panel_use_ssc(struct intel_display *display) 48 { 49 if (display->params.panel_use_ssc >= 0) 50 return display->params.panel_use_ssc != 0; 51 return display->vbt.lvds_use_ssc && 52 !intel_has_quirk(display, QUIRK_LVDS_SSC_DISABLE); 53 } 54 55 const struct drm_display_mode * 56 intel_panel_preferred_fixed_mode(struct intel_connector *connector) 57 { 58 return list_first_entry_or_null(&connector->panel.fixed_modes, 59 struct drm_display_mode, head); 60 } 61 62 static bool is_best_fixed_mode(struct intel_connector *connector, 63 int vrefresh, int fixed_mode_vrefresh, 64 const struct drm_display_mode *best_mode) 65 { 66 /* we want to always return something */ 67 if (!best_mode) 68 return true; 69 70 /* 71 * With VRR always pick a mode with equal/higher than requested 72 * vrefresh, which we can then reduce to match the requested 73 * vrefresh by extending the vblank length. 74 */ 75 if (intel_vrr_is_in_range(connector, vrefresh) && 76 intel_vrr_is_in_range(connector, fixed_mode_vrefresh) && 77 fixed_mode_vrefresh < vrefresh) 78 return false; 79 80 /* pick the fixed_mode that is closest in terms of vrefresh */ 81 return abs(fixed_mode_vrefresh - vrefresh) < 82 abs(drm_mode_vrefresh(best_mode) - vrefresh); 83 } 84 85 const struct drm_display_mode * 86 intel_panel_fixed_mode(struct intel_connector *connector, 87 const struct drm_display_mode *mode) 88 { 89 const struct drm_display_mode *fixed_mode, *best_mode = NULL; 90 int vrefresh = drm_mode_vrefresh(mode); 91 92 list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) { 93 int fixed_mode_vrefresh = drm_mode_vrefresh(fixed_mode); 94 95 if (is_best_fixed_mode(connector, vrefresh, 96 fixed_mode_vrefresh, best_mode)) 97 best_mode = fixed_mode; 98 } 99 100 return best_mode; 101 } 102 103 static bool is_alt_drrs_mode(const struct drm_display_mode *mode, 104 const struct drm_display_mode *preferred_mode) 105 { 106 return drm_mode_match(mode, preferred_mode, 107 DRM_MODE_MATCH_TIMINGS | 108 DRM_MODE_MATCH_FLAGS | 109 DRM_MODE_MATCH_3D_FLAGS) && 110 mode->clock != preferred_mode->clock; 111 } 112 113 static bool is_alt_fixed_mode(const struct drm_display_mode *mode, 114 const struct drm_display_mode *preferred_mode) 115 { 116 u32 sync_flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NHSYNC | 117 DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_NVSYNC; 118 119 return (mode->flags & ~sync_flags) == (preferred_mode->flags & ~sync_flags) && 120 mode->hdisplay == preferred_mode->hdisplay && 121 mode->vdisplay == preferred_mode->vdisplay; 122 } 123 124 const struct drm_display_mode * 125 intel_panel_downclock_mode(struct intel_connector *connector, 126 const struct drm_display_mode *adjusted_mode) 127 { 128 const struct drm_display_mode *fixed_mode, *best_mode = NULL; 129 int min_vrefresh = connector->panel.vbt.seamless_drrs_min_refresh_rate; 130 int max_vrefresh = drm_mode_vrefresh(adjusted_mode); 131 132 /* pick the fixed_mode with the lowest refresh rate */ 133 list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) { 134 int vrefresh = drm_mode_vrefresh(fixed_mode); 135 136 if (is_alt_drrs_mode(fixed_mode, adjusted_mode) && 137 vrefresh >= min_vrefresh && vrefresh < max_vrefresh) { 138 max_vrefresh = vrefresh; 139 best_mode = fixed_mode; 140 } 141 } 142 143 return best_mode; 144 } 145 146 const struct drm_display_mode * 147 intel_panel_highest_mode(struct intel_connector *connector, 148 const struct drm_display_mode *adjusted_mode) 149 { 150 const struct drm_display_mode *fixed_mode, *best_mode = adjusted_mode; 151 152 /* pick the fixed_mode that has the highest clock */ 153 list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) { 154 if (fixed_mode->clock > best_mode->clock) 155 best_mode = fixed_mode; 156 } 157 158 return best_mode; 159 } 160 161 int intel_panel_get_modes(struct intel_connector *connector) 162 { 163 const struct drm_display_mode *fixed_mode; 164 int num_modes = 0; 165 166 list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) { 167 struct drm_display_mode *mode; 168 169 mode = drm_mode_duplicate(connector->base.dev, fixed_mode); 170 if (mode) { 171 drm_mode_probed_add(&connector->base, mode); 172 num_modes++; 173 } 174 } 175 176 return num_modes; 177 } 178 179 static bool has_drrs_modes(struct intel_connector *connector) 180 { 181 const struct drm_display_mode *mode1; 182 183 list_for_each_entry(mode1, &connector->panel.fixed_modes, head) { 184 const struct drm_display_mode *mode2 = mode1; 185 186 list_for_each_entry_continue(mode2, &connector->panel.fixed_modes, head) { 187 if (is_alt_drrs_mode(mode1, mode2)) 188 return true; 189 } 190 } 191 192 return false; 193 } 194 195 enum drrs_type intel_panel_drrs_type(struct intel_connector *connector) 196 { 197 return connector->panel.vbt.drrs_type; 198 } 199 200 int intel_panel_compute_config(struct intel_connector *connector, 201 struct drm_display_mode *adjusted_mode) 202 { 203 const struct drm_display_mode *fixed_mode = 204 intel_panel_fixed_mode(connector, adjusted_mode); 205 int vrefresh, fixed_mode_vrefresh; 206 bool is_vrr; 207 208 if (!fixed_mode) 209 return 0; 210 211 vrefresh = drm_mode_vrefresh(adjusted_mode); 212 fixed_mode_vrefresh = drm_mode_vrefresh(fixed_mode); 213 214 /* 215 * Assume that we shouldn't muck about with the 216 * timings if they don't land in the VRR range. 217 */ 218 is_vrr = intel_vrr_is_in_range(connector, vrefresh) && 219 intel_vrr_is_in_range(connector, fixed_mode_vrefresh); 220 221 if (!is_vrr) { 222 /* 223 * We don't want to lie too much to the user about the refresh 224 * rate they're going to get. But we have to allow a bit of latitude 225 * for Xorg since it likes to automagically cook up modes with slightly 226 * off refresh rates. 227 */ 228 if (abs(vrefresh - fixed_mode_vrefresh) > 1) { 229 drm_dbg_kms(connector->base.dev, 230 "[CONNECTOR:%d:%s] Requested mode vrefresh (%d Hz) does not match fixed mode vrefresh (%d Hz)\n", 231 connector->base.base.id, connector->base.name, 232 vrefresh, fixed_mode_vrefresh); 233 234 return -EINVAL; 235 } 236 } 237 238 drm_mode_copy(adjusted_mode, fixed_mode); 239 240 if (is_vrr && fixed_mode_vrefresh != vrefresh) 241 adjusted_mode->vtotal = 242 DIV_ROUND_CLOSEST(adjusted_mode->clock * 1000, 243 adjusted_mode->htotal * vrefresh); 244 245 drm_mode_set_crtcinfo(adjusted_mode, 0); 246 247 return 0; 248 } 249 250 static void intel_panel_add_edid_alt_fixed_modes(struct intel_connector *connector) 251 { 252 struct intel_display *display = to_intel_display(connector); 253 const struct drm_display_mode *preferred_mode = 254 intel_panel_preferred_fixed_mode(connector); 255 struct drm_display_mode *mode, *next; 256 257 list_for_each_entry_safe(mode, next, &connector->base.probed_modes, head) { 258 if (!is_alt_fixed_mode(mode, preferred_mode)) 259 continue; 260 261 drm_dbg_kms(display->drm, 262 "[CONNECTOR:%d:%s] using alternate EDID fixed mode: " DRM_MODE_FMT "\n", 263 connector->base.base.id, connector->base.name, 264 DRM_MODE_ARG(mode)); 265 266 list_move_tail(&mode->head, &connector->panel.fixed_modes); 267 } 268 } 269 270 static void intel_panel_add_edid_preferred_mode(struct intel_connector *connector) 271 { 272 struct intel_display *display = to_intel_display(connector); 273 struct drm_display_mode *scan, *fixed_mode = NULL; 274 275 if (list_empty(&connector->base.probed_modes)) 276 return; 277 278 /* make sure the preferred mode is first */ 279 list_for_each_entry(scan, &connector->base.probed_modes, head) { 280 if (scan->type & DRM_MODE_TYPE_PREFERRED) { 281 fixed_mode = scan; 282 break; 283 } 284 } 285 286 if (!fixed_mode) 287 fixed_mode = list_first_entry(&connector->base.probed_modes, 288 typeof(*fixed_mode), head); 289 290 drm_dbg_kms(display->drm, 291 "[CONNECTOR:%d:%s] using %s EDID fixed mode: " DRM_MODE_FMT "\n", 292 connector->base.base.id, connector->base.name, 293 fixed_mode->type & DRM_MODE_TYPE_PREFERRED ? "preferred" : "first", 294 DRM_MODE_ARG(fixed_mode)); 295 296 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED; 297 298 list_move_tail(&fixed_mode->head, &connector->panel.fixed_modes); 299 } 300 301 static void intel_panel_destroy_probed_modes(struct intel_connector *connector) 302 { 303 struct intel_display *display = to_intel_display(connector); 304 struct drm_display_mode *mode, *next; 305 306 list_for_each_entry_safe(mode, next, &connector->base.probed_modes, head) { 307 drm_dbg_kms(display->drm, 308 "[CONNECTOR:%d:%s] not using EDID mode: " DRM_MODE_FMT "\n", 309 connector->base.base.id, connector->base.name, 310 DRM_MODE_ARG(mode)); 311 list_del(&mode->head); 312 drm_mode_destroy(display->drm, mode); 313 } 314 } 315 316 void intel_panel_add_edid_fixed_modes(struct intel_connector *connector, 317 bool use_alt_fixed_modes) 318 { 319 intel_panel_add_edid_preferred_mode(connector); 320 if (intel_panel_preferred_fixed_mode(connector) && use_alt_fixed_modes) 321 intel_panel_add_edid_alt_fixed_modes(connector); 322 intel_panel_destroy_probed_modes(connector); 323 } 324 325 static void intel_panel_add_fixed_mode(struct intel_connector *connector, 326 struct drm_display_mode *fixed_mode, 327 const char *type) 328 { 329 struct intel_display *display = to_intel_display(connector); 330 struct drm_display_info *info = &connector->base.display_info; 331 332 if (!fixed_mode) 333 return; 334 335 fixed_mode->type |= DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER; 336 337 info->width_mm = fixed_mode->width_mm; 338 info->height_mm = fixed_mode->height_mm; 339 340 drm_dbg_kms(display->drm, "[CONNECTOR:%d:%s] using %s fixed mode: " DRM_MODE_FMT "\n", 341 connector->base.base.id, connector->base.name, type, 342 DRM_MODE_ARG(fixed_mode)); 343 344 list_add_tail(&fixed_mode->head, &connector->panel.fixed_modes); 345 } 346 347 void intel_panel_add_vbt_lfp_fixed_mode(struct intel_connector *connector) 348 { 349 struct intel_display *display = to_intel_display(connector); 350 const struct drm_display_mode *mode; 351 352 mode = connector->panel.vbt.lfp_vbt_mode; 353 if (!mode) 354 return; 355 356 intel_panel_add_fixed_mode(connector, 357 drm_mode_duplicate(display->drm, mode), 358 "VBT LFP"); 359 } 360 361 void intel_panel_add_vbt_sdvo_fixed_mode(struct intel_connector *connector) 362 { 363 struct intel_display *display = to_intel_display(connector); 364 const struct drm_display_mode *mode; 365 366 mode = connector->panel.vbt.sdvo_lvds_vbt_mode; 367 if (!mode) 368 return; 369 370 intel_panel_add_fixed_mode(connector, 371 drm_mode_duplicate(display->drm, mode), 372 "VBT SDVO"); 373 } 374 375 void intel_panel_add_encoder_fixed_mode(struct intel_connector *connector, 376 struct intel_encoder *encoder) 377 { 378 intel_panel_add_fixed_mode(connector, 379 intel_encoder_current_mode(encoder), 380 "current (BIOS)"); 381 } 382 383 enum drm_connector_status 384 intel_panel_detect(struct drm_connector *connector, bool force) 385 { 386 struct drm_i915_private *i915 = to_i915(connector->dev); 387 388 if (!intel_display_device_enabled(i915)) 389 return connector_status_disconnected; 390 391 if (!intel_display_driver_check_access(i915)) 392 return connector->status; 393 394 return connector_status_connected; 395 } 396 397 enum drm_mode_status 398 intel_panel_mode_valid(struct intel_connector *connector, 399 const struct drm_display_mode *mode) 400 { 401 const struct drm_display_mode *fixed_mode = 402 intel_panel_fixed_mode(connector, mode); 403 404 if (!fixed_mode) 405 return MODE_OK; 406 407 if (mode->hdisplay != fixed_mode->hdisplay) 408 return MODE_PANEL; 409 410 if (mode->vdisplay != fixed_mode->vdisplay) 411 return MODE_PANEL; 412 413 if (drm_mode_vrefresh(mode) != drm_mode_vrefresh(fixed_mode)) 414 return MODE_PANEL; 415 416 return MODE_OK; 417 } 418 419 void intel_panel_init_alloc(struct intel_connector *connector) 420 { 421 struct intel_panel *panel = &connector->panel; 422 423 connector->panel.vbt.panel_type = -1; 424 connector->panel.vbt.backlight.controller = -1; 425 INIT_LIST_HEAD(&panel->fixed_modes); 426 } 427 428 int intel_panel_init(struct intel_connector *connector, 429 const struct drm_edid *fixed_edid) 430 { 431 struct intel_panel *panel = &connector->panel; 432 433 panel->fixed_edid = fixed_edid; 434 435 intel_backlight_init_funcs(panel); 436 437 if (!has_drrs_modes(connector)) 438 connector->panel.vbt.drrs_type = DRRS_TYPE_NONE; 439 440 drm_dbg_kms(connector->base.dev, 441 "[CONNECTOR:%d:%s] DRRS type: %s\n", 442 connector->base.base.id, connector->base.name, 443 intel_drrs_type_str(intel_panel_drrs_type(connector))); 444 445 return 0; 446 } 447 448 void intel_panel_fini(struct intel_connector *connector) 449 { 450 struct intel_panel *panel = &connector->panel; 451 struct drm_display_mode *fixed_mode, *next; 452 453 if (!IS_ERR_OR_NULL(panel->fixed_edid)) 454 drm_edid_free(panel->fixed_edid); 455 456 intel_backlight_destroy(panel); 457 458 intel_bios_fini_panel(panel); 459 460 list_for_each_entry_safe(fixed_mode, next, &panel->fixed_modes, head) { 461 list_del(&fixed_mode->head); 462 drm_mode_destroy(connector->base.dev, fixed_mode); 463 } 464 } 465