1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include <linux/debugfs.h>
27#include <linux/seq_file.h>
28#include <linux/slab.h>
29#include <linux/export.h>
30
31#include <drm/drm_debugfs.h>
32#include <drm/drm_edid.h>
33#include <drm/drm_atomic.h>
34#include <drm/drmP.h>
35
36#include "drm_internal.h"
37#include "drm_crtc_internal.h"
38
39#if defined(CONFIG_DEBUG_FS)
40
41
42
43
44
45static const struct drm_info_list drm_debugfs_list[] = {
46 {"name", drm_name_info, 0},
47 {"clients", drm_clients_info, 0},
48 {"gem_names", drm_gem_name_info, DRIVER_GEM},
49};
50#define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list)
51
52
53static int drm_debugfs_open(struct inode *inode, struct file *file)
54{
55 struct drm_info_node *node = inode->i_private;
56
57 return single_open(file, node->info_ent->show, node);
58}
59
60
61static const struct file_operations drm_debugfs_fops = {
62 .owner = THIS_MODULE,
63 .open = drm_debugfs_open,
64 .read = seq_read,
65 .llseek = seq_lseek,
66 .release = single_release,
67};
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82int drm_debugfs_create_files(const struct drm_info_list *files, int count,
83 struct dentry *root, struct drm_minor *minor)
84{
85 struct drm_device *dev = minor->dev;
86 struct dentry *ent;
87 struct drm_info_node *tmp;
88 int i, ret;
89
90 for (i = 0; i < count; i++) {
91 u32 features = files[i].driver_features;
92
93 if (features != 0 &&
94 (dev->driver->driver_features & features) != features)
95 continue;
96
97 tmp = kmalloc(sizeof(struct drm_info_node), GFP_KERNEL);
98 if (tmp == NULL) {
99 ret = -1;
100 goto fail;
101 }
102 ent = debugfs_create_file(files[i].name, S_IFREG | S_IRUGO,
103 root, tmp, &drm_debugfs_fops);
104 if (!ent) {
105 DRM_ERROR("Cannot create /sys/kernel/debug/dri/%pd/%s\n",
106 root, files[i].name);
107 kfree(tmp);
108 ret = -1;
109 goto fail;
110 }
111
112 tmp->minor = minor;
113 tmp->dent = ent;
114 tmp->info_ent = &files[i];
115
116 mutex_lock(&minor->debugfs_lock);
117 list_add(&tmp->list, &minor->debugfs_list);
118 mutex_unlock(&minor->debugfs_lock);
119 }
120 return 0;
121
122fail:
123 drm_debugfs_remove_files(files, count, minor);
124 return ret;
125}
126EXPORT_SYMBOL(drm_debugfs_create_files);
127
128int drm_debugfs_init(struct drm_minor *minor, int minor_id,
129 struct dentry *root)
130{
131 struct drm_device *dev = minor->dev;
132 char name[64];
133 int ret;
134
135 INIT_LIST_HEAD(&minor->debugfs_list);
136 mutex_init(&minor->debugfs_lock);
137 sprintf(name, "%d", minor_id);
138 minor->debugfs_root = debugfs_create_dir(name, root);
139 if (!minor->debugfs_root) {
140 DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s\n", name);
141 return -1;
142 }
143
144 ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES,
145 minor->debugfs_root, minor);
146 if (ret) {
147 debugfs_remove(minor->debugfs_root);
148 minor->debugfs_root = NULL;
149 DRM_ERROR("Failed to create core drm debugfs files\n");
150 return ret;
151 }
152
153 if (drm_core_check_feature(dev, DRIVER_ATOMIC)) {
154 ret = drm_atomic_debugfs_init(minor);
155 if (ret) {
156 DRM_ERROR("Failed to create atomic debugfs files\n");
157 return ret;
158 }
159 }
160
161 if (dev->driver->debugfs_init) {
162 ret = dev->driver->debugfs_init(minor);
163 if (ret) {
164 DRM_ERROR("DRM: Driver failed to initialize "
165 "/sys/kernel/debug/dri.\n");
166 return ret;
167 }
168 }
169 return 0;
170}
171
172
173int drm_debugfs_remove_files(const struct drm_info_list *files, int count,
174 struct drm_minor *minor)
175{
176 struct list_head *pos, *q;
177 struct drm_info_node *tmp;
178 int i;
179
180 mutex_lock(&minor->debugfs_lock);
181 for (i = 0; i < count; i++) {
182 list_for_each_safe(pos, q, &minor->debugfs_list) {
183 tmp = list_entry(pos, struct drm_info_node, list);
184 if (tmp->info_ent == &files[i]) {
185 debugfs_remove(tmp->dent);
186 list_del(pos);
187 kfree(tmp);
188 }
189 }
190 }
191 mutex_unlock(&minor->debugfs_lock);
192 return 0;
193}
194EXPORT_SYMBOL(drm_debugfs_remove_files);
195
196static void drm_debugfs_remove_all_files(struct drm_minor *minor)
197{
198 struct drm_info_node *node, *tmp;
199
200 mutex_lock(&minor->debugfs_lock);
201 list_for_each_entry_safe(node, tmp, &minor->debugfs_list, list) {
202 debugfs_remove(node->dent);
203 list_del(&node->list);
204 kfree(node);
205 }
206 mutex_unlock(&minor->debugfs_lock);
207}
208
209int drm_debugfs_cleanup(struct drm_minor *minor)
210{
211 if (!minor->debugfs_root)
212 return 0;
213
214 drm_debugfs_remove_all_files(minor);
215
216 debugfs_remove_recursive(minor->debugfs_root);
217 minor->debugfs_root = NULL;
218
219 return 0;
220}
221
222static int connector_show(struct seq_file *m, void *data)
223{
224 struct drm_connector *connector = m->private;
225
226 seq_printf(m, "%s\n", drm_get_connector_force_name(connector->force));
227
228 return 0;
229}
230
231static int connector_open(struct inode *inode, struct file *file)
232{
233 struct drm_connector *dev = inode->i_private;
234
235 return single_open(file, connector_show, dev);
236}
237
238static ssize_t connector_write(struct file *file, const char __user *ubuf,
239 size_t len, loff_t *offp)
240{
241 struct seq_file *m = file->private_data;
242 struct drm_connector *connector = m->private;
243 char buf[12];
244
245 if (len > sizeof(buf) - 1)
246 return -EINVAL;
247
248 if (copy_from_user(buf, ubuf, len))
249 return -EFAULT;
250
251 buf[len] = '\0';
252
253 if (!strcmp(buf, "on"))
254 connector->force = DRM_FORCE_ON;
255 else if (!strcmp(buf, "digital"))
256 connector->force = DRM_FORCE_ON_DIGITAL;
257 else if (!strcmp(buf, "off"))
258 connector->force = DRM_FORCE_OFF;
259 else if (!strcmp(buf, "unspecified"))
260 connector->force = DRM_FORCE_UNSPECIFIED;
261 else
262 return -EINVAL;
263
264 return len;
265}
266
267static int edid_show(struct seq_file *m, void *data)
268{
269 struct drm_connector *connector = m->private;
270 struct drm_property_blob *edid = connector->edid_blob_ptr;
271
272 if (connector->override_edid && edid)
273 seq_write(m, edid->data, edid->length);
274
275 return 0;
276}
277
278static int edid_open(struct inode *inode, struct file *file)
279{
280 struct drm_connector *dev = inode->i_private;
281
282 return single_open(file, edid_show, dev);
283}
284
285static ssize_t edid_write(struct file *file, const char __user *ubuf,
286 size_t len, loff_t *offp)
287{
288 struct seq_file *m = file->private_data;
289 struct drm_connector *connector = m->private;
290 char *buf;
291 struct edid *edid;
292 int ret;
293
294 buf = memdup_user(ubuf, len);
295 if (IS_ERR(buf))
296 return PTR_ERR(buf);
297
298 edid = (struct edid *) buf;
299
300 if (len == 5 && !strncmp(buf, "reset", 5)) {
301 connector->override_edid = false;
302 ret = drm_mode_connector_update_edid_property(connector, NULL);
303 } else if (len < EDID_LENGTH ||
304 EDID_LENGTH * (1 + edid->extensions) > len)
305 ret = -EINVAL;
306 else {
307 connector->override_edid = false;
308 ret = drm_mode_connector_update_edid_property(connector, edid);
309 if (!ret)
310 connector->override_edid = true;
311 }
312
313 kfree(buf);
314
315 return (ret) ? ret : len;
316}
317
318static const struct file_operations drm_edid_fops = {
319 .owner = THIS_MODULE,
320 .open = edid_open,
321 .read = seq_read,
322 .llseek = seq_lseek,
323 .release = single_release,
324 .write = edid_write
325};
326
327
328static const struct file_operations drm_connector_fops = {
329 .owner = THIS_MODULE,
330 .open = connector_open,
331 .read = seq_read,
332 .llseek = seq_lseek,
333 .release = single_release,
334 .write = connector_write
335};
336
337int drm_debugfs_connector_add(struct drm_connector *connector)
338{
339 struct drm_minor *minor = connector->dev->primary;
340 struct dentry *root, *ent;
341
342 if (!minor->debugfs_root)
343 return -1;
344
345 root = debugfs_create_dir(connector->name, minor->debugfs_root);
346 if (!root)
347 return -ENOMEM;
348
349 connector->debugfs_entry = root;
350
351
352 ent = debugfs_create_file("force", S_IRUGO | S_IWUSR, root, connector,
353 &drm_connector_fops);
354 if (!ent)
355 goto error;
356
357
358 ent = debugfs_create_file("edid_override", S_IRUGO | S_IWUSR, root,
359 connector, &drm_edid_fops);
360 if (!ent)
361 goto error;
362
363 return 0;
364
365error:
366 debugfs_remove_recursive(connector->debugfs_entry);
367 connector->debugfs_entry = NULL;
368 return -ENOMEM;
369}
370
371void drm_debugfs_connector_remove(struct drm_connector *connector)
372{
373 if (!connector->debugfs_entry)
374 return;
375
376 debugfs_remove_recursive(connector->debugfs_entry);
377
378 connector->debugfs_entry = NULL;
379}
380
381int drm_debugfs_crtc_add(struct drm_crtc *crtc)
382{
383 struct drm_minor *minor = crtc->dev->primary;
384 struct dentry *root;
385 char *name;
386
387 name = kasprintf(GFP_KERNEL, "crtc-%d", crtc->index);
388 if (!name)
389 return -ENOMEM;
390
391 root = debugfs_create_dir(name, minor->debugfs_root);
392 kfree(name);
393 if (!root)
394 return -ENOMEM;
395
396 crtc->debugfs_entry = root;
397
398 if (drm_debugfs_crtc_crc_add(crtc))
399 goto error;
400
401 return 0;
402
403error:
404 drm_debugfs_crtc_remove(crtc);
405 return -ENOMEM;
406}
407
408void drm_debugfs_crtc_remove(struct drm_crtc *crtc)
409{
410 debugfs_remove_recursive(crtc->debugfs_entry);
411 crtc->debugfs_entry = NULL;
412}
413
414#endif
415