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