1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright © 2019 Intel Corporation
4  */
5 
6 #include <linux/kernel.h>
7 
8 #include "i915_debugfs_params.h"
9 #include "gt/intel_gt.h"
10 #include "gt/uc/intel_guc.h"
11 #include "i915_drv.h"
12 #include "i915_params.h"
13 
14 #define MATCH_DEBUGFS_NODE_NAME(_file, _name) \
15 	(strcmp((_file)->f_path.dentry->d_name.name, (_name)) == 0)
16 
17 #define GET_I915(i915, name, ptr)	\
18 	do {	\
19 		struct i915_params *params;	\
20 		params = container_of(((void *)(ptr)), typeof(*params), name);	\
21 		(i915) = container_of(params, typeof(*(i915)), params);	\
22 	} while (0)
23 
24 /* int param */
25 static int i915_param_int_show(struct seq_file *m, void *data)
26 {
27 	int *value = m->private;
28 
29 	seq_printf(m, "%d\n", *value);
30 
31 	return 0;
32 }
33 
34 static int i915_param_int_open(struct inode *inode, struct file *file)
35 {
36 	return single_open(file, i915_param_int_show, inode->i_private);
37 }
38 
39 static int notify_guc(struct drm_i915_private *i915)
40 {
41 	int ret = 0;
42 
43 	if (intel_uc_uses_guc_submission(&i915->gt.uc))
44 		ret = intel_guc_global_policies_update(&i915->gt.uc.guc);
45 
46 	return ret;
47 }
48 
49 static ssize_t i915_param_int_write(struct file *file,
50 				    const char __user *ubuf, size_t len,
51 				    loff_t *offp)
52 {
53 	struct seq_file *m = file->private_data;
54 	int *value = m->private;
55 	int ret;
56 
57 	ret = kstrtoint_from_user(ubuf, len, 0, value);
58 	if (ret) {
59 		/* support boolean values too */
60 		bool b;
61 
62 		ret = kstrtobool_from_user(ubuf, len, &b);
63 		if (!ret)
64 			*value = b;
65 	}
66 
67 	return ret ?: len;
68 }
69 
70 static const struct file_operations i915_param_int_fops = {
71 	.owner = THIS_MODULE,
72 	.open = i915_param_int_open,
73 	.read = seq_read,
74 	.write = i915_param_int_write,
75 	.llseek = default_llseek,
76 	.release = single_release,
77 };
78 
79 static const struct file_operations i915_param_int_fops_ro = {
80 	.owner = THIS_MODULE,
81 	.open = i915_param_int_open,
82 	.read = seq_read,
83 	.llseek = default_llseek,
84 	.release = single_release,
85 };
86 
87 /* unsigned int param */
88 static int i915_param_uint_show(struct seq_file *m, void *data)
89 {
90 	unsigned int *value = m->private;
91 
92 	seq_printf(m, "%u\n", *value);
93 
94 	return 0;
95 }
96 
97 static int i915_param_uint_open(struct inode *inode, struct file *file)
98 {
99 	return single_open(file, i915_param_uint_show, inode->i_private);
100 }
101 
102 static ssize_t i915_param_uint_write(struct file *file,
103 				     const char __user *ubuf, size_t len,
104 				     loff_t *offp)
105 {
106 	struct drm_i915_private *i915;
107 	struct seq_file *m = file->private_data;
108 	unsigned int *value = m->private;
109 	unsigned int old = *value;
110 	int ret;
111 
112 	ret = kstrtouint_from_user(ubuf, len, 0, value);
113 	if (ret) {
114 		/* support boolean values too */
115 		bool b;
116 
117 		ret = kstrtobool_from_user(ubuf, len, &b);
118 		if (!ret)
119 			*value = b;
120 	}
121 
122 	if (!ret && MATCH_DEBUGFS_NODE_NAME(file, "reset")) {
123 		GET_I915(i915, reset, value);
124 
125 		ret = notify_guc(i915);
126 		if (ret)
127 			*value = old;
128 	}
129 
130 	return ret ?: len;
131 }
132 
133 static const struct file_operations i915_param_uint_fops = {
134 	.owner = THIS_MODULE,
135 	.open = i915_param_uint_open,
136 	.read = seq_read,
137 	.write = i915_param_uint_write,
138 	.llseek = default_llseek,
139 	.release = single_release,
140 };
141 
142 static const struct file_operations i915_param_uint_fops_ro = {
143 	.owner = THIS_MODULE,
144 	.open = i915_param_uint_open,
145 	.read = seq_read,
146 	.llseek = default_llseek,
147 	.release = single_release,
148 };
149 
150 /* char * param */
151 static int i915_param_charp_show(struct seq_file *m, void *data)
152 {
153 	const char **s = m->private;
154 
155 	seq_printf(m, "%s\n", *s);
156 
157 	return 0;
158 }
159 
160 static int i915_param_charp_open(struct inode *inode, struct file *file)
161 {
162 	return single_open(file, i915_param_charp_show, inode->i_private);
163 }
164 
165 static ssize_t i915_param_charp_write(struct file *file,
166 				      const char __user *ubuf, size_t len,
167 				      loff_t *offp)
168 {
169 	struct seq_file *m = file->private_data;
170 	char **s = m->private;
171 	char *new, *old;
172 
173 	old = *s;
174 	new = strndup_user(ubuf, PAGE_SIZE);
175 	if (IS_ERR(new)) {
176 		len = PTR_ERR(new);
177 		goto out;
178 	}
179 
180 	*s = new;
181 
182 	kfree(old);
183 out:
184 	return len;
185 }
186 
187 static const struct file_operations i915_param_charp_fops = {
188 	.owner = THIS_MODULE,
189 	.open = i915_param_charp_open,
190 	.read = seq_read,
191 	.write = i915_param_charp_write,
192 	.llseek = default_llseek,
193 	.release = single_release,
194 };
195 
196 static const struct file_operations i915_param_charp_fops_ro = {
197 	.owner = THIS_MODULE,
198 	.open = i915_param_charp_open,
199 	.read = seq_read,
200 	.llseek = default_llseek,
201 	.release = single_release,
202 };
203 
204 #define RO(mode) (((mode) & 0222) == 0)
205 
206 static struct dentry *
207 i915_debugfs_create_int(const char *name, umode_t mode,
208 			struct dentry *parent, int *value)
209 {
210 	return debugfs_create_file_unsafe(name, mode, parent, value,
211 					  RO(mode) ? &i915_param_int_fops_ro :
212 					  &i915_param_int_fops);
213 }
214 
215 static struct dentry *
216 i915_debugfs_create_uint(const char *name, umode_t mode,
217 			 struct dentry *parent, unsigned int *value)
218 {
219 	return debugfs_create_file_unsafe(name, mode, parent, value,
220 					  RO(mode) ? &i915_param_uint_fops_ro :
221 					  &i915_param_uint_fops);
222 }
223 
224 static struct dentry *
225 i915_debugfs_create_charp(const char *name, umode_t mode,
226 			  struct dentry *parent, char **value)
227 {
228 	return debugfs_create_file(name, mode, parent, value,
229 				   RO(mode) ? &i915_param_charp_fops_ro :
230 				   &i915_param_charp_fops);
231 }
232 
233 static __always_inline void
234 _i915_param_create_file(struct dentry *parent, const char *name,
235 			const char *type, int mode, void *value)
236 {
237 	if (!mode)
238 		return;
239 
240 	if (!__builtin_strcmp(type, "bool"))
241 		debugfs_create_bool(name, mode, parent, value);
242 	else if (!__builtin_strcmp(type, "int"))
243 		i915_debugfs_create_int(name, mode, parent, value);
244 	else if (!__builtin_strcmp(type, "unsigned int"))
245 		i915_debugfs_create_uint(name, mode, parent, value);
246 	else if (!__builtin_strcmp(type, "unsigned long"))
247 		debugfs_create_ulong(name, mode, parent, value);
248 	else if (!__builtin_strcmp(type, "char *"))
249 		i915_debugfs_create_charp(name, mode, parent, value);
250 	else
251 		WARN(1, "no debugfs fops defined for param type %s (i915.%s)\n",
252 		     type, name);
253 }
254 
255 /* add a subdirectory with files for each i915 param */
256 struct dentry *i915_debugfs_params(struct drm_i915_private *i915)
257 {
258 	struct drm_minor *minor = i915->drm.primary;
259 	struct i915_params *params = &i915->params;
260 	struct dentry *dir;
261 
262 	dir = debugfs_create_dir("i915_params", minor->debugfs_root);
263 	if (IS_ERR(dir))
264 		return dir;
265 
266 	/*
267 	 * Note: We could create files for params needing special handling
268 	 * here. Set mode in params to 0 to skip the generic create file, or
269 	 * just let the generic create file fail silently with -EEXIST.
270 	 */
271 
272 #define REGISTER(T, x, unused, mode, ...) _i915_param_create_file(dir, #x, #T, mode, &params->x);
273 	I915_PARAMS_FOR_EACH(REGISTER);
274 #undef REGISTER
275 
276 	return dir;
277 }
278