Branch data Line data Source code
1 : : /*
2 : : * Copyright © 2008-2010 Intel Corporation
3 : : *
4 : : * Permission is hereby granted, free of charge, to any person obtaining a
5 : : * copy of this software and associated documentation files (the "Software"),
6 : : * to deal in the Software without restriction, including without limitation
7 : : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 : : * and/or sell copies of the Software, and to permit persons to whom the
9 : : * Software is furnished to do so, subject to the following conditions:
10 : : *
11 : : * The above copyright notice and this permission notice (including the next
12 : : * paragraph) shall be included in all copies or substantial portions of the
13 : : * Software.
14 : : *
15 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 : : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 : : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 : : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 : : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 : : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 : : * IN THE SOFTWARE.
22 : : *
23 : : * Authors:
24 : : * Eric Anholt <eric@anholt.net>
25 : : * Zou Nan hai <nanhai.zou@intel.com>
26 : : * Xiang Hai hao<haihao.xiang@intel.com>
27 : : *
28 : : */
29 : :
30 : : #include <linux/log2.h>
31 : :
32 : : #include <drm/i915_drm.h>
33 : :
34 : : #include "gem/i915_gem_context.h"
35 : :
36 : : #include "gen6_ppgtt.h"
37 : : #include "i915_drv.h"
38 : : #include "i915_trace.h"
39 : : #include "intel_context.h"
40 : : #include "intel_gt.h"
41 : : #include "intel_gt_irq.h"
42 : : #include "intel_gt_pm_irq.h"
43 : : #include "intel_reset.h"
44 : : #include "intel_ring.h"
45 : : #include "intel_workarounds.h"
46 : :
47 : : /* Rough estimate of the typical request size, performing a flush,
48 : : * set-context and then emitting the batch.
49 : : */
50 : : #define LEGACY_REQUEST_SIZE 200
51 : :
52 : : static int
53 : 0 : gen2_render_ring_flush(struct i915_request *rq, u32 mode)
54 : : {
55 : 0 : unsigned int num_store_dw;
56 : 0 : u32 cmd, *cs;
57 : :
58 : 0 : cmd = MI_FLUSH;
59 : 0 : num_store_dw = 0;
60 : 0 : if (mode & EMIT_INVALIDATE)
61 : : cmd |= MI_READ_FLUSH;
62 [ # # ]: 0 : if (mode & EMIT_FLUSH)
63 : 0 : num_store_dw = 4;
64 : :
65 : 0 : cs = intel_ring_begin(rq, 2 + 3 * num_store_dw);
66 [ # # ]: 0 : if (IS_ERR(cs))
67 : 0 : return PTR_ERR(cs);
68 : :
69 : 0 : *cs++ = cmd;
70 [ # # ]: 0 : while (num_store_dw--) {
71 : 0 : *cs++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL;
72 : 0 : *cs++ = intel_gt_scratch_offset(rq->engine->gt,
73 : : INTEL_GT_SCRATCH_FIELD_DEFAULT);
74 : 0 : *cs++ = 0;
75 : : }
76 : 0 : *cs++ = MI_FLUSH | MI_NO_WRITE_FLUSH;
77 : :
78 : 0 : intel_ring_advance(rq, cs);
79 : :
80 : 0 : return 0;
81 : : }
82 : :
83 : : static int
84 : 0 : gen4_render_ring_flush(struct i915_request *rq, u32 mode)
85 : : {
86 : 0 : u32 cmd, *cs;
87 : 0 : int i;
88 : :
89 : : /*
90 : : * read/write caches:
91 : : *
92 : : * I915_GEM_DOMAIN_RENDER is always invalidated, but is
93 : : * only flushed if MI_NO_WRITE_FLUSH is unset. On 965, it is
94 : : * also flushed at 2d versus 3d pipeline switches.
95 : : *
96 : : * read-only caches:
97 : : *
98 : : * I915_GEM_DOMAIN_SAMPLER is flushed on pre-965 if
99 : : * MI_READ_FLUSH is set, and is always flushed on 965.
100 : : *
101 : : * I915_GEM_DOMAIN_COMMAND may not exist?
102 : : *
103 : : * I915_GEM_DOMAIN_INSTRUCTION, which exists on 965, is
104 : : * invalidated when MI_EXE_FLUSH is set.
105 : : *
106 : : * I915_GEM_DOMAIN_VERTEX, which exists on 965, is
107 : : * invalidated with every MI_FLUSH.
108 : : *
109 : : * TLBs:
110 : : *
111 : : * On 965, TLBs associated with I915_GEM_DOMAIN_COMMAND
112 : : * and I915_GEM_DOMAIN_CPU in are invalidated at PTE write and
113 : : * I915_GEM_DOMAIN_RENDER and I915_GEM_DOMAIN_SAMPLER
114 : : * are flushed at any MI_FLUSH.
115 : : */
116 : :
117 : 0 : cmd = MI_FLUSH;
118 [ # # ]: 0 : if (mode & EMIT_INVALIDATE) {
119 : 0 : cmd |= MI_EXE_FLUSH;
120 [ # # # # : 0 : if (IS_G4X(rq->i915) || IS_GEN(rq->i915, 5))
# # ]
121 : : cmd |= MI_INVALIDATE_ISP;
122 : : }
123 : :
124 : 0 : i = 2;
125 [ # # ]: 0 : if (mode & EMIT_INVALIDATE)
126 : 0 : i += 20;
127 : :
128 : 0 : cs = intel_ring_begin(rq, i);
129 [ # # ]: 0 : if (IS_ERR(cs))
130 : 0 : return PTR_ERR(cs);
131 : :
132 : 0 : *cs++ = cmd;
133 : :
134 : : /*
135 : : * A random delay to let the CS invalidate take effect? Without this
136 : : * delay, the GPU relocation path fails as the CS does not see
137 : : * the updated contents. Just as important, if we apply the flushes
138 : : * to the EMIT_FLUSH branch (i.e. immediately after the relocation
139 : : * write and before the invalidate on the next batch), the relocations
140 : : * still fail. This implies that is a delay following invalidation
141 : : * that is required to reset the caches as opposed to a delay to
142 : : * ensure the memory is written.
143 : : */
144 [ # # ]: 0 : if (mode & EMIT_INVALIDATE) {
145 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4) | PIPE_CONTROL_QW_WRITE;
146 : 0 : *cs++ = intel_gt_scratch_offset(rq->engine->gt,
147 : 0 : INTEL_GT_SCRATCH_FIELD_DEFAULT) |
148 : : PIPE_CONTROL_GLOBAL_GTT;
149 : 0 : *cs++ = 0;
150 : 0 : *cs++ = 0;
151 : :
152 [ # # ]: 0 : for (i = 0; i < 12; i++)
153 : 0 : *cs++ = MI_FLUSH;
154 : :
155 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4) | PIPE_CONTROL_QW_WRITE;
156 : 0 : *cs++ = intel_gt_scratch_offset(rq->engine->gt,
157 : 0 : INTEL_GT_SCRATCH_FIELD_DEFAULT) |
158 : : PIPE_CONTROL_GLOBAL_GTT;
159 : 0 : *cs++ = 0;
160 : 0 : *cs++ = 0;
161 : : }
162 : :
163 : 0 : *cs++ = cmd;
164 : :
165 : 0 : intel_ring_advance(rq, cs);
166 : :
167 : 0 : return 0;
168 : : }
169 : :
170 : : /*
171 : : * Emits a PIPE_CONTROL with a non-zero post-sync operation, for
172 : : * implementing two workarounds on gen6. From section 1.4.7.1
173 : : * "PIPE_CONTROL" of the Sandy Bridge PRM volume 2 part 1:
174 : : *
175 : : * [DevSNB-C+{W/A}] Before any depth stall flush (including those
176 : : * produced by non-pipelined state commands), software needs to first
177 : : * send a PIPE_CONTROL with no bits set except Post-Sync Operation !=
178 : : * 0.
179 : : *
180 : : * [Dev-SNB{W/A}]: Before a PIPE_CONTROL with Write Cache Flush Enable
181 : : * =1, a PIPE_CONTROL with any non-zero post-sync-op is required.
182 : : *
183 : : * And the workaround for these two requires this workaround first:
184 : : *
185 : : * [Dev-SNB{W/A}]: Pipe-control with CS-stall bit set must be sent
186 : : * BEFORE the pipe-control with a post-sync op and no write-cache
187 : : * flushes.
188 : : *
189 : : * And this last workaround is tricky because of the requirements on
190 : : * that bit. From section 1.4.7.2.3 "Stall" of the Sandy Bridge PRM
191 : : * volume 2 part 1:
192 : : *
193 : : * "1 of the following must also be set:
194 : : * - Render Target Cache Flush Enable ([12] of DW1)
195 : : * - Depth Cache Flush Enable ([0] of DW1)
196 : : * - Stall at Pixel Scoreboard ([1] of DW1)
197 : : * - Depth Stall ([13] of DW1)
198 : : * - Post-Sync Operation ([13] of DW1)
199 : : * - Notify Enable ([8] of DW1)"
200 : : *
201 : : * The cache flushes require the workaround flush that triggered this
202 : : * one, so we can't use it. Depth stall would trigger the same.
203 : : * Post-sync nonzero is what triggered this second workaround, so we
204 : : * can't use that one either. Notify enable is IRQs, which aren't
205 : : * really our business. That leaves only stall at scoreboard.
206 : : */
207 : : static int
208 : 0 : gen6_emit_post_sync_nonzero_flush(struct i915_request *rq)
209 : : {
210 : 0 : u32 scratch_addr =
211 : 0 : intel_gt_scratch_offset(rq->engine->gt,
212 : : INTEL_GT_SCRATCH_FIELD_RENDER_FLUSH);
213 : 0 : u32 *cs;
214 : :
215 : 0 : cs = intel_ring_begin(rq, 6);
216 [ # # ]: 0 : if (IS_ERR(cs))
217 : 0 : return PTR_ERR(cs);
218 : :
219 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(5);
220 : 0 : *cs++ = PIPE_CONTROL_CS_STALL | PIPE_CONTROL_STALL_AT_SCOREBOARD;
221 : 0 : *cs++ = scratch_addr | PIPE_CONTROL_GLOBAL_GTT;
222 : 0 : *cs++ = 0; /* low dword */
223 : 0 : *cs++ = 0; /* high dword */
224 : 0 : *cs++ = MI_NOOP;
225 : 0 : intel_ring_advance(rq, cs);
226 : :
227 : 0 : cs = intel_ring_begin(rq, 6);
228 [ # # ]: 0 : if (IS_ERR(cs))
229 : 0 : return PTR_ERR(cs);
230 : :
231 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(5);
232 : 0 : *cs++ = PIPE_CONTROL_QW_WRITE;
233 : 0 : *cs++ = scratch_addr | PIPE_CONTROL_GLOBAL_GTT;
234 : 0 : *cs++ = 0;
235 : 0 : *cs++ = 0;
236 : 0 : *cs++ = MI_NOOP;
237 : 0 : intel_ring_advance(rq, cs);
238 : :
239 : 0 : return 0;
240 : : }
241 : :
242 : : static int
243 : 0 : gen6_render_ring_flush(struct i915_request *rq, u32 mode)
244 : : {
245 : 0 : u32 scratch_addr =
246 : 0 : intel_gt_scratch_offset(rq->engine->gt,
247 : : INTEL_GT_SCRATCH_FIELD_RENDER_FLUSH);
248 : 0 : u32 *cs, flags = 0;
249 : 0 : int ret;
250 : :
251 : : /* Force SNB workarounds for PIPE_CONTROL flushes */
252 : 0 : ret = gen6_emit_post_sync_nonzero_flush(rq);
253 [ # # ]: 0 : if (ret)
254 : : return ret;
255 : :
256 : : /* Just flush everything. Experiments have shown that reducing the
257 : : * number of bits based on the write domains has little performance
258 : : * impact.
259 : : */
260 [ # # ]: 0 : if (mode & EMIT_FLUSH) {
261 : 0 : flags |= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;
262 : 0 : flags |= PIPE_CONTROL_DEPTH_CACHE_FLUSH;
263 : : /*
264 : : * Ensure that any following seqno writes only happen
265 : : * when the render cache is indeed flushed.
266 : : */
267 : 0 : flags |= PIPE_CONTROL_CS_STALL;
268 : : }
269 [ # # ]: 0 : if (mode & EMIT_INVALIDATE) {
270 : 0 : flags |= PIPE_CONTROL_TLB_INVALIDATE;
271 : 0 : flags |= PIPE_CONTROL_INSTRUCTION_CACHE_INVALIDATE;
272 : 0 : flags |= PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE;
273 : 0 : flags |= PIPE_CONTROL_VF_CACHE_INVALIDATE;
274 : 0 : flags |= PIPE_CONTROL_CONST_CACHE_INVALIDATE;
275 : 0 : flags |= PIPE_CONTROL_STATE_CACHE_INVALIDATE;
276 : : /*
277 : : * TLB invalidate requires a post-sync write.
278 : : */
279 : 0 : flags |= PIPE_CONTROL_QW_WRITE | PIPE_CONTROL_CS_STALL;
280 : : }
281 : :
282 : 0 : cs = intel_ring_begin(rq, 4);
283 [ # # ]: 0 : if (IS_ERR(cs))
284 : 0 : return PTR_ERR(cs);
285 : :
286 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4);
287 : 0 : *cs++ = flags;
288 : 0 : *cs++ = scratch_addr | PIPE_CONTROL_GLOBAL_GTT;
289 : 0 : *cs++ = 0;
290 : 0 : intel_ring_advance(rq, cs);
291 : :
292 : 0 : return 0;
293 : : }
294 : :
295 : 0 : static u32 *gen6_rcs_emit_breadcrumb(struct i915_request *rq, u32 *cs)
296 : : {
297 : : /* First we do the gen6_emit_post_sync_nonzero_flush w/a */
298 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4);
299 : 0 : *cs++ = PIPE_CONTROL_CS_STALL | PIPE_CONTROL_STALL_AT_SCOREBOARD;
300 : 0 : *cs++ = 0;
301 : 0 : *cs++ = 0;
302 : :
303 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4);
304 : 0 : *cs++ = PIPE_CONTROL_QW_WRITE;
305 : 0 : *cs++ = intel_gt_scratch_offset(rq->engine->gt,
306 : 0 : INTEL_GT_SCRATCH_FIELD_DEFAULT) |
307 : : PIPE_CONTROL_GLOBAL_GTT;
308 : 0 : *cs++ = 0;
309 : :
310 : : /* Finally we can flush and with it emit the breadcrumb */
311 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4);
312 : 0 : *cs++ = (PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH |
313 : : PIPE_CONTROL_DEPTH_CACHE_FLUSH |
314 : : PIPE_CONTROL_DC_FLUSH_ENABLE |
315 : : PIPE_CONTROL_QW_WRITE |
316 : : PIPE_CONTROL_CS_STALL);
317 : 0 : *cs++ = i915_request_active_timeline(rq)->hwsp_offset |
318 : : PIPE_CONTROL_GLOBAL_GTT;
319 : 0 : *cs++ = rq->fence.seqno;
320 : :
321 : 0 : *cs++ = MI_USER_INTERRUPT;
322 : 0 : *cs++ = MI_NOOP;
323 : :
324 : 0 : rq->tail = intel_ring_offset(rq, cs);
325 : 0 : assert_ring_tail_valid(rq->ring, rq->tail);
326 : :
327 : 0 : return cs;
328 : : }
329 : :
330 : : static int
331 : 0 : gen7_render_ring_cs_stall_wa(struct i915_request *rq)
332 : : {
333 : 0 : u32 *cs;
334 : :
335 : 0 : cs = intel_ring_begin(rq, 4);
336 [ # # ]: 0 : if (IS_ERR(cs))
337 : 0 : return PTR_ERR(cs);
338 : :
339 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4);
340 : 0 : *cs++ = PIPE_CONTROL_CS_STALL | PIPE_CONTROL_STALL_AT_SCOREBOARD;
341 : 0 : *cs++ = 0;
342 : 0 : *cs++ = 0;
343 : 0 : intel_ring_advance(rq, cs);
344 : :
345 : 0 : return 0;
346 : : }
347 : :
348 : : static int
349 : 0 : gen7_render_ring_flush(struct i915_request *rq, u32 mode)
350 : : {
351 : 0 : u32 scratch_addr =
352 [ # # ]: 0 : intel_gt_scratch_offset(rq->engine->gt,
353 : : INTEL_GT_SCRATCH_FIELD_RENDER_FLUSH);
354 : 0 : u32 *cs, flags = 0;
355 : :
356 : : /*
357 : : * Ensure that any following seqno writes only happen when the render
358 : : * cache is indeed flushed.
359 : : *
360 : : * Workaround: 4th PIPE_CONTROL command (except the ones with only
361 : : * read-cache invalidate bits set) must have the CS_STALL bit set. We
362 : : * don't try to be clever and just set it unconditionally.
363 : : */
364 : 0 : flags |= PIPE_CONTROL_CS_STALL;
365 : :
366 : : /*
367 : : * CS_STALL suggests at least a post-sync write.
368 : : */
369 : 0 : flags |= PIPE_CONTROL_QW_WRITE;
370 : 0 : flags |= PIPE_CONTROL_GLOBAL_GTT_IVB;
371 : :
372 : : /* Just flush everything. Experiments have shown that reducing the
373 : : * number of bits based on the write domains has little performance
374 : : * impact.
375 : : */
376 [ # # ]: 0 : if (mode & EMIT_FLUSH) {
377 : 0 : flags |= PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH;
378 : 0 : flags |= PIPE_CONTROL_DEPTH_CACHE_FLUSH;
379 : 0 : flags |= PIPE_CONTROL_DC_FLUSH_ENABLE;
380 : 0 : flags |= PIPE_CONTROL_FLUSH_ENABLE;
381 : : }
382 [ # # ]: 0 : if (mode & EMIT_INVALIDATE) {
383 : 0 : flags |= PIPE_CONTROL_TLB_INVALIDATE;
384 : 0 : flags |= PIPE_CONTROL_INSTRUCTION_CACHE_INVALIDATE;
385 : 0 : flags |= PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE;
386 : 0 : flags |= PIPE_CONTROL_VF_CACHE_INVALIDATE;
387 : 0 : flags |= PIPE_CONTROL_CONST_CACHE_INVALIDATE;
388 : 0 : flags |= PIPE_CONTROL_STATE_CACHE_INVALIDATE;
389 : 0 : flags |= PIPE_CONTROL_MEDIA_STATE_CLEAR;
390 : :
391 : : /* Workaround: we must issue a pipe_control with CS-stall bit
392 : : * set before a pipe_control command that has the state cache
393 : : * invalidate bit set. */
394 : 0 : gen7_render_ring_cs_stall_wa(rq);
395 : : }
396 : :
397 : 0 : cs = intel_ring_begin(rq, 4);
398 [ # # ]: 0 : if (IS_ERR(cs))
399 : 0 : return PTR_ERR(cs);
400 : :
401 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4);
402 : 0 : *cs++ = flags;
403 : 0 : *cs++ = scratch_addr;
404 : 0 : *cs++ = 0;
405 : 0 : intel_ring_advance(rq, cs);
406 : :
407 : 0 : return 0;
408 : : }
409 : :
410 : 0 : static u32 *gen7_rcs_emit_breadcrumb(struct i915_request *rq, u32 *cs)
411 : : {
412 : 0 : *cs++ = GFX_OP_PIPE_CONTROL(4);
413 : 0 : *cs++ = (PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH |
414 : : PIPE_CONTROL_DEPTH_CACHE_FLUSH |
415 : : PIPE_CONTROL_DC_FLUSH_ENABLE |
416 : : PIPE_CONTROL_FLUSH_ENABLE |
417 : : PIPE_CONTROL_QW_WRITE |
418 : : PIPE_CONTROL_GLOBAL_GTT_IVB |
419 : : PIPE_CONTROL_CS_STALL);
420 : 0 : *cs++ = i915_request_active_timeline(rq)->hwsp_offset;
421 : 0 : *cs++ = rq->fence.seqno;
422 : :
423 : 0 : *cs++ = MI_USER_INTERRUPT;
424 : 0 : *cs++ = MI_NOOP;
425 : :
426 : 0 : rq->tail = intel_ring_offset(rq, cs);
427 : 0 : assert_ring_tail_valid(rq->ring, rq->tail);
428 : :
429 : 0 : return cs;
430 : : }
431 : :
432 : 0 : static u32 *gen6_xcs_emit_breadcrumb(struct i915_request *rq, u32 *cs)
433 : : {
434 : 0 : GEM_BUG_ON(i915_request_active_timeline(rq)->hwsp_ggtt != rq->engine->status_page.vma);
435 : 0 : GEM_BUG_ON(offset_in_page(i915_request_active_timeline(rq)->hwsp_offset) != I915_GEM_HWS_SEQNO_ADDR);
436 : :
437 : 0 : *cs++ = MI_FLUSH_DW | MI_FLUSH_DW_OP_STOREDW | MI_FLUSH_DW_STORE_INDEX;
438 : 0 : *cs++ = I915_GEM_HWS_SEQNO_ADDR | MI_FLUSH_DW_USE_GTT;
439 : 0 : *cs++ = rq->fence.seqno;
440 : :
441 : 0 : *cs++ = MI_USER_INTERRUPT;
442 : :
443 : 0 : rq->tail = intel_ring_offset(rq, cs);
444 : 0 : assert_ring_tail_valid(rq->ring, rq->tail);
445 : :
446 : 0 : return cs;
447 : : }
448 : :
449 : : #define GEN7_XCS_WA 32
450 : 0 : static u32 *gen7_xcs_emit_breadcrumb(struct i915_request *rq, u32 *cs)
451 : : {
452 : 0 : int i;
453 : :
454 : 0 : GEM_BUG_ON(i915_request_active_timeline(rq)->hwsp_ggtt != rq->engine->status_page.vma);
455 : 0 : GEM_BUG_ON(offset_in_page(i915_request_active_timeline(rq)->hwsp_offset) != I915_GEM_HWS_SEQNO_ADDR);
456 : :
457 : 0 : *cs++ = MI_FLUSH_DW | MI_INVALIDATE_TLB |
458 : : MI_FLUSH_DW_OP_STOREDW | MI_FLUSH_DW_STORE_INDEX;
459 : 0 : *cs++ = I915_GEM_HWS_SEQNO_ADDR | MI_FLUSH_DW_USE_GTT;
460 : 0 : *cs++ = rq->fence.seqno;
461 : :
462 [ # # ]: 0 : for (i = 0; i < GEN7_XCS_WA; i++) {
463 : 0 : *cs++ = MI_STORE_DWORD_INDEX;
464 : 0 : *cs++ = I915_GEM_HWS_SEQNO_ADDR;
465 : 0 : *cs++ = rq->fence.seqno;
466 : : }
467 : :
468 : 0 : *cs++ = MI_FLUSH_DW;
469 : 0 : *cs++ = 0;
470 : 0 : *cs++ = 0;
471 : :
472 : 0 : *cs++ = MI_USER_INTERRUPT;
473 : 0 : *cs++ = MI_NOOP;
474 : :
475 : 0 : rq->tail = intel_ring_offset(rq, cs);
476 : 0 : assert_ring_tail_valid(rq->ring, rq->tail);
477 : :
478 : 0 : return cs;
479 : : }
480 : : #undef GEN7_XCS_WA
481 : :
482 : 0 : static void set_hwstam(struct intel_engine_cs *engine, u32 mask)
483 : : {
484 : : /*
485 : : * Keep the render interrupt unmasked as this papers over
486 : : * lost interrupts following a reset.
487 : : */
488 : 0 : if (engine->class == RENDER_CLASS) {
489 [ # # # # ]: 0 : if (INTEL_GEN(engine->i915) >= 6)
490 : : mask &= ~BIT(0);
491 : : else
492 : 0 : mask &= ~I915_USER_INTERRUPT;
493 : : }
494 : :
495 : 0 : intel_engine_set_hwsp_writemask(engine, mask);
496 : : }
497 : :
498 : 0 : static void set_hws_pga(struct intel_engine_cs *engine, phys_addr_t phys)
499 : : {
500 : 0 : u32 addr;
501 : :
502 : 0 : addr = lower_32_bits(phys);
503 [ # # ]: 0 : if (INTEL_GEN(engine->i915) >= 4)
504 : 0 : addr |= (phys >> 28) & 0xf0;
505 : :
506 : 0 : intel_uncore_write(engine->uncore, HWS_PGA, addr);
507 : : }
508 : :
509 : 0 : static struct page *status_page(struct intel_engine_cs *engine)
510 : : {
511 : 0 : struct drm_i915_gem_object *obj = engine->status_page.vma->obj;
512 : :
513 : 0 : GEM_BUG_ON(!i915_gem_object_has_pinned_pages(obj));
514 : 0 : return sg_page(obj->mm.pages->sgl);
515 : : }
516 : :
517 : 0 : static void ring_setup_phys_status_page(struct intel_engine_cs *engine)
518 : : {
519 [ # # ]: 0 : set_hws_pga(engine, PFN_PHYS(page_to_pfn(status_page(engine))));
520 [ # # ]: 0 : set_hwstam(engine, ~0u);
521 : 0 : }
522 : :
523 : 0 : static void set_hwsp(struct intel_engine_cs *engine, u32 offset)
524 : : {
525 : 0 : i915_reg_t hwsp;
526 : :
527 : : /*
528 : : * The ring status page addresses are no longer next to the rest of
529 : : * the ring registers as of gen7.
530 : : */
531 [ # # ]: 0 : if (IS_GEN(engine->i915, 7)) {
532 [ # # ]: 0 : switch (engine->id) {
533 : : /*
534 : : * No more rings exist on Gen7. Default case is only to shut up
535 : : * gcc switch check warning.
536 : : */
537 : : default:
538 : : GEM_BUG_ON(engine->id);
539 : : /* fallthrough */
540 : : case RCS0:
541 : : hwsp = RENDER_HWS_PGA_GEN7;
542 : : break;
543 : : case BCS0:
544 : : hwsp = BLT_HWS_PGA_GEN7;
545 : : break;
546 : : case VCS0:
547 : : hwsp = BSD_HWS_PGA_GEN7;
548 : : break;
549 : : case VECS0:
550 : : hwsp = VEBOX_HWS_PGA_GEN7;
551 : : break;
552 : : }
553 [ # # ]: 0 : } else if (IS_GEN(engine->i915, 6)) {
554 : 0 : hwsp = RING_HWS_PGA_GEN6(engine->mmio_base);
555 : : } else {
556 : 0 : hwsp = RING_HWS_PGA(engine->mmio_base);
557 : : }
558 : :
559 : 0 : intel_uncore_write(engine->uncore, hwsp, offset);
560 : 0 : intel_uncore_posting_read(engine->uncore, hwsp);
561 : 0 : }
562 : :
563 : 0 : static void flush_cs_tlb(struct intel_engine_cs *engine)
564 : : {
565 : 0 : struct drm_i915_private *dev_priv = engine->i915;
566 : :
567 [ # # ]: 0 : if (!IS_GEN_RANGE(dev_priv, 6, 7))
568 : : return;
569 : :
570 : : /* ring should be idle before issuing a sync flush*/
571 [ # # ]: 0 : WARN_ON((ENGINE_READ(engine, RING_MI_MODE) & MODE_IDLE) == 0);
572 : :
573 : 0 : ENGINE_WRITE(engine, RING_INSTPM,
574 : : _MASKED_BIT_ENABLE(INSTPM_TLB_INVALIDATE |
575 : : INSTPM_SYNC_FLUSH));
576 [ # # ]: 0 : if (intel_wait_for_register(engine->uncore,
577 : 0 : RING_INSTPM(engine->mmio_base),
578 : : INSTPM_SYNC_FLUSH, 0,
579 : : 1000))
580 : 0 : DRM_ERROR("%s: wait for SyncFlush to complete for TLB invalidation timed out\n",
581 : : engine->name);
582 : : }
583 : :
584 : 0 : static void ring_setup_status_page(struct intel_engine_cs *engine)
585 : : {
586 : 0 : set_hwsp(engine, i915_ggtt_offset(engine->status_page.vma));
587 [ # # ]: 0 : set_hwstam(engine, ~0u);
588 : :
589 : 0 : flush_cs_tlb(engine);
590 : 0 : }
591 : :
592 : 0 : static bool stop_ring(struct intel_engine_cs *engine)
593 : : {
594 : 0 : struct drm_i915_private *dev_priv = engine->i915;
595 : :
596 [ # # ]: 0 : if (INTEL_GEN(dev_priv) > 2) {
597 : 0 : ENGINE_WRITE(engine,
598 : : RING_MI_MODE, _MASKED_BIT_ENABLE(STOP_RING));
599 [ # # ]: 0 : if (intel_wait_for_register(engine->uncore,
600 : 0 : RING_MI_MODE(engine->mmio_base),
601 : : MODE_IDLE,
602 : : MODE_IDLE,
603 : : 1000)) {
604 : 0 : DRM_ERROR("%s : timed out trying to stop ring\n",
605 : : engine->name);
606 : :
607 : : /*
608 : : * Sometimes we observe that the idle flag is not
609 : : * set even though the ring is empty. So double
610 : : * check before giving up.
611 : : */
612 : 0 : if (ENGINE_READ(engine, RING_HEAD) !=
613 [ # # ]: 0 : ENGINE_READ(engine, RING_TAIL))
614 : : return false;
615 : : }
616 : : }
617 : :
618 : 0 : ENGINE_WRITE(engine, RING_HEAD, ENGINE_READ(engine, RING_TAIL));
619 : :
620 : 0 : ENGINE_WRITE(engine, RING_HEAD, 0);
621 : 0 : ENGINE_WRITE(engine, RING_TAIL, 0);
622 : :
623 : : /* The ring must be empty before it is disabled */
624 : 0 : ENGINE_WRITE(engine, RING_CTL, 0);
625 : :
626 : 0 : return (ENGINE_READ(engine, RING_HEAD) & HEAD_ADDR) == 0;
627 : : }
628 : :
629 : 0 : static int xcs_resume(struct intel_engine_cs *engine)
630 : : {
631 : 0 : struct drm_i915_private *dev_priv = engine->i915;
632 : 0 : struct intel_ring *ring = engine->legacy.ring;
633 : 0 : int ret = 0;
634 : :
635 : 0 : ENGINE_TRACE(engine, "ring:{HEAD:%04x, TAIL:%04x}\n",
636 : : ring->head, ring->tail);
637 : :
638 : 0 : intel_uncore_forcewake_get(engine->uncore, FORCEWAKE_ALL);
639 : :
640 : : /* WaClearRingBufHeadRegAtInit:ctg,elk */
641 [ # # ]: 0 : if (!stop_ring(engine)) {
642 : : /* G45 ring initialization often fails to reset head to zero */
643 : 0 : DRM_DEBUG_DRIVER("%s head not reset to zero "
644 : : "ctl %08x head %08x tail %08x start %08x\n",
645 : : engine->name,
646 : : ENGINE_READ(engine, RING_CTL),
647 : : ENGINE_READ(engine, RING_HEAD),
648 : : ENGINE_READ(engine, RING_TAIL),
649 : : ENGINE_READ(engine, RING_START));
650 : :
651 [ # # ]: 0 : if (!stop_ring(engine)) {
652 : 0 : DRM_ERROR("failed to set %s head to zero "
653 : : "ctl %08x head %08x tail %08x start %08x\n",
654 : : engine->name,
655 : : ENGINE_READ(engine, RING_CTL),
656 : : ENGINE_READ(engine, RING_HEAD),
657 : : ENGINE_READ(engine, RING_TAIL),
658 : : ENGINE_READ(engine, RING_START));
659 : 0 : ret = -EIO;
660 : 0 : goto out;
661 : : }
662 : : }
663 : :
664 [ # # ]: 0 : if (HWS_NEEDS_PHYSICAL(dev_priv))
665 : 0 : ring_setup_phys_status_page(engine);
666 : : else
667 : 0 : ring_setup_status_page(engine);
668 : :
669 : 0 : intel_engine_reset_breadcrumbs(engine);
670 : :
671 : : /* Enforce ordering by reading HEAD register back */
672 : 0 : ENGINE_POSTING_READ(engine, RING_HEAD);
673 : :
674 : : /*
675 : : * Initialize the ring. This must happen _after_ we've cleared the ring
676 : : * registers with the above sequence (the readback of the HEAD registers
677 : : * also enforces ordering), otherwise the hw might lose the new ring
678 : : * register values.
679 : : */
680 : 0 : ENGINE_WRITE(engine, RING_START, i915_ggtt_offset(ring->vma));
681 : :
682 : : /* Check that the ring offsets point within the ring! */
683 : 0 : GEM_BUG_ON(!intel_ring_offset_valid(ring, ring->head));
684 : 0 : GEM_BUG_ON(!intel_ring_offset_valid(ring, ring->tail));
685 : 0 : intel_ring_update_space(ring);
686 : :
687 : : /* First wake the ring up to an empty/idle ring */
688 : 0 : ENGINE_WRITE(engine, RING_HEAD, ring->head);
689 : 0 : ENGINE_WRITE(engine, RING_TAIL, ring->head);
690 : 0 : ENGINE_POSTING_READ(engine, RING_TAIL);
691 : :
692 : 0 : ENGINE_WRITE(engine, RING_CTL, RING_CTL_SIZE(ring->size) | RING_VALID);
693 : :
694 : : /* If the head is still not zero, the ring is dead */
695 [ # # ]: 0 : if (intel_wait_for_register(engine->uncore,
696 : 0 : RING_CTL(engine->mmio_base),
697 : : RING_VALID, RING_VALID,
698 : : 50)) {
699 : 0 : DRM_ERROR("%s initialization failed "
700 : : "ctl %08x (valid? %d) head %08x [%08x] tail %08x [%08x] start %08x [expected %08x]\n",
701 : : engine->name,
702 : : ENGINE_READ(engine, RING_CTL),
703 : : ENGINE_READ(engine, RING_CTL) & RING_VALID,
704 : : ENGINE_READ(engine, RING_HEAD), ring->head,
705 : : ENGINE_READ(engine, RING_TAIL), ring->tail,
706 : : ENGINE_READ(engine, RING_START),
707 : : i915_ggtt_offset(ring->vma));
708 : 0 : ret = -EIO;
709 : 0 : goto out;
710 : : }
711 : :
712 [ # # ]: 0 : if (INTEL_GEN(dev_priv) > 2)
713 : 0 : ENGINE_WRITE(engine,
714 : : RING_MI_MODE, _MASKED_BIT_DISABLE(STOP_RING));
715 : :
716 : : /* Now awake, let it get started */
717 [ # # ]: 0 : if (ring->tail != ring->head) {
718 : 0 : ENGINE_WRITE(engine, RING_TAIL, ring->tail);
719 : 0 : ENGINE_POSTING_READ(engine, RING_TAIL);
720 : : }
721 : :
722 : : /* Papering over lost _interrupts_ immediately following the restart */
723 : 0 : intel_engine_signal_breadcrumbs(engine);
724 : 0 : out:
725 : 0 : intel_uncore_forcewake_put(engine->uncore, FORCEWAKE_ALL);
726 : :
727 : 0 : return ret;
728 : : }
729 : :
730 : 0 : static void reset_prepare(struct intel_engine_cs *engine)
731 : : {
732 : 0 : struct intel_uncore *uncore = engine->uncore;
733 : 0 : const u32 base = engine->mmio_base;
734 : :
735 : : /*
736 : : * We stop engines, otherwise we might get failed reset and a
737 : : * dead gpu (on elk). Also as modern gpu as kbl can suffer
738 : : * from system hang if batchbuffer is progressing when
739 : : * the reset is issued, regardless of READY_TO_RESET ack.
740 : : * Thus assume it is best to stop engines on all gens
741 : : * where we have a gpu reset.
742 : : *
743 : : * WaKBLVECSSemaphoreWaitPoll:kbl (on ALL_ENGINES)
744 : : *
745 : : * WaMediaResetMainRingCleanup:ctg,elk (presumably)
746 : : *
747 : : * FIXME: Wa for more modern gens needs to be validated
748 : : */
749 : 0 : ENGINE_TRACE(engine, "\n");
750 : :
751 : 0 : if (intel_engine_stop_cs(engine))
752 : 0 : ENGINE_TRACE(engine, "timed out on STOP_RING\n");
753 : :
754 : 0 : intel_uncore_write_fw(uncore,
755 : : RING_HEAD(base),
756 : : intel_uncore_read_fw(uncore, RING_TAIL(base)));
757 : 0 : intel_uncore_posting_read_fw(uncore, RING_HEAD(base)); /* paranoia */
758 : :
759 : 0 : intel_uncore_write_fw(uncore, RING_HEAD(base), 0);
760 : 0 : intel_uncore_write_fw(uncore, RING_TAIL(base), 0);
761 : 0 : intel_uncore_posting_read_fw(uncore, RING_TAIL(base));
762 : :
763 : : /* The ring must be empty before it is disabled */
764 : 0 : intel_uncore_write_fw(uncore, RING_CTL(base), 0);
765 : :
766 : : /* Check acts as a post */
767 : 0 : if (intel_uncore_read_fw(uncore, RING_HEAD(base)))
768 : 0 : ENGINE_TRACE(engine, "ring head [%x] not parked\n",
769 : : intel_uncore_read_fw(uncore, RING_HEAD(base)));
770 : 0 : }
771 : :
772 : 0 : static void reset_rewind(struct intel_engine_cs *engine, bool stalled)
773 : : {
774 : 0 : struct i915_request *pos, *rq;
775 : 0 : unsigned long flags;
776 : 0 : u32 head;
777 : :
778 : 0 : rq = NULL;
779 : 0 : spin_lock_irqsave(&engine->active.lock, flags);
780 [ # # ]: 0 : list_for_each_entry(pos, &engine->active.requests, sched.link) {
781 [ # # ]: 0 : if (!i915_request_completed(pos)) {
782 : : rq = pos;
783 : : break;
784 : : }
785 : : }
786 : :
787 : : /*
788 : : * The guilty request will get skipped on a hung engine.
789 : : *
790 : : * Users of client default contexts do not rely on logical
791 : : * state preserved between batches so it is safe to execute
792 : : * queued requests following the hang. Non default contexts
793 : : * rely on preserved state, so skipping a batch loses the
794 : : * evolution of the state and it needs to be considered corrupted.
795 : : * Executing more queued batches on top of corrupted state is
796 : : * risky. But we take the risk by trying to advance through
797 : : * the queued requests in order to make the client behaviour
798 : : * more predictable around resets, by not throwing away random
799 : : * amount of batches it has prepared for execution. Sophisticated
800 : : * clients can use gem_reset_stats_ioctl and dma fence status
801 : : * (exported via sync_file info ioctl on explicit fences) to observe
802 : : * when it loses the context state and should rebuild accordingly.
803 : : *
804 : : * The context ban, and ultimately the client ban, mechanism are safety
805 : : * valves if client submission ends up resulting in nothing more than
806 : : * subsequent hangs.
807 : : */
808 : :
809 [ # # ]: 0 : if (rq) {
810 : : /*
811 : : * Try to restore the logical GPU state to match the
812 : : * continuation of the request queue. If we skip the
813 : : * context/PD restore, then the next request may try to execute
814 : : * assuming that its context is valid and loaded on the GPU and
815 : : * so may try to access invalid memory, prompting repeated GPU
816 : : * hangs.
817 : : *
818 : : * If the request was guilty, we still restore the logical
819 : : * state in case the next request requires it (e.g. the
820 : : * aliasing ppgtt), but skip over the hung batch.
821 : : *
822 : : * If the request was innocent, we try to replay the request
823 : : * with the restored context.
824 : : */
825 : 0 : __i915_request_reset(rq, stalled);
826 : :
827 : 0 : GEM_BUG_ON(rq->ring != engine->legacy.ring);
828 : 0 : head = rq->head;
829 : : } else {
830 : 0 : head = engine->legacy.ring->tail;
831 : : }
832 : 0 : engine->legacy.ring->head = intel_ring_wrap(engine->legacy.ring, head);
833 : :
834 : 0 : spin_unlock_irqrestore(&engine->active.lock, flags);
835 : 0 : }
836 : :
837 : 0 : static void reset_finish(struct intel_engine_cs *engine)
838 : : {
839 : 0 : }
840 : :
841 : 0 : static int rcs_resume(struct intel_engine_cs *engine)
842 : : {
843 : 0 : struct drm_i915_private *i915 = engine->i915;
844 : 0 : struct intel_uncore *uncore = engine->uncore;
845 : :
846 : : /*
847 : : * Disable CONSTANT_BUFFER before it is loaded from the context
848 : : * image. For as it is loaded, it is executed and the stored
849 : : * address may no longer be valid, leading to a GPU hang.
850 : : *
851 : : * This imposes the requirement that userspace reload their
852 : : * CONSTANT_BUFFER on every batch, fortunately a requirement
853 : : * they are already accustomed to from before contexts were
854 : : * enabled.
855 : : */
856 [ # # ]: 0 : if (IS_GEN(i915, 4))
857 : 0 : intel_uncore_write(uncore, ECOSKPD,
858 : 0 : _MASKED_BIT_ENABLE(ECO_CONSTANT_BUFFER_SR_DISABLE));
859 : :
860 : : /* WaTimedSingleVertexDispatch:cl,bw,ctg,elk,ilk,snb */
861 [ # # ]: 0 : if (IS_GEN_RANGE(i915, 4, 6))
862 : 0 : intel_uncore_write(uncore, MI_MODE,
863 : 0 : _MASKED_BIT_ENABLE(VS_TIMER_DISPATCH));
864 : :
865 : : /* We need to disable the AsyncFlip performance optimisations in order
866 : : * to use MI_WAIT_FOR_EVENT within the CS. It should already be
867 : : * programmed to '1' on all products.
868 : : *
869 : : * WaDisableAsyncFlipPerfMode:snb,ivb,hsw,vlv
870 : : */
871 [ # # ]: 0 : if (IS_GEN_RANGE(i915, 6, 7))
872 : 0 : intel_uncore_write(uncore, MI_MODE,
873 : 0 : _MASKED_BIT_ENABLE(ASYNC_FLIP_PERF_DISABLE));
874 : :
875 : : /* Required for the hardware to program scanline values for waiting */
876 : : /* WaEnableFlushTlbInvalidationMode:snb */
877 [ # # ]: 0 : if (IS_GEN(i915, 6))
878 : 0 : intel_uncore_write(uncore, GFX_MODE,
879 : 0 : _MASKED_BIT_ENABLE(GFX_TLB_INVALIDATE_EXPLICIT));
880 : :
881 : : /* WaBCSVCSTlbInvalidationMode:ivb,vlv,hsw */
882 [ # # ]: 0 : if (IS_GEN(i915, 7))
883 : 0 : intel_uncore_write(uncore, GFX_MODE_GEN7,
884 : 0 : _MASKED_BIT_ENABLE(GFX_TLB_INVALIDATE_EXPLICIT) |
885 : 0 : _MASKED_BIT_ENABLE(GFX_REPLAY_MODE));
886 : :
887 [ # # ]: 0 : if (IS_GEN(i915, 6)) {
888 : : /* From the Sandybridge PRM, volume 1 part 3, page 24:
889 : : * "If this bit is set, STCunit will have LRA as replacement
890 : : * policy. [...] This bit must be reset. LRA replacement
891 : : * policy is not supported."
892 : : */
893 : 0 : intel_uncore_write(uncore, CACHE_MODE_0,
894 : 0 : _MASKED_BIT_DISABLE(CM0_STC_EVICT_DISABLE_LRA_SNB));
895 : : }
896 : :
897 [ # # ]: 0 : if (IS_GEN_RANGE(i915, 6, 7))
898 : 0 : intel_uncore_write(uncore, INSTPM,
899 : 0 : _MASKED_BIT_ENABLE(INSTPM_FORCE_ORDERING));
900 : :
901 : 0 : return xcs_resume(engine);
902 : : }
903 : :
904 : 0 : static void reset_cancel(struct intel_engine_cs *engine)
905 : : {
906 : 0 : struct i915_request *request;
907 : 0 : unsigned long flags;
908 : :
909 : 0 : spin_lock_irqsave(&engine->active.lock, flags);
910 : :
911 : : /* Mark all submitted requests as skipped. */
912 [ # # ]: 0 : list_for_each_entry(request, &engine->active.requests, sched.link) {
913 [ # # ]: 0 : if (!i915_request_signaled(request))
914 : 0 : dma_fence_set_error(&request->fence, -EIO);
915 : :
916 : 0 : i915_request_mark_complete(request);
917 : : }
918 : :
919 : : /* Remaining _unready_ requests will be nop'ed when submitted */
920 : :
921 : 0 : spin_unlock_irqrestore(&engine->active.lock, flags);
922 : 0 : }
923 : :
924 : 0 : static void i9xx_submit_request(struct i915_request *request)
925 : : {
926 : 0 : i915_request_submit(request);
927 : 0 : wmb(); /* paranoid flush writes out of the WCB before mmio */
928 : :
929 : 0 : ENGINE_WRITE(request->engine, RING_TAIL,
930 : : intel_ring_set_tail(request->ring, request->tail));
931 : 0 : }
932 : :
933 : 0 : static u32 *i9xx_emit_breadcrumb(struct i915_request *rq, u32 *cs)
934 : : {
935 : 0 : GEM_BUG_ON(i915_request_active_timeline(rq)->hwsp_ggtt != rq->engine->status_page.vma);
936 : 0 : GEM_BUG_ON(offset_in_page(i915_request_active_timeline(rq)->hwsp_offset) != I915_GEM_HWS_SEQNO_ADDR);
937 : :
938 : 0 : *cs++ = MI_FLUSH;
939 : :
940 : 0 : *cs++ = MI_STORE_DWORD_INDEX;
941 : 0 : *cs++ = I915_GEM_HWS_SEQNO_ADDR;
942 : 0 : *cs++ = rq->fence.seqno;
943 : :
944 : 0 : *cs++ = MI_USER_INTERRUPT;
945 : 0 : *cs++ = MI_NOOP;
946 : :
947 : 0 : rq->tail = intel_ring_offset(rq, cs);
948 : 0 : assert_ring_tail_valid(rq->ring, rq->tail);
949 : :
950 : 0 : return cs;
951 : : }
952 : :
953 : : #define GEN5_WA_STORES 8 /* must be at least 1! */
954 : 0 : static u32 *gen5_emit_breadcrumb(struct i915_request *rq, u32 *cs)
955 : : {
956 : 0 : int i;
957 : :
958 : 0 : GEM_BUG_ON(i915_request_active_timeline(rq)->hwsp_ggtt != rq->engine->status_page.vma);
959 : 0 : GEM_BUG_ON(offset_in_page(i915_request_active_timeline(rq)->hwsp_offset) != I915_GEM_HWS_SEQNO_ADDR);
960 : :
961 : 0 : *cs++ = MI_FLUSH;
962 : :
963 : 0 : BUILD_BUG_ON(GEN5_WA_STORES < 1);
964 [ # # ]: 0 : for (i = 0; i < GEN5_WA_STORES; i++) {
965 : 0 : *cs++ = MI_STORE_DWORD_INDEX;
966 : 0 : *cs++ = I915_GEM_HWS_SEQNO_ADDR;
967 : 0 : *cs++ = rq->fence.seqno;
968 : : }
969 : :
970 : 0 : *cs++ = MI_USER_INTERRUPT;
971 : :
972 : 0 : rq->tail = intel_ring_offset(rq, cs);
973 : 0 : assert_ring_tail_valid(rq->ring, rq->tail);
974 : :
975 : 0 : return cs;
976 : : }
977 : : #undef GEN5_WA_STORES
978 : :
979 : : static void
980 : 0 : gen5_irq_enable(struct intel_engine_cs *engine)
981 : : {
982 : 0 : gen5_gt_enable_irq(engine->gt, engine->irq_enable_mask);
983 : 0 : }
984 : :
985 : : static void
986 : 0 : gen5_irq_disable(struct intel_engine_cs *engine)
987 : : {
988 : 0 : gen5_gt_disable_irq(engine->gt, engine->irq_enable_mask);
989 : 0 : }
990 : :
991 : : static void
992 : 0 : i9xx_irq_enable(struct intel_engine_cs *engine)
993 : : {
994 : 0 : engine->i915->irq_mask &= ~engine->irq_enable_mask;
995 : 0 : intel_uncore_write(engine->uncore, GEN2_IMR, engine->i915->irq_mask);
996 : 0 : intel_uncore_posting_read_fw(engine->uncore, GEN2_IMR);
997 : 0 : }
998 : :
999 : : static void
1000 : 0 : i9xx_irq_disable(struct intel_engine_cs *engine)
1001 : : {
1002 : 0 : engine->i915->irq_mask |= engine->irq_enable_mask;
1003 : 0 : intel_uncore_write(engine->uncore, GEN2_IMR, engine->i915->irq_mask);
1004 : 0 : }
1005 : :
1006 : : static void
1007 : 0 : i8xx_irq_enable(struct intel_engine_cs *engine)
1008 : : {
1009 : 0 : struct drm_i915_private *i915 = engine->i915;
1010 : :
1011 : 0 : i915->irq_mask &= ~engine->irq_enable_mask;
1012 : 0 : intel_uncore_write16(&i915->uncore, GEN2_IMR, i915->irq_mask);
1013 : 0 : ENGINE_POSTING_READ16(engine, RING_IMR);
1014 : 0 : }
1015 : :
1016 : : static void
1017 : 0 : i8xx_irq_disable(struct intel_engine_cs *engine)
1018 : : {
1019 : 0 : struct drm_i915_private *i915 = engine->i915;
1020 : :
1021 : 0 : i915->irq_mask |= engine->irq_enable_mask;
1022 : 0 : intel_uncore_write16(&i915->uncore, GEN2_IMR, i915->irq_mask);
1023 : 0 : }
1024 : :
1025 : : static int
1026 : 0 : bsd_ring_flush(struct i915_request *rq, u32 mode)
1027 : : {
1028 : 0 : u32 *cs;
1029 : :
1030 : 0 : cs = intel_ring_begin(rq, 2);
1031 [ # # ]: 0 : if (IS_ERR(cs))
1032 : 0 : return PTR_ERR(cs);
1033 : :
1034 : 0 : *cs++ = MI_FLUSH;
1035 : 0 : *cs++ = MI_NOOP;
1036 : 0 : intel_ring_advance(rq, cs);
1037 : 0 : return 0;
1038 : : }
1039 : :
1040 : : static void
1041 : 0 : gen6_irq_enable(struct intel_engine_cs *engine)
1042 : : {
1043 : 0 : ENGINE_WRITE(engine, RING_IMR,
1044 : : ~(engine->irq_enable_mask | engine->irq_keep_mask));
1045 : :
1046 : : /* Flush/delay to ensure the RING_IMR is active before the GT IMR */
1047 : 0 : ENGINE_POSTING_READ(engine, RING_IMR);
1048 : :
1049 : 0 : gen5_gt_enable_irq(engine->gt, engine->irq_enable_mask);
1050 : 0 : }
1051 : :
1052 : : static void
1053 : 0 : gen6_irq_disable(struct intel_engine_cs *engine)
1054 : : {
1055 : 0 : ENGINE_WRITE(engine, RING_IMR, ~engine->irq_keep_mask);
1056 : 0 : gen5_gt_disable_irq(engine->gt, engine->irq_enable_mask);
1057 : 0 : }
1058 : :
1059 : : static void
1060 : 0 : hsw_vebox_irq_enable(struct intel_engine_cs *engine)
1061 : : {
1062 : 0 : ENGINE_WRITE(engine, RING_IMR, ~engine->irq_enable_mask);
1063 : :
1064 : : /* Flush/delay to ensure the RING_IMR is active before the GT IMR */
1065 : 0 : ENGINE_POSTING_READ(engine, RING_IMR);
1066 : :
1067 : 0 : gen6_gt_pm_unmask_irq(engine->gt, engine->irq_enable_mask);
1068 : 0 : }
1069 : :
1070 : : static void
1071 : 0 : hsw_vebox_irq_disable(struct intel_engine_cs *engine)
1072 : : {
1073 : 0 : ENGINE_WRITE(engine, RING_IMR, ~0);
1074 : 0 : gen6_gt_pm_mask_irq(engine->gt, engine->irq_enable_mask);
1075 : 0 : }
1076 : :
1077 : : static int
1078 : 0 : i965_emit_bb_start(struct i915_request *rq,
1079 : : u64 offset, u32 length,
1080 : : unsigned int dispatch_flags)
1081 : : {
1082 : 0 : u32 *cs;
1083 : :
1084 : 0 : cs = intel_ring_begin(rq, 2);
1085 [ # # ]: 0 : if (IS_ERR(cs))
1086 : 0 : return PTR_ERR(cs);
1087 : :
1088 [ # # ]: 0 : *cs++ = MI_BATCH_BUFFER_START | MI_BATCH_GTT | (dispatch_flags &
1089 : : I915_DISPATCH_SECURE ? 0 : MI_BATCH_NON_SECURE_I965);
1090 : 0 : *cs++ = offset;
1091 : 0 : intel_ring_advance(rq, cs);
1092 : :
1093 : 0 : return 0;
1094 : : }
1095 : :
1096 : : /* Just userspace ABI convention to limit the wa batch bo to a resonable size */
1097 : : #define I830_BATCH_LIMIT SZ_256K
1098 : : #define I830_TLB_ENTRIES (2)
1099 : : #define I830_WA_SIZE max(I830_TLB_ENTRIES*4096, I830_BATCH_LIMIT)
1100 : : static int
1101 : 0 : i830_emit_bb_start(struct i915_request *rq,
1102 : : u64 offset, u32 len,
1103 : : unsigned int dispatch_flags)
1104 : : {
1105 : 0 : u32 *cs, cs_offset =
1106 : 0 : intel_gt_scratch_offset(rq->engine->gt,
1107 : : INTEL_GT_SCRATCH_FIELD_DEFAULT);
1108 : :
1109 : 0 : GEM_BUG_ON(rq->engine->gt->scratch->size < I830_WA_SIZE);
1110 : :
1111 : 0 : cs = intel_ring_begin(rq, 6);
1112 [ # # ]: 0 : if (IS_ERR(cs))
1113 : 0 : return PTR_ERR(cs);
1114 : :
1115 : : /* Evict the invalid PTE TLBs */
1116 : 0 : *cs++ = COLOR_BLT_CMD | BLT_WRITE_RGBA;
1117 : 0 : *cs++ = BLT_DEPTH_32 | BLT_ROP_COLOR_COPY | 4096;
1118 : 0 : *cs++ = I830_TLB_ENTRIES << 16 | 4; /* load each page */
1119 : 0 : *cs++ = cs_offset;
1120 : 0 : *cs++ = 0xdeadbeef;
1121 : 0 : *cs++ = MI_NOOP;
1122 [ # # ]: 0 : intel_ring_advance(rq, cs);
1123 : :
1124 [ # # ]: 0 : if ((dispatch_flags & I915_DISPATCH_PINNED) == 0) {
1125 [ # # ]: 0 : if (len > I830_BATCH_LIMIT)
1126 : : return -ENOSPC;
1127 : :
1128 : 0 : cs = intel_ring_begin(rq, 6 + 2);
1129 [ # # ]: 0 : if (IS_ERR(cs))
1130 : 0 : return PTR_ERR(cs);
1131 : :
1132 : : /* Blit the batch (which has now all relocs applied) to the
1133 : : * stable batch scratch bo area (so that the CS never
1134 : : * stumbles over its tlb invalidation bug) ...
1135 : : */
1136 : 0 : *cs++ = SRC_COPY_BLT_CMD | BLT_WRITE_RGBA | (6 - 2);
1137 : 0 : *cs++ = BLT_DEPTH_32 | BLT_ROP_SRC_COPY | 4096;
1138 : 0 : *cs++ = DIV_ROUND_UP(len, 4096) << 16 | 4096;
1139 : 0 : *cs++ = cs_offset;
1140 : 0 : *cs++ = 4096;
1141 : 0 : *cs++ = offset;
1142 : :
1143 : 0 : *cs++ = MI_FLUSH;
1144 : 0 : *cs++ = MI_NOOP;
1145 : 0 : intel_ring_advance(rq, cs);
1146 : :
1147 : : /* ... and execute it. */
1148 : 0 : offset = cs_offset;
1149 : : }
1150 : :
1151 : 0 : cs = intel_ring_begin(rq, 2);
1152 [ # # ]: 0 : if (IS_ERR(cs))
1153 : 0 : return PTR_ERR(cs);
1154 : :
1155 : 0 : *cs++ = MI_BATCH_BUFFER_START | MI_BATCH_GTT;
1156 : 0 : *cs++ = offset | (dispatch_flags & I915_DISPATCH_SECURE ? 0 :
1157 : : MI_BATCH_NON_SECURE);
1158 : 0 : intel_ring_advance(rq, cs);
1159 : :
1160 : 0 : return 0;
1161 : : }
1162 : :
1163 : : static int
1164 : 0 : i915_emit_bb_start(struct i915_request *rq,
1165 : : u64 offset, u32 len,
1166 : : unsigned int dispatch_flags)
1167 : : {
1168 : 0 : u32 *cs;
1169 : :
1170 : 0 : cs = intel_ring_begin(rq, 2);
1171 [ # # ]: 0 : if (IS_ERR(cs))
1172 : 0 : return PTR_ERR(cs);
1173 : :
1174 : 0 : *cs++ = MI_BATCH_BUFFER_START | MI_BATCH_GTT;
1175 : 0 : *cs++ = offset | (dispatch_flags & I915_DISPATCH_SECURE ? 0 :
1176 : : MI_BATCH_NON_SECURE);
1177 : 0 : intel_ring_advance(rq, cs);
1178 : :
1179 : 0 : return 0;
1180 : : }
1181 : :
1182 : 0 : static void __ring_context_fini(struct intel_context *ce)
1183 : : {
1184 : 0 : i915_vma_put(ce->state);
1185 : 0 : }
1186 : :
1187 : 0 : static void ring_context_destroy(struct kref *ref)
1188 : : {
1189 : 0 : struct intel_context *ce = container_of(ref, typeof(*ce), ref);
1190 : :
1191 : 0 : GEM_BUG_ON(intel_context_is_pinned(ce));
1192 : :
1193 [ # # ]: 0 : if (ce->state)
1194 : 0 : __ring_context_fini(ce);
1195 : :
1196 : 0 : intel_context_fini(ce);
1197 : 0 : intel_context_free(ce);
1198 : 0 : }
1199 : :
1200 : 0 : static struct i915_address_space *vm_alias(struct intel_context *ce)
1201 : : {
1202 : 0 : struct i915_address_space *vm;
1203 : :
1204 : 0 : vm = ce->vm;
1205 : 0 : if (i915_is_ggtt(vm))
1206 : 0 : vm = &i915_vm_to_ggtt(vm)->alias->vm;
1207 : :
1208 : 0 : return vm;
1209 : : }
1210 : :
1211 : 0 : static int __context_pin_ppgtt(struct intel_context *ce)
1212 : : {
1213 : 0 : struct i915_address_space *vm;
1214 : 0 : int err = 0;
1215 : :
1216 [ # # ]: 0 : vm = vm_alias(ce);
1217 [ # # ]: 0 : if (vm)
1218 : 0 : err = gen6_ppgtt_pin(i915_vm_to_ppgtt((vm)));
1219 : :
1220 : 0 : return err;
1221 : : }
1222 : :
1223 : 0 : static void __context_unpin_ppgtt(struct intel_context *ce)
1224 : : {
1225 : 0 : struct i915_address_space *vm;
1226 : :
1227 [ # # ]: 0 : vm = vm_alias(ce);
1228 [ # # ]: 0 : if (vm)
1229 : 0 : gen6_ppgtt_unpin(i915_vm_to_ppgtt(vm));
1230 : 0 : }
1231 : :
1232 : 0 : static void ring_context_unpin(struct intel_context *ce)
1233 : : {
1234 : 0 : __context_unpin_ppgtt(ce);
1235 : 0 : }
1236 : :
1237 : : static struct i915_vma *
1238 : 0 : alloc_context_vma(struct intel_engine_cs *engine)
1239 : : {
1240 : 0 : struct drm_i915_private *i915 = engine->i915;
1241 : 0 : struct drm_i915_gem_object *obj;
1242 : 0 : struct i915_vma *vma;
1243 : 0 : int err;
1244 : :
1245 : 0 : obj = i915_gem_object_create_shmem(i915, engine->context_size);
1246 [ # # ]: 0 : if (IS_ERR(obj))
1247 : : return ERR_CAST(obj);
1248 : :
1249 : : /*
1250 : : * Try to make the context utilize L3 as well as LLC.
1251 : : *
1252 : : * On VLV we don't have L3 controls in the PTEs so we
1253 : : * shouldn't touch the cache level, especially as that
1254 : : * would make the object snooped which might have a
1255 : : * negative performance impact.
1256 : : *
1257 : : * Snooping is required on non-llc platforms in execlist
1258 : : * mode, but since all GGTT accesses use PAT entry 0 we
1259 : : * get snooping anyway regardless of cache_level.
1260 : : *
1261 : : * This is only applicable for Ivy Bridge devices since
1262 : : * later platforms don't have L3 control bits in the PTE.
1263 : : */
1264 [ # # ]: 0 : if (IS_IVYBRIDGE(i915))
1265 : 0 : i915_gem_object_set_cache_coherency(obj, I915_CACHE_L3_LLC);
1266 : :
1267 [ # # ]: 0 : if (engine->default_state) {
1268 : 0 : void *defaults, *vaddr;
1269 : :
1270 : 0 : vaddr = i915_gem_object_pin_map(obj, I915_MAP_WB);
1271 [ # # ]: 0 : if (IS_ERR(vaddr)) {
1272 : 0 : err = PTR_ERR(vaddr);
1273 : 0 : goto err_obj;
1274 : : }
1275 : :
1276 : 0 : defaults = i915_gem_object_pin_map(engine->default_state,
1277 : : I915_MAP_WB);
1278 [ # # ]: 0 : if (IS_ERR(defaults)) {
1279 : 0 : err = PTR_ERR(defaults);
1280 : 0 : goto err_map;
1281 : : }
1282 : :
1283 : 0 : memcpy(vaddr, defaults, engine->context_size);
1284 : 0 : i915_gem_object_unpin_map(engine->default_state);
1285 : :
1286 : 0 : i915_gem_object_flush_map(obj);
1287 : 0 : i915_gem_object_unpin_map(obj);
1288 : : }
1289 : :
1290 : 0 : vma = i915_vma_instance(obj, &engine->gt->ggtt->vm, NULL);
1291 [ # # ]: 0 : if (IS_ERR(vma)) {
1292 : 0 : err = PTR_ERR(vma);
1293 : 0 : goto err_obj;
1294 : : }
1295 : :
1296 : : return vma;
1297 : :
1298 : : err_map:
1299 : 0 : i915_gem_object_unpin_map(obj);
1300 : 0 : err_obj:
1301 : 0 : i915_gem_object_put(obj);
1302 : 0 : return ERR_PTR(err);
1303 : : }
1304 : :
1305 : 0 : static int ring_context_alloc(struct intel_context *ce)
1306 : : {
1307 : 0 : struct intel_engine_cs *engine = ce->engine;
1308 : :
1309 : : /* One ringbuffer to rule them all */
1310 : 0 : GEM_BUG_ON(!engine->legacy.ring);
1311 : 0 : ce->ring = engine->legacy.ring;
1312 : 0 : ce->timeline = intel_timeline_get(engine->legacy.timeline);
1313 : :
1314 : 0 : GEM_BUG_ON(ce->state);
1315 [ # # ]: 0 : if (engine->context_size) {
1316 : 0 : struct i915_vma *vma;
1317 : :
1318 : 0 : vma = alloc_context_vma(engine);
1319 [ # # ]: 0 : if (IS_ERR(vma))
1320 : 0 : return PTR_ERR(vma);
1321 : :
1322 : 0 : ce->state = vma;
1323 [ # # ]: 0 : if (engine->default_state)
1324 : 0 : __set_bit(CONTEXT_VALID_BIT, &ce->flags);
1325 : : }
1326 : :
1327 : : return 0;
1328 : : }
1329 : :
1330 : 0 : static int ring_context_pin(struct intel_context *ce)
1331 : : {
1332 : 0 : return __context_pin_ppgtt(ce);
1333 : : }
1334 : :
1335 : 0 : static void ring_context_reset(struct intel_context *ce)
1336 : : {
1337 : 0 : intel_ring_reset(ce->ring, ce->ring->emit);
1338 : 0 : }
1339 : :
1340 : : static const struct intel_context_ops ring_context_ops = {
1341 : : .alloc = ring_context_alloc,
1342 : :
1343 : : .pin = ring_context_pin,
1344 : : .unpin = ring_context_unpin,
1345 : :
1346 : : .enter = intel_context_enter_engine,
1347 : : .exit = intel_context_exit_engine,
1348 : :
1349 : : .reset = ring_context_reset,
1350 : : .destroy = ring_context_destroy,
1351 : : };
1352 : :
1353 : : static int load_pd_dir(struct i915_request *rq,
1354 : : const struct i915_ppgtt *ppgtt,
1355 : : u32 valid)
1356 : : {
1357 : : const struct intel_engine_cs * const engine = rq->engine;
1358 : : u32 *cs;
1359 : :
1360 : : cs = intel_ring_begin(rq, 12);
1361 : : if (IS_ERR(cs))
1362 : : return PTR_ERR(cs);
1363 : :
1364 : : *cs++ = MI_LOAD_REGISTER_IMM(1);
1365 : : *cs++ = i915_mmio_reg_offset(RING_PP_DIR_DCLV(engine->mmio_base));
1366 : : *cs++ = valid;
1367 : :
1368 : : *cs++ = MI_LOAD_REGISTER_IMM(1);
1369 : : *cs++ = i915_mmio_reg_offset(RING_PP_DIR_BASE(engine->mmio_base));
1370 : : *cs++ = px_base(ppgtt->pd)->ggtt_offset << 10;
1371 : :
1372 : : /* Stall until the page table load is complete? */
1373 : : *cs++ = MI_STORE_REGISTER_MEM | MI_SRM_LRM_GLOBAL_GTT;
1374 : : *cs++ = i915_mmio_reg_offset(RING_PP_DIR_BASE(engine->mmio_base));
1375 : : *cs++ = intel_gt_scratch_offset(engine->gt,
1376 : : INTEL_GT_SCRATCH_FIELD_DEFAULT);
1377 : :
1378 : : *cs++ = MI_LOAD_REGISTER_IMM(1);
1379 : : *cs++ = i915_mmio_reg_offset(RING_INSTPM(engine->mmio_base));
1380 : : *cs++ = _MASKED_BIT_ENABLE(INSTPM_TLB_INVALIDATE);
1381 : :
1382 : : intel_ring_advance(rq, cs);
1383 : :
1384 : : return rq->engine->emit_flush(rq, EMIT_FLUSH);
1385 : : }
1386 : :
1387 : 0 : static inline int mi_set_context(struct i915_request *rq, u32 flags)
1388 : : {
1389 : 0 : struct drm_i915_private *i915 = rq->i915;
1390 : 0 : struct intel_engine_cs *engine = rq->engine;
1391 : 0 : enum intel_engine_id id;
1392 [ # # ]: 0 : const int num_engines =
1393 [ # # ]: 0 : IS_HASWELL(i915) ? RUNTIME_INFO(i915)->num_engines - 1 : 0;
1394 : 0 : bool force_restore = false;
1395 : 0 : int len;
1396 : 0 : u32 *cs;
1397 : :
1398 : 0 : len = 4;
1399 [ # # ]: 0 : if (IS_GEN(i915, 7))
1400 [ # # ]: 0 : len += 2 + (num_engines ? 4 * num_engines + 6 : 0);
1401 [ # # ]: 0 : else if (IS_GEN(i915, 5))
1402 : 0 : len += 2;
1403 [ # # ]: 0 : if (flags & MI_FORCE_RESTORE) {
1404 : 0 : GEM_BUG_ON(flags & MI_RESTORE_INHIBIT);
1405 : 0 : flags &= ~MI_FORCE_RESTORE;
1406 : 0 : force_restore = true;
1407 : 0 : len += 2;
1408 : : }
1409 : :
1410 : 0 : cs = intel_ring_begin(rq, len);
1411 [ # # ]: 0 : if (IS_ERR(cs))
1412 : 0 : return PTR_ERR(cs);
1413 : :
1414 : : /* WaProgramMiArbOnOffAroundMiSetContext:ivb,vlv,hsw,bdw,chv */
1415 [ # # ]: 0 : if (IS_GEN(i915, 7)) {
1416 : 0 : *cs++ = MI_ARB_ON_OFF | MI_ARB_DISABLE;
1417 [ # # ]: 0 : if (num_engines) {
1418 : 0 : struct intel_engine_cs *signaller;
1419 : :
1420 : 0 : *cs++ = MI_LOAD_REGISTER_IMM(num_engines);
1421 [ # # # # ]: 0 : for_each_engine(signaller, engine->gt, id) {
1422 [ # # ]: 0 : if (signaller == engine)
1423 : 0 : continue;
1424 : :
1425 : 0 : *cs++ = i915_mmio_reg_offset(
1426 : 0 : RING_PSMI_CTL(signaller->mmio_base));
1427 : 0 : *cs++ = _MASKED_BIT_ENABLE(
1428 : : GEN6_PSMI_SLEEP_MSG_DISABLE);
1429 : : }
1430 : : }
1431 [ # # ]: 0 : } else if (IS_GEN(i915, 5)) {
1432 : : /*
1433 : : * This w/a is only listed for pre-production ilk a/b steppings,
1434 : : * but is also mentioned for programming the powerctx. To be
1435 : : * safe, just apply the workaround; we do not use SyncFlush so
1436 : : * this should never take effect and so be a no-op!
1437 : : */
1438 : 0 : *cs++ = MI_SUSPEND_FLUSH | MI_SUSPEND_FLUSH_EN;
1439 : : }
1440 : :
1441 [ # # ]: 0 : if (force_restore) {
1442 : : /*
1443 : : * The HW doesn't handle being told to restore the current
1444 : : * context very well. Quite often it likes goes to go off and
1445 : : * sulk, especially when it is meant to be reloading PP_DIR.
1446 : : * A very simple fix to force the reload is to simply switch
1447 : : * away from the current context and back again.
1448 : : *
1449 : : * Note that the kernel_context will contain random state
1450 : : * following the INHIBIT_RESTORE. We accept this since we
1451 : : * never use the kernel_context state; it is merely a
1452 : : * placeholder we use to flush other contexts.
1453 : : */
1454 : 0 : *cs++ = MI_SET_CONTEXT;
1455 : 0 : *cs++ = i915_ggtt_offset(engine->kernel_context->state) |
1456 : 0 : MI_MM_SPACE_GTT |
1457 : : MI_RESTORE_INHIBIT;
1458 : : }
1459 : :
1460 : 0 : *cs++ = MI_NOOP;
1461 : 0 : *cs++ = MI_SET_CONTEXT;
1462 [ # # ]: 0 : *cs++ = i915_ggtt_offset(rq->context->state) | flags;
1463 : : /*
1464 : : * w/a: MI_SET_CONTEXT must always be followed by MI_NOOP
1465 : : * WaMiSetContext_Hang:snb,ivb,vlv
1466 : : */
1467 : 0 : *cs++ = MI_NOOP;
1468 : :
1469 [ # # ]: 0 : if (IS_GEN(i915, 7)) {
1470 [ # # ]: 0 : if (num_engines) {
1471 : 0 : struct intel_engine_cs *signaller;
1472 : 0 : i915_reg_t last_reg = {}; /* keep gcc quiet */
1473 : :
1474 : 0 : *cs++ = MI_LOAD_REGISTER_IMM(num_engines);
1475 [ # # # # ]: 0 : for_each_engine(signaller, engine->gt, id) {
1476 [ # # ]: 0 : if (signaller == engine)
1477 : 0 : continue;
1478 : :
1479 : 0 : last_reg = RING_PSMI_CTL(signaller->mmio_base);
1480 : 0 : *cs++ = i915_mmio_reg_offset(last_reg);
1481 : 0 : *cs++ = _MASKED_BIT_DISABLE(
1482 : : GEN6_PSMI_SLEEP_MSG_DISABLE);
1483 : : }
1484 : :
1485 : : /* Insert a delay before the next switch! */
1486 : 0 : *cs++ = MI_STORE_REGISTER_MEM | MI_SRM_LRM_GLOBAL_GTT;
1487 : 0 : *cs++ = i915_mmio_reg_offset(last_reg);
1488 : 0 : *cs++ = intel_gt_scratch_offset(engine->gt,
1489 : : INTEL_GT_SCRATCH_FIELD_DEFAULT);
1490 : 0 : *cs++ = MI_NOOP;
1491 : : }
1492 : 0 : *cs++ = MI_ARB_ON_OFF | MI_ARB_ENABLE;
1493 [ # # ]: 0 : } else if (IS_GEN(i915, 5)) {
1494 : 0 : *cs++ = MI_SUSPEND_FLUSH;
1495 : : }
1496 : :
1497 : : intel_ring_advance(rq, cs);
1498 : :
1499 : : return 0;
1500 : : }
1501 : :
1502 : 0 : static int remap_l3_slice(struct i915_request *rq, int slice)
1503 : : {
1504 : 0 : u32 *cs, *remap_info = rq->i915->l3_parity.remap_info[slice];
1505 : 0 : int i;
1506 : :
1507 [ # # ]: 0 : if (!remap_info)
1508 : : return 0;
1509 : :
1510 : 0 : cs = intel_ring_begin(rq, GEN7_L3LOG_SIZE/4 * 2 + 2);
1511 [ # # ]: 0 : if (IS_ERR(cs))
1512 : 0 : return PTR_ERR(cs);
1513 : :
1514 : : /*
1515 : : * Note: We do not worry about the concurrent register cacheline hang
1516 : : * here because no other code should access these registers other than
1517 : : * at initialization time.
1518 : : */
1519 : 0 : *cs++ = MI_LOAD_REGISTER_IMM(GEN7_L3LOG_SIZE/4);
1520 [ # # ]: 0 : for (i = 0; i < GEN7_L3LOG_SIZE/4; i++) {
1521 : 0 : *cs++ = i915_mmio_reg_offset(GEN7_L3LOG(slice, i));
1522 : 0 : *cs++ = remap_info[i];
1523 : : }
1524 : 0 : *cs++ = MI_NOOP;
1525 : 0 : intel_ring_advance(rq, cs);
1526 : :
1527 : 0 : return 0;
1528 : : }
1529 : :
1530 : 0 : static int remap_l3(struct i915_request *rq)
1531 : : {
1532 [ # # ]: 0 : struct i915_gem_context *ctx = i915_request_gem_context(rq);
1533 : 0 : int i, err;
1534 : :
1535 [ # # # # ]: 0 : if (!ctx || !ctx->remap_slice)
1536 : : return 0;
1537 : :
1538 [ # # ]: 0 : for (i = 0; i < MAX_L3_SLICES; i++) {
1539 [ # # ]: 0 : if (!(ctx->remap_slice & BIT(i)))
1540 : 0 : continue;
1541 : :
1542 : 0 : err = remap_l3_slice(rq, i);
1543 [ # # ]: 0 : if (err)
1544 : 0 : return err;
1545 : : }
1546 : :
1547 : 0 : ctx->remap_slice = 0;
1548 : 0 : return 0;
1549 : : }
1550 : :
1551 : 0 : static int switch_mm(struct i915_request *rq, struct i915_address_space *vm)
1552 : : {
1553 : 0 : int ret;
1554 : :
1555 [ # # ]: 0 : if (!vm)
1556 : : return 0;
1557 : :
1558 : 0 : ret = rq->engine->emit_flush(rq, EMIT_FLUSH);
1559 [ # # ]: 0 : if (ret)
1560 : : return ret;
1561 : :
1562 : : /*
1563 : : * Not only do we need a full barrier (post-sync write) after
1564 : : * invalidating the TLBs, but we need to wait a little bit
1565 : : * longer. Whether this is merely delaying us, or the
1566 : : * subsequent flush is a key part of serialising with the
1567 : : * post-sync op, this extra pass appears vital before a
1568 : : * mm switch!
1569 : : */
1570 : 0 : ret = load_pd_dir(rq, i915_vm_to_ppgtt(vm), PP_DIR_DCLV_2G);
1571 [ # # ]: 0 : if (ret)
1572 : : return ret;
1573 : :
1574 : 0 : return rq->engine->emit_flush(rq, EMIT_INVALIDATE);
1575 : : }
1576 : :
1577 : 0 : static int switch_context(struct i915_request *rq)
1578 : : {
1579 : 0 : struct intel_context *ce = rq->context;
1580 : 0 : int ret;
1581 : :
1582 : 0 : GEM_BUG_ON(HAS_EXECLISTS(rq->i915));
1583 : :
1584 [ # # ]: 0 : ret = switch_mm(rq, vm_alias(ce));
1585 [ # # ]: 0 : if (ret)
1586 : : return ret;
1587 : :
1588 [ # # ]: 0 : if (ce->state) {
1589 : 0 : u32 flags;
1590 : :
1591 : 0 : GEM_BUG_ON(rq->engine->id != RCS0);
1592 : :
1593 : : /* For resource streamer on HSW+ and power context elsewhere */
1594 : 0 : BUILD_BUG_ON(HSW_MI_RS_SAVE_STATE_EN != MI_SAVE_EXT_STATE_EN);
1595 : 0 : BUILD_BUG_ON(HSW_MI_RS_RESTORE_STATE_EN != MI_RESTORE_EXT_STATE_EN);
1596 : :
1597 : 0 : flags = MI_SAVE_EXT_STATE_EN | MI_MM_SPACE_GTT;
1598 [ # # ]: 0 : if (test_bit(CONTEXT_VALID_BIT, &ce->flags))
1599 : : flags |= MI_RESTORE_EXT_STATE_EN;
1600 : : else
1601 : 0 : flags |= MI_RESTORE_INHIBIT;
1602 : :
1603 : 0 : ret = mi_set_context(rq, flags);
1604 [ # # ]: 0 : if (ret)
1605 : : return ret;
1606 : : }
1607 : :
1608 : 0 : ret = remap_l3(rq);
1609 [ # # ]: 0 : if (ret)
1610 : 0 : return ret;
1611 : :
1612 : : return 0;
1613 : : }
1614 : :
1615 : 0 : static int ring_request_alloc(struct i915_request *request)
1616 : : {
1617 : 0 : int ret;
1618 : :
1619 : 0 : GEM_BUG_ON(!intel_context_is_pinned(request->context));
1620 : 0 : GEM_BUG_ON(i915_request_timeline(request)->has_initial_breadcrumb);
1621 : :
1622 : : /*
1623 : : * Flush enough space to reduce the likelihood of waiting after
1624 : : * we start building the request - in which case we will just
1625 : : * have to repeat work.
1626 : : */
1627 : 0 : request->reserved_space += LEGACY_REQUEST_SIZE;
1628 : :
1629 : : /* Unconditionally invalidate GPU caches and TLBs. */
1630 : 0 : ret = request->engine->emit_flush(request, EMIT_INVALIDATE);
1631 [ # # ]: 0 : if (ret)
1632 : : return ret;
1633 : :
1634 : 0 : ret = switch_context(request);
1635 [ # # ]: 0 : if (ret)
1636 : : return ret;
1637 : :
1638 : 0 : request->reserved_space -= LEGACY_REQUEST_SIZE;
1639 : 0 : return 0;
1640 : : }
1641 : :
1642 : 0 : static void gen6_bsd_submit_request(struct i915_request *request)
1643 : : {
1644 : 0 : struct intel_uncore *uncore = request->engine->uncore;
1645 : :
1646 : 0 : intel_uncore_forcewake_get(uncore, FORCEWAKE_ALL);
1647 : :
1648 : : /* Every tail move must follow the sequence below */
1649 : :
1650 : : /* Disable notification that the ring is IDLE. The GT
1651 : : * will then assume that it is busy and bring it out of rc6.
1652 : : */
1653 : 0 : intel_uncore_write_fw(uncore, GEN6_BSD_SLEEP_PSMI_CONTROL,
1654 : : _MASKED_BIT_ENABLE(GEN6_BSD_SLEEP_MSG_DISABLE));
1655 : :
1656 : : /* Clear the context id. Here be magic! */
1657 : 0 : intel_uncore_write64_fw(uncore, GEN6_BSD_RNCID, 0x0);
1658 : :
1659 : : /* Wait for the ring not to be idle, i.e. for it to wake up. */
1660 [ # # ]: 0 : if (__intel_wait_for_register_fw(uncore,
1661 : 0 : GEN6_BSD_SLEEP_PSMI_CONTROL,
1662 : : GEN6_BSD_SLEEP_INDICATOR,
1663 : : 0,
1664 : : 1000, 0, NULL))
1665 : 0 : DRM_ERROR("timed out waiting for the BSD ring to wake up\n");
1666 : :
1667 : : /* Now that the ring is fully powered up, update the tail */
1668 : 0 : i9xx_submit_request(request);
1669 : :
1670 : : /* Let the ring send IDLE messages to the GT again,
1671 : : * and so let it sleep to conserve power when idle.
1672 : : */
1673 : 0 : intel_uncore_write_fw(uncore, GEN6_BSD_SLEEP_PSMI_CONTROL,
1674 : : _MASKED_BIT_DISABLE(GEN6_BSD_SLEEP_MSG_DISABLE));
1675 : :
1676 : 0 : intel_uncore_forcewake_put(uncore, FORCEWAKE_ALL);
1677 : 0 : }
1678 : :
1679 : 0 : static int mi_flush_dw(struct i915_request *rq, u32 flags)
1680 : : {
1681 : 0 : u32 cmd, *cs;
1682 : :
1683 : 0 : cs = intel_ring_begin(rq, 4);
1684 [ # # ]: 0 : if (IS_ERR(cs))
1685 : 0 : return PTR_ERR(cs);
1686 : :
1687 : 0 : cmd = MI_FLUSH_DW;
1688 : :
1689 : : /*
1690 : : * We always require a command barrier so that subsequent
1691 : : * commands, such as breadcrumb interrupts, are strictly ordered
1692 : : * wrt the contents of the write cache being flushed to memory
1693 : : * (and thus being coherent from the CPU).
1694 : : */
1695 : 0 : cmd |= MI_FLUSH_DW_STORE_INDEX | MI_FLUSH_DW_OP_STOREDW;
1696 : :
1697 : : /*
1698 : : * Bspec vol 1c.3 - blitter engine command streamer:
1699 : : * "If ENABLED, all TLBs will be invalidated once the flush
1700 : : * operation is complete. This bit is only valid when the
1701 : : * Post-Sync Operation field is a value of 1h or 3h."
1702 : : */
1703 : 0 : cmd |= flags;
1704 : :
1705 : 0 : *cs++ = cmd;
1706 : 0 : *cs++ = I915_GEM_HWS_SCRATCH_ADDR | MI_FLUSH_DW_USE_GTT;
1707 : 0 : *cs++ = 0;
1708 : 0 : *cs++ = MI_NOOP;
1709 : :
1710 : 0 : intel_ring_advance(rq, cs);
1711 : :
1712 : 0 : return 0;
1713 : : }
1714 : :
1715 : 0 : static int gen6_flush_dw(struct i915_request *rq, u32 mode, u32 invflags)
1716 : : {
1717 [ # # ]: 0 : return mi_flush_dw(rq, mode & EMIT_INVALIDATE ? invflags : 0);
1718 : : }
1719 : :
1720 : 0 : static int gen6_bsd_ring_flush(struct i915_request *rq, u32 mode)
1721 : : {
1722 : 0 : return gen6_flush_dw(rq, mode, MI_INVALIDATE_TLB | MI_INVALIDATE_BSD);
1723 : : }
1724 : :
1725 : : static int
1726 : 0 : hsw_emit_bb_start(struct i915_request *rq,
1727 : : u64 offset, u32 len,
1728 : : unsigned int dispatch_flags)
1729 : : {
1730 : 0 : u32 *cs;
1731 : :
1732 : 0 : cs = intel_ring_begin(rq, 2);
1733 [ # # ]: 0 : if (IS_ERR(cs))
1734 : 0 : return PTR_ERR(cs);
1735 : :
1736 [ # # ]: 0 : *cs++ = MI_BATCH_BUFFER_START | (dispatch_flags & I915_DISPATCH_SECURE ?
1737 : : 0 : MI_BATCH_PPGTT_HSW | MI_BATCH_NON_SECURE_HSW);
1738 : : /* bit0-7 is the length on GEN6+ */
1739 : 0 : *cs++ = offset;
1740 : 0 : intel_ring_advance(rq, cs);
1741 : :
1742 : 0 : return 0;
1743 : : }
1744 : :
1745 : : static int
1746 : 0 : gen6_emit_bb_start(struct i915_request *rq,
1747 : : u64 offset, u32 len,
1748 : : unsigned int dispatch_flags)
1749 : : {
1750 : 0 : u32 *cs;
1751 : :
1752 : 0 : cs = intel_ring_begin(rq, 2);
1753 [ # # ]: 0 : if (IS_ERR(cs))
1754 : 0 : return PTR_ERR(cs);
1755 : :
1756 [ # # ]: 0 : *cs++ = MI_BATCH_BUFFER_START | (dispatch_flags & I915_DISPATCH_SECURE ?
1757 : : 0 : MI_BATCH_NON_SECURE_I965);
1758 : : /* bit0-7 is the length on GEN6+ */
1759 : 0 : *cs++ = offset;
1760 : 0 : intel_ring_advance(rq, cs);
1761 : :
1762 : 0 : return 0;
1763 : : }
1764 : :
1765 : : /* Blitter support (SandyBridge+) */
1766 : :
1767 : 0 : static int gen6_ring_flush(struct i915_request *rq, u32 mode)
1768 : : {
1769 : 0 : return gen6_flush_dw(rq, mode, MI_INVALIDATE_TLB);
1770 : : }
1771 : :
1772 : 0 : static void i9xx_set_default_submission(struct intel_engine_cs *engine)
1773 : : {
1774 : 0 : engine->submit_request = i9xx_submit_request;
1775 : :
1776 : 0 : engine->park = NULL;
1777 : 0 : engine->unpark = NULL;
1778 : 0 : }
1779 : :
1780 : 0 : static void gen6_bsd_set_default_submission(struct intel_engine_cs *engine)
1781 : : {
1782 : 0 : i9xx_set_default_submission(engine);
1783 : 0 : engine->submit_request = gen6_bsd_submit_request;
1784 : 0 : }
1785 : :
1786 : 0 : static void ring_release(struct intel_engine_cs *engine)
1787 : : {
1788 : 0 : struct drm_i915_private *dev_priv = engine->i915;
1789 : :
1790 [ # # # # : 0 : WARN_ON(INTEL_GEN(dev_priv) > 2 &&
# # ]
1791 : : (ENGINE_READ(engine, RING_MI_MODE) & MODE_IDLE) == 0);
1792 : :
1793 : 0 : intel_engine_cleanup_common(engine);
1794 : :
1795 : 0 : intel_ring_unpin(engine->legacy.ring);
1796 : 0 : intel_ring_put(engine->legacy.ring);
1797 : :
1798 : 0 : intel_timeline_unpin(engine->legacy.timeline);
1799 : 0 : intel_timeline_put(engine->legacy.timeline);
1800 : 0 : }
1801 : :
1802 : 0 : static void setup_irq(struct intel_engine_cs *engine)
1803 : : {
1804 : 0 : struct drm_i915_private *i915 = engine->i915;
1805 : :
1806 : 0 : if (INTEL_GEN(i915) >= 6) {
1807 : 0 : engine->irq_enable = gen6_irq_enable;
1808 : 0 : engine->irq_disable = gen6_irq_disable;
1809 [ # # ]: 0 : } else if (INTEL_GEN(i915) >= 5) {
1810 : 0 : engine->irq_enable = gen5_irq_enable;
1811 : 0 : engine->irq_disable = gen5_irq_disable;
1812 [ # # ]: 0 : } else if (INTEL_GEN(i915) >= 3) {
1813 : 0 : engine->irq_enable = i9xx_irq_enable;
1814 : 0 : engine->irq_disable = i9xx_irq_disable;
1815 : : } else {
1816 : 0 : engine->irq_enable = i8xx_irq_enable;
1817 : 0 : engine->irq_disable = i8xx_irq_disable;
1818 : : }
1819 : : }
1820 : :
1821 : 0 : static void setup_common(struct intel_engine_cs *engine)
1822 : : {
1823 : 0 : struct drm_i915_private *i915 = engine->i915;
1824 : :
1825 : : /* gen8+ are only supported with execlists */
1826 : 0 : GEM_BUG_ON(INTEL_GEN(i915) >= 8);
1827 : :
1828 [ # # ]: 0 : setup_irq(engine);
1829 : :
1830 : 0 : engine->resume = xcs_resume;
1831 : 0 : engine->reset.prepare = reset_prepare;
1832 : 0 : engine->reset.rewind = reset_rewind;
1833 : 0 : engine->reset.cancel = reset_cancel;
1834 : 0 : engine->reset.finish = reset_finish;
1835 : :
1836 : 0 : engine->cops = &ring_context_ops;
1837 : 0 : engine->request_alloc = ring_request_alloc;
1838 : :
1839 : : /*
1840 : : * Using a global execution timeline; the previous final breadcrumb is
1841 : : * equivalent to our next initial bread so we can elide
1842 : : * engine->emit_init_breadcrumb().
1843 : : */
1844 : 0 : engine->emit_fini_breadcrumb = i9xx_emit_breadcrumb;
1845 [ # # ]: 0 : if (IS_GEN(i915, 5))
1846 : 0 : engine->emit_fini_breadcrumb = gen5_emit_breadcrumb;
1847 : :
1848 : 0 : engine->set_default_submission = i9xx_set_default_submission;
1849 : :
1850 [ # # ]: 0 : if (INTEL_GEN(i915) >= 6)
1851 : 0 : engine->emit_bb_start = gen6_emit_bb_start;
1852 [ # # ]: 0 : else if (INTEL_GEN(i915) >= 4)
1853 : 0 : engine->emit_bb_start = i965_emit_bb_start;
1854 [ # # # # ]: 0 : else if (IS_I830(i915) || IS_I845G(i915))
1855 : 0 : engine->emit_bb_start = i830_emit_bb_start;
1856 : : else
1857 : 0 : engine->emit_bb_start = i915_emit_bb_start;
1858 : 0 : }
1859 : :
1860 : 0 : static void setup_rcs(struct intel_engine_cs *engine)
1861 : : {
1862 : 0 : struct drm_i915_private *i915 = engine->i915;
1863 : :
1864 [ # # ]: 0 : if (HAS_L3_DPF(i915))
1865 : 0 : engine->irq_keep_mask = GT_RENDER_L3_PARITY_ERROR_INTERRUPT;
1866 : :
1867 : 0 : engine->irq_enable_mask = GT_RENDER_USER_INTERRUPT;
1868 : :
1869 [ # # ]: 0 : if (INTEL_GEN(i915) >= 7) {
1870 : 0 : engine->emit_flush = gen7_render_ring_flush;
1871 : 0 : engine->emit_fini_breadcrumb = gen7_rcs_emit_breadcrumb;
1872 [ # # ]: 0 : } else if (IS_GEN(i915, 6)) {
1873 : 0 : engine->emit_flush = gen6_render_ring_flush;
1874 : 0 : engine->emit_fini_breadcrumb = gen6_rcs_emit_breadcrumb;
1875 [ # # ]: 0 : } else if (IS_GEN(i915, 5)) {
1876 : 0 : engine->emit_flush = gen4_render_ring_flush;
1877 : : } else {
1878 [ # # ]: 0 : if (INTEL_GEN(i915) < 4)
1879 : 0 : engine->emit_flush = gen2_render_ring_flush;
1880 : : else
1881 : 0 : engine->emit_flush = gen4_render_ring_flush;
1882 : 0 : engine->irq_enable_mask = I915_USER_INTERRUPT;
1883 : : }
1884 : :
1885 [ # # ]: 0 : if (IS_HASWELL(i915))
1886 : 0 : engine->emit_bb_start = hsw_emit_bb_start;
1887 : :
1888 : 0 : engine->resume = rcs_resume;
1889 : 0 : }
1890 : :
1891 : 0 : static void setup_vcs(struct intel_engine_cs *engine)
1892 : : {
1893 : 0 : struct drm_i915_private *i915 = engine->i915;
1894 : :
1895 : 0 : if (INTEL_GEN(i915) >= 6) {
1896 : : /* gen6 bsd needs a special wa for tail updates */
1897 [ # # ]: 0 : if (IS_GEN(i915, 6))
1898 : 0 : engine->set_default_submission = gen6_bsd_set_default_submission;
1899 : 0 : engine->emit_flush = gen6_bsd_ring_flush;
1900 : 0 : engine->irq_enable_mask = GT_BSD_USER_INTERRUPT;
1901 : :
1902 [ # # ]: 0 : if (IS_GEN(i915, 6))
1903 : 0 : engine->emit_fini_breadcrumb = gen6_xcs_emit_breadcrumb;
1904 : : else
1905 : 0 : engine->emit_fini_breadcrumb = gen7_xcs_emit_breadcrumb;
1906 : : } else {
1907 : 0 : engine->emit_flush = bsd_ring_flush;
1908 [ # # ]: 0 : if (IS_GEN(i915, 5))
1909 : 0 : engine->irq_enable_mask = ILK_BSD_USER_INTERRUPT;
1910 : : else
1911 : 0 : engine->irq_enable_mask = I915_BSD_USER_INTERRUPT;
1912 : : }
1913 : : }
1914 : :
1915 : 0 : static void setup_bcs(struct intel_engine_cs *engine)
1916 : : {
1917 : 0 : struct drm_i915_private *i915 = engine->i915;
1918 : :
1919 : 0 : engine->emit_flush = gen6_ring_flush;
1920 : 0 : engine->irq_enable_mask = GT_BLT_USER_INTERRUPT;
1921 : :
1922 : 0 : if (IS_GEN(i915, 6))
1923 : 0 : engine->emit_fini_breadcrumb = gen6_xcs_emit_breadcrumb;
1924 : : else
1925 : 0 : engine->emit_fini_breadcrumb = gen7_xcs_emit_breadcrumb;
1926 : : }
1927 : :
1928 : 0 : static void setup_vecs(struct intel_engine_cs *engine)
1929 : : {
1930 : 0 : struct drm_i915_private *i915 = engine->i915;
1931 : :
1932 : 0 : GEM_BUG_ON(INTEL_GEN(i915) < 7);
1933 : :
1934 : 0 : engine->emit_flush = gen6_ring_flush;
1935 : 0 : engine->irq_enable_mask = PM_VEBOX_USER_INTERRUPT;
1936 : 0 : engine->irq_enable = hsw_vebox_irq_enable;
1937 : 0 : engine->irq_disable = hsw_vebox_irq_disable;
1938 : :
1939 : 0 : engine->emit_fini_breadcrumb = gen7_xcs_emit_breadcrumb;
1940 : 0 : }
1941 : :
1942 : 0 : int intel_ring_submission_setup(struct intel_engine_cs *engine)
1943 : : {
1944 : 0 : struct intel_timeline *timeline;
1945 : 0 : struct intel_ring *ring;
1946 : 0 : int err;
1947 : :
1948 : 0 : setup_common(engine);
1949 : :
1950 [ # # # # : 0 : switch (engine->class) {
# ]
1951 : 0 : case RENDER_CLASS:
1952 : 0 : setup_rcs(engine);
1953 : 0 : break;
1954 : : case VIDEO_DECODE_CLASS:
1955 [ # # ]: 0 : setup_vcs(engine);
1956 : : break;
1957 : : case COPY_ENGINE_CLASS:
1958 [ # # ]: 0 : setup_bcs(engine);
1959 : : break;
1960 : : case VIDEO_ENHANCEMENT_CLASS:
1961 : 0 : setup_vecs(engine);
1962 : : break;
1963 : : default:
1964 : 0 : MISSING_CASE(engine->class);
1965 : 0 : return -ENODEV;
1966 : : }
1967 : :
1968 : 0 : timeline = intel_timeline_create(engine->gt, engine->status_page.vma);
1969 [ # # ]: 0 : if (IS_ERR(timeline)) {
1970 : 0 : err = PTR_ERR(timeline);
1971 : 0 : goto err;
1972 : : }
1973 : 0 : GEM_BUG_ON(timeline->has_initial_breadcrumb);
1974 : :
1975 : 0 : err = intel_timeline_pin(timeline);
1976 [ # # ]: 0 : if (err)
1977 : 0 : goto err_timeline;
1978 : :
1979 : 0 : ring = intel_engine_create_ring(engine, SZ_16K);
1980 [ # # ]: 0 : if (IS_ERR(ring)) {
1981 : 0 : err = PTR_ERR(ring);
1982 : 0 : goto err_timeline_unpin;
1983 : : }
1984 : :
1985 : 0 : err = intel_ring_pin(ring);
1986 [ # # ]: 0 : if (err)
1987 : 0 : goto err_ring;
1988 : :
1989 : 0 : GEM_BUG_ON(engine->legacy.ring);
1990 : 0 : engine->legacy.ring = ring;
1991 : 0 : engine->legacy.timeline = timeline;
1992 : :
1993 : 0 : GEM_BUG_ON(timeline->hwsp_ggtt != engine->status_page.vma);
1994 : :
1995 : : /* Finally, take ownership and responsibility for cleanup! */
1996 : 0 : engine->release = ring_release;
1997 : :
1998 : 0 : return 0;
1999 : :
2000 : : err_ring:
2001 : 0 : intel_ring_put(ring);
2002 : 0 : err_timeline_unpin:
2003 : 0 : intel_timeline_unpin(timeline);
2004 : 0 : err_timeline:
2005 : 0 : intel_timeline_put(timeline);
2006 : 0 : err:
2007 : 0 : intel_engine_cleanup_common(engine);
2008 : 0 : return err;
2009 : : }
|
