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 08D62C54E71 for ; Tue, 20 May 2025 15:06:05 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 99A2610E542; Tue, 20 May 2025 15:06:05 +0000 (UTC) Authentication-Results: gabe.freedesktop.org; dkim=pass (2048-bit key; unprotected) header.d=intel.com header.i=@intel.com header.b="Ranp7lD6"; dkim-atps=neutral Received: from mgamail.intel.com (mgamail.intel.com [192.198.163.18]) by gabe.freedesktop.org (Postfix) with ESMTPS id 0F5AB10E5A5 for ; Tue, 20 May 2025 15:06:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1747753565; x=1779289565; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=M8K17PNowlsGvXKrv3flra9SiY7kZFHTI6zd4AUigsw=; b=Ranp7lD6rQde0MEIrmATNKslUi4ssdD1T6ktqiOkv4d54gjT2GO9DjK8 54sWQ+Dewqc8BHipmYA28bMiPucT3tMItBHIvx7KickwMwuthGP7Yhwyq fbqKk3b4IB/T7KDo7ePQLZWW7JZ2vrzMD81hy27mKOOOrUZLygnMjDmwe 1tJmF4+NBiMmhM3uIm5N3AaLE09ChmkkKpES1VTw4Dq0nMJLy/hop/yjy +wbHGkJlRT9+9FmIOZyM4JI4BSJDnuvGQAWZte6wRItdHTONAA89XDJzh MpqLVuYpRXzxS1jTSVQPaDP/IXVgsTcGdh8XgpA6mPZIcb1ywH5pKmBbW Q==; X-CSE-ConnectionGUID: 6s+AtOsdT0CQp1M9vao9lg== X-CSE-MsgGUID: GuUMsMKDR5qanPfICp1BmQ== X-IronPort-AV: E=McAfee;i="6700,10204,11439"; a="48948069" X-IronPort-AV: E=Sophos;i="6.15,302,1739865600"; d="scan'208";a="48948069" Received: from fmviesa009.fm.intel.com ([10.60.135.149]) by fmvoesa112.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 May 2025 08:06:01 -0700 X-CSE-ConnectionGUID: O9hx6MW4QGiH/yjLUEMHSQ== X-CSE-MsgGUID: UnwoJhcMRLyKsMoBdQJ78w== X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="6.15,302,1739865600"; d="scan'208";a="140729373" Received: from lucas-s2600cw.jf.intel.com ([10.165.21.196]) by fmviesa009-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 May 2025 08:05:59 -0700 From: Lucas De Marchi To: intel-xe@lists.freedesktop.org Cc: Lucas De Marchi , Riana Tauro , Rodrigo Vivi , Matt Roper Subject: [PATCH] drm/xe: Add configfs to load with fewer engines Date: Tue, 20 May 2025 08:04:28 -0700 Message-ID: <20250520-engine-mask-v1-1-ce6daf16d23b@intel.com> X-Mailer: git-send-email 2.49.0 MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" X-Change-ID: 20250520-engine-mask-f6f5962afa42 X-Mailer: b4 0.15-dev-f7671 Content-Transfer-Encoding: 8bit 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" Sometimes it's useful to load the driver with a smaller set of engines to allow more targeted debugging, particularly on early enabling. Add a file in configfs that allows enable only a set of engines. Signed-off-by: Lucas De Marchi --- drivers/gpu/drm/xe/xe_configfs.c | 133 ++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/xe/xe_configfs.h | 2 + drivers/gpu/drm/xe/xe_hw_engine.c | 20 ++++++ 3 files changed, 155 insertions(+) diff --git a/drivers/gpu/drm/xe/xe_configfs.c b/drivers/gpu/drm/xe/xe_configfs.c index cb9f175c89a1c..fb433503501c8 100644 --- a/drivers/gpu/drm/xe/xe_configfs.c +++ b/drivers/gpu/drm/xe/xe_configfs.c @@ -3,14 +3,18 @@ * Copyright © 2025 Intel Corporation */ +#include #include #include #include #include +#include #include "xe_configfs.h" #include "xe_module.h" +#include "xe_hw_engine_types.h" + /** * DOC: Xe Configfs * @@ -48,6 +52,23 @@ * # echo 1 > /sys/kernel/config/xe/0000:03:00.0/survivability_mode * # echo 0000:03:00.0 > /sys/bus/pci/drivers/xe/bind (Enters survivability mode if supported) * + * Allowed engine: + * --------------- + * + * Allow only a set of engine(s) to be available - this is the equivalent of + * fusing engines off in software. Examples: + * + * Allow only one render and one copy engines, nothing else:: + * + * # echo 'rcs0,bcs0' > /sys/kernel/config/xe/0000:03:00.0/engine_allowed + * + * Allow only compute engines and first copy engine:: + * + * # echo 'ccs*,bcs0' > /sys/kernel/config/xe/0000:03:00.0/engine_allowed + * + * The requested configuration may not be supported by the platform and driver + * may fail to probe - intended for debugging purposes. + * * Remove devices * ============== * @@ -60,6 +81,7 @@ struct xe_config_device { struct config_group group; bool survivability_mode; + u64 engine_allowed; /* protects attributes */ struct mutex lock; @@ -94,10 +116,95 @@ static ssize_t survivability_mode_store(struct config_item *item, const char *pa return len; } +static ssize_t engine_allowed_show(struct config_item *item, char *page) +{ + struct xe_config_device *dev = to_xe_config_device(item); + + return sprintf(page, "%#llx\n", dev->engine_allowed); +} + +static bool lookup_engine_mask(const char *name, size_t namelen, u64 *mask) +{ + static const struct { + const char *cls; + u64 mask; + } map[] = { + { .cls = "rcs", .mask = XE_HW_ENGINE_RCS_MASK }, + { .cls = "bcs", .mask = XE_HW_ENGINE_BCS_MASK }, + { .cls = "vcs", .mask = XE_HW_ENGINE_VCS_MASK }, + { .cls = "vecs", .mask = XE_HW_ENGINE_VECS_MASK }, + { .cls = "ccs", .mask = XE_HW_ENGINE_CCS_MASK }, + }; + size_t i; + + for (i = 0; i < ARRAY_SIZE(map); i++) { + size_t clslen = strlen(map[i].cls); + size_t numlen = namelen - clslen; + char instancestr[4]; + u8 instance; + + if (namelen < clslen + 1 || strncmp(name, map[i].cls, clslen)) + continue; + + if (name[clslen] == '*' && numlen == 1) { + *mask = map[i].mask; + return true; + } + + if (numlen > sizeof(instancestr) - 1) + return false; + + memcpy(instancestr, name + clslen, numlen); + instancestr[numlen] = '\0'; + + if (!kstrtou8(instancestr, 10, &instance)) { + u16 bit = __ffs64(map[i].mask) + instance; + u64 val; + + if (bit > sizeof(val) * BITS_PER_BYTE) + return false; + + val = BIT_ULL(bit); + if ((val | map[i].mask) == map[i].mask) { + *mask = val; + return true; + } + } + + return false; + } + + return false; +} + +static ssize_t engine_allowed_store(struct config_item *item, const char *page, + size_t len) +{ + struct xe_config_device *dev = to_xe_config_device(item); + size_t namelen, p; + u64 mask, val = 0; + + for (p = 0; p < len; p += namelen + 1) { + namelen = strcspn(page + p, ",\n"); + if (!lookup_engine_mask(page + p, namelen, &mask)) + return -EINVAL; + + val |= mask; + } + + mutex_lock(&dev->lock); + dev->engine_allowed = val; + mutex_unlock(&dev->lock); + + return len; +} + CONFIGFS_ATTR(, survivability_mode); +CONFIGFS_ATTR(, engine_allowed); static struct configfs_attribute *xe_config_device_attrs[] = { &attr_survivability_mode, + &attr_engine_allowed, NULL, }; @@ -139,6 +246,9 @@ static struct config_group *xe_config_make_device_group(struct config_group *gro if (!dev) return ERR_PTR(-ENOMEM); + /* Default values */ + dev->engine_allowed = U64_MAX; + config_group_init_type_name(&dev->group, name, &xe_config_device_type); mutex_init(&dev->lock); @@ -226,6 +336,29 @@ void xe_configfs_clear_survivability_mode(struct pci_dev *pdev) config_item_put(&dev->group.cg_item); } +/** + * xe_configfs_get_engine_allowed - get engine allowed mask from configfs + * @pdev: pci device + * + * Find the configfs group that belongs to the pci device and return + * the mask of engines allowed to be used. + * + * Return: engine mask with allowed engines + */ +u64 xe_configfs_get_engine_allowed(struct pci_dev *pdev) +{ + struct xe_config_device *dev = configfs_find_group(pdev); + u64 engine_allowed; + + if (!dev) + return U64_MAX; + + engine_allowed = dev->engine_allowed; + config_item_put(&dev->group.cg_item); + + return engine_allowed; +} + int __init xe_configfs_init(void) { struct config_group *root = &xe_configfs.su_group; diff --git a/drivers/gpu/drm/xe/xe_configfs.h b/drivers/gpu/drm/xe/xe_configfs.h index d7d041ec26117..e7b4894bfc7be 100644 --- a/drivers/gpu/drm/xe/xe_configfs.h +++ b/drivers/gpu/drm/xe/xe_configfs.h @@ -14,11 +14,13 @@ int xe_configfs_init(void); void xe_configfs_exit(void); bool xe_configfs_get_survivability_mode(struct pci_dev *pdev); void xe_configfs_clear_survivability_mode(struct pci_dev *pdev); +u64 xe_configfs_get_engine_allowed(struct pci_dev *pdev); #else static inline int xe_configfs_init(void) { return 0; }; static inline void xe_configfs_exit(void) {}; static inline bool xe_configfs_get_survivability_mode(struct pci_dev *pdev) { return false; }; static inline void xe_configfs_clear_survivability_mode(struct pci_dev *pdev) {}; +u64 xe_configfs_get_engine_allowed(struct pci_dev *pdev) { return U64_MAX; } #endif #endif diff --git a/drivers/gpu/drm/xe/xe_hw_engine.c b/drivers/gpu/drm/xe/xe_hw_engine.c index 93241fd0a4ba3..af750ed8c0f00 100644 --- a/drivers/gpu/drm/xe/xe_hw_engine.c +++ b/drivers/gpu/drm/xe/xe_hw_engine.c @@ -17,6 +17,7 @@ #include "regs/xe_irq_regs.h" #include "xe_assert.h" #include "xe_bo.h" +#include "xe_configfs.h" #include "xe_device.h" #include "xe_execlist.h" #include "xe_force_wake.h" @@ -810,6 +811,24 @@ static void check_gsc_availability(struct xe_gt *gt) } } +static void check_sw_fuses(struct xe_gt *gt) +{ + struct xe_device *xe = gt_to_xe(gt); + u64 sw_allowed = xe_configfs_get_engine_allowed(to_pci_dev(xe->drm.dev)); + enum xe_hw_engine_id id; + + for (id = 0; id < XE_NUM_HW_ENGINES; ++id) { + if (!(gt->info.engine_mask & BIT(id))) + continue; + + if (!(sw_allowed & BIT(id))) { + gt->info.engine_mask &= ~BIT(id); + drm_info(&xe->drm, "%s fused off (in sw)\n", + engine_infos[id].name); + } + } +} + int xe_hw_engines_init_early(struct xe_gt *gt) { int i; @@ -818,6 +837,7 @@ int xe_hw_engines_init_early(struct xe_gt *gt) read_copy_fuses(gt); read_compute_fuses(gt); check_gsc_availability(gt); + check_sw_fuses(gt); BUILD_BUG_ON(XE_HW_ENGINE_PREEMPT_TIMEOUT < XE_HW_ENGINE_PREEMPT_TIMEOUT_MIN); BUILD_BUG_ON(XE_HW_ENGINE_PREEMPT_TIMEOUT > XE_HW_ENGINE_PREEMPT_TIMEOUT_MAX);