Branch data Line data Source code
1 : : /*
2 : : * SPDX-License-Identifier: MIT
3 : : *
4 : : * Copyright © 2019 Intel Corporation
5 : : */
6 : :
7 : : #include <linux/list.h>
8 : : #include <linux/list_sort.h>
9 : : #include <linux/llist.h>
10 : :
11 : : #include "i915_drv.h"
12 : : #include "intel_engine.h"
13 : : #include "intel_engine_user.h"
14 : : #include "intel_gt.h"
15 : :
16 : : struct intel_engine_cs *
17 : 0 : intel_engine_lookup_user(struct drm_i915_private *i915, u8 class, u8 instance)
18 : : {
19 : 0 : struct rb_node *p = i915->uabi_engines.rb_node;
20 : :
21 [ # # ]: 0 : while (p) {
22 : 0 : struct intel_engine_cs *it =
23 : 0 : rb_entry(p, typeof(*it), uabi_node);
24 : :
25 [ # # ]: 0 : if (class < it->uabi_class)
26 : 0 : p = p->rb_left;
27 [ # # ]: 0 : else if (class > it->uabi_class ||
28 [ # # ]: 0 : instance > it->uabi_instance)
29 : 0 : p = p->rb_right;
30 [ # # ]: 0 : else if (instance < it->uabi_instance)
31 : 0 : p = p->rb_left;
32 : : else
33 : 0 : return it;
34 : : }
35 : :
36 : : return NULL;
37 : : }
38 : :
39 : 0 : void intel_engine_add_user(struct intel_engine_cs *engine)
40 : : {
41 : 0 : llist_add((struct llist_node *)&engine->uabi_node,
42 : 0 : (struct llist_head *)&engine->i915->uabi_engines);
43 : 0 : }
44 : :
45 : : static const u8 uabi_classes[] = {
46 : : [RENDER_CLASS] = I915_ENGINE_CLASS_RENDER,
47 : : [COPY_ENGINE_CLASS] = I915_ENGINE_CLASS_COPY,
48 : : [VIDEO_DECODE_CLASS] = I915_ENGINE_CLASS_VIDEO,
49 : : [VIDEO_ENHANCEMENT_CLASS] = I915_ENGINE_CLASS_VIDEO_ENHANCE,
50 : : };
51 : :
52 : 0 : static int engine_cmp(void *priv, struct list_head *A, struct list_head *B)
53 : : {
54 : 0 : const struct intel_engine_cs *a =
55 : 0 : container_of((struct rb_node *)A, typeof(*a), uabi_node);
56 : 0 : const struct intel_engine_cs *b =
57 : 0 : container_of((struct rb_node *)B, typeof(*b), uabi_node);
58 : :
59 [ # # ]: 0 : if (uabi_classes[a->class] < uabi_classes[b->class])
60 : : return -1;
61 [ # # ]: 0 : if (uabi_classes[a->class] > uabi_classes[b->class])
62 : : return 1;
63 : :
64 [ # # ]: 0 : if (a->instance < b->instance)
65 : : return -1;
66 [ # # ]: 0 : if (a->instance > b->instance)
67 : 0 : return 1;
68 : :
69 : : return 0;
70 : : }
71 : :
72 : 0 : static struct llist_node *get_engines(struct drm_i915_private *i915)
73 : : {
74 : 0 : return llist_del_all((struct llist_head *)&i915->uabi_engines);
75 : : }
76 : :
77 : 0 : static void sort_engines(struct drm_i915_private *i915,
78 : : struct list_head *engines)
79 : : {
80 : 0 : struct llist_node *pos, *next;
81 : :
82 [ # # ]: 0 : llist_for_each_safe(pos, next, get_engines(i915)) {
83 : 0 : struct intel_engine_cs *engine =
84 : 0 : container_of((struct rb_node *)pos, typeof(*engine),
85 : : uabi_node);
86 : 0 : list_add((struct list_head *)&engine->uabi_node, engines);
87 : : }
88 : 0 : list_sort(NULL, engines, engine_cmp);
89 : 0 : }
90 : :
91 : 0 : static void set_scheduler_caps(struct drm_i915_private *i915)
92 : : {
93 : 0 : static const struct {
94 : : u8 engine;
95 : : u8 sched;
96 : : } map[] = {
97 : : #define MAP(x, y) { ilog2(I915_ENGINE_##x), ilog2(I915_SCHEDULER_CAP_##y) }
98 : : MAP(HAS_PREEMPTION, PREEMPTION),
99 : : MAP(HAS_SEMAPHORES, SEMAPHORES),
100 : : MAP(SUPPORTS_STATS, ENGINE_BUSY_STATS),
101 : : #undef MAP
102 : : };
103 : 0 : struct intel_engine_cs *engine;
104 : 0 : u32 enabled, disabled;
105 : :
106 : 0 : enabled = 0;
107 : 0 : disabled = 0;
108 [ # # # # : 0 : for_each_uabi_engine(engine, i915) { /* all engines must agree! */
# # ]
109 : 0 : int i;
110 : :
111 [ # # ]: 0 : if (engine->schedule)
112 : 0 : enabled |= (I915_SCHEDULER_CAP_ENABLED |
113 : : I915_SCHEDULER_CAP_PRIORITY);
114 : : else
115 : 0 : disabled |= (I915_SCHEDULER_CAP_ENABLED |
116 : : I915_SCHEDULER_CAP_PRIORITY);
117 : :
118 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(map); i++) {
119 [ # # ]: 0 : if (engine->flags & BIT(map[i].engine))
120 : 0 : enabled |= BIT(map[i].sched);
121 : : else
122 : 0 : disabled |= BIT(map[i].sched);
123 : : }
124 : : }
125 : :
126 : 0 : i915->caps.scheduler = enabled & ~disabled;
127 [ # # ]: 0 : if (!(i915->caps.scheduler & I915_SCHEDULER_CAP_ENABLED))
128 : 0 : i915->caps.scheduler = 0;
129 : 0 : }
130 : :
131 : 0 : const char *intel_engine_class_repr(u8 class)
132 : : {
133 : 0 : static const char * const uabi_names[] = {
134 : : [RENDER_CLASS] = "rcs",
135 : : [COPY_ENGINE_CLASS] = "bcs",
136 : : [VIDEO_DECODE_CLASS] = "vcs",
137 : : [VIDEO_ENHANCEMENT_CLASS] = "vecs",
138 : : };
139 : :
140 [ # # # # : 0 : if (class >= ARRAY_SIZE(uabi_names) || !uabi_names[class])
# # ]
141 : 0 : return "xxx";
142 : :
143 : : return uabi_names[class];
144 : : }
145 : :
146 : : struct legacy_ring {
147 : : struct intel_gt *gt;
148 : : u8 class;
149 : : u8 instance;
150 : : };
151 : :
152 : 0 : static int legacy_ring_idx(const struct legacy_ring *ring)
153 : : {
154 : 0 : static const struct {
155 : : u8 base, max;
156 : : } map[] = {
157 : : [RENDER_CLASS] = { RCS0, 1 },
158 : : [COPY_ENGINE_CLASS] = { BCS0, 1 },
159 : : [VIDEO_DECODE_CLASS] = { VCS0, I915_MAX_VCS },
160 : : [VIDEO_ENHANCEMENT_CLASS] = { VECS0, I915_MAX_VECS },
161 : : };
162 : :
163 : 0 : if (GEM_DEBUG_WARN_ON(ring->class >= ARRAY_SIZE(map)))
164 : : return INVALID_ENGINE;
165 : :
166 : 0 : if (GEM_DEBUG_WARN_ON(ring->instance >= map[ring->class].max))
167 : : return INVALID_ENGINE;
168 : :
169 : 0 : return map[ring->class].base + ring->instance;
170 : : }
171 : :
172 : 0 : static void add_legacy_ring(struct legacy_ring *ring,
173 : : struct intel_engine_cs *engine)
174 : : {
175 [ # # ]: 0 : if (engine->gt != ring->gt || engine->class != ring->class) {
176 : 0 : ring->gt = engine->gt;
177 : 0 : ring->class = engine->class;
178 : 0 : ring->instance = 0;
179 : : }
180 : :
181 : 0 : engine->legacy_idx = legacy_ring_idx(ring);
182 : 0 : if (engine->legacy_idx != INVALID_ENGINE)
183 : 0 : ring->instance++;
184 : : }
185 : :
186 : 0 : void intel_engines_driver_register(struct drm_i915_private *i915)
187 : : {
188 : 0 : struct legacy_ring ring = {};
189 : 0 : u8 uabi_instances[4] = {};
190 : 0 : struct list_head *it, *next;
191 : 0 : struct rb_node **p, *prev;
192 : 0 : LIST_HEAD(engines);
193 : :
194 : 0 : sort_engines(i915, &engines);
195 : :
196 : 0 : prev = NULL;
197 : 0 : p = &i915->uabi_engines.rb_node;
198 [ # # ]: 0 : list_for_each_safe(it, next, &engines) {
199 : 0 : struct intel_engine_cs *engine =
200 : 0 : container_of((struct rb_node *)it, typeof(*engine),
201 : : uabi_node);
202 : 0 : char old[sizeof(engine->name)];
203 : :
204 [ # # ]: 0 : if (intel_gt_has_init_error(engine->gt))
205 : 0 : continue; /* ignore incomplete engines */
206 : :
207 : 0 : GEM_BUG_ON(engine->class >= ARRAY_SIZE(uabi_classes));
208 : 0 : engine->uabi_class = uabi_classes[engine->class];
209 : :
210 : 0 : GEM_BUG_ON(engine->uabi_class >= ARRAY_SIZE(uabi_instances));
211 : 0 : engine->uabi_instance = uabi_instances[engine->uabi_class]++;
212 : :
213 : : /* Replace the internal name with the final user facing name */
214 : 0 : memcpy(old, engine->name, sizeof(engine->name));
215 : 0 : scnprintf(engine->name, sizeof(engine->name), "%s%u",
216 : 0 : intel_engine_class_repr(engine->class),
217 [ # # ]: 0 : engine->uabi_instance);
218 : 0 : DRM_DEBUG_DRIVER("renamed %s to %s\n", old, engine->name);
219 : :
220 : 0 : rb_link_node(&engine->uabi_node, prev, p);
221 : 0 : rb_insert_color(&engine->uabi_node, &i915->uabi_engines);
222 : :
223 : 0 : GEM_BUG_ON(intel_engine_lookup_user(i915,
224 : : engine->uabi_class,
225 : : engine->uabi_instance) != engine);
226 : :
227 : : /* Fix up the mapping to match default execbuf::user_map[] */
228 [ # # ]: 0 : add_legacy_ring(&ring, engine);
229 : :
230 : 0 : prev = &engine->uabi_node;
231 : 0 : p = &prev->rb_right;
232 : : }
233 : :
234 : 0 : if (IS_ENABLED(CONFIG_DRM_I915_SELFTESTS) &&
235 : : IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)) {
236 : : struct intel_engine_cs *engine;
237 : : unsigned int isolation;
238 : : int class, inst;
239 : : int errors = 0;
240 : :
241 : : for (class = 0; class < ARRAY_SIZE(uabi_instances); class++) {
242 : : for (inst = 0; inst < uabi_instances[class]; inst++) {
243 : : engine = intel_engine_lookup_user(i915,
244 : : class, inst);
245 : : if (!engine) {
246 : : pr_err("UABI engine not found for { class:%d, instance:%d }\n",
247 : : class, inst);
248 : : errors++;
249 : : continue;
250 : : }
251 : :
252 : : if (engine->uabi_class != class ||
253 : : engine->uabi_instance != inst) {
254 : : pr_err("Wrong UABI engine:%s { class:%d, instance:%d } found for { class:%d, instance:%d }\n",
255 : : engine->name,
256 : : engine->uabi_class,
257 : : engine->uabi_instance,
258 : : class, inst);
259 : : errors++;
260 : : continue;
261 : : }
262 : : }
263 : : }
264 : :
265 : : /*
266 : : * Make sure that classes with multiple engine instances all
267 : : * share the same basic configuration.
268 : : */
269 : : isolation = intel_engines_has_context_isolation(i915);
270 : : for_each_uabi_engine(engine, i915) {
271 : : unsigned int bit = BIT(engine->uabi_class);
272 : : unsigned int expected = engine->default_state ? bit : 0;
273 : :
274 : : if ((isolation & bit) != expected) {
275 : : pr_err("mismatching default context state for class %d on engine %s\n",
276 : : engine->uabi_class, engine->name);
277 : : errors++;
278 : : }
279 : : }
280 : :
281 : : if (WARN(errors, "Invalid UABI engine mapping found"))
282 : : i915->uabi_engines = RB_ROOT;
283 : : }
284 : :
285 : 0 : set_scheduler_caps(i915);
286 : 0 : }
287 : :
288 : 0 : unsigned int intel_engines_has_context_isolation(struct drm_i915_private *i915)
289 : : {
290 : 0 : struct intel_engine_cs *engine;
291 : 0 : unsigned int which;
292 : :
293 : 0 : which = 0;
294 [ # # # # : 0 : for_each_uabi_engine(engine, i915)
# # ]
295 [ # # ]: 0 : if (engine->default_state)
296 : 0 : which |= BIT(engine->uabi_class);
297 : :
298 : 0 : return which;
299 : : }
|
