xref: /openbmc/linux/drivers/gpu/drm/drm_debugfs.c (revision 3932b9ca) 
1 /**
2  * \file drm_debugfs.c
3  * debugfs support for DRM
4  *
5  * \author Ben Gamari <bgamari@gmail.com>
6  */
7 
8 /*
9  * Created: Sun Dec 21 13:08:50 2008 by bgamari@gmail.com
10  *
11  * Copyright 2008 Ben Gamari <bgamari@gmail.com>
12  *
13  * Permission is hereby granted, free of charge, to any person obtaining a
14  * copy of this software and associated documentation files (the "Software"),
15  * to deal in the Software without restriction, including without limitation
16  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
17  * and/or sell copies of the Software, and to permit persons to whom the
18  * Software is furnished to do so, subject to the following conditions:
19  *
20  * The above copyright notice and this permission notice (including the next
21  * paragraph) shall be included in all copies or substantial portions of the
22  * Software.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
27  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
28  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
29  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
30  * OTHER DEALINGS IN THE SOFTWARE.
31  */
32 
33 #include <linux/debugfs.h>
34 #include <linux/seq_file.h>
35 #include <linux/slab.h>
36 #include <linux/export.h>
37 #include <drm/drmP.h>
38 #include <drm/drm_edid.h>
39 
40 #if defined(CONFIG_DEBUG_FS)
41 
42 /***************************************************
43  * Initialization, etc.
44  **************************************************/
45 
46 static const struct drm_info_list drm_debugfs_list[] = {
47 	{"name", drm_name_info, 0},
48 	{"vm", drm_vm_info, 0},
49 	{"clients", drm_clients_info, 0},
50 	{"bufs", drm_bufs_info, 0},
51 	{"gem_names", drm_gem_name_info, DRIVER_GEM},
52 #if DRM_DEBUG_CODE
53 	{"vma", drm_vma_info, 0},
54 #endif
55 };
56 #define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list)
57 
58 
59 static int drm_debugfs_open(struct inode *inode, struct file *file)
60 {
61 	struct drm_info_node *node = inode->i_private;
62 
63 	return single_open(file, node->info_ent->show, node);
64 }
65 
66 
67 static const struct file_operations drm_debugfs_fops = {
68 	.owner = THIS_MODULE,
69 	.open = drm_debugfs_open,
70 	.read = seq_read,
71 	.llseek = seq_lseek,
72 	.release = single_release,
73 };
74 
75 
76 /**
77  * Initialize a given set of debugfs files for a device
78  *
79  * \param files The array of files to create
80  * \param count The number of files given
81  * \param root DRI debugfs dir entry.
82  * \param minor device minor number
83  * \return Zero on success, non-zero on failure
84  *
85  * Create a given set of debugfs files represented by an array of
86  * gdm_debugfs_lists in the given root directory.
87  */
88 int drm_debugfs_create_files(const struct drm_info_list *files, int count,
89 			     struct dentry *root, struct drm_minor *minor)
90 {
91 	struct drm_device *dev = minor->dev;
92 	struct dentry *ent;
93 	struct drm_info_node *tmp;
94 	int i, ret;
95 
96 	for (i = 0; i < count; i++) {
97 		u32 features = files[i].driver_features;
98 
99 		if (features != 0 &&
100 		    (dev->driver->driver_features & features) != features)
101 			continue;
102 
103 		tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
104 		if (tmp == NULL) {
105 			ret = -1;
106 			goto fail;
107 		}
108 		ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO,
109 					  root, tmp, &drm_debugfs_fops);
110 		if (!ent) {
111 			DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/%s\n",
112 				  root->d_name.name, files[i].name);
113 			kfree(tmp);
114 			ret = -1;
115 			goto fail;
116 		}
117 
118 		tmp->minor = minor;
119 		tmp->dent = ent;
120 		tmp->info_ent = &files[i];
121 
122 		mutex_lock(&minor->debugfs_lock);
123 		list_add(&tmp->list, &minor->debugfs_list);
124 		mutex_unlock(&minor->debugfs_lock);
125 	}
126 	return 0;
127 
128 fail:
129 	drm_debugfs_remove_files(files, count, minor);
130 	return ret;
131 }
132 EXPORT_SYMBOL(drm_debugfs_create_files);
133 
134 /**
135  * Initialize the DRI debugfs filesystem for a device
136  *
137  * \param dev DRM device
138  * \param minor device minor number
139  * \param root DRI debugfs dir entry.
140  *
141  * Create the DRI debugfs root entry "/sys/kernel/debug/dri", the device debugfs root entry
142  * "/sys/kernel/debug/dri/%minor%/", and each entry in debugfs_list as
143  * "/sys/kernel/debug/dri/%minor%/%name%".
144  */
145 int drm_debugfs_init(struct drm_minor *minor, int minor_id,
146 		     struct dentry *root)
147 {
148 	struct drm_device *dev = minor->dev;
149 	char name[64];
150 	int ret;
151 
152 	INIT_LIST_HEAD(&minor->debugfs_list);
153 	mutex_init(&minor->debugfs_lock);
154 	sprintf(name, "%d", minor_id);
155 	minor->debugfs_root = debugfs_create_dir(name, root);
156 	if (!minor->debugfs_root) {
157 		DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s\n", name);
158 		return -1;
159 	}
160 
161 	ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES,
162 				       minor->debugfs_root, minor);
163 	if (ret) {
164 		debugfs_remove(minor->debugfs_root);
165 		minor->debugfs_root = NULL;
166 		DRM_ERROR("Failed to create core drm debugfs files\n");
167 		return ret;
168 	}
169 
170 	if (dev->driver->debugfs_init) {
171 		ret = dev->driver->debugfs_init(minor);
172 		if (ret) {
173 			DRM_ERROR("DRM: Driver failed to initialize "
174 				  "/sys/kernel/debug/dri.\n");
175 			return ret;
176 		}
177 	}
178 	return 0;
179 }
180 
181 
182 /**
183  * Remove a list of debugfs files
184  *
185  * \param files The list of files
186  * \param count The number of files
187  * \param minor The minor of which we should remove the files
188  * \return always zero.
189  *
190  * Remove all debugfs entries created by debugfs_init().
191  */
192 int drm_debugfs_remove_files(const struct drm_info_list *files, int count,
193 			     struct drm_minor *minor)
194 {
195 	struct list_head *pos, *q;
196 	struct drm_info_node *tmp;
197 	int i;
198 
199 	mutex_lock(&minor->debugfs_lock);
200 	for (i = 0; i < count; i++) {
201 		list_for_each_safe(pos, q, &minor->debugfs_list) {
202 			tmp = list_entry(pos, struct drm_info_node, list);
203 			if (tmp->info_ent == &files[i]) {
204 				debugfs_remove(tmp->dent);
205 				list_del(pos);
206 				kfree(tmp);
207 			}
208 		}
209 	}
210 	mutex_unlock(&minor->debugfs_lock);
211 	return 0;
212 }
213 EXPORT_SYMBOL(drm_debugfs_remove_files);
214 
215 /**
216  * Cleanup the debugfs filesystem resources.
217  *
218  * \param minor device minor number.
219  * \return always zero.
220  *
221  * Remove all debugfs entries created by debugfs_init().
222  */
223 int drm_debugfs_cleanup(struct drm_minor *minor)
224 {
225 	struct drm_device *dev = minor->dev;
226 
227 	if (!minor->debugfs_root)
228 		return 0;
229 
230 	if (dev->driver->debugfs_cleanup)
231 		dev->driver->debugfs_cleanup(minor);
232 
233 	drm_debugfs_remove_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor);
234 
235 	debugfs_remove(minor->debugfs_root);
236 	minor->debugfs_root = NULL;
237 
238 	return 0;
239 }
240 
241 static int connector_show(struct seq_file *m, void *data)
242 {
243 	struct drm_connector *connector = m->private;
244 	const char *status;
245 
246 	switch (connector->force) {
247 	case DRM_FORCE_ON:
248 		status = "on\n";
249 		break;
250 
251 	case DRM_FORCE_ON_DIGITAL:
252 		status = "digital\n";
253 		break;
254 
255 	case DRM_FORCE_OFF:
256 		status = "off\n";
257 		break;
258 
259 	case DRM_FORCE_UNSPECIFIED:
260 		status = "unspecified\n";
261 		break;
262 
263 	default:
264 		return 0;
265 	}
266 
267 	seq_puts(m, status);
268 
269 	return 0;
270 }
271 
272 static int connector_open(struct inode *inode, struct file *file)
273 {
274 	struct drm_connector *dev = inode->i_private;
275 
276 	return single_open(file, connector_show, dev);
277 }
278 
279 static ssize_t connector_write(struct file *file, const char __user *ubuf,
280 			       size_t len, loff_t *offp)
281 {
282 	struct seq_file *m = file->private_data;
283 	struct drm_connector *connector = m->private;
284 	char buf[12];
285 
286 	if (len > sizeof(buf) - 1)
287 		return -EINVAL;
288 
289 	if (copy_from_user(buf, ubuf, len))
290 		return -EFAULT;
291 
292 	buf[len] = '\0';
293 
294 	if (!strcmp(buf, "on"))
295 		connector->force = DRM_FORCE_ON;
296 	else if (!strcmp(buf, "digital"))
297 		connector->force = DRM_FORCE_ON_DIGITAL;
298 	else if (!strcmp(buf, "off"))
299 		connector->force = DRM_FORCE_OFF;
300 	else if (!strcmp(buf, "unspecified"))
301 		connector->force = DRM_FORCE_UNSPECIFIED;
302 	else
303 		return -EINVAL;
304 
305 	return len;
306 }
307 
308 static int edid_show(struct seq_file *m, void *data)
309 {
310 	struct drm_connector *connector = m->private;
311 	struct drm_property_blob *edid = connector->edid_blob_ptr;
312 
313 	if (connector->override_edid && edid)
314 		seq_write(m, edid->data, edid->length);
315 
316 	return 0;
317 }
318 
319 static int edid_open(struct inode *inode, struct file *file)
320 {
321 	struct drm_connector *dev = inode->i_private;
322 
323 	return single_open(file, edid_show, dev);
324 }
325 
326 static ssize_t edid_write(struct file *file, const char __user *ubuf,
327 			  size_t len, loff_t *offp)
328 {
329 	struct seq_file *m = file->private_data;
330 	struct drm_connector *connector = m->private;
331 	char *buf;
332 	struct edid *edid;
333 	int ret;
334 
335 	buf = memdup_user(ubuf, len);
336 	if (IS_ERR(buf))
337 		return PTR_ERR(buf);
338 
339 	edid = (struct edid *) buf;
340 
341 	if (len == 5 && !strncmp(buf, "reset", 5)) {
342 		connector->override_edid = false;
343 		ret = drm_mode_connector_update_edid_property(connector, NULL);
344 	} else if (len < EDID_LENGTH ||
345 		   EDID_LENGTH * (1 + edid->extensions) > len)
346 		ret = -EINVAL;
347 	else {
348 		connector->override_edid = false;
349 		ret = drm_mode_connector_update_edid_property(connector, edid);
350 		if (!ret)
351 			connector->override_edid = true;
352 	}
353 
354 	kfree(buf);
355 
356 	return (ret) ? ret : len;
357 }
358 
359 static const struct file_operations drm_edid_fops = {
360 	.owner = THIS_MODULE,
361 	.open = edid_open,
362 	.read = seq_read,
363 	.llseek = seq_lseek,
364 	.release = single_release,
365 	.write = edid_write
366 };
367 
368 
369 static const struct file_operations drm_connector_fops = {
370 	.owner = THIS_MODULE,
371 	.open = connector_open,
372 	.read = seq_read,
373 	.llseek = seq_lseek,
374 	.release = single_release,
375 	.write = connector_write
376 };
377 
378 int drm_debugfs_connector_add(struct drm_connector *connector)
379 {
380 	struct drm_minor *minor = connector->dev->primary;
381 	struct dentry *root, *ent;
382 
383 	if (!minor->debugfs_root)
384 		return -1;
385 
386 	root = debugfs_create_dir(connector->name, minor->debugfs_root);
387 	if (!root)
388 		return -ENOMEM;
389 
390 	connector->debugfs_entry = root;
391 
392 	/* force */
393 	ent = debugfs_create_file("force", S_IRUGO | S_IWUSR, root, connector,
394 				  &drm_connector_fops);
395 	if (!ent)
396 		goto error;
397 
398 	/* edid */
399 	ent = debugfs_create_file("edid_override", S_IRUGO | S_IWUSR, root,
400 				  connector, &drm_edid_fops);
401 	if (!ent)
402 		goto error;
403 
404 	return 0;
405 
406 error:
407 	debugfs_remove_recursive(connector->debugfs_entry);
408 	connector->debugfs_entry = NULL;
409 	return -ENOMEM;
410 }
411 
412 void drm_debugfs_connector_remove(struct drm_connector *connector)
413 {
414 	if (!connector->debugfs_entry)
415 		return;
416 
417 	debugfs_remove_recursive(connector->debugfs_entry);
418 
419 	connector->debugfs_entry = NULL;
420 }
421 
422 #endif /* CONFIG_DEBUG_FS */
423 
424