src/mesa/drivers/dri/r300/r300_emit.c

   1 /*
   2 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   3
   4 The Weather Channel (TM) funded Tungsten Graphics to develop the
   5 initial release of the Radeon 8500 driver under the XFree86 license.
   6 This notice must be preserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice (including the
  17 next paragraph) shall be included in all copies or substantial
  18 portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 **************************************************************************/
  29
  30 /**
  31  * \file
  32  *
  33  * \author Keith Whitwell <keith@tungstengraphics.com>
  34  */
  35
  36 #include "glheader.h"
  37 #include "mtypes.h"
  38 #include "colormac.h"
  39 #include "imports.h"
  40 #include "macros.h"
  41 #include "image.h"
  42
  43 #include "swrast_setup/swrast_setup.h"
  44 #include "math/m_translate.h"
  45 #include "tnl/tnl.h"
  46 #include "tnl/t_context.h"
  47
  48 #include "r300_context.h"
  49 #include "radeon_ioctl.h"
  50 #include "r300_state.h"
  51 #include "r300_emit.h"
  52 #include "r300_ioctl.h"
  53
  54 #ifdef USER_BUFFERS
  55 #include "r300_mem.h"
  56 #endif
  57
  58 #if SWIZZLE_X != R300_INPUT_ROUTE_SELECT_X || \
  59     SWIZZLE_Y != R300_INPUT_ROUTE_SELECT_Y || \
  60     SWIZZLE_Z != R300_INPUT_ROUTE_SELECT_Z || \
  61     SWIZZLE_W != R300_INPUT_ROUTE_SELECT_W || \
  62     SWIZZLE_ZERO != R300_INPUT_ROUTE_SELECT_ZERO || \
  63     SWIZZLE_ONE != R300_INPUT_ROUTE_SELECT_ONE
  64 #error Cannot change these!
  65 #endif
  66
  67 #define DEBUG_ALL DEBUG_VERTS
  68
  69 #if defined(USE_X86_ASM)
  70 #define COPY_DWORDS( dst, src, nr )                                     \
  71 do {                                                                    \
  72         int __tmp;                                                      \
  73         __asm__ __volatile__( "rep ; movsl"                             \
  74                               : "=%c" (__tmp), "=D" (dst), "=S" (__tmp) \
  75                               : "0" (nr),                               \
  76                                 "D" ((long)dst),                        \
  77                                 "S" ((long)src) );                      \
  78 } while (0)
  79 #else
  80 #define COPY_DWORDS( dst, src, nr )             \
  81 do {                                            \
  82    int j;                                       \
  83    for ( j = 0 ; j < nr ; j++ )                 \
  84       dst[j] = ((int *)src)[j];                 \
  85    dst += nr;                                   \
  86 } while (0)
  87 #endif
  88
  89 static void r300EmitVec4(GLcontext * ctx,
  90                          struct r300_dma_region *rvb,
  91                          GLvoid * data, int stride, int count)
  92 {
  93         int i;
  94         int *out = (int *)(rvb->address + rvb->start);
  95
  96         if (RADEON_DEBUG & DEBUG_VERTS)
  97                 fprintf(stderr, "%s count %d stride %d\n",
  98                         __FUNCTION__, count, stride);
  99
 100         if (stride == 4)
 101                 COPY_DWORDS(out, data, count);
 102         else
 103                 for (i = 0; i < count; i++) {
 104                         out[0] = *(int *)data;
 105                         out++;
 106                         data += stride;
 107                 }
 108 }
 109
 110 static void r300EmitVec8(GLcontext * ctx,
 111                          struct r300_dma_region *rvb,
 112                          GLvoid * data, int stride, int count)
 113 {
 114         int i;
 115         int *out = (int *)(rvb->address + rvb->start);
 116
 117         if (RADEON_DEBUG & DEBUG_VERTS)
 118                 fprintf(stderr, "%s count %d stride %d\n",
 119                         __FUNCTION__, count, stride);
 120
 121         if (stride == 8)
 122                 COPY_DWORDS(out, data, count * 2);
 123         else
 124                 for (i = 0; i < count; i++) {
 125                         out[0] = *(int *)data;
 126                         out[1] = *(int *)(data + 4);
 127                         out += 2;
 128                         data += stride;
 129                 }
 130 }
 131
 132 static void r300EmitVec12(GLcontext * ctx,
 133                           struct r300_dma_region *rvb,
 134                           GLvoid * data, int stride, int count)
 135 {
 136         int i;
 137         int *out = (int *)(rvb->address + rvb->start);
 138
 139         if (RADEON_DEBUG & DEBUG_VERTS)
 140                 fprintf(stderr, "%s count %d stride %d out %p data %p\n",
 141                         __FUNCTION__, count, stride, (void *)out, (void *)data);
 142
 143         if (stride == 12)
 144                 COPY_DWORDS(out, data, count * 3);
 145         else
 146                 for (i = 0; i < count; i++) {
 147                         out[0] = *(int *)data;
 148                         out[1] = *(int *)(data + 4);
 149                         out[2] = *(int *)(data + 8);
 150                         out += 3;
 151                         data += stride;
 152                 }
 153 }
 154
 155 static void r300EmitVec16(GLcontext * ctx,
 156                           struct r300_dma_region *rvb,
 157                           GLvoid * data, int stride, int count)
 158 {
 159         int i;
 160         int *out = (int *)(rvb->address + rvb->start);
 161
 162         if (RADEON_DEBUG & DEBUG_VERTS)
 163                 fprintf(stderr, "%s count %d stride %d\n",
 164                         __FUNCTION__, count, stride);
 165
 166         if (stride == 16)
 167                 COPY_DWORDS(out, data, count * 4);
 168         else
 169                 for (i = 0; i < count; i++) {
 170                         out[0] = *(int *)data;
 171                         out[1] = *(int *)(data + 4);
 172                         out[2] = *(int *)(data + 8);
 173                         out[3] = *(int *)(data + 12);
 174                         out += 4;
 175                         data += stride;
 176                 }
 177 }
 178
 179 static void r300EmitVec(GLcontext * ctx,
 180                         struct r300_dma_region *rvb,
 181                         GLvoid * data, int size, int stride, int count)
 182 {
 183         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 184
 185         if (RADEON_DEBUG & DEBUG_VERTS)
 186                 fprintf(stderr, "%s count %d size %d stride %d\n",
 187                         __FUNCTION__, count, size, stride);
 188
 189         /* Gets triggered when playing with future_hw_tcl_on ... */
 190         //assert(!rvb->buf);
 191
 192         if (stride == 0) {
 193                 r300AllocDmaRegion(rmesa, rvb, size * 4, 4);
 194                 count = 1;
 195                 rvb->aos_offset = GET_START(rvb);
 196                 rvb->aos_stride = 0;
 197         } else {
 198                 r300AllocDmaRegion(rmesa, rvb, size * count * 4, 4);    /* alignment? */
 199                 rvb->aos_offset = GET_START(rvb);
 200                 rvb->aos_stride = size;
 201         }
 202
 203         /* Emit the data
 204          */
 205         switch (size) {
 206         case 1:
 207                 r300EmitVec4(ctx, rvb, data, stride, count);
 208                 break;
 209         case 2:
 210                 r300EmitVec8(ctx, rvb, data, stride, count);
 211                 break;
 212         case 3:
 213                 r300EmitVec12(ctx, rvb, data, stride, count);
 214                 break;
 215         case 4:
 216                 r300EmitVec16(ctx, rvb, data, stride, count);
 217                 break;
 218         default:
 219                 assert(0);
 220                 _mesa_exit(-1);
 221                 break;
 222         }
 223
 224 }
 225
 226 /* TODO: explain this... */
 227 #define R300_VIR0_AOS_SIZE_SHIFT 0
 228 #define R300_VIR0_AOS_INPUT_SHIFT 8
 229 #define R300_VIR0_AOS_STOP_SHIFT 13
 230 #define R300_VIR0_AOS_TYPE_SHIFT 14
 231 #define R300_VIR0_HIGH_SHIFT 16
 232
 233 // Pack 4 elemets in a 16 bit (aos_size first 8, input next 5, 1 stop bit(Whild gues), aos_type last 2);
 234 static inline GLuint t_vir_pack(GLvector4f ** dt, int *inputs, int i)
 235 {
 236         GLuint dw;
 237         dw = (dt[i]->size - 1) << R300_VIR0_AOS_SIZE_SHIFT;
 238         dw |= inputs[i] << R300_VIR0_AOS_INPUT_SHIFT;
 239         //dw |= t_type(&dt[i]) << R300_VIR0_AOS_TYPE_SHIFT;
 240         return dw;
 241 }
 242
 243 static GLuint t_vir0(uint32_t * dst, GLvector4f ** dt, int *inputs,
 244                      GLint * tab, GLuint nr)
 245 {
 246         GLuint i, dw, dwInternel;
 247
 248         for (i = 0; i + 1 < nr; i += 2) {
 249                 dw = t_vir_pack(dt, inputs, tab[i]);
 250                 dwInternel = t_vir_pack(dt, inputs, tab[i + 1]);
 251                 dw |= dwInternel << R300_VIR0_HIGH_SHIFT;
 252
 253                 if (i + 2 == nr) {
 254                         dw |=
 255                             (1 <<
 256                              (R300_VIR0_AOS_STOP_SHIFT + R300_VIR0_HIGH_SHIFT));
 257                 }
 258                 dst[i >> 1] = dw;       // Is the same as i/2
 259         }
 260
 261         if (nr & 1) {
 262                 dw = t_vir_pack(dt, inputs, tab[nr - 1]);
 263                 dw |= 1 << R300_VIR0_AOS_STOP_SHIFT;
 264
 265                 dst[nr >> 1] = dw;
 266         }
 267
 268         return (nr + 1) >> 1;   // Is the same as (nr+1)/2
 269 }
 270
 271 static GLuint t_swizzle(int swizzle[4])
 272 {
 273         return (swizzle[0] << R300_INPUT_ROUTE_X_SHIFT) |
 274             (swizzle[1] << R300_INPUT_ROUTE_Y_SHIFT) |
 275             (swizzle[2] << R300_INPUT_ROUTE_Z_SHIFT) |
 276             (swizzle[3] << R300_INPUT_ROUTE_W_SHIFT);
 277 }
 278
 279 static GLuint t_vir1(uint32_t * dst, int swizzle[][4], GLuint nr)
 280 {
 281         GLuint i;
 282
 283         for (i = 0; i + 1 < nr; i += 2) {
 284                 dst[i >> 1] = t_swizzle(swizzle[i]) | R300_INPUT_ROUTE_ENABLE;
 285                 dst[i >> 1] |=
 286                     (t_swizzle(swizzle[i + 1]) | R300_INPUT_ROUTE_ENABLE)
 287                     << 16;
 288         }
 289
 290         if (nr & 1)
 291                 dst[nr >> 1] =
 292                     t_swizzle(swizzle[nr - 1]) | R300_INPUT_ROUTE_ENABLE;
 293
 294         return (nr + 1) >> 1;
 295 }
 296
 297 static GLuint t_vic(GLcontext * ctx, GLuint InputsRead)
 298 {
 299         r300ContextPtr r300 = R300_CONTEXT(ctx);
 300         GLuint i, vic_1 = 0;
 301
 302         if (InputsRead & (1 << VERT_ATTRIB_POS))
 303                 vic_1 |= R300_INPUT_CNTL_POS;
 304
 305         if (InputsRead & (1 << VERT_ATTRIB_NORMAL))
 306                 vic_1 |= R300_INPUT_CNTL_NORMAL;
 307
 308         if (InputsRead & (1 << VERT_ATTRIB_COLOR0))
 309                 vic_1 |= R300_INPUT_CNTL_COLOR;
 310
 311         r300->state.texture.tc_count = 0;
 312         for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
 313                 if (InputsRead & (1 << (VERT_ATTRIB_TEX0 + i))) {
 314                         r300->state.texture.tc_count++;
 315                         vic_1 |= R300_INPUT_CNTL_TC0 << i;
 316                 }
 317
 318         return vic_1;
 319 }
 320
 321 /* Emit vertex data to GART memory
 322  * Route inputs to the vertex processor
 323  * This function should never return R300_FALLBACK_TCL when using software tcl.
 324  */
 325
 326 int r300EmitArrays(GLcontext * ctx)
 327 {
 328         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 329         r300ContextPtr r300 = rmesa;
 330         TNLcontext *tnl = TNL_CONTEXT(ctx);
 331         struct vertex_buffer *vb = &tnl->vb;
 332         GLuint nr;
 333         GLuint count = vb->Count;
 334         GLuint i;
 335         GLuint InputsRead = 0, OutputsWritten = 0;
 336         int *inputs = NULL;
 337         int vir_inputs[VERT_ATTRIB_MAX];
 338         GLint tab[VERT_ATTRIB_MAX];
 339         int swizzle[VERT_ATTRIB_MAX][4];
 340
 341         if (hw_tcl_on) {
 342                 struct r300_vertex_program *prog =
 343                     (struct r300_vertex_program *)
 344                     CURRENT_VERTEX_SHADER(ctx);
 345                 inputs = prog->inputs;
 346                 InputsRead = CURRENT_VERTEX_SHADER(ctx)->key.InputsRead;
 347                 OutputsWritten = CURRENT_VERTEX_SHADER(ctx)->key.OutputsWritten;
 348         } else {
 349                 DECLARE_RENDERINPUTS(inputs_bitset);
 350                 inputs = r300->state.sw_tcl_inputs;
 351
 352                 RENDERINPUTS_COPY(inputs_bitset,
 353                                   TNL_CONTEXT(ctx)->render_inputs_bitset);
 354
 355                 assert(RENDERINPUTS_TEST(inputs_bitset, _TNL_ATTRIB_POS));
 356                 InputsRead |= 1 << VERT_ATTRIB_POS;
 357                 OutputsWritten |= 1 << VERT_RESULT_HPOS;
 358
 359                 assert(RENDERINPUTS_TEST(inputs_bitset, _TNL_ATTRIB_NORMAL)
 360                        == 0);
 361
 362                 assert(RENDERINPUTS_TEST(inputs_bitset, _TNL_ATTRIB_COLOR0));
 363                 InputsRead |= 1 << VERT_ATTRIB_COLOR0;
 364                 OutputsWritten |= 1 << VERT_RESULT_COL0;
 365
 366                 if (RENDERINPUTS_TEST(inputs_bitset, _TNL_ATTRIB_COLOR1)) {
 367                         InputsRead |= 1 << VERT_ATTRIB_COLOR1;
 368                         OutputsWritten |= 1 << VERT_RESULT_COL1;
 369                 }
 370
 371                 for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
 372                         if (RENDERINPUTS_TEST
 373                             (inputs_bitset, _TNL_ATTRIB_TEX(i))) {
 374                                 InputsRead |= 1 << (VERT_ATTRIB_TEX0 + i);
 375                                 OutputsWritten |= 1 << (VERT_RESULT_TEX0 + i);
 376                         }
 377
 378                 for (i = 0, nr = 0; i < VERT_ATTRIB_MAX; i++)
 379                         if (InputsRead & (1 << i))
 380                                 inputs[i] = nr++;
 381                         else
 382                                 inputs[i] = -1;
 383
 384                 if (!
 385                     (r300->radeon.radeonScreen->
 386                      chip_flags & RADEON_CHIPSET_TCL)) {
 387                         /* Fixed, apply to vir0 only */
 388                         memcpy(vir_inputs, inputs,
 389                                VERT_ATTRIB_MAX * sizeof(int));
 390                         inputs = vir_inputs;
 391
 392                         if (InputsRead & VERT_ATTRIB_POS)
 393                                 inputs[VERT_ATTRIB_POS] = 0;
 394
 395                         if (InputsRead & (1 << VERT_ATTRIB_COLOR0))
 396                                 inputs[VERT_ATTRIB_COLOR0] = 2;
 397
 398                         if (InputsRead & (1 << VERT_ATTRIB_COLOR1))
 399                                 inputs[VERT_ATTRIB_COLOR1] = 3;
 400
 401                         for (i = VERT_ATTRIB_TEX0; i <= VERT_ATTRIB_TEX7; i++)
 402                                 if (InputsRead & (1 << i))
 403                                         inputs[i] = 6 + (i - VERT_ATTRIB_TEX0);
 404                 }
 405
 406                 RENDERINPUTS_COPY(rmesa->state.render_inputs_bitset,
 407                                   inputs_bitset);
 408         }
 409
 410         assert(InputsRead);
 411         assert(OutputsWritten);
 412
 413         for (i = 0, nr = 0; i < VERT_ATTRIB_MAX; i++)
 414                 if (InputsRead & (1 << i))
 415                         tab[nr++] = i;
 416
 417         if (nr > R300_MAX_AOS_ARRAYS)
 418                 return R300_FALLBACK_TCL;
 419
 420         for (i = 0; i < nr; i++) {
 421                 int ci;
 422                 int comp_size, fix, found = 0;
 423
 424                 swizzle[i][0] = SWIZZLE_ZERO;
 425                 swizzle[i][1] = SWIZZLE_ZERO;
 426                 swizzle[i][2] = SWIZZLE_ZERO;
 427                 swizzle[i][3] = SWIZZLE_ONE;
 428
 429                 for (ci = 0; ci < vb->AttribPtr[tab[i]]->size; ci++)
 430                         swizzle[i][ci] = ci;
 431
 432                 if (r300IsGartMemory(rmesa, vb->AttribPtr[tab[i]]->data, 4)) {
 433                         if (vb->AttribPtr[tab[i]]->stride % 4)
 434                                 return R300_FALLBACK_TCL;
 435
 436                         rmesa->state.aos[i].address =
 437                             (void *)(vb->AttribPtr[tab[i]]->data);
 438                         rmesa->state.aos[i].start = 0;
 439                         rmesa->state.aos[i].aos_offset =
 440                             r300GartOffsetFromVirtual(rmesa,
 441                                                       vb->
 442                                                       AttribPtr[tab[i]]->data);
 443                         rmesa->state.aos[i].aos_stride =
 444                             vb->AttribPtr[tab[i]]->stride / 4;
 445
 446                         rmesa->state.aos[i].aos_size =
 447                             vb->AttribPtr[tab[i]]->size;
 448                 } else {
 449                         r300EmitVec(ctx, &rmesa->state.aos[i],
 450                                     vb->AttribPtr[tab[i]]->data,
 451                                     vb->AttribPtr[tab[i]]->size,
 452                                     vb->AttribPtr[tab[i]]->stride, count);
 453                 }
 454
 455                 rmesa->state.aos[i].aos_size = vb->AttribPtr[tab[i]]->size;
 456
 457                 comp_size = _mesa_sizeof_type(GL_FLOAT);
 458
 459                 for (fix = 0; fix <= 4 - vb->AttribPtr[tab[i]]->size; fix++) {
 460                         if ((rmesa->state.aos[i].aos_offset -
 461                              comp_size * fix) % 4)
 462                                 continue;
 463
 464                         found = 1;
 465                         break;
 466                 }
 467
 468                 if (found) {
 469                         if (fix > 0) {
 470                                 WARN_ONCE("Feeling lucky?\n");
 471                         }
 472
 473                         rmesa->state.aos[i].aos_offset -= comp_size * fix;
 474
 475                         for (ci = 0; ci < vb->AttribPtr[tab[i]]->size; ci++)
 476                                 swizzle[i][ci] += fix;
 477                 } else {
 478                         WARN_ONCE
 479                             ("Cannot handle offset %x with stride %d, comp %d\n",
 480                              rmesa->state.aos[i].aos_offset,
 481                              rmesa->state.aos[i].aos_stride,
 482                              vb->AttribPtr[tab[i]]->size);
 483                         return R300_FALLBACK_TCL;
 484                 }
 485         }
 486
 487         /* setup INPUT_ROUTE */
 488         R300_STATECHANGE(r300, vir[0]);
 489         ((drm_r300_cmd_header_t *) r300->hw.vir[0].cmd)->packet0.count =
 490             t_vir0(&r300->hw.vir[0].cmd[R300_VIR_CNTL_0], vb->AttribPtr,
 491                    inputs, tab, nr);
 492
 493         R300_STATECHANGE(r300, vir[1]);
 494         ((drm_r300_cmd_header_t *) r300->hw.vir[1].cmd)->packet0.count =
 495             t_vir1(&r300->hw.vir[1].cmd[R300_VIR_CNTL_0], swizzle, nr);
 496
 497         /* Set up input_cntl */
 498         /* I don't think this is needed for vertex buffers, but it doesn't hurt anything */
 499         R300_STATECHANGE(r300, vic);
 500         r300->hw.vic.cmd[R300_VIC_CNTL_0] = 0x5555;     /* Hard coded value, no idea what it means */
 501         r300->hw.vic.cmd[R300_VIC_CNTL_1] = t_vic(ctx, InputsRead);
 502
 503         /* Stage 3: VAP output */
 504
 505         R300_STATECHANGE(r300, vof);
 506
 507         r300->hw.vof.cmd[R300_VOF_CNTL_0] = 0;
 508         r300->hw.vof.cmd[R300_VOF_CNTL_1] = 0;
 509
 510         if (OutputsWritten & (1 << VERT_RESULT_HPOS))
 511                 r300->hw.vof.cmd[R300_VOF_CNTL_0] |=
 512                     R300_VAP_OUTPUT_VTX_FMT_0__POS_PRESENT;
 513
 514         if (OutputsWritten & (1 << VERT_RESULT_COL0))
 515                 r300->hw.vof.cmd[R300_VOF_CNTL_0] |=
 516                     R300_VAP_OUTPUT_VTX_FMT_0__COLOR_PRESENT;
 517
 518         if (OutputsWritten & (1 << VERT_RESULT_COL1))
 519                 r300->hw.vof.cmd[R300_VOF_CNTL_0] |=
 520                     R300_VAP_OUTPUT_VTX_FMT_0__COLOR_1_PRESENT;
 521
 522         /*if(OutputsWritten & (1 << VERT_RESULT_BFC0))
 523            r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_2_PRESENT;
 524
 525            if(OutputsWritten & (1 << VERT_RESULT_BFC1))
 526            r300->hw.vof.cmd[R300_VOF_CNTL_0] |= R300_VAP_OUTPUT_VTX_FMT_0__COLOR_3_PRESENT; */
 527         //if(OutputsWritten & (1 << VERT_RESULT_FOGC))
 528
 529         if (OutputsWritten & (1 << VERT_RESULT_PSIZ))
 530                 r300->hw.vof.cmd[R300_VOF_CNTL_0] |=
 531                     R300_VAP_OUTPUT_VTX_FMT_0__PT_SIZE_PRESENT;
 532
 533         for (i = 0; i < ctx->Const.MaxTextureUnits; i++)
 534                 if (OutputsWritten & (1 << (VERT_RESULT_TEX0 + i)))
 535                         r300->hw.vof.cmd[R300_VOF_CNTL_1] |= (4 << (3 * i));
 536
 537         rmesa->state.aos_count = nr;
 538
 539         return R300_FALLBACK_NONE;
 540 }
 541
 542 #ifdef USER_BUFFERS
 543 void r300UseArrays(GLcontext * ctx)
 544 {
 545         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 546         int i;
 547
 548         if (rmesa->state.elt_dma.buf)
 549                 r300_mem_use(rmesa, rmesa->state.elt_dma.buf->id);
 550
 551         for (i = 0; i < rmesa->state.aos_count; i++) {
 552                 if (rmesa->state.aos[i].buf)
 553                         r300_mem_use(rmesa, rmesa->state.aos[i].buf->id);
 554         }
 555 }
 556 #endif
 557
 558 void r300ReleaseArrays(GLcontext * ctx)
 559 {
 560         r300ContextPtr rmesa = R300_CONTEXT(ctx);
 561         int i;
 562
 563         r300ReleaseDmaRegion(rmesa, &rmesa->state.elt_dma, __FUNCTION__);
 564         for (i = 0; i < rmesa->state.aos_count; i++) {
 565                 r300ReleaseDmaRegion(rmesa, &rmesa->state.aos[i], __FUNCTION__);
 566         }
 567 }