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