src/gallium/drivers/svga/svga_cmd_vgpu10.c

   1 /**********************************************************
   2  * Copyright 2008-2013 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 /**
  27  * @file svga_cmd_vgpu10.c
  28  *
  29  * Command construction utility for the vgpu10 SVGA3D protocol.
  30  *
  31  * \author Mingcheng Chen
  32  * \author Brian Paul
  33  */
  34
  35
  36 #include "svga_winsys.h"
  37 #include "svga_resource_buffer.h"
  38 #include "svga_resource_texture.h"
  39 #include "svga_surface.h"
  40 #include "svga_cmd.h"
  41
  42
  43 /**
  44  * Emit a surface relocation for RenderTargetViewId
  45  */
  46 static void
  47 view_relocation(struct svga_winsys_context *swc, // IN
  48                 struct pipe_surface *surface,    // IN
  49                 SVGA3dRenderTargetViewId *id,    // OUT
  50                 unsigned flags)
  51 {
  52    if (surface) {
  53       struct svga_surface *s = svga_surface(surface);
  54       assert(s->handle);
  55       swc->surface_relocation(swc, id, NULL, s->handle, flags);
  56    }
  57    else {
  58       swc->surface_relocation(swc, id, NULL, NULL, flags);
  59    }
  60 }
  61
  62
  63 /**
  64  * Emit a surface relocation for a ResourceId.
  65  */
  66 static void
  67 surface_to_resourceid(struct svga_winsys_context *swc, // IN
  68                       struct svga_winsys_surface *surface,    // IN
  69                       SVGA3dSurfaceId *sid,            // OUT
  70                       unsigned flags)                  // IN
  71 {
  72    if (surface) {
  73       swc->surface_relocation(swc, sid, NULL, surface, flags);
  74    }
  75    else {
  76       swc->surface_relocation(swc, sid, NULL, NULL, flags);
  77    }
  78 }
  79
  80
  81 #define SVGA3D_CREATE_COMMAND(CommandName, CommandCode) \
  82 SVGA3dCmdDX##CommandName *cmd; \
  83 { \
  84    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_##CommandCode, \
  85                             sizeof(SVGA3dCmdDX##CommandName), 0); \
  86    if (!cmd) \
  87       return PIPE_ERROR_OUT_OF_MEMORY; \
  88 }
  89
  90 #define SVGA3D_CREATE_CMD_COUNT(CommandName, CommandCode, ElementClassName) \
  91 SVGA3dCmdDX##CommandName *cmd; \
  92 { \
  93    assert(count > 0); \
  94    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_##CommandCode, \
  95                             sizeof(SVGA3dCmdDX##CommandName) + \
  96                             count * sizeof(ElementClassName), 0); \
  97    if (!cmd) \
  98       return PIPE_ERROR_OUT_OF_MEMORY; \
  99 }
 100
 101 #define SVGA3D_COPY_BASIC(VariableName) \
 102 { \
 103    cmd->VariableName = VariableName; \
 104 }
 105
 106 #define SVGA3D_COPY_BASIC_2(VariableName1, VariableName2) \
 107 { \
 108    SVGA3D_COPY_BASIC(VariableName1); \
 109    SVGA3D_COPY_BASIC(VariableName2); \
 110 }
 111
 112 #define SVGA3D_COPY_BASIC_3(VariableName1, VariableName2, VariableName3) \
 113 { \
 114    SVGA3D_COPY_BASIC_2(VariableName1, VariableName2); \
 115    SVGA3D_COPY_BASIC(VariableName3); \
 116 }
 117
 118 #define SVGA3D_COPY_BASIC_4(VariableName1, VariableName2, VariableName3, \
 119                             VariableName4) \
 120 { \
 121    SVGA3D_COPY_BASIC_2(VariableName1, VariableName2); \
 122    SVGA3D_COPY_BASIC_2(VariableName3, VariableName4); \
 123 }
 124
 125 #define SVGA3D_COPY_BASIC_5(VariableName1, VariableName2, VariableName3, \
 126                             VariableName4, VariableName5) \
 127 {\
 128    SVGA3D_COPY_BASIC_3(VariableName1, VariableName2, VariableName3); \
 129    SVGA3D_COPY_BASIC_2(VariableName4, VariableName5); \
 130 }
 131
 132 #define SVGA3D_COPY_BASIC_6(VariableName1, VariableName2, VariableName3, \
 133                             VariableName4, VariableName5, VariableName6) \
 134 {\
 135    SVGA3D_COPY_BASIC_3(VariableName1, VariableName2, VariableName3); \
 136    SVGA3D_COPY_BASIC_3(VariableName4, VariableName5, VariableName6); \
 137 }
 138
 139 #define SVGA3D_COPY_BASIC_7(VariableName1, VariableName2, VariableName3, \
 140                             VariableName4, VariableName5, VariableName6, \
 141                             VariableName7) \
 142 {\
 143    SVGA3D_COPY_BASIC_4(VariableName1, VariableName2, VariableName3, \
 144                        VariableName4); \
 145    SVGA3D_COPY_BASIC_3(VariableName5, VariableName6, VariableName7); \
 146 }
 147
 148 #define SVGA3D_COPY_BASIC_8(VariableName1, VariableName2, VariableName3, \
 149                             VariableName4, VariableName5, VariableName6, \
 150                             VariableName7, VariableName8) \
 151 {\
 152    SVGA3D_COPY_BASIC_4(VariableName1, VariableName2, VariableName3, \
 153                        VariableName4); \
 154    SVGA3D_COPY_BASIC_4(VariableName5, VariableName6, VariableName7, \
 155                        VariableName8); \
 156 }
 157
 158 #define SVGA3D_COPY_BASIC_9(VariableName1, VariableName2, VariableName3, \
 159                             VariableName4, VariableName5, VariableName6, \
 160                             VariableName7, VariableName8, VariableName9) \
 161 {\
 162    SVGA3D_COPY_BASIC_5(VariableName1, VariableName2, VariableName3, \
 163                        VariableName4, VariableName5); \
 164    SVGA3D_COPY_BASIC_4(VariableName6, VariableName7, VariableName8, \
 165                        VariableName9); \
 166 }
 167
 168
 169 enum pipe_error
 170 SVGA3D_vgpu10_PredCopyRegion(struct svga_winsys_context *swc,
 171                              struct svga_winsys_surface *dstSurf,
 172                              uint32 dstSubResource,
 173                              struct svga_winsys_surface *srcSurf,
 174                              uint32 srcSubResource,
 175                              const SVGA3dCopyBox *box)
 176 {
 177    SVGA3dCmdDXPredCopyRegion *cmd =
 178       SVGA3D_FIFOReserve(swc,
 179                          SVGA_3D_CMD_DX_PRED_COPY_REGION,
 180                          sizeof(SVGA3dCmdDXPredCopyRegion),
 181                          2);  /* two relocations */
 182    if (!cmd)
 183       return PIPE_ERROR_OUT_OF_MEMORY;
 184
 185    swc->surface_relocation(swc, &cmd->dstSid, NULL, dstSurf, SVGA_RELOC_WRITE);
 186    swc->surface_relocation(swc, &cmd->srcSid, NULL, srcSurf, SVGA_RELOC_READ);
 187    cmd->dstSubResource = dstSubResource;
 188    cmd->srcSubResource = srcSubResource;
 189    cmd->box = *box;
 190
 191    swc->commit(swc);
 192
 193    return PIPE_OK;
 194 }
 195
 196
 197 enum pipe_error
 198 SVGA3D_vgpu10_PredCopy(struct svga_winsys_context *swc,
 199                        struct svga_winsys_surface *dstSurf,
 200                        struct svga_winsys_surface *srcSurf)
 201 {
 202    SVGA3dCmdDXPredCopy *cmd =
 203       SVGA3D_FIFOReserve(swc,
 204                          SVGA_3D_CMD_DX_PRED_COPY,
 205                          sizeof(SVGA3dCmdDXPredCopy),
 206                          2);  /* two relocations */
 207    if (!cmd)
 208       return PIPE_ERROR_OUT_OF_MEMORY;
 209
 210    swc->surface_relocation(swc, &cmd->dstSid, NULL, dstSurf, SVGA_RELOC_WRITE);
 211    swc->surface_relocation(swc, &cmd->srcSid, NULL, srcSurf, SVGA_RELOC_READ);
 212
 213    swc->commit(swc);
 214
 215    return PIPE_OK;
 216 }
 217
 218 enum pipe_error
 219 SVGA3D_vgpu10_SetViewports(struct svga_winsys_context *swc,
 220                            unsigned count,
 221                            const SVGA3dViewport *viewports)
 222 {
 223    SVGA3D_CREATE_CMD_COUNT(SetViewports, SET_VIEWPORTS, SVGA3dViewport);
 224
 225    memcpy(cmd + 1, viewports, count * sizeof(SVGA3dViewport));
 226
 227    swc->commit(swc);
 228    return PIPE_OK;
 229 }
 230
 231
 232 enum pipe_error
 233 SVGA3D_vgpu10_SetShader(struct svga_winsys_context *swc,
 234                         SVGA3dShaderType type,
 235                         struct svga_winsys_gb_shader *gbshader,
 236                         SVGA3dShaderId shaderId)
 237 {
 238    SVGA3dCmdDXSetShader *cmd = SVGA3D_FIFOReserve(swc,
 239                                                   SVGA_3D_CMD_DX_SET_SHADER,
 240                                                   sizeof *cmd,
 241                                                   1);  /* one relocation */
 242    if (!cmd)
 243       return PIPE_ERROR_OUT_OF_MEMORY;
 244
 245    swc->shader_relocation(swc, &cmd->shaderId, NULL, NULL, gbshader, 0);
 246
 247    cmd->type = type;
 248    cmd->shaderId = shaderId;
 249    swc->commit(swc);
 250
 251    return PIPE_OK;
 252 }
 253
 254
 255 enum pipe_error
 256 SVGA3D_vgpu10_SetShaderResources(struct svga_winsys_context *swc,
 257                                  SVGA3dShaderType type,
 258                                  uint32 startView,
 259                                  unsigned count,
 260                                  const SVGA3dShaderResourceViewId ids[],
 261                                  struct svga_winsys_surface **views)
 262 {
 263    SVGA3dCmdDXSetShaderResources *cmd;
 264    SVGA3dShaderResourceViewId *cmd_ids;
 265    unsigned i;
 266
 267    cmd = SVGA3D_FIFOReserve(swc,
 268                             SVGA_3D_CMD_DX_SET_SHADER_RESOURCES,
 269                             sizeof(SVGA3dCmdDXSetShaderResources) +
 270                             count * sizeof(SVGA3dShaderResourceViewId),
 271                             count); /* 'count' relocations */
 272    if (!cmd)
 273       return PIPE_ERROR_OUT_OF_MEMORY;
 274
 275
 276    cmd->type = type;
 277    cmd->startView = startView;
 278
 279    cmd_ids = (SVGA3dShaderResourceViewId *) (cmd + 1);
 280    for (i = 0; i < count; i++) {
 281       swc->surface_relocation(swc, cmd_ids + i, NULL, views[i],
 282                               SVGA_RELOC_READ);
 283       cmd_ids[i] = ids[i];
 284    }
 285
 286    swc->commit(swc);
 287    return PIPE_OK;
 288 }
 289
 290
 291 enum pipe_error
 292 SVGA3D_vgpu10_SetSamplers(struct svga_winsys_context *swc,
 293                           unsigned count,
 294                           uint32 startSampler,
 295                           SVGA3dShaderType type,
 296                           const SVGA3dSamplerId *samplerIds)
 297 {
 298    SVGA3D_CREATE_CMD_COUNT(SetSamplers, SET_SAMPLERS, SVGA3dSamplerId);
 299
 300    SVGA3D_COPY_BASIC_2(startSampler, type);
 301    memcpy(cmd + 1, samplerIds, count * sizeof(SVGA3dSamplerId));
 302
 303    swc->commit(swc);
 304    return PIPE_OK;
 305 }
 306
 307
 308 enum pipe_error
 309 SVGA3D_vgpu10_ClearRenderTargetView(struct svga_winsys_context *swc,
 310                                     struct pipe_surface *color_surf,
 311                                     const float *rgba)
 312 {
 313    SVGA3dCmdDXClearRenderTargetView *cmd;
 314    struct svga_surface *ss = svga_surface(color_surf);
 315
 316    cmd = SVGA3D_FIFOReserve(swc,
 317                             SVGA_3D_CMD_DX_CLEAR_RENDERTARGET_VIEW,
 318                             sizeof(SVGA3dCmdDXClearRenderTargetView),
 319                             1); /* one relocation */
 320    if (!cmd)
 321       return PIPE_ERROR_OUT_OF_MEMORY;
 322
 323
 324    /* NOTE: The following is pretty tricky.  We need to emit a view/surface
 325     * relocation and we have to provide a pointer to an ID which lies in
 326     * the bounds of the command space which we just allocated.  However,
 327     * we then need to overwrite it with the original RenderTargetViewId.
 328     */
 329    view_relocation(swc, color_surf, &cmd->renderTargetViewId,
 330                    SVGA_RELOC_WRITE);
 331    cmd->renderTargetViewId = ss->view_id;
 332
 333    COPY_4V(cmd->rgba.value, rgba);
 334
 335    swc->commit(swc);
 336    return PIPE_OK;
 337 }
 338
 339
 340 enum pipe_error
 341 SVGA3D_vgpu10_SetRenderTargets(struct svga_winsys_context *swc,
 342                                unsigned color_count,
 343                                struct pipe_surface **color_surfs,
 344                                struct pipe_surface *depth_stencil_surf)
 345 {
 346    const unsigned surf_count = color_count + 1;
 347    SVGA3dCmdDXSetRenderTargets *cmd;
 348    SVGA3dRenderTargetViewId *ctarget;
 349    struct svga_surface *ss;
 350    unsigned i;
 351
 352    assert(surf_count > 0);
 353
 354    cmd = SVGA3D_FIFOReserve(swc,
 355                             SVGA_3D_CMD_DX_SET_RENDERTARGETS,
 356                             sizeof(SVGA3dCmdDXSetRenderTargets) +
 357                             color_count * sizeof(SVGA3dRenderTargetViewId),
 358                             surf_count); /* 'surf_count' relocations */
 359    if (!cmd)
 360       return PIPE_ERROR_OUT_OF_MEMORY;
 361
 362    /* NOTE: See earlier comment about the tricky handling of the ViewIds.
 363     */
 364
 365    /* Depth / Stencil buffer */
 366    if (depth_stencil_surf) {
 367       ss = svga_surface(depth_stencil_surf);
 368       view_relocation(swc, depth_stencil_surf, &cmd->depthStencilViewId,
 369                       SVGA_RELOC_WRITE);
 370       cmd->depthStencilViewId = ss->view_id;
 371    }
 372    else {
 373       /* no depth/stencil buffer - still need a relocation */
 374       view_relocation(swc, NULL, &cmd->depthStencilViewId,
 375                       SVGA_RELOC_WRITE);
 376       cmd->depthStencilViewId = SVGA3D_INVALID_ID;
 377    }
 378
 379    /* Color buffers */
 380    ctarget = (SVGA3dRenderTargetViewId *) &cmd[1];
 381    for (i = 0; i < color_count; i++) {
 382       if (color_surfs[i]) {
 383          ss = svga_surface(color_surfs[i]);
 384          view_relocation(swc, color_surfs[i], ctarget + i, SVGA_RELOC_WRITE);
 385          ctarget[i] = ss->view_id;
 386       }
 387       else {
 388          view_relocation(swc, NULL, ctarget + i, SVGA_RELOC_WRITE);
 389          ctarget[i] = SVGA3D_INVALID_ID;
 390       }
 391    }
 392
 393    swc->commit(swc);
 394    return PIPE_OK;
 395 }
 396
 397
 398 enum pipe_error
 399 SVGA3D_vgpu10_SetBlendState(struct svga_winsys_context *swc,
 400                             SVGA3dBlendStateId blendId,
 401                             const float *blendFactor,
 402                             uint32 sampleMask)
 403 {
 404    SVGA3D_CREATE_COMMAND(SetBlendState, SET_BLEND_STATE);
 405
 406    SVGA3D_COPY_BASIC_2(blendId, sampleMask);
 407    memcpy(cmd->blendFactor, blendFactor, sizeof(float) * 4);
 408
 409    swc->commit(swc);
 410    return PIPE_OK;
 411 }
 412
 413 enum pipe_error
 414 SVGA3D_vgpu10_SetDepthStencilState(struct svga_winsys_context *swc,
 415                                    SVGA3dDepthStencilStateId depthStencilId,
 416                                    uint32 stencilRef)
 417 {
 418    SVGA3D_CREATE_COMMAND(SetDepthStencilState, SET_DEPTHSTENCIL_STATE);
 419
 420    SVGA3D_COPY_BASIC_2(depthStencilId, stencilRef);
 421
 422    swc->commit(swc);
 423    return PIPE_OK;
 424 }
 425
 426 enum pipe_error
 427 SVGA3D_vgpu10_SetRasterizerState(struct svga_winsys_context *swc,
 428                                  SVGA3dRasterizerStateId rasterizerId)
 429 {
 430    SVGA3D_CREATE_COMMAND(SetRasterizerState, SET_RASTERIZER_STATE);
 431
 432    cmd->rasterizerId = rasterizerId;
 433
 434    swc->commit(swc);
 435    return PIPE_OK;
 436 }
 437
 438 enum pipe_error
 439 SVGA3D_vgpu10_SetPredication(struct svga_winsys_context *swc,
 440                              SVGA3dQueryId queryId,
 441                              uint32 predicateValue)
 442 {
 443    SVGA3dCmdDXSetPredication *cmd;
 444
 445    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_SET_PREDICATION,
 446                             sizeof *cmd, 0);
 447
 448    if (!cmd)
 449       return PIPE_ERROR_OUT_OF_MEMORY;
 450
 451    cmd->queryId = queryId;
 452    cmd->predicateValue = predicateValue;
 453    swc->commit(swc);
 454    return PIPE_OK;
 455 }
 456
 457 enum pipe_error
 458 SVGA3D_vgpu10_SetSOTargets(struct svga_winsys_context *swc,
 459                            unsigned count,
 460                            const SVGA3dSoTarget *targets,
 461                            struct svga_winsys_surface **surfaces)
 462 {
 463    SVGA3dCmdDXSetSOTargets *cmd;
 464    SVGA3dSoTarget *sot;
 465    unsigned i;
 466
 467    cmd = SVGA3D_FIFOReserve(swc,
 468                             SVGA_3D_CMD_DX_SET_SOTARGETS,
 469                             sizeof(SVGA3dCmdDXSetSOTargets) +
 470                             count * sizeof(SVGA3dSoTarget),
 471                             count);
 472
 473    if (!cmd)
 474       return PIPE_ERROR_OUT_OF_MEMORY;
 475
 476    cmd->pad0 = 0;
 477    sot = (SVGA3dSoTarget *)(cmd + 1);
 478    for (i = 0; i < count; i++, sot++) {
 479       if (surfaces[i]) {
 480          sot->offset = targets[i].offset;
 481          sot->sizeInBytes = targets[i].sizeInBytes;
 482          swc->surface_relocation(swc, &sot->sid, NULL, surfaces[i],
 483                                  SVGA_RELOC_WRITE);
 484       }
 485       else {
 486          sot->offset = 0;
 487          sot->sizeInBytes = ~0u;
 488          swc->surface_relocation(swc, &sot->sid, NULL, NULL,
 489                                  SVGA_RELOC_WRITE);
 490       }
 491    }
 492    swc->commit(swc);
 493    return PIPE_OK;
 494 }
 495
 496 enum pipe_error
 497 SVGA3D_vgpu10_SetScissorRects(struct svga_winsys_context *swc,
 498                               unsigned count,
 499                               const SVGASignedRect *rects)
 500 {
 501    SVGA3dCmdDXSetScissorRects *cmd;
 502
 503    assert(count > 0);
 504    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_SET_SCISSORRECTS,
 505                             sizeof(SVGA3dCmdDXSetScissorRects) +
 506                             count * sizeof(SVGASignedRect),
 507                             0);
 508    if (!cmd)
 509       return PIPE_ERROR_OUT_OF_MEMORY;
 510
 511    memcpy(cmd + 1, rects, count * sizeof(SVGASignedRect));
 512
 513    swc->commit(swc);
 514    return PIPE_OK;
 515 }
 516
 517 enum pipe_error
 518 SVGA3D_vgpu10_SetStreamOutput(struct svga_winsys_context *swc,
 519                               SVGA3dStreamOutputId soid)
 520 {
 521    SVGA3D_CREATE_COMMAND(SetStreamOutput, SET_STREAMOUTPUT);
 522
 523    cmd->soid = soid;
 524
 525    swc->commit(swc);
 526    return PIPE_OK;
 527 }
 528
 529 enum pipe_error
 530 SVGA3D_vgpu10_Draw(struct svga_winsys_context *swc,
 531                    uint32 vertexCount,
 532                    uint32 startVertexLocation)
 533 {
 534    SVGA3D_CREATE_COMMAND(Draw, DRAW);
 535
 536    SVGA3D_COPY_BASIC_2(vertexCount, startVertexLocation);
 537
 538    swc->hints |= SVGA_HINT_FLAG_CAN_PRE_FLUSH;
 539    swc->commit(swc);
 540    swc->num_draw_commands++;
 541    return PIPE_OK;
 542 }
 543
 544 enum pipe_error
 545 SVGA3D_vgpu10_DrawIndexed(struct svga_winsys_context *swc,
 546                           uint32 indexCount,
 547                           uint32 startIndexLocation,
 548                           int32 baseVertexLocation)
 549 {
 550    SVGA3D_CREATE_COMMAND(DrawIndexed, DRAW_INDEXED);
 551
 552    SVGA3D_COPY_BASIC_3(indexCount, startIndexLocation,
 553                        baseVertexLocation);
 554
 555    swc->hints |= SVGA_HINT_FLAG_CAN_PRE_FLUSH;
 556    swc->commit(swc);
 557    swc->num_draw_commands++;
 558    return PIPE_OK;
 559 }
 560
 561 enum pipe_error
 562 SVGA3D_vgpu10_DrawInstanced(struct svga_winsys_context *swc,
 563                             uint32 vertexCountPerInstance,
 564                             uint32 instanceCount,
 565                             uint32 startVertexLocation,
 566                             uint32 startInstanceLocation)
 567 {
 568    SVGA3D_CREATE_COMMAND(DrawInstanced, DRAW_INSTANCED);
 569
 570    SVGA3D_COPY_BASIC_4(vertexCountPerInstance, instanceCount,
 571                        startVertexLocation, startInstanceLocation);
 572
 573    swc->hints |= SVGA_HINT_FLAG_CAN_PRE_FLUSH;
 574    swc->commit(swc);
 575    swc->num_draw_commands++;
 576    return PIPE_OK;
 577 }
 578
 579 enum pipe_error
 580 SVGA3D_vgpu10_DrawIndexedInstanced(struct svga_winsys_context *swc,
 581                                    uint32 indexCountPerInstance,
 582                                    uint32 instanceCount,
 583                                    uint32 startIndexLocation,
 584                                    int32  baseVertexLocation,
 585                                    uint32 startInstanceLocation)
 586 {
 587    SVGA3D_CREATE_COMMAND(DrawIndexedInstanced, DRAW_INDEXED_INSTANCED);
 588
 589    SVGA3D_COPY_BASIC_5(indexCountPerInstance, instanceCount,
 590                        startIndexLocation, baseVertexLocation,
 591                        startInstanceLocation);
 592
 593
 594    swc->hints |= SVGA_HINT_FLAG_CAN_PRE_FLUSH;
 595    swc->commit(swc);
 596    swc->num_draw_commands++;
 597    return PIPE_OK;
 598 }
 599
 600 enum pipe_error
 601 SVGA3D_vgpu10_DrawAuto(struct svga_winsys_context *swc)
 602 {
 603    SVGA3D_CREATE_COMMAND(DrawAuto, DRAW_AUTO);
 604
 605    swc->hints |= SVGA_HINT_FLAG_CAN_PRE_FLUSH;
 606    swc->commit(swc);
 607    swc->num_draw_commands++;
 608    return PIPE_OK;
 609 }
 610
 611 enum pipe_error
 612 SVGA3D_vgpu10_DefineQuery(struct svga_winsys_context *swc,
 613                           SVGA3dQueryId queryId,
 614                           SVGA3dQueryType type,
 615                           SVGA3dDXQueryFlags flags)
 616 {
 617    SVGA3D_CREATE_COMMAND(DefineQuery, DEFINE_QUERY);
 618
 619    SVGA3D_COPY_BASIC_3(queryId, type, flags);
 620
 621    swc->commit(swc);
 622    return PIPE_OK;
 623 }
 624
 625 enum pipe_error
 626 SVGA3D_vgpu10_DestroyQuery(struct svga_winsys_context *swc,
 627                            SVGA3dQueryId queryId)
 628 {
 629    SVGA3D_CREATE_COMMAND(DestroyQuery, DESTROY_QUERY);
 630
 631    cmd->queryId = queryId;
 632
 633    swc->commit(swc);
 634    return PIPE_OK;
 635 }
 636
 637 enum pipe_error
 638 SVGA3D_vgpu10_BindQuery(struct svga_winsys_context *swc,
 639                         struct svga_winsys_gb_query *gbQuery,
 640                         SVGA3dQueryId queryId)
 641 {
 642    SVGA3dCmdDXBindQuery *cmd = SVGA3D_FIFOReserve(swc,
 643                                                   SVGA_3D_CMD_DX_BIND_QUERY,
 644                                                   sizeof *cmd,
 645                                                   1);
 646    if (!cmd)
 647       return PIPE_ERROR_OUT_OF_MEMORY;
 648
 649    cmd->queryId = queryId;
 650    swc->query_relocation(swc, &cmd->mobid, gbQuery);
 651
 652    swc->commit(swc);
 653    return PIPE_OK;
 654 }
 655
 656 enum pipe_error
 657 SVGA3D_vgpu10_SetQueryOffset(struct svga_winsys_context *swc,
 658                              SVGA3dQueryId queryId,
 659                              uint32 mobOffset)
 660 {
 661    SVGA3D_CREATE_COMMAND(SetQueryOffset, SET_QUERY_OFFSET);
 662    SVGA3D_COPY_BASIC_2(queryId, mobOffset);
 663    swc->commit(swc);
 664    return PIPE_OK;
 665 }
 666
 667 enum pipe_error
 668 SVGA3D_vgpu10_BeginQuery(struct svga_winsys_context *swc,
 669                          SVGA3dQueryId queryId)
 670 {
 671    SVGA3D_CREATE_COMMAND(BeginQuery, BEGIN_QUERY);
 672    cmd->queryId = queryId;
 673    swc->commit(swc);
 674    return PIPE_OK;
 675 }
 676
 677 enum pipe_error
 678 SVGA3D_vgpu10_EndQuery(struct svga_winsys_context *swc,
 679                        SVGA3dQueryId queryId)
 680 {
 681    SVGA3D_CREATE_COMMAND(EndQuery, END_QUERY);
 682    cmd->queryId = queryId;
 683    swc->commit(swc);
 684    return PIPE_OK;
 685 }
 686
 687
 688 enum pipe_error
 689 SVGA3D_vgpu10_ClearDepthStencilView(struct svga_winsys_context *swc,
 690                                     struct pipe_surface *ds_surf,
 691                                     uint16 flags,
 692                                     uint16 stencil,
 693                                     float depth)
 694 {
 695    SVGA3dCmdDXClearDepthStencilView *cmd;
 696    struct svga_surface *ss = svga_surface(ds_surf);
 697
 698    cmd = SVGA3D_FIFOReserve(swc,
 699                             SVGA_3D_CMD_DX_CLEAR_DEPTHSTENCIL_VIEW,
 700                             sizeof(SVGA3dCmdDXClearDepthStencilView),
 701                             1); /* one relocation */
 702    if (!cmd)
 703       return PIPE_ERROR_OUT_OF_MEMORY;
 704
 705    /* NOTE: The following is pretty tricky.  We need to emit a view/surface
 706     * relocation and we have to provide a pointer to an ID which lies in
 707     * the bounds of the command space which we just allocated.  However,
 708     * we then need to overwrite it with the original DepthStencilViewId.
 709     */
 710    view_relocation(swc, ds_surf, &cmd->depthStencilViewId,
 711                    SVGA_RELOC_WRITE);
 712    cmd->depthStencilViewId = ss->view_id;
 713    cmd->flags = flags;
 714    cmd->stencil = stencil;
 715    cmd->depth = depth;
 716
 717    swc->commit(swc);
 718    return PIPE_OK;
 719 }
 720
 721 enum pipe_error
 722 SVGA3D_vgpu10_DefineShaderResourceView(struct svga_winsys_context *swc,
 723                              SVGA3dShaderResourceViewId shaderResourceViewId,
 724                              struct svga_winsys_surface *surface,
 725                              SVGA3dSurfaceFormat format,
 726                              SVGA3dResourceType resourceDimension,
 727                              const SVGA3dShaderResourceViewDesc *desc)
 728 {
 729    SVGA3dCmdDXDefineShaderResourceView *cmd;
 730
 731    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_DEFINE_SHADERRESOURCE_VIEW,
 732                             sizeof(SVGA3dCmdDXDefineShaderResourceView),
 733                             1); /* one relocation */
 734    if (!cmd)
 735       return PIPE_ERROR_OUT_OF_MEMORY;
 736
 737    SVGA3D_COPY_BASIC_3(shaderResourceViewId, format, resourceDimension);
 738
 739    swc->surface_relocation(swc, &cmd->sid, NULL, surface,
 740                            SVGA_RELOC_READ);
 741
 742    cmd->desc = *desc;
 743
 744    swc->commit(swc);
 745    return PIPE_OK;
 746 }
 747
 748 enum pipe_error
 749 SVGA3D_vgpu10_DestroyShaderResourceView(struct svga_winsys_context *swc,
 750                              SVGA3dShaderResourceViewId shaderResourceViewId)
 751 {
 752    SVGA3D_CREATE_COMMAND(DestroyShaderResourceView,
 753                        DESTROY_SHADERRESOURCE_VIEW);
 754
 755    cmd->shaderResourceViewId = shaderResourceViewId;
 756
 757    swc->commit(swc);
 758    return PIPE_OK;
 759 }
 760
 761
 762 enum pipe_error
 763 SVGA3D_vgpu10_DefineRenderTargetView(struct svga_winsys_context *swc,
 764                                   SVGA3dRenderTargetViewId renderTargetViewId,
 765                                   struct svga_winsys_surface *surface,
 766                                   SVGA3dSurfaceFormat format,
 767                                   SVGA3dResourceType resourceDimension,
 768                                   const SVGA3dRenderTargetViewDesc *desc)
 769 {
 770    SVGA3dCmdDXDefineRenderTargetView *cmd;
 771
 772    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_DEFINE_RENDERTARGET_VIEW,
 773                             sizeof(SVGA3dCmdDXDefineRenderTargetView),
 774                             1); /* one relocation */
 775    if (!cmd)
 776       return PIPE_ERROR_OUT_OF_MEMORY;
 777
 778    SVGA3D_COPY_BASIC_3(renderTargetViewId, format, resourceDimension);
 779    cmd->desc = *desc;
 780
 781    surface_to_resourceid(swc, surface,
 782                          &cmd->sid,
 783                          SVGA_RELOC_READ | SVGA_RELOC_WRITE);
 784
 785    swc->commit(swc);
 786    return PIPE_OK;
 787 }
 788
 789 enum pipe_error
 790 SVGA3D_vgpu10_DestroyRenderTargetView(struct svga_winsys_context *swc,
 791                                  SVGA3dRenderTargetViewId renderTargetViewId)
 792 {
 793    SVGA3D_CREATE_COMMAND(DestroyRenderTargetView, DESTROY_RENDERTARGET_VIEW);
 794
 795    cmd->renderTargetViewId = renderTargetViewId;
 796
 797    swc->commit(swc);
 798    return PIPE_OK;
 799 }
 800
 801
 802 enum pipe_error
 803 SVGA3D_vgpu10_DefineDepthStencilView(struct svga_winsys_context *swc,
 804                                   SVGA3dDepthStencilViewId depthStencilViewId,
 805                                   struct svga_winsys_surface *surface,
 806                                   SVGA3dSurfaceFormat format,
 807                                   SVGA3dResourceType resourceDimension,
 808                                   const SVGA3dRenderTargetViewDesc *desc)
 809 {
 810    SVGA3dCmdDXDefineDepthStencilView *cmd;
 811
 812    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_DEFINE_DEPTHSTENCIL_VIEW,
 813                             sizeof(SVGA3dCmdDXDefineDepthStencilView),
 814                             1); /* one relocation */
 815    if (!cmd)
 816       return PIPE_ERROR_OUT_OF_MEMORY;
 817
 818    SVGA3D_COPY_BASIC_3(depthStencilViewId, format, resourceDimension);
 819    cmd->mipSlice = desc->tex.mipSlice;
 820    cmd->firstArraySlice = desc->tex.firstArraySlice;
 821    cmd->arraySize = desc->tex.arraySize;
 822
 823    surface_to_resourceid(swc, surface,
 824                          &cmd->sid,
 825                          SVGA_RELOC_READ | SVGA_RELOC_WRITE);
 826
 827    swc->commit(swc);
 828    return PIPE_OK;
 829 }
 830
 831 enum pipe_error
 832 SVGA3D_vgpu10_DestroyDepthStencilView(struct svga_winsys_context *swc,
 833                                  SVGA3dDepthStencilViewId depthStencilViewId)
 834 {
 835    SVGA3D_CREATE_COMMAND(DestroyDepthStencilView, DESTROY_DEPTHSTENCIL_VIEW);
 836
 837    cmd->depthStencilViewId = depthStencilViewId;
 838
 839    swc->commit(swc);
 840    return PIPE_OK;
 841 }
 842
 843 enum pipe_error
 844 SVGA3D_vgpu10_DefineElementLayout(struct svga_winsys_context *swc,
 845                                   unsigned count,
 846                                   SVGA3dElementLayoutId elementLayoutId,
 847                                   const SVGA3dInputElementDesc *elements)
 848 {
 849    SVGA3dCmdDXDefineElementLayout *cmd;
 850    unsigned i;
 851
 852    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_DEFINE_ELEMENTLAYOUT,
 853                             sizeof(SVGA3dCmdDXDefineElementLayout) +
 854                             count * sizeof(SVGA3dInputElementDesc), 0);
 855    if (!cmd)
 856       return PIPE_ERROR_OUT_OF_MEMORY;
 857
 858    /* check that all offsets are multiples of four */
 859    for (i = 0; i < count; i++) {
 860       assert(elements[i].alignedByteOffset % 4 == 0);
 861    }
 862    (void) i; /* silence unused var in release build */
 863
 864    cmd->elementLayoutId = elementLayoutId;
 865    memcpy(cmd + 1, elements, count * sizeof(SVGA3dInputElementDesc));
 866
 867    swc->commit(swc);
 868    return PIPE_OK;
 869 }
 870
 871 enum pipe_error
 872 SVGA3D_vgpu10_DestroyElementLayout(struct svga_winsys_context *swc,
 873                                    SVGA3dElementLayoutId elementLayoutId)
 874 {
 875    SVGA3D_CREATE_COMMAND(DestroyElementLayout, DESTROY_ELEMENTLAYOUT);
 876
 877    cmd->elementLayoutId = elementLayoutId;
 878
 879    swc->commit(swc);
 880    return PIPE_OK;
 881 }
 882
 883 enum pipe_error
 884 SVGA3D_vgpu10_DefineBlendState(struct svga_winsys_context *swc,
 885                                SVGA3dBlendStateId blendId,
 886                                uint8 alphaToCoverageEnable,
 887                                uint8 independentBlendEnable,
 888                                const SVGA3dDXBlendStatePerRT *perRT)
 889 {
 890    SVGA3D_CREATE_COMMAND(DefineBlendState, DEFINE_BLEND_STATE);
 891
 892    cmd->blendId = blendId;
 893    cmd->alphaToCoverageEnable = alphaToCoverageEnable;
 894    cmd->independentBlendEnable = independentBlendEnable;
 895    memcpy(cmd->perRT, perRT, sizeof(cmd->perRT));
 896    cmd->pad0 = 0;
 897
 898    swc->commit(swc);
 899    return PIPE_OK;
 900 }
 901
 902 enum pipe_error
 903 SVGA3D_vgpu10_DestroyBlendState(struct svga_winsys_context *swc,
 904                                 SVGA3dBlendStateId blendId)
 905 {
 906    SVGA3D_CREATE_COMMAND(DestroyBlendState, DESTROY_BLEND_STATE);
 907
 908    cmd->blendId = blendId;
 909
 910    swc->commit(swc);
 911    return PIPE_OK;
 912 }
 913
 914 enum pipe_error
 915 SVGA3D_vgpu10_DefineDepthStencilState(struct svga_winsys_context *swc,
 916                                       SVGA3dDepthStencilStateId depthStencilId,
 917                                       uint8 depthEnable,
 918                                       SVGA3dDepthWriteMask depthWriteMask,
 919                                       SVGA3dComparisonFunc depthFunc,
 920                                       uint8 stencilEnable,
 921                                       uint8 frontEnable,
 922                                       uint8 backEnable,
 923                                       uint8 stencilReadMask,
 924                                       uint8 stencilWriteMask,
 925                                       uint8 frontStencilFailOp,
 926                                       uint8 frontStencilDepthFailOp,
 927                                       uint8 frontStencilPassOp,
 928                                       SVGA3dComparisonFunc frontStencilFunc,
 929                                       uint8 backStencilFailOp,
 930                                       uint8 backStencilDepthFailOp,
 931                                       uint8 backStencilPassOp,
 932                                       SVGA3dComparisonFunc backStencilFunc)
 933 {
 934    SVGA3D_CREATE_COMMAND(DefineDepthStencilState, DEFINE_DEPTHSTENCIL_STATE);
 935
 936    SVGA3D_COPY_BASIC_9(depthStencilId, depthEnable,
 937                        depthWriteMask, depthFunc,
 938                        stencilEnable, frontEnable,
 939                        backEnable, stencilReadMask,
 940                        stencilWriteMask);
 941    SVGA3D_COPY_BASIC_8(frontStencilFailOp, frontStencilDepthFailOp,
 942                        frontStencilPassOp, frontStencilFunc,
 943                        backStencilFailOp, backStencilDepthFailOp,
 944                        backStencilPassOp, backStencilFunc);
 945
 946    swc->commit(swc);
 947    return PIPE_OK;
 948 }
 949
 950 enum pipe_error
 951 SVGA3D_vgpu10_DestroyDepthStencilState(struct svga_winsys_context *swc,
 952                                     SVGA3dDepthStencilStateId depthStencilId)
 953 {
 954    SVGA3D_CREATE_COMMAND(DestroyDepthStencilState,
 955                          DESTROY_DEPTHSTENCIL_STATE);
 956
 957    cmd->depthStencilId = depthStencilId;
 958
 959    swc->commit(swc);
 960    return PIPE_OK;
 961 }
 962
 963 enum pipe_error
 964 SVGA3D_vgpu10_DefineRasterizerState(struct svga_winsys_context *swc,
 965                                     SVGA3dRasterizerStateId rasterizerId,
 966                                     uint8 fillMode,
 967                                     SVGA3dCullMode cullMode,
 968                                     uint8 frontCounterClockwise,
 969                                     int32 depthBias,
 970                                     float depthBiasClamp,
 971                                     float slopeScaledDepthBias,
 972                                     uint8 depthClipEnable,
 973                                     uint8 scissorEnable,
 974                                     uint8 multisampleEnable,
 975                                     uint8 antialiasedLineEnable,
 976                                     float lineWidth,
 977                                     uint8 lineStippleEnable,
 978                                     uint8 lineStippleFactor,
 979                                     uint16 lineStipplePattern,
 980                                     uint8 provokingVertexLast)
 981 {
 982    SVGA3D_CREATE_COMMAND(DefineRasterizerState, DEFINE_RASTERIZER_STATE);
 983
 984    SVGA3D_COPY_BASIC_5(rasterizerId, fillMode,
 985                        cullMode, frontCounterClockwise,
 986                        depthBias);
 987    SVGA3D_COPY_BASIC_6(depthBiasClamp, slopeScaledDepthBias,
 988                        depthClipEnable, scissorEnable,
 989                        multisampleEnable, antialiasedLineEnable);
 990    cmd->lineWidth = lineWidth;
 991    cmd->lineStippleEnable = lineStippleEnable;
 992    cmd->lineStippleFactor = lineStippleFactor;
 993    cmd->lineStipplePattern = lineStipplePattern;
 994    cmd->provokingVertexLast = provokingVertexLast;
 995
 996    swc->commit(swc);
 997    return PIPE_OK;
 998 }
 999
