workbench/hidds/vmwaresvga/vmwaresvga_gallium_screen.c

   1 /*
   2     Copyright 2019, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7
   8 #include <proto/exec.h>
   9 #include <proto/graphics.h>
  10 #include <proto/utility.h>
  11 #include <proto/oop.h>
  12
  13 #include <aros/libcall.h>
  14 #include <aros/asmcall.h>
  15 #include <aros/symbolsets.h>
  16 #include <utility/tagitem.h>
  17
  18 #include <hidd/gallium.h>
  19 #include <gallium/gallium.h>
  20
  21 #include "vmwaresvga_intern.h"
  22
  23 #include "svga3d_surfacedefs.h"
  24
  25 // ****************************************************************************
  26 //                      winsys screen support functions
  27 // ****************************************************************************
  28
  29 static SVGA3dHardwareVersion VMWareSVGA_WSScr_GetHWVersion(struct svga_winsys_screen *sws)
  30 {
  31     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
  32     SVGA3dHardwareVersion retval;
  33
  34     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
  35
  36     if (sws->have_gb_objects)
  37     {
  38         retval = SVGA3D_HWVERSION_WS8_B1;
  39     }
  40     else
  41     {
  42         volatile ULONG *fifo = data->hwdata->mmiobase;
  43         if (data->hwdata->fifocapabilities & SVGA_FIFO_CAP_3D_HWVERSION_REVISED)
  44             retval = (SVGA3dHardwareVersion)fifo[SVGA_FIFO_3D_HWVERSION_REVISED];
  45         else
  46             retval = (SVGA3dHardwareVersion)fifo[SVGA_FIFO_3D_HWVERSION];
  47     }
  48
  49     D(bug("[VMWareSVGA:Gallium] %s: returning #%08x\n", __func__, retval);)
  50
  51     return retval;
  52 }
  53
  54 static void VMWareSVGA_WSScr_CopyDev3DCaps(struct HIDDGalliumVMWareSVGAData *data, ULONG capcnt)
  55 {
  56     int i;
  57
  58     D(bug("[VMWareSVGA:Gallium] %s(%d)\n", __func__, capcnt);)
  59
  60     if (capcnt > SVGA3D_DEVCAP_MAX)
  61         capcnt = SVGA3D_DEVCAP_MAX;
  62
  63     D(bug("[VMWareSVGA:Gallium] %s: copying %d capabilities ...\n", __func__, capcnt);)
  64
  65     for (i = 0; i < capcnt; ++i) {
  66         if (i == SVGA3D_DEVCAP_DEAD5) // SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES is deprecated
  67         {
  68             data->cap_3d[i].has_cap = FALSE;
  69             data->cap_3d[i].result = (SVGA3dDevCapResult)0;
  70             D(bug("[VMWareSVGA:Gallium] %s:     ** deprecated\n", __func__);)
  71         }
  72         else
  73         {
  74             data->cap_3d[i].has_cap = TRUE;
  75             vmwareWriteReg(data->hwdata, SVGA_REG_DEV_CAP, i);
  76             data->cap_3d[i].result = (SVGA3dDevCapResult)vmwareReadReg(data->hwdata, SVGA_REG_DEV_CAP);
  77             D(bug("[VMWareSVGA:Gallium] %s:     %08x\n", __func__, data->cap_3d[i].result);)
  78         }
  79     }
  80 }
  81
  82 static void VMWareSVGA_WSScr_InitHW3DCaps(struct HIDDGalliumVMWareSVGAData *data)
  83 {
  84     ULONG cap_count;
  85
  86     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__);)
  87
  88     if ((data->use_gbobjects) && (data->hwdata->capabilities & SVGA_CAP_GBOBJECTS))
  89     {
  90         cap_count = SVGA3D_DEVCAP_MAX;
  91         data->size_3dcaps = cap_count * sizeof(ULONG);
  92     }
  93     else
  94     {
  95         cap_count = (SVGA_FIFO_3D_CAPS_LAST - SVGA_FIFO_3D_CAPS + 1);
  96         data->size_3dcaps = cap_count * sizeof(ULONG);
  97     }
  98
  99     D(bug("[VMWareSVGA:Gallium] %s: cap size = %d\n", __func__, data->size_3dcaps);)
 100
 101     data->cap_3d = AllocMem((cap_count * sizeof(struct VMWareSVGA3DCap)), MEMF_CLEAR|MEMF_ANY);
 102
 103     D(bug("[VMWareSVGA:Gallium] %s: cap_3d[%d] allocated @ 0x%p\n", __func__, cap_count, data->cap_3d);)
 104     if ((data->use_gbobjects) && (data->hwdata->capabilities & SVGA_CAP_GBOBJECTS)) {
 105         VMWareSVGA_WSScr_CopyDev3DCaps(data, cap_count);
 106     } else {
 107         volatile ULONG *fifo = data->hwdata->mmiobase;
 108         int i;
 109
 110         for (i = 0; i < cap_count; i++)
 111         {
 112             data->cap_3d[i].has_cap = TRUE;
 113             data->cap_3d[i].result = (SVGA3dDevCapResult)fifo[SVGA_FIFO_3D_CAPS + i];
 114         }
 115     }
 116
 117     if (data->hwdata->capabilities & SVGA_CAP_GBOBJECTS) {
 118         data->hwdata->txrmax = vmwareReadReg(data->hwdata, SVGA_REG_MOB_MAX_SIZE);
 119     }
 120     else
 121         data->hwdata->txrmax = VMW_MAX_DEFAULT_TEXTURE_SIZE;
 122
 123     D(bug("[VMWareSVGA:Gallium] %s: max texture size = %d\n", __func__, data->hwdata->txrmax);)
 124 }
 125
 126 static boolean VMWareSVGA_WSScr_GetCap(struct svga_winsys_screen *sws,
 127               SVGA3dDevCapIndex index,
 128               SVGA3dDevCapResult *result)
 129 {
 130     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 131
 132     D(bug("[VMWareSVGA:Gallium] %s(%d)\n", __func__, index);)
 133
 134     if ((index > (data->size_3dcaps / sizeof(ULONG))) ||
 135         (index >= SVGA3D_DEVCAP_MAX) ||
 136         (!data->cap_3d[index].has_cap))
 137     {
 138         D(bug("[VMWareSVGA:Gallium] %s: unsupported\n", __func__);)
 139         return FALSE;
 140     }
 141
 142    *result = data->cap_3d[index].result;
 143     D(bug("[VMWareSVGA:Gallium] %s: returning %08x\n", __func__, *result);)
 144
 145     return TRUE;
 146 }
 147
 148 /******************************/
 149
 150 static struct svga_winsys_buffer *VMWareSVGA_WSScr_BufferCreate( struct svga_winsys_screen *sws,
 151                      unsigned alignment,
 152                      unsigned usage,
 153                      unsigned size )
 154 {
 155     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 156     struct VMWareSVGAPBBuf *buf;
 157
 158     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 159
 160     buf = CALLOC_STRUCT(VMWareSVGAPBBuf);
 161
 162     buf->allocated_size = size + alignment;
 163     if( !(buf->allocated_map = VMWareSVGA_MemAlloc(data->hwdata, buf->allocated_size) ) )
 164     {
 165         FREE(buf);
 166         return NULL;
 167     }
 168     if (alignment)
 169         buf->map = (APTR)(((IPTR)buf->allocated_map + (alignment - 1)) & ~(alignment - 1));
 170     else
 171         buf->map = buf->allocated_map;
 172     buf->size = size;
 173
 174     return (struct svga_winsys_buffer *)buf;
 175 }
 176
 177 static void *VMWareSVGA_WSScr_BufferMap( struct svga_winsys_screen *sws,
 178                   struct svga_winsys_buffer *buf,
 179                   unsigned usage )
 180 {
 181     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 182     return ((struct VMWareSVGAPBBuf *)(buf))->map;
 183 }
 184
 185 static void VMWareSVGA_WSScr_BufferUnMap( struct svga_winsys_screen *sws,
 186                     struct svga_winsys_buffer *buf )
 187 {
 188     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 189 }
 190
 191 static void VMWareSVGA_WSScr_BufferDestroy( struct svga_winsys_screen *sws,
 192                       struct svga_winsys_buffer *buf )
 193 {
 194     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 195     struct VMWareSVGAPBBuf *pbuf = (struct VMWareSVGAPBBuf *)buf;
 196
 197     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 198
 199     if (pbuf->allocated_map)
 200         VMWareSVGA_MemFree(data->hwdata, pbuf->allocated_map, pbuf->allocated_size);
 201     FREE(pbuf);
 202 }
 203
 204 /******************************/
 205
 206 static struct svga_winsys_context *VMWareSVGA_WSScr_ContextCreate(struct svga_winsys_screen *sws)
 207 {
 208     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 209     struct HIDDGalliumVMWareSVGACtx     *hiddwsctx;
 210     struct svga_winsys_context          *wsctx;
 211
 212     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 213
 214     hiddwsctx = CALLOC_STRUCT(HIDDGalliumVMWareSVGACtx);
 215     wsctx = &hiddwsctx->wscbase;
 216     hiddwsctx->wscsws = sws;
 217
 218     D(bug("[VMWareSVGA:Gallium] %s: svga_winsys_context @ 0x%p\n", __func__, wsctx));
 219
 220     hiddwsctx->command = &data->hwdata->fifocmdbuf;
 221     D(bug("[VMWareSVGA:Gallium] %s: FIFO Reserve @ 0x%p, buffer @ 0x%p\n", __func__, hiddwsctx->command, hiddwsctx->command->buffer));
 222
 223     VMWareSVGA_WSCtx_WinSysInit(data, hiddwsctx);
 224     if (wsctx->cid == -1)
 225     {
 226         D(bug("[VMWareSVGA:Gallium] %s: Failed to allocate a hardware context!!\n", __func__));
 227         FREE(hiddwsctx);
 228         return NULL;
 229     }
 230     return wsctx;
 231 }
 232
 233 ULONG VMWareSVGA_DefineSurface(struct HIDDGalliumVMWareSVGAData *data, struct svga_winsys_surface *srf, SVGA3dSize size, SVGA3dSurfaceAllFlags flags, SVGA3dSurfaceFormat format, uint32 numMipLevels)
 234 {
 235     ULONG sid = ++data->srfcnt;
 236     SVGA3dCmdHeader *header;
 237     SVGA3dCmdDefineSurface *cmd;
 238     SVGA3dSize *mipSizes;
 239     SVGA3dSurfaceFace *faces;
 240     int i;
 241
 242     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 243
 244     header = reserveVMWareSVGAFIFO(data->hwdata, sizeof *header + sizeof *cmd +
 245                             sizeof *mipSizes * numMipLevels);
 246
 247     header->id = SVGA_3D_CMD_SURFACE_DEFINE;
 248     header->size = sizeof *cmd;
 249     cmd = (SVGA3dCmdDefineSurface *)&header[1];
 250
 251     cmd->sid = sid;
 252     cmd->surfaceFlags = flags;
 253     cmd->format = format;
 254
 255     faces = &cmd->face[0];
 256     mipSizes = (SVGA3dSize*) &cmd[1];
 257     memset(faces, 0, sizeof *faces * SVGA3D_MAX_SURFACE_FACES);
 258     memset(mipSizes, 0, sizeof *mipSizes * numMipLevels);
 259
 260     faces[0].numMipLevels = numMipLevels;
 261
 262     for (i = 0; i < numMipLevels; i++)
 263     {
 264         mipSizes[i].width = size.width;
 265         mipSizes[i].height = size.height;
 266         mipSizes[i].depth = size.depth;
 267     }
 268     commitVMWareSVGAFIFO(data->hwdata, data->hwdata->fifocmdbuf.reserved);
 269
 270     D(bug("[VMWareSVGA:Gallium] %s: returning %d\n", __func__, sid));
 271
 272     return sid;
 273 }
 274
 275 static struct svga_winsys_surface *VMWareSVGA_WSScr_SurfaceCreate(
 276                     struct svga_winsys_screen *sws,
 277                      SVGA3dSurfaceAllFlags flags,
 278                      SVGA3dSurfaceFormat format,
 279                      unsigned usage,
 280                      SVGA3dSize size,
 281                      uint32 numLayers,
 282                      uint32 numMipLevels,
 283                      unsigned sampleCount)
 284 {
 285     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 286     struct HIDDGalliumVMWareSVGASurf *surface = NULL;
 287     struct pb_buffer *pb_buf;
 288
 289     uint32_t buffer_size;
 290     uint32_t num_samples = 1;
 291
 292     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 293
 294     surface = CALLOC_STRUCT(HIDDGalliumVMWareSVGASurf);
 295     D(bug("[VMWareSVGA:Gallium] %s: HIDDGalliumVMWareSVGASurf @ 0x%p\n", __func__, surface));
 296
 297     pipe_reference_init(&surface->refcnt, 1);
 298
 299     /*
 300      * Used for the backing buffer GB surfaces, and to approximate
 301      * when to flush on non-GB hosts.
 302      */
 303     buffer_size = svga3dsurface_get_serialized_size_extended(format, size,
 304                                                             numMipLevels,
 305                                                             numLayers,
 306                                                             num_samples);
 307     if (flags & SVGA3D_SURFACE_BIND_STREAM_OUTPUT)
 308         buffer_size += sizeof(SVGA3dDXSOState);
 309
 310     if (buffer_size <= data->hwdata->txrmax) {
 311         D(bug("[VMWareSVGA:Gallium] %s: buffsize = %d\n", __func__, buffer_size));
 312
 313         // allocate page aligned gfx memory
 314         surface->surfbuf = VMWareSVGA_WSScr_BufferCreate(sws, 4096,
 315                                                    0,
 316                                                    buffer_size);
 317
 318         surface->sid =  VMWareSVGA_DefineSurface(data,
 319                                                    VMWareSVGA_WSSurf_WinSysSurfFromHiddSurf(surface),
 320                                                    size,
 321                                                    flags, format, numMipLevels);
 322
 323         D(bug("[VMWareSVGA:Gallium] %s: surface buffer @ 0x%p (allocated @ 0x%p, %d bytes)\n", __func__, ((struct VMWareSVGAPBBuf *)(surface->surfbuf))->map, ((struct VMWareSVGAPBBuf *)(surface->surfbuf))->allocated_map, ((struct VMWareSVGAPBBuf *)(surface->surfbuf))->allocated_size));
 324     }
 325     else
 326     {
 327         FREE(surface);
 328         return NULL;
 329     }
 330     return VMWareSVGA_WSSurf_WinSysSurfFromHiddSurf(surface);
 331 }
 332
 333 static struct svga_winsys_surface *VMWareSVGA_WSScr_SurfaceFromHandle(struct svga_winsys_screen *sws,
 334                           struct winsys_handle *whandle,
 335                           SVGA3dSurfaceFormat *format)
 336 {
 337     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 338
 339     return NULL;
 340 }
 341
 342 static boolean VMWareSVGA_WSScr_SurfaceGetHandle(struct svga_winsys_screen *sws,
 343                          struct svga_winsys_surface *surface,
 344                          unsigned stride,
 345                          struct winsys_handle *whandle)
 346 {
 347     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 348
 349     return FALSE;
 350 }
 351
 352 static boolean VMWareSVGA_WSScr_SurfaceIsFlushed(struct svga_winsys_screen *sws,
 353                          struct svga_winsys_surface *surface)
 354 {
 355     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 356
 357     return TRUE;
 358 }
 359
 360 static void VMWareSVGA_WSScr_SurfaceReference(struct svga_winsys_screen *sws,
 361                         struct svga_winsys_surface **pdst,
 362                         struct svga_winsys_surface *src)
 363 {
 364     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 365
 366     *pdst = src;
 367 }
 368
 369 static boolean VMWareSVGA_WSScr_SurfaceCanCreate(struct svga_winsys_screen *sws,
 370                          SVGA3dSurfaceFormat format,
 371                          SVGA3dSize size,
 372                          uint32 numLayers,
 373                          uint32 numMipLevels,
 374                          uint32 numSamples)
 375 {
 376     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 377     uint32_t buffer_size;
 378
 379     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 380
 381     buffer_size = svga3dsurface_get_serialized_size(format, size,
 382                                                    numMipLevels,
 383                                                    numLayers);
 384     if (numSamples > 1)
 385       buffer_size *= numSamples;
 386
 387     if (buffer_size > data->hwdata->txrmax) {
 388         return FALSE;
 389     }
 390
 391     return TRUE;
 392 }
 393
 394 static int
 395 VMWareSVGA_WSScr_FenceGet(struct svga_winsys_screen *sws,
 396                              struct pipe_fence_handle *fence,
 397                              boolean duplicate)
 398 {
 399     return (int)(IPTR)fence;
 400 }
 401
 402 static void
 403 VMWareSVGA_WSScr_FenceCreate(struct svga_winsys_screen *sws,
 404                                 struct pipe_fence_handle **fence,
 405                                 int32_t fd)
 406 {
 407     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 408     *fence = (struct pipe_fence_handle *)(IPTR)fenceVMWareSVGAFIFO(data->hwdata);
 409 }
 410
 411 static void VMWareSVGA_WSScr_FenceReference( struct svga_winsys_screen *sws,
 412                        struct pipe_fence_handle **pdst,
 413                        struct pipe_fence_handle *src )
 414 {
 415     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 416     D(bug("[VMWareSVGA:Gallium] %s: src = 0x%p\n", __func__, src));
 417     D(bug("[VMWareSVGA:Gallium] %s: dst storage @ 0x%p\n", __func__, pdst));
 418
 419     *pdst = src;
 420 }
 421
 422 static int VMWareSVGA_WSScr_FenceSignalled( struct svga_winsys_screen *sws,
 423                            struct pipe_fence_handle *fence,
 424                            unsigned flag )
 425 {
 426     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 427
 428     return 0;
 429 }
 430
 431 static int VMWareSVGA_WSScr_FenceFinish( struct svga_winsys_screen *sws,
 432                         struct pipe_fence_handle *fence,
 433                         uint64_t timeout,
 434                         unsigned flag )
 435 {
 436     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 437
 438     return 0;
 439 }
 440
 441 static struct svga_winsys_gb_shader *VMWareSVGA_WSScr_ShaderCreate(struct svga_winsys_screen *sws,
 442                     SVGA3dShaderType shaderType,
 443                     const uint32 *bytecode,
 444                     uint32 bytecodeLen)
 445 {
 446     struct HIDDGalliumVMWareSVGAData *data = VMWareSVGA_WSScr_HiddDataFromWinSys(sws);
 447     struct HIDDGalliumVMWareSVGAShader *shader = NULL;
 448     void *code;
 449
 450     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 451
 452     shader = CALLOC_STRUCT(HIDDGalliumVMWareSVGAShader);
 453     if(!shader)
 454         return NULL;
 455
 456     pipe_reference_init(&shader->refcnt, 1);
 457     shader->shaderbuf = VMWareSVGA_WSScr_BufferCreate(sws, 64,
 458                                                SVGA_BUFFER_USAGE_SHADER,
 459                                                bytecodeLen);
 460
 461     code = VMWareSVGA_WSScr_BufferMap(sws, shader->shaderbuf, PIPE_TRANSFER_WRITE);
 462     memcpy(code, bytecode, bytecodeLen);
 463     VMWareSVGA_WSScr_BufferUnMap(sws, shader->shaderbuf);
 464
 465     if (!sws->have_vgpu10) {
 466        switch (shaderType) {
 467        case SVGA3D_SHADERTYPE_VS:
 468           D(bug("[VMWareSVGA:Gallium] %s: vertex shader", __func__);)
 469           break;
 470        case SVGA3D_SHADERTYPE_PS:
 471           D(bug("[VMWareSVGA:Gallium] %s: pixel shader", __func__);)
 472           break;
 473        default:
 474           bug("[VMWareSVGA:Gallium] %s: Invalid shader type.", __func__, shaderType);
 475           break;
 476        }
 477     }
 478
 479     return VMWareSVGA_WSSurf_WinsysShaderHiddShader(shader);
 480 }
 481
 482 static void VMWareSVGA_WSScr_ShaderDestroy(struct svga_winsys_screen *sws,
 483                      struct svga_winsys_gb_shader *shader)
 484 {
 485     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 486 }
 487
 488 static struct svga_winsys_gb_query *VMWareSVGA_WSScr_QueryCreate(struct svga_winsys_screen *sws, uint32 len)
 489 {
 490     struct svga_winsys_gb_query *query = NULL;
 491
 492     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 493
 494     return query;
 495 }
 496
 497 static void VMWareSVGA_WSScr_QueryDestroy(struct svga_winsys_screen *sws,
 498                     struct svga_winsys_gb_query *query)
 499 {
 500     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 501 }
 502
 503 static int VMWareSVGA_WSScr_QueryInit(struct svga_winsys_screen *sws,
 504                        struct svga_winsys_gb_query *query,
 505                        unsigned offset,
 506                        SVGA3dQueryState queryState)
 507 {
 508     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 509
 510     return 0;
 511 }
 512
 513 static void VMWareSVGA_WSScr_QueryGetResult(struct svga_winsys_screen *sws,
 514                        struct svga_winsys_gb_query *query,
 515                        unsigned offset,
 516                        SVGA3dQueryState *queryState,
 517                        void *result, uint32 resultLen)
 518 {
 519     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
 520 }
 521
 522 static void VMWareSVGA_WSScr_StatsInc(enum svga_stats_count index)
 523 {
 524     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__);)
 525 }
 526
 527 static void VMWareSVGA_WSScr_StatsTimePush(enum svga_stats_time index,
 528                                 struct svga_winsys_stats_timeframe *tf)
 529 {
 530     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__);)
 531 }
 532
 533 static void VMWareSVGA_WSScr_StatsTimePop()
 534 {
 535     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__);)
 536 }
 537
 538 void VMWareSVGA_WSScr_WinSysInit(struct HIDDGalliumVMWareSVGAData * data)
 539 {
 540     data->wssbase.destroy                       = NULL;
 541     data->wssbase.get_hw_version                = VMWareSVGA_WSScr_GetHWVersion;
 542     data->wssbase.get_cap                       = VMWareSVGA_WSScr_GetCap;
 543
 544     data->wssbase.context_create                = VMWareSVGA_WSScr_ContextCreate;
 545
 546     data->wssbase.surface_create                = VMWareSVGA_WSScr_SurfaceCreate;
 547     data->wssbase.surface_is_flushed            = VMWareSVGA_WSScr_SurfaceIsFlushed;
 548     data->wssbase.surface_reference             = VMWareSVGA_WSScr_SurfaceReference;
 549     data->wssbase.surface_from_handle           = VMWareSVGA_WSScr_SurfaceFromHandle;
 550     data->wssbase.surface_get_handle            = VMWareSVGA_WSScr_SurfaceGetHandle;
 551     data->wssbase.surface_can_create            = VMWareSVGA_WSScr_SurfaceCanCreate;
 552
 553     data->wssbase.buffer_create                 = VMWareSVGA_WSScr_BufferCreate;
 554     data->wssbase.buffer_map                    = VMWareSVGA_WSScr_BufferMap;
 555     data->wssbase.buffer_unmap                  = VMWareSVGA_WSScr_BufferUnMap;
 556     data->wssbase.buffer_destroy                = VMWareSVGA_WSScr_BufferDestroy;
 557
 558     data->wssbase.fence_get_fd                  = VMWareSVGA_WSScr_FenceGet;
 559     data->wssbase.fence_create_fd               = VMWareSVGA_WSScr_FenceCreate;
 560 #if (0)
 561     data->wssbase.fence_server_sync              = vmw_svga_winsys_fence_server_sync;
 562 #endif
 563     data->wssbase.fence_reference               = VMWareSVGA_WSScr_FenceReference;
 564     data->wssbase.fence_signalled               = VMWareSVGA_WSScr_FenceSignalled;
 565     data->wssbase.fence_finish                  = VMWareSVGA_WSScr_FenceFinish;
 566
 567     data->wssbase.shader_create                 = VMWareSVGA_WSScr_ShaderCreate;
 568     data->wssbase.shader_destroy                = VMWareSVGA_WSScr_ShaderDestroy;
 569
 570     data->wssbase.query_create                  = VMWareSVGA_WSScr_QueryCreate;
 571     data->wssbase.query_destroy                 = VMWareSVGA_WSScr_QueryDestroy;
 572     data->wssbase.query_init                    = VMWareSVGA_WSScr_QueryInit;
 573     data->wssbase.query_get_result              = VMWareSVGA_WSScr_QueryGetResult;
 574
 575     data->wssbase.stats_inc                     = VMWareSVGA_WSScr_StatsInc;
 576     data->wssbase.stats_time_push               = VMWareSVGA_WSScr_StatsTimePush;
 577     data->wssbase.stats_time_pop                = VMWareSVGA_WSScr_StatsTimePop;
 578
 579     data->use_gbobjects = TRUE;                 // use Guest-backed objects...
 580
 581     data->wssbase.have_gb_objects = FALSE;
 582     data->wssbase.have_gb_dma = FALSE;
 583     data->wssbase.need_to_rebind_resources = FALSE;
 584
 585     data->wssbase.have_vgpu10 = FALSE;
 586     data->wssbase.have_sm4_1 = FALSE;
 587     data->wssbase.have_intra_surface_copy = FALSE;
 588
 589     if (data->use_gbobjects)
 590     {
 591         if (data->hwdata->capabilities & SVGA_CAP_GBOBJECTS)
 592             data->wssbase.have_gb_objects = TRUE;
 593     }
 594
 595     VMWareSVGA_WSScr_InitHW3DCaps(data);
 596 }