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