src/gallium/drivers/v3d/v3d_uniforms.c

   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/format_srgb.h"
  26
  27 #include "v3d_context.h"
  28 #include "compiler/v3d_compiler.h"
  29 #include "broadcom/cle/v3d_packet_v33_pack.h"
  30
  31 #if 0
  32
  33 #define SWIZ(x,y,z,w) {          \
  34         PIPE_SWIZZLE_##x, \
  35         PIPE_SWIZZLE_##y, \
  36         PIPE_SWIZZLE_##z, \
  37         PIPE_SWIZZLE_##w  \
  38 }
  39
  40 static void
  41 write_texture_border_color(struct v3d_job *job,
  42                            struct v3d_cl_out **uniforms,
  43                            struct v3d_texture_stateobj *texstate,
  44                            uint32_t unit)
  45 {
  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);
  49         union util_color uc;
  50
  51         const struct util_format_description *tex_format_desc =
  52                 util_format_description(texture->format);
  53
  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++)
  59                         border_color[i] =
  60                                 util_format_linear_to_srgb_float(border_color[i]);
  61         }
  62
  63         /* Turn the border color into the layout of channels that it would
  64          * have when stored as texture contents.
  65          */
  66         float storage_color[4];
  67         util_format_unswizzle_4f(storage_color,
  68                                  border_color,
  69                                  tex_format_desc->swizzle);
  70
  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.
  74          */
  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;
  78         } else {
  79                 switch (rsc->v3d_format) {
  80                 default:
  81                 case VC5_TEXTURE_TYPE_RGBA8888:
  82                         util_pack_color(storage_color,
  83                                         PIPE_FORMAT_R8G8B8A8_UNORM, &uc);
  84                         break;
  85                 case VC5_TEXTURE_TYPE_RGBA4444:
  86                         util_pack_color(storage_color,
  87                                         PIPE_FORMAT_A8B8G8R8_UNORM, &uc);
  88                         break;
  89                 case VC5_TEXTURE_TYPE_RGB565:
  90                         util_pack_color(storage_color,
  91                                         PIPE_FORMAT_B8G8R8A8_UNORM, &uc);
  92                         break;
  93                 case VC5_TEXTURE_TYPE_ALPHA:
  94                         uc.ui[0] = float_to_ubyte(storage_color[0]) << 24;
  95                         break;
  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));
  99                         break;
 100                 }
 101         }
 102
 103         cl_aligned_u32(uniforms, uc.ui[0]);
 104 }
 105 #endif
 106
 107 static uint32_t
 108 get_texrect_scale(struct v3d_texture_stateobj *texstate,
 109                   enum quniform_contents contents,
 110                   uint32_t data)
 111 {
 112         struct pipe_sampler_view *texture = texstate->textures[data];
 113         uint32_t dim;
 114
 115         if (contents == QUNIFORM_TEXRECT_SCALE_X)
 116                 dim = texture->texture->width0;
 117         else
 118                 dim = texture->texture->height0;
 119
 120         return fui(1.0f / dim);
 121 }
 122
 123 static uint32_t
 124 get_texture_size(struct v3d_texture_stateobj *texstate,
 125                  enum quniform_contents contents,
 126                  uint32_t data)
 127 {
 128         struct pipe_sampler_view *texture = texstate->textures[data];
 129
 130         switch (contents) {
 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;
 145         default:
 146                 unreachable("Bad texture size field");
 147         }
 148 }
 149
 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)
 154 {
 155         if (!shader->prog_data.base->ubo_size)
 156                 return NULL;
 157
 158         struct v3d_bo *ubo = v3d_bo_alloc(v3d->screen,
 159                                           shader->prog_data.base->ubo_size,
 160                                           "ubo");
 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);
 167         }
 168
 169         return ubo;
 170 }
 171
 172 /**
 173  *  Writes the V3D 3.x P0 (CFG_MODE=1) texture parameter.
 174  *
 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
 177  * two together here.
 178  */
 179 static void
 180 write_texture_p0(struct v3d_job *job,
 181                  struct v3d_cl_out **uniforms,
 182                  struct v3d_texture_stateobj *texstate,
 183                  uint32_t unit,
 184                  uint32_t shader_data)
 185 {
 186         struct pipe_sampler_state *psampler = texstate->samplers[unit];
 187         struct v3d_sampler_state *sampler = v3d_sampler_state(psampler);
 188
 189         cl_aligned_u32(uniforms, shader_data | sampler->p0);
 190 }
 191
 192 /** Writes the V3D 3.x P1 (CFG_MODE=1) texture parameter. */
 193 static void
 194 write_texture_p1(struct v3d_job *job,
 195                  struct v3d_cl_out **uniforms,
 196                  struct v3d_texture_stateobj *texstate,
 197                  uint32_t data)
 198 {
 199         /* Extract the texture unit from the top bits, and the compiler's
 200          * packed p1 from the bottom.
 201          */
 202         uint32_t unit = data >> 5;
 203         uint32_t p1 = data & 0x1f;
 204
 205         struct pipe_sampler_view *psview = texstate->textures[unit];
 206         struct v3d_sampler_view *sview = v3d_sampler_view(psview);
 207
 208         struct V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1 unpacked = {
 209                 .texture_state_record_base_address = texstate->texture_state[unit],
 210         };
 211
 212         uint32_t packed;
 213         V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1_pack(&job->indirect,
 214                                                          (uint8_t *)&packed,
 215                                                          &unpacked);
 216
 217         cl_aligned_u32(uniforms, p1 | packed | sview->p1);
 218 }
 219
 220 /** Writes the V3D 4.x TMU configuration parameter 0. */
 221 static void
 222 write_tmu_p0(struct v3d_job *job,
 223              struct v3d_cl_out **uniforms,
 224              struct v3d_texture_stateobj *texstate,
 225              uint32_t data)
 226 {
 227         /* Extract the texture unit from the top bits, and the compiler's
 228          * packed p0 from the bottom.
 229          */
 230         uint32_t unit = data >> 24;
 231         uint32_t p0 = data & 0x00ffffff;
 232
 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);
 236
 237         cl_aligned_reloc(&job->indirect, uniforms, sview->bo, p0);
 238         v3d_job_add_bo(job, rsc->bo);
 239 }
 240
 241 /** Writes the V3D 4.x TMU configuration parameter 1. */
 242 static void
 243 write_tmu_p1(struct v3d_job *job,
 244              struct v3d_cl_out **uniforms,
 245              struct v3d_texture_stateobj *texstate,
 246              uint32_t data)
 247 {
 248         /* Extract the texture unit from the top bits, and the compiler's
 249          * packed p1 from the bottom.
 250          */
 251         uint32_t unit = data >> 24;
 252         uint32_t p0 = data & 0x00ffffff;
 253
 254         struct pipe_sampler_state *psampler = texstate->samplers[unit];
 255         struct v3d_sampler_state *sampler = v3d_sampler_state(psampler);
 256
 257         cl_aligned_reloc(&job->indirect, uniforms, sampler->bo, p0);
 258 }
 259
 260 struct v3d_cl_reloc
 261 v3d_write_uniforms(struct v3d_context *v3d, struct v3d_compiled_shader *shader,
 262                    struct v3d_constbuf_stateobj *cb,
 263                    struct v3d_texture_stateobj *texstate)
 264 {
 265         struct v3d_uniform_list *uinfo = &shader->prog_data.base->uniforms;
 266         struct v3d_job *job = v3d->job;
 267         const uint32_t *gallium_uniforms = cb->cb[0].user_buffer;
 268         struct v3d_bo *ubo = v3d_upload_ubo(v3d, shader, gallium_uniforms);
 269
 270         /* We always need to return some space for uniforms, because the HW
 271          * will be prefetching, even if we don't read any in the program.
 272          */
 273         v3d_cl_ensure_space(&job->indirect, MAX2(uinfo->count, 1) * 4, 4);
 274
 275         struct v3d_cl_reloc uniform_stream = cl_get_address(&job->indirect);
 276         v3d_bo_reference(uniform_stream.bo);
 277
 278         struct v3d_cl_out *uniforms =
 279                 cl_start(&job->indirect);
 280
 281         for (int i = 0; i < uinfo->count; i++) {
 282
 283                 switch (uinfo->contents[i]) {
 284                 case QUNIFORM_CONSTANT:
 285                         cl_aligned_u32(&uniforms, uinfo->data[i]);
 286                         break;
 287                 case QUNIFORM_UNIFORM:
 288                         cl_aligned_u32(&uniforms,
 289                                        gallium_uniforms[uinfo->data[i]]);
 290                         break;
 291                 case QUNIFORM_VIEWPORT_X_SCALE:
 292                         cl_aligned_f(&uniforms, v3d->viewport.scale[0] * 256.0f);
 293                         break;
 294                 case QUNIFORM_VIEWPORT_Y_SCALE:
 295                         cl_aligned_f(&uniforms, v3d->viewport.scale[1] * 256.0f);
 296                         break;
 297
 298                 case QUNIFORM_VIEWPORT_Z_OFFSET:
 299                         cl_aligned_f(&uniforms, v3d->viewport.translate[2]);
 300                         break;
 301                 case QUNIFORM_VIEWPORT_Z_SCALE:
 302                         cl_aligned_f(&uniforms, v3d->viewport.scale[2]);
 303                         break;
 304
 305                 case QUNIFORM_USER_CLIP_PLANE:
 306                         cl_aligned_f(&uniforms,
 307                                      v3d->clip.ucp[uinfo->data[i] / 4][uinfo->data[i] % 4]);
 308                         break;
 309
 310                 case QUNIFORM_TMU_CONFIG_P0:
 311                         write_tmu_p0(job, &uniforms, texstate,
 312                                          uinfo->data[i]);
 313                         break;
 314
 315                 case QUNIFORM_TMU_CONFIG_P1:
 316                         write_tmu_p1(job, &uniforms, texstate,
 317                                          uinfo->data[i]);
 318                         break;
 319
 320                 case QUNIFORM_TEXTURE_CONFIG_P1:
 321                         write_texture_p1(job, &uniforms, texstate,
 322                                          uinfo->data[i]);
 323                         break;
 324
 325 #if 0
 326                 case QUNIFORM_TEXTURE_FIRST_LEVEL:
 327                         write_texture_first_level(job, &uniforms, texstate,
 328                                                   uinfo->data[i]);
 329                         break;
 330 #endif
 331
 332                 case QUNIFORM_TEXRECT_SCALE_X:
 333                 case QUNIFORM_TEXRECT_SCALE_Y:
 334                         cl_aligned_u32(&uniforms,
 335                                        get_texrect_scale(texstate,
 336                                                          uinfo->contents[i],
 337                                                          uinfo->data[i]));
 338                         break;
 339
 340                 case QUNIFORM_TEXTURE_WIDTH:
 341                 case QUNIFORM_TEXTURE_HEIGHT:
 342                 case QUNIFORM_TEXTURE_DEPTH:
 343                 case QUNIFORM_TEXTURE_ARRAY_SIZE:
 344                 case QUNIFORM_TEXTURE_LEVELS:
 345                         cl_aligned_u32(&uniforms,
 346                                        get_texture_size(texstate,
 347                                                         uinfo->contents[i],
 348                                                         uinfo->data[i]));
 349                         break;
 350
 351                 case QUNIFORM_ALPHA_REF:
 352                         cl_aligned_f(&uniforms,
 353                                      v3d->zsa->base.alpha.ref_value);
 354                         break;
 355
 356                 case QUNIFORM_SAMPLE_MASK:
 357                         cl_aligned_u32(&uniforms, v3d->sample_mask);
 358                         break;
 359
 360                 case QUNIFORM_UBO_ADDR:
 361                         if (uinfo->data[i] == 0) {
 362                                 cl_aligned_reloc(&job->indirect, &uniforms,
 363                                                  ubo, 0);
 364                         } else {
 365                                 int ubo_index = uinfo->data[i];
 366                                 struct v3d_resource *rsc =
 367                                         v3d_resource(cb->cb[ubo_index].buffer);
 368
 369                                 cl_aligned_reloc(&job->indirect, &uniforms,
 370                                                  rsc->bo,
 371                                                  cb->cb[ubo_index].buffer_offset);
 372                         }
 373                         break;
 374
 375                 case QUNIFORM_TEXTURE_FIRST_LEVEL:
 376                         cl_aligned_f(&uniforms,
 377                                      texstate->textures[uinfo->data[i]]->u.tex.first_level);
 378                         break;
 379
 380                 case QUNIFORM_TEXTURE_BORDER_COLOR:
 381                         /* XXX */
 382                         break;
 383
 384                 case QUNIFORM_SPILL_OFFSET:
 385                         cl_aligned_reloc(&job->indirect, &uniforms,
 386                                          v3d->prog.spill_bo, 0);
 387                         break;
 388
 389                 case QUNIFORM_SPILL_SIZE_PER_THREAD:
 390                         cl_aligned_u32(&uniforms,
 391                                        v3d->prog.spill_size_per_thread);
 392                         break;
 393
 394                 default:
 395                         assert(quniform_contents_is_texture_p0(uinfo->contents[i]));
 396
 397                         write_texture_p0(job, &uniforms, texstate,
 398                                          uinfo->contents[i] -
 399                                          QUNIFORM_TEXTURE_CONFIG_P0_0,
 400                                          uinfo->data[i]);
 401                         break;
 402
 403                 }
 404 #if 0
 405                 uint32_t written_val = *((uint32_t *)uniforms - 1);
 406                 fprintf(stderr, "shader %p[%d]: 0x%08x / 0x%08x (%f)\n",
 407                         shader, i, __gen_address_offset(&uniform_stream) + i * 4,
 408                         written_val, uif(written_val));
 409 #endif
 410         }
 411
 412         cl_end(&job->indirect, uniforms);
 413
 414         v3d_bo_unreference(&ubo);
 415
 416         return uniform_stream;
 417 }
 418
 419 void
 420 v3d_set_shader_uniform_dirty_flags(struct v3d_compiled_shader *shader)
 421 {
 422         uint32_t dirty = 0;
 423
 424         for (int i = 0; i < shader->prog_data.base->uniforms.count; i++) {
 425                 switch (shader->prog_data.base->uniforms.contents[i]) {
 426                 case QUNIFORM_CONSTANT:
 427                         break;
 428                 case QUNIFORM_UNIFORM:
 429                 case QUNIFORM_UBO_ADDR:
 430                         dirty |= VC5_DIRTY_CONSTBUF;
 431                         break;
 432
 433                 case QUNIFORM_VIEWPORT_X_SCALE:
 434                 case QUNIFORM_VIEWPORT_Y_SCALE:
 435                 case QUNIFORM_VIEWPORT_Z_OFFSET:
 436                 case QUNIFORM_VIEWPORT_Z_SCALE:
 437                         dirty |= VC5_DIRTY_VIEWPORT;
 438                         break;
 439
 440                 case QUNIFORM_USER_CLIP_PLANE:
 441                         dirty |= VC5_DIRTY_CLIP;
 442                         break;
 443
 444                 case QUNIFORM_TMU_CONFIG_P0:
 445                 case QUNIFORM_TMU_CONFIG_P1:
 446                 case QUNIFORM_TEXTURE_CONFIG_P1:
 447                 case QUNIFORM_TEXTURE_BORDER_COLOR:
 448                 case QUNIFORM_TEXTURE_FIRST_LEVEL:
 449                 case QUNIFORM_TEXRECT_SCALE_X:
 450                 case QUNIFORM_TEXRECT_SCALE_Y:
 451                 case QUNIFORM_TEXTURE_WIDTH:
 452                 case QUNIFORM_TEXTURE_HEIGHT:
 453                 case QUNIFORM_TEXTURE_DEPTH:
 454                 case QUNIFORM_TEXTURE_ARRAY_SIZE:
 455                 case QUNIFORM_TEXTURE_LEVELS:
 456                 case QUNIFORM_SPILL_OFFSET:
 457                 case QUNIFORM_SPILL_SIZE_PER_THREAD:
 458                         /* We could flag this on just the stage we're
 459                          * compiling for, but it's not passed in.
 460                          */
 461                         dirty |= VC5_DIRTY_FRAGTEX | VC5_DIRTY_VERTTEX;
 462                         break;
 463
 464                 case QUNIFORM_ALPHA_REF:
 465                         dirty |= VC5_DIRTY_ZSA;
 466                         break;
 467
 468                 case QUNIFORM_SAMPLE_MASK:
 469                         dirty |= VC5_DIRTY_SAMPLE_STATE;
 470                         break;
 471
 472                 default:
 473                         assert(quniform_contents_is_texture_p0(shader->prog_data.base->uniforms.contents[i]));
 474                         dirty |= VC5_DIRTY_FRAGTEX | VC5_DIRTY_VERTTEX;
 475                         break;
 476                 }
 477         }
 478
 479         shader->uniform_dirty_bits = dirty;
 480 }