1 /**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28
29 #include "util/u_memory.h"
30 #include "util/u_format.h"
31 #include "util/u_format_s3tc.h"
32 #include "util/u_video.h"
33 #include "os/os_misc.h"
34 #include "os/os_time.h"
35 #include "pipe/p_defines.h"
36 #include "pipe/p_screen.h"
37 #include "draw/draw_context.h"
38
39 #include "state_tracker/sw_winsys.h"
40 #include "tgsi/tgsi_exec.h"
41
42 #include "sp_texture.h"
43 #include "sp_screen.h"
44 #include "sp_context.h"
45 #include "sp_fence.h"
46 #include "sp_public.h"
47
48 DEBUG_GET_ONCE_BOOL_OPTION(use_llvm, "SOFTPIPE_USE_LLVM", FALSE)
49
50 static const char *
softpipe_get_vendor(struct pipe_screen * screen)51 softpipe_get_vendor(struct pipe_screen *screen)
52 {
53 return "VMware, Inc.";
54 }
55
56
57 static const char *
softpipe_get_name(struct pipe_screen * screen)58 softpipe_get_name(struct pipe_screen *screen)
59 {
60 return "softpipe";
61 }
62
63
64 static int
softpipe_get_param(struct pipe_screen * screen,enum pipe_cap param)65 softpipe_get_param(struct pipe_screen *screen, enum pipe_cap param)
66 {
67 switch (param) {
68 case PIPE_CAP_NPOT_TEXTURES:
69 case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
70 case PIPE_CAP_MIXED_COLOR_DEPTH_BITS:
71 return 1;
72 case PIPE_CAP_TWO_SIDED_STENCIL:
73 return 1;
74 case PIPE_CAP_SM3:
75 return 1;
76 case PIPE_CAP_ANISOTROPIC_FILTER:
77 return 1;
78 case PIPE_CAP_POINT_SPRITE:
79 return 1;
80 case PIPE_CAP_MAX_RENDER_TARGETS:
81 return PIPE_MAX_COLOR_BUFS;
82 case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
83 return 1;
84 case PIPE_CAP_OCCLUSION_QUERY:
85 return 1;
86 case PIPE_CAP_QUERY_TIME_ELAPSED:
87 return 1;
88 case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
89 return 1;
90 case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
91 return 1;
92 case PIPE_CAP_TEXTURE_SHADOW_MAP:
93 return 1;
94 case PIPE_CAP_TEXTURE_SWIZZLE:
95 return 1;
96 case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK:
97 return 0;
98 case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
99 return SP_MAX_TEXTURE_2D_LEVELS;
100 case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
101 return SP_MAX_TEXTURE_3D_LEVELS;
102 case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
103 return SP_MAX_TEXTURE_CUBE_LEVELS;
104 case PIPE_CAP_BLEND_EQUATION_SEPARATE:
105 return 1;
106 case PIPE_CAP_INDEP_BLEND_ENABLE:
107 return 1;
108 case PIPE_CAP_INDEP_BLEND_FUNC:
109 return 1;
110 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
111 case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
112 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
113 case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
114 return 1;
115 case PIPE_CAP_DEPTH_CLIP_DISABLE:
116 return 1;
117 case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
118 return PIPE_MAX_SO_BUFFERS;
119 case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
120 case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
121 return 16*4;
122 case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
123 case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
124 return 1024;
125 case PIPE_CAP_MAX_VERTEX_STREAMS:
126 return 1;
127 case PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE:
128 return 2048;
129 case PIPE_CAP_PRIMITIVE_RESTART:
130 return 1;
131 case PIPE_CAP_SHADER_STENCIL_EXPORT:
132 return 1;
133 case PIPE_CAP_TGSI_INSTANCEID:
134 case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
135 case PIPE_CAP_START_INSTANCE:
136 return 1;
137 case PIPE_CAP_SEAMLESS_CUBE_MAP:
138 case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
139 return 1;
140 case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
141 return 256; /* for GL3 */
142 case PIPE_CAP_MIN_TEXEL_OFFSET:
143 return -8;
144 case PIPE_CAP_MAX_TEXEL_OFFSET:
145 return 7;
146 case PIPE_CAP_CONDITIONAL_RENDER:
147 return 1;
148 case PIPE_CAP_TEXTURE_BARRIER:
149 return 0;
150 case PIPE_CAP_FRAGMENT_COLOR_CLAMPED:
151 case PIPE_CAP_VERTEX_COLOR_UNCLAMPED: /* draw module */
152 case PIPE_CAP_VERTEX_COLOR_CLAMPED: /* draw module */
153 return 1;
154 case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
155 return 0;
156 case PIPE_CAP_GLSL_FEATURE_LEVEL:
157 return 330;
158 case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
159 return 0;
160 case PIPE_CAP_COMPUTE:
161 return 1;
162 case PIPE_CAP_USER_VERTEX_BUFFERS:
163 case PIPE_CAP_USER_INDEX_BUFFERS:
164 case PIPE_CAP_USER_CONSTANT_BUFFERS:
165 case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
166 case PIPE_CAP_STREAM_OUTPUT_INTERLEAVE_BUFFERS:
167 case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT:
168 return 1;
169 case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
170 return 16;
171 case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS:
172 case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY:
173 case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY:
174 case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY:
175 case PIPE_CAP_TEXTURE_MULTISAMPLE:
176 return 0;
177 case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
178 return 64;
179 case PIPE_CAP_QUERY_TIMESTAMP:
180 case PIPE_CAP_CUBE_MAP_ARRAY:
181 return 1;
182 case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
183 return 1;
184 case PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY:
185 return 0;
186 case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
187 return 65536;
188 case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
189 return 0;
190 case PIPE_CAP_TGSI_TEXCOORD:
191 case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
192 return 0;
193 case PIPE_CAP_MAX_VIEWPORTS:
194 return PIPE_MAX_VIEWPORTS;
195 case PIPE_CAP_ENDIANNESS:
196 return PIPE_ENDIAN_NATIVE;
197 case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
198 return 4;
199 case PIPE_CAP_TEXTURE_GATHER_SM5:
200 case PIPE_CAP_TEXTURE_QUERY_LOD:
201 return 1;
202 case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
203 case PIPE_CAP_SAMPLE_SHADING:
204 case PIPE_CAP_TEXTURE_GATHER_OFFSETS:
205 return 0;
206 case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION:
207 return 1;
208 case PIPE_CAP_TGSI_FS_FINE_DERIVATIVE:
209 return 0;
210 case PIPE_CAP_SAMPLER_VIEW_TARGET:
211 return 1;
212 case PIPE_CAP_FAKE_SW_MSAA:
213 return 1;
214 case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
215 return -32;
216 case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
217 return 31;
218 case PIPE_CAP_DRAW_INDIRECT:
219 return 1;
220
221 case PIPE_CAP_VENDOR_ID:
222 return 0xFFFFFFFF;
223 case PIPE_CAP_DEVICE_ID:
224 return 0xFFFFFFFF;
225 case PIPE_CAP_ACCELERATED:
226 return 0;
227 case PIPE_CAP_VIDEO_MEMORY: {
228 /* XXX: Do we want to return the full amount fo system memory ? */
229 uint64_t system_memory;
230
231 if (!os_get_total_physical_memory(&system_memory))
232 return 0;
233
234 if (sizeof(void *) == 4)
235 /* Cap to 2 GB on 32 bits system. We do this because softpipe does
236 * eat application memory, which is quite limited on 32 bits. App
237 * shouldn't expect too much available memory. */
238 system_memory = MIN2(system_memory, 2048 << 20);
239
240 return (int)(system_memory >> 20);
241 }
242 case PIPE_CAP_UMA:
243 return 0;
244 case PIPE_CAP_CONDITIONAL_RENDER_INVERTED:
245 return 1;
246 case PIPE_CAP_CLIP_HALFZ:
247 case PIPE_CAP_TEXTURE_FLOAT_LINEAR:
248 case PIPE_CAP_TEXTURE_HALF_FLOAT_LINEAR:
249 return 1;
250 case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT:
251 case PIPE_CAP_CULL_DISTANCE:
252 return 1;
253 case PIPE_CAP_VERTEXID_NOBASE:
254 return 0;
255 case PIPE_CAP_POLYGON_OFFSET_CLAMP:
256 return 0;
257 case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
258 case PIPE_CAP_TGSI_ARRAY_COMPONENTS:
259 return 1;
260 case PIPE_CAP_MULTISAMPLE_Z_RESOLVE:
261 case PIPE_CAP_RESOURCE_FROM_USER_MEMORY:
262 case PIPE_CAP_DEVICE_RESET_STATUS_QUERY:
263 case PIPE_CAP_MAX_SHADER_PATCH_VARYINGS:
264 case PIPE_CAP_DEPTH_BOUNDS_TEST:
265 case PIPE_CAP_TGSI_TXQS:
266 case PIPE_CAP_FORCE_PERSAMPLE_INTERP:
267 case PIPE_CAP_SHAREABLE_SHADERS:
268 case PIPE_CAP_CLEAR_TEXTURE:
269 case PIPE_CAP_DRAW_PARAMETERS:
270 case PIPE_CAP_TGSI_PACK_HALF_FLOAT:
271 case PIPE_CAP_MULTI_DRAW_INDIRECT:
272 case PIPE_CAP_MULTI_DRAW_INDIRECT_PARAMS:
273 case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL:
274 case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
275 case PIPE_CAP_INVALIDATE_BUFFER:
276 case PIPE_CAP_GENERATE_MIPMAP:
277 case PIPE_CAP_STRING_MARKER:
278 case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS:
279 case PIPE_CAP_QUERY_BUFFER_OBJECT:
280 case PIPE_CAP_QUERY_MEMORY_INFO:
281 case PIPE_CAP_PCI_GROUP:
282 case PIPE_CAP_PCI_BUS:
283 case PIPE_CAP_PCI_DEVICE:
284 case PIPE_CAP_PCI_FUNCTION:
285 case PIPE_CAP_ROBUST_BUFFER_ACCESS_BEHAVIOR:
286 case PIPE_CAP_PRIMITIVE_RESTART_FOR_PATCHES:
287 case PIPE_CAP_TGSI_VOTE:
288 case PIPE_CAP_MAX_WINDOW_RECTANGLES:
289 case PIPE_CAP_POLYGON_OFFSET_UNITS_UNSCALED:
290 case PIPE_CAP_VIEWPORT_SUBPIXEL_BITS:
291 case PIPE_CAP_TGSI_CAN_READ_OUTPUTS:
292 case PIPE_CAP_NATIVE_FENCE_FD:
293 case PIPE_CAP_GLSL_OPTIMIZE_CONSERVATIVELY:
294 case PIPE_CAP_TGSI_FS_FBFETCH:
295 return 0;
296 case PIPE_CAP_SHADER_BUFFER_OFFSET_ALIGNMENT:
297 return 4;
298 }
299 /* should only get here on unhandled cases */
300 debug_printf("Unexpected PIPE_CAP %d query\n", param);
301 return 0;
302 }
303
304 static int
softpipe_get_shader_param(struct pipe_screen * screen,unsigned shader,enum pipe_shader_cap param)305 softpipe_get_shader_param(struct pipe_screen *screen, unsigned shader, enum pipe_shader_cap param)
306 {
307 struct softpipe_screen *sp_screen = softpipe_screen(screen);
308 switch(shader)
309 {
310 case PIPE_SHADER_FRAGMENT:
311 return tgsi_exec_get_shader_param(param);
312 case PIPE_SHADER_COMPUTE:
313 return tgsi_exec_get_shader_param(param);
314 case PIPE_SHADER_VERTEX:
315 case PIPE_SHADER_GEOMETRY:
316 if (sp_screen->use_llvm)
317 return draw_get_shader_param(shader, param);
318 else
319 return draw_get_shader_param_no_llvm(shader, param);
320 default:
321 return 0;
322 }
323 }
324
325 static float
softpipe_get_paramf(struct pipe_screen * screen,enum pipe_capf param)326 softpipe_get_paramf(struct pipe_screen *screen, enum pipe_capf param)
327 {
328 switch (param) {
329 case PIPE_CAPF_MAX_LINE_WIDTH:
330 /* fall-through */
331 case PIPE_CAPF_MAX_LINE_WIDTH_AA:
332 return 255.0; /* arbitrary */
333 case PIPE_CAPF_MAX_POINT_WIDTH:
334 /* fall-through */
335 case PIPE_CAPF_MAX_POINT_WIDTH_AA:
336 return 255.0; /* arbitrary */
337 case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
338 return 16.0;
339 case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
340 return 16.0; /* arbitrary */
341 case PIPE_CAPF_GUARD_BAND_LEFT:
342 case PIPE_CAPF_GUARD_BAND_TOP:
343 case PIPE_CAPF_GUARD_BAND_RIGHT:
344 case PIPE_CAPF_GUARD_BAND_BOTTOM:
345 return 0.0;
346 }
347 /* should only get here on unhandled cases */
348 debug_printf("Unexpected PIPE_CAPF %d query\n", param);
349 return 0.0;
350 }
351
352 /**
353 * Query format support for creating a texture, drawing surface, etc.
354 * \param format the format to test
355 * \param type one of PIPE_TEXTURE, PIPE_SURFACE
356 */
357 static boolean
softpipe_is_format_supported(struct pipe_screen * screen,enum pipe_format format,enum pipe_texture_target target,unsigned sample_count,unsigned bind)358 softpipe_is_format_supported( struct pipe_screen *screen,
359 enum pipe_format format,
360 enum pipe_texture_target target,
361 unsigned sample_count,
362 unsigned bind)
363 {
364 struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
365 const struct util_format_description *format_desc;
366
367 assert(target == PIPE_BUFFER ||
368 target == PIPE_TEXTURE_1D ||
369 target == PIPE_TEXTURE_1D_ARRAY ||
370 target == PIPE_TEXTURE_2D ||
371 target == PIPE_TEXTURE_2D_ARRAY ||
372 target == PIPE_TEXTURE_RECT ||
373 target == PIPE_TEXTURE_3D ||
374 target == PIPE_TEXTURE_CUBE ||
375 target == PIPE_TEXTURE_CUBE_ARRAY);
376
377 format_desc = util_format_description(format);
378 if (!format_desc)
379 return FALSE;
380
381 if (sample_count > 1)
382 return FALSE;
383
384 if (bind & (PIPE_BIND_DISPLAY_TARGET |
385 PIPE_BIND_SCANOUT |
386 PIPE_BIND_SHARED)) {
387 if(!winsys->is_displaytarget_format_supported(winsys, bind, format))
388 return FALSE;
389 }
390
391 if (bind & PIPE_BIND_RENDER_TARGET) {
392 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS)
393 return FALSE;
394
395 /*
396 * Although possible, it is unnatural to render into compressed or YUV
397 * surfaces. So disable these here to avoid going into weird paths
398 * inside the state trackers.
399 */
400 if (format_desc->block.width != 1 ||
401 format_desc->block.height != 1)
402 return FALSE;
403 }
404
405 if (bind & PIPE_BIND_DEPTH_STENCIL) {
406 if (format_desc->colorspace != UTIL_FORMAT_COLORSPACE_ZS)
407 return FALSE;
408 }
409
410 if (format_desc->layout == UTIL_FORMAT_LAYOUT_BPTC ||
411 format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC) {
412 /* Software decoding is not hooked up. */
413 return FALSE;
414 }
415
416 if ((bind & (PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW)) &&
417 ((bind & PIPE_BIND_DISPLAY_TARGET) == 0) &&
418 target != PIPE_BUFFER) {
419 const struct util_format_description *desc =
420 util_format_description(format);
421 if (desc->nr_channels == 3 && desc->is_array) {
422 /* Don't support any 3-component formats for rendering/texturing
423 * since we don't support the corresponding 8-bit 3 channel UNORM
424 * formats. This allows us to support GL_ARB_copy_image between
425 * GL_RGB8 and GL_RGB8UI, for example. Otherwise, we may be asked to
426 * do a resource copy between PIPE_FORMAT_R8G8B8_UINT and
427 * PIPE_FORMAT_R8G8B8X8_UNORM, for example, which will not work
428 * (different bpp).
429 */
430 return FALSE;
431 }
432 }
433
434 if (format_desc->layout == UTIL_FORMAT_LAYOUT_ETC &&
435 format != PIPE_FORMAT_ETC1_RGB8)
436 return FALSE;
437
438 /*
439 * All other operations (sampling, transfer, etc).
440 */
441
442 if (format_desc->layout == UTIL_FORMAT_LAYOUT_S3TC) {
443 return util_format_s3tc_enabled;
444 }
445
446 /*
447 * Everything else should be supported by u_format.
448 */
449 return TRUE;
450 }
451
452
453 static void
softpipe_destroy_screen(struct pipe_screen * screen)454 softpipe_destroy_screen( struct pipe_screen *screen )
455 {
456 struct softpipe_screen *sp_screen = softpipe_screen(screen);
457 struct sw_winsys *winsys = sp_screen->winsys;
458
459 if(winsys->destroy)
460 winsys->destroy(winsys);
461
462 FREE(screen);
463 }
464
465
466 /* This is often overriden by the co-state tracker.
467 */
468 static void
softpipe_flush_frontbuffer(struct pipe_screen * _screen,struct pipe_resource * resource,unsigned level,unsigned layer,void * context_private,struct pipe_box * sub_box)469 softpipe_flush_frontbuffer(struct pipe_screen *_screen,
470 struct pipe_resource *resource,
471 unsigned level, unsigned layer,
472 void *context_private,
473 struct pipe_box *sub_box)
474 {
475 struct softpipe_screen *screen = softpipe_screen(_screen);
476 struct sw_winsys *winsys = screen->winsys;
477 struct softpipe_resource *texture = softpipe_resource(resource);
478
479 assert(texture->dt);
480 if (texture->dt)
481 winsys->displaytarget_display(winsys, texture->dt, context_private, sub_box);
482 }
483
484 static uint64_t
softpipe_get_timestamp(struct pipe_screen * _screen)485 softpipe_get_timestamp(struct pipe_screen *_screen)
486 {
487 return os_time_get_nano();
488 }
489
490 static int
softpipe_get_compute_param(struct pipe_screen * _screen,enum pipe_shader_ir ir_type,enum pipe_compute_cap param,void * ret)491 softpipe_get_compute_param(struct pipe_screen *_screen,
492 enum pipe_shader_ir ir_type,
493 enum pipe_compute_cap param,
494 void *ret)
495 {
496 switch (param) {
497 case PIPE_COMPUTE_CAP_IR_TARGET:
498 return 0;
499 case PIPE_COMPUTE_CAP_MAX_GRID_SIZE:
500 if (ret) {
501 uint64_t *grid_size = ret;
502 grid_size[0] = 65535;
503 grid_size[1] = 65535;
504 grid_size[2] = 65535;
505 }
506 return 3 * sizeof(uint64_t) ;
507 case PIPE_COMPUTE_CAP_MAX_BLOCK_SIZE:
508 if (ret) {
509 uint64_t *block_size = ret;
510 block_size[0] = 1024;
511 block_size[1] = 1024;
512 block_size[2] = 1024;
513 }
514 return 3 * sizeof(uint64_t);
515 case PIPE_COMPUTE_CAP_MAX_THREADS_PER_BLOCK:
516 if (ret) {
517 uint64_t *max_threads_per_block = ret;
518 *max_threads_per_block = 1024;
519 }
520 return sizeof(uint64_t);
521 case PIPE_COMPUTE_CAP_MAX_LOCAL_SIZE:
522 if (ret) {
523 uint64_t *max_local_size = ret;
524 *max_local_size = 32768;
525 }
526 return sizeof(uint64_t);
527 case PIPE_COMPUTE_CAP_GRID_DIMENSION:
528 case PIPE_COMPUTE_CAP_MAX_GLOBAL_SIZE:
529 case PIPE_COMPUTE_CAP_MAX_PRIVATE_SIZE:
530 case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE:
531 case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
532 case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
533 case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
534 case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
535 case PIPE_COMPUTE_CAP_SUBGROUP_SIZE:
536 case PIPE_COMPUTE_CAP_ADDRESS_BITS:
537 case PIPE_COMPUTE_CAP_MAX_VARIABLE_THREADS_PER_BLOCK:
538 break;
539 }
540 return 0;
541 }
542
543 /**
544 * Create a new pipe_screen object
545 * Note: we're not presently subclassing pipe_screen (no softpipe_screen).
546 */
547 struct pipe_screen *
softpipe_create_screen(struct sw_winsys * winsys)548 softpipe_create_screen(struct sw_winsys *winsys)
549 {
550 struct softpipe_screen *screen = CALLOC_STRUCT(softpipe_screen);
551
552 if (!screen)
553 return NULL;
554
555 screen->winsys = winsys;
556
557 screen->base.destroy = softpipe_destroy_screen;
558
559 screen->base.get_name = softpipe_get_name;
560 screen->base.get_vendor = softpipe_get_vendor;
561 screen->base.get_device_vendor = softpipe_get_vendor; // TODO should be the CPU vendor
562 screen->base.get_param = softpipe_get_param;
563 screen->base.get_shader_param = softpipe_get_shader_param;
564 screen->base.get_paramf = softpipe_get_paramf;
565 screen->base.get_timestamp = softpipe_get_timestamp;
566 screen->base.is_format_supported = softpipe_is_format_supported;
567 screen->base.context_create = softpipe_create_context;
568 screen->base.flush_frontbuffer = softpipe_flush_frontbuffer;
569 screen->base.get_compute_param = softpipe_get_compute_param;
570 screen->use_llvm = debug_get_option_use_llvm();
571
572 util_format_s3tc_init();
573
574 softpipe_init_screen_texture_funcs(&screen->base);
575 softpipe_init_screen_fence_funcs(&screen->base);
576
577 return &screen->base;
578 }
579