projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
vk/device: Free border color states when we have valgrind
[mesa.git] / src / vulkan / device.c
1 /*
2 * Copyright © 2015 Intel Corporation
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 <unistd.h>
28 #include <fcntl.h>
29
30 #include "private.h"
31
32 static int
33 anv_env_get_int(const char *name)
34 {
35 const char *val = getenv(name);
36
37 if (!val)
38 return 0;
39
40 return strtol(val, NULL, 0);
41 }
42
43 static VkResult
44 fill_physical_device(struct anv_physical_device *device,
45 struct anv_instance *instance,
46 const char *path)
47 {
48 int fd;
49
50 fd = open("/dev/dri/renderD128", O_RDWR | O_CLOEXEC);
51 if (fd < 0)
52 return vk_error(VK_ERROR_UNAVAILABLE);
53
54 device->instance = instance;
55 device->path = path;
56
57 device->chipset_id = anv_env_get_int("INTEL_DEVID_OVERRIDE");
58 device->no_hw = false;
59 if (device->chipset_id) {
60 /* INTEL_DEVID_OVERRIDE implies INTEL_NO_HW. */
61 device->no_hw = true;
62 } else {
63 device->chipset_id = anv_gem_get_param(fd, I915_PARAM_CHIPSET_ID);
64 }
65 if (!device->chipset_id)
66 goto fail;
67
68 device->name = brw_get_device_name(device->chipset_id);
69 device->info = brw_get_device_info(device->chipset_id, -1);
70 if (!device->info)
71 goto fail;
72
73 if (!anv_gem_get_param(fd, I915_PARAM_HAS_WAIT_TIMEOUT))
74 goto fail;
75
76 if (!anv_gem_get_param(fd, I915_PARAM_HAS_EXECBUF2))
77 goto fail;
78
79 if (!anv_gem_get_param(fd, I915_PARAM_HAS_LLC))
80 goto fail;
81
82 if (!anv_gem_get_param(fd, I915_PARAM_HAS_EXEC_CONSTANTS))
83 goto fail;
84
85 close(fd);
86
87 return VK_SUCCESS;
88
89 fail:
90 close(fd);
91
92 return vk_error(VK_ERROR_UNAVAILABLE);
93 }
94
95 static void *default_alloc(
96 void* pUserData,
97 size_t size,
98 size_t alignment,
99 VkSystemAllocType allocType)
100 {
101 return malloc(size);
102 }
103
104 static void default_free(
105 void* pUserData,
106 void* pMem)
107 {
108 free(pMem);
109 }
110
111 static const VkAllocCallbacks default_alloc_callbacks = {
112 .pUserData = NULL,
113 .pfnAlloc = default_alloc,
114 .pfnFree = default_free
115 };
116
117 VkResult anv_CreateInstance(
118 const VkInstanceCreateInfo* pCreateInfo,
119 VkInstance* pInstance)
120 {
121 struct anv_instance *instance;
122 const VkAllocCallbacks *alloc_callbacks = &default_alloc_callbacks;
123 void *user_data = NULL;
124 VkResult result;
125
126 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
127
128 if (pCreateInfo->pAllocCb) {
129 alloc_callbacks = pCreateInfo->pAllocCb;
130 user_data = pCreateInfo->pAllocCb->pUserData;
131 }
132 instance = alloc_callbacks->pfnAlloc(user_data, sizeof(*instance), 8,
133 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
134 if (!instance)
135 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
136
137 instance->pAllocUserData = alloc_callbacks->pUserData;
138 instance->pfnAlloc = alloc_callbacks->pfnAlloc;
139 instance->pfnFree = alloc_callbacks->pfnFree;
140 instance->apiVersion = pCreateInfo->pAppInfo->apiVersion;
141
142 instance->physicalDeviceCount = 0;
143 result = fill_physical_device(&instance->physicalDevice,
144 instance, "/dev/dri/renderD128");
145
146 if (result != VK_SUCCESS)
147 return result;
148
149 instance->physicalDeviceCount++;
150 *pInstance = (VkInstance) instance;
151
152 return VK_SUCCESS;
153 }
154
155 VkResult anv_DestroyInstance(
156 VkInstance _instance)
157 {
158 struct anv_instance *instance = (struct anv_instance *) _instance;
159
160 instance->pfnFree(instance->pAllocUserData, instance);
161
162 return VK_SUCCESS;
163 }
164
165 VkResult anv_EnumeratePhysicalDevices(
166 VkInstance _instance,
167 uint32_t* pPhysicalDeviceCount,
168 VkPhysicalDevice* pPhysicalDevices)
169 {
170 struct anv_instance *instance = (struct anv_instance *) _instance;
171
172 if (*pPhysicalDeviceCount >= 1)
173 pPhysicalDevices[0] = (VkPhysicalDevice) &instance->physicalDevice;
174 *pPhysicalDeviceCount = instance->physicalDeviceCount;
175
176 return VK_SUCCESS;
177 }
178
179 VkResult anv_GetPhysicalDeviceInfo(
180 VkPhysicalDevice physicalDevice,
181 VkPhysicalDeviceInfoType infoType,
182 size_t* pDataSize,
183 void* pData)
184 {
185 struct anv_physical_device *device = (struct anv_physical_device *) physicalDevice;
186 VkPhysicalDeviceProperties *properties;
187 VkPhysicalDevicePerformance *performance;
188 VkPhysicalDeviceQueueProperties *queue_properties;
189 VkPhysicalDeviceMemoryProperties *memory_properties;
190 VkDisplayPropertiesWSI *display_properties;
191 uint64_t ns_per_tick = 80;
192
193 switch ((uint32_t) infoType) {
194 case VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES:
195 properties = pData;
196
197 *pDataSize = sizeof(*properties);
198 if (pData == NULL)
199 return VK_SUCCESS;
200
201 properties->apiVersion = 1;
202 properties->driverVersion = 1;
203 properties->vendorId = 0x8086;
204 properties->deviceId = device->chipset_id;
205 properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
206 strcpy(properties->deviceName, device->name);
207 properties->maxInlineMemoryUpdateSize = 0;
208 properties->maxBoundDescriptorSets = MAX_SETS;
209 properties->maxThreadGroupSize = 512;
210 properties->timestampFrequency = 1000 * 1000 * 1000 / ns_per_tick;
211 properties->multiColorAttachmentClears = true;
212 properties->maxDescriptorSets = 8;
213 properties->maxViewports = 16;
214 properties->maxColorAttachments = 8;
215 return VK_SUCCESS;
216
217 case VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE:
218 performance = pData;
219
220 *pDataSize = sizeof(*performance);
221 if (pData == NULL)
222 return VK_SUCCESS;
223
224 performance->maxDeviceClock = 1.0;
225 performance->aluPerClock = 1.0;
226 performance->texPerClock = 1.0;
227 performance->primsPerClock = 1.0;
228 performance->pixelsPerClock = 1.0;
229 return VK_SUCCESS;
230
231 case VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES:
232 queue_properties = pData;
233
234 *pDataSize = sizeof(*queue_properties);
235 if (pData == NULL)
236 return VK_SUCCESS;
237
238 queue_properties->queueFlags = 0;
239 queue_properties->queueCount = 1;
240 queue_properties->maxAtomicCounters = 0;
241 queue_properties->supportsTimestamps = true;
242 queue_properties->maxMemReferences = 256;
243 return VK_SUCCESS;
244
245 case VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES:
246 memory_properties = pData;
247
248 *pDataSize = sizeof(*memory_properties);
249 if (pData == NULL)
250 return VK_SUCCESS;
251
252 memory_properties->supportsMigration = false;
253 memory_properties->supportsPinning = false;
254 return VK_SUCCESS;
255
256 case VK_PHYSICAL_DEVICE_INFO_TYPE_DISPLAY_PROPERTIES_WSI:
257 anv_finishme("VK_PHYSICAL_DEVICE_INFO_TYPE_DISPLAY_PROPERTIES_WSI");
258
259 *pDataSize = sizeof(*display_properties);
260 if (pData == NULL)
261 return VK_SUCCESS;
262
263 display_properties = pData;
264 display_properties->display = 0;
265 display_properties->physicalResolution = (VkExtent2D) { 0, 0 };
266 return VK_SUCCESS;
267
268 case VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PRESENT_PROPERTIES_WSI:
269 anv_finishme("VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PRESENT_PROPERTIES_WSI");
270 return VK_SUCCESS;
271
272
273 default:
274 return VK_UNSUPPORTED;
275 }
276
277 }
278
279 void * vkGetProcAddr(
280 VkPhysicalDevice physicalDevice,
281 const char* pName)
282 {
283 return anv_lookup_entrypoint(pName);
284 }
285
286 static void
287 parse_debug_flags(struct anv_device *device)
288 {
289 const char *debug, *p, *end;
290
291 debug = getenv("INTEL_DEBUG");
292 device->dump_aub = false;
293 if (debug) {
294 for (p = debug; *p; p = end + 1) {
295 end = strchrnul(p, ',');
296 if (end - p == 3 && memcmp(p, "aub", 3) == 0)
297 device->dump_aub = true;
298 if (end - p == 5 && memcmp(p, "no_hw", 5) == 0)
299 device->no_hw = true;
300 if (*end == '\0')
301 break;
302 }
303 }
304 }
305
306 static void
307 anv_device_init_border_colors(struct anv_device *device)
308 {
309 float float_border_colors[][4] = {
310 [VK_BORDER_COLOR_OPAQUE_WHITE] = { 1.0, 1.0, 1.0, 1.0 },
311 [VK_BORDER_COLOR_TRANSPARENT_BLACK] = { 0.0, 0.0, 0.0, 0.0 },
312 [VK_BORDER_COLOR_OPAQUE_BLACK] = { 0.0, 0.0, 0.0, 1.0 }
313 };
314
315 uint32_t uint32_border_colors[][4] = {
316 [VK_BORDER_COLOR_OPAQUE_WHITE] = { 1, 1, 1, 1 },
317 [VK_BORDER_COLOR_TRANSPARENT_BLACK] = { 0, 0, 0, 0 },
318 [VK_BORDER_COLOR_OPAQUE_BLACK] = { 0, 0, 0, 1 }
319 };
320
321 device->float_border_colors =
322 anv_state_pool_alloc(&device->dynamic_state_pool,
323 sizeof(float_border_colors), 32);
324 memcpy(device->float_border_colors.map,
325 float_border_colors, sizeof(float_border_colors));
326
327 device->uint32_border_colors =
328 anv_state_pool_alloc(&device->dynamic_state_pool,
329 sizeof(uint32_border_colors), 32);
330 memcpy(device->uint32_border_colors.map,
331 uint32_border_colors, sizeof(uint32_border_colors));
332
333 }
334
335 static const uint32_t BATCH_SIZE = 8192;
336
337 VkResult anv_CreateDevice(
338 VkPhysicalDevice _physicalDevice,
339 const VkDeviceCreateInfo* pCreateInfo,
340 VkDevice* pDevice)
341 {
342 struct anv_physical_device *physicalDevice =
343 (struct anv_physical_device *) _physicalDevice;
344 struct anv_instance *instance = physicalDevice->instance;
345 struct anv_device *device;
346
347 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
348
349 device = instance->pfnAlloc(instance->pAllocUserData,
350 sizeof(*device), 8,
351 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
352 if (!device)
353 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
354
355 device->no_hw = physicalDevice->no_hw;
356 parse_debug_flags(device);
357
358 device->instance = physicalDevice->instance;
359 device->fd = open("/dev/dri/renderD128", O_RDWR | O_CLOEXEC);
360 if (device->fd == -1)
361 goto fail_device;
362
363 device->context_id = anv_gem_create_context(device);
364 if (device->context_id == -1)
365 goto fail_fd;
366
367 anv_bo_pool_init(&device->batch_bo_pool, device, BATCH_SIZE);
368
369 anv_block_pool_init(&device->dynamic_state_block_pool, device, 2048);
370
371 anv_state_pool_init(&device->dynamic_state_pool,
372 &device->dynamic_state_block_pool);
373
374 anv_block_pool_init(&device->instruction_block_pool, device, 2048);
375 anv_block_pool_init(&device->surface_state_block_pool, device, 2048);
376
377 anv_state_pool_init(&device->surface_state_pool,
378 &device->surface_state_block_pool);
379
380 device->info = *physicalDevice->info;
381
382 device->compiler = anv_compiler_create(device);
383 device->aub_writer = NULL;
384
385 pthread_mutex_init(&device->mutex, NULL);
386
387 anv_device_init_meta(device);
388
389 anv_device_init_border_colors(device);
390
391 *pDevice = (VkDevice) device;
392
393 return VK_SUCCESS;
394
395 fail_fd:
396 close(device->fd);
397 fail_device:
398 anv_device_free(device, device);
399
400 return vk_error(VK_ERROR_UNAVAILABLE);
401 }
402
403 VkResult anv_DestroyDevice(
404 VkDevice _device)
405 {
406 struct anv_device *device = (struct anv_device *) _device;
407
408 /* FIXME: We should make device destruction actually safe. */
409 return VK_UNSUPPORTED;
410
411 anv_compiler_destroy(device->compiler);
412
413 anv_device_finish_meta(device);
414
415 #ifdef HAVE_VALGRIND
416 /* We only need to free these to prevent valgrind errors. The backing
417 * BO will go away in a couple of lines so we don't actually leak.
418 */
419 anv_state_pool_free(&device->dynamic_state_pool,
420 device->float_border_colors);
421 anv_state_pool_free(&device->dynamic_state_pool,
422 device->uint32_border_colors);
423 #endif
424
425 anv_bo_pool_finish(&device->batch_bo_pool);
426 anv_block_pool_finish(&device->dynamic_state_block_pool);
427 anv_block_pool_finish(&device->instruction_block_pool);
428 anv_block_pool_finish(&device->surface_state_block_pool);
429
430 close(device->fd);
431
432 if (device->aub_writer)
433 anv_aub_writer_destroy(device->aub_writer);
434
435 anv_device_free(device, device);
436
437 return VK_SUCCESS;
438 }
439
440 VkResult anv_GetGlobalExtensionInfo(
441 VkExtensionInfoType infoType,
442 uint32_t extensionIndex,
443 size_t* pDataSize,
444 void* pData)
445 {
446 static const VkExtensionProperties extensions[] = {
447 {
448 .extName = "VK_WSI_LunarG",
449 .version = 3
450 }
451 };
452 uint32_t count = ARRAY_SIZE(extensions);
453
454 switch (infoType) {
455 case VK_EXTENSION_INFO_TYPE_COUNT:
456 memcpy(pData, &count, sizeof(count));
457 *pDataSize = sizeof(count);
458 return VK_SUCCESS;
459
460 case VK_EXTENSION_INFO_TYPE_PROPERTIES:
461 if (extensionIndex >= count)
462 return vk_error(VK_ERROR_INVALID_EXTENSION);
463
464 memcpy(pData, &extensions[extensionIndex], sizeof(extensions[0]));
465 *pDataSize = sizeof(extensions[0]);
466 return VK_SUCCESS;
467
468 default:
469 return VK_UNSUPPORTED;
470 }
471 }
472
473 VkResult anv_GetPhysicalDeviceExtensionInfo(
474 VkPhysicalDevice physicalDevice,
475 VkExtensionInfoType infoType,
476 uint32_t extensionIndex,
477 size_t* pDataSize,
478 void* pData)
479 {
480 uint32_t *count;
481
482 switch (infoType) {
483 case VK_EXTENSION_INFO_TYPE_COUNT:
484 *pDataSize = 4;
485 if (pData == NULL)
486 return VK_SUCCESS;
487
488 count = pData;
489 *count = 0;
490 return VK_SUCCESS;
491
492 case VK_EXTENSION_INFO_TYPE_PROPERTIES:
493 return vk_error(VK_ERROR_INVALID_EXTENSION);
494
495 default:
496 return VK_UNSUPPORTED;
497 }
498 }
499
500 VkResult anv_EnumerateLayers(
501 VkPhysicalDevice physicalDevice,
502 size_t maxStringSize,
503 size_t* pLayerCount,
504 char* const* pOutLayers,
505 void* pReserved)
506 {
507 *pLayerCount = 0;
508
509 return VK_SUCCESS;
510 }
511
512 VkResult anv_GetDeviceQueue(
513 VkDevice _device,
514 uint32_t queueNodeIndex,
515 uint32_t queueIndex,
516 VkQueue* pQueue)
517 {
518 struct anv_device *device = (struct anv_device *) _device;
519 struct anv_queue *queue;
520
521 /* FIXME: Should allocate these at device create time. */
522
523 queue = anv_device_alloc(device, sizeof(*queue), 8,
524 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
525 if (queue == NULL)
526 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
527
528 queue->device = device;
529 queue->pool = &device->surface_state_pool;
530
531 queue->completed_serial = anv_state_pool_alloc(queue->pool, 4, 4);
532 *(uint32_t *)queue->completed_serial.map = 0;
533 queue->next_serial = 1;
534
535 *pQueue = (VkQueue) queue;
536
537 return VK_SUCCESS;
538 }
539
540 VkResult
541 anv_reloc_list_init(struct anv_reloc_list *list, struct anv_device *device)
542 {
543 list->num_relocs = 0;
544 list->array_length = 256;
545 list->relocs =
546 anv_device_alloc(device, list->array_length * sizeof(*list->relocs), 8,
547 VK_SYSTEM_ALLOC_TYPE_INTERNAL);
548
549 if (list->relocs == NULL)
550 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
551
552 list->reloc_bos =
553 anv_device_alloc(device, list->array_length * sizeof(*list->reloc_bos), 8,
554 VK_SYSTEM_ALLOC_TYPE_INTERNAL);
555
556 if (list->relocs == NULL) {
557 anv_device_free(device, list->relocs);
558 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
559 }
560
561 return VK_SUCCESS;
562 }
563
564 void
565 anv_reloc_list_finish(struct anv_reloc_list *list, struct anv_device *device)
566 {
567 anv_device_free(device, list->relocs);
568 anv_device_free(device, list->reloc_bos);
569 }
570
571 static VkResult
572 anv_reloc_list_grow(struct anv_reloc_list *list, struct anv_device *device,
573 size_t num_additional_relocs)
574 {
575 if (list->num_relocs + num_additional_relocs <= list->array_length)
576 return VK_SUCCESS;
577
578 size_t new_length = list->array_length * 2;
579 while (new_length < list->num_relocs + num_additional_relocs)
580 new_length *= 2;
581
582 struct drm_i915_gem_relocation_entry *new_relocs =
583 anv_device_alloc(device, new_length * sizeof(*list->relocs), 8,
584 VK_SYSTEM_ALLOC_TYPE_INTERNAL);
585 if (new_relocs == NULL)
586 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
587
588 struct anv_bo **new_reloc_bos =
589 anv_device_alloc(device, new_length * sizeof(*list->reloc_bos), 8,
590 VK_SYSTEM_ALLOC_TYPE_INTERNAL);
591 if (new_relocs == NULL) {
592 anv_device_free(device, new_relocs);
593 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
594 }
595
596 memcpy(new_relocs, list->relocs, list->num_relocs * sizeof(*list->relocs));
597 memcpy(new_reloc_bos, list->reloc_bos,
598 list->num_relocs * sizeof(*list->reloc_bos));
599
600 anv_device_free(device, list->relocs);
601 anv_device_free(device, list->reloc_bos);
602
603 list->relocs = new_relocs;
604 list->reloc_bos = new_reloc_bos;
605
606 return VK_SUCCESS;
607 }
608
609 static VkResult
610 anv_batch_bo_create(struct anv_device *device, struct anv_batch_bo **bbo_out)
611 {
612 VkResult result;
613
614 struct anv_batch_bo *bbo =
615 anv_device_alloc(device, sizeof(*bbo), 8, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
616 if (bbo == NULL)
617 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
618
619 bbo->num_relocs = 0;
620 bbo->prev_batch_bo = NULL;
621
622 result = anv_bo_pool_alloc(&device->batch_bo_pool, &bbo->bo);
623 if (result != VK_SUCCESS) {
624 anv_device_free(device, bbo);
625 return result;
626 }
627
628 *bbo_out = bbo;
629
630 return VK_SUCCESS;
631 }
632
633 static void
634 anv_batch_bo_start(struct anv_batch_bo *bbo, struct anv_batch *batch,
635 size_t batch_padding)
636 {
637 batch->next = batch->start = bbo->bo.map;
638 batch->end = bbo->bo.map + bbo->bo.size - batch_padding;
639 bbo->first_reloc = batch->relocs.num_relocs;
640 }
641
642 static void
643 anv_batch_bo_finish(struct anv_batch_bo *bbo, struct anv_batch *batch)
644 {
645 assert(batch->start == bbo->bo.map);
646 bbo->length = batch->next - batch->start;
647 bbo->num_relocs = batch->relocs.num_relocs - bbo->first_reloc;
648 }
649
650 static void
651 anv_batch_bo_destroy(struct anv_batch_bo *bbo, struct anv_device *device)
652 {
653 anv_bo_pool_free(&device->batch_bo_pool, &bbo->bo);
654 anv_device_free(device, bbo);
655 }
656
657 void *
658 anv_batch_emit_dwords(struct anv_batch *batch, int num_dwords)
659 {
660 if (batch->next + num_dwords * 4 > batch->end)
661 batch->extend_cb(batch, batch->user_data);
662
663 void *p = batch->next;
664
665 batch->next += num_dwords * 4;
666 assert(batch->next <= batch->end);
667
668 return p;
669 }
670
671 static void
672 anv_reloc_list_append(struct anv_reloc_list *list, struct anv_device *device,
673 struct anv_reloc_list *other, uint32_t offset)
674 {
675 anv_reloc_list_grow(list, device, other->num_relocs);
676 /* TODO: Handle failure */
677
678 memcpy(&list->relocs[list->num_relocs], &other->relocs[0],
679 other->num_relocs * sizeof(other->relocs[0]));
680 memcpy(&list->reloc_bos[list->num_relocs], &other->reloc_bos[0],
681 other->num_relocs * sizeof(other->reloc_bos[0]));
682
683 for (uint32_t i = 0; i < other->num_relocs; i++)
684 list->relocs[i + list->num_relocs].offset += offset;
685
686 list->num_relocs += other->num_relocs;
687 }
688
689 static uint64_t
690 anv_reloc_list_add(struct anv_reloc_list *list, struct anv_device *device,
691 uint32_t offset, struct anv_bo *target_bo, uint32_t delta)
692 {
693 struct drm_i915_gem_relocation_entry *entry;
694 int index;
695
696 anv_reloc_list_grow(list, device, 1);
697 /* TODO: Handle failure */
698
699 /* XXX: Can we use I915_EXEC_HANDLE_LUT? */
700 index = list->num_relocs++;
701 list->reloc_bos[index] = target_bo;
702 entry = &list->relocs[index];
703 entry->target_handle = target_bo->gem_handle;
704 entry->delta = delta;
705 entry->offset = offset;
706 entry->presumed_offset = target_bo->offset;
707 entry->read_domains = 0;
708 entry->write_domain = 0;
709
710 return target_bo->offset + delta;
711 }
712
713 void
714 anv_batch_emit_batch(struct anv_batch *batch, struct anv_batch *other)
715 {
716 uint32_t size, offset;
717
718 size = other->next - other->start;
719 assert(size % 4 == 0);
720
721 if (batch->next + size > batch->end)
722 batch->extend_cb(batch, batch->user_data);
723
724 assert(batch->next + size <= batch->end);
725
726 memcpy(batch->next, other->start, size);
727
728 offset = batch->next - batch->start;
729 anv_reloc_list_append(&batch->relocs, batch->device,
730 &other->relocs, offset);
731
732 batch->next += size;
733 }
734
735 uint64_t
736 anv_batch_emit_reloc(struct anv_batch *batch,
737 void *location, struct anv_bo *bo, uint32_t delta)
738 {
739 return anv_reloc_list_add(&batch->relocs, batch->device,
740 location - batch->start, bo, delta);
741 }
742
743 VkResult anv_QueueSubmit(
744 VkQueue _queue,
745 uint32_t cmdBufferCount,
746 const VkCmdBuffer* pCmdBuffers,
747 VkFence _fence)
748 {
749 struct anv_queue *queue = (struct anv_queue *) _queue;
750 struct anv_device *device = queue->device;
751 struct anv_fence *fence = (struct anv_fence *) _fence;
752 int ret;
753
754 for (uint32_t i = 0; i < cmdBufferCount; i++) {
755 struct anv_cmd_buffer *cmd_buffer =
756 (struct anv_cmd_buffer *) pCmdBuffers[i];
757
758 if (device->dump_aub)
759 anv_cmd_buffer_dump(cmd_buffer);
760
761 if (!device->no_hw) {
762 ret = anv_gem_execbuffer(device, &cmd_buffer->execbuf);
763 if (ret != 0)
764 return vk_error(VK_ERROR_UNKNOWN);
765
766 if (fence) {
767 ret = anv_gem_execbuffer(device, &fence->execbuf);
768 if (ret != 0)
769 return vk_error(VK_ERROR_UNKNOWN);
770 }
771
772 for (uint32_t i = 0; i < cmd_buffer->bo_count; i++)
773 cmd_buffer->exec2_bos[i]->offset = cmd_buffer->exec2_objects[i].offset;
774 } else {
775 *(uint32_t *)queue->completed_serial.map = cmd_buffer->serial;
776 }
777 }
778
779 return VK_SUCCESS;
780 }
781
782 VkResult anv_QueueAddMemReferences(
783 VkQueue queue,
784 uint32_t count,
785 const VkDeviceMemory* pMems)
786 {
787 return VK_SUCCESS;
788 }
789
790 VkResult anv_QueueRemoveMemReferences(
791 VkQueue queue,
792 uint32_t count,
793 const VkDeviceMemory* pMems)
794 {
795 return VK_SUCCESS;
796 }
797
798 VkResult anv_QueueWaitIdle(
799 VkQueue _queue)
800 {
801 struct anv_queue *queue = (struct anv_queue *) _queue;
802
803 return vkDeviceWaitIdle((VkDevice) queue->device);
804 }
805
806 VkResult anv_DeviceWaitIdle(
807 VkDevice _device)
808 {
809 struct anv_device *device = (struct anv_device *) _device;
810 struct anv_state state;
811 struct anv_batch batch;
812 struct drm_i915_gem_execbuffer2 execbuf;
813 struct drm_i915_gem_exec_object2 exec2_objects[1];
814 struct anv_bo *bo = NULL;
815 VkResult result;
816 int64_t timeout;
817 int ret;
818
819 state = anv_state_pool_alloc(&device->dynamic_state_pool, 32, 32);
820 bo = &device->dynamic_state_pool.block_pool->bo;
821 batch.start = batch.next = state.map;
822 batch.end = state.map + 32;
823 anv_batch_emit(&batch, GEN8_MI_BATCH_BUFFER_END);
824 anv_batch_emit(&batch, GEN8_MI_NOOP);
825
826 exec2_objects[0].handle = bo->gem_handle;
827 exec2_objects[0].relocation_count = 0;
828 exec2_objects[0].relocs_ptr = 0;
829 exec2_objects[0].alignment = 0;
830 exec2_objects[0].offset = bo->offset;
831 exec2_objects[0].flags = 0;
832 exec2_objects[0].rsvd1 = 0;
833 exec2_objects[0].rsvd2 = 0;
834
835 execbuf.buffers_ptr = (uintptr_t) exec2_objects;
836 execbuf.buffer_count = 1;
837 execbuf.batch_start_offset = state.offset;
838 execbuf.batch_len = batch.next - state.map;
839 execbuf.cliprects_ptr = 0;
840 execbuf.num_cliprects = 0;
841 execbuf.DR1 = 0;
842 execbuf.DR4 = 0;
843
844 execbuf.flags =
845 I915_EXEC_HANDLE_LUT | I915_EXEC_NO_RELOC | I915_EXEC_RENDER;
846 execbuf.rsvd1 = device->context_id;
847 execbuf.rsvd2 = 0;
848
849 if (!device->no_hw) {
850 ret = anv_gem_execbuffer(device, &execbuf);
851 if (ret != 0) {
852 result = vk_error(VK_ERROR_UNKNOWN);
853 goto fail;
854 }
855
856 timeout = INT64_MAX;
857 ret = anv_gem_wait(device, bo->gem_handle, &timeout);
858 if (ret != 0) {
859 result = vk_error(VK_ERROR_UNKNOWN);
860 goto fail;
861 }
862 }
863
864 anv_state_pool_free(&device->dynamic_state_pool, state);
865
866 return VK_SUCCESS;
867
868 fail:
869 anv_state_pool_free(&device->dynamic_state_pool, state);
870
871 return result;
872 }
873
874 void *
875 anv_device_alloc(struct anv_device * device,
876 size_t size,
877 size_t alignment,
878 VkSystemAllocType allocType)
879 {
880 return device->instance->pfnAlloc(device->instance->pAllocUserData,
881 size,
882 alignment,
883 allocType);
884 }
885
886 void
887 anv_device_free(struct anv_device * device,
888 void * mem)
889 {
890 return device->instance->pfnFree(device->instance->pAllocUserData,
891 mem);
892 }
893
894 VkResult
895 anv_bo_init_new(struct anv_bo *bo, struct anv_device *device, uint64_t size)
896 {
897 bo->gem_handle = anv_gem_create(device, size);
898 if (!bo->gem_handle)
899 return vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY);
900
901 bo->map = NULL;
902 bo->index = 0;
903 bo->offset = 0;
904 bo->size = size;
905
906 return VK_SUCCESS;
907 }
908
909 VkResult anv_AllocMemory(
910 VkDevice _device,
911 const VkMemoryAllocInfo* pAllocInfo,
912 VkDeviceMemory* pMem)
913 {
914 struct anv_device *device = (struct anv_device *) _device;
915 struct anv_device_memory *mem;
916 VkResult result;
917
918 assert(pAllocInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO);
919
920 mem = anv_device_alloc(device, sizeof(*mem), 8,
921 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
922 if (mem == NULL)
923 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
924
925 result = anv_bo_init_new(&mem->bo, device, pAllocInfo->allocationSize);
926 if (result != VK_SUCCESS)
927 goto fail;
928
929 *pMem = (VkDeviceMemory) mem;
930
931 return VK_SUCCESS;
932
933 fail:
934 anv_device_free(device, mem);
935
936 return result;
937 }
938
939 VkResult anv_FreeMemory(
940 VkDevice _device,
941 VkDeviceMemory _mem)
942 {
943 struct anv_device *device = (struct anv_device *) _device;
944 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
945
946 if (mem->bo.map)
947 anv_gem_munmap(mem->bo.map, mem->bo.size);
948
949 if (mem->bo.gem_handle != 0)
950 anv_gem_close(device, mem->bo.gem_handle);
951
952 anv_device_free(device, mem);
953
954 return VK_SUCCESS;
955 }
956
957 VkResult anv_SetMemoryPriority(
958 VkDevice device,
959 VkDeviceMemory mem,
960 VkMemoryPriority priority)
961 {
962 return VK_SUCCESS;
963 }
964
965 VkResult anv_MapMemory(
966 VkDevice _device,
967 VkDeviceMemory _mem,
968 VkDeviceSize offset,
969 VkDeviceSize size,
970 VkMemoryMapFlags flags,
971 void** ppData)
972 {
973 struct anv_device *device = (struct anv_device *) _device;
974 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
975
976 /* FIXME: Is this supposed to be thread safe? Since vkUnmapMemory() only
977 * takes a VkDeviceMemory pointer, it seems like only one map of the memory
978 * at a time is valid. We could just mmap up front and return an offset
979 * pointer here, but that may exhaust virtual memory on 32 bit
980 * userspace. */
981
982 mem->map = anv_gem_mmap(device, mem->bo.gem_handle, offset, size);
983 mem->map_size = size;
984
985 *ppData = mem->map;
986
987 return VK_SUCCESS;
988 }
989
990 VkResult anv_UnmapMemory(
991 VkDevice _device,
992 VkDeviceMemory _mem)
993 {
994 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
995
996 anv_gem_munmap(mem->map, mem->map_size);
997
998 return VK_SUCCESS;
999 }
1000
1001 VkResult anv_FlushMappedMemory(
1002 VkDevice device,
1003 VkDeviceMemory mem,
1004 VkDeviceSize offset,
1005 VkDeviceSize size)
1006 {
1007 /* clflush here for !llc platforms */
1008
1009 return VK_SUCCESS;
1010 }
1011
1012 VkResult anv_PinSystemMemory(
1013 VkDevice device,
1014 const void* pSysMem,
1015 size_t memSize,
1016 VkDeviceMemory* pMem)
1017 {
1018 return VK_SUCCESS;
1019 }
1020
1021 VkResult anv_GetMultiDeviceCompatibility(
1022 VkPhysicalDevice physicalDevice0,
1023 VkPhysicalDevice physicalDevice1,
1024 VkPhysicalDeviceCompatibilityInfo* pInfo)
1025 {
1026 return VK_UNSUPPORTED;
1027 }
1028
1029 VkResult anv_OpenSharedMemory(
1030 VkDevice device,
1031 const VkMemoryOpenInfo* pOpenInfo,
1032 VkDeviceMemory* pMem)
1033 {
1034 return VK_UNSUPPORTED;
1035 }
1036
1037 VkResult anv_OpenSharedSemaphore(
1038 VkDevice device,
1039 const VkSemaphoreOpenInfo* pOpenInfo,
1040 VkSemaphore* pSemaphore)
1041 {
1042 return VK_UNSUPPORTED;
1043 }
1044
1045 VkResult anv_OpenPeerMemory(
1046 VkDevice device,
1047 const VkPeerMemoryOpenInfo* pOpenInfo,
1048 VkDeviceMemory* pMem)
1049 {
1050 return VK_UNSUPPORTED;
1051 }
1052
1053 VkResult anv_OpenPeerImage(
1054 VkDevice device,
1055 const VkPeerImageOpenInfo* pOpenInfo,
1056 VkImage* pImage,
1057 VkDeviceMemory* pMem)
1058 {
1059 return VK_UNSUPPORTED;
1060 }
1061
1062 VkResult anv_DestroyObject(
1063 VkDevice _device,
1064 VkObjectType objType,
1065 VkObject _object)
1066 {
1067 struct anv_device *device = (struct anv_device *) _device;
1068 struct anv_object *object = (struct anv_object *) _object;
1069
1070 switch (objType) {
1071 case VK_OBJECT_TYPE_INSTANCE:
1072 return anv_DestroyInstance((VkInstance) _object);
1073
1074 case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
1075 /* We don't want to actually destroy physical devices */
1076 return VK_SUCCESS;
1077
1078 case VK_OBJECT_TYPE_DEVICE:
1079 assert(_device == (VkDevice) _object);
1080 return anv_DestroyDevice((VkDevice) _object);
1081
1082 case VK_OBJECT_TYPE_QUEUE:
1083 /* TODO */
1084 return VK_SUCCESS;
1085
1086 case VK_OBJECT_TYPE_DEVICE_MEMORY:
1087 return anv_FreeMemory(_device, (VkDeviceMemory) _object);
1088
1089 case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
1090 /* These are just dummys anyway, so we don't need to destroy them */
1091 return VK_SUCCESS;
1092
1093 case VK_OBJECT_TYPE_BUFFER:
1094 case VK_OBJECT_TYPE_IMAGE:
1095 case VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW:
1096 case VK_OBJECT_TYPE_SHADER:
1097 case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
1098 case VK_OBJECT_TYPE_SAMPLER:
1099 case VK_OBJECT_TYPE_DESCRIPTOR_SET:
1100 case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
1101 case VK_OBJECT_TYPE_DYNAMIC_RS_STATE:
1102 case VK_OBJECT_TYPE_DYNAMIC_CB_STATE:
1103 case VK_OBJECT_TYPE_DYNAMIC_DS_STATE:
1104 case VK_OBJECT_TYPE_RENDER_PASS:
1105 /* These are trivially destroyable */
1106 anv_device_free(device, (void *) _object);
1107 return VK_SUCCESS;
1108
1109 case VK_OBJECT_TYPE_COMMAND_BUFFER:
1110 case VK_OBJECT_TYPE_PIPELINE:
1111 case VK_OBJECT_TYPE_DYNAMIC_VP_STATE:
1112 case VK_OBJECT_TYPE_FENCE:
1113 case VK_OBJECT_TYPE_QUERY_POOL:
1114 case VK_OBJECT_TYPE_FRAMEBUFFER:
1115 case VK_OBJECT_TYPE_BUFFER_VIEW:
1116 case VK_OBJECT_TYPE_IMAGE_VIEW:
1117 case VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW:
1118 (object->destructor)(device, object, objType);
1119 return VK_SUCCESS;
1120
1121 case VK_OBJECT_TYPE_SEMAPHORE:
1122 case VK_OBJECT_TYPE_EVENT:
1123 stub_return(VK_UNSUPPORTED);
1124
1125 default:
1126 unreachable("Invalid object type");
1127 }
1128 }
1129
1130 static void
1131 fill_memory_requirements(
1132 VkObjectType objType,
1133 VkObject object,
1134 VkMemoryRequirements * memory_requirements)
1135 {
1136 struct anv_buffer *buffer;
1137 struct anv_image *image;
1138
1139 memory_requirements->memPropsAllowed =
1140 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
1141 VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT |
1142 /* VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT | */
1143 VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT |
1144 VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL |
1145 VK_MEMORY_PROPERTY_SHAREABLE_BIT;
1146
1147 memory_requirements->memPropsRequired = 0;
1148
1149 switch (objType) {
1150 case VK_OBJECT_TYPE_BUFFER:
1151 buffer = (struct anv_buffer *) object;
1152 memory_requirements->size = buffer->size;
1153 memory_requirements->alignment = 16;
1154 break;
1155 case VK_OBJECT_TYPE_IMAGE:
1156 image = (struct anv_image *) object;
1157 memory_requirements->size = image->size;
1158 memory_requirements->alignment = image->alignment;
1159 break;
1160 default:
1161 memory_requirements->size = 0;
1162 break;
1163 }
1164 }
1165
1166 static uint32_t
1167 get_allocation_count(VkObjectType objType)
1168 {
1169 switch (objType) {
1170 case VK_OBJECT_TYPE_BUFFER:
1171 case VK_OBJECT_TYPE_IMAGE:
1172 return 1;
1173 default:
1174 return 0;
1175 }
1176 }
1177
1178 VkResult anv_GetObjectInfo(
1179 VkDevice _device,
1180 VkObjectType objType,
1181 VkObject object,
1182 VkObjectInfoType infoType,
1183 size_t* pDataSize,
1184 void* pData)
1185 {
1186 VkMemoryRequirements memory_requirements;
1187 uint32_t *count;
1188
1189 switch (infoType) {
1190 case VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS:
1191 *pDataSize = sizeof(memory_requirements);
1192 if (pData == NULL)
1193 return VK_SUCCESS;
1194
1195 fill_memory_requirements(objType, object, pData);
1196 return VK_SUCCESS;
1197
1198 case VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
1199 *pDataSize = sizeof(count);
1200 if (pData == NULL)
1201 return VK_SUCCESS;
1202
1203 count = pData;
1204 *count = get_allocation_count(objType);
1205 return VK_SUCCESS;
1206
1207 default:
1208 return VK_UNSUPPORTED;
1209 }
1210
1211 }
1212
1213 VkResult anv_QueueBindObjectMemory(
1214 VkQueue queue,
1215 VkObjectType objType,
1216 VkObject object,
1217 uint32_t allocationIdx,
1218 VkDeviceMemory _mem,
1219 VkDeviceSize memOffset)
1220 {
1221 struct anv_buffer *buffer;
1222 struct anv_image *image;
1223 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
1224
1225 switch (objType) {
1226 case VK_OBJECT_TYPE_BUFFER:
1227 buffer = (struct anv_buffer *) object;
1228 buffer->bo = &mem->bo;
1229 buffer->offset = memOffset;
1230 break;
1231 case VK_OBJECT_TYPE_IMAGE:
1232 image = (struct anv_image *) object;
1233 image->bo = &mem->bo;
1234 image->offset = memOffset;
1235 break;
1236 default:
1237 break;
1238 }
1239
1240 return VK_SUCCESS;
1241 }
1242
1243 VkResult anv_QueueBindObjectMemoryRange(
1244 VkQueue queue,
1245 VkObjectType objType,
1246 VkObject object,
1247 uint32_t allocationIdx,
1248 VkDeviceSize rangeOffset,
1249 VkDeviceSize rangeSize,
1250 VkDeviceMemory mem,
1251 VkDeviceSize memOffset)
1252 {
1253 stub_return(VK_UNSUPPORTED);
1254 }
1255
1256 VkResult anv_QueueBindImageMemoryRange(
1257 VkQueue queue,
1258 VkImage image,
1259 uint32_t allocationIdx,
1260 const VkImageMemoryBindInfo* pBindInfo,
1261 VkDeviceMemory mem,
1262 VkDeviceSize memOffset)
1263 {
1264 stub_return(VK_UNSUPPORTED);
1265 }
1266
1267 static void
1268 anv_fence_destroy(struct anv_device *device,
1269 struct anv_object *object,
1270 VkObjectType obj_type)
1271 {
1272 struct anv_fence *fence = (struct anv_fence *) object;
1273
1274 assert(obj_type == VK_OBJECT_TYPE_FENCE);
1275
1276 anv_gem_munmap(fence->bo.map, fence->bo.size);
1277 anv_gem_close(device, fence->bo.gem_handle);
1278 anv_device_free(device, fence);
1279 }
1280
1281 VkResult anv_CreateFence(
1282 VkDevice _device,
1283 const VkFenceCreateInfo* pCreateInfo,
1284 VkFence* pFence)
1285 {
1286 struct anv_device *device = (struct anv_device *) _device;
1287 struct anv_fence *fence;
1288 struct anv_batch batch;
1289 VkResult result;
1290
1291 const uint32_t fence_size = 128;
1292
1293 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
1294
1295 fence = anv_device_alloc(device, sizeof(*fence), 8,
1296 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1297 if (fence == NULL)
1298 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1299
1300 result = anv_bo_init_new(&fence->bo, device, fence_size);
1301 if (result != VK_SUCCESS)
1302 goto fail;
1303
1304 fence->base.destructor = anv_fence_destroy;
1305
1306 fence->bo.map =
1307 anv_gem_mmap(device, fence->bo.gem_handle, 0, fence->bo.size);
1308 batch.next = batch.start = fence->bo.map;
1309 batch.end = fence->bo.map + fence->bo.size;
1310 anv_batch_emit(&batch, GEN8_MI_BATCH_BUFFER_END);
1311 anv_batch_emit(&batch, GEN8_MI_NOOP);
1312
1313 fence->exec2_objects[0].handle = fence->bo.gem_handle;
1314 fence->exec2_objects[0].relocation_count = 0;
1315 fence->exec2_objects[0].relocs_ptr = 0;
1316 fence->exec2_objects[0].alignment = 0;
1317 fence->exec2_objects[0].offset = fence->bo.offset;
1318 fence->exec2_objects[0].flags = 0;
1319 fence->exec2_objects[0].rsvd1 = 0;
1320 fence->exec2_objects[0].rsvd2 = 0;
1321
1322 fence->execbuf.buffers_ptr = (uintptr_t) fence->exec2_objects;
1323 fence->execbuf.buffer_count = 1;
1324 fence->execbuf.batch_start_offset = 0;
1325 fence->execbuf.batch_len = batch.next - fence->bo.map;
1326 fence->execbuf.cliprects_ptr = 0;
1327 fence->execbuf.num_cliprects = 0;
1328 fence->execbuf.DR1 = 0;
1329 fence->execbuf.DR4 = 0;
1330
1331 fence->execbuf.flags =
1332 I915_EXEC_HANDLE_LUT | I915_EXEC_NO_RELOC | I915_EXEC_RENDER;
1333 fence->execbuf.rsvd1 = device->context_id;
1334 fence->execbuf.rsvd2 = 0;
1335
1336 *pFence = (VkFence) fence;
1337
1338 return VK_SUCCESS;
1339
1340 fail:
1341 anv_device_free(device, fence);
1342
1343 return result;
1344 }
1345
1346 VkResult anv_ResetFences(
1347 VkDevice _device,
1348 uint32_t fenceCount,
1349 VkFence* pFences)
1350 {
1351 struct anv_fence **fences = (struct anv_fence **) pFences;
1352
1353 for (uint32_t i = 0; i < fenceCount; i++)
1354 fences[i]->ready = false;
1355
1356 return VK_SUCCESS;
1357 }
1358
1359 VkResult anv_GetFenceStatus(
1360 VkDevice _device,
1361 VkFence _fence)
1362 {
1363 struct anv_device *device = (struct anv_device *) _device;
1364 struct anv_fence *fence = (struct anv_fence *) _fence;
1365 int64_t t = 0;
1366 int ret;
1367
1368 if (fence->ready)
1369 return VK_SUCCESS;
1370
1371 ret = anv_gem_wait(device, fence->bo.gem_handle, &t);
1372 if (ret == 0) {
1373 fence->ready = true;
1374 return VK_SUCCESS;
1375 }
1376
1377 return VK_NOT_READY;
1378 }
1379
1380 VkResult anv_WaitForFences(
1381 VkDevice _device,
1382 uint32_t fenceCount,
1383 const VkFence* pFences,
1384 bool32_t waitAll,
1385 uint64_t timeout)
1386 {
1387 struct anv_device *device = (struct anv_device *) _device;
1388 struct anv_fence **fences = (struct anv_fence **) pFences;
1389 int64_t t = timeout;
1390 int ret;
1391
1392 /* FIXME: handle !waitAll */
1393
1394 for (uint32_t i = 0; i < fenceCount; i++) {
1395 ret = anv_gem_wait(device, fences[i]->bo.gem_handle, &t);
1396 if (ret == -1 && errno == ETIME)
1397 return VK_TIMEOUT;
1398 else if (ret == -1)
1399 return vk_error(VK_ERROR_UNKNOWN);
1400 }
1401
1402 return VK_SUCCESS;
1403 }
1404
1405 // Queue semaphore functions
1406
1407 VkResult anv_CreateSemaphore(
1408 VkDevice device,
1409 const VkSemaphoreCreateInfo* pCreateInfo,
1410 VkSemaphore* pSemaphore)
1411 {
1412 stub_return(VK_UNSUPPORTED);
1413 }
1414
1415 VkResult anv_QueueSignalSemaphore(
1416 VkQueue queue,
1417 VkSemaphore semaphore)
1418 {
1419 stub_return(VK_UNSUPPORTED);
1420 }
1421
1422 VkResult anv_QueueWaitSemaphore(
1423 VkQueue queue,
1424 VkSemaphore semaphore)
1425 {
1426 stub_return(VK_UNSUPPORTED);
1427 }
1428
1429 // Event functions
1430
1431 VkResult anv_CreateEvent(
1432 VkDevice device,
1433 const VkEventCreateInfo* pCreateInfo,
1434 VkEvent* pEvent)
1435 {
1436 stub_return(VK_UNSUPPORTED);
1437 }
1438
1439 VkResult anv_GetEventStatus(
1440 VkDevice device,
1441 VkEvent event)
1442 {
1443 stub_return(VK_UNSUPPORTED);
1444 }
1445
1446 VkResult anv_SetEvent(
1447 VkDevice device,
1448 VkEvent event)
1449 {
1450 stub_return(VK_UNSUPPORTED);
1451 }
1452
1453 VkResult anv_ResetEvent(
1454 VkDevice device,
1455 VkEvent event)
1456 {
1457 stub_return(VK_UNSUPPORTED);
1458 }
1459
1460 // Buffer functions
1461
1462 VkResult anv_CreateBuffer(
1463 VkDevice _device,
1464 const VkBufferCreateInfo* pCreateInfo,
1465 VkBuffer* pBuffer)
1466 {
1467 struct anv_device *device = (struct anv_device *) _device;
1468 struct anv_buffer *buffer;
1469
1470 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
1471
1472 buffer = anv_device_alloc(device, sizeof(*buffer), 8,
1473 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1474 if (buffer == NULL)
1475 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1476
1477 buffer->size = pCreateInfo->size;
1478 buffer->bo = NULL;
1479 buffer->offset = 0;
1480
1481 *pBuffer = (VkBuffer) buffer;
1482
1483 return VK_SUCCESS;
1484 }
1485
1486 // Buffer view functions
1487
1488 static void
1489 fill_buffer_surface_state(void *state, VkFormat format,
1490 uint32_t offset, uint32_t range)
1491 {
1492 const struct anv_format *info;
1493
1494 info = anv_format_for_vk_format(format);
1495 /* This assumes RGBA float format. */
1496 uint32_t stride = 4;
1497 uint32_t num_elements = range / stride;
1498
1499 struct GEN8_RENDER_SURFACE_STATE surface_state = {
1500 .SurfaceType = SURFTYPE_BUFFER,
1501 .SurfaceArray = false,
1502 .SurfaceFormat = info->format,
1503 .SurfaceVerticalAlignment = VALIGN4,
1504 .SurfaceHorizontalAlignment = HALIGN4,
1505 .TileMode = LINEAR,
1506 .VerticalLineStride = 0,
1507 .VerticalLineStrideOffset = 0,
1508 .SamplerL2BypassModeDisable = true,
1509 .RenderCacheReadWriteMode = WriteOnlyCache,
1510 .MemoryObjectControlState = GEN8_MOCS,
1511 .BaseMipLevel = 0,
1512 .SurfaceQPitch = 0,
1513 .Height = (num_elements >> 7) & 0x3fff,
1514 .Width = num_elements & 0x7f,
1515 .Depth = (num_elements >> 21) & 0x3f,
1516 .SurfacePitch = stride - 1,
1517 .MinimumArrayElement = 0,
1518 .NumberofMultisamples = MULTISAMPLECOUNT_1,
1519 .XOffset = 0,
1520 .YOffset = 0,
1521 .SurfaceMinLOD = 0,
1522 .MIPCountLOD = 0,
1523 .AuxiliarySurfaceMode = AUX_NONE,
1524 .RedClearColor = 0,
1525 .GreenClearColor = 0,
1526 .BlueClearColor = 0,
1527 .AlphaClearColor = 0,
1528 .ShaderChannelSelectRed = SCS_RED,
1529 .ShaderChannelSelectGreen = SCS_GREEN,
1530 .ShaderChannelSelectBlue = SCS_BLUE,
1531 .ShaderChannelSelectAlpha = SCS_ALPHA,
1532 .ResourceMinLOD = 0,
1533 /* FIXME: We assume that the image must be bound at this time. */
1534 .SurfaceBaseAddress = { NULL, offset },
1535 };
1536
1537 GEN8_RENDER_SURFACE_STATE_pack(NULL, state, &surface_state);
1538 }
1539
1540 VkResult anv_CreateBufferView(
1541 VkDevice _device,
1542 const VkBufferViewCreateInfo* pCreateInfo,
1543 VkBufferView* pView)
1544 {
1545 struct anv_device *device = (struct anv_device *) _device;
1546 struct anv_buffer *buffer = (struct anv_buffer *) pCreateInfo->buffer;
1547 struct anv_surface_view *view;
1548
1549 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);
1550
1551 view = anv_device_alloc(device, sizeof(*view), 8,
1552 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1553 if (view == NULL)
1554 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1555
1556 view->base.destructor = anv_surface_view_destroy;
1557
1558 view->bo = buffer->bo;
1559 view->offset = buffer->offset + pCreateInfo->offset;
1560 view->surface_state =
1561 anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
1562 view->format = pCreateInfo->format;
1563 view->range = pCreateInfo->range;
1564
1565 fill_buffer_surface_state(view->surface_state.map,
1566 pCreateInfo->format, view->offset, pCreateInfo->range);
1567
1568 *pView = (VkBufferView) view;
1569
1570 return VK_SUCCESS;
1571 }
1572
1573 // Sampler functions
1574
1575 VkResult anv_CreateSampler(
1576 VkDevice _device,
1577 const VkSamplerCreateInfo* pCreateInfo,
1578 VkSampler* pSampler)
1579 {
1580 struct anv_device *device = (struct anv_device *) _device;
1581 struct anv_sampler *sampler;
1582 uint32_t mag_filter, min_filter, max_anisotropy;
1583
1584 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
1585
1586 sampler = anv_device_alloc(device, sizeof(*sampler), 8,
1587 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1588 if (!sampler)
1589 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1590
1591 static const uint32_t vk_to_gen_tex_filter[] = {
1592 [VK_TEX_FILTER_NEAREST] = MAPFILTER_NEAREST,
1593 [VK_TEX_FILTER_LINEAR] = MAPFILTER_LINEAR
1594 };
1595
1596 static const uint32_t vk_to_gen_mipmap_mode[] = {
1597 [VK_TEX_MIPMAP_MODE_BASE] = MIPFILTER_NONE,
1598 [VK_TEX_MIPMAP_MODE_NEAREST] = MIPFILTER_NEAREST,
1599 [VK_TEX_MIPMAP_MODE_LINEAR] = MIPFILTER_LINEAR
1600 };
1601
1602 static const uint32_t vk_to_gen_tex_address[] = {
1603 [VK_TEX_ADDRESS_WRAP] = TCM_WRAP,
1604 [VK_TEX_ADDRESS_MIRROR] = TCM_MIRROR,
1605 [VK_TEX_ADDRESS_CLAMP] = TCM_CLAMP,
1606 [VK_TEX_ADDRESS_MIRROR_ONCE] = TCM_MIRROR_ONCE,
1607 [VK_TEX_ADDRESS_CLAMP_BORDER] = TCM_CLAMP_BORDER,
1608 };
1609
1610 static const uint32_t vk_to_gen_compare_op[] = {
1611 [VK_COMPARE_OP_NEVER] = PREFILTEROPNEVER,
1612 [VK_COMPARE_OP_LESS] = PREFILTEROPLESS,
1613 [VK_COMPARE_OP_EQUAL] = PREFILTEROPEQUAL,
1614 [VK_COMPARE_OP_LESS_EQUAL] = PREFILTEROPLEQUAL,
1615 [VK_COMPARE_OP_GREATER] = PREFILTEROPGREATER,
1616 [VK_COMPARE_OP_NOT_EQUAL] = PREFILTEROPNOTEQUAL,
1617 [VK_COMPARE_OP_GREATER_EQUAL] = PREFILTEROPGEQUAL,
1618 [VK_COMPARE_OP_ALWAYS] = PREFILTEROPALWAYS,
1619 };
1620
1621 if (pCreateInfo->maxAnisotropy > 1) {
1622 mag_filter = MAPFILTER_ANISOTROPIC;
1623 min_filter = MAPFILTER_ANISOTROPIC;
1624 max_anisotropy = (pCreateInfo->maxAnisotropy - 2) / 2;
1625 } else {
1626 mag_filter = vk_to_gen_tex_filter[pCreateInfo->magFilter];
1627 min_filter = vk_to_gen_tex_filter[pCreateInfo->minFilter];
1628 max_anisotropy = RATIO21;
1629 }
1630
1631 struct GEN8_SAMPLER_STATE sampler_state = {
1632 .SamplerDisable = false,
1633 .TextureBorderColorMode = DX10OGL,
1634 .LODPreClampMode = 0,
1635 .BaseMipLevel = 0,
1636 .MipModeFilter = vk_to_gen_mipmap_mode[pCreateInfo->mipMode],
1637 .MagModeFilter = mag_filter,
1638 .MinModeFilter = min_filter,
1639 .TextureLODBias = pCreateInfo->mipLodBias * 256,
1640 .AnisotropicAlgorithm = EWAApproximation,
1641 .MinLOD = pCreateInfo->minLod * 256,
1642 .MaxLOD = pCreateInfo->maxLod * 256,
1643 .ChromaKeyEnable = 0,
1644 .ChromaKeyIndex = 0,
1645 .ChromaKeyMode = 0,
1646 .ShadowFunction = vk_to_gen_compare_op[pCreateInfo->compareOp],
1647 .CubeSurfaceControlMode = 0,
1648
1649 .IndirectStatePointer =
1650 device->float_border_colors.offset +
1651 pCreateInfo->borderColor * sizeof(float) * 4,
1652
1653 .LODClampMagnificationMode = MIPNONE,
1654 .MaximumAnisotropy = max_anisotropy,
1655 .RAddressMinFilterRoundingEnable = 0,
1656 .RAddressMagFilterRoundingEnable = 0,
1657 .VAddressMinFilterRoundingEnable = 0,
1658 .VAddressMagFilterRoundingEnable = 0,
1659 .UAddressMinFilterRoundingEnable = 0,
1660 .UAddressMagFilterRoundingEnable = 0,
1661 .TrilinearFilterQuality = 0,
1662 .NonnormalizedCoordinateEnable = 0,
1663 .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressU],
1664 .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressV],
1665 .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressW],
1666 };
1667
1668 GEN8_SAMPLER_STATE_pack(NULL, sampler->state, &sampler_state);
1669
1670 *pSampler = (VkSampler) sampler;
1671
1672 return VK_SUCCESS;
1673 }
1674
1675 // Descriptor set functions
1676
1677 VkResult anv_CreateDescriptorSetLayout(
1678 VkDevice _device,
1679 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1680 VkDescriptorSetLayout* pSetLayout)
1681 {
1682 struct anv_device *device = (struct anv_device *) _device;
1683 struct anv_descriptor_set_layout *set_layout;
1684
1685 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
1686
1687 uint32_t sampler_count[VK_NUM_SHADER_STAGE] = { 0, };
1688 uint32_t surface_count[VK_NUM_SHADER_STAGE] = { 0, };
1689 uint32_t num_dynamic_buffers = 0;
1690 uint32_t count = 0;
1691 uint32_t stages = 0;
1692 uint32_t s;
1693
1694 for (uint32_t i = 0; i < pCreateInfo->count; i++) {
1695 switch (pCreateInfo->pBinding[i].descriptorType) {
1696 case VK_DESCRIPTOR_TYPE_SAMPLER:
1697 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1698 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1699 sampler_count[s] += pCreateInfo->pBinding[i].count;
1700 break;
1701 default:
1702 break;
1703 }
1704
1705 switch (pCreateInfo->pBinding[i].descriptorType) {
1706 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1707 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1708 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1709 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1710 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1711 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1712 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1713 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1714 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1715 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1716 surface_count[s] += pCreateInfo->pBinding[i].count;
1717 break;
1718 default:
1719 break;
1720 }
1721
1722 switch (pCreateInfo->pBinding[i].descriptorType) {
1723 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1724 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1725 num_dynamic_buffers += pCreateInfo->pBinding[i].count;
1726 break;
1727 default:
1728 break;
1729 }
1730
1731 stages |= pCreateInfo->pBinding[i].stageFlags;
1732 count += pCreateInfo->pBinding[i].count;
1733 }
1734
1735 uint32_t sampler_total = 0;
1736 uint32_t surface_total = 0;
1737 for (uint32_t s = 0; s < VK_NUM_SHADER_STAGE; s++) {
1738 sampler_total += sampler_count[s];
1739 surface_total += surface_count[s];
1740 }
1741
1742 size_t size = sizeof(*set_layout) +
1743 (sampler_total + surface_total) * sizeof(set_layout->entries[0]);
1744 set_layout = anv_device_alloc(device, size, 8,
1745 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1746 if (!set_layout)
1747 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1748
1749 set_layout->num_dynamic_buffers = num_dynamic_buffers;
1750 set_layout->count = count;
1751 set_layout->shader_stages = stages;
1752
1753 struct anv_descriptor_slot *p = set_layout->entries;
1754 struct anv_descriptor_slot *sampler[VK_NUM_SHADER_STAGE];
1755 struct anv_descriptor_slot *surface[VK_NUM_SHADER_STAGE];
1756 for (uint32_t s = 0; s < VK_NUM_SHADER_STAGE; s++) {
1757 set_layout->stage[s].surface_count = surface_count[s];
1758 set_layout->stage[s].surface_start = surface[s] = p;
1759 p += surface_count[s];
1760 set_layout->stage[s].sampler_count = sampler_count[s];
1761 set_layout->stage[s].sampler_start = sampler[s] = p;
1762 p += sampler_count[s];
1763 }
1764
1765 uint32_t descriptor = 0;
1766 int8_t dynamic_slot = 0;
1767 bool is_dynamic;
1768 for (uint32_t i = 0; i < pCreateInfo->count; i++) {
1769 switch (pCreateInfo->pBinding[i].descriptorType) {
1770 case VK_DESCRIPTOR_TYPE_SAMPLER:
1771 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1772 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1773 for (uint32_t j = 0; j < pCreateInfo->pBinding[i].count; j++) {
1774 sampler[s]->index = descriptor + j;
1775 sampler[s]->dynamic_slot = -1;
1776 sampler[s]++;
1777 }
1778 break;
1779 default:
1780 break;
1781 }
1782
1783 switch (pCreateInfo->pBinding[i].descriptorType) {
1784 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1785 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1786 is_dynamic = true;
1787 break;
1788 default:
1789 is_dynamic = false;
1790 break;
1791 }
1792
1793 switch (pCreateInfo->pBinding[i].descriptorType) {
1794 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1795 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1796 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1797 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1798 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1799 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1800 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1801 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1802 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1803 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1804 for (uint32_t j = 0; j < pCreateInfo->pBinding[i].count; j++) {
1805 surface[s]->index = descriptor + j;
1806 if (is_dynamic)
1807 surface[s]->dynamic_slot = dynamic_slot + j;
1808 else
1809 surface[s]->dynamic_slot = -1;
1810 surface[s]++;
1811 }
1812 break;
1813 default:
1814 break;
1815 }
1816
1817 if (is_dynamic)
1818 dynamic_slot += pCreateInfo->pBinding[i].count;
1819
1820 descriptor += pCreateInfo->pBinding[i].count;
1821 }
1822
1823 *pSetLayout = (VkDescriptorSetLayout) set_layout;
1824
1825 return VK_SUCCESS;
1826 }
1827
1828 VkResult anv_BeginDescriptorPoolUpdate(
1829 VkDevice device,
1830 VkDescriptorUpdateMode updateMode)
1831 {
1832 return VK_SUCCESS;
1833 }
1834
1835 VkResult anv_EndDescriptorPoolUpdate(
1836 VkDevice device,
1837 VkCmdBuffer cmd)
1838 {
1839 return VK_SUCCESS;
1840 }
1841
1842 VkResult anv_CreateDescriptorPool(
1843 VkDevice device,
1844 VkDescriptorPoolUsage poolUsage,
1845 uint32_t maxSets,
1846 const VkDescriptorPoolCreateInfo* pCreateInfo,
1847 VkDescriptorPool* pDescriptorPool)
1848 {
1849 *pDescriptorPool = 1;
1850
1851 return VK_SUCCESS;
1852 }
1853
1854 VkResult anv_ResetDescriptorPool(
1855 VkDevice device,
1856 VkDescriptorPool descriptorPool)
1857 {
1858 return VK_SUCCESS;
1859 }
1860
1861 VkResult anv_AllocDescriptorSets(
1862 VkDevice _device,
1863 VkDescriptorPool descriptorPool,
1864 VkDescriptorSetUsage setUsage,
1865 uint32_t count,
1866 const VkDescriptorSetLayout* pSetLayouts,
1867 VkDescriptorSet* pDescriptorSets,
1868 uint32_t* pCount)
1869 {
1870 struct anv_device *device = (struct anv_device *) _device;
1871 const struct anv_descriptor_set_layout *layout;
1872 struct anv_descriptor_set *set;
1873 size_t size;
1874
1875 for (uint32_t i = 0; i < count; i++) {
1876 layout = (struct anv_descriptor_set_layout *) pSetLayouts[i];
1877 size = sizeof(*set) + layout->count * sizeof(set->descriptors[0]);
1878 set = anv_device_alloc(device, size, 8,
1879 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1880 if (!set) {
1881 *pCount = i;
1882 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1883 }
1884
1885 /* Descriptor sets may not be 100% filled out so we need to memset to
1886 * ensure that we can properly detect and handle holes.
1887 */
1888 memset(set, 0, size);
1889
1890 pDescriptorSets[i] = (VkDescriptorSet) set;
1891 }
1892
1893 *pCount = count;
1894
1895 return VK_SUCCESS;
1896 }
1897
1898 void anv_ClearDescriptorSets(
1899 VkDevice device,
1900 VkDescriptorPool descriptorPool,
1901 uint32_t count,
1902 const VkDescriptorSet* pDescriptorSets)
1903 {
1904 }
1905
1906 void anv_UpdateDescriptors(
1907 VkDevice _device,
1908 VkDescriptorSet descriptorSet,
1909 uint32_t updateCount,
1910 const void** ppUpdateArray)
1911 {
1912 struct anv_descriptor_set *set = (struct anv_descriptor_set *) descriptorSet;
1913 VkUpdateSamplers *update_samplers;
1914 VkUpdateSamplerTextures *update_sampler_textures;
1915 VkUpdateImages *update_images;
1916 VkUpdateBuffers *update_buffers;
1917 VkUpdateAsCopy *update_as_copy;
1918
1919 for (uint32_t i = 0; i < updateCount; i++) {
1920 const struct anv_common *common = ppUpdateArray[i];
1921
1922 switch (common->sType) {
1923 case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
1924 update_samplers = (VkUpdateSamplers *) common;
1925
1926 for (uint32_t j = 0; j < update_samplers->count; j++) {
1927 set->descriptors[update_samplers->binding + j].sampler =
1928 (struct anv_sampler *) update_samplers->pSamplers[j];
1929 }
1930 break;
1931
1932 case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
1933 /* FIXME: Shouldn't this be *_UPDATE_SAMPLER_IMAGES? */
1934 update_sampler_textures = (VkUpdateSamplerTextures *) common;
1935
1936 for (uint32_t j = 0; j < update_sampler_textures->count; j++) {
1937 set->descriptors[update_sampler_textures->binding + j].view =
1938 (struct anv_surface_view *)
1939 update_sampler_textures->pSamplerImageViews[j].pImageView->view;
1940 set->descriptors[update_sampler_textures->binding + j].sampler =
1941 (struct anv_sampler *)
1942 update_sampler_textures->pSamplerImageViews[j].sampler;
1943 }
1944 break;
1945
1946 case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
1947 update_images = (VkUpdateImages *) common;
1948
1949 for (uint32_t j = 0; j < update_images->count; j++) {
1950 set->descriptors[update_images->binding + j].view =
1951 (struct anv_surface_view *) update_images->pImageViews[j].view;
1952 }
1953 break;
1954
1955 case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
1956 update_buffers = (VkUpdateBuffers *) common;
1957
1958 for (uint32_t j = 0; j < update_buffers->count; j++) {
1959 set->descriptors[update_buffers->binding + j].view =
1960 (struct anv_surface_view *) update_buffers->pBufferViews[j].view;
1961 }
1962 /* FIXME: descriptor arrays? */
1963 break;
1964
1965 case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
1966 update_as_copy = (VkUpdateAsCopy *) common;
1967 (void) update_as_copy;
1968 break;
1969
1970 default:
1971 break;
1972 }
1973 }
1974 }
1975
1976 // State object functions
1977
1978 static inline int64_t
1979 clamp_int64(int64_t x, int64_t min, int64_t max)
1980 {
1981 if (x < min)
1982 return min;
1983 else if (x < max)
1984 return x;
1985 else
1986 return max;
1987 }
1988
1989 static void
1990 anv_dynamic_vp_state_destroy(struct anv_device *device,
1991 struct anv_object *object,
1992 VkObjectType obj_type)
1993 {
1994 struct anv_dynamic_vp_state *state = (void *)object;
1995
1996 assert(obj_type == VK_OBJECT_TYPE_DYNAMIC_VP_STATE);
1997
1998 anv_state_pool_free(&device->dynamic_state_pool, state->sf_clip_vp);
1999 anv_state_pool_free(&device->dynamic_state_pool, state->cc_vp);
2000 anv_state_pool_free(&device->dynamic_state_pool, state->scissor);
2001
2002 anv_device_free(device, state);
2003 }
2004
2005 VkResult anv_CreateDynamicViewportState(
2006 VkDevice _device,
2007 const VkDynamicVpStateCreateInfo* pCreateInfo,
2008 VkDynamicVpState* pState)
2009 {
2010 struct anv_device *device = (struct anv_device *) _device;
2011 struct anv_dynamic_vp_state *state;
2012
2013 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO);
2014
2015 state = anv_device_alloc(device, sizeof(*state), 8,
2016 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
2017 if (state == NULL)
2018 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2019
2020 state->base.destructor = anv_dynamic_vp_state_destroy;
2021
2022 unsigned count = pCreateInfo->viewportAndScissorCount;
2023 state->sf_clip_vp = anv_state_pool_alloc(&device->dynamic_state_pool,
2024 count * 64, 64);
2025 state->cc_vp = anv_state_pool_alloc(&device->dynamic_state_pool,
2026 count * 8, 32);
2027 state->scissor = anv_state_pool_alloc(&device->dynamic_state_pool,
2028 count * 32, 32);
2029
2030 for (uint32_t i = 0; i < pCreateInfo->viewportAndScissorCount; i++) {
2031 const VkViewport *vp = &pCreateInfo->pViewports[i];
2032 const VkRect *s = &pCreateInfo->pScissors[i];
2033
2034 struct GEN8_SF_CLIP_VIEWPORT sf_clip_viewport = {
2035 .ViewportMatrixElementm00 = vp->width / 2,
2036 .ViewportMatrixElementm11 = vp->height / 2,
2037 .ViewportMatrixElementm22 = (vp->maxDepth - vp->minDepth) / 2,
2038 .ViewportMatrixElementm30 = vp->originX + vp->width / 2,
2039 .ViewportMatrixElementm31 = vp->originY + vp->height / 2,
2040 .ViewportMatrixElementm32 = (vp->maxDepth + vp->minDepth) / 2,
2041 .XMinClipGuardband = -1.0f,
2042 .XMaxClipGuardband = 1.0f,
2043 .YMinClipGuardband = -1.0f,
2044 .YMaxClipGuardband = 1.0f,
2045 .XMinViewPort = vp->originX,
2046 .XMaxViewPort = vp->originX + vp->width - 1,
2047 .YMinViewPort = vp->originY,
2048 .YMaxViewPort = vp->originY + vp->height - 1,
2049 };
2050
2051 struct GEN8_CC_VIEWPORT cc_viewport = {
2052 .MinimumDepth = vp->minDepth,
2053 .MaximumDepth = vp->maxDepth
2054 };
2055
2056 /* Since xmax and ymax are inclusive, we have to have xmax < xmin or
2057 * ymax < ymin for empty clips. In case clip x, y, width height are all
2058 * 0, the clamps below produce 0 for xmin, ymin, xmax, ymax, which isn't
2059 * what we want. Just special case empty clips and produce a canonical
2060 * empty clip. */
2061 static const struct GEN8_SCISSOR_RECT empty_scissor = {
2062 .ScissorRectangleYMin = 1,
2063 .ScissorRectangleXMin = 1,
2064 .ScissorRectangleYMax = 0,
2065 .ScissorRectangleXMax = 0
2066 };
2067
2068 const int max = 0xffff;
2069 struct GEN8_SCISSOR_RECT scissor = {
2070 /* Do this math using int64_t so overflow gets clamped correctly. */
2071 .ScissorRectangleYMin = clamp_int64(s->offset.y, 0, max),
2072 .ScissorRectangleXMin = clamp_int64(s->offset.x, 0, max),
2073 .ScissorRectangleYMax = clamp_int64((uint64_t) s->offset.y + s->extent.height - 1, 0, max),
2074 .ScissorRectangleXMax = clamp_int64((uint64_t) s->offset.x + s->extent.width - 1, 0, max)
2075 };
2076
2077 GEN8_SF_CLIP_VIEWPORT_pack(NULL, state->sf_clip_vp.map + i * 64, &sf_clip_viewport);
2078 GEN8_CC_VIEWPORT_pack(NULL, state->cc_vp.map + i * 32, &cc_viewport);
2079
2080 if (s->extent.width <= 0 || s->extent.height <= 0) {
2081 GEN8_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &empty_scissor);
2082 } else {
2083 GEN8_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &scissor);
2084 }
2085 }
2086
2087 *pState = (VkDynamicVpState) state;
2088
2089 return VK_SUCCESS;
2090 }
2091
2092 VkResult anv_CreateDynamicRasterState(
2093 VkDevice _device,
2094 const VkDynamicRsStateCreateInfo* pCreateInfo,
2095 VkDynamicRsState* pState)
2096 {
2097 struct anv_device *device = (struct anv_device *) _device;
2098 struct anv_dynamic_rs_state *state;
2099
2100 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO);
2101
2102 state = anv_device_alloc(device, sizeof(*state), 8,
2103 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
2104 if (state == NULL)
2105 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2106
2107 /* Missing these:
2108 * float pointFadeThreshold;
2109 * // optional (GL45) - Size of point fade threshold
2110 */
2111
2112 struct GEN8_3DSTATE_SF sf = {
2113 GEN8_3DSTATE_SF_header,
2114 .LineWidth = pCreateInfo->lineWidth,
2115 .PointWidth = pCreateInfo->pointSize,
2116 };
2117
2118 GEN8_3DSTATE_SF_pack(NULL, state->state_sf, &sf);
2119
2120 bool enable_bias = pCreateInfo->depthBias != 0.0f ||
2121 pCreateInfo->slopeScaledDepthBias != 0.0f;
2122 struct GEN8_3DSTATE_RASTER raster = {
2123 .GlobalDepthOffsetEnableSolid = enable_bias,
2124 .GlobalDepthOffsetEnableWireframe = enable_bias,
2125 .GlobalDepthOffsetEnablePoint = enable_bias,
2126 .GlobalDepthOffsetConstant = pCreateInfo->depthBias,
2127 .GlobalDepthOffsetScale = pCreateInfo->slopeScaledDepthBias,
2128 .GlobalDepthOffsetClamp = pCreateInfo->depthBiasClamp
2129 };
2130
2131 GEN8_3DSTATE_RASTER_pack(NULL, state->state_raster, &raster);
2132
2133 *pState = (VkDynamicRsState) state;
2134
2135 return VK_SUCCESS;
2136 }
2137
2138 VkResult anv_CreateDynamicColorBlendState(
2139 VkDevice _device,
2140 const VkDynamicCbStateCreateInfo* pCreateInfo,
2141 VkDynamicCbState* pState)
2142 {
2143 struct anv_device *device = (struct anv_device *) _device;
2144 struct anv_dynamic_cb_state *state;
2145
2146 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO);
2147
2148 state = anv_device_alloc(device, sizeof(*state), 8,
2149 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
2150 if (state == NULL)
2151 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2152
2153 struct GEN8_COLOR_CALC_STATE color_calc_state = {
2154 .BlendConstantColorRed = pCreateInfo->blendConst[0],
2155 .BlendConstantColorGreen = pCreateInfo->blendConst[1],
2156 .BlendConstantColorBlue = pCreateInfo->blendConst[2],
2157 .BlendConstantColorAlpha = pCreateInfo->blendConst[3]
2158 };
2159
2160 GEN8_COLOR_CALC_STATE_pack(NULL, state->state_color_calc, &color_calc_state);
2161
2162 *pState = (VkDynamicCbState) state;
2163
2164 return VK_SUCCESS;
2165 }
2166
2167 VkResult anv_CreateDynamicDepthStencilState(
2168 VkDevice _device,
2169 const VkDynamicDsStateCreateInfo* pCreateInfo,
2170 VkDynamicDsState* pState)
2171 {
2172 struct anv_device *device = (struct anv_device *) _device;
2173 struct anv_dynamic_ds_state *state;
2174
2175 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO);
2176
2177 state = anv_device_alloc(device, sizeof(*state), 8,
2178 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
2179 if (state == NULL)
2180 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2181
2182 struct GEN8_3DSTATE_WM_DEPTH_STENCIL wm_depth_stencil = {
2183 GEN8_3DSTATE_WM_DEPTH_STENCIL_header,
2184
2185 /* Is this what we need to do? */
2186 .StencilBufferWriteEnable = pCreateInfo->stencilWriteMask != 0,
2187
2188 .StencilTestMask = pCreateInfo->stencilReadMask & 0xff,
2189 .StencilWriteMask = pCreateInfo->stencilWriteMask & 0xff,
2190
2191 .BackfaceStencilTestMask = pCreateInfo->stencilReadMask & 0xff,
2192 .BackfaceStencilWriteMask = pCreateInfo->stencilWriteMask & 0xff,
2193 };
2194
2195 GEN8_3DSTATE_WM_DEPTH_STENCIL_pack(NULL, state->state_wm_depth_stencil,
2196 &wm_depth_stencil);
2197
2198 struct GEN8_COLOR_CALC_STATE color_calc_state = {
2199 .StencilReferenceValue = pCreateInfo->stencilFrontRef,
2200 .BackFaceStencilReferenceValue = pCreateInfo->stencilBackRef
2201 };
2202
2203 GEN8_COLOR_CALC_STATE_pack(NULL, state->state_color_calc, &color_calc_state);
2204
2205 *pState = (VkDynamicDsState) state;
2206
2207 return VK_SUCCESS;
2208 }
2209
2210 // Command buffer functions
2211
2212 static void
2213 anv_cmd_buffer_destroy(struct anv_device *device,
2214 struct anv_object *object,
2215 VkObjectType obj_type)
2216 {
2217 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) object;
2218
2219 assert(obj_type == VK_OBJECT_TYPE_COMMAND_BUFFER);
2220
2221 /* Destroy all of the batch buffers */
2222 struct anv_batch_bo *bbo = cmd_buffer->last_batch_bo;
2223 while (bbo) {
2224 struct anv_batch_bo *prev = bbo->prev_batch_bo;
2225 anv_batch_bo_destroy(bbo, device);
2226 bbo = prev;
2227 }
2228 anv_reloc_list_finish(&cmd_buffer->batch.relocs, device);
2229
2230 /* Destroy all of the surface state buffers */
2231 bbo = cmd_buffer->surface_batch_bo;
2232 while (bbo) {
2233 struct anv_batch_bo *prev = bbo->prev_batch_bo;
2234 anv_batch_bo_destroy(bbo, device);
2235 bbo = prev;
2236 }
2237 anv_reloc_list_finish(&cmd_buffer->surface_relocs, device);
2238
2239 anv_state_stream_finish(&cmd_buffer->surface_state_stream);
2240 anv_state_stream_finish(&cmd_buffer->dynamic_state_stream);
2241 anv_device_free(device, cmd_buffer->exec2_objects);
2242 anv_device_free(device, cmd_buffer->exec2_bos);
2243 anv_device_free(device, cmd_buffer);
2244 }
2245
2246 static VkResult
2247 anv_cmd_buffer_chain_batch(struct anv_batch *batch, void *_data)
2248 {
2249 struct anv_cmd_buffer *cmd_buffer = _data;
2250
2251 struct anv_batch_bo *new_bbo, *old_bbo = cmd_buffer->last_batch_bo;
2252
2253 VkResult result = anv_batch_bo_create(cmd_buffer->device, &new_bbo);
2254 if (result != VK_SUCCESS)
2255 return result;
2256
2257 /* We set the end of the batch a little short so we would be sure we
2258 * have room for the chaining command. Since we're about to emit the
2259 * chaining command, let's set it back where it should go.
2260 */
2261 batch->end += GEN8_MI_BATCH_BUFFER_START_length * 4;
2262 assert(batch->end == old_bbo->bo.map + old_bbo->bo.size);
2263
2264 anv_batch_emit(batch, GEN8_MI_BATCH_BUFFER_START,
2265 GEN8_MI_BATCH_BUFFER_START_header,
2266 ._2ndLevelBatchBuffer = _1stlevelbatch,
2267 .AddressSpaceIndicator = ASI_PPGTT,
2268 .BatchBufferStartAddress = { &new_bbo->bo, 0 },
2269 );
2270
2271 /* Pad out to a 2-dword aligned boundary with zeros */
2272 if ((uintptr_t)batch->next % 8 != 0) {
2273 *(uint32_t *)batch->next = 0;
2274 batch->next += 4;
2275 }
2276
2277 anv_batch_bo_finish(cmd_buffer->last_batch_bo, batch);
2278
2279 new_bbo->prev_batch_bo = old_bbo;
2280 cmd_buffer->last_batch_bo = new_bbo;
2281
2282 anv_batch_bo_start(new_bbo, batch, GEN8_MI_BATCH_BUFFER_START_length * 4);
2283
2284 return VK_SUCCESS;
2285 }
2286
2287 VkResult anv_CreateCommandBuffer(
2288 VkDevice _device,
2289 const VkCmdBufferCreateInfo* pCreateInfo,
2290 VkCmdBuffer* pCmdBuffer)
2291 {
2292 struct anv_device *device = (struct anv_device *) _device;
2293 struct anv_cmd_buffer *cmd_buffer;
2294 VkResult result;
2295
2296 cmd_buffer = anv_device_alloc(device, sizeof(*cmd_buffer), 8,
2297 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
2298 if (cmd_buffer == NULL)
2299 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2300
2301 cmd_buffer->base.destructor = anv_cmd_buffer_destroy;
2302
2303 cmd_buffer->device = device;
2304 cmd_buffer->rs_state = NULL;
2305 cmd_buffer->vp_state = NULL;
2306 cmd_buffer->cb_state = NULL;
2307 memset(&cmd_buffer->descriptors, 0, sizeof(cmd_buffer->descriptors));
2308
2309 result = anv_batch_bo_create(device, &cmd_buffer->last_batch_bo);
2310 if (result != VK_SUCCESS)
2311 goto fail;
2312
2313 result = anv_reloc_list_init(&cmd_buffer->batch.relocs, device);
2314 if (result != VK_SUCCESS)
2315 goto fail_batch_bo;
2316
2317 cmd_buffer->batch.device = device;
2318 cmd_buffer->batch.extend_cb = anv_cmd_buffer_chain_batch;
2319 cmd_buffer->batch.user_data = cmd_buffer;
2320
2321 anv_batch_bo_start(cmd_buffer->last_batch_bo, &cmd_buffer->batch,
2322 GEN8_MI_BATCH_BUFFER_START_length * 4);
2323
2324 result = anv_batch_bo_create(device, &cmd_buffer->surface_batch_bo);
2325 if (result != VK_SUCCESS)
2326 goto fail_batch_relocs;
2327 cmd_buffer->surface_batch_bo->first_reloc = 0;
2328
2329 result = anv_reloc_list_init(&cmd_buffer->surface_relocs, device);
2330 if (result != VK_SUCCESS)
2331 goto fail_ss_batch_bo;
2332
2333 /* Start surface_next at 1 so surface offset 0 is invalid. */
2334 cmd_buffer->surface_next = 1;
2335
2336 cmd_buffer->exec2_objects = NULL;
2337 cmd_buffer->exec2_bos = NULL;
2338 cmd_buffer->exec2_array_length = 0;
2339
2340 anv_state_stream_init(&cmd_buffer->surface_state_stream,
2341 &device->surface_state_block_pool);
2342 anv_state_stream_init(&cmd_buffer->dynamic_state_stream,
2343 &device->dynamic_state_block_pool);
2344
2345 cmd_buffer->dirty = 0;
2346 cmd_buffer->vb_dirty = 0;
2347 cmd_buffer->descriptors_dirty = 0;
2348 cmd_buffer->pipeline = NULL;
2349 cmd_buffer->vp_state = NULL;
2350 cmd_buffer->rs_state = NULL;
2351 cmd_buffer->ds_state = NULL;
2352
2353 *pCmdBuffer = (VkCmdBuffer) cmd_buffer;
2354
2355 return VK_SUCCESS;
2356
2357 fail_ss_batch_bo:
2358 anv_batch_bo_destroy(cmd_buffer->surface_batch_bo, device);
2359 fail_batch_relocs:
2360 anv_reloc_list_finish(&cmd_buffer->batch.relocs, device);
2361 fail_batch_bo:
2362 anv_batch_bo_destroy(cmd_buffer->last_batch_bo, device);
2363 fail:
2364 anv_device_free(device, cmd_buffer);
2365
2366 return result;
2367 }
2368
2369 static void
2370 anv_cmd_buffer_emit_state_base_address(struct anv_cmd_buffer *cmd_buffer)
2371 {
2372 struct anv_device *device = cmd_buffer->device;
2373
2374 anv_batch_emit(&cmd_buffer->batch, GEN8_STATE_BASE_ADDRESS,
2375 .GeneralStateBaseAddress = { NULL, 0 },
2376 .GeneralStateMemoryObjectControlState = GEN8_MOCS,
2377 .GeneralStateBaseAddressModifyEnable = true,
2378 .GeneralStateBufferSize = 0xfffff,
2379 .GeneralStateBufferSizeModifyEnable = true,
2380
2381 .SurfaceStateBaseAddress = { &cmd_buffer->surface_batch_bo->bo, 0 },
2382 .SurfaceStateMemoryObjectControlState = GEN8_MOCS,
2383 .SurfaceStateBaseAddressModifyEnable = true,
2384
2385 .DynamicStateBaseAddress = { &device->dynamic_state_block_pool.bo, 0 },
2386 .DynamicStateMemoryObjectControlState = GEN8_MOCS,
2387 .DynamicStateBaseAddressModifyEnable = true,
2388 .DynamicStateBufferSize = 0xfffff,
2389 .DynamicStateBufferSizeModifyEnable = true,
2390
2391 .IndirectObjectBaseAddress = { NULL, 0 },
2392 .IndirectObjectMemoryObjectControlState = GEN8_MOCS,
2393 .IndirectObjectBaseAddressModifyEnable = true,
2394 .IndirectObjectBufferSize = 0xfffff,
2395 .IndirectObjectBufferSizeModifyEnable = true,
2396
2397 .InstructionBaseAddress = { &device->instruction_block_pool.bo, 0 },
2398 .InstructionMemoryObjectControlState = GEN8_MOCS,
2399 .InstructionBaseAddressModifyEnable = true,
2400 .InstructionBufferSize = 0xfffff,
2401 .InstructionBuffersizeModifyEnable = true);
2402 }
2403
2404 VkResult anv_BeginCommandBuffer(
2405 VkCmdBuffer cmdBuffer,
2406 const VkCmdBufferBeginInfo* pBeginInfo)
2407 {
2408 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2409
2410 anv_batch_emit(&cmd_buffer->batch, GEN8_PIPELINE_SELECT,
2411 .PipelineSelection = _3D);
2412 anv_batch_emit(&cmd_buffer->batch, GEN8_STATE_SIP);
2413
2414 anv_cmd_buffer_emit_state_base_address(cmd_buffer);
2415
2416 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VF_STATISTICS,
2417 .StatisticsEnable = true);
2418 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_HS, .Enable = false);
2419 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_TE, .TEEnable = false);
2420 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DS, .FunctionEnable = false);
2421 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_STREAMOUT, .SOFunctionEnable = false);
2422
2423 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS,
2424 .ConstantBufferOffset = 0,
2425 .ConstantBufferSize = 4);
2426 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS,
2427 .ConstantBufferOffset = 4,
2428 .ConstantBufferSize = 4);
2429 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS,
2430 .ConstantBufferOffset = 8,
2431 .ConstantBufferSize = 4);
2432
2433 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_WM_CHROMAKEY,
2434 .ChromaKeyKillEnable = false);
2435 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SBE_SWIZ);
2436 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_AA_LINE_PARAMETERS);
2437
2438 return VK_SUCCESS;
2439 }
2440
2441 static VkResult
2442 anv_cmd_buffer_add_bo(struct anv_cmd_buffer *cmd_buffer,
2443 struct anv_bo *bo,
2444 struct drm_i915_gem_relocation_entry *relocs,
2445 size_t num_relocs)
2446 {
2447 struct drm_i915_gem_exec_object2 *obj;
2448
2449 if (bo->index < cmd_buffer->bo_count &&
2450 cmd_buffer->exec2_bos[bo->index] == bo)
2451 return VK_SUCCESS;
2452
2453 if (cmd_buffer->bo_count >= cmd_buffer->exec2_array_length) {
2454 uint32_t new_len = cmd_buffer->exec2_objects ?
2455 cmd_buffer->exec2_array_length * 2 : 64;
2456
2457 struct drm_i915_gem_exec_object2 *new_objects =
2458 anv_device_alloc(cmd_buffer->device, new_len * sizeof(*new_objects),
2459 8, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
2460 if (new_objects == NULL)
2461 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2462
2463 struct anv_bo **new_bos =
2464 anv_device_alloc(cmd_buffer->device, new_len * sizeof(*new_bos),
2465 8, VK_SYSTEM_ALLOC_TYPE_INTERNAL);
2466 if (new_objects == NULL) {
2467 anv_device_free(cmd_buffer->device, new_objects);
2468 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2469 }
2470
2471 if (cmd_buffer->exec2_objects) {
2472 memcpy(new_objects, cmd_buffer->exec2_objects,
2473 cmd_buffer->bo_count * sizeof(*new_objects));
2474 memcpy(new_bos, cmd_buffer->exec2_bos,
2475 cmd_buffer->bo_count * sizeof(*new_bos));
2476 }
2477
2478 cmd_buffer->exec2_objects = new_objects;
2479 cmd_buffer->exec2_bos = new_bos;
2480 cmd_buffer->exec2_array_length = new_len;
2481 }
2482
2483 assert(cmd_buffer->bo_count < cmd_buffer->exec2_array_length);
2484
2485 bo->index = cmd_buffer->bo_count++;
2486 obj = &cmd_buffer->exec2_objects[bo->index];
2487 cmd_buffer->exec2_bos[bo->index] = bo;
2488
2489 obj->handle = bo->gem_handle;
2490 obj->relocation_count = 0;
2491 obj->relocs_ptr = 0;
2492 obj->alignment = 0;
2493 obj->offset = bo->offset;
2494 obj->flags = 0;
2495 obj->rsvd1 = 0;
2496 obj->rsvd2 = 0;
2497
2498 if (relocs) {
2499 obj->relocation_count = num_relocs;
2500 obj->relocs_ptr = (uintptr_t) relocs;
2501 }
2502
2503 return VK_SUCCESS;
2504 }
2505
2506 static void
2507 anv_cmd_buffer_add_validate_bos(struct anv_cmd_buffer *cmd_buffer,
2508 struct anv_reloc_list *list)
2509 {
2510 for (size_t i = 0; i < list->num_relocs; i++)
2511 anv_cmd_buffer_add_bo(cmd_buffer, list->reloc_bos[i], NULL, 0);
2512 }
2513
2514 static void
2515 anv_cmd_buffer_process_relocs(struct anv_cmd_buffer *cmd_buffer,
2516 struct anv_reloc_list *list)
2517 {
2518 struct anv_bo *bo;
2519
2520 /* If the kernel supports I915_EXEC_NO_RELOC, it will compare offset in
2521 * struct drm_i915_gem_exec_object2 against the bos current offset and if
2522 * all bos haven't moved it will skip relocation processing alltogether.
2523 * If I915_EXEC_NO_RELOC is not supported, the kernel ignores the incoming
2524 * value of offset so we can set it either way. For that to work we need
2525 * to make sure all relocs use the same presumed offset.
2526 */
2527
2528 for (size_t i = 0; i < list->num_relocs; i++) {
2529 bo = list->reloc_bos[i];
2530 if (bo->offset != list->relocs[i].presumed_offset)
2531 cmd_buffer->need_reloc = true;
2532
2533 list->relocs[i].target_handle = bo->index;
2534 }
2535 }
2536
2537 VkResult anv_EndCommandBuffer(
2538 VkCmdBuffer cmdBuffer)
2539 {
2540 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2541 struct anv_device *device = cmd_buffer->device;
2542 struct anv_batch *batch = &cmd_buffer->batch;
2543
2544 anv_batch_emit(batch, GEN8_MI_BATCH_BUFFER_END);
2545
2546 /* Round batch up to an even number of dwords. */
2547 if ((batch->next - batch->start) & 4)
2548 anv_batch_emit(batch, GEN8_MI_NOOP);
2549
2550 anv_batch_bo_finish(cmd_buffer->last_batch_bo, &cmd_buffer->batch);
2551 cmd_buffer->surface_batch_bo->num_relocs =
2552 cmd_buffer->surface_relocs.num_relocs - cmd_buffer->surface_batch_bo->first_reloc;
2553 cmd_buffer->surface_batch_bo->length = cmd_buffer->surface_next;
2554
2555 cmd_buffer->bo_count = 0;
2556 cmd_buffer->need_reloc = false;
2557
2558 /* Lock for access to bo->index. */
2559 pthread_mutex_lock(&device->mutex);
2560
2561 /* Add surface state bos first so we can add them with their relocs. */
2562 for (struct anv_batch_bo *bbo = cmd_buffer->surface_batch_bo;
2563 bbo != NULL; bbo = bbo->prev_batch_bo) {
2564 anv_cmd_buffer_add_bo(cmd_buffer, &bbo->bo,
2565 &cmd_buffer->surface_relocs.relocs[bbo->first_reloc],
2566 bbo->num_relocs);
2567 }
2568
2569 /* Add all of the BOs referenced by surface state */
2570 anv_cmd_buffer_add_validate_bos(cmd_buffer, &cmd_buffer->surface_relocs);
2571
2572 /* Add all but the first batch BO */
2573 struct anv_batch_bo *batch_bo = cmd_buffer->last_batch_bo;
2574 while (batch_bo->prev_batch_bo) {
2575 anv_cmd_buffer_add_bo(cmd_buffer, &batch_bo->bo,
2576 &batch->relocs.relocs[batch_bo->first_reloc],
2577 batch_bo->num_relocs);
2578 batch_bo = batch_bo->prev_batch_bo;
2579 }
2580
2581 /* Add everything referenced by the batches */
2582 anv_cmd_buffer_add_validate_bos(cmd_buffer, &batch->relocs);
2583
2584 /* Add the first batch bo last */
2585 assert(batch_bo->prev_batch_bo == NULL && batch_bo->first_reloc == 0);
2586 anv_cmd_buffer_add_bo(cmd_buffer, &batch_bo->bo,
2587 &batch->relocs.relocs[batch_bo->first_reloc],
2588 batch_bo->num_relocs);
2589 assert(batch_bo->bo.index == cmd_buffer->bo_count - 1);
2590
2591 anv_cmd_buffer_process_relocs(cmd_buffer, &cmd_buffer->surface_relocs);
2592 anv_cmd_buffer_process_relocs(cmd_buffer, &batch->relocs);
2593
2594 cmd_buffer->execbuf.buffers_ptr = (uintptr_t) cmd_buffer->exec2_objects;
2595 cmd_buffer->execbuf.buffer_count = cmd_buffer->bo_count;
2596 cmd_buffer->execbuf.batch_start_offset = 0;
2597 cmd_buffer->execbuf.batch_len = batch->next - batch->start;
2598 cmd_buffer->execbuf.cliprects_ptr = 0;
2599 cmd_buffer->execbuf.num_cliprects = 0;
2600 cmd_buffer->execbuf.DR1 = 0;
2601 cmd_buffer->execbuf.DR4 = 0;
2602
2603 cmd_buffer->execbuf.flags = I915_EXEC_HANDLE_LUT;
2604 if (!cmd_buffer->need_reloc)
2605 cmd_buffer->execbuf.flags |= I915_EXEC_NO_RELOC;
2606 cmd_buffer->execbuf.flags |= I915_EXEC_RENDER;
2607 cmd_buffer->execbuf.rsvd1 = device->context_id;
2608 cmd_buffer->execbuf.rsvd2 = 0;
2609
2610 pthread_mutex_unlock(&device->mutex);
2611
2612 return VK_SUCCESS;
2613 }
2614
2615 VkResult anv_ResetCommandBuffer(
2616 VkCmdBuffer cmdBuffer)
2617 {
2618 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2619
2620 /* Delete all but the first batch bo */
2621 while (cmd_buffer->last_batch_bo->prev_batch_bo) {
2622 struct anv_batch_bo *prev = cmd_buffer->last_batch_bo->prev_batch_bo;
2623 anv_batch_bo_destroy(cmd_buffer->last_batch_bo, cmd_buffer->device);
2624 cmd_buffer->last_batch_bo = prev;
2625 }
2626 assert(cmd_buffer->last_batch_bo->prev_batch_bo == NULL);
2627
2628 cmd_buffer->batch.relocs.num_relocs = 0;
2629 anv_batch_bo_start(cmd_buffer->last_batch_bo, &cmd_buffer->batch,
2630 GEN8_MI_BATCH_BUFFER_START_length * 4);
2631
2632 /* Delete all but the first batch bo */
2633 while (cmd_buffer->surface_batch_bo->prev_batch_bo) {
2634 struct anv_batch_bo *prev = cmd_buffer->surface_batch_bo->prev_batch_bo;
2635 anv_batch_bo_destroy(cmd_buffer->surface_batch_bo, cmd_buffer->device);
2636 cmd_buffer->surface_batch_bo = prev;
2637 }
2638 assert(cmd_buffer->surface_batch_bo->prev_batch_bo == NULL);
2639
2640 cmd_buffer->surface_next = 1;
2641 cmd_buffer->surface_relocs.num_relocs = 0;
2642
2643 return VK_SUCCESS;
2644 }
2645
2646 // Command buffer building functions
2647
2648 void anv_CmdBindPipeline(
2649 VkCmdBuffer cmdBuffer,
2650 VkPipelineBindPoint pipelineBindPoint,
2651 VkPipeline _pipeline)
2652 {
2653 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2654 struct anv_pipeline *pipeline = (struct anv_pipeline *) _pipeline;
2655
2656 cmd_buffer->pipeline = pipeline;
2657 cmd_buffer->vb_dirty |= pipeline->vb_used;
2658 cmd_buffer->dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY;
2659 }
2660
2661 void anv_CmdBindDynamicStateObject(
2662 VkCmdBuffer cmdBuffer,
2663 VkStateBindPoint stateBindPoint,
2664 VkDynamicStateObject dynamicState)
2665 {
2666 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2667 struct anv_dynamic_vp_state *vp_state;
2668
2669 switch (stateBindPoint) {
2670 case VK_STATE_BIND_POINT_VIEWPORT:
2671 vp_state = (struct anv_dynamic_vp_state *) dynamicState;
2672 /* We emit state immediately, but set cmd_buffer->vp_state to indicate
2673 * that vp state has been set in this command buffer. */
2674 cmd_buffer->vp_state = vp_state;
2675 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SCISSOR_STATE_POINTERS,
2676 .ScissorRectPointer = vp_state->scissor.offset);
2677 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC,
2678 .CCViewportPointer = vp_state->cc_vp.offset);
2679 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP,
2680 .SFClipViewportPointer = vp_state->sf_clip_vp.offset);
2681 break;
2682 case VK_STATE_BIND_POINT_RASTER:
2683 cmd_buffer->rs_state = (struct anv_dynamic_rs_state *) dynamicState;
2684 cmd_buffer->dirty |= ANV_CMD_BUFFER_RS_DIRTY;
2685 break;
2686 case VK_STATE_BIND_POINT_COLOR_BLEND:
2687 cmd_buffer->cb_state = (struct anv_dynamic_cb_state *) dynamicState;
2688 cmd_buffer->dirty |= ANV_CMD_BUFFER_CB_DIRTY;
2689 break;
2690 case VK_STATE_BIND_POINT_DEPTH_STENCIL:
2691 cmd_buffer->ds_state = (struct anv_dynamic_ds_state *) dynamicState;
2692 cmd_buffer->dirty |= ANV_CMD_BUFFER_DS_DIRTY;
2693 break;
2694 default:
2695 break;
2696 };
2697 }
2698
2699 static struct anv_state
2700 anv_cmd_buffer_alloc_surface_state(struct anv_cmd_buffer *cmd_buffer,
2701 uint32_t size, uint32_t alignment)
2702 {
2703 struct anv_state state;
2704
2705 state.offset = ALIGN_U32(cmd_buffer->surface_next, alignment);
2706 if (state.offset + size > cmd_buffer->surface_batch_bo->bo.size)
2707 return (struct anv_state) { 0 };
2708
2709 state.map = cmd_buffer->surface_batch_bo->bo.map + state.offset;
2710 state.alloc_size = size;
2711 cmd_buffer->surface_next = state.offset + size;
2712
2713 assert(state.offset + size <= cmd_buffer->surface_batch_bo->bo.size);
2714
2715 return state;
2716 }
2717
2718 static VkResult
2719 anv_cmd_buffer_new_surface_state_bo(struct anv_cmd_buffer *cmd_buffer)
2720 {
2721 struct anv_batch_bo *new_bbo, *old_bbo = cmd_buffer->surface_batch_bo;
2722
2723 /* Finish off the old buffer */
2724 old_bbo->num_relocs =
2725 cmd_buffer->surface_relocs.num_relocs - old_bbo->first_reloc;
2726 old_bbo->length = cmd_buffer->surface_next;
2727
2728 VkResult result = anv_batch_bo_create(cmd_buffer->device, &new_bbo);
2729 if (result != VK_SUCCESS)
2730 return result;
2731
2732 new_bbo->first_reloc = cmd_buffer->surface_relocs.num_relocs;
2733 cmd_buffer->surface_next = 1;
2734
2735 new_bbo->prev_batch_bo = old_bbo;
2736 cmd_buffer->surface_batch_bo = new_bbo;
2737
2738 /* Re-emit state base addresses so we get the new surface state base
2739 * address before we start emitting binding tables etc.
2740 */
2741 anv_cmd_buffer_emit_state_base_address(cmd_buffer);
2742
2743 /* It seems like just changing the state base addresses isn't enough.
2744 * Invalidating the cache seems to be enough to cause things to
2745 * propagate. However, I'm not 100% sure what we're supposed to do.
2746 */
2747 anv_batch_emit(&cmd_buffer->batch, GEN8_PIPE_CONTROL,
2748 .TextureCacheInvalidationEnable = true);
2749
2750 return VK_SUCCESS;
2751 }
2752
2753 void anv_CmdBindDescriptorSets(
2754 VkCmdBuffer cmdBuffer,
2755 VkPipelineBindPoint pipelineBindPoint,
2756 uint32_t firstSet,
2757 uint32_t setCount,
2758 const VkDescriptorSet* pDescriptorSets,
2759 uint32_t dynamicOffsetCount,
2760 const uint32_t* pDynamicOffsets)
2761 {
2762 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2763 struct anv_pipeline_layout *layout = cmd_buffer->pipeline->layout;
2764 struct anv_descriptor_set *set;
2765 struct anv_descriptor_set_layout *set_layout;
2766
2767 assert(firstSet + setCount < MAX_SETS);
2768
2769 uint32_t dynamic_slot = 0;
2770 for (uint32_t i = 0; i < setCount; i++) {
2771 set = (struct anv_descriptor_set *) pDescriptorSets[i];
2772 set_layout = layout->set[firstSet + i].layout;
2773
2774 cmd_buffer->descriptors[firstSet + i].set = set;
2775
2776 assert(set_layout->num_dynamic_buffers <
2777 ARRAY_SIZE(cmd_buffer->descriptors[0].dynamic_offsets));
2778 memcpy(cmd_buffer->descriptors[firstSet + i].dynamic_offsets,
2779 pDynamicOffsets + dynamic_slot,
2780 set_layout->num_dynamic_buffers * sizeof(*pDynamicOffsets));
2781
2782 cmd_buffer->descriptors_dirty |= set_layout->shader_stages;
2783
2784 dynamic_slot += set_layout->num_dynamic_buffers;
2785 }
2786 }
2787
2788 void anv_CmdBindIndexBuffer(
2789 VkCmdBuffer cmdBuffer,
2790 VkBuffer _buffer,
2791 VkDeviceSize offset,
2792 VkIndexType indexType)
2793 {
2794 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2795 struct anv_buffer *buffer = (struct anv_buffer *) _buffer;
2796
2797 static const uint32_t vk_to_gen_index_type[] = {
2798 [VK_INDEX_TYPE_UINT8] = INDEX_BYTE,
2799 [VK_INDEX_TYPE_UINT16] = INDEX_WORD,
2800 [VK_INDEX_TYPE_UINT32] = INDEX_DWORD,
2801 };
2802
2803 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_INDEX_BUFFER,
2804 .IndexFormat = vk_to_gen_index_type[indexType],
2805 .MemoryObjectControlState = GEN8_MOCS,
2806 .BufferStartingAddress = { buffer->bo, buffer->offset + offset },
2807 .BufferSize = buffer->size - offset);
2808 }
2809
2810 void anv_CmdBindVertexBuffers(
2811 VkCmdBuffer cmdBuffer,
2812 uint32_t startBinding,
2813 uint32_t bindingCount,
2814 const VkBuffer* pBuffers,
2815 const VkDeviceSize* pOffsets)
2816 {
2817 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2818 struct anv_vertex_binding *vb = cmd_buffer->vertex_bindings;
2819
2820 /* We have to defer setting up vertex buffer since we need the buffer
2821 * stride from the pipeline. */
2822
2823 assert(startBinding + bindingCount < MAX_VBS);
2824 for (uint32_t i = 0; i < bindingCount; i++) {
2825 vb[startBinding + i].buffer = (struct anv_buffer *) pBuffers[i];
2826 vb[startBinding + i].offset = pOffsets[i];
2827 cmd_buffer->vb_dirty |= 1 << (startBinding + i);
2828 }
2829 }
2830
2831 static VkResult
2832 cmd_buffer_emit_binding_table(struct anv_cmd_buffer *cmd_buffer,
2833 unsigned stage)
2834 {
2835 struct anv_pipeline_layout *layout = cmd_buffer->pipeline->layout;
2836 uint32_t color_attachments, bias, size;
2837 struct anv_state bt_state;
2838
2839 if (stage == VK_SHADER_STAGE_FRAGMENT) {
2840 bias = MAX_RTS;
2841 color_attachments = cmd_buffer->framebuffer->color_attachment_count;
2842 } else {
2843 bias = 0;
2844 color_attachments = 0;
2845 }
2846
2847 /* This is a little awkward: layout can be NULL but we still have to
2848 * allocate and set a binding table for the PS stage for render
2849 * targets. */
2850 uint32_t surface_count = layout ? layout->stage[stage].surface_count : 0;
2851
2852 if (color_attachments + surface_count == 0)
2853 return VK_SUCCESS;
2854
2855 size = (bias + surface_count) * sizeof(uint32_t);
2856 bt_state = anv_cmd_buffer_alloc_surface_state(cmd_buffer, size, 32);
2857 uint32_t *bt_map = bt_state.map;
2858
2859 if (bt_state.map == NULL)
2860 return VK_ERROR_OUT_OF_DEVICE_MEMORY;
2861
2862 static const uint32_t binding_table_opcodes[] = {
2863 [VK_SHADER_STAGE_VERTEX] = 38,
2864 [VK_SHADER_STAGE_TESS_CONTROL] = 39,
2865 [VK_SHADER_STAGE_TESS_EVALUATION] = 40,
2866 [VK_SHADER_STAGE_GEOMETRY] = 41,
2867 [VK_SHADER_STAGE_FRAGMENT] = 42,
2868 [VK_SHADER_STAGE_COMPUTE] = 0,
2869 };
2870
2871 anv_batch_emit(&cmd_buffer->batch,
2872 GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS,
2873 ._3DCommandSubOpcode = binding_table_opcodes[stage],
2874 .PointertoVSBindingTable = bt_state.offset);
2875
2876 for (uint32_t ca = 0; ca < color_attachments; ca++) {
2877 const struct anv_surface_view *view =
2878 cmd_buffer->framebuffer->color_attachments[ca];
2879
2880 struct anv_state state =
2881 anv_cmd_buffer_alloc_surface_state(cmd_buffer, 64, 64);
2882
2883 if (state.map == NULL)
2884 return VK_ERROR_OUT_OF_DEVICE_MEMORY;
2885
2886 memcpy(state.map, view->surface_state.map, 64);
2887
2888 /* The address goes in dwords 8 and 9 of the SURFACE_STATE */
2889 *(uint64_t *)(state.map + 8 * 4) =
2890 anv_reloc_list_add(&cmd_buffer->surface_relocs,
2891 cmd_buffer->device,
2892 state.offset + 8 * 4,
2893 view->bo, view->offset);
2894
2895 bt_map[ca] = state.offset;
2896 }
2897
2898 if (layout == NULL)
2899 return VK_SUCCESS;
2900
2901 for (uint32_t set = 0; set < layout->num_sets; set++) {
2902 struct anv_descriptor_set_binding *d = &cmd_buffer->descriptors[set];
2903 struct anv_descriptor_set_layout *set_layout = layout->set[set].layout;
2904 struct anv_descriptor_slot *surface_slots =
2905 set_layout->stage[stage].surface_start;
2906
2907 uint32_t start = bias + layout->set[set].surface_start[stage];
2908
2909 for (uint32_t b = 0; b < set_layout->stage[stage].surface_count; b++) {
2910 struct anv_surface_view *view =
2911 d->set->descriptors[surface_slots[b].index].view;
2912
2913 if (!view)
2914 continue;
2915
2916 struct anv_state state =
2917 anv_cmd_buffer_alloc_surface_state(cmd_buffer, 64, 64);
2918
2919 if (state.map == NULL)
2920 return VK_ERROR_OUT_OF_DEVICE_MEMORY;
2921
2922 uint32_t offset;
2923 if (surface_slots[b].dynamic_slot >= 0) {
2924 uint32_t dynamic_offset =
2925 d->dynamic_offsets[surface_slots[b].dynamic_slot];
2926
2927 offset = view->offset + dynamic_offset;
2928 fill_buffer_surface_state(state.map, view->format, offset,
2929 view->range - dynamic_offset);
2930 } else {
2931 offset = view->offset;
2932 memcpy(state.map, view->surface_state.map, 64);
2933 }
2934
2935 /* The address goes in dwords 8 and 9 of the SURFACE_STATE */
2936 *(uint64_t *)(state.map + 8 * 4) =
2937 anv_reloc_list_add(&cmd_buffer->surface_relocs,
2938 cmd_buffer->device,
2939 state.offset + 8 * 4,
2940 view->bo, offset);
2941
2942 bt_map[start + b] = state.offset;
2943 }
2944 }
2945
2946 return VK_SUCCESS;
2947 }
2948
2949 static VkResult
2950 cmd_buffer_emit_samplers(struct anv_cmd_buffer *cmd_buffer, unsigned stage)
2951 {
2952 struct anv_pipeline_layout *layout = cmd_buffer->pipeline->layout;
2953 struct anv_state state;
2954
2955 if (!layout)
2956 return VK_SUCCESS;
2957
2958 uint32_t sampler_count = layout->stage[stage].sampler_count;
2959
2960 if (sampler_count == 0)
2961 return VK_SUCCESS;
2962
2963 uint32_t size = sampler_count * 16;
2964 state = anv_state_stream_alloc(&cmd_buffer->dynamic_state_stream, size, 32);
2965
2966 if (state.map == NULL)
2967 return VK_ERROR_OUT_OF_DEVICE_MEMORY;
2968
2969 static const uint32_t sampler_state_opcodes[] = {
2970 [VK_SHADER_STAGE_VERTEX] = 43,
2971 [VK_SHADER_STAGE_TESS_CONTROL] = 44, /* HS */
2972 [VK_SHADER_STAGE_TESS_EVALUATION] = 45, /* DS */
2973 [VK_SHADER_STAGE_GEOMETRY] = 46,
2974 [VK_SHADER_STAGE_FRAGMENT] = 47,
2975 [VK_SHADER_STAGE_COMPUTE] = 0,
2976 };
2977
2978 anv_batch_emit(&cmd_buffer->batch,
2979 GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS,
2980 ._3DCommandSubOpcode = sampler_state_opcodes[stage],
2981 .PointertoVSSamplerState = state.offset);
2982
2983 for (uint32_t set = 0; set < layout->num_sets; set++) {
2984 struct anv_descriptor_set_binding *d = &cmd_buffer->descriptors[set];
2985 struct anv_descriptor_set_layout *set_layout = layout->set[set].layout;
2986 struct anv_descriptor_slot *sampler_slots =
2987 set_layout->stage[stage].sampler_start;
2988
2989 uint32_t start = layout->set[set].sampler_start[stage];
2990
2991 for (uint32_t b = 0; b < set_layout->stage[stage].sampler_count; b++) {
2992 struct anv_sampler *sampler =
2993 d->set->descriptors[sampler_slots[b].index].sampler;
2994
2995 if (!sampler)
2996 continue;
2997
2998 memcpy(state.map + (start + b) * 16,
2999 sampler->state, sizeof(sampler->state));
3000 }
3001 }
3002
3003 return VK_SUCCESS;
3004 }
3005
3006 static void
3007 flush_descriptor_sets(struct anv_cmd_buffer *cmd_buffer)
3008 {
3009 uint32_t s, dirty = cmd_buffer->descriptors_dirty &
3010 cmd_buffer->pipeline->active_stages;
3011
3012 VkResult result;
3013 for_each_bit(s, dirty) {
3014 result = cmd_buffer_emit_binding_table(cmd_buffer, s);
3015 if (result != VK_SUCCESS)
3016 break;
3017
3018 result = cmd_buffer_emit_samplers(cmd_buffer, s);
3019 if (result != VK_SUCCESS)
3020 break;
3021 }
3022
3023 if (result != VK_SUCCESS) {
3024 assert(result == VK_ERROR_OUT_OF_DEVICE_MEMORY);
3025
3026 result = anv_cmd_buffer_new_surface_state_bo(cmd_buffer);
3027 assert(result == VK_SUCCESS);
3028
3029 /* Re-emit all active binding tables */
3030 for_each_bit(s, cmd_buffer->pipeline->active_stages) {
3031 result = cmd_buffer_emit_binding_table(cmd_buffer, s);
3032 result = cmd_buffer_emit_samplers(cmd_buffer, s);
3033 }
3034
3035 /* It had better succeed this time */
3036 assert(result == VK_SUCCESS);
3037 }
3038
3039 cmd_buffer->descriptors_dirty &= ~cmd_buffer->pipeline->active_stages;
3040 }
3041
3042 static struct anv_state
3043 anv_cmd_buffer_emit_dynamic(struct anv_cmd_buffer *cmd_buffer,
3044 uint32_t *a, uint32_t dwords, uint32_t alignment)
3045 {
3046 struct anv_state state;
3047
3048 state = anv_state_stream_alloc(&cmd_buffer->dynamic_state_stream,
3049 dwords * 4, alignment);
3050 memcpy(state.map, a, dwords * 4);
3051
3052 return state;
3053 }
3054
3055 static struct anv_state
3056 anv_cmd_buffer_merge_dynamic(struct anv_cmd_buffer *cmd_buffer,
3057 uint32_t *a, uint32_t *b,
3058 uint32_t dwords, uint32_t alignment)
3059 {
3060 struct anv_state state;
3061 uint32_t *p;
3062
3063 state = anv_state_stream_alloc(&cmd_buffer->dynamic_state_stream,
3064 dwords * 4, alignment);
3065 p = state.map;
3066 for (uint32_t i = 0; i < dwords; i++)
3067 p[i] = a[i] | b[i];
3068
3069 return state;
3070 }
3071
3072 static void
3073 anv_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer)
3074 {
3075 struct anv_pipeline *pipeline = cmd_buffer->pipeline;
3076 uint32_t *p;
3077
3078 uint32_t vb_emit = cmd_buffer->vb_dirty & pipeline->vb_used;
3079
3080 if (vb_emit) {
3081 const uint32_t num_buffers = __builtin_popcount(vb_emit);
3082 const uint32_t num_dwords = 1 + num_buffers * 4;
3083
3084 p = anv_batch_emitn(&cmd_buffer->batch, num_dwords,
3085 GEN8_3DSTATE_VERTEX_BUFFERS);
3086 uint32_t vb, i = 0;
3087 for_each_bit(vb, vb_emit) {
3088 struct anv_buffer *buffer = cmd_buffer->vertex_bindings[vb].buffer;
3089 uint32_t offset = cmd_buffer->vertex_bindings[vb].offset;
3090
3091 struct GEN8_VERTEX_BUFFER_STATE state = {
3092 .VertexBufferIndex = vb,
3093 .MemoryObjectControlState = GEN8_MOCS,
3094 .AddressModifyEnable = true,
3095 .BufferPitch = pipeline->binding_stride[vb],
3096 .BufferStartingAddress = { buffer->bo, buffer->offset + offset },
3097 .BufferSize = buffer->size - offset
3098 };
3099
3100 GEN8_VERTEX_BUFFER_STATE_pack(&cmd_buffer->batch, &p[1 + i * 4], &state);
3101 i++;
3102 }
3103 }
3104
3105 if (cmd_buffer->dirty & ANV_CMD_BUFFER_PIPELINE_DIRTY)
3106 anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch);
3107
3108 if (cmd_buffer->descriptors_dirty)
3109 flush_descriptor_sets(cmd_buffer);
3110
3111 if (cmd_buffer->dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_RS_DIRTY)) {
3112 anv_batch_emit_merge(&cmd_buffer->batch,
3113 cmd_buffer->rs_state->state_sf, pipeline->state_sf);
3114 anv_batch_emit_merge(&cmd_buffer->batch,
3115 cmd_buffer->rs_state->state_raster, pipeline->state_raster);
3116 }
3117
3118 if (cmd_buffer->ds_state &&
3119 (cmd_buffer->dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_DS_DIRTY)))
3120 anv_batch_emit_merge(&cmd_buffer->batch,
3121 cmd_buffer->ds_state->state_wm_depth_stencil,
3122 pipeline->state_wm_depth_stencil);
3123
3124 if (cmd_buffer->dirty & (ANV_CMD_BUFFER_CB_DIRTY | ANV_CMD_BUFFER_DS_DIRTY)) {
3125 struct anv_state state;
3126 if (cmd_buffer->ds_state == NULL)
3127 state = anv_cmd_buffer_emit_dynamic(cmd_buffer,
3128 cmd_buffer->cb_state->state_color_calc,
3129 GEN8_COLOR_CALC_STATE_length, 64);
3130 else if (cmd_buffer->cb_state == NULL)
3131 state = anv_cmd_buffer_emit_dynamic(cmd_buffer,
3132 cmd_buffer->ds_state->state_color_calc,
3133 GEN8_COLOR_CALC_STATE_length, 64);
3134 else
3135 state = anv_cmd_buffer_merge_dynamic(cmd_buffer,
3136 cmd_buffer->ds_state->state_color_calc,
3137 cmd_buffer->cb_state->state_color_calc,
3138 GEN8_COLOR_CALC_STATE_length, 64);
3139
3140 anv_batch_emit(&cmd_buffer->batch,
3141 GEN8_3DSTATE_CC_STATE_POINTERS,
3142 .ColorCalcStatePointer = state.offset,
3143 .ColorCalcStatePointerValid = true);
3144 }
3145
3146 cmd_buffer->vb_dirty &= ~vb_emit;
3147 cmd_buffer->dirty = 0;
3148 }
3149
3150 void anv_CmdDraw(
3151 VkCmdBuffer cmdBuffer,
3152 uint32_t firstVertex,
3153 uint32_t vertexCount,
3154 uint32_t firstInstance,
3155 uint32_t instanceCount)
3156 {
3157 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
3158
3159 anv_cmd_buffer_flush_state(cmd_buffer);
3160
3161 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
3162 .VertexAccessType = SEQUENTIAL,
3163 .VertexCountPerInstance = vertexCount,
3164 .StartVertexLocation = firstVertex,
3165 .InstanceCount = instanceCount,
3166 .StartInstanceLocation = firstInstance,
3167 .BaseVertexLocation = 0);
3168 }
3169
3170 void anv_CmdDrawIndexed(
3171 VkCmdBuffer cmdBuffer,
3172 uint32_t firstIndex,
3173 uint32_t indexCount,
3174 int32_t vertexOffset,
3175 uint32_t firstInstance,
3176 uint32_t instanceCount)
3177 {
3178 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
3179
3180 anv_cmd_buffer_flush_state(cmd_buffer);
3181
3182 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
3183 .VertexAccessType = RANDOM,
3184 .VertexCountPerInstance = indexCount,
3185 .StartVertexLocation = firstIndex,
3186 .InstanceCount = instanceCount,
3187 .StartInstanceLocation = firstInstance,
3188 .BaseVertexLocation = vertexOffset);
3189 }
3190
3191 static void
3192 anv_batch_lrm(struct anv_batch *batch,
3193 uint32_t reg, struct anv_bo *bo, uint32_t offset)
3194 {
3195 anv_batch_emit(batch, GEN8_MI_LOAD_REGISTER_MEM,
3196 .RegisterAddress = reg,
3197 .MemoryAddress = { bo, offset });
3198 }
3199
3200 static void
3201 anv_batch_lri(struct anv_batch *batch, uint32_t reg, uint32_t imm)
3202 {
3203 anv_batch_emit(batch, GEN8_MI_LOAD_REGISTER_IMM,
3204 .RegisterOffset = reg,
3205 .DataDWord = imm);
3206 }
3207
3208 /* Auto-Draw / Indirect Registers */
3209 #define GEN7_3DPRIM_END_OFFSET 0x2420
3210 #define GEN7_3DPRIM_START_VERTEX 0x2430
3211 #define GEN7_3DPRIM_VERTEX_COUNT 0x2434
3212 #define GEN7_3DPRIM_INSTANCE_COUNT 0x2438
3213 #define GEN7_3DPRIM_START_INSTANCE 0x243C
3214 #define GEN7_3DPRIM_BASE_VERTEX 0x2440
3215
3216 void anv_CmdDrawIndirect(
3217 VkCmdBuffer cmdBuffer,
3218 VkBuffer _buffer,
3219 VkDeviceSize offset,
3220 uint32_t count,
3221 uint32_t stride)
3222 {
3223 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
3224 struct anv_buffer *buffer = (struct anv_buffer *) _buffer;
3225 struct anv_bo *bo = buffer->bo;
3226 uint32_t bo_offset = buffer->offset + offset;
3227
3228 anv_cmd_buffer_flush_state(cmd_buffer);
3229
3230 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset);
3231 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4);
3232 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8);
3233 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 12);
3234 anv_batch_lri(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, 0);
3235
3236 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
3237 .IndirectParameterEnable = true,
3238 .VertexAccessType = SEQUENTIAL);
3239 }
3240
3241 void anv_CmdDrawIndexedIndirect(
3242 VkCmdBuffer cmdBuffer,
3243 VkBuffer _buffer,
3244 VkDeviceSize offset,
3245 uint32_t count,
3246 uint32_t stride)
3247 {
3248 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
3249 struct anv_buffer *buffer = (struct anv_buffer *) _buffer;
3250 struct anv_bo *bo = buffer->bo;
3251 uint32_t bo_offset = buffer->offset + offset;
3252
3253 anv_cmd_buffer_flush_state(cmd_buffer);
3254
3255 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset);
3256 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4);
3257 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8);
3258 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, bo, bo_offset + 12);
3259 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 16);
3260
3261 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
3262 .IndirectParameterEnable = true,
3263 .VertexAccessType = RANDOM);
3264 }
3265
3266 void anv_CmdDispatch(
3267 VkCmdBuffer cmdBuffer,
3268 uint32_t x,
3269 uint32_t y,
3270 uint32_t z)
3271 {
3272 stub();
3273 }
3274
3275 void anv_CmdDispatchIndirect(
3276 VkCmdBuffer cmdBuffer,
3277 VkBuffer buffer,
3278 VkDeviceSize offset)
3279 {
3280 stub();
3281 }
3282
3283 void anv_CmdSetEvent(
3284 VkCmdBuffer cmdBuffer,
3285 VkEvent event,
3286 VkPipeEvent pipeEvent)
3287 {
3288 stub();
3289 }
3290
3291 void anv_CmdResetEvent(
3292 VkCmdBuffer cmdBuffer,
3293 VkEvent event,
3294 VkPipeEvent pipeEvent)
3295 {
3296 stub();
3297 }
3298
3299 void anv_CmdWaitEvents(
3300 VkCmdBuffer cmdBuffer,
3301 VkWaitEvent waitEvent,
3302 uint32_t eventCount,
3303 const VkEvent* pEvents,
3304 uint32_t memBarrierCount,
3305 const void** ppMemBarriers)
3306 {
3307 stub();
3308 }
3309
3310 void anv_CmdPipelineBarrier(
3311 VkCmdBuffer cmdBuffer,
3312 VkWaitEvent waitEvent,
3313 uint32_t pipeEventCount,
3314 const VkPipeEvent* pPipeEvents,
3315 uint32_t memBarrierCount,
3316 const void** ppMemBarriers)
3317 {
3318 stub();
3319 }
3320
3321 void anv_CmdInitAtomicCounters(
3322 VkCmdBuffer cmdBuffer,
3323 VkPipelineBindPoint pipelineBindPoint,
3324 uint32_t startCounter,
3325 uint32_t counterCount,
3326 const uint32_t* pData)
3327 {
3328 stub();
3329 }
3330
3331 void anv_CmdLoadAtomicCounters(
3332 VkCmdBuffer cmdBuffer,
3333 VkPipelineBindPoint pipelineBindPoint,
3334 uint32_t startCounter,
3335 uint32_t counterCount,
3336 VkBuffer srcBuffer,
3337 VkDeviceSize srcOffset)
3338 {
3339 stub();
3340 }
3341
3342 void anv_CmdSaveAtomicCounters(
3343 VkCmdBuffer cmdBuffer,
3344 VkPipelineBindPoint pipelineBindPoint,
3345 uint32_t startCounter,
3346 uint32_t counterCount,
3347 VkBuffer destBuffer,
3348 VkDeviceSize destOffset)
3349 {
3350 stub();
3351 }
3352
3353 static void
3354 anv_framebuffer_destroy(struct anv_device *device,
3355 struct anv_object *object,
3356 VkObjectType obj_type)
3357 {
3358 struct anv_framebuffer *fb = (struct anv_framebuffer *)object;
3359
3360 assert(obj_type == VK_OBJECT_TYPE_FRAMEBUFFER);
3361
3362 anv_DestroyObject((VkDevice) device,
3363 VK_OBJECT_TYPE_DYNAMIC_VP_STATE,
3364 fb->vp_state);
3365
3366 anv_device_free(device, fb);
3367 }
3368
3369 VkResult anv_CreateFramebuffer(
3370 VkDevice _device,
3371 const VkFramebufferCreateInfo* pCreateInfo,
3372 VkFramebuffer* pFramebuffer)
3373 {
3374 struct anv_device *device = (struct anv_device *) _device;
3375 struct anv_framebuffer *framebuffer;
3376
3377 static const struct anv_depth_stencil_view null_view =
3378 { .depth_format = D16_UNORM, .depth_stride = 0, .stencil_stride = 0 };
3379
3380 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
3381
3382 framebuffer = anv_device_alloc(device, sizeof(*framebuffer), 8,
3383 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
3384 if (framebuffer == NULL)
3385 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
3386
3387 framebuffer->base.destructor = anv_framebuffer_destroy;
3388
3389 framebuffer->color_attachment_count = pCreateInfo->colorAttachmentCount;
3390 for (uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; i++) {
3391 framebuffer->color_attachments[i] =
3392 (struct anv_surface_view *) pCreateInfo->pColorAttachments[i].view;
3393 }
3394
3395 if (pCreateInfo->pDepthStencilAttachment) {
3396 framebuffer->depth_stencil =
3397 (struct anv_depth_stencil_view *) pCreateInfo->pDepthStencilAttachment->view;
3398 } else {
3399 framebuffer->depth_stencil = &null_view;
3400 }
3401
3402 framebuffer->sample_count = pCreateInfo->sampleCount;
3403 framebuffer->width = pCreateInfo->width;
3404 framebuffer->height = pCreateInfo->height;
3405 framebuffer->layers = pCreateInfo->layers;
3406
3407 vkCreateDynamicViewportState((VkDevice) device,
3408 &(VkDynamicVpStateCreateInfo) {
3409 .sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO,
3410 .viewportAndScissorCount = 1,
3411 .pViewports = (VkViewport[]) {
3412 {
3413 .originX = 0,
3414 .originY = 0,
3415 .width = pCreateInfo->width,
3416 .height = pCreateInfo->height,
3417 .minDepth = 0,
3418 .maxDepth = 1
3419 },
3420 },
3421 .pScissors = (VkRect[]) {
3422 { { 0, 0 },
3423 { pCreateInfo->width, pCreateInfo->height } },
3424 }
3425 },
3426 &framebuffer->vp_state);
3427
3428 *pFramebuffer = (VkFramebuffer) framebuffer;
3429
3430 return VK_SUCCESS;
3431 }
3432
3433 VkResult anv_CreateRenderPass(
3434 VkDevice _device,
3435 const VkRenderPassCreateInfo* pCreateInfo,
3436 VkRenderPass* pRenderPass)
3437 {
3438 struct anv_device *device = (struct anv_device *) _device;
3439 struct anv_render_pass *pass;
3440 size_t size;
3441
3442 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
3443
3444 size = sizeof(*pass) +
3445 pCreateInfo->layers * sizeof(struct anv_render_pass_layer);
3446 pass = anv_device_alloc(device, size, 8,
3447 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
3448 if (pass == NULL)
3449 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
3450
3451 pass->render_area = pCreateInfo->renderArea;
3452
3453 pass->num_layers = pCreateInfo->layers;
3454
3455 pass->num_clear_layers = 0;
3456 for (uint32_t i = 0; i < pCreateInfo->layers; i++) {
3457 pass->layers[i].color_load_op = pCreateInfo->pColorLoadOps[i];
3458 pass->layers[i].clear_color = pCreateInfo->pColorLoadClearValues[i];
3459 if (pass->layers[i].color_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR)
3460 pass->num_clear_layers++;
3461 }
3462
3463 *pRenderPass = (VkRenderPass) pass;
3464
3465 return VK_SUCCESS;
3466 }
3467
3468 static void
3469 anv_cmd_buffer_emit_depth_stencil(struct anv_cmd_buffer *cmd_buffer,
3470 struct anv_render_pass *pass)
3471 {
3472 const struct anv_depth_stencil_view *view =
3473 cmd_buffer->framebuffer->depth_stencil;
3474
3475 /* FIXME: Implement the PMA stall W/A */
3476
3477 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DEPTH_BUFFER,
3478 .SurfaceType = SURFTYPE_2D,
3479 .DepthWriteEnable = view->depth_stride > 0,
3480 .StencilWriteEnable = view->stencil_stride > 0,
3481 .HierarchicalDepthBufferEnable = false,
3482 .SurfaceFormat = view->depth_format,
3483 .SurfacePitch = view->depth_stride > 0 ? view->depth_stride - 1 : 0,
3484 .SurfaceBaseAddress = { view->bo, view->depth_offset },
3485 .Height = pass->render_area.extent.height - 1,
3486 .Width = pass->render_area.extent.width - 1,
3487 .LOD = 0,
3488 .Depth = 1 - 1,
3489 .MinimumArrayElement = 0,
3490 .DepthBufferObjectControlState = GEN8_MOCS,
3491 .RenderTargetViewExtent = 1 - 1,
3492 .SurfaceQPitch = 0);
3493
3494 /* Disable hierarchial depth buffers. */
3495 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_HIER_DEPTH_BUFFER);
3496
3497 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_STENCIL_BUFFER,
3498 .StencilBufferEnable = view->stencil_stride > 0,
3499 .StencilBufferObjectControlState = GEN8_MOCS,
3500 .SurfacePitch = view->stencil_stride > 0 ? view->stencil_stride - 1 : 0,
3501 .SurfaceBaseAddress = { view->bo, view->stencil_offset },
3502 .SurfaceQPitch = 0);
3503
3504 /* Clear the clear params. */
3505 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_CLEAR_PARAMS);
3506 }
3507
3508 void anv_CmdBeginRenderPass(
3509 VkCmdBuffer cmdBuffer,
3510 const VkRenderPassBegin* pRenderPassBegin)
3511 {
3512 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
3513 struct anv_render_pass *pass = (struct anv_render_pass *) pRenderPassBegin->renderPass;
3514 struct anv_framebuffer *framebuffer =
3515 (struct anv_framebuffer *) pRenderPassBegin->framebuffer;
3516
3517 cmd_buffer->framebuffer = framebuffer;
3518
3519 cmd_buffer->descriptors_dirty |= VK_SHADER_STAGE_FRAGMENT_BIT;
3520
3521 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DRAWING_RECTANGLE,
3522 .ClippedDrawingRectangleYMin = pass->render_area.offset.y,
3523 .ClippedDrawingRectangleXMin = pass->render_area.offset.x,
3524 .ClippedDrawingRectangleYMax =
3525 pass->render_area.offset.y + pass->render_area.extent.height - 1,
3526 .ClippedDrawingRectangleXMax =
3527 pass->render_area.offset.x + pass->render_area.extent.width - 1,
3528 .DrawingRectangleOriginY = 0,
3529 .DrawingRectangleOriginX = 0);
3530
3531 anv_cmd_buffer_emit_depth_stencil(cmd_buffer, pass);
3532
3533 anv_cmd_buffer_clear(cmd_buffer, pass);
3534 }
3535
3536 void anv_CmdEndRenderPass(
3537 VkCmdBuffer cmdBuffer,
3538 VkRenderPass renderPass)
3539 {
3540 /* Emit a flushing pipe control at the end of a pass. This is kind of a
3541 * hack but it ensures that render targets always actually get written.
3542 * Eventually, we should do flushing based on image format transitions
3543 * or something of that nature.
3544 */
3545 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
3546 anv_batch_emit(&cmd_buffer->batch, GEN8_PIPE_CONTROL,
3547 .PostSyncOperation = NoWrite,
3548 .RenderTargetCacheFlushEnable = true,
3549 .InstructionCacheInvalidateEnable = true,
3550 .DepthCacheFlushEnable = true,
3551 .VFCacheInvalidationEnable = true,
3552 .TextureCacheInvalidationEnable = true,
3553 .CommandStreamerStallEnable = true);
3554 }
3555
3556 void vkCmdDbgMarkerBegin(
3557 VkCmdBuffer cmdBuffer,
3558 const char* pMarker)
3559 __attribute__ ((visibility ("default")));
3560
3561 void vkCmdDbgMarkerEnd(
3562 VkCmdBuffer cmdBuffer)
3563 __attribute__ ((visibility ("default")));
3564
3565 VkResult vkDbgSetObjectTag(
3566 VkDevice device,
3567 VkObject object,
3568 size_t tagSize,
3569 const void* pTag)
3570 __attribute__ ((visibility ("default")));
3571
3572
3573 void vkCmdDbgMarkerBegin(
3574 VkCmdBuffer cmdBuffer,
3575 const char* pMarker)
3576 {
3577 }
3578
3579 void vkCmdDbgMarkerEnd(
3580 VkCmdBuffer cmdBuffer)
3581 {
3582 }
3583
3584 VkResult vkDbgSetObjectTag(
3585 VkDevice device,
3586 VkObject object,
3587 size_t tagSize,
3588 const void* pTag)
3589 {
3590 return VK_SUCCESS;
3591 }