tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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_ggtt.h"
16#include "xe_gt.h"
17#include "xe_gt_mcr.h"
18#include "xe_gt_idle.h"
19#include "xe_gt_sriov_pf_debugfs.h"
20#include "xe_gt_sriov_vf_debugfs.h"
21#include "xe_gt_stats.h"
22#include "xe_gt_topology.h"
23#include "xe_guc_hwconfig.h"
24#include "xe_hw_engine.h"
25#include "xe_lrc.h"
26#include "xe_macros.h"
27#include "xe_mocs.h"
28#include "xe_pat.h"
29#include "xe_pm.h"
30#include "xe_reg_sr.h"
31#include "xe_reg_whitelist.h"
32#include "xe_sriov.h"
33#include "xe_tuning.h"
34#include "xe_uc_debugfs.h"
35#include "xe_wa.h"
36
37/**
38 * xe_gt_debugfs_simple_show - A show callback for struct drm_info_list
39 * @m: the &seq_file
40 * @data: data used by the drm debugfs helpers
41 *
42 * This callback can be used in struct drm_info_list to describe debugfs
43 * files that are &xe_gt specific.
44 *
45 * It is assumed that those debugfs files will be created on directory entry
46 * which struct dentry d_inode->i_private points to &xe_gt.
47 *
48 * This function assumes that &m->private will be set to the &struct
49 * drm_info_node corresponding to the instance of the info on a given &struct
50 * drm_minor (see struct drm_info_list.show for details).
51 *
52 * This function also assumes that struct drm_info_list.data will point to the
53 * function code that will actually print a file content::
54 *
55 * int (*print)(struct xe_gt *, struct drm_printer *)
56 *
57 * Example::
58 *
59 * int foo(struct xe_gt *gt, struct drm_printer *p)
60 * {
61 * drm_printf(p, "GT%u\n", gt->info.id);
62 * return 0;
63 * }
64 *
65 * static const struct drm_info_list bar[] = {
66 * { name = "foo", .show = xe_gt_debugfs_simple_show, .data = foo },
67 * };
68 *
69 * dir = debugfs_create_dir("gt", parent);
70 * dir->d_inode->i_private = gt;
71 * drm_debugfs_create_files(bar, ARRAY_SIZE(bar), dir, minor);
72 *
73 * Return: 0 on success or a negative error code on failure.
74 */
75int xe_gt_debugfs_simple_show(struct seq_file *m, void *data)
76{
77 struct drm_printer p = drm_seq_file_printer(m);
78 struct drm_info_node *node = m->private;
79 struct dentry *parent = node->dent->d_parent;
80 struct xe_gt *gt = parent->d_inode->i_private;
81 int (*print)(struct xe_gt *, struct drm_printer *) = node->info_ent->data;
82
83 if (WARN_ON(!print))
84 return -EINVAL;
85
86 return print(gt, &p);
87}
88
89static int hw_engines(struct xe_gt *gt, struct drm_printer *p)
90{
91 struct xe_device *xe = gt_to_xe(gt);
92 struct xe_hw_engine *hwe;
93 enum xe_hw_engine_id id;
94 unsigned int fw_ref;
95 int ret = 0;
96
97 xe_pm_runtime_get(xe);
98 fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FORCEWAKE_ALL);
99 if (!xe_force_wake_ref_has_domain(fw_ref, XE_FORCEWAKE_ALL)) {
100 ret = -ETIMEDOUT;
101 goto fw_put;
102 }
103
104 for_each_hw_engine(hwe, gt, id)
105 xe_hw_engine_print(hwe, p);
106
107fw_put:
108 xe_force_wake_put(gt_to_fw(gt), fw_ref);
109 xe_pm_runtime_put(xe);
110
111 return ret;
112}
113
114static int powergate_info(struct xe_gt *gt, struct drm_printer *p)
115{
116 int ret;
117
118 xe_pm_runtime_get(gt_to_xe(gt));
119 ret = xe_gt_idle_pg_print(gt, p);
120 xe_pm_runtime_put(gt_to_xe(gt));
121
122 return ret;
123}
124
125static int force_reset(struct xe_gt *gt, struct drm_printer *p)
126{
127 xe_pm_runtime_get(gt_to_xe(gt));
128 xe_gt_reset_async(gt);
129 xe_pm_runtime_put(gt_to_xe(gt));
130
131 return 0;
132}
133
134static int force_reset_sync(struct xe_gt *gt, struct drm_printer *p)
135{
136 xe_pm_runtime_get(gt_to_xe(gt));
137 xe_gt_reset(gt);
138 xe_pm_runtime_put(gt_to_xe(gt));
139
140 return 0;
141}
142
143static int sa_info(struct xe_gt *gt, struct drm_printer *p)
144{
145 struct xe_tile *tile = gt_to_tile(gt);
146
147 xe_pm_runtime_get(gt_to_xe(gt));
148 drm_suballoc_dump_debug_info(&tile->mem.kernel_bb_pool->base, p,
149 tile->mem.kernel_bb_pool->gpu_addr);
150 xe_pm_runtime_put(gt_to_xe(gt));
151
152 return 0;
153}
154
155static int topology(struct xe_gt *gt, struct drm_printer *p)
156{
157 xe_pm_runtime_get(gt_to_xe(gt));
158 xe_gt_topology_dump(gt, p);
159 xe_pm_runtime_put(gt_to_xe(gt));
160
161 return 0;
162}
163
164static int steering(struct xe_gt *gt, struct drm_printer *p)
165{
166 xe_pm_runtime_get(gt_to_xe(gt));
167 xe_gt_mcr_steering_dump(gt, p);
168 xe_pm_runtime_put(gt_to_xe(gt));
169
170 return 0;
171}
172
173static int ggtt(struct xe_gt *gt, struct drm_printer *p)
174{
175 int ret;
176
177 xe_pm_runtime_get(gt_to_xe(gt));
178 ret = xe_ggtt_dump(gt_to_tile(gt)->mem.ggtt, p);
179 xe_pm_runtime_put(gt_to_xe(gt));
180
181 return ret;
182}
183
184static int register_save_restore(struct xe_gt *gt, struct drm_printer *p)
185{
186 struct xe_hw_engine *hwe;
187 enum xe_hw_engine_id id;
188
189 xe_pm_runtime_get(gt_to_xe(gt));
190
191 xe_reg_sr_dump(>->reg_sr, p);
192 drm_printf(p, "\n");
193
194 drm_printf(p, "Engine\n");
195 for_each_hw_engine(hwe, gt, id)
196 xe_reg_sr_dump(&hwe->reg_sr, p);
197 drm_printf(p, "\n");
198
199 drm_printf(p, "LRC\n");
200 for_each_hw_engine(hwe, gt, id)
201 xe_reg_sr_dump(&hwe->reg_lrc, p);
202 drm_printf(p, "\n");
203
204 drm_printf(p, "Whitelist\n");
205 for_each_hw_engine(hwe, gt, id)
206 xe_reg_whitelist_dump(&hwe->reg_whitelist, p);
207
208 xe_pm_runtime_put(gt_to_xe(gt));
209
210 return 0;
211}
212
213static int workarounds(struct xe_gt *gt, struct drm_printer *p)
214{
215 xe_pm_runtime_get(gt_to_xe(gt));
216 xe_wa_dump(gt, p);
217 xe_pm_runtime_put(gt_to_xe(gt));
218
219 return 0;
220}
221
222static int tunings(struct xe_gt *gt, struct drm_printer *p)
223{
224 xe_pm_runtime_get(gt_to_xe(gt));
225 xe_tuning_dump(gt, p);
226 xe_pm_runtime_put(gt_to_xe(gt));
227
228 return 0;
229}
230
231static int pat(struct xe_gt *gt, struct drm_printer *p)
232{
233 xe_pm_runtime_get(gt_to_xe(gt));
234 xe_pat_dump(gt, p);
235 xe_pm_runtime_put(gt_to_xe(gt));
236
237 return 0;
238}
239
240static int mocs(struct xe_gt *gt, struct drm_printer *p)
241{
242 xe_pm_runtime_get(gt_to_xe(gt));
243 xe_mocs_dump(gt, p);
244 xe_pm_runtime_put(gt_to_xe(gt));
245
246 return 0;
247}
248
249static int rcs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
250{
251 xe_pm_runtime_get(gt_to_xe(gt));
252 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_RENDER);
253 xe_pm_runtime_put(gt_to_xe(gt));
254
255 return 0;
256}
257
258static int ccs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
259{
260 xe_pm_runtime_get(gt_to_xe(gt));
261 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_COMPUTE);
262 xe_pm_runtime_put(gt_to_xe(gt));
263
264 return 0;
265}
266
267static int bcs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
268{
269 xe_pm_runtime_get(gt_to_xe(gt));
270 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_COPY);
271 xe_pm_runtime_put(gt_to_xe(gt));
272
273 return 0;
274}
275
276static int vcs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
277{
278 xe_pm_runtime_get(gt_to_xe(gt));
279 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_VIDEO_DECODE);
280 xe_pm_runtime_put(gt_to_xe(gt));
281
282 return 0;
283}
284
285static int vecs_default_lrc(struct xe_gt *gt, struct drm_printer *p)
286{
287 xe_pm_runtime_get(gt_to_xe(gt));
288 xe_lrc_dump_default(p, gt, XE_ENGINE_CLASS_VIDEO_ENHANCE);
289 xe_pm_runtime_put(gt_to_xe(gt));
290
291 return 0;
292}
293
294static int hwconfig(struct xe_gt *gt, struct drm_printer *p)
295{
296 xe_pm_runtime_get(gt_to_xe(gt));
297 xe_guc_hwconfig_dump(>->uc.guc, p);
298 xe_pm_runtime_put(gt_to_xe(gt));
299
300 return 0;
301}
302
303static const struct drm_info_list debugfs_list[] = {
304 {"hw_engines", .show = xe_gt_debugfs_simple_show, .data = hw_engines},
305 {"force_reset", .show = xe_gt_debugfs_simple_show, .data = force_reset},
306 {"force_reset_sync", .show = xe_gt_debugfs_simple_show, .data = force_reset_sync},
307 {"sa_info", .show = xe_gt_debugfs_simple_show, .data = sa_info},
308 {"topology", .show = xe_gt_debugfs_simple_show, .data = topology},
309 {"steering", .show = xe_gt_debugfs_simple_show, .data = steering},
310 {"ggtt", .show = xe_gt_debugfs_simple_show, .data = ggtt},
311 {"powergate_info", .show = xe_gt_debugfs_simple_show, .data = powergate_info},
312 {"register-save-restore", .show = xe_gt_debugfs_simple_show, .data = register_save_restore},
313 {"workarounds", .show = xe_gt_debugfs_simple_show, .data = workarounds},
314 {"tunings", .show = xe_gt_debugfs_simple_show, .data = tunings},
315 {"pat", .show = xe_gt_debugfs_simple_show, .data = pat},
316 {"mocs", .show = xe_gt_debugfs_simple_show, .data = mocs},
317 {"default_lrc_rcs", .show = xe_gt_debugfs_simple_show, .data = rcs_default_lrc},
318 {"default_lrc_ccs", .show = xe_gt_debugfs_simple_show, .data = ccs_default_lrc},
319 {"default_lrc_bcs", .show = xe_gt_debugfs_simple_show, .data = bcs_default_lrc},
320 {"default_lrc_vcs", .show = xe_gt_debugfs_simple_show, .data = vcs_default_lrc},
321 {"default_lrc_vecs", .show = xe_gt_debugfs_simple_show, .data = vecs_default_lrc},
322 {"stats", .show = xe_gt_debugfs_simple_show, .data = xe_gt_stats_print_info},
323 {"hwconfig", .show = xe_gt_debugfs_simple_show, .data = hwconfig},
324};
325
326void xe_gt_debugfs_register(struct xe_gt *gt)
327{
328 struct xe_device *xe = gt_to_xe(gt);
329 struct drm_minor *minor = gt_to_xe(gt)->drm.primary;
330 struct dentry *root;
331 char name[8];
332
333 xe_gt_assert(gt, minor->debugfs_root);
334
335 snprintf(name, sizeof(name), "gt%d", gt->info.id);
336 root = debugfs_create_dir(name, minor->debugfs_root);
337 if (IS_ERR(root)) {
338 drm_warn(&xe->drm, "Create GT directory failed");
339 return;
340 }
341
342 /*
343 * Store the xe_gt pointer as private data of the gt/ directory node
344 * so other GT specific attributes under that directory may refer to
345 * it by looking at its parent node private data.
346 */
347 root->d_inode->i_private = gt;
348
349 drm_debugfs_create_files(debugfs_list,
350 ARRAY_SIZE(debugfs_list),
351 root, minor);
352
353 xe_uc_debugfs_register(>->uc, root);
354
355 if (IS_SRIOV_PF(xe))
356 xe_gt_sriov_pf_debugfs_register(gt, root);
357 else if (IS_SRIOV_VF(xe))
358 xe_gt_sriov_vf_debugfs_register(gt, root);
359}