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_string.h"
  31 #include "util/u_memory.h"
  32 #include "util/u_helpers.h"
  33
  34 #include "freedreno_state.h"
  35 #include "freedreno_context.h"
  36 #include "freedreno_resource.h"
  37 #include "freedreno_texture.h"
  38 #include "freedreno_gmem.h"
  39 #include "freedreno_util.h"
  40
  41 /* All the generic state handling.. In case of CSO's that are specific
  42  * to the GPU version, when the bind and the delete are common they can
  43  * go in here.
  44  */
  45
  46 static void
  47 fd_set_blend_color(struct pipe_context *pctx,
  48                 const struct pipe_blend_color *blend_color)
  49 {
  50         struct fd_context *ctx = fd_context(pctx);
  51         ctx->blend_color = *blend_color;
  52         ctx->dirty |= FD_DIRTY_BLEND_COLOR;
  53 }
  54
  55 static void
  56 fd_set_stencil_ref(struct pipe_context *pctx,
  57                 const struct pipe_stencil_ref *stencil_ref)
  58 {
  59         struct fd_context *ctx = fd_context(pctx);
  60         ctx->stencil_ref =* stencil_ref;
  61         ctx->dirty |= FD_DIRTY_STENCIL_REF;
  62 }
  63
  64 static void
  65 fd_set_clip_state(struct pipe_context *pctx,
  66                 const struct pipe_clip_state *clip)
  67 {
  68         DBG("TODO: ");
  69 }
  70
  71 static void
  72 fd_set_sample_mask(struct pipe_context *pctx, unsigned sample_mask)
  73 {
  74         struct fd_context *ctx = fd_context(pctx);
  75         ctx->sample_mask = (uint16_t)sample_mask;
  76         ctx->dirty |= FD_DIRTY_SAMPLE_MASK;
  77 }
  78
  79 /* notes from calim on #dri-devel:
  80  * index==0 will be non-UBO (ie. glUniformXYZ()) all packed together padded
  81  * out to vec4's
  82  * I should be able to consider that I own the user_ptr until the next
  83  * set_constant_buffer() call, at which point I don't really care about the
  84  * previous values.
  85  * index>0 will be UBO's.. well, I'll worry about that later
  86  */
  87 static void
  88 fd_set_constant_buffer(struct pipe_context *pctx, uint shader, uint index,
  89                 struct pipe_constant_buffer *cb)
  90 {
  91         struct fd_context *ctx = fd_context(pctx);
  92         struct fd_constbuf_stateobj *so = &ctx->constbuf[shader];
  93
  94         /* Note that the state tracker can unbind constant buffers by
  95          * passing NULL here.
  96          */
  97         if (unlikely(!cb)) {
  98                 so->enabled_mask &= ~(1 << index);
  99                 so->dirty_mask &= ~(1 << index);
 100                 pipe_resource_reference(&so->cb[index].buffer, NULL);
 101                 return;
 102         }
 103
 104         pipe_resource_reference(&so->cb[index].buffer, cb->buffer);
 105         so->cb[index].buffer_offset = cb->buffer_offset;
 106         so->cb[index].buffer_size   = cb->buffer_size;
 107         so->cb[index].user_buffer   = cb->user_buffer;
 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 = &ctx->framebuffer;
 120         unsigned i;
 121
 122         DBG("%d: cbufs[0]=%p, zsbuf=%p", ctx->needs_flush,
 123                         framebuffer->cbufs[0], framebuffer->zsbuf);
 124
 125         fd_context_render(pctx);
 126
 127         for (i = 0; i < framebuffer->nr_cbufs; i++)
 128                 pipe_surface_reference(&cso->cbufs[i], framebuffer->cbufs[i]);
 129         for (; i < ctx->framebuffer.nr_cbufs; i++)
 130                 pipe_surface_reference(&cso->cbufs[i], NULL);
 131
 132         cso->nr_cbufs = framebuffer->nr_cbufs;
 133
 134         if ((cso->width != framebuffer->width) ||
 135                         (cso->height != framebuffer->height))
 136                 ctx->needs_rb_fbd = true;
 137
 138         cso->width = framebuffer->width;
 139         cso->height = framebuffer->height;
 140
 141         pipe_surface_reference(&cso->zsbuf, framebuffer->zsbuf);
 142
 143         ctx->dirty |= FD_DIRTY_FRAMEBUFFER;
 144
 145         ctx->disabled_scissor.minx = 0;
 146         ctx->disabled_scissor.miny = 0;
 147         ctx->disabled_scissor.maxx = cso->width;
 148         ctx->disabled_scissor.maxy = cso->height;
 149
 150         ctx->dirty |= FD_DIRTY_SCISSOR;
 151 }
 152
 153 static void
 154 fd_set_polygon_stipple(struct pipe_context *pctx,
 155                 const struct pipe_poly_stipple *stipple)
 156 {
 157         struct fd_context *ctx = fd_context(pctx);
 158         ctx->stipple = *stipple;
 159         ctx->dirty |= FD_DIRTY_STIPPLE;
 160 }
 161
 162 static void
 163 fd_set_scissor_states(struct pipe_context *pctx,
 164                 unsigned start_slot,
 165                 unsigned num_scissors,
 166                 const struct pipe_scissor_state *scissor)
 167 {
 168         struct fd_context *ctx = fd_context(pctx);
 169
 170         ctx->scissor = *scissor;
 171         ctx->dirty |= FD_DIRTY_SCISSOR;
 172 }
 173
 174 static void
 175 fd_set_viewport_states(struct pipe_context *pctx,
 176                 unsigned start_slot,
 177                 unsigned num_viewports,
 178                 const struct pipe_viewport_state *viewport)
 179 {
 180         struct fd_context *ctx = fd_context(pctx);
 181         ctx->viewport = *viewport;
 182         ctx->dirty |= FD_DIRTY_VIEWPORT;
 183 }
 184
 185 static void
 186 fd_set_vertex_buffers(struct pipe_context *pctx,
 187                 unsigned start_slot, unsigned count,
 188                 const struct pipe_vertex_buffer *vb)
 189 {
 190         struct fd_context *ctx = fd_context(pctx);
 191         struct fd_vertexbuf_stateobj *so = &ctx->vertexbuf;
 192         int i;
 193
 194         /* on a2xx, pitch is encoded in the vtx fetch instruction, so
 195          * we need to mark VTXSTATE as dirty as well to trigger patching
 196          * and re-emitting the vtx shader:
 197          */
 198         for (i = 0; i < count; i++) {
 199                 bool new_enabled = vb && (vb[i].buffer || vb[i].user_buffer);
 200                 bool old_enabled = so->vb[i].buffer || so->vb[i].user_buffer;
 201                 uint32_t new_stride = vb ? vb[i].stride : 0;
 202                 uint32_t old_stride = so->vb[i].stride;
 203                 if ((new_enabled != old_enabled) || (new_stride != old_stride)) {
 204                         ctx->dirty |= FD_DIRTY_VTXSTATE;
 205                         break;
 206                 }
 207         }
 208
 209         util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, start_slot, count);
 210         so->count = util_last_bit(so->enabled_mask);
 211
 212         ctx->dirty |= FD_DIRTY_VTXBUF;
 213 }
 214
 215 static void
 216 fd_set_index_buffer(struct pipe_context *pctx,
 217                 const struct pipe_index_buffer *ib)
 218 {
 219         struct fd_context *ctx = fd_context(pctx);
 220
 221         if (ib) {
 222                 pipe_resource_reference(&ctx->indexbuf.buffer, ib->buffer);
 223                 ctx->indexbuf.index_size = ib->index_size;
 224                 ctx->indexbuf.offset = ib->offset;
 225                 ctx->indexbuf.user_buffer = ib->user_buffer;
 226         } else {
 227                 pipe_resource_reference(&ctx->indexbuf.buffer, NULL);
 228         }
 229
 230         ctx->dirty |= FD_DIRTY_INDEXBUF;
 231 }
 232
 233 static void
 234 fd_blend_state_bind(struct pipe_context *pctx, void *hwcso)
 235 {
 236         struct fd_context *ctx = fd_context(pctx);
 237         ctx->blend = hwcso;
 238         ctx->dirty |= FD_DIRTY_BLEND;
 239 }
 240
 241 static void
 242 fd_blend_state_delete(struct pipe_context *pctx, void *hwcso)
 243 {
 244         FREE(hwcso);
 245 }
 246
 247 static void
 248 fd_rasterizer_state_bind(struct pipe_context *pctx, void *hwcso)
 249 {
 250         struct fd_context *ctx = fd_context(pctx);
 251         ctx->rasterizer = hwcso;
 252         ctx->dirty |= FD_DIRTY_RASTERIZER;
 253 }
 254
 255 static void
 256 fd_rasterizer_state_delete(struct pipe_context *pctx, void *hwcso)
 257 {
 258         FREE(hwcso);
 259 }
 260
 261 static void
 262 fd_zsa_state_bind(struct pipe_context *pctx, void *hwcso)
 263 {
 264         struct fd_context *ctx = fd_context(pctx);
 265         ctx->zsa = hwcso;
 266         ctx->dirty |= FD_DIRTY_ZSA;
 267 }
 268
 269 static void
 270 fd_zsa_state_delete(struct pipe_context *pctx, void *hwcso)
 271 {
 272         FREE(hwcso);
 273 }
 274
 275 static void *
 276 fd_vertex_state_create(struct pipe_context *pctx, unsigned num_elements,
 277                 const struct pipe_vertex_element *elements)
 278 {
 279         struct fd_vertex_stateobj *so = CALLOC_STRUCT(fd_vertex_stateobj);
 280
 281         if (!so)
 282                 return NULL;
 283
 284         memcpy(so->pipe, elements, sizeof(*elements) * num_elements);
 285         so->num_elements = num_elements;
 286
 287         return so;
 288 }
 289
 290 static void
 291 fd_vertex_state_delete(struct pipe_context *pctx, void *hwcso)
 292 {
 293         FREE(hwcso);
 294 }
 295
 296 static void
 297 fd_vertex_state_bind(struct pipe_context *pctx, void *hwcso)
 298 {
 299         struct fd_context *ctx = fd_context(pctx);
 300         ctx->vtx = hwcso;
 301         ctx->dirty |= FD_DIRTY_VTXSTATE;
 302 }
 303
 304 void
 305 fd_state_init(struct pipe_context *pctx)
 306 {
 307         pctx->set_blend_color = fd_set_blend_color;
 308         pctx->set_stencil_ref = fd_set_stencil_ref;
 309         pctx->set_clip_state = fd_set_clip_state;
 310         pctx->set_sample_mask = fd_set_sample_mask;
 311         pctx->set_constant_buffer = fd_set_constant_buffer;
 312         pctx->set_framebuffer_state = fd_set_framebuffer_state;
 313         pctx->set_polygon_stipple = fd_set_polygon_stipple;
 314         pctx->set_scissor_states = fd_set_scissor_states;
 315         pctx->set_viewport_states = fd_set_viewport_states;
 316
 317         pctx->set_vertex_buffers = fd_set_vertex_buffers;
 318         pctx->set_index_buffer = fd_set_index_buffer;
 319
 320         pctx->bind_blend_state = fd_blend_state_bind;
 321         pctx->delete_blend_state = fd_blend_state_delete;
 322
 323         pctx->bind_rasterizer_state = fd_rasterizer_state_bind;
 324         pctx->delete_rasterizer_state = fd_rasterizer_state_delete;
 325
 326         pctx->bind_depth_stencil_alpha_state = fd_zsa_state_bind;
 327         pctx->delete_depth_stencil_alpha_state = fd_zsa_state_delete;
 328
 329         pctx->create_vertex_elements_state = fd_vertex_state_create;
 330         pctx->delete_vertex_elements_state = fd_vertex_state_delete;
 331         pctx->bind_vertex_elements_state = fd_vertex_state_bind;
 332 }