path: root/drivers/gpu/drm/xe/xe_gt_debugfs.c

// SPDX-License-Identifier: MIT
/*
 * Copyright © 2022 Intel Corporation
 */

#include "xe_gt_debugfs.h"

#include <drm/drm_debugfs.h>
#include <drm/drm_managed.h>

#include "xe_device.h"
#include "xe_force_wake.h"
#include "xe_ggtt.h"
#include "xe_gt.h"
#include "xe_gt_mcr.h"
#include "xe_gt_topology.h"
#include "xe_hw_engine.h"
#include "xe_lrc.h"
#include "xe_macros.h"
#include "xe_pat.h"
#include "xe_pm.h"
#include "xe_reg_sr.h"
#include "xe_reg_whitelist.h"
#include "xe_uc_debugfs.h"
#include "xe_wa.h"

/**
 * xe_gt_debugfs_simple_show - A show callback for struct drm_info_list
 * @m: the &seq_file
 * @data: data used by the drm debugfs helpers
 *
 * This callback can be used in struct drm_info_list to describe debugfs
 * files that are &xe_gt specific.
 *
 * It is assumed that those debugfs files will be created on directory entry
 * which struct dentry d_inode->i_private points to &xe_gt.
 *
 * This function assumes that &m->private will be set to the &struct
 * drm_info_node corresponding to the instance of the info on a given &struct
 * drm_minor (see struct drm_info_list.show for details).
 *
 * This function also assumes that struct drm_info_list.data will point to the
 * function code that will actually print a file content::
 *
 *   int (*print)(struct xe_gt *, struct drm_printer *)
 *
 * Example::
 *
 *    int foo(struct xe_gt *gt, struct drm_printer *p)
 *    {
 *        drm_printf(p, "GT%u\n", gt->info.id);
 *        return 0;
 *    }
 *
 *    static const struct drm_info_list bar[] = {
 *        { name = "foo", .show = xe_gt_debugfs_simple_show, .data = foo },
 *    };
 *
 *    dir = debugfs_create_dir("gt", parent);
 *    dir->d_inode->i_private = gt;
 *    drm_debugfs_create_files(bar, ARRAY_SIZE(bar), dir, minor);
 *
 * Return: 0 on success or a negative error code on failure.
 */
int xe_gt_debugfs_simple_show(struct seq_file *m, void *data)
{
	struct drm_printer p = drm_seq_file_printer(m);
	struct drm_info_node *node = m->private;
	struct dentry *parent = node->dent->d_parent;
	struct xe_gt *gt = parent->d_inode->i_private;
	int (*print)(struct xe_gt *, struct drm_printer *) = node->info_ent->data;

	if (WARN_ON(!print))
		return -EINVAL;

	return print(gt, &p);
}

static struct xe_gt *node_to_gt(struct drm_info_node *node)
{
	return node->info_ent->data;
}

static int hw_engines(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct xe_device *xe = gt_to_xe(gt);
	struct drm_printer p = drm_seq_file_printer(m);
	struct xe_hw_engine *hwe;
	enum xe_hw_engine_id id;
	int err;

	xe_pm_runtime_get(xe);
	err = xe_force_wake_get(gt_to_fw(gt), XE_FORCEWAKE_ALL);
	if (err) {
		xe_pm_runtime_put(xe);
		return err;
	}

	for_each_hw_engine(hwe, gt, id)
		xe_hw_engine_print(hwe, &p);

	err = xe_force_wake_put(gt_to_fw(gt), XE_FORCEWAKE_ALL);
	xe_pm_runtime_put(xe);
	if (err)
		return err;

	return 0;
}

