src/gallium/drivers/svga/svga_state.c

   1 /**********************************************************
   2  * Copyright 2008-2009 VMware, Inc.  All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use, copy,
   8  * modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  **********************************************************/
  25
  26 #include "util/u_bitmask.h"
  27 #include "util/u_debug.h"
  28 #include "pipe/p_defines.h"
  29 #include "util/u_memory.h"
  30 #include "draw/draw_context.h"
  31
  32 #include "svga_context.h"
  33 #include "svga_screen.h"
  34 #include "svga_state.h"
  35 #include "svga_draw.h"
  36 #include "svga_cmd.h"
  37 #include "svga_hw_reg.h"
  38
  39 /* This is just enough to decide whether we need to use the draw
  40  * module (swtnl) or not.
  41  */
  42 static const struct svga_tracked_state *need_swtnl_state[] =
  43 {
  44    &svga_update_need_swvfetch,
  45    &svga_update_need_pipeline,
  46    &svga_update_need_swtnl,
  47    NULL
  48 };
  49
  50
  51 /* Atoms to update hardware state prior to emitting a clear or draw
  52  * packet.
  53  */
  54 static const struct svga_tracked_state *hw_clear_state[] =
  55 {
  56    &svga_hw_scissor,
  57    &svga_hw_viewport,
  58    &svga_hw_framebuffer,
  59    NULL
  60 };
  61
  62
  63 /* Atoms to update hardware state prior to emitting a draw packet.
  64  */
  65 static const struct svga_tracked_state *hw_draw_state[] =
  66 {
  67    &svga_need_tgsi_transform,
  68    &svga_hw_fs,
  69    &svga_hw_gs,
  70    &svga_hw_vs,
  71    &svga_hw_rss,
  72    &svga_hw_sampler,           /* VGPU10 */
  73    &svga_hw_sampler_bindings,  /* VGPU10 */
  74    &svga_hw_tss,               /* pre-VGPU10 */
  75    &svga_hw_tss_binding,       /* pre-VGPU10 */
  76    &svga_hw_clip_planes,
  77    &svga_hw_vdecl,
  78    &svga_hw_fs_constants,
  79    &svga_hw_gs_constants,
  80    &svga_hw_vs_constants,
  81    NULL
  82 };
  83
  84
  85 static const struct svga_tracked_state *swtnl_draw_state[] =
  86 {
  87    &svga_update_swtnl_draw,
  88    &svga_update_swtnl_vdecl,
  89    NULL
  90 };
  91
  92 /* Flattens the graph of state dependencies.  Could swap the positions
  93  * of hw_clear_state and need_swtnl_state without breaking anything.
  94  */
  95 static const struct svga_tracked_state **state_levels[] =
  96 {
  97    need_swtnl_state,
  98    hw_clear_state,
  99    hw_draw_state,
 100    swtnl_draw_state
 101 };
 102
 103
 104
 105 static unsigned check_state( unsigned a,
 106                              unsigned b )
 107 {
 108    return (a & b);
 109 }
 110
 111 static void accumulate_state( unsigned *a,
 112                               unsigned b )
 113 {
 114    *a |= b;
 115 }
 116
 117
 118 static void xor_states( unsigned *result,
 119                         unsigned a,
 120                         unsigned b )
 121 {
 122    *result = a ^ b;
 123 }
 124
 125
 126
 127 static enum pipe_error
 128 update_state(struct svga_context *svga,
 129              const struct svga_tracked_state *atoms[],
 130              unsigned *state)
 131 {
 132 #ifdef DEBUG
 133    boolean debug = TRUE;
 134 #else
 135    boolean debug = FALSE;
 136 #endif
 137    enum pipe_error ret = PIPE_OK;
 138    unsigned i;
 139
 140    ret = svga_hwtnl_flush( svga->hwtnl );
 141    if (ret != PIPE_OK)
 142       return ret;
 143
 144    if (debug) {
 145       /* Debug version which enforces various sanity checks on the
 146        * state flags which are generated and checked to help ensure
 147        * state atoms are ordered correctly in the list.
 148        */
 149       unsigned examined, prev;
 150
 151       examined = 0;
 152       prev = *state;
 153
 154       for (i = 0; atoms[i] != NULL; i++) {
 155          unsigned generated;
 156
 157          assert(atoms[i]->dirty);
 158          assert(atoms[i]->update);
 159
 160          if (check_state(*state, atoms[i]->dirty)) {
 161             if (0)
 162                debug_printf("update: %s\n", atoms[i]->name);
 163             ret = atoms[i]->update( svga, *state );
 164             if (ret != PIPE_OK)
 165                return ret;
 166          }
 167
 168          /* generated = (prev ^ state)
 169           * if (examined & generated)
 170           *     fail;
 171           */
 172          xor_states(&generated, prev, *state);
 173          if (check_state(examined, generated)) {
 174             debug_printf("state atom %s generated state already examined\n",
 175                          atoms[i]->name);
 176             assert(0);
 177          }
 178
 179          prev = *state;
 180          accumulate_state(&examined, atoms[i]->dirty);
 181       }
 182    }
 183    else {
 184       for (i = 0; atoms[i] != NULL; i++) {
 185          if (check_state(*state, atoms[i]->dirty)) {
 186             ret = atoms[i]->update( svga, *state );
 187             if (ret != PIPE_OK)
 188                return ret;
 189          }
 190       }
 191    }
 192
 193    return PIPE_OK;
 194 }
 195
 196
 197
 198 enum pipe_error
 199 svga_update_state(struct svga_context *svga, unsigned max_level)
 200 {
 201    struct svga_screen *screen = svga_screen(svga->pipe.screen);
 202    enum pipe_error ret = PIPE_OK;
 203    unsigned i;
 204
 205    /* Check for updates to bound textures.  This can't be done in an
 206     * atom as there is no flag which could provoke this test, and we
 207     * cannot create one.
 208     */
 209    if (svga->state.texture_timestamp != screen->texture_timestamp) {
 210       svga->state.texture_timestamp = screen->texture_timestamp;
 211       svga->dirty |= SVGA_NEW_TEXTURE;
 212    }
 213
 214    for (i = 0; i <= max_level; i++) {
 215       svga->dirty |= svga->state.dirty[i];
 216
 217       if (svga->dirty) {
 218          ret = update_state( svga,
 219                              state_levels[i],
 220                              &svga->dirty );
 221          if (ret != PIPE_OK)
 222             return ret;
 223
 224          svga->state.dirty[i] = 0;
 225       }
 226    }
 227
 228    for (; i < SVGA_STATE_MAX; i++)
 229       svga->state.dirty[i] |= svga->dirty;
 230
 231    svga->dirty = 0;
 232
 233    svga->hud.num_validations++;
 234
 235    return PIPE_OK;
 236 }
 237
 238
 239
 240
 241 void svga_update_state_retry( struct svga_context *svga,
 242                               unsigned max_level )
 243 {
 244    enum pipe_error ret;
 245
 246    ret = svga_update_state( svga, max_level );
 247
 248    if (ret == PIPE_ERROR_OUT_OF_MEMORY) {
 249       svga_context_flush(svga, NULL);
 250       ret = svga_update_state( svga, max_level );
 251    }
 252
 253    assert( ret == PIPE_OK );
 254 }
 255
 256
 257
 258 #define EMIT_RS(_rs, _count, _name, _value)     \
 259 do {                                            \
 260    _rs[_count].state = _name;                   \
 261    _rs[_count].uintValue = _value;              \
 262    _count++;                                    \
 263 } while (0)
 264
 265
 266 /* Setup any hardware state which will be constant through the life of
 267  * a context.
 268  */
 269 enum pipe_error svga_emit_initial_state( struct svga_context *svga )
 270 {
 271    if (svga_have_vgpu10(svga)) {
 272       SVGA3dRasterizerStateId id = util_bitmask_add(svga->rast_object_id_bm);
 273       enum pipe_error ret;
 274
 275       /* XXX preliminary code */
 276       ret = SVGA3D_vgpu10_DefineRasterizerState(svga->swc,
 277                                              id,
 278                                              SVGA3D_FILLMODE_FILL,
 279                                              SVGA3D_CULL_NONE,
 280                                              1, /* frontCounterClockwise */
 281                                              0, /* depthBias */
 282                                              0.0f, /* depthBiasClamp */
 283                                              0.0f, /* slopeScaledDepthBiasClamp */
 284                                              0, /* depthClampEnable */
 285                                              0, /* scissorEnable */
 286                                              0, /* multisampleEnable */
 287                                              0, /* aalineEnable */
 288                                              1.0f, /* lineWidth */
 289                                              0, /* lineStippleEnable */
 290                                              0, /* lineStippleFactor */
 291                                              0, /* lineStipplePattern */
 292                                              0); /* provokingVertexLast */
 293
 294
 295       assert(ret == PIPE_OK);
 296
 297       ret = SVGA3D_vgpu10_SetRasterizerState(svga->swc, id);
 298       return ret;
 299    }
 300    else {
 301       SVGA3dRenderState *rs;
 302       unsigned count = 0;
 303       const unsigned COUNT = 2;
 304       enum pipe_error ret;
 305
 306       ret = SVGA3D_BeginSetRenderState( svga->swc, &rs, COUNT );
 307       if (ret != PIPE_OK)
 308          return ret;
 309
 310       /* Always use D3D style coordinate space as this is the only one
 311        * which is implemented on all backends.
 312        */
 313       EMIT_RS(rs, count, SVGA3D_RS_COORDINATETYPE,
 314               SVGA3D_COORDINATE_LEFTHANDED );
 315       EMIT_RS(rs, count, SVGA3D_RS_FRONTWINDING, SVGA3D_FRONTWINDING_CW );
 316
 317       assert( COUNT == count );
 318       SVGA_FIFOCommitAll( svga->swc );
 319
 320       return PIPE_OK;
 321    }
 322 }