workbench/hidds/vmwaresvga/vmwaresvga_galliumclass.c

   1 /*
   2     Copyright 2015-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 "util/u_memory.h"
  24 #include "pipebuffer/pb_buffer.h"
  25
  26 struct VMWareSVGAPBBuf
  27 {
  28     struct pb_buffer pbbuf;
  29     void *map;
  30 };
  31
  32 #if (AROS_BIG_ENDIAN == 1)
  33 #define AROS_PIXFMT RECTFMT_RAW   /* Big Endian Archs. */
  34 #else
  35 #define AROS_PIXFMT RECTFMT_BGRA32   /* Little Endian Archs. */
  36 #endif
  37
  38
  39 // ****************************************************************************
  40 //                                               winsys/support functions
  41 // ****************************************************************************
  42
  43 static SVGA3dHardwareVersion VMWareSVGA_GetHWVersion(struct svga_winsys_screen *sws)
  44 {
  45     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
  46
  47 #if (0)
  48     if (sws->have_gb_objects)
  49     {
  50 #endif
  51         D(bug("[VMWareSVGA:Gallium] %s: returning SVGA3D_HWVERSION_WS8_B1\n", __func__));
  52         return SVGA3D_HWVERSION_WS8_B1;
  53 #if (0)
  54     }
  55     return (SVGA3dHardwareVersion) vws->ioctl.hwversion;
  56 #else
  57     return 0;
  58 #endif
  59 }
  60
  61 static boolean VMWareSVGA_GetCap(struct svga_winsys_screen *sws,
  62               SVGA3dDevCapIndex index,
  63               SVGA3dDevCapResult *result)
  64 {
  65     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
  66
  67 #if (0)
  68     if (index > vws->ioctl.num_cap_3d ||
  69         index >= SVGA3D_DEVCAP_MAX ||
  70         !vws->ioctl.cap_3d[index].has_cap)
  71 #endif
  72         return FALSE;
  73 #if (0)
  74    *result = vws->ioctl.cap_3d[index].result;
  75     return TRUE;
  76 #endif
  77 }
  78
  79 static struct svga_winsys_context *VMWareSVGA_ContextCreate(struct svga_winsys_screen *sws)
  80 {
  81     struct svga_winsys_context *wsctx;
  82
  83     D(bug("[VMWareSVGA:Gallium] %s(0x%p)\n", __func__, sws));
  84
  85     wsctx = CALLOC_STRUCT(svga_winsys_context);
  86
  87     D(bug("[VMWareSVGA:Gallium] %s: svga_winsys_context @ 0x%p\n", __func__, wsctx));
  88
  89     return wsctx;
  90 }
  91
  92 static struct svga_winsys_surface *VMWareSVGA_SurfaceCreate(
  93                     struct svga_winsys_screen *sws,
  94                      SVGA3dSurfaceAllFlags flags,
  95                      SVGA3dSurfaceFormat format,
  96                      unsigned usage,
  97                      SVGA3dSize size,
  98                      uint32 numLayers,
  99                      uint32 numMipLevels,
 100                      unsigned sampleCount)
 101 {
 102     struct svga_winsys_surface *surf = NULL;
 103
 104     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 105
 106 #if (0)
 107     surf = CALLOC_STRUCT(svga_winsys_surface);
 108 #endif
 109
 110     return surf;
 111 }
 112
 113 static struct svga_winsys_surface *VMWareSVGA_SurfaceFromHandle(struct svga_winsys_screen *sws,
 114                           struct winsys_handle *whandle,
 115                           SVGA3dSurfaceFormat *format)
 116 {
 117     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 118
 119     return NULL;
 120 }
 121
 122 static boolean VMWareSVGA_SurfaceGetHandle(struct svga_winsys_screen *sws,
 123                          struct svga_winsys_surface *surface,
 124                          unsigned stride,
 125                          struct winsys_handle *whandle)
 126 {
 127     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 128
 129     return FALSE;
 130 }
 131
 132 static boolean VMWareSVGA_SurfaceIsFlushed(struct svga_winsys_screen *sws,
 133                          struct svga_winsys_surface *surface)
 134 {
 135     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 136
 137     return TRUE;
 138 }
 139
 140 static void VMWareSVGA_SurfaceReference(struct svga_winsys_screen *sws,
 141                         struct svga_winsys_surface **pdst,
 142                         struct svga_winsys_surface *src)
 143 {
 144     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 145 }
 146
 147 static boolean VMWareSVGA_SurfaceCanCreate(struct svga_winsys_screen *sws,
 148                          SVGA3dSurfaceFormat format,
 149                          SVGA3dSize size,
 150                          uint32 numLayers,
 151                          uint32 numMipLevels,
 152                          uint32 numSamples)
 153 {
 154     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 155
 156     return TRUE;
 157 }
 158
 159 static struct svga_winsys_buffer *VMWareSVGA_BufferCreate( struct svga_winsys_screen *sws,
 160                      unsigned alignment,
 161                      unsigned usage,
 162                      unsigned size )
 163 {
 164     struct VMWareSVGAPBBuf *buf;
 165
 166     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 167
 168     buf = CALLOC_STRUCT(VMWareSVGAPBBuf);
 169
 170     return (struct svga_winsys_buffer *)buf;
 171 }
 172
 173 static void *VMWareSVGA_BufferMap( struct svga_winsys_screen *sws,
 174                   struct svga_winsys_buffer *buf,
 175                   unsigned usage )
 176 {
 177     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 178     return ((struct VMWareSVGAPBBuf *)(buf))->map;
 179 }
 180
 181 static void VMWareSVGA_BufferUnMap( struct svga_winsys_screen *sws,
 182                     struct svga_winsys_buffer *buf )
 183 {
 184     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 185 }
 186
 187 static void VMWareSVGA_BufferDestroy( struct svga_winsys_screen *sws,
 188                       struct svga_winsys_buffer *buf )
 189 {
 190     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 191     FREE(buf);
 192 }
 193
 194 static void VMWareSVGA_FenceReference( struct svga_winsys_screen *sws,
 195                        struct pipe_fence_handle **pdst,
 196                        struct pipe_fence_handle *src )
 197 {
 198     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 199 }
 200
 201 static int VMWareSVGA_FenceSignalled( struct svga_winsys_screen *sws,
 202                            struct pipe_fence_handle *fence,
 203                            unsigned flag )
 204 {
 205     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 206
 207     return 0;
 208 }
 209
 210 static int VMWareSVGA_FenceFinish( struct svga_winsys_screen *sws,
 211                         struct pipe_fence_handle *fence,
 212                         uint64_t timeout,
 213                         unsigned flag )
 214 {
 215     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 216
 217     return 0;
 218 }
 219
 220 static struct svga_winsys_gb_shader *VMWareSVGA_ShaderCreate(struct svga_winsys_screen *sws,
 221                     SVGA3dShaderType shaderType,
 222                     const uint32 *bytecode,
 223                     uint32 bytecodeLen)
 224 {
 225     struct svga_winsys_gb_shader *shader = NULL;
 226
 227     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 228
 229     return shader;
 230 }
 231
 232 static void VMWareSVGA_ShaderDestroy(struct svga_winsys_screen *sws,
 233                      struct svga_winsys_gb_shader *shader)
 234 {
 235     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 236 }
 237
 238 static struct svga_winsys_gb_query *VMWareSVGA_QueryCreate(struct svga_winsys_screen *sws, uint32 len)
 239 {
 240     struct svga_winsys_gb_query *query = NULL;
 241
 242     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 243
 244     return query;
 245 }
 246
 247 static void VMWareSVGA_QueryDestroy(struct svga_winsys_screen *sws,
 248                     struct svga_winsys_gb_query *query)
 249 {
 250     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 251 }
 252
 253 static int VMWareSVGA_QueryInit(struct svga_winsys_screen *sws,
 254                        struct svga_winsys_gb_query *query,
 255                        unsigned offset,
 256                        SVGA3dQueryState queryState)
 257 {
 258     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 259
 260     return 0;
 261 }
 262
 263 static void VMWareSVGA_QueryGetResult(struct svga_winsys_screen *sws,
 264                        struct svga_winsys_gb_query *query,
 265                        unsigned offset,
 266                        SVGA3dQueryState *queryState,
 267                        void *result, uint32 resultLen)
 268 {
 269     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 270 }
 271
 272
 273
 274 static void VMWareSVGA_StatsInc(enum svga_stats_count index)
 275 {
 276     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 277 }
 278
 279 static void VMWareSVGA_StatsTimePush(enum svga_stats_time index,
 280                                 struct svga_winsys_stats_timeframe *tf)
 281 {
 282     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 283 }
 284
 285 static void VMWareSVGA_StatsTimePop()
 286 {
 287     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 288 }
 289
 290
 291 // ****************************************************************************
 292 //                                                                Gallium Hidd Methods
 293 // ****************************************************************************
 294
 295 OOP_Object *METHOD(GalliumVMWareSVGA, Root, New)
 296 {
 297     IPTR interfaceVers;
 298
 299     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 300
 301     interfaceVers = GetTagData(aHidd_Gallium_InterfaceVersion, -1, msg->attrList);
 302     if (interfaceVers != GALLIUM_INTERFACE_VERSION)
 303         return NULL;
 304
 305     o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
 306     if (0)
 307     {
 308         struct HIDDGalliumVMWareSVGAData * data = OOP_INST_DATA(cl, o);
 309
 310         data->wsi.destroy                       = NULL;
 311         data->wsi.get_hw_version                = VMWareSVGA_GetHWVersion;
 312         data->wsi.get_cap                       = VMWareSVGA_GetCap;
 313
 314         data->wsi.context_create                = VMWareSVGA_ContextCreate;
 315
 316         data->wsi.surface_create                = VMWareSVGA_SurfaceCreate;
 317         data->wsi.surface_is_flushed            = VMWareSVGA_SurfaceIsFlushed;
 318         data->wsi.surface_reference             = VMWareSVGA_SurfaceReference;
 319         data->wsi.surface_from_handle           = VMWareSVGA_SurfaceFromHandle;
 320         data->wsi.surface_get_handle            = VMWareSVGA_SurfaceGetHandle;
 321         data->wsi.surface_can_create            = VMWareSVGA_SurfaceCanCreate;
 322
 323         data->wsi.buffer_create                 = VMWareSVGA_BufferCreate;
 324         data->wsi.buffer_map                    = VMWareSVGA_BufferMap;
 325         data->wsi.buffer_unmap                  = VMWareSVGA_BufferUnMap;
 326         data->wsi.buffer_destroy                = VMWareSVGA_BufferDestroy;
 327
 328         data->wsi.fence_reference               = VMWareSVGA_FenceReference;
 329         data->wsi.fence_signalled               = VMWareSVGA_FenceSignalled;
 330         data->wsi.fence_finish                  = VMWareSVGA_FenceFinish;
 331 #if (0)
 332         data->wsi.fence_get_fd = vmw_svga_winsys_fence_get_fd;
 333         data->wsi.fence_create_fd = vmw_svga_winsys_fence_create_fd;
 334         data->wsi.fence_server_sync = vmw_svga_winsys_fence_server_sync;
 335 #endif
 336
 337         data->wsi.shader_create                 = VMWareSVGA_ShaderCreate;
 338         data->wsi.shader_destroy                = VMWareSVGA_ShaderDestroy;
 339
 340         data->wsi.query_create                  = VMWareSVGA_QueryCreate;
 341         data->wsi.query_destroy                 = VMWareSVGA_QueryDestroy;
 342         data->wsi.query_init                    = VMWareSVGA_QueryInit;
 343         data->wsi.query_get_result              = VMWareSVGA_QueryGetResult;
 344
 345         data->wsi.stats_inc                     = VMWareSVGA_StatsInc;
 346         data->wsi.stats_time_push               = VMWareSVGA_StatsTimePush;
 347         data->wsi.stats_time_pop                = VMWareSVGA_StatsTimePop;
 348     }
 349
 350     return o;
 351 }
 352
 353 VOID METHOD(GalliumVMWareSVGA, Root, Dispose)
 354 {
 355     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 356
 357     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 358 }
 359
 360 VOID METHOD(GalliumVMWareSVGA, Root, Get)
 361 {
 362     ULONG idx;
 363
 364     if (IS_GALLIUM_ATTR(msg->attrID, idx))
 365     {
 366         switch (idx)
 367         {
 368             /* Overload the property */
 369             case aoHidd_Gallium_InterfaceVersion:
 370                 *msg->storage = GALLIUM_INTERFACE_VERSION;
 371                 return;
 372         }
 373     }
 374
 375     /* Use parent class for all other properties */
 376     OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
 377 }
 378
 379 APTR METHOD(GalliumVMWareSVGA, Hidd_Gallium, CreatePipeScreen)
 380 {
 381     struct HIDDGalliumVMWareSVGAData * data = OOP_INST_DATA(cl, o);
 382     struct pipe_screen *screen = NULL;
 383
 384     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 385
 386     screen = svga_screen_create(&data->wsi);
 387
 388     D(bug("[VMWareSVGA:Gallium] %s: screen @ 0x%p\n", __func__, screen));
 389
 390     return screen;
 391
 392 }
 393
 394 VOID METHOD(GalliumVMWareSVGA, Hidd_Gallium, DisplayResource)
 395 {
 396     D(bug("[VMWareSVGA:Gallium] %s()\n", __func__));
 397 }