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_reg.h"
37 #include "intel_backlight.h"
38 #include "intel_connector.h"
39 #include "intel_de.h"
40 #include "intel_display_types.h"
41 #include "intel_drrs.h"
42 #include "intel_lvds_regs.h"
43 #include "intel_panel.h"
44 #include "intel_quirks.h"
45 #include "intel_vrr.h"
46 
47 bool intel_panel_use_ssc(struct drm_i915_private *i915)
48 {
49 	if (i915->params.panel_use_ssc >= 0)
50 		return i915->params.panel_use_ssc != 0;
51 	return i915->display.vbt.lvds_use_ssc &&
52 		!intel_has_quirk(i915, 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_in_vrr_range(struct intel_connector *connector, int vrefresh)
63 {
64 	const struct drm_display_info *info = &connector->base.display_info;
65 
66 	return intel_vrr_is_capable(connector) &&
67 		vrefresh >= info->monitor_range.min_vfreq &&
68 		vrefresh <= info->monitor_range.max_vfreq;
69 }
70 
71 static bool is_best_fixed_mode(struct intel_connector *connector,
72 			       int vrefresh, int fixed_mode_vrefresh,
73 			       const struct drm_display_mode *best_mode)
74 {
75 	/* we want to always return something */
76 	if (!best_mode)
77 		return true;
78 
79 	/*
80 	 * With VRR always pick a mode with equal/higher than requested
81 	 * vrefresh, which we can then reduce to match the requested
82 	 * vrefresh by extending the vblank length.
83 	 */
84 	if (is_in_vrr_range(connector, vrefresh) &&
85 	    is_in_vrr_range(connector, fixed_mode_vrefresh) &&
86 	    fixed_mode_vrefresh < vrefresh)
87 		return false;
88 
89 	/* pick the fixed_mode that is closest in terms of vrefresh */
90 	return abs(fixed_mode_vrefresh - vrefresh) <
91 		abs(drm_mode_vrefresh(best_mode) - vrefresh);
92 }
93 
94 const struct drm_display_mode *
95 intel_panel_fixed_mode(struct intel_connector *connector,
96 		       const struct drm_display_mode *mode)
97 {
98 	const struct drm_display_mode *fixed_mode, *best_mode = NULL;
99 	int vrefresh = drm_mode_vrefresh(mode);
100 
101 	list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) {
102 		int fixed_mode_vrefresh = drm_mode_vrefresh(fixed_mode);
103 
104 		if (is_best_fixed_mode(connector, vrefresh,
105 				       fixed_mode_vrefresh, best_mode))
106 			best_mode = fixed_mode;
107 	}
108 
109 	return best_mode;
110 }
111 
112 static bool is_alt_drrs_mode(const struct drm_display_mode *mode,
113 			     const struct drm_display_mode *preferred_mode)
114 {
115 	return drm_mode_match(mode, preferred_mode,
116 			      DRM_MODE_MATCH_TIMINGS |
117 			      DRM_MODE_MATCH_FLAGS |
118 			      DRM_MODE_MATCH_3D_FLAGS) &&
119 		mode->clock != preferred_mode->clock;
120 }
121 
122 static bool is_alt_fixed_mode(const struct drm_display_mode *mode,
123 			      const struct drm_display_mode *preferred_mode)
124 {
125 	u32 sync_flags = DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NHSYNC |
126 		DRM_MODE_FLAG_PVSYNC | DRM_MODE_FLAG_NVSYNC;
127 
128 	return (mode->flags & ~sync_flags) == (preferred_mode->flags & ~sync_flags) &&
129 		mode->hdisplay == preferred_mode->hdisplay &&
130 		mode->vdisplay == preferred_mode->vdisplay;
131 }
132 
133 const struct drm_display_mode *
134 intel_panel_downclock_mode(struct intel_connector *connector,
135 			   const struct drm_display_mode *adjusted_mode)
136 {
137 	const struct drm_display_mode *fixed_mode, *best_mode = NULL;
138 	int min_vrefresh = connector->panel.vbt.seamless_drrs_min_refresh_rate;
139 	int max_vrefresh = drm_mode_vrefresh(adjusted_mode);
140 
141 	/* pick the fixed_mode with the lowest refresh rate */
142 	list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) {
143 		int vrefresh = drm_mode_vrefresh(fixed_mode);
144 
145 		if (is_alt_drrs_mode(fixed_mode, adjusted_mode) &&
146 		    vrefresh >= min_vrefresh && vrefresh < max_vrefresh) {
147 			max_vrefresh = vrefresh;
148 			best_mode = fixed_mode;
149 		}
150 	}
151 
152 	return best_mode;
153 }
154 
155 const struct drm_display_mode *
156 intel_panel_highest_mode(struct intel_connector *connector,
157 			 const struct drm_display_mode *adjusted_mode)
158 {
159 	const struct drm_display_mode *fixed_mode, *best_mode = adjusted_mode;
160 
161 	/* pick the fixed_mode that has the highest clock */
162 	list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) {
163 		if (fixed_mode->clock > best_mode->clock)
164 			best_mode = fixed_mode;
165 	}
166 
167 	return best_mode;
168 }
169 
170 int intel_panel_get_modes(struct intel_connector *connector)
171 {
172 	const struct drm_display_mode *fixed_mode;
173 	int num_modes = 0;
174 
175 	list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) {
176 		struct drm_display_mode *mode;
177 
178 		mode = drm_mode_duplicate(connector->base.dev, fixed_mode);
179 		if (mode) {
180 			drm_mode_probed_add(&connector->base, mode);
181 			num_modes++;
182 		}
183 	}
184 
185 	return num_modes;
186 }
187 
188 static bool has_drrs_modes(struct intel_connector *connector)
189 {
190 	const struct drm_display_mode *mode1;
191 
192 	list_for_each_entry(mode1, &connector->panel.fixed_modes, head) {
193 		const struct drm_display_mode *mode2 = mode1;
194 
195 		list_for_each_entry_continue(mode2, &connector->panel.fixed_modes, head) {
196 			if (is_alt_drrs_mode(mode1, mode2))
197 				return true;
198 		}
199 	}
200 
201 	return false;
202 }
203 
204 enum drrs_type intel_panel_drrs_type(struct intel_connector *connector)
205 {
206 	return connector->panel.vbt.drrs_type;
207 }
208 
209 int intel_panel_compute_config(struct intel_connector *connector,
210 			       struct drm_display_mode *adjusted_mode)
211 {
212 	const struct drm_display_mode *fixed_mode =
213 		intel_panel_fixed_mode(connector, adjusted_mode);
214 	int vrefresh, fixed_mode_vrefresh;
215 	bool is_vrr;
216 
217 	if (!fixed_mode)
218 		return 0;
219 
220 	vrefresh = drm_mode_vrefresh(adjusted_mode);
221 	fixed_mode_vrefresh = drm_mode_vrefresh(fixed_mode);
222 
223 	/*
224 	 * Assume that we shouldn't muck about with the
225 	 * timings if they don't land in the VRR range.
226 	 */
227 	is_vrr = is_in_vrr_range(connector, vrefresh) &&
228 		is_in_vrr_range(connector, fixed_mode_vrefresh);
229 
230 	if (!is_vrr) {
231 		/*
232 		 * We don't want to lie too much to the user about the refresh
233 		 * rate they're going to get. But we have to allow a bit of latitude
234 		 * for Xorg since it likes to automagically cook up modes with slightly
235 		 * off refresh rates.
236 		 */
237 		if (abs(vrefresh - fixed_mode_vrefresh) > 1) {
238 			drm_dbg_kms(connector->base.dev,
239 				    "[CONNECTOR:%d:%s] Requested mode vrefresh (%d Hz) does not match fixed mode vrefresh (%d Hz)\n",
240 				    connector->base.base.id, connector->base.name,
241 				    vrefresh, fixed_mode_vrefresh);
242 
243 			return -EINVAL;
244 		}
245 	}
246 
247 	drm_mode_copy(adjusted_mode, fixed_mode);
248 
249 	if (is_vrr && fixed_mode_vrefresh != vrefresh)
250 		adjusted_mode->vtotal =
251 			DIV_ROUND_CLOSEST(adjusted_mode->clock * 1000,
252 					  adjusted_mode->htotal * vrefresh);
253 
254 	drm_mode_set_crtcinfo(adjusted_mode, 0);
255 
256 	return 0;
257 }
258 
259 static void intel_panel_add_edid_alt_fixed_modes(struct intel_connector *connector)
260 {
261 	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
262 	const struct drm_display_mode *preferred_mode =
263 		intel_panel_preferred_fixed_mode(connector);
264 	struct drm_display_mode *mode, *next;
265 
266 	list_for_each_entry_safe(mode, next, &connector->base.probed_modes, head) {
267 		if (!is_alt_fixed_mode(mode, preferred_mode))
268 			continue;
269 
270 		drm_dbg_kms(&dev_priv->drm,
271 			    "[CONNECTOR:%d:%s] using alternate EDID fixed mode: " DRM_MODE_FMT "\n",
272 			    connector->base.base.id, connector->base.name,
273 			    DRM_MODE_ARG(mode));
274 
275 		list_move_tail(&mode->head, &connector->panel.fixed_modes);
276 	}
277 }
278 
279 static void intel_panel_add_edid_preferred_mode(struct intel_connector *connector)
280 {
281 	struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
282 	struct drm_display_mode *scan, *fixed_mode = NULL;
283 
284 	if (list_empty(&connector->base.probed_modes))
285 		return;
286 
287 	/* make sure the preferred mode is first */
288 	list_for_each_entry(scan, &connector->base.probed_modes, head) {
289 		if (scan->type & DRM_MODE_TYPE_PREFERRED) {
290 			fixed_mode = scan;
291 			break;
292 		}
293 	}
294 
295 	if (!fixed_mode)
296 		fixed_mode = list_first_entry(&connector->base.probed_modes,
297 					      typeof(*fixed_mode), head);
298 
299 	drm_dbg_kms(&dev_priv->drm,
300 		    "[CONNECTOR:%d:%s] using %s EDID fixed mode: " DRM_MODE_FMT "\n",
301 		    connector->base.base.id, connector->base.name,
302 		    fixed_mode->type & DRM_MODE_TYPE_PREFERRED ? "preferred" : "first",
303 		    DRM_MODE_ARG(fixed_mode));
304 
305 	fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
306 
307 	list_move_tail(&fixed_mode->head, &connector->panel.fixed_modes);
308 }
309 
310 static void intel_panel_destroy_probed_modes(struct intel_connector *connector)
311 {
312 	struct drm_i915_private *i915 = to_i915(connector->base.dev);
313 	struct drm_display_mode *mode, *next;
314 
315 	list_for_each_entry_safe(mode, next, &connector->base.probed_modes, head) {
316 		drm_dbg_kms(&i915->drm,
317 			    "[CONNECTOR:%d:%s] not using EDID mode: " DRM_MODE_FMT "\n",
318 			    connector->base.base.id, connector->base.name,
319 			    DRM_MODE_ARG(mode));
320 		list_del(&mode->head);
321 		drm_mode_destroy(&i915->drm, mode);
322 	}
323 }
324 
325 void intel_panel_add_edid_fixed_modes(struct intel_connector *connector,
326 				      bool use_alt_fixed_modes)
327 {
328 	intel_panel_add_edid_preferred_mode(connector);
329 	if (intel_panel_preferred_fixed_mode(connector) && use_alt_fixed_modes)
330 		intel_panel_add_edid_alt_fixed_modes(connector);
331 	intel_panel_destroy_probed_modes(connector);
332 }
333 
334 static void intel_panel_add_fixed_mode(struct intel_connector *connector,
335 				       struct drm_display_mode *fixed_mode,
336 				       const char *type)
337 {
338 	struct drm_i915_private *i915 = to_i915(connector->base.dev);
339 	struct drm_display_info *info = &connector->base.display_info;
340 
341 	if (!fixed_mode)
342 		return;
343 
344 	fixed_mode->type |= DRM_MODE_TYPE_PREFERRED | DRM_MODE_TYPE_DRIVER;
345 
346 	info->width_mm = fixed_mode->width_mm;
347 	info->height_mm = fixed_mode->height_mm;
348 
349 	drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] using %s fixed mode: " DRM_MODE_FMT "\n",
350 		    connector->base.base.id, connector->base.name, type,
351 		    DRM_MODE_ARG(fixed_mode));
352 
353 	list_add_tail(&fixed_mode->head, &connector->panel.fixed_modes);
354 }
355 
356 void intel_panel_add_vbt_lfp_fixed_mode(struct intel_connector *connector)
357 {
358 	struct drm_i915_private *i915 = to_i915(connector->base.dev);
359 	const struct drm_display_mode *mode;
360 
361 	mode = connector->panel.vbt.lfp_lvds_vbt_mode;
362 	if (!mode)
363 		return;
364 
365 	intel_panel_add_fixed_mode(connector,
366 				   drm_mode_duplicate(&i915->drm, mode),
367 				   "VBT LFP");
368 }
369 
370 void intel_panel_add_vbt_sdvo_fixed_mode(struct intel_connector *connector)
371 {
372 	struct drm_i915_private *i915 = to_i915(connector->base.dev);
373 	const struct drm_display_mode *mode;
374 
375 	mode = connector->panel.vbt.sdvo_lvds_vbt_mode;
376 	if (!mode)
377 		return;
378 
379 	intel_panel_add_fixed_mode(connector,
380 				   drm_mode_duplicate(&i915->drm, mode),
381 				   "VBT SDVO");
382 }
383 
384 void intel_panel_add_encoder_fixed_mode(struct intel_connector *connector,
385 					struct intel_encoder *encoder)
386 {
387 	intel_panel_add_fixed_mode(connector,
388 				   intel_encoder_current_mode(encoder),
389 				   "current (BIOS)");
390 }
391 
392 /* adjusted_mode has been preset to be the panel's fixed mode */
393 static int pch_panel_fitting(struct intel_crtc_state *crtc_state,
394 			     const struct drm_connector_state *conn_state)
395 {
396 	const struct drm_display_mode *adjusted_mode =
397 		&crtc_state->hw.adjusted_mode;
398 	int pipe_src_w = drm_rect_width(&crtc_state->pipe_src);
399 	int pipe_src_h = drm_rect_height(&crtc_state->pipe_src);
400 	int x, y, width, height;
401 
402 	/* Native modes don't need fitting */
403 	if (adjusted_mode->crtc_hdisplay == pipe_src_w &&
404 	    adjusted_mode->crtc_vdisplay == pipe_src_h &&
405 	    crtc_state->output_format != INTEL_OUTPUT_FORMAT_YCBCR420)
406 		return 0;
407 
408 	switch (conn_state->scaling_mode) {
409 	case DRM_MODE_SCALE_CENTER:
410 		width = pipe_src_w;
411 		height = pipe_src_h;
412 		x = (adjusted_mode->crtc_hdisplay - width + 1)/2;
413 		y = (adjusted_mode->crtc_vdisplay - height + 1)/2;
414 		break;
415 
416 	case DRM_MODE_SCALE_ASPECT:
417 		/* Scale but preserve the aspect ratio */
418 		{
419 			u32 scaled_width = adjusted_mode->crtc_hdisplay * pipe_src_h;
420 			u32 scaled_height = pipe_src_w * adjusted_mode->crtc_vdisplay;
421 			if (scaled_width > scaled_height) { /* pillar */
422 				width = scaled_height / pipe_src_h;
423 				if (width & 1)
424 					width++;
425 				x = (adjusted_mode->crtc_hdisplay - width + 1) / 2;
426 				y = 0;
427 				height = adjusted_mode->crtc_vdisplay;
428 			} else if (scaled_width < scaled_height) { /* letter */
429 				height = scaled_width / pipe_src_w;
430 				if (height & 1)
431 				    height++;
432 				y = (adjusted_mode->crtc_vdisplay - height + 1) / 2;
433 				x = 0;
434 				width = adjusted_mode->crtc_hdisplay;
435 			} else {
436 				x = y = 0;
437 				width = adjusted_mode->crtc_hdisplay;
438 				height = adjusted_mode->crtc_vdisplay;
439 			}
440 		}
441 		break;
442 
443 	case DRM_MODE_SCALE_NONE:
444 		WARN_ON(adjusted_mode->crtc_hdisplay != pipe_src_w);
445 		WARN_ON(adjusted_mode->crtc_vdisplay != pipe_src_h);
446 		fallthrough;
447 	case DRM_MODE_SCALE_FULLSCREEN:
448 		x = y = 0;
449 		width = adjusted_mode->crtc_hdisplay;
450 		height = adjusted_mode->crtc_vdisplay;
451 		break;
452 
453 	default:
454 		MISSING_CASE(conn_state->scaling_mode);
455 		return -EINVAL;
456 	}
457 
458 	drm_rect_init(&crtc_state->pch_pfit.dst,
459 		      x, y, width, height);
460 	crtc_state->pch_pfit.enabled = true;
461 
462 	return 0;
463 }
464 
465 static void
466 centre_horizontally(struct drm_display_mode *adjusted_mode,
467 		    int width)
468 {
469 	u32 border, sync_pos, blank_width, sync_width;
470 
471 	/* keep the hsync and hblank widths constant */
472 	sync_width = adjusted_mode->crtc_hsync_end - adjusted_mode->crtc_hsync_start;
473 	blank_width = adjusted_mode->crtc_hblank_end - adjusted_mode->crtc_hblank_start;
474 	sync_pos = (blank_width - sync_width + 1) / 2;
475 
476 	border = (adjusted_mode->crtc_hdisplay - width + 1) / 2;
477 	border += border & 1; /* make the border even */
478 
479 	adjusted_mode->crtc_hdisplay = width;
480 	adjusted_mode->crtc_hblank_start = width + border;
481 	adjusted_mode->crtc_hblank_end = adjusted_mode->crtc_hblank_start + blank_width;
482 
483 	adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hblank_start + sync_pos;
484 	adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_start + sync_width;
485 }
486 
487 static void
488 centre_vertically(struct drm_display_mode *adjusted_mode,
489 		  int height)
490 {
491 	u32 border, sync_pos, blank_width, sync_width;
492 
493 	/* keep the vsync and vblank widths constant */
494 	sync_width = adjusted_mode->crtc_vsync_end - adjusted_mode->crtc_vsync_start;
495 	blank_width = adjusted_mode->crtc_vblank_end - adjusted_mode->crtc_vblank_start;
496 	sync_pos = (blank_width - sync_width + 1) / 2;
497 
498 	border = (adjusted_mode->crtc_vdisplay - height + 1) / 2;
499 
500 	adjusted_mode->crtc_vdisplay = height;
501 	adjusted_mode->crtc_vblank_start = height + border;
502 	adjusted_mode->crtc_vblank_end = adjusted_mode->crtc_vblank_start + blank_width;
503 
504 	adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vblank_start + sync_pos;
505 	adjusted_mode->crtc_vsync_end = adjusted_mode->crtc_vsync_start + sync_width;
506 }
507 
508 static u32 panel_fitter_scaling(u32 source, u32 target)
509 {
510 	/*
511 	 * Floating point operation is not supported. So the FACTOR
512 	 * is defined, which can avoid the floating point computation
513 	 * when calculating the panel ratio.
514 	 */
515 #define ACCURACY 12
516 #define FACTOR (1 << ACCURACY)
517 	u32 ratio = source * FACTOR / target;
518 	return (FACTOR * ratio + FACTOR/2) / FACTOR;
519 }
520 
521 static void i965_scale_aspect(struct intel_crtc_state *crtc_state,
522 			      u32 *pfit_control)
523 {
524 	const struct drm_display_mode *adjusted_mode =
525 		&crtc_state->hw.adjusted_mode;
526 	int pipe_src_w = drm_rect_width(&crtc_state->pipe_src);
527 	int pipe_src_h = drm_rect_height(&crtc_state->pipe_src);
528 	u32 scaled_width = adjusted_mode->crtc_hdisplay * pipe_src_h;
529 	u32 scaled_height = pipe_src_w * adjusted_mode->crtc_vdisplay;
530 
531 	/* 965+ is easy, it does everything in hw */
532 	if (scaled_width > scaled_height)
533 		*pfit_control |= PFIT_ENABLE |
534 			PFIT_SCALING_PILLAR;
535 	else if (scaled_width < scaled_height)
536 		*pfit_control |= PFIT_ENABLE |
537 			PFIT_SCALING_LETTER;
538 	else if (adjusted_mode->crtc_hdisplay != pipe_src_w)
539 		*pfit_control |= PFIT_ENABLE | PFIT_SCALING_AUTO;
540 }
541 
542 static void i9xx_scale_aspect(struct intel_crtc_state *crtc_state,
543 			      u32 *pfit_control, u32 *pfit_pgm_ratios,
544 			      u32 *border)
545 {
546 	struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;
547 	int pipe_src_w = drm_rect_width(&crtc_state->pipe_src);
548 	int pipe_src_h = drm_rect_height(&crtc_state->pipe_src);
549 	u32 scaled_width = adjusted_mode->crtc_hdisplay * pipe_src_h;
550 	u32 scaled_height = pipe_src_w * adjusted_mode->crtc_vdisplay;
551 	u32 bits;
552 
553 	/*
554 	 * For earlier chips we have to calculate the scaling
555 	 * ratio by hand and program it into the
556 	 * PFIT_PGM_RATIO register
557 	 */
558 	if (scaled_width > scaled_height) { /* pillar */
559 		centre_horizontally(adjusted_mode,
560 				    scaled_height / pipe_src_h);
561 
562 		*border = LVDS_BORDER_ENABLE;
563 		if (pipe_src_h != adjusted_mode->crtc_vdisplay) {
564 			bits = panel_fitter_scaling(pipe_src_h,
565 						    adjusted_mode->crtc_vdisplay);
566 
567 			*pfit_pgm_ratios |= (PFIT_HORIZ_SCALE(bits) |
568 					     PFIT_VERT_SCALE(bits));
569 			*pfit_control |= (PFIT_ENABLE |
570 					  PFIT_VERT_INTERP_BILINEAR |
571 					  PFIT_HORIZ_INTERP_BILINEAR);
572 		}
573 	} else if (scaled_width < scaled_height) { /* letter */
574 		centre_vertically(adjusted_mode,
575 				  scaled_width / pipe_src_w);
576 
577 		*border = LVDS_BORDER_ENABLE;
578 		if (pipe_src_w != adjusted_mode->crtc_hdisplay) {
579 			bits = panel_fitter_scaling(pipe_src_w,
580 						    adjusted_mode->crtc_hdisplay);
581 
582 			*pfit_pgm_ratios |= (PFIT_HORIZ_SCALE(bits) |
583 					     PFIT_VERT_SCALE(bits));
584 			*pfit_control |= (PFIT_ENABLE |
585 					  PFIT_VERT_INTERP_BILINEAR |
586 					  PFIT_HORIZ_INTERP_BILINEAR);
587 		}
588 	} else {
589 		/* Aspects match, Let hw scale both directions */
590 		*pfit_control |= (PFIT_ENABLE |
591 				  PFIT_VERT_AUTO_SCALE |
592 				  PFIT_HORIZ_AUTO_SCALE |
593 				  PFIT_VERT_INTERP_BILINEAR |
594 				  PFIT_HORIZ_INTERP_BILINEAR);
595 	}
596 }
597 
598 static int gmch_panel_fitting(struct intel_crtc_state *crtc_state,
599 			      const struct drm_connector_state *conn_state)
600 {
601 	struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
602 	struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
603 	u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
604 	struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;
605 	int pipe_src_w = drm_rect_width(&crtc_state->pipe_src);
606 	int pipe_src_h = drm_rect_height(&crtc_state->pipe_src);
607 
608 	/* Native modes don't need fitting */
609 	if (adjusted_mode->crtc_hdisplay == pipe_src_w &&
610 	    adjusted_mode->crtc_vdisplay == pipe_src_h)
611 		goto out;
612 
613 	switch (conn_state->scaling_mode) {
614 	case DRM_MODE_SCALE_CENTER:
615 		/*
616 		 * For centered modes, we have to calculate border widths &
617 		 * heights and modify the values programmed into the CRTC.
618 		 */
619 		centre_horizontally(adjusted_mode, pipe_src_w);
620 		centre_vertically(adjusted_mode, pipe_src_h);
621 		border = LVDS_BORDER_ENABLE;
622 		break;
623 	case DRM_MODE_SCALE_ASPECT:
624 		/* Scale but preserve the aspect ratio */
625 		if (DISPLAY_VER(dev_priv) >= 4)
626 			i965_scale_aspect(crtc_state, &pfit_control);
627 		else
628 			i9xx_scale_aspect(crtc_state, &pfit_control,
629 					  &pfit_pgm_ratios, &border);
630 		break;
631 	case DRM_MODE_SCALE_FULLSCREEN:
632 		/*
633 		 * Full scaling, even if it changes the aspect ratio.
634 		 * Fortunately this is all done for us in hw.
635 		 */
636 		if (pipe_src_h != adjusted_mode->crtc_vdisplay ||
637 		    pipe_src_w != adjusted_mode->crtc_hdisplay) {
638 			pfit_control |= PFIT_ENABLE;
639 			if (DISPLAY_VER(dev_priv) >= 4)
640 				pfit_control |= PFIT_SCALING_AUTO;
641 			else
642 				pfit_control |= (PFIT_VERT_AUTO_SCALE |
643 						 PFIT_VERT_INTERP_BILINEAR |
644 						 PFIT_HORIZ_AUTO_SCALE |
645 						 PFIT_HORIZ_INTERP_BILINEAR);
646 		}
647 		break;
648 	default:
649 		MISSING_CASE(conn_state->scaling_mode);
650 		return -EINVAL;
651 	}
652 
653 	/* 965+ wants fuzzy fitting */
654 	/* FIXME: handle multiple panels by failing gracefully */
655 	if (DISPLAY_VER(dev_priv) >= 4)
656 		pfit_control |= PFIT_PIPE(crtc->pipe) | PFIT_FILTER_FUZZY;
657 
658 out:
659 	if ((pfit_control & PFIT_ENABLE) == 0) {
660 		pfit_control = 0;
661 		pfit_pgm_ratios = 0;
662 	}
663 
664 	/* Make sure pre-965 set dither correctly for 18bpp panels. */
665 	if (DISPLAY_VER(dev_priv) < 4 && crtc_state->pipe_bpp == 18)
666 		pfit_control |= PFIT_PANEL_8TO6_DITHER_ENABLE;
667 
668 	crtc_state->gmch_pfit.control = pfit_control;
669 	crtc_state->gmch_pfit.pgm_ratios = pfit_pgm_ratios;
670 	crtc_state->gmch_pfit.lvds_border_bits = border;
671 
672 	return 0;
673 }
674 
675 int intel_panel_fitting(struct intel_crtc_state *crtc_state,
676 			const struct drm_connector_state *conn_state)
677 {
678 	struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
679 	struct drm_i915_private *i915 = to_i915(crtc->base.dev);
680 
681 	if (HAS_GMCH(i915))
682 		return gmch_panel_fitting(crtc_state, conn_state);
683 	else
684 		return pch_panel_fitting(crtc_state, conn_state);
685 }
686 
687 enum drm_connector_status
688 intel_panel_detect(struct drm_connector *connector, bool force)
689 {
690 	struct drm_i915_private *i915 = to_i915(connector->dev);
691 
692 	if (!INTEL_DISPLAY_ENABLED(i915))
693 		return connector_status_disconnected;
694 
695 	return connector_status_connected;
696 }
697 
698 enum drm_mode_status
699 intel_panel_mode_valid(struct intel_connector *connector,
700 		       const struct drm_display_mode *mode)
701 {
702 	const struct drm_display_mode *fixed_mode =
703 		intel_panel_fixed_mode(connector, mode);
704 
705 	if (!fixed_mode)
706 		return MODE_OK;
707 
708 	if (mode->hdisplay != fixed_mode->hdisplay)
709 		return MODE_PANEL;
710 
711 	if (mode->vdisplay != fixed_mode->vdisplay)
712 		return MODE_PANEL;
713 
714 	if (drm_mode_vrefresh(mode) != drm_mode_vrefresh(fixed_mode))
715 		return MODE_PANEL;
716 
717 	return MODE_OK;
718 }
719 
720 void intel_panel_init_alloc(struct intel_connector *connector)
721 {
722 	struct intel_panel *panel = &connector->panel;
723 
724 	connector->panel.vbt.panel_type = -1;
725 	connector->panel.vbt.backlight.controller = -1;
726 	INIT_LIST_HEAD(&panel->fixed_modes);
727 }
728 
729 int intel_panel_init(struct intel_connector *connector,
730 		     const struct drm_edid *fixed_edid)
731 {
732 	struct intel_panel *panel = &connector->panel;
733 
734 	panel->fixed_edid = fixed_edid;
735 
736 	intel_backlight_init_funcs(panel);
737 
738 	if (!has_drrs_modes(connector))
739 		connector->panel.vbt.drrs_type = DRRS_TYPE_NONE;
740 
741 	drm_dbg_kms(connector->base.dev,
742 		    "[CONNECTOR:%d:%s] DRRS type: %s\n",
743 		    connector->base.base.id, connector->base.name,
744 		    intel_drrs_type_str(intel_panel_drrs_type(connector)));
745 
746 	return 0;
747 }
748 
749 void intel_panel_fini(struct intel_connector *connector)
750 {
751 	struct intel_panel *panel = &connector->panel;
752 	struct drm_display_mode *fixed_mode, *next;
753 
754 	if (!IS_ERR_OR_NULL(panel->fixed_edid))
755 		drm_edid_free(panel->fixed_edid);
756 
757 	intel_backlight_destroy(panel);
758 
759 	intel_bios_fini_panel(panel);
760 
761 	list_for_each_entry_safe(fixed_mode, next, &panel->fixed_modes, head) {
762 		list_del(&fixed_mode->head);
763 		drm_mode_destroy(connector->base.dev, fixed_mode);
764 	}
765 }
766