1 /*
2 * Copyright © 2014-2017 Broadcom
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
24 #include "util/u_pack_color.h"
25 #include "util/u_upload_mgr.h"
26 #include "util/format_srgb.h"
27
28 #include "v3d_context.h"
29 #include "compiler/v3d_compiler.h"
30 #include "broadcom/cle/v3d_packet_v33_pack.h"
31
32 static uint32_t
get_texrect_scale(struct v3d_texture_stateobj * texstate,enum quniform_contents contents,uint32_t data)33 get_texrect_scale(struct v3d_texture_stateobj *texstate,
34 enum quniform_contents contents,
35 uint32_t data)
36 {
37 struct pipe_sampler_view *texture = texstate->textures[data];
38 uint32_t dim;
39
40 if (contents == QUNIFORM_TEXRECT_SCALE_X)
41 dim = texture->texture->width0;
42 else
43 dim = texture->texture->height0;
44
45 return fui(1.0f / dim);
46 }
47
48 static uint32_t
get_texture_size(struct v3d_texture_stateobj * texstate,enum quniform_contents contents,uint32_t data)49 get_texture_size(struct v3d_texture_stateobj *texstate,
50 enum quniform_contents contents,
51 uint32_t data)
52 {
53 struct pipe_sampler_view *texture = texstate->textures[data];
54
55 switch (contents) {
56 case QUNIFORM_TEXTURE_WIDTH:
57 return u_minify(texture->texture->width0,
58 texture->u.tex.first_level);
59 case QUNIFORM_TEXTURE_HEIGHT:
60 return u_minify(texture->texture->height0,
61 texture->u.tex.first_level);
62 case QUNIFORM_TEXTURE_DEPTH:
63 return u_minify(texture->texture->depth0,
64 texture->u.tex.first_level);
65 case QUNIFORM_TEXTURE_ARRAY_SIZE:
66 return texture->texture->array_size;
67 case QUNIFORM_TEXTURE_LEVELS:
68 return (texture->u.tex.last_level -
69 texture->u.tex.first_level) + 1;
70 default:
71 unreachable("Bad texture size field");
72 }
73 }
74
75 static uint32_t
get_image_size(struct v3d_shaderimg_stateobj * shaderimg,enum quniform_contents contents,uint32_t data)76 get_image_size(struct v3d_shaderimg_stateobj *shaderimg,
77 enum quniform_contents contents,
78 uint32_t data)
79 {
80 struct v3d_image_view *image = &shaderimg->si[data];
81
82 switch (contents) {
83 case QUNIFORM_IMAGE_WIDTH:
84 return u_minify(image->base.resource->width0,
85 image->base.u.tex.level);
86 case QUNIFORM_IMAGE_HEIGHT:
87 return u_minify(image->base.resource->height0,
88 image->base.u.tex.level);
89 case QUNIFORM_IMAGE_DEPTH:
90 return u_minify(image->base.resource->depth0,
91 image->base.u.tex.level);
92 case QUNIFORM_IMAGE_ARRAY_SIZE:
93 return image->base.resource->array_size;
94 default:
95 unreachable("Bad texture size field");
96 }
97 }
98
99 /**
100 * Writes the V3D 3.x P0 (CFG_MODE=1) texture parameter.
101 *
102 * Some bits of this field are dependent on the type of sample being done by
103 * the shader, while other bits are dependent on the sampler state. We OR the
104 * two together here.
105 */
106 static void
write_texture_p0(struct v3d_job * job,struct v3d_cl_out ** uniforms,struct v3d_texture_stateobj * texstate,uint32_t unit,uint32_t shader_data)107 write_texture_p0(struct v3d_job *job,
108 struct v3d_cl_out **uniforms,
109 struct v3d_texture_stateobj *texstate,
110 uint32_t unit,
111 uint32_t shader_data)
112 {
113 struct pipe_sampler_state *psampler = texstate->samplers[unit];
114 struct v3d_sampler_state *sampler = v3d_sampler_state(psampler);
115
116 cl_aligned_u32(uniforms, shader_data | sampler->p0);
117 }
118
119 /** Writes the V3D 3.x P1 (CFG_MODE=1) texture parameter. */
120 static void
write_texture_p1(struct v3d_job * job,struct v3d_cl_out ** uniforms,struct v3d_texture_stateobj * texstate,uint32_t data)121 write_texture_p1(struct v3d_job *job,
122 struct v3d_cl_out **uniforms,
123 struct v3d_texture_stateobj *texstate,
124 uint32_t data)
125 {
126 /* Extract the texture unit from the top bits, and the compiler's
127 * packed p1 from the bottom.
128 */
129 uint32_t unit = data >> 5;
130 uint32_t p1 = data & 0x1f;
131
132 struct pipe_sampler_view *psview = texstate->textures[unit];
133 struct v3d_sampler_view *sview = v3d_sampler_view(psview);
134
135 struct V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1 unpacked = {
136 .texture_state_record_base_address = texstate->texture_state[unit],
137 };
138
139 uint32_t packed;
140 V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1_pack(&job->indirect,
141 (uint8_t *)&packed,
142 &unpacked);
143
144 cl_aligned_u32(uniforms, p1 | packed | sview->p1);
145 }
146
147 /** Writes the V3D 4.x TMU configuration parameter 0. */
148 static void
write_tmu_p0(struct v3d_job * job,struct v3d_cl_out ** uniforms,struct v3d_texture_stateobj * texstate,uint32_t data)149 write_tmu_p0(struct v3d_job *job,
150 struct v3d_cl_out **uniforms,
151 struct v3d_texture_stateobj *texstate,
152 uint32_t data)
153 {
154 int unit = v3d_unit_data_get_unit(data);
155 struct pipe_sampler_view *psview = texstate->textures[unit];
156 struct v3d_sampler_view *sview = v3d_sampler_view(psview);
157 struct v3d_resource *rsc = v3d_resource(sview->texture);
158
159 cl_aligned_reloc(&job->indirect, uniforms, sview->bo,
160 v3d_unit_data_get_offset(data));
161 v3d_job_add_bo(job, rsc->bo);
162 }
163
164 static void
write_image_tmu_p0(struct v3d_job * job,struct v3d_cl_out ** uniforms,struct v3d_shaderimg_stateobj * img,uint32_t data)165 write_image_tmu_p0(struct v3d_job *job,
166 struct v3d_cl_out **uniforms,
167 struct v3d_shaderimg_stateobj *img,
168 uint32_t data)
169 {
170 /* Extract the image unit from the top bits, and the compiler's
171 * packed p0 from the bottom.
172 */
173 uint32_t unit = data >> 24;
174 uint32_t p0 = data & 0x00ffffff;
175
176 struct v3d_image_view *iview = &img->si[unit];
177 struct v3d_resource *rsc = v3d_resource(iview->base.resource);
178
179 cl_aligned_reloc(&job->indirect, uniforms,
180 v3d_resource(iview->tex_state)->bo,
181 iview->tex_state_offset | p0);
182 v3d_job_add_bo(job, rsc->bo);
183 }
184
185 /** Writes the V3D 4.x TMU configuration parameter 1. */
186 static void
write_tmu_p1(struct v3d_job * job,struct v3d_cl_out ** uniforms,struct v3d_texture_stateobj * texstate,uint32_t data)187 write_tmu_p1(struct v3d_job *job,
188 struct v3d_cl_out **uniforms,
189 struct v3d_texture_stateobj *texstate,
190 uint32_t data)
191 {
192 uint32_t unit = v3d_unit_data_get_unit(data);
193 struct pipe_sampler_state *psampler = texstate->samplers[unit];
194 struct v3d_sampler_state *sampler = v3d_sampler_state(psampler);
195 struct pipe_sampler_view *psview = texstate->textures[unit];
196 struct v3d_sampler_view *sview = v3d_sampler_view(psview);
197 int variant = 0;
198
199 if (sampler->border_color_variants)
200 variant = sview->sampler_variant;
201
202 cl_aligned_reloc(&job->indirect, uniforms,
203 v3d_resource(sampler->sampler_state)->bo,
204 sampler->sampler_state_offset[variant] |
205 v3d_unit_data_get_offset(data));
206 }
207
208 struct v3d_cl_reloc
v3d_write_uniforms(struct v3d_context * v3d,struct v3d_job * job,struct v3d_compiled_shader * shader,enum pipe_shader_type stage)209 v3d_write_uniforms(struct v3d_context *v3d, struct v3d_job *job,
210 struct v3d_compiled_shader *shader,
211 enum pipe_shader_type stage)
212 {
213 struct v3d_constbuf_stateobj *cb = &v3d->constbuf[stage];
214 struct v3d_texture_stateobj *texstate = &v3d->tex[stage];
215 struct v3d_uniform_list *uinfo = &shader->prog_data.base->uniforms;
216 const uint32_t *gallium_uniforms = cb->cb[0].user_buffer;
217
218 /* The hardware always pre-fetches the next uniform (also when there
219 * aren't any), so we always allocate space for an extra slot. This
220 * fixes MMU exceptions reported since Linux kernel 5.4 when the
221 * uniforms fill up the tail bytes of a page in the indirect
222 * BO. In that scenario, when the hardware pre-fetches after reading
223 * the last uniform it will read beyond the end of the page and trigger
224 * the MMU exception.
225 */
226 v3d_cl_ensure_space(&job->indirect, (uinfo->count + 1) * 4, 4);
227
228 struct v3d_cl_reloc uniform_stream = cl_get_address(&job->indirect);
229 v3d_bo_reference(uniform_stream.bo);
230
231 struct v3d_cl_out *uniforms =
232 cl_start(&job->indirect);
233
234 for (int i = 0; i < uinfo->count; i++) {
235 uint32_t data = uinfo->data[i];
236
237 switch (uinfo->contents[i]) {
238 case QUNIFORM_CONSTANT:
239 cl_aligned_u32(&uniforms, data);
240 break;
241 case QUNIFORM_UNIFORM:
242 cl_aligned_u32(&uniforms, gallium_uniforms[data]);
243 break;
244 case QUNIFORM_VIEWPORT_X_SCALE:
245 cl_aligned_f(&uniforms, v3d->viewport.scale[0] * 256.0f);
246 break;
247 case QUNIFORM_VIEWPORT_Y_SCALE:
248 cl_aligned_f(&uniforms, v3d->viewport.scale[1] * 256.0f);
249 break;
250
251 case QUNIFORM_VIEWPORT_Z_OFFSET:
252 cl_aligned_f(&uniforms, v3d->viewport.translate[2]);
253 break;
254 case QUNIFORM_VIEWPORT_Z_SCALE:
255 cl_aligned_f(&uniforms, v3d->viewport.scale[2]);
256 break;
257
258 case QUNIFORM_USER_CLIP_PLANE:
259 cl_aligned_f(&uniforms,
260 v3d->clip.ucp[data / 4][data % 4]);
261 break;
262
263 case QUNIFORM_TMU_CONFIG_P0:
264 write_tmu_p0(job, &uniforms, texstate, data);
265 break;
266
267 case QUNIFORM_TMU_CONFIG_P1:
268 write_tmu_p1(job, &uniforms, texstate, data);
269 break;
270
271 case QUNIFORM_IMAGE_TMU_CONFIG_P0:
272 write_image_tmu_p0(job, &uniforms,
273 &v3d->shaderimg[stage], data);
274 break;
275
276 case QUNIFORM_TEXTURE_CONFIG_P1:
277 write_texture_p1(job, &uniforms, texstate,
278 data);
279 break;
280
281 case QUNIFORM_TEXRECT_SCALE_X:
282 case QUNIFORM_TEXRECT_SCALE_Y:
283 cl_aligned_u32(&uniforms,
284 get_texrect_scale(texstate,
285 uinfo->contents[i],
286 data));
287 break;
288
289 case QUNIFORM_TEXTURE_WIDTH:
290 case QUNIFORM_TEXTURE_HEIGHT:
291 case QUNIFORM_TEXTURE_DEPTH:
292 case QUNIFORM_TEXTURE_ARRAY_SIZE:
293 case QUNIFORM_TEXTURE_LEVELS:
294 cl_aligned_u32(&uniforms,
295 get_texture_size(texstate,
296 uinfo->contents[i],
297 data));
298 break;
299
300 case QUNIFORM_IMAGE_WIDTH:
301 case QUNIFORM_IMAGE_HEIGHT:
302 case QUNIFORM_IMAGE_DEPTH:
303 case QUNIFORM_IMAGE_ARRAY_SIZE:
304 cl_aligned_u32(&uniforms,
305 get_image_size(&v3d->shaderimg[stage],
306 uinfo->contents[i],
307 data));
308 break;
309
310 case QUNIFORM_ALPHA_REF:
311 cl_aligned_f(&uniforms,
312 v3d->zsa->base.alpha.ref_value);
313 break;
314
315 case QUNIFORM_LINE_WIDTH:
316 cl_aligned_f(&uniforms,
317 v3d->rasterizer->base.line_width);
318 break;
319
320 case QUNIFORM_AA_LINE_WIDTH:
321 cl_aligned_f(&uniforms, v3d_get_real_line_width(v3d));
322 break;
323
324 case QUNIFORM_UBO_ADDR: {
325 uint32_t unit = v3d_unit_data_get_unit(data);
326 /* Constant buffer 0 may be a system memory pointer,
327 * in which case we want to upload a shadow copy to
328 * the GPU.
329 */
330 if (!cb->cb[unit].buffer) {
331 u_upload_data(v3d->uploader, 0,
332 cb->cb[unit].buffer_size, 16,
333 cb->cb[unit].user_buffer,
334 &cb->cb[unit].buffer_offset,
335 &cb->cb[unit].buffer);
336 }
337
338 cl_aligned_reloc(&job->indirect, &uniforms,
339 v3d_resource(cb->cb[unit].buffer)->bo,
340 cb->cb[unit].buffer_offset +
341 v3d_unit_data_get_offset(data));
342 break;
343 }
344
345 case QUNIFORM_SSBO_OFFSET: {
346 struct pipe_shader_buffer *sb =
347 &v3d->ssbo[stage].sb[data];
348
349 cl_aligned_reloc(&job->indirect, &uniforms,
350 v3d_resource(sb->buffer)->bo,
351 sb->buffer_offset);
352 break;
353 }
354
355 case QUNIFORM_GET_SSBO_SIZE:
356 cl_aligned_u32(&uniforms,
357 v3d->ssbo[stage].sb[data].buffer_size);
358 break;
359
360 case QUNIFORM_TEXTURE_FIRST_LEVEL:
361 cl_aligned_f(&uniforms,
362 texstate->textures[data]->u.tex.first_level);
363 break;
364
365 case QUNIFORM_SPILL_OFFSET:
366 cl_aligned_reloc(&job->indirect, &uniforms,
367 v3d->prog.spill_bo, 0);
368 break;
369
370 case QUNIFORM_SPILL_SIZE_PER_THREAD:
371 cl_aligned_u32(&uniforms,
372 v3d->prog.spill_size_per_thread);
373 break;
374
375 case QUNIFORM_NUM_WORK_GROUPS:
376 cl_aligned_u32(&uniforms,
377 v3d->compute_num_workgroups[data]);
378 break;
379
380 case QUNIFORM_SHARED_OFFSET:
381 cl_aligned_reloc(&job->indirect, &uniforms,
382 v3d->compute_shared_memory, 0);
383 break;
384
385 case QUNIFORM_FB_LAYERS:
386 cl_aligned_u32(&uniforms, job->num_layers);
387 break;
388
389 default:
390 assert(quniform_contents_is_texture_p0(uinfo->contents[i]));
391
392 write_texture_p0(job, &uniforms, texstate,
393 uinfo->contents[i] -
394 QUNIFORM_TEXTURE_CONFIG_P0_0,
395 data);
396 break;
397
398 }
399 #if 0
400 uint32_t written_val = *((uint32_t *)uniforms - 1);
401 fprintf(stderr, "shader %p[%d]: 0x%08x / 0x%08x (%f) ",
402 shader, i, __gen_address_offset(&uniform_stream) + i * 4,
403 written_val, uif(written_val));
404 vir_dump_uniform(uinfo->contents[i], data);
405 fprintf(stderr, "\n");
406 #endif
407 }
408
409 cl_end(&job->indirect, uniforms);
410
411 return uniform_stream;
412 }
413
414 void
v3d_set_shader_uniform_dirty_flags(struct v3d_compiled_shader * shader)415 v3d_set_shader_uniform_dirty_flags(struct v3d_compiled_shader *shader)
416 {
417 uint32_t dirty = 0;
418
419 for (int i = 0; i < shader->prog_data.base->uniforms.count; i++) {
420 switch (shader->prog_data.base->uniforms.contents[i]) {
421 case QUNIFORM_CONSTANT:
422 break;
423 case QUNIFORM_UNIFORM:
424 case QUNIFORM_UBO_ADDR:
425 dirty |= VC5_DIRTY_CONSTBUF;
426 break;
427
428 case QUNIFORM_VIEWPORT_X_SCALE:
429 case QUNIFORM_VIEWPORT_Y_SCALE:
430 case QUNIFORM_VIEWPORT_Z_OFFSET:
431 case QUNIFORM_VIEWPORT_Z_SCALE:
432 dirty |= VC5_DIRTY_VIEWPORT;
433 break;
434
435 case QUNIFORM_USER_CLIP_PLANE:
436 dirty |= VC5_DIRTY_CLIP;
437 break;
438
439 case QUNIFORM_TMU_CONFIG_P0:
440 case QUNIFORM_TMU_CONFIG_P1:
441 case QUNIFORM_TEXTURE_CONFIG_P1:
442 case QUNIFORM_TEXTURE_FIRST_LEVEL:
443 case QUNIFORM_TEXRECT_SCALE_X:
444 case QUNIFORM_TEXRECT_SCALE_Y:
445 case QUNIFORM_TEXTURE_WIDTH:
446 case QUNIFORM_TEXTURE_HEIGHT:
447 case QUNIFORM_TEXTURE_DEPTH:
448 case QUNIFORM_TEXTURE_ARRAY_SIZE:
449 case QUNIFORM_TEXTURE_LEVELS:
450 case QUNIFORM_SPILL_OFFSET:
451 case QUNIFORM_SPILL_SIZE_PER_THREAD:
452 /* We could flag this on just the stage we're
453 * compiling for, but it's not passed in.
454 */
455 dirty |= VC5_DIRTY_FRAGTEX | VC5_DIRTY_VERTTEX |
456 VC5_DIRTY_GEOMTEX | VC5_DIRTY_COMPTEX;
457 break;
458
459 case QUNIFORM_SSBO_OFFSET:
460 case QUNIFORM_GET_SSBO_SIZE:
461 dirty |= VC5_DIRTY_SSBO;
462 break;
463
464 case QUNIFORM_IMAGE_TMU_CONFIG_P0:
465 case QUNIFORM_IMAGE_WIDTH:
466 case QUNIFORM_IMAGE_HEIGHT:
467 case QUNIFORM_IMAGE_DEPTH:
468 case QUNIFORM_IMAGE_ARRAY_SIZE:
469 dirty |= VC5_DIRTY_SHADER_IMAGE;
470 break;
471
472 case QUNIFORM_ALPHA_REF:
473 dirty |= VC5_DIRTY_ZSA;
474 break;
475
476 case QUNIFORM_LINE_WIDTH:
477 case QUNIFORM_AA_LINE_WIDTH:
478 dirty |= VC5_DIRTY_RASTERIZER;
479 break;
480
481 case QUNIFORM_NUM_WORK_GROUPS:
482 case QUNIFORM_SHARED_OFFSET:
483 /* Compute always recalculates uniforms. */
484 break;
485
486 case QUNIFORM_FB_LAYERS:
487 dirty |= VC5_DIRTY_FRAMEBUFFER;
488 break;
489
490 default:
491 assert(quniform_contents_is_texture_p0(shader->prog_data.base->uniforms.contents[i]));
492 dirty |= VC5_DIRTY_FRAGTEX | VC5_DIRTY_VERTTEX |
493 VC5_DIRTY_GEOMTEX | VC5_DIRTY_COMPTEX;
494 break;
495 }
496 }
497
498 shader->uniform_dirty_bits = dirty;
499 }
500