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_debugfs.h"
7
8#include <linux/debugfs.h>
9#include <linux/fault-inject.h>
10#include <linux/string_helpers.h>
11
12#include <drm/drm_debugfs.h>
13
14#include "regs/xe_pmt.h"
15#include "xe_bo.h"
16#include "xe_device.h"
17#include "xe_force_wake.h"
18#include "xe_gt_debugfs.h"
19#include "xe_gt_printk.h"
20#include "xe_guc_ads.h"
21#include "xe_mmio.h"
22#include "xe_pm.h"
23#include "xe_psmi.h"
24#include "xe_pxp_debugfs.h"
25#include "xe_sriov.h"
26#include "xe_sriov_pf_debugfs.h"
27#include "xe_sriov_vf.h"
28#include "xe_step.h"
29#include "xe_tile_debugfs.h"
30#include "xe_vsec.h"
31#include "xe_wa.h"
32
33#ifdef CONFIG_DRM_XE_DEBUG
34#include "xe_bo_evict.h"
35#include "xe_migrate.h"
36#include "xe_vm.h"
37#endif
38
39DECLARE_FAULT_ATTR(gt_reset_failure);
40DECLARE_FAULT_ATTR(inject_csc_hw_error);
41
42static void read_residency_counter(struct xe_device *xe, struct xe_mmio *mmio,
43 u32 offset, const char *name, struct drm_printer *p)
44{
45 u64 residency = 0;
46 int ret;
47
48 ret = xe_pmt_telem_read(xe->drm.dev,
49 xe_mmio_read32(mmio, PUNIT_TELEMETRY_GUID),
50 &residency, offset, sizeof(residency));
51 if (ret != sizeof(residency)) {
52 drm_warn(&xe->drm, "%s counter failed to read, ret %d\n", name, ret);
53 return;
54 }
55
56 drm_printf(p, "%s : %llu\n", name, residency);
57}
58
59static struct xe_device *node_to_xe(struct drm_info_node *node)
60{
61 return to_xe_device(node->minor->dev);
62}
63
64static int info(struct seq_file *m, void *data)
65{
66 struct xe_device *xe = node_to_xe(m->private);
67 struct drm_printer p = drm_seq_file_printer(m);
68 struct xe_gt *gt;
69 u8 id;
70
71 guard(xe_pm_runtime)(xe);
72
73 drm_printf(&p, "graphics_verx100 %d\n", xe->info.graphics_verx100);
74 drm_printf(&p, "media_verx100 %d\n", xe->info.media_verx100);
75 drm_printf(&p, "stepping G:%s M:%s B:%s\n",
76 xe_step_name(xe->info.step.graphics),
77 xe_step_name(xe->info.step.media),
78 xe_step_name(xe->info.step.basedie));
79 drm_printf(&p, "is_dgfx %s\n", str_yes_no(xe->info.is_dgfx));
80 drm_printf(&p, "platform %d\n", xe->info.platform);
81 drm_printf(&p, "subplatform %d\n",
82 xe->info.subplatform > XE_SUBPLATFORM_NONE ? xe->info.subplatform : 0);
83 drm_printf(&p, "devid 0x%x\n", xe->info.devid);
84 drm_printf(&p, "revid %d\n", xe->info.revid);
85 drm_printf(&p, "tile_count %d\n", xe->info.tile_count);
86 drm_printf(&p, "vm_max_level %d\n", xe->info.vm_max_level);
87 drm_printf(&p, "force_execlist %s\n", str_yes_no(xe->info.force_execlist));
88 drm_printf(&p, "has_flat_ccs %s\n", str_yes_no(xe->info.has_flat_ccs));
89 drm_printf(&p, "has_usm %s\n", str_yes_no(xe->info.has_usm));
90 drm_printf(&p, "skip_guc_pc %s\n", str_yes_no(xe->info.skip_guc_pc));
91 for_each_gt(gt, xe, id) {
92 drm_printf(&p, "gt%d force wake %d\n", id,
93 xe_force_wake_ref(gt_to_fw(gt), XE_FW_GT));
94 drm_printf(&p, "gt%d engine_mask 0x%llx\n", id,
95 gt->info.engine_mask);
96 drm_printf(&p, "gt%d multi_queue_engine_class_mask 0x%x\n", id,
97 gt->info.multi_queue_engine_class_mask);
98 }
99
100 return 0;
101}
102
103static int sriov_info(struct seq_file *m, void *data)
104{
105 struct xe_device *xe = node_to_xe(m->private);
106 struct drm_printer p = drm_seq_file_printer(m);
107
108 xe_sriov_print_info(xe, &p);
109 return 0;
110}
111
112static int workarounds(struct xe_device *xe, struct drm_printer *p)
113{
114 guard(xe_pm_runtime)(xe);
115 xe_wa_device_dump(xe, p);
116
117 return 0;
118}
119
120static int workaround_info(struct seq_file *m, void *data)
121{
122 struct xe_device *xe = node_to_xe(m->private);
123 struct drm_printer p = drm_seq_file_printer(m);
124
125 workarounds(xe, &p);
126 return 0;
127}
128
129static int dgfx_pkg_residencies_show(struct seq_file *m, void *data)
130{
131 struct xe_device *xe;
132 struct xe_mmio *mmio;
133 struct drm_printer p;
134
135 xe = node_to_xe(m->private);
136 p = drm_seq_file_printer(m);
137 guard(xe_pm_runtime)(xe);
138 mmio = xe_root_tile_mmio(xe);
139 static const struct {
140 u32 offset;
141 const char *name;
142 } residencies[] = {
143 {BMG_G2_RESIDENCY_OFFSET, "Package G2"},
144 {BMG_G6_RESIDENCY_OFFSET, "Package G6"},
145 {BMG_G7_RESIDENCY_OFFSET, "Package G7"},
146 {BMG_G8_RESIDENCY_OFFSET, "Package G8"},
147 {BMG_G10_RESIDENCY_OFFSET, "Package G10"},
148 {BMG_MODS_RESIDENCY_OFFSET, "Package ModS"}
149 };
150
151 for (int i = 0; i < ARRAY_SIZE(residencies); i++)
152 read_residency_counter(xe, mmio, residencies[i].offset, residencies[i].name, &p);
153
154 return 0;
155}
156
157static int dgfx_pcie_link_residencies_show(struct seq_file *m, void *data)
158{
159 struct xe_device *xe;
160 struct xe_mmio *mmio;
161 struct drm_printer p;
162
163 xe = node_to_xe(m->private);
164 p = drm_seq_file_printer(m);
165 guard(xe_pm_runtime)(xe);
166 mmio = xe_root_tile_mmio(xe);
167
168 static const struct {
169 u32 offset;
170 const char *name;
171 } residencies[] = {
172 {BMG_PCIE_LINK_L0_RESIDENCY_OFFSET, "PCIE LINK L0 RESIDENCY"},
173 {BMG_PCIE_LINK_L1_RESIDENCY_OFFSET, "PCIE LINK L1 RESIDENCY"},
174 {BMG_PCIE_LINK_L1_2_RESIDENCY_OFFSET, "PCIE LINK L1.2 RESIDENCY"}
175 };
176
177 for (int i = 0; i < ARRAY_SIZE(residencies); i++)
178 read_residency_counter(xe, mmio, residencies[i].offset, residencies[i].name, &p);
179
180 return 0;
181}
182
183static const struct drm_info_list debugfs_list[] = {
184 {"info", info, 0},
185 { .name = "sriov_info", .show = sriov_info, },
186 { .name = "workarounds", .show = workaround_info, },
187};
188
189static const struct drm_info_list debugfs_residencies[] = {
190 { .name = "dgfx_pkg_residencies", .show = dgfx_pkg_residencies_show, },
191 { .name = "dgfx_pcie_link_residencies", .show = dgfx_pcie_link_residencies_show, },
192};
193
194static int forcewake_open(struct inode *inode, struct file *file)
195{
196 struct xe_device *xe = inode->i_private;
197 struct xe_gt *gt;
198 u8 id, last_gt;
199 unsigned int fw_ref;
200
201 xe_pm_runtime_get(xe);
202 for_each_gt(gt, xe, id) {
203 last_gt = id;
204
205 fw_ref = xe_force_wake_get(gt_to_fw(gt), XE_FORCEWAKE_ALL);
206 if (!xe_force_wake_ref_has_domain(fw_ref, XE_FORCEWAKE_ALL))
207 goto err_fw_get;
208 }
209
210 return 0;
211
212err_fw_get:
213 for_each_gt(gt, xe, id) {
214 if (id < last_gt)
215 xe_force_wake_put(gt_to_fw(gt), XE_FORCEWAKE_ALL);
216 else if (id == last_gt)
217 xe_force_wake_put(gt_to_fw(gt), fw_ref);
218 else
219 break;
220 }
221
222 xe_pm_runtime_put(xe);
223 return -ETIMEDOUT;
224}
225
226static int forcewake_release(struct inode *inode, struct file *file)
227{
228 struct xe_device *xe = inode->i_private;
229 struct xe_gt *gt;
230 u8 id;
231
232 for_each_gt(gt, xe, id)
233 xe_force_wake_put(gt_to_fw(gt), XE_FORCEWAKE_ALL);
234 xe_pm_runtime_put(xe);
235
236 return 0;
237}
238
239static const struct file_operations forcewake_all_fops = {
240 .owner = THIS_MODULE,
241 .open = forcewake_open,
242 .release = forcewake_release,
243};
244
245static ssize_t wedged_mode_show(struct file *f, char __user *ubuf,
246 size_t size, loff_t *pos)
247{
248 struct xe_device *xe = file_inode(f)->i_private;
249 char buf[32];
250 int len = 0;
251
252 len = scnprintf(buf, sizeof(buf), "%d\n", xe->wedged.mode);
253
254 return simple_read_from_buffer(ubuf, size, pos, buf, len);
255}
256
257static int __wedged_mode_set_reset_policy(struct xe_gt *gt, enum xe_wedged_mode mode)
258{
259 bool enable_engine_reset;
260 int ret;
261
262 enable_engine_reset = (mode != XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET);
263 ret = xe_guc_ads_scheduler_policy_toggle_reset(>->uc.guc.ads,
264 enable_engine_reset);
265 if (ret)
266 xe_gt_err(gt, "Failed to update GuC ADS scheduler policy (%pe)\n", ERR_PTR(ret));
267
268 return ret;
269}
270
271static int wedged_mode_set_reset_policy(struct xe_device *xe, enum xe_wedged_mode mode)
272{
273 struct xe_gt *gt;
274 int ret;
275 u8 id;
276
277 guard(xe_pm_runtime)(xe);
278 for_each_gt(gt, xe, id) {
279 ret = __wedged_mode_set_reset_policy(gt, mode);
280 if (ret) {
281 if (id > 0) {
282 xe->wedged.inconsistent_reset = true;
283 drm_err(&xe->drm, "Inconsistent reset policy state between GTs\n");
284 }
285 return ret;
286 }
287 }
288
289 xe->wedged.inconsistent_reset = false;
290
291 return 0;
292}
293
294static bool wedged_mode_needs_policy_update(struct xe_device *xe, enum xe_wedged_mode mode)
295{
296 if (xe->wedged.inconsistent_reset)
297 return true;
298
299 if (xe->wedged.mode == mode)
300 return false;
301
302 if (xe->wedged.mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET ||
303 mode == XE_WEDGED_MODE_UPON_ANY_HANG_NO_RESET)
304 return true;
305
306 return false;
307}
308
309static ssize_t wedged_mode_set(struct file *f, const char __user *ubuf,
310 size_t size, loff_t *pos)
311{
312 struct xe_device *xe = file_inode(f)->i_private;
313 u32 wedged_mode;
314 ssize_t ret;
315
316 ret = kstrtouint_from_user(ubuf, size, 0, &wedged_mode);
317 if (ret)
318 return ret;
319
320 ret = xe_device_validate_wedged_mode(xe, wedged_mode);
321 if (ret)
322 return ret;
323
324 if (wedged_mode_needs_policy_update(xe, wedged_mode)) {
325 ret = wedged_mode_set_reset_policy(xe, wedged_mode);
326 if (ret)
327 return ret;
328 }
329
330 xe->wedged.mode = wedged_mode;
331
332 return size;
333}
334
335static const struct file_operations wedged_mode_fops = {
336 .owner = THIS_MODULE,
337 .read = wedged_mode_show,
338 .write = wedged_mode_set,
339};
340
341static ssize_t page_reclaim_hw_assist_show(struct file *f, char __user *ubuf,
342 size_t size, loff_t *pos)
343{
344 struct xe_device *xe = file_inode(f)->i_private;
345 char buf[8];
346 int len;
347
348 len = scnprintf(buf, sizeof(buf), "%d\n", xe->info.has_page_reclaim_hw_assist);
349 return simple_read_from_buffer(ubuf, size, pos, buf, len);
350}
351
352static ssize_t page_reclaim_hw_assist_set(struct file *f, const char __user *ubuf,
353 size_t size, loff_t *pos)
354{
355 struct xe_device *xe = file_inode(f)->i_private;
356 bool val;
357 ssize_t ret;
358
359 ret = kstrtobool_from_user(ubuf, size, &val);
360 if (ret)
361 return ret;
362
363 xe->info.has_page_reclaim_hw_assist = val;
364
365 return size;
366}
367
368static const struct file_operations page_reclaim_hw_assist_fops = {
369 .owner = THIS_MODULE,
370 .read = page_reclaim_hw_assist_show,
371 .write = page_reclaim_hw_assist_set,
372};
373
374static ssize_t atomic_svm_timeslice_ms_show(struct file *f, char __user *ubuf,
375 size_t size, loff_t *pos)
376{
377 struct xe_device *xe = file_inode(f)->i_private;
378 char buf[32];
379 int len = 0;
380
381 len = scnprintf(buf, sizeof(buf), "%d\n", xe->atomic_svm_timeslice_ms);
382
383 return simple_read_from_buffer(ubuf, size, pos, buf, len);
384}
385
386static ssize_t atomic_svm_timeslice_ms_set(struct file *f,
387 const char __user *ubuf,
388 size_t size, loff_t *pos)
389{
390 struct xe_device *xe = file_inode(f)->i_private;
391 u32 atomic_svm_timeslice_ms;
392 ssize_t ret;
393
394 ret = kstrtouint_from_user(ubuf, size, 0, &atomic_svm_timeslice_ms);
395 if (ret)
396 return ret;
397
398 xe->atomic_svm_timeslice_ms = atomic_svm_timeslice_ms;
399
400 return size;
401}
402
403static const struct file_operations atomic_svm_timeslice_ms_fops = {
404 .owner = THIS_MODULE,
405 .read = atomic_svm_timeslice_ms_show,
406 .write = atomic_svm_timeslice_ms_set,
407};
408
409static ssize_t min_run_period_lr_ms_show(struct file *f, char __user *ubuf,
410 size_t size, loff_t *pos)
411{
412 struct xe_device *xe = file_inode(f)->i_private;
413 char buf[32];
414 int len = 0;
415
416 len = scnprintf(buf, sizeof(buf), "%d\n", xe->min_run_period_lr_ms);
417
418 return simple_read_from_buffer(ubuf, size, pos, buf, len);
419}
420
421static ssize_t min_run_period_lr_ms_set(struct file *f, const char __user *ubuf,
422 size_t size, loff_t *pos)
423{
424 struct xe_device *xe = file_inode(f)->i_private;
425 u32 min_run_period_lr_ms;
426 ssize_t ret;
427
428 ret = kstrtouint_from_user(ubuf, size, 0, &min_run_period_lr_ms);
429 if (ret)
430 return ret;
431
432 xe->min_run_period_lr_ms = min_run_period_lr_ms;
433
434 return size;
435}
436
437static const struct file_operations min_run_period_lr_ms_fops = {
438 .owner = THIS_MODULE,
439 .read = min_run_period_lr_ms_show,
440 .write = min_run_period_lr_ms_set,
441};
442
443static ssize_t min_run_period_pf_ms_show(struct file *f, char __user *ubuf,
444 size_t size, loff_t *pos)
445{
446 struct xe_device *xe = file_inode(f)->i_private;
447 char buf[32];
448 int len = 0;
449
450 len = scnprintf(buf, sizeof(buf), "%d\n", xe->min_run_period_pf_ms);
451
452 return simple_read_from_buffer(ubuf, size, pos, buf, len);
453}
454
455static ssize_t min_run_period_pf_ms_set(struct file *f, const char __user *ubuf,
456 size_t size, loff_t *pos)
457{
458 struct xe_device *xe = file_inode(f)->i_private;
459 u32 min_run_period_pf_ms;
460 ssize_t ret;
461
462 ret = kstrtouint_from_user(ubuf, size, 0, &min_run_period_pf_ms);
463 if (ret)
464 return ret;
465
466 xe->min_run_period_pf_ms = min_run_period_pf_ms;
467
468 return size;
469}
470
471static const struct file_operations min_run_period_pf_ms_fops = {
472 .owner = THIS_MODULE,
473 .read = min_run_period_pf_ms_show,
474 .write = min_run_period_pf_ms_set,
475};
476
477static ssize_t disable_late_binding_show(struct file *f, char __user *ubuf,
478 size_t size, loff_t *pos)
479{
480 struct xe_device *xe = file_inode(f)->i_private;
481 struct xe_late_bind *late_bind = &xe->late_bind;
482 char buf[32];
483 int len;
484
485 len = scnprintf(buf, sizeof(buf), "%d\n", late_bind->disable);
486
487 return simple_read_from_buffer(ubuf, size, pos, buf, len);
488}
489
490static ssize_t disable_late_binding_set(struct file *f, const char __user *ubuf,
491 size_t size, loff_t *pos)
492{
493 struct xe_device *xe = file_inode(f)->i_private;
494 struct xe_late_bind *late_bind = &xe->late_bind;
495 bool val;
496 int ret;
497
498 ret = kstrtobool_from_user(ubuf, size, &val);
499 if (ret)
500 return ret;
501
502 late_bind->disable = val;
503 return size;
504}
505
506static const struct file_operations disable_late_binding_fops = {
507 .owner = THIS_MODULE,
508 .read = disable_late_binding_show,
509 .write = disable_late_binding_set,
510};
511
512void xe_debugfs_register(struct xe_device *xe)
513{
514 struct ttm_device *bdev = &xe->ttm;
515 struct drm_minor *minor = xe->drm.primary;
516 struct dentry *root = minor->debugfs_root;
517 struct ttm_resource_manager *man;
518 struct xe_tile *tile;
519 struct xe_gt *gt;
520 u8 tile_id;
521 u8 id;
522
523 drm_debugfs_create_files(debugfs_list,
524 ARRAY_SIZE(debugfs_list),
525 root, minor);
526
527 if (xe->info.platform == XE_BATTLEMAGE && !IS_SRIOV_VF(xe)) {
528 drm_debugfs_create_files(debugfs_residencies,
529 ARRAY_SIZE(debugfs_residencies),
530 root, minor);
531 fault_create_debugfs_attr("inject_csc_hw_error", root,
532 &inject_csc_hw_error);
533 }
534
535 debugfs_create_file("forcewake_all", 0400, root, xe,
536 &forcewake_all_fops);
537
538 debugfs_create_file("wedged_mode", 0600, root, xe,
539 &wedged_mode_fops);
540
541 debugfs_create_file("atomic_svm_timeslice_ms", 0600, root, xe,
542 &atomic_svm_timeslice_ms_fops);
543
544 debugfs_create_file("min_run_period_lr_ms", 0600, root, xe,
545 &min_run_period_lr_ms_fops);
546
547 debugfs_create_file("min_run_period_pf_ms", 0600, root, xe,
548 &min_run_period_pf_ms_fops);
549
550 debugfs_create_file("disable_late_binding", 0600, root, xe,
551 &disable_late_binding_fops);
552
553 /*
554 * Don't expose page reclaim configuration file if not supported by the
555 * hardware initially.
556 */
557 if (xe->info.has_page_reclaim_hw_assist)
558 debugfs_create_file("page_reclaim_hw_assist", 0600, root, xe,
559 &page_reclaim_hw_assist_fops);
560
561 man = ttm_manager_type(bdev, XE_PL_TT);
562 ttm_resource_manager_create_debugfs(man, root, "gtt_mm");
563
564 man = ttm_manager_type(bdev, XE_PL_STOLEN);
565 if (man)
566 ttm_resource_manager_create_debugfs(man, root, "stolen_mm");
567
568 for_each_tile(tile, xe, tile_id)
569 xe_tile_debugfs_register(tile);
570
571 for_each_gt(gt, xe, id)
572 xe_gt_debugfs_register(gt);
573
574 xe_pxp_debugfs_register(xe->pxp);
575
576 xe_psmi_debugfs_register(xe);
577
578 fault_create_debugfs_attr("fail_gt_reset", root, >_reset_failure);
579
580 if (IS_SRIOV_PF(xe))
581 xe_sriov_pf_debugfs_register(xe, root);
582 else if (IS_SRIOV_VF(xe))
583 xe_sriov_vf_debugfs_register(xe, root);
584}