svga_screen.c revision e567b34f0d67a184ee17013f5262122fcd1380c0 
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_public.h"
33#include "svga_context.h"
34#include "svga_format.h"
35#include "svga_screen.h"
36#include "svga_resource_texture.h"
37#include "svga_resource.h"
38#include "svga_debug.h"
39
40#include "svga3d_shaderdefs.h"
41
42
43#ifdef DEBUG
44int SVGA_DEBUG = 0;
45
46static const struct debug_named_value svga_debug_flags[] = {
47   { "dma",      DEBUG_DMA, NULL },
48   { "tgsi",     DEBUG_TGSI, NULL },
49   { "pipe",     DEBUG_PIPE, NULL },
50   { "state",    DEBUG_STATE, NULL },
51   { "screen",   DEBUG_SCREEN, NULL },
52   { "tex",      DEBUG_TEX, NULL },
53   { "swtnl",    DEBUG_SWTNL, NULL },
54   { "const",    DEBUG_CONSTS, NULL },
55   { "viewport", DEBUG_VIEWPORT, NULL },
56   { "views",    DEBUG_VIEWS, NULL },
57   { "perf",     DEBUG_PERF, NULL },
58   { "flush",    DEBUG_FLUSH, NULL },
59   { "sync",     DEBUG_SYNC, NULL },
60   { "cache",    DEBUG_CACHE, NULL },
61   DEBUG_NAMED_VALUE_END
62};
63#endif
64
65static const char *
66svga_get_vendor( struct pipe_screen *pscreen )
67{
68   return "VMware, Inc.";
69}
70
71
72static const char *
73svga_get_name( struct pipe_screen *pscreen )
74{
75   const char *build = "", *llvm = "", *mutex = "";
76   static char name[100];
77#ifdef DEBUG
78   /* Only return internal details in the DEBUG version:
79    */
80   build = "build: DEBUG;";
81   mutex = "mutex: " PIPE_ATOMIC ";";
82#ifdef HAVE_LLVM
83   llvm = "LLVM;";
84#endif
85#else
86   build = "build: RELEASE;";
87#endif
88
89   util_snprintf(name, sizeof(name), "SVGA3D; %s %s %s", build, mutex, llvm);
90   return name;
91}
92
93
94
95
96static float
97svga_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
98{
99   struct svga_screen *svgascreen = svga_screen(screen);
100   struct svga_winsys_screen *sws = svgascreen->sws;
101   SVGA3dDevCapResult result;
102
103   switch (param) {
104   case PIPE_CAPF_MAX_LINE_WIDTH:
105      /* fall-through */
106   case PIPE_CAPF_MAX_LINE_WIDTH_AA:
107      return 7.0;
108
109   case PIPE_CAPF_MAX_POINT_WIDTH:
110      /* fall-through */
111   case PIPE_CAPF_MAX_POINT_WIDTH_AA:
112      /* Keep this to a reasonable size to avoid failures in
113       * conform/pntaa.c:
114       */
115      return SVGA_MAX_POINTSIZE;
116
117   case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
118      if(!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY, &result))
119         return 4.0;
120      return result.u;
121
122   case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
123      return 15.0;
124
125   default:
126      return 0;
127   }
128}
129
130
131static int
132svga_get_param(struct pipe_screen *screen, enum pipe_cap param)
133{
134   struct svga_screen *svgascreen = svga_screen(screen);
135   struct svga_winsys_screen *sws = svgascreen->sws;
136   SVGA3dDevCapResult result;
137
138   switch (param) {
139   case PIPE_CAP_MAX_COMBINED_SAMPLERS:
140      return 16;
141   case PIPE_CAP_NPOT_TEXTURES:
142      return 1;
143   case PIPE_CAP_TWO_SIDED_STENCIL:
144      return 1;
145   case PIPE_CAP_ANISOTROPIC_FILTER:
146      return 1;
147   case PIPE_CAP_POINT_SPRITE:
148      return 1;
149   case PIPE_CAP_MAX_RENDER_TARGETS:
150      if(!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_RENDER_TARGETS, &result))
151         return 1;
152      if(!result.u)
153         return 1;
154      return MIN2(result.u, PIPE_MAX_COLOR_BUFS);
155   case PIPE_CAP_OCCLUSION_QUERY:
156      return 1;
157   case PIPE_CAP_TIMER_QUERY:
158      return 0;
159   case PIPE_CAP_TEXTURE_SHADOW_MAP:
160      return 1;
161   case PIPE_CAP_TEXTURE_SWIZZLE:
162      return 1;
163
164   case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
165      {
166         unsigned levels = SVGA_MAX_TEXTURE_LEVELS;
167         if (sws->get_cap(sws, SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH, &result))
168            levels = MIN2(util_logbase2(result.u) + 1, levels);
169         else
170            levels = 12 /* 2048x2048 */;
171         if (sws->get_cap(sws, SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT, &result))
172            levels = MIN2(util_logbase2(result.u) + 1, levels);
173         else
174            levels = 12 /* 2048x2048 */;
175         return levels;
176      }
177
178   case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
179      if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_VOLUME_EXTENT, &result))
180         return 8;  /* max 128x128x128 */
181      return MIN2(util_logbase2(result.u) + 1, SVGA_MAX_TEXTURE_LEVELS);
182
183   case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
184      /*
185       * No mechanism to query the host, and at least limited to 2048x2048 on
186       * certain hardware.
187       */
188      return MIN2(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
189                  12 /* 2048x2048 */);
190
191   case PIPE_CAP_BLEND_EQUATION_SEPARATE: /* req. for GL 1.5 */
192      return 1;
193
194   case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
195   case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
196      return 1;
197   case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
198   case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
199      return 0;
200
201   case PIPE_CAP_DEPTHSTENCIL_CLEAR_SEPARATE:
202      return 1;
203   case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
204      return 0;
205
206   case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
207      return 0;
208
209   default:
210      return 0;
211   }
212}
213
214static int svga_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe_shader_cap param)
215{
216   struct svga_screen *svgascreen = svga_screen(screen);
217   struct svga_winsys_screen *sws = svgascreen->sws;
218   SVGA3dDevCapResult result;
219
220   switch (shader)
221   {
222   case PIPE_SHADER_FRAGMENT:
223      switch (param)
224      {
225      case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
226      case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
227      case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
228      case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
229         return 512;
230      case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
231         return SVGA3D_MAX_NESTING_LEVEL;
232      case PIPE_SHADER_CAP_MAX_INPUTS:
233         return 10;
234      case PIPE_SHADER_CAP_MAX_CONSTS:
235         return 224;
236      case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
237         return 1;
238      case PIPE_SHADER_CAP_MAX_TEMPS:
239         if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS, &result))
240            return 32;
241         return MIN2(result.u, SVGA3D_TEMPREG_MAX);
242      case PIPE_SHADER_CAP_MAX_ADDRS:
243      case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
244	 /*
245	  * Although PS 3.0 has some addressing abilities it can only represent
246	  * loops that can be statically determined and unrolled. Given we can
247	  * only handle a subset of the cases that the state tracker already
248	  * does it is better to defer loop unrolling to the state tracker.
249	  */
250         return 0;
251      case PIPE_SHADER_CAP_MAX_PREDS:
252         return 1;
253      case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
254         return 1;
255      case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
256      case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
257      case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
258         return 0;
259      case PIPE_SHADER_CAP_SUBROUTINES:
260         return 0;
261      case PIPE_SHADER_CAP_INTEGERS:
262         return 0;
263      case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
264         return 16;
265      }
266      break;
267   case PIPE_SHADER_VERTEX:
268      switch (param)
269      {
270      case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
271      case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
272         if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS, &result))
273            return 512;
274         return result.u;
275      case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
276      case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
277         /* XXX: until we have vertex texture support */
278         return 0;
279      case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
280         return SVGA3D_MAX_NESTING_LEVEL;
281      case PIPE_SHADER_CAP_MAX_INPUTS:
282         return 16;
283      case PIPE_SHADER_CAP_MAX_CONSTS:
284         return 256;
285      case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
286         return 1;
287      case PIPE_SHADER_CAP_MAX_TEMPS:
288         if (!sws->get_cap(sws, SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS, &result))
289            return 32;
290         return MIN2(result.u, SVGA3D_TEMPREG_MAX);
291      case PIPE_SHADER_CAP_MAX_ADDRS:
292         return 1;
293      case PIPE_SHADER_CAP_MAX_PREDS:
294         return 1;
295      case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
296         return 1;
297      case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
298      case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
299         return 1;
300      case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
301         return 0;
302      case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
303         return 1;
304      case PIPE_SHADER_CAP_SUBROUTINES:
305         return 0;
306      case PIPE_SHADER_CAP_INTEGERS:
307         return 0;
308      default:
309         break;
310      }
311      break;
312   default:
313      break;
314   }
315   return 0;
316}
317
318
319static boolean
320svga_is_format_supported( struct pipe_screen *screen,
321                          enum pipe_format format,
322                          enum pipe_texture_target target,
323                          unsigned sample_count,
324                          unsigned tex_usage)
325{
326   struct svga_screen *ss = svga_screen(screen);
327   SVGA3dSurfaceFormat svga_format;
328   SVGA3dSurfaceFormatCaps caps;
329   SVGA3dSurfaceFormatCaps mask;
330
331   assert(tex_usage);
332
333   if (sample_count > 1) {
334      return FALSE;
335   }
336
337   svga_format = svga_translate_format(ss, format, tex_usage);
338   if (svga_format == SVGA3D_FORMAT_INVALID) {
339      return FALSE;
340   }
341
342   /*
343    * Override host capabilities, so that we end up with the same
344    * visuals for all virtual hardware implementations.
345    */
346
347   if (tex_usage & PIPE_BIND_DISPLAY_TARGET) {
348      switch (svga_format) {
349      case SVGA3D_A8R8G8B8:
350      case SVGA3D_X8R8G8B8:
351      case SVGA3D_R5G6B5:
352         break;
353
354      /* Often unsupported/problematic. This means we end up with the same
355       * visuals for all virtual hardware implementations.
356       */
357      case SVGA3D_A4R4G4B4:
358      case SVGA3D_A1R5G5B5:
359         return FALSE;
360
361      default:
362         return FALSE;
363      }
364   }
365
366   /*
367    * Query the host capabilities.
368    */
369
370   svga_get_format_cap(ss, svga_format, &caps);
371
372   mask.value = 0;
373   if (tex_usage & PIPE_BIND_RENDER_TARGET) {
374      mask.offscreenRenderTarget = 1;
375   }
376   if (tex_usage & PIPE_BIND_DEPTH_STENCIL) {
377      mask.zStencil = 1;
378   }
379   if (tex_usage & PIPE_BIND_SAMPLER_VIEW) {
380      mask.texture = 1;
381   }
382
383   return (caps.value & mask.value) == mask.value;
384}
385
386
387static void
388svga_fence_reference(struct pipe_screen *screen,
389                     struct pipe_fence_handle **ptr,
390                     struct pipe_fence_handle *fence)
391{
392   struct svga_winsys_screen *sws = svga_screen(screen)->sws;
393   sws->fence_reference(sws, ptr, fence);
394}
395
396
397static boolean
398svga_fence_signalled(struct pipe_screen *screen,
399                     struct pipe_fence_handle *fence)
400{
401   struct svga_winsys_screen *sws = svga_screen(screen)->sws;
402   return sws->fence_signalled(sws, fence, 0) == 0;
403}
404
405
406static boolean
407svga_fence_finish(struct pipe_screen *screen,
408                  struct pipe_fence_handle *fence,
409                  uint64_t timeout)
410{
411   struct svga_winsys_screen *sws = svga_screen(screen)->sws;
412
413   SVGA_DBG(DEBUG_DMA|DEBUG_PERF, "%s fence_ptr %p\n",
414            __FUNCTION__, fence);
415
416   return sws->fence_finish(sws, fence, 0) == 0;
417}
418
419
420static void
421svga_destroy_screen( struct pipe_screen *screen )
422{
423   struct svga_screen *svgascreen = svga_screen(screen);
424
425   svga_screen_cache_cleanup(svgascreen);
426
427   pipe_mutex_destroy(svgascreen->swc_mutex);
428   pipe_mutex_destroy(svgascreen->tex_mutex);
429
430   svgascreen->sws->destroy(svgascreen->sws);
431
432   FREE(svgascreen);
433}
434
435
436/**
437 * Create a new svga_screen object
438 */
439struct pipe_screen *
440svga_screen_create(struct svga_winsys_screen *sws)
441{
442   struct svga_screen *svgascreen;
443   struct pipe_screen *screen;
444   SVGA3dDevCapResult result;
445   boolean use_vs30, use_ps30;
446
447#ifdef DEBUG
448   SVGA_DEBUG = debug_get_flags_option("SVGA_DEBUG", svga_debug_flags, 0 );
449#endif
450
451   svgascreen = CALLOC_STRUCT(svga_screen);
452   if (!svgascreen)
453      goto error1;
454
455   svgascreen->debug.force_level_surface_view =
456      debug_get_bool_option("SVGA_FORCE_LEVEL_SURFACE_VIEW", FALSE);
457   svgascreen->debug.force_surface_view =
458      debug_get_bool_option("SVGA_FORCE_SURFACE_VIEW", FALSE);
459   svgascreen->debug.force_sampler_view =
460      debug_get_bool_option("SVGA_FORCE_SAMPLER_VIEW", FALSE);
461   svgascreen->debug.no_surface_view =
462      debug_get_bool_option("SVGA_NO_SURFACE_VIEW", FALSE);
463   svgascreen->debug.no_sampler_view =
464      debug_get_bool_option("SVGA_NO_SAMPLER_VIEW", FALSE);
465
466   screen = &svgascreen->screen;
467
468   screen->destroy = svga_destroy_screen;
469   screen->get_name = svga_get_name;
470   screen->get_vendor = svga_get_vendor;
471   screen->get_param = svga_get_param;
472   screen->get_shader_param = svga_get_shader_param;
473   screen->get_paramf = svga_get_paramf;
474   screen->is_format_supported = svga_is_format_supported;
475   screen->context_create = svga_context_create;
476   screen->fence_reference = svga_fence_reference;
477   screen->fence_signalled = svga_fence_signalled;
478   screen->fence_finish = svga_fence_finish;
479   svgascreen->sws = sws;
480
481   svga_init_screen_resource_functions(svgascreen);
482
483   if (sws->get_hw_version) {
484      svgascreen->hw_version = sws->get_hw_version(sws);
485   } else {
486      svgascreen->hw_version = SVGA3D_HWVERSION_WS65_B1;
487   }
488
489   use_ps30 =
490      sws->get_cap(sws, SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION, &result) &&
491      result.u >= SVGA3DPSVERSION_30 ? TRUE : FALSE;
492
493   use_vs30 =
494      sws->get_cap(sws, SVGA3D_DEVCAP_VERTEX_SHADER_VERSION, &result) &&
495      result.u >= SVGA3DVSVERSION_30 ? TRUE : FALSE;
496
497   /* we require Shader model 3.0 or later */
498   if (!use_ps30 || !use_vs30)
499      goto error2;
500
501   /*
502    * The D16, D24X8, and D24S8 formats always do an implicit shadow compare
503    * when sampled from, where as the DF16, DF24, and D24S8_INT do not.  So
504    * we prefer the later when available.
505    *
506    * This mimics hardware vendors extensions for D3D depth sampling. See also
507    * http://aras-p.info/texts/D3D9GPUHacks.html
508    */
509
510   {
511      boolean has_df16, has_df24, has_d24s8_int;
512      SVGA3dSurfaceFormatCaps caps;
513      SVGA3dSurfaceFormatCaps mask;
514      mask.value = 0;
515      mask.zStencil = 1;
516      mask.texture = 1;
517
518      svgascreen->depth.z16 = SVGA3D_Z_D16;
519      svgascreen->depth.x8z24 = SVGA3D_Z_D24X8;
520      svgascreen->depth.s8z24 = SVGA3D_Z_D24S8;
521
522      svga_get_format_cap(svgascreen, SVGA3D_Z_DF16, &caps);
523      has_df16 = (caps.value & mask.value) == mask.value;
524
525      svga_get_format_cap(svgascreen, SVGA3D_Z_DF24, &caps);
526      has_df24 = (caps.value & mask.value) == mask.value;
527
528      svga_get_format_cap(svgascreen, SVGA3D_Z_D24S8_INT, &caps);
529      has_d24s8_int = (caps.value & mask.value) == mask.value;
530
531      /* XXX: We might want some other logic here.
532       * Like if we only have d24s8_int we should
533       * emulate the other formats with that.
534       */
535      if (has_df16) {
536         svgascreen->depth.z16 = SVGA3D_Z_DF16;
537      }
538      if (has_df24) {
539         svgascreen->depth.x8z24 = SVGA3D_Z_DF24;
540      }
541      if (has_d24s8_int) {
542         svgascreen->depth.s8z24 = SVGA3D_Z_D24S8_INT;
543      }
544   }
545
546   pipe_mutex_init(svgascreen->tex_mutex);
547   pipe_mutex_init(svgascreen->swc_mutex);
548
549   svga_screen_cache_init(svgascreen);
550
551   return screen;
552error2:
553   FREE(svgascreen);
554error1:
555   return NULL;
556}
557
558struct svga_winsys_screen *
559svga_winsys_screen(struct pipe_screen *screen)
560{
561   return svga_screen(screen)->sws;
562}
563
564#ifdef DEBUG
565struct svga_screen *
566svga_screen(struct pipe_screen *screen)
567{
568   assert(screen);
569   assert(screen->destroy == svga_destroy_screen);
570   return (struct svga_screen *)screen;
571}
572#endif
573