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
intel_panel_use_ssc(struct intel_display * display)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 *
intel_panel_preferred_fixed_mode(struct intel_connector * connector)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
is_best_fixed_mode(struct intel_connector * connector,int vrefresh,int fixed_mode_vrefresh,const struct drm_display_mode * best_mode)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 *
intel_panel_fixed_mode(struct intel_connector * connector,const struct drm_display_mode * 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
is_alt_drrs_mode(const struct drm_display_mode * mode,const struct drm_display_mode * preferred_mode)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
is_alt_fixed_mode(const struct drm_display_mode * mode,const struct drm_display_mode * preferred_mode)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 *
intel_panel_downclock_mode(struct intel_connector * connector,const struct drm_display_mode * adjusted_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 *
intel_panel_highest_mode(struct intel_connector * connector,const struct drm_display_mode * adjusted_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
intel_panel_get_modes(struct intel_connector * connector)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
has_drrs_modes(struct intel_connector * connector)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
intel_panel_drrs_type(struct intel_connector * connector)194 enum drrs_type intel_panel_drrs_type(struct intel_connector *connector)
195 {
196 return connector->panel.vbt.drrs_type;
197 }
198
intel_panel_compute_config(struct intel_connector * connector,struct drm_display_mode * adjusted_mode)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
intel_panel_add_edid_alt_fixed_modes(struct intel_connector * connector)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
intel_panel_add_edid_preferred_mode(struct intel_connector * connector)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
intel_panel_destroy_probed_modes(struct intel_connector * connector)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
intel_panel_add_edid_fixed_modes(struct intel_connector * connector,bool use_alt_fixed_modes)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
intel_panel_add_fixed_mode(struct intel_connector * connector,struct drm_display_mode * fixed_mode,const char * type)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
intel_panel_add_vbt_lfp_fixed_mode(struct intel_connector * connector)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
intel_panel_add_vbt_sdvo_fixed_mode(struct intel_connector * connector)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
intel_panel_add_encoder_fixed_mode(struct intel_connector * connector,struct intel_encoder * encoder)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
intel_panel_detect(struct drm_connector * connector,bool force)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
intel_panel_mode_valid(struct intel_connector * connector,const struct drm_display_mode * mode)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
intel_panel_init_alloc(struct intel_connector * connector)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
intel_panel_init(struct intel_connector * connector,const struct drm_edid * fixed_edid)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
intel_panel_fini(struct intel_connector * connector)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