1// SPDX-License-Identifier: MIT
2/*
3 * Copyright © 2022 Intel Corporation
4 */
5
6#include "xe_gt_debugfs.h"
7
8#include <linux/debugfs.h>
9
10#include <drm/drm_debugfs.h>
11#include <drm/drm_managed.h>
12
13#include "xe_device.h"
14#include "xe_force_wake.h"
15#include "xe_gt.h"
16#include "xe_gt_mcr.h"
17#include "xe_gt_idle.h"
18#include "xe_gt_sriov_pf_debugfs.h"
19#include "xe_gt_sriov_vf_debugfs.h"
20#include "xe_gt_stats.h"
21#include "xe_gt_topology.h"
22#include "xe_guc_hwconfig.h"
23#include "xe_hw_engine.h"
24#include "xe_lrc.h"
25#include "xe_macros.h"
26#include "xe_mocs.h"
27#include "xe_pat.h"
28#include "xe_pm.h"
29#include "xe_reg_sr.h"
30#include "xe_reg_whitelist.h"
31#include "xe_sa.h"
32#include "xe_sriov.h"
33#include "xe_sriov_vf_ccs.h"
34#include "xe_tuning.h"
35#include "xe_uc_debugfs.h"
36#include "xe_wa.h"
37
38static struct xe_gt *node_to_gt(struct drm_info_node *node)
39{
40 return node->dent->d_parent->d_inode->i_private;
41}
42
43/**
44 * xe_gt_debugfs_simple_show - A show callback for struct drm_info_list
45 * @m: the &seq_file
46 * @data: data used by the drm debugfs helpers
47 *
48 * This callback can be used in struct drm_info_list to describe debugfs
49 * files that are &xe_gt specific.
50 *
51 * It is assumed that those debugfs files will be created on directory entry
52 * which struct dentry d_inode->i_private points to &xe_gt.
53 *
54 * This function assumes that &m->private will be set to the &struct
55 * drm_info_node corresponding to the instance of the info on a given &struct
56 * drm_minor (see struct drm_info_list.show for details).
57 *
58 * This function also assumes that struct drm_info_list.data will point to the
59 * function code that will actually print a file content::
60 *
61 * int (*print)(struct xe_gt *, struct drm_printer *)
62 *
63 * Example::
64 *
65 * int foo(struct xe_gt *gt, struct drm_printer *p)
66 * {
67 * drm_printf(p, "GT%u\n", gt->info.id);
68 * return 0;
69 * }
70 *
71 * static const struct drm_info_list bar[] = {
72 * { name = "foo", .show = xe_gt_debugfs_simple_show, .data = foo },
73 * };
74 *
75 * dir = debugfs_create_dir("gt", parent);
76 * dir->d_inode->i_private = gt;
77 * drm_debugfs_create_files(bar, ARRAY_SIZE(bar), dir, minor);
78 *
79 * Return: 0 on success or a negative error code on failure.
80 */
81int xe_gt_debugfs_simple_show(struct seq_file *m, void *data)
82{
83 struct drm_printer p = drm_seq_file_printer(f: m);
84 struct drm_info_node *node = m->private;
85 struct xe_gt *gt = node_to_gt(node);
86 int (*print)(struct xe_gt *, struct drm_printer *) = node->info_ent->data;
87
88 if (WARN_ON(!print))
89 return -EINVAL;
90
91 return print(gt, &p);
92}
93
94/**
95 * xe_gt_debugfs_show_with_rpm - A show callback for struct drm_info_list
96 * @m: the &seq_file
97 * @data: data used by the drm debugfs helpers
98 *
99 * Similar to xe_gt_debugfs_simple_show() but implicitly takes a RPM ref.
100 *
101 * Return: 0 on success or a negative error code on failure.
102 */
103int xe_gt_debugfs_show_with_rpm(struct seq_file *m, void *data)
104{
105 struct drm_info_node *node = m->private;
106 struct xe_gt *gt = node_to_gt(node);
107 struct xe_device *xe = gt_to_xe(gt);
108 int ret;
109
110 xe_pm_runtime_get(xe);
111 ret = xe_gt_debugfs_simple_show(m, data);
112 xe_pm_runtime_put(xe);
113
114 return ret;
115}
116
117static int hw_engines(struct xe_gt *gt, struct drm_printer *p)
118{
119 struct xe_hw_engine *hwe;
120 enum xe_hw_engine_id id;
121 unsigned int fw_ref;
122 int ret = 0;
123
124 fw_ref = xe_force_wake_get(fw: gt_to_fw(gt), domains: XE_FORCEWAKE_ALL);
125 if (!xe_force_wake_ref_has_domain(fw_ref, domain: XE_FORCEWAKE_ALL)) {
126 ret = -ETIMEDOUT;
127 goto fw_put;
128 }
129
130 for_each_hw_engine(hwe, gt, id)
131 xe_hw_engine_print(hwe, p);
132
133fw_put:
134 xe_force_wake_put(fw: gt_to_fw(gt), fw_ref);
135
136 return ret;
137}
138
139static int steering(struct xe_gt *gt, struct drm_printer *p)
140{
141 xe_gt_mcr_steering_dump(gt, p);
142 return 0;
143}
144
145static int register_save_restore(struct xe_gt *gt, struct drm_printer *p)
146{
147 struct xe_hw_engine *hwe;
148 enum xe_hw_engine_id id;
149
150 xe_reg_sr_dump(sr: &gt->reg_sr, p);
151 drm_printf(p, f: "\n");
152
153 drm_printf(p, f: "Engine\n");
154 for_each_hw_engine(hwe, gt, id)
155 xe_reg_sr_dump(sr: &hwe->reg_sr, p);
156 drm_printf(p, f: "\n");
157
158 drm_printf(p, f: "LRC\n");
159 for_each_hw_engine(hwe, gt, id)
160 xe_reg_sr_dump(sr: &hwe->reg_lrc, p);
161 drm_printf(p, f: "\n");
162
163 drm_printf(p, f: "Whitelist\n");
164 for_each_hw_engine(hwe, gt, id)
165 xe_reg_whitelist_dump(sr: &hwe->reg_whitelist, p);
166
167 return 0;
168}
169
170static int rcs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
171{
172 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_RENDER);
173 return 0;
174}
175
176static int ccs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
177{
178 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_COMPUTE);
179 return 0;
180}
181
182static int bcs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
183{
184 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_COPY);
185 return 0;
186}
187
188static int vcs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
189{
190 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_VIDEO_DECODE);
191 return 0;
192}
193
194static int vecs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
195{
196 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_VIDEO_ENHANCE);
197 return 0;
198}
199
200static int hwconfig(struct xe_gt *gt, struct drm_printer *p)
201{
202 xe_guc_hwconfig_dump(guc: &gt->uc.guc, p);
203 return 0;
204}
205
206/*
207 * only for GT debugfs files which can be safely used on the VF as well:
208 * - without access to the GT privileged registers
209 * - without access to the PF specific data
210 */
211static const struct drm_info_list vf_safe_debugfs_list[] = {
212 { "topology", .show = xe_gt_debugfs_show_with_rpm, .data = xe_gt_topology_dump },
213 { "register-save-restore",
214 .show = xe_gt_debugfs_show_with_rpm, .data = register_save_restore },
215 { "workarounds", .show = xe_gt_debugfs_show_with_rpm, .data = xe_wa_gt_dump },
216 { "tunings", .show = xe_gt_debugfs_show_with_rpm, .data = xe_tuning_dump },
217 { "default_lrc_rcs", .show = xe_gt_debugfs_show_with_rpm, .data = rcs_default_lrc },
218 { "default_lrc_ccs", .show = xe_gt_debugfs_show_with_rpm, .data = ccs_default_lrc },
219 { "default_lrc_bcs", .show = xe_gt_debugfs_show_with_rpm, .data = bcs_default_lrc },
220 { "default_lrc_vcs", .show = xe_gt_debugfs_show_with_rpm, .data = vcs_default_lrc },
221 { "default_lrc_vecs", .show = xe_gt_debugfs_show_with_rpm, .data = vecs_default_lrc },
222 { "hwconfig", .show = xe_gt_debugfs_show_with_rpm, .data = hwconfig },
223};
224
225/* everything else should be added here */
226static const struct drm_info_list pf_only_debugfs_list[] = {
227 { "hw_engines", .show = xe_gt_debugfs_show_with_rpm, .data = hw_engines },
228 { "mocs", .show = xe_gt_debugfs_show_with_rpm, .data = xe_mocs_dump },
229 { "pat", .show = xe_gt_debugfs_show_with_rpm, .data = xe_pat_dump },
230 { "powergate_info", .show = xe_gt_debugfs_show_with_rpm, .data = xe_gt_idle_pg_print },
231 { "steering", .show = xe_gt_debugfs_show_with_rpm, .data = steering },
232};
233
234static ssize_t write_to_gt_call(const char __user *userbuf, size_t count, loff_t *ppos,
235 void (*call)(struct xe_gt *), struct xe_gt *gt)
236{
237 bool yes;
238 int ret;
239
240 if (*ppos)
241 return -EINVAL;
242 ret = kstrtobool_from_user(s: userbuf, count, res: &yes);
243 if (ret < 0)
244 return ret;
245 if (yes)
246 call(gt);
247 return count;
248}
249
250static ssize_t stats_write(struct file *file, const char __user *userbuf,
251 size_t count, loff_t *ppos)
252{
253 struct seq_file *s = file->private_data;
254 struct xe_gt *gt = s->private;
255
256 return write_to_gt_call(userbuf, count, ppos, call: xe_gt_stats_clear, gt);
257}
258
259static int stats_show(struct seq_file *s, void *unused)
260{
261 struct drm_printer p = drm_seq_file_printer(f: s);
262 struct xe_gt *gt = s->private;
263
264 return xe_gt_stats_print_info(gt, p: &p);
265}
266DEFINE_SHOW_STORE_ATTRIBUTE(stats);
267
268static void force_reset(struct xe_gt *gt)
269{
270 struct xe_device *xe = gt_to_xe(gt);
271
272 xe_pm_runtime_get(xe);
273 xe_gt_reset_async(gt);
274 xe_pm_runtime_put(xe);
275}
276
277static ssize_t force_reset_write(struct file *file,
278 const char __user *userbuf,
279 size_t count, loff_t *ppos)
280{
281 struct seq_file *s = file->private_data;
282 struct xe_gt *gt = s->private;
283
284 return write_to_gt_call(userbuf, count, ppos, call: force_reset, gt);
285}
286
287static int force_reset_show(struct seq_file *s, void *unused)
288{
289 struct xe_gt *gt = s->private;
290
291 force_reset(gt); /* to be deprecated! */
292 return 0;
293}
294DEFINE_SHOW_STORE_ATTRIBUTE(force_reset);
295
296static void force_reset_sync(struct xe_gt *gt)
297{
298 struct xe_device *xe = gt_to_xe(gt);
299
300 xe_pm_runtime_get(xe);
301 xe_gt_reset(gt);
302 xe_pm_runtime_put(xe);
303}
304
305static ssize_t force_reset_sync_write(struct file *file,
306 const char __user *userbuf,
307 size_t count, loff_t *ppos)
308{
309 struct seq_file *s = file->private_data;
310 struct xe_gt *gt = s->private;
311
312 return write_to_gt_call(userbuf, count, ppos, call: force_reset_sync, gt);
313}
314
315static int force_reset_sync_show(struct seq_file *s, void *unused)
316{
317 struct xe_gt *gt = s->private;
318
319 force_reset_sync(gt); /* to be deprecated! */
320 return 0;
321}
322DEFINE_SHOW_STORE_ATTRIBUTE(force_reset_sync);
323
324void xe_gt_debugfs_register(struct xe_gt *gt)
325{
326 struct xe_device *xe = gt_to_xe(gt);
327 struct drm_minor *minor = gt_to_xe(gt)->drm.primary;
328 struct dentry *parent = gt->tile->debugfs;
329 struct dentry *root;
330 char symlink[16];
331 char name[8];
332
333 xe_gt_assert(gt, minor->debugfs_root);
334
335 if (IS_ERR(ptr: parent))
336 return;
337
338 snprintf(buf: name, size: sizeof(name), fmt: "gt%d", gt->info.id);
339 root = debugfs_create_dir(name, parent);
340 if (IS_ERR(ptr: root)) {
341 drm_warn(&xe->drm, "Create GT directory failed");
342 return;
343 }
344
345 /*
346 * Store the xe_gt pointer as private data of the gt/ directory node
347 * so other GT specific attributes under that directory may refer to
348 * it by looking at its parent node private data.
349 */
350 root->d_inode->i_private = gt;
351
352 /* VF safe */
353 debugfs_create_file("stats", 0600, root, gt, &stats_fops);
354 debugfs_create_file("force_reset", 0600, root, gt, &force_reset_fops);
355 debugfs_create_file("force_reset_sync", 0600, root, gt, &force_reset_sync_fops);
356
357 drm_debugfs_create_files(files: vf_safe_debugfs_list,
358 ARRAY_SIZE(vf_safe_debugfs_list),
359 root, minor);
360
361 if (!IS_SRIOV_VF(xe))
362 drm_debugfs_create_files(files: pf_only_debugfs_list,
363 ARRAY_SIZE(pf_only_debugfs_list),
364 root, minor);
365
366 xe_uc_debugfs_register(uc: &gt->uc, parent: root);
367
368 if (IS_SRIOV_PF(xe))
369 xe_gt_sriov_pf_debugfs_register(gt, root);
370 else if (IS_SRIOV_VF(xe))
371 xe_gt_sriov_vf_debugfs_register(gt, root);
372
373 /*
374 * Backwards compatibility only: create a link for the legacy clients
375 * who may expect gt/ directory at the root level, not the tile level.
376 */
377 snprintf(buf: symlink, size: sizeof(symlink), fmt: "tile%u/%s", gt->tile->id, name);
378 debugfs_create_symlink(name, parent: minor->debugfs_root, dest: symlink);
379}
380

source code of linux/drivers/gpu/drm/xe/xe_gt_debugfs.c