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