ivpu_debugfs.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2020-2024 Intel Corporation
  4 */
  5
  6#include <linux/debugfs.h>
  7#include <linux/fault-inject.h>
  8
  9#include <drm/drm_debugfs.h>
 10#include <drm/drm_file.h>
 11#include <drm/drm_print.h>
 12
 13#include <uapi/drm/ivpu_accel.h>
 14
 15#include "ivpu_debugfs.h"
 16#include "ivpu_drv.h"
 17#include "ivpu_fw.h"
 18#include "ivpu_fw_log.h"
 19#include "ivpu_gem.h"
 20#include "ivpu_hw.h"
 21#include "ivpu_jsm_msg.h"
 22#include "ivpu_pm.h"
 23
 24static inline struct ivpu_device *seq_to_ivpu(struct seq_file *s)
 25{
 26	struct drm_debugfs_entry *entry = s->private;
 27
 28	return to_ivpu_device(entry->dev);
 29}
 30
 31static int bo_list_show(struct seq_file *s, void *v)
 32{
 33	struct drm_printer p = drm_seq_file_printer(s);
 34	struct ivpu_device *vdev = seq_to_ivpu(s);
 35
 36	ivpu_bo_list(&vdev->drm, &p);
 37
 38	return 0;
 39}
 40
 41static int fw_name_show(struct seq_file *s, void *v)
 42{
 43	struct ivpu_device *vdev = seq_to_ivpu(s);
 44
 45	seq_printf(s, "%s\n", vdev->fw->name);
 46	return 0;
 47}
 48
 49static int fw_version_show(struct seq_file *s, void *v)
 50{
 51	struct ivpu_device *vdev = seq_to_ivpu(s);
 52
 53	seq_printf(s, "%s\n", vdev->fw->version);
 54	return 0;
 55}
 56
 57static int fw_trace_capability_show(struct seq_file *s, void *v)
 58{
 59	struct ivpu_device *vdev = seq_to_ivpu(s);
 60	u64 trace_hw_component_mask;
 61	u32 trace_destination_mask;
 62	int ret;
 63
 64	ret = ivpu_jsm_trace_get_capability(vdev, &trace_destination_mask,
 65					    &trace_hw_component_mask);
 66	if (!ret) {
 67		seq_printf(s,
 68			   "trace_destination_mask:  %#18x\n"
 69			   "trace_hw_component_mask: %#18llx\n",
 70			   trace_destination_mask, trace_hw_component_mask);
 71	}
 72	return 0;
 73}
 74
 75static int fw_trace_config_show(struct seq_file *s, void *v)
 76{
 77	struct ivpu_device *vdev = seq_to_ivpu(s);
 78	/**
 79	 * WA: VPU_JSM_MSG_TRACE_GET_CONFIG command is not working yet,
 80	 * so we use values from vdev->fw instead of calling ivpu_jsm_trace_get_config()
 81	 */
 82	u32 trace_level = vdev->fw->trace_level;
 83	u32 trace_destination_mask = vdev->fw->trace_destination_mask;
 84	u64 trace_hw_component_mask = vdev->fw->trace_hw_component_mask;
 85
 86	seq_printf(s,
 87		   "trace_level:             %#18x\n"
 88		   "trace_destination_mask:  %#18x\n"
 89		   "trace_hw_component_mask: %#18llx\n",
 90		   trace_level, trace_destination_mask, trace_hw_component_mask);
 91
 92	return 0;
 93}
 94
 95static int last_bootmode_show(struct seq_file *s, void *v)
 96{
 97	struct ivpu_device *vdev = seq_to_ivpu(s);
 98
 99	seq_printf(s, "%s\n", (vdev->pm->is_warmboot) ? "warmboot" : "coldboot");
100
101	return 0;
102}
103
104static int reset_counter_show(struct seq_file *s, void *v)
105{
106	struct ivpu_device *vdev = seq_to_ivpu(s);
107
108	seq_printf(s, "%d\n", atomic_read(&vdev->pm->reset_counter));
109	return 0;
110}
111
112static int reset_pending_show(struct seq_file *s, void *v)
113{
114	struct ivpu_device *vdev = seq_to_ivpu(s);
115
116	seq_printf(s, "%d\n", atomic_read(&vdev->pm->reset_pending));
117	return 0;
118}
119
120static int firewall_irq_counter_show(struct seq_file *s, void *v)
121{
122	struct ivpu_device *vdev = seq_to_ivpu(s);
123
124	seq_printf(s, "%d\n", atomic_read(&vdev->hw->firewall_irq_counter));
125	return 0;
126}
127
128static const struct drm_debugfs_info vdev_debugfs_list[] = {
129	{"bo_list", bo_list_show, 0},
130	{"fw_name", fw_name_show, 0},
131	{"fw_version", fw_version_show, 0},
132	{"fw_trace_capability", fw_trace_capability_show, 0},
133	{"fw_trace_config", fw_trace_config_show, 0},
134	{"last_bootmode", last_bootmode_show, 0},
135	{"reset_counter", reset_counter_show, 0},
136	{"reset_pending", reset_pending_show, 0},
137	{"firewall_irq_counter", firewall_irq_counter_show, 0},
138};
139
140static int dvfs_mode_get(void *data, u64 *dvfs_mode)
141{
142	struct ivpu_device *vdev = (struct ivpu_device *)data;
143
144	*dvfs_mode = vdev->fw->dvfs_mode;
145	return 0;
146}
147
148static int dvfs_mode_set(void *data, u64 dvfs_mode)
149{
150	struct ivpu_device *vdev = (struct ivpu_device *)data;
151
152	vdev->fw->dvfs_mode = (u32)dvfs_mode;
153	return pci_try_reset_function(to_pci_dev(vdev->drm.dev));
154}
155
156DEFINE_DEBUGFS_ATTRIBUTE(dvfs_mode_fops, dvfs_mode_get, dvfs_mode_set, "%llu\n");
157
158static ssize_t
159fw_dyndbg_fops_write(struct file *file, const char __user *user_buf, size_t size, loff_t *pos)
160{
161	struct ivpu_device *vdev = file->private_data;
162	char buffer[VPU_DYNDBG_CMD_MAX_LEN] = {};
163	int ret;
164
165	if (size >= VPU_DYNDBG_CMD_MAX_LEN)
166		return -EINVAL;
167
168	ret = strncpy_from_user(buffer, user_buf, size);
169	if (ret < 0)
170		return ret;
171
172	ivpu_jsm_dyndbg_control(vdev, buffer, size);
173	return size;
174}
175
176static const struct file_operations fw_dyndbg_fops = {
177	.owner = THIS_MODULE,
178	.open = simple_open,
179	.write = fw_dyndbg_fops_write,
180};
181
182static int fw_log_show(struct seq_file *s, void *v)
183{
184	struct ivpu_device *vdev = s->private;
185	struct drm_printer p = drm_seq_file_printer(s);
186
187	ivpu_fw_log_print(vdev, true, &p);
188	return 0;
189}
190
191static int fw_log_fops_open(struct inode *inode, struct file *file)
192{
193	return single_open(file, fw_log_show, inode->i_private);
194}
195
196static ssize_t
197fw_log_fops_write(struct file *file, const char __user *user_buf, size_t size, loff_t *pos)
198{
199	struct seq_file *s = file->private_data;
200	struct ivpu_device *vdev = s->private;
201
202	if (!size)
203		return -EINVAL;
204
205	ivpu_fw_log_mark_read(vdev);
206	return size;
207}
208
209static const struct file_operations fw_log_fops = {
210	.owner = THIS_MODULE,
211	.open = fw_log_fops_open,
212	.write = fw_log_fops_write,
213	.read = seq_read,
214	.llseek = seq_lseek,
215	.release = single_release,
216};
217
218static ssize_t
219fw_profiling_freq_fops_write(struct file *file, const char __user *user_buf,
220			     size_t size, loff_t *pos)
221{
222	struct ivpu_device *vdev = file->private_data;
223	bool enable;
224	int ret;
225
226	ret = kstrtobool_from_user(user_buf, size, &enable);
227	if (ret < 0)
228		return ret;
229
230	ivpu_hw_profiling_freq_drive(vdev, enable);
231
232	ret = pci_try_reset_function(to_pci_dev(vdev->drm.dev));
233	if (ret)
234		return ret;
235
236	return size;
237}
238
239static const struct file_operations fw_profiling_freq_fops = {
240	.owner = THIS_MODULE,
241	.open = simple_open,
242	.write = fw_profiling_freq_fops_write,
243};
244
245static ssize_t
246fw_trace_destination_mask_fops_write(struct file *file, const char __user *user_buf,
247				     size_t size, loff_t *pos)
248{
249	struct ivpu_device *vdev = file->private_data;
250	struct ivpu_fw_info *fw = vdev->fw;
251	u32 trace_destination_mask;
252	int ret;
253
254	ret = kstrtou32_from_user(user_buf, size, 0, &trace_destination_mask);
255	if (ret < 0)
256		return ret;
257
258	fw->trace_destination_mask = trace_destination_mask;
259
260	ivpu_jsm_trace_set_config(vdev, fw->trace_level, trace_destination_mask,
261				  fw->trace_hw_component_mask);
262
263	return size;
264}
265
266static const struct file_operations fw_trace_destination_mask_fops = {
267	.owner = THIS_MODULE,
268	.open = simple_open,
269	.write = fw_trace_destination_mask_fops_write,
270};
271
272static ssize_t
273fw_trace_hw_comp_mask_fops_write(struct file *file, const char __user *user_buf,
274				 size_t size, loff_t *pos)
275{
276	struct ivpu_device *vdev = file->private_data;
277	struct ivpu_fw_info *fw = vdev->fw;
278	u64 trace_hw_component_mask;
279	int ret;
280
281	ret = kstrtou64_from_user(user_buf, size, 0, &trace_hw_component_mask);
282	if (ret < 0)
283		return ret;
284
285	fw->trace_hw_component_mask = trace_hw_component_mask;
286
287	ivpu_jsm_trace_set_config(vdev, fw->trace_level, fw->trace_destination_mask,
288				  trace_hw_component_mask);
289
290	return size;
291}
292
293static const struct file_operations fw_trace_hw_comp_mask_fops = {
294	.owner = THIS_MODULE,
295	.open = simple_open,
296	.write = fw_trace_hw_comp_mask_fops_write,
297};
298
299static ssize_t
300fw_trace_level_fops_write(struct file *file, const char __user *user_buf, size_t size, loff_t *pos)
301{
302	struct ivpu_device *vdev = file->private_data;
303	struct ivpu_fw_info *fw = vdev->fw;
304	u32 trace_level;
305	int ret;
306
307	ret = kstrtou32_from_user(user_buf, size, 0, &trace_level);
308	if (ret < 0)
309		return ret;
310
311	fw->trace_level = trace_level;
312
313	ivpu_jsm_trace_set_config(vdev, trace_level, fw->trace_destination_mask,
314				  fw->trace_hw_component_mask);
315
316	return size;
317}
318
319static const struct file_operations fw_trace_level_fops = {
320	.owner = THIS_MODULE,
321	.open = simple_open,
322	.write = fw_trace_level_fops_write,
323};
324
325static ssize_t
326ivpu_force_recovery_fn(struct file *file, const char __user *user_buf, size_t size, loff_t *pos)
327{
328	struct ivpu_device *vdev = file->private_data;
329	int ret;
330
331	if (!size)
332		return -EINVAL;
333
334	ret = ivpu_rpm_get(vdev);
335	if (ret < 0)
336		return ret;
337
338	ivpu_pm_trigger_recovery(vdev, "debugfs");
339	flush_work(&vdev->pm->recovery_work);
340	ivpu_rpm_put(vdev);
341	return size;
342}
343
344static const struct file_operations ivpu_force_recovery_fops = {
345	.owner = THIS_MODULE,
346	.open = simple_open,
347	.write = ivpu_force_recovery_fn,
348};
349
350static int ivpu_reset_engine_fn(void *data, u64 val)
351{
352	struct ivpu_device *vdev = (struct ivpu_device *)data;
353
354	return ivpu_jsm_reset_engine(vdev, (u32)val);
355}
356
357DEFINE_DEBUGFS_ATTRIBUTE(ivpu_reset_engine_fops, NULL, ivpu_reset_engine_fn, "0x%02llx\n");
358
359static int ivpu_resume_engine_fn(void *data, u64 val)
360{
361	struct ivpu_device *vdev = (struct ivpu_device *)data;
362
363	return ivpu_jsm_hws_resume_engine(vdev, (u32)val);
364}
365
366DEFINE_DEBUGFS_ATTRIBUTE(ivpu_resume_engine_fops, NULL, ivpu_resume_engine_fn, "0x%02llx\n");
367
368static int dct_active_get(void *data, u64 *active_percent)
369{
370	struct ivpu_device *vdev = data;
371
372	*active_percent = vdev->pm->dct_active_percent;
373
374	return 0;
375}
376
377static int dct_active_set(void *data, u64 active_percent)
378{
379	struct ivpu_device *vdev = data;
380	int ret;
381
382	if (active_percent > 100)
383		return -EINVAL;
384
385	ret = ivpu_rpm_get(vdev);
386	if (ret < 0)
387		return ret;
388
389	if (active_percent)
390		ret = ivpu_pm_dct_enable(vdev, active_percent);
391	else
392		ret = ivpu_pm_dct_disable(vdev);
393
394	ivpu_rpm_put(vdev);
395
396	return ret;
397}
398
399DEFINE_DEBUGFS_ATTRIBUTE(ivpu_dct_fops, dct_active_get, dct_active_set, "%llu\n");
400
401static void print_priority_band(struct seq_file *s, struct ivpu_hw_info *hw,
402				int band, const char *name)
403{
404	seq_printf(s, "%-9s: grace_period %9u process_grace_period %9u process_quantum %9u\n",
405		   name,
406		   hw->hws.grace_period[band],
407		   hw->hws.process_grace_period[band],
408		   hw->hws.process_quantum[band]);
409}
410
411static int priority_bands_show(struct seq_file *s, void *v)
412{
413	struct ivpu_device *vdev = s->private;
414	struct ivpu_hw_info *hw = vdev->hw;
415
416	print_priority_band(s, hw, VPU_JOB_SCHEDULING_PRIORITY_BAND_IDLE, "Idle");
417	print_priority_band(s, hw, VPU_JOB_SCHEDULING_PRIORITY_BAND_NORMAL, "Normal");
418	print_priority_band(s, hw, VPU_JOB_SCHEDULING_PRIORITY_BAND_FOCUS, "Focus");
419	print_priority_band(s, hw, VPU_JOB_SCHEDULING_PRIORITY_BAND_REALTIME, "Realtime");
420
421	return 0;
422}
423
424static int priority_bands_fops_open(struct inode *inode, struct file *file)
425{
426	return single_open(file, priority_bands_show, inode->i_private);
427}
428
429static ssize_t
430priority_bands_fops_write(struct file *file, const char __user *user_buf, size_t size, loff_t *pos)
431{
432	struct seq_file *s = file->private_data;
433	struct ivpu_device *vdev = s->private;
434	char buf[64];
435	u32 grace_period;
436	u32 process_grace_period;
437	u32 process_quantum;
438	u32 band;
439	int ret;
440
441	if (size >= sizeof(buf))
442		return -EINVAL;
443
444	ret = simple_write_to_buffer(buf, sizeof(buf) - 1, pos, user_buf, size);
445	if (ret < 0)
446		return ret;
447
448	buf[ret] = '\0';
449	ret = sscanf(buf, "%u %u %u %u", &band, &grace_period, &process_grace_period,
450		     &process_quantum);
451	if (ret != 4)
452		return -EINVAL;
453
454	if (band >= VPU_JOB_SCHEDULING_PRIORITY_BAND_COUNT)
455		return -EINVAL;
456
457	vdev->hw->hws.grace_period[band] = grace_period;
458	vdev->hw->hws.process_grace_period[band] = process_grace_period;
459	vdev->hw->hws.process_quantum[band] = process_quantum;
460
461	return size;
462}
463
464static const struct file_operations ivpu_hws_priority_bands_fops = {
465	.owner = THIS_MODULE,
466	.open = priority_bands_fops_open,
467	.write = priority_bands_fops_write,
468	.read = seq_read,
469	.llseek = seq_lseek,
470	.release = single_release,
471};
472
473void ivpu_debugfs_init(struct ivpu_device *vdev)
474{
475	struct dentry *debugfs_root = vdev->drm.debugfs_root;
476
477	drm_debugfs_add_files(&vdev->drm, vdev_debugfs_list, ARRAY_SIZE(vdev_debugfs_list));
478
479	debugfs_create_file("force_recovery", 0200, debugfs_root, vdev,
480			    &ivpu_force_recovery_fops);
481
482	debugfs_create_file("dvfs_mode", 0644, debugfs_root, vdev,
483			    &dvfs_mode_fops);
484
485	debugfs_create_file("fw_dyndbg", 0200, debugfs_root, vdev,
486			    &fw_dyndbg_fops);
487	debugfs_create_file("fw_log", 0644, debugfs_root, vdev,
488			    &fw_log_fops);
489	debugfs_create_file("fw_trace_destination_mask", 0200, debugfs_root, vdev,
490			    &fw_trace_destination_mask_fops);
491	debugfs_create_file("fw_trace_hw_comp_mask", 0200, debugfs_root, vdev,
492			    &fw_trace_hw_comp_mask_fops);
493	debugfs_create_file("fw_trace_level", 0200, debugfs_root, vdev,
494			    &fw_trace_level_fops);
495	debugfs_create_file("hws_priority_bands", 0200, debugfs_root, vdev,
496			    &ivpu_hws_priority_bands_fops);
497
498	debugfs_create_file("reset_engine", 0200, debugfs_root, vdev,
499			    &ivpu_reset_engine_fops);
500	debugfs_create_file("resume_engine", 0200, debugfs_root, vdev,
501			    &ivpu_resume_engine_fops);
502
503	if (ivpu_hw_ip_gen(vdev) >= IVPU_HW_IP_40XX) {
504		debugfs_create_file("fw_profiling_freq_drive", 0200,
505				    debugfs_root, vdev, &fw_profiling_freq_fops);
506		debugfs_create_file("dct", 0644, debugfs_root, vdev, &ivpu_dct_fops);
507	}
508
509#ifdef CONFIG_FAULT_INJECTION
510	fault_create_debugfs_attr("fail_hw", debugfs_root, &ivpu_hw_failure);
511#endif
512}