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 
kobj_to_engine(struct kobject * kobj)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
name_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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
class_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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
inst_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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
mmio_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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 
repr_trim(char * buf,ssize_t len)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
__caps_show(struct intel_engine_cs * engine,unsigned long caps,char * buf,bool show_unknown)81 __caps_show(struct intel_engine_cs *engine,
82 	    unsigned long caps, char *buf, bool show_unknown)
83 {
84 	const char * const *repr;
85 	int count, n;
86 	ssize_t len;
87 
88 	switch (engine->class) {
89 	case VIDEO_DECODE_CLASS:
90 		repr = vcs_caps;
91 		count = ARRAY_SIZE(vcs_caps);
92 		break;
93 
94 	case VIDEO_ENHANCEMENT_CLASS:
95 		repr = vecs_caps;
96 		count = ARRAY_SIZE(vecs_caps);
97 		break;
98 
99 	default:
100 		repr = NULL;
101 		count = 0;
102 		break;
103 	}
104 	GEM_BUG_ON(count > BITS_PER_LONG);
105 
106 	len = 0;
107 	for_each_set_bit(n, &caps, show_unknown ? BITS_PER_LONG : count) {
108 		if (n >= count || !repr[n]) {
109 			if (GEM_WARN_ON(show_unknown))
110 				len += snprintf(buf + len, PAGE_SIZE - len,
111 						"[%x] ", n);
112 		} else {
113 			len += snprintf(buf + len, PAGE_SIZE - len,
114 					"%s ", repr[n]);
115 		}
116 		if (GEM_WARN_ON(len >= PAGE_SIZE))
117 			break;
118 	}
119 	return repr_trim(buf, len);
120 }
121 
122 static ssize_t
caps_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)123 caps_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
124 {
125 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
126 
127 	return __caps_show(engine, engine->uabi_capabilities, buf, true);
128 }
129 
130 static struct kobj_attribute caps_attr =
131 __ATTR(capabilities, 0444, caps_show, NULL);
132 
133 static ssize_t
all_caps_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)134 all_caps_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
135 {
136 	return __caps_show(kobj_to_engine(kobj), -1, buf, false);
137 }
138 
139 static struct kobj_attribute all_caps_attr =
140 __ATTR(known_capabilities, 0444, all_caps_show, NULL);
141 
142 static ssize_t
max_spin_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)143 max_spin_store(struct kobject *kobj, struct kobj_attribute *attr,
144 	       const char *buf, size_t count)
145 {
146 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
147 	unsigned long long duration, clamped;
148 	int err;
149 
150 	/*
151 	 * When waiting for a request, if is it currently being executed
152 	 * on the GPU, we busywait for a short while before sleeping. The
153 	 * premise is that most requests are short, and if it is already
154 	 * executing then there is a good chance that it will complete
155 	 * before we can setup the interrupt handler and go to sleep.
156 	 * We try to offset the cost of going to sleep, by first spinning
157 	 * on the request -- if it completed in less time than it would take
158 	 * to go sleep, process the interrupt and return back to the client,
159 	 * then we have saved the client some latency, albeit at the cost
160 	 * of spinning on an expensive CPU core.
161 	 *
162 	 * While we try to avoid waiting at all for a request that is unlikely
163 	 * to complete, deciding how long it is worth spinning is for is an
164 	 * arbitrary decision: trading off power vs latency.
165 	 */
166 
167 	err = kstrtoull(buf, 0, &duration);
168 	if (err)
169 		return err;
170 
171 	clamped = intel_clamp_max_busywait_duration_ns(engine, duration);
172 	if (duration != clamped)
173 		return -EINVAL;
174 
175 	WRITE_ONCE(engine->props.max_busywait_duration_ns, duration);
176 
177 	return count;
178 }
179 
180 static ssize_t
max_spin_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)181 max_spin_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
182 {
183 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
184 
185 	return sprintf(buf, "%lu\n", engine->props.max_busywait_duration_ns);
186 }
187 
188 static struct kobj_attribute max_spin_attr =
189 __ATTR(max_busywait_duration_ns, 0644, max_spin_show, max_spin_store);
190 
191 static ssize_t
max_spin_default(struct kobject * kobj,struct kobj_attribute * attr,char * buf)192 max_spin_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
193 {
194 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
195 
196 	return sprintf(buf, "%lu\n", engine->defaults.max_busywait_duration_ns);
197 }
198 
199 static struct kobj_attribute max_spin_def =
200 __ATTR(max_busywait_duration_ns, 0444, max_spin_default, NULL);
201 
202 static ssize_t
timeslice_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)203 timeslice_store(struct kobject *kobj, struct kobj_attribute *attr,
204 		const char *buf, size_t count)
205 {
206 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
207 	unsigned long long duration, clamped;
208 	int err;
209 
210 	/*
211 	 * Execlists uses a scheduling quantum (a timeslice) to alternate
212 	 * execution between ready-to-run contexts of equal priority. This
213 	 * ensures that all users (though only if they of equal importance)
214 	 * have the opportunity to run and prevents livelocks where contexts
215 	 * may have implicit ordering due to userspace semaphores.
216 	 */
217 
218 	err = kstrtoull(buf, 0, &duration);
219 	if (err)
220 		return err;
221 
222 	clamped = intel_clamp_timeslice_duration_ms(engine, duration);
223 	if (duration != clamped)
224 		return -EINVAL;
225 
226 	WRITE_ONCE(engine->props.timeslice_duration_ms, duration);
227 
228 	if (execlists_active(&engine->execlists))
229 		set_timer_ms(&engine->execlists.timer, duration);
230 
231 	return count;
232 }
233 
234 static ssize_t
timeslice_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)235 timeslice_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
236 {
237 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
238 
239 	return sprintf(buf, "%lu\n", engine->props.timeslice_duration_ms);
240 }
241 
242 static struct kobj_attribute timeslice_duration_attr =
243 __ATTR(timeslice_duration_ms, 0644, timeslice_show, timeslice_store);
244 
245 static ssize_t
timeslice_default(struct kobject * kobj,struct kobj_attribute * attr,char * buf)246 timeslice_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
247 {
248 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
249 
250 	return sprintf(buf, "%lu\n", engine->defaults.timeslice_duration_ms);
251 }
252 
253 static struct kobj_attribute timeslice_duration_def =
254 __ATTR(timeslice_duration_ms, 0444, timeslice_default, NULL);
255 
256 static ssize_t
stop_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)257 stop_store(struct kobject *kobj, struct kobj_attribute *attr,
258 	   const char *buf, size_t count)
259 {
260 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
261 	unsigned long long duration, clamped;
262 	int err;
263 
264 	/*
265 	 * When we allow ourselves to sleep before a GPU reset after disabling
266 	 * submission, even for a few milliseconds, gives an innocent context
267 	 * the opportunity to clear the GPU before the reset occurs. However,
268 	 * how long to sleep depends on the typical non-preemptible duration
269 	 * (a similar problem to determining the ideal preempt-reset timeout
270 	 * or even the heartbeat interval).
271 	 */
272 
273 	err = kstrtoull(buf, 0, &duration);
274 	if (err)
275 		return err;
276 
277 	clamped = intel_clamp_stop_timeout_ms(engine, duration);
278 	if (duration != clamped)
279 		return -EINVAL;
280 
281 	WRITE_ONCE(engine->props.stop_timeout_ms, duration);
282 	return count;
283 }
284 
285 static ssize_t
stop_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)286 stop_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
287 {
288 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
289 
290 	return sprintf(buf, "%lu\n", engine->props.stop_timeout_ms);
291 }
292 
293 static struct kobj_attribute stop_timeout_attr =
294 __ATTR(stop_timeout_ms, 0644, stop_show, stop_store);
295 
296 static ssize_t
stop_default(struct kobject * kobj,struct kobj_attribute * attr,char * buf)297 stop_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
298 {
299 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
300 
301 	return sprintf(buf, "%lu\n", engine->defaults.stop_timeout_ms);
302 }
303 
304 static struct kobj_attribute stop_timeout_def =
305 __ATTR(stop_timeout_ms, 0444, stop_default, NULL);
306 
307 static ssize_t
preempt_timeout_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)308 preempt_timeout_store(struct kobject *kobj, struct kobj_attribute *attr,
309 		      const char *buf, size_t count)
310 {
311 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
312 	unsigned long long timeout, clamped;
313 	int err;
314 
315 	/*
316 	 * After initialising a preemption request, we give the current
317 	 * resident a small amount of time to vacate the GPU. The preemption
318 	 * request is for a higher priority context and should be immediate to
319 	 * maintain high quality of service (and avoid priority inversion).
320 	 * However, the preemption granularity of the GPU can be quite coarse
321 	 * and so we need a compromise.
322 	 */
323 
324 	err = kstrtoull(buf, 0, &timeout);
325 	if (err)
326 		return err;
327 
328 	clamped = intel_clamp_preempt_timeout_ms(engine, timeout);
329 	if (timeout != clamped)
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
preempt_timeout_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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
preempt_timeout_default(struct kobject * kobj,struct kobj_attribute * attr,char * buf)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
heartbeat_store(struct kobject * kobj,struct kobj_attribute * attr,const char * buf,size_t count)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, clamped;
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 	clamped = intel_clamp_heartbeat_interval_ms(engine, delay);
387 	if (delay != clamped)
388 		return -EINVAL;
389 
390 	err = intel_engine_set_heartbeat(engine, delay);
391 	if (err)
392 		return err;
393 
394 	return count;
395 }
396 
397 static ssize_t
heartbeat_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)398 heartbeat_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
399 {
400 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
401 
402 	return sprintf(buf, "%lu\n", engine->props.heartbeat_interval_ms);
403 }
404 
405 static struct kobj_attribute heartbeat_interval_attr =
406 __ATTR(heartbeat_interval_ms, 0644, heartbeat_show, heartbeat_store);
407 
408 static ssize_t
heartbeat_default(struct kobject * kobj,struct kobj_attribute * attr,char * buf)409 heartbeat_default(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
410 {
411 	struct intel_engine_cs *engine = kobj_to_engine(kobj);
412 
413 	return sprintf(buf, "%lu\n", engine->defaults.heartbeat_interval_ms);
414 }
415 
416 static struct kobj_attribute heartbeat_interval_def =
417 __ATTR(heartbeat_interval_ms, 0444, heartbeat_default, NULL);
418 
kobj_engine_release(struct kobject * kobj)419 static void kobj_engine_release(struct kobject *kobj)
420 {
421 	kfree(kobj);
422 }
423 
424 static struct kobj_type kobj_engine_type = {
425 	.release = kobj_engine_release,
426 	.sysfs_ops = &kobj_sysfs_ops
427 };
428 
429 static struct kobject *
kobj_engine(struct kobject * dir,struct intel_engine_cs * engine)430 kobj_engine(struct kobject *dir, struct intel_engine_cs *engine)
431 {
432 	struct kobj_engine *ke;
433 
434 	ke = kzalloc(sizeof(*ke), GFP_KERNEL);
435 	if (!ke)
436 		return NULL;
437 
438 	kobject_init(&ke->base, &kobj_engine_type);
439 	ke->engine = engine;
440 
441 	if (kobject_add(&ke->base, dir, "%s", engine->name)) {
442 		kobject_put(&ke->base);
443 		return NULL;
444 	}
445 
446 	/* xfer ownership to sysfs tree */
447 	return &ke->base;
448 }
449 
add_defaults(struct kobj_engine * parent)450 static void add_defaults(struct kobj_engine *parent)
451 {
452 	static const struct attribute *files[] = {
453 		&max_spin_def.attr,
454 		&stop_timeout_def.attr,
455 #if CONFIG_DRM_I915_HEARTBEAT_INTERVAL
456 		&heartbeat_interval_def.attr,
457 #endif
458 		NULL
459 	};
460 	struct kobj_engine *ke;
461 
462 	ke = kzalloc(sizeof(*ke), GFP_KERNEL);
463 	if (!ke)
464 		return;
465 
466 	kobject_init(&ke->base, &kobj_engine_type);
467 	ke->engine = parent->engine;
468 
469 	if (kobject_add(&ke->base, &parent->base, "%s", ".defaults")) {
470 		kobject_put(&ke->base);
471 		return;
472 	}
473 
474 	if (sysfs_create_files(&ke->base, files))
475 		return;
476 
477 	if (intel_engine_has_timeslices(ke->engine) &&
478 	    sysfs_create_file(&ke->base, &timeslice_duration_def.attr))
479 		return;
480 
481 	if (intel_engine_has_preempt_reset(ke->engine) &&
482 	    sysfs_create_file(&ke->base, &preempt_timeout_def.attr))
483 		return;
484 }
485 
intel_engines_add_sysfs(struct drm_i915_private * i915)486 void intel_engines_add_sysfs(struct drm_i915_private *i915)
487 {
488 	static const struct attribute *files[] = {
489 		&name_attr.attr,
490 		&class_attr.attr,
491 		&inst_attr.attr,
492 		&mmio_attr.attr,
493 		&caps_attr.attr,
494 		&all_caps_attr.attr,
495 		&max_spin_attr.attr,
496 		&stop_timeout_attr.attr,
497 #if CONFIG_DRM_I915_HEARTBEAT_INTERVAL
498 		&heartbeat_interval_attr.attr,
499 #endif
500 		NULL
501 	};
502 
503 	struct device *kdev = i915->drm.primary->kdev;
504 	struct intel_engine_cs *engine;
505 	struct kobject *dir;
506 
507 	dir = kobject_create_and_add("engine", &kdev->kobj);
508 	if (!dir)
509 		return;
510 
511 	for_each_uabi_engine(engine, i915) {
512 		struct kobject *kobj;
513 
514 		kobj = kobj_engine(dir, engine);
515 		if (!kobj)
516 			goto err_engine;
517 
518 		if (sysfs_create_files(kobj, files))
519 			goto err_object;
520 
521 		if (intel_engine_has_timeslices(engine) &&
522 		    sysfs_create_file(kobj, &timeslice_duration_attr.attr))
523 			goto err_engine;
524 
525 		if (intel_engine_has_preempt_reset(engine) &&
526 		    sysfs_create_file(kobj, &preempt_timeout_attr.attr))
527 			goto err_engine;
528 
529 		add_defaults(container_of(kobj, struct kobj_engine, base));
530 
531 		if (0) {
532 err_object:
533 			kobject_put(kobj);
534 err_engine:
535 			dev_err(kdev, "Failed to add sysfs engine '%s'\n",
536 				engine->name);
537 			break;
538 		}
539 	}
540 }
541