src/gallium/drivers/svga/svga_screen.c

   1 /**********************************************************
   2  * Copyright 2008-2009 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 #include "util/u_memory.h"
  27 #include "util/u_inlines.h"
  28 #include "util/u_string.h"
  29 #include "util/u_math.h"
  30
  31 #include "svga_winsys.h"
  32 #include "svga_context.h"
  33 #include "svga_screen.h"
  34 #include "svga_screen_texture.h"
  35 #include "svga_screen_buffer.h"
  36 #include "svga_debug.h"
  37
  38 #include "svga3d_shaderdefs.h"
  39
  40
  41 #ifdef DEBUG
  42 int SVGA_DEBUG = 0;
  43
  44 static const struct debug_named_value svga_debug_flags[] = {
  45    { "dma",      DEBUG_DMA },
  46    { "tgsi",     DEBUG_TGSI },
  47    { "pipe",     DEBUG_PIPE },
  48    { "state",    DEBUG_STATE },
  49    { "screen",   DEBUG_SCREEN },
  50    { "tex",      DEBUG_TEX },
  51    { "swtnl",    DEBUG_SWTNL },
  52    { "const",    DEBUG_CONSTS },
  53    { "viewport", DEBUG_VIEWPORT },
  54    { "views",    DEBUG_VIEWS },
  55    { "perf",     DEBUG_PERF },
  56    { "flush",    DEBUG_FLUSH },
  57    { "sync",     DEBUG_SYNC },
  58    { "cache",    DEBUG_CACHE },
  59    {NULL, 0}
  60 };
  61 #endif
  62
  63 static const char *
  64 svga_get_vendor( struct pipe_screen *pscreen )
  65 {
  66    return "VMware, Inc.";
  67 }
  68
  69
  70 static const char *
  71 svga_get_name( struct pipe_screen *pscreen )
  72 {
  73 #ifdef DEBUG
  74    /* Only return internal details in the DEBUG version:
  75     */
  76    return "SVGA3D; build: DEBUG; mutex: " PIPE_ATOMIC;
  77 #else
  78    return "SVGA3D; build: RELEASE; ";
  79 #endif
  80 }
  81
  82
  83
  84
  85 static float
  86 svga_get_paramf(struct pipe_screen *screen, int param)
  87 {
  88    struct svga_screen *svgascreen = svga_screen(screen);
  89    struct svga_winsys_screen *sws = svgascreen->sws;
  90    SVGA3dDevCapResult result;
  91
  92    switch (param) {
  93    case PIPE_CAP_MAX_LINE_WIDTH:
  94       /* fall-through */
  95    case PIPE_CAP_MAX_LINE_WIDTH_AA:
  96       return 7.0;
  97
  98    case PIPE_CAP_MAX_POINT_WIDTH:
  99       /* fall-through */
 100    case PIPE_CAP_MAX_POINT_WIDTH_AA:
 101       /* Keep this to a reasonable size to avoid failures in
 102        * conform/pntaa.c:
 103        */
 104       return SVGA_MAX_POINTSIZE;
 105
 106    case PIPE_CAP_MAX_TEXTURE_ANISOTROPY:
 107       return 4.0;
 108
 109    case PIPE_CAP_MAX_TEXTURE_LOD_BIAS:
 110       return 16.0;
 111
 112    case PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS:
 113       return 16;
 114    case PIPE_CAP_MAX_COMBINED_SAMPLERS:
 115       return 16;
 116    case PIPE_CAP_NPOT_TEXTURES:
 117       return 1;
 118    case PIPE_CAP_TWO_SIDED_STENCIL:
 119       return 1;
 120    case PIPE_CAP_GLSL:
 121       return svgascreen->use_ps30 && svgascreen->use_vs30;
 122    case PIPE_CAP_ANISOTROPIC_FILTER:
 123       return 1;
 124    case PIPE_CAP_POINT_SPRITE:
 125       return 1;
 126    case PIPE_CAP_MAX_RENDER_TARGETS:
 127       if(!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_RENDER_TARGETS, &result))
 128          return 1;
 129       if(!result.u)
 130          return 1;
 131       return MIN2(result.u, PIPE_MAX_COLOR_BUFS);
 132    case PIPE_CAP_OCCLUSION_QUERY:
 133       return 1;
 134    case PIPE_CAP_TEXTURE_SHADOW_MAP:
 135       return 1;
 136    case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
 137       return SVGA_MAX_TEXTURE_LEVELS;
 138    case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
 139       return 8;  /* max 128x128x128 */
 140    case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
 141       return SVGA_MAX_TEXTURE_LEVELS;
 142
 143    case PIPE_CAP_TEXTURE_MIRROR_REPEAT: /* req. for GL 1.4 */
 144       return 1;
 145
 146    case PIPE_CAP_BLEND_EQUATION_SEPARATE: /* req. for GL 1.5 */
 147       return 1;
 148
 149    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
 150    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
 151       return 1;
 152    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
 153    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
 154       return 0;
 155
 156    default:
 157       return 0;
 158    }
 159 }
 160
 161
 162 /* This is a fairly pointless interface
 163  */
 164 static int
 165 svga_get_param(struct pipe_screen *screen, int param)
 166 {
 167    return (int) svga_get_paramf( screen, param );
 168 }
 169
 170
 171 static INLINE SVGA3dDevCapIndex
 172 svga_translate_format_cap(enum pipe_format format)
 173 {
 174    switch(format) {
 175
 176    case PIPE_FORMAT_A8R8G8B8_UNORM:
 177       return SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8;
 178    case PIPE_FORMAT_X8R8G8B8_UNORM:
 179       return SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8;
 180
 181    case PIPE_FORMAT_R5G6B5_UNORM:
 182       return SVGA3D_DEVCAP_SURFACEFMT_R5G6B5;
 183    case PIPE_FORMAT_A1R5G5B5_UNORM:
 184       return SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5;
 185    case PIPE_FORMAT_A4R4G4B4_UNORM:
 186       return SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4;
 187
 188    case PIPE_FORMAT_Z16_UNORM:
 189       return SVGA3D_DEVCAP_SURFACEFMT_Z_D16;
 190    case PIPE_FORMAT_Z24S8_UNORM:
 191       return SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8;
 192    case PIPE_FORMAT_Z24X8_UNORM:
 193       return SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8;
 194
 195    case PIPE_FORMAT_A8_UNORM:
 196       return SVGA3D_DEVCAP_SURFACEFMT_ALPHA8;
 197    case PIPE_FORMAT_L8_UNORM:
 198       return SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8;
 199
 200    case PIPE_FORMAT_DXT1_RGB:
 201    case PIPE_FORMAT_DXT1_RGBA:
 202       return SVGA3D_DEVCAP_SURFACEFMT_DXT1;
 203    case PIPE_FORMAT_DXT3_RGBA:
 204       return SVGA3D_DEVCAP_SURFACEFMT_DXT3;
 205    case PIPE_FORMAT_DXT5_RGBA:
 206       return SVGA3D_DEVCAP_SURFACEFMT_DXT5;
 207
 208    default:
 209       return SVGA3D_DEVCAP_MAX;
 210    }
 211 }
 212
 213
 214 static boolean
 215 svga_is_format_supported( struct pipe_screen *screen,
 216                           enum pipe_format format,
 217                           enum pipe_texture_target target,
 218                           unsigned tex_usage,
 219                           unsigned geom_flags )
 220 {
 221    struct svga_winsys_screen *sws = svga_screen(screen)->sws;
 222    SVGA3dDevCapIndex index;
 223    SVGA3dDevCapResult result;
 224
 225    assert(tex_usage);
 226
 227    /* Override host capabilities */
 228    if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET) {
 229       switch(format) {
 230
 231       /* Often unsupported/problematic. This means we end up with the same
 232        * visuals for all virtual hardware implementations.
 233        */
 234       case PIPE_FORMAT_A4R4G4B4_UNORM:
 235       case PIPE_FORMAT_A1R5G5B5_UNORM:
 236          return FALSE;
 237
 238       /* Simulate ability to render into compressed textures */
 239       case PIPE_FORMAT_DXT1_RGB:
 240       case PIPE_FORMAT_DXT1_RGBA:
 241       case PIPE_FORMAT_DXT3_RGBA:
 242       case PIPE_FORMAT_DXT5_RGBA:
 243          return TRUE;
 244
 245       default:
 246          break;
 247       }
 248    }
 249
 250    /* Try to query the host */
 251    index = svga_translate_format_cap(format);
 252    if( index < SVGA3D_DEVCAP_MAX &&
 253        sws->get_cap(sws, index, &result) )
 254    {
 255       SVGA3dSurfaceFormatCaps mask;
 256
 257       mask.value = 0;
 258       if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 259          mask.offscreenRenderTarget = 1;
 260       if (tex_usage & PIPE_TEXTURE_USAGE_DEPTH_STENCIL)
 261          mask.zStencil = 1;
 262       if (tex_usage & PIPE_TEXTURE_USAGE_SAMPLER)
 263          mask.texture = 1;
 264
 265       if ((result.u & mask.value) == mask.value)
 266          return TRUE;
 267       else
 268          return FALSE;
 269    }
 270
 271    /* Use our translate functions directly rather than relying on a
 272     * duplicated list of supported formats which is prone to getting
 273     * out of sync:
 274     */
 275    if(tex_usage & (PIPE_TEXTURE_USAGE_RENDER_TARGET | PIPE_TEXTURE_USAGE_DEPTH_STENCIL))
 276       return svga_translate_format_render(format) != SVGA3D_FORMAT_INVALID;
 277    else
 278       return svga_translate_format(format) != SVGA3D_FORMAT_INVALID;
 279 }
 280
 281
 282 static void
 283 svga_fence_reference(struct pipe_screen *screen,
 284                      struct pipe_fence_handle **ptr,
 285                      struct pipe_fence_handle *fence)
 286 {
 287    struct svga_winsys_screen *sws = svga_screen(screen)->sws;
 288    sws->fence_reference(sws, ptr, fence);
 289 }
 290
 291
 292 static int
 293 svga_fence_signalled(struct pipe_screen *screen,
 294                      struct pipe_fence_handle *fence,
 295                      unsigned flag)
 296 {
 297    struct svga_winsys_screen *sws = svga_screen(screen)->sws;
 298    return sws->fence_signalled(sws, fence, flag);
 299 }
 300
 301
 302 static int
 303 svga_fence_finish(struct pipe_screen *screen,
 304                   struct pipe_fence_handle *fence,
 305                   unsigned flag)
 306 {
 307    struct svga_winsys_screen *sws = svga_screen(screen)->sws;
 308
 309    SVGA_DBG(DEBUG_DMA|DEBUG_PERF, "%s fence_ptr %p\n",
 310             __FUNCTION__, fence);
 311
 312    return sws->fence_finish(sws, fence, flag);
 313 }
 314
 315
 316 static void
 317 svga_destroy_screen( struct pipe_screen *screen )
 318 {
 319    struct svga_screen *svgascreen = svga_screen(screen);
 320
 321    svga_screen_cache_cleanup(svgascreen);
 322
 323    pipe_mutex_destroy(svgascreen->swc_mutex);
 324    pipe_mutex_destroy(svgascreen->tex_mutex);
 325
 326    svgascreen->swc->destroy(svgascreen->swc);
 327
 328    svgascreen->sws->destroy(svgascreen->sws);
 329
 330    FREE(svgascreen);
 331 }
 332
 333
 334 /**
 335  * Create a new svga_screen object
 336  */
 337 struct pipe_screen *
 338 svga_screen_create(struct svga_winsys_screen *sws)
 339 {
 340    struct svga_screen *svgascreen;
 341    struct pipe_screen *screen;
 342    SVGA3dDevCapResult result;
 343
 344 #ifdef DEBUG
 345    SVGA_DEBUG = debug_get_flags_option("SVGA_DEBUG", svga_debug_flags, 0 );
 346 #endif
 347
 348    svgascreen = CALLOC_STRUCT(svga_screen);
 349    if (!svgascreen)
 350       goto error1;
 351
 352    svgascreen->debug.force_level_surface_view =
 353       debug_get_bool_option("SVGA_FORCE_LEVEL_SURFACE_VIEW", FALSE);
 354    svgascreen->debug.force_surface_view =
 355       debug_get_bool_option("SVGA_FORCE_SURFACE_VIEW", FALSE);
 356    svgascreen->debug.force_sampler_view =
 357       debug_get_bool_option("SVGA_FORCE_SAMPLER_VIEW", FALSE);
 358    svgascreen->debug.no_surface_view =
 359       debug_get_bool_option("SVGA_NO_SURFACE_VIEW", FALSE);
 360    svgascreen->debug.no_sampler_view =
 361       debug_get_bool_option("SVGA_NO_SAMPLER_VIEW", FALSE);
 362
 363    screen = &svgascreen->screen;
 364
 365    screen->destroy = svga_destroy_screen;
 366    screen->get_name = svga_get_name;
 367    screen->get_vendor = svga_get_vendor;
 368    screen->get_param = svga_get_param;
 369    screen->get_paramf = svga_get_paramf;
 370    screen->is_format_supported = svga_is_format_supported;
 371    screen->context_create = svga_context_create;
 372    screen->fence_reference = svga_fence_reference;
 373    screen->fence_signalled = svga_fence_signalled;
 374    screen->fence_finish = svga_fence_finish;
 375    svgascreen->sws = sws;
 376
 377    svga_screen_init_texture_functions(screen);
 378    svga_screen_init_buffer_functions(screen);
 379
 380    svgascreen->use_ps30 =
 381       sws->get_cap(sws, SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION, &result) &&
 382       result.u >= SVGA3DPSVERSION_30 ? TRUE : FALSE;
 383
 384    svgascreen->use_vs30 =
 385       sws->get_cap(sws, SVGA3D_DEVCAP_VERTEX_SHADER_VERSION, &result) &&
 386       result.u >= SVGA3DVSVERSION_30 ? TRUE : FALSE;
 387
 388 #if 1
 389    /* Shader model 2.0 is unsupported at the moment. */
 390    if(!svgascreen->use_ps30 || !svgascreen->use_vs30)
 391       goto error2;
 392 #else
 393    if(debug_get_bool_option("SVGA_NO_SM30", FALSE))
 394       svgascreen->use_vs30 = svgascreen->use_ps30 = FALSE;
 395 #endif
 396
 397    svgascreen->swc = sws->context_create(sws);
 398    if(!svgascreen->swc)
 399       goto error2;
 400
 401    pipe_mutex_init(svgascreen->tex_mutex);
 402    pipe_mutex_init(svgascreen->swc_mutex);
 403
 404    svga_screen_cache_init(svgascreen);
 405
 406    return screen;
 407 error2:
 408    FREE(svgascreen);
 409 error1:
 410    return NULL;
 411 }
 412
 413 void svga_screen_flush( struct svga_screen *svgascreen,
 414                         struct pipe_fence_handle **pfence )
 415 {
 416    struct pipe_fence_handle *fence = NULL;
 417
 418    SVGA_DBG(DEBUG_PERF, "%s\n", __FUNCTION__);
 419
 420    pipe_mutex_lock(svgascreen->swc_mutex);
 421    svgascreen->swc->flush(svgascreen->swc, &fence);
 422    pipe_mutex_unlock(svgascreen->swc_mutex);
 423
 424    svga_screen_cache_flush(svgascreen, fence);
 425
 426    if(pfence)
 427       *pfence = fence;
 428    else
 429       svgascreen->sws->fence_reference(svgascreen->sws, &fence, NULL);
 430 }
 431
 432 struct svga_winsys_screen *
 433 svga_winsys_screen(struct pipe_screen *screen)
 434 {
 435    return svga_screen(screen)->sws;
 436 }
 437
 438 #ifdef DEBUG
 439 struct svga_screen *
 440 svga_screen(struct pipe_screen *screen)
 441 {
 442    assert(screen);
 443    assert(screen->destroy == svga_destroy_screen);
 444    return (struct svga_screen *)screen;
 445 }
 446 #endif