2 * Copyright © 2014-2017 Broadcom
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:
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
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
24 #include "util/u_pack_color.h"
25 #include "util/format_srgb.h"
27 #include "v3d_context.h"
28 #include "compiler/v3d_compiler.h"
29 #include "broadcom/cle/v3d_packet_v33_pack.h"
33 #define SWIZ(x,y,z,w) { \
41 write_texture_border_color(struct v3d_job
*job
,
42 struct v3d_cl_out
**uniforms
,
43 struct v3d_texture_stateobj
*texstate
,
46 struct pipe_sampler_state
*sampler
= texstate
->samplers
[unit
];
47 struct pipe_sampler_view
*texture
= texstate
->textures
[unit
];
48 struct v3d_resource
*rsc
= v3d_resource(texture
->texture
);
51 const struct util_format_description
*tex_format_desc
=
52 util_format_description(texture
->format
);
54 float border_color
[4];
55 for (int i
= 0; i
< 4; i
++)
56 border_color
[i
] = sampler
->border_color
.f
[i
];
57 if (util_format_is_srgb(texture
->format
)) {
58 for (int i
= 0; i
< 3; i
++)
60 util_format_linear_to_srgb_float(border_color
[i
]);
63 /* Turn the border color into the layout of channels that it would
64 * have when stored as texture contents.
66 float storage_color
[4];
67 util_format_unswizzle_4f(storage_color
,
69 tex_format_desc
->swizzle
);
71 /* Now, pack so that when the v3d_format-sampled texture contents are
72 * replaced with our border color, the v3d_get_format_swizzle()
73 * swizzling will get the right channels.
75 if (util_format_is_depth_or_stencil(texture
->format
)) {
76 uc
.ui
[0] = util_pack_z(PIPE_FORMAT_Z24X8_UNORM
,
77 sampler
->border_color
.f
[0]) << 8;
79 switch (rsc
->v3d_format
) {
81 case VC5_TEXTURE_TYPE_RGBA8888
:
82 util_pack_color(storage_color
,
83 PIPE_FORMAT_R8G8B8A8_UNORM
, &uc
);
85 case VC5_TEXTURE_TYPE_RGBA4444
:
86 util_pack_color(storage_color
,
87 PIPE_FORMAT_A8B8G8R8_UNORM
, &uc
);
89 case VC5_TEXTURE_TYPE_RGB565
:
90 util_pack_color(storage_color
,
91 PIPE_FORMAT_B8G8R8A8_UNORM
, &uc
);
93 case VC5_TEXTURE_TYPE_ALPHA
:
94 uc
.ui
[0] = float_to_ubyte(storage_color
[0]) << 24;
96 case VC5_TEXTURE_TYPE_LUMALPHA
:
97 uc
.ui
[0] = ((float_to_ubyte(storage_color
[1]) << 24) |
98 (float_to_ubyte(storage_color
[0]) << 0));
103 cl_aligned_u32(uniforms
, uc
.ui
[0]);
108 get_texrect_scale(struct v3d_texture_stateobj
*texstate
,
109 enum quniform_contents contents
,
112 struct pipe_sampler_view
*texture
= texstate
->textures
[data
];
115 if (contents
== QUNIFORM_TEXRECT_SCALE_X
)
116 dim
= texture
->texture
->width0
;
118 dim
= texture
->texture
->height0
;
120 return fui(1.0f
/ dim
);
124 get_texture_size(struct v3d_texture_stateobj
*texstate
,
125 enum quniform_contents contents
,
128 struct pipe_sampler_view
*texture
= texstate
->textures
[data
];
131 case QUNIFORM_TEXTURE_WIDTH
:
132 return u_minify(texture
->texture
->width0
,
133 texture
->u
.tex
.first_level
);
134 case QUNIFORM_TEXTURE_HEIGHT
:
135 return u_minify(texture
->texture
->height0
,
136 texture
->u
.tex
.first_level
);
137 case QUNIFORM_TEXTURE_DEPTH
:
138 return u_minify(texture
->texture
->depth0
,
139 texture
->u
.tex
.first_level
);
140 case QUNIFORM_TEXTURE_ARRAY_SIZE
:
141 return texture
->texture
->array_size
;
142 case QUNIFORM_TEXTURE_LEVELS
:
143 return (texture
->u
.tex
.last_level
-
144 texture
->u
.tex
.first_level
) + 1;
146 unreachable("Bad texture size field");
150 static struct v3d_bo
*
151 v3d_upload_ubo(struct v3d_context
*v3d
,
152 struct v3d_compiled_shader
*shader
,
153 const uint32_t *gallium_uniforms
)
155 if (!shader
->prog_data
.base
->ubo_size
)
158 struct v3d_bo
*ubo
= v3d_bo_alloc(v3d
->screen
,
159 shader
->prog_data
.base
->ubo_size
,
161 void *data
= v3d_bo_map(ubo
);
162 for (uint32_t i
= 0; i
< shader
->prog_data
.base
->num_ubo_ranges
; i
++) {
163 memcpy(data
+ shader
->prog_data
.base
->ubo_ranges
[i
].dst_offset
,
164 ((const void *)gallium_uniforms
+
165 shader
->prog_data
.base
->ubo_ranges
[i
].src_offset
),
166 shader
->prog_data
.base
->ubo_ranges
[i
].size
);
173 * Writes the V3D 3.x P0 (CFG_MODE=1) texture parameter.
175 * Some bits of this field are dependent on the type of sample being done by
176 * the shader, while other bits are dependent on the sampler state. We OR the
180 write_texture_p0(struct v3d_job
*job
,
181 struct v3d_cl_out
**uniforms
,
182 struct v3d_texture_stateobj
*texstate
,
184 uint32_t shader_data
)
186 struct pipe_sampler_state
*psampler
= texstate
->samplers
[unit
];
187 struct v3d_sampler_state
*sampler
= v3d_sampler_state(psampler
);
189 cl_aligned_u32(uniforms
, shader_data
| sampler
->p0
);
192 /** Writes the V3D 3.x P1 (CFG_MODE=1) texture parameter. */
194 write_texture_p1(struct v3d_job
*job
,
195 struct v3d_cl_out
**uniforms
,
196 struct v3d_texture_stateobj
*texstate
,
199 /* Extract the texture unit from the top bits, and the compiler's
200 * packed p1 from the bottom.
202 uint32_t unit
= data
>> 5;
203 uint32_t p1
= data
& 0x1f;
205 struct pipe_sampler_view
*psview
= texstate
->textures
[unit
];
206 struct v3d_sampler_view
*sview
= v3d_sampler_view(psview
);
208 struct V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1 unpacked
= {
209 .texture_state_record_base_address
= texstate
->texture_state
[unit
],
213 V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1_pack(&job
->indirect
,
217 cl_aligned_u32(uniforms
, p1
| packed
| sview
->p1
);
220 /** Writes the V3D 4.x TMU configuration parameter 0. */
222 write_tmu_p0(struct v3d_job
*job
,
223 struct v3d_cl_out
**uniforms
,
224 struct v3d_texture_stateobj
*texstate
,
227 /* Extract the texture unit from the top bits, and the compiler's
228 * packed p0 from the bottom.
230 uint32_t unit
= data
>> 24;
231 uint32_t p0
= data
& 0x00ffffff;
233 struct pipe_sampler_view
*psview
= texstate
->textures
[unit
];
234 struct v3d_sampler_view
*sview
= v3d_sampler_view(psview
);
235 struct v3d_resource
*rsc
= v3d_resource(psview
->texture
);
237 cl_aligned_reloc(&job
->indirect
, uniforms
, sview
->bo
, p0
);
238 v3d_job_add_bo(job
, rsc
->bo
);
241 /** Writes the V3D 4.x TMU configuration parameter 1. */
243 write_tmu_p1(struct v3d_job
*job
,
244 struct v3d_cl_out
**uniforms
,
245 struct v3d_texture_stateobj
*texstate
,
248 /* Extract the texture unit from the top bits, and the compiler's
249 * packed p1 from the bottom.
251 uint32_t unit
= data
>> 24;
252 uint32_t p0
= data
& 0x00ffffff;
254 struct pipe_sampler_state
*psampler
= texstate
->samplers
[unit
];
255 struct v3d_sampler_state
*sampler
= v3d_sampler_state(psampler
);
257 cl_aligned_reloc(&job
->indirect
, uniforms
, sampler
->bo
, p0
);
261 v3d_write_uniforms(struct v3d_context
*v3d
, struct v3d_compiled_shader
*shader
,
262 enum pipe_shader_type stage
)
264 struct v3d_constbuf_stateobj
*cb
= &v3d
->constbuf
[stage
];
265 struct v3d_texture_stateobj
*texstate
= &v3d
->tex
[stage
];
266 struct v3d_uniform_list
*uinfo
= &shader
->prog_data
.base
->uniforms
;
267 struct v3d_job
*job
= v3d
->job
;
268 const uint32_t *gallium_uniforms
= cb
->cb
[0].user_buffer
;
269 struct v3d_bo
*ubo
= v3d_upload_ubo(v3d
, shader
, gallium_uniforms
);
271 /* We always need to return some space for uniforms, because the HW
272 * will be prefetching, even if we don't read any in the program.
274 v3d_cl_ensure_space(&job
->indirect
, MAX2(uinfo
->count
, 1) * 4, 4);
276 struct v3d_cl_reloc uniform_stream
= cl_get_address(&job
->indirect
);
277 v3d_bo_reference(uniform_stream
.bo
);
279 struct v3d_cl_out
*uniforms
=
280 cl_start(&job
->indirect
);
282 for (int i
= 0; i
< uinfo
->count
; i
++) {
284 switch (uinfo
->contents
[i
]) {
285 case QUNIFORM_CONSTANT
:
286 cl_aligned_u32(&uniforms
, uinfo
->data
[i
]);
288 case QUNIFORM_UNIFORM
:
289 cl_aligned_u32(&uniforms
,
290 gallium_uniforms
[uinfo
->data
[i
]]);
292 case QUNIFORM_VIEWPORT_X_SCALE
:
293 cl_aligned_f(&uniforms
, v3d
->viewport
.scale
[0] * 256.0f
);
295 case QUNIFORM_VIEWPORT_Y_SCALE
:
296 cl_aligned_f(&uniforms
, v3d
->viewport
.scale
[1] * 256.0f
);
299 case QUNIFORM_VIEWPORT_Z_OFFSET
:
300 cl_aligned_f(&uniforms
, v3d
->viewport
.translate
[2]);
302 case QUNIFORM_VIEWPORT_Z_SCALE
:
303 cl_aligned_f(&uniforms
, v3d
->viewport
.scale
[2]);
306 case QUNIFORM_USER_CLIP_PLANE
:
307 cl_aligned_f(&uniforms
,
308 v3d
->clip
.ucp
[uinfo
->data
[i
] / 4][uinfo
->data
[i
] % 4]);
311 case QUNIFORM_TMU_CONFIG_P0
:
312 write_tmu_p0(job
, &uniforms
, texstate
,
316 case QUNIFORM_TMU_CONFIG_P1
:
317 write_tmu_p1(job
, &uniforms
, texstate
,
321 case QUNIFORM_TEXTURE_CONFIG_P1
:
322 write_texture_p1(job
, &uniforms
, texstate
,
327 case QUNIFORM_TEXTURE_FIRST_LEVEL
:
328 write_texture_first_level(job
, &uniforms
, texstate
,
333 case QUNIFORM_TEXRECT_SCALE_X
:
334 case QUNIFORM_TEXRECT_SCALE_Y
:
335 cl_aligned_u32(&uniforms
,
336 get_texrect_scale(texstate
,
341 case QUNIFORM_TEXTURE_WIDTH
:
342 case QUNIFORM_TEXTURE_HEIGHT
:
343 case QUNIFORM_TEXTURE_DEPTH
:
344 case QUNIFORM_TEXTURE_ARRAY_SIZE
:
345 case QUNIFORM_TEXTURE_LEVELS
:
346 cl_aligned_u32(&uniforms
,
347 get_texture_size(texstate
,
352 case QUNIFORM_ALPHA_REF
:
353 cl_aligned_f(&uniforms
,
354 v3d
->zsa
->base
.alpha
.ref_value
);
357 case QUNIFORM_UBO_ADDR
:
358 if (uinfo
->data
[i
] == 0) {
359 cl_aligned_reloc(&job
->indirect
, &uniforms
,
362 int ubo_index
= uinfo
->data
[i
];
363 struct v3d_resource
*rsc
=
364 v3d_resource(cb
->cb
[ubo_index
].buffer
);
366 cl_aligned_reloc(&job
->indirect
, &uniforms
,
368 cb
->cb
[ubo_index
].buffer_offset
);
372 case QUNIFORM_TEXTURE_FIRST_LEVEL
:
373 cl_aligned_f(&uniforms
,
374 texstate
->textures
[uinfo
->data
[i
]]->u
.tex
.first_level
);
377 case QUNIFORM_TEXTURE_BORDER_COLOR
:
381 case QUNIFORM_SPILL_OFFSET
:
382 cl_aligned_reloc(&job
->indirect
, &uniforms
,
383 v3d
->prog
.spill_bo
, 0);
386 case QUNIFORM_SPILL_SIZE_PER_THREAD
:
387 cl_aligned_u32(&uniforms
,
388 v3d
->prog
.spill_size_per_thread
);
392 assert(quniform_contents_is_texture_p0(uinfo
->contents
[i
]));
394 write_texture_p0(job
, &uniforms
, texstate
,
396 QUNIFORM_TEXTURE_CONFIG_P0_0
,
402 uint32_t written_val
= *((uint32_t *)uniforms
- 1);
403 fprintf(stderr
, "shader %p[%d]: 0x%08x / 0x%08x (%f)\n",
404 shader
, i
, __gen_address_offset(&uniform_stream
) + i
* 4,
405 written_val
, uif(written_val
));
409 cl_end(&job
->indirect
, uniforms
);
411 v3d_bo_unreference(&ubo
);
413 return uniform_stream
;
417 v3d_set_shader_uniform_dirty_flags(struct v3d_compiled_shader
*shader
)
421 for (int i
= 0; i
< shader
->prog_data
.base
->uniforms
.count
; i
++) {
422 switch (shader
->prog_data
.base
->uniforms
.contents
[i
]) {
423 case QUNIFORM_CONSTANT
:
425 case QUNIFORM_UNIFORM
:
426 case QUNIFORM_UBO_ADDR
:
427 dirty
|= VC5_DIRTY_CONSTBUF
;
430 case QUNIFORM_VIEWPORT_X_SCALE
:
431 case QUNIFORM_VIEWPORT_Y_SCALE
:
432 case QUNIFORM_VIEWPORT_Z_OFFSET
:
433 case QUNIFORM_VIEWPORT_Z_SCALE
:
434 dirty
|= VC5_DIRTY_VIEWPORT
;
437 case QUNIFORM_USER_CLIP_PLANE
:
438 dirty
|= VC5_DIRTY_CLIP
;
441 case QUNIFORM_TMU_CONFIG_P0
:
442 case QUNIFORM_TMU_CONFIG_P1
:
443 case QUNIFORM_TEXTURE_CONFIG_P1
:
444 case QUNIFORM_TEXTURE_BORDER_COLOR
:
445 case QUNIFORM_TEXTURE_FIRST_LEVEL
:
446 case QUNIFORM_TEXRECT_SCALE_X
:
447 case QUNIFORM_TEXRECT_SCALE_Y
:
448 case QUNIFORM_TEXTURE_WIDTH
:
449 case QUNIFORM_TEXTURE_HEIGHT
:
450 case QUNIFORM_TEXTURE_DEPTH
:
451 case QUNIFORM_TEXTURE_ARRAY_SIZE
:
452 case QUNIFORM_TEXTURE_LEVELS
:
453 case QUNIFORM_SPILL_OFFSET
:
454 case QUNIFORM_SPILL_SIZE_PER_THREAD
:
455 /* We could flag this on just the stage we're
456 * compiling for, but it's not passed in.
458 dirty
|= VC5_DIRTY_FRAGTEX
| VC5_DIRTY_VERTTEX
;
461 case QUNIFORM_ALPHA_REF
:
462 dirty
|= VC5_DIRTY_ZSA
;
466 assert(quniform_contents_is_texture_p0(shader
->prog_data
.base
->uniforms
.contents
[i
]));
467 dirty
|= VC5_DIRTY_FRAGTEX
| VC5_DIRTY_VERTTEX
;
472 shader
->uniform_dirty_bits
= dirty
;