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_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
 47bool 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
 55const struct drm_display_mode *
 56intel_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
 62static 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
 85const struct drm_display_mode *
 86intel_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
103static 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
113static 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
124const struct drm_display_mode *
125intel_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
146const struct drm_display_mode *
147intel_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
161int 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
179static 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
195enum drrs_type intel_panel_drrs_type(struct intel_connector *connector)
196{
197	return connector->panel.vbt.drrs_type;
198}
199
200int 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
250static 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
270static 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
301static 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
316void 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
325static 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
347void 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
361void 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
375void 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
383enum drm_connector_status
384intel_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
397enum drm_mode_status
398intel_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
419void 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
428int 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
448void 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}