xref: /openbsd-src/sys/dev/pci/drm/drm_debugfs.c (revision f005ef32267c16bdb134f0e9fa4477dbe07c263a)
1c349dbc7Sjsg /*
2c349dbc7Sjsg  * Created: Sun Dec 21 13:08:50 2008 by bgamari@gmail.com
3c349dbc7Sjsg  *
4c349dbc7Sjsg  * Copyright 2008 Ben Gamari <bgamari@gmail.com>
5c349dbc7Sjsg  *
6c349dbc7Sjsg  * Permission is hereby granted, free of charge, to any person obtaining a
7c349dbc7Sjsg  * copy of this software and associated documentation files (the "Software"),
8c349dbc7Sjsg  * to deal in the Software without restriction, including without limitation
9c349dbc7Sjsg  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10c349dbc7Sjsg  * and/or sell copies of the Software, and to permit persons to whom the
11c349dbc7Sjsg  * Software is furnished to do so, subject to the following conditions:
12c349dbc7Sjsg  *
13c349dbc7Sjsg  * The above copyright notice and this permission notice (including the next
14c349dbc7Sjsg  * paragraph) shall be included in all copies or substantial portions of the
15c349dbc7Sjsg  * Software.
16c349dbc7Sjsg  *
17c349dbc7Sjsg  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18c349dbc7Sjsg  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19c349dbc7Sjsg  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20c349dbc7Sjsg  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21c349dbc7Sjsg  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22c349dbc7Sjsg  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23c349dbc7Sjsg  * OTHER DEALINGS IN THE SOFTWARE.
24c349dbc7Sjsg  */
25c349dbc7Sjsg 
26c349dbc7Sjsg #include <linux/debugfs.h>
27c349dbc7Sjsg #include <linux/export.h>
28c349dbc7Sjsg #include <linux/seq_file.h>
29c349dbc7Sjsg #include <linux/slab.h>
30c349dbc7Sjsg #include <linux/uaccess.h>
31c349dbc7Sjsg 
32c349dbc7Sjsg #include <drm/drm_atomic.h>
33c349dbc7Sjsg #include <drm/drm_auth.h>
34*f005ef32Sjsg #include <drm/drm_bridge.h>
35c349dbc7Sjsg #include <drm/drm_client.h>
36c349dbc7Sjsg #include <drm/drm_debugfs.h>
37c349dbc7Sjsg #include <drm/drm_device.h>
38c349dbc7Sjsg #include <drm/drm_drv.h>
39c349dbc7Sjsg #include <drm/drm_edid.h>
40c349dbc7Sjsg #include <drm/drm_file.h>
41c349dbc7Sjsg #include <drm/drm_gem.h>
42*f005ef32Sjsg #include <drm/drm_managed.h>
43*f005ef32Sjsg #include <drm/drm_gpuva_mgr.h>
44c349dbc7Sjsg 
45c349dbc7Sjsg #include "drm_crtc_internal.h"
46c349dbc7Sjsg #include "drm_internal.h"
47c349dbc7Sjsg 
48c349dbc7Sjsg #if defined(CONFIG_DEBUG_FS)
49c349dbc7Sjsg 
50c349dbc7Sjsg /***************************************************
51c349dbc7Sjsg  * Initialization, etc.
52c349dbc7Sjsg  **************************************************/
53c349dbc7Sjsg 
drm_name_info(struct seq_file * m,void * data)54c349dbc7Sjsg static int drm_name_info(struct seq_file *m, void *data)
55c349dbc7Sjsg {
56*f005ef32Sjsg 	struct drm_debugfs_entry *entry = m->private;
57*f005ef32Sjsg 	struct drm_device *dev = entry->dev;
58c349dbc7Sjsg 	struct drm_master *master;
59c349dbc7Sjsg 
60c349dbc7Sjsg 	mutex_lock(&dev->master_mutex);
61c349dbc7Sjsg 	master = dev->master;
62c349dbc7Sjsg 	seq_printf(m, "%s", dev->driver->name);
63c349dbc7Sjsg 	if (dev->dev)
64c349dbc7Sjsg 		seq_printf(m, " dev=%s", dev_name(dev->dev));
65c349dbc7Sjsg 	if (master && master->unique)
66c349dbc7Sjsg 		seq_printf(m, " master=%s", master->unique);
67c349dbc7Sjsg 	if (dev->unique)
68c349dbc7Sjsg 		seq_printf(m, " unique=%s", dev->unique);
69c349dbc7Sjsg 	seq_printf(m, "\n");
70c349dbc7Sjsg 	mutex_unlock(&dev->master_mutex);
71c349dbc7Sjsg 
72c349dbc7Sjsg 	return 0;
73c349dbc7Sjsg }
74c349dbc7Sjsg 
drm_clients_info(struct seq_file * m,void * data)75c349dbc7Sjsg static int drm_clients_info(struct seq_file *m, void *data)
76c349dbc7Sjsg {
77*f005ef32Sjsg 	struct drm_debugfs_entry *entry = m->private;
78*f005ef32Sjsg 	struct drm_device *dev = entry->dev;
79c349dbc7Sjsg 	struct drm_file *priv;
80c349dbc7Sjsg 	kuid_t uid;
81c349dbc7Sjsg 
82c349dbc7Sjsg 	seq_printf(m,
83c349dbc7Sjsg 		   "%20s %5s %3s master a %5s %10s\n",
84c349dbc7Sjsg 		   "command",
85*f005ef32Sjsg 		   "tgid",
86c349dbc7Sjsg 		   "dev",
87c349dbc7Sjsg 		   "uid",
88c349dbc7Sjsg 		   "magic");
89c349dbc7Sjsg 
90c349dbc7Sjsg 	/* dev->filelist is sorted youngest first, but we want to present
91c349dbc7Sjsg 	 * oldest first (i.e. kernel, servers, clients), so walk backwardss.
92c349dbc7Sjsg 	 */
93c349dbc7Sjsg 	mutex_lock(&dev->filelist_mutex);
94c349dbc7Sjsg 	list_for_each_entry_reverse(priv, &dev->filelist, lhead) {
9540694f2cSjsg 		bool is_current_master = drm_is_current_master(priv);
96*f005ef32Sjsg 		struct task_struct *task;
97*f005ef32Sjsg 		struct pid *pid;
98c349dbc7Sjsg 
99*f005ef32Sjsg 		rcu_read_lock(); /* Locks priv->pid and pid_task()->comm! */
100*f005ef32Sjsg 		pid = rcu_dereference(priv->pid);
101*f005ef32Sjsg 		task = pid_task(pid, PIDTYPE_TGID);
102c349dbc7Sjsg 		uid = task ? __task_cred(task)->euid : GLOBAL_ROOT_UID;
103c349dbc7Sjsg 		seq_printf(m, "%20s %5d %3d   %c    %c %5d %10u\n",
104c349dbc7Sjsg 			   task ? task->comm : "<unknown>",
105*f005ef32Sjsg 			   pid_vnr(pid),
106c349dbc7Sjsg 			   priv->minor->index,
10740694f2cSjsg 			   is_current_master ? 'y' : 'n',
108c349dbc7Sjsg 			   priv->authenticated ? 'y' : 'n',
109c349dbc7Sjsg 			   from_kuid_munged(seq_user_ns(m), uid),
110c349dbc7Sjsg 			   priv->magic);
111c349dbc7Sjsg 		rcu_read_unlock();
112c349dbc7Sjsg 	}
113c349dbc7Sjsg 	mutex_unlock(&dev->filelist_mutex);
114c349dbc7Sjsg 	return 0;
115c349dbc7Sjsg }
116c349dbc7Sjsg 
drm_gem_one_name_info(int id,void * ptr,void * data)117c349dbc7Sjsg static int drm_gem_one_name_info(int id, void *ptr, void *data)
118c349dbc7Sjsg {
119c349dbc7Sjsg 	struct drm_gem_object *obj = ptr;
120c349dbc7Sjsg 	struct seq_file *m = data;
121c349dbc7Sjsg 
122c349dbc7Sjsg 	seq_printf(m, "%6d %8zd %7d %8d\n",
123c349dbc7Sjsg 		   obj->name, obj->size,
124c349dbc7Sjsg 		   obj->handle_count,
125c349dbc7Sjsg 		   kref_read(&obj->refcount));
126c349dbc7Sjsg 	return 0;
127c349dbc7Sjsg }
128c349dbc7Sjsg 
drm_gem_name_info(struct seq_file * m,void * data)129c349dbc7Sjsg static int drm_gem_name_info(struct seq_file *m, void *data)
130c349dbc7Sjsg {
131*f005ef32Sjsg 	struct drm_debugfs_entry *entry = m->private;
132*f005ef32Sjsg 	struct drm_device *dev = entry->dev;
133c349dbc7Sjsg 
134c349dbc7Sjsg 	seq_printf(m, "  name     size handles refcount\n");
135c349dbc7Sjsg 
136c349dbc7Sjsg 	mutex_lock(&dev->object_name_lock);
137c349dbc7Sjsg 	idr_for_each(&dev->object_name_idr, drm_gem_one_name_info, m);
138c349dbc7Sjsg 	mutex_unlock(&dev->object_name_lock);
139c349dbc7Sjsg 
140c349dbc7Sjsg 	return 0;
141c349dbc7Sjsg }
142c349dbc7Sjsg 
143*f005ef32Sjsg static const struct drm_debugfs_info drm_debugfs_list[] = {
144c349dbc7Sjsg 	{"name", drm_name_info, 0},
145c349dbc7Sjsg 	{"clients", drm_clients_info, 0},
146c349dbc7Sjsg 	{"gem_names", drm_gem_name_info, DRIVER_GEM},
147c349dbc7Sjsg };
148c349dbc7Sjsg #define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list)
149c349dbc7Sjsg 
150c349dbc7Sjsg 
drm_debugfs_open(struct inode * inode,struct file * file)151c349dbc7Sjsg static int drm_debugfs_open(struct inode *inode, struct file *file)
152c349dbc7Sjsg {
153c349dbc7Sjsg 	struct drm_info_node *node = inode->i_private;
154c349dbc7Sjsg 
155c349dbc7Sjsg 	return single_open(file, node->info_ent->show, node);
156c349dbc7Sjsg }
157c349dbc7Sjsg 
drm_debugfs_entry_open(struct inode * inode,struct file * file)158*f005ef32Sjsg static int drm_debugfs_entry_open(struct inode *inode, struct file *file)
159*f005ef32Sjsg {
160*f005ef32Sjsg 	struct drm_debugfs_entry *entry = inode->i_private;
161*f005ef32Sjsg 	struct drm_debugfs_info *node = &entry->file;
162*f005ef32Sjsg 
163*f005ef32Sjsg 	return single_open(file, node->show, entry);
164*f005ef32Sjsg }
165*f005ef32Sjsg 
166*f005ef32Sjsg static const struct file_operations drm_debugfs_entry_fops = {
167*f005ef32Sjsg 	.owner = THIS_MODULE,
168*f005ef32Sjsg 	.open = drm_debugfs_entry_open,
169*f005ef32Sjsg 	.read = seq_read,
170*f005ef32Sjsg 	.llseek = seq_lseek,
171*f005ef32Sjsg 	.release = single_release,
172*f005ef32Sjsg };
173c349dbc7Sjsg 
174c349dbc7Sjsg static const struct file_operations drm_debugfs_fops = {
175c349dbc7Sjsg 	.owner = THIS_MODULE,
176c349dbc7Sjsg 	.open = drm_debugfs_open,
177c349dbc7Sjsg 	.read = seq_read,
178c349dbc7Sjsg 	.llseek = seq_lseek,
179c349dbc7Sjsg 	.release = single_release,
180c349dbc7Sjsg };
181c349dbc7Sjsg 
182*f005ef32Sjsg /**
183*f005ef32Sjsg  * drm_debugfs_gpuva_info - dump the given DRM GPU VA space
184*f005ef32Sjsg  * @m: pointer to the &seq_file to write
185*f005ef32Sjsg  * @mgr: the &drm_gpuva_manager representing the GPU VA space
186*f005ef32Sjsg  *
187*f005ef32Sjsg  * Dumps the GPU VA mappings of a given DRM GPU VA manager.
188*f005ef32Sjsg  *
189*f005ef32Sjsg  * For each DRM GPU VA space drivers should call this function from their
190*f005ef32Sjsg  * &drm_info_list's show callback.
191*f005ef32Sjsg  *
192*f005ef32Sjsg  * Returns: 0 on success, -ENODEV if the &mgr is not initialized
193*f005ef32Sjsg  */
drm_debugfs_gpuva_info(struct seq_file * m,struct drm_gpuva_manager * mgr)194*f005ef32Sjsg int drm_debugfs_gpuva_info(struct seq_file *m,
195*f005ef32Sjsg 			   struct drm_gpuva_manager *mgr)
196*f005ef32Sjsg {
197*f005ef32Sjsg 	struct drm_gpuva *va, *kva = &mgr->kernel_alloc_node;
198*f005ef32Sjsg 
199*f005ef32Sjsg 	if (!mgr->name)
200*f005ef32Sjsg 		return -ENODEV;
201*f005ef32Sjsg 
202*f005ef32Sjsg 	seq_printf(m, "DRM GPU VA space (%s) [0x%016llx;0x%016llx]\n",
203*f005ef32Sjsg 		   mgr->name, mgr->mm_start, mgr->mm_start + mgr->mm_range);
204*f005ef32Sjsg 	seq_printf(m, "Kernel reserved node [0x%016llx;0x%016llx]\n",
205*f005ef32Sjsg 		   kva->va.addr, kva->va.addr + kva->va.range);
206*f005ef32Sjsg 	seq_puts(m, "\n");
207*f005ef32Sjsg 	seq_puts(m, " VAs | start              | range              | end                | object             | object offset\n");
208*f005ef32Sjsg 	seq_puts(m, "-------------------------------------------------------------------------------------------------------------\n");
209*f005ef32Sjsg 	drm_gpuva_for_each_va(va, mgr) {
210*f005ef32Sjsg 		if (unlikely(va == kva))
211*f005ef32Sjsg 			continue;
212*f005ef32Sjsg 
213*f005ef32Sjsg 		seq_printf(m, "     | 0x%016llx | 0x%016llx | 0x%016llx | 0x%016llx | 0x%016llx\n",
214*f005ef32Sjsg 			   va->va.addr, va->va.range, va->va.addr + va->va.range,
215*f005ef32Sjsg 			   (u64)(uintptr_t)va->gem.obj, va->gem.offset);
216*f005ef32Sjsg 	}
217*f005ef32Sjsg 
218*f005ef32Sjsg 	return 0;
219*f005ef32Sjsg }
220*f005ef32Sjsg EXPORT_SYMBOL(drm_debugfs_gpuva_info);
221c349dbc7Sjsg 
222c349dbc7Sjsg /**
223c349dbc7Sjsg  * drm_debugfs_create_files - Initialize a given set of debugfs files for DRM
224c349dbc7Sjsg  * 			minor
225c349dbc7Sjsg  * @files: The array of files to create
226c349dbc7Sjsg  * @count: The number of files given
227c349dbc7Sjsg  * @root: DRI debugfs dir entry.
228c349dbc7Sjsg  * @minor: device minor number
229c349dbc7Sjsg  *
230c349dbc7Sjsg  * Create a given set of debugfs files represented by an array of
231c349dbc7Sjsg  * &struct drm_info_list in the given root directory. These files will be removed
232c349dbc7Sjsg  * automatically on drm_debugfs_cleanup().
233c349dbc7Sjsg  */
drm_debugfs_create_files(const struct drm_info_list * files,int count,struct dentry * root,struct drm_minor * minor)234ad8b1aafSjsg void drm_debugfs_create_files(const struct drm_info_list *files, int count,
235c349dbc7Sjsg 			      struct dentry *root, struct drm_minor *minor)
236c349dbc7Sjsg {
237c349dbc7Sjsg 	struct drm_device *dev = minor->dev;
238c349dbc7Sjsg 	struct drm_info_node *tmp;
239c349dbc7Sjsg 	int i;
240c349dbc7Sjsg 
241c349dbc7Sjsg 	for (i = 0; i < count; i++) {
242c349dbc7Sjsg 		u32 features = files[i].driver_features;
243c349dbc7Sjsg 
244c349dbc7Sjsg 		if (features && !drm_core_check_all_features(dev, features))
245c349dbc7Sjsg 			continue;
246c349dbc7Sjsg 
247c349dbc7Sjsg 		tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
248c349dbc7Sjsg 		if (tmp == NULL)
249c349dbc7Sjsg 			continue;
250c349dbc7Sjsg 
251c349dbc7Sjsg 		tmp->minor = minor;
252c349dbc7Sjsg 		tmp->dent = debugfs_create_file(files[i].name,
253*f005ef32Sjsg 						0444, root, tmp,
254c349dbc7Sjsg 						&drm_debugfs_fops);
255c349dbc7Sjsg 		tmp->info_ent = &files[i];
256c349dbc7Sjsg 
257c349dbc7Sjsg 		mutex_lock(&minor->debugfs_lock);
258c349dbc7Sjsg 		list_add(&tmp->list, &minor->debugfs_list);
259c349dbc7Sjsg 		mutex_unlock(&minor->debugfs_lock);
260c349dbc7Sjsg 	}
261c349dbc7Sjsg }
262c349dbc7Sjsg EXPORT_SYMBOL(drm_debugfs_create_files);
263c349dbc7Sjsg 
drm_debugfs_init(struct drm_minor * minor,int minor_id,struct dentry * root)264c349dbc7Sjsg int drm_debugfs_init(struct drm_minor *minor, int minor_id,
265c349dbc7Sjsg 		     struct dentry *root)
266c349dbc7Sjsg {
267c349dbc7Sjsg 	struct drm_device *dev = minor->dev;
268*f005ef32Sjsg 	struct drm_debugfs_entry *entry, *tmp;
269c349dbc7Sjsg 	char name[64];
270c349dbc7Sjsg 
271c349dbc7Sjsg 	INIT_LIST_HEAD(&minor->debugfs_list);
272c349dbc7Sjsg 	rw_init(&minor->debugfs_lock, "dbgfs");
273c349dbc7Sjsg 	sprintf(name, "%d", minor_id);
274c349dbc7Sjsg 	minor->debugfs_root = debugfs_create_dir(name, root);
275c349dbc7Sjsg 
276*f005ef32Sjsg 	drm_debugfs_add_files(minor->dev, drm_debugfs_list, DRM_DEBUGFS_ENTRIES);
277c349dbc7Sjsg 
278c349dbc7Sjsg 	if (drm_drv_uses_atomic_modeset(dev)) {
279ad8b1aafSjsg 		drm_atomic_debugfs_init(minor);
280*f005ef32Sjsg 		drm_bridge_debugfs_init(minor);
281c349dbc7Sjsg 	}
282c349dbc7Sjsg 
283c349dbc7Sjsg 	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
284ad8b1aafSjsg 		drm_framebuffer_debugfs_init(minor);
285ad8b1aafSjsg 
286ad8b1aafSjsg 		drm_client_debugfs_init(minor);
287c349dbc7Sjsg 	}
288c349dbc7Sjsg 
289ad8b1aafSjsg 	if (dev->driver->debugfs_init)
290ad8b1aafSjsg 		dev->driver->debugfs_init(minor);
291c349dbc7Sjsg 
292*f005ef32Sjsg 	list_for_each_entry_safe(entry, tmp, &dev->debugfs_list, list) {
293*f005ef32Sjsg 		debugfs_create_file(entry->file.name, 0444,
294*f005ef32Sjsg 				    minor->debugfs_root, entry, &drm_debugfs_entry_fops);
295*f005ef32Sjsg 		list_del(&entry->list);
296*f005ef32Sjsg 	}
297*f005ef32Sjsg 
298c349dbc7Sjsg 	return 0;
299c349dbc7Sjsg }
300c349dbc7Sjsg 
drm_debugfs_late_register(struct drm_device * dev)301*f005ef32Sjsg void drm_debugfs_late_register(struct drm_device *dev)
302*f005ef32Sjsg {
303*f005ef32Sjsg 	struct drm_minor *minor = dev->primary;
304*f005ef32Sjsg 	struct drm_debugfs_entry *entry, *tmp;
305*f005ef32Sjsg 
306*f005ef32Sjsg 	if (!minor)
307*f005ef32Sjsg 		return;
308*f005ef32Sjsg 
309*f005ef32Sjsg 	list_for_each_entry_safe(entry, tmp, &dev->debugfs_list, list) {
310*f005ef32Sjsg 		debugfs_create_file(entry->file.name, 0444,
311*f005ef32Sjsg 				    minor->debugfs_root, entry, &drm_debugfs_entry_fops);
312*f005ef32Sjsg 		list_del(&entry->list);
313*f005ef32Sjsg 	}
314*f005ef32Sjsg }
315c349dbc7Sjsg 
drm_debugfs_remove_files(const struct drm_info_list * files,int count,struct drm_minor * minor)316c349dbc7Sjsg int drm_debugfs_remove_files(const struct drm_info_list *files, int count,
317c349dbc7Sjsg 			     struct drm_minor *minor)
318c349dbc7Sjsg {
319c349dbc7Sjsg 	struct list_head *pos, *q;
320c349dbc7Sjsg 	struct drm_info_node *tmp;
321c349dbc7Sjsg 	int i;
322c349dbc7Sjsg 
323c349dbc7Sjsg 	mutex_lock(&minor->debugfs_lock);
324c349dbc7Sjsg 	for (i = 0; i < count; i++) {
325c349dbc7Sjsg 		list_for_each_safe(pos, q, &minor->debugfs_list) {
326c349dbc7Sjsg 			tmp = list_entry(pos, struct drm_info_node, list);
327c349dbc7Sjsg 			if (tmp->info_ent == &files[i]) {
328c349dbc7Sjsg 				debugfs_remove(tmp->dent);
329c349dbc7Sjsg 				list_del(pos);
330c349dbc7Sjsg 				kfree(tmp);
331c349dbc7Sjsg 			}
332c349dbc7Sjsg 		}
333c349dbc7Sjsg 	}
334c349dbc7Sjsg 	mutex_unlock(&minor->debugfs_lock);
335c349dbc7Sjsg 	return 0;
336c349dbc7Sjsg }
337c349dbc7Sjsg EXPORT_SYMBOL(drm_debugfs_remove_files);
338c349dbc7Sjsg 
drm_debugfs_remove_all_files(struct drm_minor * minor)339c349dbc7Sjsg static void drm_debugfs_remove_all_files(struct drm_minor *minor)
340c349dbc7Sjsg {
341c349dbc7Sjsg 	struct drm_info_node *node, *tmp;
342c349dbc7Sjsg 
343c349dbc7Sjsg 	mutex_lock(&minor->debugfs_lock);
344c349dbc7Sjsg 	list_for_each_entry_safe(node, tmp, &minor->debugfs_list, list) {
345c349dbc7Sjsg 		debugfs_remove(node->dent);
346c349dbc7Sjsg 		list_del(&node->list);
347c349dbc7Sjsg 		kfree(node);
348c349dbc7Sjsg 	}
349c349dbc7Sjsg 	mutex_unlock(&minor->debugfs_lock);
350c349dbc7Sjsg }
351c349dbc7Sjsg 
drm_debugfs_cleanup(struct drm_minor * minor)352c349dbc7Sjsg void drm_debugfs_cleanup(struct drm_minor *minor)
353c349dbc7Sjsg {
354c349dbc7Sjsg 	if (!minor->debugfs_root)
355c349dbc7Sjsg 		return;
356c349dbc7Sjsg 
357c349dbc7Sjsg 	drm_debugfs_remove_all_files(minor);
358c349dbc7Sjsg 
359c349dbc7Sjsg 	debugfs_remove_recursive(minor->debugfs_root);
360c349dbc7Sjsg 	minor->debugfs_root = NULL;
361c349dbc7Sjsg }
362c349dbc7Sjsg 
363*f005ef32Sjsg /**
364*f005ef32Sjsg  * drm_debugfs_add_file - Add a given file to the DRM device debugfs file list
365*f005ef32Sjsg  * @dev: drm device for the ioctl
366*f005ef32Sjsg  * @name: debugfs file name
367*f005ef32Sjsg  * @show: show callback
368*f005ef32Sjsg  * @data: driver-private data, should not be device-specific
369*f005ef32Sjsg  *
370*f005ef32Sjsg  * Add a given file entry to the DRM device debugfs file list to be created on
371*f005ef32Sjsg  * drm_debugfs_init.
372*f005ef32Sjsg  */
drm_debugfs_add_file(struct drm_device * dev,const char * name,int (* show)(struct seq_file *,void *),void * data)373*f005ef32Sjsg void drm_debugfs_add_file(struct drm_device *dev, const char *name,
374*f005ef32Sjsg 			  int (*show)(struct seq_file*, void*), void *data)
375*f005ef32Sjsg {
376*f005ef32Sjsg 	struct drm_debugfs_entry *entry = drmm_kzalloc(dev, sizeof(*entry), GFP_KERNEL);
377*f005ef32Sjsg 
378*f005ef32Sjsg 	if (!entry)
379*f005ef32Sjsg 		return;
380*f005ef32Sjsg 
381*f005ef32Sjsg 	entry->file.name = name;
382*f005ef32Sjsg 	entry->file.show = show;
383*f005ef32Sjsg 	entry->file.data = data;
384*f005ef32Sjsg 	entry->dev = dev;
385*f005ef32Sjsg 
386*f005ef32Sjsg 	mutex_lock(&dev->debugfs_mutex);
387*f005ef32Sjsg 	list_add(&entry->list, &dev->debugfs_list);
388*f005ef32Sjsg 	mutex_unlock(&dev->debugfs_mutex);
389*f005ef32Sjsg }
390*f005ef32Sjsg EXPORT_SYMBOL(drm_debugfs_add_file);
391*f005ef32Sjsg 
392*f005ef32Sjsg /**
393*f005ef32Sjsg  * drm_debugfs_add_files - Add an array of files to the DRM device debugfs file list
394*f005ef32Sjsg  * @dev: drm device for the ioctl
395*f005ef32Sjsg  * @files: The array of files to create
396*f005ef32Sjsg  * @count: The number of files given
397*f005ef32Sjsg  *
398*f005ef32Sjsg  * Add a given set of debugfs files represented by an array of
399*f005ef32Sjsg  * &struct drm_debugfs_info in the DRM device debugfs file list.
400*f005ef32Sjsg  */
drm_debugfs_add_files(struct drm_device * dev,const struct drm_debugfs_info * files,int count)401*f005ef32Sjsg void drm_debugfs_add_files(struct drm_device *dev, const struct drm_debugfs_info *files, int count)
402*f005ef32Sjsg {
403*f005ef32Sjsg 	int i;
404*f005ef32Sjsg 
405*f005ef32Sjsg 	for (i = 0; i < count; i++)
406*f005ef32Sjsg 		drm_debugfs_add_file(dev, files[i].name, files[i].show, files[i].data);
407*f005ef32Sjsg }
408*f005ef32Sjsg EXPORT_SYMBOL(drm_debugfs_add_files);
409*f005ef32Sjsg 
connector_show(struct seq_file * m,void * data)410c349dbc7Sjsg static int connector_show(struct seq_file *m, void *data)
411c349dbc7Sjsg {
412c349dbc7Sjsg 	struct drm_connector *connector = m->private;
413c349dbc7Sjsg 
414c349dbc7Sjsg 	seq_printf(m, "%s\n", drm_get_connector_force_name(connector->force));
415c349dbc7Sjsg 
416c349dbc7Sjsg 	return 0;
417c349dbc7Sjsg }
418c349dbc7Sjsg 
connector_open(struct inode * inode,struct file * file)419c349dbc7Sjsg static int connector_open(struct inode *inode, struct file *file)
420c349dbc7Sjsg {
421c349dbc7Sjsg 	struct drm_connector *dev = inode->i_private;
422c349dbc7Sjsg 
423c349dbc7Sjsg 	return single_open(file, connector_show, dev);
424c349dbc7Sjsg }
425c349dbc7Sjsg 
connector_write(struct file * file,const char __user * ubuf,size_t len,loff_t * offp)426c349dbc7Sjsg static ssize_t connector_write(struct file *file, const char __user *ubuf,
427c349dbc7Sjsg 			       size_t len, loff_t *offp)
428c349dbc7Sjsg {
429c349dbc7Sjsg 	struct seq_file *m = file->private_data;
430c349dbc7Sjsg 	struct drm_connector *connector = m->private;
431c349dbc7Sjsg 	char buf[12];
432c349dbc7Sjsg 
433c349dbc7Sjsg 	if (len > sizeof(buf) - 1)
434c349dbc7Sjsg 		return -EINVAL;
435c349dbc7Sjsg 
436c349dbc7Sjsg 	if (copy_from_user(buf, ubuf, len))
437c349dbc7Sjsg 		return -EFAULT;
438c349dbc7Sjsg 
439c349dbc7Sjsg 	buf[len] = '\0';
440c349dbc7Sjsg 
441113d9775Sjsg 	if (sysfs_streq(buf, "on"))
442c349dbc7Sjsg 		connector->force = DRM_FORCE_ON;
443113d9775Sjsg 	else if (sysfs_streq(buf, "digital"))
444c349dbc7Sjsg 		connector->force = DRM_FORCE_ON_DIGITAL;
445113d9775Sjsg 	else if (sysfs_streq(buf, "off"))
446c349dbc7Sjsg 		connector->force = DRM_FORCE_OFF;
447113d9775Sjsg 	else if (sysfs_streq(buf, "unspecified"))
448c349dbc7Sjsg 		connector->force = DRM_FORCE_UNSPECIFIED;
449c349dbc7Sjsg 	else
450c349dbc7Sjsg 		return -EINVAL;
451c349dbc7Sjsg 
452c349dbc7Sjsg 	return len;
453c349dbc7Sjsg }
454c349dbc7Sjsg 
edid_show(struct seq_file * m,void * data)455c349dbc7Sjsg static int edid_show(struct seq_file *m, void *data)
456c349dbc7Sjsg {
457*f005ef32Sjsg 	return drm_edid_override_show(m->private, m);
458c349dbc7Sjsg }
459c349dbc7Sjsg 
edid_open(struct inode * inode,struct file * file)460c349dbc7Sjsg static int edid_open(struct inode *inode, struct file *file)
461c349dbc7Sjsg {
462c349dbc7Sjsg 	struct drm_connector *dev = inode->i_private;
463c349dbc7Sjsg 
464c349dbc7Sjsg 	return single_open(file, edid_show, dev);
465c349dbc7Sjsg }
466c349dbc7Sjsg 
edid_write(struct file * file,const char __user * ubuf,size_t len,loff_t * offp)467c349dbc7Sjsg static ssize_t edid_write(struct file *file, const char __user *ubuf,
468c349dbc7Sjsg 			  size_t len, loff_t *offp)
469c349dbc7Sjsg {
470c349dbc7Sjsg 	struct seq_file *m = file->private_data;
471c349dbc7Sjsg 	struct drm_connector *connector = m->private;
472c349dbc7Sjsg 	char *buf;
473c349dbc7Sjsg 	int ret;
474c349dbc7Sjsg 
475c349dbc7Sjsg 	buf = memdup_user(ubuf, len);
476c349dbc7Sjsg 	if (IS_ERR(buf))
477c349dbc7Sjsg 		return PTR_ERR(buf);
478c349dbc7Sjsg 
4791bb76ff1Sjsg 	if (len == 5 && !strncmp(buf, "reset", 5))
4801bb76ff1Sjsg 		ret = drm_edid_override_reset(connector);
4811bb76ff1Sjsg 	else
4821bb76ff1Sjsg 		ret = drm_edid_override_set(connector, buf, len);
483c349dbc7Sjsg 
484c349dbc7Sjsg 	kfree(buf);
485c349dbc7Sjsg 
4861bb76ff1Sjsg 	return ret ? ret : len;
487c349dbc7Sjsg }
488c349dbc7Sjsg 
489ad8b1aafSjsg /*
490ad8b1aafSjsg  * Returns the min and max vrr vfreq through the connector's debugfs file.
491ad8b1aafSjsg  * Example usage: cat /sys/kernel/debug/dri/0/DP-1/vrr_range
492ad8b1aafSjsg  */
vrr_range_show(struct seq_file * m,void * data)493ad8b1aafSjsg static int vrr_range_show(struct seq_file *m, void *data)
494ad8b1aafSjsg {
495ad8b1aafSjsg 	struct drm_connector *connector = m->private;
496ad8b1aafSjsg 
497ad8b1aafSjsg 	if (connector->status != connector_status_connected)
498ad8b1aafSjsg 		return -ENODEV;
499ad8b1aafSjsg 
5001bb76ff1Sjsg 	seq_printf(m, "Min: %u\n", connector->display_info.monitor_range.min_vfreq);
5011bb76ff1Sjsg 	seq_printf(m, "Max: %u\n", connector->display_info.monitor_range.max_vfreq);
502ad8b1aafSjsg 
503ad8b1aafSjsg 	return 0;
504ad8b1aafSjsg }
505ad8b1aafSjsg DEFINE_SHOW_ATTRIBUTE(vrr_range);
506ad8b1aafSjsg 
5071bb76ff1Sjsg /*
5081bb76ff1Sjsg  * Returns Connector's max supported bpc through debugfs file.
5091bb76ff1Sjsg  * Example usage: cat /sys/kernel/debug/dri/0/DP-1/output_bpc
5101bb76ff1Sjsg  */
output_bpc_show(struct seq_file * m,void * data)5111bb76ff1Sjsg static int output_bpc_show(struct seq_file *m, void *data)
5121bb76ff1Sjsg {
5131bb76ff1Sjsg 	struct drm_connector *connector = m->private;
5141bb76ff1Sjsg 
5151bb76ff1Sjsg 	if (connector->status != connector_status_connected)
5161bb76ff1Sjsg 		return -ENODEV;
5171bb76ff1Sjsg 
5181bb76ff1Sjsg 	seq_printf(m, "Maximum: %u\n", connector->display_info.bpc);
5191bb76ff1Sjsg 
5201bb76ff1Sjsg 	return 0;
5211bb76ff1Sjsg }
5221bb76ff1Sjsg DEFINE_SHOW_ATTRIBUTE(output_bpc);
5231bb76ff1Sjsg 
524c349dbc7Sjsg static const struct file_operations drm_edid_fops = {
525c349dbc7Sjsg 	.owner = THIS_MODULE,
526c349dbc7Sjsg 	.open = edid_open,
527c349dbc7Sjsg 	.read = seq_read,
528c349dbc7Sjsg 	.llseek = seq_lseek,
529c349dbc7Sjsg 	.release = single_release,
530c349dbc7Sjsg 	.write = edid_write
531c349dbc7Sjsg };
532c349dbc7Sjsg 
533c349dbc7Sjsg 
534c349dbc7Sjsg static const struct file_operations drm_connector_fops = {
535c349dbc7Sjsg 	.owner = THIS_MODULE,
536c349dbc7Sjsg 	.open = connector_open,
537c349dbc7Sjsg 	.read = seq_read,
538c349dbc7Sjsg 	.llseek = seq_lseek,
539c349dbc7Sjsg 	.release = single_release,
540c349dbc7Sjsg 	.write = connector_write
541c349dbc7Sjsg };
542c349dbc7Sjsg 
drm_debugfs_connector_add(struct drm_connector * connector)543c349dbc7Sjsg void drm_debugfs_connector_add(struct drm_connector *connector)
544c349dbc7Sjsg {
545c349dbc7Sjsg 	struct drm_minor *minor = connector->dev->primary;
546c349dbc7Sjsg 	struct dentry *root;
547c349dbc7Sjsg 
548c349dbc7Sjsg 	if (!minor->debugfs_root)
549c349dbc7Sjsg 		return;
550c349dbc7Sjsg 
551c349dbc7Sjsg 	root = debugfs_create_dir(connector->name, minor->debugfs_root);
552c349dbc7Sjsg 	connector->debugfs_entry = root;
553c349dbc7Sjsg 
554c349dbc7Sjsg 	/* force */
555*f005ef32Sjsg 	debugfs_create_file("force", 0644, root, connector,
556c349dbc7Sjsg 			    &drm_connector_fops);
557c349dbc7Sjsg 
558c349dbc7Sjsg 	/* edid */
559*f005ef32Sjsg 	debugfs_create_file("edid_override", 0644, root, connector,
560c349dbc7Sjsg 			    &drm_edid_fops);
561ad8b1aafSjsg 
562ad8b1aafSjsg 	/* vrr range */
563*f005ef32Sjsg 	debugfs_create_file("vrr_range", 0444, root, connector,
564ad8b1aafSjsg 			    &vrr_range_fops);
5651bb76ff1Sjsg 
5661bb76ff1Sjsg 	/* max bpc */
5671bb76ff1Sjsg 	debugfs_create_file("output_bpc", 0444, root, connector,
5681bb76ff1Sjsg 			    &output_bpc_fops);
5691bb76ff1Sjsg 
5701bb76ff1Sjsg 	if (connector->funcs->debugfs_init)
5711bb76ff1Sjsg 		connector->funcs->debugfs_init(connector, root);
572c349dbc7Sjsg }
573c349dbc7Sjsg 
drm_debugfs_connector_remove(struct drm_connector * connector)574c349dbc7Sjsg void drm_debugfs_connector_remove(struct drm_connector *connector)
575c349dbc7Sjsg {
576c349dbc7Sjsg 	if (!connector->debugfs_entry)
577c349dbc7Sjsg 		return;
578c349dbc7Sjsg 
579c349dbc7Sjsg 	debugfs_remove_recursive(connector->debugfs_entry);
580c349dbc7Sjsg 
581c349dbc7Sjsg 	connector->debugfs_entry = NULL;
582c349dbc7Sjsg }
583c349dbc7Sjsg 
drm_debugfs_crtc_add(struct drm_crtc * crtc)584c349dbc7Sjsg void drm_debugfs_crtc_add(struct drm_crtc *crtc)
585c349dbc7Sjsg {
586c349dbc7Sjsg 	struct drm_minor *minor = crtc->dev->primary;
587c349dbc7Sjsg 	struct dentry *root;
588c349dbc7Sjsg 	char *name;
589c349dbc7Sjsg 
590c349dbc7Sjsg 	name = kasprintf(GFP_KERNEL, "crtc-%d", crtc->index);
591c349dbc7Sjsg 	if (!name)
592c349dbc7Sjsg 		return;
593c349dbc7Sjsg 
594c349dbc7Sjsg 	root = debugfs_create_dir(name, minor->debugfs_root);
595c349dbc7Sjsg 	kfree(name);
596c349dbc7Sjsg 
597c349dbc7Sjsg 	crtc->debugfs_entry = root;
598c349dbc7Sjsg 
599c349dbc7Sjsg 	drm_debugfs_crtc_crc_add(crtc);
600c349dbc7Sjsg }
601c349dbc7Sjsg 
drm_debugfs_crtc_remove(struct drm_crtc * crtc)602c349dbc7Sjsg void drm_debugfs_crtc_remove(struct drm_crtc *crtc)
603c349dbc7Sjsg {
604c349dbc7Sjsg 	debugfs_remove_recursive(crtc->debugfs_entry);
605c349dbc7Sjsg 	crtc->debugfs_entry = NULL;
606c349dbc7Sjsg }
607c349dbc7Sjsg 
608c349dbc7Sjsg #endif /* CONFIG_DEBUG_FS */
609