546f175c7d8bc922fb199c847ee8cfdcd7822c84
[mesa.git] / src / libre-soc / vulkan / libresoc_device.c
1 /*
2 * Copyright © 2019 Raspberry Pi
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include <assert.h>
25 #include <stdbool.h>
26 #include <string.h>
27 #include <sys/mman.h>
28 #include <sys/sysinfo.h>
29 #include <unistd.h>
30
31 #include "util/debug.h"
32 #include "util/driconf.h"
33 #include "libresoc_private.h"
34 #include "compiler/glsl_types.h"
35 #include "vk_util.h"
36 #include "vk_alloc.h"
37
38 struct libresoc_deferred_queue_submission {
39 struct libresoc_queue *queue;
40 VkCommandBuffer *cmd_buffers;
41 uint32_t cmd_buffer_count;
42
43 /* Sparse bindings that happen on a queue. */
44 VkSparseBufferMemoryBindInfo *buffer_binds;
45 uint32_t buffer_bind_count;
46 VkSparseImageOpaqueMemoryBindInfo *image_opaque_binds;
47 uint32_t image_opaque_bind_count;
48
49 bool flush_caches;
50 VkShaderStageFlags wait_dst_stage_mask;
51 struct libresoc_semaphore_part **wait_semaphores;
52 uint32_t wait_semaphore_count;
53 struct libresoc_semaphore_part **signal_semaphores;
54 uint32_t signal_semaphore_count;
55 VkFence fence;
56
57 uint64_t *wait_values;
58 uint64_t *signal_values;
59
60 struct libresoc_semaphore_part *temporary_semaphore_parts;
61 uint32_t temporary_semaphore_part_count;
62
63 struct list_head queue_pending_list;
64 uint32_t submission_wait_count;
65 struct libresoc_timeline_waiter *wait_nodes;
66
67 struct list_head processing_list;
68 };
69
70 struct libresoc_queue_submission {
71 const VkCommandBuffer *cmd_buffers;
72 uint32_t cmd_buffer_count;
73
74 /* Sparse bindings that happen on a queue. */
75 const VkSparseBufferMemoryBindInfo *buffer_binds;
76 uint32_t buffer_bind_count;
77 const VkSparseImageOpaqueMemoryBindInfo *image_opaque_binds;
78 uint32_t image_opaque_bind_count;
79
80 bool flush_caches;
81 VkPipelineStageFlags wait_dst_stage_mask;
82 const VkSemaphore *wait_semaphores;
83 uint32_t wait_semaphore_count;
84 const VkSemaphore *signal_semaphores;
85 uint32_t signal_semaphore_count;
86 VkFence fence;
87
88 const uint64_t *wait_values;
89 uint32_t wait_value_count;
90 const uint64_t *signal_values;
91 uint32_t signal_value_count;
92 };
93
94 void
95 libresoc_free_memory(struct libresoc_device *device,
96 const VkAllocationCallbacks* pAllocator,
97 struct libresoc_device_memory *mem)
98 {
99 if (mem == NULL)
100 return;
101
102 vk_object_base_finish(&mem->base);
103 vk_free2(&device->vk.alloc, pAllocator, mem);
104 }
105
106 static VkResult libresoc_alloc_memory(struct libresoc_device *device,
107 const VkMemoryAllocateInfo* pAllocateInfo,
108 const VkAllocationCallbacks* pAllocator,
109 VkDeviceMemory* pMem)
110 {
111 struct libresoc_device_memory *mem;
112 VkResult result;
113 uint32_t flags = 0;
114
115 assert(pAllocateInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
116
117 const VkImportMemoryFdInfoKHR *import_info =
118 vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_FD_INFO_KHR);
119 const VkMemoryDedicatedAllocateInfo *dedicate_info =
120 vk_find_struct_const(pAllocateInfo->pNext, MEMORY_DEDICATED_ALLOCATE_INFO);
121 const VkExportMemoryAllocateInfo *export_info =
122 vk_find_struct_const(pAllocateInfo->pNext, EXPORT_MEMORY_ALLOCATE_INFO);
123 const VkImportMemoryHostPointerInfoEXT *host_ptr_info =
124 vk_find_struct_const(pAllocateInfo->pNext, IMPORT_MEMORY_HOST_POINTER_INFO_EXT);
125
126 const struct wsi_memory_allocate_info *wsi_info =
127 vk_find_struct_const(pAllocateInfo->pNext, WSI_MEMORY_ALLOCATE_INFO_MESA);
128
129
130 mem = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*mem), 8,
131 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
132 if (mem == NULL)
133 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
134
135 vk_object_base_init(&device->vk, &mem->base,
136 VK_OBJECT_TYPE_DEVICE_MEMORY);
137
138 if (dedicate_info) {
139 mem->image = libresoc_image_from_handle(dedicate_info->image);
140 //mem->buffer = libresoc_buffer_from_handle(dedicate_info->buffer);
141 } else {
142 mem->image = NULL;
143 //mem->buffer = NULL;
144 }
145
146 // float priority_float = 0.5;
147 // const struct VkMemoryPriorityAllocateInfoEXT *priority_ext =
148 // vk_find_struct_const(pAllocateInfo->pNext,
149 // MEMORY_PRIORITY_ALLOCATE_INFO_EXT);
150 // if (priority_ext)
151 // priority_float = priority_ext->priority;
152
153 // unsigned priority = MIN2(LIBRESOC_BO_PRIORITY_APPLICATION_MAX - 1,
154 // (int)(priority_float * LIBRESOC_BO_PRIORITY_APPLICATION_MAX));
155
156 mem->user_ptr = NULL;
157 //mem->bo = NULL;
158
159
160 if (import_info) {
161 assert(import_info->handleType ==
162 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT ||
163 import_info->handleType ==
164 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT);
165 // mem->bo = device->ws->buffer_from_fd(device->ws, import_info->fd,
166 // priority, NULL);
167 // if (!mem->bo) {
168 // result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
169 // goto fail;
170 // } else {
171 // close(import_info->fd);
172 // }
173
174 // if (mem->image && mem->image->plane_count == 1 &&
175 // !vk_format_is_depth_or_stencil(mem->image->vk_format)) {
176 // struct radeon_bo_metadata metadata;
177 // device->ws->buffer_get_metadata(mem->bo, &metadata);
178
179 // struct libresoc_image_create_info create_info = {
180 // .no_metadata_planes = true,
181 // .bo_metadata = &metadata
182 // };
183
184 // /* This gives a basic ability to import radeonsi images
185 // * that don't have DCC. This is not guaranteed by any
186 // * spec and can be removed after we support modifiers. */
187 // result = libresoc_image_create_layout(device, create_info, mem->image);
188 // if (result != VK_SUCCESS) {
189 // device->ws->buffer_destroy(mem->bo);
190 // goto fail;
191 // }
192 // }
193 } else if (host_ptr_info) {
194 // assert(host_ptr_info->handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT);
195 // mem->bo = device->ws->buffer_from_ptr(device->ws, host_ptr_info->pHostPointer,
196 // pAllocateInfo->allocationSize,
197 // priority);
198 // if (!mem->bo) {
199 // result = VK_ERROR_INVALID_EXTERNAL_HANDLE;
200 // goto fail;
201 // } else {
202 // mem->user_ptr = host_ptr_info->pHostPointer;
203 // }
204 } else {
205 uint64_t alloc_size = align_u64(pAllocateInfo->allocationSize, 4096);
206 uint32_t heap_index;
207
208 heap_index = device->physical_device->memory_properties.memoryTypes[pAllocateInfo->memoryTypeIndex].heapIndex;
209 // domain = device->physical_device->memory_domains[pAllocateInfo->memoryTypeIndex];
210 // flags |= device->physical_device->memory_flags[pAllocateInfo->memoryTypeIndex];
211
212 // if (!dedicate_info && !import_info && (!export_info || !export_info->handleTypes)) {
213 // flags |= RADEON_FLAG_NO_INTERPROCESS_SHARING;
214 // if (device->use_global_bo_list) {
215 // flags |= RADEON_FLAG_PREFER_LOCAL_BO;
216 // }
217 // }
218
219 if (device->overallocation_disallowed) {
220 uint64_t total_size =
221 device->physical_device->memory_properties.memoryHeaps[heap_index].size;
222
223 mtx_lock(&device->overallocation_mutex);
224 if (device->allocated_memory_size[heap_index] + alloc_size > total_size) {
225 mtx_unlock(&device->overallocation_mutex);
226 result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
227 goto fail;
228 }
229 device->allocated_memory_size[heap_index] += alloc_size;
230 mtx_unlock(&device->overallocation_mutex);
231 }
232
233 // mem->bo = device->ws->buffer_create(device->ws, alloc_size, device->physical_device->rad_info.max_alignment,
234 // domain, flags, priority);
235
236 // if (!mem->bo) {
237 // if (device->overallocation_disallowed) {
238 // mtx_lock(&device->overallocation_mutex);
239 // device->allocated_memory_size[heap_index] -= alloc_size;
240 // mtx_unlock(&device->overallocation_mutex);
241 // }
242 // result = VK_ERROR_OUT_OF_DEVICE_MEMORY;
243 // goto fail;
244 // }
245
246 mem->heap_index = heap_index;
247 mem->alloc_size = alloc_size;
248 }
249
250 // if (!wsi_info) {
251 // result = libresoc_bo_list_add(device, mem->bo);
252 // if (result != VK_SUCCESS)
253 // goto fail;
254 // }
255
256 *pMem = libresoc_device_memory_to_handle(mem);
257
258 return VK_SUCCESS;
259
260 fail:
261 libresoc_free_memory(device, pAllocator,mem);
262
263 return result;
264 }
265
266 VkResult libresoc_AllocateMemory(
267 VkDevice _device,
268 const VkMemoryAllocateInfo* pAllocateInfo,
269 const VkAllocationCallbacks* pAllocator,
270 VkDeviceMemory* pMem)
271 {
272 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
273 return libresoc_alloc_memory(device, pAllocateInfo, pAllocator, pMem);
274 }
275
276 void libresoc_FreeMemory(
277 VkDevice _device,
278 VkDeviceMemory _mem,
279 const VkAllocationCallbacks* pAllocator)
280 {
281 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
282 LIBRESOC_FROM_HANDLE(libresoc_device_memory, mem, _mem);
283
284 libresoc_free_memory(device, pAllocator, mem);
285 }
286 static VkResult
287 libresoc_create_pthread_cond(pthread_cond_t *cond)
288 {
289 pthread_condattr_t condattr;
290 if (pthread_condattr_init(&condattr)) {
291 return VK_ERROR_INITIALIZATION_FAILED;
292 }
293
294 if (pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC)) {
295 pthread_condattr_destroy(&condattr);
296 return VK_ERROR_INITIALIZATION_FAILED;
297 }
298 if (pthread_cond_init(cond, &condattr)) {
299 pthread_condattr_destroy(&condattr);
300 return VK_ERROR_INITIALIZATION_FAILED;
301 }
302 pthread_condattr_destroy(&condattr);
303 return VK_SUCCESS;
304 }
305
306 VkResult
307 libresoc_EnumerateInstanceExtensionProperties(const char *pLayerName,
308 uint32_t *pPropertyCount,
309 VkExtensionProperties *pProperties)
310 {
311 if (getenv("LIBRESOC_TRACE")) {
312 fprintf(stderr, "EnumerateInstanceExtensionProperties called for: %s \n", pLayerName);
313 }
314 VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount);
315
316 for (int i = 0; i < LIBRESOC_INSTANCE_EXTENSION_COUNT; i++) {
317 if (libresoc_instance_extensions_supported.extensions[i]) {
318 vk_outarray_append(&out, prop) {
319 *prop = libresoc_instance_extensions[i];
320 }
321 }
322 }
323
324 return vk_outarray_status(&out);
325 }
326
327 static void *
328 default_alloc_func(void *pUserData, size_t size, size_t align,
329 VkSystemAllocationScope allocationScope)
330 {
331 return malloc(size);
332 }
333
334 static void *
335 default_realloc_func(void *pUserData, void *pOriginal, size_t size,
336 size_t align, VkSystemAllocationScope allocationScope)
337 {
338 return realloc(pOriginal, size);
339 }
340
341 static void
342 default_free_func(void *pUserData, void *pMemory)
343 {
344 free(pMemory);
345 }
346
347 static const VkAllocationCallbacks default_alloc = {
348 .pUserData = NULL,
349 .pfnAllocation = default_alloc_func,
350 .pfnReallocation = default_realloc_func,
351 .pfnFree = default_free_func,
352 };
353
354 static const struct debug_control libresoc_debug_options[] = {
355 {"nofastclears", LIBRESOC_DEBUG_NO_FAST_CLEARS},
356 {"nodcc", LIBRESOC_DEBUG_NO_DCC},
357 {"shaders", LIBRESOC_DEBUG_DUMP_SHADERS},
358 {"nocache", LIBRESOC_DEBUG_NO_CACHE},
359 {"shaderstats", LIBRESOC_DEBUG_DUMP_SHADER_STATS},
360 {"nohiz", LIBRESOC_DEBUG_NO_HIZ},
361 {"nocompute", LIBRESOC_DEBUG_NO_COMPUTE_QUEUE},
362 {"allbos", LIBRESOC_DEBUG_ALL_BOS},
363 {"noibs", LIBRESOC_DEBUG_NO_IBS},
364 {"spirv", LIBRESOC_DEBUG_DUMP_SPIRV},
365 {"vmfaults", LIBRESOC_DEBUG_VM_FAULTS},
366 {"zerovram", LIBRESOC_DEBUG_ZERO_VRAM},
367 {"syncshaders", LIBRESOC_DEBUG_SYNC_SHADERS},
368 {"preoptir", LIBRESOC_DEBUG_PREOPTIR},
369 {"nodynamicbounds", LIBRESOC_DEBUG_NO_DYNAMIC_BOUNDS},
370 {"nooutoforder", LIBRESOC_DEBUG_NO_OUT_OF_ORDER},
371 {"info", LIBRESOC_DEBUG_INFO},
372 {"errors", LIBRESOC_DEBUG_ERRORS},
373 {"startup", LIBRESOC_DEBUG_STARTUP},
374 {"checkir", LIBRESOC_DEBUG_CHECKIR},
375 {"nothreadllvm", LIBRESOC_DEBUG_NOTHREADLLVM},
376 {"nobinning", LIBRESOC_DEBUG_NOBINNING},
377 {"nongg", LIBRESOC_DEBUG_NO_NGG},
378 {"allentrypoints", LIBRESOC_DEBUG_ALL_ENTRYPOINTS},
379 {"metashaders", LIBRESOC_DEBUG_DUMP_META_SHADERS},
380 {"nomemorycache", LIBRESOC_DEBUG_NO_MEMORY_CACHE},
381 {"llvm", LIBRESOC_DEBUG_LLVM},
382 {"forcecompress", LIBRESOC_DEBUG_FORCE_COMPRESS},
383 {"nir", LIBRESOC_DEBUG_DUMP_NIR},
384 {NULL, 0}
385 };
386
387 const char *
388 libresoc_get_debug_option_name(int id)
389 {
390 assert(id < ARRAY_SIZE(libresoc_debug_options) - 1);
391 return libresoc_debug_options[id].string;
392 }
393
394 static const char libresoc_dri_options_xml[] =
395 DRI_CONF_BEGIN
396 DRI_CONF_SECTION_PERFORMANCE
397 DRI_CONF_ADAPTIVE_SYNC("true")
398 DRI_CONF_VK_X11_OVERRIDE_MIN_IMAGE_COUNT(0)
399 DRI_CONF_VK_X11_STRICT_IMAGE_COUNT("false")
400 DRI_CONF_VK_X11_ENSURE_MIN_IMAGE_COUNT("false")
401 DRI_CONF_SECTION_END
402
403 DRI_CONF_SECTION_DEBUG
404 DRI_CONF_VK_WSI_FORCE_BGRA8_UNORM_FIRST("false")
405 DRI_CONF_SECTION_END
406 DRI_CONF_END;
407
408 static void libresoc_init_dri_options(struct libresoc_instance *instance)
409 {
410 driParseOptionInfo(&instance->available_dri_options, libresoc_dri_options_xml);
411 driParseConfigFiles(&instance->dri_options,
412 &instance->available_dri_options,
413 0, "libresoc", NULL,
414 instance->app_info.app_name,
415 instance->app_info.app_version,
416 instance->engineName,
417 instance->engineVersion);
418 }
419
420 VkResult
421 libresoc_CreateInstance(const VkInstanceCreateInfo *pCreateInfo,
422 const VkAllocationCallbacks *pAllocator,
423 VkInstance *pInstance)
424 {
425 if (getenv("LIBRESOC_TRACE")) {
426 fprintf(stderr, "CreateInstance called. \n");
427 }
428 struct libresoc_instance *instance;
429
430 instance = vk_zalloc2(&default_alloc, pAllocator, sizeof(*instance), 8,
431 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
432 if (!instance)
433 return vk_error(NULL, VK_ERROR_OUT_OF_HOST_MEMORY);
434
435 vk_object_base_init(NULL, &instance->base, VK_OBJECT_TYPE_INSTANCE);
436
437 if (pAllocator)
438 instance->alloc = *pAllocator;
439 else
440 instance->alloc = default_alloc;
441 if (pCreateInfo->pApplicationInfo) {
442 const VkApplicationInfo *app = pCreateInfo->pApplicationInfo;
443
444 instance->engineName =
445 vk_strdup(&instance->alloc, app->pEngineName,
446 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
447 instance->engineVersion = app->engineVersion;
448 instance->apiVersion = app->apiVersion;
449 }
450 instance->debug_flags = parse_debug_string(getenv("LIBRESOC_DEBUG"),
451 libresoc_debug_options);
452 /*TODO : enable extensions*/
453 for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
454 int idx;
455 for (idx = 0; idx < LIBRESOC_INSTANCE_EXTENSION_COUNT; idx++) {
456 if (!strcmp(pCreateInfo->ppEnabledExtensionNames[i],
457 libresoc_instance_extensions[idx].extensionName))
458 break;
459 }
460
461 if (idx >= LIBRESOC_INSTANCE_EXTENSION_COUNT ||
462 !libresoc_instance_extensions_supported.extensions[idx]) {
463 vk_object_base_finish(&instance->base);
464 vk_free2(&default_alloc, pAllocator, instance);
465 return vk_error(instance, VK_ERROR_EXTENSION_NOT_PRESENT);
466 }
467
468 instance->enabled_extensions.extensions[idx] = true;
469 }
470 for (unsigned i = 0; i < ARRAY_SIZE(instance->dispatch.entrypoints); i++) {
471 /* Vulkan requires that entrypoints for extensions which have
472 * not been enabled must not be advertised.
473 */
474 if (!libresoc_instance_entrypoint_is_enabled(i, instance->apiVersion,
475 &instance->enabled_extensions)) {
476 instance->dispatch.entrypoints[i] = NULL;
477 } else {
478 instance->dispatch.entrypoints[i] =
479 libresoc_instance_dispatch_table.entrypoints[i];
480 }
481 }
482 for (unsigned i = 0; i < ARRAY_SIZE(instance->physical_device_dispatch.entrypoints); i++) {
483 /* Vulkan requires that entrypoints for extensions which have
484 * not been enabled must not be advertised.
485 */
486 if (!libresoc_physical_device_entrypoint_is_enabled(i, instance->apiVersion,
487 &instance->enabled_extensions)) {
488 instance->physical_device_dispatch.entrypoints[i] = NULL;
489 } else {
490 instance->physical_device_dispatch.entrypoints[i] =
491 libresoc_physical_device_dispatch_table.entrypoints[i];
492 }
493 }
494
495 for (unsigned i = 0; i < ARRAY_SIZE(instance->device_dispatch.entrypoints); i++) {
496 /* Vulkan requires that entrypoints for extensions which have
497 * not been enabled must not be advertised.
498 */
499 if (!libresoc_device_entrypoint_is_enabled(i, instance->apiVersion,
500 &instance->enabled_extensions, NULL)) {
501 instance->device_dispatch.entrypoints[i] = NULL;
502 } else {
503 instance->device_dispatch.entrypoints[i] =
504 libresoc_device_dispatch_table.entrypoints[i];
505 }
506 }
507 instance->physical_devices_enumerated = false;
508 list_inithead(&instance->physical_devices);
509 glsl_type_singleton_init_or_ref();
510 libresoc_init_dri_options(instance);
511 *pInstance = libresoc_instance_to_handle(instance);
512
513 return VK_SUCCESS;
514 }
515
516 void
517 libresoc_DestroyInstance(VkInstance _instance,
518 const VkAllocationCallbacks *pAllocator)
519 {
520 if (getenv("LIBRESOC_TRACE")) {
521 fprintf(stderr, "DestroyInstance called. \n");
522 }
523 /* FIXME: stub */
524 }
525
526 static void
527 libresoc_physical_device_init_mem_types(struct libresoc_physical_device *device)
528 {
529 uint64_t visible_vram_size = 65536; //TODO: some dummy value
530 uint64_t vram_size = 65536; //TODO: some dummy value
531 int vram_index = -1, visible_vram_index = -1;
532 device->memory_properties.memoryHeapCount = 0;
533 if (vram_size > 0) {
534 vram_index = device->memory_properties.memoryHeapCount++;
535 device->memory_properties.memoryHeaps[vram_index] = (VkMemoryHeap) {
536 .size = vram_size,
537 .flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
538 };
539 }
540
541 if (visible_vram_size) {
542 visible_vram_index = device->memory_properties.memoryHeapCount++;
543 device->memory_properties.memoryHeaps[visible_vram_index] = (VkMemoryHeap) {
544 .size = visible_vram_size,
545 .flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
546 };
547 }
548 unsigned type_count = 0;
549
550 if (vram_index >= 0 || visible_vram_index >= 0) {
551 device->memory_properties.memoryTypes[type_count++] = (VkMemoryType) {
552 .propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
553 .heapIndex = vram_index >= 0 ? vram_index : visible_vram_index,
554 };
555 }
556
557 if (visible_vram_index >= 0) {
558 device->memory_properties.memoryTypes[type_count++] = (VkMemoryType) {
559 .propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
560 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
561 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
562 .heapIndex = visible_vram_index,
563 };
564 }
565
566 device->memory_properties.memoryTypeCount = type_count;
567
568
569 }
570 static VkResult
571 libresoc_physical_device_try_create(struct libresoc_instance *instance,
572 struct libresoc_physical_device **device_out)
573 {
574 VkResult result;
575 int fd = -1;
576 int master_fd = -1;
577
578 struct libresoc_physical_device *device =
579 vk_zalloc2(&instance->alloc, NULL, sizeof(*device), 8,
580 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
581 if (!device) {
582 result = vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY);
583 return result;
584 }
585
586 device->_loader_data.loaderMagic = ICD_LOADER_MAGIC;
587 device->instance = instance;
588
589 device->master_fd = master_fd;
590 device->local_fd = fd;
591 libresoc_physical_device_init_mem_types(device);
592
593 libresoc_physical_device_get_supported_extensions(device,
594 &device->supported_extensions);
595 result = libresoc_init_wsi(device);
596 if (result != VK_SUCCESS) {
597 return result;
598 }
599 snprintf(device->name, sizeof(device->name),
600 "LIBRE-SOC DEVICE");
601 *device_out = device;
602 //TODO: incase of failures need to deallocate and cleanup various allocation properly.
603 return VK_SUCCESS;
604
605 }
606 static VkResult
607 libresoc_enumerate_physical_devices(struct libresoc_instance *instance)
608 {
609
610 if (instance->physical_devices_enumerated)
611 return VK_SUCCESS;
612
613 instance->physical_devices_enumerated = true;
614 VkResult result = VK_SUCCESS;
615 /* the driver creates a null
616 * device that allows to test the compiler without having a physical device
617 */
618 struct libresoc_physical_device *pdevice;
619
620 result = libresoc_physical_device_try_create(instance, &pdevice);
621 if (result != VK_SUCCESS)
622 return result;
623
624 list_addtail(&pdevice->link, &instance->physical_devices);
625 return VK_SUCCESS;
626
627 }
628
629 VkResult
630 libresoc_EnumeratePhysicalDevices(VkInstance _instance,
631 uint32_t *pPhysicalDeviceCount,
632 VkPhysicalDevice *pPhysicalDevices)
633 {
634 if (getenv("LIBRESOC_TRACE")) {
635 fprintf(stderr, "EnumeratePhysicalDevices called\n");
636 }
637 LIBRESOC_FROM_HANDLE(libresoc_instance, instance, _instance);
638 VK_OUTARRAY_MAKE(out, pPhysicalDevices, pPhysicalDeviceCount);
639
640 VkResult result = libresoc_enumerate_physical_devices(instance);
641 if (result != VK_SUCCESS)
642 return result;
643
644 list_for_each_entry(struct libresoc_physical_device, pdevice,
645 &instance->physical_devices, link) {
646 vk_outarray_append(&out, i) {
647 *i = libresoc_physical_device_to_handle(pdevice);
648 }
649 }
650
651 return vk_outarray_status(&out);
652 }
653
654 void
655 libresoc_GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
656 VkPhysicalDeviceFeatures *pFeatures)
657 {
658 if (getenv("LIBRESOC_TRACE")) {
659 fprintf(stderr, "GetPhysicalDeviceFeatures called. \n");
660 }
661 //LIBRESOC_FROM_HANDLE(libresoc_physical_device, pdevice, physicalDevice);
662 memset(pFeatures, 0, sizeof(*pFeatures));
663
664 *pFeatures = (VkPhysicalDeviceFeatures) {
665 .robustBufferAccess = true,
666 .fullDrawIndexUint32 = true,
667 .imageCubeArray = true,
668 .independentBlend = true,
669 .geometryShader = true,
670 .tessellationShader = true,
671 .sampleRateShading = true,
672 .dualSrcBlend = true,
673 .logicOp = true,
674 .multiDrawIndirect = true,
675 .drawIndirectFirstInstance = true,
676 .depthClamp = true,
677 .depthBiasClamp = true,
678 .fillModeNonSolid = true,
679 .depthBounds = true,
680 .wideLines = true,
681 .largePoints = true,
682 .alphaToOne = true,
683 .multiViewport = true,
684 .samplerAnisotropy = true,
685 .textureCompressionETC2 = false,
686 .textureCompressionASTC_LDR = false,
687 .textureCompressionBC = true,
688 .occlusionQueryPrecise = true,
689 .pipelineStatisticsQuery = true,
690 .vertexPipelineStoresAndAtomics = true,
691 .fragmentStoresAndAtomics = true,
692 .shaderTessellationAndGeometryPointSize = true,
693 .shaderImageGatherExtended = true,
694 .shaderStorageImageExtendedFormats = true,
695 .shaderStorageImageMultisample = true,
696 .shaderUniformBufferArrayDynamicIndexing = true,
697 .shaderSampledImageArrayDynamicIndexing = true,
698 .shaderStorageBufferArrayDynamicIndexing = true,
699 .shaderStorageImageArrayDynamicIndexing = true,
700 .shaderStorageImageReadWithoutFormat = true,
701 .shaderStorageImageWriteWithoutFormat = true,
702 .shaderClipDistance = true,
703 .shaderCullDistance = true,
704 .shaderFloat64 = true,
705 .shaderInt64 = true,
706 .shaderInt16 = true,
707 .sparseBinding = true,
708 .variableMultisampleRate = true,
709 .shaderResourceMinLod = true,
710 .inheritedQueries = true,
711 };
712 }
713
714 static size_t
715 libresoc_max_descriptor_set_size()
716 {
717 /* make sure that the entire descriptor set is addressable with a signed
718 * 32-bit int. So the sum of all limits scaled by descriptor size has to
719 * be at most 2 GiB. the combined image & samples object count as one of
720 * both. This limit is for the pipeline layout, not for the set layout, but
721 * there is no set limit, so we just set a pipeline limit. I don't think
722 * any app is going to hit this soon. */
723 return ((1ull << 31) - 16 * MAX_DYNAMIC_BUFFERS
724 - MAX_INLINE_UNIFORM_BLOCK_SIZE * MAX_INLINE_UNIFORM_BLOCK_COUNT) /
725 (32 /* uniform buffer, 32 due to potential space wasted on alignment */ +
726 32 /* storage buffer, 32 due to potential space wasted on alignment */ +
727 32 /* sampler, largest when combined with image */ +
728 64 /* sampled image */ +
729 64 /* storage image */);
730 }
731
732 void
733 libresoc_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
734 VkPhysicalDeviceProperties *pProperties)
735 {
736 if (getenv("LIBRESOC_TRACE")) {
737 fprintf(stderr, "GetPhysicalDeviceProperties called. \n");
738 }
739 LIBRESOC_FROM_HANDLE(libresoc_physical_device, pdevice, physicalDevice);
740 VkSampleCountFlags sample_counts = 0xf;
741
742 size_t max_descriptor_set_size = libresoc_max_descriptor_set_size();
743
744 VkPhysicalDeviceLimits limits = {
745 .maxImageDimension1D = (1 << 14),
746 .maxImageDimension2D = (1 << 14),
747 .maxImageDimension3D = (1 << 11),
748 .maxImageDimensionCube = (1 << 14),
749 .maxImageArrayLayers = (1 << 11),
750 .maxTexelBufferElements = UINT32_MAX,
751 .maxUniformBufferRange = UINT32_MAX,
752 .maxStorageBufferRange = UINT32_MAX,
753 .maxPushConstantsSize = MAX_PUSH_CONSTANTS_SIZE,
754 .maxMemoryAllocationCount = UINT32_MAX,
755 .maxSamplerAllocationCount = 64 * 1024,
756 .bufferImageGranularity = 64, /* A cache line */
757 .sparseAddressSpaceSize = LIBRESOC_MAX_MEMORY_ALLOCATION_SIZE, /* buffer max size */
758 .maxBoundDescriptorSets = MAX_SETS,
759 .maxPerStageDescriptorSamplers = max_descriptor_set_size,
760 .maxPerStageDescriptorUniformBuffers = max_descriptor_set_size,
761 .maxPerStageDescriptorStorageBuffers = max_descriptor_set_size,
762 .maxPerStageDescriptorSampledImages = max_descriptor_set_size,
763 .maxPerStageDescriptorStorageImages = max_descriptor_set_size,
764 .maxPerStageDescriptorInputAttachments = max_descriptor_set_size,
765 .maxPerStageResources = max_descriptor_set_size,
766 .maxDescriptorSetSamplers = max_descriptor_set_size,
767 .maxDescriptorSetUniformBuffers = max_descriptor_set_size,
768 .maxDescriptorSetUniformBuffersDynamic = MAX_DYNAMIC_UNIFORM_BUFFERS,
769 .maxDescriptorSetStorageBuffers = max_descriptor_set_size,
770 .maxDescriptorSetStorageBuffersDynamic = MAX_DYNAMIC_STORAGE_BUFFERS,
771 .maxDescriptorSetSampledImages = max_descriptor_set_size,
772 .maxDescriptorSetStorageImages = max_descriptor_set_size,
773 .maxDescriptorSetInputAttachments = max_descriptor_set_size,
774 .maxVertexInputAttributes = MAX_VERTEX_ATTRIBS,
775 .maxVertexInputBindings = MAX_VBS,
776 .maxVertexInputAttributeOffset = 2047,
777 .maxVertexInputBindingStride = 2048,
778 .maxVertexOutputComponents = 128,
779 .maxTessellationGenerationLevel = 64,
780 .maxTessellationPatchSize = 32,
781 .maxTessellationControlPerVertexInputComponents = 128,
782 .maxTessellationControlPerVertexOutputComponents = 128,
783 .maxTessellationControlPerPatchOutputComponents = 120,
784 .maxTessellationControlTotalOutputComponents = 4096,
785 .maxTessellationEvaluationInputComponents = 128,
786 .maxTessellationEvaluationOutputComponents = 128,
787 .maxGeometryShaderInvocations = 127,
788 .maxGeometryInputComponents = 64,
789 .maxGeometryOutputComponents = 128,
790 .maxGeometryOutputVertices = 256,
791 .maxGeometryTotalOutputComponents = 1024,
792 .maxFragmentInputComponents = 128,
793 .maxFragmentOutputAttachments = 8,
794 .maxFragmentDualSrcAttachments = 1,
795 .maxFragmentCombinedOutputResources = 8,
796 .maxComputeSharedMemorySize = 32768,
797 .maxComputeWorkGroupCount = { 65535, 65535, 65535 },
798 .maxComputeWorkGroupInvocations = 1024,
799 .maxComputeWorkGroupSize = {
800 1024,
801 1024,
802 1024
803 },
804 .subPixelPrecisionBits = 8,
805 .subTexelPrecisionBits = 8,
806 .mipmapPrecisionBits = 8,
807 .maxDrawIndexedIndexValue = UINT32_MAX,
808 .maxDrawIndirectCount = UINT32_MAX,
809 .maxSamplerLodBias = 16,
810 .maxSamplerAnisotropy = 16,
811 .maxViewports = MAX_VIEWPORTS,
812 .maxViewportDimensions = { (1 << 14), (1 << 14) },
813 .viewportBoundsRange = { INT16_MIN, INT16_MAX },
814 .viewportSubPixelBits = 8,
815 .minMemoryMapAlignment = 4096, /* A page */
816 .minTexelBufferOffsetAlignment = 4,
817 .minUniformBufferOffsetAlignment = 4,
818 .minStorageBufferOffsetAlignment = 4,
819 .minTexelOffset = -32,
820 .maxTexelOffset = 31,
821 .minTexelGatherOffset = -32,
822 .maxTexelGatherOffset = 31,
823 .minInterpolationOffset = -2,
824 .maxInterpolationOffset = 2,
825 .subPixelInterpolationOffsetBits = 8,
826 .maxFramebufferWidth = (1 << 14),
827 .maxFramebufferHeight = (1 << 14),
828 .maxFramebufferLayers = (1 << 10),
829 .framebufferColorSampleCounts = sample_counts,
830 .framebufferDepthSampleCounts = sample_counts,
831 .framebufferStencilSampleCounts = sample_counts,
832 .framebufferNoAttachmentsSampleCounts = sample_counts,
833 .maxColorAttachments = MAX_RTS,
834 .sampledImageColorSampleCounts = sample_counts,
835 .sampledImageIntegerSampleCounts = sample_counts,
836 .sampledImageDepthSampleCounts = sample_counts,
837 .sampledImageStencilSampleCounts = sample_counts,
838 .storageImageSampleCounts = sample_counts,
839 .maxSampleMaskWords = 1,
840 .timestampComputeAndGraphics = true,
841 .timestampPeriod = 1000000.0 /* FIXME /pdevice->rad_info.clock_crystal_freq*/,
842 .maxClipDistances = 8,
843 .maxCullDistances = 8,
844 .maxCombinedClipAndCullDistances = 8,
845 .discreteQueuePriorities = 2,
846 .pointSizeRange = { 0.0, 8191.875 },
847 .lineWidthRange = { 0.0, 8191.875 },
848 .pointSizeGranularity = (1.0 / 8.0),
849 .lineWidthGranularity = (1.0 / 8.0),
850 .strictLines = false, /* FINISHME */
851 .standardSampleLocations = true,
852 .optimalBufferCopyOffsetAlignment = 128,
853 .optimalBufferCopyRowPitchAlignment = 128,
854 .nonCoherentAtomSize = 64,
855 };
856
857 *pProperties = (VkPhysicalDeviceProperties) {
858 .apiVersion = libresoc_physical_device_api_version(pdevice),
859 .driverVersion = vk_get_driver_version(),
860 .vendorID = 1, //TODO: some dummy value
861 .deviceID = 1, //TODO: dome dummy value
862 .deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
863 .limits = limits,
864 .sparseProperties = {0},
865 };
866
867 strcpy(pProperties->deviceName, pdevice->name);
868 memcpy(pProperties->pipelineCacheUUID, pdevice->cache_uuid, VK_UUID_SIZE);
869 }
870
871 static void libresoc_get_physical_device_queue_family_properties(
872 struct libresoc_physical_device* pdevice,
873 uint32_t* pCount,
874 VkQueueFamilyProperties** pQueueFamilyProperties)
875 {
876 int num_queue_families = 1;
877 int idx;
878
879 if (pQueueFamilyProperties == NULL) {
880 *pCount = num_queue_families;
881 return;
882 }
883
884 if (!*pCount)
885 return;
886
887 idx = 0;
888 if (*pCount >= 1) {
889 *pQueueFamilyProperties[idx] = (VkQueueFamilyProperties) {
890 .queueFlags = VK_QUEUE_GRAPHICS_BIT |
891 VK_QUEUE_COMPUTE_BIT |
892 VK_QUEUE_TRANSFER_BIT |
893 VK_QUEUE_SPARSE_BINDING_BIT,
894 .queueCount = 1,
895 .timestampValidBits = 64,
896 .minImageTransferGranularity = (VkExtent3D) { 1, 1, 1 },
897 };
898 idx++;
899 }
900
901 *pCount = idx;
902 }
903
904 void
905 libresoc_GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
906 uint32_t *pCount,
907 VkQueueFamilyProperties *pQueueFamilyProperties)
908 {
909 if (getenv("LIBRESOC_TRACE")) {
910 fprintf(stderr, "GetPhysicalDeviceQueueFamilyProperites called. \n");
911 }
912 LIBRESOC_FROM_HANDLE(libresoc_physical_device, pdevice, physicalDevice);
913 if (!pQueueFamilyProperties) {
914 libresoc_get_physical_device_queue_family_properties(pdevice, pCount, NULL);
915 return;
916 }
917 VkQueueFamilyProperties *properties[] = {
918 pQueueFamilyProperties + 0,
919 pQueueFamilyProperties + 1,
920 pQueueFamilyProperties + 2,
921 };
922 libresoc_get_physical_device_queue_family_properties(pdevice, pCount, properties);
923 assert(*pCount <= 3);
924 }
925
926 void
927 libresoc_GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
928 VkPhysicalDeviceMemoryProperties *pMemoryProperties)
929 {
930 if (getenv("LIBRESOC_TRACE")) {
931 fprintf(stderr, "GetPhysicalDEviceMemoryProperties called. \n");
932 }
933 LIBRESOC_FROM_HANDLE(libresoc_physical_device, physical_device, physicalDevice);
934
935 *pMemoryProperties = physical_device->memory_properties;
936 /* FIXME: stub */
937 }
938
939 //void
940 //libresoc_GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties) {
941 //
942 // if (getenv("LIBRESOC_TRACE")) {
943 // fprintf(stderr, "GetPhysicalDeviceFormatProperties called. \n");
944 // }
945 // /* FIXME: stub */
946 //}
947
948 //VkResult
949 // libresoc_GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
950 //{
951 // if (getenv("LIBRESOC_TRACE")) {
952 // fprintf(stderr, "GetPhysicalDEviceImageFormatProperties called. \n");
953 // }
954 //
955 // /* FIXME: stub */
956 // return VK_SUCCESS;
957 //}
958 // void
959 // libresoc_GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
960 // {
961 // if (getenv("LIBRESOC_TRACE")) {
962 // fprintf(stderr, "GetPhysicalDeviceSparseImageFormatProperties called. \n");
963 // }
964 // /* FIXME: stub */
965 // }
966 PFN_vkVoidFunction
967 libresoc_GetInstanceProcAddr(VkInstance _instance,
968 const char *pName)
969 {
970 if (getenv("LIBRESOC_TRACE")) {
971 fprintf(stderr, "GetInstanceProcAddr called for: %s \n", pName);
972 }
973 LIBRESOC_FROM_HANDLE(libresoc_instance, instance, _instance);
974
975 /* The Vulkan 1.0 spec for vkGetInstanceProcAddr has a table of exactly
976 * when we have to return valid function pointers, NULL, or it's left
977 * undefined. See the table for exact details.
978 */
979 if (pName == NULL)
980 return NULL;
981
982 #define LOOKUP_LIBRESOC_ENTRYPOINT(entrypoint) \
983 if (strcmp(pName, "vk" #entrypoint) == 0) \
984 return (PFN_vkVoidFunction)libresoc_##entrypoint
985
986 LOOKUP_LIBRESOC_ENTRYPOINT(EnumerateInstanceExtensionProperties);
987 LOOKUP_LIBRESOC_ENTRYPOINT(CreateInstance);
988 LOOKUP_LIBRESOC_ENTRYPOINT(DestroyInstance);
989 LOOKUP_LIBRESOC_ENTRYPOINT(EnumeratePhysicalDevices);
990 LOOKUP_LIBRESOC_ENTRYPOINT(GetPhysicalDeviceFeatures);
991 LOOKUP_LIBRESOC_ENTRYPOINT(GetPhysicalDeviceFormatProperties);
992 LOOKUP_LIBRESOC_ENTRYPOINT(GetPhysicalDeviceImageFormatProperties);
993 LOOKUP_LIBRESOC_ENTRYPOINT(GetPhysicalDeviceProperties);
994 LOOKUP_LIBRESOC_ENTRYPOINT(GetPhysicalDeviceQueueFamilyProperties);
995 LOOKUP_LIBRESOC_ENTRYPOINT(GetPhysicalDeviceMemoryProperties);
996 LOOKUP_LIBRESOC_ENTRYPOINT(GetDeviceProcAddr);
997 LOOKUP_LIBRESOC_ENTRYPOINT(CreateDevice);
998 LOOKUP_LIBRESOC_ENTRYPOINT(EnumerateDeviceExtensionProperties);
999 LOOKUP_LIBRESOC_ENTRYPOINT(GetPhysicalDeviceSparseImageFormatProperties);
1000
1001
1002 #undef LOOKUP_LIBRESOC_ENTRYPOINT
1003
1004 if (instance == NULL)
1005 return NULL;
1006
1007 int idx = libresoc_get_instance_entrypoint_index(pName);
1008 if (idx >= 0)
1009 return instance->dispatch.entrypoints[idx];
1010
1011 idx = libresoc_get_physical_device_entrypoint_index(pName);
1012 if (idx >= 0)
1013 return instance->physical_device_dispatch.entrypoints[idx];
1014
1015 idx = libresoc_get_device_entrypoint_index(pName);
1016 if (idx >= 0)
1017 return instance->device_dispatch.entrypoints[idx];
1018
1019 return NULL;
1020 }
1021
1022 /* With version 1+ of the loader interface the ICD should expose
1023 * vk_icdGetInstanceProcAddr to work around certain LD_PRELOAD issues seen in apps.
1024 */
1025 PUBLIC
1026 VKAPI_ATTR PFN_vkVoidFunction
1027 VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance,
1028 const char *pName);
1029
1030 PUBLIC
1031 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
1032 vk_icdGetInstanceProcAddr(VkInstance instance,
1033 const char* pName)
1034 {
1035 if (getenv("LIBRESOC_TRACE")) {
1036 fprintf(stderr, "vk_icdGetInstanceProcAddr called for: %s \n", pName);
1037 }
1038 return libresoc_GetInstanceProcAddr(instance, pName);
1039 }
1040
1041 PFN_vkVoidFunction
1042 libresoc_GetDeviceProcAddr(VkDevice _device,
1043 const char *pName)
1044 {
1045 if (getenv("LIBRESOC_TRACE")) {
1046 fprintf(stderr, "GetDeviceProcAddr called for: %s \n", pName);
1047 }
1048 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1049
1050 if (!device || !pName)
1051 return NULL;
1052
1053 int idx = libresoc_get_device_entrypoint_index(pName);
1054 if (idx < 0)
1055 return NULL;
1056
1057 return device->dispatch.entrypoints[idx];
1058 }
1059
1060 /* With version 4+ of the loader interface the ICD should expose
1061 * vk_icdGetPhysicalDeviceProcAddr()
1062 */
1063 PUBLIC
1064 VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
1065 vk_icdGetPhysicalDeviceProcAddr(VkInstance _instance,
1066 const char* pName);
1067
1068 PFN_vkVoidFunction
1069 vk_icdGetPhysicalDeviceProcAddr(VkInstance _instance,
1070 const char* pName)
1071 {
1072 if (getenv("LIBRESOC_TRACE")) {
1073 fprintf(stderr, "vk_icdGetPhysicalDeviceProcAddr called for: %s \n", pName);
1074 }
1075 LIBRESOC_FROM_HANDLE(libresoc_instance, instance, _instance);
1076
1077 if (!pName || !instance)
1078 return NULL;
1079
1080 int idx = libresoc_get_physical_device_entrypoint_index(pName);
1081 if (idx < 0)
1082 return NULL;
1083
1084 return instance->physical_device_dispatch.entrypoints[idx];
1085 }
1086
1087 VkResult
1088 libresoc_EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
1089 const char *pLayerName,
1090 uint32_t *pPropertyCount,
1091 VkExtensionProperties *pProperties)
1092 {
1093 if (getenv("LIBRESOC_TRACE")) {
1094 fprintf(stderr, "EnumerateDeviceExtensionProperties called for layer: %s \n", pLayerName);
1095 }
1096 LIBRESOC_FROM_HANDLE(libresoc_physical_device, device, physicalDevice);
1097 VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount);
1098
1099 for (int i = 0; i < LIBRESOC_DEVICE_EXTENSION_COUNT; i++) {
1100 if (device->supported_extensions.extensions[i]) {
1101 vk_outarray_append(&out, prop) {
1102 *prop = libresoc_device_extensions[i];
1103 }
1104 }
1105 }
1106
1107 return vk_outarray_status(&out);
1108 }
1109
1110 static void
1111 libresoc_device_init_dispatch(struct libresoc_device *device)
1112 {
1113 const struct libresoc_instance *instance = device->physical_device->instance;
1114 const struct libresoc_device_dispatch_table *dispatch_table_layer = NULL;
1115
1116 for (unsigned i = 0; i < ARRAY_SIZE(device->dispatch.entrypoints); i++) {
1117 /* Vulkan requires that entrypoints for extensions which have not been
1118 * enabled must not be advertised.
1119 */
1120 if (!libresoc_device_entrypoint_is_enabled(i, instance->apiVersion,
1121 &instance->enabled_extensions,
1122 &device->enabled_extensions)) {
1123 device->dispatch.entrypoints[i] = NULL;
1124 } else if (dispatch_table_layer &&
1125 dispatch_table_layer->entrypoints[i]) {
1126 device->dispatch.entrypoints[i] =
1127 dispatch_table_layer->entrypoints[i];
1128 } else {
1129 device->dispatch.entrypoints[i] =
1130 libresoc_device_dispatch_table.entrypoints[i];
1131 }
1132 }
1133 }
1134
1135 static VkResult
1136 check_physical_device_features(VkPhysicalDevice physicalDevice,
1137 const VkPhysicalDeviceFeatures *features)
1138 {
1139 LIBRESOC_FROM_HANDLE(libresoc_physical_device, physical_device, physicalDevice);
1140 VkPhysicalDeviceFeatures supported_features;
1141 libresoc_GetPhysicalDeviceFeatures(physicalDevice, &supported_features);
1142 VkBool32 *supported_feature = (VkBool32 *)&supported_features;
1143 VkBool32 *enabled_feature = (VkBool32 *)features;
1144 unsigned num_features = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
1145 for (uint32_t i = 0; i < num_features; i++) {
1146 if (enabled_feature[i] && !supported_feature[i])
1147 return vk_error(physical_device->instance, VK_ERROR_FEATURE_NOT_PRESENT);
1148 }
1149
1150 return VK_SUCCESS;
1151 }
1152 static int libresoc_get_device_extension_index(const char *name)
1153 {
1154 for (unsigned i = 0; i < LIBRESOC_DEVICE_EXTENSION_COUNT; ++i) {
1155 if (strcmp(name, libresoc_device_extensions[i].extensionName) == 0)
1156 return i;
1157 }
1158 return -1;
1159 }
1160
1161 static int
1162 libresoc_queue_init(struct libresoc_device *device, struct libresoc_queue *queue,
1163 uint32_t queue_family_index, int idx,
1164 VkDeviceQueueCreateFlags flags,
1165 const VkDeviceQueueGlobalPriorityCreateInfoEXT *global_priority)
1166 {
1167 queue->_loader_data.loaderMagic = ICD_LOADER_MAGIC;
1168 queue->device = device;
1169 queue->queue_family_index = queue_family_index;
1170 queue->queue_idx = idx;
1171 queue->flags = flags;
1172 list_inithead(&queue->pending_submissions);
1173 pthread_mutex_init(&queue->pending_mutex, NULL);
1174
1175 pthread_mutex_init(&queue->thread_mutex, NULL);
1176 //queue->thread_submission = NULL;
1177 queue->thread_running = queue->thread_exit = false;
1178 VkResult result = libresoc_create_pthread_cond(&queue->thread_cond);
1179 if (result != VK_SUCCESS)
1180 return vk_error(device->instance, result);
1181
1182 return VK_SUCCESS;
1183 }
1184
1185 static void
1186 libresoc_queue_finish(struct libresoc_queue *queue)
1187 {
1188 //TODO: understand and enable following code
1189 // if (queue->thread_running) {
1190 // p_atomic_set(&queue->thread_exit, true);
1191 // pthread_cond_broadcast(&queue->thread_cond);
1192 // pthread_join(queue->submission_thread, NULL);
1193 // }
1194 // pthread_cond_destroy(&queue->thread_cond);
1195 // pthread_mutex_destroy(&queue->pending_mutex);
1196 // pthread_mutex_destroy(&queue->thread_mutex);
1197 //
1198 // if (queue->hw_ctx)
1199 // queue->device->ws->ctx_destroy(queue->hw_ctx);
1200 //
1201 // if (queue->initial_full_flush_preamble_cs)
1202 // queue->device->ws->cs_destroy(queue->initial_full_flush_preamble_cs);
1203 // if (queue->initial_preamble_cs)
1204 // queue->device->ws->cs_destroy(queue->initial_preamble_cs);
1205 // if (queue->continue_preamble_cs)
1206 // queue->device->ws->cs_destroy(queue->continue_preamble_cs);
1207 // if (queue->descriptor_bo)
1208 // queue->device->ws->buffer_destroy(queue->descriptor_bo);
1209 // if (queue->scratch_bo)
1210 // queue->device->ws->buffer_destroy(queue->scratch_bo);
1211 // if (queue->esgs_ring_bo)
1212 // queue->device->ws->buffer_destroy(queue->esgs_ring_bo);
1213 // if (queue->gsvs_ring_bo)
1214 // queue->device->ws->buffer_destroy(queue->gsvs_ring_bo);
1215 // if (queue->tess_rings_bo)
1216 // queue->device->ws->buffer_destroy(queue->tess_rings_bo);
1217 // if (queue->gds_bo)
1218 // queue->device->ws->buffer_destroy(queue->gds_bo);
1219 // if (queue->gds_oa_bo)
1220 // queue->device->ws->buffer_destroy(queue->gds_oa_bo);
1221 // if (queue->compute_scratch_bo)
1222 // queue->device->ws->buffer_destroy(queue->compute_scratch_bo);
1223 }
1224 VkResult
1225 libresoc_CreateDevice(VkPhysicalDevice physicalDevice,
1226 const VkDeviceCreateInfo *pCreateInfo,
1227 const VkAllocationCallbacks *pAllocator,
1228 VkDevice *pDevice)
1229 {
1230 if (getenv("LIBRESOC_TRACE")) {
1231 fprintf(stderr, "CreateDevice called \n");
1232 }
1233 LIBRESOC_FROM_HANDLE(libresoc_physical_device, physical_device, physicalDevice);
1234 VkResult result;
1235 struct libresoc_device *device;
1236
1237 /* Check enabled features */
1238 if (pCreateInfo->pEnabledFeatures) {
1239 result = check_physical_device_features(physicalDevice,
1240 pCreateInfo->pEnabledFeatures);
1241 if (result != VK_SUCCESS)
1242 return result;
1243 }
1244
1245 device = vk_zalloc2(&physical_device->instance->alloc, pAllocator,
1246 sizeof(*device), 8,
1247 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
1248 if (!device)
1249 return vk_error(physical_device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
1250
1251 vk_device_init(&device->vk, pCreateInfo,
1252 &physical_device->instance->alloc, pAllocator);
1253
1254 device->instance = physical_device->instance;
1255 device->physical_device = physical_device;
1256
1257 for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
1258 const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i];
1259 int index = libresoc_get_device_extension_index(ext_name);
1260 if (index < 0 || !physical_device->supported_extensions.extensions[index]) {
1261 vk_free(&device->vk.alloc, device);
1262 return vk_error(physical_device->instance, VK_ERROR_EXTENSION_NOT_PRESENT);
1263 }
1264
1265 device->enabled_extensions.extensions[index] = true;
1266 }
1267
1268 libresoc_device_init_dispatch(device);
1269
1270 for (unsigned i = 0; i < pCreateInfo->queueCreateInfoCount; i++) {
1271 const VkDeviceQueueCreateInfo *queue_create = &pCreateInfo->pQueueCreateInfos[i];
1272 uint32_t qfi = queue_create->queueFamilyIndex;
1273 const VkDeviceQueueGlobalPriorityCreateInfoEXT *global_priority =
1274 vk_find_struct_const(queue_create->pNext, DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT);
1275
1276
1277 device->queues[qfi] = vk_alloc(&device->vk.alloc,
1278 queue_create->queueCount * sizeof(struct libresoc_queue), 8, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
1279 if (!device->queues[qfi]) {
1280 result = VK_ERROR_OUT_OF_HOST_MEMORY;
1281 goto fail;
1282 }
1283
1284 memset(device->queues[qfi], 0, queue_create->queueCount * sizeof(struct libresoc_queue));
1285
1286 device->queue_count[qfi] = queue_create->queueCount;
1287
1288 for (unsigned q = 0; q < queue_create->queueCount; q++) {
1289 result = libresoc_queue_init(device, &device->queues[qfi][q],
1290 qfi, q, queue_create->flags,
1291 global_priority);
1292 if (result != VK_SUCCESS)
1293 goto fail;
1294 }
1295 }
1296
1297 if (result != VK_SUCCESS)
1298 goto fail;
1299
1300 VkPipelineCacheCreateInfo ci;
1301 ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
1302 ci.pNext = NULL;
1303 ci.flags = 0;
1304 ci.pInitialData = NULL;
1305 ci.initialDataSize = 0;
1306 VkPipelineCache pc;
1307 result = libresoc_CreatePipelineCache(libresoc_device_to_handle(device),
1308 &ci, NULL, &pc);
1309 if (result != VK_SUCCESS)
1310 goto fail;
1311
1312 *pDevice = libresoc_device_to_handle(device);
1313 return VK_SUCCESS;
1314
1315 fail:
1316 libresoc_DestroyPipelineCache(libresoc_device_to_handle(device), pc, NULL);
1317 for (unsigned i = 0; i < LIBRESOC_MAX_QUEUE_FAMILIES; i++) {
1318 for (unsigned q = 0; q < device->queue_count[i]; q++)
1319 libresoc_queue_finish(&device->queues[i][q]);
1320 if (device->queue_count[i])
1321 vk_free(&device->vk.alloc, device->queues[i]);
1322 }
1323
1324 vk_free(&device->vk.alloc, device);
1325 return result;
1326 }
1327
1328 void
1329 libresoc_DestroyDevice(VkDevice _device,
1330 const VkAllocationCallbacks *pAllocator)
1331 {
1332 if (getenv("LIBRESOC_TRACE")) {
1333 fprintf(stderr, "DestroyDevice called. \n");
1334 }
1335 /* FIXME: stub */
1336 }
1337
1338 void libresoc_GetDeviceQueue(
1339 VkDevice _device,
1340 uint32_t queueFamilyIndex,
1341 uint32_t queueIndex,
1342 VkQueue* pQueue)
1343 {
1344 if (getenv("LIBRESOC_TRACE")) {
1345 fprintf(stderr, "GetDeviceQueue called. \n");
1346 }
1347 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1348 struct libresoc_queue *queue;
1349
1350 queue = &device->queues[queueFamilyIndex][queueIndex];
1351 *pQueue = libresoc_queue_to_handle(queue);
1352 }
1353
1354 VkResult libresoc_QueueWaitIdle(
1355 VkQueue _queue)
1356 {
1357 LIBRESOC_FROM_HANDLE(libresoc_queue, queue, _queue);
1358
1359 pthread_mutex_lock(&queue->pending_mutex);
1360 while (!list_is_empty(&queue->pending_submissions)) {
1361 pthread_cond_wait(&queue->device->timeline_cond, &queue->pending_mutex);
1362 }
1363 pthread_mutex_unlock(&queue->pending_mutex);
1364
1365 return VK_SUCCESS;
1366 }
1367
1368 VkResult libresoc_DeviceWaitIdle(
1369 VkDevice _device)
1370 {
1371 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1372
1373 for (unsigned i = 0; i < LIBRESOC_MAX_QUEUE_FAMILIES; i++) {
1374 for (unsigned q = 0; q < device->queue_count[i]; q++) {
1375 VkResult result =
1376 libresoc_QueueWaitIdle(libresoc_queue_to_handle(&device->queues[i][q]));
1377
1378 if (result != VK_SUCCESS)
1379 return result;
1380 }
1381 }
1382 return VK_SUCCESS;
1383 }
1384
1385 void libresoc_GetPhysicalDeviceProperties2(
1386 VkPhysicalDevice physicalDevice,
1387 VkPhysicalDeviceProperties2 *pProperties)
1388 {
1389 LIBRESOC_FROM_HANDLE(libresoc_physical_device, pdevice, physicalDevice);
1390 libresoc_GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
1391 //TODO: add more stuffs when required
1392 }
1393
1394 void libresoc_GetPhysicalDeviceFeatures2(
1395 VkPhysicalDevice physicalDevice,
1396 VkPhysicalDeviceFeatures2 *pFeatures)
1397 {
1398 LIBRESOC_FROM_HANDLE(libresoc_physical_device, pdevice, physicalDevice);
1399 libresoc_GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
1400 }
1401
1402 void libresoc_GetPhysicalDeviceQueueFamilyProperties2(
1403 VkPhysicalDevice physicalDevice,
1404 uint32_t* pCount,
1405 VkQueueFamilyProperties2 *pQueueFamilyProperties)
1406 {
1407 LIBRESOC_FROM_HANDLE(libresoc_physical_device, pdevice, physicalDevice);
1408 if (!pQueueFamilyProperties) {
1409 libresoc_get_physical_device_queue_family_properties(pdevice, pCount, NULL);
1410 return;
1411 }
1412 VkQueueFamilyProperties *properties[] = {
1413 &pQueueFamilyProperties[0].queueFamilyProperties,
1414 &pQueueFamilyProperties[1].queueFamilyProperties,
1415 &pQueueFamilyProperties[2].queueFamilyProperties,
1416 };
1417 libresoc_get_physical_device_queue_family_properties(pdevice, pCount, properties);
1418 assert(*pCount <= 3);
1419 }
1420
1421 static void
1422 libresoc_get_memory_budget_properties(VkPhysicalDevice physicalDevice,
1423 VkPhysicalDeviceMemoryBudgetPropertiesEXT *memoryBudget)
1424 {
1425 //TODO: stub
1426 }
1427
1428 void libresoc_GetPhysicalDeviceMemoryProperties2(
1429 VkPhysicalDevice physicalDevice,
1430 VkPhysicalDeviceMemoryProperties2 *pMemoryProperties)
1431 {
1432 libresoc_GetPhysicalDeviceMemoryProperties(physicalDevice,
1433 &pMemoryProperties->memoryProperties);
1434
1435 VkPhysicalDeviceMemoryBudgetPropertiesEXT *memory_budget =
1436 vk_find_struct(pMemoryProperties->pNext,
1437 PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT);
1438 if (memory_budget)
1439 libresoc_get_memory_budget_properties(physicalDevice, memory_budget);
1440 }
1441
1442 VkResult libresoc_CreateSemaphore(
1443 VkDevice _device,
1444 const VkSemaphoreCreateInfo* pCreateInfo,
1445 const VkAllocationCallbacks* pAllocator,
1446 VkSemaphore* pSemaphore)
1447 {
1448 //TODO: minimal things as of now, add more complex code as required
1449 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1450 struct libresoc_semaphore *sem = vk_alloc2(&device->vk.alloc, pAllocator,
1451 sizeof(*sem), 8,
1452 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
1453 if (!sem)
1454 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
1455
1456 vk_object_base_init(&device->vk, &sem->base,
1457 VK_OBJECT_TYPE_SEMAPHORE);
1458
1459 *pSemaphore = libresoc_semaphore_to_handle(sem);
1460 return VK_SUCCESS;
1461 }
1462
1463 void libresoc_GetImageMemoryRequirements(
1464 VkDevice _device,
1465 VkImage _image,
1466 VkMemoryRequirements* pMemoryRequirements)
1467 {
1468 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1469 LIBRESOC_FROM_HANDLE(libresoc_image, image, _image);
1470
1471 pMemoryRequirements->memoryTypeBits = (1u << device->physical_device->memory_properties.memoryTypeCount) - 1;
1472
1473 pMemoryRequirements->size = image->size;
1474 pMemoryRequirements->alignment = image->alignment;
1475 }
1476
1477 void libresoc_GetImageMemoryRequirements2(
1478 VkDevice device,
1479 const VkImageMemoryRequirementsInfo2 *pInfo,
1480 VkMemoryRequirements2 *pMemoryRequirements)
1481 {
1482 libresoc_GetImageMemoryRequirements(device, pInfo->image,
1483 &pMemoryRequirements->memoryRequirements);
1484 }
1485
1486 VkResult libresoc_BindImageMemory2(VkDevice device,
1487 uint32_t bindInfoCount,
1488 const VkBindImageMemoryInfo *pBindInfos)
1489 {
1490 for (uint32_t i = 0; i < bindInfoCount; ++i) {
1491 LIBRESOC_FROM_HANDLE(libresoc_device_memory, mem, pBindInfos[i].memory);
1492 LIBRESOC_FROM_HANDLE(libresoc_image, image, pBindInfos[i].image);
1493
1494 if (mem) {
1495 // image->bo = mem->bo;
1496 // image->offset = pBindInfos[i].memoryOffset;
1497 } else {
1498 // image->bo = NULL;
1499 // image->offset = 0;
1500 }
1501 }
1502 return VK_SUCCESS;
1503 }
1504
1505
1506 VkResult libresoc_BindImageMemory(
1507 VkDevice device,
1508 VkImage image,
1509 VkDeviceMemory memory,
1510 VkDeviceSize memoryOffset)
1511 {
1512 const VkBindImageMemoryInfo info = {
1513 .sType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
1514 .image = image,
1515 .memory = memory,
1516 .memoryOffset = memoryOffset
1517 };
1518
1519 return libresoc_BindImageMemory2(device, 1, &info);
1520 }
1521
1522 static VkResult libresoc_queue_submit(struct libresoc_queue *queue,
1523 const struct libresoc_queue_submission *submission)
1524 {
1525 return VK_SUCCESS;
1526 // struct libresoc_deferred_queue_submission *deferred = NULL;
1527
1528 // VkResult result = libresoc_create_deferred_submission(queue, submission, &deferred);
1529 // if (result != VK_SUCCESS)
1530 // return result;
1531
1532 // struct list_head processing_list;
1533 // list_inithead(&processing_list);
1534
1535 // result = libresoc_queue_enqueue_submission(deferred, &processing_list);
1536 // if (result != VK_SUCCESS) {
1537 // /* If anything is in the list we leak. */
1538 // assert(list_is_empty(&processing_list));
1539 // return result;
1540 // }
1541 // return libresoc_process_submissions(&processing_list);
1542 }
1543
1544 /* Signals fence as soon as all the work currently put on queue is done. */
1545 static VkResult libresoc_signal_fence(struct libresoc_queue *queue,
1546 VkFence fence)
1547 {
1548 return libresoc_queue_submit(queue, &(struct libresoc_queue_submission) {
1549 .fence = fence
1550 });
1551 }
1552
1553 static bool libresoc_submit_has_effects(const VkSubmitInfo *info)
1554 {
1555 return info->commandBufferCount ||
1556 info->waitSemaphoreCount ||
1557 info->signalSemaphoreCount;
1558 }
1559
1560 VkResult libresoc_QueueSubmit(
1561 VkQueue _queue,
1562 uint32_t submitCount,
1563 const VkSubmitInfo* pSubmits,
1564 VkFence fence)
1565 {
1566 LIBRESOC_FROM_HANDLE(libresoc_queue, queue, _queue);
1567 VkResult result;
1568 uint32_t fence_idx = 0;
1569 bool flushed_caches = false;
1570
1571 if (fence != VK_NULL_HANDLE) {
1572 for (uint32_t i = 0; i < submitCount; ++i)
1573 if (libresoc_submit_has_effects(pSubmits + i))
1574 fence_idx = i;
1575 } else
1576 fence_idx = UINT32_MAX;
1577
1578 for (uint32_t i = 0; i < submitCount; i++) {
1579 if (!libresoc_submit_has_effects(pSubmits + i) && fence_idx != i)
1580 continue;
1581
1582 VkPipelineStageFlags wait_dst_stage_mask = 0;
1583 for (unsigned j = 0; j < pSubmits[i].waitSemaphoreCount; ++j) {
1584 wait_dst_stage_mask |= pSubmits[i].pWaitDstStageMask[j];
1585 }
1586
1587 const VkTimelineSemaphoreSubmitInfo *timeline_info =
1588 vk_find_struct_const(pSubmits[i].pNext, TIMELINE_SEMAPHORE_SUBMIT_INFO);
1589
1590 result = libresoc_queue_submit(queue, &(struct libresoc_queue_submission) {
1591 .cmd_buffers = pSubmits[i].pCommandBuffers,
1592 .cmd_buffer_count = pSubmits[i].commandBufferCount,
1593 .wait_dst_stage_mask = wait_dst_stage_mask,
1594 .flush_caches = !flushed_caches,
1595 .wait_semaphores = pSubmits[i].pWaitSemaphores,
1596 .wait_semaphore_count = pSubmits[i].waitSemaphoreCount,
1597 .signal_semaphores = pSubmits[i].pSignalSemaphores,
1598 .signal_semaphore_count = pSubmits[i].signalSemaphoreCount,
1599 .fence = i == fence_idx ? fence : VK_NULL_HANDLE,
1600 .wait_values = timeline_info ? timeline_info->pWaitSemaphoreValues : NULL,
1601 .wait_value_count = timeline_info && timeline_info->pWaitSemaphoreValues ? timeline_info->waitSemaphoreValueCount : 0,
1602 .signal_values = timeline_info ? timeline_info->pSignalSemaphoreValues : NULL,
1603 .signal_value_count = timeline_info && timeline_info->pSignalSemaphoreValues ? timeline_info->signalSemaphoreValueCount : 0,
1604 });
1605 if (result != VK_SUCCESS)
1606 return result;
1607
1608 flushed_caches = true;
1609 }
1610
1611 if (fence != VK_NULL_HANDLE && !submitCount) {
1612 result = libresoc_signal_fence(queue, fence);
1613 if (result != VK_SUCCESS)
1614 return result;
1615 }
1616
1617 return VK_SUCCESS;
1618 }
1619
1620 VkResult libresoc_CreateFence(
1621 VkDevice _device,
1622 const VkFenceCreateInfo* pCreateInfo,
1623 const VkAllocationCallbacks* pAllocator,
1624 VkFence* pFence)
1625 {
1626 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1627 const VkExportFenceCreateInfo *export =
1628 vk_find_struct_const(pCreateInfo->pNext, EXPORT_FENCE_CREATE_INFO);
1629 VkExternalFenceHandleTypeFlags handleTypes =
1630 export ? export->handleTypes : 0;
1631 struct libresoc_fence *fence;
1632
1633 fence = vk_zalloc2(&device->vk.alloc, pAllocator, sizeof(*fence), 8,
1634 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
1635 if (!fence)
1636 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
1637
1638 vk_object_base_init(&device->vk, &fence->base, VK_OBJECT_TYPE_FENCE);
1639
1640 // if (device->always_use_syncobj || handleTypes) {
1641 // fence->permanent.kind = LIBRESOC_FENCE_SYNCOBJ;
1642
1643 // bool create_signaled = false;
1644 // if (pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT)
1645 // create_signaled = true;
1646
1647 // int ret = device->ws->create_syncobj(device->ws, create_signaled,
1648 // &fence->permanent.syncobj);
1649 // if (ret) {
1650 // libresoc_destroy_fence(device, pAllocator, fence);
1651 // return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
1652 // }
1653 // } else {
1654 // fence->permanent.kind = LIBRESOC_FENCE_WINSYS;
1655
1656 // fence->permanent.fence = device->ws->create_fence();
1657 // if (!fence->permanent.fence) {
1658 // vk_free2(&device->vk.alloc, pAllocator, fence);
1659 // libresoc_destroy_fence(device, pAllocator, fence);
1660 // return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
1661 // }
1662 // if (pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT)
1663 // device->ws->signal_fence(fence->permanent.fence);
1664 // }
1665
1666 *pFence = libresoc_fence_to_handle(fence);
1667
1668 return VK_SUCCESS;
1669 }
1670
1671 VkResult libresoc_MapMemory(
1672 VkDevice _device,
1673 VkDeviceMemory _memory,
1674 VkDeviceSize offset,
1675 VkDeviceSize size,
1676 VkMemoryMapFlags flags,
1677 void** ppData)
1678 {
1679 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1680 LIBRESOC_FROM_HANDLE(libresoc_device_memory, mem, _memory);
1681
1682 if (mem == NULL) {
1683 *ppData = NULL;
1684 return VK_SUCCESS;
1685 }
1686
1687 if (mem->user_ptr)
1688 *ppData = mem->user_ptr;
1689 // else
1690 // *ppData = device->ws->buffer_map(mem->bo);
1691
1692 if (*ppData) {
1693 *ppData += offset;
1694 return VK_SUCCESS;
1695 }
1696
1697 return vk_error(device->instance, VK_ERROR_MEMORY_MAP_FAILED);
1698 }
1699
1700 void libresoc_UnmapMemory(
1701 VkDevice _device,
1702 VkDeviceMemory _memory)
1703 {
1704 LIBRESOC_FROM_HANDLE(libresoc_device, device, _device);
1705 LIBRESOC_FROM_HANDLE(libresoc_device_memory, mem, _memory);
1706
1707 if (mem == NULL)
1708 return;
1709
1710 // if (mem->user_ptr == NULL)
1711 // device->ws->buffer_unmap(mem->bo);
1712 }
1713
1714 VkResult libresoc_WaitForFences(
1715 VkDevice _device,
1716 uint32_t fenceCount,
1717 const VkFence* pFences,
1718 VkBool32 waitAll,
1719 uint64_t timeout)
1720 {
1721 //TODO: stub
1722 return VK_SUCCESS;
1723 }
1724
1725 VkResult libresoc_ResetFences(VkDevice _device,
1726 uint32_t fenceCount,
1727 const VkFence *pFences)
1728 {
1729
1730 //TODO: stub
1731 return VK_SUCCESS;
1732 }
1733
1734 VkResult libresoc_CreateFramebuffer(
1735 VkDevice _device,
1736 const VkFramebufferCreateInfo* pCreateInfo,
1737 const VkAllocationCallbacks* pAllocator,
1738 VkFramebuffer* pFramebuffer)
1739 {
1740 //TODO: stub
1741 return VK_SUCCESS;
1742 }
1743 void libresoc_DestroyBuffer(
1744 VkDevice _device,
1745 VkBuffer _buffer,
1746 const VkAllocationCallbacks* pAllocator)
1747 {}
1748
1749 void libresoc_DestroyFence(
1750 VkDevice _device,
1751 VkFence _fence,
1752 const VkAllocationCallbacks* pAllocator)
1753 {}
1754
1755
1756 void libresoc_DestroySemaphore(
1757 VkDevice _device,
1758 VkSemaphore _semaphore,
1759 const VkAllocationCallbacks* pAllocator)
1760 {}