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 08BDFC6FD18 for ; Wed, 19 Apr 2023 17:55:06 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id B252810EA39; Wed, 19 Apr 2023 17:55:06 +0000 (UTC) Received: from mga06.intel.com (mga06b.intel.com [134.134.136.31]) by gabe.freedesktop.org (Postfix) with ESMTPS id 8F2D410EA39 for ; Wed, 19 Apr 2023 17:55:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1681926904; x=1713462904; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=6n/ngAARYaAx7JLmPVjF1iqikcS1yjt7gtg7ssynar4=; b=EtOhJiMukdfJulGEVL/0ATDT9F9Ynb6GxP1KBCK8bUvzlbzD3sSYu0dh myEe4vlM9vlTwNErOQH1cacT1BltwtfclLIgO7Ufq2J6rdtcTQWgjQwOG SzJtBe7E576Mec5+ewa+wCB/VxT7dLlLo/MzvNxIeLo697qByl0sZK2Wd yjAeS+T4Kc74M9dDaLJnIuke4831kmv33UkTmPOGxK4eCo9RfcSC46ydQ 41umjjc2zQA/Hq+HwO2/0h1R/PtnnmiTP3slY2AhQ5SkHk1aAtqRNiLbV x5PWioKUDXf9sEXyrOSEcacY9oMlipAIIv2/RMTh+5sutvXqgAPLey/BY w==; X-IronPort-AV: E=McAfee;i="6600,9927,10685"; a="408429384" X-IronPort-AV: E=Sophos;i="5.99,208,1677571200"; d="scan'208";a="408429384" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by orsmga104.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 19 Apr 2023 10:55:02 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10685"; a="722022447" X-IronPort-AV: E=Sophos;i="5.99,208,1677571200"; d="scan'208";a="722022447" Received: from dut125tglh.fm.intel.com ([10.105.23.23]) by orsmga008.jf.intel.com with ESMTP; 19 Apr 2023 10:55:02 -0700 From: Stuart Summers To: Date: Wed, 19 Apr 2023 17:55:00 +0000 Message-Id: <20230419175501.155319-4-stuart.summers@intel.com> X-Mailer: git-send-email 2.38.1.143.g1fc3c0ad40 In-Reply-To: <20230419175501.155319-1-stuart.summers@intel.com> References: <20230419175501.155319-1-stuart.summers@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Subject: [Intel-xe] [PATCH 3/4] drm/xe: Add new device configuration debugfs infrastructure 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: , Cc: stuart.summers@intel.com, matthew.d.roper@intel.com, lucas.demarchi@intel.com, intel-xe@lists.freedesktop.org Errors-To: intel-xe-bounces@lists.freedesktop.org Sender: "Intel-xe" The i915 driver defined an infrastructure for module parameters which would push these into debugfs for configurability at runtime with an eventual goal of removing those module parameters completely. There is a goal in the xe driver to avoid using module parameters altogether. However, we do need some way to configure the driver for debug purposes on a per-device level either before initializing the GPU or even during runtime in some cases. Bring in the debugfs infrastructure being used in i915, but drop the references to module parameters. This patch adds a dummy debugfs entry just to illustrate the new infrastructure here. It is intended that this will be replaced with actual driver-usable parameters in a future patch. Signed-off-by: Stuart Summers --- drivers/gpu/drm/xe/Makefile | 1 + drivers/gpu/drm/xe/xe_debugfs_params.c | 235 +++++++++++++++++++++++++ drivers/gpu/drm/xe/xe_debugfs_params.h | 14 ++ drivers/gpu/drm/xe/xe_device_types.h | 4 + drivers/gpu/drm/xe/xe_params.c | 118 +++++++++++++ drivers/gpu/drm/xe/xe_params.h | 40 +++++ drivers/gpu/drm/xe/xe_pci.c | 6 + 7 files changed, 418 insertions(+) create mode 100644 drivers/gpu/drm/xe/xe_debugfs_params.c create mode 100644 drivers/gpu/drm/xe/xe_debugfs_params.h create mode 100644 drivers/gpu/drm/xe/xe_params.c create mode 100644 drivers/gpu/drm/xe/xe_params.h diff --git a/drivers/gpu/drm/xe/Makefile b/drivers/gpu/drm/xe/Makefile index 5799589d2634..6a8794578f21 100644 --- a/drivers/gpu/drm/xe/Makefile +++ b/drivers/gpu/drm/xe/Makefile @@ -67,6 +67,7 @@ xe-y += xe_bb.o \ xe_mmio.o \ xe_mocs.o \ xe_module.o \ + xe_params.o \ xe_pci.o \ xe_pcode.o \ xe_pm.o \ diff --git a/drivers/gpu/drm/xe/xe_debugfs_params.c b/drivers/gpu/drm/xe/xe_debugfs_params.c new file mode 100644 index 000000000000..9e7272ce153d --- /dev/null +++ b/drivers/gpu/drm/xe/xe_debugfs_params.c @@ -0,0 +1,235 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2023 Intel Corporation + */ + +#include + +#include "xe_debugfs_params.h" +#include "xe_params.h" + +/* int param */ +static int xe_param_int_show(struct seq_file *m, void *data) +{ + int *value = m->private; + + seq_printf(m, "%d\n", *value); + + return 0; +} + +static int xe_param_int_open(struct inode *inode, struct file *file) +{ + return single_open(file, xe_param_int_show, inode->i_private); +} + +static ssize_t xe_param_int_write(struct file *file, + const char __user *ubuf, size_t len, + loff_t *offp) +{ + struct seq_file *m = file->private_data; + int *value = m->private; + int ret; + + ret = kstrtoint_from_user(ubuf, len, 0, value); + if (ret) { + /* support boolean values too */ + bool b; + + ret = kstrtobool_from_user(ubuf, len, &b); + if (!ret) + *value = b; + } + + return ret ?: len; +} + +static const struct file_operations xe_param_int_fops = { + .owner = THIS_MODULE, + .open = xe_param_int_open, + .read = seq_read, + .write = xe_param_int_write, + .llseek = default_llseek, + .release = single_release, +}; + +static const struct file_operations xe_param_int_fops_ro = { + .owner = THIS_MODULE, + .open = xe_param_int_open, + .read = seq_read, + .llseek = default_llseek, + .release = single_release, +}; + +/* unsigned int param */ +static int xe_param_uint_show(struct seq_file *m, void *data) +{ + unsigned int *value = m->private; + + seq_printf(m, "%u\n", *value); + + return 0; +} + +static int xe_param_uint_open(struct inode *inode, struct file *file) +{ + return single_open(file, xe_param_uint_show, inode->i_private); +} + +static ssize_t xe_param_uint_write(struct file *file, + const char __user *ubuf, size_t len, + loff_t *offp) +{ + struct drm_xe_private *xe; + struct seq_file *m = file->private_data; + unsigned int *value = m->private; + unsigned int old = *value; + int ret; + + ret = kstrtouint_from_user(ubuf, len, 0, value); + if (ret) { + /* support boolean values too */ + bool b; + + ret = kstrtobool_from_user(ubuf, len, &b); + if (!ret) + *value = b; + } + + return ret ?: len; +} + +static const struct file_operations xe_param_uint_fops = { + .owner = THIS_MODULE, + .open = xe_param_uint_open, + .read = seq_read, + .write = xe_param_uint_write, + .llseek = default_llseek, + .release = single_release, +}; + +static const struct file_operations xe_param_uint_fops_ro = { + .owner = THIS_MODULE, + .open = xe_param_uint_open, + .read = seq_read, + .llseek = default_llseek, + .release = single_release, +}; + +/* char * param */ +static int xe_param_charp_show(struct seq_file *m, void *data) +{ + const char **s = m->private; + + seq_printf(m, "%s\n", *s); + + return 0; +} + +static int xe_param_charp_open(struct inode *inode, struct file *file) +{ + return single_open(file, xe_param_charp_show, inode->i_private); +} + +static ssize_t xe_param_charp_write(struct file *file, + const char __user *ubuf, size_t len, + loff_t *offp) +{ + struct seq_file *m = file->private_data; + char **s = m->private; + char *new, *old; + + old = *s; + new = strndup_user(ubuf, PAGE_SIZE); + if (IS_ERR(new)) { + len = PTR_ERR(new); + goto out; + } + + *s = new; + + kfree(old); +out: + return len; +} + +static const struct file_operations xe_param_charp_fops = { + .owner = THIS_MODULE, + .open = xe_param_charp_open, + .read = seq_read, + .write = xe_param_charp_write, + .llseek = default_llseek, + .release = single_release, +}; + +static const struct file_operations xe_param_charp_fops_ro = { + .owner = THIS_MODULE, + .open = xe_param_charp_open, + .read = seq_read, + .llseek = default_llseek, + .release = single_release, +}; + +#define RO(mode) (((mode) & 0222) == 0) + +static struct dentry * +xe_debugfs_create_int(const char *name, umode_t mode, + struct dentry *parent, int *value) +{ + return debugfs_create_file_unsafe(name, mode, parent, value, + RO(mode) ? &xe_param_int_fops_ro : + &xe_param_int_fops); +} + +static struct dentry * +xe_debugfs_create_uint(const char *name, umode_t mode, + struct dentry *parent, unsigned int *value) +{ + return debugfs_create_file_unsafe(name, mode, parent, value, + RO(mode) ? &xe_param_uint_fops_ro : + &xe_param_uint_fops); +} + +static struct dentry * +xe_debugfs_create_charp(const char *name, umode_t mode, + struct dentry *parent, char **value) +{ + return debugfs_create_file(name, mode, parent, value, + RO(mode) ? &xe_param_charp_fops_ro : + &xe_param_charp_fops); +} + +#define _xe_param_create_file(parent, name, mode, valp) \ + do { \ + if (mode) \ + _Generic(valp, \ + bool *: debugfs_create_bool, \ + int *: xe_debugfs_create_int, \ + unsigned int *: xe_debugfs_create_uint, \ + unsigned long *: debugfs_create_ulong, \ + char **: xe_debugfs_create_charp)(name, mode, parent, valp); \ + } while(0) + +/* add a subdirectory with files for each xe param */ +struct dentry *xe_debugfs_params(struct drm_xe_private *xe) +{ + struct drm_minor *minor = xe->drm.primary; + struct xe_params *params = &xe->info.params; + struct dentry *dir; + + dir = debugfs_create_dir("xe_params", minor->debugfs_root); + if (IS_ERR(dir)) + return dir; + + /* + * Note: We could create files for params needing special handling + * here. Set mode in params to 0 to skip the generic create file, or + * just let the generic create file fail silently with -EEXIST. + */ + +#define REGISTER(T, x, unused, mode, ...) _xe_param_create_file(dir, #x, mode, ¶ms->x); + XE_PARAMS_FOR_EACH(REGISTER); +#undef REGISTER + + return dir; +} diff --git a/drivers/gpu/drm/xe/xe_debugfs_params.h b/drivers/gpu/drm/xe/xe_debugfs_params.h new file mode 100644 index 000000000000..d4f9b394a443 --- /dev/null +++ b/drivers/gpu/drm/xe/xe_debugfs_params.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2023 Intel Corporation + */ + +#ifndef __XE_DEBUGFS_PARAMS__ +#define __XE_DEBUGFS_PARAMS__ + +struct dentry; +struct drm_xe_private; + +struct dentry *xe_debugfs_params(struct drm_xe_private *xe); + +#endif /* __XE_DEBUGFS_PARAMS__ */ diff --git a/drivers/gpu/drm/xe/xe_device_types.h b/drivers/gpu/drm/xe/xe_device_types.h index a02c4eb6bd0d..6847fb2d035c 100644 --- a/drivers/gpu/drm/xe/xe_device_types.h +++ b/drivers/gpu/drm/xe/xe_device_types.h @@ -15,6 +15,7 @@ #include "xe_gt_types.h" #include "xe_platform_types.h" #include "xe_step_types.h" +#include "xe_params.h" #if IS_ENABLED(CONFIG_DRM_XE_DISPLAY) #include "ext/intel_device_info.h" @@ -152,6 +153,9 @@ struct xe_device { u32 rawclk_freq; } display; #endif + + /* device_info params configurable through debugfs */ + struct xe_params params; } info; /** @irq: device interrupt state */ diff --git a/drivers/gpu/drm/xe/xe_params.c b/drivers/gpu/drm/xe/xe_params.c new file mode 100644 index 000000000000..7c8f4e07b49c --- /dev/null +++ b/drivers/gpu/drm/xe/xe_params.c @@ -0,0 +1,118 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2023 Intel Corporation + */ + +#include + +#include + +#include "xe_params.h" + +struct xe_params xe_modparams __read_mostly = { +#define MEMBER(T, member, value, ...) .member = (value), + XE_PARAMS_FOR_EACH(MEMBER) +#undef MEMBER +}; + +/* + * Note: As a rule, keep module parameter sysfs permissions read-only + * 0400. Runtime changes are only supported through xe debugfs. + * + * For any exceptions requiring write access and runtime changes through module + * parameter sysfs, prevent debugfs file creation by setting the parameter's + * debugfs mode to 0. + */ + +static void _param_print_bool(struct drm_printer *p, const char *name, + bool val) +{ + drm_printf(p, "xe.%s=%s\n", name, str_yes_no(val)); +} + +static void _param_print_int(struct drm_printer *p, const char *name, + int val) +{ + drm_printf(p, "xe.%s=%d\n", name, val); +} + +static void _param_print_uint(struct drm_printer *p, const char *name, + unsigned int val) +{ + drm_printf(p, "xe.%s=%u\n", name, val); +} + +static void _param_print_ulong(struct drm_printer *p, const char *name, + unsigned long val) +{ + drm_printf(p, "xe.%s=%lu\n", name, val); +} + +static void _param_print_charp(struct drm_printer *p, const char *name, + const char *val) +{ + drm_printf(p, "xe.%s=%s\n", name, val); +} + +#define _param_print(p, name, val) \ + _Generic(val, \ + bool: _param_print_bool, \ + int: _param_print_int, \ + unsigned int: _param_print_uint, \ + unsigned long: _param_print_ulong, \ + char *: _param_print_charp)(p, name, val) + +/** + * xe_params_dump - dump xe modparams + * @params: xe modparams + * @p: the &drm_printer + * + * Pretty printer for xe modparams. + */ +void xe_params_dump(const struct xe_params *params, struct drm_printer *p) +{ +#define PRINT(T, x, ...) _param_print(p, #x, params->x); + XE_PARAMS_FOR_EACH(PRINT); +#undef PRINT +} + +static void _param_dup_charp(char **valp) +{ + *valp = kstrdup(*valp, GFP_ATOMIC); +} + +static void _param_nop(void *valp) +{ +} + +#define _param_dup(valp) \ + _Generic(valp, \ + char **: _param_dup_charp, \ + default: _param_nop)(valp) + +void xe_params_copy(struct xe_params *dest, const struct xe_params *src) +{ + *dest = *src; +#define DUP(T, x, ...) _param_dup(&dest->x); + XE_PARAMS_FOR_EACH(DUP); +#undef DUP +} + +static void _param_free_charp(char **valp) +{ + kfree(*valp); + *valp = NULL; +} + +#define _param_free(valp) \ + _Generic(valp, \ + char **: _param_free_charp, \ + default: _param_nop)(valp) + +/* free the allocated members, *not* the passed in params itself */ +void xe_params_free(struct xe_params *params) +{ +#define FREE(T, x, ...) _param_free(¶ms->x); + XE_PARAMS_FOR_EACH(FREE); +#undef FREE +} diff --git a/drivers/gpu/drm/xe/xe_params.h b/drivers/gpu/drm/xe/xe_params.h new file mode 100644 index 000000000000..26fb592e9cd6 --- /dev/null +++ b/drivers/gpu/drm/xe/xe_params.h @@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2023 Intel Corporation + */ + +#ifndef _XE_PARAMS_H_ +#define _XE_PARAMS_H_ + +#include +#include /* for __read_mostly */ + +struct drm_printer; + +/* + * Invoke param, a function-like macro, for each xe param, with arguments: + * + * param(type, name, value, mode) + * + * type: parameter type, one of {bool, int, unsigned int, unsigned long, char *} + * name: name of the parameter + * value: initial/default value of the parameter + * mode: debugfs file permissions, one of {0400, 0600, 0}, use 0 to not create + * debugfs file + */ +#define XE_PARAMS_FOR_EACH(param) \ + param(bool, dummy, true, 0444) + +#define MEMBER(T, member, ...) T member; +struct xe_params { + XE_PARAMS_FOR_EACH(MEMBER); +}; +#undef MEMBER + +extern struct xe_params xe_modparams __read_mostly; + +void xe_params_dump(const struct xe_params *params, struct drm_printer *p); +void xe_params_copy(struct xe_params *dest, const struct xe_params *src); +void xe_params_free(struct xe_params *params); + +#endif diff --git a/drivers/gpu/drm/xe/xe_pci.c b/drivers/gpu/drm/xe/xe_pci.c index f8ca179254fa..11da5abe587f 100644 --- a/drivers/gpu/drm/xe/xe_pci.c +++ b/drivers/gpu/drm/xe/xe_pci.c @@ -22,6 +22,8 @@ #include "xe_module.h" #include "xe_pm.h" #include "xe_step.h" +#include "xe_params.h" +#include "xe_debugfs.h" #define DEV_INFO_FOR_EACH_FLAG(func) \ func(require_force_probe); \ @@ -370,6 +372,8 @@ static void xe_pci_remove(struct pci_dev *pdev) if (!xe) /* driver load aborted, nothing to cleanup */ return; + xe_params_free(&xe->info.params); + xe_device_remove(xe); xe_pm_runtime_fini(xe); pci_set_drvdata(pdev, NULL); @@ -406,6 +410,8 @@ static int xe_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) if (IS_ERR(xe)) return PTR_ERR(xe); + xe_params_copy(&xe->info.params, &xe_modparams); + xe->info.graphics_verx100 = desc->graphics_ver * 100 + desc->graphics_rel; xe->info.media_verx100 = desc->media_ver * 100 + -- 2.38.1.143.g1fc3c0ad40