1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright © 2019 Intel Corporation
4  */
5 
6 #include "gen7_renderclear.h"
7 #include "i915_drv.h"
8 #include "intel_gpu_commands.h"
9 #include "intel_gt_regs.h"
10 
11 #define GT3_INLINE_DATA_DELAYS 0x1E00
12 #define batch_advance(Y, CS) GEM_BUG_ON((Y)->end != (CS))
13 
14 struct cb_kernel {
15 	const void *data;
16 	u32 size;
17 };
18 
19 #define CB_KERNEL(name) { .data = (name), .size = sizeof(name) }
20 
21 #include "ivb_clear_kernel.c"
22 static const struct cb_kernel cb_kernel_ivb = CB_KERNEL(ivb_clear_kernel);
23 
24 #include "hsw_clear_kernel.c"
25 static const struct cb_kernel cb_kernel_hsw = CB_KERNEL(hsw_clear_kernel);
26 
27 struct batch_chunk {
28 	struct i915_vma *vma;
29 	u32 offset;
30 	u32 *start;
31 	u32 *end;
32 	u32 max_items;
33 };
34 
35 struct batch_vals {
36 	u32 max_threads;
37 	u32 state_start;
38 	u32 surface_start;
39 	u32 surface_height;
40 	u32 surface_width;
41 	u32 size;
42 };
43 
44 static int num_primitives(const struct batch_vals *bv)
45 {
46 	/*
47 	 * We need to saturate the GPU with work in order to dispatch
48 	 * a shader on every HW thread, and clear the thread-local registers.
49 	 * In short, we have to dispatch work faster than the shaders can
50 	 * run in order to fill the EU and occupy each HW thread.
51 	 */
52 	return bv->max_threads;
53 }
54 
55 static void
56 batch_get_defaults(struct drm_i915_private *i915, struct batch_vals *bv)
57 {
58 	if (IS_HASWELL(i915)) {
59 		switch (INTEL_INFO(i915)->gt) {
60 		default:
61 		case 1:
62 			bv->max_threads = 70;
63 			break;
64 		case 2:
65 			bv->max_threads = 140;
66 			break;
67 		case 3:
68 			bv->max_threads = 280;
69 			break;
70 		}
71 		bv->surface_height = 16 * 16;
72 		bv->surface_width = 32 * 2 * 16;
73 	} else {
74 		switch (INTEL_INFO(i915)->gt) {
75 		default:
76 		case 1: /* including vlv */
77 			bv->max_threads = 36;
78 			break;
79 		case 2:
80 			bv->max_threads = 128;
81 			break;
82 		}
83 		bv->surface_height = 16 * 8;
84 		bv->surface_width = 32 * 16;
85 	}
86 	bv->state_start = round_up(SZ_1K + num_primitives(bv) * 64, SZ_4K);
87 	bv->surface_start = bv->state_start + SZ_4K;
88 	bv->size = bv->surface_start + bv->surface_height * bv->surface_width;
89 }
90 
91 static void batch_init(struct batch_chunk *bc,
92 		       struct i915_vma *vma,
93 		       u32 *start, u32 offset, u32 max_bytes)
94 {
95 	bc->vma = vma;
96 	bc->offset = offset;
97 	bc->start = start + bc->offset / sizeof(*bc->start);
98 	bc->end = bc->start;
99 	bc->max_items = max_bytes / sizeof(*bc->start);
100 }
101 
102 static u32 batch_offset(const struct batch_chunk *bc, u32 *cs)
103 {
104 	return (cs - bc->start) * sizeof(*bc->start) + bc->offset;
105 }
106 
107 static u32 batch_addr(const struct batch_chunk *bc)
108 {
109 	return i915_vma_offset(bc->vma);
110 }
111 
112 static void batch_add(struct batch_chunk *bc, const u32 d)
113 {
114 	GEM_BUG_ON((bc->end - bc->start) >= bc->max_items);
115 	*bc->end++ = d;
116 }
117 
118 static u32 *batch_alloc_items(struct batch_chunk *bc, u32 align, u32 items)
119 {
120 	u32 *map;
121 
122 	if (align) {
123 		u32 *end = PTR_ALIGN(bc->end, align);
124 
125 		memset32(bc->end, 0, end - bc->end);
126 		bc->end = end;
127 	}
128 
129 	map = bc->end;
130 	bc->end += items;
131 
132 	return map;
133 }
134 
135 static u32 *batch_alloc_bytes(struct batch_chunk *bc, u32 align, u32 bytes)
136 {
137 	GEM_BUG_ON(!IS_ALIGNED(bytes, sizeof(*bc->start)));
138 	return batch_alloc_items(bc, align, bytes / sizeof(*bc->start));
139 }
140 
141 static u32
142 gen7_fill_surface_state(struct batch_chunk *state,
143 			const u32 dst_offset,
144 			const struct batch_vals *bv)
145 {
146 	u32 surface_h = bv->surface_height;
147 	u32 surface_w = bv->surface_width;
148 	u32 *cs = batch_alloc_items(state, 32, 8);
149 	u32 offset = batch_offset(state, cs);
150 
151 #define SURFACE_2D 1
152 #define SURFACEFORMAT_B8G8R8A8_UNORM 0x0C0
153 #define RENDER_CACHE_READ_WRITE 1
154 
155 	*cs++ = SURFACE_2D << 29 |
156 		(SURFACEFORMAT_B8G8R8A8_UNORM << 18) |
157 		(RENDER_CACHE_READ_WRITE << 8);
158 
159 	*cs++ = batch_addr(state) + dst_offset;
160 
161 	*cs++ = ((surface_h / 4 - 1) << 16) | (surface_w / 4 - 1);
162 	*cs++ = surface_w;
163 	*cs++ = 0;
164 	*cs++ = 0;
165 	*cs++ = 0;
166 #define SHADER_CHANNELS(r, g, b, a) \
167 	(((r) << 25) | ((g) << 22) | ((b) << 19) | ((a) << 16))
168 	*cs++ = SHADER_CHANNELS(4, 5, 6, 7);
169 	batch_advance(state, cs);
170 
171 	return offset;
172 }
173 
174 static u32
175 gen7_fill_binding_table(struct batch_chunk *state,
176 			const struct batch_vals *bv)
177 {
178 	u32 surface_start =
179 		gen7_fill_surface_state(state, bv->surface_start, bv);
180 	u32 *cs = batch_alloc_items(state, 32, 8);
181 	u32 offset = batch_offset(state, cs);
182 
183 	*cs++ = surface_start - state->offset;
184 	*cs++ = 0;
185 	*cs++ = 0;
186 	*cs++ = 0;
187 	*cs++ = 0;
188 	*cs++ = 0;
189 	*cs++ = 0;
190 	*cs++ = 0;
191 	batch_advance(state, cs);
192 
193 	return offset;
194 }
195 
196 static u32
197 gen7_fill_kernel_data(struct batch_chunk *state,
198 		      const u32 *data,
199 		      const u32 size)
200 {
201 	return batch_offset(state,
202 			    memcpy(batch_alloc_bytes(state, 64, size),
203 				   data, size));
204 }
205 
206 static u32
207 gen7_fill_interface_descriptor(struct batch_chunk *state,
208 			       const struct batch_vals *bv,
209 			       const struct cb_kernel *kernel,
210 			       unsigned int count)
211 {
212 	u32 kernel_offset =
213 		gen7_fill_kernel_data(state, kernel->data, kernel->size);
214 	u32 binding_table = gen7_fill_binding_table(state, bv);
215 	u32 *cs = batch_alloc_items(state, 32, 8 * count);
216 	u32 offset = batch_offset(state, cs);
217 
218 	*cs++ = kernel_offset;
219 	*cs++ = (1 << 7) | (1 << 13);
220 	*cs++ = 0;
221 	*cs++ = (binding_table - state->offset) | 1;
222 	*cs++ = 0;
223 	*cs++ = 0;
224 	*cs++ = 0;
225 	*cs++ = 0;
226 
227 	/* 1 - 63dummy idds */
228 	memset32(cs, 0x00, (count - 1) * 8);
229 	batch_advance(state, cs + (count - 1) * 8);
230 
231 	return offset;
232 }
233 
234 static void
235 gen7_emit_state_base_address(struct batch_chunk *batch,
236 			     u32 surface_state_base)
237 {
238 	u32 *cs = batch_alloc_items(batch, 0, 10);
239 
240 	*cs++ = STATE_BASE_ADDRESS | (10 - 2);
241 	/* general */
242 	*cs++ = batch_addr(batch) | BASE_ADDRESS_MODIFY;
243 	/* surface */
244 	*cs++ = (batch_addr(batch) + surface_state_base) | BASE_ADDRESS_MODIFY;
245 	/* dynamic */
246 	*cs++ = batch_addr(batch) | BASE_ADDRESS_MODIFY;
247 	/* indirect */
248 	*cs++ = batch_addr(batch) | BASE_ADDRESS_MODIFY;
249 	/* instruction */
250 	*cs++ = batch_addr(batch) | BASE_ADDRESS_MODIFY;
251 
252 	/* general/dynamic/indirect/instruction access Bound */
253 	*cs++ = 0;
254 	*cs++ = BASE_ADDRESS_MODIFY;
255 	*cs++ = 0;
256 	*cs++ = BASE_ADDRESS_MODIFY;
257 	batch_advance(batch, cs);
258 }
259 
260 static void
261 gen7_emit_vfe_state(struct batch_chunk *batch,
262 		    const struct batch_vals *bv,
263 		    u32 urb_size, u32 curbe_size,
264 		    u32 mode)
265 {
266 	u32 threads = bv->max_threads - 1;
267 	u32 *cs = batch_alloc_items(batch, 32, 8);
268 
269 	*cs++ = MEDIA_VFE_STATE | (8 - 2);
270 
271 	/* scratch buffer */
272 	*cs++ = 0;
273 
274 	/* number of threads & urb entries for GPGPU vs Media Mode */
275 	*cs++ = threads << 16 | 1 << 8 | mode << 2;
276 
277 	*cs++ = 0;
278 
279 	/* urb entry size & curbe size in 256 bits unit */
280 	*cs++ = urb_size << 16 | curbe_size;
281 
282 	/* scoreboard */
283 	*cs++ = 0;
284 	*cs++ = 0;
285 	*cs++ = 0;
286 	batch_advance(batch, cs);
287 }
288 
289 static void
290 gen7_emit_interface_descriptor_load(struct batch_chunk *batch,
291 				    const u32 interface_descriptor,
292 				    unsigned int count)
293 {
294 	u32 *cs = batch_alloc_items(batch, 8, 4);
295 
296 	*cs++ = MEDIA_INTERFACE_DESCRIPTOR_LOAD | (4 - 2);
297 	*cs++ = 0;
298 	*cs++ = count * 8 * sizeof(*cs);
299 
300 	/*
301 	 * interface descriptor address - it is relative to the dynamics base
302 	 * address
303 	 */
304 	*cs++ = interface_descriptor;
305 	batch_advance(batch, cs);
306 }
307 
308 static void
309 gen7_emit_media_object(struct batch_chunk *batch,
310 		       unsigned int media_object_index)
311 {
312 	unsigned int x_offset = (media_object_index % 16) * 64;
313 	unsigned int y_offset = (media_object_index / 16) * 16;
314 	unsigned int pkt = 6 + 3;
315 	u32 *cs;
316 
317 	cs = batch_alloc_items(batch, 8, pkt);
318 
319 	*cs++ = MEDIA_OBJECT | (pkt - 2);
320 
321 	/* interface descriptor offset */
322 	*cs++ = 0;
323 
324 	/* without indirect data */
325 	*cs++ = 0;
326 	*cs++ = 0;
327 
328 	/* scoreboard */
329 	*cs++ = 0;
330 	*cs++ = 0;
331 
332 	/* inline */
333 	*cs++ = y_offset << 16 | x_offset;
334 	*cs++ = 0;
335 	*cs++ = GT3_INLINE_DATA_DELAYS;
336 
337 	batch_advance(batch, cs);
338 }
339 
340 static void gen7_emit_pipeline_flush(struct batch_chunk *batch)
341 {
342 	u32 *cs = batch_alloc_items(batch, 0, 4);
343 
344 	*cs++ = GFX_OP_PIPE_CONTROL(4);
345 	*cs++ = PIPE_CONTROL_RENDER_TARGET_CACHE_FLUSH |
346 		PIPE_CONTROL_DEPTH_CACHE_FLUSH |
347 		PIPE_CONTROL_DC_FLUSH_ENABLE |
348 		PIPE_CONTROL_CS_STALL;
349 	*cs++ = 0;
350 	*cs++ = 0;
351 
352 	batch_advance(batch, cs);
353 }
354 
355 static void gen7_emit_pipeline_invalidate(struct batch_chunk *batch)
356 {
357 	u32 *cs = batch_alloc_items(batch, 0, 10);
358 
359 	/* ivb: Stall before STATE_CACHE_INVALIDATE */
360 	*cs++ = GFX_OP_PIPE_CONTROL(5);
361 	*cs++ = PIPE_CONTROL_STALL_AT_SCOREBOARD |
362 		PIPE_CONTROL_CS_STALL;
363 	*cs++ = 0;
364 	*cs++ = 0;
365 	*cs++ = 0;
366 
367 	*cs++ = GFX_OP_PIPE_CONTROL(5);
368 	*cs++ = PIPE_CONTROL_STATE_CACHE_INVALIDATE;
369 	*cs++ = 0;
370 	*cs++ = 0;
371 	*cs++ = 0;
372 
373 	batch_advance(batch, cs);
374 }
375 
376 static void emit_batch(struct i915_vma * const vma,
377 		       u32 *start,
378 		       const struct batch_vals *bv)
379 {
380 	struct drm_i915_private *i915 = vma->vm->i915;
381 	const unsigned int desc_count = 1;
382 	const unsigned int urb_size = 1;
383 	struct batch_chunk cmds, state;
384 	u32 descriptors;
385 	unsigned int i;
386 
387 	batch_init(&cmds, vma, start, 0, bv->state_start);
388 	batch_init(&state, vma, start, bv->state_start, SZ_4K);
389 
390 	descriptors = gen7_fill_interface_descriptor(&state, bv,
391 						     IS_HASWELL(i915) ?
392 						     &cb_kernel_hsw :
393 						     &cb_kernel_ivb,
394 						     desc_count);
395 
396 	/* Reset inherited context registers */
397 	gen7_emit_pipeline_flush(&cmds);
398 	gen7_emit_pipeline_invalidate(&cmds);
399 	batch_add(&cmds, MI_LOAD_REGISTER_IMM(2));
400 	batch_add(&cmds, i915_mmio_reg_offset(CACHE_MODE_0_GEN7));
401 	batch_add(&cmds, 0xffff0000 |
402 			((IS_IVB_GT1(i915) || IS_VALLEYVIEW(i915)) ?
403 			 HIZ_RAW_STALL_OPT_DISABLE :
404 			 0));
405 	batch_add(&cmds, i915_mmio_reg_offset(CACHE_MODE_1));
406 	batch_add(&cmds, 0xffff0000 | PIXEL_SUBSPAN_COLLECT_OPT_DISABLE);
407 	gen7_emit_pipeline_invalidate(&cmds);
408 	gen7_emit_pipeline_flush(&cmds);
409 
410 	/* Switch to the media pipeline and our base address */
411 	gen7_emit_pipeline_invalidate(&cmds);
412 	batch_add(&cmds, PIPELINE_SELECT | PIPELINE_SELECT_MEDIA);
413 	batch_add(&cmds, MI_NOOP);
414 	gen7_emit_pipeline_invalidate(&cmds);
415 
416 	gen7_emit_pipeline_flush(&cmds);
417 	gen7_emit_state_base_address(&cmds, descriptors);
418 	gen7_emit_pipeline_invalidate(&cmds);
419 
420 	/* Set the clear-residual kernel state */
421 	gen7_emit_vfe_state(&cmds, bv, urb_size - 1, 0, 0);
422 	gen7_emit_interface_descriptor_load(&cmds, descriptors, desc_count);
423 
424 	/* Execute the kernel on all HW threads */
425 	for (i = 0; i < num_primitives(bv); i++)
426 		gen7_emit_media_object(&cmds, i);
427 
428 	batch_add(&cmds, MI_BATCH_BUFFER_END);
429 }
430 
431 int gen7_setup_clear_gpr_bb(struct intel_engine_cs * const engine,
432 			    struct i915_vma * const vma)
433 {
434 	struct batch_vals bv;
435 	u32 *batch;
436 
437 	batch_get_defaults(engine->i915, &bv);
438 	if (!vma)
439 		return bv.size;
440 
441 	GEM_BUG_ON(vma->obj->base.size < bv.size);
442 
443 	batch = i915_gem_object_pin_map(vma->obj, I915_MAP_WC);
444 	if (IS_ERR(batch))
445 		return PTR_ERR(batch);
446 
447 	emit_batch(vma, memset(batch, 0, bv.size), &bv);
448 
449 	i915_gem_object_flush_map(vma->obj);
450 	__i915_gem_object_release_map(vma->obj);
451 
452 	return 0;
453 }
454