src/gallium/drivers/freedreno/freedreno_state.c

   1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
   2
   3 /*
   4  * Copyright (C) 2012 Rob Clark <robclark@freedesktop.org>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rob Clark <robclark@freedesktop.org>
  27  */
  28
  29 #include "pipe/p_state.h"
  30 #include "util/u_dual_blend.h"
  31 #include "util/u_string.h"
  32 #include "util/u_memory.h"
  33 #include "util/u_helpers.h"
  34
  35 #include "freedreno_state.h"
  36 #include "freedreno_context.h"
  37 #include "freedreno_resource.h"
  38 #include "freedreno_texture.h"
  39 #include "freedreno_gmem.h"
  40 #include "freedreno_query_hw.h"
  41 #include "freedreno_util.h"
  42
  43 /* All the generic state handling.. In case of CSO's that are specific
  44  * to the GPU version, when the bind and the delete are common they can
  45  * go in here.
  46  */
  47
  48 static void
  49 fd_set_blend_color(struct pipe_context *pctx,
  50                 const struct pipe_blend_color *blend_color)
  51 {
  52         struct fd_context *ctx = fd_context(pctx);
  53         ctx->blend_color = *blend_color;
  54         ctx->dirty |= FD_DIRTY_BLEND_COLOR;
  55 }
  56
  57 static void
  58 fd_set_stencil_ref(struct pipe_context *pctx,
  59                 const struct pipe_stencil_ref *stencil_ref)
  60 {
  61         struct fd_context *ctx = fd_context(pctx);
  62         ctx->stencil_ref =* stencil_ref;
  63         ctx->dirty |= FD_DIRTY_STENCIL_REF;
  64 }
  65
  66 static void
  67 fd_set_clip_state(struct pipe_context *pctx,
  68                 const struct pipe_clip_state *clip)
  69 {
  70         struct fd_context *ctx = fd_context(pctx);
  71         ctx->ucp = *clip;
  72         ctx->dirty |= FD_DIRTY_UCP;
  73 }
  74
  75 static void
  76 fd_set_sample_mask(struct pipe_context *pctx, unsigned sample_mask)
  77 {
  78         struct fd_context *ctx = fd_context(pctx);
  79         ctx->sample_mask = (uint16_t)sample_mask;
  80         ctx->dirty |= FD_DIRTY_SAMPLE_MASK;
  81 }
  82
  83 /* notes from calim on #dri-devel:
  84  * index==0 will be non-UBO (ie. glUniformXYZ()) all packed together padded
  85  * out to vec4's
  86  * I should be able to consider that I own the user_ptr until the next
  87  * set_constant_buffer() call, at which point I don't really care about the
  88  * previous values.
  89  * index>0 will be UBO's.. well, I'll worry about that later
  90  */
  91 static void
  92 fd_set_constant_buffer(struct pipe_context *pctx, uint shader, uint index,
  93                 const struct pipe_constant_buffer *cb)
  94 {
  95         struct fd_context *ctx = fd_context(pctx);
  96         struct fd_constbuf_stateobj *so = &ctx->constbuf[shader];
  97
  98         util_copy_constant_buffer(&so->cb[index], cb);
  99
 100         /* Note that the state tracker can unbind constant buffers by
 101          * passing NULL here.
 102          */
 103         if (unlikely(!cb)) {
 104                 so->enabled_mask &= ~(1 << index);
 105                 so->dirty_mask &= ~(1 << index);
 106                 return;
 107         }
 108
 109         so->enabled_mask |= 1 << index;
 110         so->dirty_mask |= 1 << index;
 111         ctx->dirty |= FD_DIRTY_CONSTBUF;
 112 }
 113
 114 static void
 115 fd_set_framebuffer_state(struct pipe_context *pctx,
 116                 const struct pipe_framebuffer_state *framebuffer)
 117 {
 118         struct fd_context *ctx = fd_context(pctx);
 119         struct pipe_framebuffer_state *cso;
 120
 121         if (ctx->screen->reorder) {
 122                 struct fd_batch *batch, *old_batch = NULL;
 123
 124                 fd_batch_reference(&old_batch, ctx->batch);
 125
 126                 if (likely(old_batch))
 127                         fd_hw_query_set_stage(old_batch, old_batch->draw, FD_STAGE_NULL);
 128
 129                 batch = fd_batch_from_fb(&ctx->screen->batch_cache, ctx, framebuffer);
 130                 fd_batch_reference(&ctx->batch, NULL);
 131                 fd_reset_wfi(batch);
 132                 ctx->batch = batch;
 133                 ctx->dirty = ~0;
 134
 135                 if (old_batch && old_batch->blit && !old_batch->back_blit) {
 136                         /* for blits, there is not really much point in hanging on
 137                          * to the uncommitted batch (ie. you probably don't blit
 138                          * multiple times to the same surface), so we might as
 139                          * well go ahead and flush this one:
 140                          */
 141                         fd_batch_flush(old_batch, false);
 142                 }
 143
 144                 fd_batch_reference(&old_batch, NULL);
 145         } else {
 146                 DBG("%d: cbufs[0]=%p, zsbuf=%p", ctx->batch->needs_flush,
 147                                 framebuffer->cbufs[0], framebuffer->zsbuf);
 148                 fd_batch_flush(ctx->batch, false);
 149         }
 150
 151         cso = &ctx->batch->framebuffer;
 152
 153         util_copy_framebuffer_state(cso, framebuffer);
 154
 155         ctx->dirty |= FD_DIRTY_FRAMEBUFFER;
 156
 157         ctx->disabled_scissor.minx = 0;
 158         ctx->disabled_scissor.miny = 0;
 159         ctx->disabled_scissor.maxx = cso->width;
 160         ctx->disabled_scissor.maxy = cso->height;
 161
 162         ctx->dirty |= FD_DIRTY_SCISSOR;
 163 }
 164
 165 static void
 166 fd_set_polygon_stipple(struct pipe_context *pctx,
 167                 const struct pipe_poly_stipple *stipple)
 168 {
 169         struct fd_context *ctx = fd_context(pctx);
 170         ctx->stipple = *stipple;
 171         ctx->dirty |= FD_DIRTY_STIPPLE;
 172 }
 173
 174 static void
 175 fd_set_scissor_states(struct pipe_context *pctx,
 176                 unsigned start_slot,
 177                 unsigned num_scissors,
 178                 const struct pipe_scissor_state *scissor)
 179 {
 180         struct fd_context *ctx = fd_context(pctx);
 181
 182         ctx->scissor = *scissor;
 183         ctx->dirty |= FD_DIRTY_SCISSOR;
 184 }
 185
 186 static void
 187 fd_set_viewport_states(struct pipe_context *pctx,
 188                 unsigned start_slot,
 189                 unsigned num_viewports,
 190                 const struct pipe_viewport_state *viewport)
 191 {
 192         struct fd_context *ctx = fd_context(pctx);
 193         ctx->viewport = *viewport;
 194         ctx->dirty |= FD_DIRTY_VIEWPORT;
 195 }
 196
 197 static void
 198 fd_set_vertex_buffers(struct pipe_context *pctx,
 199                 unsigned start_slot, unsigned count,
 200                 const struct pipe_vertex_buffer *vb)
 201 {
 202         struct fd_context *ctx = fd_context(pctx);
 203         struct fd_vertexbuf_stateobj *so = &ctx->vtx.vertexbuf;
 204         int i;
 205
 206         /* on a2xx, pitch is encoded in the vtx fetch instruction, so
 207          * we need to mark VTXSTATE as dirty as well to trigger patching
 208          * and re-emitting the vtx shader:
 209          */
 210         if (ctx->screen->gpu_id < 300) {
 211                 for (i = 0; i < count; i++) {
 212                         bool new_enabled = vb && (vb[i].buffer || vb[i].user_buffer);
 213                         bool old_enabled = so->vb[i].buffer || so->vb[i].user_buffer;
 214                         uint32_t new_stride = vb ? vb[i].stride : 0;
 215                         uint32_t old_stride = so->vb[i].stride;
 216                         if ((new_enabled != old_enabled) || (new_stride != old_stride)) {
 217                                 ctx->dirty |= FD_DIRTY_VTXSTATE;
 218                                 break;
 219                         }
 220                 }
 221         }
 222
 223         util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, start_slot, count);
 224         so->count = util_last_bit(so->enabled_mask);
 225
 226         ctx->dirty |= FD_DIRTY_VTXBUF;
 227 }
 228
 229 static void
 230 fd_set_index_buffer(struct pipe_context *pctx,
 231                 const struct pipe_index_buffer *ib)
 232 {
 233         struct fd_context *ctx = fd_context(pctx);
 234
 235         if (ib) {
 236                 pipe_resource_reference(&ctx->indexbuf.buffer, ib->buffer);
 237                 ctx->indexbuf.index_size = ib->index_size;
 238                 ctx->indexbuf.offset = ib->offset;
 239                 ctx->indexbuf.user_buffer = ib->user_buffer;
 240         } else {
 241                 pipe_resource_reference(&ctx->indexbuf.buffer, NULL);
 242         }
 243
 244         ctx->dirty |= FD_DIRTY_INDEXBUF;
 245 }
 246
 247 static void
 248 fd_blend_state_bind(struct pipe_context *pctx, void *hwcso)
 249 {
 250         struct fd_context *ctx = fd_context(pctx);
 251         struct pipe_blend_state *cso = hwcso;
 252         bool old_is_dual = ctx->blend ?
 253                 ctx->blend->rt[0].blend_enable && util_blend_state_is_dual(ctx->blend, 0) :
 254                 false;
 255         bool new_is_dual = cso ?
 256                 cso->rt[0].blend_enable && util_blend_state_is_dual(cso, 0) :
 257                 false;
 258         ctx->blend = hwcso;
 259         ctx->dirty |= FD_DIRTY_BLEND;
 260         if (old_is_dual != new_is_dual)
 261                 ctx->dirty |= FD_DIRTY_BLEND_DUAL;
 262 }
 263
 264 static void
 265 fd_blend_state_delete(struct pipe_context *pctx, void *hwcso)
 266 {
 267         FREE(hwcso);
 268 }
 269
 270 static void
 271 fd_rasterizer_state_bind(struct pipe_context *pctx, void *hwcso)
 272 {
 273         struct fd_context *ctx = fd_context(pctx);
 274         struct pipe_scissor_state *old_scissor = fd_context_get_scissor(ctx);
 275
 276         ctx->rasterizer = hwcso;
 277         ctx->dirty |= FD_DIRTY_RASTERIZER;
 278
 279         /* if scissor enable bit changed we need to mark scissor
 280          * state as dirty as well:
 281          * NOTE: we can do a shallow compare, since we only care
 282          * if it changed to/from &ctx->disable_scissor
 283          */
 284         if (old_scissor != fd_context_get_scissor(ctx))
 285                 ctx->dirty |= FD_DIRTY_SCISSOR;
 286 }
 287
 288 static void
 289 fd_rasterizer_state_delete(struct pipe_context *pctx, void *hwcso)
 290 {
 291         FREE(hwcso);
 292 }
 293
 294 static void
 295 fd_zsa_state_bind(struct pipe_context *pctx, void *hwcso)
 296 {
 297         struct fd_context *ctx = fd_context(pctx);
 298         ctx->zsa = hwcso;
 299         ctx->dirty |= FD_DIRTY_ZSA;
 300 }
 301
 302 static void
 303 fd_zsa_state_delete(struct pipe_context *pctx, void *hwcso)
 304 {
 305         FREE(hwcso);
 306 }
 307
 308 static void *
 309 fd_vertex_state_create(struct pipe_context *pctx, unsigned num_elements,
 310                 const struct pipe_vertex_element *elements)
 311 {
 312         struct fd_vertex_stateobj *so = CALLOC_STRUCT(fd_vertex_stateobj);
 313
 314         if (!so)
 315                 return NULL;
 316
 317         memcpy(so->pipe, elements, sizeof(*elements) * num_elements);
 318         so->num_elements = num_elements;
 319
 320         return so;
 321 }
 322
 323 static void
 324 fd_vertex_state_delete(struct pipe_context *pctx, void *hwcso)
 325 {
 326         FREE(hwcso);
 327 }
 328
 329 static void
 330 fd_vertex_state_bind(struct pipe_context *pctx, void *hwcso)
 331 {
 332         struct fd_context *ctx = fd_context(pctx);
 333         ctx->vtx.vtx = hwcso;
 334         ctx->dirty |= FD_DIRTY_VTXSTATE;
 335 }
 336
 337 static struct pipe_stream_output_target *
 338 fd_create_stream_output_target(struct pipe_context *pctx,
 339                 struct pipe_resource *prsc, unsigned buffer_offset,
 340                 unsigned buffer_size)
 341 {
 342         struct pipe_stream_output_target *target;
 343         struct fd_resource *rsc = fd_resource(prsc);
 344
 345         target = CALLOC_STRUCT(pipe_stream_output_target);
 346         if (!target)
 347                 return NULL;
 348
 349         pipe_reference_init(&target->reference, 1);
 350         pipe_resource_reference(&target->buffer, prsc);
 351
 352         target->context = pctx;
 353         target->buffer_offset = buffer_offset;
 354         target->buffer_size = buffer_size;
 355
 356         assert(rsc->base.b.target == PIPE_BUFFER);
 357         util_range_add(&rsc->valid_buffer_range,
 358                 buffer_offset, buffer_offset + buffer_size);
 359
 360         return target;
 361 }
 362
 363 static void
 364 fd_stream_output_target_destroy(struct pipe_context *pctx,
 365                 struct pipe_stream_output_target *target)
 366 {
 367         pipe_resource_reference(&target->buffer, NULL);
 368         FREE(target);
 369 }
 370
 371 static void
 372 fd_set_stream_output_targets(struct pipe_context *pctx,
 373                 unsigned num_targets, struct pipe_stream_output_target **targets,
 374                 const unsigned *offsets)
 375 {
 376         struct fd_context *ctx = fd_context(pctx);
 377         struct fd_streamout_stateobj *so = &ctx->streamout;
 378         unsigned i;
 379
 380         debug_assert(num_targets <= ARRAY_SIZE(so->targets));
 381
 382         for (i = 0; i < num_targets; i++) {
 383                 boolean changed = targets[i] != so->targets[i];
 384                 boolean append = (offsets[i] == (unsigned)-1);
 385
 386                 if (!changed && append)
 387                         continue;
 388
 389                 if (!append)
 390                         so->offsets[i] = offsets[i];
 391
 392                 pipe_so_target_reference(&so->targets[i], targets[i]);
 393         }
 394
 395         for (; i < so->num_targets; i++) {
 396                 pipe_so_target_reference(&so->targets[i], NULL);
 397         }
 398
 399         so->num_targets = num_targets;
 400
 401         ctx->dirty |= FD_DIRTY_STREAMOUT;
 402 }
 403
 404 void
 405 fd_state_init(struct pipe_context *pctx)
 406 {
 407         pctx->set_blend_color = fd_set_blend_color;
 408         pctx->set_stencil_ref = fd_set_stencil_ref;
 409         pctx->set_clip_state = fd_set_clip_state;
 410         pctx->set_sample_mask = fd_set_sample_mask;
 411         pctx->set_constant_buffer = fd_set_constant_buffer;
 412         pctx->set_framebuffer_state = fd_set_framebuffer_state;
 413         pctx->set_polygon_stipple = fd_set_polygon_stipple;
 414         pctx->set_scissor_states = fd_set_scissor_states;
 415         pctx->set_viewport_states = fd_set_viewport_states;
 416
 417         pctx->set_vertex_buffers = fd_set_vertex_buffers;
 418         pctx->set_index_buffer = fd_set_index_buffer;
 419
 420         pctx->bind_blend_state = fd_blend_state_bind;
 421         pctx->delete_blend_state = fd_blend_state_delete;
 422
 423         pctx->bind_rasterizer_state = fd_rasterizer_state_bind;
 424         pctx->delete_rasterizer_state = fd_rasterizer_state_delete;
 425
 426         pctx->bind_depth_stencil_alpha_state = fd_zsa_state_bind;
 427         pctx->delete_depth_stencil_alpha_state = fd_zsa_state_delete;
 428
 429         pctx->create_vertex_elements_state = fd_vertex_state_create;
 430         pctx->delete_vertex_elements_state = fd_vertex_state_delete;
 431         pctx->bind_vertex_elements_state = fd_vertex_state_bind;
 432
 433         pctx->create_stream_output_target = fd_create_stream_output_target;
 434         pctx->stream_output_target_destroy = fd_stream_output_target_destroy;
 435         pctx->set_stream_output_targets = fd_set_stream_output_targets;
 436 }