Loading...
1// SPDX-License-Identifier: MIT
2/*
3 * Copyright © 2023 Intel Corporation
4 */
5
6#include <linux/debugfs.h>
7#include <linux/kernel.h>
8
9#include <drm/drm_drv.h>
10
11#include "intel_display_debugfs_params.h"
12#include "i915_drv.h"
13#include "intel_display_params.h"
14
15/* int param */
16static int intel_display_param_int_show(struct seq_file *m, void *data)
17{
18 int *value = m->private;
19
20 seq_printf(m, "%d\n", *value);
21
22 return 0;
23}
24
25static int intel_display_param_int_open(struct inode *inode, struct file *file)
26{
27 return single_open(file, intel_display_param_int_show, inode->i_private);
28}
29
30static ssize_t intel_display_param_int_write(struct file *file,
31 const char __user *ubuf, size_t len,
32 loff_t *offp)
33{
34 struct seq_file *m = file->private_data;
35 int *value = m->private;
36 int ret;
37
38 ret = kstrtoint_from_user(ubuf, len, 0, value);
39 if (ret) {
40 /* support boolean values too */
41 bool b;
42
43 ret = kstrtobool_from_user(ubuf, len, &b);
44 if (!ret)
45 *value = b;
46 }
47
48 return ret ?: len;
49}
50
51static const struct file_operations intel_display_param_int_fops = {
52 .owner = THIS_MODULE,
53 .open = intel_display_param_int_open,
54 .read = seq_read,
55 .write = intel_display_param_int_write,
56 .llseek = default_llseek,
57 .release = single_release,
58};
59
60static const struct file_operations intel_display_param_int_fops_ro = {
61 .owner = THIS_MODULE,
62 .open = intel_display_param_int_open,
63 .read = seq_read,
64 .llseek = default_llseek,
65 .release = single_release,
66};
67
68/* unsigned int param */
69static int intel_display_param_uint_show(struct seq_file *m, void *data)
70{
71 unsigned int *value = m->private;
72
73 seq_printf(m, "%u\n", *value);
74
75 return 0;
76}
77
78static int intel_display_param_uint_open(struct inode *inode, struct file *file)
79{
80 return single_open(file, intel_display_param_uint_show, inode->i_private);
81}
82
83static ssize_t intel_display_param_uint_write(struct file *file,
84 const char __user *ubuf, size_t len,
85 loff_t *offp)
86{
87 struct seq_file *m = file->private_data;
88 unsigned int *value = m->private;
89 int ret;
90
91 ret = kstrtouint_from_user(ubuf, len, 0, value);
92 if (ret) {
93 /* support boolean values too */
94 bool b;
95
96 ret = kstrtobool_from_user(ubuf, len, &b);
97 if (!ret)
98 *value = b;
99 }
100
101 return ret ?: len;
102}
103
104static const struct file_operations intel_display_param_uint_fops = {
105 .owner = THIS_MODULE,
106 .open = intel_display_param_uint_open,
107 .read = seq_read,
108 .write = intel_display_param_uint_write,
109 .llseek = default_llseek,
110 .release = single_release,
111};
112
113static const struct file_operations intel_display_param_uint_fops_ro = {
114 .owner = THIS_MODULE,
115 .open = intel_display_param_uint_open,
116 .read = seq_read,
117 .llseek = default_llseek,
118 .release = single_release,
119};
120
121#define RO(mode) (((mode) & 0222) == 0)
122
123__maybe_unused static struct dentry *
124intel_display_debugfs_create_int(const char *name, umode_t mode,
125 struct dentry *parent, int *value)
126{
127 return debugfs_create_file_unsafe(name, mode, parent, value,
128 RO(mode) ? &intel_display_param_int_fops_ro :
129 &intel_display_param_int_fops);
130}
131
132__maybe_unused static struct dentry *
133intel_display_debugfs_create_uint(const char *name, umode_t mode,
134 struct dentry *parent, unsigned int *value)
135{
136 return debugfs_create_file_unsafe(name, mode, parent, value,
137 RO(mode) ? &intel_display_param_uint_fops_ro :
138 &intel_display_param_uint_fops);
139}
140
141#define _intel_display_param_create_file(parent, name, mode, valp) \
142 do { \
143 if (mode) \
144 _Generic(valp, \
145 bool * : debugfs_create_bool, \
146 int * : intel_display_debugfs_create_int, \
147 unsigned int * : intel_display_debugfs_create_uint, \
148 unsigned long * : debugfs_create_ulong, \
149 char ** : debugfs_create_str) \
150 (name, mode, parent, valp); \
151 } while (0)
152
153/* add a subdirectory with files for each intel display param */
154void intel_display_debugfs_params(struct intel_display *display)
155{
156 struct drm_minor *minor = display->drm->primary;
157 struct dentry *dir;
158 char dirname[16];
159
160 snprintf(dirname, sizeof(dirname), "%s_params", display->drm->driver->name);
161 dir = debugfs_lookup(dirname, minor->debugfs_root);
162 if (!dir)
163 dir = debugfs_create_dir(dirname, minor->debugfs_root);
164 if (IS_ERR(dir))
165 return;
166
167 /*
168 * Note: We could create files for params needing special handling
169 * here. Set mode in params to 0 to skip the generic create file, or
170 * just let the generic create file fail silently with -EEXIST.
171 */
172
173#define REGISTER(T, x, unused, mode, ...) _intel_display_param_create_file( \
174 dir, #x, mode, &display->params.x);
175 INTEL_DISPLAY_PARAMS_FOR_EACH(REGISTER);
176#undef REGISTER
177}
1// SPDX-License-Identifier: MIT
2/*
3 * Copyright © 2023 Intel Corporation
4 */
5
6#include <linux/kernel.h>
7
8#include <drm/drm_drv.h>
9
10#include "intel_display_debugfs_params.h"
11#include "i915_drv.h"
12#include "intel_display_params.h"
13
14/* int param */
15static int intel_display_param_int_show(struct seq_file *m, void *data)
16{
17 int *value = m->private;
18
19 seq_printf(m, "%d\n", *value);
20
21 return 0;
22}
23
24static int intel_display_param_int_open(struct inode *inode, struct file *file)
25{
26 return single_open(file, intel_display_param_int_show, inode->i_private);
27}
28
29static ssize_t intel_display_param_int_write(struct file *file,
30 const char __user *ubuf, size_t len,
31 loff_t *offp)
32{
33 struct seq_file *m = file->private_data;
34 int *value = m->private;
35 int ret;
36
37 ret = kstrtoint_from_user(ubuf, len, 0, value);
38 if (ret) {
39 /* support boolean values too */
40 bool b;
41
42 ret = kstrtobool_from_user(ubuf, len, &b);
43 if (!ret)
44 *value = b;
45 }
46
47 return ret ?: len;
48}
49
50static const struct file_operations intel_display_param_int_fops = {
51 .owner = THIS_MODULE,
52 .open = intel_display_param_int_open,
53 .read = seq_read,
54 .write = intel_display_param_int_write,
55 .llseek = default_llseek,
56 .release = single_release,
57};
58
59static const struct file_operations intel_display_param_int_fops_ro = {
60 .owner = THIS_MODULE,
61 .open = intel_display_param_int_open,
62 .read = seq_read,
63 .llseek = default_llseek,
64 .release = single_release,
65};
66
67/* unsigned int param */
68static int intel_display_param_uint_show(struct seq_file *m, void *data)
69{
70 unsigned int *value = m->private;
71
72 seq_printf(m, "%u\n", *value);
73
74 return 0;
75}
76
77static int intel_display_param_uint_open(struct inode *inode, struct file *file)
78{
79 return single_open(file, intel_display_param_uint_show, inode->i_private);
80}
81
82static ssize_t intel_display_param_uint_write(struct file *file,
83 const char __user *ubuf, size_t len,
84 loff_t *offp)
85{
86 struct seq_file *m = file->private_data;
87 unsigned int *value = m->private;
88 int ret;
89
90 ret = kstrtouint_from_user(ubuf, len, 0, value);
91 if (ret) {
92 /* support boolean values too */
93 bool b;
94
95 ret = kstrtobool_from_user(ubuf, len, &b);
96 if (!ret)
97 *value = b;
98 }
99
100 return ret ?: len;
101}
102
103static const struct file_operations intel_display_param_uint_fops = {
104 .owner = THIS_MODULE,
105 .open = intel_display_param_uint_open,
106 .read = seq_read,
107 .write = intel_display_param_uint_write,
108 .llseek = default_llseek,
109 .release = single_release,
110};
111
112static const struct file_operations intel_display_param_uint_fops_ro = {
113 .owner = THIS_MODULE,
114 .open = intel_display_param_uint_open,
115 .read = seq_read,
116 .llseek = default_llseek,
117 .release = single_release,
118};
119
120#define RO(mode) (((mode) & 0222) == 0)
121
122__maybe_unused static struct dentry *
123intel_display_debugfs_create_int(const char *name, umode_t mode,
124 struct dentry *parent, int *value)
125{
126 return debugfs_create_file_unsafe(name, mode, parent, value,
127 RO(mode) ? &intel_display_param_int_fops_ro :
128 &intel_display_param_int_fops);
129}
130
131__maybe_unused static struct dentry *
132intel_display_debugfs_create_uint(const char *name, umode_t mode,
133 struct dentry *parent, unsigned int *value)
134{
135 return debugfs_create_file_unsafe(name, mode, parent, value,
136 RO(mode) ? &intel_display_param_uint_fops_ro :
137 &intel_display_param_uint_fops);
138}
139
140#define _intel_display_param_create_file(parent, name, mode, valp) \
141 do { \
142 if (mode) \
143 _Generic(valp, \
144 bool * : debugfs_create_bool, \
145 int * : intel_display_debugfs_create_int, \
146 unsigned int * : intel_display_debugfs_create_uint, \
147 unsigned long * : debugfs_create_ulong, \
148 char ** : debugfs_create_str) \
149 (name, mode, parent, valp); \
150 } while (0)
151
152/* add a subdirectory with files for each intel display param */
153void intel_display_debugfs_params(struct drm_i915_private *i915)
154{
155 struct drm_minor *minor = i915->drm.primary;
156 struct dentry *dir;
157 char dirname[16];
158
159 snprintf(dirname, sizeof(dirname), "%s_params", i915->drm.driver->name);
160 dir = debugfs_lookup(dirname, minor->debugfs_root);
161 if (!dir)
162 dir = debugfs_create_dir(dirname, minor->debugfs_root);
163 if (IS_ERR(dir))
164 return;
165
166 /*
167 * Note: We could create files for params needing special handling
168 * here. Set mode in params to 0 to skip the generic create file, or
169 * just let the generic create file fail silently with -EEXIST.
170 */
171
172#define REGISTER(T, x, unused, mode, ...) _intel_display_param_create_file( \
173 dir, #x, mode, &i915->display.params.x);
174 INTEL_DISPLAY_PARAMS_FOR_EACH(REGISTER);
175#undef REGISTER
176}