Merge tag 'drm-intel-next-2023-06-05' of git://anongit.freedesktop.org/drm/drm-intel into drm-next
drm/i915 features for v6.5: Features and functionality: - Meteorlake (MTL) display enabling (Mika, Radhakrishna, José, Ankit, Clint, Gustavo, Imre, Anusha, Juha-Pekka, Matt) - Allow VRR to be toggled during fastsets (Ville) - Allow arbitrary refresh rates with VRR eDP panels (Ville) - Support async flips on linear buffers on display ver 12+ (Arun) - New debugfs for display clock frequencies (Bhanuprakash) - Taint kernel when force probing unsupported devices (Jani) - Expose CRTC CTM property on ILK/SNB/VLV (Ville) DRM subsystem changes: - EDID changes to support further conversion to struct drm_edid (Jani) - Move i915 DSC parameter code to common DRM helpers (Dmitry Baryshkov) Refactoring and cleanups: - CSC color refactoring (Ville) - VRR cleanups (Ville) - Finish i915 conversion to struct drm_edid (Jani) - Start high level display driver file (Jani) - Hotplug refactoring (Ville) - Misc display refactoring and cleanups (Jani, Ville) - Use device based logging for state checker warnings (Jani) - Split out hotplug and display irq handling (Jani) - Move display device info and probe under display/ (Matt) - HDCP cleanups (Suraj) - Use localized warning ignores instead of per file (Jani) - Remove superfluous enum i915_drm_suspend_mode (Maarten) - PSR, pfit, scaler and chicken register definition cleanups (Ville) - Constify pointers to hwmon_channel_info (Krzysztof Kozlowski) - Replace all non-returning strlcpy with strscpy (Azeem Shaikh) - Refactor VBT aux channel and DDC pin mapping (Ville) - Include cleanups (Jani) Fixes: - Fix modeset locking issue in DP MST HDCP (Suraj) - Fix disconnected Type-C/DP-alt disable at probe (Imre) - Fix HDMI PCON DSC usage and color conversions (Ankit) - Fix g4x HDMI infoframe/audio transmission port usage (Ville) - Avoid use-after-free when DP connector init fails (Maarten) - Fix voltage level for 480 MHz CDCLK (Chaitanya) - Check HPD live state during eDP probe (Ville) - Fix active port PLL selection for secondary MST streams (Imre) - Check pipe source size when using SKL+ scalers (Ville) - Fix MIPI DSI sleep sequences (Hans de Goede) - Fix DPCD register write order to match 128b/132b requirement (Arun) - Increase AUX timeout for Type-C (Suraj) - Communicate display power demands to pcode (Stan) - Fix potential division by zero in DSC compute config (Nikita Zhandarovich) - Fix fast wake AUX sync length (Jouni) - Fix potential oops on intel_get_crtc_new_encoder() (Ville) Merges: - drm-next backmerges (Rodrigo, Jani) Signed-off-by: Dave Airlie <airlied@redhat.com> From: Jani Nikula <jani.nikula@intel.com> Link: https://patchwork.freedesktop.org/patch/msgid/87zg5eat32.fsf@intel.com
This commit is contained in:
@@ -1823,7 +1823,7 @@ static void drm_dp_destroy_port(struct kref *kref)
|
||||
return;
|
||||
}
|
||||
|
||||
kfree(port->cached_edid);
|
||||
drm_edid_free(port->cached_edid);
|
||||
|
||||
/*
|
||||
* we can't destroy the connector here, as we might be holding the
|
||||
@@ -2272,8 +2272,8 @@ drm_dp_mst_port_add_connector(struct drm_dp_mst_branch *mstb,
|
||||
if (port->pdt != DP_PEER_DEVICE_NONE &&
|
||||
drm_dp_mst_is_end_device(port->pdt, port->mcs) &&
|
||||
port->port_num >= DP_MST_LOGICAL_PORT_0)
|
||||
port->cached_edid = drm_get_edid(port->connector,
|
||||
&port->aux.ddc);
|
||||
port->cached_edid = drm_edid_read_ddc(port->connector,
|
||||
&port->aux.ddc);
|
||||
|
||||
drm_connector_register(port->connector);
|
||||
return;
|
||||
@@ -4133,7 +4133,7 @@ drm_dp_mst_detect_port(struct drm_connector *connector,
|
||||
ret = connector_status_connected;
|
||||
/* for logical ports - cache the EDID */
|
||||
if (port->port_num >= DP_MST_LOGICAL_PORT_0 && !port->cached_edid)
|
||||
port->cached_edid = drm_get_edid(connector, &port->aux.ddc);
|
||||
port->cached_edid = drm_edid_read_ddc(connector, &port->aux.ddc);
|
||||
break;
|
||||
case DP_PEER_DEVICE_DP_LEGACY_CONV:
|
||||
if (port->ldps)
|
||||
@@ -4147,7 +4147,7 @@ out:
|
||||
EXPORT_SYMBOL(drm_dp_mst_detect_port);
|
||||
|
||||
/**
|
||||
* drm_dp_mst_get_edid() - get EDID for an MST port
|
||||
* drm_dp_mst_edid_read() - get EDID for an MST port
|
||||
* @connector: toplevel connector to get EDID for
|
||||
* @mgr: manager for this port
|
||||
* @port: unverified pointer to a port.
|
||||
@@ -4156,9 +4156,11 @@ EXPORT_SYMBOL(drm_dp_mst_detect_port);
|
||||
* It validates the pointer still exists so the caller doesn't require a
|
||||
* reference.
|
||||
*/
|
||||
struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port)
|
||||
const struct drm_edid *drm_dp_mst_edid_read(struct drm_connector *connector,
|
||||
struct drm_dp_mst_topology_mgr *mgr,
|
||||
struct drm_dp_mst_port *port)
|
||||
{
|
||||
struct edid *edid = NULL;
|
||||
const struct drm_edid *drm_edid;
|
||||
|
||||
/* we need to search for the port in the mgr in case it's gone */
|
||||
port = drm_dp_mst_topology_get_port_validated(mgr, port);
|
||||
@@ -4166,12 +4168,41 @@ struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_
|
||||
return NULL;
|
||||
|
||||
if (port->cached_edid)
|
||||
edid = drm_edid_duplicate(port->cached_edid);
|
||||
else {
|
||||
edid = drm_get_edid(connector, &port->aux.ddc);
|
||||
}
|
||||
port->has_audio = drm_detect_monitor_audio(edid);
|
||||
drm_edid = drm_edid_dup(port->cached_edid);
|
||||
else
|
||||
drm_edid = drm_edid_read_ddc(connector, &port->aux.ddc);
|
||||
|
||||
drm_dp_mst_topology_put_port(port);
|
||||
|
||||
return drm_edid;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_dp_mst_edid_read);
|
||||
|
||||
/**
|
||||
* drm_dp_mst_get_edid() - get EDID for an MST port
|
||||
* @connector: toplevel connector to get EDID for
|
||||
* @mgr: manager for this port
|
||||
* @port: unverified pointer to a port.
|
||||
*
|
||||
* This function is deprecated; please use drm_dp_mst_edid_read() instead.
|
||||
*
|
||||
* This returns an EDID for the port connected to a connector,
|
||||
* It validates the pointer still exists so the caller doesn't require a
|
||||
* reference.
|
||||
*/
|
||||
struct edid *drm_dp_mst_get_edid(struct drm_connector *connector,
|
||||
struct drm_dp_mst_topology_mgr *mgr,
|
||||
struct drm_dp_mst_port *port)
|
||||
{
|
||||
const struct drm_edid *drm_edid;
|
||||
struct edid *edid;
|
||||
|
||||
drm_edid = drm_dp_mst_edid_read(connector, mgr, port);
|
||||
|
||||
edid = drm_edid_duplicate(drm_edid_raw(drm_edid));
|
||||
|
||||
drm_edid_free(drm_edid);
|
||||
|
||||
return edid;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_dp_mst_get_edid);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -2844,6 +2844,35 @@ struct edid *drm_get_edid_switcheroo(struct drm_connector *connector,
|
||||
}
|
||||
EXPORT_SYMBOL(drm_get_edid_switcheroo);
|
||||
|
||||
/**
|
||||
* drm_edid_read_switcheroo - get EDID data for a vga_switcheroo output
|
||||
* @connector: connector we're probing
|
||||
* @adapter: I2C adapter to use for DDC
|
||||
*
|
||||
* Wrapper around drm_edid_read_ddc() for laptops with dual GPUs using one set
|
||||
* of outputs. The wrapper adds the requisite vga_switcheroo calls to
|
||||
* temporarily switch DDC to the GPU which is retrieving EDID.
|
||||
*
|
||||
* Return: Pointer to valid EDID or %NULL if we couldn't find any.
|
||||
*/
|
||||
const struct drm_edid *drm_edid_read_switcheroo(struct drm_connector *connector,
|
||||
struct i2c_adapter *adapter)
|
||||
{
|
||||
struct drm_device *dev = connector->dev;
|
||||
struct pci_dev *pdev = to_pci_dev(dev->dev);
|
||||
const struct drm_edid *drm_edid;
|
||||
|
||||
if (drm_WARN_ON_ONCE(dev, !dev_is_pci(dev->dev)))
|
||||
return NULL;
|
||||
|
||||
vga_switcheroo_lock_ddc(pdev);
|
||||
drm_edid = drm_edid_read_ddc(connector, adapter);
|
||||
vga_switcheroo_unlock_ddc(pdev);
|
||||
|
||||
return drm_edid;
|
||||
}
|
||||
EXPORT_SYMBOL(drm_edid_read_switcheroo);
|
||||
|
||||
/**
|
||||
* drm_edid_duplicate - duplicate an EDID and the extensions
|
||||
* @edid: EDID to duplicate
|
||||
@@ -2852,6 +2881,9 @@ EXPORT_SYMBOL(drm_get_edid_switcheroo);
|
||||
*/
|
||||
struct edid *drm_edid_duplicate(const struct edid *edid)
|
||||
{
|
||||
if (!edid)
|
||||
return NULL;
|
||||
|
||||
return kmemdup(edid, edid_size(edid), GFP_KERNEL);
|
||||
}
|
||||
EXPORT_SYMBOL(drm_edid_duplicate);
|
||||
@@ -6243,6 +6275,9 @@ static void drm_parse_cea_ext(struct drm_connector *connector,
|
||||
info->color_formats |= DRM_COLOR_FORMAT_YCBCR444;
|
||||
if (edid_ext[3] & EDID_CEA_YCRCB422)
|
||||
info->color_formats |= DRM_COLOR_FORMAT_YCBCR422;
|
||||
if (edid_ext[3] & EDID_BASIC_AUDIO)
|
||||
info->has_audio = true;
|
||||
|
||||
}
|
||||
drm_edid_iter_end(&edid_iter);
|
||||
|
||||
@@ -6268,6 +6303,8 @@ static void drm_parse_cea_ext(struct drm_connector *connector,
|
||||
drm_parse_hdr_metadata_block(connector, data);
|
||||
else if (cea_db_tag(db) == CTA_DB_VIDEO)
|
||||
parse_cta_vdb(connector, db);
|
||||
else if (cea_db_tag(db) == CTA_DB_AUDIO)
|
||||
info->has_audio = true;
|
||||
}
|
||||
cea_db_iter_end(&iter);
|
||||
|
||||
@@ -6424,6 +6461,7 @@ static void drm_reset_display_info(struct drm_connector *connector)
|
||||
info->max_tmds_clock = 0;
|
||||
info->dvi_dual = false;
|
||||
info->is_hdmi = false;
|
||||
info->has_audio = false;
|
||||
info->has_hdmi_infoframe = false;
|
||||
info->rgb_quant_range_selectable = false;
|
||||
memset(&info->hdmi, 0, sizeof(info->hdmi));
|
||||
|
||||
@@ -23,10 +23,6 @@ subdir-ccflags-y += $(call cc-disable-warning, unused-but-set-variable)
|
||||
subdir-ccflags-y += $(call cc-disable-warning, frame-address)
|
||||
subdir-ccflags-$(CONFIG_DRM_I915_WERROR) += -Werror
|
||||
|
||||
# Fine grained warnings disable
|
||||
CFLAGS_i915_pci.o = $(call cc-disable-warning, override-init)
|
||||
CFLAGS_display/intel_fbdev.o = $(call cc-disable-warning, override-init)
|
||||
|
||||
subdir-ccflags-y += -I$(srctree)/$(src)
|
||||
|
||||
# Please keep these build lists sorted!
|
||||
@@ -238,9 +234,12 @@ i915-y += \
|
||||
display/intel_crtc_state_dump.o \
|
||||
display/intel_cursor.o \
|
||||
display/intel_display.o \
|
||||
display/intel_display_driver.o \
|
||||
display/intel_display_irq.o \
|
||||
display/intel_display_power.o \
|
||||
display/intel_display_power_map.o \
|
||||
display/intel_display_power_well.o \
|
||||
display/intel_display_reset.o \
|
||||
display/intel_display_rps.o \
|
||||
display/intel_dmc.o \
|
||||
display/intel_dpio_phy.o \
|
||||
@@ -259,8 +258,11 @@ i915-y += \
|
||||
display/intel_hdcp.o \
|
||||
display/intel_hdcp_gsc.o \
|
||||
display/intel_hotplug.o \
|
||||
display/intel_hotplug_irq.o \
|
||||
display/intel_hti.o \
|
||||
display/intel_load_detect.o \
|
||||
display/intel_lpe_audio.o \
|
||||
display/intel_modeset_lock.o \
|
||||
display/intel_modeset_verify.o \
|
||||
display/intel_modeset_setup.o \
|
||||
display/intel_overlay.o \
|
||||
@@ -299,8 +301,10 @@ i915-y += \
|
||||
display/icl_dsi.o \
|
||||
display/intel_backlight.o \
|
||||
display/intel_crt.o \
|
||||
display/intel_cx0_phy.o \
|
||||
display/intel_ddi.o \
|
||||
display/intel_ddi_buf_trans.o \
|
||||
display/intel_display_device.o \
|
||||
display/intel_display_trace.o \
|
||||
display/intel_dkl_phy.o \
|
||||
display/intel_dp.o \
|
||||
|
||||
@@ -169,7 +169,7 @@ static void assert_dp_port(struct intel_dp *intel_dp, bool state)
|
||||
struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
|
||||
bool cur_state = intel_de_read(dev_priv, intel_dp->output_reg) & DP_PORT_EN;
|
||||
|
||||
I915_STATE_WARN(cur_state != state,
|
||||
I915_STATE_WARN(dev_priv, cur_state != state,
|
||||
"[ENCODER:%d:%s] state assertion failure (expected %s, current %s)\n",
|
||||
dig_port->base.base.base.id, dig_port->base.base.name,
|
||||
str_on_off(state), str_on_off(cur_state));
|
||||
@@ -180,7 +180,7 @@ static void assert_edp_pll(struct drm_i915_private *dev_priv, bool state)
|
||||
{
|
||||
bool cur_state = intel_de_read(dev_priv, DP_A) & DP_PLL_ENABLE;
|
||||
|
||||
I915_STATE_WARN(cur_state != state,
|
||||
I915_STATE_WARN(dev_priv, cur_state != state,
|
||||
"eDP PLL state assertion failure (expected %s, current %s)\n",
|
||||
str_on_off(state), str_on_off(cur_state));
|
||||
}
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
|
||||
#include "g4x_hdmi.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_audio.h"
|
||||
#include "intel_connector.h"
|
||||
#include "intel_crtc.h"
|
||||
@@ -80,15 +81,67 @@ static bool intel_hdmi_get_hw_state(struct intel_encoder *encoder,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static bool connector_is_hdmi(struct drm_connector *connector)
|
||||
{
|
||||
struct intel_encoder *encoder =
|
||||
intel_attached_encoder(to_intel_connector(connector));
|
||||
|
||||
return encoder && encoder->type == INTEL_OUTPUT_HDMI;
|
||||
}
|
||||
|
||||
static bool g4x_compute_has_hdmi_sink(struct intel_atomic_state *state,
|
||||
struct intel_crtc *this_crtc)
|
||||
{
|
||||
const struct drm_connector_state *conn_state;
|
||||
struct drm_connector *connector;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* On g4x only one HDMI port can transmit infoframes/audio at
|
||||
* any given time. Select the first suitable port for this duty.
|
||||
*
|
||||
* See also g4x_hdmi_connector_atomic_check().
|
||||
*/
|
||||
for_each_new_connector_in_state(&state->base, connector, conn_state, i) {
|
||||
struct intel_encoder *encoder = to_intel_encoder(conn_state->best_encoder);
|
||||
const struct intel_crtc_state *crtc_state;
|
||||
struct intel_crtc *crtc;
|
||||
|
||||
if (!connector_is_hdmi(connector))
|
||||
continue;
|
||||
|
||||
crtc = to_intel_crtc(conn_state->crtc);
|
||||
if (!crtc)
|
||||
continue;
|
||||
|
||||
crtc_state = intel_atomic_get_new_crtc_state(state, crtc);
|
||||
|
||||
if (!intel_hdmi_compute_has_hdmi_sink(encoder, crtc_state, conn_state))
|
||||
continue;
|
||||
|
||||
return crtc == this_crtc;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static int g4x_hdmi_compute_config(struct intel_encoder *encoder,
|
||||
struct intel_crtc_state *crtc_state,
|
||||
struct drm_connector_state *conn_state)
|
||||
{
|
||||
struct intel_atomic_state *state = to_intel_atomic_state(crtc_state->uapi.state);
|
||||
struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
|
||||
if (HAS_PCH_SPLIT(i915))
|
||||
crtc_state->has_pch_encoder = true;
|
||||
|
||||
if (IS_G4X(i915))
|
||||
crtc_state->has_hdmi_sink = g4x_compute_has_hdmi_sink(state, crtc);
|
||||
else
|
||||
crtc_state->has_hdmi_sink =
|
||||
intel_hdmi_compute_has_hdmi_sink(encoder, crtc_state, conn_state);
|
||||
|
||||
return intel_hdmi_compute_config(encoder, crtc_state, conn_state);
|
||||
}
|
||||
|
||||
@@ -546,6 +599,66 @@ intel_hdmi_hotplug(struct intel_encoder *encoder,
|
||||
return state;
|
||||
}
|
||||
|
||||
int g4x_hdmi_connector_atomic_check(struct drm_connector *connector,
|
||||
struct drm_atomic_state *state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(state->dev);
|
||||
struct drm_connector_list_iter conn_iter;
|
||||
struct drm_connector *conn;
|
||||
int ret;
|
||||
|
||||
ret = intel_digital_connector_atomic_check(connector, state);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (!IS_G4X(i915))
|
||||
return 0;
|
||||
|
||||
if (!intel_connector_needs_modeset(to_intel_atomic_state(state), connector))
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* On g4x only one HDMI port can transmit infoframes/audio
|
||||
* at any given time. Make sure all enabled HDMI ports are
|
||||
* included in the state so that it's possible to select
|
||||
* one of them for this duty.
|
||||
*
|
||||
* See also g4x_compute_has_hdmi_sink().
|
||||
*/
|
||||
drm_connector_list_iter_begin(&i915->drm, &conn_iter);
|
||||
drm_for_each_connector_iter(conn, &conn_iter) {
|
||||
struct drm_connector_state *conn_state;
|
||||
struct drm_crtc_state *crtc_state;
|
||||
struct drm_crtc *crtc;
|
||||
|
||||
if (!connector_is_hdmi(conn))
|
||||
continue;
|
||||
|
||||
drm_dbg_kms(&i915->drm, "Adding [CONNECTOR:%d:%s]\n",
|
||||
conn->base.id, conn->name);
|
||||
|
||||
conn_state = drm_atomic_get_connector_state(state, conn);
|
||||
if (IS_ERR(conn_state)) {
|
||||
ret = PTR_ERR(conn_state);
|
||||
break;
|
||||
}
|
||||
|
||||
crtc = conn_state->crtc;
|
||||
if (!crtc)
|
||||
continue;
|
||||
|
||||
crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
|
||||
crtc_state->mode_changed = true;
|
||||
|
||||
ret = drm_atomic_add_affected_planes(state, crtc);
|
||||
if (ret)
|
||||
break;
|
||||
}
|
||||
drm_connector_list_iter_end(&conn_iter);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void g4x_hdmi_init(struct drm_i915_private *dev_priv,
|
||||
i915_reg_t hdmi_reg, enum port port)
|
||||
{
|
||||
|
||||
@@ -11,9 +11,13 @@
|
||||
#include "i915_reg_defs.h"
|
||||
|
||||
enum port;
|
||||
struct drm_atomic_state;
|
||||
struct drm_connector;
|
||||
struct drm_i915_private;
|
||||
|
||||
void g4x_hdmi_init(struct drm_i915_private *dev_priv,
|
||||
i915_reg_t hdmi_reg, enum port port);
|
||||
int g4x_hdmi_connector_atomic_check(struct drm_connector *connector,
|
||||
struct drm_atomic_state *state);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -8,12 +8,12 @@
|
||||
#include <drm/drm_blend.h>
|
||||
#include <drm/drm_fourcc.h>
|
||||
|
||||
#include "i915_irq.h"
|
||||
#include "i915_reg.h"
|
||||
#include "i9xx_plane.h"
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_atomic_plane.h"
|
||||
#include "intel_de.h"
|
||||
#include "intel_display_irq.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_fb.h"
|
||||
#include "intel_fbc.h"
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
*/
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i915_reg.h"
|
||||
#include "i9xx_wm.h"
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_display.h"
|
||||
@@ -3447,9 +3448,10 @@ void ilk_wm_sanitize(struct drm_i915_private *dev_priv)
|
||||
|
||||
drm_modeset_acquire_init(&ctx, 0);
|
||||
|
||||
retry:
|
||||
state->acquire_ctx = &ctx;
|
||||
to_intel_atomic_state(state)->internal = true;
|
||||
|
||||
retry:
|
||||
/*
|
||||
* Hardware readout is the only time we don't want to calculate
|
||||
* intermediate watermarks (since we don't trust the current
|
||||
|
||||
@@ -12,7 +12,6 @@ struct drm_i915_private;
|
||||
struct intel_crtc_state;
|
||||
struct intel_plane_state;
|
||||
|
||||
int ilk_wm_max_level(const struct drm_i915_private *i915);
|
||||
bool ilk_disable_lp_wm(struct drm_i915_private *i915);
|
||||
void ilk_wm_sanitize(struct drm_i915_private *i915);
|
||||
bool intel_set_memory_cxsr(struct drm_i915_private *i915, bool enable);
|
||||
|
||||
@@ -1591,6 +1591,7 @@ static int gen11_dsi_compute_config(struct intel_encoder *encoder,
|
||||
&pipe_config->hw.adjusted_mode;
|
||||
int ret;
|
||||
|
||||
pipe_config->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
|
||||
ret = intel_panel_compute_config(intel_connector, adjusted_mode);
|
||||
|
||||
@@ -265,7 +265,6 @@ intel_crtc_duplicate_state(struct drm_crtc *crtc)
|
||||
crtc_state->update_wm_post = false;
|
||||
crtc_state->fifo_changed = false;
|
||||
crtc_state->preload_luts = false;
|
||||
crtc_state->inherited = false;
|
||||
crtc_state->wm.need_postvbl_update = false;
|
||||
crtc_state->do_async_flip = false;
|
||||
crtc_state->fb_bits = 0;
|
||||
@@ -311,262 +310,6 @@ intel_crtc_destroy_state(struct drm_crtc *crtc,
|
||||
kfree(crtc_state);
|
||||
}
|
||||
|
||||
static int intel_atomic_setup_scaler(struct intel_crtc_scaler_state *scaler_state,
|
||||
int num_scalers_need, struct intel_crtc *intel_crtc,
|
||||
const char *name, int idx,
|
||||
struct intel_plane_state *plane_state,
|
||||
int *scaler_id)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(intel_crtc->base.dev);
|
||||
int j;
|
||||
u32 mode;
|
||||
|
||||
if (*scaler_id < 0) {
|
||||
/* find a free scaler */
|
||||
for (j = 0; j < intel_crtc->num_scalers; j++) {
|
||||
if (scaler_state->scalers[j].in_use)
|
||||
continue;
|
||||
|
||||
*scaler_id = j;
|
||||
scaler_state->scalers[*scaler_id].in_use = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (drm_WARN(&dev_priv->drm, *scaler_id < 0,
|
||||
"Cannot find scaler for %s:%d\n", name, idx))
|
||||
return -EINVAL;
|
||||
|
||||
/* set scaler mode */
|
||||
if (plane_state && plane_state->hw.fb &&
|
||||
plane_state->hw.fb->format->is_yuv &&
|
||||
plane_state->hw.fb->format->num_planes > 1) {
|
||||
struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
|
||||
if (DISPLAY_VER(dev_priv) == 9) {
|
||||
mode = SKL_PS_SCALER_MODE_NV12;
|
||||
} else if (icl_is_hdr_plane(dev_priv, plane->id)) {
|
||||
/*
|
||||
* On gen11+'s HDR planes we only use the scaler for
|
||||
* scaling. They have a dedicated chroma upsampler, so
|
||||
* we don't need the scaler to upsample the UV plane.
|
||||
*/
|
||||
mode = PS_SCALER_MODE_NORMAL;
|
||||
} else {
|
||||
struct intel_plane *linked =
|
||||
plane_state->planar_linked_plane;
|
||||
|
||||
mode = PS_SCALER_MODE_PLANAR;
|
||||
|
||||
if (linked)
|
||||
mode |= PS_PLANE_Y_SEL(linked->id);
|
||||
}
|
||||
} else if (DISPLAY_VER(dev_priv) >= 10) {
|
||||
mode = PS_SCALER_MODE_NORMAL;
|
||||
} else if (num_scalers_need == 1 && intel_crtc->num_scalers > 1) {
|
||||
/*
|
||||
* when only 1 scaler is in use on a pipe with 2 scalers
|
||||
* scaler 0 operates in high quality (HQ) mode.
|
||||
* In this case use scaler 0 to take advantage of HQ mode
|
||||
*/
|
||||
scaler_state->scalers[*scaler_id].in_use = 0;
|
||||
*scaler_id = 0;
|
||||
scaler_state->scalers[0].in_use = 1;
|
||||
mode = SKL_PS_SCALER_MODE_HQ;
|
||||
} else {
|
||||
mode = SKL_PS_SCALER_MODE_DYN;
|
||||
}
|
||||
|
||||
/*
|
||||
* FIXME: we should also check the scaler factors for pfit, so
|
||||
* this shouldn't be tied directly to planes.
|
||||
*/
|
||||
if (plane_state && plane_state->hw.fb) {
|
||||
const struct drm_framebuffer *fb = plane_state->hw.fb;
|
||||
const struct drm_rect *src = &plane_state->uapi.src;
|
||||
const struct drm_rect *dst = &plane_state->uapi.dst;
|
||||
int hscale, vscale, max_vscale, max_hscale;
|
||||
|
||||
/*
|
||||
* FIXME: When two scalers are needed, but only one of
|
||||
* them needs to downscale, we should make sure that
|
||||
* the one that needs downscaling support is assigned
|
||||
* as the first scaler, so we don't reject downscaling
|
||||
* unnecessarily.
|
||||
*/
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 14) {
|
||||
/*
|
||||
* On versions 14 and up, only the first
|
||||
* scaler supports a vertical scaling factor
|
||||
* of more than 1.0, while a horizontal
|
||||
* scaling factor of 3.0 is supported.
|
||||
*/
|
||||
max_hscale = 0x30000 - 1;
|
||||
if (*scaler_id == 0)
|
||||
max_vscale = 0x30000 - 1;
|
||||
else
|
||||
max_vscale = 0x10000;
|
||||
|
||||
} else if (DISPLAY_VER(dev_priv) >= 10 ||
|
||||
!intel_format_info_is_yuv_semiplanar(fb->format, fb->modifier)) {
|
||||
max_hscale = 0x30000 - 1;
|
||||
max_vscale = 0x30000 - 1;
|
||||
} else {
|
||||
max_hscale = 0x20000 - 1;
|
||||
max_vscale = 0x20000 - 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* FIXME: We should change the if-else block above to
|
||||
* support HQ vs dynamic scaler properly.
|
||||
*/
|
||||
|
||||
/* Check if required scaling is within limits */
|
||||
hscale = drm_rect_calc_hscale(src, dst, 1, max_hscale);
|
||||
vscale = drm_rect_calc_vscale(src, dst, 1, max_vscale);
|
||||
|
||||
if (hscale < 0 || vscale < 0) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"Scaler %d doesn't support required plane scaling\n",
|
||||
*scaler_id);
|
||||
drm_rect_debug_print("src: ", src, true);
|
||||
drm_rect_debug_print("dst: ", dst, false);
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
drm_dbg_kms(&dev_priv->drm, "Attached scaler id %u.%u to %s:%d\n",
|
||||
intel_crtc->pipe, *scaler_id, name, idx);
|
||||
scaler_state->scalers[*scaler_id].mode = mode;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* intel_atomic_setup_scalers() - setup scalers for crtc per staged requests
|
||||
* @dev_priv: i915 device
|
||||
* @intel_crtc: intel crtc
|
||||
* @crtc_state: incoming crtc_state to validate and setup scalers
|
||||
*
|
||||
* This function sets up scalers based on staged scaling requests for
|
||||
* a @crtc and its planes. It is called from crtc level check path. If request
|
||||
* is a supportable request, it attaches scalers to requested planes and crtc.
|
||||
*
|
||||
* This function takes into account the current scaler(s) in use by any planes
|
||||
* not being part of this atomic state
|
||||
*
|
||||
* Returns:
|
||||
* 0 - scalers were setup succesfully
|
||||
* error code - otherwise
|
||||
*/
|
||||
int intel_atomic_setup_scalers(struct drm_i915_private *dev_priv,
|
||||
struct intel_crtc *intel_crtc,
|
||||
struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_plane *plane = NULL;
|
||||
struct intel_plane *intel_plane;
|
||||
struct intel_plane_state *plane_state = NULL;
|
||||
struct intel_crtc_scaler_state *scaler_state =
|
||||
&crtc_state->scaler_state;
|
||||
struct drm_atomic_state *drm_state = crtc_state->uapi.state;
|
||||
struct intel_atomic_state *intel_state = to_intel_atomic_state(drm_state);
|
||||
int num_scalers_need;
|
||||
int i;
|
||||
|
||||
num_scalers_need = hweight32(scaler_state->scaler_users);
|
||||
|
||||
/*
|
||||
* High level flow:
|
||||
* - staged scaler requests are already in scaler_state->scaler_users
|
||||
* - check whether staged scaling requests can be supported
|
||||
* - add planes using scalers that aren't in current transaction
|
||||
* - assign scalers to requested users
|
||||
* - as part of plane commit, scalers will be committed
|
||||
* (i.e., either attached or detached) to respective planes in hw
|
||||
* - as part of crtc_commit, scaler will be either attached or detached
|
||||
* to crtc in hw
|
||||
*/
|
||||
|
||||
/* fail if required scalers > available scalers */
|
||||
if (num_scalers_need > intel_crtc->num_scalers){
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"Too many scaling requests %d > %d\n",
|
||||
num_scalers_need, intel_crtc->num_scalers);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* walkthrough scaler_users bits and start assigning scalers */
|
||||
for (i = 0; i < sizeof(scaler_state->scaler_users) * 8; i++) {
|
||||
int *scaler_id;
|
||||
const char *name;
|
||||
int idx, ret;
|
||||
|
||||
/* skip if scaler not required */
|
||||
if (!(scaler_state->scaler_users & (1 << i)))
|
||||
continue;
|
||||
|
||||
if (i == SKL_CRTC_INDEX) {
|
||||
name = "CRTC";
|
||||
idx = intel_crtc->base.base.id;
|
||||
|
||||
/* panel fitter case: assign as a crtc scaler */
|
||||
scaler_id = &scaler_state->scaler_id;
|
||||
} else {
|
||||
name = "PLANE";
|
||||
|
||||
/* plane scaler case: assign as a plane scaler */
|
||||
/* find the plane that set the bit as scaler_user */
|
||||
plane = drm_state->planes[i].ptr;
|
||||
|
||||
/*
|
||||
* to enable/disable hq mode, add planes that are using scaler
|
||||
* into this transaction
|
||||
*/
|
||||
if (!plane) {
|
||||
struct drm_plane_state *state;
|
||||
|
||||
/*
|
||||
* GLK+ scalers don't have a HQ mode so it
|
||||
* isn't necessary to change between HQ and dyn mode
|
||||
* on those platforms.
|
||||
*/
|
||||
if (DISPLAY_VER(dev_priv) >= 10)
|
||||
continue;
|
||||
|
||||
plane = drm_plane_from_index(&dev_priv->drm, i);
|
||||
state = drm_atomic_get_plane_state(drm_state, plane);
|
||||
if (IS_ERR(state)) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"Failed to add [PLANE:%d] to drm_state\n",
|
||||
plane->base.id);
|
||||
return PTR_ERR(state);
|
||||
}
|
||||
}
|
||||
|
||||
intel_plane = to_intel_plane(plane);
|
||||
idx = plane->base.id;
|
||||
|
||||
/* plane on different crtc cannot be a scaler user of this crtc */
|
||||
if (drm_WARN_ON(&dev_priv->drm,
|
||||
intel_plane->pipe != intel_crtc->pipe))
|
||||
continue;
|
||||
|
||||
plane_state = intel_atomic_get_new_plane_state(intel_state,
|
||||
intel_plane);
|
||||
scaler_id = &plane_state->scaler_id;
|
||||
}
|
||||
|
||||
ret = intel_atomic_setup_scaler(scaler_state, num_scalers_need,
|
||||
intel_crtc, name, idx,
|
||||
plane_state, scaler_id);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct drm_atomic_state *
|
||||
intel_atomic_state_alloc(struct drm_device *dev)
|
||||
{
|
||||
@@ -599,6 +342,8 @@ void intel_atomic_state_clear(struct drm_atomic_state *s)
|
||||
drm_atomic_state_default_clear(&state->base);
|
||||
intel_atomic_clear_global_state(state);
|
||||
|
||||
/* state->internal not reset on purpose */
|
||||
|
||||
state->dpll_set = state->modeset = false;
|
||||
}
|
||||
|
||||
|
||||
@@ -52,8 +52,4 @@ struct intel_crtc_state *
|
||||
intel_atomic_get_crtc_state(struct drm_atomic_state *state,
|
||||
struct intel_crtc *crtc);
|
||||
|
||||
int intel_atomic_setup_scalers(struct drm_i915_private *dev_priv,
|
||||
struct intel_crtc *intel_crtc,
|
||||
struct intel_crtc_state *crtc_state);
|
||||
|
||||
#endif /* __INTEL_ATOMIC_H__ */
|
||||
|
||||
@@ -36,6 +36,7 @@
|
||||
#include <drm/drm_fourcc.h>
|
||||
|
||||
#include "i915_config.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_atomic_plane.h"
|
||||
#include "intel_cdclk.h"
|
||||
#include "intel_display_rps.h"
|
||||
|
||||
@@ -1039,6 +1039,7 @@ static void glk_force_audio_cdclk(struct drm_i915_private *i915,
|
||||
return;
|
||||
|
||||
state->acquire_ctx = &ctx;
|
||||
to_intel_atomic_state(state)->internal = true;
|
||||
|
||||
retry:
|
||||
ret = glk_force_audio_cdclk_commit(to_intel_atomic_state(state), crtc,
|
||||
|
||||
@@ -2141,58 +2141,58 @@ static u8 translate_iboost(u8 val)
|
||||
|
||||
static const u8 cnp_ddc_pin_map[] = {
|
||||
[0] = 0, /* N/A */
|
||||
[DDC_BUS_DDI_B] = GMBUS_PIN_1_BXT,
|
||||
[DDC_BUS_DDI_C] = GMBUS_PIN_2_BXT,
|
||||
[DDC_BUS_DDI_D] = GMBUS_PIN_4_CNP, /* sic */
|
||||
[DDC_BUS_DDI_F] = GMBUS_PIN_3_BXT, /* sic */
|
||||
[GMBUS_PIN_1_BXT] = DDC_BUS_DDI_B,
|
||||
[GMBUS_PIN_2_BXT] = DDC_BUS_DDI_C,
|
||||
[GMBUS_PIN_4_CNP] = DDC_BUS_DDI_D, /* sic */
|
||||
[GMBUS_PIN_3_BXT] = DDC_BUS_DDI_F, /* sic */
|
||||
};
|
||||
|
||||
static const u8 icp_ddc_pin_map[] = {
|
||||
[ICL_DDC_BUS_DDI_A] = GMBUS_PIN_1_BXT,
|
||||
[ICL_DDC_BUS_DDI_B] = GMBUS_PIN_2_BXT,
|
||||
[TGL_DDC_BUS_DDI_C] = GMBUS_PIN_3_BXT,
|
||||
[ICL_DDC_BUS_PORT_1] = GMBUS_PIN_9_TC1_ICP,
|
||||
[ICL_DDC_BUS_PORT_2] = GMBUS_PIN_10_TC2_ICP,
|
||||
[ICL_DDC_BUS_PORT_3] = GMBUS_PIN_11_TC3_ICP,
|
||||
[ICL_DDC_BUS_PORT_4] = GMBUS_PIN_12_TC4_ICP,
|
||||
[TGL_DDC_BUS_PORT_5] = GMBUS_PIN_13_TC5_TGP,
|
||||
[TGL_DDC_BUS_PORT_6] = GMBUS_PIN_14_TC6_TGP,
|
||||
[GMBUS_PIN_1_BXT] = ICL_DDC_BUS_DDI_A,
|
||||
[GMBUS_PIN_2_BXT] = ICL_DDC_BUS_DDI_B,
|
||||
[GMBUS_PIN_3_BXT] = TGL_DDC_BUS_DDI_C,
|
||||
[GMBUS_PIN_9_TC1_ICP] = ICL_DDC_BUS_PORT_1,
|
||||
[GMBUS_PIN_10_TC2_ICP] = ICL_DDC_BUS_PORT_2,
|
||||
[GMBUS_PIN_11_TC3_ICP] = ICL_DDC_BUS_PORT_3,
|
||||
[GMBUS_PIN_12_TC4_ICP] = ICL_DDC_BUS_PORT_4,
|
||||
[GMBUS_PIN_13_TC5_TGP] = TGL_DDC_BUS_PORT_5,
|
||||
[GMBUS_PIN_14_TC6_TGP] = TGL_DDC_BUS_PORT_6,
|
||||
};
|
||||
|
||||
static const u8 rkl_pch_tgp_ddc_pin_map[] = {
|
||||
[ICL_DDC_BUS_DDI_A] = GMBUS_PIN_1_BXT,
|
||||
[ICL_DDC_BUS_DDI_B] = GMBUS_PIN_2_BXT,
|
||||
[RKL_DDC_BUS_DDI_D] = GMBUS_PIN_9_TC1_ICP,
|
||||
[RKL_DDC_BUS_DDI_E] = GMBUS_PIN_10_TC2_ICP,
|
||||
[GMBUS_PIN_1_BXT] = ICL_DDC_BUS_DDI_A,
|
||||
[GMBUS_PIN_2_BXT] = ICL_DDC_BUS_DDI_B,
|
||||
[GMBUS_PIN_9_TC1_ICP] = RKL_DDC_BUS_DDI_D,
|
||||
[GMBUS_PIN_10_TC2_ICP] = RKL_DDC_BUS_DDI_E,
|
||||
};
|
||||
|
||||
static const u8 adls_ddc_pin_map[] = {
|
||||
[ICL_DDC_BUS_DDI_A] = GMBUS_PIN_1_BXT,
|
||||
[ADLS_DDC_BUS_PORT_TC1] = GMBUS_PIN_9_TC1_ICP,
|
||||
[ADLS_DDC_BUS_PORT_TC2] = GMBUS_PIN_10_TC2_ICP,
|
||||
[ADLS_DDC_BUS_PORT_TC3] = GMBUS_PIN_11_TC3_ICP,
|
||||
[ADLS_DDC_BUS_PORT_TC4] = GMBUS_PIN_12_TC4_ICP,
|
||||
[GMBUS_PIN_1_BXT] = ICL_DDC_BUS_DDI_A,
|
||||
[GMBUS_PIN_9_TC1_ICP] = ADLS_DDC_BUS_PORT_TC1,
|
||||
[GMBUS_PIN_10_TC2_ICP] = ADLS_DDC_BUS_PORT_TC2,
|
||||
[GMBUS_PIN_11_TC3_ICP] = ADLS_DDC_BUS_PORT_TC3,
|
||||
[GMBUS_PIN_12_TC4_ICP] = ADLS_DDC_BUS_PORT_TC4,
|
||||
};
|
||||
|
||||
static const u8 gen9bc_tgp_ddc_pin_map[] = {
|
||||
[DDC_BUS_DDI_B] = GMBUS_PIN_2_BXT,
|
||||
[DDC_BUS_DDI_C] = GMBUS_PIN_9_TC1_ICP,
|
||||
[DDC_BUS_DDI_D] = GMBUS_PIN_10_TC2_ICP,
|
||||
[GMBUS_PIN_2_BXT] = DDC_BUS_DDI_B,
|
||||
[GMBUS_PIN_9_TC1_ICP] = DDC_BUS_DDI_C,
|
||||
[GMBUS_PIN_10_TC2_ICP] = DDC_BUS_DDI_D,
|
||||
};
|
||||
|
||||
static const u8 adlp_ddc_pin_map[] = {
|
||||
[ICL_DDC_BUS_DDI_A] = GMBUS_PIN_1_BXT,
|
||||
[ICL_DDC_BUS_DDI_B] = GMBUS_PIN_2_BXT,
|
||||
[ADLP_DDC_BUS_PORT_TC1] = GMBUS_PIN_9_TC1_ICP,
|
||||
[ADLP_DDC_BUS_PORT_TC2] = GMBUS_PIN_10_TC2_ICP,
|
||||
[ADLP_DDC_BUS_PORT_TC3] = GMBUS_PIN_11_TC3_ICP,
|
||||
[ADLP_DDC_BUS_PORT_TC4] = GMBUS_PIN_12_TC4_ICP,
|
||||
[GMBUS_PIN_1_BXT] = ICL_DDC_BUS_DDI_A,
|
||||
[GMBUS_PIN_2_BXT] = ICL_DDC_BUS_DDI_B,
|
||||
[GMBUS_PIN_9_TC1_ICP] = ADLP_DDC_BUS_PORT_TC1,
|
||||
[GMBUS_PIN_10_TC2_ICP] = ADLP_DDC_BUS_PORT_TC2,
|
||||
[GMBUS_PIN_11_TC3_ICP] = ADLP_DDC_BUS_PORT_TC3,
|
||||
[GMBUS_PIN_12_TC4_ICP] = ADLP_DDC_BUS_PORT_TC4,
|
||||
};
|
||||
|
||||
static u8 map_ddc_pin(struct drm_i915_private *i915, u8 vbt_pin)
|
||||
{
|
||||
const u8 *ddc_pin_map;
|
||||
int n_entries;
|
||||
int i, n_entries;
|
||||
|
||||
if (HAS_PCH_MTP(i915) || IS_ALDERLAKE_P(i915)) {
|
||||
ddc_pin_map = adlp_ddc_pin_map;
|
||||
@@ -2219,8 +2219,10 @@ static u8 map_ddc_pin(struct drm_i915_private *i915, u8 vbt_pin)
|
||||
return vbt_pin;
|
||||
}
|
||||
|
||||
if (vbt_pin < n_entries && ddc_pin_map[vbt_pin] != 0)
|
||||
return ddc_pin_map[vbt_pin];
|
||||
for (i = 0; i < n_entries; i++) {
|
||||
if (ddc_pin_map[i] == vbt_pin)
|
||||
return i;
|
||||
}
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"Ignoring alternate pin: VBT claims DDC pin %d, which is not valid for this platform\n",
|
||||
@@ -2675,8 +2677,9 @@ static void print_ddi_port(const struct intel_bios_encoder_data *devdata,
|
||||
supports_tbt = intel_bios_encoder_supports_tbt(devdata);
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"Port %c VBT info: CRT:%d DVI:%d HDMI:%d DP:%d eDP:%d DSI:%d LSPCON:%d USB-Type-C:%d TBT:%d DSC:%d\n",
|
||||
"Port %c VBT info: CRT:%d DVI:%d HDMI:%d DP:%d eDP:%d DSI:%d DP++:%d LSPCON:%d USB-Type-C:%d TBT:%d DSC:%d\n",
|
||||
port_name(port), is_crt, is_dvi, is_hdmi, is_dp, is_edp, is_dsi,
|
||||
intel_bios_encoder_supports_dp_dual_mode(devdata),
|
||||
intel_bios_encoder_is_lspcon(devdata),
|
||||
supports_typec_usb, supports_tbt,
|
||||
devdata->dsc != NULL);
|
||||
@@ -3030,6 +3033,13 @@ bool intel_bios_is_valid_vbt(const void *buf, size_t size)
|
||||
return vbt;
|
||||
}
|
||||
|
||||
static u32 intel_spi_read(struct intel_uncore *uncore, u32 offset)
|
||||
{
|
||||
intel_uncore_write(uncore, PRIMARY_SPI_ADDRESS, offset);
|
||||
|
||||
return intel_uncore_read(uncore, PRIMARY_SPI_TRIGGER);
|
||||
}
|
||||
|
||||
static struct vbt_header *spi_oprom_get_vbt(struct drm_i915_private *i915)
|
||||
{
|
||||
u32 count, data, found, store = 0;
|
||||
@@ -3046,9 +3056,7 @@ static struct vbt_header *spi_oprom_get_vbt(struct drm_i915_private *i915)
|
||||
oprom_offset &= OROM_OFFSET_MASK;
|
||||
|
||||
for (count = 0; count < oprom_size; count += 4) {
|
||||
intel_uncore_write(&i915->uncore, PRIMARY_SPI_ADDRESS, oprom_offset + count);
|
||||
data = intel_uncore_read(&i915->uncore, PRIMARY_SPI_TRIGGER);
|
||||
|
||||
data = intel_spi_read(&i915->uncore, oprom_offset + count);
|
||||
if (data == *((const u32 *)"$VBT")) {
|
||||
found = oprom_offset + count;
|
||||
break;
|
||||
@@ -3059,20 +3067,16 @@ static struct vbt_header *spi_oprom_get_vbt(struct drm_i915_private *i915)
|
||||
goto err_not_found;
|
||||
|
||||
/* Get VBT size and allocate space for the VBT */
|
||||
intel_uncore_write(&i915->uncore, PRIMARY_SPI_ADDRESS, found +
|
||||
offsetof(struct vbt_header, vbt_size));
|
||||
vbt_size = intel_uncore_read(&i915->uncore, PRIMARY_SPI_TRIGGER);
|
||||
vbt_size = intel_spi_read(&i915->uncore,
|
||||
found + offsetof(struct vbt_header, vbt_size));
|
||||
vbt_size &= 0xffff;
|
||||
|
||||
vbt = kzalloc(round_up(vbt_size, 4), GFP_KERNEL);
|
||||
if (!vbt)
|
||||
goto err_not_found;
|
||||
|
||||
for (count = 0; count < vbt_size; count += 4) {
|
||||
intel_uncore_write(&i915->uncore, PRIMARY_SPI_ADDRESS, found + count);
|
||||
data = intel_uncore_read(&i915->uncore, PRIMARY_SPI_TRIGGER);
|
||||
*(vbt + store++) = data;
|
||||
}
|
||||
for (count = 0; count < vbt_size; count += 4)
|
||||
*(vbt + store++) = intel_spi_read(&i915->uncore, found + count);
|
||||
|
||||
if (!intel_bios_is_valid_vbt(vbt, vbt_size))
|
||||
goto err_free_vbt;
|
||||
@@ -3424,7 +3428,7 @@ bool intel_bios_is_port_present(struct drm_i915_private *i915, enum port port)
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool intel_bios_encoder_supports_dp_dual_mode(const struct intel_bios_encoder_data *devdata)
|
||||
bool intel_bios_encoder_supports_dp_dual_mode(const struct intel_bios_encoder_data *devdata)
|
||||
{
|
||||
const struct child_device_config *child = &devdata->child;
|
||||
|
||||
@@ -3443,15 +3447,6 @@ static bool intel_bios_encoder_supports_dp_dual_mode(const struct intel_bios_enc
|
||||
return false;
|
||||
}
|
||||
|
||||
bool intel_bios_is_port_dp_dual_mode(struct drm_i915_private *i915,
|
||||
enum port port)
|
||||
{
|
||||
const struct intel_bios_encoder_data *devdata =
|
||||
intel_bios_encoder_data_lookup(i915, port);
|
||||
|
||||
return devdata && intel_bios_encoder_supports_dp_dual_mode(devdata);
|
||||
}
|
||||
|
||||
/**
|
||||
* intel_bios_is_dsi_present - is DSI present in VBT
|
||||
* @i915: i915 device instance
|
||||
@@ -3578,84 +3573,82 @@ bool intel_bios_get_dsc_params(struct intel_encoder *encoder,
|
||||
return false;
|
||||
}
|
||||
|
||||
static const u8 adlp_aux_ch_map[] = {
|
||||
[AUX_CH_A] = DP_AUX_A,
|
||||
[AUX_CH_B] = DP_AUX_B,
|
||||
[AUX_CH_C] = DP_AUX_C,
|
||||
[AUX_CH_D_XELPD] = DP_AUX_D,
|
||||
[AUX_CH_E_XELPD] = DP_AUX_E,
|
||||
[AUX_CH_USBC1] = DP_AUX_F,
|
||||
[AUX_CH_USBC2] = DP_AUX_G,
|
||||
[AUX_CH_USBC3] = DP_AUX_H,
|
||||
[AUX_CH_USBC4] = DP_AUX_I,
|
||||
};
|
||||
|
||||
/*
|
||||
* ADL-S VBT uses PHY based mapping. Combo PHYs A,B,C,D,E
|
||||
* map to DDI A,TC1,TC2,TC3,TC4 respectively.
|
||||
*/
|
||||
static const u8 adls_aux_ch_map[] = {
|
||||
[AUX_CH_A] = DP_AUX_A,
|
||||
[AUX_CH_USBC1] = DP_AUX_B,
|
||||
[AUX_CH_USBC2] = DP_AUX_C,
|
||||
[AUX_CH_USBC3] = DP_AUX_D,
|
||||
[AUX_CH_USBC4] = DP_AUX_E,
|
||||
};
|
||||
|
||||
/*
|
||||
* RKL/DG1 VBT uses PHY based mapping. Combo PHYs A,B,C,D
|
||||
* map to DDI A,B,TC1,TC2 respectively.
|
||||
*/
|
||||
static const u8 rkl_aux_ch_map[] = {
|
||||
[AUX_CH_A] = DP_AUX_A,
|
||||
[AUX_CH_B] = DP_AUX_B,
|
||||
[AUX_CH_USBC1] = DP_AUX_C,
|
||||
[AUX_CH_USBC2] = DP_AUX_D,
|
||||
};
|
||||
|
||||
static const u8 direct_aux_ch_map[] = {
|
||||
[AUX_CH_A] = DP_AUX_A,
|
||||
[AUX_CH_B] = DP_AUX_B,
|
||||
[AUX_CH_C] = DP_AUX_C,
|
||||
[AUX_CH_D] = DP_AUX_D, /* aka AUX_CH_USBC1 */
|
||||
[AUX_CH_E] = DP_AUX_E, /* aka AUX_CH_USBC2 */
|
||||
[AUX_CH_F] = DP_AUX_F, /* aka AUX_CH_USBC3 */
|
||||
[AUX_CH_G] = DP_AUX_G, /* aka AUX_CH_USBC4 */
|
||||
[AUX_CH_H] = DP_AUX_H, /* aka AUX_CH_USBC5 */
|
||||
[AUX_CH_I] = DP_AUX_I, /* aka AUX_CH_USBC6 */
|
||||
};
|
||||
|
||||
static enum aux_ch map_aux_ch(struct drm_i915_private *i915, u8 aux_channel)
|
||||
{
|
||||
enum aux_ch aux_ch;
|
||||
const u8 *aux_ch_map;
|
||||
int i, n_entries;
|
||||
|
||||
/*
|
||||
* RKL/DG1 VBT uses PHY based mapping. Combo PHYs A,B,C,D
|
||||
* map to DDI A,B,TC1,TC2 respectively.
|
||||
*
|
||||
* ADL-S VBT uses PHY based mapping. Combo PHYs A,B,C,D,E
|
||||
* map to DDI A,TC1,TC2,TC3,TC4 respectively.
|
||||
*/
|
||||
switch (aux_channel) {
|
||||
case DP_AUX_A:
|
||||
aux_ch = AUX_CH_A;
|
||||
break;
|
||||
case DP_AUX_B:
|
||||
if (IS_ALDERLAKE_S(i915))
|
||||
aux_ch = AUX_CH_USBC1;
|
||||
else
|
||||
aux_ch = AUX_CH_B;
|
||||
break;
|
||||
case DP_AUX_C:
|
||||
if (IS_ALDERLAKE_S(i915))
|
||||
aux_ch = AUX_CH_USBC2;
|
||||
else if (IS_DG1(i915) || IS_ROCKETLAKE(i915))
|
||||
aux_ch = AUX_CH_USBC1;
|
||||
else
|
||||
aux_ch = AUX_CH_C;
|
||||
break;
|
||||
case DP_AUX_D:
|
||||
if (DISPLAY_VER(i915) >= 13)
|
||||
aux_ch = AUX_CH_D_XELPD;
|
||||
else if (IS_ALDERLAKE_S(i915))
|
||||
aux_ch = AUX_CH_USBC3;
|
||||
else if (IS_DG1(i915) || IS_ROCKETLAKE(i915))
|
||||
aux_ch = AUX_CH_USBC2;
|
||||
else
|
||||
aux_ch = AUX_CH_D;
|
||||
break;
|
||||
case DP_AUX_E:
|
||||
if (DISPLAY_VER(i915) >= 13)
|
||||
aux_ch = AUX_CH_E_XELPD;
|
||||
else if (IS_ALDERLAKE_S(i915))
|
||||
aux_ch = AUX_CH_USBC4;
|
||||
else
|
||||
aux_ch = AUX_CH_E;
|
||||
break;
|
||||
case DP_AUX_F:
|
||||
if (DISPLAY_VER(i915) >= 13)
|
||||
aux_ch = AUX_CH_USBC1;
|
||||
else
|
||||
aux_ch = AUX_CH_F;
|
||||
break;
|
||||
case DP_AUX_G:
|
||||
if (DISPLAY_VER(i915) >= 13)
|
||||
aux_ch = AUX_CH_USBC2;
|
||||
else
|
||||
aux_ch = AUX_CH_G;
|
||||
break;
|
||||
case DP_AUX_H:
|
||||
if (DISPLAY_VER(i915) >= 13)
|
||||
aux_ch = AUX_CH_USBC3;
|
||||
else
|
||||
aux_ch = AUX_CH_H;
|
||||
break;
|
||||
case DP_AUX_I:
|
||||
if (DISPLAY_VER(i915) >= 13)
|
||||
aux_ch = AUX_CH_USBC4;
|
||||
else
|
||||
aux_ch = AUX_CH_I;
|
||||
break;
|
||||
default:
|
||||
MISSING_CASE(aux_channel);
|
||||
aux_ch = AUX_CH_A;
|
||||
break;
|
||||
if (DISPLAY_VER(i915) >= 13) {
|
||||
aux_ch_map = adlp_aux_ch_map;
|
||||
n_entries = ARRAY_SIZE(adlp_aux_ch_map);
|
||||
} else if (IS_ALDERLAKE_S(i915)) {
|
||||
aux_ch_map = adls_aux_ch_map;
|
||||
n_entries = ARRAY_SIZE(adls_aux_ch_map);
|
||||
} else if (IS_DG1(i915) || IS_ROCKETLAKE(i915)) {
|
||||
aux_ch_map = rkl_aux_ch_map;
|
||||
n_entries = ARRAY_SIZE(rkl_aux_ch_map);
|
||||
} else {
|
||||
aux_ch_map = direct_aux_ch_map;
|
||||
n_entries = ARRAY_SIZE(direct_aux_ch_map);
|
||||
}
|
||||
|
||||
return aux_ch;
|
||||
for (i = 0; i < n_entries; i++) {
|
||||
if (aux_ch_map[i] == aux_channel)
|
||||
return i;
|
||||
}
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"Ignoring alternate AUX CH: VBT claims AUX 0x%x, which is not valid for this platform\n",
|
||||
aux_channel);
|
||||
|
||||
return AUX_CH_NONE;
|
||||
}
|
||||
|
||||
enum aux_ch intel_bios_dp_aux_ch(const struct intel_bios_encoder_data *devdata)
|
||||
|
||||
@@ -247,7 +247,6 @@ bool intel_bios_is_tv_present(struct drm_i915_private *dev_priv);
|
||||
bool intel_bios_is_lvds_present(struct drm_i915_private *dev_priv, u8 *i2c_pin);
|
||||
bool intel_bios_is_port_present(struct drm_i915_private *dev_priv, enum port port);
|
||||
bool intel_bios_is_port_edp(struct drm_i915_private *dev_priv, enum port port);
|
||||
bool intel_bios_is_port_dp_dual_mode(struct drm_i915_private *dev_priv, enum port port);
|
||||
bool intel_bios_is_dsi_present(struct drm_i915_private *dev_priv, enum port *port);
|
||||
bool intel_bios_get_dsc_params(struct intel_encoder *encoder,
|
||||
struct intel_crtc_state *crtc_state,
|
||||
@@ -264,6 +263,7 @@ bool intel_bios_encoder_supports_dp(const struct intel_bios_encoder_data *devdat
|
||||
bool intel_bios_encoder_supports_edp(const struct intel_bios_encoder_data *devdata);
|
||||
bool intel_bios_encoder_supports_typec_usb(const struct intel_bios_encoder_data *devdata);
|
||||
bool intel_bios_encoder_supports_tbt(const struct intel_bios_encoder_data *devdata);
|
||||
bool intel_bios_encoder_supports_dp_dual_mode(const struct intel_bios_encoder_data *devdata);
|
||||
bool intel_bios_encoder_is_lspcon(const struct intel_bios_encoder_data *devdata);
|
||||
bool intel_bios_encoder_lane_reversal(const struct intel_bios_encoder_data *devdata);
|
||||
bool intel_bios_encoder_hpd_invert(const struct intel_bios_encoder_data *devdata);
|
||||
|
||||
@@ -150,6 +150,9 @@ int icl_pcode_restrict_qgv_points(struct drm_i915_private *dev_priv,
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
return 0;
|
||||
|
||||
/* bspec says to keep retrying for at least 1 ms */
|
||||
ret = skl_pcode_request(&dev_priv->uncore, ICL_PCODE_SAGV_DE_MEM_SS_CONFIG,
|
||||
points_mask,
|
||||
|
||||
@@ -1453,6 +1453,18 @@ static u8 tgl_calc_voltage_level(int cdclk)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static u8 rplu_calc_voltage_level(int cdclk)
|
||||
{
|
||||
if (cdclk > 556800)
|
||||
return 3;
|
||||
else if (cdclk > 480000)
|
||||
return 2;
|
||||
else if (cdclk > 312000)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void icl_readout_refclk(struct drm_i915_private *dev_priv,
|
||||
struct intel_cdclk_config *cdclk_config)
|
||||
{
|
||||
@@ -1896,7 +1908,7 @@ static void bxt_set_cdclk(struct drm_i915_private *dev_priv,
|
||||
* mailbox communication, skip
|
||||
* this step.
|
||||
*/
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
if (DISPLAY_VER(dev_priv) >= 14 || IS_DG2(dev_priv))
|
||||
/* NOOP */;
|
||||
else if (DISPLAY_VER(dev_priv) >= 11)
|
||||
ret = skl_pcode_request(&dev_priv->uncore, SKL_PCODE_CDCLK_CONTROL,
|
||||
@@ -1932,10 +1944,10 @@ static void bxt_set_cdclk(struct drm_i915_private *dev_priv,
|
||||
* NOOP - No Pcode communication needed for
|
||||
* Display versions 14 and beyond
|
||||
*/;
|
||||
else if (DISPLAY_VER(dev_priv) >= 11)
|
||||
else if (DISPLAY_VER(dev_priv) >= 11 && !IS_DG2(dev_priv))
|
||||
ret = snb_pcode_write(&dev_priv->uncore, SKL_PCODE_CDCLK_CONTROL,
|
||||
cdclk_config->voltage_level);
|
||||
else
|
||||
if (DISPLAY_VER(dev_priv) < 11) {
|
||||
/*
|
||||
* The timeout isn't specified, the 2ms used here is based on
|
||||
* experiment.
|
||||
@@ -1946,7 +1958,7 @@ static void bxt_set_cdclk(struct drm_i915_private *dev_priv,
|
||||
HSW_PCODE_DE_WRITE_FREQ_REQ,
|
||||
cdclk_config->voltage_level,
|
||||
150, 2);
|
||||
|
||||
}
|
||||
if (ret) {
|
||||
drm_err(&dev_priv->drm,
|
||||
"PCode CDCLK freq set failed, (err %d, freq %d)\n",
|
||||
@@ -2242,6 +2254,38 @@ void intel_cdclk_dump_config(struct drm_i915_private *i915,
|
||||
cdclk_config->voltage_level);
|
||||
}
|
||||
|
||||
static void intel_pcode_notify(struct drm_i915_private *i915,
|
||||
u8 voltage_level,
|
||||
u8 active_pipe_count,
|
||||
u16 cdclk,
|
||||
bool cdclk_update_valid,
|
||||
bool pipe_count_update_valid)
|
||||
{
|
||||
int ret;
|
||||
u32 update_mask = 0;
|
||||
|
||||
if (!IS_DG2(i915))
|
||||
return;
|
||||
|
||||
update_mask = DISPLAY_TO_PCODE_UPDATE_MASK(cdclk, active_pipe_count, voltage_level);
|
||||
|
||||
if (cdclk_update_valid)
|
||||
update_mask |= DISPLAY_TO_PCODE_CDCLK_VALID;
|
||||
|
||||
if (pipe_count_update_valid)
|
||||
update_mask |= DISPLAY_TO_PCODE_PIPE_COUNT_VALID;
|
||||
|
||||
ret = skl_pcode_request(&i915->uncore, SKL_PCODE_CDCLK_CONTROL,
|
||||
SKL_CDCLK_PREPARE_FOR_CHANGE |
|
||||
update_mask,
|
||||
SKL_CDCLK_READY_FOR_CHANGE,
|
||||
SKL_CDCLK_READY_FOR_CHANGE, 3);
|
||||
if (ret)
|
||||
drm_err(&i915->drm,
|
||||
"Failed to inform PCU about display config (err %d)\n",
|
||||
ret);
|
||||
}
|
||||
|
||||
/**
|
||||
* intel_set_cdclk - Push the CDCLK configuration to the hardware
|
||||
* @dev_priv: i915 device
|
||||
@@ -2311,6 +2355,88 @@ static void intel_set_cdclk(struct drm_i915_private *dev_priv,
|
||||
}
|
||||
}
|
||||
|
||||
static void intel_cdclk_pcode_pre_notify(struct intel_atomic_state *state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(state->base.dev);
|
||||
const struct intel_cdclk_state *old_cdclk_state =
|
||||
intel_atomic_get_old_cdclk_state(state);
|
||||
const struct intel_cdclk_state *new_cdclk_state =
|
||||
intel_atomic_get_new_cdclk_state(state);
|
||||
unsigned int cdclk = 0; u8 voltage_level, num_active_pipes = 0;
|
||||
bool change_cdclk, update_pipe_count;
|
||||
|
||||
if (!intel_cdclk_changed(&old_cdclk_state->actual,
|
||||
&new_cdclk_state->actual) &&
|
||||
new_cdclk_state->active_pipes ==
|
||||
old_cdclk_state->active_pipes)
|
||||
return;
|
||||
|
||||
/* According to "Sequence Before Frequency Change", voltage level set to 0x3 */
|
||||
voltage_level = DISPLAY_TO_PCODE_VOLTAGE_MAX;
|
||||
|
||||
change_cdclk = new_cdclk_state->actual.cdclk != old_cdclk_state->actual.cdclk;
|
||||
update_pipe_count = hweight8(new_cdclk_state->active_pipes) >
|
||||
hweight8(old_cdclk_state->active_pipes);
|
||||
|
||||
/*
|
||||
* According to "Sequence Before Frequency Change",
|
||||
* if CDCLK is increasing, set bits 25:16 to upcoming CDCLK,
|
||||
* if CDCLK is decreasing or not changing, set bits 25:16 to current CDCLK,
|
||||
* which basically means we choose the maximum of old and new CDCLK, if we know both
|
||||
*/
|
||||
if (change_cdclk)
|
||||
cdclk = max(new_cdclk_state->actual.cdclk, old_cdclk_state->actual.cdclk);
|
||||
|
||||
/*
|
||||
* According to "Sequence For Pipe Count Change",
|
||||
* if pipe count is increasing, set bits 25:16 to upcoming pipe count
|
||||
* (power well is enabled)
|
||||
* no action if it is decreasing, before the change
|
||||
*/
|
||||
if (update_pipe_count)
|
||||
num_active_pipes = hweight8(new_cdclk_state->active_pipes);
|
||||
|
||||
intel_pcode_notify(i915, voltage_level, num_active_pipes, cdclk,
|
||||
change_cdclk, update_pipe_count);
|
||||
}
|
||||
|
||||
static void intel_cdclk_pcode_post_notify(struct intel_atomic_state *state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(state->base.dev);
|
||||
const struct intel_cdclk_state *new_cdclk_state =
|
||||
intel_atomic_get_new_cdclk_state(state);
|
||||
const struct intel_cdclk_state *old_cdclk_state =
|
||||
intel_atomic_get_old_cdclk_state(state);
|
||||
unsigned int cdclk = 0; u8 voltage_level, num_active_pipes = 0;
|
||||
bool update_cdclk, update_pipe_count;
|
||||
|
||||
/* According to "Sequence After Frequency Change", set voltage to used level */
|
||||
voltage_level = new_cdclk_state->actual.voltage_level;
|
||||
|
||||
update_cdclk = new_cdclk_state->actual.cdclk != old_cdclk_state->actual.cdclk;
|
||||
update_pipe_count = hweight8(new_cdclk_state->active_pipes) <
|
||||
hweight8(old_cdclk_state->active_pipes);
|
||||
|
||||
/*
|
||||
* According to "Sequence After Frequency Change",
|
||||
* set bits 25:16 to current CDCLK
|
||||
*/
|
||||
if (update_cdclk)
|
||||
cdclk = new_cdclk_state->actual.cdclk;
|
||||
|
||||
/*
|
||||
* According to "Sequence For Pipe Count Change",
|
||||
* if pipe count is decreasing, set bits 25:16 to current pipe count,
|
||||
* after the change(power well is disabled)
|
||||
* no action if it is increasing, after the change
|
||||
*/
|
||||
if (update_pipe_count)
|
||||
num_active_pipes = hweight8(new_cdclk_state->active_pipes);
|
||||
|
||||
intel_pcode_notify(i915, voltage_level, num_active_pipes, cdclk,
|
||||
update_cdclk, update_pipe_count);
|
||||
}
|
||||
|
||||
/**
|
||||
* intel_set_cdclk_pre_plane_update - Push the CDCLK state to the hardware
|
||||
* @state: intel atomic state
|
||||
@@ -2321,7 +2447,7 @@ static void intel_set_cdclk(struct drm_i915_private *dev_priv,
|
||||
void
|
||||
intel_set_cdclk_pre_plane_update(struct intel_atomic_state *state)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(state->base.dev);
|
||||
struct drm_i915_private *i915 = to_i915(state->base.dev);
|
||||
const struct intel_cdclk_state *old_cdclk_state =
|
||||
intel_atomic_get_old_cdclk_state(state);
|
||||
const struct intel_cdclk_state *new_cdclk_state =
|
||||
@@ -2332,11 +2458,14 @@ intel_set_cdclk_pre_plane_update(struct intel_atomic_state *state)
|
||||
&new_cdclk_state->actual))
|
||||
return;
|
||||
|
||||
if (IS_DG2(i915))
|
||||
intel_cdclk_pcode_pre_notify(state);
|
||||
|
||||
if (pipe == INVALID_PIPE ||
|
||||
old_cdclk_state->actual.cdclk <= new_cdclk_state->actual.cdclk) {
|
||||
drm_WARN_ON(&dev_priv->drm, !new_cdclk_state->base.changed);
|
||||
drm_WARN_ON(&i915->drm, !new_cdclk_state->base.changed);
|
||||
|
||||
intel_set_cdclk(dev_priv, &new_cdclk_state->actual, pipe);
|
||||
intel_set_cdclk(i915, &new_cdclk_state->actual, pipe);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2350,7 +2479,7 @@ intel_set_cdclk_pre_plane_update(struct intel_atomic_state *state)
|
||||
void
|
||||
intel_set_cdclk_post_plane_update(struct intel_atomic_state *state)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(state->base.dev);
|
||||
struct drm_i915_private *i915 = to_i915(state->base.dev);
|
||||
const struct intel_cdclk_state *old_cdclk_state =
|
||||
intel_atomic_get_old_cdclk_state(state);
|
||||
const struct intel_cdclk_state *new_cdclk_state =
|
||||
@@ -2361,11 +2490,14 @@ intel_set_cdclk_post_plane_update(struct intel_atomic_state *state)
|
||||
&new_cdclk_state->actual))
|
||||
return;
|
||||
|
||||
if (IS_DG2(i915))
|
||||
intel_cdclk_pcode_post_notify(state);
|
||||
|
||||
if (pipe != INVALID_PIPE &&
|
||||
old_cdclk_state->actual.cdclk > new_cdclk_state->actual.cdclk) {
|
||||
drm_WARN_ON(&dev_priv->drm, !new_cdclk_state->base.changed);
|
||||
drm_WARN_ON(&i915->drm, !new_cdclk_state->base.changed);
|
||||
|
||||
intel_set_cdclk(dev_priv, &new_cdclk_state->actual, pipe);
|
||||
intel_set_cdclk(i915, &new_cdclk_state->actual, pipe);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2871,6 +3003,21 @@ int intel_cdclk_init(struct drm_i915_private *dev_priv)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool intel_cdclk_need_serialize(struct drm_i915_private *i915,
|
||||
const struct intel_cdclk_state *old_cdclk_state,
|
||||
const struct intel_cdclk_state *new_cdclk_state)
|
||||
{
|
||||
bool power_well_cnt_changed = hweight8(old_cdclk_state->active_pipes) !=
|
||||
hweight8(new_cdclk_state->active_pipes);
|
||||
bool cdclk_changed = intel_cdclk_changed(&old_cdclk_state->actual,
|
||||
&new_cdclk_state->actual);
|
||||
/*
|
||||
* We need to poke hw for gen >= 12, because we notify PCode if
|
||||
* pipe power well count changes.
|
||||
*/
|
||||
return cdclk_changed || (IS_DG2(i915) && power_well_cnt_changed);
|
||||
}
|
||||
|
||||
int intel_modeset_calc_cdclk(struct intel_atomic_state *state)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(state->base.dev);
|
||||
@@ -2892,8 +3039,7 @@ int intel_modeset_calc_cdclk(struct intel_atomic_state *state)
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (intel_cdclk_changed(&old_cdclk_state->actual,
|
||||
&new_cdclk_state->actual)) {
|
||||
if (intel_cdclk_need_serialize(dev_priv, old_cdclk_state, new_cdclk_state)) {
|
||||
/*
|
||||
* Also serialize commits across all crtcs
|
||||
* if the actual hw needs to be poked.
|
||||
@@ -3235,6 +3381,27 @@ u32 intel_read_rawclk(struct drm_i915_private *dev_priv)
|
||||
return freq;
|
||||
}
|
||||
|
||||
static int i915_cdclk_info_show(struct seq_file *m, void *unused)
|
||||
{
|
||||
struct drm_i915_private *i915 = m->private;
|
||||
|
||||
seq_printf(m, "Current CD clock frequency: %d kHz\n", i915->display.cdclk.hw.cdclk);
|
||||
seq_printf(m, "Max CD clock frequency: %d kHz\n", i915->display.cdclk.max_cdclk_freq);
|
||||
seq_printf(m, "Max pixel clock frequency: %d kHz\n", i915->max_dotclk_freq);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
DEFINE_SHOW_ATTRIBUTE(i915_cdclk_info);
|
||||
|
||||
void intel_cdclk_debugfs_register(struct drm_i915_private *i915)
|
||||
{
|
||||
struct drm_minor *minor = i915->drm.primary;
|
||||
|
||||
debugfs_create_file("i915_cdclk_info", 0444, minor->debugfs_root,
|
||||
i915, &i915_cdclk_info_fops);
|
||||
}
|
||||
|
||||
static const struct intel_cdclk_funcs mtl_cdclk_funcs = {
|
||||
.get_cdclk = bxt_get_cdclk,
|
||||
.set_cdclk = bxt_set_cdclk,
|
||||
@@ -3242,6 +3409,13 @@ static const struct intel_cdclk_funcs mtl_cdclk_funcs = {
|
||||
.calc_voltage_level = tgl_calc_voltage_level,
|
||||
};
|
||||
|
||||
static const struct intel_cdclk_funcs rplu_cdclk_funcs = {
|
||||
.get_cdclk = bxt_get_cdclk,
|
||||
.set_cdclk = bxt_set_cdclk,
|
||||
.modeset_calc_cdclk = bxt_modeset_calc_cdclk,
|
||||
.calc_voltage_level = rplu_calc_voltage_level,
|
||||
};
|
||||
|
||||
static const struct intel_cdclk_funcs tgl_cdclk_funcs = {
|
||||
.get_cdclk = bxt_get_cdclk,
|
||||
.set_cdclk = bxt_set_cdclk,
|
||||
@@ -3384,14 +3558,17 @@ void intel_init_cdclk_hooks(struct drm_i915_private *dev_priv)
|
||||
dev_priv->display.funcs.cdclk = &tgl_cdclk_funcs;
|
||||
dev_priv->display.cdclk.table = dg2_cdclk_table;
|
||||
} else if (IS_ALDERLAKE_P(dev_priv)) {
|
||||
dev_priv->display.funcs.cdclk = &tgl_cdclk_funcs;
|
||||
/* Wa_22011320316:adl-p[a0] */
|
||||
if (IS_ADLP_DISPLAY_STEP(dev_priv, STEP_A0, STEP_B0))
|
||||
if (IS_ADLP_DISPLAY_STEP(dev_priv, STEP_A0, STEP_B0)) {
|
||||
dev_priv->display.cdclk.table = adlp_a_step_cdclk_table;
|
||||
else if (IS_ADLP_RPLU(dev_priv))
|
||||
dev_priv->display.funcs.cdclk = &tgl_cdclk_funcs;
|
||||
} else if (IS_ADLP_RPLU(dev_priv)) {
|
||||
dev_priv->display.cdclk.table = rplu_cdclk_table;
|
||||
else
|
||||
dev_priv->display.funcs.cdclk = &rplu_cdclk_funcs;
|
||||
} else {
|
||||
dev_priv->display.cdclk.table = adlp_cdclk_table;
|
||||
dev_priv->display.funcs.cdclk = &tgl_cdclk_funcs;
|
||||
}
|
||||
} else if (IS_ROCKETLAKE(dev_priv)) {
|
||||
dev_priv->display.funcs.cdclk = &tgl_cdclk_funcs;
|
||||
dev_priv->display.cdclk.table = rkl_cdclk_table;
|
||||
|
||||
@@ -82,5 +82,6 @@ intel_atomic_get_cdclk_state(struct intel_atomic_state *state);
|
||||
to_intel_cdclk_state(intel_atomic_get_new_global_obj_state(state, &to_i915(state->base.dev)->display.cdclk.obj))
|
||||
|
||||
int intel_cdclk_init(struct drm_i915_private *dev_priv);
|
||||
void intel_cdclk_debugfs_register(struct drm_i915_private *i915);
|
||||
|
||||
#endif /* __INTEL_CDCLK_H__ */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -176,15 +176,15 @@ enum pipe intel_connector_get_pipe(struct intel_connector *connector)
|
||||
/**
|
||||
* intel_connector_update_modes - update connector from edid
|
||||
* @connector: DRM connector device to use
|
||||
* @edid: previously read EDID information
|
||||
* @drm_edid: previously read EDID information
|
||||
*/
|
||||
int intel_connector_update_modes(struct drm_connector *connector,
|
||||
struct edid *edid)
|
||||
const struct drm_edid *drm_edid)
|
||||
{
|
||||
int ret;
|
||||
|
||||
drm_connector_update_edid_property(connector, edid);
|
||||
ret = drm_add_edid_modes(connector, edid);
|
||||
drm_edid_connector_update(connector, drm_edid);
|
||||
ret = drm_edid_connector_add_modes(connector);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -199,15 +199,15 @@ int intel_connector_update_modes(struct drm_connector *connector,
|
||||
int intel_ddc_get_modes(struct drm_connector *connector,
|
||||
struct i2c_adapter *adapter)
|
||||
{
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
int ret;
|
||||
|
||||
edid = drm_get_edid(connector, adapter);
|
||||
if (!edid)
|
||||
drm_edid = drm_edid_read_ddc(connector, adapter);
|
||||
if (!drm_edid)
|
||||
return 0;
|
||||
|
||||
ret = intel_connector_update_modes(connector, edid);
|
||||
kfree(edid);
|
||||
ret = intel_connector_update_modes(connector, drm_edid);
|
||||
drm_edid_free(drm_edid);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
#include <linux/types.h>
|
||||
|
||||
struct drm_connector;
|
||||
struct edid;
|
||||
struct drm_edid;
|
||||
struct i2c_adapter;
|
||||
struct intel_connector;
|
||||
struct intel_encoder;
|
||||
@@ -25,7 +25,7 @@ void intel_connector_attach_encoder(struct intel_connector *connector,
|
||||
bool intel_connector_get_hw_state(struct intel_connector *connector);
|
||||
enum pipe intel_connector_get_pipe(struct intel_connector *connector);
|
||||
int intel_connector_update_modes(struct drm_connector *connector,
|
||||
struct edid *edid);
|
||||
const struct drm_edid *drm_edid);
|
||||
int intel_ddc_get_modes(struct drm_connector *c, struct i2c_adapter *adapter);
|
||||
void intel_attach_force_audio_property(struct drm_connector *connector);
|
||||
void intel_attach_broadcast_rgb_property(struct drm_connector *connector);
|
||||
|
||||
@@ -48,6 +48,8 @@
|
||||
#include "intel_fifo_underrun.h"
|
||||
#include "intel_gmbus.h"
|
||||
#include "intel_hotplug.h"
|
||||
#include "intel_hotplug_irq.h"
|
||||
#include "intel_load_detect.h"
|
||||
#include "intel_pch_display.h"
|
||||
#include "intel_pch_refclk.h"
|
||||
|
||||
@@ -394,6 +396,7 @@ static int intel_crt_compute_config(struct intel_encoder *encoder,
|
||||
if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN)
|
||||
return -EINVAL;
|
||||
|
||||
pipe_config->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
|
||||
return 0;
|
||||
@@ -606,37 +609,38 @@ static bool intel_crt_detect_hotplug(struct drm_connector *connector)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static struct edid *intel_crt_get_edid(struct drm_connector *connector,
|
||||
struct i2c_adapter *i2c)
|
||||
static const struct drm_edid *intel_crt_get_edid(struct drm_connector *connector,
|
||||
struct i2c_adapter *i2c)
|
||||
{
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
|
||||
edid = drm_get_edid(connector, i2c);
|
||||
drm_edid = drm_edid_read_ddc(connector, i2c);
|
||||
|
||||
if (!edid && !intel_gmbus_is_forced_bit(i2c)) {
|
||||
if (!drm_edid && !intel_gmbus_is_forced_bit(i2c)) {
|
||||
drm_dbg_kms(connector->dev,
|
||||
"CRT GMBUS EDID read failed, retry using GPIO bit-banging\n");
|
||||
intel_gmbus_force_bit(i2c, true);
|
||||
edid = drm_get_edid(connector, i2c);
|
||||
drm_edid = drm_edid_read_ddc(connector, i2c);
|
||||
intel_gmbus_force_bit(i2c, false);
|
||||
}
|
||||
|
||||
return edid;
|
||||
return drm_edid;
|
||||
}
|
||||
|
||||
/* local version of intel_ddc_get_modes() to use intel_crt_get_edid() */
|
||||
static int intel_crt_ddc_get_modes(struct drm_connector *connector,
|
||||
struct i2c_adapter *adapter)
|
||||
{
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
int ret;
|
||||
|
||||
edid = intel_crt_get_edid(connector, adapter);
|
||||
if (!edid)
|
||||
drm_edid = intel_crt_get_edid(connector, adapter);
|
||||
if (!drm_edid)
|
||||
return 0;
|
||||
|
||||
ret = intel_connector_update_modes(connector, edid);
|
||||
kfree(edid);
|
||||
ret = intel_connector_update_modes(connector, drm_edid);
|
||||
|
||||
drm_edid_free(drm_edid);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -645,14 +649,15 @@ static bool intel_crt_detect_ddc(struct drm_connector *connector)
|
||||
{
|
||||
struct intel_crt *crt = intel_attached_crt(to_intel_connector(connector));
|
||||
struct drm_i915_private *dev_priv = to_i915(crt->base.base.dev);
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
struct i2c_adapter *i2c;
|
||||
bool ret = false;
|
||||
|
||||
i2c = intel_gmbus_get_adapter(dev_priv, dev_priv->display.vbt.crt_ddc_pin);
|
||||
edid = intel_crt_get_edid(connector, i2c);
|
||||
drm_edid = intel_crt_get_edid(connector, i2c);
|
||||
|
||||
if (edid) {
|
||||
if (drm_edid) {
|
||||
const struct edid *edid = drm_edid_raw(drm_edid);
|
||||
bool is_digital = edid->input & DRM_EDID_INPUT_DIGITAL;
|
||||
|
||||
/*
|
||||
@@ -673,7 +678,7 @@ static bool intel_crt_detect_ddc(struct drm_connector *connector)
|
||||
"CRT not detected via DDC:0x50 [no valid EDID found]\n");
|
||||
}
|
||||
|
||||
kfree(edid);
|
||||
drm_edid_free(drm_edid);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -821,9 +826,9 @@ intel_crt_detect(struct drm_connector *connector,
|
||||
struct drm_i915_private *dev_priv = to_i915(connector->dev);
|
||||
struct intel_crt *crt = intel_attached_crt(to_intel_connector(connector));
|
||||
struct intel_encoder *intel_encoder = &crt->base;
|
||||
struct drm_atomic_state *state;
|
||||
intel_wakeref_t wakeref;
|
||||
int status, ret;
|
||||
struct intel_load_detect_pipe tmp;
|
||||
int status;
|
||||
|
||||
drm_dbg_kms(&dev_priv->drm, "[CONNECTOR:%d:%s] force=%d\n",
|
||||
connector->base.id, connector->name,
|
||||
@@ -881,8 +886,12 @@ load_detect:
|
||||
}
|
||||
|
||||
/* for pre-945g platforms use load detect */
|
||||
ret = intel_get_load_detect_pipe(connector, &tmp, ctx);
|
||||
if (ret > 0) {
|
||||
state = intel_load_detect_get_pipe(connector, ctx);
|
||||
if (IS_ERR(state)) {
|
||||
status = PTR_ERR(state);
|
||||
} else if (!state) {
|
||||
status = connector_status_unknown;
|
||||
} else {
|
||||
if (intel_crt_detect_ddc(connector))
|
||||
status = connector_status_connected;
|
||||
else if (DISPLAY_VER(dev_priv) < 4)
|
||||
@@ -892,11 +901,7 @@ load_detect:
|
||||
status = connector_status_disconnected;
|
||||
else
|
||||
status = connector_status_unknown;
|
||||
intel_release_load_detect_pipe(connector, &tmp, ctx);
|
||||
} else if (ret == 0) {
|
||||
status = connector_status_unknown;
|
||||
} else {
|
||||
status = ret;
|
||||
intel_load_detect_release_pipe(connector, state, ctx);
|
||||
}
|
||||
|
||||
out:
|
||||
|
||||
@@ -11,7 +11,6 @@
|
||||
#include <drm/drm_plane.h>
|
||||
#include <drm/drm_vblank_work.h>
|
||||
|
||||
#include "i915_irq.h"
|
||||
#include "i915_vgpu.h"
|
||||
#include "i9xx_plane.h"
|
||||
#include "icl_dsi.h"
|
||||
@@ -21,6 +20,7 @@
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_cursor.h"
|
||||
#include "intel_display_debugfs.h"
|
||||
#include "intel_display_irq.h"
|
||||
#include "intel_display_trace.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_drrs.h"
|
||||
@@ -35,7 +35,11 @@
|
||||
|
||||
static void assert_vblank_disabled(struct drm_crtc *crtc)
|
||||
{
|
||||
if (I915_STATE_WARN_ON(drm_crtc_vblank_get(crtc) == 0))
|
||||
struct drm_i915_private *i915 = to_i915(crtc->dev);
|
||||
|
||||
if (I915_STATE_WARN(i915, drm_crtc_vblank_get(crtc) == 0,
|
||||
"[CRTC:%d:%s] vblank assertion failure (expected off, current on)\n",
|
||||
crtc->base.id, crtc->name))
|
||||
drm_crtc_vblank_put(crtc);
|
||||
}
|
||||
|
||||
@@ -302,7 +306,7 @@ int intel_crtc_init(struct drm_i915_private *dev_priv, enum pipe pipe)
|
||||
return PTR_ERR(crtc);
|
||||
|
||||
crtc->pipe = pipe;
|
||||
crtc->num_scalers = RUNTIME_INFO(dev_priv)->num_scalers[pipe];
|
||||
crtc->num_scalers = DISPLAY_RUNTIME_INFO(dev_priv)->num_scalers[pipe];
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 9)
|
||||
primary = skl_universal_plane_create(dev_priv, pipe,
|
||||
@@ -510,6 +514,13 @@ void intel_pipe_update_start(struct intel_crtc_state *new_crtc_state)
|
||||
VBLANK_EVASION_TIME_US);
|
||||
max = vblank_start - 1;
|
||||
|
||||
/*
|
||||
* M/N is double buffered on the transcoder's undelayed vblank,
|
||||
* so with seamless M/N we must evade both vblanks.
|
||||
*/
|
||||
if (new_crtc_state->seamless_m_n && intel_crtc_needs_fastset(new_crtc_state))
|
||||
min -= adjusted_mode->crtc_vblank_start - adjusted_mode->crtc_vdisplay;
|
||||
|
||||
if (min <= 0 || max <= 0)
|
||||
goto irq_disable;
|
||||
|
||||
@@ -692,7 +703,8 @@ void intel_pipe_update_end(struct intel_crtc_state *new_crtc_state)
|
||||
* FIXME Should be synchronized with the start of vblank somehow...
|
||||
*/
|
||||
if (new_crtc_state->seamless_m_n && intel_crtc_needs_fastset(new_crtc_state))
|
||||
intel_crtc_update_active_timings(new_crtc_state);
|
||||
intel_crtc_update_active_timings(new_crtc_state,
|
||||
new_crtc_state->vrr.enable);
|
||||
|
||||
local_irq_enable();
|
||||
|
||||
|
||||
@@ -16,6 +16,16 @@ struct intel_atomic_state;
|
||||
struct intel_crtc;
|
||||
struct intel_crtc_state;
|
||||
|
||||
/*
|
||||
* FIXME: We should instead only take spinlocks once for the entire update
|
||||
* instead of once per mmio.
|
||||
*/
|
||||
#if IS_ENABLED(CONFIG_PROVE_LOCKING)
|
||||
#define VBLANK_EVASION_TIME_US 250
|
||||
#else
|
||||
#define VBLANK_EVASION_TIME_US 100
|
||||
#endif
|
||||
|
||||
int intel_usecs_to_scanlines(const struct drm_display_mode *adjusted_mode,
|
||||
int usecs);
|
||||
u32 intel_crtc_max_vblank_count(const struct intel_crtc_state *crtc_state);
|
||||
|
||||
@@ -158,6 +158,45 @@ static void intel_dump_plane_state(const struct intel_plane_state *plane_state)
|
||||
DRM_RECT_ARG(&plane_state->uapi.dst));
|
||||
}
|
||||
|
||||
static void
|
||||
ilk_dump_csc(struct drm_i915_private *i915, const char *name,
|
||||
const struct intel_csc_matrix *csc)
|
||||
{
|
||||
int i;
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"%s: pre offsets: 0x%04x 0x%04x 0x%04x\n", name,
|
||||
csc->preoff[0], csc->preoff[1], csc->preoff[2]);
|
||||
|
||||
for (i = 0; i < 3; i++)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"%s: coefficients: 0x%04x 0x%04x 0x%04x\n", name,
|
||||
csc->coeff[3 * i + 0],
|
||||
csc->coeff[3 * i + 1],
|
||||
csc->coeff[3 * i + 2]);
|
||||
|
||||
if (DISPLAY_VER(i915) < 7)
|
||||
return;
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"%s: post offsets: 0x%04x 0x%04x 0x%04x\n", name,
|
||||
csc->postoff[0], csc->postoff[1], csc->postoff[2]);
|
||||
}
|
||||
|
||||
static void
|
||||
vlv_dump_csc(struct drm_i915_private *i915, const char *name,
|
||||
const struct intel_csc_matrix *csc)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 3; i++)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"%s: coefficients: 0x%04x 0x%04x 0x%04x\n", name,
|
||||
csc->coeff[3 * i + 0],
|
||||
csc->coeff[3 * i + 1],
|
||||
csc->coeff[3 * i + 2]);
|
||||
}
|
||||
|
||||
void intel_crtc_state_dump(const struct intel_crtc_state *pipe_config,
|
||||
struct intel_atomic_state *state,
|
||||
const char *context)
|
||||
@@ -178,10 +217,11 @@ void intel_crtc_state_dump(const struct intel_crtc_state *pipe_config,
|
||||
|
||||
snprintf_output_types(buf, sizeof(buf), pipe_config->output_types);
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"active: %s, output_types: %s (0x%x), output format: %s\n",
|
||||
"active: %s, output_types: %s (0x%x), output format: %s, sink format: %s\n",
|
||||
str_yes_no(pipe_config->hw.active),
|
||||
buf, pipe_config->output_types,
|
||||
intel_output_format_name(pipe_config->output_format));
|
||||
intel_output_format_name(pipe_config->output_format),
|
||||
intel_output_format_name(pipe_config->sink_format));
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"cpu_transcoder: %s, pipe bpp: %i, dithering: %i\n",
|
||||
@@ -325,6 +365,16 @@ void intel_crtc_state_dump(const struct intel_crtc_state *pipe_config,
|
||||
pipe_config->post_csc_lut ?
|
||||
drm_color_lut_size(pipe_config->post_csc_lut) : 0);
|
||||
|
||||
if (DISPLAY_VER(i915) >= 11)
|
||||
ilk_dump_csc(i915, "output csc", &pipe_config->output_csc);
|
||||
|
||||
if (!HAS_GMCH(i915))
|
||||
ilk_dump_csc(i915, "pipe csc", &pipe_config->csc);
|
||||
else if (IS_CHERRYVIEW(i915))
|
||||
vlv_dump_csc(i915, "cgm csc", &pipe_config->csc);
|
||||
else if (IS_VALLEYVIEW(i915))
|
||||
vlv_dump_csc(i915, "wgc csc", &pipe_config->csc);
|
||||
|
||||
dump_planes:
|
||||
if (!state)
|
||||
return;
|
||||
|
||||
@@ -36,7 +36,7 @@ static u32 intel_cursor_base(const struct intel_plane_state *plane_state)
|
||||
const struct drm_i915_gem_object *obj = intel_fb_obj(fb);
|
||||
u32 base;
|
||||
|
||||
if (INTEL_INFO(dev_priv)->display.cursor_needs_physical)
|
||||
if (DISPLAY_INFO(dev_priv)->cursor_needs_physical)
|
||||
base = sg_dma_address(obj->mm.pages->sgl);
|
||||
else
|
||||
base = intel_plane_ggtt_offset(plane_state);
|
||||
@@ -814,7 +814,7 @@ intel_cursor_plane_create(struct drm_i915_private *dev_priv,
|
||||
DRM_MODE_ROTATE_0 |
|
||||
DRM_MODE_ROTATE_180);
|
||||
|
||||
zpos = RUNTIME_INFO(dev_priv)->num_sprites[pipe] + 1;
|
||||
zpos = DISPLAY_RUNTIME_INFO(dev_priv)->num_sprites[pipe] + 1;
|
||||
drm_plane_create_zpos_immutable_property(&cursor->base, zpos);
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 12)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,50 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_CX0_PHY_H__
|
||||
#define __INTEL_CX0_PHY_H__
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/bitfield.h>
|
||||
#include <linux/bits.h>
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "intel_display_types.h"
|
||||
|
||||
struct drm_i915_private;
|
||||
struct intel_encoder;
|
||||
struct intel_crtc_state;
|
||||
enum icl_port_dpll_id;
|
||||
enum phy;
|
||||
|
||||
bool intel_is_c10phy(struct drm_i915_private *dev_priv, enum phy phy);
|
||||
void intel_mtl_pll_enable(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state);
|
||||
void intel_mtl_pll_disable(struct intel_encoder *encoder);
|
||||
enum icl_port_dpll_id
|
||||
intel_mtl_port_pll_type(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state);
|
||||
void intel_c10pll_readout_hw_state(struct intel_encoder *encoder, struct intel_c10pll_state *pll_state);
|
||||
int intel_cx0pll_calc_state(struct intel_crtc_state *crtc_state, struct intel_encoder *encoder);
|
||||
void intel_c10pll_dump_hw_state(struct drm_i915_private *dev_priv,
|
||||
const struct intel_c10pll_state *hw_state);
|
||||
int intel_c10pll_calc_port_clock(struct intel_encoder *encoder,
|
||||
const struct intel_c10pll_state *pll_state);
|
||||
void intel_c10pll_state_verify(struct intel_atomic_state *state,
|
||||
struct intel_crtc_state *new_crtc_state);
|
||||
void intel_c20pll_readout_hw_state(struct intel_encoder *encoder,
|
||||
struct intel_c20pll_state *pll_state);
|
||||
void intel_c20pll_dump_hw_state(struct drm_i915_private *i915,
|
||||
const struct intel_c20pll_state *hw_state);
|
||||
int intel_c20pll_calc_port_clock(struct intel_encoder *encoder,
|
||||
const struct intel_c20pll_state *pll_state);
|
||||
void intel_cx0_phy_set_signal_levels(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state);
|
||||
int intel_cx0_phy_check_hdmi_link_rate(struct intel_hdmi *hdmi, int clock);
|
||||
void intel_cx0_phy_ddi_vswing_sequence(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
u32 level);
|
||||
int intel_mtl_tbt_calc_port_clock(struct intel_encoder *encoder);
|
||||
#endif /* __INTEL_CX0_PHY_H__ */
|
||||
@@ -0,0 +1,274 @@
|
||||
/* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_CX0_PHY_REGS_H__
|
||||
#define __INTEL_CX0_PHY_REGS_H__
|
||||
|
||||
#include "i915_reg_defs.h"
|
||||
|
||||
#define _XELPDP_PORT_M2P_MSGBUS_CTL_LN0_A 0x64040
|
||||
#define _XELPDP_PORT_M2P_MSGBUS_CTL_LN0_B 0x64140
|
||||
#define _XELPDP_PORT_M2P_MSGBUS_CTL_LN0_USBC1 0x16F240
|
||||
#define _XELPDP_PORT_M2P_MSGBUS_CTL_LN0_USBC2 0x16F440
|
||||
#define XELPDP_PORT_M2P_MSGBUS_CTL(port, lane) _MMIO(_PICK_EVEN_2RANGES(port, PORT_TC1, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_A, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_B, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_USBC1, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_USBC2) + (lane) * 4)
|
||||
#define XELPDP_PORT_M2P_TRANSACTION_PENDING REG_BIT(31)
|
||||
#define XELPDP_PORT_M2P_COMMAND_TYPE_MASK REG_GENMASK(30, 27)
|
||||
#define XELPDP_PORT_M2P_COMMAND_WRITE_UNCOMMITTED REG_FIELD_PREP(XELPDP_PORT_M2P_COMMAND_TYPE_MASK, 0x1)
|
||||
#define XELPDP_PORT_M2P_COMMAND_WRITE_COMMITTED REG_FIELD_PREP(XELPDP_PORT_M2P_COMMAND_TYPE_MASK, 0x2)
|
||||
#define XELPDP_PORT_M2P_COMMAND_READ REG_FIELD_PREP(XELPDP_PORT_M2P_COMMAND_TYPE_MASK, 0x3)
|
||||
#define XELPDP_PORT_M2P_DATA_MASK REG_GENMASK(23, 16)
|
||||
#define XELPDP_PORT_M2P_DATA(val) REG_FIELD_PREP(XELPDP_PORT_M2P_DATA_MASK, val)
|
||||
#define XELPDP_PORT_M2P_TRANSACTION_RESET REG_BIT(15)
|
||||
#define XELPDP_PORT_M2P_ADDRESS_MASK REG_GENMASK(11, 0)
|
||||
#define XELPDP_PORT_M2P_ADDRESS(val) REG_FIELD_PREP(XELPDP_PORT_M2P_ADDRESS_MASK, val)
|
||||
#define XELPDP_PORT_P2M_MSGBUS_STATUS(port, lane) _MMIO(_PICK_EVEN_2RANGES(port, PORT_TC1, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_A, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_B, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_USBC1, \
|
||||
_XELPDP_PORT_M2P_MSGBUS_CTL_LN0_USBC2) + (lane) * 4 + 8)
|
||||
#define XELPDP_PORT_P2M_RESPONSE_READY REG_BIT(31)
|
||||
#define XELPDP_PORT_P2M_COMMAND_TYPE_MASK REG_GENMASK(30, 27)
|
||||
#define XELPDP_PORT_P2M_COMMAND_READ_ACK 0x4
|
||||
#define XELPDP_PORT_P2M_COMMAND_WRITE_ACK 0x5
|
||||
#define XELPDP_PORT_P2M_DATA_MASK REG_GENMASK(23, 16)
|
||||
#define XELPDP_PORT_P2M_DATA(val) REG_FIELD_PREP(XELPDP_PORT_P2M_DATA_MASK, val)
|
||||
#define XELPDP_PORT_P2M_ERROR_SET REG_BIT(15)
|
||||
|
||||
#define XELPDP_MSGBUS_TIMEOUT_SLOW 1
|
||||
#define XELPDP_MSGBUS_TIMEOUT_FAST_US 2
|
||||
#define XELPDP_PCLK_PLL_ENABLE_TIMEOUT_US 3200
|
||||
#define XELPDP_PCLK_PLL_DISABLE_TIMEOUT_US 20
|
||||
#define XELPDP_PORT_BUF_SOC_READY_TIMEOUT_US 100
|
||||
#define XELPDP_PORT_RESET_START_TIMEOUT_US 5
|
||||
#define XELPDP_PORT_POWERDOWN_UPDATE_TIMEOUT_US 100
|
||||
#define XELPDP_PORT_RESET_END_TIMEOUT 15
|
||||
#define XELPDP_REFCLK_ENABLE_TIMEOUT_US 1
|
||||
|
||||
#define _XELPDP_PORT_BUF_CTL1_LN0_A 0x64004
|
||||
#define _XELPDP_PORT_BUF_CTL1_LN0_B 0x64104
|
||||
#define _XELPDP_PORT_BUF_CTL1_LN0_USBC1 0x16F200
|
||||
#define _XELPDP_PORT_BUF_CTL1_LN0_USBC2 0x16F400
|
||||
#define XELPDP_PORT_BUF_CTL1(port) _MMIO(_PICK_EVEN_2RANGES(port, PORT_TC1, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_A, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_B, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_USBC1, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_USBC2))
|
||||
#define XELPDP_PORT_BUF_D2D_LINK_ENABLE REG_BIT(29)
|
||||
#define XELPDP_PORT_BUF_D2D_LINK_STATE REG_BIT(28)
|
||||
#define XELPDP_PORT_BUF_SOC_PHY_READY REG_BIT(24)
|
||||
#define XELPDP_PORT_BUF_PORT_DATA_WIDTH_MASK REG_GENMASK(19, 18)
|
||||
#define XELPDP_PORT_BUF_PORT_DATA_10BIT REG_FIELD_PREP(XELPDP_PORT_BUF_PORT_DATA_WIDTH_MASK, 0)
|
||||
#define XELPDP_PORT_BUF_PORT_DATA_20BIT REG_FIELD_PREP(XELPDP_PORT_BUF_PORT_DATA_WIDTH_MASK, 1)
|
||||
#define XELPDP_PORT_BUF_PORT_DATA_40BIT REG_FIELD_PREP(XELPDP_PORT_BUF_PORT_DATA_WIDTH_MASK, 2)
|
||||
#define XELPDP_PORT_REVERSAL REG_BIT(16)
|
||||
#define XELPDP_PORT_BUF_IO_SELECT_TBT REG_BIT(11)
|
||||
#define XELPDP_PORT_BUF_PHY_IDLE REG_BIT(7)
|
||||
#define XELPDP_TC_PHY_OWNERSHIP REG_BIT(6)
|
||||
#define XELPDP_TCSS_POWER_REQUEST REG_BIT(5)
|
||||
#define XELPDP_TCSS_POWER_STATE REG_BIT(4)
|
||||
#define XELPDP_PORT_WIDTH_MASK REG_GENMASK(3, 1)
|
||||
#define XELPDP_PORT_WIDTH(val) REG_FIELD_PREP(XELPDP_PORT_WIDTH_MASK, val)
|
||||
|
||||
#define XELPDP_PORT_BUF_CTL2(port) _MMIO(_PICK_EVEN_2RANGES(port, PORT_TC1, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_A, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_B, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_USBC1, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_USBC2) + 4)
|
||||
|
||||
#define XELPDP_LANE_PIPE_RESET(lane) _PICK(lane, REG_BIT(31), REG_BIT(30))
|
||||
#define XELPDP_LANE_PHY_CURRENT_STATUS(lane) _PICK(lane, REG_BIT(29), REG_BIT(28))
|
||||
#define XELPDP_LANE_POWERDOWN_UPDATE(lane) _PICK(lane, REG_BIT(25), REG_BIT(24))
|
||||
#define _XELPDP_LANE0_POWERDOWN_NEW_STATE_MASK REG_GENMASK(23, 20)
|
||||
#define _XELPDP_LANE0_POWERDOWN_NEW_STATE(val) REG_FIELD_PREP(_XELPDP_LANE0_POWERDOWN_NEW_STATE_MASK, val)
|
||||
#define _XELPDP_LANE1_POWERDOWN_NEW_STATE_MASK REG_GENMASK(19, 16)
|
||||
#define _XELPDP_LANE1_POWERDOWN_NEW_STATE(val) REG_FIELD_PREP(_XELPDP_LANE1_POWERDOWN_NEW_STATE_MASK, val)
|
||||
#define XELPDP_LANE_POWERDOWN_NEW_STATE(lane, val) _PICK(lane, \
|
||||
_XELPDP_LANE0_POWERDOWN_NEW_STATE(val), \
|
||||
_XELPDP_LANE1_POWERDOWN_NEW_STATE(val))
|
||||
#define XELPDP_LANE_POWERDOWN_NEW_STATE_MASK REG_GENMASK(3, 0)
|
||||
#define XELPDP_POWER_STATE_READY_MASK REG_GENMASK(7, 4)
|
||||
#define XELPDP_POWER_STATE_READY(val) REG_FIELD_PREP(XELPDP_POWER_STATE_READY_MASK, val)
|
||||
|
||||
#define XELPDP_PORT_BUF_CTL3(port) _MMIO(_PICK_EVEN_2RANGES(port, PORT_TC1, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_A, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_B, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_USBC1, \
|
||||
_XELPDP_PORT_BUF_CTL1_LN0_USBC2) + 8)
|
||||
#define XELPDP_PLL_LANE_STAGGERING_DELAY_MASK REG_GENMASK(15, 8)
|
||||
#define XELPDP_PLL_LANE_STAGGERING_DELAY(val) REG_FIELD_PREP(XELPDP_PLL_LANE_STAGGERING_DELAY_MASK, val)
|
||||
#define XELPDP_POWER_STATE_ACTIVE_MASK REG_GENMASK(3, 0)
|
||||
#define XELPDP_POWER_STATE_ACTIVE(val) REG_FIELD_PREP(XELPDP_POWER_STATE_ACTIVE_MASK, val)
|
||||
#define CX0_P0_STATE_ACTIVE 0x0
|
||||
#define CX0_P2_STATE_READY 0x2
|
||||
#define CX0_P2PG_STATE_DISABLE 0x9
|
||||
#define CX0_P4PG_STATE_DISABLE 0xC
|
||||
#define CX0_P2_STATE_RESET 0x2
|
||||
|
||||
#define _XELPDP_PORT_CLOCK_CTL_A 0x640E0
|
||||
#define _XELPDP_PORT_CLOCK_CTL_B 0x641E0
|
||||
#define _XELPDP_PORT_CLOCK_CTL_USBC1 0x16F260
|
||||
#define _XELPDP_PORT_CLOCK_CTL_USBC2 0x16F460
|
||||
#define XELPDP_PORT_CLOCK_CTL(port) _MMIO(_PICK_EVEN_2RANGES(port, PORT_TC1, \
|
||||
_XELPDP_PORT_CLOCK_CTL_A, \
|
||||
_XELPDP_PORT_CLOCK_CTL_B, \
|
||||
_XELPDP_PORT_CLOCK_CTL_USBC1, \
|
||||
_XELPDP_PORT_CLOCK_CTL_USBC2))
|
||||
#define XELPDP_LANE_PCLK_PLL_REQUEST(lane) REG_BIT(31 - ((lane) * 4))
|
||||
#define XELPDP_LANE_PCLK_PLL_ACK(lane) REG_BIT(30 - ((lane) * 4))
|
||||
#define XELPDP_LANE_PCLK_REFCLK_REQUEST(lane) REG_BIT(29 - ((lane) * 4))
|
||||
#define XELPDP_LANE_PCLK_REFCLK_ACK(lane) REG_BIT(28 - ((lane) * 4))
|
||||
|
||||
#define XELPDP_TBT_CLOCK_REQUEST REG_BIT(19)
|
||||
#define XELPDP_TBT_CLOCK_ACK REG_BIT(18)
|
||||
#define XELPDP_DDI_CLOCK_SELECT_MASK REG_GENMASK(15, 12)
|
||||
#define XELPDP_DDI_CLOCK_SELECT(val) REG_FIELD_PREP(XELPDP_DDI_CLOCK_SELECT_MASK, val)
|
||||
#define XELPDP_DDI_CLOCK_SELECT_NONE 0x0
|
||||
#define XELPDP_DDI_CLOCK_SELECT_MAXPCLK 0x8
|
||||
#define XELPDP_DDI_CLOCK_SELECT_DIV18CLK 0x9
|
||||
#define XELPDP_DDI_CLOCK_SELECT_TBT_162 0xc
|
||||
#define XELPDP_DDI_CLOCK_SELECT_TBT_270 0xd
|
||||
#define XELPDP_DDI_CLOCK_SELECT_TBT_540 0xe
|
||||
#define XELPDP_DDI_CLOCK_SELECT_TBT_810 0xf
|
||||
#define XELPDP_FORWARD_CLOCK_UNGATE REG_BIT(10)
|
||||
#define XELPDP_LANE1_PHY_CLOCK_SELECT REG_BIT(8)
|
||||
#define XELPDP_SSC_ENABLE_PLLA REG_BIT(1)
|
||||
#define XELPDP_SSC_ENABLE_PLLB REG_BIT(0)
|
||||
|
||||
/* C10 Vendor Registers */
|
||||
#define PHY_C10_VDR_PLL(idx) (0xC00 + (idx))
|
||||
#define C10_PLL0_FRACEN REG_BIT8(4)
|
||||
#define C10_PLL3_MULTIPLIERH_MASK REG_GENMASK8(3, 0)
|
||||
#define C10_PLL15_TXCLKDIV_MASK REG_GENMASK8(2, 0)
|
||||
#define C10_PLL15_HDMIDIV_MASK REG_GENMASK8(5, 3)
|
||||
|
||||
#define PHY_C10_VDR_CMN(idx) (0xC20 + (idx))
|
||||
#define C10_CMN0_REF_RANGE REG_FIELD_PREP(REG_GENMASK(4, 0), 1)
|
||||
#define C10_CMN0_REF_CLK_MPLLB_DIV REG_FIELD_PREP(REG_GENMASK(7, 5), 1)
|
||||
#define C10_CMN3_TXVBOOST_MASK REG_GENMASK8(7, 5)
|
||||
#define C10_CMN3_TXVBOOST(val) REG_FIELD_PREP8(C10_CMN3_TXVBOOST_MASK, val)
|
||||
#define PHY_C10_VDR_TX(idx) (0xC30 + (idx))
|
||||
#define C10_TX0_TX_MPLLB_SEL REG_BIT(4)
|
||||
#define C10_TX1_TERMCTL_MASK REG_GENMASK8(7, 5)
|
||||
#define C10_TX1_TERMCTL(val) REG_FIELD_PREP8(C10_TX1_TERMCTL_MASK, val)
|
||||
#define PHY_C10_VDR_CONTROL(idx) (0xC70 + (idx) - 1)
|
||||
#define C10_VDR_CTRL_MSGBUS_ACCESS REG_BIT8(2)
|
||||
#define C10_VDR_CTRL_MASTER_LANE REG_BIT8(1)
|
||||
#define C10_VDR_CTRL_UPDATE_CFG REG_BIT8(0)
|
||||
#define PHY_C10_VDR_CUSTOM_WIDTH 0xD02
|
||||
#define C10_VDR_CUSTOM_WIDTH_MASK REG_GENMASK(1, 0)
|
||||
#define C10_VDR_CUSTOM_WIDTH_8_10 REG_FIELD_PREP(C10_VDR_CUSTOM_WIDTH_MASK, 0)
|
||||
#define PHY_C10_VDR_OVRD 0xD71
|
||||
#define PHY_C10_VDR_OVRD_TX1 REG_BIT8(0)
|
||||
#define PHY_C10_VDR_OVRD_TX2 REG_BIT8(2)
|
||||
#define PHY_C10_VDR_PRE_OVRD_TX1 0xD80
|
||||
#define C10_PHY_OVRD_LEVEL_MASK REG_GENMASK8(5, 0)
|
||||
#define C10_PHY_OVRD_LEVEL(val) REG_FIELD_PREP8(C10_PHY_OVRD_LEVEL_MASK, val)
|
||||
#define PHY_CX0_VDROVRD_CTL(lane, tx, control) \
|
||||
(PHY_C10_VDR_PRE_OVRD_TX1 + \
|
||||
((lane) ^ (tx)) * 0x10 + (control))
|
||||
|
||||
/* PIPE SPEC Defined Registers */
|
||||
#define PHY_CX0_TX_CONTROL(tx, control) (0x400 + ((tx) - 1) * 0x200 + (control))
|
||||
#define CONTROL2_DISABLE_SINGLE_TX REG_BIT(6)
|
||||
|
||||
/* C20 Registers */
|
||||
#define PHY_C20_WR_ADDRESS_L 0xC02
|
||||
#define PHY_C20_WR_ADDRESS_H 0xC03
|
||||
#define PHY_C20_WR_DATA_L 0xC04
|
||||
#define PHY_C20_WR_DATA_H 0xC05
|
||||
#define PHY_C20_RD_ADDRESS_L 0xC06
|
||||
#define PHY_C20_RD_ADDRESS_H 0xC07
|
||||
#define PHY_C20_RD_DATA_L 0xC08
|
||||
#define PHY_C20_RD_DATA_H 0xC09
|
||||
#define PHY_C20_VDR_CUSTOM_SERDES_RATE 0xD00
|
||||
#define PHY_C20_VDR_HDMI_RATE 0xD01
|
||||
#define PHY_C20_CONTEXT_TOGGLE REG_BIT8(0)
|
||||
#define PHY_C20_CUSTOM_SERDES_MASK REG_GENMASK8(4, 1)
|
||||
#define PHY_C20_CUSTOM_SERDES(val) REG_FIELD_PREP8(PHY_C20_CUSTOM_SERDES_MASK, val)
|
||||
#define PHY_C20_VDR_CUSTOM_WIDTH 0xD02
|
||||
#define PHY_C20_CUSTOM_WIDTH_MASK REG_GENMASK(1, 0)
|
||||
#define PHY_C20_CUSTOM_WIDTH(val) REG_FIELD_PREP8(PHY_C20_CUSTOM_WIDTH_MASK, val)
|
||||
#define PHY_C20_A_TX_CNTX_CFG(idx) (0xCF2E - (idx))
|
||||
#define PHY_C20_B_TX_CNTX_CFG(idx) (0xCF2A - (idx))
|
||||
#define C20_PHY_TX_RATE REG_GENMASK(2, 0)
|
||||
#define PHY_C20_A_CMN_CNTX_CFG(idx) (0xCDAA - (idx))
|
||||
#define PHY_C20_B_CMN_CNTX_CFG(idx) (0xCDA5 - (idx))
|
||||
#define PHY_C20_A_MPLLA_CNTX_CFG(idx) (0xCCF0 - (idx))
|
||||
#define PHY_C20_B_MPLLA_CNTX_CFG(idx) (0xCCE5 - (idx))
|
||||
#define C20_MPLLA_FRACEN REG_BIT(14)
|
||||
#define C20_FB_CLK_DIV4_EN REG_BIT(13)
|
||||
#define C20_MPLLA_TX_CLK_DIV_MASK REG_GENMASK(10, 8)
|
||||
#define PHY_C20_A_MPLLB_CNTX_CFG(idx) (0xCB5A - (idx))
|
||||
#define PHY_C20_B_MPLLB_CNTX_CFG(idx) (0xCB4E - (idx))
|
||||
#define C20_MPLLB_TX_CLK_DIV_MASK REG_GENMASK(15, 13)
|
||||
#define C20_MPLLB_FRACEN REG_BIT(13)
|
||||
#define C20_REF_CLK_MPLLB_DIV_MASK REG_GENMASK(12, 10)
|
||||
#define C20_MULTIPLIER_MASK REG_GENMASK(11, 0)
|
||||
#define C20_PHY_USE_MPLLB REG_BIT(7)
|
||||
|
||||
/* C20 Phy VSwing Masks */
|
||||
#define C20_PHY_VSWING_PREEMPH_MASK REG_GENMASK8(5, 0)
|
||||
#define C20_PHY_VSWING_PREEMPH(val) REG_FIELD_PREP8(C20_PHY_VSWING_PREEMPH_MASK, val)
|
||||
|
||||
#define RAWLANEAONX_DIG_TX_MPLLB_CAL_DONE_BANK(idx) (0x303D + (idx))
|
||||
|
||||
/* C20 HDMI computed pll definitions */
|
||||
#define REFCLK_38_4_MHZ 38400000
|
||||
#define CLOCK_4999MHZ 4999999999
|
||||
#define CLOCK_9999MHZ 9999999999
|
||||
#define DATARATE_3000000000 3000000000
|
||||
#define DATARATE_3500000000 3500000000
|
||||
#define DATARATE_4000000000 4000000000
|
||||
#define MPLL_FRACN_DEN 0xFFFF
|
||||
|
||||
#define SSC_UP_SPREAD REG_BIT16(9)
|
||||
#define WORD_CLK_DIV REG_BIT16(8)
|
||||
|
||||
#define MPLL_TX_CLK_DIV(val) REG_FIELD_PREP16(C20_MPLLB_TX_CLK_DIV_MASK, val)
|
||||
#define MPLL_MULTIPLIER(val) REG_FIELD_PREP16(C20_MULTIPLIER_MASK, val)
|
||||
|
||||
#define MPLLB_ANA_FREQ_VCO_0 0
|
||||
#define MPLLB_ANA_FREQ_VCO_1 1
|
||||
#define MPLLB_ANA_FREQ_VCO_2 2
|
||||
#define MPLLB_ANA_FREQ_VCO_3 3
|
||||
#define MPLLB_ANA_FREQ_VCO_MASK REG_GENMASK16(15, 14)
|
||||
#define MPLLB_ANA_FREQ_VCO(val) REG_FIELD_PREP16(MPLLB_ANA_FREQ_VCO_MASK, val)
|
||||
|
||||
#define MPLL_DIV_MULTIPLIER_MASK REG_GENMASK16(7, 0)
|
||||
#define MPLL_DIV_MULTIPLIER(val) REG_FIELD_PREP16(MPLL_DIV_MULTIPLIER_MASK, val)
|
||||
|
||||
#define CAL_DAC_CODE_31 31
|
||||
#define CAL_DAC_CODE_MASK REG_GENMASK16(14, 10)
|
||||
#define CAL_DAC_CODE(val) REG_FIELD_PREP16(CAL_DAC_CODE_MASK, val)
|
||||
|
||||
#define CP_INT_GS_28 28
|
||||
#define CP_INT_GS_MASK REG_GENMASK16(6, 0)
|
||||
#define CP_INT_GS(val) REG_FIELD_PREP16(CP_INT_GS_MASK, val)
|
||||
|
||||
#define CP_PROP_GS_30 30
|
||||
#define CP_PROP_GS_MASK REG_GENMASK16(13, 7)
|
||||
#define CP_PROP_GS(val) REG_FIELD_PREP16(CP_PROP_GS_MASK, val)
|
||||
|
||||
#define CP_INT_6 6
|
||||
#define CP_INT_MASK REG_GENMASK16(6, 0)
|
||||
#define CP_INT(val) REG_FIELD_PREP16(CP_INT_MASK, val)
|
||||
|
||||
#define CP_PROP_20 20
|
||||
#define CP_PROP_MASK REG_GENMASK16(13, 7)
|
||||
#define CP_PROP(val) REG_FIELD_PREP16(CP_PROP_MASK, val)
|
||||
|
||||
#define V2I_2 2
|
||||
#define V2I_MASK REG_GENMASK16(15, 14)
|
||||
#define V2I(val) REG_FIELD_PREP16(V2I_MASK, val)
|
||||
|
||||
#define HDMI_DIV_1 1
|
||||
#define HDMI_DIV_MASK REG_GENMASK16(2, 0)
|
||||
#define HDMI_DIV(val) REG_FIELD_PREP16(HDMI_DIV_MASK, val)
|
||||
|
||||
#endif /* __INTEL_CX0_REG_DEFS_H__ */
|
||||
@@ -39,6 +39,8 @@
|
||||
#include "intel_combo_phy_regs.h"
|
||||
#include "intel_connector.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_cx0_phy.h"
|
||||
#include "intel_cx0_phy_regs.h"
|
||||
#include "intel_ddi.h"
|
||||
#include "intel_ddi_buf_trans.h"
|
||||
#include "intel_de.h"
|
||||
@@ -61,6 +63,7 @@
|
||||
#include "intel_hti.h"
|
||||
#include "intel_lspcon.h"
|
||||
#include "intel_mg_phy_regs.h"
|
||||
#include "intel_modeset_lock.h"
|
||||
#include "intel_pps.h"
|
||||
#include "intel_psr.h"
|
||||
#include "intel_quirks.h"
|
||||
@@ -68,7 +71,6 @@
|
||||
#include "intel_tc.h"
|
||||
#include "intel_vdsc.h"
|
||||
#include "intel_vdsc_regs.h"
|
||||
#include "intel_vrr.h"
|
||||
#include "skl_scaler.h"
|
||||
#include "skl_universal_plane.h"
|
||||
|
||||
@@ -169,6 +171,18 @@ static void hsw_prepare_hdmi_ddi_buffers(struct intel_encoder *encoder,
|
||||
trans->entries[level].hsw.trans2);
|
||||
}
|
||||
|
||||
static void mtl_wait_ddi_buf_idle(struct drm_i915_private *i915, enum port port)
|
||||
{
|
||||
int ret;
|
||||
|
||||
/* FIXME: find out why Bspec's 100us timeout is too short */
|
||||
ret = wait_for_us((intel_de_read(i915, XELPDP_PORT_BUF_CTL1(port)) &
|
||||
XELPDP_PORT_BUF_PHY_IDLE), 10000);
|
||||
if (ret)
|
||||
drm_err(&i915->drm, "Timeout waiting for DDI BUF %c to get idle\n",
|
||||
port_name(port));
|
||||
}
|
||||
|
||||
void intel_wait_ddi_buf_idle(struct drm_i915_private *dev_priv,
|
||||
enum port port)
|
||||
{
|
||||
@@ -196,7 +210,9 @@ static void intel_wait_ddi_buf_active(struct drm_i915_private *dev_priv,
|
||||
return;
|
||||
}
|
||||
|
||||
if (IS_DG2(dev_priv)) {
|
||||
if (DISPLAY_VER(dev_priv) >= 14) {
|
||||
timeout_us = 10000;
|
||||
} else if (IS_DG2(dev_priv)) {
|
||||
timeout_us = 1200;
|
||||
} else if (DISPLAY_VER(dev_priv) >= 12) {
|
||||
if (intel_phy_is_tc(dev_priv, phy))
|
||||
@@ -207,8 +223,12 @@ static void intel_wait_ddi_buf_active(struct drm_i915_private *dev_priv,
|
||||
timeout_us = 500;
|
||||
}
|
||||
|
||||
ret = _wait_for(!(intel_de_read(dev_priv, DDI_BUF_CTL(port)) &
|
||||
DDI_BUF_IS_IDLE), timeout_us, 10, 10);
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
ret = _wait_for(!(intel_de_read(dev_priv, XELPDP_PORT_BUF_CTL1(port)) & XELPDP_PORT_BUF_PHY_IDLE),
|
||||
timeout_us, 10, 10);
|
||||
else
|
||||
ret = _wait_for(!(intel_de_read(dev_priv, DDI_BUF_CTL(port)) & DDI_BUF_IS_IDLE),
|
||||
timeout_us, 10, 10);
|
||||
|
||||
if (ret)
|
||||
drm_err(&dev_priv->drm, "Timeout waiting for DDI BUF %c to get active\n",
|
||||
@@ -313,6 +333,13 @@ static void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder,
|
||||
DDI_PORT_WIDTH(crtc_state->lane_count) |
|
||||
DDI_BUF_TRANS_SELECT(0);
|
||||
|
||||
if (DISPLAY_VER(i915) >= 14) {
|
||||
if (intel_dp_is_uhbr(crtc_state))
|
||||
intel_dp->DP |= DDI_BUF_PORT_DATA_40BIT;
|
||||
else
|
||||
intel_dp->DP |= DDI_BUF_PORT_DATA_10BIT;
|
||||
}
|
||||
|
||||
if (IS_ALDERLAKE_P(i915) && intel_phy_is_tc(i915, phy)) {
|
||||
intel_dp->DP |= ddi_buf_phy_link_rate(crtc_state->port_clock);
|
||||
if (!intel_tc_port_in_tbt_alt_mode(dig_port))
|
||||
@@ -515,6 +542,8 @@ intel_ddi_transcoder_func_reg_val_get(struct intel_encoder *encoder,
|
||||
temp |= TRANS_DDI_HDMI_SCRAMBLING;
|
||||
if (crtc_state->hdmi_high_tmds_clock_ratio)
|
||||
temp |= TRANS_DDI_HIGH_TMDS_CHAR_RATE;
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
temp |= TRANS_DDI_PORT_WIDTH(crtc_state->lane_count);
|
||||
} else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_ANALOG)) {
|
||||
temp |= TRANS_DDI_MODE_SELECT_FDI_OR_128B132B;
|
||||
temp |= (crtc_state->fdi_lanes - 1) << 1;
|
||||
@@ -2309,6 +2338,179 @@ static void intel_ddi_mso_configure(const struct intel_crtc_state *crtc_state)
|
||||
OVERLAP_PIXELS_MASK, dss1);
|
||||
}
|
||||
|
||||
static u8 mtl_get_port_width(u8 lane_count)
|
||||
{
|
||||
switch (lane_count) {
|
||||
case 1:
|
||||
return 0;
|
||||
case 2:
|
||||
return 1;
|
||||
case 3:
|
||||
return 4;
|
||||
case 4:
|
||||
return 3;
|
||||
default:
|
||||
MISSING_CASE(lane_count);
|
||||
return 4;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
mtl_ddi_enable_d2d(struct intel_encoder *encoder)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
enum port port = encoder->port;
|
||||
|
||||
intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(port), 0,
|
||||
XELPDP_PORT_BUF_D2D_LINK_ENABLE);
|
||||
|
||||
if (wait_for_us((intel_de_read(dev_priv, XELPDP_PORT_BUF_CTL1(port)) &
|
||||
XELPDP_PORT_BUF_D2D_LINK_STATE), 100)) {
|
||||
drm_err(&dev_priv->drm, "Timeout waiting for D2D Link enable for PORT_BUF_CTL %c\n",
|
||||
port_name(port));
|
||||
}
|
||||
}
|
||||
|
||||
static void mtl_port_buf_ctl_program(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
|
||||
enum port port = encoder->port;
|
||||
u32 val;
|
||||
|
||||
val = intel_de_read(i915, XELPDP_PORT_BUF_CTL1(port));
|
||||
val &= ~XELPDP_PORT_WIDTH_MASK;
|
||||
val |= XELPDP_PORT_WIDTH(mtl_get_port_width(crtc_state->lane_count));
|
||||
|
||||
val &= ~XELPDP_PORT_BUF_PORT_DATA_WIDTH_MASK;
|
||||
if (intel_dp_is_uhbr(crtc_state))
|
||||
val |= XELPDP_PORT_BUF_PORT_DATA_40BIT;
|
||||
else
|
||||
val |= XELPDP_PORT_BUF_PORT_DATA_10BIT;
|
||||
|
||||
if (dig_port->saved_port_bits & DDI_BUF_PORT_REVERSAL)
|
||||
val |= XELPDP_PORT_REVERSAL;
|
||||
|
||||
intel_de_write(i915, XELPDP_PORT_BUF_CTL1(port), val);
|
||||
}
|
||||
|
||||
static void mtl_port_buf_ctl_io_selection(struct intel_encoder *encoder)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
|
||||
u32 val;
|
||||
|
||||
val = intel_tc_port_in_tbt_alt_mode(dig_port) ?
|
||||
XELPDP_PORT_BUF_IO_SELECT_TBT : 0;
|
||||
intel_de_rmw(i915, XELPDP_PORT_BUF_CTL1(encoder->port),
|
||||
XELPDP_PORT_BUF_IO_SELECT_TBT, val);
|
||||
}
|
||||
|
||||
static void mtl_ddi_pre_enable_dp(struct intel_atomic_state *state,
|
||||
struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state)
|
||||
{
|
||||
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
||||
bool is_mst = intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST);
|
||||
|
||||
intel_dp_set_link_params(intel_dp,
|
||||
crtc_state->port_clock,
|
||||
crtc_state->lane_count);
|
||||
|
||||
/*
|
||||
* We only configure what the register value will be here. Actual
|
||||
* enabling happens during link training farther down.
|
||||
*/
|
||||
intel_ddi_init_dp_buf_reg(encoder, crtc_state);
|
||||
|
||||
/*
|
||||
* 1. Enable Power Wells
|
||||
*
|
||||
* This was handled at the beginning of intel_atomic_commit_tail(),
|
||||
* before we called down into this function.
|
||||
*/
|
||||
|
||||
/* 2. PMdemand was already set */
|
||||
|
||||
/* 3. Select Thunderbolt */
|
||||
mtl_port_buf_ctl_io_selection(encoder);
|
||||
|
||||
/* 4. Enable Panel Power if PPS is required */
|
||||
intel_pps_on(intel_dp);
|
||||
|
||||
/* 5. Enable the port PLL */
|
||||
intel_ddi_enable_clock(encoder, crtc_state);
|
||||
|
||||
/*
|
||||
* 6.a Configure Transcoder Clock Select to direct the Port clock to the
|
||||
* Transcoder.
|
||||
*/
|
||||
intel_ddi_enable_transcoder_clock(encoder, crtc_state);
|
||||
|
||||
/*
|
||||
* 6.b If DP v2.0/128b mode - Configure TRANS_DP2_CTL register settings.
|
||||
*/
|
||||
intel_ddi_config_transcoder_dp2(encoder, crtc_state);
|
||||
|
||||
/*
|
||||
* 6.c Configure TRANS_DDI_FUNC_CTL DDI Select, DDI Mode Select & MST
|
||||
* Transport Select
|
||||
*/
|
||||
intel_ddi_config_transcoder_func(encoder, crtc_state);
|
||||
|
||||
/*
|
||||
* 6.e Program CoG/MSO configuration bits in DSS_CTL1 if selected.
|
||||
*/
|
||||
intel_ddi_mso_configure(crtc_state);
|
||||
|
||||
if (!is_mst)
|
||||
intel_dp_set_power(intel_dp, DP_SET_POWER_D0);
|
||||
|
||||
intel_dp_configure_protocol_converter(intel_dp, crtc_state);
|
||||
intel_dp_sink_set_decompression_state(intel_dp, crtc_state, true);
|
||||
/*
|
||||
* DDI FEC: "anticipates enabling FEC encoding sets the FEC_READY bit
|
||||
* in the FEC_CONFIGURATION register to 1 before initiating link
|
||||
* training
|
||||
*/
|
||||
intel_dp_sink_set_fec_ready(intel_dp, crtc_state);
|
||||
|
||||
intel_dp_check_frl_training(intel_dp);
|
||||
intel_dp_pcon_dsc_configure(intel_dp, crtc_state);
|
||||
|
||||
/*
|
||||
* 6. The rest of the below are substeps under the bspec's "Enable and
|
||||
* Train Display Port" step. Note that steps that are specific to
|
||||
* MST will be handled by intel_mst_pre_enable_dp() before/after it
|
||||
* calls into this function. Also intel_mst_pre_enable_dp() only calls
|
||||
* us when active_mst_links==0, so any steps designated for "single
|
||||
* stream or multi-stream master transcoder" can just be performed
|
||||
* unconditionally here.
|
||||
*
|
||||
* mtl_ddi_prepare_link_retrain() that is called by
|
||||
* intel_dp_start_link_train() will execute steps: 6.d, 6.f, 6.g, 6.h,
|
||||
* 6.i and 6.j
|
||||
*
|
||||
* 6.k Follow DisplayPort specification training sequence (see notes for
|
||||
* failure handling)
|
||||
* 6.m If DisplayPort multi-stream - Set DP_TP_CTL link training to Idle
|
||||
* Pattern, wait for 5 idle patterns (DP_TP_STATUS Min_Idles_Sent)
|
||||
* (timeout after 800 us)
|
||||
*/
|
||||
intel_dp_start_link_train(intel_dp, crtc_state);
|
||||
|
||||
/* 6.n Set DP_TP_CTL link training to Normal */
|
||||
if (!is_trans_port_sync_mode(crtc_state))
|
||||
intel_dp_stop_link_train(intel_dp, crtc_state);
|
||||
|
||||
/* 6.o Configure and enable FEC if needed */
|
||||
intel_ddi_enable_fec(encoder, crtc_state);
|
||||
|
||||
intel_dsc_dp_pps_write(encoder, crtc_state);
|
||||
}
|
||||
|
||||
static void tgl_ddi_pre_enable_dp(struct intel_atomic_state *state,
|
||||
struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
@@ -2523,7 +2725,9 @@ static void intel_ddi_pre_enable_dp(struct intel_atomic_state *state,
|
||||
intel_dp_128b132b_sdp_crc16(enc_to_intel_dp(encoder),
|
||||
crtc_state);
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 12)
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
mtl_ddi_pre_enable_dp(state, encoder, crtc_state, conn_state);
|
||||
else if (DISPLAY_VER(dev_priv) >= 12)
|
||||
tgl_ddi_pre_enable_dp(state, encoder, crtc_state, conn_state);
|
||||
else
|
||||
hsw_ddi_pre_enable_dp(state, encoder, crtc_state, conn_state);
|
||||
@@ -2597,15 +2801,57 @@ static void intel_ddi_pre_enable(struct intel_atomic_state *state,
|
||||
|
||||
/* FIXME precompute everything properly */
|
||||
/* FIXME how do we turn infoframes off again? */
|
||||
if (dig_port->lspcon.active && dig_port->dp.has_hdmi_sink)
|
||||
if (dig_port->lspcon.active && intel_dp_has_hdmi_sink(&dig_port->dp))
|
||||
dig_port->set_infoframes(encoder,
|
||||
crtc_state->has_infoframe,
|
||||
crtc_state, conn_state);
|
||||
}
|
||||
}
|
||||
|
||||
static void intel_disable_ddi_buf(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
static void
|
||||
mtl_ddi_disable_d2d_link(struct intel_encoder *encoder)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
enum port port = encoder->port;
|
||||
|
||||
intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(port),
|
||||
XELPDP_PORT_BUF_D2D_LINK_ENABLE, 0);
|
||||
|
||||
if (wait_for_us(!(intel_de_read(dev_priv, XELPDP_PORT_BUF_CTL1(port)) &
|
||||
XELPDP_PORT_BUF_D2D_LINK_STATE), 100))
|
||||
drm_err(&dev_priv->drm, "Timeout waiting for D2D Link disable for PORT_BUF_CTL %c\n",
|
||||
port_name(port));
|
||||
}
|
||||
|
||||
static void mtl_disable_ddi_buf(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
enum port port = encoder->port;
|
||||
u32 val;
|
||||
|
||||
/* 3.b Clear DDI_CTL_DE Enable to 0. */
|
||||
val = intel_de_read(dev_priv, DDI_BUF_CTL(port));
|
||||
if (val & DDI_BUF_CTL_ENABLE) {
|
||||
val &= ~DDI_BUF_CTL_ENABLE;
|
||||
intel_de_write(dev_priv, DDI_BUF_CTL(port), val);
|
||||
|
||||
/* 3.c Poll for PORT_BUF_CTL Idle Status == 1, timeout after 100us */
|
||||
mtl_wait_ddi_buf_idle(dev_priv, port);
|
||||
}
|
||||
|
||||
/* 3.d Disable D2D Link */
|
||||
mtl_ddi_disable_d2d_link(encoder);
|
||||
|
||||
/* 3.e Disable DP_TP_CTL */
|
||||
if (intel_crtc_has_dp_encoder(crtc_state)) {
|
||||
intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
|
||||
DP_TP_CTL_ENABLE, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void disable_ddi_buf(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
enum port port = encoder->port;
|
||||
@@ -2630,6 +2876,21 @@ static void intel_disable_ddi_buf(struct intel_encoder *encoder,
|
||||
intel_wait_ddi_buf_idle(dev_priv, port);
|
||||
}
|
||||
|
||||
static void intel_disable_ddi_buf(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 14) {
|
||||
mtl_disable_ddi_buf(encoder, crtc_state);
|
||||
|
||||
/* 3.f Disable DP_TP_CTL FEC Enable if it is needed */
|
||||
intel_ddi_disable_fec_state(encoder, crtc_state);
|
||||
} else {
|
||||
disable_ddi_buf(encoder, crtc_state);
|
||||
}
|
||||
}
|
||||
|
||||
static void intel_ddi_post_disable_dp(struct intel_atomic_state *state,
|
||||
struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *old_crtc_state,
|
||||
@@ -2638,6 +2899,7 @@ static void intel_ddi_post_disable_dp(struct intel_atomic_state *state,
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
|
||||
struct intel_dp *intel_dp = &dig_port->dp;
|
||||
intel_wakeref_t wakeref;
|
||||
bool is_mst = intel_crtc_has_type(old_crtc_state,
|
||||
INTEL_OUTPUT_DP_MST);
|
||||
|
||||
@@ -2677,12 +2939,19 @@ static void intel_ddi_post_disable_dp(struct intel_atomic_state *state,
|
||||
intel_pps_vdd_on(intel_dp);
|
||||
intel_pps_off(intel_dp);
|
||||
|
||||
if (!intel_tc_port_in_tbt_alt_mode(dig_port))
|
||||
wakeref = fetch_and_zero(&dig_port->ddi_io_wakeref);
|
||||
|
||||
if (wakeref)
|
||||
intel_display_power_put(dev_priv,
|
||||
dig_port->ddi_io_power_domain,
|
||||
fetch_and_zero(&dig_port->ddi_io_wakeref));
|
||||
wakeref);
|
||||
|
||||
intel_ddi_disable_clock(encoder);
|
||||
|
||||
/* De-select Thunderbolt */
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(encoder->port),
|
||||
XELPDP_PORT_BUF_IO_SELECT_TBT, 0);
|
||||
}
|
||||
|
||||
static void intel_ddi_post_disable_hdmi(struct intel_atomic_state *state,
|
||||
@@ -2693,6 +2962,7 @@ static void intel_ddi_post_disable_hdmi(struct intel_atomic_state *state,
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
|
||||
struct intel_hdmi *intel_hdmi = &dig_port->hdmi;
|
||||
intel_wakeref_t wakeref;
|
||||
|
||||
dig_port->set_infoframes(encoder, false,
|
||||
old_crtc_state, old_conn_state);
|
||||
@@ -2705,9 +2975,11 @@ static void intel_ddi_post_disable_hdmi(struct intel_atomic_state *state,
|
||||
if (DISPLAY_VER(dev_priv) >= 12)
|
||||
intel_ddi_disable_transcoder_clock(old_crtc_state);
|
||||
|
||||
intel_display_power_put(dev_priv,
|
||||
dig_port->ddi_io_power_domain,
|
||||
fetch_and_zero(&dig_port->ddi_io_wakeref));
|
||||
wakeref = fetch_and_zero(&dig_port->ddi_io_wakeref);
|
||||
if (wakeref)
|
||||
intel_display_power_put(dev_priv,
|
||||
dig_port->ddi_io_power_domain,
|
||||
wakeref);
|
||||
|
||||
intel_ddi_disable_clock(encoder);
|
||||
|
||||
@@ -2725,8 +2997,6 @@ static void intel_ddi_post_disable(struct intel_atomic_state *state,
|
||||
if (!intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_DP_MST)) {
|
||||
intel_crtc_vblank_off(old_crtc_state);
|
||||
|
||||
intel_vrr_disable(old_crtc_state);
|
||||
|
||||
intel_disable_transcoder(old_crtc_state);
|
||||
|
||||
intel_ddi_disable_transcoder_func(old_crtc_state);
|
||||
@@ -2840,7 +3110,7 @@ static void intel_enable_ddi_dp(struct intel_atomic_state *state,
|
||||
drm_connector_update_privacy_screen(conn_state);
|
||||
intel_edp_backlight_on(crtc_state, conn_state);
|
||||
|
||||
if (!dig_port->lspcon.active || dig_port->dp.has_hdmi_sink)
|
||||
if (!dig_port->lspcon.active || intel_dp_has_hdmi_sink(&dig_port->dp))
|
||||
intel_dp_set_infoframes(encoder, true, crtc_state, conn_state);
|
||||
|
||||
intel_audio_codec_enable(encoder, crtc_state, conn_state);
|
||||
@@ -2890,6 +3160,10 @@ static void intel_enable_ddi_hdmi(struct intel_atomic_state *state,
|
||||
if (has_buf_trans_select(dev_priv))
|
||||
hsw_prepare_hdmi_ddi_buffers(encoder, crtc_state);
|
||||
|
||||
/* e. Enable D2D Link for C10/C20 Phy */
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
mtl_ddi_enable_d2d(encoder);
|
||||
|
||||
encoder->set_signal_levels(encoder, crtc_state);
|
||||
|
||||
/* Display WA #1143: skl,kbl,cfl */
|
||||
@@ -2935,12 +3209,30 @@ static void intel_enable_ddi_hdmi(struct intel_atomic_state *state,
|
||||
*
|
||||
* On ADL_P the PHY link rate and lane count must be programmed but
|
||||
* these are both 0 for HDMI.
|
||||
*
|
||||
* But MTL onwards HDMI2.1 is supported and in TMDS mode this
|
||||
* is filled with lane count, already set in the crtc_state.
|
||||
* The same is required to be filled in PORT_BUF_CTL for C10/20 Phy.
|
||||
*/
|
||||
buf_ctl = dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE;
|
||||
if (IS_ALDERLAKE_P(dev_priv) && intel_phy_is_tc(dev_priv, phy)) {
|
||||
if (DISPLAY_VER(dev_priv) >= 14) {
|
||||
u8 lane_count = mtl_get_port_width(crtc_state->lane_count);
|
||||
u32 port_buf = 0;
|
||||
|
||||
port_buf |= XELPDP_PORT_WIDTH(lane_count);
|
||||
|
||||
if (dig_port->saved_port_bits & DDI_BUF_PORT_REVERSAL)
|
||||
port_buf |= XELPDP_PORT_REVERSAL;
|
||||
|
||||
intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(port),
|
||||
XELPDP_PORT_WIDTH_MASK | XELPDP_PORT_REVERSAL, port_buf);
|
||||
|
||||
buf_ctl |= DDI_PORT_WIDTH(lane_count);
|
||||
} else if (IS_ALDERLAKE_P(dev_priv) && intel_phy_is_tc(dev_priv, phy)) {
|
||||
drm_WARN_ON(&dev_priv->drm, !intel_tc_port_in_legacy_mode(dig_port));
|
||||
buf_ctl |= DDI_BUF_CTL_TC_PHY_OWNERSHIP;
|
||||
}
|
||||
|
||||
intel_de_write(dev_priv, DDI_BUF_CTL(port), buf_ctl);
|
||||
|
||||
intel_wait_ddi_buf_active(dev_priv, port);
|
||||
@@ -2963,8 +3255,6 @@ static void intel_enable_ddi(struct intel_atomic_state *state,
|
||||
|
||||
intel_enable_transcoder(crtc_state);
|
||||
|
||||
intel_vrr_enable(encoder, crtc_state);
|
||||
|
||||
intel_crtc_vblank_on(crtc_state);
|
||||
|
||||
if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
|
||||
@@ -2975,9 +3265,7 @@ static void intel_enable_ddi(struct intel_atomic_state *state,
|
||||
/* Enable hdcp if it's desired */
|
||||
if (conn_state->content_protection ==
|
||||
DRM_MODE_CONTENT_PROTECTION_DESIRED)
|
||||
intel_hdcp_enable(to_intel_connector(conn_state->connector),
|
||||
crtc_state,
|
||||
(u8)conn_state->hdcp_content_type);
|
||||
intel_hdcp_enable(state, encoder, crtc_state, conn_state);
|
||||
}
|
||||
|
||||
static void intel_disable_ddi_dp(struct intel_atomic_state *state,
|
||||
@@ -3023,6 +3311,8 @@ static void intel_disable_ddi(struct intel_atomic_state *state,
|
||||
const struct intel_crtc_state *old_crtc_state,
|
||||
const struct drm_connector_state *old_conn_state)
|
||||
{
|
||||
intel_tc_port_link_cancel_reset_work(enc_to_dig_port(encoder));
|
||||
|
||||
intel_hdcp_disable(to_intel_connector(old_conn_state->connector));
|
||||
|
||||
if (intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_HDMI))
|
||||
@@ -3070,7 +3360,8 @@ void intel_ddi_update_active_dpll(struct intel_atomic_state *state,
|
||||
struct intel_crtc *slave_crtc;
|
||||
enum phy phy = intel_port_to_phy(i915, encoder->port);
|
||||
|
||||
if (!intel_phy_is_tc(i915, phy))
|
||||
/* FIXME: Add MTL pll_mgr */
|
||||
if (DISPLAY_VER(i915) >= 14 || !intel_phy_is_tc(i915, phy))
|
||||
return;
|
||||
|
||||
intel_update_active_dpll(state, crtc, encoder);
|
||||
@@ -3121,6 +3412,53 @@ static void adlp_tbt_to_dp_alt_switch_wa(struct intel_encoder *encoder)
|
||||
intel_dkl_phy_rmw(i915, DKL_PCS_DW5(tc_port, ln), DKL_PCS_DW5_CORE_SOFTRESET, 0);
|
||||
}
|
||||
|
||||
static void mtl_ddi_prepare_link_retrain(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
||||
struct intel_encoder *encoder = &dig_port->base;
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
enum port port = encoder->port;
|
||||
u32 dp_tp_ctl;
|
||||
|
||||
/*
|
||||
* TODO: To train with only a different voltage swing entry is not
|
||||
* necessary disable and enable port
|
||||
*/
|
||||
dp_tp_ctl = intel_de_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
|
||||
if (dp_tp_ctl & DP_TP_CTL_ENABLE)
|
||||
mtl_disable_ddi_buf(encoder, crtc_state);
|
||||
|
||||
/* 6.d Configure and enable DP_TP_CTL with link training pattern 1 selected */
|
||||
dp_tp_ctl = DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_PAT1;
|
||||
if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)) {
|
||||
dp_tp_ctl |= DP_TP_CTL_MODE_MST;
|
||||
} else {
|
||||
dp_tp_ctl |= DP_TP_CTL_MODE_SST;
|
||||
if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
|
||||
dp_tp_ctl |= DP_TP_CTL_ENHANCED_FRAME_ENABLE;
|
||||
}
|
||||
intel_de_write(dev_priv, dp_tp_ctl_reg(encoder, crtc_state), dp_tp_ctl);
|
||||
intel_de_posting_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
|
||||
|
||||
/* 6.f Enable D2D Link */
|
||||
mtl_ddi_enable_d2d(encoder);
|
||||
|
||||
/* 6.g Configure voltage swing and related IO settings */
|
||||
encoder->set_signal_levels(encoder, crtc_state);
|
||||
|
||||
/* 6.h Configure PORT_BUF_CTL1 */
|
||||
mtl_port_buf_ctl_program(encoder, crtc_state);
|
||||
|
||||
/* 6.i Configure and enable DDI_CTL_DE to start sending valid data to port slice */
|
||||
intel_dp->DP |= DDI_BUF_CTL_ENABLE;
|
||||
intel_de_write(dev_priv, DDI_BUF_CTL(port), intel_dp->DP);
|
||||
intel_de_posting_read(dev_priv, DDI_BUF_CTL(port));
|
||||
|
||||
/* 6.j Poll for PORT_BUF_CTL Idle Status == 0, timeout after 100 us */
|
||||
intel_wait_ddi_buf_active(dev_priv, port);
|
||||
}
|
||||
|
||||
static void intel_ddi_prepare_link_retrain(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
@@ -3369,7 +3707,11 @@ static void intel_ddi_read_func_ctl(struct intel_encoder *encoder,
|
||||
fallthrough;
|
||||
case TRANS_DDI_MODE_SELECT_DVI:
|
||||
pipe_config->output_types |= BIT(INTEL_OUTPUT_HDMI);
|
||||
pipe_config->lane_count = 4;
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
pipe_config->lane_count =
|
||||
((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1;
|
||||
else
|
||||
pipe_config->lane_count = 4;
|
||||
break;
|
||||
case TRANS_DDI_MODE_SELECT_DP_SST:
|
||||
if (encoder->type == INTEL_OUTPUT_EDP)
|
||||
@@ -3396,7 +3738,7 @@ static void intel_ddi_read_func_ctl(struct intel_encoder *encoder,
|
||||
pipe_config->fec_enable);
|
||||
}
|
||||
|
||||
if (dig_port->lspcon.active && dig_port->dp.has_hdmi_sink)
|
||||
if (dig_port->lspcon.active && intel_dp_has_hdmi_sink(&dig_port->dp))
|
||||
pipe_config->infoframes.enable |=
|
||||
intel_lspcon_infoframes_enabled(encoder, pipe_config);
|
||||
else
|
||||
@@ -3506,6 +3848,28 @@ void intel_ddi_get_clock(struct intel_encoder *encoder,
|
||||
&crtc_state->dpll_hw_state);
|
||||
}
|
||||
|
||||
static void mtl_ddi_get_config(struct intel_encoder *encoder,
|
||||
struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
enum phy phy = intel_port_to_phy(i915, encoder->port);
|
||||
struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
|
||||
|
||||
if (intel_tc_port_in_tbt_alt_mode(dig_port)) {
|
||||
crtc_state->port_clock = intel_mtl_tbt_calc_port_clock(encoder);
|
||||
} else if (intel_is_c10phy(i915, phy)) {
|
||||
intel_c10pll_readout_hw_state(encoder, &crtc_state->cx0pll_state.c10);
|
||||
intel_c10pll_dump_hw_state(i915, &crtc_state->cx0pll_state.c10);
|
||||
crtc_state->port_clock = intel_c10pll_calc_port_clock(encoder, &crtc_state->cx0pll_state.c10);
|
||||
} else {
|
||||
intel_c20pll_readout_hw_state(encoder, &crtc_state->cx0pll_state.c20);
|
||||
intel_c20pll_dump_hw_state(i915, &crtc_state->cx0pll_state.c20);
|
||||
crtc_state->port_clock = intel_c20pll_calc_port_clock(encoder, &crtc_state->cx0pll_state.c20);
|
||||
}
|
||||
|
||||
intel_ddi_get_config(encoder, crtc_state);
|
||||
}
|
||||
|
||||
static void dg2_ddi_get_config(struct intel_encoder *encoder,
|
||||
struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
@@ -3700,6 +4064,9 @@ static int intel_ddi_compute_config(struct intel_encoder *encoder,
|
||||
pipe_config->cpu_transcoder = TRANSCODER_EDP;
|
||||
|
||||
if (intel_crtc_has_type(pipe_config, INTEL_OUTPUT_HDMI)) {
|
||||
pipe_config->has_hdmi_sink =
|
||||
intel_hdmi_compute_has_hdmi_sink(encoder, pipe_config, conn_state);
|
||||
|
||||
ret = intel_hdmi_compute_config(encoder, pipe_config, conn_state);
|
||||
} else {
|
||||
ret = intel_dp_compute_config(encoder, pipe_config, conn_state);
|
||||
@@ -3865,14 +4232,25 @@ static void intel_ddi_encoder_reset(struct drm_encoder *encoder)
|
||||
intel_tc_port_init_mode(dig_port);
|
||||
}
|
||||
|
||||
static int intel_ddi_encoder_late_register(struct drm_encoder *_encoder)
|
||||
{
|
||||
struct intel_encoder *encoder = to_intel_encoder(_encoder);
|
||||
|
||||
intel_tc_port_link_reset(enc_to_dig_port(encoder));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct drm_encoder_funcs intel_ddi_funcs = {
|
||||
.reset = intel_ddi_encoder_reset,
|
||||
.destroy = intel_ddi_encoder_destroy,
|
||||
.late_register = intel_ddi_encoder_late_register,
|
||||
};
|
||||
|
||||
static struct intel_connector *
|
||||
intel_ddi_init_dp_connector(struct intel_digital_port *dig_port)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
|
||||
struct intel_connector *connector;
|
||||
enum port port = dig_port->base.port;
|
||||
|
||||
@@ -3881,7 +4259,10 @@ intel_ddi_init_dp_connector(struct intel_digital_port *dig_port)
|
||||
return NULL;
|
||||
|
||||
dig_port->dp.output_reg = DDI_BUF_CTL(port);
|
||||
dig_port->dp.prepare_link_retrain = intel_ddi_prepare_link_retrain;
|
||||
if (DISPLAY_VER(i915) >= 14)
|
||||
dig_port->dp.prepare_link_retrain = mtl_ddi_prepare_link_retrain;
|
||||
else
|
||||
dig_port->dp.prepare_link_retrain = intel_ddi_prepare_link_retrain;
|
||||
dig_port->dp.set_link_train = intel_ddi_set_link_train;
|
||||
dig_port->dp.set_idle_link_train = intel_ddi_set_idle_link_train;
|
||||
|
||||
@@ -3921,6 +4302,7 @@ static int modeset_pipe(struct drm_crtc *crtc,
|
||||
return -ENOMEM;
|
||||
|
||||
state->acquire_ctx = ctx;
|
||||
to_intel_atomic_state(state)->internal = true;
|
||||
|
||||
crtc_state = drm_atomic_get_crtc_state(state, crtc);
|
||||
if (IS_ERR(crtc_state)) {
|
||||
@@ -4032,27 +4414,17 @@ intel_ddi_hotplug(struct intel_encoder *encoder,
|
||||
|
||||
state = intel_encoder_hotplug(encoder, connector);
|
||||
|
||||
drm_modeset_acquire_init(&ctx, 0);
|
||||
|
||||
for (;;) {
|
||||
if (connector->base.connector_type == DRM_MODE_CONNECTOR_HDMIA)
|
||||
ret = intel_hdmi_reset_link(encoder, &ctx);
|
||||
else
|
||||
ret = intel_dp_retrain_link(encoder, &ctx);
|
||||
|
||||
if (ret == -EDEADLK) {
|
||||
drm_modeset_backoff(&ctx);
|
||||
continue;
|
||||
if (!intel_tc_port_link_reset(dig_port)) {
|
||||
intel_modeset_lock_ctx_retry(&ctx, NULL, 0, ret) {
|
||||
if (connector->base.connector_type == DRM_MODE_CONNECTOR_HDMIA)
|
||||
ret = intel_hdmi_reset_link(encoder, &ctx);
|
||||
else
|
||||
ret = intel_dp_retrain_link(encoder, &ctx);
|
||||
}
|
||||
|
||||
break;
|
||||
drm_WARN_ON(encoder->base.dev, ret);
|
||||
}
|
||||
|
||||
drm_modeset_drop_locks(&ctx);
|
||||
drm_modeset_acquire_fini(&ctx);
|
||||
drm_WARN(encoder->base.dev, ret,
|
||||
"Acquiring modeset locks failed with %i\n", ret);
|
||||
|
||||
/*
|
||||
* Unpowered type-c dongles can take some time to boot and be
|
||||
* responsible, so here giving some time to those dongles to power up
|
||||
@@ -4257,31 +4629,27 @@ static bool intel_ddi_is_tc(struct drm_i915_private *i915, enum port port)
|
||||
|
||||
static void intel_ddi_encoder_suspend(struct intel_encoder *encoder)
|
||||
{
|
||||
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
||||
enum phy phy = intel_port_to_phy(i915, encoder->port);
|
||||
|
||||
intel_dp_encoder_suspend(encoder);
|
||||
}
|
||||
|
||||
if (!intel_phy_is_tc(i915, phy))
|
||||
return;
|
||||
static void intel_ddi_tc_encoder_suspend_complete(struct intel_encoder *encoder)
|
||||
{
|
||||
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
||||
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
||||
|
||||
intel_tc_port_flush_work(dig_port);
|
||||
intel_tc_port_suspend(dig_port);
|
||||
}
|
||||
|
||||
static void intel_ddi_encoder_shutdown(struct intel_encoder *encoder)
|
||||
{
|
||||
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
||||
enum phy phy = intel_port_to_phy(i915, encoder->port);
|
||||
|
||||
intel_dp_encoder_shutdown(encoder);
|
||||
intel_hdmi_encoder_shutdown(encoder);
|
||||
}
|
||||
|
||||
if (!intel_phy_is_tc(i915, phy))
|
||||
return;
|
||||
static void intel_ddi_tc_encoder_shutdown_complete(struct intel_encoder *encoder)
|
||||
{
|
||||
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
||||
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
||||
|
||||
intel_tc_port_cleanup(dig_port);
|
||||
}
|
||||
@@ -4413,7 +4781,12 @@ void intel_ddi_init(struct drm_i915_private *dev_priv, enum port port)
|
||||
encoder->cloneable = 0;
|
||||
encoder->pipe_mask = ~0;
|
||||
|
||||
if (IS_DG2(dev_priv)) {
|
||||
if (DISPLAY_VER(dev_priv) >= 14) {
|
||||
encoder->enable_clock = intel_mtl_pll_enable;
|
||||
encoder->disable_clock = intel_mtl_pll_disable;
|
||||
encoder->port_pll_type = intel_mtl_port_pll_type;
|
||||
encoder->get_config = mtl_ddi_get_config;
|
||||
} else if (IS_DG2(dev_priv)) {
|
||||
encoder->enable_clock = intel_mpllb_enable;
|
||||
encoder->disable_clock = intel_mpllb_disable;
|
||||
encoder->get_config = dg2_ddi_get_config;
|
||||
@@ -4473,7 +4846,9 @@ void intel_ddi_init(struct drm_i915_private *dev_priv, enum port port)
|
||||
encoder->get_config = hsw_ddi_get_config;
|
||||
}
|
||||
|
||||
if (IS_DG2(dev_priv)) {
|
||||
if (DISPLAY_VER(dev_priv) >= 14) {
|
||||
encoder->set_signal_levels = intel_cx0_phy_set_signal_levels;
|
||||
} else if (IS_DG2(dev_priv)) {
|
||||
encoder->set_signal_levels = intel_snps_phy_set_signal_levels;
|
||||
} else if (DISPLAY_VER(dev_priv) >= 12) {
|
||||
if (intel_phy_is_combo(dev_priv, phy))
|
||||
@@ -4541,6 +4916,9 @@ void intel_ddi_init(struct drm_i915_private *dev_priv, enum port port)
|
||||
is_legacy ? "legacy" : "non-legacy");
|
||||
}
|
||||
|
||||
encoder->suspend_complete = intel_ddi_tc_encoder_suspend_complete;
|
||||
encoder->shutdown_complete = intel_ddi_tc_encoder_shutdown_complete;
|
||||
|
||||
if (intel_tc_port_init(dig_port, is_legacy) < 0)
|
||||
goto err;
|
||||
}
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
#include "intel_de.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_dp.h"
|
||||
#include "intel_cx0_phy.h"
|
||||
|
||||
/* HDMI/DVI modes ignore everything but the last 2 items. So we share
|
||||
* them for both DP and FDI transports, allowing those ports to
|
||||
@@ -1035,6 +1036,65 @@ static const struct intel_ddi_buf_trans dg2_snps_trans_uhbr = {
|
||||
.num_entries = ARRAY_SIZE(_dg2_snps_trans_uhbr),
|
||||
};
|
||||
|
||||
static const union intel_ddi_buf_trans_entry _mtl_c10_trans_dp14[] = {
|
||||
{ .snps = { 26, 0, 0 } }, /* preset 0 */
|
||||
{ .snps = { 33, 0, 6 } }, /* preset 1 */
|
||||
{ .snps = { 38, 0, 11 } }, /* preset 2 */
|
||||
{ .snps = { 43, 0, 19 } }, /* preset 3 */
|
||||
{ .snps = { 39, 0, 0 } }, /* preset 4 */
|
||||
{ .snps = { 45, 0, 7 } }, /* preset 5 */
|
||||
{ .snps = { 46, 0, 13 } }, /* preset 6 */
|
||||
{ .snps = { 46, 0, 0 } }, /* preset 7 */
|
||||
{ .snps = { 55, 0, 7 } }, /* preset 8 */
|
||||
{ .snps = { 62, 0, 0 } }, /* preset 9 */
|
||||
};
|
||||
|
||||
static const struct intel_ddi_buf_trans mtl_cx0_trans = {
|
||||
.entries = _mtl_c10_trans_dp14,
|
||||
.num_entries = ARRAY_SIZE(_mtl_c10_trans_dp14),
|
||||
.hdmi_default_entry = ARRAY_SIZE(_mtl_c10_trans_dp14) - 1,
|
||||
};
|
||||
|
||||
/* DP2.0 */
|
||||
static const union intel_ddi_buf_trans_entry _mtl_c20_trans_uhbr[] = {
|
||||
{ .snps = { 48, 0, 0 } }, /* preset 0 */
|
||||
{ .snps = { 43, 0, 5 } }, /* preset 1 */
|
||||
{ .snps = { 40, 0, 8 } }, /* preset 2 */
|
||||
{ .snps = { 37, 0, 11 } }, /* preset 3 */
|
||||
{ .snps = { 33, 0, 15 } }, /* preset 4 */
|
||||
{ .snps = { 46, 2, 0 } }, /* preset 5 */
|
||||
{ .snps = { 42, 2, 4 } }, /* preset 6 */
|
||||
{ .snps = { 38, 2, 8 } }, /* preset 7 */
|
||||
{ .snps = { 35, 2, 11 } }, /* preset 8 */
|
||||
{ .snps = { 33, 2, 13 } }, /* preset 9 */
|
||||
{ .snps = { 44, 4, 0 } }, /* preset 10 */
|
||||
{ .snps = { 40, 4, 4 } }, /* preset 11 */
|
||||
{ .snps = { 37, 4, 7 } }, /* preset 12 */
|
||||
{ .snps = { 33, 4, 11 } }, /* preset 13 */
|
||||
{ .snps = { 40, 8, 0 } }, /* preset 14 */
|
||||
{ .snps = { 28, 2, 2 } }, /* preset 15 */
|
||||
};
|
||||
|
||||
/* HDMI2.0 */
|
||||
static const union intel_ddi_buf_trans_entry _mtl_c20_trans_hdmi[] = {
|
||||
{ .snps = { 48, 0, 0 } }, /* preset 0 */
|
||||
{ .snps = { 38, 4, 6 } }, /* preset 1 */
|
||||
{ .snps = { 36, 4, 8 } }, /* preset 2 */
|
||||
{ .snps = { 34, 4, 10 } }, /* preset 3 */
|
||||
{ .snps = { 32, 4, 12 } }, /* preset 4 */
|
||||
};
|
||||
|
||||
static const struct intel_ddi_buf_trans mtl_c20_trans_hdmi = {
|
||||
.entries = _mtl_c20_trans_hdmi,
|
||||
.num_entries = ARRAY_SIZE(_mtl_c20_trans_hdmi),
|
||||
.hdmi_default_entry = 0,
|
||||
};
|
||||
|
||||
static const struct intel_ddi_buf_trans mtl_c20_trans_uhbr = {
|
||||
.entries = _mtl_c20_trans_uhbr,
|
||||
.num_entries = ARRAY_SIZE(_mtl_c20_trans_uhbr),
|
||||
};
|
||||
|
||||
bool is_hobl_buf_trans(const struct intel_ddi_buf_trans *table)
|
||||
{
|
||||
return table == &tgl_combo_phy_trans_edp_hbr2_hobl;
|
||||
@@ -1606,12 +1666,30 @@ dg2_get_snps_buf_trans(struct intel_encoder *encoder,
|
||||
return intel_get_buf_trans(&dg2_snps_trans, n_entries);
|
||||
}
|
||||
|
||||
static const struct intel_ddi_buf_trans *
|
||||
mtl_get_cx0_buf_trans(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
int *n_entries)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
enum phy phy = intel_port_to_phy(i915, encoder->port);
|
||||
|
||||
if (intel_crtc_has_dp_encoder(crtc_state) && crtc_state->port_clock >= 1000000)
|
||||
return intel_get_buf_trans(&mtl_c20_trans_uhbr, n_entries);
|
||||
else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI) && !(intel_is_c10phy(i915, phy)))
|
||||
return intel_get_buf_trans(&mtl_c20_trans_hdmi, n_entries);
|
||||
else
|
||||
return intel_get_buf_trans(&mtl_cx0_trans, n_entries);
|
||||
}
|
||||
|
||||
void intel_ddi_buf_trans_init(struct intel_encoder *encoder)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
enum phy phy = intel_port_to_phy(i915, encoder->port);
|
||||
|
||||
if (IS_DG2(i915)) {
|
||||
if (DISPLAY_VER(i915) >= 14) {
|
||||
encoder->get_buf_trans = mtl_get_cx0_buf_trans;
|
||||
} else if (IS_DG2(i915)) {
|
||||
encoder->get_buf_trans = dg2_get_snps_buf_trans;
|
||||
} else if (IS_ALDERLAKE_P(i915)) {
|
||||
if (intel_phy_is_combo(i915, phy))
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -56,13 +56,13 @@ struct intel_dp;
|
||||
struct intel_encoder;
|
||||
struct intel_initial_plane_config;
|
||||
struct intel_link_m_n;
|
||||
struct intel_load_detect_pipe;
|
||||
struct intel_plane;
|
||||
struct intel_plane_state;
|
||||
struct intel_power_domain_mask;
|
||||
struct intel_remapped_info;
|
||||
struct intel_rotation_info;
|
||||
struct pci_dev;
|
||||
struct work_struct;
|
||||
|
||||
|
||||
#define pipe_name(p) ((p) + 'A')
|
||||
@@ -105,7 +105,7 @@ enum i9xx_plane_id {
|
||||
};
|
||||
|
||||
#define plane_name(p) ((p) + 'A')
|
||||
#define sprite_name(p, s) ((p) * RUNTIME_INFO(dev_priv)->num_sprites[(p)] + (s) + 'A')
|
||||
#define sprite_name(p, s) ((p) * DISPLAY_RUNTIME_INFO(dev_priv)->num_sprites[(p)] + (s) + 'A')
|
||||
|
||||
#define for_each_plane_id_on_crtc(__crtc, __p) \
|
||||
for ((__p) = PLANE_PRIMARY; (__p) < I915_MAX_PLANES; (__p)++) \
|
||||
@@ -113,7 +113,7 @@ enum i9xx_plane_id {
|
||||
|
||||
#define for_each_dbuf_slice(__dev_priv, __slice) \
|
||||
for ((__slice) = DBUF_S1; (__slice) < I915_MAX_DBUF_SLICES; (__slice)++) \
|
||||
for_each_if(INTEL_INFO(__dev_priv)->display.dbuf.slice_mask & BIT(__slice))
|
||||
for_each_if(INTEL_INFO(__dev_priv)->display->dbuf.slice_mask & BIT(__slice))
|
||||
|
||||
#define for_each_dbuf_slice_in_mask(__dev_priv, __slice, __mask) \
|
||||
for_each_dbuf_slice((__dev_priv), (__slice)) \
|
||||
@@ -221,7 +221,7 @@ enum phy_fia {
|
||||
|
||||
#define for_each_pipe(__dev_priv, __p) \
|
||||
for ((__p) = 0; (__p) < I915_MAX_PIPES; (__p)++) \
|
||||
for_each_if(RUNTIME_INFO(__dev_priv)->pipe_mask & BIT(__p))
|
||||
for_each_if(DISPLAY_RUNTIME_INFO(__dev_priv)->pipe_mask & BIT(__p))
|
||||
|
||||
#define for_each_pipe_masked(__dev_priv, __p, __mask) \
|
||||
for_each_pipe(__dev_priv, __p) \
|
||||
@@ -229,7 +229,7 @@ enum phy_fia {
|
||||
|
||||
#define for_each_cpu_transcoder(__dev_priv, __t) \
|
||||
for ((__t) = 0; (__t) < I915_MAX_TRANSCODERS; (__t)++) \
|
||||
for_each_if (RUNTIME_INFO(__dev_priv)->cpu_transcoder_mask & BIT(__t))
|
||||
for_each_if (DISPLAY_RUNTIME_INFO(__dev_priv)->cpu_transcoder_mask & BIT(__t))
|
||||
|
||||
#define for_each_cpu_transcoder_masked(__dev_priv, __t, __mask) \
|
||||
for_each_cpu_transcoder(__dev_priv, __t) \
|
||||
@@ -237,7 +237,7 @@ enum phy_fia {
|
||||
|
||||
#define for_each_sprite(__dev_priv, __p, __s) \
|
||||
for ((__s) = 0; \
|
||||
(__s) < RUNTIME_INFO(__dev_priv)->num_sprites[(__p)]; \
|
||||
(__s) < DISPLAY_RUNTIME_INFO(__dev_priv)->num_sprites[(__p)]; \
|
||||
(__s)++)
|
||||
|
||||
#define for_each_port(__port) \
|
||||
@@ -407,6 +407,7 @@ intel_mode_valid_max_plane_size(struct drm_i915_private *dev_priv,
|
||||
bool bigjoiner);
|
||||
enum phy intel_port_to_phy(struct drm_i915_private *i915, enum port port);
|
||||
bool is_trans_port_sync_mode(const struct intel_crtc_state *state);
|
||||
bool is_trans_port_sync_master(const struct intel_crtc_state *state);
|
||||
bool intel_crtc_is_bigjoiner_slave(const struct intel_crtc_state *crtc_state);
|
||||
bool intel_crtc_is_bigjoiner_master(const struct intel_crtc_state *crtc_state);
|
||||
u8 intel_crtc_bigjoiner_slave_pipes(const struct intel_crtc_state *crtc_state);
|
||||
@@ -437,7 +438,6 @@ void intel_add_fb_offsets(int *x, int *y,
|
||||
unsigned int intel_rotation_info_size(const struct intel_rotation_info *rot_info);
|
||||
unsigned int intel_remapped_info_size(const struct intel_remapped_info *rem_info);
|
||||
bool intel_has_pending_fb_unpin(struct drm_i915_private *dev_priv);
|
||||
int intel_display_suspend(struct drm_device *dev);
|
||||
void intel_encoder_destroy(struct drm_encoder *encoder);
|
||||
struct drm_display_mode *
|
||||
intel_encoder_current_mode(struct intel_encoder *encoder);
|
||||
@@ -455,20 +455,12 @@ int ilk_get_lanes_required(int target_clock, int link_bw, int bpp);
|
||||
void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
|
||||
struct intel_digital_port *dig_port,
|
||||
unsigned int expected_mask);
|
||||
int intel_get_load_detect_pipe(struct drm_connector *connector,
|
||||
struct intel_load_detect_pipe *old,
|
||||
struct drm_modeset_acquire_ctx *ctx);
|
||||
void intel_release_load_detect_pipe(struct drm_connector *connector,
|
||||
struct intel_load_detect_pipe *old,
|
||||
struct drm_modeset_acquire_ctx *ctx);
|
||||
struct drm_framebuffer *
|
||||
intel_framebuffer_create(struct drm_i915_gem_object *obj,
|
||||
struct drm_mode_fb_cmd2 *mode_cmd);
|
||||
|
||||
bool intel_fuzzy_clock_check(int clock1, int clock2);
|
||||
|
||||
void intel_display_prepare_reset(struct drm_i915_private *dev_priv);
|
||||
void intel_display_finish_reset(struct drm_i915_private *dev_priv);
|
||||
void intel_zero_m_n(struct intel_link_m_n *m_n);
|
||||
void intel_set_m_n(struct drm_i915_private *i915,
|
||||
const struct intel_link_m_n *m_n,
|
||||
@@ -518,21 +510,9 @@ void intel_set_plane_visible(struct intel_crtc_state *crtc_state,
|
||||
bool visible);
|
||||
void intel_plane_fixup_bitmasks(struct intel_crtc_state *crtc_state);
|
||||
|
||||
void intel_display_driver_register(struct drm_i915_private *i915);
|
||||
void intel_display_driver_unregister(struct drm_i915_private *i915);
|
||||
|
||||
void intel_update_watermarks(struct drm_i915_private *i915);
|
||||
|
||||
/* modesetting */
|
||||
bool intel_modeset_probe_defer(struct pci_dev *pdev);
|
||||
void intel_modeset_init_hw(struct drm_i915_private *i915);
|
||||
int intel_modeset_init_noirq(struct drm_i915_private *i915);
|
||||
int intel_modeset_init_nogem(struct drm_i915_private *i915);
|
||||
int intel_modeset_init(struct drm_i915_private *i915);
|
||||
void intel_modeset_driver_remove(struct drm_i915_private *i915);
|
||||
void intel_modeset_driver_remove_noirq(struct drm_i915_private *i915);
|
||||
void intel_modeset_driver_remove_nogem(struct drm_i915_private *i915);
|
||||
void intel_display_resume(struct drm_device *dev);
|
||||
int intel_modeset_all_pipes(struct intel_atomic_state *state,
|
||||
const char *reason);
|
||||
void intel_modeset_get_crtc_power_domains(struct intel_crtc_state *crtc_state,
|
||||
@@ -540,30 +520,41 @@ void intel_modeset_get_crtc_power_domains(struct intel_crtc_state *crtc_state,
|
||||
void intel_modeset_put_crtc_power_domains(struct intel_crtc *crtc,
|
||||
struct intel_power_domain_mask *domains);
|
||||
|
||||
/* interface for intel_display_driver.c */
|
||||
void intel_setup_outputs(struct drm_i915_private *i915);
|
||||
int intel_initial_commit(struct drm_device *dev);
|
||||
void intel_panel_sanitize_ssc(struct drm_i915_private *i915);
|
||||
void intel_update_czclk(struct drm_i915_private *i915);
|
||||
void intel_atomic_helper_free_state_worker(struct work_struct *work);
|
||||
enum drm_mode_status intel_mode_valid(struct drm_device *dev,
|
||||
const struct drm_display_mode *mode);
|
||||
int intel_atomic_commit(struct drm_device *dev, struct drm_atomic_state *_state,
|
||||
bool nonblock);
|
||||
|
||||
void intel_hpd_poll_fini(struct drm_i915_private *i915);
|
||||
|
||||
/* modesetting asserts */
|
||||
void assert_transcoder(struct drm_i915_private *dev_priv,
|
||||
enum transcoder cpu_transcoder, bool state);
|
||||
#define assert_transcoder_enabled(d, t) assert_transcoder(d, t, true)
|
||||
#define assert_transcoder_disabled(d, t) assert_transcoder(d, t, false)
|
||||
|
||||
/* Use I915_STATE_WARN(x) and I915_STATE_WARN_ON() (rather than WARN() and
|
||||
* WARN_ON()) for hw state sanity checks to check for unexpected conditions
|
||||
* which may not necessarily be a user visible problem. This will either
|
||||
* WARN() or DRM_ERROR() depending on the verbose_checks moduleparam, to
|
||||
* enable distros and users to tailor their preferred amount of i915 abrt
|
||||
* spam.
|
||||
/*
|
||||
* Use I915_STATE_WARN(x) (rather than WARN() and WARN_ON()) for hw state sanity
|
||||
* checks to check for unexpected conditions which may not necessarily be a user
|
||||
* visible problem. This will either WARN() or DRM_ERROR() depending on the
|
||||
* verbose_state_checks module param, to enable distros and users to tailor
|
||||
* their preferred amount of i915 abrt spam.
|
||||
*/
|
||||
#define I915_STATE_WARN(condition, format...) ({ \
|
||||
#define I915_STATE_WARN(__i915, condition, format...) ({ \
|
||||
struct drm_device *drm = &(__i915)->drm; \
|
||||
int __ret_warn_on = !!(condition); \
|
||||
if (unlikely(__ret_warn_on)) \
|
||||
if (!WARN(i915_modparams.verbose_state_checks, format)) \
|
||||
DRM_ERROR(format); \
|
||||
if (!drm_WARN(drm, i915_modparams.verbose_state_checks, format)) \
|
||||
drm_err(drm, format); \
|
||||
unlikely(__ret_warn_on); \
|
||||
})
|
||||
|
||||
#define I915_STATE_WARN_ON(x) \
|
||||
I915_STATE_WARN((x), "%s", "WARN_ON(" __stringify(x) ")")
|
||||
|
||||
bool intel_scanout_needs_vtd_wa(struct drm_i915_private *i915);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -30,7 +30,7 @@ struct drm_i915_private;
|
||||
struct drm_property;
|
||||
struct drm_property_blob;
|
||||
struct i915_audio_component;
|
||||
struct i915_hdcp_comp_master;
|
||||
struct i915_hdcp_arbiter;
|
||||
struct intel_atomic_state;
|
||||
struct intel_audio_funcs;
|
||||
struct intel_bios_encoder_data;
|
||||
@@ -395,7 +395,7 @@ struct intel_display {
|
||||
} gmbus;
|
||||
|
||||
struct {
|
||||
struct i915_hdcp_master *master;
|
||||
struct i915_hdcp_arbiter *arbiter;
|
||||
bool comp_added;
|
||||
|
||||
/*
|
||||
@@ -404,8 +404,8 @@ struct intel_display {
|
||||
* this is only populated post Meteorlake
|
||||
*/
|
||||
struct intel_hdcp_gsc_message *hdcp_message;
|
||||
/* Mutex to protect the above hdcp component related values. */
|
||||
struct mutex comp_mutex;
|
||||
/* Mutex to protect the above hdcp related values. */
|
||||
struct mutex hdcp_mutex;
|
||||
} hdcp;
|
||||
|
||||
struct {
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
#include "i915_debugfs.h"
|
||||
#include "i915_irq.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_de.h"
|
||||
#include "intel_crtc_state_dump.h"
|
||||
#include "intel_display_debugfs.h"
|
||||
@@ -30,7 +31,6 @@
|
||||
#include "intel_panel.h"
|
||||
#include "intel_psr.h"
|
||||
#include "intel_psr_regs.h"
|
||||
#include "intel_sprite.h"
|
||||
#include "intel_wm.h"
|
||||
|
||||
static inline struct drm_i915_private *node_to_i915(struct drm_info_node *node)
|
||||
@@ -237,28 +237,26 @@ static void intel_dp_info(struct seq_file *m,
|
||||
|
||||
seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]);
|
||||
seq_printf(m, "\taudio support: %s\n",
|
||||
str_yes_no(intel_dp->has_audio));
|
||||
str_yes_no(intel_connector->base.display_info.has_audio));
|
||||
|
||||
drm_dp_downstream_debug(m, intel_dp->dpcd, intel_dp->downstream_ports,
|
||||
edid ? edid->data : NULL, &intel_dp->aux);
|
||||
}
|
||||
|
||||
static void intel_dp_mst_info(struct seq_file *m,
|
||||
struct intel_connector *intel_connector)
|
||||
struct intel_connector *connector)
|
||||
{
|
||||
bool has_audio = intel_connector->port->has_audio;
|
||||
bool has_audio = connector->base.display_info.has_audio;
|
||||
|
||||
seq_printf(m, "\taudio support: %s\n", str_yes_no(has_audio));
|
||||
}
|
||||
|
||||
static void intel_hdmi_info(struct seq_file *m,
|
||||
struct intel_connector *intel_connector)
|
||||
struct intel_connector *connector)
|
||||
{
|
||||
struct intel_encoder *intel_encoder = intel_attached_encoder(intel_connector);
|
||||
struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(intel_encoder);
|
||||
bool has_audio = connector->base.display_info.has_audio;
|
||||
|
||||
seq_printf(m, "\taudio support: %s\n",
|
||||
str_yes_no(intel_hdmi->has_audio));
|
||||
seq_printf(m, "\taudio support: %s\n", str_yes_no(has_audio));
|
||||
}
|
||||
|
||||
static void intel_connector_info(struct seq_file *m,
|
||||
@@ -1094,6 +1092,7 @@ void intel_display_debugfs_register(struct drm_i915_private *i915)
|
||||
ARRAY_SIZE(intel_display_debugfs_list),
|
||||
minor->debugfs_root, minor);
|
||||
|
||||
intel_cdclk_debugfs_register(i915);
|
||||
intel_dmc_debugfs_register(i915);
|
||||
intel_fbc_debugfs_register(i915);
|
||||
intel_hpd_debugfs_register(i915);
|
||||
|
||||
@@ -0,0 +1,780 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#include <drm/i915_pciids.h>
|
||||
#include <drm/drm_color_mgmt.h>
|
||||
#include <linux/pci.h>
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_display_device.h"
|
||||
#include "intel_display_power.h"
|
||||
#include "intel_display_reg_defs.h"
|
||||
#include "intel_fbc.h"
|
||||
|
||||
__diag_push();
|
||||
__diag_ignore_all("-Woverride-init", "Allow overriding inherited members");
|
||||
|
||||
static const struct intel_display_device_info no_display = {};
|
||||
|
||||
#define PIPE_A_OFFSET 0x70000
|
||||
#define PIPE_B_OFFSET 0x71000
|
||||
#define PIPE_C_OFFSET 0x72000
|
||||
#define PIPE_D_OFFSET 0x73000
|
||||
#define CHV_PIPE_C_OFFSET 0x74000
|
||||
/*
|
||||
* There's actually no pipe EDP. Some pipe registers have
|
||||
* simply shifted from the pipe to the transcoder, while
|
||||
* keeping their original offset. Thus we need PIPE_EDP_OFFSET
|
||||
* to access such registers in transcoder EDP.
|
||||
*/
|
||||
#define PIPE_EDP_OFFSET 0x7f000
|
||||
|
||||
/* ICL DSI 0 and 1 */
|
||||
#define PIPE_DSI0_OFFSET 0x7b000
|
||||
#define PIPE_DSI1_OFFSET 0x7b800
|
||||
|
||||
#define TRANSCODER_A_OFFSET 0x60000
|
||||
#define TRANSCODER_B_OFFSET 0x61000
|
||||
#define TRANSCODER_C_OFFSET 0x62000
|
||||
#define CHV_TRANSCODER_C_OFFSET 0x63000
|
||||
#define TRANSCODER_D_OFFSET 0x63000
|
||||
#define TRANSCODER_EDP_OFFSET 0x6f000
|
||||
#define TRANSCODER_DSI0_OFFSET 0x6b000
|
||||
#define TRANSCODER_DSI1_OFFSET 0x6b800
|
||||
|
||||
#define CURSOR_A_OFFSET 0x70080
|
||||
#define CURSOR_B_OFFSET 0x700c0
|
||||
#define CHV_CURSOR_C_OFFSET 0x700e0
|
||||
#define IVB_CURSOR_B_OFFSET 0x71080
|
||||
#define IVB_CURSOR_C_OFFSET 0x72080
|
||||
#define TGL_CURSOR_D_OFFSET 0x73080
|
||||
|
||||
#define I845_PIPE_OFFSETS \
|
||||
.pipe_offsets = { \
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET, \
|
||||
}, \
|
||||
.trans_offsets = { \
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET, \
|
||||
}
|
||||
|
||||
#define I9XX_PIPE_OFFSETS \
|
||||
.pipe_offsets = { \
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET, \
|
||||
[TRANSCODER_B] = PIPE_B_OFFSET, \
|
||||
}, \
|
||||
.trans_offsets = { \
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET, \
|
||||
[TRANSCODER_B] = TRANSCODER_B_OFFSET, \
|
||||
}
|
||||
|
||||
#define IVB_PIPE_OFFSETS \
|
||||
.pipe_offsets = { \
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET, \
|
||||
[TRANSCODER_B] = PIPE_B_OFFSET, \
|
||||
[TRANSCODER_C] = PIPE_C_OFFSET, \
|
||||
}, \
|
||||
.trans_offsets = { \
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET, \
|
||||
[TRANSCODER_B] = TRANSCODER_B_OFFSET, \
|
||||
[TRANSCODER_C] = TRANSCODER_C_OFFSET, \
|
||||
}
|
||||
|
||||
#define HSW_PIPE_OFFSETS \
|
||||
.pipe_offsets = { \
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET, \
|
||||
[TRANSCODER_B] = PIPE_B_OFFSET, \
|
||||
[TRANSCODER_C] = PIPE_C_OFFSET, \
|
||||
[TRANSCODER_EDP] = PIPE_EDP_OFFSET, \
|
||||
}, \
|
||||
.trans_offsets = { \
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET, \
|
||||
[TRANSCODER_B] = TRANSCODER_B_OFFSET, \
|
||||
[TRANSCODER_C] = TRANSCODER_C_OFFSET, \
|
||||
[TRANSCODER_EDP] = TRANSCODER_EDP_OFFSET, \
|
||||
}
|
||||
|
||||
#define CHV_PIPE_OFFSETS \
|
||||
.pipe_offsets = { \
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET, \
|
||||
[TRANSCODER_B] = PIPE_B_OFFSET, \
|
||||
[TRANSCODER_C] = CHV_PIPE_C_OFFSET, \
|
||||
}, \
|
||||
.trans_offsets = { \
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET, \
|
||||
[TRANSCODER_B] = TRANSCODER_B_OFFSET, \
|
||||
[TRANSCODER_C] = CHV_TRANSCODER_C_OFFSET, \
|
||||
}
|
||||
|
||||
#define I845_CURSOR_OFFSETS \
|
||||
.cursor_offsets = { \
|
||||
[PIPE_A] = CURSOR_A_OFFSET, \
|
||||
}
|
||||
|
||||
#define I9XX_CURSOR_OFFSETS \
|
||||
.cursor_offsets = { \
|
||||
[PIPE_A] = CURSOR_A_OFFSET, \
|
||||
[PIPE_B] = CURSOR_B_OFFSET, \
|
||||
}
|
||||
|
||||
#define CHV_CURSOR_OFFSETS \
|
||||
.cursor_offsets = { \
|
||||
[PIPE_A] = CURSOR_A_OFFSET, \
|
||||
[PIPE_B] = CURSOR_B_OFFSET, \
|
||||
[PIPE_C] = CHV_CURSOR_C_OFFSET, \
|
||||
}
|
||||
|
||||
#define IVB_CURSOR_OFFSETS \
|
||||
.cursor_offsets = { \
|
||||
[PIPE_A] = CURSOR_A_OFFSET, \
|
||||
[PIPE_B] = IVB_CURSOR_B_OFFSET, \
|
||||
[PIPE_C] = IVB_CURSOR_C_OFFSET, \
|
||||
}
|
||||
|
||||
#define TGL_CURSOR_OFFSETS \
|
||||
.cursor_offsets = { \
|
||||
[PIPE_A] = CURSOR_A_OFFSET, \
|
||||
[PIPE_B] = IVB_CURSOR_B_OFFSET, \
|
||||
[PIPE_C] = IVB_CURSOR_C_OFFSET, \
|
||||
[PIPE_D] = TGL_CURSOR_D_OFFSET, \
|
||||
}
|
||||
|
||||
#define I845_COLORS \
|
||||
.color = { .gamma_lut_size = 256 }
|
||||
#define I9XX_COLORS \
|
||||
.color = { .gamma_lut_size = 129, \
|
||||
.gamma_lut_tests = DRM_COLOR_LUT_NON_DECREASING, \
|
||||
}
|
||||
#define ILK_COLORS \
|
||||
.color = { .gamma_lut_size = 1024 }
|
||||
#define IVB_COLORS \
|
||||
.color = { .degamma_lut_size = 1024, .gamma_lut_size = 1024 }
|
||||
#define CHV_COLORS \
|
||||
.color = { \
|
||||
.degamma_lut_size = 65, .gamma_lut_size = 257, \
|
||||
.degamma_lut_tests = DRM_COLOR_LUT_NON_DECREASING, \
|
||||
.gamma_lut_tests = DRM_COLOR_LUT_NON_DECREASING, \
|
||||
}
|
||||
#define GLK_COLORS \
|
||||
.color = { \
|
||||
.degamma_lut_size = 33, .gamma_lut_size = 1024, \
|
||||
.degamma_lut_tests = DRM_COLOR_LUT_NON_DECREASING | \
|
||||
DRM_COLOR_LUT_EQUAL_CHANNELS, \
|
||||
}
|
||||
#define ICL_COLORS \
|
||||
.color = { \
|
||||
.degamma_lut_size = 33, .gamma_lut_size = 262145, \
|
||||
.degamma_lut_tests = DRM_COLOR_LUT_NON_DECREASING | \
|
||||
DRM_COLOR_LUT_EQUAL_CHANNELS, \
|
||||
.gamma_lut_tests = DRM_COLOR_LUT_NON_DECREASING, \
|
||||
}
|
||||
|
||||
#define I830_DISPLAY \
|
||||
.has_overlay = 1, \
|
||||
.cursor_needs_physical = 1, \
|
||||
.overlay_needs_physical = 1, \
|
||||
.has_gmch = 1, \
|
||||
I9XX_PIPE_OFFSETS, \
|
||||
I9XX_CURSOR_OFFSETS, \
|
||||
I9XX_COLORS, \
|
||||
\
|
||||
.__runtime_defaults.ip.ver = 2, \
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B), \
|
||||
.__runtime_defaults.cpu_transcoder_mask = \
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B)
|
||||
|
||||
static const struct intel_display_device_info i830_display = {
|
||||
I830_DISPLAY,
|
||||
};
|
||||
|
||||
#define I845_DISPLAY \
|
||||
.has_overlay = 1, \
|
||||
.overlay_needs_physical = 1, \
|
||||
.has_gmch = 1, \
|
||||
I845_PIPE_OFFSETS, \
|
||||
I845_CURSOR_OFFSETS, \
|
||||
I845_COLORS, \
|
||||
\
|
||||
.__runtime_defaults.ip.ver = 2, \
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A), \
|
||||
.__runtime_defaults.cpu_transcoder_mask = BIT(TRANSCODER_A)
|
||||
|
||||
static const struct intel_display_device_info i845_display = {
|
||||
I845_DISPLAY,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info i85x_display = {
|
||||
I830_DISPLAY,
|
||||
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info i865g_display = {
|
||||
I845_DISPLAY,
|
||||
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
#define GEN3_DISPLAY \
|
||||
.has_gmch = 1, \
|
||||
.has_overlay = 1, \
|
||||
I9XX_PIPE_OFFSETS, \
|
||||
I9XX_CURSOR_OFFSETS, \
|
||||
I9XX_COLORS, \
|
||||
\
|
||||
.__runtime_defaults.ip.ver = 3, \
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B), \
|
||||
.__runtime_defaults.cpu_transcoder_mask = \
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B)
|
||||
|
||||
static const struct intel_display_device_info i915g_display = {
|
||||
GEN3_DISPLAY,
|
||||
.cursor_needs_physical = 1,
|
||||
.overlay_needs_physical = 1,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info i915gm_display = {
|
||||
GEN3_DISPLAY,
|
||||
.cursor_needs_physical = 1,
|
||||
.overlay_needs_physical = 1,
|
||||
.supports_tv = 1,
|
||||
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info i945g_display = {
|
||||
GEN3_DISPLAY,
|
||||
.has_hotplug = 1,
|
||||
.cursor_needs_physical = 1,
|
||||
.overlay_needs_physical = 1,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info i945gm_display = {
|
||||
GEN3_DISPLAY,
|
||||
.has_hotplug = 1,
|
||||
.cursor_needs_physical = 1,
|
||||
.overlay_needs_physical = 1,
|
||||
.supports_tv = 1,
|
||||
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info g33_display = {
|
||||
GEN3_DISPLAY,
|
||||
.has_hotplug = 1,
|
||||
};
|
||||
|
||||
#define GEN4_DISPLAY \
|
||||
.has_hotplug = 1, \
|
||||
.has_gmch = 1, \
|
||||
I9XX_PIPE_OFFSETS, \
|
||||
I9XX_CURSOR_OFFSETS, \
|
||||
I9XX_COLORS, \
|
||||
\
|
||||
.__runtime_defaults.ip.ver = 4, \
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B), \
|
||||
.__runtime_defaults.cpu_transcoder_mask = \
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B)
|
||||
|
||||
static const struct intel_display_device_info i965g_display = {
|
||||
GEN4_DISPLAY,
|
||||
.has_overlay = 1,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info i965gm_display = {
|
||||
GEN4_DISPLAY,
|
||||
.has_overlay = 1,
|
||||
.supports_tv = 1,
|
||||
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info g45_display = {
|
||||
GEN4_DISPLAY,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info gm45_display = {
|
||||
GEN4_DISPLAY,
|
||||
.supports_tv = 1,
|
||||
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
#define ILK_DISPLAY \
|
||||
.has_hotplug = 1, \
|
||||
I9XX_PIPE_OFFSETS, \
|
||||
I9XX_CURSOR_OFFSETS, \
|
||||
ILK_COLORS, \
|
||||
\
|
||||
.__runtime_defaults.ip.ver = 5, \
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B), \
|
||||
.__runtime_defaults.cpu_transcoder_mask = \
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B)
|
||||
|
||||
static const struct intel_display_device_info ilk_d_display = {
|
||||
ILK_DISPLAY,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info ilk_m_display = {
|
||||
ILK_DISPLAY,
|
||||
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info snb_display = {
|
||||
.has_hotplug = 1,
|
||||
I9XX_PIPE_OFFSETS,
|
||||
I9XX_CURSOR_OFFSETS,
|
||||
ILK_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 6,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B),
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info ivb_display = {
|
||||
.has_hotplug = 1,
|
||||
IVB_PIPE_OFFSETS,
|
||||
IVB_CURSOR_OFFSETS,
|
||||
IVB_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 7,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) | BIT(TRANSCODER_C),
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info vlv_display = {
|
||||
.has_gmch = 1,
|
||||
.has_hotplug = 1,
|
||||
.mmio_offset = VLV_DISPLAY_BASE,
|
||||
I9XX_PIPE_OFFSETS,
|
||||
I9XX_CURSOR_OFFSETS,
|
||||
I9XX_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 7,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info hsw_display = {
|
||||
.has_ddi = 1,
|
||||
.has_dp_mst = 1,
|
||||
.has_fpga_dbg = 1,
|
||||
.has_hotplug = 1,
|
||||
HSW_PIPE_OFFSETS,
|
||||
IVB_CURSOR_OFFSETS,
|
||||
IVB_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 7,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_EDP),
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info bdw_display = {
|
||||
.has_ddi = 1,
|
||||
.has_dp_mst = 1,
|
||||
.has_fpga_dbg = 1,
|
||||
.has_hotplug = 1,
|
||||
HSW_PIPE_OFFSETS,
|
||||
IVB_CURSOR_OFFSETS,
|
||||
IVB_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 8,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_EDP),
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info chv_display = {
|
||||
.has_hotplug = 1,
|
||||
.has_gmch = 1,
|
||||
.mmio_offset = VLV_DISPLAY_BASE,
|
||||
CHV_PIPE_OFFSETS,
|
||||
CHV_CURSOR_OFFSETS,
|
||||
CHV_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 8,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) | BIT(TRANSCODER_C),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info skl_display = {
|
||||
.dbuf.size = 896 - 4, /* 4 blocks for bypass path allocation */
|
||||
.dbuf.slice_mask = BIT(DBUF_S1),
|
||||
.has_ddi = 1,
|
||||
.has_dp_mst = 1,
|
||||
.has_fpga_dbg = 1,
|
||||
.has_hotplug = 1,
|
||||
.has_ipc = 1,
|
||||
.has_psr = 1,
|
||||
.has_psr_hw_tracking = 1,
|
||||
HSW_PIPE_OFFSETS,
|
||||
IVB_CURSOR_OFFSETS,
|
||||
IVB_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 9,
|
||||
.__runtime_defaults.has_dmc = 1,
|
||||
.__runtime_defaults.has_hdcp = 1,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_EDP),
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
#define GEN9_LP_DISPLAY \
|
||||
.dbuf.slice_mask = BIT(DBUF_S1), \
|
||||
.has_dp_mst = 1, \
|
||||
.has_ddi = 1, \
|
||||
.has_fpga_dbg = 1, \
|
||||
.has_hotplug = 1, \
|
||||
.has_ipc = 1, \
|
||||
.has_psr = 1, \
|
||||
.has_psr_hw_tracking = 1, \
|
||||
HSW_PIPE_OFFSETS, \
|
||||
IVB_CURSOR_OFFSETS, \
|
||||
IVB_COLORS, \
|
||||
\
|
||||
.__runtime_defaults.has_dmc = 1, \
|
||||
.__runtime_defaults.has_hdcp = 1, \
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A), \
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C), \
|
||||
.__runtime_defaults.cpu_transcoder_mask = \
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) | \
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_EDP) | \
|
||||
BIT(TRANSCODER_DSI_A) | BIT(TRANSCODER_DSI_C)
|
||||
|
||||
static const struct intel_display_device_info bxt_display = {
|
||||
GEN9_LP_DISPLAY,
|
||||
.dbuf.size = 512 - 4, /* 4 blocks for bypass path allocation */
|
||||
|
||||
.__runtime_defaults.ip.ver = 9,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info glk_display = {
|
||||
GEN9_LP_DISPLAY,
|
||||
.dbuf.size = 1024 - 4, /* 4 blocks for bypass path allocation */
|
||||
GLK_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 10,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info gen11_display = {
|
||||
.abox_mask = BIT(0),
|
||||
.dbuf.size = 2048,
|
||||
.dbuf.slice_mask = BIT(DBUF_S1) | BIT(DBUF_S2),
|
||||
.has_ddi = 1,
|
||||
.has_dp_mst = 1,
|
||||
.has_fpga_dbg = 1,
|
||||
.has_hotplug = 1,
|
||||
.has_ipc = 1,
|
||||
.has_psr = 1,
|
||||
.has_psr_hw_tracking = 1,
|
||||
.pipe_offsets = {
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET,
|
||||
[TRANSCODER_B] = PIPE_B_OFFSET,
|
||||
[TRANSCODER_C] = PIPE_C_OFFSET,
|
||||
[TRANSCODER_EDP] = PIPE_EDP_OFFSET,
|
||||
[TRANSCODER_DSI_0] = PIPE_DSI0_OFFSET,
|
||||
[TRANSCODER_DSI_1] = PIPE_DSI1_OFFSET,
|
||||
},
|
||||
.trans_offsets = {
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET,
|
||||
[TRANSCODER_B] = TRANSCODER_B_OFFSET,
|
||||
[TRANSCODER_C] = TRANSCODER_C_OFFSET,
|
||||
[TRANSCODER_EDP] = TRANSCODER_EDP_OFFSET,
|
||||
[TRANSCODER_DSI_0] = TRANSCODER_DSI0_OFFSET,
|
||||
[TRANSCODER_DSI_1] = TRANSCODER_DSI1_OFFSET,
|
||||
},
|
||||
IVB_CURSOR_OFFSETS,
|
||||
ICL_COLORS,
|
||||
|
||||
.__runtime_defaults.ip.ver = 11,
|
||||
.__runtime_defaults.has_dmc = 1,
|
||||
.__runtime_defaults.has_dsc = 1,
|
||||
.__runtime_defaults.has_hdcp = 1,
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_EDP) |
|
||||
BIT(TRANSCODER_DSI_0) | BIT(TRANSCODER_DSI_1),
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A),
|
||||
};
|
||||
|
||||
#define XE_D_DISPLAY \
|
||||
.abox_mask = GENMASK(2, 1), \
|
||||
.dbuf.size = 2048, \
|
||||
.dbuf.slice_mask = BIT(DBUF_S1) | BIT(DBUF_S2), \
|
||||
.has_ddi = 1, \
|
||||
.has_dp_mst = 1, \
|
||||
.has_dsb = 1, \
|
||||
.has_fpga_dbg = 1, \
|
||||
.has_hotplug = 1, \
|
||||
.has_ipc = 1, \
|
||||
.has_psr = 1, \
|
||||
.has_psr_hw_tracking = 1, \
|
||||
.pipe_offsets = { \
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET, \
|
||||
[TRANSCODER_B] = PIPE_B_OFFSET, \
|
||||
[TRANSCODER_C] = PIPE_C_OFFSET, \
|
||||
[TRANSCODER_D] = PIPE_D_OFFSET, \
|
||||
[TRANSCODER_DSI_0] = PIPE_DSI0_OFFSET, \
|
||||
[TRANSCODER_DSI_1] = PIPE_DSI1_OFFSET, \
|
||||
}, \
|
||||
.trans_offsets = { \
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET, \
|
||||
[TRANSCODER_B] = TRANSCODER_B_OFFSET, \
|
||||
[TRANSCODER_C] = TRANSCODER_C_OFFSET, \
|
||||
[TRANSCODER_D] = TRANSCODER_D_OFFSET, \
|
||||
[TRANSCODER_DSI_0] = TRANSCODER_DSI0_OFFSET, \
|
||||
[TRANSCODER_DSI_1] = TRANSCODER_DSI1_OFFSET, \
|
||||
}, \
|
||||
TGL_CURSOR_OFFSETS, \
|
||||
ICL_COLORS, \
|
||||
\
|
||||
.__runtime_defaults.ip.ver = 12, \
|
||||
.__runtime_defaults.has_dmc = 1, \
|
||||
.__runtime_defaults.has_dsc = 1, \
|
||||
.__runtime_defaults.has_hdcp = 1, \
|
||||
.__runtime_defaults.pipe_mask = \
|
||||
BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C) | BIT(PIPE_D), \
|
||||
.__runtime_defaults.cpu_transcoder_mask = \
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) | \
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_D) | \
|
||||
BIT(TRANSCODER_DSI_0) | BIT(TRANSCODER_DSI_1), \
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A)
|
||||
|
||||
static const struct intel_display_device_info tgl_display = {
|
||||
XE_D_DISPLAY,
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info rkl_display = {
|
||||
XE_D_DISPLAY,
|
||||
.abox_mask = BIT(0),
|
||||
.has_hti = 1,
|
||||
.has_psr_hw_tracking = 0,
|
||||
|
||||
.__runtime_defaults.pipe_mask = BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) | BIT(TRANSCODER_C),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info adl_s_display = {
|
||||
XE_D_DISPLAY,
|
||||
.has_hti = 1,
|
||||
.has_psr_hw_tracking = 0,
|
||||
};
|
||||
|
||||
#define XE_LPD_FEATURES \
|
||||
.abox_mask = GENMASK(1, 0), \
|
||||
.color = { \
|
||||
.degamma_lut_size = 129, .gamma_lut_size = 1024, \
|
||||
.degamma_lut_tests = DRM_COLOR_LUT_NON_DECREASING | \
|
||||
DRM_COLOR_LUT_EQUAL_CHANNELS, \
|
||||
}, \
|
||||
.dbuf.size = 4096, \
|
||||
.dbuf.slice_mask = BIT(DBUF_S1) | BIT(DBUF_S2) | BIT(DBUF_S3) | \
|
||||
BIT(DBUF_S4), \
|
||||
.has_ddi = 1, \
|
||||
.has_dp_mst = 1, \
|
||||
.has_dsb = 1, \
|
||||
.has_fpga_dbg = 1, \
|
||||
.has_hotplug = 1, \
|
||||
.has_ipc = 1, \
|
||||
.has_psr = 1, \
|
||||
.pipe_offsets = { \
|
||||
[TRANSCODER_A] = PIPE_A_OFFSET, \
|
||||
[TRANSCODER_B] = PIPE_B_OFFSET, \
|
||||
[TRANSCODER_C] = PIPE_C_OFFSET, \
|
||||
[TRANSCODER_D] = PIPE_D_OFFSET, \
|
||||
[TRANSCODER_DSI_0] = PIPE_DSI0_OFFSET, \
|
||||
[TRANSCODER_DSI_1] = PIPE_DSI1_OFFSET, \
|
||||
}, \
|
||||
.trans_offsets = { \
|
||||
[TRANSCODER_A] = TRANSCODER_A_OFFSET, \
|
||||
[TRANSCODER_B] = TRANSCODER_B_OFFSET, \
|
||||
[TRANSCODER_C] = TRANSCODER_C_OFFSET, \
|
||||
[TRANSCODER_D] = TRANSCODER_D_OFFSET, \
|
||||
[TRANSCODER_DSI_0] = TRANSCODER_DSI0_OFFSET, \
|
||||
[TRANSCODER_DSI_1] = TRANSCODER_DSI1_OFFSET, \
|
||||
}, \
|
||||
TGL_CURSOR_OFFSETS, \
|
||||
\
|
||||
.__runtime_defaults.ip.ver = 13, \
|
||||
.__runtime_defaults.has_dmc = 1, \
|
||||
.__runtime_defaults.has_dsc = 1, \
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A), \
|
||||
.__runtime_defaults.has_hdcp = 1, \
|
||||
.__runtime_defaults.pipe_mask = \
|
||||
BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C) | BIT(PIPE_D)
|
||||
|
||||
static const struct intel_display_device_info xe_lpd_display = {
|
||||
XE_LPD_FEATURES,
|
||||
.has_cdclk_crawl = 1,
|
||||
.has_psr_hw_tracking = 0,
|
||||
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_D) |
|
||||
BIT(TRANSCODER_DSI_0) | BIT(TRANSCODER_DSI_1),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info xe_hpd_display = {
|
||||
XE_LPD_FEATURES,
|
||||
.has_cdclk_squash = 1,
|
||||
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_D),
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info xe_lpdp_display = {
|
||||
XE_LPD_FEATURES,
|
||||
.has_cdclk_crawl = 1,
|
||||
.has_cdclk_squash = 1,
|
||||
|
||||
.__runtime_defaults.ip.ver = 14,
|
||||
.__runtime_defaults.fbc_mask = BIT(INTEL_FBC_A) | BIT(INTEL_FBC_B),
|
||||
.__runtime_defaults.cpu_transcoder_mask =
|
||||
BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
|
||||
BIT(TRANSCODER_C) | BIT(TRANSCODER_D),
|
||||
};
|
||||
|
||||
__diag_pop();
|
||||
|
||||
#undef INTEL_VGA_DEVICE
|
||||
#undef INTEL_QUANTA_VGA_DEVICE
|
||||
#define INTEL_VGA_DEVICE(id, info) { id, info }
|
||||
#define INTEL_QUANTA_VGA_DEVICE(info) { 0x16a, info }
|
||||
|
||||
static const struct {
|
||||
u32 devid;
|
||||
const struct intel_display_device_info *info;
|
||||
} intel_display_ids[] = {
|
||||
INTEL_I830_IDS(&i830_display),
|
||||
INTEL_I845G_IDS(&i845_display),
|
||||
INTEL_I85X_IDS(&i85x_display),
|
||||
INTEL_I865G_IDS(&i865g_display),
|
||||
INTEL_I915G_IDS(&i915g_display),
|
||||
INTEL_I915GM_IDS(&i915gm_display),
|
||||
INTEL_I945G_IDS(&i945g_display),
|
||||
INTEL_I945GM_IDS(&i945gm_display),
|
||||
INTEL_I965G_IDS(&i965g_display),
|
||||
INTEL_G33_IDS(&g33_display),
|
||||
INTEL_I965GM_IDS(&i965gm_display),
|
||||
INTEL_GM45_IDS(&gm45_display),
|
||||
INTEL_G45_IDS(&g45_display),
|
||||
INTEL_PINEVIEW_G_IDS(&g33_display),
|
||||
INTEL_PINEVIEW_M_IDS(&g33_display),
|
||||
INTEL_IRONLAKE_D_IDS(&ilk_d_display),
|
||||
INTEL_IRONLAKE_M_IDS(&ilk_m_display),
|
||||
INTEL_SNB_D_IDS(&snb_display),
|
||||
INTEL_SNB_M_IDS(&snb_display),
|
||||
INTEL_IVB_Q_IDS(NULL), /* must be first IVB in list */
|
||||
INTEL_IVB_M_IDS(&ivb_display),
|
||||
INTEL_IVB_D_IDS(&ivb_display),
|
||||
INTEL_HSW_IDS(&hsw_display),
|
||||
INTEL_VLV_IDS(&vlv_display),
|
||||
INTEL_BDW_IDS(&bdw_display),
|
||||
INTEL_CHV_IDS(&chv_display),
|
||||
INTEL_SKL_IDS(&skl_display),
|
||||
INTEL_BXT_IDS(&bxt_display),
|
||||
INTEL_GLK_IDS(&glk_display),
|
||||
INTEL_KBL_IDS(&skl_display),
|
||||
INTEL_CFL_IDS(&skl_display),
|
||||
INTEL_ICL_11_IDS(&gen11_display),
|
||||
INTEL_EHL_IDS(&gen11_display),
|
||||
INTEL_JSL_IDS(&gen11_display),
|
||||
INTEL_TGL_12_IDS(&tgl_display),
|
||||
INTEL_DG1_IDS(&tgl_display),
|
||||
INTEL_RKL_IDS(&rkl_display),
|
||||
INTEL_ADLS_IDS(&adl_s_display),
|
||||
INTEL_RPLS_IDS(&adl_s_display),
|
||||
INTEL_ADLP_IDS(&xe_lpd_display),
|
||||
INTEL_ADLN_IDS(&xe_lpd_display),
|
||||
INTEL_RPLP_IDS(&xe_lpd_display),
|
||||
INTEL_DG2_IDS(&xe_hpd_display),
|
||||
|
||||
/*
|
||||
* Do not add any GMD_ID-based platforms to this list. They will
|
||||
* be probed automatically based on the IP version reported by
|
||||
* the hardware.
|
||||
*/
|
||||
};
|
||||
|
||||
static const struct {
|
||||
u16 ver;
|
||||
u16 rel;
|
||||
const struct intel_display_device_info *display;
|
||||
} gmdid_display_map[] = {
|
||||
{ 14, 0, &xe_lpdp_display },
|
||||
};
|
||||
|
||||
static const struct intel_display_device_info *
|
||||
probe_gmdid_display(struct drm_i915_private *i915, u16 *ver, u16 *rel, u16 *step)
|
||||
{
|
||||
struct pci_dev *pdev = to_pci_dev(i915->drm.dev);
|
||||
void __iomem *addr;
|
||||
u32 val;
|
||||
int i;
|
||||
|
||||
addr = pci_iomap_range(pdev, 0, i915_mmio_reg_offset(GMD_ID_DISPLAY), sizeof(u32));
|
||||
if (!addr) {
|
||||
drm_err(&i915->drm, "Cannot map MMIO BAR to read display GMD_ID\n");
|
||||
return &no_display;
|
||||
}
|
||||
|
||||
val = ioread32(addr);
|
||||
pci_iounmap(pdev, addr);
|
||||
|
||||
if (val == 0)
|
||||
/* Platform doesn't have display */
|
||||
return &no_display;
|
||||
|
||||
*ver = REG_FIELD_GET(GMD_ID_ARCH_MASK, val);
|
||||
*rel = REG_FIELD_GET(GMD_ID_RELEASE_MASK, val);
|
||||
*step = REG_FIELD_GET(GMD_ID_STEP, val);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(gmdid_display_map); i++)
|
||||
if (*ver == gmdid_display_map[i].ver &&
|
||||
*rel == gmdid_display_map[i].rel)
|
||||
return gmdid_display_map[i].display;
|
||||
|
||||
drm_err(&i915->drm, "Unrecognized display IP version %d.%02d; disabling display.\n",
|
||||
*ver, *rel);
|
||||
return &no_display;
|
||||
}
|
||||
|
||||
const struct intel_display_device_info *
|
||||
intel_display_device_probe(struct drm_i915_private *i915, bool has_gmdid,
|
||||
u16 *gmdid_ver, u16 *gmdid_rel, u16 *gmdid_step)
|
||||
{
|
||||
struct pci_dev *pdev = to_pci_dev(i915->drm.dev);
|
||||
int i;
|
||||
|
||||
if (has_gmdid)
|
||||
return probe_gmdid_display(i915, gmdid_ver, gmdid_rel, gmdid_step);
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(intel_display_ids); i++) {
|
||||
if (intel_display_ids[i].devid == pdev->device)
|
||||
return intel_display_ids[i].info;
|
||||
}
|
||||
|
||||
drm_dbg(&i915->drm, "No display ID found for device ID %04x; disabling display.\n",
|
||||
pdev->device);
|
||||
|
||||
return &no_display;
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
/* SPDX-License-Identifier: MIT */
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_DISPLAY_DEVICE_H__
|
||||
#define __INTEL_DISPLAY_DEVICE_H__
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
#include "display/intel_display_limits.h"
|
||||
|
||||
struct drm_i915_private;
|
||||
|
||||
#define DEV_INFO_DISPLAY_FOR_EACH_FLAG(func) \
|
||||
/* Keep in alphabetical order */ \
|
||||
func(cursor_needs_physical); \
|
||||
func(has_cdclk_crawl); \
|
||||
func(has_cdclk_squash); \
|
||||
func(has_ddi); \
|
||||
func(has_dp_mst); \
|
||||
func(has_dsb); \
|
||||
func(has_fpga_dbg); \
|
||||
func(has_gmch); \
|
||||
func(has_hotplug); \
|
||||
func(has_hti); \
|
||||
func(has_ipc); \
|
||||
func(has_overlay); \
|
||||
func(has_psr); \
|
||||
func(has_psr_hw_tracking); \
|
||||
func(overlay_needs_physical); \
|
||||
func(supports_tv);
|
||||
|
||||
#define HAS_ASYNC_FLIPS(i915) (DISPLAY_VER(i915) >= 5)
|
||||
#define HAS_CDCLK_CRAWL(i915) (DISPLAY_INFO(i915)->has_cdclk_crawl)
|
||||
#define HAS_CDCLK_SQUASH(i915) (DISPLAY_INFO(i915)->has_cdclk_squash)
|
||||
#define HAS_CUR_FBC(i915) (!HAS_GMCH(i915) && DISPLAY_VER(i915) >= 7)
|
||||
#define HAS_D12_PLANE_MINIMIZATION(i915) (IS_ROCKETLAKE(i915) || IS_ALDERLAKE_S(i915))
|
||||
#define HAS_DDI(i915) (DISPLAY_INFO(i915)->has_ddi)
|
||||
#define HAS_DISPLAY(i915) (DISPLAY_RUNTIME_INFO(i915)->pipe_mask != 0)
|
||||
#define HAS_DMC(i915) (DISPLAY_RUNTIME_INFO(i915)->has_dmc)
|
||||
#define HAS_DOUBLE_BUFFERED_M_N(i915) (DISPLAY_VER(i915) >= 9 || IS_BROADWELL(i915))
|
||||
#define HAS_DP_MST(i915) (DISPLAY_INFO(i915)->has_dp_mst)
|
||||
#define HAS_DP20(i915) (IS_DG2(i915) || DISPLAY_VER(i915) >= 14)
|
||||
#define HAS_DPT(i915) (DISPLAY_VER(i915) >= 13)
|
||||
#define HAS_DSB(i915) (DISPLAY_INFO(i915)->has_dsb)
|
||||
#define HAS_DSC(__i915) (DISPLAY_RUNTIME_INFO(__i915)->has_dsc)
|
||||
#define HAS_FBC(i915) (DISPLAY_RUNTIME_INFO(i915)->fbc_mask != 0)
|
||||
#define HAS_FPGA_DBG_UNCLAIMED(i915) (DISPLAY_INFO(i915)->has_fpga_dbg)
|
||||
#define HAS_FW_BLC(i915) (DISPLAY_VER(i915) > 2)
|
||||
#define HAS_GMBUS_IRQ(i915) (DISPLAY_VER(i915) >= 4)
|
||||
#define HAS_GMBUS_BURST_READ(i915) (DISPLAY_VER(i915) >= 10 || IS_KABYLAKE(i915))
|
||||
#define HAS_GMCH(i915) (DISPLAY_INFO(i915)->has_gmch)
|
||||
#define HAS_HW_SAGV_WM(i915) (DISPLAY_VER(i915) >= 13 && !IS_DGFX(i915))
|
||||
#define HAS_IPC(i915) (DISPLAY_INFO(i915)->has_ipc)
|
||||
#define HAS_IPS(i915) (IS_HSW_ULT(i915) || IS_BROADWELL(i915))
|
||||
#define HAS_LSPCON(i915) (IS_DISPLAY_VER(i915, 9, 10))
|
||||
#define HAS_MBUS_JOINING(i915) (IS_ALDERLAKE_P(i915) || DISPLAY_VER(i915) >= 14)
|
||||
#define HAS_MSO(i915) (DISPLAY_VER(i915) >= 12)
|
||||
#define HAS_OVERLAY(i915) (DISPLAY_INFO(i915)->has_overlay)
|
||||
#define HAS_PSR(i915) (DISPLAY_INFO(i915)->has_psr)
|
||||
#define HAS_PSR_HW_TRACKING(i915) (DISPLAY_INFO(i915)->has_psr_hw_tracking)
|
||||
#define HAS_PSR2_SEL_FETCH(i915) (DISPLAY_VER(i915) >= 12)
|
||||
#define HAS_SAGV(i915) (DISPLAY_VER(i915) >= 9 && !IS_LP(i915))
|
||||
#define HAS_TRANSCODER(i915, trans) ((DISPLAY_RUNTIME_INFO(i915)->cpu_transcoder_mask & \
|
||||
BIT(trans)) != 0)
|
||||
#define HAS_VRR(i915) (DISPLAY_VER(i915) >= 11)
|
||||
#define INTEL_NUM_PIPES(i915) (hweight8(DISPLAY_RUNTIME_INFO(i915)->pipe_mask))
|
||||
#define I915_HAS_HOTPLUG(i915) (DISPLAY_INFO(i915)->has_hotplug)
|
||||
#define OVERLAY_NEEDS_PHYSICAL(i915) (DISPLAY_INFO(i915)->overlay_needs_physical)
|
||||
#define SUPPORTS_TV(i915) (DISPLAY_INFO(i915)->supports_tv)
|
||||
|
||||
struct intel_display_runtime_info {
|
||||
struct {
|
||||
u16 ver;
|
||||
u16 rel;
|
||||
u16 step;
|
||||
} ip;
|
||||
|
||||
u8 pipe_mask;
|
||||
u8 cpu_transcoder_mask;
|
||||
|
||||
u8 num_sprites[I915_MAX_PIPES];
|
||||
u8 num_scalers[I915_MAX_PIPES];
|
||||
|
||||
u8 fbc_mask;
|
||||
|
||||
bool has_hdcp;
|
||||
bool has_dmc;
|
||||
bool has_dsc;
|
||||
};
|
||||
|
||||
struct intel_display_device_info {
|
||||
/* Initial runtime info. */
|
||||
const struct intel_display_runtime_info __runtime_defaults;
|
||||
|
||||
u8 abox_mask;
|
||||
|
||||
struct {
|
||||
u16 size; /* in blocks */
|
||||
u8 slice_mask;
|
||||
} dbuf;
|
||||
|
||||
#define DEFINE_FLAG(name) u8 name:1
|
||||
DEV_INFO_DISPLAY_FOR_EACH_FLAG(DEFINE_FLAG);
|
||||
#undef DEFINE_FLAG
|
||||
|
||||
/* Global register offset for the display engine */
|
||||
u32 mmio_offset;
|
||||
|
||||
/* Register offsets for the various display pipes and transcoders */
|
||||
u32 pipe_offsets[I915_MAX_TRANSCODERS];
|
||||
u32 trans_offsets[I915_MAX_TRANSCODERS];
|
||||
u32 cursor_offsets[I915_MAX_PIPES];
|
||||
|
||||
struct {
|
||||
u32 degamma_lut_size;
|
||||
u32 gamma_lut_size;
|
||||
u32 degamma_lut_tests;
|
||||
u32 gamma_lut_tests;
|
||||
} color;
|
||||
};
|
||||
|
||||
const struct intel_display_device_info *
|
||||
intel_display_device_probe(struct drm_i915_private *i915, bool has_gmdid,
|
||||
u16 *ver, u16 *rel, u16 *step);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,583 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Copyright © 2022-2023 Intel Corporation
|
||||
*
|
||||
* High level display driver entry points. This is a layer between top level
|
||||
* driver code and low level display functionality; no low level display code or
|
||||
* details here.
|
||||
*/
|
||||
|
||||
#include <linux/vga_switcheroo.h>
|
||||
#include <acpi/video.h>
|
||||
#include <drm/display/drm_dp_mst_helper.h>
|
||||
#include <drm/drm_atomic_helper.h>
|
||||
#include <drm/drm_mode_config.h>
|
||||
#include <drm/drm_privacy_screen_consumer.h>
|
||||
#include <drm/drm_probe_helper.h>
|
||||
#include <drm/drm_vblank.h>
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i9xx_wm.h"
|
||||
#include "intel_acpi.h"
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_audio.h"
|
||||
#include "intel_bios.h"
|
||||
#include "intel_bw.h"
|
||||
#include "intel_cdclk.h"
|
||||
#include "intel_color.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_display_debugfs.h"
|
||||
#include "intel_display_driver.h"
|
||||
#include "intel_display_power.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_dkl_phy.h"
|
||||
#include "intel_dmc.h"
|
||||
#include "intel_dp.h"
|
||||
#include "intel_dpll.h"
|
||||
#include "intel_dpll_mgr.h"
|
||||
#include "intel_fb.h"
|
||||
#include "intel_fbc.h"
|
||||
#include "intel_fbdev.h"
|
||||
#include "intel_fdi.h"
|
||||
#include "intel_gmbus.h"
|
||||
#include "intel_hdcp.h"
|
||||
#include "intel_hotplug.h"
|
||||
#include "intel_hti.h"
|
||||
#include "intel_modeset_setup.h"
|
||||
#include "intel_opregion.h"
|
||||
#include "intel_overlay.h"
|
||||
#include "intel_plane_initial.h"
|
||||
#include "intel_pps.h"
|
||||
#include "intel_quirks.h"
|
||||
#include "intel_vga.h"
|
||||
#include "intel_wm.h"
|
||||
#include "skl_watermark.h"
|
||||
|
||||
bool intel_display_driver_probe_defer(struct pci_dev *pdev)
|
||||
{
|
||||
struct drm_privacy_screen *privacy_screen;
|
||||
|
||||
/*
|
||||
* apple-gmux is needed on dual GPU MacBook Pro
|
||||
* to probe the panel if we're the inactive GPU.
|
||||
*/
|
||||
if (vga_switcheroo_client_probe_defer(pdev))
|
||||
return true;
|
||||
|
||||
/* If the LCD panel has a privacy-screen, wait for it */
|
||||
privacy_screen = drm_privacy_screen_get(&pdev->dev, NULL);
|
||||
if (IS_ERR(privacy_screen) && PTR_ERR(privacy_screen) == -EPROBE_DEFER)
|
||||
return true;
|
||||
|
||||
drm_privacy_screen_put(privacy_screen);
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void intel_display_driver_init_hw(struct drm_i915_private *i915)
|
||||
{
|
||||
struct intel_cdclk_state *cdclk_state;
|
||||
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
cdclk_state = to_intel_cdclk_state(i915->display.cdclk.obj.state);
|
||||
|
||||
intel_update_cdclk(i915);
|
||||
intel_cdclk_dump_config(i915, &i915->display.cdclk.hw, "Current CDCLK");
|
||||
cdclk_state->logical = cdclk_state->actual = i915->display.cdclk.hw;
|
||||
}
|
||||
|
||||
static const struct drm_mode_config_funcs intel_mode_funcs = {
|
||||
.fb_create = intel_user_framebuffer_create,
|
||||
.get_format_info = intel_fb_get_format_info,
|
||||
.output_poll_changed = intel_fbdev_output_poll_changed,
|
||||
.mode_valid = intel_mode_valid,
|
||||
.atomic_check = intel_atomic_check,
|
||||
.atomic_commit = intel_atomic_commit,
|
||||
.atomic_state_alloc = intel_atomic_state_alloc,
|
||||
.atomic_state_clear = intel_atomic_state_clear,
|
||||
.atomic_state_free = intel_atomic_state_free,
|
||||
};
|
||||
|
||||
static const struct drm_mode_config_helper_funcs intel_mode_config_funcs = {
|
||||
.atomic_commit_setup = drm_dp_mst_atomic_setup_commit,
|
||||
};
|
||||
|
||||
static void intel_mode_config_init(struct drm_i915_private *i915)
|
||||
{
|
||||
struct drm_mode_config *mode_config = &i915->drm.mode_config;
|
||||
|
||||
drm_mode_config_init(&i915->drm);
|
||||
INIT_LIST_HEAD(&i915->display.global.obj_list);
|
||||
|
||||
mode_config->min_width = 0;
|
||||
mode_config->min_height = 0;
|
||||
|
||||
mode_config->preferred_depth = 24;
|
||||
mode_config->prefer_shadow = 1;
|
||||
|
||||
mode_config->funcs = &intel_mode_funcs;
|
||||
mode_config->helper_private = &intel_mode_config_funcs;
|
||||
|
||||
mode_config->async_page_flip = HAS_ASYNC_FLIPS(i915);
|
||||
|
||||
/*
|
||||
* Maximum framebuffer dimensions, chosen to match
|
||||
* the maximum render engine surface size on gen4+.
|
||||
*/
|
||||
if (DISPLAY_VER(i915) >= 7) {
|
||||
mode_config->max_width = 16384;
|
||||
mode_config->max_height = 16384;
|
||||
} else if (DISPLAY_VER(i915) >= 4) {
|
||||
mode_config->max_width = 8192;
|
||||
mode_config->max_height = 8192;
|
||||
} else if (DISPLAY_VER(i915) == 3) {
|
||||
mode_config->max_width = 4096;
|
||||
mode_config->max_height = 4096;
|
||||
} else {
|
||||
mode_config->max_width = 2048;
|
||||
mode_config->max_height = 2048;
|
||||
}
|
||||
|
||||
if (IS_I845G(i915) || IS_I865G(i915)) {
|
||||
mode_config->cursor_width = IS_I845G(i915) ? 64 : 512;
|
||||
mode_config->cursor_height = 1023;
|
||||
} else if (IS_I830(i915) || IS_I85X(i915) ||
|
||||
IS_I915G(i915) || IS_I915GM(i915)) {
|
||||
mode_config->cursor_width = 64;
|
||||
mode_config->cursor_height = 64;
|
||||
} else {
|
||||
mode_config->cursor_width = 256;
|
||||
mode_config->cursor_height = 256;
|
||||
}
|
||||
}
|
||||
|
||||
static void intel_mode_config_cleanup(struct drm_i915_private *i915)
|
||||
{
|
||||
intel_atomic_global_obj_cleanup(i915);
|
||||
drm_mode_config_cleanup(&i915->drm);
|
||||
}
|
||||
|
||||
static void intel_plane_possible_crtcs_init(struct drm_i915_private *dev_priv)
|
||||
{
|
||||
struct intel_plane *plane;
|
||||
|
||||
for_each_intel_plane(&dev_priv->drm, plane) {
|
||||
struct intel_crtc *crtc = intel_crtc_for_pipe(dev_priv,
|
||||
plane->pipe);
|
||||
|
||||
plane->base.possible_crtcs = drm_crtc_mask(&crtc->base);
|
||||
}
|
||||
}
|
||||
|
||||
void intel_display_driver_early_probe(struct drm_i915_private *i915)
|
||||
{
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
intel_dkl_phy_init(i915);
|
||||
intel_color_init_hooks(i915);
|
||||
intel_init_cdclk_hooks(i915);
|
||||
intel_audio_hooks_init(i915);
|
||||
intel_dpll_init_clock_hook(i915);
|
||||
intel_init_display_hooks(i915);
|
||||
intel_fdi_init_hook(i915);
|
||||
}
|
||||
|
||||
/* part #1: call before irq install */
|
||||
int intel_display_driver_probe_noirq(struct drm_i915_private *i915)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (i915_inject_probe_failure(i915))
|
||||
return -ENODEV;
|
||||
|
||||
if (HAS_DISPLAY(i915)) {
|
||||
ret = drm_vblank_init(&i915->drm,
|
||||
INTEL_NUM_PIPES(i915));
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
intel_bios_init(i915);
|
||||
|
||||
ret = intel_vga_register(i915);
|
||||
if (ret)
|
||||
goto cleanup_bios;
|
||||
|
||||
/* FIXME: completely on the wrong abstraction layer */
|
||||
ret = intel_power_domains_init(i915);
|
||||
if (ret < 0)
|
||||
goto cleanup_vga;
|
||||
|
||||
intel_power_domains_init_hw(i915, false);
|
||||
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return 0;
|
||||
|
||||
intel_dmc_init(i915);
|
||||
|
||||
i915->display.wq.modeset = alloc_ordered_workqueue("i915_modeset", 0);
|
||||
i915->display.wq.flip = alloc_workqueue("i915_flip", WQ_HIGHPRI |
|
||||
WQ_UNBOUND, WQ_UNBOUND_MAX_ACTIVE);
|
||||
|
||||
intel_mode_config_init(i915);
|
||||
|
||||
ret = intel_cdclk_init(i915);
|
||||
if (ret)
|
||||
goto cleanup_vga_client_pw_domain_dmc;
|
||||
|
||||
ret = intel_color_init(i915);
|
||||
if (ret)
|
||||
goto cleanup_vga_client_pw_domain_dmc;
|
||||
|
||||
ret = intel_dbuf_init(i915);
|
||||
if (ret)
|
||||
goto cleanup_vga_client_pw_domain_dmc;
|
||||
|
||||
ret = intel_bw_init(i915);
|
||||
if (ret)
|
||||
goto cleanup_vga_client_pw_domain_dmc;
|
||||
|
||||
init_llist_head(&i915->display.atomic_helper.free_list);
|
||||
INIT_WORK(&i915->display.atomic_helper.free_work,
|
||||
intel_atomic_helper_free_state_worker);
|
||||
|
||||
intel_init_quirks(i915);
|
||||
|
||||
intel_fbc_init(i915);
|
||||
|
||||
return 0;
|
||||
|
||||
cleanup_vga_client_pw_domain_dmc:
|
||||
intel_dmc_fini(i915);
|
||||
intel_power_domains_driver_remove(i915);
|
||||
cleanup_vga:
|
||||
intel_vga_unregister(i915);
|
||||
cleanup_bios:
|
||||
intel_bios_driver_remove(i915);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* part #2: call after irq install, but before gem init */
|
||||
int intel_display_driver_probe_nogem(struct drm_i915_private *i915)
|
||||
{
|
||||
struct drm_device *dev = &i915->drm;
|
||||
enum pipe pipe;
|
||||
struct intel_crtc *crtc;
|
||||
int ret;
|
||||
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return 0;
|
||||
|
||||
intel_wm_init(i915);
|
||||
|
||||
intel_panel_sanitize_ssc(i915);
|
||||
|
||||
intel_pps_setup(i915);
|
||||
|
||||
intel_gmbus_setup(i915);
|
||||
|
||||
drm_dbg_kms(&i915->drm, "%d display pipe%s available.\n",
|
||||
INTEL_NUM_PIPES(i915),
|
||||
INTEL_NUM_PIPES(i915) > 1 ? "s" : "");
|
||||
|
||||
for_each_pipe(i915, pipe) {
|
||||
ret = intel_crtc_init(i915, pipe);
|
||||
if (ret) {
|
||||
intel_mode_config_cleanup(i915);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
intel_plane_possible_crtcs_init(i915);
|
||||
intel_shared_dpll_init(i915);
|
||||
intel_fdi_pll_freq_update(i915);
|
||||
|
||||
intel_update_czclk(i915);
|
||||
intel_display_driver_init_hw(i915);
|
||||
intel_dpll_update_ref_clks(i915);
|
||||
|
||||
intel_hdcp_component_init(i915);
|
||||
|
||||
if (i915->display.cdclk.max_cdclk_freq == 0)
|
||||
intel_update_max_cdclk(i915);
|
||||
|
||||
intel_hti_init(i915);
|
||||
|
||||
/* Just disable it once at startup */
|
||||
intel_vga_disable(i915);
|
||||
intel_setup_outputs(i915);
|
||||
|
||||
drm_modeset_lock_all(dev);
|
||||
intel_modeset_setup_hw_state(i915, dev->mode_config.acquire_ctx);
|
||||
intel_acpi_assign_connector_fwnodes(i915);
|
||||
drm_modeset_unlock_all(dev);
|
||||
|
||||
for_each_intel_crtc(dev, crtc) {
|
||||
if (!to_intel_crtc_state(crtc->base.state)->uapi.active)
|
||||
continue;
|
||||
intel_crtc_initial_plane_config(crtc);
|
||||
}
|
||||
|
||||
/*
|
||||
* Make sure hardware watermarks really match the state we read out.
|
||||
* Note that we need to do this after reconstructing the BIOS fb's
|
||||
* since the watermark calculation done here will use pstate->fb.
|
||||
*/
|
||||
if (!HAS_GMCH(i915))
|
||||
ilk_wm_sanitize(i915);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* part #3: call after gem init */
|
||||
int intel_display_driver_probe(struct drm_i915_private *i915)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* Force all active planes to recompute their states. So that on
|
||||
* mode_setcrtc after probe, all the intel_plane_state variables
|
||||
* are already calculated and there is no assert_plane warnings
|
||||
* during bootup.
|
||||
*/
|
||||
ret = intel_initial_commit(&i915->drm);
|
||||
if (ret)
|
||||
drm_dbg_kms(&i915->drm, "Initial modeset failed, %d\n", ret);
|
||||
|
||||
intel_overlay_setup(i915);
|
||||
|
||||
ret = intel_fbdev_init(&i915->drm);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* Only enable hotplug handling once the fbdev is fully set up. */
|
||||
intel_hpd_init(i915);
|
||||
intel_hpd_poll_disable(i915);
|
||||
|
||||
skl_watermark_ipc_init(i915);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void intel_display_driver_register(struct drm_i915_private *i915)
|
||||
{
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
/* Must be done after probing outputs */
|
||||
intel_opregion_register(i915);
|
||||
intel_acpi_video_register(i915);
|
||||
|
||||
intel_audio_init(i915);
|
||||
|
||||
intel_display_debugfs_register(i915);
|
||||
|
||||
/*
|
||||
* Some ports require correctly set-up hpd registers for
|
||||
* detection to work properly (leading to ghost connected
|
||||
* connector status), e.g. VGA on gm45. Hence we can only set
|
||||
* up the initial fbdev config after hpd irqs are fully
|
||||
* enabled. We do it last so that the async config cannot run
|
||||
* before the connectors are registered.
|
||||
*/
|
||||
intel_fbdev_initial_config_async(i915);
|
||||
|
||||
/*
|
||||
* We need to coordinate the hotplugs with the asynchronous
|
||||
* fbdev configuration, for which we use the
|
||||
* fbdev->async_cookie.
|
||||
*/
|
||||
drm_kms_helper_poll_init(&i915->drm);
|
||||
}
|
||||
|
||||
/* part #1: call before irq uninstall */
|
||||
void intel_display_driver_remove(struct drm_i915_private *i915)
|
||||
{
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
flush_workqueue(i915->display.wq.flip);
|
||||
flush_workqueue(i915->display.wq.modeset);
|
||||
|
||||
flush_work(&i915->display.atomic_helper.free_work);
|
||||
drm_WARN_ON(&i915->drm, !llist_empty(&i915->display.atomic_helper.free_list));
|
||||
|
||||
/*
|
||||
* MST topology needs to be suspended so we don't have any calls to
|
||||
* fbdev after it's finalized. MST will be destroyed later as part of
|
||||
* drm_mode_config_cleanup()
|
||||
*/
|
||||
intel_dp_mst_suspend(i915);
|
||||
}
|
||||
|
||||
/* part #2: call after irq uninstall */
|
||||
void intel_display_driver_remove_noirq(struct drm_i915_private *i915)
|
||||
{
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
/*
|
||||
* Due to the hpd irq storm handling the hotplug work can re-arm the
|
||||
* poll handlers. Hence disable polling after hpd handling is shut down.
|
||||
*/
|
||||
intel_hpd_poll_fini(i915);
|
||||
|
||||
/* poll work can call into fbdev, hence clean that up afterwards */
|
||||
intel_fbdev_fini(i915);
|
||||
|
||||
intel_unregister_dsm_handler();
|
||||
|
||||
/* flush any delayed tasks or pending work */
|
||||
flush_scheduled_work();
|
||||
|
||||
intel_hdcp_component_fini(i915);
|
||||
|
||||
intel_mode_config_cleanup(i915);
|
||||
|
||||
intel_overlay_cleanup(i915);
|
||||
|
||||
intel_gmbus_teardown(i915);
|
||||
|
||||
destroy_workqueue(i915->display.wq.flip);
|
||||
destroy_workqueue(i915->display.wq.modeset);
|
||||
|
||||
intel_fbc_cleanup(i915);
|
||||
}
|
||||
|
||||
/* part #3: call after gem init */
|
||||
void intel_display_driver_remove_nogem(struct drm_i915_private *i915)
|
||||
{
|
||||
intel_dmc_fini(i915);
|
||||
|
||||
intel_power_domains_driver_remove(i915);
|
||||
|
||||
intel_vga_unregister(i915);
|
||||
|
||||
intel_bios_driver_remove(i915);
|
||||
}
|
||||
|
||||
void intel_display_driver_unregister(struct drm_i915_private *i915)
|
||||
{
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
intel_fbdev_unregister(i915);
|
||||
intel_audio_deinit(i915);
|
||||
|
||||
/*
|
||||
* After flushing the fbdev (incl. a late async config which
|
||||
* will have delayed queuing of a hotplug event), then flush
|
||||
* the hotplug events.
|
||||
*/
|
||||
drm_kms_helper_poll_fini(&i915->drm);
|
||||
drm_atomic_helper_shutdown(&i915->drm);
|
||||
|
||||
acpi_video_unregister();
|
||||
intel_opregion_unregister(i915);
|
||||
}
|
||||
|
||||
/*
|
||||
* turn all crtc's off, but do not adjust state
|
||||
* This has to be paired with a call to intel_modeset_setup_hw_state.
|
||||
*/
|
||||
int intel_display_driver_suspend(struct drm_i915_private *i915)
|
||||
{
|
||||
struct drm_atomic_state *state;
|
||||
int ret;
|
||||
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return 0;
|
||||
|
||||
state = drm_atomic_helper_suspend(&i915->drm);
|
||||
ret = PTR_ERR_OR_ZERO(state);
|
||||
if (ret)
|
||||
drm_err(&i915->drm, "Suspending crtc's failed with %i\n",
|
||||
ret);
|
||||
else
|
||||
i915->display.restore.modeset_state = state;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int
|
||||
__intel_display_driver_resume(struct drm_i915_private *i915,
|
||||
struct drm_atomic_state *state,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
struct drm_crtc_state *crtc_state;
|
||||
struct drm_crtc *crtc;
|
||||
int ret, i;
|
||||
|
||||
intel_modeset_setup_hw_state(i915, ctx);
|
||||
intel_vga_redisable(i915);
|
||||
|
||||
if (!state)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* We've duplicated the state, pointers to the old state are invalid.
|
||||
*
|
||||
* Don't attempt to use the old state until we commit the duplicated state.
|
||||
*/
|
||||
for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
|
||||
/*
|
||||
* Force recalculation even if we restore
|
||||
* current state. With fast modeset this may not result
|
||||
* in a modeset when the state is compatible.
|
||||
*/
|
||||
crtc_state->mode_changed = true;
|
||||
}
|
||||
|
||||
/* ignore any reset values/BIOS leftovers in the WM registers */
|
||||
if (!HAS_GMCH(i915))
|
||||
to_intel_atomic_state(state)->skip_intermediate_wm = true;
|
||||
|
||||
ret = drm_atomic_helper_commit_duplicated_state(state, ctx);
|
||||
|
||||
drm_WARN_ON(&i915->drm, ret == -EDEADLK);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void intel_display_driver_resume(struct drm_i915_private *i915)
|
||||
{
|
||||
struct drm_atomic_state *state = i915->display.restore.modeset_state;
|
||||
struct drm_modeset_acquire_ctx ctx;
|
||||
int ret;
|
||||
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
i915->display.restore.modeset_state = NULL;
|
||||
if (state)
|
||||
state->acquire_ctx = &ctx;
|
||||
|
||||
drm_modeset_acquire_init(&ctx, 0);
|
||||
|
||||
while (1) {
|
||||
ret = drm_modeset_lock_all_ctx(&i915->drm, &ctx);
|
||||
if (ret != -EDEADLK)
|
||||
break;
|
||||
|
||||
drm_modeset_backoff(&ctx);
|
||||
}
|
||||
|
||||
if (!ret)
|
||||
ret = __intel_display_driver_resume(i915, state, &ctx);
|
||||
|
||||
skl_watermark_ipc_update(i915);
|
||||
drm_modeset_drop_locks(&ctx);
|
||||
drm_modeset_acquire_fini(&ctx);
|
||||
|
||||
if (ret)
|
||||
drm_err(&i915->drm,
|
||||
"Restoring old state failed with %i\n", ret);
|
||||
if (state)
|
||||
drm_atomic_state_put(state);
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
/* SPDX-License-Identifier: MIT */
|
||||
/*
|
||||
* Copyright © 2022-2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_DISPLAY_DRIVER_H__
|
||||
#define __INTEL_DISPLAY_DRIVER_H__
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct drm_atomic_state;
|
||||
struct drm_i915_private;
|
||||
struct drm_modeset_acquire_ctx;
|
||||
struct pci_dev;
|
||||
|
||||
bool intel_display_driver_probe_defer(struct pci_dev *pdev);
|
||||
void intel_display_driver_init_hw(struct drm_i915_private *i915);
|
||||
void intel_display_driver_early_probe(struct drm_i915_private *i915);
|
||||
int intel_display_driver_probe_noirq(struct drm_i915_private *i915);
|
||||
int intel_display_driver_probe_nogem(struct drm_i915_private *i915);
|
||||
int intel_display_driver_probe(struct drm_i915_private *i915);
|
||||
void intel_display_driver_register(struct drm_i915_private *i915);
|
||||
void intel_display_driver_remove(struct drm_i915_private *i915);
|
||||
void intel_display_driver_remove_noirq(struct drm_i915_private *i915);
|
||||
void intel_display_driver_remove_nogem(struct drm_i915_private *i915);
|
||||
void intel_display_driver_unregister(struct drm_i915_private *i915);
|
||||
int intel_display_driver_suspend(struct drm_i915_private *i915);
|
||||
void intel_display_driver_resume(struct drm_i915_private *i915);
|
||||
|
||||
/* interface for intel_display_reset.c */
|
||||
int __intel_display_driver_resume(struct drm_i915_private *i915,
|
||||
struct drm_atomic_state *state,
|
||||
struct drm_modeset_acquire_ctx *ctx);
|
||||
|
||||
#endif /* __INTEL_DISPLAY_DRIVER_H__ */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,81 @@
|
||||
/* SPDX-License-Identifier: MIT */
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_DISPLAY_IRQ_H__
|
||||
#define __INTEL_DISPLAY_IRQ_H__
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
#include "intel_display_limits.h"
|
||||
|
||||
enum pipe;
|
||||
struct drm_i915_private;
|
||||
struct drm_crtc;
|
||||
|
||||
void valleyview_enable_display_irqs(struct drm_i915_private *i915);
|
||||
void valleyview_disable_display_irqs(struct drm_i915_private *i915);
|
||||
|
||||
void ilk_update_display_irq(struct drm_i915_private *i915,
|
||||
u32 interrupt_mask, u32 enabled_irq_mask);
|
||||
void ilk_enable_display_irq(struct drm_i915_private *i915, u32 bits);
|
||||
void ilk_disable_display_irq(struct drm_i915_private *i915, u32 bits);
|
||||
|
||||
void bdw_update_port_irq(struct drm_i915_private *i915, u32 interrupt_mask, u32 enabled_irq_mask);
|
||||
void bdw_enable_pipe_irq(struct drm_i915_private *i915, enum pipe pipe, u32 bits);
|
||||
void bdw_disable_pipe_irq(struct drm_i915_private *i915, enum pipe pipe, u32 bits);
|
||||
|
||||
void ibx_display_interrupt_update(struct drm_i915_private *i915,
|
||||
u32 interrupt_mask, u32 enabled_irq_mask);
|
||||
void ibx_enable_display_interrupt(struct drm_i915_private *i915, u32 bits);
|
||||
void ibx_disable_display_interrupt(struct drm_i915_private *i915, u32 bits);
|
||||
|
||||
void gen8_irq_power_well_post_enable(struct drm_i915_private *i915, u8 pipe_mask);
|
||||
void gen8_irq_power_well_pre_disable(struct drm_i915_private *i915, u8 pipe_mask);
|
||||
u32 gen8_de_pipe_underrun_mask(struct drm_i915_private *i915);
|
||||
|
||||
int i8xx_enable_vblank(struct drm_crtc *crtc);
|
||||
int i915gm_enable_vblank(struct drm_crtc *crtc);
|
||||
int i965_enable_vblank(struct drm_crtc *crtc);
|
||||
int ilk_enable_vblank(struct drm_crtc *crtc);
|
||||
int bdw_enable_vblank(struct drm_crtc *crtc);
|
||||
void i8xx_disable_vblank(struct drm_crtc *crtc);
|
||||
void i915gm_disable_vblank(struct drm_crtc *crtc);
|
||||
void i965_disable_vblank(struct drm_crtc *crtc);
|
||||
void ilk_disable_vblank(struct drm_crtc *crtc);
|
||||
void bdw_disable_vblank(struct drm_crtc *crtc);
|
||||
|
||||
void ivb_display_irq_handler(struct drm_i915_private *i915, u32 de_iir);
|
||||
void ilk_display_irq_handler(struct drm_i915_private *i915, u32 de_iir);
|
||||
void gen8_de_irq_handler(struct drm_i915_private *i915, u32 master_ctl);
|
||||
void gen11_display_irq_handler(struct drm_i915_private *i915);
|
||||
|
||||
u32 gen11_gu_misc_irq_ack(struct drm_i915_private *i915, const u32 master_ctl);
|
||||
void gen11_gu_misc_irq_handler(struct drm_i915_private *i915, const u32 iir);
|
||||
|
||||
void vlv_display_irq_reset(struct drm_i915_private *i915);
|
||||
void gen8_display_irq_reset(struct drm_i915_private *i915);
|
||||
void gen11_display_irq_reset(struct drm_i915_private *i915);
|
||||
|
||||
void ibx_irq_postinstall(struct drm_i915_private *i915);
|
||||
void vlv_display_irq_postinstall(struct drm_i915_private *i915);
|
||||
void icp_irq_postinstall(struct drm_i915_private *i915);
|
||||
void gen8_de_irq_postinstall(struct drm_i915_private *i915);
|
||||
void mtp_irq_postinstall(struct drm_i915_private *i915);
|
||||
void gen11_de_irq_postinstall(struct drm_i915_private *i915);
|
||||
|
||||
u32 i915_pipestat_enable_mask(struct drm_i915_private *i915, enum pipe pipe);
|
||||
void i915_enable_pipestat(struct drm_i915_private *i915, enum pipe pipe, u32 status_mask);
|
||||
void i915_disable_pipestat(struct drm_i915_private *i915, enum pipe pipe, u32 status_mask);
|
||||
void i915_enable_asle_pipestat(struct drm_i915_private *i915);
|
||||
void i9xx_pipestat_irq_reset(struct drm_i915_private *i915);
|
||||
|
||||
void i9xx_pipestat_irq_ack(struct drm_i915_private *i915, u32 iir, u32 pipe_stats[I915_MAX_PIPES]);
|
||||
|
||||
void i915_pipestat_irq_handler(struct drm_i915_private *i915, u32 iir, u32 pipe_stats[I915_MAX_PIPES]);
|
||||
void i965_pipestat_irq_handler(struct drm_i915_private *i915, u32 iir, u32 pipe_stats[I915_MAX_PIPES]);
|
||||
void valleyview_pipestat_irq_handler(struct drm_i915_private *i915, u32 pipe_stats[I915_MAX_PIPES]);
|
||||
void i8xx_pipestat_irq_handler(struct drm_i915_private *i915, u16 iir, u32 pipe_stats[I915_MAX_PIPES]);
|
||||
|
||||
#endif /* __INTEL_DISPLAY_IRQ_H__ */
|
||||
@@ -7,6 +7,7 @@
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i915_irq.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_backlight_regs.h"
|
||||
#include "intel_cdclk.h"
|
||||
#include "intel_combo_phy.h"
|
||||
@@ -1052,7 +1053,7 @@ void gen9_dbuf_slices_update(struct drm_i915_private *dev_priv,
|
||||
u8 req_slices)
|
||||
{
|
||||
struct i915_power_domains *power_domains = &dev_priv->display.power.domains;
|
||||
u8 slice_mask = INTEL_INFO(dev_priv)->display.dbuf.slice_mask;
|
||||
u8 slice_mask = DISPLAY_INFO(dev_priv)->dbuf.slice_mask;
|
||||
enum dbuf_slice slice;
|
||||
|
||||
drm_WARN(&dev_priv->drm, req_slices & ~slice_mask,
|
||||
@@ -1112,7 +1113,7 @@ static void gen12_dbuf_slices_config(struct drm_i915_private *dev_priv)
|
||||
|
||||
static void icl_mbus_init(struct drm_i915_private *dev_priv)
|
||||
{
|
||||
unsigned long abox_regs = INTEL_INFO(dev_priv)->display.abox_mask;
|
||||
unsigned long abox_regs = DISPLAY_INFO(dev_priv)->abox_mask;
|
||||
u32 mask, val, i;
|
||||
|
||||
if (IS_ALDERLAKE_P(dev_priv) || DISPLAY_VER(dev_priv) >= 14)
|
||||
@@ -1164,31 +1165,39 @@ static void assert_can_disable_lcpll(struct drm_i915_private *dev_priv)
|
||||
struct intel_crtc *crtc;
|
||||
|
||||
for_each_intel_crtc(&dev_priv->drm, crtc)
|
||||
I915_STATE_WARN(crtc->active, "CRTC for pipe %c enabled\n",
|
||||
I915_STATE_WARN(dev_priv, crtc->active,
|
||||
"CRTC for pipe %c enabled\n",
|
||||
pipe_name(crtc->pipe));
|
||||
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, HSW_PWR_WELL_CTL2),
|
||||
I915_STATE_WARN(dev_priv, intel_de_read(dev_priv, HSW_PWR_WELL_CTL2),
|
||||
"Display power well on\n");
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, SPLL_CTL) & SPLL_PLL_ENABLE,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, SPLL_CTL) & SPLL_PLL_ENABLE,
|
||||
"SPLL enabled\n");
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, WRPLL_CTL(0)) & WRPLL_PLL_ENABLE,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, WRPLL_CTL(0)) & WRPLL_PLL_ENABLE,
|
||||
"WRPLL1 enabled\n");
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, WRPLL_CTL(1)) & WRPLL_PLL_ENABLE,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, WRPLL_CTL(1)) & WRPLL_PLL_ENABLE,
|
||||
"WRPLL2 enabled\n");
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, PP_STATUS(0)) & PP_ON,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, PP_STATUS(0)) & PP_ON,
|
||||
"Panel power on\n");
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, BLC_PWM_CPU_CTL2) & BLM_PWM_ENABLE,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, BLC_PWM_CPU_CTL2) & BLM_PWM_ENABLE,
|
||||
"CPU PWM1 enabled\n");
|
||||
if (IS_HASWELL(dev_priv))
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, HSW_BLC_PWM2_CTL) & BLM_PWM_ENABLE,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, HSW_BLC_PWM2_CTL) & BLM_PWM_ENABLE,
|
||||
"CPU PWM2 enabled\n");
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, BLC_PWM_PCH_CTL1) & BLM_PCH_PWM_ENABLE,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, BLC_PWM_PCH_CTL1) & BLM_PCH_PWM_ENABLE,
|
||||
"PCH PWM1 enabled\n");
|
||||
I915_STATE_WARN((intel_de_read(dev_priv, UTIL_PIN_CTL) &
|
||||
(UTIL_PIN_ENABLE | UTIL_PIN_MODE_MASK)) ==
|
||||
(UTIL_PIN_ENABLE | UTIL_PIN_MODE_PWM),
|
||||
I915_STATE_WARN(dev_priv,
|
||||
(intel_de_read(dev_priv, UTIL_PIN_CTL) & (UTIL_PIN_ENABLE | UTIL_PIN_MODE_MASK)) == (UTIL_PIN_ENABLE | UTIL_PIN_MODE_PWM),
|
||||
"Utility pin enabled in PWM mode\n");
|
||||
I915_STATE_WARN(intel_de_read(dev_priv, PCH_GTC_CTL) & PCH_GTC_ENABLE,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_de_read(dev_priv, PCH_GTC_CTL) & PCH_GTC_ENABLE,
|
||||
"PCH GTC enabled\n");
|
||||
|
||||
/*
|
||||
@@ -1197,7 +1206,8 @@ static void assert_can_disable_lcpll(struct drm_i915_private *dev_priv)
|
||||
* gen-specific and since we only disable LCPLL after we fully disable
|
||||
* the interrupts, the check below should be enough.
|
||||
*/
|
||||
I915_STATE_WARN(intel_irqs_enabled(dev_priv), "IRQs enabled\n");
|
||||
I915_STATE_WARN(dev_priv, intel_irqs_enabled(dev_priv),
|
||||
"IRQs enabled\n");
|
||||
}
|
||||
|
||||
static u32 hsw_read_dcomp(struct drm_i915_private *dev_priv)
|
||||
@@ -1558,7 +1568,7 @@ static void tgl_bw_buddy_init(struct drm_i915_private *dev_priv)
|
||||
enum intel_dram_type type = dev_priv->dram_info.type;
|
||||
u8 num_channels = dev_priv->dram_info.num_channels;
|
||||
const struct buddy_page_mask *table;
|
||||
unsigned long abox_mask = INTEL_INFO(dev_priv)->display.abox_mask;
|
||||
unsigned long abox_mask = DISPLAY_INFO(dev_priv)->abox_mask;
|
||||
int config, i;
|
||||
|
||||
/* BW_BUDDY registers are not used on dgpu's beyond DG1 */
|
||||
@@ -2021,7 +2031,7 @@ void intel_power_domains_disable(struct drm_i915_private *i915)
|
||||
/**
|
||||
* intel_power_domains_suspend - suspend power domain state
|
||||
* @i915: i915 device instance
|
||||
* @suspend_mode: specifies the target suspend state (idle, mem, hibernation)
|
||||
* @s2idle: specifies whether we go to idle, or deeper sleep
|
||||
*
|
||||
* This function prepares the hardware power domain state before entering
|
||||
* system suspend.
|
||||
@@ -2029,8 +2039,7 @@ void intel_power_domains_disable(struct drm_i915_private *i915)
|
||||
* It must be called with power domains already disabled (after a call to
|
||||
* intel_power_domains_disable()) and paired with intel_power_domains_resume().
|
||||
*/
|
||||
void intel_power_domains_suspend(struct drm_i915_private *i915,
|
||||
enum i915_drm_suspend_mode suspend_mode)
|
||||
void intel_power_domains_suspend(struct drm_i915_private *i915, bool s2idle)
|
||||
{
|
||||
struct i915_power_domains *power_domains = &i915->display.power.domains;
|
||||
intel_wakeref_t wakeref __maybe_unused =
|
||||
@@ -2045,8 +2054,7 @@ void intel_power_domains_suspend(struct drm_i915_private *i915,
|
||||
* resources as required and also enable deeper system power states
|
||||
* that would be blocked if the firmware was inactive.
|
||||
*/
|
||||
if (!(power_domains->allowed_dc_mask & DC_STATE_EN_DC9) &&
|
||||
suspend_mode == I915_DRM_SUSPEND_IDLE &&
|
||||
if (!(power_domains->allowed_dc_mask & DC_STATE_EN_DC9) && s2idle &&
|
||||
intel_dmc_has_payload(i915)) {
|
||||
intel_display_power_flush_work(i915);
|
||||
intel_power_domains_verify_state(i915);
|
||||
|
||||
@@ -171,8 +171,7 @@ void intel_power_domains_init_hw(struct drm_i915_private *dev_priv, bool resume)
|
||||
void intel_power_domains_driver_remove(struct drm_i915_private *dev_priv);
|
||||
void intel_power_domains_enable(struct drm_i915_private *dev_priv);
|
||||
void intel_power_domains_disable(struct drm_i915_private *dev_priv);
|
||||
void intel_power_domains_suspend(struct drm_i915_private *dev_priv,
|
||||
enum i915_drm_suspend_mode);
|
||||
void intel_power_domains_suspend(struct drm_i915_private *dev_priv, bool s2idle);
|
||||
void intel_power_domains_resume(struct drm_i915_private *dev_priv);
|
||||
void intel_power_domains_sanitize_state(struct drm_i915_private *dev_priv);
|
||||
|
||||
|
||||
@@ -1251,22 +1251,11 @@ I915_DECL_PW_DOMAINS(xelpd_pwdoms_pw_a,
|
||||
POWER_DOMAIN_PIPE_PANEL_FITTER_A,
|
||||
POWER_DOMAIN_INIT);
|
||||
|
||||
#define XELPD_PW_2_POWER_DOMAINS \
|
||||
XELPD_PW_B_POWER_DOMAINS, \
|
||||
XELPD_PW_C_POWER_DOMAINS, \
|
||||
XELPD_PW_D_POWER_DOMAINS, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_C, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_D, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_E, \
|
||||
#define XELPD_DC_OFF_PORT_POWER_DOMAINS \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_TC1, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_TC2, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_TC3, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_TC4, \
|
||||
POWER_DOMAIN_VGA, \
|
||||
POWER_DOMAIN_AUDIO_PLAYBACK, \
|
||||
POWER_DOMAIN_AUX_IO_C, \
|
||||
POWER_DOMAIN_AUX_IO_D, \
|
||||
POWER_DOMAIN_AUX_IO_E, \
|
||||
POWER_DOMAIN_AUX_C, \
|
||||
POWER_DOMAIN_AUX_D, \
|
||||
POWER_DOMAIN_AUX_E, \
|
||||
@@ -1279,6 +1268,20 @@ I915_DECL_PW_DOMAINS(xelpd_pwdoms_pw_a,
|
||||
POWER_DOMAIN_AUX_TBT3, \
|
||||
POWER_DOMAIN_AUX_TBT4
|
||||
|
||||
#define XELPD_PW_2_POWER_DOMAINS \
|
||||
XELPD_PW_B_POWER_DOMAINS, \
|
||||
XELPD_PW_C_POWER_DOMAINS, \
|
||||
XELPD_PW_D_POWER_DOMAINS, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_C, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_D, \
|
||||
POWER_DOMAIN_PORT_DDI_LANES_E, \
|
||||
POWER_DOMAIN_VGA, \
|
||||
POWER_DOMAIN_AUDIO_PLAYBACK, \
|
||||
POWER_DOMAIN_AUX_IO_C, \
|
||||
POWER_DOMAIN_AUX_IO_D, \
|
||||
POWER_DOMAIN_AUX_IO_E, \
|
||||
XELPD_DC_OFF_PORT_POWER_DOMAINS
|
||||
|
||||
I915_DECL_PW_DOMAINS(xelpd_pwdoms_pw_2,
|
||||
XELPD_PW_2_POWER_DOMAINS,
|
||||
POWER_DOMAIN_INIT);
|
||||
@@ -1301,7 +1304,9 @@ I915_DECL_PW_DOMAINS(xelpd_pwdoms_pw_2,
|
||||
*/
|
||||
|
||||
I915_DECL_PW_DOMAINS(xelpd_pwdoms_dc_off,
|
||||
XELPD_PW_2_POWER_DOMAINS,
|
||||
XELPD_DC_OFF_PORT_POWER_DOMAINS,
|
||||
XELPD_PW_C_POWER_DOMAINS,
|
||||
XELPD_PW_D_POWER_DOMAINS,
|
||||
POWER_DOMAIN_PORT_DSI,
|
||||
POWER_DOMAIN_AUDIO_MMIO,
|
||||
POWER_DOMAIN_AUX_A,
|
||||
@@ -1310,14 +1315,18 @@ I915_DECL_PW_DOMAINS(xelpd_pwdoms_dc_off,
|
||||
POWER_DOMAIN_DC_OFF,
|
||||
POWER_DOMAIN_INIT);
|
||||
|
||||
static const struct i915_power_well_desc xelpd_power_wells_main[] = {
|
||||
static const struct i915_power_well_desc xelpd_power_wells_dc_off[] = {
|
||||
{
|
||||
.instances = &I915_PW_INSTANCES(
|
||||
I915_PW("DC_off", &xelpd_pwdoms_dc_off,
|
||||
.id = SKL_DISP_DC_OFF),
|
||||
),
|
||||
.ops = &gen9_dc_off_power_well_ops,
|
||||
}, {
|
||||
}
|
||||
};
|
||||
|
||||
static const struct i915_power_well_desc xelpd_power_wells_main[] = {
|
||||
{
|
||||
.instances = &I915_PW_INSTANCES(
|
||||
I915_PW("PW_2", &xelpd_pwdoms_pw_2,
|
||||
.hsw.idx = ICL_PW_CTL_IDX_PW_2,
|
||||
@@ -1378,6 +1387,11 @@ static const struct i915_power_well_desc xelpd_power_wells_main[] = {
|
||||
I915_PW("AUX_C", &icl_pwdoms_aux_c, .hsw.idx = ICL_PW_CTL_IDX_AUX_C),
|
||||
I915_PW("AUX_D", &icl_pwdoms_aux_d, .hsw.idx = XELPD_PW_CTL_IDX_AUX_D),
|
||||
I915_PW("AUX_E", &icl_pwdoms_aux_e, .hsw.idx = XELPD_PW_CTL_IDX_AUX_E),
|
||||
),
|
||||
.ops = &icl_aux_power_well_ops,
|
||||
.fixed_enable_delay = true,
|
||||
}, {
|
||||
.instances = &I915_PW_INSTANCES(
|
||||
I915_PW("AUX_USBC1", &tgl_pwdoms_aux_usbc1, .hsw.idx = TGL_PW_CTL_IDX_AUX_TC1),
|
||||
I915_PW("AUX_USBC2", &tgl_pwdoms_aux_usbc2, .hsw.idx = TGL_PW_CTL_IDX_AUX_TC2),
|
||||
I915_PW("AUX_USBC3", &tgl_pwdoms_aux_usbc3, .hsw.idx = TGL_PW_CTL_IDX_AUX_TC3),
|
||||
@@ -1385,6 +1399,8 @@ static const struct i915_power_well_desc xelpd_power_wells_main[] = {
|
||||
),
|
||||
.ops = &icl_aux_power_well_ops,
|
||||
.fixed_enable_delay = true,
|
||||
/* WA_14017248603: adlp */
|
||||
.enable_timeout = 500,
|
||||
}, {
|
||||
.instances = &I915_PW_INSTANCES(
|
||||
I915_PW("AUX_TBT1", &icl_pwdoms_aux_tbt1, .hsw.idx = TGL_PW_CTL_IDX_AUX_TBT1),
|
||||
@@ -1400,6 +1416,34 @@ static const struct i915_power_well_desc xelpd_power_wells_main[] = {
|
||||
static const struct i915_power_well_desc_list xelpd_power_wells[] = {
|
||||
I915_PW_DESCRIPTORS(i9xx_power_wells_always_on),
|
||||
I915_PW_DESCRIPTORS(icl_power_wells_pw_1),
|
||||
I915_PW_DESCRIPTORS(xelpd_power_wells_dc_off),
|
||||
I915_PW_DESCRIPTORS(xelpd_power_wells_main),
|
||||
};
|
||||
|
||||
I915_DECL_PW_DOMAINS(xehpd_pwdoms_dc_off,
|
||||
XELPD_PW_2_POWER_DOMAINS,
|
||||
POWER_DOMAIN_PORT_DSI,
|
||||
POWER_DOMAIN_AUDIO_MMIO,
|
||||
POWER_DOMAIN_AUX_A,
|
||||
POWER_DOMAIN_AUX_B,
|
||||
POWER_DOMAIN_MODESET,
|
||||
POWER_DOMAIN_DC_OFF,
|
||||
POWER_DOMAIN_INIT);
|
||||
|
||||
static const struct i915_power_well_desc xehpd_power_wells_dc_off[] = {
|
||||
{
|
||||
.instances = &I915_PW_INSTANCES(
|
||||
I915_PW("DC_off", &xehpd_pwdoms_dc_off,
|
||||
.id = SKL_DISP_DC_OFF),
|
||||
),
|
||||
.ops = &gen9_dc_off_power_well_ops,
|
||||
}
|
||||
};
|
||||
|
||||
static const struct i915_power_well_desc_list xehpd_power_wells[] = {
|
||||
I915_PW_DESCRIPTORS(i9xx_power_wells_always_on),
|
||||
I915_PW_DESCRIPTORS(icl_power_wells_pw_1),
|
||||
I915_PW_DESCRIPTORS(xehpd_power_wells_dc_off),
|
||||
I915_PW_DESCRIPTORS(xelpd_power_wells_main),
|
||||
};
|
||||
|
||||
@@ -1423,15 +1467,6 @@ I915_DECL_PW_DOMAINS(xelpdp_pwdoms_pw_2,
|
||||
XELPDP_PW_2_POWER_DOMAINS,
|
||||
POWER_DOMAIN_INIT);
|
||||
|
||||
I915_DECL_PW_DOMAINS(xelpdp_pwdoms_dc_off,
|
||||
XELPDP_PW_2_POWER_DOMAINS,
|
||||
POWER_DOMAIN_AUDIO_MMIO,
|
||||
POWER_DOMAIN_MODESET,
|
||||
POWER_DOMAIN_AUX_A,
|
||||
POWER_DOMAIN_AUX_B,
|
||||
POWER_DOMAIN_DC_OFF,
|
||||
POWER_DOMAIN_INIT);
|
||||
|
||||
I915_DECL_PW_DOMAINS(xelpdp_pwdoms_aux_tc1,
|
||||
POWER_DOMAIN_AUX_USBC1,
|
||||
POWER_DOMAIN_AUX_TBT1);
|
||||
@@ -1450,12 +1485,6 @@ I915_DECL_PW_DOMAINS(xelpdp_pwdoms_aux_tc4,
|
||||
|
||||
static const struct i915_power_well_desc xelpdp_power_wells_main[] = {
|
||||
{
|
||||
.instances = &I915_PW_INSTANCES(
|
||||
I915_PW("DC_off", &xelpdp_pwdoms_dc_off,
|
||||
.id = SKL_DISP_DC_OFF),
|
||||
),
|
||||
.ops = &gen9_dc_off_power_well_ops,
|
||||
}, {
|
||||
.instances = &I915_PW_INSTANCES(
|
||||
I915_PW("PW_2", &xelpdp_pwdoms_pw_2,
|
||||
.hsw.idx = ICL_PW_CTL_IDX_PW_2,
|
||||
@@ -1512,6 +1541,7 @@ static const struct i915_power_well_desc xelpdp_power_wells_main[] = {
|
||||
static const struct i915_power_well_desc_list xelpdp_power_wells[] = {
|
||||
I915_PW_DESCRIPTORS(i9xx_power_wells_always_on),
|
||||
I915_PW_DESCRIPTORS(icl_power_wells_pw_1),
|
||||
I915_PW_DESCRIPTORS(xelpd_power_wells_dc_off),
|
||||
I915_PW_DESCRIPTORS(xelpdp_power_wells_main),
|
||||
};
|
||||
|
||||
@@ -1624,6 +1654,8 @@ int intel_display_power_map_init(struct i915_power_domains *power_domains)
|
||||
|
||||
if (DISPLAY_VER(i915) >= 14)
|
||||
return set_power_wells(power_domains, xelpdp_power_wells);
|
||||
else if (IS_DG2(i915))
|
||||
return set_power_wells(power_domains, xehpd_power_wells);
|
||||
else if (DISPLAY_VER(i915) >= 13)
|
||||
return set_power_wells(power_domains, xelpd_power_wells);
|
||||
else if (IS_DG1(i915))
|
||||
|
||||
@@ -5,11 +5,13 @@
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i915_irq.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_backlight_regs.h"
|
||||
#include "intel_combo_phy.h"
|
||||
#include "intel_combo_phy_regs.h"
|
||||
#include "intel_crt.h"
|
||||
#include "intel_de.h"
|
||||
#include "intel_display_irq.h"
|
||||
#include "intel_display_power_well.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_dkl_phy.h"
|
||||
@@ -253,6 +255,7 @@ static void hsw_wait_for_power_well_enable(struct drm_i915_private *dev_priv,
|
||||
{
|
||||
const struct i915_power_well_regs *regs = power_well->desc->ops->regs;
|
||||
int pw_idx = i915_power_well_instance(power_well)->hsw.idx;
|
||||
int timeout = power_well->desc->enable_timeout ? : 1;
|
||||
|
||||
/*
|
||||
* For some power wells we're not supposed to watch the status bit for
|
||||
@@ -266,7 +269,7 @@ static void hsw_wait_for_power_well_enable(struct drm_i915_private *dev_priv,
|
||||
|
||||
/* Timeout for PW1:10 us, AUX:not specified, other PWs:20 us. */
|
||||
if (intel_de_wait_for_set(dev_priv, regs->driver,
|
||||
HSW_PWR_WELL_CTL_STATE(pw_idx), 1)) {
|
||||
HSW_PWR_WELL_CTL_STATE(pw_idx), timeout)) {
|
||||
drm_dbg_kms(&dev_priv->drm, "%s power well enable timeout\n",
|
||||
intel_power_well_name(power_well));
|
||||
|
||||
|
||||
@@ -110,6 +110,8 @@ struct i915_power_well_desc {
|
||||
* Thunderbolt mode.
|
||||
*/
|
||||
u16 is_tc_tbt:1;
|
||||
/* Enable timeout if greater than the default 1ms */
|
||||
u16 enable_timeout;
|
||||
};
|
||||
|
||||
struct i915_power_well {
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
|
||||
#include "i915_reg_defs.h"
|
||||
|
||||
#define DISPLAY_MMIO_BASE(dev_priv) (INTEL_INFO(dev_priv)->display.mmio_offset)
|
||||
#define DISPLAY_MMIO_BASE(dev_priv) (DISPLAY_INFO(dev_priv)->mmio_offset)
|
||||
|
||||
#define VLV_DISPLAY_BASE 0x180000
|
||||
|
||||
@@ -36,14 +36,14 @@
|
||||
* Device info offset array based helpers for groups of registers with unevenly
|
||||
* spaced base offsets.
|
||||
*/
|
||||
#define _MMIO_PIPE2(pipe, reg) _MMIO(INTEL_INFO(dev_priv)->display.pipe_offsets[(pipe)] - \
|
||||
INTEL_INFO(dev_priv)->display.pipe_offsets[PIPE_A] + \
|
||||
#define _MMIO_PIPE2(pipe, reg) _MMIO(DISPLAY_INFO(dev_priv)->pipe_offsets[(pipe)] - \
|
||||
DISPLAY_INFO(dev_priv)->pipe_offsets[PIPE_A] + \
|
||||
DISPLAY_MMIO_BASE(dev_priv) + (reg))
|
||||
#define _MMIO_TRANS2(tran, reg) _MMIO(INTEL_INFO(dev_priv)->display.trans_offsets[(tran)] - \
|
||||
INTEL_INFO(dev_priv)->display.trans_offsets[TRANSCODER_A] + \
|
||||
#define _MMIO_TRANS2(tran, reg) _MMIO(DISPLAY_INFO(dev_priv)->trans_offsets[(tran)] - \
|
||||
DISPLAY_INFO(dev_priv)->trans_offsets[TRANSCODER_A] + \
|
||||
DISPLAY_MMIO_BASE(dev_priv) + (reg))
|
||||
#define _MMIO_CURSOR2(pipe, reg) _MMIO(INTEL_INFO(dev_priv)->display.cursor_offsets[(pipe)] - \
|
||||
INTEL_INFO(dev_priv)->display.cursor_offsets[PIPE_A] + \
|
||||
#define _MMIO_CURSOR2(pipe, reg) _MMIO(DISPLAY_INFO(dev_priv)->cursor_offsets[(pipe)] - \
|
||||
DISPLAY_INFO(dev_priv)->cursor_offsets[PIPE_A] + \
|
||||
DISPLAY_MMIO_BASE(dev_priv) + (reg))
|
||||
|
||||
#endif /* __INTEL_DISPLAY_REG_DEFS_H__ */
|
||||
|
||||
@@ -0,0 +1,135 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#include <drm/drm_atomic_helper.h>
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "intel_clock_gating.h"
|
||||
#include "intel_display_driver.h"
|
||||
#include "intel_display_reset.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_hotplug.h"
|
||||
#include "intel_pps.h"
|
||||
|
||||
static bool gpu_reset_clobbers_display(struct drm_i915_private *dev_priv)
|
||||
{
|
||||
return (INTEL_INFO(dev_priv)->gpu_reset_clobbers_display &&
|
||||
intel_has_gpu_reset(to_gt(dev_priv)));
|
||||
}
|
||||
|
||||
void intel_display_reset_prepare(struct drm_i915_private *dev_priv)
|
||||
{
|
||||
struct drm_modeset_acquire_ctx *ctx = &dev_priv->display.restore.reset_ctx;
|
||||
struct drm_atomic_state *state;
|
||||
int ret;
|
||||
|
||||
if (!HAS_DISPLAY(dev_priv))
|
||||
return;
|
||||
|
||||
/* reset doesn't touch the display */
|
||||
if (!dev_priv->params.force_reset_modeset_test &&
|
||||
!gpu_reset_clobbers_display(dev_priv))
|
||||
return;
|
||||
|
||||
/* We have a modeset vs reset deadlock, defensively unbreak it. */
|
||||
set_bit(I915_RESET_MODESET, &to_gt(dev_priv)->reset.flags);
|
||||
smp_mb__after_atomic();
|
||||
wake_up_bit(&to_gt(dev_priv)->reset.flags, I915_RESET_MODESET);
|
||||
|
||||
if (atomic_read(&dev_priv->gpu_error.pending_fb_pin)) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"Modeset potentially stuck, unbreaking through wedging\n");
|
||||
intel_gt_set_wedged(to_gt(dev_priv));
|
||||
}
|
||||
|
||||
/*
|
||||
* Need mode_config.mutex so that we don't
|
||||
* trample ongoing ->detect() and whatnot.
|
||||
*/
|
||||
mutex_lock(&dev_priv->drm.mode_config.mutex);
|
||||
drm_modeset_acquire_init(ctx, 0);
|
||||
while (1) {
|
||||
ret = drm_modeset_lock_all_ctx(&dev_priv->drm, ctx);
|
||||
if (ret != -EDEADLK)
|
||||
break;
|
||||
|
||||
drm_modeset_backoff(ctx);
|
||||
}
|
||||
/*
|
||||
* Disabling the crtcs gracefully seems nicer. Also the
|
||||
* g33 docs say we should at least disable all the planes.
|
||||
*/
|
||||
state = drm_atomic_helper_duplicate_state(&dev_priv->drm, ctx);
|
||||
if (IS_ERR(state)) {
|
||||
ret = PTR_ERR(state);
|
||||
drm_err(&dev_priv->drm, "Duplicating state failed with %i\n",
|
||||
ret);
|
||||
return;
|
||||
}
|
||||
|
||||
ret = drm_atomic_helper_disable_all(&dev_priv->drm, ctx);
|
||||
if (ret) {
|
||||
drm_err(&dev_priv->drm, "Suspending crtc's failed with %i\n",
|
||||
ret);
|
||||
drm_atomic_state_put(state);
|
||||
return;
|
||||
}
|
||||
|
||||
dev_priv->display.restore.modeset_state = state;
|
||||
state->acquire_ctx = ctx;
|
||||
}
|
||||
|
||||
void intel_display_reset_finish(struct drm_i915_private *i915)
|
||||
{
|
||||
struct drm_modeset_acquire_ctx *ctx = &i915->display.restore.reset_ctx;
|
||||
struct drm_atomic_state *state;
|
||||
int ret;
|
||||
|
||||
if (!HAS_DISPLAY(i915))
|
||||
return;
|
||||
|
||||
/* reset doesn't touch the display */
|
||||
if (!test_bit(I915_RESET_MODESET, &to_gt(i915)->reset.flags))
|
||||
return;
|
||||
|
||||
state = fetch_and_zero(&i915->display.restore.modeset_state);
|
||||
if (!state)
|
||||
goto unlock;
|
||||
|
||||
/* reset doesn't touch the display */
|
||||
if (!gpu_reset_clobbers_display(i915)) {
|
||||
/* for testing only restore the display */
|
||||
ret = drm_atomic_helper_commit_duplicated_state(state, ctx);
|
||||
if (ret) {
|
||||
drm_WARN_ON(&i915->drm, ret == -EDEADLK);
|
||||
drm_err(&i915->drm,
|
||||
"Restoring old state failed with %i\n", ret);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* The display has been reset as well,
|
||||
* so need a full re-initialization.
|
||||
*/
|
||||
intel_pps_unlock_regs_wa(i915);
|
||||
intel_display_driver_init_hw(i915);
|
||||
intel_clock_gating_init(i915);
|
||||
intel_hpd_init(i915);
|
||||
|
||||
ret = __intel_display_driver_resume(i915, state, ctx);
|
||||
if (ret)
|
||||
drm_err(&i915->drm,
|
||||
"Restoring old state failed with %i\n", ret);
|
||||
|
||||
intel_hpd_poll_disable(i915);
|
||||
}
|
||||
|
||||
drm_atomic_state_put(state);
|
||||
unlock:
|
||||
drm_modeset_drop_locks(ctx);
|
||||
drm_modeset_acquire_fini(ctx);
|
||||
mutex_unlock(&i915->drm.mode_config.mutex);
|
||||
|
||||
clear_bit_unlock(I915_RESET_MODESET, &to_gt(i915)->reset.flags);
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
/* SPDX-License-Identifier: MIT */
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_RESET_H__
|
||||
#define __INTEL_RESET_H__
|
||||
|
||||
struct drm_i915_private;
|
||||
|
||||
void intel_display_reset_prepare(struct drm_i915_private *i915);
|
||||
void intel_display_reset_finish(struct drm_i915_private *i915);
|
||||
|
||||
#endif /* __INTEL_RESET_H__ */
|
||||
@@ -14,7 +14,6 @@
|
||||
#include <linux/tracepoint.h>
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i915_irq.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_vblank.h"
|
||||
|
||||
@@ -233,13 +233,25 @@ struct intel_encoder {
|
||||
* Called during system suspend after all pending requests for the
|
||||
* encoder are flushed (for example for DP AUX transactions) and
|
||||
* device interrupts are disabled.
|
||||
* All modeset locks are held while the hook is called.
|
||||
*/
|
||||
void (*suspend)(struct intel_encoder *);
|
||||
/*
|
||||
* Called without the modeset locks held after the suspend() hook for
|
||||
* all encoders have been called.
|
||||
*/
|
||||
void (*suspend_complete)(struct intel_encoder *encoder);
|
||||
/*
|
||||
* Called during system reboot/shutdown after all the
|
||||
* encoders have been disabled and suspended.
|
||||
* All modeset locks are held while the hook is called.
|
||||
*/
|
||||
void (*shutdown)(struct intel_encoder *encoder);
|
||||
/*
|
||||
* Called without the modeset locks held after the shutdown() hook for
|
||||
* all encoders have been called.
|
||||
*/
|
||||
void (*shutdown_complete)(struct intel_encoder *encoder);
|
||||
/*
|
||||
* Enable/disable the clock to the port.
|
||||
*/
|
||||
@@ -643,6 +655,9 @@ struct intel_atomic_state {
|
||||
struct __intel_global_objs_state *global_objs;
|
||||
int num_global_objs;
|
||||
|
||||
/* Internal commit, as opposed to userspace/client initiated one */
|
||||
bool internal;
|
||||
|
||||
bool dpll_set, modeset;
|
||||
|
||||
struct intel_shared_dpll_state shared_dpll[I915_NUM_PLLS];
|
||||
@@ -980,6 +995,38 @@ struct intel_link_m_n {
|
||||
u32 link_n;
|
||||
};
|
||||
|
||||
struct intel_csc_matrix {
|
||||
u16 coeff[9];
|
||||
u16 preoff[3];
|
||||
u16 postoff[3];
|
||||
};
|
||||
|
||||
struct intel_c10pll_state {
|
||||
u32 clock; /* in KHz */
|
||||
u8 tx;
|
||||
u8 cmn;
|
||||
u8 pll[20];
|
||||
};
|
||||
|
||||
struct intel_c20pll_state {
|
||||
u32 link_bit_rate;
|
||||
u32 clock; /* in kHz */
|
||||
u16 tx[3];
|
||||
u16 cmn[4];
|
||||
union {
|
||||
u16 mplla[10];
|
||||
u16 mpllb[11];
|
||||
};
|
||||
};
|
||||
|
||||
struct intel_cx0pll_state {
|
||||
union {
|
||||
struct intel_c10pll_state c10;
|
||||
struct intel_c20pll_state c20;
|
||||
};
|
||||
bool ssc_enabled;
|
||||
};
|
||||
|
||||
struct intel_crtc_state {
|
||||
/*
|
||||
* uapi (drm) state. This is the software state shown to userspace.
|
||||
@@ -1021,6 +1068,8 @@ struct intel_crtc_state {
|
||||
/* actual state of LUTs */
|
||||
struct drm_property_blob *pre_csc_lut, *post_csc_lut;
|
||||
|
||||
struct intel_csc_matrix csc, output_csc;
|
||||
|
||||
/**
|
||||
* quirks - bitfield with hw state readout quirks
|
||||
*
|
||||
@@ -1123,6 +1172,7 @@ struct intel_crtc_state {
|
||||
union {
|
||||
struct intel_dpll_hw_state dpll_hw_state;
|
||||
struct intel_mpllb_state mpllb_state;
|
||||
struct intel_cx0pll_state cx0pll_state;
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -1275,15 +1325,27 @@ struct intel_crtc_state {
|
||||
/* HDMI High TMDS char rate ratio */
|
||||
bool hdmi_high_tmds_clock_ratio;
|
||||
|
||||
/* Output format RGB/YCBCR etc */
|
||||
/*
|
||||
* Output format RGB/YCBCR etc., that is coming out
|
||||
* at the end of the pipe.
|
||||
*/
|
||||
enum intel_output_format output_format;
|
||||
|
||||
/*
|
||||
* Sink output format RGB/YCBCR etc., that is going
|
||||
* into the sink.
|
||||
*/
|
||||
enum intel_output_format sink_format;
|
||||
|
||||
/* enable pipe gamma? */
|
||||
bool gamma_enable;
|
||||
|
||||
/* enable pipe csc? */
|
||||
bool csc_enable;
|
||||
|
||||
/* enable vlv/chv wgc csc? */
|
||||
bool wgc_enable;
|
||||
|
||||
/* big joiner pipe bitmask */
|
||||
u8 bigjoiner_pipes;
|
||||
|
||||
@@ -1524,8 +1586,6 @@ struct intel_hdmi {
|
||||
enum drm_dp_dual_mode_type type;
|
||||
int max_tmds_clock;
|
||||
} dp_dual_mode;
|
||||
bool has_hdmi_sink;
|
||||
bool has_audio;
|
||||
struct intel_connector *attached_connector;
|
||||
struct cec_notifier *cec_notifier;
|
||||
};
|
||||
@@ -1645,8 +1705,6 @@ struct intel_dp {
|
||||
u8 lane_count;
|
||||
u8 sink_count;
|
||||
bool link_trained;
|
||||
bool has_hdmi_sink;
|
||||
bool has_audio;
|
||||
bool reset_link_params;
|
||||
bool use_max_params;
|
||||
u8 dpcd[DP_RECEIVER_CAP_SIZE];
|
||||
@@ -1728,6 +1786,7 @@ struct intel_dp {
|
||||
int pcon_max_frl_bw;
|
||||
u8 max_bpc;
|
||||
bool ycbcr_444_to_420;
|
||||
bool ycbcr420_passthrough;
|
||||
bool rgb_to_ycbcr;
|
||||
} dfp;
|
||||
|
||||
@@ -1814,10 +1873,6 @@ struct intel_dp_mst_encoder {
|
||||
struct intel_connector *connector;
|
||||
};
|
||||
|
||||
struct intel_load_detect_pipe {
|
||||
struct drm_atomic_state *restore_state;
|
||||
};
|
||||
|
||||
static inline struct intel_encoder *
|
||||
intel_attached_encoder(struct intel_connector *connector)
|
||||
{
|
||||
|
||||
@@ -11,6 +11,15 @@
|
||||
#include "intel_dkl_phy.h"
|
||||
#include "intel_dkl_phy_regs.h"
|
||||
|
||||
/**
|
||||
* intel_dkl_phy_init - initialize Dekel PHY
|
||||
* @i915: i915 device instance
|
||||
*/
|
||||
void intel_dkl_phy_init(struct drm_i915_private *i915)
|
||||
{
|
||||
spin_lock_init(&i915->display.dkl.phy_lock);
|
||||
}
|
||||
|
||||
static void
|
||||
dkl_phy_set_hip_idx(struct drm_i915_private *i915, struct intel_dkl_phy_reg reg)
|
||||
{
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
|
||||
struct drm_i915_private;
|
||||
|
||||
void intel_dkl_phy_init(struct drm_i915_private *i915);
|
||||
u32
|
||||
intel_dkl_phy_read(struct drm_i915_private *i915, struct intel_dkl_phy_reg reg);
|
||||
void
|
||||
|
||||
@@ -44,8 +44,8 @@
|
||||
#include <drm/drm_probe_helper.h>
|
||||
|
||||
#include "g4x_dp.h"
|
||||
#include "i915_debugfs.h"
|
||||
#include "i915_drv.h"
|
||||
#include "i915_irq.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_audio.h"
|
||||
@@ -53,6 +53,7 @@
|
||||
#include "intel_combo_phy_regs.h"
|
||||
#include "intel_connector.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_cx0_phy.h"
|
||||
#include "intel_ddi.h"
|
||||
#include "intel_de.h"
|
||||
#include "intel_display_types.h"
|
||||
@@ -67,6 +68,7 @@
|
||||
#include "intel_hdcp.h"
|
||||
#include "intel_hdmi.h"
|
||||
#include "intel_hotplug.h"
|
||||
#include "intel_hotplug_irq.h"
|
||||
#include "intel_lspcon.h"
|
||||
#include "intel_lvds.h"
|
||||
#include "intel_panel.h"
|
||||
@@ -421,6 +423,18 @@ static int ehl_max_source_rate(struct intel_dp *intel_dp)
|
||||
return 810000;
|
||||
}
|
||||
|
||||
static int mtl_max_source_rate(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
|
||||
struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
|
||||
enum phy phy = intel_port_to_phy(i915, dig_port->base.port);
|
||||
|
||||
if (intel_is_c10phy(i915, phy))
|
||||
return intel_dp_is_edp(intel_dp) ? 675000 : 810000;
|
||||
|
||||
return 2000000;
|
||||
}
|
||||
|
||||
static int vbt_max_link_rate(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
@@ -445,6 +459,10 @@ static void
|
||||
intel_dp_set_source_rates(struct intel_dp *intel_dp)
|
||||
{
|
||||
/* The values must be in increasing order */
|
||||
static const int mtl_rates[] = {
|
||||
162000, 216000, 243000, 270000, 324000, 432000, 540000, 675000,
|
||||
810000, 1000000, 1350000, 2000000,
|
||||
};
|
||||
static const int icl_rates[] = {
|
||||
162000, 216000, 270000, 324000, 432000, 540000, 648000, 810000,
|
||||
1000000, 1350000,
|
||||
@@ -470,7 +488,11 @@ intel_dp_set_source_rates(struct intel_dp *intel_dp)
|
||||
drm_WARN_ON(&dev_priv->drm,
|
||||
intel_dp->source_rates || intel_dp->num_source_rates);
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 11) {
|
||||
if (DISPLAY_VER(dev_priv) >= 14) {
|
||||
source_rates = mtl_rates;
|
||||
size = ARRAY_SIZE(mtl_rates);
|
||||
max_rate = mtl_max_source_rate(intel_dp);
|
||||
} else if (DISPLAY_VER(dev_priv) >= 11) {
|
||||
source_rates = icl_rates;
|
||||
size = ARRAY_SIZE(icl_rates);
|
||||
if (IS_DG2(dev_priv))
|
||||
@@ -828,26 +850,88 @@ u8 intel_dp_dsc_get_slice_count(struct intel_dp *intel_dp,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool source_can_output(struct intel_dp *intel_dp,
|
||||
enum intel_output_format format)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
|
||||
switch (format) {
|
||||
case INTEL_OUTPUT_FORMAT_RGB:
|
||||
return true;
|
||||
|
||||
case INTEL_OUTPUT_FORMAT_YCBCR444:
|
||||
/*
|
||||
* No YCbCr output support on gmch platforms.
|
||||
* Also, ILK doesn't seem capable of DP YCbCr output.
|
||||
* The displayed image is severly corrupted. SNB+ is fine.
|
||||
*/
|
||||
return !HAS_GMCH(i915) && !IS_IRONLAKE(i915);
|
||||
|
||||
case INTEL_OUTPUT_FORMAT_YCBCR420:
|
||||
/* Platform < Gen 11 cannot output YCbCr420 format */
|
||||
return DISPLAY_VER(i915) >= 11;
|
||||
|
||||
default:
|
||||
MISSING_CASE(format);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
dfp_can_convert_from_rgb(struct intel_dp *intel_dp,
|
||||
enum intel_output_format sink_format)
|
||||
{
|
||||
if (!drm_dp_is_branch(intel_dp->dpcd))
|
||||
return false;
|
||||
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR444)
|
||||
return intel_dp->dfp.rgb_to_ycbcr;
|
||||
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420)
|
||||
return intel_dp->dfp.rgb_to_ycbcr &&
|
||||
intel_dp->dfp.ycbcr_444_to_420;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool
|
||||
dfp_can_convert_from_ycbcr444(struct intel_dp *intel_dp,
|
||||
enum intel_output_format sink_format)
|
||||
{
|
||||
if (!drm_dp_is_branch(intel_dp->dpcd))
|
||||
return false;
|
||||
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420)
|
||||
return intel_dp->dfp.ycbcr_444_to_420;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static enum intel_output_format
|
||||
intel_dp_output_format(struct intel_connector *connector,
|
||||
bool ycbcr_420_output)
|
||||
enum intel_output_format sink_format)
|
||||
{
|
||||
struct intel_dp *intel_dp = intel_attached_dp(connector);
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
enum intel_output_format output_format;
|
||||
|
||||
if (intel_dp->force_dsc_output_format)
|
||||
return intel_dp->force_dsc_output_format;
|
||||
|
||||
if (!connector->base.ycbcr_420_allowed || !ycbcr_420_output)
|
||||
return INTEL_OUTPUT_FORMAT_RGB;
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_RGB ||
|
||||
dfp_can_convert_from_rgb(intel_dp, sink_format))
|
||||
output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
|
||||
if (intel_dp->dfp.rgb_to_ycbcr &&
|
||||
intel_dp->dfp.ycbcr_444_to_420)
|
||||
return INTEL_OUTPUT_FORMAT_RGB;
|
||||
else if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR444 ||
|
||||
dfp_can_convert_from_ycbcr444(intel_dp, sink_format))
|
||||
output_format = INTEL_OUTPUT_FORMAT_YCBCR444;
|
||||
|
||||
if (intel_dp->dfp.ycbcr_444_to_420)
|
||||
return INTEL_OUTPUT_FORMAT_YCBCR444;
|
||||
else
|
||||
return INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
output_format = INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
|
||||
drm_WARN_ON(&i915->drm, !source_can_output(intel_dp, output_format));
|
||||
|
||||
return output_format;
|
||||
}
|
||||
|
||||
int intel_dp_min_bpp(enum intel_output_format output_format)
|
||||
@@ -871,13 +955,27 @@ static int intel_dp_output_bpp(enum intel_output_format output_format, int bpp)
|
||||
return bpp;
|
||||
}
|
||||
|
||||
static enum intel_output_format
|
||||
intel_dp_sink_format(struct intel_connector *connector,
|
||||
const struct drm_display_mode *mode)
|
||||
{
|
||||
const struct drm_display_info *info = &connector->base.display_info;
|
||||
|
||||
if (drm_mode_is_420_only(info, mode))
|
||||
return INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
|
||||
return INTEL_OUTPUT_FORMAT_RGB;
|
||||
}
|
||||
|
||||
static int
|
||||
intel_dp_mode_min_output_bpp(struct intel_connector *connector,
|
||||
const struct drm_display_mode *mode)
|
||||
{
|
||||
const struct drm_display_info *info = &connector->base.display_info;
|
||||
enum intel_output_format output_format =
|
||||
intel_dp_output_format(connector, drm_mode_is_420_only(info, mode));
|
||||
enum intel_output_format output_format, sink_format;
|
||||
|
||||
sink_format = intel_dp_sink_format(connector, mode);
|
||||
|
||||
output_format = intel_dp_output_format(connector, sink_format);
|
||||
|
||||
return intel_dp_output_bpp(output_format, intel_dp_min_bpp(output_format));
|
||||
}
|
||||
@@ -916,7 +1014,8 @@ static int intel_dp_max_tmds_clock(struct intel_dp *intel_dp)
|
||||
|
||||
static enum drm_mode_status
|
||||
intel_dp_tmds_clock_valid(struct intel_dp *intel_dp,
|
||||
int clock, int bpc, bool ycbcr420_output,
|
||||
int clock, int bpc,
|
||||
enum intel_output_format sink_format,
|
||||
bool respect_downstream_limits)
|
||||
{
|
||||
int tmds_clock, min_tmds_clock, max_tmds_clock;
|
||||
@@ -924,7 +1023,7 @@ intel_dp_tmds_clock_valid(struct intel_dp *intel_dp,
|
||||
if (!respect_downstream_limits)
|
||||
return MODE_OK;
|
||||
|
||||
tmds_clock = intel_hdmi_tmds_clock(clock, bpc, ycbcr420_output);
|
||||
tmds_clock = intel_hdmi_tmds_clock(clock, bpc, sink_format);
|
||||
|
||||
min_tmds_clock = intel_dp->dfp.min_tmds_clock;
|
||||
max_tmds_clock = intel_dp_max_tmds_clock(intel_dp);
|
||||
@@ -946,7 +1045,7 @@ intel_dp_mode_valid_downstream(struct intel_connector *connector,
|
||||
struct intel_dp *intel_dp = intel_attached_dp(connector);
|
||||
const struct drm_display_info *info = &connector->base.display_info;
|
||||
enum drm_mode_status status;
|
||||
bool ycbcr_420_only;
|
||||
enum intel_output_format sink_format;
|
||||
|
||||
/* If PCON supports FRL MODE, check FRL bandwidth constraints */
|
||||
if (intel_dp->dfp.pcon_max_frl_bw) {
|
||||
@@ -971,20 +1070,20 @@ intel_dp_mode_valid_downstream(struct intel_connector *connector,
|
||||
target_clock > intel_dp->dfp.max_dotclock)
|
||||
return MODE_CLOCK_HIGH;
|
||||
|
||||
ycbcr_420_only = drm_mode_is_420_only(info, mode);
|
||||
sink_format = intel_dp_sink_format(connector, mode);
|
||||
|
||||
/* Assume 8bpc for the DP++/HDMI/DVI TMDS clock check */
|
||||
status = intel_dp_tmds_clock_valid(intel_dp, target_clock,
|
||||
8, ycbcr_420_only, true);
|
||||
8, sink_format, true);
|
||||
|
||||
if (status != MODE_OK) {
|
||||
if (ycbcr_420_only ||
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420 ||
|
||||
!connector->base.ycbcr_420_allowed ||
|
||||
!drm_mode_is_420_also(info, mode))
|
||||
return status;
|
||||
|
||||
sink_format = INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
status = intel_dp_tmds_clock_valid(intel_dp, target_clock,
|
||||
8, true, true);
|
||||
8, sink_format, true);
|
||||
if (status != MODE_OK)
|
||||
return status;
|
||||
}
|
||||
@@ -1041,6 +1140,9 @@ intel_dp_mode_valid(struct drm_connector *_connector,
|
||||
if (target_clock > max_dotclk)
|
||||
return MODE_CLOCK_HIGH;
|
||||
|
||||
if (intel_dp_hdisplay_bad(dev_priv, mode->hdisplay))
|
||||
return MODE_H_ILLEGAL;
|
||||
|
||||
max_link_clock = intel_dp_max_link_rate(intel_dp);
|
||||
max_lanes = intel_dp_max_lane_count(intel_dp);
|
||||
|
||||
@@ -1048,13 +1150,6 @@ intel_dp_mode_valid(struct drm_connector *_connector,
|
||||
mode_rate = intel_dp_link_required(target_clock,
|
||||
intel_dp_mode_min_output_bpp(connector, mode));
|
||||
|
||||
if (intel_dp_hdisplay_bad(dev_priv, mode->hdisplay))
|
||||
return MODE_H_ILLEGAL;
|
||||
|
||||
/*
|
||||
* Output bpp is stored in 6.4 format so right shift by 4 to get the
|
||||
* integer value since we support only integer values of bpp.
|
||||
*/
|
||||
if (HAS_DSC(dev_priv) &&
|
||||
drm_dp_sink_supports_dsc(intel_dp->dsc_dpcd)) {
|
||||
/*
|
||||
@@ -1063,6 +1158,10 @@ intel_dp_mode_valid(struct drm_connector *_connector,
|
||||
*/
|
||||
int pipe_bpp = intel_dp_dsc_compute_bpp(intel_dp, U8_MAX);
|
||||
|
||||
/*
|
||||
* Output bpp is stored in 6.4 format so right shift by 4 to get the
|
||||
* integer value since we support only integer values of bpp.
|
||||
*/
|
||||
if (intel_dp_is_edp(intel_dp)) {
|
||||
dsc_max_output_bpp =
|
||||
drm_edp_dsc_sink_output_bpp(intel_dp->dsc_dpcd) >> 4;
|
||||
@@ -1188,6 +1287,13 @@ void intel_dp_compute_rate(struct intel_dp *intel_dp, int port_clock,
|
||||
}
|
||||
}
|
||||
|
||||
bool intel_dp_has_hdmi_sink(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
|
||||
return connector->base.display_info.is_hdmi;
|
||||
}
|
||||
|
||||
static bool intel_dp_source_supports_fec(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *pipe_config)
|
||||
{
|
||||
@@ -1220,19 +1326,10 @@ static bool intel_dp_supports_dsc(struct intel_dp *intel_dp,
|
||||
drm_dp_sink_supports_dsc(intel_dp->dsc_dpcd);
|
||||
}
|
||||
|
||||
static bool intel_dp_is_ycbcr420(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
return crtc_state->output_format == INTEL_OUTPUT_FORMAT_YCBCR420 ||
|
||||
(crtc_state->output_format == INTEL_OUTPUT_FORMAT_YCBCR444 &&
|
||||
intel_dp->dfp.ycbcr_444_to_420);
|
||||
}
|
||||
|
||||
static int intel_dp_hdmi_compute_bpc(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
int bpc, bool respect_downstream_limits)
|
||||
{
|
||||
bool ycbcr420_output = intel_dp_is_ycbcr420(intel_dp, crtc_state);
|
||||
int clock = crtc_state->hw.adjusted_mode.crtc_clock;
|
||||
|
||||
/*
|
||||
@@ -1252,8 +1349,8 @@ static int intel_dp_hdmi_compute_bpc(struct intel_dp *intel_dp,
|
||||
|
||||
for (; bpc >= 8; bpc -= 2) {
|
||||
if (intel_hdmi_bpc_possible(crtc_state, bpc,
|
||||
intel_dp->has_hdmi_sink, ycbcr420_output) &&
|
||||
intel_dp_tmds_clock_valid(intel_dp, clock, bpc, ycbcr420_output,
|
||||
intel_dp_has_hdmi_sink(intel_dp)) &&
|
||||
intel_dp_tmds_clock_valid(intel_dp, clock, bpc, crtc_state->sink_format,
|
||||
respect_downstream_limits) == MODE_OK)
|
||||
return bpc;
|
||||
}
|
||||
@@ -2069,6 +2166,7 @@ static bool intel_dp_has_audio(struct intel_encoder *encoder,
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
const struct intel_digital_connector_state *intel_conn_state =
|
||||
to_intel_digital_connector_state(conn_state);
|
||||
|
||||
@@ -2076,7 +2174,7 @@ static bool intel_dp_has_audio(struct intel_encoder *encoder,
|
||||
return false;
|
||||
|
||||
if (intel_conn_state->force_audio == HDMI_AUDIO_AUTO)
|
||||
return intel_dp->has_audio;
|
||||
return connector->base.display_info.has_audio;
|
||||
else
|
||||
return intel_conn_state->force_audio == HDMI_AUDIO_ON;
|
||||
}
|
||||
@@ -2097,23 +2195,27 @@ intel_dp_compute_output_format(struct intel_encoder *encoder,
|
||||
|
||||
ycbcr_420_only = drm_mode_is_420_only(info, adjusted_mode);
|
||||
|
||||
crtc_state->output_format = intel_dp_output_format(connector, ycbcr_420_only);
|
||||
|
||||
if (ycbcr_420_only && !intel_dp_is_ycbcr420(intel_dp, crtc_state)) {
|
||||
if (ycbcr_420_only && !connector->base.ycbcr_420_allowed) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"YCbCr 4:2:0 mode but YCbCr 4:2:0 output not possible. Falling back to RGB.\n");
|
||||
crtc_state->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
crtc_state->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
} else {
|
||||
crtc_state->sink_format = intel_dp_sink_format(connector, adjusted_mode);
|
||||
}
|
||||
|
||||
crtc_state->output_format = intel_dp_output_format(connector, crtc_state->sink_format);
|
||||
|
||||
ret = intel_dp_compute_link_config(encoder, crtc_state, conn_state,
|
||||
respect_downstream_limits);
|
||||
if (ret) {
|
||||
if (intel_dp_is_ycbcr420(intel_dp, crtc_state) ||
|
||||
if (crtc_state->sink_format == INTEL_OUTPUT_FORMAT_YCBCR420 ||
|
||||
!connector->base.ycbcr_420_allowed ||
|
||||
!drm_mode_is_420_also(info, adjusted_mode))
|
||||
return ret;
|
||||
|
||||
crtc_state->output_format = intel_dp_output_format(connector, true);
|
||||
crtc_state->sink_format = INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
crtc_state->output_format = intel_dp_output_format(connector,
|
||||
crtc_state->sink_format);
|
||||
ret = intel_dp_compute_link_config(encoder, crtc_state, conn_state,
|
||||
respect_downstream_limits);
|
||||
}
|
||||
@@ -2637,7 +2739,7 @@ frl_trained:
|
||||
static bool intel_dp_is_hdmi_2_1_sink(struct intel_dp *intel_dp)
|
||||
{
|
||||
if (drm_dp_is_branch(intel_dp->dpcd) &&
|
||||
intel_dp->has_hdmi_sink &&
|
||||
intel_dp_has_hdmi_sink(intel_dp) &&
|
||||
intel_dp_hdmi_sink_max_frl(intel_dp) > 0)
|
||||
return true;
|
||||
|
||||
@@ -2795,6 +2897,8 @@ void intel_dp_configure_protocol_converter(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
bool ycbcr444_to_420 = false;
|
||||
bool rgb_to_ycbcr = false;
|
||||
u8 tmp;
|
||||
|
||||
if (intel_dp->dpcd[DP_DPCD_REV] < 0x13)
|
||||
@@ -2803,16 +2907,42 @@ void intel_dp_configure_protocol_converter(struct intel_dp *intel_dp,
|
||||
if (!drm_dp_is_branch(intel_dp->dpcd))
|
||||
return;
|
||||
|
||||
tmp = intel_dp->has_hdmi_sink ?
|
||||
DP_HDMI_DVI_OUTPUT_CONFIG : 0;
|
||||
tmp = intel_dp_has_hdmi_sink(intel_dp) ? DP_HDMI_DVI_OUTPUT_CONFIG : 0;
|
||||
|
||||
if (drm_dp_dpcd_writeb(&intel_dp->aux,
|
||||
DP_PROTOCOL_CONVERTER_CONTROL_0, tmp) != 1)
|
||||
drm_dbg_kms(&i915->drm, "Failed to %s protocol converter HDMI mode\n",
|
||||
str_enable_disable(intel_dp->has_hdmi_sink));
|
||||
str_enable_disable(intel_dp_has_hdmi_sink(intel_dp)));
|
||||
|
||||
tmp = crtc_state->output_format == INTEL_OUTPUT_FORMAT_YCBCR444 &&
|
||||
intel_dp->dfp.ycbcr_444_to_420 ? DP_CONVERSION_TO_YCBCR420_ENABLE : 0;
|
||||
if (crtc_state->sink_format == INTEL_OUTPUT_FORMAT_YCBCR420) {
|
||||
switch (crtc_state->output_format) {
|
||||
case INTEL_OUTPUT_FORMAT_YCBCR420:
|
||||
break;
|
||||
case INTEL_OUTPUT_FORMAT_YCBCR444:
|
||||
ycbcr444_to_420 = true;
|
||||
break;
|
||||
case INTEL_OUTPUT_FORMAT_RGB:
|
||||
rgb_to_ycbcr = true;
|
||||
ycbcr444_to_420 = true;
|
||||
break;
|
||||
default:
|
||||
MISSING_CASE(crtc_state->output_format);
|
||||
break;
|
||||
}
|
||||
} else if (crtc_state->sink_format == INTEL_OUTPUT_FORMAT_YCBCR444) {
|
||||
switch (crtc_state->output_format) {
|
||||
case INTEL_OUTPUT_FORMAT_YCBCR444:
|
||||
break;
|
||||
case INTEL_OUTPUT_FORMAT_RGB:
|
||||
rgb_to_ycbcr = true;
|
||||
break;
|
||||
default:
|
||||
MISSING_CASE(crtc_state->output_format);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
tmp = ycbcr444_to_420 ? DP_CONVERSION_TO_YCBCR420_ENABLE : 0;
|
||||
|
||||
if (drm_dp_dpcd_writeb(&intel_dp->aux,
|
||||
DP_PROTOCOL_CONVERTER_CONTROL_1, tmp) != 1)
|
||||
@@ -2820,13 +2950,12 @@ void intel_dp_configure_protocol_converter(struct intel_dp *intel_dp,
|
||||
"Failed to %s protocol converter YCbCr 4:2:0 conversion mode\n",
|
||||
str_enable_disable(intel_dp->dfp.ycbcr_444_to_420));
|
||||
|
||||
tmp = intel_dp->dfp.rgb_to_ycbcr ?
|
||||
DP_CONVERSION_BT709_RGB_YCBCR_ENABLE : 0;
|
||||
tmp = rgb_to_ycbcr ? DP_CONVERSION_BT709_RGB_YCBCR_ENABLE : 0;
|
||||
|
||||
if (drm_dp_pcon_convert_rgb_to_ycbcr(&intel_dp->aux, tmp) < 0)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"Failed to %s protocol converter RGB->YCbCr conversion mode\n",
|
||||
str_enable_disable(tmp));
|
||||
"Failed to %s protocol converter RGB->YCbCr conversion mode\n",
|
||||
str_enable_disable(tmp));
|
||||
}
|
||||
|
||||
bool intel_dp_get_colorimetry_status(struct intel_dp *intel_dp)
|
||||
@@ -4110,9 +4239,9 @@ static bool intel_dp_has_connector(struct intel_dp *intel_dp,
|
||||
return false;
|
||||
}
|
||||
|
||||
static int intel_dp_prep_link_retrain(struct intel_dp *intel_dp,
|
||||
struct drm_modeset_acquire_ctx *ctx,
|
||||
u8 *pipe_mask)
|
||||
int intel_dp_get_active_pipes(struct intel_dp *intel_dp,
|
||||
struct drm_modeset_acquire_ctx *ctx,
|
||||
u8 *pipe_mask)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
struct drm_connector_list_iter conn_iter;
|
||||
@@ -4121,9 +4250,6 @@ static int intel_dp_prep_link_retrain(struct intel_dp *intel_dp,
|
||||
|
||||
*pipe_mask = 0;
|
||||
|
||||
if (!intel_dp_needs_link_retrain(intel_dp))
|
||||
return 0;
|
||||
|
||||
drm_connector_list_iter_begin(&i915->drm, &conn_iter);
|
||||
for_each_intel_connector_iter(connector, &conn_iter) {
|
||||
struct drm_connector_state *conn_state =
|
||||
@@ -4157,9 +4283,6 @@ static int intel_dp_prep_link_retrain(struct intel_dp *intel_dp,
|
||||
}
|
||||
drm_connector_list_iter_end(&conn_iter);
|
||||
|
||||
if (!intel_dp_needs_link_retrain(intel_dp))
|
||||
*pipe_mask = 0;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -4188,13 +4311,19 @@ int intel_dp_retrain_link(struct intel_encoder *encoder,
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = intel_dp_prep_link_retrain(intel_dp, ctx, &pipe_mask);
|
||||
if (!intel_dp_needs_link_retrain(intel_dp))
|
||||
return 0;
|
||||
|
||||
ret = intel_dp_get_active_pipes(intel_dp, ctx, &pipe_mask);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (pipe_mask == 0)
|
||||
return 0;
|
||||
|
||||
if (!intel_dp_needs_link_retrain(intel_dp))
|
||||
return 0;
|
||||
|
||||
drm_dbg_kms(&dev_priv->drm, "[ENCODER:%d:%s] retraining link\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
|
||||
@@ -4616,57 +4745,44 @@ intel_dp_update_dfp(struct intel_dp *intel_dp,
|
||||
intel_dp_get_pcon_dsc_cap(intel_dp);
|
||||
}
|
||||
|
||||
static bool
|
||||
intel_dp_can_ycbcr420(struct intel_dp *intel_dp)
|
||||
{
|
||||
if (source_can_output(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR420) &&
|
||||
(!drm_dp_is_branch(intel_dp->dpcd) || intel_dp->dfp.ycbcr420_passthrough))
|
||||
return true;
|
||||
|
||||
if (source_can_output(intel_dp, INTEL_OUTPUT_FORMAT_RGB) &&
|
||||
dfp_can_convert_from_rgb(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR420))
|
||||
return true;
|
||||
|
||||
if (source_can_output(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR444) &&
|
||||
dfp_can_convert_from_ycbcr444(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR420))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static void
|
||||
intel_dp_update_420(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
bool is_branch, ycbcr_420_passthrough, ycbcr_444_to_420, rgb_to_ycbcr;
|
||||
|
||||
/* No YCbCr output support on gmch platforms */
|
||||
if (HAS_GMCH(i915))
|
||||
return;
|
||||
|
||||
/*
|
||||
* ILK doesn't seem capable of DP YCbCr output. The
|
||||
* displayed image is severly corrupted. SNB+ is fine.
|
||||
*/
|
||||
if (IS_IRONLAKE(i915))
|
||||
return;
|
||||
|
||||
is_branch = drm_dp_is_branch(intel_dp->dpcd);
|
||||
ycbcr_420_passthrough =
|
||||
intel_dp->dfp.ycbcr420_passthrough =
|
||||
drm_dp_downstream_420_passthrough(intel_dp->dpcd,
|
||||
intel_dp->downstream_ports);
|
||||
/* on-board LSPCON always assumed to support 4:4:4->4:2:0 conversion */
|
||||
ycbcr_444_to_420 =
|
||||
intel_dp->dfp.ycbcr_444_to_420 =
|
||||
dp_to_dig_port(intel_dp)->lspcon.active ||
|
||||
drm_dp_downstream_444_to_420_conversion(intel_dp->dpcd,
|
||||
intel_dp->downstream_ports);
|
||||
rgb_to_ycbcr = drm_dp_downstream_rgb_to_ycbcr_conversion(intel_dp->dpcd,
|
||||
intel_dp->downstream_ports,
|
||||
DP_DS_HDMI_BT709_RGB_YCBCR_CONV);
|
||||
intel_dp->dfp.rgb_to_ycbcr =
|
||||
drm_dp_downstream_rgb_to_ycbcr_conversion(intel_dp->dpcd,
|
||||
intel_dp->downstream_ports,
|
||||
DP_DS_HDMI_BT709_RGB_YCBCR_CONV);
|
||||
|
||||
if (DISPLAY_VER(i915) >= 11) {
|
||||
/* Let PCON convert from RGB->YCbCr if possible */
|
||||
if (is_branch && rgb_to_ycbcr && ycbcr_444_to_420) {
|
||||
intel_dp->dfp.rgb_to_ycbcr = true;
|
||||
intel_dp->dfp.ycbcr_444_to_420 = true;
|
||||
connector->base.ycbcr_420_allowed = true;
|
||||
} else {
|
||||
/* Prefer 4:2:0 passthrough over 4:4:4->4:2:0 conversion */
|
||||
intel_dp->dfp.ycbcr_444_to_420 =
|
||||
ycbcr_444_to_420 && !ycbcr_420_passthrough;
|
||||
|
||||
connector->base.ycbcr_420_allowed =
|
||||
!is_branch || ycbcr_444_to_420 || ycbcr_420_passthrough;
|
||||
}
|
||||
} else {
|
||||
/* 4:4:4->4:2:0 conversion is the only way */
|
||||
intel_dp->dfp.ycbcr_444_to_420 = ycbcr_444_to_420;
|
||||
|
||||
connector->base.ycbcr_420_allowed = ycbcr_444_to_420;
|
||||
}
|
||||
connector->base.ycbcr_420_allowed = intel_dp_can_ycbcr420(intel_dp);
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[CONNECTOR:%d:%s] RGB->YcbCr conversion? %s, YCbCr 4:2:0 allowed? %s, YCbCr 4:4:4->4:2:0 conversion? %s\n",
|
||||
@@ -4702,10 +4818,6 @@ intel_dp_set_edid(struct intel_dp *intel_dp)
|
||||
|
||||
/* FIXME: Get rid of drm_edid_raw() */
|
||||
edid = drm_edid_raw(drm_edid);
|
||||
if (edid && edid->input & DRM_EDID_INPUT_DIGITAL) {
|
||||
intel_dp->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
|
||||
intel_dp->has_audio = drm_detect_monitor_audio(edid);
|
||||
}
|
||||
|
||||
drm_dp_cec_set_edid(&intel_dp->aux, edid);
|
||||
}
|
||||
@@ -4719,9 +4831,6 @@ intel_dp_unset_edid(struct intel_dp *intel_dp)
|
||||
drm_edid_free(connector->detect_edid);
|
||||
connector->detect_edid = NULL;
|
||||
|
||||
intel_dp->has_hdmi_sink = false;
|
||||
intel_dp->has_audio = false;
|
||||
|
||||
intel_dp->dfp.max_bpc = 0;
|
||||
intel_dp->dfp.max_dotclock = 0;
|
||||
intel_dp->dfp.min_tmds_clock = 0;
|
||||
@@ -5370,6 +5479,15 @@ static bool intel_edp_init_connector(struct intel_dp *intel_dp,
|
||||
goto out_vdd_off;
|
||||
}
|
||||
|
||||
/*
|
||||
* Enable HPD sense for live status check.
|
||||
* intel_hpd_irq_setup() will turn it off again
|
||||
* if it's no longer needed later.
|
||||
*
|
||||
* The DPCD probe below will make sure VDD is on.
|
||||
*/
|
||||
intel_hpd_enable_detection(encoder);
|
||||
|
||||
/* Cache DPCD and EDID for edp. */
|
||||
has_dpcd = intel_edp_init_dpcd(intel_dp);
|
||||
|
||||
@@ -5381,6 +5499,24 @@ static bool intel_edp_init_connector(struct intel_dp *intel_dp,
|
||||
goto out_vdd_off;
|
||||
}
|
||||
|
||||
/*
|
||||
* VBT and straps are liars. Also check HPD as that seems
|
||||
* to be the most reliable piece of information available.
|
||||
*/
|
||||
if (!intel_digital_port_connected(encoder)) {
|
||||
/*
|
||||
* If this fails, presume the DPCD answer came
|
||||
* from some other port using the same AUX CH.
|
||||
*
|
||||
* FIXME maybe cleaner to check this before the
|
||||
* DPCD read? Would need sort out the VDD handling...
|
||||
*/
|
||||
drm_info(&dev_priv->drm,
|
||||
"[ENCODER:%d:%s] HPD is down, disabling eDP\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
goto out_vdd_off;
|
||||
}
|
||||
|
||||
mutex_lock(&dev_priv->drm.mode_config.mutex);
|
||||
drm_edid = drm_edid_read_ddc(connector, &intel_dp->aux.ddc);
|
||||
if (!drm_edid) {
|
||||
@@ -5583,6 +5719,7 @@ intel_dp_init_connector(struct intel_digital_port *dig_port,
|
||||
return true;
|
||||
|
||||
fail:
|
||||
intel_display_power_flush_work(dev_priv);
|
||||
drm_connector_cleanup(connector);
|
||||
|
||||
return false;
|
||||
|
||||
@@ -42,6 +42,9 @@ void intel_dp_set_link_params(struct intel_dp *intel_dp,
|
||||
int link_rate, int lane_count);
|
||||
int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,
|
||||
int link_rate, u8 lane_count);
|
||||
int intel_dp_get_active_pipes(struct intel_dp *intel_dp,
|
||||
struct drm_modeset_acquire_ctx *ctx,
|
||||
u8 *pipe_mask);
|
||||
int intel_dp_retrain_link(struct intel_encoder *encoder,
|
||||
struct drm_modeset_acquire_ctx *ctx);
|
||||
void intel_dp_set_power(struct intel_dp *intel_dp, u8 mode);
|
||||
@@ -62,6 +65,7 @@ int intel_dp_dsc_compute_config(struct intel_dp *intel_dp,
|
||||
struct link_config_limits *limits,
|
||||
int timeslots,
|
||||
bool recompute_pipe_bpp);
|
||||
bool intel_dp_has_hdmi_sink(struct intel_dp *intel_dp);
|
||||
bool intel_dp_is_edp(struct intel_dp *intel_dp);
|
||||
bool intel_dp_is_uhbr(const struct intel_crtc_state *crtc_state);
|
||||
bool intel_dp_is_port_edp(struct drm_i915_private *dev_priv, enum port port);
|
||||
|
||||
@@ -129,7 +129,7 @@ static int intel_dp_aux_sync_len(void)
|
||||
|
||||
static int intel_dp_aux_fw_sync_len(void)
|
||||
{
|
||||
int precharge = 16; /* 10-16 */
|
||||
int precharge = 10; /* 10-16 */
|
||||
int preamble = 8;
|
||||
|
||||
return precharge + preamble;
|
||||
@@ -161,14 +161,14 @@ static u32 g4x_get_aux_send_ctl(struct intel_dp *intel_dp,
|
||||
timeout = DP_AUX_CH_CTL_TIME_OUT_400us;
|
||||
|
||||
return DP_AUX_CH_CTL_SEND_BUSY |
|
||||
DP_AUX_CH_CTL_DONE |
|
||||
DP_AUX_CH_CTL_INTERRUPT |
|
||||
DP_AUX_CH_CTL_TIME_OUT_ERROR |
|
||||
timeout |
|
||||
DP_AUX_CH_CTL_RECEIVE_ERROR |
|
||||
(send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
|
||||
(g4x_dp_aux_precharge_len() << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
|
||||
(aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT);
|
||||
DP_AUX_CH_CTL_DONE |
|
||||
DP_AUX_CH_CTL_INTERRUPT |
|
||||
DP_AUX_CH_CTL_TIME_OUT_ERROR |
|
||||
timeout |
|
||||
DP_AUX_CH_CTL_RECEIVE_ERROR |
|
||||
DP_AUX_CH_CTL_MESSAGE_SIZE(send_bytes) |
|
||||
DP_AUX_CH_CTL_PRECHARGE_2US(g4x_dp_aux_precharge_len()) |
|
||||
DP_AUX_CH_CTL_BIT_CLOCK_2X(aux_clock_divider);
|
||||
}
|
||||
|
||||
static u32 skl_get_aux_send_ctl(struct intel_dp *intel_dp,
|
||||
@@ -185,14 +185,14 @@ static u32 skl_get_aux_send_ctl(struct intel_dp *intel_dp,
|
||||
* ICL+: 4ms
|
||||
*/
|
||||
ret = DP_AUX_CH_CTL_SEND_BUSY |
|
||||
DP_AUX_CH_CTL_DONE |
|
||||
DP_AUX_CH_CTL_INTERRUPT |
|
||||
DP_AUX_CH_CTL_TIME_OUT_ERROR |
|
||||
DP_AUX_CH_CTL_TIME_OUT_MAX |
|
||||
DP_AUX_CH_CTL_RECEIVE_ERROR |
|
||||
(send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
|
||||
DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL(intel_dp_aux_fw_sync_len()) |
|
||||
DP_AUX_CH_CTL_SYNC_PULSE_SKL(intel_dp_aux_sync_len());
|
||||
DP_AUX_CH_CTL_DONE |
|
||||
DP_AUX_CH_CTL_INTERRUPT |
|
||||
DP_AUX_CH_CTL_TIME_OUT_ERROR |
|
||||
DP_AUX_CH_CTL_TIME_OUT_MAX |
|
||||
DP_AUX_CH_CTL_RECEIVE_ERROR |
|
||||
DP_AUX_CH_CTL_MESSAGE_SIZE(send_bytes) |
|
||||
DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL(intel_dp_aux_fw_sync_len()) |
|
||||
DP_AUX_CH_CTL_SYNC_PULSE_SKL(intel_dp_aux_sync_len());
|
||||
|
||||
if (intel_tc_port_in_tbt_alt_mode(dig_port))
|
||||
ret |= DP_AUX_CH_CTL_TBT_IO;
|
||||
@@ -268,6 +268,11 @@ intel_dp_aux_xfer(struct intel_dp *intel_dp,
|
||||
|
||||
intel_pps_check_power_unlocked(intel_dp);
|
||||
|
||||
/*
|
||||
* FIXME PSR should be disabled here to prevent
|
||||
* it using the same AUX CH simultaneously
|
||||
*/
|
||||
|
||||
/* Try to wait for any previous AUX channel activity */
|
||||
for (try = 0; try < 3; try++) {
|
||||
status = intel_de_read_notrace(i915, ch_ctl);
|
||||
@@ -373,8 +378,7 @@ done:
|
||||
}
|
||||
|
||||
/* Unload any bytes sent back from the other side */
|
||||
recv_bytes = ((status & DP_AUX_CH_CTL_MESSAGE_SIZE_MASK) >>
|
||||
DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT);
|
||||
recv_bytes = REG_FIELD_GET(DP_AUX_CH_CTL_MESSAGE_SIZE_MASK, status);
|
||||
|
||||
/*
|
||||
* By BSpec: "Message sizes of 0 or >20 are not allowed."
|
||||
@@ -810,3 +814,8 @@ enum aux_ch intel_dp_aux_ch(struct intel_encoder *encoder)
|
||||
|
||||
return aux_ch;
|
||||
}
|
||||
|
||||
void intel_dp_aux_irq_handler(struct drm_i915_private *i915)
|
||||
{
|
||||
wake_up_all(&i915->display.gmbus.wait_queue);
|
||||
}
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
#define __INTEL_DP_AUX_H__
|
||||
|
||||
enum aux_ch;
|
||||
struct drm_i915_private;
|
||||
struct intel_dp;
|
||||
struct intel_encoder;
|
||||
|
||||
@@ -15,4 +16,6 @@ void intel_dp_aux_init(struct intel_dp *intel_dp);
|
||||
|
||||
enum aux_ch intel_dp_aux_ch(struct intel_encoder *encoder);
|
||||
|
||||
void intel_dp_aux_irq_handler(struct drm_i915_private *i915);
|
||||
|
||||
#endif /* __INTEL_DP_AUX_H__ */
|
||||
|
||||
@@ -50,35 +50,37 @@
|
||||
_XELPDP_USBC3_AUX_CH_DATA1, \
|
||||
_XELPDP_USBC4_AUX_CH_DATA1) + (i) * 4)
|
||||
|
||||
#define DP_AUX_CH_CTL_SEND_BUSY (1 << 31)
|
||||
#define DP_AUX_CH_CTL_DONE (1 << 30)
|
||||
#define DP_AUX_CH_CTL_INTERRUPT (1 << 29)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_ERROR (1 << 28)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_400us (0 << 26)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_600us (1 << 26)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_800us (2 << 26)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_MAX (3 << 26) /* Varies per platform */
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_MASK (3 << 26)
|
||||
#define DP_AUX_CH_CTL_RECEIVE_ERROR (1 << 25)
|
||||
#define DP_AUX_CH_CTL_MESSAGE_SIZE_MASK (0x1f << 20)
|
||||
#define DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT 20
|
||||
#define XELPDP_DP_AUX_CH_CTL_POWER_REQUEST REG_BIT(19)
|
||||
#define XELPDP_DP_AUX_CH_CTL_POWER_STATUS REG_BIT(18)
|
||||
#define DP_AUX_CH_CTL_PRECHARGE_2US_MASK (0xf << 16)
|
||||
#define DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT 16
|
||||
#define DP_AUX_CH_CTL_AUX_AKSV_SELECT (1 << 15)
|
||||
#define DP_AUX_CH_CTL_MANCHESTER_TEST (1 << 14)
|
||||
#define DP_AUX_CH_CTL_SYNC_TEST (1 << 13)
|
||||
#define DP_AUX_CH_CTL_DEGLITCH_TEST (1 << 12)
|
||||
#define DP_AUX_CH_CTL_PRECHARGE_TEST (1 << 11)
|
||||
#define DP_AUX_CH_CTL_BIT_CLOCK_2X_MASK (0x7ff)
|
||||
#define DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT 0
|
||||
#define DP_AUX_CH_CTL_PSR_DATA_AUX_REG_SKL (1 << 14)
|
||||
#define DP_AUX_CH_CTL_FS_DATA_AUX_REG_SKL (1 << 13)
|
||||
#define DP_AUX_CH_CTL_GTC_DATA_AUX_REG_SKL (1 << 12)
|
||||
#define DP_AUX_CH_CTL_TBT_IO (1 << 11)
|
||||
#define DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL_MASK (0x1f << 5)
|
||||
#define DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL(c) (((c) - 1) << 5)
|
||||
#define DP_AUX_CH_CTL_SYNC_PULSE_SKL(c) ((c) - 1)
|
||||
#define DP_AUX_CH_CTL_SEND_BUSY REG_BIT(31)
|
||||
#define DP_AUX_CH_CTL_DONE REG_BIT(30)
|
||||
#define DP_AUX_CH_CTL_INTERRUPT REG_BIT(29)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_ERROR REG_BIT(28)
|
||||
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_MASK REG_GENMASK(27, 26)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_400us REG_FIELD_PREP(DP_AUX_CH_CTL_TIME_OUT_MASK, 0)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_600us REG_FIELD_PREP(DP_AUX_CH_CTL_TIME_OUT_MASK, 1)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_800us REG_FIELD_PREP(DP_AUX_CH_CTL_TIME_OUT_MASK, 2)
|
||||
#define DP_AUX_CH_CTL_TIME_OUT_MAX REG_FIELD_PREP(DP_AUX_CH_CTL_TIME_OUT_MASK, 3) /* Varies per platform */
|
||||
#define DP_AUX_CH_CTL_RECEIVE_ERROR REG_BIT(25)
|
||||
#define DP_AUX_CH_CTL_MESSAGE_SIZE_MASK REG_GENMASK(24, 20)
|
||||
#define DP_AUX_CH_CTL_MESSAGE_SIZE(x) REG_FIELD_PREP(DP_AUX_CH_CTL_MESSAGE_SIZE_MASK, (x))
|
||||
#define DP_AUX_CH_CTL_PRECHARGE_2US_MASK REG_GENMASK(19, 16) /* pre-skl */
|
||||
#define DP_AUX_CH_CTL_PRECHARGE_2US(x) REG_FIELD_PREP(DP_AUX_CH_CTL_PRECHARGE_2US_MASK, (x))
|
||||
#define XELPDP_DP_AUX_CH_CTL_POWER_REQUEST REG_BIT(19) /* mtl+ */
|
||||
#define XELPDP_DP_AUX_CH_CTL_POWER_STATUS REG_BIT(18) /* mtl+ */
|
||||
#define DP_AUX_CH_CTL_AUX_AKSV_SELECT REG_BIT(15)
|
||||
#define DP_AUX_CH_CTL_MANCHESTER_TEST REG_BIT(14) /* pre-hsw */
|
||||
#define DP_AUX_CH_CTL_PSR_DATA_AUX_REG_SKL REG_BIT(14) /* skl+ */
|
||||
#define DP_AUX_CH_CTL_SYNC_TEST REG_BIT(13) /* pre-hsw */
|
||||
#define DP_AUX_CH_CTL_FS_DATA_AUX_REG_SKL REG_BIT(13) /* skl+ */
|
||||
#define DP_AUX_CH_CTL_DEGLITCH_TEST REG_BIT(12) /* pre-hsw */
|
||||
#define DP_AUX_CH_CTL_GTC_DATA_AUX_REG_SKL REG_BIT(12) /* skl+ */
|
||||
#define DP_AUX_CH_CTL_PRECHARGE_TEST REG_BIT(11) /* pre-hsw */
|
||||
#define DP_AUX_CH_CTL_TBT_IO REG_BIT(11) /* icl+ */
|
||||
#define DP_AUX_CH_CTL_BIT_CLOCK_2X_MASK REG_GENMASK(10, 0) /* pre-skl */
|
||||
#define DP_AUX_CH_CTL_BIT_CLOCK_2X(x) REG_FIELD_PREP(DP_AUX_CH_CTL_BIT_CLOCK_2X_MASK, (x))
|
||||
#define DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL_MASK REG_GENMASK(9, 5) /* skl+ */
|
||||
#define DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL(c) REG_FIELD_PREP(DP_AUX_CH_CTL_FW_SYNC_PULSE_SKL_MASK, (c) - 1)
|
||||
#define DP_AUX_CH_CTL_SYNC_PULSE_SKL_MASK REG_GENMASK(4, 0) /* skl+ */
|
||||
#define DP_AUX_CH_CTL_SYNC_PULSE_SKL(c) REG_FIELD_PREP(DP_AUX_CH_CTL_SYNC_PULSE_SKL_MASK, (c) - 1)
|
||||
|
||||
#endif /* __INTEL_DP_AUX_REGS_H__ */
|
||||
|
||||
@@ -26,6 +26,27 @@
|
||||
#include "intel_dp.h"
|
||||
#include "intel_dp_link_training.h"
|
||||
|
||||
#define LT_MSG_PREFIX "[CONNECTOR:%d:%s][ENCODER:%d:%s][%s] "
|
||||
#define LT_MSG_ARGS(_intel_dp, _dp_phy) (_intel_dp)->attached_connector->base.base.id, \
|
||||
(_intel_dp)->attached_connector->base.name, \
|
||||
dp_to_dig_port(_intel_dp)->base.base.base.id, \
|
||||
dp_to_dig_port(_intel_dp)->base.base.name, \
|
||||
drm_dp_phy_name(_dp_phy)
|
||||
|
||||
#define lt_dbg(_intel_dp, _dp_phy, _format, ...) \
|
||||
drm_dbg_kms(&dp_to_i915(_intel_dp)->drm, \
|
||||
LT_MSG_PREFIX _format, \
|
||||
LT_MSG_ARGS(_intel_dp, _dp_phy), ## __VA_ARGS__)
|
||||
|
||||
#define lt_err(_intel_dp, _dp_phy, _format, ...) do { \
|
||||
if (intel_digital_port_connected(&dp_to_dig_port(_intel_dp)->base)) \
|
||||
drm_err(&dp_to_i915(_intel_dp)->drm, \
|
||||
LT_MSG_PREFIX _format, \
|
||||
LT_MSG_ARGS(_intel_dp, _dp_phy), ## __VA_ARGS__); \
|
||||
else \
|
||||
lt_dbg(_intel_dp, _dp_phy, "Sink disconnected: " _format, ## __VA_ARGS__); \
|
||||
} while (0)
|
||||
|
||||
static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
|
||||
{
|
||||
memset(intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));
|
||||
@@ -47,29 +68,21 @@ static void intel_dp_read_lttpr_phy_caps(struct intel_dp *intel_dp,
|
||||
const u8 dpcd[DP_RECEIVER_CAP_SIZE],
|
||||
enum drm_dp_phy dp_phy)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
u8 *phy_caps = intel_dp_lttpr_phy_caps(intel_dp, dp_phy);
|
||||
|
||||
if (drm_dp_read_lttpr_phy_caps(&intel_dp->aux, dpcd, dp_phy, phy_caps) < 0) {
|
||||
drm_dbg_kms(&dp_to_i915(intel_dp)->drm,
|
||||
"[ENCODER:%d:%s][%s] failed to read the PHY caps\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_dbg(intel_dp, dp_phy, "failed to read the PHY caps\n");
|
||||
return;
|
||||
}
|
||||
|
||||
drm_dbg_kms(&dp_to_i915(intel_dp)->drm,
|
||||
"[ENCODER:%d:%s][%s] PHY capabilities: %*ph\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
(int)sizeof(intel_dp->lttpr_phy_caps[0]),
|
||||
phy_caps);
|
||||
lt_dbg(intel_dp, dp_phy, "PHY capabilities: %*ph\n",
|
||||
(int)sizeof(intel_dp->lttpr_phy_caps[0]),
|
||||
phy_caps);
|
||||
}
|
||||
|
||||
static bool intel_dp_read_lttpr_common_caps(struct intel_dp *intel_dp,
|
||||
const u8 dpcd[DP_RECEIVER_CAP_SIZE])
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
int ret;
|
||||
|
||||
ret = drm_dp_read_lttpr_common_caps(&intel_dp->aux, dpcd,
|
||||
@@ -77,11 +90,9 @@ static bool intel_dp_read_lttpr_common_caps(struct intel_dp *intel_dp,
|
||||
if (ret < 0)
|
||||
goto reset_caps;
|
||||
|
||||
drm_dbg_kms(&dp_to_i915(intel_dp)->drm,
|
||||
"[ENCODER:%d:%s] LTTPR common capabilities: %*ph\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
(int)sizeof(intel_dp->lttpr_common_caps),
|
||||
intel_dp->lttpr_common_caps);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "LTTPR common capabilities: %*ph\n",
|
||||
(int)sizeof(intel_dp->lttpr_common_caps),
|
||||
intel_dp->lttpr_common_caps);
|
||||
|
||||
/* The minimum value of LT_TUNABLE_PHY_REPEATER_FIELD_DATA_STRUCTURE_REV is 1.4 */
|
||||
if (intel_dp->lttpr_common_caps[0] < 0x14)
|
||||
@@ -105,8 +116,6 @@ intel_dp_set_lttpr_transparent_mode(struct intel_dp *intel_dp, bool enable)
|
||||
|
||||
static int intel_dp_init_lttpr(struct intel_dp *intel_dp, const u8 dpcd[DP_RECEIVER_CAP_SIZE])
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
int lttpr_count;
|
||||
int i;
|
||||
|
||||
@@ -138,9 +147,8 @@ static int intel_dp_init_lttpr(struct intel_dp *intel_dp, const u8 dpcd[DP_RECEI
|
||||
return 0;
|
||||
|
||||
if (!intel_dp_set_lttpr_transparent_mode(intel_dp, false)) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s] Switching to LTTPR non-transparent LT mode failed, fall-back to transparent mode\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX,
|
||||
"Switching to LTTPR non-transparent LT mode failed, fall-back to transparent mode\n");
|
||||
|
||||
intel_dp_set_lttpr_transparent_mode(intel_dp, true);
|
||||
intel_dp_reset_lttpr_count(intel_dp);
|
||||
@@ -409,26 +417,22 @@ intel_dp_get_adjust_train(struct intel_dp *intel_dp,
|
||||
enum drm_dp_phy dp_phy,
|
||||
const u8 link_status[DP_LINK_STATUS_SIZE])
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
int lane;
|
||||
|
||||
if (intel_dp_is_uhbr(crtc_state)) {
|
||||
drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s][%s] 128b/132b, lanes: %d, "
|
||||
"TX FFE request: " TRAIN_REQ_FMT "\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
crtc_state->lane_count,
|
||||
TRAIN_REQ_TX_FFE_ARGS(link_status));
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"128b/132b, lanes: %d, "
|
||||
"TX FFE request: " TRAIN_REQ_FMT "\n",
|
||||
crtc_state->lane_count,
|
||||
TRAIN_REQ_TX_FFE_ARGS(link_status));
|
||||
} else {
|
||||
drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s][%s] 8b/10b, lanes: %d, "
|
||||
"vswing request: " TRAIN_REQ_FMT ", "
|
||||
"pre-emphasis request: " TRAIN_REQ_FMT "\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
crtc_state->lane_count,
|
||||
TRAIN_REQ_VSWING_ARGS(link_status),
|
||||
TRAIN_REQ_PREEMPH_ARGS(link_status));
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"8b/10b, lanes: %d, "
|
||||
"vswing request: " TRAIN_REQ_FMT ", "
|
||||
"pre-emphasis request: " TRAIN_REQ_FMT "\n",
|
||||
crtc_state->lane_count,
|
||||
TRAIN_REQ_VSWING_ARGS(link_status),
|
||||
TRAIN_REQ_PREEMPH_ARGS(link_status));
|
||||
}
|
||||
|
||||
for (lane = 0; lane < 4; lane++)
|
||||
@@ -487,16 +491,11 @@ intel_dp_program_link_training_pattern(struct intel_dp *intel_dp,
|
||||
enum drm_dp_phy dp_phy,
|
||||
u8 dp_train_pat)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
u8 train_pat = intel_dp_training_pattern_symbol(dp_train_pat);
|
||||
|
||||
if (train_pat != DP_TRAINING_PATTERN_DISABLE)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Using DP training pattern TPS%c\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
dp_training_pattern_name(train_pat));
|
||||
lt_dbg(intel_dp, dp_phy, "Using DP training pattern TPS%c\n",
|
||||
dp_training_pattern_name(train_pat));
|
||||
|
||||
intel_dp->set_link_train(intel_dp, crtc_state, dp_train_pat);
|
||||
}
|
||||
@@ -531,24 +530,21 @@ void intel_dp_set_signal_levels(struct intel_dp *intel_dp,
|
||||
enum drm_dp_phy dp_phy)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
|
||||
if (intel_dp_is_uhbr(crtc_state)) {
|
||||
drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s][%s] 128b/132b, lanes: %d, "
|
||||
"TX FFE presets: " TRAIN_SET_FMT "\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
crtc_state->lane_count,
|
||||
TRAIN_SET_TX_FFE_ARGS(intel_dp->train_set));
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"128b/132b, lanes: %d, "
|
||||
"TX FFE presets: " TRAIN_SET_FMT "\n",
|
||||
crtc_state->lane_count,
|
||||
TRAIN_SET_TX_FFE_ARGS(intel_dp->train_set));
|
||||
} else {
|
||||
drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s][%s] 8b/10b, lanes: %d, "
|
||||
"vswing levels: " TRAIN_SET_FMT ", "
|
||||
"pre-emphasis levels: " TRAIN_SET_FMT "\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
crtc_state->lane_count,
|
||||
TRAIN_SET_VSWING_ARGS(intel_dp->train_set),
|
||||
TRAIN_SET_PREEMPH_ARGS(intel_dp->train_set));
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"8b/10b, lanes: %d, "
|
||||
"vswing levels: " TRAIN_SET_FMT ", "
|
||||
"pre-emphasis levels: " TRAIN_SET_FMT "\n",
|
||||
crtc_state->lane_count,
|
||||
TRAIN_SET_VSWING_ARGS(intel_dp->train_set),
|
||||
TRAIN_SET_PREEMPH_ARGS(intel_dp->train_set));
|
||||
}
|
||||
|
||||
if (intel_dp_phy_is_downstream_of_source(intel_dp, dp_phy))
|
||||
@@ -637,6 +633,38 @@ static bool intel_dp_link_max_vswing_reached(struct intel_dp *intel_dp,
|
||||
return true;
|
||||
}
|
||||
|
||||
static void
|
||||
intel_dp_update_downspread_ctrl(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
u8 link_config[2];
|
||||
|
||||
link_config[0] = crtc_state->vrr.flipline ? DP_MSA_TIMING_PAR_IGNORE_EN : 0;
|
||||
link_config[1] = intel_dp_is_uhbr(crtc_state) ?
|
||||
DP_SET_ANSI_128B132B : DP_SET_ANSI_8B10B;
|
||||
drm_dp_dpcd_write(&intel_dp->aux, DP_DOWNSPREAD_CTRL, link_config, 2);
|
||||
}
|
||||
|
||||
static void
|
||||
intel_dp_update_link_bw_set(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
u8 link_bw, u8 rate_select)
|
||||
{
|
||||
u8 link_config[2];
|
||||
|
||||
/* Write the link configuration data */
|
||||
link_config[0] = link_bw;
|
||||
link_config[1] = crtc_state->lane_count;
|
||||
if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
|
||||
link_config[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
|
||||
drm_dp_dpcd_write(&intel_dp->aux, DP_LINK_BW_SET, link_config, 2);
|
||||
|
||||
/* eDP 1.4 rate select method. */
|
||||
if (!link_bw)
|
||||
drm_dp_dpcd_write(&intel_dp->aux, DP_LINK_RATE_SET,
|
||||
&rate_select, 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Prepare link training by configuring the link parameters. On DDI platforms
|
||||
* also enable the port here.
|
||||
@@ -645,9 +673,6 @@ static bool
|
||||
intel_dp_prepare_link_train(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
u8 link_config[2];
|
||||
u8 link_bw, rate_select;
|
||||
|
||||
if (intel_dp->prepare_link_retrain)
|
||||
@@ -668,41 +693,28 @@ intel_dp_prepare_link_train(struct intel_dp *intel_dp,
|
||||
* link rates are not stable.
|
||||
*/
|
||||
if (!link_bw) {
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
__le16 sink_rates[DP_MAX_SUPPORTED_RATES];
|
||||
|
||||
drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] Reloading eDP link rates\n",
|
||||
connector->base.base.id, connector->base.name);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "Reloading eDP link rates\n");
|
||||
|
||||
drm_dp_dpcd_read(&intel_dp->aux, DP_SUPPORTED_LINK_RATES,
|
||||
sink_rates, sizeof(sink_rates));
|
||||
}
|
||||
|
||||
if (link_bw)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s] Using LINK_BW_SET value %02x\n",
|
||||
encoder->base.base.id, encoder->base.name, link_bw);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "Using LINK_BW_SET value %02x\n",
|
||||
link_bw);
|
||||
else
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s] Using LINK_RATE_SET value %02x\n",
|
||||
encoder->base.base.id, encoder->base.name, rate_select);
|
||||
|
||||
/* Write the link configuration data */
|
||||
link_config[0] = link_bw;
|
||||
link_config[1] = crtc_state->lane_count;
|
||||
if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
|
||||
link_config[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
|
||||
drm_dp_dpcd_write(&intel_dp->aux, DP_LINK_BW_SET, link_config, 2);
|
||||
|
||||
/* eDP 1.4 rate select method. */
|
||||
if (!link_bw)
|
||||
drm_dp_dpcd_write(&intel_dp->aux, DP_LINK_RATE_SET,
|
||||
&rate_select, 1);
|
||||
|
||||
link_config[0] = crtc_state->vrr.enable ? DP_MSA_TIMING_PAR_IGNORE_EN : 0;
|
||||
link_config[1] = intel_dp_is_uhbr(crtc_state) ?
|
||||
DP_SET_ANSI_128B132B : DP_SET_ANSI_8B10B;
|
||||
drm_dp_dpcd_write(&intel_dp->aux, DP_DOWNSPREAD_CTRL, link_config, 2);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX,
|
||||
"Using LINK_RATE_SET value %02x\n",
|
||||
rate_select);
|
||||
/*
|
||||
* Spec DP2.1 Section 3.5.2.16
|
||||
* Prior to LT DPTX should set 128b/132b DP Channel coding and then set link rate
|
||||
*/
|
||||
intel_dp_update_downspread_ctrl(intel_dp, crtc_state);
|
||||
intel_dp_update_link_bw_set(intel_dp, crtc_state, link_bw,
|
||||
rate_select);
|
||||
|
||||
return true;
|
||||
}
|
||||
@@ -737,15 +749,10 @@ void
|
||||
intel_dp_dump_link_status(struct intel_dp *intel_dp, enum drm_dp_phy dp_phy,
|
||||
const u8 link_status[DP_LINK_STATUS_SIZE])
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] ln0_1:0x%x ln2_3:0x%x align:0x%x sink:0x%x adj_req0_1:0x%x adj_req2_3:0x%x\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
link_status[0], link_status[1], link_status[2],
|
||||
link_status[3], link_status[4], link_status[5]);
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"ln0_1:0x%x ln2_3:0x%x align:0x%x sink:0x%x adj_req0_1:0x%x adj_req2_3:0x%x\n",
|
||||
link_status[0], link_status[1], link_status[2],
|
||||
link_status[3], link_status[4], link_status[5]);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -757,8 +764,6 @@ intel_dp_link_training_clock_recovery(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
enum drm_dp_phy dp_phy)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
u8 old_link_status[DP_LINK_STATUS_SIZE] = {};
|
||||
int voltage_tries, cr_tries, max_cr_tries;
|
||||
u8 link_status[DP_LINK_STATUS_SIZE];
|
||||
@@ -773,9 +778,7 @@ intel_dp_link_training_clock_recovery(struct intel_dp *intel_dp,
|
||||
if (!intel_dp_reset_link_train(intel_dp, crtc_state, dp_phy,
|
||||
DP_TRAINING_PATTERN_1 |
|
||||
DP_LINK_SCRAMBLING_DISABLE)) {
|
||||
drm_err(&i915->drm, "[ENCODER:%d:%s][%s] Failed to enable link training\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_err(intel_dp, dp_phy, "Failed to enable link training\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -798,35 +801,24 @@ intel_dp_link_training_clock_recovery(struct intel_dp *intel_dp,
|
||||
|
||||
if (drm_dp_dpcd_read_phy_link_status(&intel_dp->aux, dp_phy,
|
||||
link_status) < 0) {
|
||||
drm_err(&i915->drm, "[ENCODER:%d:%s][%s] Failed to get link status\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_err(intel_dp, dp_phy, "Failed to get link status\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (drm_dp_clock_recovery_ok(link_status, crtc_state->lane_count)) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Clock recovery OK\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_dbg(intel_dp, dp_phy, "Clock recovery OK\n");
|
||||
return true;
|
||||
}
|
||||
|
||||
if (voltage_tries == 5) {
|
||||
intel_dp_dump_link_status(intel_dp, dp_phy, link_status);
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Same voltage tried 5 times\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_dbg(intel_dp, dp_phy, "Same voltage tried 5 times\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (max_vswing_reached) {
|
||||
intel_dp_dump_link_status(intel_dp, dp_phy, link_status);
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Max Voltage Swing reached\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_dbg(intel_dp, dp_phy, "Max Voltage Swing reached\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -834,10 +826,7 @@ intel_dp_link_training_clock_recovery(struct intel_dp *intel_dp,
|
||||
intel_dp_get_adjust_train(intel_dp, crtc_state, dp_phy,
|
||||
link_status);
|
||||
if (!intel_dp_update_link_train(intel_dp, crtc_state, dp_phy)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Failed to update link training\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_err(intel_dp, dp_phy, "Failed to update link training\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -853,10 +842,8 @@ intel_dp_link_training_clock_recovery(struct intel_dp *intel_dp,
|
||||
}
|
||||
|
||||
intel_dp_dump_link_status(intel_dp, dp_phy, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Failed clock recovery %d times, giving up!\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy), max_cr_tries);
|
||||
lt_err(intel_dp, dp_phy, "Failed clock recovery %d times, giving up!\n",
|
||||
max_cr_tries);
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -890,11 +877,11 @@ static u32 intel_dp_training_pattern(struct intel_dp *intel_dp,
|
||||
return DP_TRAINING_PATTERN_4;
|
||||
} else if (crtc_state->port_clock == 810000) {
|
||||
if (!source_tps4)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"8.1 Gbps link rate without source TPS4 support\n");
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"8.1 Gbps link rate without source TPS4 support\n");
|
||||
if (!sink_tps4)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"8.1 Gbps link rate without sink TPS4 support\n");
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"8.1 Gbps link rate without sink TPS4 support\n");
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -908,11 +895,11 @@ static u32 intel_dp_training_pattern(struct intel_dp *intel_dp,
|
||||
return DP_TRAINING_PATTERN_3;
|
||||
} else if (crtc_state->port_clock >= 540000) {
|
||||
if (!source_tps3)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
">=5.4/6.48 Gbps link rate without source TPS3 support\n");
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
">=5.4/6.48 Gbps link rate without source TPS3 support\n");
|
||||
if (!sink_tps3)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
">=5.4/6.48 Gbps link rate without sink TPS3 support\n");
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
">=5.4/6.48 Gbps link rate without sink TPS3 support\n");
|
||||
}
|
||||
|
||||
return DP_TRAINING_PATTERN_2;
|
||||
@@ -928,8 +915,6 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
enum drm_dp_phy dp_phy)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
int tries;
|
||||
u32 training_pattern;
|
||||
u8 link_status[DP_LINK_STATUS_SIZE];
|
||||
@@ -948,10 +933,7 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp,
|
||||
/* channel equalization */
|
||||
if (!intel_dp_set_link_train(intel_dp, crtc_state, dp_phy,
|
||||
training_pattern)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Failed to start channel equalization\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_err(intel_dp, dp_phy, "Failed to start channel equalization\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -960,10 +942,7 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp,
|
||||
|
||||
if (drm_dp_dpcd_read_phy_link_status(&intel_dp->aux, dp_phy,
|
||||
link_status) < 0) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Failed to get link status\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_err(intel_dp, dp_phy, "Failed to get link status\n");
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -971,21 +950,15 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp,
|
||||
if (!drm_dp_clock_recovery_ok(link_status,
|
||||
crtc_state->lane_count)) {
|
||||
intel_dp_dump_link_status(intel_dp, dp_phy, link_status);
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Clock recovery check failed, cannot "
|
||||
"continue channel equalization\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"Clock recovery check failed, cannot continue channel equalization\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (drm_dp_channel_eq_ok(link_status,
|
||||
crtc_state->lane_count)) {
|
||||
channel_eq = true;
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Channel EQ done. DP Training successful\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_dbg(intel_dp, dp_phy, "Channel EQ done. DP Training successful\n");
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -993,10 +966,7 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp,
|
||||
intel_dp_get_adjust_train(intel_dp, crtc_state, dp_phy,
|
||||
link_status);
|
||||
if (!intel_dp_update_link_train(intel_dp, crtc_state, dp_phy)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Failed to update link training\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_err(intel_dp, dp_phy, "Failed to update link training\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -1004,10 +974,7 @@ intel_dp_link_training_channel_equalization(struct intel_dp *intel_dp,
|
||||
/* Try 5 times, else fail and try at lower BW */
|
||||
if (tries == 5) {
|
||||
intel_dp_dump_link_status(intel_dp, dp_phy, link_status);
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s][%s] Channel equalization failed 5 times\n",
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy));
|
||||
lt_dbg(intel_dp, dp_phy, "Channel equalization failed 5 times\n");
|
||||
}
|
||||
|
||||
return channel_eq;
|
||||
@@ -1026,13 +993,12 @@ static int
|
||||
intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
u8 sink_status;
|
||||
int ret;
|
||||
|
||||
ret = drm_dp_dpcd_readb(&intel_dp->aux, DP_SINK_STATUS, &sink_status);
|
||||
if (ret != 1) {
|
||||
drm_dbg_kms(&i915->drm, "Failed to read sink status\n");
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "Failed to read sink status\n");
|
||||
return ret < 0 ? ret : -EIO;
|
||||
}
|
||||
|
||||
@@ -1058,9 +1024,6 @@ intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
|
||||
void intel_dp_stop_link_train(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
|
||||
intel_dp->link_trained = true;
|
||||
|
||||
intel_dp_disable_dpcd_training_pattern(intel_dp, DP_PHY_DPRX);
|
||||
@@ -1069,9 +1032,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
|
||||
|
||||
if (intel_dp_is_uhbr(crtc_state) &&
|
||||
wait_for(intel_dp_128b132b_intra_hop(intel_dp, crtc_state) == 0, 500)) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s] 128b/132b intra-hop not clearing\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "128b/132b intra-hop not clearing\n");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1080,8 +1041,6 @@ intel_dp_link_train_phy(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
enum drm_dp_phy dp_phy)
|
||||
{
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
bool ret = false;
|
||||
|
||||
if (!intel_dp_link_training_clock_recovery(intel_dp, crtc_state, dp_phy))
|
||||
@@ -1093,13 +1052,10 @@ intel_dp_link_train_phy(struct intel_dp *intel_dp,
|
||||
ret = true;
|
||||
|
||||
out:
|
||||
drm_dbg_kms(&dp_to_i915(intel_dp)->drm,
|
||||
"[CONNECTOR:%d:%s][ENCODER:%d:%s][%s] Link Training %s at link rate = %d, lane count = %d\n",
|
||||
connector->base.base.id, connector->base.name,
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
drm_dp_phy_name(dp_phy),
|
||||
ret ? "passed" : "failed",
|
||||
crtc_state->port_clock, crtc_state->lane_count);
|
||||
lt_dbg(intel_dp, dp_phy,
|
||||
"Link Training %s at link rate = %d, lane count = %d\n",
|
||||
ret ? "passed" : "failed",
|
||||
crtc_state->port_clock, crtc_state->lane_count);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -1108,13 +1064,15 @@ static void intel_dp_schedule_fallback_link_training(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct intel_connector *intel_connector = intel_dp->attached_connector;
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
|
||||
if (!intel_digital_port_connected(&dp_to_dig_port(intel_dp)->base)) {
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "Link Training failed on disconnected sink.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (intel_dp->hobl_active) {
|
||||
drm_dbg_kms(&dp_to_i915(intel_dp)->drm,
|
||||
"[ENCODER:%d:%s] Link Training failed with HOBL active, "
|
||||
"not enabling it from now on",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX,
|
||||
"Link Training failed with HOBL active, not enabling it from now on\n");
|
||||
intel_dp->hobl_failed = true;
|
||||
} else if (intel_dp_get_link_train_fallback_values(intel_dp,
|
||||
crtc_state->port_clock,
|
||||
@@ -1161,8 +1119,6 @@ static bool
|
||||
intel_dp_128b132b_lane_eq(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
u8 link_status[DP_LINK_STATUS_SIZE];
|
||||
int delay_us;
|
||||
int try, max_tries = 20;
|
||||
@@ -1177,9 +1133,7 @@ intel_dp_128b132b_lane_eq(struct intel_dp *intel_dp,
|
||||
*/
|
||||
if (!intel_dp_reset_link_train(intel_dp, crtc_state, DP_PHY_DPRX,
|
||||
DP_TRAINING_PATTERN_1)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to start 128b/132b TPS1\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to start 128b/132b TPS1\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1187,27 +1141,21 @@ intel_dp_128b132b_lane_eq(struct intel_dp *intel_dp,
|
||||
|
||||
/* Read the initial TX FFE settings. */
|
||||
if (drm_dp_dpcd_read_link_status(&intel_dp->aux, link_status) < 0) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to read TX FFE presets\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to read TX FFE presets\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Update signal levels and training set as requested. */
|
||||
intel_dp_get_adjust_train(intel_dp, crtc_state, DP_PHY_DPRX, link_status);
|
||||
if (!intel_dp_update_link_train(intel_dp, crtc_state, DP_PHY_DPRX)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to set initial TX FFE settings\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to set initial TX FFE settings\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Start transmitting 128b/132b TPS2. */
|
||||
if (!intel_dp_set_link_train(intel_dp, crtc_state, DP_PHY_DPRX,
|
||||
DP_TRAINING_PATTERN_2)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to start 128b/132b TPS2\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to start 128b/132b TPS2\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1224,32 +1172,25 @@ intel_dp_128b132b_lane_eq(struct intel_dp *intel_dp,
|
||||
delay_us = drm_dp_128b132b_read_aux_rd_interval(&intel_dp->aux);
|
||||
|
||||
if (drm_dp_dpcd_read_link_status(&intel_dp->aux, link_status) < 0) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to read link status\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to read link status\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (drm_dp_128b132b_link_training_failed(link_status)) {
|
||||
intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Downstream link training failure\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX,
|
||||
"Downstream link training failure\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (drm_dp_128b132b_lane_channel_eq_done(link_status, crtc_state->lane_count)) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s] Lane channel eq done\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "Lane channel eq done\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (timeout) {
|
||||
intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Lane channel eq timeout\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Lane channel eq timeout\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1259,18 +1200,14 @@ intel_dp_128b132b_lane_eq(struct intel_dp *intel_dp,
|
||||
/* Update signal levels and training set as requested. */
|
||||
intel_dp_get_adjust_train(intel_dp, crtc_state, DP_PHY_DPRX, link_status);
|
||||
if (!intel_dp_update_link_train(intel_dp, crtc_state, DP_PHY_DPRX)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to update TX FFE settings\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to update TX FFE settings\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (try == max_tries) {
|
||||
intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Max loop count reached\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Max loop count reached\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1279,32 +1216,24 @@ intel_dp_128b132b_lane_eq(struct intel_dp *intel_dp,
|
||||
timeout = true; /* try one last time after deadline */
|
||||
|
||||
if (drm_dp_dpcd_read_link_status(&intel_dp->aux, link_status) < 0) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to read link status\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to read link status\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (drm_dp_128b132b_link_training_failed(link_status)) {
|
||||
intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Downstream link training failure\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Downstream link training failure\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (drm_dp_128b132b_eq_interlane_align_done(link_status)) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s] Interlane align done\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "Interlane align done\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (timeout) {
|
||||
intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Interlane align timeout\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Interlane align timeout\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1322,16 +1251,12 @@ intel_dp_128b132b_lane_cds(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
int lttpr_count)
|
||||
{
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
u8 link_status[DP_LINK_STATUS_SIZE];
|
||||
unsigned long deadline;
|
||||
|
||||
if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_TRAINING_PATTERN_SET,
|
||||
DP_TRAINING_PATTERN_2_CDS) != 1) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to start 128b/132b TPS2 CDS\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to start 128b/132b TPS2 CDS\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1347,34 +1272,26 @@ intel_dp_128b132b_lane_cds(struct intel_dp *intel_dp,
|
||||
usleep_range(2000, 3000);
|
||||
|
||||
if (drm_dp_dpcd_read_link_status(&intel_dp->aux, link_status) < 0) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Failed to read link status\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Failed to read link status\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (drm_dp_128b132b_eq_interlane_align_done(link_status) &&
|
||||
drm_dp_128b132b_cds_interlane_align_done(link_status) &&
|
||||
drm_dp_128b132b_lane_symbol_locked(link_status, crtc_state->lane_count)) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[ENCODER:%d:%s] CDS interlane align done\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "CDS interlane align done\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (drm_dp_128b132b_link_training_failed(link_status)) {
|
||||
intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] Downstream link training failure\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "Downstream link training failure\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (timeout) {
|
||||
intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] CDS timeout\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "CDS timeout\n");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -1390,15 +1307,10 @@ intel_dp_128b132b_link_train(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
int lttpr_count)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
bool passed = false;
|
||||
|
||||
if (wait_for(intel_dp_128b132b_intra_hop(intel_dp, crtc_state) == 0, 500)) {
|
||||
drm_err(&i915->drm,
|
||||
"[ENCODER:%d:%s] 128b/132b intra-hop not clear\n",
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_err(intel_dp, DP_PHY_DPRX, "128b/132b intra-hop not clear\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -1406,12 +1318,10 @@ intel_dp_128b132b_link_train(struct intel_dp *intel_dp,
|
||||
intel_dp_128b132b_lane_cds(intel_dp, crtc_state, lttpr_count))
|
||||
passed = true;
|
||||
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[CONNECTOR:%d:%s][ENCODER:%d:%s] 128b/132b Link Training %s at link rate = %d, lane count = %d\n",
|
||||
connector->base.base.id, connector->base.name,
|
||||
encoder->base.base.id, encoder->base.name,
|
||||
passed ? "passed" : "failed",
|
||||
crtc_state->port_clock, crtc_state->lane_count);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX,
|
||||
"128b/132b Link Training %s at link rate = %d, lane count = %d\n",
|
||||
passed ? "passed" : "failed",
|
||||
crtc_state->port_clock, crtc_state->lane_count);
|
||||
|
||||
return passed;
|
||||
}
|
||||
@@ -1430,8 +1340,6 @@ void intel_dp_start_link_train(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
|
||||
bool passed;
|
||||
|
||||
/*
|
||||
@@ -1464,10 +1372,7 @@ void intel_dp_start_link_train(struct intel_dp *intel_dp,
|
||||
* ignore_long_hpd flag can unset from the testcase.
|
||||
*/
|
||||
if (!passed && i915->display.hotplug.ignore_long_hpd) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"[CONNECTOR:%d:%s][ENCODER:%d:%s] Ignore the link failure\n",
|
||||
connector->base.base.id, connector->base.name,
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "Ignore the link failure\n");
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -1478,8 +1383,6 @@ void intel_dp_start_link_train(struct intel_dp *intel_dp,
|
||||
void intel_dp_128b132b_sdp_crc16(struct intel_dp *intel_dp,
|
||||
const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = dp_to_i915(intel_dp);
|
||||
|
||||
/*
|
||||
* VIDEO_DIP_CTL register bit 31 should be set to '0' to not
|
||||
* disable SDP CRC. This is applicable for Display version 13.
|
||||
@@ -1492,5 +1395,5 @@ void intel_dp_128b132b_sdp_crc16(struct intel_dp *intel_dp,
|
||||
DP_SDP_ERROR_DETECTION_CONFIGURATION,
|
||||
DP_SDP_CRC16_128B132B_EN);
|
||||
|
||||
drm_dbg_kms(&i915->drm, "DP2.0 SDP CRC16 for 128b/132b enabled\n");
|
||||
lt_dbg(intel_dp, DP_PHY_DPRX, "DP2.0 SDP CRC16 for 128b/132b enabled\n");
|
||||
}
|
||||
|
||||
@@ -298,7 +298,7 @@ static bool intel_dp_mst_has_audio(const struct drm_connector_state *conn_state)
|
||||
to_intel_connector(conn_state->connector);
|
||||
|
||||
if (intel_conn_state->force_audio == HDMI_AUDIO_AUTO)
|
||||
return connector->port->has_audio;
|
||||
return connector->base.display_info.has_audio;
|
||||
else
|
||||
return intel_conn_state->force_audio == HDMI_AUDIO_ON;
|
||||
}
|
||||
@@ -318,6 +318,7 @@ static int intel_dp_mst_compute_config(struct intel_encoder *encoder,
|
||||
if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN)
|
||||
return -EINVAL;
|
||||
|
||||
pipe_config->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
pipe_config->has_pch_encoder = false;
|
||||
|
||||
@@ -800,9 +801,7 @@ static void intel_mst_enable_dp(struct intel_atomic_state *state,
|
||||
/* Enable hdcp if it's desired */
|
||||
if (conn_state->content_protection ==
|
||||
DRM_MODE_CONTENT_PROTECTION_DESIRED)
|
||||
intel_hdcp_enable(to_intel_connector(conn_state->connector),
|
||||
pipe_config,
|
||||
(u8)conn_state->hdcp_content_type);
|
||||
intel_hdcp_enable(state, encoder, pipe_config, conn_state);
|
||||
}
|
||||
|
||||
static bool intel_dp_mst_enc_get_hw_state(struct intel_encoder *encoder,
|
||||
@@ -837,15 +836,17 @@ static int intel_dp_mst_get_ddc_modes(struct drm_connector *connector)
|
||||
{
|
||||
struct intel_connector *intel_connector = to_intel_connector(connector);
|
||||
struct intel_dp *intel_dp = intel_connector->mst_port;
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
int ret;
|
||||
|
||||
if (drm_connector_is_unregistered(connector))
|
||||
return intel_connector_update_modes(connector, NULL);
|
||||
|
||||
edid = drm_dp_mst_get_edid(connector, &intel_dp->mst_mgr, intel_connector->port);
|
||||
ret = intel_connector_update_modes(connector, edid);
|
||||
kfree(edid);
|
||||
drm_edid = drm_dp_mst_edid_read(connector, &intel_dp->mst_mgr, intel_connector->port);
|
||||
|
||||
ret = intel_connector_update_modes(connector, drm_edid);
|
||||
|
||||
drm_edid_free(drm_edid);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
|
||||
#include "i915_reg.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_cx0_phy.h"
|
||||
#include "intel_de.h"
|
||||
#include "intel_display.h"
|
||||
#include "intel_display_types.h"
|
||||
@@ -995,6 +996,32 @@ static int dg2_crtc_compute_clock(struct intel_atomic_state *state,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mtl_crtc_compute_clock(struct intel_atomic_state *state,
|
||||
struct intel_crtc *crtc)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(state->base.dev);
|
||||
struct intel_crtc_state *crtc_state =
|
||||
intel_atomic_get_new_crtc_state(state, crtc);
|
||||
struct intel_encoder *encoder =
|
||||
intel_get_crtc_new_encoder(state, crtc_state);
|
||||
enum phy phy = intel_port_to_phy(i915, encoder->port);
|
||||
int ret;
|
||||
|
||||
ret = intel_cx0pll_calc_state(crtc_state, encoder);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/* TODO: Do the readback via intel_compute_shared_dplls() */
|
||||
if (intel_is_c10phy(i915, phy))
|
||||
crtc_state->port_clock = intel_c10pll_calc_port_clock(encoder, &crtc_state->cx0pll_state.c10);
|
||||
else
|
||||
crtc_state->port_clock = intel_c20pll_calc_port_clock(encoder, &crtc_state->cx0pll_state.c20);
|
||||
|
||||
crtc_state->hw.adjusted_mode.crtc_clock = intel_crtc_dotclock(crtc_state);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool ilk_needs_fb_cb_tune(const struct dpll *dpll, int factor)
|
||||
{
|
||||
return dpll->m < factor * dpll->n;
|
||||
@@ -1423,6 +1450,10 @@ static int i8xx_crtc_compute_clock(struct intel_atomic_state *state,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct intel_dpll_funcs mtl_dpll_funcs = {
|
||||
.crtc_compute_clock = mtl_crtc_compute_clock,
|
||||
};
|
||||
|
||||
static const struct intel_dpll_funcs dg2_dpll_funcs = {
|
||||
.crtc_compute_clock = dg2_crtc_compute_clock,
|
||||
};
|
||||
@@ -1517,7 +1548,9 @@ int intel_dpll_crtc_get_shared_dpll(struct intel_atomic_state *state,
|
||||
void
|
||||
intel_dpll_init_clock_hook(struct drm_i915_private *dev_priv)
|
||||
{
|
||||
if (IS_DG2(dev_priv))
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
dev_priv->display.funcs.dpll = &mtl_dpll_funcs;
|
||||
else if (IS_DG2(dev_priv))
|
||||
dev_priv->display.funcs.dpll = &dg2_dpll_funcs;
|
||||
else if (DISPLAY_VER(dev_priv) >= 9 || HAS_DDI(dev_priv))
|
||||
dev_priv->display.funcs.dpll = &hsw_dpll_funcs;
|
||||
@@ -2047,7 +2080,7 @@ static void assert_pll(struct drm_i915_private *dev_priv,
|
||||
bool cur_state;
|
||||
|
||||
cur_state = intel_de_read(dev_priv, DPLL(pipe)) & DPLL_VCO_ENABLE;
|
||||
I915_STATE_WARN(cur_state != state,
|
||||
I915_STATE_WARN(dev_priv, cur_state != state,
|
||||
"PLL state assertion failure (expected %s, current %s)\n",
|
||||
str_on_off(state), str_on_off(cur_state));
|
||||
}
|
||||
|
||||
@@ -169,8 +169,8 @@ void assert_shared_dpll(struct drm_i915_private *dev_priv,
|
||||
return;
|
||||
|
||||
cur_state = intel_dpll_get_hw_state(dev_priv, pll, &hw_state);
|
||||
I915_STATE_WARN(cur_state != state,
|
||||
"%s assertion failure (expected %s, current %s)\n",
|
||||
I915_STATE_WARN(dev_priv, cur_state != state,
|
||||
"%s assertion failure (expected %s, current %s)\n",
|
||||
pll->info->name, str_on_off(state),
|
||||
str_on_off(cur_state));
|
||||
}
|
||||
@@ -351,13 +351,35 @@ intel_find_shared_dpll(struct intel_atomic_state *state,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* intel_reference_shared_dpll_crtc - Get a DPLL reference for a CRTC
|
||||
* @crtc: CRTC on which behalf the reference is taken
|
||||
* @pll: DPLL for which the reference is taken
|
||||
* @shared_dpll_state: the DPLL atomic state in which the reference is tracked
|
||||
*
|
||||
* Take a reference for @pll tracking the use of it by @crtc.
|
||||
*/
|
||||
static void
|
||||
intel_reference_shared_dpll_crtc(const struct intel_crtc *crtc,
|
||||
const struct intel_shared_dpll *pll,
|
||||
struct intel_shared_dpll_state *shared_dpll_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
|
||||
drm_WARN_ON(&i915->drm, (shared_dpll_state->pipe_mask & BIT(crtc->pipe)) != 0);
|
||||
|
||||
shared_dpll_state->pipe_mask |= BIT(crtc->pipe);
|
||||
|
||||
drm_dbg_kms(&i915->drm, "[CRTC:%d:%s] reserving %s\n",
|
||||
crtc->base.base.id, crtc->base.name, pll->info->name);
|
||||
}
|
||||
|
||||
static void
|
||||
intel_reference_shared_dpll(struct intel_atomic_state *state,
|
||||
const struct intel_crtc *crtc,
|
||||
const struct intel_shared_dpll *pll,
|
||||
const struct intel_dpll_hw_state *pll_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(state->base.dev);
|
||||
struct intel_shared_dpll_state *shared_dpll;
|
||||
const enum intel_dpll_id id = pll->info->id;
|
||||
|
||||
@@ -366,11 +388,29 @@ intel_reference_shared_dpll(struct intel_atomic_state *state,
|
||||
if (shared_dpll[id].pipe_mask == 0)
|
||||
shared_dpll[id].hw_state = *pll_state;
|
||||
|
||||
drm_WARN_ON(&i915->drm, (shared_dpll[id].pipe_mask & BIT(crtc->pipe)) != 0);
|
||||
intel_reference_shared_dpll_crtc(crtc, pll, &shared_dpll[id]);
|
||||
}
|
||||
|
||||
shared_dpll[id].pipe_mask |= BIT(crtc->pipe);
|
||||
/**
|
||||
* intel_unreference_shared_dpll_crtc - Drop a DPLL reference for a CRTC
|
||||
* @crtc: CRTC on which behalf the reference is dropped
|
||||
* @pll: DPLL for which the reference is dropped
|
||||
* @shared_dpll_state: the DPLL atomic state in which the reference is tracked
|
||||
*
|
||||
* Drop a reference for @pll tracking the end of use of it by @crtc.
|
||||
*/
|
||||
void
|
||||
intel_unreference_shared_dpll_crtc(const struct intel_crtc *crtc,
|
||||
const struct intel_shared_dpll *pll,
|
||||
struct intel_shared_dpll_state *shared_dpll_state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
|
||||
drm_dbg_kms(&i915->drm, "[CRTC:%d:%s] reserving %s\n",
|
||||
drm_WARN_ON(&i915->drm, (shared_dpll_state->pipe_mask & BIT(crtc->pipe)) == 0);
|
||||
|
||||
shared_dpll_state->pipe_mask &= ~BIT(crtc->pipe);
|
||||
|
||||
drm_dbg_kms(&i915->drm, "[CRTC:%d:%s] releasing %s\n",
|
||||
crtc->base.base.id, crtc->base.name, pll->info->name);
|
||||
}
|
||||
|
||||
@@ -378,18 +418,12 @@ static void intel_unreference_shared_dpll(struct intel_atomic_state *state,
|
||||
const struct intel_crtc *crtc,
|
||||
const struct intel_shared_dpll *pll)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(state->base.dev);
|
||||
struct intel_shared_dpll_state *shared_dpll;
|
||||
const enum intel_dpll_id id = pll->info->id;
|
||||
|
||||
shared_dpll = intel_atomic_get_shared_dpll_state(&state->base);
|
||||
|
||||
drm_WARN_ON(&i915->drm, (shared_dpll[id].pipe_mask & BIT(crtc->pipe)) == 0);
|
||||
|
||||
shared_dpll[id].pipe_mask &= ~BIT(crtc->pipe);
|
||||
|
||||
drm_dbg_kms(&i915->drm, "[CRTC:%d:%s] releasing %s\n",
|
||||
crtc->base.base.id, crtc->base.name, pll->info->name);
|
||||
intel_unreference_shared_dpll_crtc(crtc, pll, &shared_dpll[id]);
|
||||
}
|
||||
|
||||
static void intel_put_dpll(struct intel_atomic_state *state,
|
||||
@@ -464,12 +498,11 @@ static void ibx_assert_pch_refclk_enabled(struct drm_i915_private *dev_priv)
|
||||
u32 val;
|
||||
bool enabled;
|
||||
|
||||
I915_STATE_WARN_ON(!(HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv)));
|
||||
|
||||
val = intel_de_read(dev_priv, PCH_DREF_CONTROL);
|
||||
enabled = !!(val & (DREF_SSC_SOURCE_MASK | DREF_NONSPREAD_SOURCE_MASK |
|
||||
DREF_SUPERSPREAD_SOURCE_MASK));
|
||||
I915_STATE_WARN(!enabled, "PCH refclk assertion failure, should be active but is disabled\n");
|
||||
I915_STATE_WARN(dev_priv, !enabled,
|
||||
"PCH refclk assertion failure, should be active but is disabled\n");
|
||||
}
|
||||
|
||||
static void ibx_pch_dpll_enable(struct drm_i915_private *dev_priv,
|
||||
@@ -4104,7 +4137,7 @@ void intel_shared_dpll_init(struct drm_i915_private *dev_priv)
|
||||
|
||||
mutex_init(&dev_priv->display.dpll.lock);
|
||||
|
||||
if (IS_DG2(dev_priv))
|
||||
if (DISPLAY_VER(dev_priv) >= 14 || IS_DG2(dev_priv))
|
||||
/* No shared DPLLs on DG2; port PLLs are part of the PHY */
|
||||
dpll_mgr = NULL;
|
||||
else if (IS_ALDERLAKE_P(dev_priv))
|
||||
@@ -4314,7 +4347,7 @@ static void readout_dpll_hw_state(struct drm_i915_private *i915,
|
||||
to_intel_crtc_state(crtc->base.state);
|
||||
|
||||
if (crtc_state->hw.active && crtc_state->shared_dpll == pll)
|
||||
pll->state.pipe_mask |= BIT(crtc->pipe);
|
||||
intel_reference_shared_dpll_crtc(crtc, pll, &pll->state);
|
||||
}
|
||||
pll->active_mask = pll->state.pipe_mask;
|
||||
|
||||
@@ -4407,17 +4440,18 @@ verify_single_dpll_state(struct drm_i915_private *dev_priv,
|
||||
active = intel_dpll_get_hw_state(dev_priv, pll, &dpll_hw_state);
|
||||
|
||||
if (!(pll->info->flags & INTEL_DPLL_ALWAYS_ON)) {
|
||||
I915_STATE_WARN(!pll->on && pll->active_mask,
|
||||
I915_STATE_WARN(dev_priv, !pll->on && pll->active_mask,
|
||||
"pll in active use but not on in sw tracking\n");
|
||||
I915_STATE_WARN(pll->on && !pll->active_mask,
|
||||
I915_STATE_WARN(dev_priv, pll->on && !pll->active_mask,
|
||||
"pll is on but not used by any active pipe\n");
|
||||
I915_STATE_WARN(pll->on != active,
|
||||
I915_STATE_WARN(dev_priv, pll->on != active,
|
||||
"pll on state mismatch (expected %i, found %i)\n",
|
||||
pll->on, active);
|
||||
}
|
||||
|
||||
if (!crtc) {
|
||||
I915_STATE_WARN(pll->active_mask & ~pll->state.pipe_mask,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
pll->active_mask & ~pll->state.pipe_mask,
|
||||
"more active pll users than references: 0x%x vs 0x%x\n",
|
||||
pll->active_mask, pll->state.pipe_mask);
|
||||
|
||||
@@ -4427,20 +4461,20 @@ verify_single_dpll_state(struct drm_i915_private *dev_priv,
|
||||
pipe_mask = BIT(crtc->pipe);
|
||||
|
||||
if (new_crtc_state->hw.active)
|
||||
I915_STATE_WARN(!(pll->active_mask & pipe_mask),
|
||||
I915_STATE_WARN(dev_priv, !(pll->active_mask & pipe_mask),
|
||||
"pll active mismatch (expected pipe %c in active mask 0x%x)\n",
|
||||
pipe_name(crtc->pipe), pll->active_mask);
|
||||
else
|
||||
I915_STATE_WARN(pll->active_mask & pipe_mask,
|
||||
I915_STATE_WARN(dev_priv, pll->active_mask & pipe_mask,
|
||||
"pll active mismatch (didn't expect pipe %c in active mask 0x%x)\n",
|
||||
pipe_name(crtc->pipe), pll->active_mask);
|
||||
|
||||
I915_STATE_WARN(!(pll->state.pipe_mask & pipe_mask),
|
||||
I915_STATE_WARN(dev_priv, !(pll->state.pipe_mask & pipe_mask),
|
||||
"pll enabled crtcs mismatch (expected 0x%x in 0x%x)\n",
|
||||
pipe_mask, pll->state.pipe_mask);
|
||||
|
||||
I915_STATE_WARN(pll->on && memcmp(&pll->state.hw_state,
|
||||
&dpll_hw_state,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
pll->on && memcmp(&pll->state.hw_state, &dpll_hw_state,
|
||||
sizeof(dpll_hw_state)),
|
||||
"pll hw state mismatch\n");
|
||||
}
|
||||
@@ -4460,10 +4494,10 @@ void intel_shared_dpll_state_verify(struct intel_crtc *crtc,
|
||||
u8 pipe_mask = BIT(crtc->pipe);
|
||||
struct intel_shared_dpll *pll = old_crtc_state->shared_dpll;
|
||||
|
||||
I915_STATE_WARN(pll->active_mask & pipe_mask,
|
||||
I915_STATE_WARN(dev_priv, pll->active_mask & pipe_mask,
|
||||
"pll active mismatch (didn't expect pipe %c in active mask (0x%x))\n",
|
||||
pipe_name(crtc->pipe), pll->active_mask);
|
||||
I915_STATE_WARN(pll->state.pipe_mask & pipe_mask,
|
||||
I915_STATE_WARN(dev_priv, pll->state.pipe_mask & pipe_mask,
|
||||
"pll enabled crtcs mismatch (found %x in enabled mask (0x%x))\n",
|
||||
pipe_name(crtc->pipe), pll->state.pipe_mask);
|
||||
}
|
||||
|
||||
@@ -341,6 +341,9 @@ int intel_reserve_shared_dplls(struct intel_atomic_state *state,
|
||||
struct intel_encoder *encoder);
|
||||
void intel_release_shared_dplls(struct intel_atomic_state *state,
|
||||
struct intel_crtc *crtc);
|
||||
void intel_unreference_shared_dpll_crtc(const struct intel_crtc *crtc,
|
||||
const struct intel_shared_dpll *pll,
|
||||
struct intel_shared_dpll_state *shared_dpll_state);
|
||||
void icl_set_active_port_dpll(struct intel_crtc_state *crtc_state,
|
||||
enum icl_port_dpll_id port_dpll_id);
|
||||
void intel_update_active_dpll(struct intel_atomic_state *state,
|
||||
|
||||
@@ -271,6 +271,7 @@ static int intel_dvo_compute_config(struct intel_encoder *encoder,
|
||||
if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN)
|
||||
return -EINVAL;
|
||||
|
||||
pipe_config->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -157,6 +157,32 @@ struct intel_modifier_desc {
|
||||
|
||||
static const struct intel_modifier_desc intel_modifiers[] = {
|
||||
{
|
||||
.modifier = I915_FORMAT_MOD_4_TILED_MTL_MC_CCS,
|
||||
.display_ver = { 14, 14 },
|
||||
.plane_caps = INTEL_PLANE_CAP_TILING_4 | INTEL_PLANE_CAP_CCS_MC,
|
||||
|
||||
.ccs.packed_aux_planes = BIT(1),
|
||||
.ccs.planar_aux_planes = BIT(2) | BIT(3),
|
||||
|
||||
FORMAT_OVERRIDE(gen12_ccs_formats),
|
||||
}, {
|
||||
.modifier = I915_FORMAT_MOD_4_TILED_MTL_RC_CCS,
|
||||
.display_ver = { 14, 14 },
|
||||
.plane_caps = INTEL_PLANE_CAP_TILING_4 | INTEL_PLANE_CAP_CCS_RC,
|
||||
|
||||
.ccs.packed_aux_planes = BIT(1),
|
||||
|
||||
FORMAT_OVERRIDE(gen12_ccs_formats),
|
||||
}, {
|
||||
.modifier = I915_FORMAT_MOD_4_TILED_MTL_RC_CCS_CC,
|
||||
.display_ver = { 14, 14 },
|
||||
.plane_caps = INTEL_PLANE_CAP_TILING_4 | INTEL_PLANE_CAP_CCS_RC_CC,
|
||||
|
||||
.ccs.cc_planes = BIT(2),
|
||||
.ccs.packed_aux_planes = BIT(1),
|
||||
|
||||
FORMAT_OVERRIDE(gen12_ccs_cc_formats),
|
||||
}, {
|
||||
.modifier = I915_FORMAT_MOD_4_TILED_DG2_MC_CCS,
|
||||
.display_ver = { 13, 13 },
|
||||
.plane_caps = INTEL_PLANE_CAP_TILING_4 | INTEL_PLANE_CAP_CCS_MC,
|
||||
@@ -370,6 +396,14 @@ static bool plane_has_modifier(struct drm_i915_private *i915,
|
||||
if (!plane_caps_contain_all(plane_caps, md->plane_caps))
|
||||
return false;
|
||||
|
||||
/*
|
||||
* Separate AuxCCS and Flat CCS modifiers to be run only on platforms
|
||||
* where supported.
|
||||
*/
|
||||
if (intel_fb_is_ccs_modifier(md->modifier) &&
|
||||
HAS_FLAT_CCS(i915) != !md->ccs.packed_aux_planes)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -489,7 +523,7 @@ static bool intel_fb_is_gen12_ccs_aux_plane(const struct drm_framebuffer *fb, in
|
||||
{
|
||||
const struct intel_modifier_desc *md = lookup_modifier(fb->modifier);
|
||||
|
||||
return check_modifier_display_ver_range(md, 12, 13) &&
|
||||
return check_modifier_display_ver_range(md, 12, 14) &&
|
||||
ccs_aux_plane_mask(md, fb->format) & BIT(color_plane);
|
||||
}
|
||||
|
||||
@@ -605,6 +639,9 @@ intel_tile_width_bytes(const struct drm_framebuffer *fb, int color_plane)
|
||||
if (intel_fb_is_ccs_aux_plane(fb, color_plane))
|
||||
return 128;
|
||||
fallthrough;
|
||||
case I915_FORMAT_MOD_4_TILED_MTL_RC_CCS:
|
||||
case I915_FORMAT_MOD_4_TILED_MTL_RC_CCS_CC:
|
||||
case I915_FORMAT_MOD_4_TILED_MTL_MC_CCS:
|
||||
case I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS:
|
||||
case I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS_CC:
|
||||
case I915_FORMAT_MOD_Y_TILED_GEN12_MC_CCS:
|
||||
@@ -791,6 +828,9 @@ unsigned int intel_surf_alignment(const struct drm_framebuffer *fb,
|
||||
case I915_FORMAT_MOD_Y_TILED_GEN12_MC_CCS:
|
||||
case I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS:
|
||||
case I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS_CC:
|
||||
case I915_FORMAT_MOD_4_TILED_MTL_MC_CCS:
|
||||
case I915_FORMAT_MOD_4_TILED_MTL_RC_CCS:
|
||||
case I915_FORMAT_MOD_4_TILED_MTL_RC_CCS_CC:
|
||||
return 16 * 1024;
|
||||
case I915_FORMAT_MOD_Y_TILED_CCS:
|
||||
case I915_FORMAT_MOD_Yf_TILED_CCS:
|
||||
|
||||
@@ -243,7 +243,7 @@ int intel_plane_pin_fb(struct intel_plane_state *plane_state)
|
||||
struct i915_vma *vma;
|
||||
bool phys_cursor =
|
||||
plane->id == PLANE_CURSOR &&
|
||||
INTEL_INFO(dev_priv)->display.cursor_needs_physical;
|
||||
DISPLAY_INFO(dev_priv)->cursor_needs_physical;
|
||||
|
||||
if (!intel_fb_uses_dpt(fb)) {
|
||||
vma = intel_pin_and_fence_fb_obj(fb, phys_cursor,
|
||||
|
||||
@@ -44,6 +44,7 @@
|
||||
#include <drm/drm_fourcc.h>
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i915_reg.h"
|
||||
#include "i915_utils.h"
|
||||
#include "i915_vgpu.h"
|
||||
#include "intel_cdclk.h"
|
||||
@@ -55,7 +56,7 @@
|
||||
|
||||
#define for_each_fbc_id(__dev_priv, __fbc_id) \
|
||||
for ((__fbc_id) = INTEL_FBC_A; (__fbc_id) < I915_MAX_FBCS; (__fbc_id)++) \
|
||||
for_each_if(RUNTIME_INFO(__dev_priv)->fbc_mask & BIT(__fbc_id))
|
||||
for_each_if(DISPLAY_RUNTIME_INFO(__dev_priv)->fbc_mask & BIT(__fbc_id))
|
||||
|
||||
#define for_each_intel_fbc(__dev_priv, __fbc, __fbc_id) \
|
||||
for_each_fbc_id((__dev_priv), (__fbc_id)) \
|
||||
@@ -1707,10 +1708,10 @@ void intel_fbc_init(struct drm_i915_private *i915)
|
||||
enum intel_fbc_id fbc_id;
|
||||
|
||||
if (!drm_mm_initialized(&i915->mm.stolen))
|
||||
RUNTIME_INFO(i915)->fbc_mask = 0;
|
||||
DISPLAY_RUNTIME_INFO(i915)->fbc_mask = 0;
|
||||
|
||||
if (need_fbc_vtd_wa(i915))
|
||||
RUNTIME_INFO(i915)->fbc_mask = 0;
|
||||
DISPLAY_RUNTIME_INFO(i915)->fbc_mask = 0;
|
||||
|
||||
i915->params.enable_fbc = intel_sanitize_fbc_option(i915);
|
||||
drm_dbg_kms(&i915->drm, "Sanitized enable_fbc value: %d\n",
|
||||
|
||||
@@ -135,6 +135,9 @@ static int intel_fbdev_mmap(struct fb_info *info, struct vm_area_struct *vma)
|
||||
return i915_gem_fb_mmap(obj, vma);
|
||||
}
|
||||
|
||||
__diag_push();
|
||||
__diag_ignore_all("-Woverride-init", "Allow overriding the default ops");
|
||||
|
||||
static const struct fb_ops intelfb_ops = {
|
||||
.owner = THIS_MODULE,
|
||||
__FB_DEFAULT_DEFERRED_OPS_RDWR(intel_fbdev),
|
||||
@@ -146,6 +149,8 @@ static const struct fb_ops intelfb_ops = {
|
||||
.fb_mmap = intel_fbdev_mmap,
|
||||
};
|
||||
|
||||
__diag_pop();
|
||||
|
||||
static int intelfb_alloc(struct drm_fb_helper *helper,
|
||||
struct drm_fb_helper_surface_size *sizes)
|
||||
{
|
||||
|
||||
@@ -36,7 +36,7 @@ static void assert_fdi_tx(struct drm_i915_private *dev_priv,
|
||||
} else {
|
||||
cur_state = intel_de_read(dev_priv, FDI_TX_CTL(pipe)) & FDI_TX_ENABLE;
|
||||
}
|
||||
I915_STATE_WARN(cur_state != state,
|
||||
I915_STATE_WARN(dev_priv, cur_state != state,
|
||||
"FDI TX state assertion failure (expected %s, current %s)\n",
|
||||
str_on_off(state), str_on_off(cur_state));
|
||||
}
|
||||
@@ -57,7 +57,7 @@ static void assert_fdi_rx(struct drm_i915_private *dev_priv,
|
||||
bool cur_state;
|
||||
|
||||
cur_state = intel_de_read(dev_priv, FDI_RX_CTL(pipe)) & FDI_RX_ENABLE;
|
||||
I915_STATE_WARN(cur_state != state,
|
||||
I915_STATE_WARN(dev_priv, cur_state != state,
|
||||
"FDI RX state assertion failure (expected %s, current %s)\n",
|
||||
str_on_off(state), str_on_off(cur_state));
|
||||
}
|
||||
@@ -86,7 +86,8 @@ void assert_fdi_tx_pll_enabled(struct drm_i915_private *i915,
|
||||
return;
|
||||
|
||||
cur_state = intel_de_read(i915, FDI_TX_CTL(pipe)) & FDI_TX_PLL_ENABLE;
|
||||
I915_STATE_WARN(!cur_state, "FDI TX PLL assertion failure, should be active but is disabled\n");
|
||||
I915_STATE_WARN(i915, !cur_state,
|
||||
"FDI TX PLL assertion failure, should be active but is disabled\n");
|
||||
}
|
||||
|
||||
static void assert_fdi_rx_pll(struct drm_i915_private *i915,
|
||||
@@ -95,7 +96,7 @@ static void assert_fdi_rx_pll(struct drm_i915_private *i915,
|
||||
bool cur_state;
|
||||
|
||||
cur_state = intel_de_read(i915, FDI_RX_CTL(pipe)) & FDI_RX_PLL_ENABLE;
|
||||
I915_STATE_WARN(cur_state != state,
|
||||
I915_STATE_WARN(i915, cur_state != state,
|
||||
"FDI RX PLL assertion failure (expected %s, current %s)\n",
|
||||
str_on_off(state), str_on_off(cur_state));
|
||||
}
|
||||
|
||||
@@ -26,7 +26,9 @@
|
||||
*/
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_de.h"
|
||||
#include "intel_display_irq.h"
|
||||
#include "intel_display_trace.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_fbc.h"
|
||||
|
||||
@@ -991,3 +991,8 @@ void intel_gmbus_teardown(struct drm_i915_private *i915)
|
||||
i915->display.gmbus.bus[pin] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void intel_gmbus_irq_handler(struct drm_i915_private *i915)
|
||||
{
|
||||
wake_up_all(&i915->display.gmbus.wait_queue);
|
||||
}
|
||||
|
||||
@@ -46,4 +46,6 @@ void intel_gmbus_force_bit(struct i2c_adapter *adapter, bool force_bit);
|
||||
bool intel_gmbus_is_forced_bit(struct i2c_adapter *adapter);
|
||||
void intel_gmbus_reset(struct drm_i915_private *dev_priv);
|
||||
|
||||
void intel_gmbus_irq_handler(struct drm_i915_private *i915);
|
||||
|
||||
#endif /* __INTEL_GMBUS_H__ */
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -28,18 +28,20 @@ void intel_hdcp_atomic_check(struct drm_connector *connector,
|
||||
int intel_hdcp_init(struct intel_connector *connector,
|
||||
struct intel_digital_port *dig_port,
|
||||
const struct intel_hdcp_shim *hdcp_shim);
|
||||
int intel_hdcp_enable(struct intel_connector *connector,
|
||||
const struct intel_crtc_state *pipe_config, u8 content_type);
|
||||
int intel_hdcp_enable(struct intel_atomic_state *state,
|
||||
struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *pipe_config,
|
||||
const struct drm_connector_state *conn_state);
|
||||
int intel_hdcp_disable(struct intel_connector *connector);
|
||||
void intel_hdcp_update_pipe(struct intel_atomic_state *state,
|
||||
struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state);
|
||||
bool is_hdcp_supported(struct drm_i915_private *dev_priv, enum port port);
|
||||
bool is_hdcp_supported(struct drm_i915_private *i915, enum port port);
|
||||
bool intel_hdcp_capable(struct intel_connector *connector);
|
||||
bool intel_hdcp2_capable(struct intel_connector *connector);
|
||||
void intel_hdcp_component_init(struct drm_i915_private *dev_priv);
|
||||
void intel_hdcp_component_fini(struct drm_i915_private *dev_priv);
|
||||
void intel_hdcp_component_init(struct drm_i915_private *i915);
|
||||
void intel_hdcp_component_fini(struct drm_i915_private *i915);
|
||||
void intel_hdcp_cleanup(struct intel_connector *connector);
|
||||
void intel_hdcp_handle_cp_irq(struct intel_connector *connector);
|
||||
|
||||
|
||||
@@ -5,11 +5,11 @@
|
||||
|
||||
#include <drm/i915_hdcp_interface.h>
|
||||
|
||||
#include "display/intel_hdcp_gsc.h"
|
||||
#include "gem/i915_gem_region.h"
|
||||
#include "gt/uc/intel_gsc_uc_heci_cmd_submit.h"
|
||||
#include "i915_drv.h"
|
||||
#include "i915_utils.h"
|
||||
#include "intel_hdcp_gsc.h"
|
||||
|
||||
bool intel_hdcp_gsc_cs_required(struct drm_i915_private *i915)
|
||||
{
|
||||
@@ -697,19 +697,19 @@ static void intel_hdcp_gsc_free_message(struct drm_i915_private *i915)
|
||||
|
||||
int intel_hdcp_gsc_init(struct drm_i915_private *i915)
|
||||
{
|
||||
struct i915_hdcp_master *data;
|
||||
struct i915_hdcp_arbiter *data;
|
||||
int ret;
|
||||
|
||||
data = kzalloc(sizeof(struct i915_hdcp_master), GFP_KERNEL);
|
||||
data = kzalloc(sizeof(struct i915_hdcp_arbiter), GFP_KERNEL);
|
||||
if (!data)
|
||||
return -ENOMEM;
|
||||
|
||||
mutex_lock(&i915->display.hdcp.comp_mutex);
|
||||
i915->display.hdcp.master = data;
|
||||
i915->display.hdcp.master->hdcp_dev = i915->drm.dev;
|
||||
i915->display.hdcp.master->ops = &gsc_hdcp_ops;
|
||||
mutex_lock(&i915->display.hdcp.hdcp_mutex);
|
||||
i915->display.hdcp.arbiter = data;
|
||||
i915->display.hdcp.arbiter->hdcp_dev = i915->drm.dev;
|
||||
i915->display.hdcp.arbiter->ops = &gsc_hdcp_ops;
|
||||
ret = intel_hdcp_gsc_hdcp2_init(i915);
|
||||
mutex_unlock(&i915->display.hdcp.comp_mutex);
|
||||
mutex_unlock(&i915->display.hdcp.hdcp_mutex);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -717,7 +717,7 @@ int intel_hdcp_gsc_init(struct drm_i915_private *i915)
|
||||
void intel_hdcp_gsc_fini(struct drm_i915_private *i915)
|
||||
{
|
||||
intel_hdcp_gsc_free_message(i915);
|
||||
kfree(i915->display.hdcp.master);
|
||||
kfree(i915->display.hdcp.arbiter);
|
||||
}
|
||||
|
||||
static int intel_gsc_send_sync(struct drm_i915_private *i915,
|
||||
|
||||
@@ -40,12 +40,13 @@
|
||||
#include <drm/drm_edid.h>
|
||||
#include <drm/intel_lpe_audio.h>
|
||||
|
||||
#include "i915_debugfs.h"
|
||||
#include "g4x_hdmi.h"
|
||||
#include "i915_drv.h"
|
||||
#include "i915_reg.h"
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_audio.h"
|
||||
#include "intel_connector.h"
|
||||
#include "intel_cx0_phy.h"
|
||||
#include "intel_ddi.h"
|
||||
#include "intel_de.h"
|
||||
#include "intel_display_types.h"
|
||||
@@ -58,7 +59,7 @@
|
||||
#include "intel_panel.h"
|
||||
#include "intel_snps_phy.h"
|
||||
|
||||
static struct drm_i915_private *intel_hdmi_to_i915(struct intel_hdmi *intel_hdmi)
|
||||
inline struct drm_i915_private *intel_hdmi_to_i915(struct intel_hdmi *intel_hdmi)
|
||||
{
|
||||
return to_i915(hdmi_to_dig_port(intel_hdmi)->base.base.dev);
|
||||
}
|
||||
@@ -1789,7 +1790,9 @@ static int intel_hdmi_source_max_tmds_clock(struct intel_encoder *encoder)
|
||||
static bool intel_has_hdmi_sink(struct intel_hdmi *hdmi,
|
||||
const struct drm_connector_state *conn_state)
|
||||
{
|
||||
return hdmi->has_hdmi_sink &&
|
||||
struct intel_connector *connector = hdmi->attached_connector;
|
||||
|
||||
return connector->base.display_info.is_hdmi &&
|
||||
READ_ONCE(to_intel_digital_connector_state(conn_state)->force_audio) != HDMI_AUDIO_OFF_DVI;
|
||||
}
|
||||
|
||||
@@ -1865,16 +1868,19 @@ hdmi_port_clock_valid(struct intel_hdmi *hdmi,
|
||||
* FIXME: We will hopefully get an algorithmic way of programming
|
||||
* the MPLLB for HDMI in the future.
|
||||
*/
|
||||
if (IS_DG2(dev_priv))
|
||||
if (DISPLAY_VER(dev_priv) >= 14)
|
||||
return intel_cx0_phy_check_hdmi_link_rate(hdmi, clock);
|
||||
else if (IS_DG2(dev_priv))
|
||||
return intel_snps_phy_check_hdmi_link_rate(clock);
|
||||
|
||||
return MODE_OK;
|
||||
}
|
||||
|
||||
int intel_hdmi_tmds_clock(int clock, int bpc, bool ycbcr420_output)
|
||||
int intel_hdmi_tmds_clock(int clock, int bpc,
|
||||
enum intel_output_format sink_format)
|
||||
{
|
||||
/* YCBCR420 TMDS rate requirement is half the pixel clock */
|
||||
if (ycbcr420_output)
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420)
|
||||
clock /= 2;
|
||||
|
||||
/*
|
||||
@@ -1901,7 +1907,8 @@ static bool intel_hdmi_source_bpc_possible(struct drm_i915_private *i915, int bp
|
||||
}
|
||||
|
||||
static bool intel_hdmi_sink_bpc_possible(struct drm_connector *connector,
|
||||
int bpc, bool has_hdmi_sink, bool ycbcr420_output)
|
||||
int bpc, bool has_hdmi_sink,
|
||||
enum intel_output_format sink_format)
|
||||
{
|
||||
const struct drm_display_info *info = &connector->display_info;
|
||||
const struct drm_hdmi_info *hdmi = &info->hdmi;
|
||||
@@ -1911,7 +1918,7 @@ static bool intel_hdmi_sink_bpc_possible(struct drm_connector *connector,
|
||||
if (!has_hdmi_sink)
|
||||
return false;
|
||||
|
||||
if (ycbcr420_output)
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420)
|
||||
return hdmi->y420_dc_modes & DRM_EDID_YCBCR420_DC_36;
|
||||
else
|
||||
return info->edid_hdmi_rgb444_dc_modes & DRM_EDID_HDMI_DC_36;
|
||||
@@ -1919,7 +1926,7 @@ static bool intel_hdmi_sink_bpc_possible(struct drm_connector *connector,
|
||||
if (!has_hdmi_sink)
|
||||
return false;
|
||||
|
||||
if (ycbcr420_output)
|
||||
if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420)
|
||||
return hdmi->y420_dc_modes & DRM_EDID_YCBCR420_DC_30;
|
||||
else
|
||||
return info->edid_hdmi_rgb444_dc_modes & DRM_EDID_HDMI_DC_30;
|
||||
@@ -1933,7 +1940,8 @@ static bool intel_hdmi_sink_bpc_possible(struct drm_connector *connector,
|
||||
|
||||
static enum drm_mode_status
|
||||
intel_hdmi_mode_clock_valid(struct drm_connector *connector, int clock,
|
||||
bool has_hdmi_sink, bool ycbcr420_output)
|
||||
bool has_hdmi_sink,
|
||||
enum intel_output_format sink_format)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(connector->dev);
|
||||
struct intel_hdmi *hdmi = intel_attached_hdmi(to_intel_connector(connector));
|
||||
@@ -1946,12 +1954,12 @@ intel_hdmi_mode_clock_valid(struct drm_connector *connector, int clock,
|
||||
* least one color depth is accepted.
|
||||
*/
|
||||
for (bpc = 12; bpc >= 8; bpc -= 2) {
|
||||
int tmds_clock = intel_hdmi_tmds_clock(clock, bpc, ycbcr420_output);
|
||||
int tmds_clock = intel_hdmi_tmds_clock(clock, bpc, sink_format);
|
||||
|
||||
if (!intel_hdmi_source_bpc_possible(i915, bpc))
|
||||
continue;
|
||||
|
||||
if (!intel_hdmi_sink_bpc_possible(connector, bpc, has_hdmi_sink, ycbcr420_output))
|
||||
if (!intel_hdmi_sink_bpc_possible(connector, bpc, has_hdmi_sink, sink_format))
|
||||
continue;
|
||||
|
||||
status = hdmi_port_clock_valid(hdmi, tmds_clock, true, has_hdmi_sink);
|
||||
@@ -1976,6 +1984,7 @@ intel_hdmi_mode_valid(struct drm_connector *connector,
|
||||
int max_dotclk = to_i915(connector->dev)->max_dotclk_freq;
|
||||
bool has_hdmi_sink = intel_has_hdmi_sink(hdmi, connector->state);
|
||||
bool ycbcr_420_only;
|
||||
enum intel_output_format sink_format;
|
||||
|
||||
if ((mode->flags & DRM_MODE_FLAG_3D_MASK) == DRM_MODE_FLAG_3D_FRAME_PACKING)
|
||||
clock *= 2;
|
||||
@@ -2000,14 +2009,20 @@ intel_hdmi_mode_valid(struct drm_connector *connector,
|
||||
|
||||
ycbcr_420_only = drm_mode_is_420_only(&connector->display_info, mode);
|
||||
|
||||
status = intel_hdmi_mode_clock_valid(connector, clock, has_hdmi_sink, ycbcr_420_only);
|
||||
if (ycbcr_420_only)
|
||||
sink_format = INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
else
|
||||
sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
|
||||
status = intel_hdmi_mode_clock_valid(connector, clock, has_hdmi_sink, sink_format);
|
||||
if (status != MODE_OK) {
|
||||
if (ycbcr_420_only ||
|
||||
!connector->ycbcr_420_allowed ||
|
||||
!drm_mode_is_420_also(&connector->display_info, mode))
|
||||
return status;
|
||||
|
||||
status = intel_hdmi_mode_clock_valid(connector, clock, has_hdmi_sink, true);
|
||||
sink_format = INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
status = intel_hdmi_mode_clock_valid(connector, clock, has_hdmi_sink, sink_format);
|
||||
if (status != MODE_OK)
|
||||
return status;
|
||||
}
|
||||
@@ -2016,7 +2031,7 @@ intel_hdmi_mode_valid(struct drm_connector *connector,
|
||||
}
|
||||
|
||||
bool intel_hdmi_bpc_possible(const struct intel_crtc_state *crtc_state,
|
||||
int bpc, bool has_hdmi_sink, bool ycbcr420_output)
|
||||
int bpc, bool has_hdmi_sink)
|
||||
{
|
||||
struct drm_atomic_state *state = crtc_state->uapi.state;
|
||||
struct drm_connector_state *connector_state;
|
||||
@@ -2027,7 +2042,8 @@ bool intel_hdmi_bpc_possible(const struct intel_crtc_state *crtc_state,
|
||||
if (connector_state->crtc != crtc_state->uapi.crtc)
|
||||
continue;
|
||||
|
||||
if (!intel_hdmi_sink_bpc_possible(connector, bpc, has_hdmi_sink, ycbcr420_output))
|
||||
if (!intel_hdmi_sink_bpc_possible(connector, bpc, has_hdmi_sink,
|
||||
crtc_state->sink_format))
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -2051,8 +2067,7 @@ static bool hdmi_bpc_possible(const struct intel_crtc_state *crtc_state, int bpc
|
||||
adjusted_mode->crtc_hblank_start) % 8 == 2)
|
||||
return false;
|
||||
|
||||
return intel_hdmi_bpc_possible(crtc_state, bpc, crtc_state->has_hdmi_sink,
|
||||
intel_hdmi_is_ycbcr420(crtc_state));
|
||||
return intel_hdmi_bpc_possible(crtc_state, bpc, crtc_state->has_hdmi_sink);
|
||||
}
|
||||
|
||||
static int intel_hdmi_compute_bpc(struct intel_encoder *encoder,
|
||||
@@ -2060,7 +2075,6 @@ static int intel_hdmi_compute_bpc(struct intel_encoder *encoder,
|
||||
int clock, bool respect_downstream_limits)
|
||||
{
|
||||
struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
|
||||
bool ycbcr420_output = intel_hdmi_is_ycbcr420(crtc_state);
|
||||
int bpc;
|
||||
|
||||
/*
|
||||
@@ -2078,7 +2092,8 @@ static int intel_hdmi_compute_bpc(struct intel_encoder *encoder,
|
||||
bpc = 8;
|
||||
|
||||
for (; bpc >= 8; bpc -= 2) {
|
||||
int tmds_clock = intel_hdmi_tmds_clock(clock, bpc, ycbcr420_output);
|
||||
int tmds_clock = intel_hdmi_tmds_clock(clock, bpc,
|
||||
crtc_state->sink_format);
|
||||
|
||||
if (hdmi_bpc_possible(crtc_state, bpc) &&
|
||||
hdmi_port_clock_valid(intel_hdmi, tmds_clock,
|
||||
@@ -2108,7 +2123,7 @@ static int intel_hdmi_compute_clock(struct intel_encoder *encoder,
|
||||
return bpc;
|
||||
|
||||
crtc_state->port_clock =
|
||||
intel_hdmi_tmds_clock(clock, bpc, intel_hdmi_is_ycbcr420(crtc_state));
|
||||
intel_hdmi_tmds_clock(clock, bpc, crtc_state->sink_format);
|
||||
|
||||
/*
|
||||
* pipe_bpp could already be below 8bpc due to
|
||||
@@ -2156,7 +2171,7 @@ static bool intel_hdmi_has_audio(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state)
|
||||
{
|
||||
struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
|
||||
struct drm_connector *connector = conn_state->connector;
|
||||
const struct intel_digital_connector_state *intel_conn_state =
|
||||
to_intel_digital_connector_state(conn_state);
|
||||
|
||||
@@ -2164,15 +2179,15 @@ static bool intel_hdmi_has_audio(struct intel_encoder *encoder,
|
||||
return false;
|
||||
|
||||
if (intel_conn_state->force_audio == HDMI_AUDIO_AUTO)
|
||||
return intel_hdmi->has_audio;
|
||||
return connector->display_info.has_audio;
|
||||
else
|
||||
return intel_conn_state->force_audio == HDMI_AUDIO_ON;
|
||||
}
|
||||
|
||||
static enum intel_output_format
|
||||
intel_hdmi_output_format(const struct intel_crtc_state *crtc_state,
|
||||
struct intel_connector *connector,
|
||||
bool ycbcr_420_output)
|
||||
intel_hdmi_sink_format(const struct intel_crtc_state *crtc_state,
|
||||
struct intel_connector *connector,
|
||||
bool ycbcr_420_output)
|
||||
{
|
||||
if (!crtc_state->has_hdmi_sink)
|
||||
return INTEL_OUTPUT_FORMAT_RGB;
|
||||
@@ -2183,6 +2198,12 @@ intel_hdmi_output_format(const struct intel_crtc_state *crtc_state,
|
||||
return INTEL_OUTPUT_FORMAT_RGB;
|
||||
}
|
||||
|
||||
static enum intel_output_format
|
||||
intel_hdmi_output_format(const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
return crtc_state->sink_format;
|
||||
}
|
||||
|
||||
static int intel_hdmi_compute_output_format(struct intel_encoder *encoder,
|
||||
struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state,
|
||||
@@ -2195,23 +2216,26 @@ static int intel_hdmi_compute_output_format(struct intel_encoder *encoder,
|
||||
bool ycbcr_420_only = drm_mode_is_420_only(info, adjusted_mode);
|
||||
int ret;
|
||||
|
||||
crtc_state->output_format =
|
||||
intel_hdmi_output_format(crtc_state, connector, ycbcr_420_only);
|
||||
crtc_state->sink_format =
|
||||
intel_hdmi_sink_format(crtc_state, connector, ycbcr_420_only);
|
||||
|
||||
if (ycbcr_420_only && !intel_hdmi_is_ycbcr420(crtc_state)) {
|
||||
if (ycbcr_420_only && crtc_state->sink_format != INTEL_OUTPUT_FORMAT_YCBCR420) {
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"YCbCr 4:2:0 mode but YCbCr 4:2:0 output not possible. Falling back to RGB.\n");
|
||||
crtc_state->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
crtc_state->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
}
|
||||
|
||||
crtc_state->output_format = intel_hdmi_output_format(crtc_state);
|
||||
ret = intel_hdmi_compute_clock(encoder, crtc_state, respect_downstream_limits);
|
||||
if (ret) {
|
||||
if (intel_hdmi_is_ycbcr420(crtc_state) ||
|
||||
if (crtc_state->sink_format == INTEL_OUTPUT_FORMAT_YCBCR420 ||
|
||||
!crtc_state->has_hdmi_sink ||
|
||||
!connector->base.ycbcr_420_allowed ||
|
||||
!drm_mode_is_420_also(info, adjusted_mode))
|
||||
return ret;
|
||||
|
||||
crtc_state->output_format = intel_hdmi_output_format(crtc_state, connector, true);
|
||||
crtc_state->sink_format = INTEL_OUTPUT_FORMAT_YCBCR420;
|
||||
crtc_state->output_format = intel_hdmi_output_format(crtc_state);
|
||||
ret = intel_hdmi_compute_clock(encoder, crtc_state, respect_downstream_limits);
|
||||
}
|
||||
|
||||
@@ -2243,11 +2267,20 @@ static bool source_supports_scrambling(struct intel_encoder *encoder)
|
||||
return intel_hdmi_source_max_tmds_clock(encoder) > 340000;
|
||||
}
|
||||
|
||||
bool intel_hdmi_compute_has_hdmi_sink(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state)
|
||||
{
|
||||
struct intel_hdmi *hdmi = enc_to_intel_hdmi(encoder);
|
||||
|
||||
return intel_has_hdmi_sink(hdmi, conn_state) &&
|
||||
!intel_hdmi_is_cloned(crtc_state);
|
||||
}
|
||||
|
||||
int intel_hdmi_compute_config(struct intel_encoder *encoder,
|
||||
struct intel_crtc_state *pipe_config,
|
||||
struct drm_connector_state *conn_state)
|
||||
{
|
||||
struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(encoder);
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
|
||||
struct drm_connector *connector = conn_state->connector;
|
||||
@@ -2262,9 +2295,6 @@ int intel_hdmi_compute_config(struct intel_encoder *encoder,
|
||||
return -EINVAL;
|
||||
|
||||
pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
pipe_config->has_hdmi_sink =
|
||||
intel_has_hdmi_sink(intel_hdmi, conn_state) &&
|
||||
!intel_hdmi_is_cloned(pipe_config);
|
||||
|
||||
if (pipe_config->has_hdmi_sink)
|
||||
pipe_config->has_infoframe = true;
|
||||
@@ -2357,9 +2387,6 @@ intel_hdmi_unset_edid(struct drm_connector *connector)
|
||||
{
|
||||
struct intel_hdmi *intel_hdmi = intel_attached_hdmi(to_intel_connector(connector));
|
||||
|
||||
intel_hdmi->has_hdmi_sink = false;
|
||||
intel_hdmi->has_audio = false;
|
||||
|
||||
intel_hdmi->dp_dual_mode.type = DRM_DP_DUAL_MODE_NONE;
|
||||
intel_hdmi->dp_dual_mode.max_tmds_clock = 0;
|
||||
|
||||
@@ -2372,7 +2399,7 @@ intel_hdmi_dp_dual_mode_detect(struct drm_connector *connector)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(connector->dev);
|
||||
struct intel_hdmi *hdmi = intel_attached_hdmi(to_intel_connector(connector));
|
||||
enum port port = hdmi_to_dig_port(hdmi)->base.port;
|
||||
struct intel_encoder *encoder = &hdmi_to_dig_port(hdmi)->base;
|
||||
struct i2c_adapter *adapter =
|
||||
intel_gmbus_get_adapter(dev_priv, hdmi->ddc_bus);
|
||||
enum drm_dp_dual_mode_type type = drm_dp_dual_mode_detect(&dev_priv->drm, adapter);
|
||||
@@ -2388,7 +2415,7 @@ intel_hdmi_dp_dual_mode_detect(struct drm_connector *connector)
|
||||
*/
|
||||
if (type == DRM_DP_DUAL_MODE_UNKNOWN) {
|
||||
if (!connector->force &&
|
||||
intel_bios_is_port_dp_dual_mode(dev_priv, port)) {
|
||||
intel_bios_encoder_supports_dp_dual_mode(encoder->devdata)) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"Assuming DP dual mode adaptor presence based on VBT\n");
|
||||
type = DRM_DP_DUAL_MODE_TYPE1_DVI;
|
||||
@@ -2411,7 +2438,7 @@ intel_hdmi_dp_dual_mode_detect(struct drm_connector *connector)
|
||||
|
||||
/* Older VBTs are often buggy and can't be trusted :( Play it safe. */
|
||||
if ((DISPLAY_VER(dev_priv) >= 8 || IS_HASWELL(dev_priv)) &&
|
||||
!intel_bios_is_port_dp_dual_mode(dev_priv, port)) {
|
||||
!intel_bios_encoder_supports_dp_dual_mode(encoder->devdata)) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"Ignoring DP dual mode adaptor max TMDS clock for native HDMI port\n");
|
||||
hdmi->dp_dual_mode.max_tmds_clock = 0;
|
||||
@@ -2451,9 +2478,6 @@ intel_hdmi_set_edid(struct drm_connector *connector)
|
||||
/* FIXME: Get rid of drm_edid_raw() */
|
||||
edid = drm_edid_raw(drm_edid);
|
||||
if (edid && edid->input & DRM_EDID_INPUT_DIGITAL) {
|
||||
intel_hdmi->has_audio = drm_detect_monitor_audio(edid);
|
||||
intel_hdmi->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
|
||||
|
||||
intel_hdmi_dp_dual_mode_detect(connector);
|
||||
|
||||
connected = true;
|
||||
@@ -2597,10 +2621,21 @@ static const struct drm_connector_funcs intel_hdmi_connector_funcs = {
|
||||
.atomic_duplicate_state = intel_digital_connector_duplicate_state,
|
||||
};
|
||||
|
||||
static int intel_hdmi_connector_atomic_check(struct drm_connector *connector,
|
||||
struct drm_atomic_state *state)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(state->dev);
|
||||
|
||||
if (HAS_DDI(i915))
|
||||
return intel_digital_connector_atomic_check(connector, state);
|
||||
else
|
||||
return g4x_hdmi_connector_atomic_check(connector, state);
|
||||
}
|
||||
|
||||
static const struct drm_connector_helper_funcs intel_hdmi_connector_helper_funcs = {
|
||||
.get_modes = intel_hdmi_get_modes,
|
||||
.mode_valid = intel_hdmi_mode_valid,
|
||||
.atomic_check = intel_digital_connector_atomic_check,
|
||||
.atomic_check = intel_hdmi_connector_atomic_check,
|
||||
};
|
||||
|
||||
static void
|
||||
|
||||
@@ -9,6 +9,7 @@
|
||||
#include <linux/types.h>
|
||||
|
||||
enum hdmi_infoframe_type;
|
||||
enum intel_output_format;
|
||||
enum port;
|
||||
struct drm_connector;
|
||||
struct drm_connector_state;
|
||||
@@ -23,6 +24,9 @@ union hdmi_infoframe;
|
||||
|
||||
void intel_hdmi_init_connector(struct intel_digital_port *dig_port,
|
||||
struct intel_connector *intel_connector);
|
||||
bool intel_hdmi_compute_has_hdmi_sink(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state);
|
||||
int intel_hdmi_compute_config(struct intel_encoder *encoder,
|
||||
struct intel_crtc_state *pipe_config,
|
||||
struct drm_connector_state *conn_state);
|
||||
@@ -45,8 +49,8 @@ void intel_read_infoframe(struct intel_encoder *encoder,
|
||||
bool intel_hdmi_limited_color_range(const struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state);
|
||||
bool intel_hdmi_bpc_possible(const struct intel_crtc_state *crtc_state,
|
||||
int bpc, bool has_hdmi_sink, bool ycbcr420_output);
|
||||
int intel_hdmi_tmds_clock(int clock, int bpc, bool ycbcr420_output);
|
||||
int bpc, bool has_hdmi_sink);
|
||||
int intel_hdmi_tmds_clock(int clock, int bpc, enum intel_output_format sink_format);
|
||||
int intel_hdmi_dsc_get_bpp(int src_fractional_bpp, int slice_width,
|
||||
int num_slices, int output_format, bool hdmi_all_bpp,
|
||||
int hdmi_max_chunk_bytes);
|
||||
@@ -54,5 +58,6 @@ int intel_hdmi_dsc_get_num_slices(const struct intel_crtc_state *crtc_state,
|
||||
int src_max_slices, int src_max_slice_width,
|
||||
int hdmi_max_slices, int hdmi_throughput);
|
||||
int intel_hdmi_dsc_get_slice_height(int vactive);
|
||||
struct drm_i915_private *intel_hdmi_to_i915(struct intel_hdmi *intel_hdmi);
|
||||
|
||||
#endif /* __INTEL_HDMI_H__ */
|
||||
|
||||
@@ -27,6 +27,7 @@
|
||||
#include "i915_irq.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_hotplug.h"
|
||||
#include "intel_hotplug_irq.h"
|
||||
|
||||
/**
|
||||
* DOC: Hotplug
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,35 @@
|
||||
/* SPDX-License-Identifier: MIT */
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_HOTPLUG_IRQ_H__
|
||||
#define __INTEL_HOTPLUG_IRQ_H__
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct drm_i915_private;
|
||||
struct intel_encoder;
|
||||
|
||||
u32 i9xx_hpd_irq_ack(struct drm_i915_private *i915);
|
||||
|
||||
void i9xx_hpd_irq_handler(struct drm_i915_private *i915, u32 hotplug_status);
|
||||
void ibx_hpd_irq_handler(struct drm_i915_private *i915, u32 hotplug_trigger);
|
||||
void ilk_hpd_irq_handler(struct drm_i915_private *i915, u32 hotplug_trigger);
|
||||
void gen11_hpd_irq_handler(struct drm_i915_private *i915, u32 iir);
|
||||
void bxt_hpd_irq_handler(struct drm_i915_private *i915, u32 hotplug_trigger);
|
||||
void xelpdp_pica_irq_handler(struct drm_i915_private *i915, u32 iir);
|
||||
void icp_irq_handler(struct drm_i915_private *i915, u32 pch_iir);
|
||||
void spt_irq_handler(struct drm_i915_private *i915, u32 pch_iir);
|
||||
|
||||
void i915_hotplug_interrupt_update_locked(struct drm_i915_private *i915,
|
||||
u32 mask, u32 bits);
|
||||
void i915_hotplug_interrupt_update(struct drm_i915_private *i915,
|
||||
u32 mask, u32 bits);
|
||||
|
||||
void intel_hpd_enable_detection(struct intel_encoder *encoder);
|
||||
void intel_hpd_irq_setup(struct drm_i915_private *i915);
|
||||
|
||||
void intel_hotplug_irq_init(struct drm_i915_private *i915);
|
||||
|
||||
#endif /* __INTEL_HOTPLUG_IRQ_H__ */
|
||||
@@ -15,7 +15,7 @@ void intel_hti_init(struct drm_i915_private *i915)
|
||||
* If the platform has HTI, we need to find out whether it has reserved
|
||||
* any display resources before we create our display outputs.
|
||||
*/
|
||||
if (INTEL_INFO(i915)->display.has_hti)
|
||||
if (DISPLAY_INFO(i915)->has_hti)
|
||||
i915->display.hti.state = intel_de_read(i915, HDPORT_STATE);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,225 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#include <drm/drm_atomic.h>
|
||||
#include <drm/drm_atomic_helper.h>
|
||||
#include <drm/drm_atomic_uapi.h>
|
||||
|
||||
#include "i915_drv.h"
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_load_detect.h"
|
||||
|
||||
/* VESA 640x480x72Hz mode to set on the pipe */
|
||||
static const struct drm_display_mode load_detect_mode = {
|
||||
DRM_MODE("640x480", DRM_MODE_TYPE_DEFAULT, 31500, 640, 664,
|
||||
704, 832, 0, 480, 489, 491, 520, 0, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC),
|
||||
};
|
||||
|
||||
static int intel_modeset_disable_planes(struct drm_atomic_state *state,
|
||||
struct drm_crtc *crtc)
|
||||
{
|
||||
struct drm_plane *plane;
|
||||
struct drm_plane_state *plane_state;
|
||||
int ret, i;
|
||||
|
||||
ret = drm_atomic_add_affected_planes(state, crtc);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
for_each_new_plane_in_state(state, plane, plane_state, i) {
|
||||
if (plane_state->crtc != crtc)
|
||||
continue;
|
||||
|
||||
ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
drm_atomic_set_fb_for_plane(plane_state, NULL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct drm_atomic_state *
|
||||
intel_load_detect_get_pipe(struct drm_connector *connector,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
struct intel_encoder *encoder =
|
||||
intel_attached_encoder(to_intel_connector(connector));
|
||||
struct intel_crtc *possible_crtc;
|
||||
struct intel_crtc *crtc = NULL;
|
||||
struct drm_device *dev = encoder->base.dev;
|
||||
struct drm_i915_private *dev_priv = to_i915(dev);
|
||||
struct drm_mode_config *config = &dev->mode_config;
|
||||
struct drm_atomic_state *state = NULL, *restore_state = NULL;
|
||||
struct drm_connector_state *connector_state;
|
||||
struct intel_crtc_state *crtc_state;
|
||||
int ret;
|
||||
|
||||
drm_dbg_kms(&dev_priv->drm, "[CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
|
||||
connector->base.id, connector->name,
|
||||
encoder->base.base.id, encoder->base.name);
|
||||
|
||||
drm_WARN_ON(dev, !drm_modeset_is_locked(&config->connection_mutex));
|
||||
|
||||
/*
|
||||
* Algorithm gets a little messy:
|
||||
*
|
||||
* - if the connector already has an assigned crtc, use it (but make
|
||||
* sure it's on first)
|
||||
*
|
||||
* - try to find the first unused crtc that can drive this connector,
|
||||
* and use that if we find one
|
||||
*/
|
||||
|
||||
/* See if we already have a CRTC for this connector */
|
||||
if (connector->state->crtc) {
|
||||
crtc = to_intel_crtc(connector->state->crtc);
|
||||
|
||||
ret = drm_modeset_lock(&crtc->base.mutex, ctx);
|
||||
if (ret)
|
||||
goto fail;
|
||||
|
||||
/* Make sure the crtc and connector are running */
|
||||
goto found;
|
||||
}
|
||||
|
||||
/* Find an unused one (if possible) */
|
||||
for_each_intel_crtc(dev, possible_crtc) {
|
||||
if (!(encoder->base.possible_crtcs &
|
||||
drm_crtc_mask(&possible_crtc->base)))
|
||||
continue;
|
||||
|
||||
ret = drm_modeset_lock(&possible_crtc->base.mutex, ctx);
|
||||
if (ret)
|
||||
goto fail;
|
||||
|
||||
if (possible_crtc->base.state->enable) {
|
||||
drm_modeset_unlock(&possible_crtc->base.mutex);
|
||||
continue;
|
||||
}
|
||||
|
||||
crtc = possible_crtc;
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we didn't find an unused CRTC, don't use any.
|
||||
*/
|
||||
if (!crtc) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"no pipe available for load-detect\n");
|
||||
ret = -ENODEV;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
found:
|
||||
state = drm_atomic_state_alloc(dev);
|
||||
restore_state = drm_atomic_state_alloc(dev);
|
||||
if (!state || !restore_state) {
|
||||
ret = -ENOMEM;
|
||||
goto fail;
|
||||
}
|
||||
|
||||
state->acquire_ctx = ctx;
|
||||
to_intel_atomic_state(state)->internal = true;
|
||||
|
||||
restore_state->acquire_ctx = ctx;
|
||||
to_intel_atomic_state(restore_state)->internal = true;
|
||||
|
||||
connector_state = drm_atomic_get_connector_state(state, connector);
|
||||
if (IS_ERR(connector_state)) {
|
||||
ret = PTR_ERR(connector_state);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
ret = drm_atomic_set_crtc_for_connector(connector_state, &crtc->base);
|
||||
if (ret)
|
||||
goto fail;
|
||||
|
||||
crtc_state = intel_atomic_get_crtc_state(state, crtc);
|
||||
if (IS_ERR(crtc_state)) {
|
||||
ret = PTR_ERR(crtc_state);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
crtc_state->uapi.active = true;
|
||||
|
||||
ret = drm_atomic_set_mode_for_crtc(&crtc_state->uapi,
|
||||
&load_detect_mode);
|
||||
if (ret)
|
||||
goto fail;
|
||||
|
||||
ret = intel_modeset_disable_planes(state, &crtc->base);
|
||||
if (ret)
|
||||
goto fail;
|
||||
|
||||
ret = PTR_ERR_OR_ZERO(drm_atomic_get_connector_state(restore_state, connector));
|
||||
if (!ret)
|
||||
ret = PTR_ERR_OR_ZERO(drm_atomic_get_crtc_state(restore_state, &crtc->base));
|
||||
if (!ret)
|
||||
ret = drm_atomic_add_affected_planes(restore_state, &crtc->base);
|
||||
if (ret) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"Failed to create a copy of old state to restore: %i\n",
|
||||
ret);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
ret = drm_atomic_commit(state);
|
||||
if (ret) {
|
||||
drm_dbg_kms(&dev_priv->drm,
|
||||
"failed to set mode on load-detect pipe\n");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
drm_atomic_state_put(state);
|
||||
|
||||
/* let the connector get through one full cycle before testing */
|
||||
intel_crtc_wait_for_next_vblank(crtc);
|
||||
|
||||
return restore_state;
|
||||
|
||||
fail:
|
||||
if (state) {
|
||||
drm_atomic_state_put(state);
|
||||
state = NULL;
|
||||
}
|
||||
if (restore_state) {
|
||||
drm_atomic_state_put(restore_state);
|
||||
restore_state = NULL;
|
||||
}
|
||||
|
||||
if (ret == -EDEADLK)
|
||||
return ERR_PTR(ret);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void intel_load_detect_release_pipe(struct drm_connector *connector,
|
||||
struct drm_atomic_state *state,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
struct intel_encoder *intel_encoder =
|
||||
intel_attached_encoder(to_intel_connector(connector));
|
||||
struct drm_i915_private *i915 = to_i915(intel_encoder->base.dev);
|
||||
struct drm_encoder *encoder = &intel_encoder->base;
|
||||
int ret;
|
||||
|
||||
drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s], [ENCODER:%d:%s]\n",
|
||||
connector->base.id, connector->name,
|
||||
encoder->base.id, encoder->name);
|
||||
|
||||
if (IS_ERR_OR_NULL(state))
|
||||
return;
|
||||
|
||||
ret = drm_atomic_helper_commit_duplicated_state(state, ctx);
|
||||
if (ret)
|
||||
drm_dbg_kms(&i915->drm,
|
||||
"Couldn't release load detect pipe: %i\n", ret);
|
||||
drm_atomic_state_put(state);
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
/* SPDX-License-Identifier: MIT */
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_LOAD_DETECT_H__
|
||||
#define __INTEL_LOAD_DETECT_H__
|
||||
|
||||
struct drm_atomic_state;
|
||||
struct drm_connector;
|
||||
struct drm_modeset_acquire_ctx;
|
||||
|
||||
struct drm_atomic_state *
|
||||
intel_load_detect_get_pipe(struct drm_connector *connector,
|
||||
struct drm_modeset_acquire_ctx *ctx);
|
||||
void intel_load_detect_release_pipe(struct drm_connector *connector,
|
||||
struct drm_atomic_state *old,
|
||||
struct drm_modeset_acquire_ctx *ctx);
|
||||
|
||||
#endif /* __INTEL_LOAD_DETECT_H__ */
|
||||
@@ -150,7 +150,7 @@ static void intel_lvds_get_config(struct intel_encoder *encoder,
|
||||
if (DISPLAY_VER(dev_priv) < 4) {
|
||||
tmp = intel_de_read(dev_priv, PFIT_CONTROL);
|
||||
|
||||
crtc_state->gmch_pfit.control |= tmp & PANEL_8TO6_DITHER_ENABLE;
|
||||
crtc_state->gmch_pfit.control |= tmp & PFIT_PANEL_8TO6_DITHER_ENABLE;
|
||||
}
|
||||
|
||||
crtc_state->hw.adjusted_mode.crtc_clock = crtc_state->port_clock;
|
||||
@@ -437,6 +437,7 @@ static int intel_lvds_compute_config(struct intel_encoder *encoder,
|
||||
crtc_state->pipe_bpp = lvds_bpp;
|
||||
}
|
||||
|
||||
crtc_state->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
crtc_state->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
|
||||
/*
|
||||
@@ -943,17 +944,8 @@ void intel_lvds_init(struct drm_i915_private *i915)
|
||||
*/
|
||||
mutex_lock(&i915->drm.mode_config.mutex);
|
||||
if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC) {
|
||||
const struct edid *edid;
|
||||
|
||||
/* FIXME: Make drm_get_edid_switcheroo() return drm_edid */
|
||||
edid = drm_get_edid_switcheroo(&connector->base,
|
||||
intel_gmbus_get_adapter(i915, pin));
|
||||
if (edid) {
|
||||
drm_edid = drm_edid_alloc(edid, (edid->extensions + 1) * EDID_LENGTH);
|
||||
kfree(edid);
|
||||
} else {
|
||||
drm_edid = NULL;
|
||||
}
|
||||
drm_edid = drm_edid_read_switcheroo(&connector->base,
|
||||
intel_gmbus_get_adapter(i915, pin));
|
||||
} else {
|
||||
drm_edid = drm_edid_read_ddc(&connector->base,
|
||||
intel_gmbus_get_adapter(i915, pin));
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#include <drm/drm_modeset_lock.h>
|
||||
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_modeset_lock.h"
|
||||
|
||||
void _intel_modeset_lock_begin(struct drm_modeset_acquire_ctx *ctx,
|
||||
struct intel_atomic_state *state,
|
||||
unsigned int flags, int *ret)
|
||||
{
|
||||
drm_modeset_acquire_init(ctx, flags);
|
||||
|
||||
if (state)
|
||||
state->base.acquire_ctx = ctx;
|
||||
|
||||
*ret = -EDEADLK;
|
||||
}
|
||||
|
||||
bool _intel_modeset_lock_loop(int *ret)
|
||||
{
|
||||
if (*ret == -EDEADLK) {
|
||||
*ret = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void _intel_modeset_lock_end(struct drm_modeset_acquire_ctx *ctx,
|
||||
struct intel_atomic_state *state,
|
||||
int *ret)
|
||||
{
|
||||
if (*ret == -EDEADLK) {
|
||||
if (state)
|
||||
drm_atomic_state_clear(&state->base);
|
||||
|
||||
*ret = drm_modeset_backoff(ctx);
|
||||
if (*ret == 0) {
|
||||
*ret = -EDEADLK;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
drm_modeset_drop_locks(ctx);
|
||||
drm_modeset_acquire_fini(ctx);
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
/* SPDX-License-Identifier: MIT */
|
||||
/*
|
||||
* Copyright © 2023 Intel Corporation
|
||||
*/
|
||||
|
||||
#ifndef __INTEL_MODESET_LOCK_H__
|
||||
#define __INTEL_MODESET_LOCK_H__
|
||||
|
||||
#include <linux/types.h>
|
||||
|
||||
struct drm_modeset_acquire_ctx;
|
||||
struct intel_atomic_state;
|
||||
|
||||
void _intel_modeset_lock_begin(struct drm_modeset_acquire_ctx *ctx,
|
||||
struct intel_atomic_state *state,
|
||||
unsigned int flags,
|
||||
int *ret);
|
||||
bool _intel_modeset_lock_loop(int *ret);
|
||||
void _intel_modeset_lock_end(struct drm_modeset_acquire_ctx *ctx,
|
||||
struct intel_atomic_state *state,
|
||||
int *ret);
|
||||
|
||||
/*
|
||||
* Note that one must always use "continue" rather than
|
||||
* "break" or "return" to handle errors within the
|
||||
* intel_modeset_lock_ctx_retry() block.
|
||||
*/
|
||||
#define intel_modeset_lock_ctx_retry(ctx, state, flags, ret) \
|
||||
for (_intel_modeset_lock_begin((ctx), (state), (flags), &(ret)); \
|
||||
_intel_modeset_lock_loop(&(ret)); \
|
||||
_intel_modeset_lock_end((ctx), (state), &(ret)))
|
||||
|
||||
#endif /* __INTEL_MODESET_LOCK_H__ */
|
||||
@@ -26,28 +26,21 @@
|
||||
#include "intel_fifo_underrun.h"
|
||||
#include "intel_modeset_setup.h"
|
||||
#include "intel_pch_display.h"
|
||||
#include "intel_tc.h"
|
||||
#include "intel_vblank.h"
|
||||
#include "intel_wm.h"
|
||||
#include "skl_watermark.h"
|
||||
|
||||
static void intel_crtc_disable_noatomic(struct intel_crtc *crtc,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
static void intel_crtc_disable_noatomic_begin(struct intel_crtc *crtc,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
struct intel_encoder *encoder;
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
struct intel_bw_state *bw_state =
|
||||
to_intel_bw_state(i915->display.bw.obj.state);
|
||||
struct intel_cdclk_state *cdclk_state =
|
||||
to_intel_cdclk_state(i915->display.cdclk.obj.state);
|
||||
struct intel_dbuf_state *dbuf_state =
|
||||
to_intel_dbuf_state(i915->display.dbuf.obj.state);
|
||||
struct intel_crtc_state *crtc_state =
|
||||
to_intel_crtc_state(crtc->base.state);
|
||||
struct intel_plane *plane;
|
||||
struct drm_atomic_state *state;
|
||||
struct intel_crtc_state *temp_crtc_state;
|
||||
struct intel_crtc *temp_crtc;
|
||||
enum pipe pipe = crtc->pipe;
|
||||
int ret;
|
||||
|
||||
if (!crtc_state->hw.active)
|
||||
return;
|
||||
@@ -69,12 +62,20 @@ static void intel_crtc_disable_noatomic(struct intel_crtc *crtc,
|
||||
}
|
||||
|
||||
state->acquire_ctx = ctx;
|
||||
to_intel_atomic_state(state)->internal = true;
|
||||
|
||||
/* Everything's already locked, -EDEADLK can't happen. */
|
||||
temp_crtc_state = intel_atomic_get_crtc_state(state, crtc);
|
||||
ret = drm_atomic_add_affected_connectors(state, &crtc->base);
|
||||
for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc,
|
||||
BIT(pipe) |
|
||||
intel_crtc_bigjoiner_slave_pipes(crtc_state)) {
|
||||
struct intel_crtc_state *temp_crtc_state =
|
||||
intel_atomic_get_crtc_state(state, temp_crtc);
|
||||
int ret;
|
||||
|
||||
drm_WARN_ON(&i915->drm, IS_ERR(temp_crtc_state) || ret);
|
||||
ret = drm_atomic_add_affected_connectors(state, &temp_crtc->base);
|
||||
|
||||
drm_WARN_ON(&i915->drm, IS_ERR(temp_crtc_state) || ret);
|
||||
}
|
||||
|
||||
i915->display.funcs.display->crtc_disable(to_intel_atomic_state(state), crtc);
|
||||
|
||||
@@ -87,16 +88,78 @@ static void intel_crtc_disable_noatomic(struct intel_crtc *crtc,
|
||||
crtc->active = false;
|
||||
crtc->base.enabled = false;
|
||||
|
||||
drm_WARN_ON(&i915->drm,
|
||||
drm_atomic_set_mode_for_crtc(&crtc_state->uapi, NULL) < 0);
|
||||
crtc_state->uapi.active = false;
|
||||
crtc_state->uapi.connector_mask = 0;
|
||||
crtc_state->uapi.encoder_mask = 0;
|
||||
intel_crtc_free_hw_state(crtc_state);
|
||||
memset(&crtc_state->hw, 0, sizeof(crtc_state->hw));
|
||||
if (crtc_state->shared_dpll)
|
||||
intel_unreference_shared_dpll_crtc(crtc,
|
||||
crtc_state->shared_dpll,
|
||||
&crtc_state->shared_dpll->state);
|
||||
}
|
||||
|
||||
for_each_encoder_on_crtc(&i915->drm, &crtc->base, encoder)
|
||||
static void set_encoder_for_connector(struct intel_connector *connector,
|
||||
struct intel_encoder *encoder)
|
||||
{
|
||||
struct drm_connector_state *conn_state = connector->base.state;
|
||||
|
||||
if (conn_state->crtc)
|
||||
drm_connector_put(&connector->base);
|
||||
|
||||
if (encoder) {
|
||||
conn_state->best_encoder = &encoder->base;
|
||||
conn_state->crtc = encoder->base.crtc;
|
||||
drm_connector_get(&connector->base);
|
||||
} else {
|
||||
conn_state->best_encoder = NULL;
|
||||
conn_state->crtc = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static void reset_encoder_connector_state(struct intel_encoder *encoder)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
struct intel_connector *connector;
|
||||
struct drm_connector_list_iter conn_iter;
|
||||
|
||||
drm_connector_list_iter_begin(&i915->drm, &conn_iter);
|
||||
for_each_intel_connector_iter(connector, &conn_iter) {
|
||||
if (connector->base.encoder != &encoder->base)
|
||||
continue;
|
||||
|
||||
set_encoder_for_connector(connector, NULL);
|
||||
|
||||
connector->base.dpms = DRM_MODE_DPMS_OFF;
|
||||
connector->base.encoder = NULL;
|
||||
}
|
||||
drm_connector_list_iter_end(&conn_iter);
|
||||
}
|
||||
|
||||
static void reset_crtc_encoder_state(struct intel_crtc *crtc)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
struct intel_encoder *encoder;
|
||||
|
||||
for_each_encoder_on_crtc(&i915->drm, &crtc->base, encoder) {
|
||||
reset_encoder_connector_state(encoder);
|
||||
encoder->base.crtc = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static void intel_crtc_disable_noatomic_complete(struct intel_crtc *crtc)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
struct intel_bw_state *bw_state =
|
||||
to_intel_bw_state(i915->display.bw.obj.state);
|
||||
struct intel_cdclk_state *cdclk_state =
|
||||
to_intel_cdclk_state(i915->display.cdclk.obj.state);
|
||||
struct intel_dbuf_state *dbuf_state =
|
||||
to_intel_dbuf_state(i915->display.dbuf.obj.state);
|
||||
struct intel_crtc_state *crtc_state =
|
||||
to_intel_crtc_state(crtc->base.state);
|
||||
enum pipe pipe = crtc->pipe;
|
||||
|
||||
__drm_atomic_helper_crtc_destroy_state(&crtc_state->uapi);
|
||||
intel_crtc_free_hw_state(crtc_state);
|
||||
intel_crtc_state_reset(crtc_state, crtc);
|
||||
|
||||
reset_crtc_encoder_state(crtc);
|
||||
|
||||
intel_fbc_disable(crtc);
|
||||
intel_update_watermarks(i915);
|
||||
@@ -113,6 +176,118 @@ static void intel_crtc_disable_noatomic(struct intel_crtc *crtc,
|
||||
bw_state->num_active_planes[pipe] = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return all the pipes using a transcoder in @transcoder_mask.
|
||||
* For bigjoiner configs return only the bigjoiner master.
|
||||
*/
|
||||
static u8 get_transcoder_pipes(struct drm_i915_private *i915,
|
||||
u8 transcoder_mask)
|
||||
{
|
||||
struct intel_crtc *temp_crtc;
|
||||
u8 pipes = 0;
|
||||
|
||||
for_each_intel_crtc(&i915->drm, temp_crtc) {
|
||||
struct intel_crtc_state *temp_crtc_state =
|
||||
to_intel_crtc_state(temp_crtc->base.state);
|
||||
|
||||
if (temp_crtc_state->cpu_transcoder == INVALID_TRANSCODER)
|
||||
continue;
|
||||
|
||||
if (intel_crtc_is_bigjoiner_slave(temp_crtc_state))
|
||||
continue;
|
||||
|
||||
if (transcoder_mask & BIT(temp_crtc_state->cpu_transcoder))
|
||||
pipes |= BIT(temp_crtc->pipe);
|
||||
}
|
||||
|
||||
return pipes;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the port sync master and slave pipes linked to @crtc.
|
||||
* For bigjoiner configs return only the bigjoiner master pipes.
|
||||
*/
|
||||
static void get_portsync_pipes(struct intel_crtc *crtc,
|
||||
u8 *master_pipe_mask, u8 *slave_pipes_mask)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
struct intel_crtc_state *crtc_state =
|
||||
to_intel_crtc_state(crtc->base.state);
|
||||
struct intel_crtc *master_crtc;
|
||||
struct intel_crtc_state *master_crtc_state;
|
||||
enum transcoder master_transcoder;
|
||||
|
||||
if (!is_trans_port_sync_mode(crtc_state)) {
|
||||
*master_pipe_mask = BIT(crtc->pipe);
|
||||
*slave_pipes_mask = 0;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (is_trans_port_sync_master(crtc_state))
|
||||
master_transcoder = crtc_state->cpu_transcoder;
|
||||
else
|
||||
master_transcoder = crtc_state->master_transcoder;
|
||||
|
||||
*master_pipe_mask = get_transcoder_pipes(i915, BIT(master_transcoder));
|
||||
drm_WARN_ON(&i915->drm, !is_power_of_2(*master_pipe_mask));
|
||||
|
||||
master_crtc = intel_crtc_for_pipe(i915, ffs(*master_pipe_mask) - 1);
|
||||
master_crtc_state = to_intel_crtc_state(master_crtc->base.state);
|
||||
*slave_pipes_mask = get_transcoder_pipes(i915, master_crtc_state->sync_mode_slaves_mask);
|
||||
}
|
||||
|
||||
static u8 get_bigjoiner_slave_pipes(struct drm_i915_private *i915, u8 master_pipes_mask)
|
||||
{
|
||||
struct intel_crtc *master_crtc;
|
||||
u8 pipes = 0;
|
||||
|
||||
for_each_intel_crtc_in_pipe_mask(&i915->drm, master_crtc, master_pipes_mask) {
|
||||
struct intel_crtc_state *master_crtc_state =
|
||||
to_intel_crtc_state(master_crtc->base.state);
|
||||
|
||||
pipes |= intel_crtc_bigjoiner_slave_pipes(master_crtc_state);
|
||||
}
|
||||
|
||||
return pipes;
|
||||
}
|
||||
|
||||
static void intel_crtc_disable_noatomic(struct intel_crtc *crtc,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
u8 portsync_master_mask;
|
||||
u8 portsync_slaves_mask;
|
||||
u8 bigjoiner_slaves_mask;
|
||||
struct intel_crtc *temp_crtc;
|
||||
|
||||
/* TODO: Add support for MST */
|
||||
get_portsync_pipes(crtc, &portsync_master_mask, &portsync_slaves_mask);
|
||||
bigjoiner_slaves_mask = get_bigjoiner_slave_pipes(i915,
|
||||
portsync_master_mask |
|
||||
portsync_slaves_mask);
|
||||
|
||||
drm_WARN_ON(&i915->drm,
|
||||
portsync_master_mask & portsync_slaves_mask ||
|
||||
portsync_master_mask & bigjoiner_slaves_mask ||
|
||||
portsync_slaves_mask & bigjoiner_slaves_mask);
|
||||
|
||||
for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, bigjoiner_slaves_mask)
|
||||
intel_crtc_disable_noatomic_begin(temp_crtc, ctx);
|
||||
|
||||
for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, portsync_slaves_mask)
|
||||
intel_crtc_disable_noatomic_begin(temp_crtc, ctx);
|
||||
|
||||
for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc, portsync_master_mask)
|
||||
intel_crtc_disable_noatomic_begin(temp_crtc, ctx);
|
||||
|
||||
for_each_intel_crtc_in_pipe_mask(&i915->drm, temp_crtc,
|
||||
bigjoiner_slaves_mask |
|
||||
portsync_slaves_mask |
|
||||
portsync_master_mask)
|
||||
intel_crtc_disable_noatomic_complete(temp_crtc);
|
||||
}
|
||||
|
||||
static void intel_modeset_update_connector_atomic_state(struct drm_i915_private *i915)
|
||||
{
|
||||
struct intel_connector *connector;
|
||||
@@ -124,8 +299,7 @@ static void intel_modeset_update_connector_atomic_state(struct drm_i915_private
|
||||
struct intel_encoder *encoder =
|
||||
to_intel_encoder(connector->base.encoder);
|
||||
|
||||
if (conn_state->crtc)
|
||||
drm_connector_put(&connector->base);
|
||||
set_encoder_for_connector(connector, encoder);
|
||||
|
||||
if (encoder) {
|
||||
struct intel_crtc *crtc =
|
||||
@@ -133,14 +307,7 @@ static void intel_modeset_update_connector_atomic_state(struct drm_i915_private
|
||||
const struct intel_crtc_state *crtc_state =
|
||||
to_intel_crtc_state(crtc->base.state);
|
||||
|
||||
conn_state->best_encoder = &encoder->base;
|
||||
conn_state->crtc = &crtc->base;
|
||||
conn_state->max_bpc = (crtc_state->pipe_bpp ?: 24) / 3;
|
||||
|
||||
drm_connector_get(&connector->base);
|
||||
} else {
|
||||
conn_state->best_encoder = NULL;
|
||||
conn_state->crtc = NULL;
|
||||
}
|
||||
}
|
||||
drm_connector_list_iter_end(&conn_iter);
|
||||
@@ -213,6 +380,21 @@ static bool intel_crtc_has_encoders(struct intel_crtc *crtc)
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool intel_crtc_needs_link_reset(struct intel_crtc *crtc)
|
||||
{
|
||||
struct drm_device *dev = crtc->base.dev;
|
||||
struct intel_encoder *encoder;
|
||||
|
||||
for_each_encoder_on_crtc(dev, &crtc->base, encoder) {
|
||||
struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
|
||||
|
||||
if (dig_port && intel_tc_port_link_needs_reset(dig_port))
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static struct intel_connector *intel_encoder_find_connector(struct intel_encoder *encoder)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(encoder->base.dev);
|
||||
@@ -255,11 +437,12 @@ static void intel_sanitize_fifo_underrun_reporting(const struct intel_crtc_state
|
||||
!HAS_GMCH(i915));
|
||||
}
|
||||
|
||||
static void intel_sanitize_crtc(struct intel_crtc *crtc,
|
||||
static bool intel_sanitize_crtc(struct intel_crtc *crtc,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
struct drm_i915_private *i915 = to_i915(crtc->base.dev);
|
||||
struct intel_crtc_state *crtc_state = to_intel_crtc_state(crtc->base.state);
|
||||
bool needs_link_reset;
|
||||
|
||||
if (crtc_state->hw.active) {
|
||||
struct intel_plane *plane;
|
||||
@@ -279,13 +462,67 @@ static void intel_sanitize_crtc(struct intel_crtc *crtc,
|
||||
intel_color_commit_arm(crtc_state);
|
||||
}
|
||||
|
||||
if (!crtc_state->hw.active ||
|
||||
intel_crtc_is_bigjoiner_slave(crtc_state))
|
||||
return false;
|
||||
|
||||
needs_link_reset = intel_crtc_needs_link_reset(crtc);
|
||||
|
||||
/*
|
||||
* Adjust the state of the output pipe according to whether we have
|
||||
* active connectors/encoders.
|
||||
*/
|
||||
if (crtc_state->hw.active && !intel_crtc_has_encoders(crtc) &&
|
||||
!intel_crtc_is_bigjoiner_slave(crtc_state))
|
||||
intel_crtc_disable_noatomic(crtc, ctx);
|
||||
if (!needs_link_reset && intel_crtc_has_encoders(crtc))
|
||||
return false;
|
||||
|
||||
intel_crtc_disable_noatomic(crtc, ctx);
|
||||
|
||||
/*
|
||||
* The HPD state on other active/disconnected TC ports may be stuck in
|
||||
* the connected state until this port is disabled and a ~10ms delay has
|
||||
* passed, wait here for that so that sanitizing other CRTCs will see the
|
||||
* up-to-date HPD state.
|
||||
*/
|
||||
if (needs_link_reset)
|
||||
msleep(20);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void intel_sanitize_all_crtcs(struct drm_i915_private *i915,
|
||||
struct drm_modeset_acquire_ctx *ctx)
|
||||
{
|
||||
struct intel_crtc *crtc;
|
||||
u32 crtcs_forced_off = 0;
|
||||
|
||||
/*
|
||||
* An active and disconnected TypeC port prevents the HPD live state
|
||||
* to get updated on other active/disconnected TypeC ports, so after
|
||||
* a port gets disabled the CRTCs using other TypeC ports must be
|
||||
* rechecked wrt. their link status.
|
||||
*/
|
||||
for (;;) {
|
||||
u32 old_mask = crtcs_forced_off;
|
||||
|
||||
for_each_intel_crtc(&i915->drm, crtc) {
|
||||
u32 crtc_mask = drm_crtc_mask(&crtc->base);
|
||||
|
||||
if (crtcs_forced_off & crtc_mask)
|
||||
continue;
|
||||
|
||||
if (intel_sanitize_crtc(crtc, ctx))
|
||||
crtcs_forced_off |= crtc_mask;
|
||||
}
|
||||
if (crtcs_forced_off == old_mask)
|
||||
break;
|
||||
}
|
||||
|
||||
for_each_intel_crtc(&i915->drm, crtc) {
|
||||
struct intel_crtc_state *crtc_state =
|
||||
to_intel_crtc_state(crtc->base.state);
|
||||
|
||||
intel_crtc_state_dump(crtc_state, NULL, "setup_hw_state");
|
||||
}
|
||||
}
|
||||
|
||||
static bool has_bogus_dpll_config(const struct intel_crtc_state *crtc_state)
|
||||
@@ -559,7 +796,8 @@ static void intel_modeset_readout_hw_state(struct drm_i915_private *i915)
|
||||
*/
|
||||
crtc_state->inherited = true;
|
||||
|
||||
intel_crtc_update_active_timings(crtc_state);
|
||||
intel_crtc_update_active_timings(crtc_state,
|
||||
crtc_state->vrr.enable);
|
||||
|
||||
intel_crtc_copy_hw_to_uapi_state(crtc_state);
|
||||
}
|
||||
@@ -698,16 +936,14 @@ void intel_modeset_setup_hw_state(struct drm_i915_private *i915,
|
||||
for_each_intel_encoder(&i915->drm, encoder)
|
||||
intel_sanitize_encoder(encoder);
|
||||
|
||||
for_each_intel_crtc(&i915->drm, crtc) {
|
||||
struct intel_crtc_state *crtc_state =
|
||||
to_intel_crtc_state(crtc->base.state);
|
||||
|
||||
intel_sanitize_crtc(crtc, ctx);
|
||||
intel_crtc_state_dump(crtc_state, NULL, "setup_hw_state");
|
||||
}
|
||||
|
||||
/*
|
||||
* Sanitizing CRTCs needs their connector atomic state to be
|
||||
* up-to-date, so ensure that already here.
|
||||
*/
|
||||
intel_modeset_update_connector_atomic_state(i915);
|
||||
|
||||
intel_sanitize_all_crtcs(i915, ctx);
|
||||
|
||||
intel_dpll_sanitize_state(i915);
|
||||
|
||||
intel_wm_get_hw_state(i915);
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
#include "intel_atomic.h"
|
||||
#include "intel_crtc.h"
|
||||
#include "intel_crtc_state_dump.h"
|
||||
#include "intel_cx0_phy.h"
|
||||
#include "intel_display.h"
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_fdi.h"
|
||||
@@ -34,27 +35,28 @@ static void intel_connector_verify_state(struct intel_crtc_state *crtc_state,
|
||||
if (connector->get_hw_state(connector)) {
|
||||
struct intel_encoder *encoder = intel_attached_encoder(connector);
|
||||
|
||||
I915_STATE_WARN(!crtc_state,
|
||||
I915_STATE_WARN(i915, !crtc_state,
|
||||
"connector enabled without attached crtc\n");
|
||||
|
||||
if (!crtc_state)
|
||||
return;
|
||||
|
||||
I915_STATE_WARN(!crtc_state->hw.active,
|
||||
I915_STATE_WARN(i915, !crtc_state->hw.active,
|
||||
"connector is active, but attached crtc isn't\n");
|
||||
|
||||
if (!encoder || encoder->type == INTEL_OUTPUT_DP_MST)
|
||||
return;
|
||||
|
||||
I915_STATE_WARN(conn_state->best_encoder != &encoder->base,
|
||||
I915_STATE_WARN(i915,
|
||||
conn_state->best_encoder != &encoder->base,
|
||||
"atomic encoder doesn't match attached encoder\n");
|
||||
|
||||
I915_STATE_WARN(conn_state->crtc != encoder->base.crtc,
|
||||
I915_STATE_WARN(i915, conn_state->crtc != encoder->base.crtc,
|
||||
"attached encoder crtc differs from connector crtc\n");
|
||||
} else {
|
||||
I915_STATE_WARN(crtc_state && crtc_state->hw.active,
|
||||
I915_STATE_WARN(i915, crtc_state && crtc_state->hw.active,
|
||||
"attached crtc is active, but connector isn't\n");
|
||||
I915_STATE_WARN(!crtc_state && conn_state->best_encoder,
|
||||
I915_STATE_WARN(i915, !crtc_state && conn_state->best_encoder,
|
||||
"best encoder set without crtc!\n");
|
||||
}
|
||||
}
|
||||
@@ -79,7 +81,7 @@ verify_connector_state(struct intel_atomic_state *state,
|
||||
|
||||
intel_connector_verify_state(crtc_state, new_conn_state);
|
||||
|
||||
I915_STATE_WARN(new_conn_state->best_encoder != encoder,
|
||||
I915_STATE_WARN(to_i915(connector->dev), new_conn_state->best_encoder != encoder,
|
||||
"connector's atomic encoder doesn't match legacy encoder\n");
|
||||
}
|
||||
}
|
||||
@@ -130,15 +132,15 @@ verify_encoder_state(struct drm_i915_private *dev_priv, struct intel_atomic_stat
|
||||
found = true;
|
||||
enabled = true;
|
||||
|
||||
I915_STATE_WARN(new_conn_state->crtc !=
|
||||
encoder->base.crtc,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
new_conn_state->crtc != encoder->base.crtc,
|
||||
"connector's crtc doesn't match encoder crtc\n");
|
||||
}
|
||||
|
||||
if (!found)
|
||||
continue;
|
||||
|
||||
I915_STATE_WARN(!!encoder->base.crtc != enabled,
|
||||
I915_STATE_WARN(dev_priv, !!encoder->base.crtc != enabled,
|
||||
"encoder's enabled state mismatch (expected %i, found %i)\n",
|
||||
!!encoder->base.crtc, enabled);
|
||||
|
||||
@@ -146,7 +148,7 @@ verify_encoder_state(struct drm_i915_private *dev_priv, struct intel_atomic_stat
|
||||
bool active;
|
||||
|
||||
active = encoder->get_hw_state(encoder, &pipe);
|
||||
I915_STATE_WARN(active,
|
||||
I915_STATE_WARN(dev_priv, active,
|
||||
"encoder detached but still enabled on pipe %c.\n",
|
||||
pipe_name(pipe));
|
||||
}
|
||||
@@ -181,11 +183,12 @@ verify_crtc_state(struct intel_crtc *crtc,
|
||||
if (IS_I830(dev_priv) && pipe_config->hw.active)
|
||||
pipe_config->hw.active = new_crtc_state->hw.active;
|
||||
|
||||
I915_STATE_WARN(new_crtc_state->hw.active != pipe_config->hw.active,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
new_crtc_state->hw.active != pipe_config->hw.active,
|
||||
"crtc active state doesn't match with hw state (expected %i, found %i)\n",
|
||||
new_crtc_state->hw.active, pipe_config->hw.active);
|
||||
|
||||
I915_STATE_WARN(crtc->active != new_crtc_state->hw.active,
|
||||
I915_STATE_WARN(dev_priv, crtc->active != new_crtc_state->hw.active,
|
||||
"transitional active state does not match atomic hw state (expected %i, found %i)\n",
|
||||
new_crtc_state->hw.active, crtc->active);
|
||||
|
||||
@@ -196,12 +199,12 @@ verify_crtc_state(struct intel_crtc *crtc,
|
||||
bool active;
|
||||
|
||||
active = encoder->get_hw_state(encoder, &pipe);
|
||||
I915_STATE_WARN(active != new_crtc_state->hw.active,
|
||||
I915_STATE_WARN(dev_priv, active != new_crtc_state->hw.active,
|
||||
"[ENCODER:%i] active %i with crtc active %i\n",
|
||||
encoder->base.base.id, active,
|
||||
new_crtc_state->hw.active);
|
||||
|
||||
I915_STATE_WARN(active && master_crtc->pipe != pipe,
|
||||
I915_STATE_WARN(dev_priv, active && master_crtc->pipe != pipe,
|
||||
"Encoder connected to wrong pipe %c\n",
|
||||
pipe_name(pipe));
|
||||
|
||||
@@ -216,7 +219,7 @@ verify_crtc_state(struct intel_crtc *crtc,
|
||||
|
||||
if (!intel_pipe_config_compare(new_crtc_state,
|
||||
pipe_config, false)) {
|
||||
I915_STATE_WARN(1, "pipe state doesn't match!\n");
|
||||
I915_STATE_WARN(dev_priv, 1, "pipe state doesn't match!\n");
|
||||
intel_crtc_state_dump(pipe_config, NULL, "hw state");
|
||||
intel_crtc_state_dump(new_crtc_state, NULL, "sw state");
|
||||
}
|
||||
@@ -236,6 +239,7 @@ void intel_modeset_verify_crtc(struct intel_crtc *crtc,
|
||||
verify_crtc_state(crtc, old_crtc_state, new_crtc_state);
|
||||
intel_shared_dpll_state_verify(crtc, old_crtc_state, new_crtc_state);
|
||||
intel_mpllb_state_verify(state, new_crtc_state);
|
||||
intel_c10pll_state_verify(state, new_crtc_state);
|
||||
}
|
||||
|
||||
void intel_modeset_verify_disabled(struct drm_i915_private *dev_priv,
|
||||
|
||||
@@ -935,21 +935,25 @@ static int check_overlay_possible_on_crtc(struct intel_overlay *overlay,
|
||||
static void update_pfit_vscale_ratio(struct intel_overlay *overlay)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = overlay->i915;
|
||||
u32 pfit_control = intel_de_read(dev_priv, PFIT_CONTROL);
|
||||
u32 ratio;
|
||||
|
||||
/* XXX: This is not the same logic as in the xorg driver, but more in
|
||||
* line with the intel documentation for the i965
|
||||
*/
|
||||
if (DISPLAY_VER(dev_priv) >= 4) {
|
||||
u32 tmp = intel_de_read(dev_priv, PFIT_PGM_RATIOS);
|
||||
|
||||
/* on i965 use the PGM reg to read out the autoscaler values */
|
||||
ratio = intel_de_read(dev_priv, PFIT_PGM_RATIOS) >> PFIT_VERT_SCALE_SHIFT_965;
|
||||
ratio = REG_FIELD_GET(PFIT_VERT_SCALE_MASK_965, tmp);
|
||||
} else {
|
||||
if (pfit_control & VERT_AUTO_SCALE)
|
||||
ratio = intel_de_read(dev_priv, PFIT_AUTO_RATIOS);
|
||||
u32 tmp;
|
||||
|
||||
if (intel_de_read(dev_priv, PFIT_CONTROL) & PFIT_VERT_AUTO_SCALE)
|
||||
tmp = intel_de_read(dev_priv, PFIT_AUTO_RATIOS);
|
||||
else
|
||||
ratio = intel_de_read(dev_priv, PFIT_PGM_RATIOS);
|
||||
ratio >>= PFIT_VERT_SCALE_SHIFT;
|
||||
tmp = intel_de_read(dev_priv, PFIT_PGM_RATIOS);
|
||||
|
||||
ratio = REG_FIELD_GET(PFIT_VERT_SCALE_MASK, tmp);
|
||||
}
|
||||
|
||||
overlay->pfit_vscale_ratio = ratio;
|
||||
|
||||
@@ -42,6 +42,7 @@
|
||||
#include "intel_lvds_regs.h"
|
||||
#include "intel_panel.h"
|
||||
#include "intel_quirks.h"
|
||||
#include "intel_vrr.h"
|
||||
|
||||
bool intel_panel_use_ssc(struct drm_i915_private *i915)
|
||||
{
|
||||
@@ -58,6 +59,38 @@ intel_panel_preferred_fixed_mode(struct intel_connector *connector)
|
||||
struct drm_display_mode, head);
|
||||
}
|
||||
|
||||
static bool is_in_vrr_range(struct intel_connector *connector, int vrefresh)
|
||||
{
|
||||
const struct drm_display_info *info = &connector->base.display_info;
|
||||
|
||||
return intel_vrr_is_capable(connector) &&
|
||||
vrefresh >= info->monitor_range.min_vfreq &&
|
||||
vrefresh <= info->monitor_range.max_vfreq;
|
||||
}
|
||||
|
||||
static bool is_best_fixed_mode(struct intel_connector *connector,
|
||||
int vrefresh, int fixed_mode_vrefresh,
|
||||
const struct drm_display_mode *best_mode)
|
||||
{
|
||||
/* we want to always return something */
|
||||
if (!best_mode)
|
||||
return true;
|
||||
|
||||
/*
|
||||
* With VRR always pick a mode with equal/higher than requested
|
||||
* vrefresh, which we can then reduce to match the requested
|
||||
* vrefresh by extending the vblank length.
|
||||
*/
|
||||
if (is_in_vrr_range(connector, vrefresh) &&
|
||||
is_in_vrr_range(connector, fixed_mode_vrefresh) &&
|
||||
fixed_mode_vrefresh < vrefresh)
|
||||
return false;
|
||||
|
||||
/* pick the fixed_mode that is closest in terms of vrefresh */
|
||||
return abs(fixed_mode_vrefresh - vrefresh) <
|
||||
abs(drm_mode_vrefresh(best_mode) - vrefresh);
|
||||
}
|
||||
|
||||
const struct drm_display_mode *
|
||||
intel_panel_fixed_mode(struct intel_connector *connector,
|
||||
const struct drm_display_mode *mode)
|
||||
@@ -65,11 +98,11 @@ intel_panel_fixed_mode(struct intel_connector *connector,
|
||||
const struct drm_display_mode *fixed_mode, *best_mode = NULL;
|
||||
int vrefresh = drm_mode_vrefresh(mode);
|
||||
|
||||
/* pick the fixed_mode that is closest in terms of vrefresh */
|
||||
list_for_each_entry(fixed_mode, &connector->panel.fixed_modes, head) {
|
||||
if (!best_mode ||
|
||||
abs(drm_mode_vrefresh(fixed_mode) - vrefresh) <
|
||||
abs(drm_mode_vrefresh(best_mode) - vrefresh))
|
||||
int fixed_mode_vrefresh = drm_mode_vrefresh(fixed_mode);
|
||||
|
||||
if (is_best_fixed_mode(connector, vrefresh,
|
||||
fixed_mode_vrefresh, best_mode))
|
||||
best_mode = fixed_mode;
|
||||
}
|
||||
|
||||
@@ -178,27 +211,46 @@ int intel_panel_compute_config(struct intel_connector *connector,
|
||||
{
|
||||
const struct drm_display_mode *fixed_mode =
|
||||
intel_panel_fixed_mode(connector, adjusted_mode);
|
||||
int vrefresh, fixed_mode_vrefresh;
|
||||
bool is_vrr;
|
||||
|
||||
if (!fixed_mode)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* We don't want to lie too much to the user about the refresh
|
||||
* rate they're going to get. But we have to allow a bit of latitude
|
||||
* for Xorg since it likes to automagically cook up modes with slightly
|
||||
* off refresh rates.
|
||||
*/
|
||||
if (abs(drm_mode_vrefresh(adjusted_mode) - drm_mode_vrefresh(fixed_mode)) > 1) {
|
||||
drm_dbg_kms(connector->base.dev,
|
||||
"[CONNECTOR:%d:%s] Requested mode vrefresh (%d Hz) does not match fixed mode vrefresh (%d Hz)\n",
|
||||
connector->base.base.id, connector->base.name,
|
||||
drm_mode_vrefresh(adjusted_mode), drm_mode_vrefresh(fixed_mode));
|
||||
vrefresh = drm_mode_vrefresh(adjusted_mode);
|
||||
fixed_mode_vrefresh = drm_mode_vrefresh(fixed_mode);
|
||||
|
||||
return -EINVAL;
|
||||
/*
|
||||
* Assume that we shouldn't muck about with the
|
||||
* timings if they don't land in the VRR range.
|
||||
*/
|
||||
is_vrr = is_in_vrr_range(connector, vrefresh) &&
|
||||
is_in_vrr_range(connector, fixed_mode_vrefresh);
|
||||
|
||||
if (!is_vrr) {
|
||||
/*
|
||||
* We don't want to lie too much to the user about the refresh
|
||||
* rate they're going to get. But we have to allow a bit of latitude
|
||||
* for Xorg since it likes to automagically cook up modes with slightly
|
||||
* off refresh rates.
|
||||
*/
|
||||
if (abs(vrefresh - fixed_mode_vrefresh) > 1) {
|
||||
drm_dbg_kms(connector->base.dev,
|
||||
"[CONNECTOR:%d:%s] Requested mode vrefresh (%d Hz) does not match fixed mode vrefresh (%d Hz)\n",
|
||||
connector->base.base.id, connector->base.name,
|
||||
vrefresh, fixed_mode_vrefresh);
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
drm_mode_copy(adjusted_mode, fixed_mode);
|
||||
|
||||
if (is_vrr && fixed_mode_vrefresh != vrefresh)
|
||||
adjusted_mode->vtotal =
|
||||
DIV_ROUND_CLOSEST(adjusted_mode->clock * 1000,
|
||||
adjusted_mode->htotal * vrefresh);
|
||||
|
||||
drm_mode_set_crtcinfo(adjusted_mode, 0);
|
||||
|
||||
return 0;
|
||||
@@ -512,11 +564,11 @@ static void i9xx_scale_aspect(struct intel_crtc_state *crtc_state,
|
||||
bits = panel_fitter_scaling(pipe_src_h,
|
||||
adjusted_mode->crtc_vdisplay);
|
||||
|
||||
*pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT |
|
||||
bits << PFIT_VERT_SCALE_SHIFT);
|
||||
*pfit_pgm_ratios |= (PFIT_HORIZ_SCALE(bits) |
|
||||
PFIT_VERT_SCALE(bits));
|
||||
*pfit_control |= (PFIT_ENABLE |
|
||||
VERT_INTERP_BILINEAR |
|
||||
HORIZ_INTERP_BILINEAR);
|
||||
PFIT_VERT_INTERP_BILINEAR |
|
||||
PFIT_HORIZ_INTERP_BILINEAR);
|
||||
}
|
||||
} else if (scaled_width < scaled_height) { /* letter */
|
||||
centre_vertically(adjusted_mode,
|
||||
@@ -527,18 +579,19 @@ static void i9xx_scale_aspect(struct intel_crtc_state *crtc_state,
|
||||
bits = panel_fitter_scaling(pipe_src_w,
|
||||
adjusted_mode->crtc_hdisplay);
|
||||
|
||||
*pfit_pgm_ratios |= (bits << PFIT_HORIZ_SCALE_SHIFT |
|
||||
bits << PFIT_VERT_SCALE_SHIFT);
|
||||
*pfit_pgm_ratios |= (PFIT_HORIZ_SCALE(bits) |
|
||||
PFIT_VERT_SCALE(bits));
|
||||
*pfit_control |= (PFIT_ENABLE |
|
||||
VERT_INTERP_BILINEAR |
|
||||
HORIZ_INTERP_BILINEAR);
|
||||
PFIT_VERT_INTERP_BILINEAR |
|
||||
PFIT_HORIZ_INTERP_BILINEAR);
|
||||
}
|
||||
} else {
|
||||
/* Aspects match, Let hw scale both directions */
|
||||
*pfit_control |= (PFIT_ENABLE |
|
||||
VERT_AUTO_SCALE | HORIZ_AUTO_SCALE |
|
||||
VERT_INTERP_BILINEAR |
|
||||
HORIZ_INTERP_BILINEAR);
|
||||
PFIT_VERT_AUTO_SCALE |
|
||||
PFIT_HORIZ_AUTO_SCALE |
|
||||
PFIT_VERT_INTERP_BILINEAR |
|
||||
PFIT_HORIZ_INTERP_BILINEAR);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -586,10 +639,10 @@ static int gmch_panel_fitting(struct intel_crtc_state *crtc_state,
|
||||
if (DISPLAY_VER(dev_priv) >= 4)
|
||||
pfit_control |= PFIT_SCALING_AUTO;
|
||||
else
|
||||
pfit_control |= (VERT_AUTO_SCALE |
|
||||
VERT_INTERP_BILINEAR |
|
||||
HORIZ_AUTO_SCALE |
|
||||
HORIZ_INTERP_BILINEAR);
|
||||
pfit_control |= (PFIT_VERT_AUTO_SCALE |
|
||||
PFIT_VERT_INTERP_BILINEAR |
|
||||
PFIT_HORIZ_AUTO_SCALE |
|
||||
PFIT_HORIZ_INTERP_BILINEAR);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
@@ -610,7 +663,7 @@ out:
|
||||
|
||||
/* Make sure pre-965 set dither correctly for 18bpp panels. */
|
||||
if (DISPLAY_VER(dev_priv) < 4 && crtc_state->pipe_bpp == 18)
|
||||
pfit_control |= PANEL_8TO6_DITHER_ENABLE;
|
||||
pfit_control |= PFIT_PANEL_8TO6_DITHER_ENABLE;
|
||||
|
||||
crtc_state->gmch_pfit.control = pfit_control;
|
||||
crtc_state->gmch_pfit.pgm_ratios = pfit_pgm_ratios;
|
||||
|
||||
@@ -43,11 +43,12 @@ static void assert_pch_dp_disabled(struct drm_i915_private *dev_priv,
|
||||
|
||||
state = g4x_dp_port_enabled(dev_priv, dp_reg, port, &port_pipe);
|
||||
|
||||
I915_STATE_WARN(state && port_pipe == pipe,
|
||||
I915_STATE_WARN(dev_priv, state && port_pipe == pipe,
|
||||
"PCH DP %c enabled on transcoder %c, should be disabled\n",
|
||||
port_name(port), pipe_name(pipe));
|
||||
|
||||
I915_STATE_WARN(HAS_PCH_IBX(dev_priv) && !state && port_pipe == PIPE_B,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
HAS_PCH_IBX(dev_priv) && !state && port_pipe == PIPE_B,
|
||||
"IBX PCH DP %c still using transcoder B\n",
|
||||
port_name(port));
|
||||
}
|
||||
@@ -61,11 +62,12 @@ static void assert_pch_hdmi_disabled(struct drm_i915_private *dev_priv,
|
||||
|
||||
state = intel_sdvo_port_enabled(dev_priv, hdmi_reg, &port_pipe);
|
||||
|
||||
I915_STATE_WARN(state && port_pipe == pipe,
|
||||
I915_STATE_WARN(dev_priv, state && port_pipe == pipe,
|
||||
"PCH HDMI %c enabled on transcoder %c, should be disabled\n",
|
||||
port_name(port), pipe_name(pipe));
|
||||
|
||||
I915_STATE_WARN(HAS_PCH_IBX(dev_priv) && !state && port_pipe == PIPE_B,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
HAS_PCH_IBX(dev_priv) && !state && port_pipe == PIPE_B,
|
||||
"IBX PCH HDMI %c still using transcoder B\n",
|
||||
port_name(port));
|
||||
}
|
||||
@@ -79,13 +81,13 @@ static void assert_pch_ports_disabled(struct drm_i915_private *dev_priv,
|
||||
assert_pch_dp_disabled(dev_priv, pipe, PORT_C, PCH_DP_C);
|
||||
assert_pch_dp_disabled(dev_priv, pipe, PORT_D, PCH_DP_D);
|
||||
|
||||
I915_STATE_WARN(intel_crt_port_enabled(dev_priv, PCH_ADPA, &port_pipe) &&
|
||||
port_pipe == pipe,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_crt_port_enabled(dev_priv, PCH_ADPA, &port_pipe) && port_pipe == pipe,
|
||||
"PCH VGA enabled on transcoder %c, should be disabled\n",
|
||||
pipe_name(pipe));
|
||||
|
||||
I915_STATE_WARN(intel_lvds_port_enabled(dev_priv, PCH_LVDS, &port_pipe) &&
|
||||
port_pipe == pipe,
|
||||
I915_STATE_WARN(dev_priv,
|
||||
intel_lvds_port_enabled(dev_priv, PCH_LVDS, &port_pipe) && port_pipe == pipe,
|
||||
"PCH LVDS enabled on transcoder %c, should be disabled\n",
|
||||
pipe_name(pipe));
|
||||
|
||||
@@ -103,7 +105,7 @@ static void assert_pch_transcoder_disabled(struct drm_i915_private *dev_priv,
|
||||
|
||||
val = intel_de_read(dev_priv, PCH_TRANSCONF(pipe));
|
||||
enabled = !!(val & TRANS_ENABLE);
|
||||
I915_STATE_WARN(enabled,
|
||||
I915_STATE_WARN(dev_priv, enabled,
|
||||
"transcoder assertion failed, should be off on pipe %c but is still active\n",
|
||||
pipe_name(pipe));
|
||||
}
|
||||
|
||||
@@ -293,6 +293,7 @@ intel_crtc_crc_setup_workarounds(struct intel_crtc *crtc, bool enable)
|
||||
}
|
||||
|
||||
state->acquire_ctx = &ctx;
|
||||
to_intel_atomic_state(state)->internal = true;
|
||||
|
||||
retry:
|
||||
pipe_config = intel_atomic_get_crtc_state(state, crtc);
|
||||
|
||||
@@ -787,7 +787,7 @@ void intel_pps_vdd_on(struct intel_dp *intel_dp)
|
||||
vdd = false;
|
||||
with_intel_pps_lock(intel_dp, wakeref)
|
||||
vdd = intel_pps_vdd_on_unlocked(intel_dp);
|
||||
I915_STATE_WARN(!vdd, "[ENCODER:%d:%s] %s VDD already requested on\n",
|
||||
I915_STATE_WARN(i915, !vdd, "[ENCODER:%d:%s] %s VDD already requested on\n",
|
||||
dp_to_dig_port(intel_dp)->base.base.base.id,
|
||||
dp_to_dig_port(intel_dp)->base.base.name,
|
||||
pps_name(i915, &intel_dp->pps));
|
||||
@@ -899,7 +899,8 @@ void intel_pps_vdd_off_unlocked(struct intel_dp *intel_dp, bool sync)
|
||||
if (!intel_dp_is_edp(intel_dp))
|
||||
return;
|
||||
|
||||
I915_STATE_WARN(!intel_dp->pps.want_panel_vdd, "[ENCODER:%d:%s] %s VDD not forced on",
|
||||
I915_STATE_WARN(dev_priv, !intel_dp->pps.want_panel_vdd,
|
||||
"[ENCODER:%d:%s] %s VDD not forced on",
|
||||
dp_to_dig_port(intel_dp)->base.base.base.id,
|
||||
dp_to_dig_port(intel_dp)->base.base.name,
|
||||
pps_name(dev_priv, &intel_dp->pps));
|
||||
@@ -1653,12 +1654,9 @@ void intel_pps_unlock_regs_wa(struct drm_i915_private *dev_priv)
|
||||
*/
|
||||
pps_num = intel_num_pps(dev_priv);
|
||||
|
||||
for (pps_idx = 0; pps_idx < pps_num; pps_idx++) {
|
||||
u32 val = intel_de_read(dev_priv, PP_CONTROL(pps_idx));
|
||||
|
||||
val = (val & ~PANEL_UNLOCK_MASK) | PANEL_UNLOCK_REGS;
|
||||
intel_de_write(dev_priv, PP_CONTROL(pps_idx), val);
|
||||
}
|
||||
for (pps_idx = 0; pps_idx < pps_num; pps_idx++)
|
||||
intel_de_rmw(dev_priv, PP_CONTROL(pps_idx),
|
||||
PANEL_UNLOCK_MASK, PANEL_UNLOCK_REGS);
|
||||
}
|
||||
|
||||
void intel_pps_setup(struct drm_i915_private *i915)
|
||||
@@ -1724,7 +1722,7 @@ void assert_pps_unlocked(struct drm_i915_private *dev_priv, enum pipe pipe)
|
||||
((val & PANEL_UNLOCK_MASK) == PANEL_UNLOCK_REGS))
|
||||
locked = false;
|
||||
|
||||
I915_STATE_WARN(panel_pipe == pipe && locked,
|
||||
I915_STATE_WARN(dev_priv, panel_pipe == pipe && locked,
|
||||
"panel assertion failure, pipe %c regs locked\n",
|
||||
pipe_name(pipe));
|
||||
}
|
||||
|
||||
@@ -85,6 +85,91 @@
|
||||
* use page flips.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Description of PSR mask bits:
|
||||
*
|
||||
* EDP_PSR_DEBUG[16]/EDP_PSR_DEBUG_MASK_DISP_REG_WRITE (hsw-skl):
|
||||
*
|
||||
* When unmasked (nearly) all display register writes (eg. even
|
||||
* SWF) trigger a PSR exit. Some registers are excluded from this
|
||||
* and they have a more specific mask (described below). On icl+
|
||||
* this bit no longer exists and is effectively always set.
|
||||
*
|
||||
* PIPE_MISC[21]/PIPE_MISC_PSR_MASK_PIPE_REG_WRITE (skl+):
|
||||
*
|
||||
* When unmasked (nearly) all pipe/plane register writes
|
||||
* trigger a PSR exit. Some plane registers are excluded from this
|
||||
* and they have a more specific mask (described below).
|
||||
*
|
||||
* CHICKEN_PIPESL_1[11]/SKL_PSR_MASK_PLANE_FLIP (skl+):
|
||||
* PIPE_MISC[23]/PIPE_MISC_PSR_MASK_PRIMARY_FLIP (bdw):
|
||||
* EDP_PSR_DEBUG[23]/EDP_PSR_DEBUG_MASK_PRIMARY_FLIP (hsw):
|
||||
*
|
||||
* When unmasked PRI_SURF/PLANE_SURF writes trigger a PSR exit.
|
||||
* SPR_SURF/CURBASE are not included in this and instead are
|
||||
* controlled by PIPE_MISC_PSR_MASK_PIPE_REG_WRITE (skl+) or
|
||||
* EDP_PSR_DEBUG_MASK_DISP_REG_WRITE (hsw/bdw).
|
||||
*
|
||||
* PIPE_MISC[22]/PIPE_MISC_PSR_MASK_SPRITE_ENABLE (bdw):
|
||||
* EDP_PSR_DEBUG[21]/EDP_PSR_DEBUG_MASK_SPRITE_ENABLE (hsw):
|
||||
*
|
||||
* When unmasked PSR is blocked as long as the sprite
|
||||
* plane is enabled. skl+ with their universal planes no
|
||||
* longer have a mask bit like this, and no plane being
|
||||
* enabledb blocks PSR.
|
||||
*
|
||||
* PIPE_MISC[21]/PIPE_MISC_PSR_MASK_CURSOR_MOVE (bdw):
|
||||
* EDP_PSR_DEBUG[20]/EDP_PSR_DEBUG_MASK_CURSOR_MOVE (hsw):
|
||||
*
|
||||
* When umasked CURPOS writes trigger a PSR exit. On skl+
|
||||
* this doesn't exit but CURPOS is included in the
|
||||
* PIPE_MISC_PSR_MASK_PIPE_REG_WRITE mask.
|
||||
*
|
||||
* PIPE_MISC[20]/PIPE_MISC_PSR_MASK_VBLANK_VSYNC_INT (bdw+):
|
||||
* EDP_PSR_DEBUG[19]/EDP_PSR_DEBUG_MASK_VBLANK_VSYNC_INT (hsw):
|
||||
*
|
||||
* When unmasked PSR is blocked as long as vblank and/or vsync
|
||||
* interrupt is unmasked in IMR *and* enabled in IER.
|
||||
*
|
||||
* CHICKEN_TRANS[30]/SKL_UNMASK_VBL_TO_PIPE_IN_SRD (skl+):
|
||||
* CHICKEN_PAR1_1[15]/HSW_MASK_VBL_TO_PIPE_IN_SRD (hsw/bdw):
|
||||
*
|
||||
* Selectcs whether PSR exit generates an extra vblank before
|
||||
* the first frame is transmitted. Also note the opposite polarity
|
||||
* if the bit on hsw/bdw vs. skl+ (masked==generate the extra vblank,
|
||||
* unmasked==do not generate the extra vblank).
|
||||
*
|
||||
* With DC states enabled the extra vblank happens after link training,
|
||||
* with DC states disabled it happens immediately upuon PSR exit trigger.
|
||||
* No idea as of now why there is a difference. HSW/BDW (which don't
|
||||
* even have DMC) always generate it after link training. Go figure.
|
||||
*
|
||||
* Unfortunately CHICKEN_TRANS itself seems to be double buffered
|
||||
* and thus won't latch until the first vblank. So with DC states
|
||||
* enabled the register effctively uses the reset value during DC5
|
||||
* exit+PSR exit sequence, and thus the bit does nothing until
|
||||
* latched by the vblank that it was trying to prevent from being
|
||||
* generated in the first place. So we should probably call this
|
||||
* one a chicken/egg bit instead on skl+.
|
||||
*
|
||||
* In standby mode (as opposed to link-off) this makes no difference
|
||||
* as the timing generator keeps running the whole time generating
|
||||
* normal periodic vblanks.
|
||||
*
|
||||
* WaPsrDPAMaskVBlankInSRD asks us to set the bit on hsw/bdw,
|
||||
* and doing so makes the behaviour match the skl+ reset value.
|
||||
*
|
||||
* CHICKEN_PIPESL_1[0]/BDW_UNMASK_VBL_TO_REGS_IN_SRD (bdw):
|
||||
* CHICKEN_PIPESL_1[15]/HSW_UNMASK_VBL_TO_REGS_IN_SRD (hsw):
|
||||
*
|
||||
* On BDW without this bit is no vblanks whatsoever are
|
||||
* generated after PSR exit. On HSW this has no apparant effect.
|
||||
* WaPsrDPRSUnmaskVBlankInSRD says to set this.
|
||||
*
|
||||
* The rest of the bits are more self-explanatory and/or
|
||||
* irrelevant for normal operation.
|
||||
*/
|
||||
|
||||
static bool psr_global_enabled(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct intel_connector *connector = intel_dp->attached_connector;
|
||||
@@ -208,13 +293,13 @@ static void psr_event_print(struct drm_i915_private *i915,
|
||||
|
||||
void intel_psr_irq_handler(struct intel_dp *intel_dp, u32 psr_iir)
|
||||
{
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
ktime_t time_ns = ktime_get();
|
||||
i915_reg_t imr_reg;
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 12)
|
||||
imr_reg = TRANS_PSR_IMR(intel_dp->psr.transcoder);
|
||||
imr_reg = TRANS_PSR_IMR(cpu_transcoder);
|
||||
else
|
||||
imr_reg = EDP_PSR_IMR;
|
||||
|
||||
@@ -232,13 +317,11 @@ void intel_psr_irq_handler(struct intel_dp *intel_dp, u32 psr_iir)
|
||||
transcoder_name(cpu_transcoder));
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 9) {
|
||||
u32 val = intel_de_read(dev_priv,
|
||||
PSR_EVENT(cpu_transcoder));
|
||||
bool psr2_enabled = intel_dp->psr.psr2_enabled;
|
||||
u32 val;
|
||||
|
||||
intel_de_write(dev_priv, PSR_EVENT(cpu_transcoder),
|
||||
val);
|
||||
psr_event_print(dev_priv, val, psr2_enabled);
|
||||
val = intel_de_rmw(dev_priv, PSR_EVENT(cpu_transcoder), 0, 0);
|
||||
|
||||
psr_event_print(dev_priv, val, intel_dp->psr.psr2_enabled);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -419,7 +502,7 @@ static u32 intel_psr1_get_tp_time(struct intel_dp *intel_dp)
|
||||
u32 val = 0;
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 11)
|
||||
val |= EDP_PSR_TP4_TIME_0US;
|
||||
val |= EDP_PSR_TP4_TIME_0us;
|
||||
|
||||
if (dev_priv->params.psr_safest_params) {
|
||||
val |= EDP_PSR_TP1_TIME_2500us;
|
||||
@@ -448,9 +531,9 @@ static u32 intel_psr1_get_tp_time(struct intel_dp *intel_dp)
|
||||
check_tp3_sel:
|
||||
if (intel_dp_source_supports_tps3(dev_priv) &&
|
||||
drm_dp_tps3_supported(intel_dp->dpcd))
|
||||
val |= EDP_PSR_TP1_TP3_SEL;
|
||||
val |= EDP_PSR_TP_TP1_TP3;
|
||||
else
|
||||
val |= EDP_PSR_TP1_TP2_SEL;
|
||||
val |= EDP_PSR_TP_TP1_TP2;
|
||||
|
||||
return val;
|
||||
}
|
||||
@@ -476,12 +559,13 @@ static u8 psr_compute_idle_frames(struct intel_dp *intel_dp)
|
||||
static void hsw_activate_psr1(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
u32 max_sleep_time = 0x1f;
|
||||
u32 val = EDP_PSR_ENABLE;
|
||||
|
||||
val |= psr_compute_idle_frames(intel_dp) << EDP_PSR_IDLE_FRAME_SHIFT;
|
||||
val |= EDP_PSR_IDLE_FRAMES(psr_compute_idle_frames(intel_dp));
|
||||
|
||||
val |= max_sleep_time << EDP_PSR_MAX_SLEEP_TIME_SHIFT;
|
||||
val |= EDP_PSR_MAX_SLEEP_TIME(max_sleep_time);
|
||||
if (IS_HASWELL(dev_priv))
|
||||
val |= EDP_PSR_MIN_LINK_ENTRY_TIME_8_LINES;
|
||||
|
||||
@@ -493,9 +577,8 @@ static void hsw_activate_psr1(struct intel_dp *intel_dp)
|
||||
if (DISPLAY_VER(dev_priv) >= 8)
|
||||
val |= EDP_PSR_CRC_ENABLE;
|
||||
|
||||
val |= (intel_de_read(dev_priv, EDP_PSR_CTL(intel_dp->psr.transcoder)) &
|
||||
EDP_PSR_RESTORE_PSR_ACTIVE_CTX_MASK);
|
||||
intel_de_write(dev_priv, EDP_PSR_CTL(intel_dp->psr.transcoder), val);
|
||||
intel_de_rmw(dev_priv, EDP_PSR_CTL(cpu_transcoder),
|
||||
~EDP_PSR_RESTORE_PSR_ACTIVE_CTX_MASK, val);
|
||||
}
|
||||
|
||||
static u32 intel_psr2_get_tp_time(struct intel_dp *intel_dp)
|
||||
@@ -534,9 +617,10 @@ static int psr2_block_count(struct intel_dp *intel_dp)
|
||||
static void hsw_activate_psr2(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
u32 val = EDP_PSR2_ENABLE;
|
||||
|
||||
val |= psr_compute_idle_frames(intel_dp) << EDP_PSR2_IDLE_FRAME_SHIFT;
|
||||
val |= EDP_PSR2_IDLE_FRAMES(psr_compute_idle_frames(intel_dp));
|
||||
|
||||
if (DISPLAY_VER(dev_priv) <= 13 && !IS_ALDERLAKE_P(dev_priv))
|
||||
val |= EDP_SU_TRACK_ENABLE;
|
||||
@@ -570,15 +654,13 @@ static void hsw_activate_psr2(struct intel_dp *intel_dp)
|
||||
* Still using the default IO_BUFFER_WAKE and FAST_WAKE, see
|
||||
* comments bellow for more information
|
||||
*/
|
||||
u32 tmp;
|
||||
int tmp;
|
||||
|
||||
tmp = map[intel_dp->psr.io_wake_lines - TGL_EDP_PSR2_IO_BUFFER_WAKE_MIN_LINES];
|
||||
tmp = tmp << TGL_EDP_PSR2_IO_BUFFER_WAKE_SHIFT;
|
||||
val |= tmp;
|
||||
val |= TGL_EDP_PSR2_IO_BUFFER_WAKE(tmp + TGL_EDP_PSR2_IO_BUFFER_WAKE_MIN_LINES);
|
||||
|
||||
tmp = map[intel_dp->psr.fast_wake_lines - TGL_EDP_PSR2_FAST_WAKE_MIN_LINES];
|
||||
tmp = tmp << TGL_EDP_PSR2_FAST_WAKE_MIN_SHIFT;
|
||||
val |= tmp;
|
||||
val |= TGL_EDP_PSR2_FAST_WAKE(tmp + TGL_EDP_PSR2_FAST_WAKE_MIN_LINES);
|
||||
} else if (DISPLAY_VER(dev_priv) >= 12) {
|
||||
val |= TGL_EDP_PSR2_IO_BUFFER_WAKE(intel_dp->psr.io_wake_lines);
|
||||
val |= TGL_EDP_PSR2_FAST_WAKE(intel_dp->psr.fast_wake_lines);
|
||||
@@ -593,31 +675,30 @@ static void hsw_activate_psr2(struct intel_dp *intel_dp)
|
||||
if (intel_dp->psr.psr2_sel_fetch_enabled) {
|
||||
u32 tmp;
|
||||
|
||||
tmp = intel_de_read(dev_priv, PSR2_MAN_TRK_CTL(intel_dp->psr.transcoder));
|
||||
tmp = intel_de_read(dev_priv, PSR2_MAN_TRK_CTL(cpu_transcoder));
|
||||
drm_WARN_ON(&dev_priv->drm, !(tmp & PSR2_MAN_TRK_CTL_ENABLE));
|
||||
} else if (HAS_PSR2_SEL_FETCH(dev_priv)) {
|
||||
intel_de_write(dev_priv,
|
||||
PSR2_MAN_TRK_CTL(intel_dp->psr.transcoder), 0);
|
||||
intel_de_write(dev_priv, PSR2_MAN_TRK_CTL(cpu_transcoder), 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* PSR2 HW is incorrectly using EDP_PSR_TP1_TP3_SEL and BSpec is
|
||||
* recommending keep this bit unset while PSR2 is enabled.
|
||||
*/
|
||||
intel_de_write(dev_priv, EDP_PSR_CTL(intel_dp->psr.transcoder), 0);
|
||||
intel_de_write(dev_priv, EDP_PSR_CTL(cpu_transcoder), 0);
|
||||
|
||||
intel_de_write(dev_priv, EDP_PSR2_CTL(intel_dp->psr.transcoder), val);
|
||||
intel_de_write(dev_priv, EDP_PSR2_CTL(cpu_transcoder), val);
|
||||
}
|
||||
|
||||
static bool
|
||||
transcoder_has_psr2(struct drm_i915_private *dev_priv, enum transcoder trans)
|
||||
transcoder_has_psr2(struct drm_i915_private *dev_priv, enum transcoder cpu_transcoder)
|
||||
{
|
||||
if (IS_ALDERLAKE_P(dev_priv) || DISPLAY_VER(dev_priv) >= 14)
|
||||
return trans == TRANSCODER_A || trans == TRANSCODER_B;
|
||||
return cpu_transcoder == TRANSCODER_A || cpu_transcoder == TRANSCODER_B;
|
||||
else if (DISPLAY_VER(dev_priv) >= 12)
|
||||
return trans == TRANSCODER_A;
|
||||
return cpu_transcoder == TRANSCODER_A;
|
||||
else
|
||||
return trans == TRANSCODER_EDP;
|
||||
return cpu_transcoder == TRANSCODER_EDP;
|
||||
}
|
||||
|
||||
static u32 intel_get_frame_time_us(const struct intel_crtc_state *cstate)
|
||||
@@ -633,10 +714,11 @@ static void psr2_program_idle_frames(struct intel_dp *intel_dp,
|
||||
u32 idle_frames)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
|
||||
idle_frames <<= EDP_PSR2_IDLE_FRAME_SHIFT;
|
||||
intel_de_rmw(dev_priv, EDP_PSR2_CTL(intel_dp->psr.transcoder),
|
||||
EDP_PSR2_IDLE_FRAME_MASK, idle_frames);
|
||||
intel_de_rmw(dev_priv, EDP_PSR2_CTL(cpu_transcoder),
|
||||
EDP_PSR2_IDLE_FRAMES_MASK,
|
||||
EDP_PSR2_IDLE_FRAMES(idle_frames));
|
||||
}
|
||||
|
||||
static void tgl_psr2_enable_dc3co(struct intel_dp *intel_dp)
|
||||
@@ -1074,6 +1156,7 @@ void intel_psr_get_config(struct intel_encoder *encoder,
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
|
||||
struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
|
||||
enum transcoder cpu_transcoder = pipe_config->cpu_transcoder;
|
||||
struct intel_dp *intel_dp;
|
||||
u32 val;
|
||||
|
||||
@@ -1100,15 +1183,14 @@ void intel_psr_get_config(struct intel_encoder *encoder,
|
||||
goto unlock;
|
||||
|
||||
if (HAS_PSR2_SEL_FETCH(dev_priv)) {
|
||||
val = intel_de_read(dev_priv, PSR2_MAN_TRK_CTL(intel_dp->psr.transcoder));
|
||||
val = intel_de_read(dev_priv, PSR2_MAN_TRK_CTL(cpu_transcoder));
|
||||
if (val & PSR2_MAN_TRK_CTL_ENABLE)
|
||||
pipe_config->enable_psr2_sel_fetch = true;
|
||||
}
|
||||
|
||||
if (DISPLAY_VER(dev_priv) >= 12) {
|
||||
val = intel_de_read(dev_priv, TRANS_EXITLINE(intel_dp->psr.transcoder));
|
||||
val &= EXITLINE_MASK;
|
||||
pipe_config->dc3co_exitline = val;
|
||||
val = intel_de_read(dev_priv, TRANS_EXITLINE(cpu_transcoder));
|
||||
pipe_config->dc3co_exitline = REG_FIELD_GET(EXITLINE_MASK, val);
|
||||
}
|
||||
unlock:
|
||||
mutex_unlock(&intel_dp->psr.lock);
|
||||
@@ -1117,14 +1199,14 @@ unlock:
|
||||
static void intel_psr_activate(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder transcoder = intel_dp->psr.transcoder;
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
|
||||
if (transcoder_has_psr2(dev_priv, transcoder))
|
||||
if (transcoder_has_psr2(dev_priv, cpu_transcoder))
|
||||
drm_WARN_ON(&dev_priv->drm,
|
||||
intel_de_read(dev_priv, EDP_PSR2_CTL(transcoder)) & EDP_PSR2_ENABLE);
|
||||
intel_de_read(dev_priv, EDP_PSR2_CTL(cpu_transcoder)) & EDP_PSR2_ENABLE);
|
||||
|
||||
drm_WARN_ON(&dev_priv->drm,
|
||||
intel_de_read(dev_priv, EDP_PSR_CTL(transcoder)) & EDP_PSR_ENABLE);
|
||||
intel_de_read(dev_priv, EDP_PSR_CTL(cpu_transcoder)) & EDP_PSR_ENABLE);
|
||||
drm_WARN_ON(&dev_priv->drm, intel_dp->psr.active);
|
||||
lockdep_assert_held(&intel_dp->psr.lock);
|
||||
|
||||
@@ -1203,7 +1285,7 @@ static void intel_psr_enable_source(struct intel_dp *intel_dp,
|
||||
if (DISPLAY_VER(dev_priv) < 11)
|
||||
mask |= EDP_PSR_DEBUG_MASK_DISP_REG_WRITE;
|
||||
|
||||
intel_de_write(dev_priv, EDP_PSR_DEBUG(intel_dp->psr.transcoder),
|
||||
intel_de_write(dev_priv, EDP_PSR_DEBUG(cpu_transcoder),
|
||||
mask);
|
||||
|
||||
psr_irq_control(intel_dp);
|
||||
@@ -1259,6 +1341,7 @@ static void intel_psr_enable_source(struct intel_dp *intel_dp,
|
||||
static bool psr_interrupt_error_check(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
u32 val;
|
||||
|
||||
/*
|
||||
@@ -1270,8 +1353,7 @@ static bool psr_interrupt_error_check(struct intel_dp *intel_dp)
|
||||
* to avoid any rendering problems.
|
||||
*/
|
||||
if (DISPLAY_VER(dev_priv) >= 12)
|
||||
val = intel_de_read(dev_priv,
|
||||
TRANS_PSR_IIR(intel_dp->psr.transcoder));
|
||||
val = intel_de_read(dev_priv, TRANS_PSR_IIR(cpu_transcoder));
|
||||
else
|
||||
val = intel_de_read(dev_priv, EDP_PSR_IIR);
|
||||
val &= psr_irq_psr_error_bit_get(intel_dp);
|
||||
@@ -1327,17 +1409,16 @@ static void intel_psr_enable_locked(struct intel_dp *intel_dp,
|
||||
static void intel_psr_exit(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
u32 val;
|
||||
|
||||
if (!intel_dp->psr.active) {
|
||||
if (transcoder_has_psr2(dev_priv, intel_dp->psr.transcoder)) {
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR2_CTL(intel_dp->psr.transcoder));
|
||||
if (transcoder_has_psr2(dev_priv, cpu_transcoder)) {
|
||||
val = intel_de_read(dev_priv, EDP_PSR2_CTL(cpu_transcoder));
|
||||
drm_WARN_ON(&dev_priv->drm, val & EDP_PSR2_ENABLE);
|
||||
}
|
||||
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR_CTL(intel_dp->psr.transcoder));
|
||||
val = intel_de_read(dev_priv, EDP_PSR_CTL(cpu_transcoder));
|
||||
drm_WARN_ON(&dev_priv->drm, val & EDP_PSR_ENABLE);
|
||||
|
||||
return;
|
||||
@@ -1345,19 +1426,16 @@ static void intel_psr_exit(struct intel_dp *intel_dp)
|
||||
|
||||
if (intel_dp->psr.psr2_enabled) {
|
||||
tgl_disallow_dc3co_on_psr2_exit(intel_dp);
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR2_CTL(intel_dp->psr.transcoder));
|
||||
|
||||
val = intel_de_rmw(dev_priv, EDP_PSR2_CTL(cpu_transcoder),
|
||||
EDP_PSR2_ENABLE, 0);
|
||||
|
||||
drm_WARN_ON(&dev_priv->drm, !(val & EDP_PSR2_ENABLE));
|
||||
val &= ~EDP_PSR2_ENABLE;
|
||||
intel_de_write(dev_priv,
|
||||
EDP_PSR2_CTL(intel_dp->psr.transcoder), val);
|
||||
} else {
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR_CTL(intel_dp->psr.transcoder));
|
||||
val = intel_de_rmw(dev_priv, EDP_PSR_CTL(cpu_transcoder),
|
||||
EDP_PSR_ENABLE, 0);
|
||||
|
||||
drm_WARN_ON(&dev_priv->drm, !(val & EDP_PSR_ENABLE));
|
||||
val &= ~EDP_PSR_ENABLE;
|
||||
intel_de_write(dev_priv,
|
||||
EDP_PSR_CTL(intel_dp->psr.transcoder), val);
|
||||
}
|
||||
intel_dp->psr.active = false;
|
||||
}
|
||||
@@ -1365,14 +1443,15 @@ static void intel_psr_exit(struct intel_dp *intel_dp)
|
||||
static void intel_psr_wait_exit_locked(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
i915_reg_t psr_status;
|
||||
u32 psr_status_mask;
|
||||
|
||||
if (intel_dp->psr.psr2_enabled) {
|
||||
psr_status = EDP_PSR2_STATUS(intel_dp->psr.transcoder);
|
||||
psr_status = EDP_PSR2_STATUS(cpu_transcoder);
|
||||
psr_status_mask = EDP_PSR2_STATUS_STATE_MASK;
|
||||
} else {
|
||||
psr_status = EDP_PSR_STATUS(intel_dp->psr.transcoder);
|
||||
psr_status = EDP_PSR_STATUS(cpu_transcoder);
|
||||
psr_status_mask = EDP_PSR_STATUS_STATE_MASK;
|
||||
}
|
||||
|
||||
@@ -1385,6 +1464,7 @@ static void intel_psr_wait_exit_locked(struct intel_dp *intel_dp)
|
||||
static void intel_psr_disable_locked(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
enum phy phy = intel_port_to_phy(dev_priv,
|
||||
dp_to_dig_port(intel_dp)->base.port);
|
||||
|
||||
@@ -1411,7 +1491,7 @@ static void intel_psr_disable_locked(struct intel_dp *intel_dp)
|
||||
/* Wa_16012604467:adlp,mtl[a0,b0] */
|
||||
if (IS_MTL_DISPLAY_STEP(dev_priv, STEP_A0, STEP_B0))
|
||||
intel_de_rmw(dev_priv,
|
||||
MTL_CLKGATE_DIS_TRANS(intel_dp->psr.transcoder),
|
||||
MTL_CLKGATE_DIS_TRANS(cpu_transcoder),
|
||||
MTL_CLKGATE_DIS_TRANS_DMASC_GATING_DIS, 0);
|
||||
else if (IS_ALDERLAKE_P(dev_priv))
|
||||
intel_de_rmw(dev_priv, CLKGATE_DIS_MISC,
|
||||
@@ -1548,10 +1628,11 @@ static u32 man_trk_ctl_continuos_full_frame(struct drm_i915_private *dev_priv)
|
||||
static void psr_force_hw_tracking_exit(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
|
||||
if (intel_dp->psr.psr2_sel_fetch_enabled)
|
||||
intel_de_write(dev_priv,
|
||||
PSR2_MAN_TRK_CTL(intel_dp->psr.transcoder),
|
||||
PSR2_MAN_TRK_CTL(cpu_transcoder),
|
||||
man_trk_ctl_enable_bit_get(dev_priv) |
|
||||
man_trk_ctl_partial_frame_bit_get(dev_priv) |
|
||||
man_trk_ctl_single_full_frame_bit_get(dev_priv) |
|
||||
@@ -1651,6 +1732,7 @@ void intel_psr2_program_plane_sel_fetch_noarm(struct intel_plane *plane,
|
||||
void intel_psr2_program_trans_man_trk_ctl(const struct intel_crtc_state *crtc_state)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev);
|
||||
enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
|
||||
struct intel_encoder *encoder;
|
||||
|
||||
if (!crtc_state->enable_psr2_sel_fetch)
|
||||
@@ -1666,7 +1748,7 @@ void intel_psr2_program_trans_man_trk_ctl(const struct intel_crtc_state *crtc_st
|
||||
break;
|
||||
}
|
||||
|
||||
intel_de_write(dev_priv, PSR2_MAN_TRK_CTL(crtc_state->cpu_transcoder),
|
||||
intel_de_write(dev_priv, PSR2_MAN_TRK_CTL(cpu_transcoder),
|
||||
crtc_state->psr2_man_track_ctl);
|
||||
}
|
||||
|
||||
@@ -2045,6 +2127,7 @@ void intel_psr_post_plane_update(const struct intel_atomic_state *state)
|
||||
static int _psr2_ready_for_pipe_update_locked(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
|
||||
/*
|
||||
* Any state lower than EDP_PSR2_STATUS_STATE_DEEP_SLEEP is enough.
|
||||
@@ -2052,13 +2135,14 @@ static int _psr2_ready_for_pipe_update_locked(struct intel_dp *intel_dp)
|
||||
* EDP_PSR2_STATUS_STATE_DEEP_SLEEP to be cleared.
|
||||
*/
|
||||
return intel_de_wait_for_clear(dev_priv,
|
||||
EDP_PSR2_STATUS(intel_dp->psr.transcoder),
|
||||
EDP_PSR2_STATUS(cpu_transcoder),
|
||||
EDP_PSR2_STATUS_STATE_DEEP_SLEEP, 50);
|
||||
}
|
||||
|
||||
static int _psr1_ready_for_pipe_update_locked(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
|
||||
/*
|
||||
* From bspec: Panel Self Refresh (BDW+)
|
||||
@@ -2067,7 +2151,7 @@ static int _psr1_ready_for_pipe_update_locked(struct intel_dp *intel_dp)
|
||||
* defensive enough to cover everything.
|
||||
*/
|
||||
return intel_de_wait_for_clear(dev_priv,
|
||||
EDP_PSR_STATUS(intel_dp->psr.transcoder),
|
||||
EDP_PSR_STATUS(cpu_transcoder),
|
||||
EDP_PSR_STATUS_STATE_MASK, 50);
|
||||
}
|
||||
|
||||
@@ -2109,6 +2193,7 @@ void intel_psr_wait_for_idle_locked(const struct intel_crtc_state *new_crtc_stat
|
||||
static bool __psr_wait_for_idle_locked(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
i915_reg_t reg;
|
||||
u32 mask;
|
||||
int err;
|
||||
@@ -2117,10 +2202,10 @@ static bool __psr_wait_for_idle_locked(struct intel_dp *intel_dp)
|
||||
return false;
|
||||
|
||||
if (intel_dp->psr.psr2_enabled) {
|
||||
reg = EDP_PSR2_STATUS(intel_dp->psr.transcoder);
|
||||
reg = EDP_PSR2_STATUS(cpu_transcoder);
|
||||
mask = EDP_PSR2_STATUS_STATE_MASK;
|
||||
} else {
|
||||
reg = EDP_PSR_STATUS(intel_dp->psr.transcoder);
|
||||
reg = EDP_PSR_STATUS(cpu_transcoder);
|
||||
mask = EDP_PSR_STATUS_STATE_MASK;
|
||||
}
|
||||
|
||||
@@ -2149,10 +2234,11 @@ static int intel_psr_fastset_force(struct drm_i915_private *dev_priv)
|
||||
return -ENOMEM;
|
||||
|
||||
drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
|
||||
|
||||
state->acquire_ctx = &ctx;
|
||||
to_intel_atomic_state(state)->internal = true;
|
||||
|
||||
retry:
|
||||
|
||||
drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
|
||||
drm_for_each_connector_iter(conn, &conn_iter) {
|
||||
struct drm_connector_state *conn_state;
|
||||
@@ -2281,6 +2367,7 @@ unlock:
|
||||
static void _psr_invalidate_handle(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
|
||||
if (intel_dp->psr.psr2_sel_fetch_enabled) {
|
||||
u32 val;
|
||||
@@ -2294,7 +2381,7 @@ static void _psr_invalidate_handle(struct intel_dp *intel_dp)
|
||||
val = man_trk_ctl_enable_bit_get(dev_priv) |
|
||||
man_trk_ctl_partial_frame_bit_get(dev_priv) |
|
||||
man_trk_ctl_continuos_full_frame(dev_priv);
|
||||
intel_de_write(dev_priv, PSR2_MAN_TRK_CTL(intel_dp->psr.transcoder), val);
|
||||
intel_de_write(dev_priv, PSR2_MAN_TRK_CTL(cpu_transcoder), val);
|
||||
intel_de_write(dev_priv, CURSURFLIVE(intel_dp->psr.pipe), 0);
|
||||
intel_dp->psr.psr2_sel_fetch_cff_enabled = true;
|
||||
} else {
|
||||
@@ -2373,6 +2460,7 @@ tgl_dc3co_flush_locked(struct intel_dp *intel_dp, unsigned int frontbuffer_bits,
|
||||
static void _psr_flush_handle(struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
|
||||
if (intel_dp->psr.psr2_sel_fetch_enabled) {
|
||||
if (intel_dp->psr.psr2_sel_fetch_cff_enabled) {
|
||||
@@ -2389,7 +2477,7 @@ static void _psr_flush_handle(struct intel_dp *intel_dp)
|
||||
* SU configuration in case update is sent for any reason after
|
||||
* sff bit gets cleared by the HW on next vblank.
|
||||
*/
|
||||
intel_de_write(dev_priv, PSR2_MAN_TRK_CTL(intel_dp->psr.transcoder),
|
||||
intel_de_write(dev_priv, PSR2_MAN_TRK_CTL(cpu_transcoder),
|
||||
val);
|
||||
intel_de_write(dev_priv, CURSURFLIVE(intel_dp->psr.pipe), 0);
|
||||
intel_dp->psr.psr2_sel_fetch_cff_enabled = false;
|
||||
@@ -2702,6 +2790,7 @@ static void
|
||||
psr_source_status(struct intel_dp *intel_dp, struct seq_file *m)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
const char *status = "unknown";
|
||||
u32 val, status_val;
|
||||
|
||||
@@ -2719,8 +2808,7 @@ psr_source_status(struct intel_dp *intel_dp, struct seq_file *m)
|
||||
"BUF_ON",
|
||||
"TG_ON"
|
||||
};
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR2_STATUS(intel_dp->psr.transcoder));
|
||||
val = intel_de_read(dev_priv, EDP_PSR2_STATUS(cpu_transcoder));
|
||||
status_val = REG_FIELD_GET(EDP_PSR2_STATUS_STATE_MASK, val);
|
||||
if (status_val < ARRAY_SIZE(live_status))
|
||||
status = live_status[status_val];
|
||||
@@ -2735,10 +2823,8 @@ psr_source_status(struct intel_dp *intel_dp, struct seq_file *m)
|
||||
"SRDOFFACK",
|
||||
"SRDENT_ON",
|
||||
};
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR_STATUS(intel_dp->psr.transcoder));
|
||||
status_val = (val & EDP_PSR_STATUS_STATE_MASK) >>
|
||||
EDP_PSR_STATUS_STATE_SHIFT;
|
||||
val = intel_de_read(dev_priv, EDP_PSR_STATUS(cpu_transcoder));
|
||||
status_val = REG_FIELD_GET(EDP_PSR_STATUS_STATE_MASK, val);
|
||||
if (status_val < ARRAY_SIZE(live_status))
|
||||
status = live_status[status_val];
|
||||
}
|
||||
@@ -2749,6 +2835,7 @@ psr_source_status(struct intel_dp *intel_dp, struct seq_file *m)
|
||||
static int intel_psr_status(struct seq_file *m, struct intel_dp *intel_dp)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
|
||||
enum transcoder cpu_transcoder = intel_dp->psr.transcoder;
|
||||
struct intel_psr *psr = &intel_dp->psr;
|
||||
intel_wakeref_t wakeref;
|
||||
const char *status;
|
||||
@@ -2780,12 +2867,10 @@ static int intel_psr_status(struct seq_file *m, struct intel_dp *intel_dp)
|
||||
}
|
||||
|
||||
if (psr->psr2_enabled) {
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR2_CTL(intel_dp->psr.transcoder));
|
||||
val = intel_de_read(dev_priv, EDP_PSR2_CTL(cpu_transcoder));
|
||||
enabled = val & EDP_PSR2_ENABLE;
|
||||
} else {
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR_CTL(intel_dp->psr.transcoder));
|
||||
val = intel_de_read(dev_priv, EDP_PSR_CTL(cpu_transcoder));
|
||||
enabled = val & EDP_PSR_ENABLE;
|
||||
}
|
||||
seq_printf(m, "Source PSR ctl: %s [0x%08x]\n",
|
||||
@@ -2797,12 +2882,9 @@ static int intel_psr_status(struct seq_file *m, struct intel_dp *intel_dp)
|
||||
/*
|
||||
* SKL+ Perf counter is reset to 0 everytime DC state is entered
|
||||
*/
|
||||
if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) {
|
||||
val = intel_de_read(dev_priv,
|
||||
EDP_PSR_PERF_CNT(intel_dp->psr.transcoder));
|
||||
val &= EDP_PSR_PERF_CNT_MASK;
|
||||
seq_printf(m, "Performance counter: %u\n", val);
|
||||
}
|
||||
val = intel_de_read(dev_priv, EDP_PSR_PERF_CNT(cpu_transcoder));
|
||||
seq_printf(m, "Performance counter: %u\n",
|
||||
REG_FIELD_GET(EDP_PSR_PERF_CNT_MASK, val));
|
||||
|
||||
if (psr->debug & I915_PSR_DEBUG_IRQ) {
|
||||
seq_printf(m, "Last attempted entry at: %lld\n",
|
||||
@@ -2819,8 +2901,7 @@ static int intel_psr_status(struct seq_file *m, struct intel_dp *intel_dp)
|
||||
* frame boundary between register reads
|
||||
*/
|
||||
for (frame = 0; frame < PSR2_SU_STATUS_FRAMES; frame += 3) {
|
||||
val = intel_de_read(dev_priv,
|
||||
PSR2_SU_STATUS(intel_dp->psr.transcoder, frame));
|
||||
val = intel_de_read(dev_priv, PSR2_SU_STATUS(cpu_transcoder, frame));
|
||||
su_frames_val[frame / 3] = val;
|
||||
}
|
||||
|
||||
|
||||
@@ -22,30 +22,36 @@
|
||||
#define _SRD_CTL_A 0x60800
|
||||
#define _SRD_CTL_EDP 0x6f800
|
||||
#define EDP_PSR_CTL(tran) _MMIO_TRANS2(tran, _SRD_CTL_A)
|
||||
#define EDP_PSR_ENABLE (1 << 31)
|
||||
#define BDW_PSR_SINGLE_FRAME (1 << 30)
|
||||
#define EDP_PSR_RESTORE_PSR_ACTIVE_CTX_MASK (1 << 29) /* SW can't modify */
|
||||
#define EDP_PSR_LINK_STANDBY (1 << 27)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_MASK (3 << 25)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_8_LINES (0 << 25)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_4_LINES (1 << 25)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_2_LINES (2 << 25)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_0_LINES (3 << 25)
|
||||
#define EDP_PSR_MAX_SLEEP_TIME_SHIFT 20
|
||||
#define EDP_PSR_SKIP_AUX_EXIT (1 << 12)
|
||||
#define EDP_PSR_TP1_TP2_SEL (0 << 11)
|
||||
#define EDP_PSR_TP1_TP3_SEL (1 << 11)
|
||||
#define EDP_PSR_CRC_ENABLE (1 << 10) /* BDW+ */
|
||||
#define EDP_PSR_TP2_TP3_TIME_500us (0 << 8)
|
||||
#define EDP_PSR_TP2_TP3_TIME_100us (1 << 8)
|
||||
#define EDP_PSR_TP2_TP3_TIME_2500us (2 << 8)
|
||||
#define EDP_PSR_TP2_TP3_TIME_0us (3 << 8)
|
||||
#define EDP_PSR_TP4_TIME_0US (3 << 6) /* ICL+ */
|
||||
#define EDP_PSR_TP1_TIME_500us (0 << 4)
|
||||
#define EDP_PSR_TP1_TIME_100us (1 << 4)
|
||||
#define EDP_PSR_TP1_TIME_2500us (2 << 4)
|
||||
#define EDP_PSR_TP1_TIME_0us (3 << 4)
|
||||
#define EDP_PSR_IDLE_FRAME_SHIFT 0
|
||||
#define EDP_PSR_ENABLE REG_BIT(31)
|
||||
#define BDW_PSR_SINGLE_FRAME REG_BIT(30)
|
||||
#define EDP_PSR_RESTORE_PSR_ACTIVE_CTX_MASK REG_BIT(29) /* SW can't modify */
|
||||
#define EDP_PSR_LINK_STANDBY REG_BIT(27)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_MASK REG_GENMASK(26, 25)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_8_LINES REG_FIELD_PREP(EDP_PSR_MIN_LINK_ENTRY_TIME_MASK, 0)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_4_LINES REG_FIELD_PREP(EDP_PSR_MIN_LINK_ENTRY_TIME_MASK, 1)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_2_LINES REG_FIELD_PREP(EDP_PSR_MIN_LINK_ENTRY_TIME_MASK, 2)
|
||||
#define EDP_PSR_MIN_LINK_ENTRY_TIME_0_LINES REG_FIELD_PREP(EDP_PSR_MIN_LINK_ENTRY_TIME_MASK, 3)
|
||||
#define EDP_PSR_MAX_SLEEP_TIME_MASK REG_GENMASK(24, 20)
|
||||
#define EDP_PSR_MAX_SLEEP_TIME(x) REG_FIELD_PREP(EDP_PSR_MAX_SLEEP_TIME_MASK, (x))
|
||||
#define EDP_PSR_SKIP_AUX_EXIT REG_BIT(12)
|
||||
#define EDP_PSR_TP_MASK REG_BIT(11)
|
||||
#define EDP_PSR_TP_TP1_TP2 REG_FIELD_PREP(EDP_PSR_TP_MASK, 0)
|
||||
#define EDP_PSR_TP_TP1_TP3 REG_FIELD_PREP(EDP_PSR_TP_MASK, 1)
|
||||
#define EDP_PSR_CRC_ENABLE REG_BIT(10) /* BDW+ */
|
||||
#define EDP_PSR_TP2_TP3_TIME_MASK REG_GENMASK(9, 8)
|
||||
#define EDP_PSR_TP2_TP3_TIME_500us REG_FIELD_PREP(EDP_PSR_TP2_TP3_TIME_MASK, 0)
|
||||
#define EDP_PSR_TP2_TP3_TIME_100us REG_FIELD_PREP(EDP_PSR_TP2_TP3_TIME_MASK, 1)
|
||||
#define EDP_PSR_TP2_TP3_TIME_2500us REG_FIELD_PREP(EDP_PSR_TP2_TP3_TIME_MASK, 2)
|
||||
#define EDP_PSR_TP2_TP3_TIME_0us REG_FIELD_PREP(EDP_PSR_TP2_TP3_TIME_MASK, 3)
|
||||
#define EDP_PSR_TP4_TIME_MASK REG_GENMASK(7, 6)
|
||||
#define EDP_PSR_TP4_TIME_0us REG_FIELD_PREP(EDP_PSR_TP4_TIME_MASK, 3) /* ICL+ */
|
||||
#define EDP_PSR_TP1_TIME_MASK REG_GENMASK(5, 4)
|
||||
#define EDP_PSR_TP1_TIME_500us REG_FIELD_PREP(EDP_PSR_TP1_TIME_MASK, 0)
|
||||
#define EDP_PSR_TP1_TIME_100us REG_FIELD_PREP(EDP_PSR_TP1_TIME_MASK, 1)
|
||||
#define EDP_PSR_TP1_TIME_2500us REG_FIELD_PREP(EDP_PSR_TP1_TIME_MASK, 2)
|
||||
#define EDP_PSR_TP1_TIME_0us REG_FIELD_PREP(EDP_PSR_TP1_TIME_MASK, 3)
|
||||
#define EDP_PSR_IDLE_FRAMES_MASK REG_GENMASK(3, 0)
|
||||
#define EDP_PSR_IDLE_FRAMES(x) REG_FIELD_PREP(EDP_PSR_IDLE_FRAMES_MASK, (x))
|
||||
|
||||
/*
|
||||
* Until TGL, IMR/IIR are fixed at 0x648xx. On TGL+ those registers are relative
|
||||
@@ -80,81 +86,90 @@
|
||||
#define _SRD_STATUS_A 0x60840
|
||||
#define _SRD_STATUS_EDP 0x6f840
|
||||
#define EDP_PSR_STATUS(tran) _MMIO_TRANS2(tran, _SRD_STATUS_A)
|
||||
#define EDP_PSR_STATUS_STATE_MASK (7 << 29)
|
||||
#define EDP_PSR_STATUS_STATE_SHIFT 29
|
||||
#define EDP_PSR_STATUS_STATE_IDLE (0 << 29)
|
||||
#define EDP_PSR_STATUS_STATE_SRDONACK (1 << 29)
|
||||
#define EDP_PSR_STATUS_STATE_SRDENT (2 << 29)
|
||||
#define EDP_PSR_STATUS_STATE_BUFOFF (3 << 29)
|
||||
#define EDP_PSR_STATUS_STATE_BUFON (4 << 29)
|
||||
#define EDP_PSR_STATUS_STATE_AUXACK (5 << 29)
|
||||
#define EDP_PSR_STATUS_STATE_SRDOFFACK (6 << 29)
|
||||
#define EDP_PSR_STATUS_LINK_MASK (3 << 26)
|
||||
#define EDP_PSR_STATUS_LINK_FULL_OFF (0 << 26)
|
||||
#define EDP_PSR_STATUS_LINK_FULL_ON (1 << 26)
|
||||
#define EDP_PSR_STATUS_LINK_STANDBY (2 << 26)
|
||||
#define EDP_PSR_STATUS_MAX_SLEEP_TIMER_SHIFT 20
|
||||
#define EDP_PSR_STATUS_MAX_SLEEP_TIMER_MASK 0x1f
|
||||
#define EDP_PSR_STATUS_COUNT_SHIFT 16
|
||||
#define EDP_PSR_STATUS_COUNT_MASK 0xf
|
||||
#define EDP_PSR_STATUS_AUX_ERROR (1 << 15)
|
||||
#define EDP_PSR_STATUS_AUX_SENDING (1 << 12)
|
||||
#define EDP_PSR_STATUS_SENDING_IDLE (1 << 9)
|
||||
#define EDP_PSR_STATUS_SENDING_TP2_TP3 (1 << 8)
|
||||
#define EDP_PSR_STATUS_SENDING_TP1 (1 << 4)
|
||||
#define EDP_PSR_STATUS_IDLE_MASK 0xf
|
||||
#define EDP_PSR_STATUS_STATE_MASK REG_GENMASK(31, 29)
|
||||
#define EDP_PSR_STATUS_STATE_IDLE REG_FIELD_PREP(EDP_PSR_STATUS_STATE_MASK, 0)
|
||||
#define EDP_PSR_STATUS_STATE_SRDONACK REG_FIELD_PREP(EDP_PSR_STATUS_STATE_MASK, 1)
|
||||
#define EDP_PSR_STATUS_STATE_SRDENT REG_FIELD_PREP(EDP_PSR_STATUS_STATE_MASK, 2)
|
||||
#define EDP_PSR_STATUS_STATE_BUFOFF REG_FIELD_PREP(EDP_PSR_STATUS_STATE_MASK, 3)
|
||||
#define EDP_PSR_STATUS_STATE_BUFON REG_FIELD_PREP(EDP_PSR_STATUS_STATE_MASK, 4)
|
||||
#define EDP_PSR_STATUS_STATE_AUXACK REG_FIELD_PREP(EDP_PSR_STATUS_STATE_MASK, 5)
|
||||
#define EDP_PSR_STATUS_STATE_SRDOFFACK REG_FIELD_PREP(EDP_PSR_STATUS_STATE_MASK, 6)
|
||||
#define EDP_PSR_STATUS_LINK_MASK REG_GENMASK(27, 26)
|
||||
#define EDP_PSR_STATUS_LINK_FULL_OFF REG_FIELD_PREP(EDP_PSR_STATUS_LINK_MASK, 0)
|
||||
#define EDP_PSR_STATUS_LINK_FULL_ON REG_FIELD_PREP(EDP_PSR_STATUS_LINK_MASK, 1)
|
||||
#define EDP_PSR_STATUS_LINK_STANDBY REG_FIELD_PREP(EDP_PSR_STATUS_LINK_MASK, 2)
|
||||
#define EDP_PSR_STATUS_MAX_SLEEP_TIMER_MASK REG_GENMASK(24, 20)
|
||||
#define EDP_PSR_STATUS_COUNT_MASK REG_GENMASK(19, 16)
|
||||
#define EDP_PSR_STATUS_AUX_ERROR REG_BIT(15)
|
||||
#define EDP_PSR_STATUS_AUX_SENDING REG_BIT(12)
|
||||
#define EDP_PSR_STATUS_SENDING_IDLE REG_BIT(9)
|
||||
#define EDP_PSR_STATUS_SENDING_TP2_TP3 REG_BIT(8)
|
||||
#define EDP_PSR_STATUS_SENDING_TP1 REG_BIT(4)
|
||||
#define EDP_PSR_STATUS_IDLE_MASK REG_GENMASK(3, 0)
|
||||
|
||||
#define _SRD_PERF_CNT_A 0x60844
|
||||
#define _SRD_PERF_CNT_EDP 0x6f844
|
||||
#define EDP_PSR_PERF_CNT(tran) _MMIO_TRANS2(tran, _SRD_PERF_CNT_A)
|
||||
#define EDP_PSR_PERF_CNT_MASK 0xffffff
|
||||
#define EDP_PSR_PERF_CNT_MASK REG_GENMASK(23, 0)
|
||||
|
||||
/* PSR_MASK on SKL+ */
|
||||
#define _SRD_DEBUG_A 0x60860
|
||||
#define _SRD_DEBUG_EDP 0x6f860
|
||||
#define EDP_PSR_DEBUG(tran) _MMIO_TRANS2(tran, _SRD_DEBUG_A)
|
||||
#define EDP_PSR_DEBUG_MASK_MAX_SLEEP (1 << 28)
|
||||
#define EDP_PSR_DEBUG_MASK_LPSP (1 << 27)
|
||||
#define EDP_PSR_DEBUG_MASK_MEMUP (1 << 26)
|
||||
#define EDP_PSR_DEBUG_MASK_HPD (1 << 25)
|
||||
#define EDP_PSR_DEBUG_MASK_DISP_REG_WRITE (1 << 16) /* Reserved in ICL+ */
|
||||
#define EDP_PSR_DEBUG_EXIT_ON_PIXEL_UNDERRUN (1 << 15) /* SKL+ */
|
||||
#define EDP_PSR_DEBUG_MASK_MAX_SLEEP REG_BIT(28)
|
||||
#define EDP_PSR_DEBUG_MASK_LPSP REG_BIT(27)
|
||||
#define EDP_PSR_DEBUG_MASK_MEMUP REG_BIT(26)
|
||||
#define EDP_PSR_DEBUG_MASK_HPD REG_BIT(25)
|
||||
#define EDP_PSR_DEBUG_MASK_FBC_MODIFY REG_BIT(24)
|
||||
#define EDP_PSR_DEBUG_MASK_PRIMARY_FLIP REG_BIT(23) /* hsw */
|
||||
#define EDP_PSR_DEBUG_MASK_HDCP_ENABLE REG_BIT(22) /* hsw/bdw */
|
||||
#define EDP_PSR_DEBUG_MASK_SPRITE_ENABLE REG_BIT(21) /* hsw */
|
||||
#define EDP_PSR_DEBUG_MASK_CURSOR_MOVE REG_BIT(20) /* hsw */
|
||||
#define EDP_PSR_DEBUG_MASK_VBLANK_VSYNC_INT REG_BIT(19) /* hsw */
|
||||
#define EDP_PSR_DEBUG_MASK_DPST_PHASE_IN REG_BIT(18) /* hsw */
|
||||
#define EDP_PSR_DEBUG_MASK_KVMR_SESSION_EN REG_BIT(17)
|
||||
#define EDP_PSR_DEBUG_MASK_DISP_REG_WRITE REG_BIT(16) /* hsw-skl */
|
||||
#define EDP_PSR_DEBUG_EXIT_ON_PIXEL_UNDERRUN REG_BIT(15) /* skl+ */
|
||||
#define EDP_PSR_DEBUG_RFB_UPDATE_SENT REG_BIT(2) /* bdw */
|
||||
#define EDP_PSR_DEBUG_ENTRY_COMPLETION REG_BIT(1) /* hsw/bdw */
|
||||
|
||||
#define _PSR2_CTL_A 0x60900
|
||||
#define _PSR2_CTL_EDP 0x6f900
|
||||
#define EDP_PSR2_CTL(tran) _MMIO_TRANS2(tran, _PSR2_CTL_A)
|
||||
#define EDP_PSR2_ENABLE (1 << 31)
|
||||
#define EDP_SU_TRACK_ENABLE (1 << 30) /* up to adl-p */
|
||||
#define TGL_EDP_PSR2_BLOCK_COUNT_NUM_2 (0 << 28)
|
||||
#define TGL_EDP_PSR2_BLOCK_COUNT_NUM_3 (1 << 28)
|
||||
#define EDP_PSR2_ENABLE REG_BIT(31)
|
||||
#define EDP_SU_TRACK_ENABLE REG_BIT(30) /* up to adl-p */
|
||||
#define TGL_EDP_PSR2_BLOCK_COUNT_MASK REG_BIT(28)
|
||||
#define TGL_EDP_PSR2_BLOCK_COUNT_NUM_2 REG_FIELD_PREP(TGL_EDP_PSR2_BLOCK_COUNT_MASK, 0)
|
||||
#define TGL_EDP_PSR2_BLOCK_COUNT_NUM_3 REG_FIELD_PREP(TGL_EDP_PSR2_BLOCK_COUNT_MASK, 1)
|
||||
#define EDP_Y_COORDINATE_ENABLE REG_BIT(25) /* display 10, 11 and 12 */
|
||||
#define EDP_PSR2_SU_SDP_SCANLINE REG_BIT(25) /* display 13+ */
|
||||
#define EDP_MAX_SU_DISABLE_TIME(t) ((t) << 20)
|
||||
#define EDP_MAX_SU_DISABLE_TIME_MASK (0x1f << 20)
|
||||
#define EDP_MAX_SU_DISABLE_TIME_MASK REG_GENMASK(24, 20)
|
||||
#define EDP_MAX_SU_DISABLE_TIME(t) REG_FIELD_PREP(EDP_MAX_SU_DISABLE_TIME, (t))
|
||||
#define EDP_PSR2_IO_BUFFER_WAKE_MASK REG_GENMASK(14, 13)
|
||||
#define EDP_PSR2_IO_BUFFER_WAKE_MAX_LINES 8
|
||||
#define EDP_PSR2_IO_BUFFER_WAKE(lines) ((EDP_PSR2_IO_BUFFER_WAKE_MAX_LINES - (lines)) << 13)
|
||||
#define EDP_PSR2_IO_BUFFER_WAKE_MASK (3 << 13)
|
||||
#define EDP_PSR2_IO_BUFFER_WAKE(lines) REG_FIELD_PREP(EDP_PSR2_IO_BUFFER_WAKE_MASK, \
|
||||
EDP_PSR2_IO_BUFFER_WAKE_MAX_LINES - (lines))
|
||||
#define TGL_EDP_PSR2_IO_BUFFER_WAKE_MASK REG_GENMASK(15, 13)
|
||||
#define TGL_EDP_PSR2_IO_BUFFER_WAKE_MIN_LINES 5
|
||||
#define TGL_EDP_PSR2_IO_BUFFER_WAKE_SHIFT 13
|
||||
#define TGL_EDP_PSR2_IO_BUFFER_WAKE(lines) (((lines) - TGL_EDP_PSR2_IO_BUFFER_WAKE_MIN_LINES) << TGL_EDP_PSR2_IO_BUFFER_WAKE_SHIFT)
|
||||
#define TGL_EDP_PSR2_IO_BUFFER_WAKE_MASK (7 << 13)
|
||||
#define TGL_EDP_PSR2_IO_BUFFER_WAKE(lines) REG_FIELD_PREP(TGL_EDP_PSR2_IO_BUFFER_WAKE_MASK, \
|
||||
(lines) - TGL_EDP_PSR2_IO_BUFFER_WAKE_MIN_LINES)
|
||||
#define EDP_PSR2_FAST_WAKE_MASK REG_GENMASK(12, 11)
|
||||
#define EDP_PSR2_FAST_WAKE_MAX_LINES 8
|
||||
#define EDP_PSR2_FAST_WAKE(lines) ((EDP_PSR2_FAST_WAKE_MAX_LINES - (lines)) << 11)
|
||||
#define EDP_PSR2_FAST_WAKE_MASK (3 << 11)
|
||||
#define EDP_PSR2_FAST_WAKE(lines) REG_FIELD_PREP(EDP_PSR2_FAST_WAKE_MASK, \
|
||||
EDP_PSR2_FAST_WAKE_MAX_LINES - (lines))
|
||||
#define TGL_EDP_PSR2_FAST_WAKE_MASK REG_GENMASK(12, 10)
|
||||
#define TGL_EDP_PSR2_FAST_WAKE_MIN_LINES 5
|
||||
#define TGL_EDP_PSR2_FAST_WAKE_MIN_SHIFT 10
|
||||
#define TGL_EDP_PSR2_FAST_WAKE(lines) (((lines) - TGL_EDP_PSR2_FAST_WAKE_MIN_LINES) << TGL_EDP_PSR2_FAST_WAKE_MIN_SHIFT)
|
||||
#define TGL_EDP_PSR2_FAST_WAKE_MASK (7 << 10)
|
||||
#define EDP_PSR2_TP2_TIME_500us (0 << 8)
|
||||
#define EDP_PSR2_TP2_TIME_100us (1 << 8)
|
||||
#define EDP_PSR2_TP2_TIME_2500us (2 << 8)
|
||||
#define EDP_PSR2_TP2_TIME_50us (3 << 8)
|
||||
#define EDP_PSR2_TP2_TIME_MASK (3 << 8)
|
||||
#define EDP_PSR2_FRAME_BEFORE_SU_SHIFT 4
|
||||
#define EDP_PSR2_FRAME_BEFORE_SU_MASK (0xf << 4)
|
||||
#define EDP_PSR2_FRAME_BEFORE_SU(a) ((a) << 4)
|
||||
#define EDP_PSR2_IDLE_FRAME_MASK 0xf
|
||||
#define EDP_PSR2_IDLE_FRAME_SHIFT 0
|
||||
#define TGL_EDP_PSR2_FAST_WAKE(lines) REG_FIELD_PREP(TGL_EDP_PSR2_FAST_WAKE_MASK, \
|
||||
(lines) - TGL_EDP_PSR2_FAST_WAKE_MIN_LINES)
|
||||
#define EDP_PSR2_TP2_TIME_MASK REG_GENMASK(9, 8)
|
||||
#define EDP_PSR2_TP2_TIME_500us REG_FIELD_PREP(EDP_PSR2_TP2_TIME_MASK, 0)
|
||||
#define EDP_PSR2_TP2_TIME_100us REG_FIELD_PREP(EDP_PSR2_TP2_TIME_MASK, 1)
|
||||
#define EDP_PSR2_TP2_TIME_2500us REG_FIELD_PREP(EDP_PSR2_TP2_TIME_MASK, 2)
|
||||
#define EDP_PSR2_TP2_TIME_50us REG_FIELD_PREP(EDP_PSR2_TP2_TIME_MASK, 3)
|
||||
#define EDP_PSR2_FRAME_BEFORE_SU_MASK REG_GENMASK(7, 4)
|
||||
#define EDP_PSR2_FRAME_BEFORE_SU(a) REG_FIELD_PREP(EDP_PSR2_FRAME_BEFORE_SU_MASK, (a))
|
||||
#define EDP_PSR2_IDLE_FRAMES_MASK REG_GENMASK(3, 0)
|
||||
#define EDP_PSR2_IDLE_FRAMES(x) REG_FIELD_PREP(EDP_PSR2_IDLE_FRAMES_MASK, (x))
|
||||
|
||||
#define _PSR_EVENT_TRANS_A 0x60848
|
||||
#define _PSR_EVENT_TRANS_B 0x61848
|
||||
@@ -162,22 +177,22 @@
|
||||
#define _PSR_EVENT_TRANS_D 0x63848
|
||||
#define _PSR_EVENT_TRANS_EDP 0x6f848
|
||||
#define PSR_EVENT(tran) _MMIO_TRANS2(tran, _PSR_EVENT_TRANS_A)
|
||||
#define PSR_EVENT_PSR2_WD_TIMER_EXPIRE (1 << 17)
|
||||
#define PSR_EVENT_PSR2_DISABLED (1 << 16)
|
||||
#define PSR_EVENT_SU_DIRTY_FIFO_UNDERRUN (1 << 15)
|
||||
#define PSR_EVENT_SU_CRC_FIFO_UNDERRUN (1 << 14)
|
||||
#define PSR_EVENT_GRAPHICS_RESET (1 << 12)
|
||||
#define PSR_EVENT_PCH_INTERRUPT (1 << 11)
|
||||
#define PSR_EVENT_MEMORY_UP (1 << 10)
|
||||
#define PSR_EVENT_FRONT_BUFFER_MODIFY (1 << 9)
|
||||
#define PSR_EVENT_WD_TIMER_EXPIRE (1 << 8)
|
||||
#define PSR_EVENT_PIPE_REGISTERS_UPDATE (1 << 6)
|
||||
#define PSR_EVENT_REGISTER_UPDATE (1 << 5) /* Reserved in ICL+ */
|
||||
#define PSR_EVENT_HDCP_ENABLE (1 << 4)
|
||||
#define PSR_EVENT_KVMR_SESSION_ENABLE (1 << 3)
|
||||
#define PSR_EVENT_VBI_ENABLE (1 << 2)
|
||||
#define PSR_EVENT_LPSP_MODE_EXIT (1 << 1)
|
||||
#define PSR_EVENT_PSR_DISABLE (1 << 0)
|
||||
#define PSR_EVENT_PSR2_WD_TIMER_EXPIRE REG_BIT(17)
|
||||
#define PSR_EVENT_PSR2_DISABLED REG_BIT(16)
|
||||
#define PSR_EVENT_SU_DIRTY_FIFO_UNDERRUN REG_BIT(15)
|
||||
#define PSR_EVENT_SU_CRC_FIFO_UNDERRUN REG_BIT(14)
|
||||
#define PSR_EVENT_GRAPHICS_RESET REG_BIT(12)
|
||||
#define PSR_EVENT_PCH_INTERRUPT REG_BIT(11)
|
||||
#define PSR_EVENT_MEMORY_UP REG_BIT(10)
|
||||
#define PSR_EVENT_FRONT_BUFFER_MODIFY REG_BIT(9)
|
||||
#define PSR_EVENT_WD_TIMER_EXPIRE REG_BIT(8)
|
||||
#define PSR_EVENT_PIPE_REGISTERS_UPDATE REG_BIT(6)
|
||||
#define PSR_EVENT_REGISTER_UPDATE REG_BIT(5) /* Reserved in ICL+ */
|
||||
#define PSR_EVENT_HDCP_ENABLE REG_BIT(4)
|
||||
#define PSR_EVENT_KVMR_SESSION_ENABLE REG_BIT(3)
|
||||
#define PSR_EVENT_VBI_ENABLE REG_BIT(2)
|
||||
#define PSR_EVENT_LPSP_MODE_EXIT REG_BIT(1)
|
||||
#define PSR_EVENT_PSR_DISABLE REG_BIT(0)
|
||||
|
||||
#define _PSR2_STATUS_A 0x60940
|
||||
#define _PSR2_STATUS_EDP 0x6f940
|
||||
|
||||
@@ -117,9 +117,6 @@ struct intel_sdvo {
|
||||
|
||||
enum port port;
|
||||
|
||||
bool has_hdmi_monitor;
|
||||
bool has_hdmi_audio;
|
||||
|
||||
/* DDC bus used by this SDVO encoder */
|
||||
u8 ddc_bus;
|
||||
|
||||
@@ -1303,10 +1300,13 @@ static void i9xx_adjust_sdvo_tv_clock(struct intel_crtc_state *pipe_config)
|
||||
pipe_config->clock_set = true;
|
||||
}
|
||||
|
||||
static bool intel_has_hdmi_sink(struct intel_sdvo *sdvo,
|
||||
static bool intel_has_hdmi_sink(struct intel_sdvo_connector *intel_sdvo_connector,
|
||||
const struct drm_connector_state *conn_state)
|
||||
{
|
||||
return sdvo->has_hdmi_monitor &&
|
||||
struct drm_connector *connector = conn_state->connector;
|
||||
|
||||
return intel_sdvo_connector->is_hdmi &&
|
||||
connector->display_info.is_hdmi &&
|
||||
READ_ONCE(to_intel_digital_connector_state(conn_state)->force_audio) != HDMI_AUDIO_OFF_DVI;
|
||||
}
|
||||
|
||||
@@ -1326,7 +1326,9 @@ static bool intel_sdvo_has_audio(struct intel_encoder *encoder,
|
||||
const struct intel_crtc_state *crtc_state,
|
||||
const struct drm_connector_state *conn_state)
|
||||
{
|
||||
struct intel_sdvo *intel_sdvo = to_sdvo(encoder);
|
||||
struct drm_connector *connector = conn_state->connector;
|
||||
struct intel_sdvo_connector *intel_sdvo_connector =
|
||||
to_intel_sdvo_connector(connector);
|
||||
const struct intel_digital_connector_state *intel_conn_state =
|
||||
to_intel_digital_connector_state(conn_state);
|
||||
|
||||
@@ -1334,7 +1336,8 @@ static bool intel_sdvo_has_audio(struct intel_encoder *encoder,
|
||||
return false;
|
||||
|
||||
if (intel_conn_state->force_audio == HDMI_AUDIO_AUTO)
|
||||
return intel_sdvo->has_hdmi_audio;
|
||||
return intel_sdvo_connector->is_hdmi &&
|
||||
connector->display_info.has_audio;
|
||||
else
|
||||
return intel_conn_state->force_audio == HDMI_AUDIO_ON;
|
||||
}
|
||||
@@ -1351,6 +1354,7 @@ static int intel_sdvo_compute_config(struct intel_encoder *encoder,
|
||||
|
||||
DRM_DEBUG_KMS("forcing bpc to 8 for SDVO\n");
|
||||
pipe_config->pipe_bpp = 8*3;
|
||||
pipe_config->sink_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;
|
||||
|
||||
if (HAS_PCH_SPLIT(to_i915(encoder->base.dev)))
|
||||
@@ -1400,7 +1404,7 @@ static int intel_sdvo_compute_config(struct intel_encoder *encoder,
|
||||
pipe_config->pixel_multiplier =
|
||||
intel_sdvo_get_pixel_multiplier(adjusted_mode);
|
||||
|
||||
pipe_config->has_hdmi_sink = intel_has_hdmi_sink(intel_sdvo, conn_state);
|
||||
pipe_config->has_hdmi_sink = intel_has_hdmi_sink(intel_sdvo_connector, conn_state);
|
||||
|
||||
pipe_config->has_audio =
|
||||
intel_sdvo_has_audio(encoder, pipe_config, conn_state) &&
|
||||
@@ -1906,7 +1910,7 @@ intel_sdvo_mode_valid(struct drm_connector *connector,
|
||||
struct intel_sdvo_connector *intel_sdvo_connector =
|
||||
to_intel_sdvo_connector(connector);
|
||||
int max_dotclk = to_i915(connector->dev)->max_dotclk_freq;
|
||||
bool has_hdmi_sink = intel_has_hdmi_sink(intel_sdvo, connector->state);
|
||||
bool has_hdmi_sink = intel_has_hdmi_sink(intel_sdvo_connector, connector->state);
|
||||
int clock = mode->clock;
|
||||
|
||||
if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
|
||||
@@ -2032,36 +2036,35 @@ intel_sdvo_multifunc_encoder(struct intel_sdvo *intel_sdvo)
|
||||
return hweight16(intel_sdvo->caps.output_flags) > 1;
|
||||
}
|
||||
|
||||
static struct edid *
|
||||
static const struct drm_edid *
|
||||
intel_sdvo_get_edid(struct drm_connector *connector)
|
||||
{
|
||||
struct intel_sdvo *sdvo = intel_attached_sdvo(to_intel_connector(connector));
|
||||
return drm_get_edid(connector, &sdvo->ddc);
|
||||
return drm_edid_read_ddc(connector, &sdvo->ddc);
|
||||
}
|
||||
|
||||
/* Mac mini hack -- use the same DDC as the analog connector */
|
||||
static struct edid *
|
||||
static const struct drm_edid *
|
||||
intel_sdvo_get_analog_edid(struct drm_connector *connector)
|
||||
{
|
||||
struct drm_i915_private *dev_priv = to_i915(connector->dev);
|
||||
struct drm_i915_private *i915 = to_i915(connector->dev);
|
||||
struct i2c_adapter *i2c;
|
||||
|
||||
return drm_get_edid(connector,
|
||||
intel_gmbus_get_adapter(dev_priv,
|
||||
dev_priv->display.vbt.crt_ddc_pin));
|
||||
i2c = intel_gmbus_get_adapter(i915, i915->display.vbt.crt_ddc_pin);
|
||||
|
||||
return drm_edid_read_ddc(connector, i2c);
|
||||
}
|
||||
|
||||
static enum drm_connector_status
|
||||
intel_sdvo_tmds_sink_detect(struct drm_connector *connector)
|
||||
{
|
||||
struct intel_sdvo *intel_sdvo = intel_attached_sdvo(to_intel_connector(connector));
|
||||
struct intel_sdvo_connector *intel_sdvo_connector =
|
||||
to_intel_sdvo_connector(connector);
|
||||
enum drm_connector_status status;
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
|
||||
edid = intel_sdvo_get_edid(connector);
|
||||
drm_edid = intel_sdvo_get_edid(connector);
|
||||
|
||||
if (edid == NULL && intel_sdvo_multifunc_encoder(intel_sdvo)) {
|
||||
if (!drm_edid && intel_sdvo_multifunc_encoder(intel_sdvo)) {
|
||||
u8 ddc, saved_ddc = intel_sdvo->ddc_bus;
|
||||
|
||||
/*
|
||||
@@ -2070,15 +2073,15 @@ intel_sdvo_tmds_sink_detect(struct drm_connector *connector)
|
||||
*/
|
||||
for (ddc = intel_sdvo->ddc_bus >> 1; ddc > 1; ddc >>= 1) {
|
||||
intel_sdvo->ddc_bus = ddc;
|
||||
edid = intel_sdvo_get_edid(connector);
|
||||
if (edid)
|
||||
drm_edid = intel_sdvo_get_edid(connector);
|
||||
if (drm_edid)
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* If we found the EDID on the other bus,
|
||||
* assume that is the correct DDC bus.
|
||||
*/
|
||||
if (edid == NULL)
|
||||
if (!drm_edid)
|
||||
intel_sdvo->ddc_bus = saved_ddc;
|
||||
}
|
||||
|
||||
@@ -2086,21 +2089,19 @@ intel_sdvo_tmds_sink_detect(struct drm_connector *connector)
|
||||
* When there is no edid and no monitor is connected with VGA
|
||||
* port, try to use the CRT ddc to read the EDID for DVI-connector.
|
||||
*/
|
||||
if (edid == NULL)
|
||||
edid = intel_sdvo_get_analog_edid(connector);
|
||||
if (!drm_edid)
|
||||
drm_edid = intel_sdvo_get_analog_edid(connector);
|
||||
|
||||
status = connector_status_unknown;
|
||||
if (edid != NULL) {
|
||||
if (drm_edid) {
|
||||
const struct edid *edid = drm_edid_raw(drm_edid);
|
||||
|
||||
/* DDC bus is shared, match EDID to connector type */
|
||||
if (edid->input & DRM_EDID_INPUT_DIGITAL) {
|
||||
if (edid->input & DRM_EDID_INPUT_DIGITAL)
|
||||
status = connector_status_connected;
|
||||
if (intel_sdvo_connector->is_hdmi) {
|
||||
intel_sdvo->has_hdmi_monitor = drm_detect_hdmi_monitor(edid);
|
||||
intel_sdvo->has_hdmi_audio = drm_detect_monitor_audio(edid);
|
||||
}
|
||||
} else
|
||||
else
|
||||
status = connector_status_disconnected;
|
||||
kfree(edid);
|
||||
drm_edid_free(drm_edid);
|
||||
}
|
||||
|
||||
return status;
|
||||
@@ -2108,8 +2109,9 @@ intel_sdvo_tmds_sink_detect(struct drm_connector *connector)
|
||||
|
||||
static bool
|
||||
intel_sdvo_connector_matches_edid(struct intel_sdvo_connector *sdvo,
|
||||
struct edid *edid)
|
||||
const struct drm_edid *drm_edid)
|
||||
{
|
||||
const struct edid *edid = drm_edid_raw(drm_edid);
|
||||
bool monitor_is_digital = !!(edid->input & DRM_EDID_INPUT_DIGITAL);
|
||||
bool connector_is_digital = !!IS_DIGITAL(sdvo);
|
||||
|
||||
@@ -2147,30 +2149,28 @@ intel_sdvo_detect(struct drm_connector *connector, bool force)
|
||||
|
||||
intel_sdvo->attached_output = response;
|
||||
|
||||
intel_sdvo->has_hdmi_monitor = false;
|
||||
intel_sdvo->has_hdmi_audio = false;
|
||||
|
||||
if ((intel_sdvo_connector->output_flag & response) == 0)
|
||||
ret = connector_status_disconnected;
|
||||
else if (IS_TMDS(intel_sdvo_connector))
|
||||
ret = intel_sdvo_tmds_sink_detect(connector);
|
||||
else {
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
|
||||
/* if we have an edid check it matches the connection */
|
||||
edid = intel_sdvo_get_edid(connector);
|
||||
if (edid == NULL)
|
||||
edid = intel_sdvo_get_analog_edid(connector);
|
||||
if (edid != NULL) {
|
||||
drm_edid = intel_sdvo_get_edid(connector);
|
||||
if (!drm_edid)
|
||||
drm_edid = intel_sdvo_get_analog_edid(connector);
|
||||
if (drm_edid) {
|
||||
if (intel_sdvo_connector_matches_edid(intel_sdvo_connector,
|
||||
edid))
|
||||
drm_edid))
|
||||
ret = connector_status_connected;
|
||||
else
|
||||
ret = connector_status_disconnected;
|
||||
|
||||
kfree(edid);
|
||||
} else
|
||||
drm_edid_free(drm_edid);
|
||||
} else {
|
||||
ret = connector_status_connected;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
@@ -2179,13 +2179,13 @@ intel_sdvo_detect(struct drm_connector *connector, bool force)
|
||||
static int intel_sdvo_get_ddc_modes(struct drm_connector *connector)
|
||||
{
|
||||
int num_modes = 0;
|
||||
struct edid *edid;
|
||||
const struct drm_edid *drm_edid;
|
||||
|
||||
DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
|
||||
connector->base.id, connector->name);
|
||||
|
||||
/* set the bus switch and get the modes */
|
||||
edid = intel_sdvo_get_edid(connector);
|
||||
drm_edid = intel_sdvo_get_edid(connector);
|
||||
|
||||
/*
|
||||
* Mac mini hack. On this device, the DVI-I connector shares one DDC
|
||||
@@ -2193,17 +2193,17 @@ static int intel_sdvo_get_ddc_modes(struct drm_connector *connector)
|
||||
* DDC fails, check to see if the analog output is disconnected, in
|
||||
* which case we'll look there for the digital DDC data.
|
||||
*/
|
||||
if (!edid)
|
||||
edid = intel_sdvo_get_analog_edid(connector);
|
||||
if (!drm_edid)
|
||||
drm_edid = intel_sdvo_get_analog_edid(connector);
|
||||
|
||||
if (!edid)
|
||||
if (!drm_edid)
|
||||
return 0;
|
||||
|
||||
if (intel_sdvo_connector_matches_edid(to_intel_sdvo_connector(connector),
|
||||
edid))
|
||||
num_modes += intel_connector_update_modes(connector, edid);
|
||||
drm_edid))
|
||||
num_modes += intel_connector_update_modes(connector, drm_edid);
|
||||
|
||||
kfree(edid);
|
||||
drm_edid_free(drm_edid);
|
||||
|
||||
return num_modes;
|
||||
}
|
||||
|
||||
@@ -2007,11 +2007,16 @@ void intel_mpllb_state_verify(struct intel_atomic_state *state,
|
||||
if (!new_crtc_state->hw.active)
|
||||
return;
|
||||
|
||||
/* intel_get_crtc_new_encoder() only works for modeset/fastset commits */
|
||||
if (!intel_crtc_needs_modeset(new_crtc_state) &&
|
||||
!intel_crtc_needs_fastset(new_crtc_state))
|
||||
return;
|
||||
|
||||
encoder = intel_get_crtc_new_encoder(state, new_crtc_state);
|
||||
intel_mpllb_readout_hw_state(encoder, &mpllb_hw_state);
|
||||
|
||||
#define MPLLB_CHECK(__name) \
|
||||
I915_STATE_WARN(mpllb_sw_state->__name != mpllb_hw_state.__name, \
|
||||
I915_STATE_WARN(i915, mpllb_sw_state->__name != mpllb_hw_state.__name, \
|
||||
"[CRTC:%d:%s] mismatch in MPLLB: %s (expected 0x%08x, found 0x%08x)", \
|
||||
crtc->base.base.id, crtc->base.name, \
|
||||
__stringify(__name), \
|
||||
|
||||
@@ -16,16 +16,6 @@ struct intel_crtc_state;
|
||||
struct intel_plane_state;
|
||||
enum pipe;
|
||||
|
||||
/*
|
||||
* FIXME: We should instead only take spinlocks once for the entire update
|
||||
* instead of once per mmio.
|
||||
*/
|
||||
#if IS_ENABLED(CONFIG_PROVE_LOCKING)
|
||||
#define VBLANK_EVASION_TIME_US 250
|
||||
#else
|
||||
#define VBLANK_EVASION_TIME_US 100
|
||||
#endif
|
||||
|
||||
struct intel_plane *intel_sprite_plane_create(struct drm_i915_private *dev_priv,
|
||||
enum pipe pipe, int plane);
|
||||
int intel_sprite_set_colorkey_ioctl(struct drm_device *dev, void *data,
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user