xref: /linux/drivers/gpu/drm/i915/gt/sysfs_engines.c (revision 312b62b6610cabea4cb535fd4889c41e9a84afca)
1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright © 2019 Intel Corporation
4  */
5 
6 #include <linux/kobject.h>
7 #include <linux/sysfs.h>
8 
9 #include "i915_drv.h"
10 #include "intel_engine.h"
11 #include "intel_engine_heartbeat.h"
12 #include "sysfs_engines.h"
13 
14 struct kobj_engine {
15 	struct kobject base;
16 	struct intel_engine_cs *engine;
17 };
18 
19 static struct intel_engine_cs *kobj_to_engine(struct kobject *kobj)
20 {
21 	return container_of(kobj, struct kobj_engine, base)->engine;
22 }
23 
24 static ssize_t
25 name_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
26 {
27 	return sprintf(buf, "%s\n", kobj_to_engine(kobj)->name);
28 }
29 
30 static struct kobj_attribute name_attr =
31 __ATTR(name, 0444, name_show, NULL);
32 
33 static ssize_t
34 class_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
35 {
36 	return sprintf(buf, "%d\n", kobj_to_engine(kobj)->uabi_class);
37 }
38 
39 static struct kobj_attribute class_attr =
40 __ATTR(class, 0444, class_show, NULL);
41 
42 static ssize_t
43 inst_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
44 {
45 	return sprintf(buf, "%d\n", kobj_to_engine(kobj)->uabi_instance);
46 }
47 
48 static struct kobj_attribute inst_attr =
49 __ATTR(instance, 0444, inst_show, NULL);
50 
51 static ssize_t
52 mmio_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
53 {
54 	return sprintf(buf, "0x%x\n", kobj_to_engine(kobj)->mmio_base);
55 }
56 
57 static struct kobj_attribute mmio_attr =
58 __ATTR(mmio_base, 0444, mmio_show, NULL);
59 
60 static const char * const vcs_caps[] = {
61 	[ilog2(I915_VIDEO_CLASS_CAPABILITY_HEVC)] = "hevc",
62 	[ilog2(I915_VIDEO_AND_ENHANCE_CLASS_CAPABILITY_SFC)] = "sfc",
63 };
64 
65 static const char * const vecs_caps[] = {
66 	[ilog2(I915_VIDEO_AND_ENHANCE_CLASS_CAPABILITY_SFC)] = "sfc",
67 };
68 
69 static ssize_t repr_trim(char *buf, ssize_t len)
70 {
71 	/* Trim off the trailing space and replace with a newline */
72 	if (len > PAGE_SIZE)
73 		len = PAGE_SIZE;
74 	if (len > 0)
75 		buf[len - 1] = '\n';
76 
77 	return len;
78 }
79 
80 static ssize_t
81 __caps_show(struct intel_engine_cs *engine,
82 	    u32 caps, char *buf, bool show_unknown)
83 {
84 	const char * const *repr;
85 	int count, n;
86 	ssize_t len;
87 
88 	BUILD_BUG_ON(!typecheck(typeof(caps), engine->uabi_capabilities));
89 
90 	switch (engine->class) {
91 	case VIDEO_DECODE_CLASS:
92 		repr = vcs_caps;
93 		count = ARRAY_SIZE(vcs_caps);
94 		break;
95 
96 	case VIDEO_ENHANCEMENT_CLASS:
97 		repr = vecs_caps;
98 		count = ARRAY_SIZE(vecs_caps);
99 		break;
100 
101 	default:
102 		repr = NULL;
103 		count = 0;
104 		break;
105 	}
106 	GEM_BUG_ON(count > BITS_PER_TYPE(typeof(caps)));
107 
108 	len = 0;
109 	for_each_set_bit(n,
110 			 (unsigned long *)&caps,
111 			 show_unknown ? BITS_PER_TYPE(typeof(caps)) : count) {
112 		if (n >= count || !repr[n]) {
113 			if (GEM_WARN_ON(show_unknown))
114 				len += snprintf(buf + len, PAGE_SIZE - len,
115 						"[%x] ", n);
116 		} else {
117 			len += snprintf(buf + len, PAGE_SIZE - len,
118 					"%s ", repr[n]);
119 		}
120 		if (GEM_WARN_ON(len >= PAGE_SIZE))
121 			break;
122 	}
123 	return repr_trim(buf, len);
124 }
125 
126 static ssize_t
127 caps_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
128 {
129 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
130 
131 	return __caps_show(engine, engine->uabi_capabilities, buf, true);
132 }
133 
134 static struct kobj_attribute caps_attr =
135 __ATTR(capabilities, 0444, caps_show, NULL);
136 
137 static ssize_t
138 all_caps_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
139 {
140 	return __caps_show(kobj_to_engine(kobj), -1, buf, false);
141 }
142 
143 static struct kobj_attribute all_caps_attr =
144 __ATTR(known_capabilities, 0444, all_caps_show, NULL);
145 
146 static ssize_t
147 max_spin_store(struct kobject *kobj, struct kobj_attribute *attr,
148 	       const char *buf, size_t count)
149 {
150 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
151 	unsigned long long duration;
152 	int err;
153 
154 	/*
155 	 * When waiting for a request, if is it currently being executed
156 	 * on the GPU, we busywait for a short while before sleeping. The
157 	 * premise is that most requests are short, and if it is already
158 	 * executing then there is a good chance that it will complete
159 	 * before we can setup the interrupt handler and go to sleep.
160 	 * We try to offset the cost of going to sleep, by first spinning
161 	 * on the request -- if it completed in less time than it would take
162 	 * to go sleep, process the interrupt and return back to the client,
163 	 * then we have saved the client some latency, albeit at the cost
164 	 * of spinning on an expensive CPU core.
165 	 *
166 	 * While we try to avoid waiting at all for a request that is unlikely
167 	 * to complete, deciding how long it is worth spinning is for is an
168 	 * arbitrary decision: trading off power vs latency.
169 	 */
170 
171 	err = kstrtoull(buf, 0, &duration);
172 	if (err)
173 		return err;
174 
175 	if (duration > jiffies_to_nsecs(2))
176 		return -EINVAL;
177 
178 	WRITE_ONCE(engine->props.max_busywait_duration_ns, duration);
179 
180 	return count;
181 }
182 
183 static ssize_t
184 max_spin_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
185 {
186 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
187 
188 	return sprintf(buf, "%lu\n", engine->props.max_busywait_duration_ns);
189 }
190 
191 static struct kobj_attribute max_spin_attr =
192 __ATTR(max_busywait_duration_ns, 0644, max_spin_show, max_spin_store);
193 
194 static ssize_t
195 max_spin_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
196 {
197 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
198 
199 	return sprintf(buf, "%lu\n", engine->defaults.max_busywait_duration_ns);
200 }
201 
202 static struct kobj_attribute max_spin_def =
203 __ATTR(max_busywait_duration_ns, 0444, max_spin_default, NULL);
204 
205 static ssize_t
206 timeslice_store(struct kobject *kobj, struct kobj_attribute *attr,
207 		const char *buf, size_t count)
208 {
209 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
210 	unsigned long long duration;
211 	int err;
212 
213 	/*
214 	 * Execlists uses a scheduling quantum (a timeslice) to alternate
215 	 * execution between ready-to-run contexts of equal priority. This
216 	 * ensures that all users (though only if they of equal importance)
217 	 * have the opportunity to run and prevents livelocks where contexts
218 	 * may have implicit ordering due to userspace semaphores.
219 	 */
220 
221 	err = kstrtoull(buf, 0, &duration);
222 	if (err)
223 		return err;
224 
225 	if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
226 		return -EINVAL;
227 
228 	WRITE_ONCE(engine->props.timeslice_duration_ms, duration);
229 
230 	if (execlists_active(&engine->execlists))
231 		set_timer_ms(&engine->execlists.timer, duration);
232 
233 	return count;
234 }
235 
236 static ssize_t
237 timeslice_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
238 {
239 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
240 
241 	return sprintf(buf, "%lu\n", engine->props.timeslice_duration_ms);
242 }
243 
244 static struct kobj_attribute timeslice_duration_attr =
245 __ATTR(timeslice_duration_ms, 0644, timeslice_show, timeslice_store);
246 
247 static ssize_t
248 timeslice_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
249 {
250 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
251 
252 	return sprintf(buf, "%lu\n", engine->defaults.timeslice_duration_ms);
253 }
254 
255 static struct kobj_attribute timeslice_duration_def =
256 __ATTR(timeslice_duration_ms, 0444, timeslice_default, NULL);
257 
258 static ssize_t
259 stop_store(struct kobject *kobj, struct kobj_attribute *attr,
260 	   const char *buf, size_t count)
261 {
262 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
263 	unsigned long long duration;
264 	int err;
265 
266 	/*
267 	 * When we allow ourselves to sleep before a GPU reset after disabling
268 	 * submission, even for a few milliseconds, gives an innocent context
269 	 * the opportunity to clear the GPU before the reset occurs. However,
270 	 * how long to sleep depends on the typical non-preemptible duration
271 	 * (a similar problem to determining the ideal preempt-reset timeout
272 	 * or even the heartbeat interval).
273 	 */
274 
275 	err = kstrtoull(buf, 0, &duration);
276 	if (err)
277 		return err;
278 
279 	if (duration > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
280 		return -EINVAL;
281 
282 	WRITE_ONCE(engine->props.stop_timeout_ms, duration);
283 	return count;
284 }
285 
286 static ssize_t
287 stop_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
288 {
289 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
290 
291 	return sprintf(buf, "%lu\n", engine->props.stop_timeout_ms);
292 }
293 
294 static struct kobj_attribute stop_timeout_attr =
295 __ATTR(stop_timeout_ms, 0644, stop_show, stop_store);
296 
297 static ssize_t
298 stop_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
299 {
300 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
301 
302 	return sprintf(buf, "%lu\n", engine->defaults.stop_timeout_ms);
303 }
304 
305 static struct kobj_attribute stop_timeout_def =
306 __ATTR(stop_timeout_ms, 0444, stop_default, NULL);
307 
308 static ssize_t
309 preempt_timeout_store(struct kobject *kobj, struct kobj_attribute *attr,
310 		      const char *buf, size_t count)
311 {
312 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
313 	unsigned long long timeout;
314 	int err;
315 
316 	/*
317 	 * After initialising a preemption request, we give the current
318 	 * resident a small amount of time to vacate the GPU. The preemption
319 	 * request is for a higher priority context and should be immediate to
320 	 * maintain high quality of service (and avoid priority inversion).
321 	 * However, the preemption granularity of the GPU can be quite coarse
322 	 * and so we need a compromise.
323 	 */
324 
325 	err = kstrtoull(buf, 0, &timeout);
326 	if (err)
327 		return err;
328 
329 	if (timeout > jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
330 		return -EINVAL;
331 
332 	WRITE_ONCE(engine->props.preempt_timeout_ms, timeout);
333 
334 	if (READ_ONCE(engine->execlists.pending[0]))
335 		set_timer_ms(&engine->execlists.preempt, timeout);
336 
337 	return count;
338 }
339 
340 static ssize_t
341 preempt_timeout_show(struct kobject *kobj, struct kobj_attribute *attr,
342 		     char *buf)
343 {
344 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
345 
346 	return sprintf(buf, "%lu\n", engine->props.preempt_timeout_ms);
347 }
348 
349 static struct kobj_attribute preempt_timeout_attr =
350 __ATTR(preempt_timeout_ms, 0644, preempt_timeout_show, preempt_timeout_store);
351 
352 static ssize_t
353 preempt_timeout_default(struct kobject *kobj, struct kobj_attribute *attr,
354 			char *buf)
355 {
356 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
357 
358 	return sprintf(buf, "%lu\n", engine->defaults.preempt_timeout_ms);
359 }
360 
361 static struct kobj_attribute preempt_timeout_def =
362 __ATTR(preempt_timeout_ms, 0444, preempt_timeout_default, NULL);
363 
364 static ssize_t
365 heartbeat_store(struct kobject *kobj, struct kobj_attribute *attr,
366 		const char *buf, size_t count)
367 {
368 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
369 	unsigned long long delay;
370 	int err;
371 
372 	/*
373 	 * We monitor the health of the system via periodic heartbeat pulses.
374 	 * The pulses also provide the opportunity to perform garbage
375 	 * collection.  However, we interpret an incomplete pulse (a missed
376 	 * heartbeat) as an indication that the system is no longer responsive,
377 	 * i.e. hung, and perform an engine or full GPU reset. Given that the
378 	 * preemption granularity can be very coarse on a system, the optimal
379 	 * value for any workload is unknowable!
380 	 */
381 
382 	err = kstrtoull(buf, 0, &delay);
383 	if (err)
384 		return err;
385 
386 	if (delay >= jiffies_to_msecs(MAX_SCHEDULE_TIMEOUT))
387 		return -EINVAL;
388 
389 	err = intel_engine_set_heartbeat(engine, delay);
390 	if (err)
391 		return err;
392 
393 	return count;
394 }
395 
396 static ssize_t
397 heartbeat_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
398 {
399 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
400 
401 	return sprintf(buf, "%lu\n", engine->props.heartbeat_interval_ms);
402 }
403 
404 static struct kobj_attribute heartbeat_interval_attr =
405 __ATTR(heartbeat_interval_ms, 0644, heartbeat_show, heartbeat_store);
406 
407 static ssize_t
408 heartbeat_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
409 {
410 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
411 
412 	return sprintf(buf, "%lu\n", engine->defaults.heartbeat_interval_ms);
413 }
414 
415 static struct kobj_attribute heartbeat_interval_def =
416 __ATTR(heartbeat_interval_ms, 0444, heartbeat_default, NULL);
417 
418 static void kobj_engine_release(struct kobject *kobj)
419 {
420 	kfree(kobj);
421 }
422 
423 static struct kobj_type kobj_engine_type = {
424 	.release = kobj_engine_release,
425 	.sysfs_ops = &kobj_sysfs_ops
426 };
427 
428 static struct kobject *
429 kobj_engine(struct kobject *dir, struct intel_engine_cs *engine)
430 {
431 	struct kobj_engine *ke;
432 
433 	ke = kzalloc(sizeof(*ke), GFP_KERNEL);
434 	if (!ke)
435 		return NULL;
436 
437 	kobject_init(&ke->base, &kobj_engine_type);
438 	ke->engine = engine;
439 
440 	if (kobject_add(&ke->base, dir, "%s", engine->name)) {
441 		kobject_put(&ke->base);
442 		return NULL;
443 	}
444 
445 	/* xfer ownership to sysfs tree */
446 	return &ke->base;
447 }
448 
449 static void add_defaults(struct kobj_engine *parent)
450 {
451 	static const struct attribute *files[] = {
452 		&max_spin_def.attr,
453 		&stop_timeout_def.attr,
454 #if CONFIG_DRM_I915_HEARTBEAT_INTERVAL
455 		&heartbeat_interval_def.attr,
456 #endif
457 		NULL
458 	};
459 	struct kobj_engine *ke;
460 
461 	ke = kzalloc(sizeof(*ke), GFP_KERNEL);
462 	if (!ke)
463 		return;
464 
465 	kobject_init(&ke->base, &kobj_engine_type);
466 	ke->engine = parent->engine;
467 
468 	if (kobject_add(&ke->base, &parent->base, "%s", ".defaults")) {
469 		kobject_put(&ke->base);
470 		return;
471 	}
472 
473 	if (sysfs_create_files(&ke->base, files))
474 		return;
475 
476 	if (intel_engine_has_timeslices(ke->engine) &&
477 	    sysfs_create_file(&ke->base, &timeslice_duration_def.attr))
478 		return;
479 
480 	if (intel_engine_has_preempt_reset(ke->engine) &&
481 	    sysfs_create_file(&ke->base, &preempt_timeout_def.attr))
482 		return;
483 }
484 
485 void intel_engines_add_sysfs(struct drm_i915_private *i915)
486 {
487 	static const struct attribute *files[] = {
488 		&name_attr.attr,
489 		&class_attr.attr,
490 		&inst_attr.attr,
491 		&mmio_attr.attr,
492 		&caps_attr.attr,
493 		&all_caps_attr.attr,
494 		&max_spin_attr.attr,
495 		&stop_timeout_attr.attr,
496 #if CONFIG_DRM_I915_HEARTBEAT_INTERVAL
497 		&heartbeat_interval_attr.attr,
498 #endif
499 		NULL
500 	};
501 
502 	struct device *kdev = i915->drm.primary->kdev;
503 	struct intel_engine_cs *engine;
504 	struct kobject *dir;
505 
506 	dir = kobject_create_and_add("engine", &kdev->kobj);
507 	if (!dir)
508 		return;
509 
510 	for_each_uabi_engine(engine, i915) {
511 		struct kobject *kobj;
512 
513 		kobj = kobj_engine(dir, engine);
514 		if (!kobj)
515 			goto err_engine;
516 
517 		if (sysfs_create_files(kobj, files))
518 			goto err_object;
519 
520 		if (intel_engine_has_timeslices(engine) &&
521 		    sysfs_create_file(kobj, &timeslice_duration_attr.attr))
522 			goto err_engine;
523 
524 		if (intel_engine_has_preempt_reset(engine) &&
525 		    sysfs_create_file(kobj, &preempt_timeout_attr.attr))
526 			goto err_engine;
527 
528 		add_defaults(container_of(kobj, struct kobj_engine, base));
529 
530 		if (0) {
531 err_object:
532 			kobject_put(kobj);
533 err_engine:
534 			dev_err(kdev, "Failed to add sysfs engine '%s'\n",
535 				engine->name);
536 			break;
537 		}
538 	}
539 }
540