xref: /linux/drivers/gpu/drm/xe/xe_debugfs.c (revision c0d6f52f9b62479d61f8cd4faf9fb2f8bce6e301) 
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 
39 DECLARE_FAULT_ATTR(gt_reset_failure);
40 DECLARE_FAULT_ATTR(inject_csc_hw_error);
41 
42 static 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(to_pci_dev(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 
59 static struct xe_device *node_to_xe(struct drm_info_node *node)
60 {
61 	return to_xe_device(node->minor->dev);
62 }
63 
64 static 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 
103 static 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 
112 static 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 
120 static 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 
129 static 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 
157 static 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 
183 static 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 
189 static 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 
194 static 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 
212 err_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 
226 static 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 
239 static const struct file_operations forcewake_all_fops = {
240 	.owner = THIS_MODULE,
241 	.open = forcewake_open,
242 	.release = forcewake_release,
243 };
244 
245 static 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 
257 static 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(&gt->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 
271 static 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 
294 static 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 
309 static 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 
335 static const struct file_operations wedged_mode_fops = {
336 	.owner = THIS_MODULE,
337 	.read = wedged_mode_show,
338 	.write = wedged_mode_set,
339 };
340 
341 static 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 
352 static 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 
368 static 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 
374 static 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 
386 static 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 
403 static 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 
409 static 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 
421 static 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 
437 static 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 
443 static 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 
455 static 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 
471 static 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 
477 static 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 
490 static 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 
506 static 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 
512 void 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, &gt_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 }
585