#include <linux/debugfs.h>
#include <drm/drm_print.h>
#include <drm/drm_debugfs.h>
#include "xe_debugfs.h"
#include "xe_device.h"
#include "xe_gt.h"
#include "xe_gt_debugfs.h"
#include "xe_gt_sriov_pf_config.h"
#include "xe_gt_sriov_pf_control.h"
#include "xe_gt_sriov_pf_debugfs.h"
#include "xe_gt_sriov_pf_helpers.h"
#include "xe_gt_sriov_pf_migration.h"
#include "xe_gt_sriov_pf_monitor.h"
#include "xe_gt_sriov_pf_policy.h"
#include "xe_gt_sriov_pf_service.h"
#include "xe_guc.h"
#include "xe_pm.h"
#include "xe_sriov_pf.h"
#include "xe_sriov_pf_provision.h"
static void *extract_priv(struct dentry *d)
{
return d->d_inode->i_private;
}
static struct xe_gt *extract_gt(struct dentry *d)
{
return extract_priv(d);
}
static struct xe_device *extract_xe(struct dentry *d)
{
return extract_priv(d->d_parent->d_parent->d_parent);
}
static unsigned int extract_vfid(struct dentry *d)
{
void *priv = extract_priv(d->d_parent->d_parent);
return priv == extract_xe(d) ? PFID : (uintptr_t)priv;
}
static const struct drm_info_list pf_info[] = {
{
"contexts_provisioned",
.show = xe_gt_debugfs_simple_show,
.data = xe_gt_sriov_pf_config_print_ctxs,
},
{
"doorbells_provisioned",
.show = xe_gt_debugfs_simple_show,
.data = xe_gt_sriov_pf_config_print_dbs,
},
{
"runtime_registers",
.show = xe_gt_debugfs_simple_show,
.data = xe_gt_sriov_pf_service_print_runtime,
},
{
"adverse_events",
.show = xe_gt_debugfs_simple_show,
.data = xe_gt_sriov_pf_monitor_print_events,
},
};
#define DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(POLICY, TYPE, FORMAT) \
\
static int POLICY##_set(void *data, u64 val) \
{ \
struct xe_gt *gt = extract_gt(data); \
struct xe_device *xe = gt_to_xe(gt); \
int err; \
\
if (val > (TYPE)~0ull) \
return -EOVERFLOW; \
\
guard(xe_pm_runtime)(xe); \
err = xe_gt_sriov_pf_policy_set_##POLICY(gt, val); \
if (!err) \
xe_sriov_pf_provision_set_custom_mode(xe); \
\
return err; \
} \
\
static int POLICY##_get(void *data, u64 *val) \
{ \
struct xe_gt *gt = extract_gt(data); \
\
*val = xe_gt_sriov_pf_policy_get_##POLICY(gt); \
return 0; \
} \
\
DEFINE_DEBUGFS_ATTRIBUTE(POLICY##_fops, POLICY##_get, POLICY##_set, FORMAT)
DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(reset_engine, bool, "%llu\n");
DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(sched_if_idle, bool, "%llu\n");
DEFINE_SRIOV_GT_POLICY_DEBUGFS_ATTRIBUTE(sample_period, u32, "%llu\n");
static void pf_add_policy_attrs(struct xe_gt *gt, struct dentry *parent)
{
xe_gt_assert(gt, gt == extract_gt(parent));
xe_gt_assert(gt, PFID == extract_vfid(parent));
debugfs_create_file_unsafe("reset_engine", 0644, parent, parent, &reset_engine_fops);
debugfs_create_file_unsafe("sched_if_idle", 0644, parent, parent, &sched_if_idle_fops);
debugfs_create_file_unsafe("sample_period_ms", 0644, parent, parent, &sample_period_fops);
}
static const char *sched_group_mode_to_string(enum xe_sriov_sched_group_modes mode)
{
switch (mode) {
case XE_SRIOV_SCHED_GROUPS_DISABLED:
return "disabled";
case XE_SRIOV_SCHED_GROUPS_MEDIA_SLICES:
return "media_slices";
case XE_SRIOV_SCHED_GROUPS_MODES_COUNT:
break;
}
return "unknown";
}
static int sched_groups_info(struct seq_file *m, void *data)
{
struct drm_printer p = drm_seq_file_printer(m);
struct xe_gt *gt = extract_gt(m->private);
enum xe_sriov_sched_group_modes current_mode =
gt->sriov.pf.policy.guc.sched_groups.current_mode;
enum xe_sriov_sched_group_modes mode;
for (mode = XE_SRIOV_SCHED_GROUPS_DISABLED;
mode < XE_SRIOV_SCHED_GROUPS_MODES_COUNT;
mode++) {
if (!xe_sriov_gt_pf_policy_has_sched_group_mode(gt, mode))
continue;
drm_printf(&p, "%s%s%s%s",
mode == XE_SRIOV_SCHED_GROUPS_DISABLED ? "" : " ",
mode == current_mode ? "[" : "",
sched_group_mode_to_string(mode),
mode == current_mode ? "]" : "");
}
drm_puts(&p, "\n");
return 0;
}
static int sched_groups_open(struct inode *inode, struct file *file)
{
return single_open(file, sched_groups_info, inode->i_private);
}
static ssize_t sched_groups_write(struct file *file, const char __user *ubuf,
size_t size, loff_t *pos)
{
struct xe_gt *gt = extract_gt(file_inode(file)->i_private);
enum xe_sriov_sched_group_modes mode;
char name[32];
int ret;
if (*pos)
return -ESPIPE;
if (!size)
return -ENODATA;
if (size > sizeof(name) - 1)
return -EINVAL;
ret = simple_write_to_buffer(name, sizeof(name) - 1, pos, ubuf, size);
if (ret < 0)
return ret;
name[ret] = '\0';
for (mode = XE_SRIOV_SCHED_GROUPS_DISABLED;
mode < XE_SRIOV_SCHED_GROUPS_MODES_COUNT;
mode++)
if (sysfs_streq(name, sched_group_mode_to_string(mode)))
break;
if (mode == XE_SRIOV_SCHED_GROUPS_MODES_COUNT)
return -EINVAL;
guard(xe_pm_runtime)(gt_to_xe(gt));
ret = xe_gt_sriov_pf_policy_set_sched_groups_mode(gt, mode);
return ret < 0 ? ret : size;
}
static const struct file_operations sched_groups_fops = {
.owner = THIS_MODULE,
.open = sched_groups_open,
.read = seq_read,
.write = sched_groups_write,
.llseek = seq_lseek,
.release = single_release,
};
static int sched_groups_config_show(struct seq_file *m, void *data,
void (*get)(struct xe_gt *, unsigned int, u32 *, u32))
{
struct drm_printer p = drm_seq_file_printer(m);
unsigned int vfid = extract_vfid(m->private);
struct xe_gt *gt = extract_gt(m->private);
u32 values[GUC_MAX_SCHED_GROUPS];
bool first = true;
u8 group;
get(gt, vfid, values, ARRAY_SIZE(values));
for (group = 0; group < ARRAY_SIZE(values); group++) {
drm_printf(&p, "%s%u", first ? "" : ",", values[group]);
first = false;
}
drm_puts(&p, "\n");
return 0;
}
static ssize_t sched_groups_config_write(struct file *file, const char __user *ubuf,
size_t size, loff_t *pos,
int (*set)(struct xe_gt *, unsigned int, u32 *, u32))
{
struct dentry *parent = file_inode(file)->i_private;
unsigned int vfid = extract_vfid(parent);
struct xe_gt *gt = extract_gt(parent);
u32 values[GUC_MAX_SCHED_GROUPS];
int *input __free(kfree) = NULL;
u32 count;
int ret;
int i;
if (*pos)
return -ESPIPE;
if (!size)
return -ENODATA;
ret = parse_int_array_user(ubuf, min(size, GUC_MAX_SCHED_GROUPS * sizeof(u32)), &input);
if (ret)
return ret;
count = input[0];
if (count > GUC_MAX_SCHED_GROUPS)
return -E2BIG;
for (i = 0; i < count; i++) {
if (input[i + 1] < 0 || input[i + 1] > S32_MAX)
return -EINVAL;
values[i] = input[i + 1];
}
guard(xe_pm_runtime)(gt_to_xe(gt));
ret = set(gt, vfid, values, count);
return ret < 0 ? ret : size;
}
#define DEFINE_SRIOV_GT_GRP_CFG_DEBUGFS_ATTRIBUTE(CONFIG) \
static int sched_groups_##CONFIG##_show(struct seq_file *m, void *data) \
{ \
return sched_groups_config_show(m, data, \
xe_gt_sriov_pf_config_get_groups_##CONFIG); \
} \
\
static int sched_groups_##CONFIG##_open(struct inode *inode, struct file *file) \
{ \
return single_open(file, sched_groups_##CONFIG##_show, \
inode->i_private); \
} \
\
static ssize_t sched_groups_##CONFIG##_write(struct file *file, \
const char __user *ubuf, \
size_t size, loff_t *pos) \
{ \
return sched_groups_config_write(file, ubuf, size, pos, \
xe_gt_sriov_pf_config_set_groups_##CONFIG); \
} \
\
static const struct file_operations sched_groups_##CONFIG##_fops = { \
.owner = THIS_MODULE, \
.open = sched_groups_##CONFIG##_open, \
.read = seq_read, \
.llseek = seq_lseek, \
.write = sched_groups_##CONFIG##_write, \
.release = single_release, \
}
DEFINE_SRIOV_GT_GRP_CFG_DEBUGFS_ATTRIBUTE(exec_quantums);
DEFINE_SRIOV_GT_GRP_CFG_DEBUGFS_ATTRIBUTE(preempt_timeouts);
static ssize_t sched_group_engines_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct dentry *dent = file_dentry(file);
struct xe_gt *gt = extract_gt(dent->d_parent->d_parent);
struct xe_gt_sriov_scheduler_groups *info = >->sriov.pf.policy.guc.sched_groups;
struct guc_sched_group *groups = info->modes[info->current_mode].groups;
u32 num_groups = info->modes[info->current_mode].num_groups;
unsigned int group = (uintptr_t)extract_priv(dent);
struct xe_hw_engine *hwe;
enum xe_hw_engine_id id;
char engines[128];
engines[0] = '\0';
if (group < num_groups) {
for_each_hw_engine(hwe, gt, id) {
u8 guc_class = xe_engine_class_to_guc_class(hwe->class);
u32 mask = groups[group].engines[guc_class];
if (mask & BIT(hwe->logical_instance)) {
strlcat(engines, hwe->name, sizeof(engines));
strlcat(engines, " ", sizeof(engines));
}
}
strlcat(engines, "\n", sizeof(engines));
}
return simple_read_from_buffer(buf, count, ppos, engines, strlen(engines));
}
static const struct file_operations sched_group_engines_fops = {
.owner = THIS_MODULE,
.open = simple_open,
.read = sched_group_engines_read,
.llseek = default_llseek,
};
static void pf_add_sched_groups(struct xe_gt *gt, struct dentry *parent, unsigned int vfid)
{
struct dentry *groups;
u8 group;
xe_gt_assert(gt, gt == extract_gt(parent));
xe_gt_assert(gt, vfid == extract_vfid(parent));
if (!xe_sriov_gt_pf_policy_has_sched_groups_support(gt))
return;
debugfs_create_file("sched_groups_exec_quantums_ms", 0644, parent, parent,
&sched_groups_exec_quantums_fops);
debugfs_create_file("sched_groups_preempt_timeouts_us", 0644, parent, parent,
&sched_groups_preempt_timeouts_fops);
if (vfid != PFID)
return;
debugfs_create_file("sched_groups_mode", 0644, parent, parent, &sched_groups_fops);
groups = debugfs_create_dir("sched_groups", parent);
if (IS_ERR(groups))
return;
for (group = 0; group < GUC_MAX_SCHED_GROUPS; group++) {
char name[10];
snprintf(name, sizeof(name), "group%u", group);
debugfs_create_file(name, 0644, groups, (void *)(uintptr_t)group,
&sched_group_engines_fops);
}
}
#define DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(CONFIG, TYPE, FORMAT) \
\
static int CONFIG##_set(void *data, u64 val) \
{ \
struct xe_gt *gt = extract_gt(data); \
unsigned int vfid = extract_vfid(data); \
struct xe_device *xe = gt_to_xe(gt); \
int err; \
\
if (val > (TYPE)~0ull) \
return -EOVERFLOW; \
\
guard(xe_pm_runtime)(xe); \
err = xe_sriov_pf_wait_ready(xe) ?: \
xe_gt_sriov_pf_config_set_##CONFIG(gt, vfid, val); \
if (!err) \
xe_sriov_pf_provision_set_custom_mode(xe); \
\
return err; \
} \
\
static int CONFIG##_get(void *data, u64 *val) \
{ \
struct xe_gt *gt = extract_gt(data); \
unsigned int vfid = extract_vfid(data); \
\
*val = xe_gt_sriov_pf_config_get_##CONFIG(gt, vfid); \
return 0; \
} \
\
DEFINE_DEBUGFS_ATTRIBUTE(CONFIG##_fops, CONFIG##_get, CONFIG##_set, FORMAT)
DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(ctxs, u32, "%llu\n");
DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(dbs, u32, "%llu\n");
DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(exec_quantum, u32, "%llu\n");
DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(preempt_timeout, u32, "%llu\n");
DEFINE_SRIOV_GT_CONFIG_DEBUGFS_ATTRIBUTE(sched_priority, u32, "%llu\n");
static int set_threshold(void *data, u64 val, enum xe_guc_klv_threshold_index index)
{
struct xe_gt *gt = extract_gt(data);
unsigned int vfid = extract_vfid(data);
struct xe_device *xe = gt_to_xe(gt);
int err;
if (val > (u32)~0ull)
return -EOVERFLOW;
guard(xe_pm_runtime)(xe);
err = xe_gt_sriov_pf_config_set_threshold(gt, vfid, index, val);
if (!err)
xe_sriov_pf_provision_set_custom_mode(xe);
return err;
}
static int get_threshold(void *data, u64 *val, enum xe_guc_klv_threshold_index index)
{
struct xe_gt *gt = extract_gt(data);
unsigned int vfid = extract_vfid(data);
*val = xe_gt_sriov_pf_config_get_threshold(gt, vfid, index);
return 0;
}
#define DEFINE_SRIOV_GT_THRESHOLD_DEBUGFS_ATTRIBUTE(THRESHOLD, INDEX) \
\
static int THRESHOLD##_set(void *data, u64 val) \
{ \
return set_threshold(data, val, INDEX); \
} \
\
static int THRESHOLD##_get(void *data, u64 *val) \
{ \
return get_threshold(data, val, INDEX); \
} \
\
DEFINE_DEBUGFS_ATTRIBUTE(THRESHOLD##_fops, THRESHOLD##_get, THRESHOLD##_set, "%llu\n")
#define define_threshold_attribute(TAG, NAME, ...) \
DEFINE_SRIOV_GT_THRESHOLD_DEBUGFS_ATTRIBUTE(NAME, MAKE_XE_GUC_KLV_THRESHOLD_INDEX(TAG));
MAKE_XE_GUC_KLV_THRESHOLDS_SET(define_threshold_attribute)
#undef define_threshold_attribute
static void pf_add_config_attrs(struct xe_gt *gt, struct dentry *parent, unsigned int vfid)
{
xe_gt_assert(gt, gt == extract_gt(parent));
xe_gt_assert(gt, vfid == extract_vfid(parent));
debugfs_create_file_unsafe(vfid ? "doorbells_quota" : "doorbells_spare",
0644, parent, parent, &dbs_fops);
debugfs_create_file_unsafe(vfid ? "contexts_quota" : "contexts_spare",
0644, parent, parent, &ctxs_fops);
debugfs_create_file_unsafe("exec_quantum_ms", 0644, parent, parent,
&exec_quantum_fops);
debugfs_create_file_unsafe("preempt_timeout_us", 0644, parent, parent,
&preempt_timeout_fops);
debugfs_create_file_unsafe("sched_priority", 0644, parent, parent,
&sched_priority_fops);
#define register_threshold_attribute(TAG, NAME, VER...) ({ \
if (IF_ARGS(GUC_FIRMWARE_VER_AT_LEAST(>->uc.guc, VER), true, VER)) \
debugfs_create_file_unsafe("threshold_" #NAME, 0644, parent, parent, \
&NAME##_fops); \
});
MAKE_XE_GUC_KLV_THRESHOLDS_SET(register_threshold_attribute)
#undef register_threshold_attribute
}
static const struct {
const char *cmd;
int (*fn)(struct xe_gt *gt, unsigned int vfid);
} control_cmds[] = {
{ "stop", xe_gt_sriov_pf_control_stop_vf },
{ "pause", xe_gt_sriov_pf_control_pause_vf },
{ "resume", xe_gt_sriov_pf_control_resume_vf },
};
static ssize_t control_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
struct dentry *dent = file_dentry(file);
struct dentry *parent = dent->d_parent;
struct xe_gt *gt = extract_gt(parent);
struct xe_device *xe = gt_to_xe(gt);
unsigned int vfid = extract_vfid(parent);
int ret = -EINVAL;
char cmd[32];
size_t n;
xe_gt_assert(gt, vfid);
xe_gt_sriov_pf_assert_vfid(gt, vfid);
if (*pos)
return -ESPIPE;
if (count > sizeof(cmd) - 1)
return -EINVAL;
ret = simple_write_to_buffer(cmd, sizeof(cmd) - 1, pos, buf, count);
if (ret < 0)
return ret;
cmd[ret] = '\0';
for (n = 0; n < ARRAY_SIZE(control_cmds); n++) {
xe_gt_assert(gt, sizeof(cmd) > strlen(control_cmds[n].cmd));
if (sysfs_streq(cmd, control_cmds[n].cmd)) {
guard(xe_pm_runtime)(xe);
ret = control_cmds[n].fn ? (*control_cmds[n].fn)(gt, vfid) : 0;
break;
}
}
return (ret < 0) ? ret : count;
}
static ssize_t control_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
char help[128];
size_t n;
help[0] = '\0';
for (n = 0; n < ARRAY_SIZE(control_cmds); n++) {
strlcat(help, control_cmds[n].cmd, sizeof(help));
strlcat(help, "\n", sizeof(help));
}
return simple_read_from_buffer(buf, count, ppos, help, strlen(help));
}
static const struct file_operations control_ops = {
.owner = THIS_MODULE,
.open = simple_open,
.write = control_write,
.read = control_read,
.llseek = default_llseek,
};
struct config_blob_data {
size_t size;
u8 blob[];
};
static int config_blob_open(struct inode *inode, struct file *file)
{
struct dentry *dent = file_dentry(file);
struct dentry *parent = dent->d_parent;
struct xe_gt *gt = extract_gt(parent);
unsigned int vfid = extract_vfid(parent);
struct config_blob_data *cbd;
ssize_t ret;
ret = xe_gt_sriov_pf_config_save(gt, vfid, NULL, 0);
if (!ret)
return -ENODATA;
if (ret < 0)
return ret;
cbd = kzalloc_flex(*cbd, blob, ret);
if (!cbd)
return -ENOMEM;
ret = xe_gt_sriov_pf_config_save(gt, vfid, cbd->blob, ret);
if (ret < 0) {
kfree(cbd);
return ret;
}
cbd->size = ret;
file->private_data = cbd;
return nonseekable_open(inode, file);
}
static ssize_t config_blob_read(struct file *file, char __user *buf,
size_t count, loff_t *pos)
{
struct config_blob_data *cbd = file->private_data;
return simple_read_from_buffer(buf, count, pos, cbd->blob, cbd->size);
}
static ssize_t config_blob_write(struct file *file, const char __user *buf,
size_t count, loff_t *pos)
{
struct dentry *dent = file_dentry(file);
struct dentry *parent = dent->d_parent;
struct xe_gt *gt = extract_gt(parent);
unsigned int vfid = extract_vfid(parent);
ssize_t ret;
void *tmp;
if (*pos)
return -EINVAL;
if (!count)
return -ENODATA;
if (count > SZ_4K)
return -EINVAL;
tmp = kzalloc(count, GFP_KERNEL);
if (!tmp)
return -ENOMEM;
if (copy_from_user(tmp, buf, count)) {
ret = -EFAULT;
} else {
ret = xe_gt_sriov_pf_config_restore(gt, vfid, tmp, count);
if (!ret)
ret = count;
}
kfree(tmp);
return ret;
}
static int config_blob_release(struct inode *inode, struct file *file)
{
kfree(file->private_data);
return 0;
}
static const struct file_operations config_blob_ops = {
.owner = THIS_MODULE,
.open = config_blob_open,
.read = config_blob_read,
.write = config_blob_write,
.release = config_blob_release,
};
static void pf_add_compat_attrs(struct xe_gt *gt, struct dentry *dent, unsigned int vfid)
{
struct xe_device *xe = gt_to_xe(gt);
if (!xe_gt_is_main_type(gt))
return;
if (vfid) {
debugfs_create_symlink("ggtt_quota", dent, "../ggtt_quota");
if (xe_device_has_lmtt(xe))
debugfs_create_symlink("lmem_quota", dent, "../vram_quota");
} else {
debugfs_create_symlink("ggtt_spare", dent, "../ggtt_spare");
debugfs_create_symlink("ggtt_available", dent, "../ggtt_available");
debugfs_create_symlink("ggtt_provisioned", dent, "../ggtt_provisioned");
if (xe_device_has_lmtt(xe)) {
debugfs_create_symlink("lmem_spare", dent, "../vram_spare");
debugfs_create_symlink("lmem_provisioned", dent, "../vram_provisioned");
}
}
}
static void pf_populate_gt(struct xe_gt *gt, struct dentry *dent, unsigned int vfid)
{
struct xe_device *xe = gt_to_xe(gt);
struct drm_minor *minor = xe->drm.primary;
if (vfid) {
pf_add_config_attrs(gt, dent, vfid);
pf_add_sched_groups(gt, dent, vfid);
debugfs_create_file("control", 0600, dent, NULL, &control_ops);
if (IS_ENABLED(CONFIG_DRM_XE_DEBUG)) {
debugfs_create_file("config_blob",
IS_ENABLED(CONFIG_DRM_XE_DEBUG_SRIOV) ? 0600 : 0400,
dent, NULL, &config_blob_ops);
}
} else {
pf_add_config_attrs(gt, dent, PFID);
pf_add_policy_attrs(gt, dent);
pf_add_sched_groups(gt, dent, PFID);
drm_debugfs_create_files(pf_info, ARRAY_SIZE(pf_info), dent, minor);
}
pf_add_compat_attrs(gt, dent, vfid);
}
void xe_gt_sriov_pf_debugfs_populate(struct xe_gt *gt, struct dentry *parent, unsigned int vfid)
{
struct dentry *dent;
char name[8];
xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));
xe_gt_assert(gt, extract_priv(parent) == gt->tile);
xe_gt_assert(gt, extract_priv(parent->d_parent) == gt_to_xe(gt) ||
(uintptr_t)extract_priv(parent->d_parent) == vfid);
snprintf(name, sizeof(name), "gt%u", gt->info.id);
dent = debugfs_create_dir(name, parent);
if (IS_ERR(dent))
return;
dent->d_inode->i_private = gt;
xe_gt_assert(gt, extract_gt(dent) == gt);
xe_gt_assert(gt, extract_vfid(dent) == vfid);
pf_populate_gt(gt, dent, vfid);
}
static void pf_add_links(struct xe_gt *gt, struct dentry *dent)
{
unsigned int totalvfs = xe_gt_sriov_pf_get_totalvfs(gt);
unsigned int vfid;
char name[16];
char symlink[64];
for (vfid = 0; vfid <= totalvfs; vfid++) {
if (vfid)
snprintf(name, sizeof(name), "vf%u", vfid);
else
snprintf(name, sizeof(name), "pf");
snprintf(symlink, sizeof(symlink), "../../sriov/%s/tile%u/gt%u",
name, gt->tile->id, gt->info.id);
debugfs_create_symlink(name, dent, symlink);
}
}
void xe_gt_sriov_pf_debugfs_register(struct xe_gt *gt, struct dentry *dent)
{
xe_gt_assert(gt, IS_SRIOV_PF(gt_to_xe(gt)));
xe_gt_assert(gt, dent->d_inode->i_private == gt);
pf_add_links(gt, dent);
}
