src/gallium/drivers/i915simple/i915_state_emit.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include "i915_reg.h"
  30 #include "i915_context.h"
  31 #include "i915_winsys.h"
  32 #include "i915_batch.h"
  33 #include "i915_reg.h"
  34
  35 #include "pipe/p_context.h"
  36 #include "pipe/p_defines.h"
  37
  38 static unsigned translate_format( enum pipe_format format )
  39 {
  40    switch (format) {
  41    case PIPE_FORMAT_A8R8G8B8_UNORM:
  42       return COLOR_BUF_ARGB8888;
  43    case PIPE_FORMAT_R5G6B5_UNORM:
  44       return COLOR_BUF_RGB565;
  45    default:
  46       assert(0);
  47       return 0;
  48    }
  49 }
  50
  51 static unsigned translate_depth_format( enum pipe_format zformat )
  52 {
  53    switch (zformat) {
  54    case PIPE_FORMAT_S8Z24_UNORM:
  55       return DEPTH_FRMT_24_FIXED_8_OTHER;
  56    case PIPE_FORMAT_Z16_UNORM:
  57       return DEPTH_FRMT_16_FIXED;
  58    default:
  59       assert(0);
  60       return 0;
  61    }
  62 }
  63
  64
  65 /**
  66  * Examine framebuffer state to determine width, height.
  67  */
  68 static boolean
  69 framebuffer_size(const struct pipe_framebuffer_state *fb,
  70                  uint *width, uint *height)
  71 {
  72    if (fb->cbufs[0]) {
  73       *width = fb->cbufs[0]->width;
  74       *height = fb->cbufs[0]->height;
  75       return TRUE;
  76    }
  77    else if (fb->zsbuf) {
  78       *width = fb->zsbuf->width;
  79       *height = fb->zsbuf->height;
  80       return TRUE;
  81    }
  82    else {
  83       *width = *height = 0;
  84       return FALSE;
  85    }
  86 }
  87
  88
  89 /* Push the state into the sarea and/or texture memory.
  90  */
  91 void
  92 i915_emit_hardware_state(struct i915_context *i915 )
  93 {
  94    /* XXX: there must be an easier way */
  95    const unsigned dwords = ( 14 +
  96                              7 +
  97                              I915_MAX_DYNAMIC +
  98                              8 +
  99                              2 + I915_TEX_UNITS*3 +
 100                              2 + I915_TEX_UNITS*3 +
 101                              2 + I915_MAX_CONSTANT*4 +
 102 #if 0
 103                              i915->current.program_len +
 104 #else
 105                              i915->fs->program_len +
 106 #endif
 107                              6
 108                            ) * 3/2; /* plus 50% margin */
 109    const unsigned relocs = ( I915_TEX_UNITS +
 110                              3
 111                            ) * 3/2; /* plus 50% margin */
 112
 113 #if 0
 114    debug_printf("i915_emit_hardware_state: %d dwords, %d relocs\n", dwords, relocs);
 115 #endif
 116
 117    if(!BEGIN_BATCH(dwords, relocs)) {
 118       FLUSH_BATCH();
 119       assert(BEGIN_BATCH(dwords, relocs));
 120    }
 121
 122    /* 14 dwords, 0 relocs */
 123    if (i915->hardware_dirty & I915_HW_INVARIENT)
 124    {
 125       OUT_BATCH(_3DSTATE_AA_CMD |
 126                 AA_LINE_ECAAR_WIDTH_ENABLE |
 127                 AA_LINE_ECAAR_WIDTH_1_0 |
 128                 AA_LINE_REGION_WIDTH_ENABLE | AA_LINE_REGION_WIDTH_1_0);
 129
 130       OUT_BATCH(_3DSTATE_DFLT_DIFFUSE_CMD);
 131       OUT_BATCH(0);
 132
 133       OUT_BATCH(_3DSTATE_DFLT_SPEC_CMD);
 134       OUT_BATCH(0);
 135
 136       OUT_BATCH(_3DSTATE_DFLT_Z_CMD);
 137       OUT_BATCH(0);
 138
 139       OUT_BATCH(_3DSTATE_COORD_SET_BINDINGS |
 140                 CSB_TCB(0, 0) |
 141                 CSB_TCB(1, 1) |
 142                 CSB_TCB(2, 2) |
 143                 CSB_TCB(3, 3) |
 144                 CSB_TCB(4, 4) |
 145                 CSB_TCB(5, 5) |
 146                 CSB_TCB(6, 6) |
 147                 CSB_TCB(7, 7));
 148
 149       OUT_BATCH(_3DSTATE_RASTER_RULES_CMD |
 150                 ENABLE_POINT_RASTER_RULE |
 151                 OGL_POINT_RASTER_RULE |
 152                 ENABLE_LINE_STRIP_PROVOKE_VRTX |
 153                 ENABLE_TRI_FAN_PROVOKE_VRTX |
 154                 LINE_STRIP_PROVOKE_VRTX(1) |
 155                 TRI_FAN_PROVOKE_VRTX(2) |
 156                 ENABLE_TEXKILL_3D_4D |
 157                 TEXKILL_4D);
 158
 159       /* Need to initialize this to zero.
 160        */
 161       OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 | I1_LOAD_S(3) | (0));
 162       OUT_BATCH(0);
 163
 164       OUT_BATCH(_3DSTATE_DEPTH_SUBRECT_DISABLE);
 165
 166       /* disable indirect state for now
 167        */
 168       OUT_BATCH(_3DSTATE_LOAD_INDIRECT | 0);
 169       OUT_BATCH(0);
 170    }
 171
 172    /* 7 dwords, 1 relocs */
 173    if (i915->hardware_dirty & I915_HW_IMMEDIATE)
 174    {
 175       OUT_BATCH(_3DSTATE_LOAD_STATE_IMMEDIATE_1 |
 176                 I1_LOAD_S(0) |
 177                 I1_LOAD_S(1) |
 178                 I1_LOAD_S(2) |
 179                 I1_LOAD_S(4) |
 180                 I1_LOAD_S(5) |
 181                 I1_LOAD_S(6) |
 182                 (5));
 183
 184       if(i915->vbo)
 185          OUT_RELOC(i915->vbo,
 186                    I915_BUFFER_ACCESS_READ,
 187                    i915->current.immediate[I915_IMMEDIATE_S0]);
 188       else
 189          /* FIXME: we should not do this */
 190          OUT_BATCH(0);
 191       OUT_BATCH(i915->current.immediate[I915_IMMEDIATE_S1]);
 192       OUT_BATCH(i915->current.immediate[I915_IMMEDIATE_S2]);
 193       OUT_BATCH(i915->current.immediate[I915_IMMEDIATE_S4]);
 194       OUT_BATCH(i915->current.immediate[I915_IMMEDIATE_S5]);
 195       OUT_BATCH(i915->current.immediate[I915_IMMEDIATE_S6]);
 196    }
 197
 198    /* I915_MAX_DYNAMIC dwords, 0 relocs */
 199    if (i915->hardware_dirty & I915_HW_DYNAMIC)
 200    {
 201       int i;
 202       for (i = 0; i < I915_MAX_DYNAMIC; i++) {
 203          OUT_BATCH(i915->current.dynamic[i]);
 204       }
 205    }
 206
 207    /* 8 dwords, 2 relocs */
 208    if (i915->hardware_dirty & I915_HW_STATIC)
 209    {
 210       struct pipe_surface *cbuf_surface = i915->framebuffer.cbufs[0];
 211       struct pipe_surface *depth_surface = i915->framebuffer.zsbuf;
 212
 213       if (cbuf_surface) {
 214          unsigned pitch = (cbuf_surface->pitch * cbuf_surface->cpp);
 215
 216          OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
 217
 218          OUT_BATCH(BUF_3D_ID_COLOR_BACK |
 219                    BUF_3D_PITCH(pitch) |  /* pitch in bytes */
 220                    BUF_3D_USE_FENCE);
 221
 222          OUT_RELOC(cbuf_surface->buffer,
 223                    I915_BUFFER_ACCESS_WRITE,
 224                    0);
 225       }
 226
 227       /* What happens if no zbuf??
 228        */
 229       if (depth_surface) {
 230          unsigned zpitch = (depth_surface->pitch * depth_surface->cpp);
 231
 232          OUT_BATCH(_3DSTATE_BUF_INFO_CMD);
 233
 234          OUT_BATCH(BUF_3D_ID_DEPTH |
 235                    BUF_3D_PITCH(zpitch) |  /* pitch in bytes */
 236                    BUF_3D_USE_FENCE);
 237
 238          OUT_RELOC(depth_surface->buffer,
 239                    I915_BUFFER_ACCESS_WRITE,
 240                    0);
 241       }
 242
 243       {
 244          unsigned cformat, zformat = 0;
 245
 246          if (cbuf_surface)
 247             cformat = cbuf_surface->format;
 248          else
 249             cformat = PIPE_FORMAT_A8R8G8B8_UNORM; /* arbitrary */
 250          cformat = translate_format(cformat);
 251
 252          if (depth_surface)
 253             zformat = translate_depth_format( i915->framebuffer.zsbuf->format );
 254
 255          OUT_BATCH(_3DSTATE_DST_BUF_VARS_CMD);
 256          OUT_BATCH(DSTORG_HORT_BIAS(0x8) | /* .5 */
 257                    DSTORG_VERT_BIAS(0x8) | /* .5 */
 258                    LOD_PRECLAMP_OGL |
 259                    TEX_DEFAULT_COLOR_OGL |
 260                    cformat |
 261                    zformat );
 262       }
 263    }
 264
 265 #if 01
 266       /* texture images */
 267       /* 2 + I915_TEX_UNITS*3 dwords, I915_TEX_UNITS relocs */
 268       if (i915->hardware_dirty & (I915_HW_MAP | I915_HW_SAMPLER))
 269       {
 270          /* XXX: we were refering to sampler state
 271           * (current.sampler_enable_nr) below, but only checking
 272           * I915_HW_MAP above.  Should probably calculate the enabled
 273           * flags separately - but there will be further rework of
 274           * state so perhaps not necessary yet.
 275           */
 276          const uint nr = i915->current.sampler_enable_nr;
 277          if (nr) {
 278             const uint enabled = i915->current.sampler_enable_flags;
 279             uint unit;
 280             uint count = 0;
 281             OUT_BATCH(_3DSTATE_MAP_STATE | (3 * nr));
 282             OUT_BATCH(enabled);
 283             for (unit = 0; unit < I915_TEX_UNITS; unit++) {
 284                if (enabled & (1 << unit)) {
 285                   struct pipe_buffer *buf =
 286                      i915->texture[unit]->buffer;
 287                   uint offset = 0;
 288                   assert(buf);
 289
 290                   count++;
 291
 292                   OUT_RELOC(buf,
 293                             I915_BUFFER_ACCESS_READ,
 294                             offset);
 295                   OUT_BATCH(i915->current.texbuffer[unit][0]); /* MS3 */
 296                   OUT_BATCH(i915->current.texbuffer[unit][1]); /* MS4 */
 297                }
 298             }
 299             assert(count == nr);
 300          }
 301       }
 302 #endif
 303
 304 #if 01
 305    /* samplers */
 306    /* 2 + I915_TEX_UNITS*3 dwords, 0 relocs */
 307    if (i915->hardware_dirty & I915_HW_SAMPLER)
 308    {
 309       if (i915->current.sampler_enable_nr) {
 310          int i;
 311
 312          OUT_BATCH( _3DSTATE_SAMPLER_STATE |
 313                     (3 * i915->current.sampler_enable_nr) );
 314
 315          OUT_BATCH( i915->current.sampler_enable_flags );
 316
 317          for (i = 0; i < I915_TEX_UNITS; i++) {
 318             if (i915->current.sampler_enable_flags & (1<<i)) {
 319                OUT_BATCH( i915->current.sampler[i][0] );
 320                OUT_BATCH( i915->current.sampler[i][1] );
 321                OUT_BATCH( i915->current.sampler[i][2] );
 322             }
 323          }
 324       }
 325    }
 326 #endif
 327
 328    /* constants */
 329    /* 2 + I915_MAX_CONSTANT*4 dwords, 0 relocs */
 330    if (i915->hardware_dirty & I915_HW_PROGRAM)
 331    {
 332       /* Collate the user-defined constants with the fragment shader's
 333        * immediates according to the constant_flags[] array.
 334        */
 335       const uint nr = i915->fs->num_constants;
 336       if (nr) {
 337          uint i;
 338
 339          OUT_BATCH( _3DSTATE_PIXEL_SHADER_CONSTANTS | (nr * 4) );
 340          OUT_BATCH( (1 << (nr - 1)) | ((1 << (nr - 1)) - 1) );
 341
 342          for (i = 0; i < nr; i++) {
 343             const uint *c;
 344             if (i915->fs->constant_flags[i] == I915_CONSTFLAG_USER) {
 345                /* grab user-defined constant */
 346                c = (uint *) i915->current.constants[PIPE_SHADER_FRAGMENT][i];
 347             }
 348             else {
 349                /* emit program constant */
 350                c = (uint *) i915->fs->constants[i];
 351             }
 352 #if 0 /* debug */
 353             {
 354                float *f = (float *) c;
 355                printf("Const %2d: %f %f %f %f %s\n", i, f[0], f[1], f[2], f[3],
 356                       (i915->fs->constant_flags[i] == I915_CONSTFLAG_USER
 357                        ? "user" : "immediate"));
 358             }
 359 #endif
 360             OUT_BATCH(*c++);
 361             OUT_BATCH(*c++);
 362             OUT_BATCH(*c++);
 363             OUT_BATCH(*c++);
 364          }
 365       }
 366    }
 367
 368    /* Fragment program */
 369    /* i915->current.program_len dwords, 0 relocs */
 370    if (i915->hardware_dirty & I915_HW_PROGRAM)
 371    {
 372       uint i;
 373       /* we should always have, at least, a pass-through program */
 374       assert(i915->fs->program_len > 0);
 375       for (i = 0; i < i915->fs->program_len; i++) {
 376          OUT_BATCH(i915->fs->program[i]);
 377       }
 378    }
 379
 380    /* drawing surface size */
 381    /* 6 dwords, 0 relocs */
 382    {
 383       uint w, h;
 384       boolean k = framebuffer_size(&i915->framebuffer, &w, &h);
 385       assert(k);
 386
 387       OUT_BATCH(_3DSTATE_DRAW_RECT_CMD);
 388       OUT_BATCH(0);
 389       OUT_BATCH(0);
 390       OUT_BATCH(((w - 1) & 0xffff) | ((h - 1) << 16));
 391       OUT_BATCH(0);
 392       OUT_BATCH(0);
 393    }
 394
 395
 396    i915->hardware_dirty = 0;
 397 }