From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id E9B83CCF9F8 for ; Sat, 8 Nov 2025 00:06:59 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id A766810EBBD; Sat, 8 Nov 2025 00:06:59 +0000 (UTC) Authentication-Results: gabe.freedesktop.org; dkim=pass (2048-bit key; unprotected) header.d=intel.com header.i=@intel.com header.b="E6gnZLom"; dkim-atps=neutral Received: from mgamail.intel.com (mgamail.intel.com [198.175.65.21]) by gabe.freedesktop.org (Postfix) with ESMTPS id 2147510EBBA; Sat, 8 Nov 2025 00:06:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1762560418; x=1794096418; h=from:date:subject:mime-version:content-transfer-encoding: message-id:references:in-reply-to:to:cc; bh=68DJ+t67Bnvr9UKAXIXkwqMJXn1usk/AOSwNXsKJnX4=; b=E6gnZLomDLOvx5fXV9YWswBcg+EwRGGiWN1HFBRooPzLDeIqPJxqBsnS uT665aIjakhD+9kA/BpNg2/qgl4v8eo0cI57iIQEjSdcRnDLV9I3mxBKR 9beNR7OFGm26OFt9Z468UKj6Nme3wbi3LpMHd9s5wNGJF51ztKhxoMaj2 quSLVOQKgcDPhH3mzMkYaXaQl9rIhHgXwCTfBXHqanC+7TMPxMCFUVvAc aeVM31jIl+p32WM55QxtZbCk1Audg2R5YONXl3cuwiJI0ixP1b6aS+YjQ tet8X2tpAI4CsOdK5/7G2JXl3CUYwWbltEw/iwGOOzNVx0gk3FiO9zfJd Q==; X-CSE-ConnectionGUID: XTeW8BywRYOpwq5zlr/3IA== X-CSE-MsgGUID: N6chswHASF+AwmB6W0+aCg== X-IronPort-AV: E=McAfee;i="6800,10657,11531"; a="64621281" X-IronPort-AV: E=Sophos;i="6.17,312,1747724400"; d="scan'208";a="64621281" Received: from orviesa002.jf.intel.com ([10.64.159.142]) by orvoesa113.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Nov 2025 16:06:58 -0800 X-CSE-ConnectionGUID: /q8qBNiPR9Kz4jH4YyqKoQ== X-CSE-MsgGUID: F6WGrcI8SOC8qaqjCNg1Og== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.19,288,1754982000"; d="scan'208";a="218822634" Received: from mgerlach-mobl1.amr.corp.intel.com (HELO [192.168.1.16]) ([10.124.222.137]) by orviesa002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 07 Nov 2025 16:06:55 -0800 From: Gustavo Sousa Date: Fri, 07 Nov 2025 21:05:40 -0300 Subject: [PATCH v4 07/11] drm/i915/xe3p_lpd: Extend Type-C flow for static DDI allocation MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20251107-xe3p_lpd-basic-enabling-v4-7-ab3367f65f15@intel.com> References: <20251107-xe3p_lpd-basic-enabling-v4-0-ab3367f65f15@intel.com> In-Reply-To: <20251107-xe3p_lpd-basic-enabling-v4-0-ab3367f65f15@intel.com> To: intel-xe@lists.freedesktop.org, intel-gfx@lists.freedesktop.org Cc: Ankit Nautiyal , Dnyaneshwar Bhadane , Gustavo Sousa , =?utf-8?q?Jouni_H=C3=B6gander?= , Juha-pekka Heikkila , Luca Coelho , Lucas De Marchi , Matt Atwood , Matt Roper , Ravi Kumar Vodapalli , Shekhar Chauhan , Vinod Govindapillai X-Mailer: b4 0.15-dev X-BeenThere: intel-xe@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel Xe graphics driver List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-xe-bounces@lists.freedesktop.org Sender: "Intel-xe" Xe3p_LPD has a new feature that allows the driver to allocate at runtime the DDI (TC ones) port to drive a legacy connection on the Type-C subsystem. This allows better resource utilization, because now there is no need to statically reserve ports for legacy connectors on the Type-C subsystem. That said, our driver is not yet ready for the dynamic allocation. Thus, as an incremental step, let's add the logic containing the required programming sequence for the allocation, but, instead of selecting the first available port, we try so use the 1:1 mapping expected by the driver today. Bspec: 68954 Co-developed-by: Dnyaneshwar Bhadane Signed-off-by: Dnyaneshwar Bhadane Signed-off-by: Gustavo Sousa --- NOTE: This patch is still a WIP. There are some opens to resolve here. Nevertheless, I'm sending it here for early feedback. For the HIP-index stuff, I have a local refactor started and need to finish it up and send it. The other open is about concurrent calls to iom_dp_resource_lock(). It is likely that we need to have a software lock to prevent concurrent access to IOM_DP_HW_RESOURCE_SEMAPHORE from our driver. --- drivers/gpu/drm/i915/display/intel_display_regs.h | 20 ++- drivers/gpu/drm/i915/display/intel_tc.c | 151 +++++++++++++++++++++- 2 files changed, 169 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/drm/i915/display/intel_display_regs.h b/drivers/gpu/drm/i915/display/intel_display_regs.h index 89ea0156ee06..0cf7d43ce210 100644 --- a/drivers/gpu/drm/i915/display/intel_display_regs.h +++ b/drivers/gpu/drm/i915/display/intel_display_regs.h @@ -2908,6 +2908,25 @@ enum skl_power_gate { #define DP_PIN_ASSIGNMENT(idx, x) ((x) << ((idx) * 4)) /* See enum intel_tc_pin_assignment for the pin assignment field values. */ +/* + * FIXME: There is also a definition for this register in intel_dkl_phy_regs.h. + * We need to consolidate the definitions. + */ +#define HIP_INDEX_REG0 _MMIO(0x1010a0) +#define HIP_168_INDEX_MASK REG_GENMASK(3, 0) +#define HIP_168_IOM_RES_MGMT REG_FIELD_PREP(HIP_168_INDEX_MASK, 0x1) + +#define IOM_DP_HW_RESOURCE_SEMAPHORE _MMIO(0x168038) +#define IOM_DP_HW_SEMLOCK REG_BIT(31) +#define IOM_REQUESTOR_ID_MASK REG_GENMASK(3, 0) +#define IOM_REQUESTOR_ID_DISPLAY_ENGINE REG_FIELD_PREP(IOM_REQUESTOR_ID_MASK, 0x4) + +#define IOM_DP_RESOURCE_MNG _MMIO(0x16802c) +#define IOM_DDI_CONSUMER_SHIFT(tc_port) ((tc_port) * 4) +#define IOM_DDI_CONSUMER_MASK(tc_port) (0xf << IOM_DDI_CONSUMER_SHIFT(tc_port)) +#define IOM_DDI_CONSUMER(tc_port, x) ((x) << IOM_DDI_CONSUMER_SHIFT(tc_port)) +#define IOM_DDI_CONSUMER_STATIC_TC(tc_port) IOM_DDI_CONSUMER(tc_port, 0x8 + (tc_port)) + #define _TCSS_DDI_STATUS_1 0x161500 #define _TCSS_DDI_STATUS_2 0x161504 #define TCSS_DDI_STATUS(tc) _MMIO(_PICK_EVEN(tc, \ @@ -2946,5 +2965,4 @@ enum skl_power_gate { #define MTL_TRDPRE_MASK REG_GENMASK(7, 0) - #endif /* __INTEL_DISPLAY_REGS_H__ */ diff --git a/drivers/gpu/drm/i915/display/intel_tc.c b/drivers/gpu/drm/i915/display/intel_tc.c index 7e17ca018748..3c333999bbe4 100644 --- a/drivers/gpu/drm/i915/display/intel_tc.c +++ b/drivers/gpu/drm/i915/display/intel_tc.c @@ -9,6 +9,7 @@ #include "i915_reg.h" #include "intel_atomic.h" +#include "intel_bios.h" #include "intel_cx0_phy_regs.h" #include "intel_ddi.h" #include "intel_de.h" @@ -25,6 +26,9 @@ #include "intel_modeset_lock.h" #include "intel_tc.h" +#define IOM_DP_RES_SEMAPHORE_LOCK_TIMEOUT_US 10 +#define IOM_DP_RES_SEMAPHORE_RETRY_TIMEOUT_US 10000 + enum tc_port_mode { TC_PORT_DISCONNECTED, TC_PORT_TBT_ALT, @@ -1200,6 +1204,143 @@ static void xelpdp_tc_phy_get_hw_state(struct intel_tc_port *tc) __tc_cold_unblock(tc, domain, tc_cold_wref); } +static void iom_res_mgmt_prepare_reg_access(struct intel_display *display) +{ + /* + * IOM resource management registers live in the 2nd 4KB page of IOM + * address space. So we need to configure HIP_INDEX_REG0 with the + * correct index. + * + * FIXME: We need to have this and dekel PHY implementation using a + * common abstraction to access registers on the HIP-indexed ranges, and + * this function would then be dropped. + */ + intel_de_rmw(display, HIP_INDEX_REG0, + HIP_168_INDEX_MASK, HIP_168_IOM_RES_MGMT); +} + +/* + * FIXME: This function also needs to avoid concurrent accesses from the driver + * itself, possibly via a software lock. + */ +static int iom_dp_resource_lock(struct intel_tc_port *tc) +{ + struct intel_display *display = to_intel_display(tc->dig_port); + u32 val = IOM_DP_HW_SEMLOCK | IOM_REQUESTOR_ID_DISPLAY_ENGINE; + int ret; + + iom_res_mgmt_prepare_reg_access(display); + ret = poll_timeout_us(intel_de_write(display, IOM_DP_HW_RESOURCE_SEMAPHORE, val), + (intel_de_read(display, IOM_DP_HW_RESOURCE_SEMAPHORE) & val) == val, + IOM_DP_RES_SEMAPHORE_LOCK_TIMEOUT_US, + IOM_DP_RES_SEMAPHORE_RETRY_TIMEOUT_US, false); + + if (ret) + drm_err(display->drm, "Port %s: timeout trying to lock IOM semaphore\n", + tc->port_name); + + return ret; +} + +static void iom_dp_resource_unlock(struct intel_tc_port *tc) +{ + struct intel_display *display = to_intel_display(tc->dig_port); + + iom_res_mgmt_prepare_reg_access(display); + intel_de_write(display, IOM_DP_HW_RESOURCE_SEMAPHORE, IOM_REQUESTOR_ID_DISPLAY_ENGINE); +} + +static bool xe3p_tc_iom_allocate_ddi(struct intel_tc_port *tc, bool allocate) +{ + struct intel_display *display = to_intel_display(tc->dig_port); + struct intel_digital_port *dig_port = tc->dig_port; + enum tc_port tc_port = intel_encoder_to_tc(&dig_port->base); + u32 val; + u32 consumer; + u32 expected_consumer; + bool ret; + + if (DISPLAY_VER(display) < 35) + return true; + + if (tc->mode != TC_PORT_LEGACY) + return true; + + if (!intel_bios_encoder_supports_dyn_port_over_tc(dig_port->base.devdata)) + return true; + + if (iom_dp_resource_lock(tc)) + return false; + + val = intel_de_read(display, IOM_DP_RESOURCE_MNG); + + consumer = val & IOM_DDI_CONSUMER_MASK(tc_port); + consumer >>= IOM_DDI_CONSUMER_SHIFT(tc_port); + + /* + * Bspec instructs to select first available DDI, but our driver is not + * ready for such dynamic allocation yet. For now, we force a "static" + * allocation: map the physical port (where HPD happens) to the + * encoder's DDI (logical TC port, represented by tc_port). + */ + expected_consumer = IOM_DDI_CONSUMER_STATIC_TC(tc_port); + expected_consumer >>= IOM_DDI_CONSUMER_SHIFT(tc_port); + + if (allocate) { + struct intel_encoder *other_encoder; + + /* + * Check if this encoder's DDI is already allocated for another + * physical port, which could have happened prior to the driver + * taking over (e.g. GOP). + */ + for_each_intel_encoder(display->drm, other_encoder) { + enum tc_port other_tc_port = intel_encoder_to_tc(other_encoder); + u32 other_consumer; + + if (tc_port == TC_PORT_NONE || other_tc_port == tc_port) + continue; + + other_consumer = val & IOM_DDI_CONSUMER_MASK(other_tc_port); + other_consumer >>= IOM_DDI_CONSUMER_SHIFT(other_tc_port); + if (other_consumer == expected_consumer) { + drm_err(display->drm, "Port %s: expected consumer %u already allocated another DDI; IOM_DP_RESOURCE_MNG=0x%08x\n", + tc->port_name, expected_consumer, val); + ret = false; + goto out_resource_unlock; + } + } + + if (consumer == 0) { + /* DDI is free to use, let's allocate it. */ + val &= ~IOM_DDI_CONSUMER_MASK(tc_port); + val |= IOM_DDI_CONSUMER(tc_port, expected_consumer); + intel_de_write(display, IOM_DP_RESOURCE_MNG, val); + ret = true; + } else if (consumer == expected_consumer) { + /* + * Nothing to do, as the expected "static" DDI allocation is + * already in place. + */ + ret = true; + } else { + drm_err(display->drm, "Port %s: DDI already allocated for consumer %u; IOM_DP_RESOURCE_MNG=0x%08x\n", + tc->port_name, consumer, val); + ret = false; + } + } else { + drm_WARN_ON(display->drm, consumer != expected_consumer); + val &= ~IOM_DDI_CONSUMER_MASK(tc_port); + intel_de_write(display, IOM_DP_RESOURCE_MNG, val); + ret = true; + } + +out_resource_unlock: + iom_dp_resource_unlock(tc); + + return ret; +} + static bool xelpdp_tc_phy_connect(struct intel_tc_port *tc, int required_lanes) { tc->lock_wakeref = tc_cold_block(tc); @@ -1210,9 +1351,12 @@ static bool xelpdp_tc_phy_connect(struct intel_tc_port *tc, int required_lanes) return true; } - if (!xelpdp_tc_phy_enable_tcss_power(tc, true)) + if (!xe3p_tc_iom_allocate_ddi(tc, true)) goto out_unblock_tccold; + if (!xelpdp_tc_phy_enable_tcss_power(tc, true)) + goto out_deallocate_ddi; + xelpdp_tc_phy_take_ownership(tc, true); read_pin_configuration(tc); @@ -1226,6 +1370,9 @@ static bool xelpdp_tc_phy_connect(struct intel_tc_port *tc, int required_lanes) xelpdp_tc_phy_take_ownership(tc, false); xelpdp_tc_phy_wait_for_tcss_power(tc, false); +out_deallocate_ddi: + xe3p_tc_iom_allocate_ddi(tc, false); + out_unblock_tccold: tc_cold_unblock(tc, fetch_and_zero(&tc->lock_wakeref)); @@ -1236,6 +1383,8 @@ static void xelpdp_tc_phy_disconnect(struct intel_tc_port *tc) { switch (tc->mode) { case TC_PORT_LEGACY: + xe3p_tc_iom_allocate_ddi(tc, false); + fallthrough; case TC_PORT_DP_ALT: xelpdp_tc_phy_take_ownership(tc, false); xelpdp_tc_phy_enable_tcss_power(tc, false); -- 2.51.0