1000 enum pipe_error
1001 SVGA3D_vgpu10_DestroyRasterizerState(struct svga_winsys_context *swc,
1002                                      SVGA3dRasterizerStateId rasterizerId)
1003 {
1004    SVGA3D_CREATE_COMMAND(DestroyRasterizerState, DESTROY_RASTERIZER_STATE);
1005
1006    cmd->rasterizerId = rasterizerId;
1007
1008    swc->commit(swc);
1009    return PIPE_OK;
1010 }
1011
1012 enum pipe_error
1013 SVGA3D_vgpu10_DefineSamplerState(struct svga_winsys_context *swc,
1014                                  SVGA3dSamplerId samplerId,
1015                                  SVGA3dFilter filter,
1016                                  uint8 addressU,
1017                                  uint8 addressV,
1018                                  uint8 addressW,
1019                                  float mipLODBias,
1020                                  uint8 maxAnisotropy,
1021                                  uint8 comparisonFunc,
1022                                  SVGA3dRGBAFloat borderColor,
1023                                  float minLOD,
1024                                  float maxLOD)
1025 {
1026    SVGA3D_CREATE_COMMAND(DefineSamplerState, DEFINE_SAMPLER_STATE);
1027
1028    SVGA3D_COPY_BASIC_6(samplerId, filter,
1029                        addressU, addressV,
1030                        addressW, mipLODBias);
1031    SVGA3D_COPY_BASIC_5(maxAnisotropy, comparisonFunc,
1032                        borderColor, minLOD,
1033                        maxLOD);
1034
1035    swc->commit(swc);
1036    return PIPE_OK;
1037 }
1038
1039 enum pipe_error
1040 SVGA3D_vgpu10_DestroySamplerState(struct svga_winsys_context *swc,
1041                                   SVGA3dSamplerId samplerId)
1042 {
1043    SVGA3D_CREATE_COMMAND(DestroySamplerState, DESTROY_SAMPLER_STATE);
1044
1045    cmd->samplerId = samplerId;
1046
1047    swc->commit(swc);
1048    return PIPE_OK;
1049 }
1050
1051
1052 enum pipe_error
1053 SVGA3D_vgpu10_DefineAndBindShader(struct svga_winsys_context *swc,
1054                                   struct svga_winsys_gb_shader *gbshader,
1055                                   SVGA3dShaderId shaderId,
1056                                   SVGA3dShaderType type,
1057                                   uint32 sizeInBytes)
1058 {
1059    SVGA3dCmdHeader *header;
1060    SVGA3dCmdDXDefineShader *dcmd;
1061    SVGA3dCmdDXBindShader *bcmd;
1062    unsigned totalSize = 2 * sizeof(*header) +
1063                         sizeof(*dcmd) + sizeof(*bcmd);
1064
1065    /* Make sure there is room for both commands */
1066    header = swc->reserve(swc, totalSize, 2);
1067    if (!header)
1068       return PIPE_ERROR_OUT_OF_MEMORY;
1069
1070    /* DXDefineShader command */
1071    header->id = SVGA_3D_CMD_DX_DEFINE_SHADER;
1072    header->size = sizeof(*dcmd);
1073    dcmd = (SVGA3dCmdDXDefineShader *)(header + 1);
1074    dcmd->shaderId = shaderId;
1075    dcmd->type = type;
1076    dcmd->sizeInBytes = sizeInBytes;
1077
1078    /* DXBindShader command */
1079    header = (SVGA3dCmdHeader *)(dcmd + 1);
1080
1081    header->id = SVGA_3D_CMD_DX_BIND_SHADER;
1082    header->size = sizeof(*bcmd);
1083    bcmd = (SVGA3dCmdDXBindShader *)(header + 1);
1084
1085    bcmd->cid = swc->cid;
1086    swc->shader_relocation(swc, NULL, &bcmd->mobid,
1087                           &bcmd->offsetInBytes, gbshader, 0);
1088
1089    bcmd->shid = shaderId;
1090
1091    swc->commit(swc);
1092    return PIPE_OK;
1093 }
1094
1095 enum pipe_error
1096 SVGA3D_vgpu10_DestroyShader(struct svga_winsys_context *swc,
1097                             SVGA3dShaderId shaderId)
1098 {
1099    SVGA3D_CREATE_COMMAND(DestroyShader, DESTROY_SHADER);
1100
1101    cmd->shaderId = shaderId;
1102
1103    swc->commit(swc);
1104    return PIPE_OK;
1105 }
1106
1107 enum pipe_error
1108 SVGA3D_vgpu10_DefineStreamOutput(struct svga_winsys_context *swc,
1109        SVGA3dStreamOutputId soid,
1110        uint32 numOutputStreamEntries,
1111        uint32 streamOutputStrideInBytes[SVGA3D_DX_MAX_SOTARGETS],
1112        const SVGA3dStreamOutputDeclarationEntry decl[SVGA3D_MAX_STREAMOUT_DECLS])
1113 {
1114    unsigned i;
1115    SVGA3D_CREATE_COMMAND(DefineStreamOutput, DEFINE_STREAMOUTPUT);
1116
1117    cmd->soid = soid;
1118    cmd->numOutputStreamEntries = numOutputStreamEntries;
1119
1120    for (i = 0; i < ARRAY_SIZE(cmd->streamOutputStrideInBytes); i++)
1121       cmd->streamOutputStrideInBytes[i] = streamOutputStrideInBytes[i];
1122
1123    memcpy(cmd->decl, decl,
1124           sizeof(SVGA3dStreamOutputDeclarationEntry)
1125           * SVGA3D_MAX_STREAMOUT_DECLS);
1126
1127    swc->commit(swc);
1128    return PIPE_OK;
1129 }
1130
1131 enum pipe_error
1132 SVGA3D_vgpu10_DestroyStreamOutput(struct svga_winsys_context *swc,
1133                                   SVGA3dStreamOutputId soid)
1134 {
1135    SVGA3D_CREATE_COMMAND(DestroyStreamOutput, DESTROY_STREAMOUTPUT);
1136
1137    cmd->soid = soid;
1138
1139    swc->commit(swc);
1140    return PIPE_OK;
1141 }
1142
1143 enum pipe_error
1144 SVGA3D_vgpu10_SetInputLayout(struct svga_winsys_context *swc,
1145                              SVGA3dElementLayoutId elementLayoutId)
1146 {
1147    SVGA3D_CREATE_COMMAND(SetInputLayout, SET_INPUT_LAYOUT);
1148
1149    cmd->elementLayoutId = elementLayoutId;
1150
1151    swc->commit(swc);
1152    return PIPE_OK;
1153 }
1154
1155 enum pipe_error
1156 SVGA3D_vgpu10_SetVertexBuffers(struct svga_winsys_context *swc,
1157                                unsigned count,
1158                                uint32 startBuffer,
1159                                const SVGA3dVertexBuffer *bufferInfo,
1160                                struct svga_winsys_surface **surfaces)
1161 {
1162    SVGA3dCmdDXSetVertexBuffers *cmd;
1163    SVGA3dVertexBuffer *bufs;
1164    unsigned i;
1165
1166    assert(count > 0);
1167
1168    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_SET_VERTEX_BUFFERS,
1169                             sizeof(SVGA3dCmdDXSetVertexBuffers) +
1170                             count * sizeof(SVGA3dVertexBuffer),
1171                             count); /* 'count' relocations */
1172    if (!cmd)
1173       return PIPE_ERROR_OUT_OF_MEMORY;
1174
1175    cmd->startBuffer = startBuffer;
1176
1177    bufs = (SVGA3dVertexBuffer *) &cmd[1];
1178    for (i = 0; i < count; i++) {
1179       bufs[i].stride = bufferInfo[i].stride;
1180       bufs[i].offset = bufferInfo[i].offset;
1181       assert(bufs[i].stride % 4 == 0);
1182       assert(bufs[i].offset % 4 == 0);
1183       swc->surface_relocation(swc, &bufs[i].sid, NULL, surfaces[i],
1184                               SVGA_RELOC_READ);
1185    }
1186
1187    swc->commit(swc);
1188    return PIPE_OK;
1189 }
1190
1191 enum pipe_error
1192 SVGA3D_vgpu10_SetTopology(struct svga_winsys_context *swc,
1193                           SVGA3dPrimitiveType topology)
1194 {
1195    SVGA3D_CREATE_COMMAND(SetTopology, SET_TOPOLOGY);
1196
1197    cmd->topology = topology;
1198
1199    swc->commit(swc);
1200    return PIPE_OK;
1201 }
1202
1203 enum pipe_error
1204 SVGA3D_vgpu10_SetIndexBuffer(struct svga_winsys_context *swc,
1205                              struct svga_winsys_surface *indexes,
1206                              SVGA3dSurfaceFormat format,
1207                              uint32 offset)
1208 {
1209    SVGA3dCmdDXSetIndexBuffer *cmd;
1210
1211    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_SET_INDEX_BUFFER,
1212                             sizeof(SVGA3dCmdDXSetIndexBuffer),
1213                             1); /* one relocations */
1214    if (!cmd)
1215       return PIPE_ERROR_OUT_OF_MEMORY;
1216
1217    swc->surface_relocation(swc, &cmd->sid, NULL, indexes, SVGA_RELOC_READ);
1218    SVGA3D_COPY_BASIC_2(format, offset);
1219
1220    swc->commit(swc);
1221    return PIPE_OK;
1222 }
1223
1224 enum pipe_error
1225 SVGA3D_vgpu10_SetSingleConstantBuffer(struct svga_winsys_context *swc,
1226                                       unsigned slot,
1227                                       SVGA3dShaderType type,
1228                                       struct svga_winsys_surface *surface,
1229                                       uint32 offsetInBytes,
1230                                       uint32 sizeInBytes)
1231 {
1232    SVGA3dCmdDXSetSingleConstantBuffer *cmd;
1233
1234    assert(offsetInBytes % 256 == 0);
1235    if (!surface)
1236       assert(sizeInBytes == 0);
1237    else
1238       assert(sizeInBytes > 0);
1239
1240    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_SET_SINGLE_CONSTANT_BUFFER,
1241                             sizeof(SVGA3dCmdDXSetSingleConstantBuffer),
1242                             1);  /* one relocation */
1243    if (!cmd)
1244       return PIPE_ERROR_OUT_OF_MEMORY;
1245
1246    cmd->slot = slot;
1247    cmd->type = type;
1248    swc->surface_relocation(swc, &cmd->sid, NULL, surface, SVGA_RELOC_READ);
1249    cmd->offsetInBytes = offsetInBytes;
1250    cmd->sizeInBytes = sizeInBytes;
1251
1252    swc->commit(swc);
1253
1254    return PIPE_OK;
1255 }
1256
1257
1258 enum pipe_error
1259 SVGA3D_vgpu10_ReadbackSubResource(struct svga_winsys_context *swc,
1260                                   struct svga_winsys_surface *surface,
1261                                   unsigned subResource)
1262 {
1263    SVGA3dCmdDXReadbackSubResource *cmd;
1264
1265    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_READBACK_SUBRESOURCE,
1266                             sizeof(SVGA3dCmdDXReadbackSubResource),
1267                             1);
1268    if (!cmd)
1269       return PIPE_ERROR_OUT_OF_MEMORY;
1270
1271    swc->surface_relocation(swc, &cmd->sid, NULL, surface,
1272                            SVGA_RELOC_READ | SVGA_RELOC_INTERNAL);
1273    cmd->subResource = subResource;
1274
1275    swc->commit(swc);
1276    return PIPE_OK;
1277 }
1278
1279 enum pipe_error
1280 SVGA3D_vgpu10_UpdateSubResource(struct svga_winsys_context *swc,
1281                                 struct svga_winsys_surface *surface,
1282                                 const SVGA3dBox *box,
1283                                 unsigned subResource)
1284 {
1285    SVGA3dCmdDXUpdateSubResource *cmd;
1286
1287    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_UPDATE_SUBRESOURCE,
1288                             sizeof(SVGA3dCmdDXUpdateSubResource),
1289                             1);
1290    if (!cmd)
1291       return PIPE_ERROR_OUT_OF_MEMORY;
1292
1293    swc->surface_relocation(swc, &cmd->sid, NULL, surface,
1294                            SVGA_RELOC_WRITE | SVGA_RELOC_INTERNAL);
1295    cmd->subResource = subResource;
1296    cmd->box = *box;
1297
1298    swc->commit(swc);
1299    return PIPE_OK;
1300 }
1301
1302 enum pipe_error
1303 SVGA3D_vgpu10_GenMips(struct svga_winsys_context *swc,
1304                       SVGA3dShaderResourceViewId shaderResourceViewId,
1305                       struct svga_winsys_surface *view)
1306 {
1307    SVGA3dCmdDXGenMips *cmd;
1308
1309    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_GENMIPS,
1310                             sizeof(SVGA3dCmdDXGenMips), 1);
1311
1312    if (!cmd)
1313       return PIPE_ERROR_OUT_OF_MEMORY;
1314
1315    swc->surface_relocation(swc, &cmd->shaderResourceViewId, NULL, view,
1316                            SVGA_RELOC_WRITE);
1317    cmd->shaderResourceViewId = shaderResourceViewId;
1318
1319    swc->commit(swc);
1320    return PIPE_OK;
1321 }
1322
1323
1324 enum pipe_error
1325 SVGA3D_vgpu10_BufferCopy(struct svga_winsys_context *swc,
1326                           struct svga_winsys_surface *src,
1327                           struct svga_winsys_surface *dst,
1328                           unsigned srcx, unsigned dstx, unsigned width)
1329 {
1330    SVGA3dCmdDXBufferCopy *cmd;
1331
1332    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_BUFFER_COPY, sizeof *cmd, 2);
1333
1334    if (!cmd)
1335       return PIPE_ERROR_OUT_OF_MEMORY;
1336
1337    swc->surface_relocation(swc, &cmd->dest, NULL, dst, SVGA_RELOC_WRITE);
1338    swc->surface_relocation(swc, &cmd->src, NULL, src, SVGA_RELOC_READ);
1339    cmd->destX = dstx;
1340    cmd->srcX = srcx;
1341    cmd->width = width;
1342
1343    swc->commit(swc);
1344    return PIPE_OK;
1345 }
1346
1347 enum pipe_error
1348 SVGA3D_vgpu10_TransferFromBuffer(struct svga_winsys_context *swc,
1349                                  struct svga_winsys_surface *src,
1350                                  unsigned srcOffset, unsigned srcPitch,
1351                                  unsigned srcSlicePitch,
1352                                  struct svga_winsys_surface *dst,
1353                                  unsigned dstSubResource,
1354                                  SVGA3dBox *dstBox)
1355 {
1356    SVGA3dCmdDXTransferFromBuffer *cmd;
1357
1358    cmd = SVGA3D_FIFOReserve(swc, SVGA_3D_CMD_DX_TRANSFER_FROM_BUFFER,
1359                             sizeof(SVGA3dCmdDXTransferFromBuffer), 2);
1360
1361    if (!cmd)
1362       return PIPE_ERROR_OUT_OF_MEMORY;
1363
1364    swc->surface_relocation(swc, &cmd->srcSid, NULL, src, SVGA_RELOC_READ);
1365    swc->surface_relocation(swc, &cmd->destSid, NULL, dst, SVGA_RELOC_WRITE);
1366    cmd->srcOffset = srcOffset;
1367    cmd->srcPitch = srcPitch;
1368    cmd->srcSlicePitch = srcSlicePitch;
1369    cmd->destSubResource = dstSubResource;
1370    cmd->destBox = *dstBox;
1371
1372    swc->commit(swc);
1373    return PIPE_OK;
1374 }