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