drivers/gpu/drm/i915/display/intel_panel.c

   1 /*
   2  * Copyright © 2006-2010 Intel Corporation
   3  * Copyright (c) 2006 Dave Airlie <[email protected]>
   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 <[email protected]>
  26  *      Dave Airlie <[email protected]>
  27  *      Jesse Barnes <[email protected]>
  28  *      Chris Wilson <[email protected]>
  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 }