static int force_reset(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_gt_reset_async(gt);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int sa_info(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct xe_tile *tile = gt_to_tile(gt);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	drm_suballoc_dump_debug_info(&tile->mem.kernel_bb_pool->base, &p,
				     tile->mem.kernel_bb_pool->gpu_addr);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int topology(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_gt_topology_dump(gt, &p);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int steering(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_gt_mcr_steering_dump(gt, &p);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int ggtt(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);
	int ret;

	xe_pm_runtime_get(gt_to_xe(gt));
	ret = xe_ggtt_dump(gt_to_tile(gt)->mem.ggtt, &p);
	xe_pm_runtime_put(gt_to_xe(gt));

	return ret;
}

static int register_save_restore(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);
	struct xe_hw_engine *hwe;
	enum xe_hw_engine_id id;

	xe_pm_runtime_get(gt_to_xe(gt));

	xe_reg_sr_dump(&gt->reg_sr, &p);
	drm_printf(&p, "\n");

	drm_printf(&p, "Engine\n");
	for_each_hw_engine(hwe, gt, id)
		xe_reg_sr_dump(&hwe->reg_sr, &p);
	drm_printf(&p, "\n");

	drm_printf(&p, "LRC\n");
	for_each_hw_engine(hwe, gt, id)
		xe_reg_sr_dump(&hwe->reg_lrc, &p);
	drm_printf(&p, "\n");

	drm_printf(&p, "Whitelist\n");
	for_each_hw_engine(hwe, gt, id)
		xe_reg_whitelist_dump(&hwe->reg_whitelist, &p);

	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int workarounds(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_wa_dump(gt, &p);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int pat(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_pat_dump(gt, &p);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int rcs_default_lrc(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_lrc_dump_default(&p, node_to_gt(m->private), XE_ENGINE_CLASS_RENDER);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int ccs_default_lrc(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_lrc_dump_default(&p, node_to_gt(m->private), XE_ENGINE_CLASS_COMPUTE);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int bcs_default_lrc(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_lrc_dump_default(&p, node_to_gt(m->private), XE_ENGINE_CLASS_COPY);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int vcs_default_lrc(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_lrc_dump_default(&p, node_to_gt(m->private), XE_ENGINE_CLASS_VIDEO_DECODE);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static int vecs_default_lrc(struct seq_file *m, void *data)
{
	struct xe_gt *gt = node_to_gt(m->private);
	struct drm_printer p = drm_seq_file_printer(m);

	xe_pm_runtime_get(gt_to_xe(gt));
	xe_lrc_dump_default(&p, node_to_gt(m->private), XE_ENGINE_CLASS_VIDEO_ENHANCE);
	xe_pm_runtime_put(gt_to_xe(gt));

	return 0;
}

static const struct drm_info_list debugfs_list[] = {
	{"hw_engines", hw_engines, 0},
	{"force_reset", force_reset, 0},
	{"sa_info", sa_info, 0},
	{"topology", topology, 0},
	{"steering", steering, 0},
	{"ggtt", ggtt, 0},
	{"register-save-restore", register_save_restore, 0},
	{"workarounds", workarounds, 0},
	{"pat", pat, 0},
	{"default_lrc_rcs", rcs_default_lrc},
	{"default_lrc_ccs", ccs_default_lrc},
	{"default_lrc_bcs", bcs_default_lrc},
	{"default_lrc_vcs", vcs_default_lrc},
	{"default_lrc_vecs", vecs_default_lrc},
};

void xe_gt_debugfs_register(struct xe_gt *gt)
{
	struct xe_device *xe = gt_to_xe(gt);
	struct drm_minor *minor = gt_to_xe(gt)->drm.primary;
	struct dentry *root;
	struct drm_info_list *local;
	char name[8];
	int i;

	xe_gt_assert(gt, minor->debugfs_root);

	sprintf(name, "gt%d", gt->info.id);
	root = debugfs_create_dir(name, minor->debugfs_root);
	if (IS_ERR(root)) {
		drm_warn(&xe->drm, "Create GT directory failed");
		return;
	}

	/*
	 * Store the xe_gt pointer as private data of the gt/ directory node
	 * so other GT specific attributes under that directory may refer to
	 * it by looking at its parent node private data.
	 */
	root->d_inode->i_private = gt;

	/*
	 * Allocate local copy as we need to pass in the GT to the debugfs
	 * entry and drm_debugfs_create_files just references the drm_info_list
	 * passed in (e.g. can't define this on the stack).
	 */
#define DEBUGFS_SIZE	(ARRAY_SIZE(debugfs_list) * sizeof(struct drm_info_list))
	local = drmm_kmalloc(&xe->drm, DEBUGFS_SIZE, GFP_KERNEL);
	if (!local)
		return;

	memcpy(local, debugfs_list, DEBUGFS_SIZE);
#undef DEBUGFS_SIZE

	for (i = 0; i < ARRAY_SIZE(debugfs_list); ++i)
		local[i].data = gt;

	drm_debugfs_create_files(local,
				 ARRAY_SIZE(debugfs_list),
				 root, minor);

	xe_uc_debugfs_register(&gt->uc, root);
}