projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
vk/device: Simplify surface_count calculation
[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 VKAPI vkCreateInstance(
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 if (result == VK_SUCCESS)
146 instance->physicalDeviceCount++;
147
148 *pInstance = (VkInstance) instance;
149
150 return VK_SUCCESS;
151 }
152
153 VkResult VKAPI vkDestroyInstance(
154 VkInstance _instance)
155 {
156 struct anv_instance *instance = (struct anv_instance *) _instance;
157
158 instance->pfnFree(instance->pAllocUserData, instance);
159
160 return VK_SUCCESS;
161 }
162
163 VkResult VKAPI vkEnumeratePhysicalDevices(
164 VkInstance _instance,
165 uint32_t* pPhysicalDeviceCount,
166 VkPhysicalDevice* pPhysicalDevices)
167 {
168 struct anv_instance *instance = (struct anv_instance *) _instance;
169
170 if (*pPhysicalDeviceCount >= 1)
171 pPhysicalDevices[0] = (VkPhysicalDevice) &instance->physicalDevice;
172 *pPhysicalDeviceCount = instance->physicalDeviceCount;
173
174 return VK_SUCCESS;
175 }
176
177 VkResult VKAPI vkGetPhysicalDeviceInfo(
178 VkPhysicalDevice physicalDevice,
179 VkPhysicalDeviceInfoType infoType,
180 size_t* pDataSize,
181 void* pData)
182 {
183 struct anv_physical_device *device = (struct anv_physical_device *) physicalDevice;
184 VkPhysicalDeviceProperties *properties;
185 VkPhysicalDevicePerformance *performance;
186 VkPhysicalDeviceQueueProperties *queue_properties;
187 VkPhysicalDeviceMemoryProperties *memory_properties;
188 uint64_t ns_per_tick = 80;
189
190 switch (infoType) {
191 case VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES:
192 properties = pData;
193 assert(*pDataSize >= sizeof(*properties));
194 *pDataSize = sizeof(*properties); /* Assuming we have to return the size of our struct. */
195
196 properties->apiVersion = 1;
197 properties->driverVersion = 1;
198 properties->vendorId = 0x8086;
199 properties->deviceId = device->chipset_id;
200 properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU;
201 strcpy(properties->deviceName, device->name);
202 properties->maxInlineMemoryUpdateSize = 0;
203 properties->maxBoundDescriptorSets = 0;
204 properties->maxThreadGroupSize = 0;
205 properties->timestampFrequency = 1000 * 1000 * 1000 / ns_per_tick;
206 properties->multiColorAttachmentClears = 0;
207 properties->maxDescriptorSets = 2;
208 properties->maxViewports = 16;
209 properties->maxColorAttachments = 8;
210 return VK_SUCCESS;
211
212 case VK_PHYSICAL_DEVICE_INFO_TYPE_PERFORMANCE:
213 performance = pData;
214 assert(*pDataSize >= sizeof(*performance));
215 *pDataSize = sizeof(*performance); /* Assuming we have to return the size of our struct. */
216
217 performance->maxDeviceClock = 1.0;
218 performance->aluPerClock = 1.0;
219 performance->texPerClock = 1.0;
220 performance->primsPerClock = 1.0;
221 performance->pixelsPerClock = 1.0;
222 return VK_SUCCESS;
223
224 case VK_PHYSICAL_DEVICE_INFO_TYPE_QUEUE_PROPERTIES:
225 queue_properties = pData;
226 assert(*pDataSize >= sizeof(*queue_properties));
227 *pDataSize = sizeof(*queue_properties);
228
229 queue_properties->queueFlags = 0;
230 queue_properties->queueCount = 1;
231 queue_properties->maxAtomicCounters = 0;
232 queue_properties->supportsTimestamps = 0;
233 queue_properties->maxMemReferences = 0;
234 return VK_SUCCESS;
235
236 case VK_PHYSICAL_DEVICE_INFO_TYPE_MEMORY_PROPERTIES:
237 memory_properties = pData;
238 assert(*pDataSize >= sizeof(*memory_properties));
239 *pDataSize = sizeof(*memory_properties);
240
241 memory_properties->supportsMigration = false;
242 memory_properties->supportsPinning = false;
243 return VK_SUCCESS;
244
245 default:
246 return VK_UNSUPPORTED;
247 }
248
249 }
250
251 void * vkGetProcAddr(
252 VkPhysicalDevice physicalDevice,
253 const char* pName)
254 {
255 return NULL;
256 }
257
258 static void
259 parse_debug_flags(struct anv_device *device)
260 {
261 const char *debug, *p, *end;
262
263 debug = getenv("INTEL_DEBUG");
264 device->dump_aub = false;
265 if (debug) {
266 for (p = debug; *p; p = end + 1) {
267 end = strchrnul(p, ',');
268 if (end - p == 3 && memcmp(p, "aub", 3) == 0)
269 device->dump_aub = true;
270 if (end - p == 5 && memcmp(p, "no_hw", 5) == 0)
271 device->no_hw = true;
272 if (*end == '\0')
273 break;
274 }
275 }
276 }
277
278 VkResult VKAPI vkCreateDevice(
279 VkPhysicalDevice _physicalDevice,
280 const VkDeviceCreateInfo* pCreateInfo,
281 VkDevice* pDevice)
282 {
283 struct anv_physical_device *physicalDevice =
284 (struct anv_physical_device *) _physicalDevice;
285 struct anv_instance *instance = physicalDevice->instance;
286 struct anv_device *device;
287
288 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
289
290 device = instance->pfnAlloc(instance->pAllocUserData,
291 sizeof(*device), 8,
292 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
293 if (!device)
294 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
295
296 device->no_hw = physicalDevice->no_hw;
297 parse_debug_flags(device);
298
299 device->instance = physicalDevice->instance;
300 device->fd = open("/dev/dri/renderD128", O_RDWR | O_CLOEXEC);
301 if (device->fd == -1)
302 goto fail_device;
303
304 device->context_id = anv_gem_create_context(device);
305 if (device->context_id == -1)
306 goto fail_fd;
307
308 anv_block_pool_init(&device->dynamic_state_block_pool, device, 2048);
309
310 anv_state_pool_init(&device->dynamic_state_pool,
311 &device->dynamic_state_block_pool);
312
313 anv_block_pool_init(&device->instruction_block_pool, device, 2048);
314 anv_block_pool_init(&device->surface_state_block_pool, device, 2048);
315
316 anv_state_pool_init(&device->surface_state_pool,
317 &device->surface_state_block_pool);
318
319 device->compiler = anv_compiler_create(device->fd);
320 device->aub_writer = NULL;
321
322 device->info = *physicalDevice->info;
323
324 pthread_mutex_init(&device->mutex, NULL);
325
326 anv_device_init_meta(device);
327
328 *pDevice = (VkDevice) device;
329
330 return VK_SUCCESS;
331
332 fail_fd:
333 close(device->fd);
334 fail_device:
335 anv_device_free(device, device);
336
337 return vk_error(VK_ERROR_UNAVAILABLE);
338 }
339
340 VkResult VKAPI vkDestroyDevice(
341 VkDevice _device)
342 {
343 struct anv_device *device = (struct anv_device *) _device;
344
345 anv_compiler_destroy(device->compiler);
346
347 anv_block_pool_finish(&device->dynamic_state_block_pool);
348 anv_block_pool_finish(&device->instruction_block_pool);
349 anv_block_pool_finish(&device->surface_state_block_pool);
350
351 close(device->fd);
352
353 if (device->aub_writer)
354 anv_aub_writer_destroy(device->aub_writer);
355
356 anv_device_free(device, device);
357
358 return VK_SUCCESS;
359 }
360
361 VkResult VKAPI vkGetGlobalExtensionInfo(
362 VkExtensionInfoType infoType,
363 uint32_t extensionIndex,
364 size_t* pDataSize,
365 void* pData)
366 {
367 uint32_t *count;
368
369 switch (infoType) {
370 case VK_EXTENSION_INFO_TYPE_COUNT:
371 count = pData;
372 assert(*pDataSize == 4);
373 *count = 0;
374 return VK_SUCCESS;
375
376 case VK_EXTENSION_INFO_TYPE_PROPERTIES:
377 return vk_error(VK_ERROR_INVALID_EXTENSION);
378
379 default:
380 return VK_UNSUPPORTED;
381 }
382 }
383
384 VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
385 VkPhysicalDevice physicalDevice,
386 VkExtensionInfoType infoType,
387 uint32_t extensionIndex,
388 size_t* pDataSize,
389 void* pData)
390 {
391 uint32_t *count;
392
393 switch (infoType) {
394 case VK_EXTENSION_INFO_TYPE_COUNT:
395 count = pData;
396 assert(*pDataSize == 4);
397 *count = 0;
398 return VK_SUCCESS;
399
400 case VK_EXTENSION_INFO_TYPE_PROPERTIES:
401 return vk_error(VK_ERROR_INVALID_EXTENSION);
402
403 default:
404 return VK_UNSUPPORTED;
405 }
406 }
407
408 VkResult VKAPI vkEnumerateLayers(
409 VkPhysicalDevice physicalDevice,
410 size_t maxStringSize,
411 size_t* pLayerCount,
412 char* const* pOutLayers,
413 void* pReserved)
414 {
415 *pLayerCount = 0;
416
417 return VK_SUCCESS;
418 }
419
420 VkResult VKAPI vkGetDeviceQueue(
421 VkDevice _device,
422 uint32_t queueNodeIndex,
423 uint32_t queueIndex,
424 VkQueue* pQueue)
425 {
426 struct anv_device *device = (struct anv_device *) _device;
427 struct anv_queue *queue;
428
429 /* FIXME: Should allocate these at device create time. */
430
431 queue = anv_device_alloc(device, sizeof(*queue), 8,
432 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
433 if (queue == NULL)
434 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
435
436 queue->device = device;
437 queue->pool = &device->surface_state_pool;
438
439 queue->completed_serial = anv_state_pool_alloc(queue->pool, 4, 4);
440 *(uint32_t *)queue->completed_serial.map = 0;
441 queue->next_serial = 1;
442
443 *pQueue = (VkQueue) queue;
444
445 return VK_SUCCESS;
446 }
447
448 static const uint32_t BATCH_SIZE = 8192;
449
450 VkResult
451 anv_batch_init(struct anv_batch *batch, struct anv_device *device)
452 {
453 VkResult result;
454
455 result = anv_bo_init_new(&batch->bo, device, BATCH_SIZE);
456 if (result != VK_SUCCESS)
457 return result;
458
459 batch->bo.map =
460 anv_gem_mmap(device, batch->bo.gem_handle, 0, BATCH_SIZE);
461 if (batch->bo.map == NULL) {
462 anv_gem_close(device, batch->bo.gem_handle);
463 return vk_error(VK_ERROR_MEMORY_MAP_FAILED);
464 }
465
466 batch->cmd_relocs.num_relocs = 0;
467 batch->surf_relocs.num_relocs = 0;
468 batch->next = batch->bo.map;
469
470 return VK_SUCCESS;
471 }
472
473 void
474 anv_batch_finish(struct anv_batch *batch, struct anv_device *device)
475 {
476 anv_gem_munmap(batch->bo.map, BATCH_SIZE);
477 anv_gem_close(device, batch->bo.gem_handle);
478 }
479
480 void
481 anv_batch_reset(struct anv_batch *batch)
482 {
483 batch->next = batch->bo.map;
484 batch->cmd_relocs.num_relocs = 0;
485 batch->surf_relocs.num_relocs = 0;
486 }
487
488 void *
489 anv_batch_emit_dwords(struct anv_batch *batch, int num_dwords)
490 {
491 void *p = batch->next;
492
493 batch->next += num_dwords * 4;
494
495 return p;
496 }
497
498 static void
499 anv_reloc_list_append(struct anv_reloc_list *list,
500 struct anv_reloc_list *other, uint32_t offset)
501 {
502 uint32_t i, count;
503
504 count = list->num_relocs;
505 memcpy(&list->relocs[count], &other->relocs[0],
506 other->num_relocs * sizeof(other->relocs[0]));
507 memcpy(&list->reloc_bos[count], &other->reloc_bos[0],
508 other->num_relocs * sizeof(other->reloc_bos[0]));
509 for (i = 0; i < other->num_relocs; i++)
510 list->relocs[i + count].offset += offset;
511
512 count += other->num_relocs;
513 }
514
515 static uint64_t
516 anv_reloc_list_add(struct anv_reloc_list *list,
517 uint32_t offset,
518 struct anv_bo *target_bo, uint32_t delta)
519 {
520 struct drm_i915_gem_relocation_entry *entry;
521 int index;
522
523 assert(list->num_relocs < ANV_BATCH_MAX_RELOCS);
524
525 /* XXX: Can we use I915_EXEC_HANDLE_LUT? */
526 index = list->num_relocs++;
527 list->reloc_bos[index] = target_bo;
528 entry = &list->relocs[index];
529 entry->target_handle = target_bo->gem_handle;
530 entry->delta = delta;
531 entry->offset = offset;
532 entry->presumed_offset = target_bo->offset;
533 entry->read_domains = 0;
534 entry->write_domain = 0;
535
536 return target_bo->offset + delta;
537 }
538
539 void
540 anv_batch_emit_batch(struct anv_batch *batch, struct anv_batch *other)
541 {
542 uint32_t size, offset;
543
544 size = other->next - other->bo.map;
545 memcpy(batch->next, other->bo.map, size);
546
547 offset = batch->next - batch->bo.map;
548 anv_reloc_list_append(&batch->cmd_relocs, &other->cmd_relocs, offset);
549 anv_reloc_list_append(&batch->surf_relocs, &other->surf_relocs, offset);
550
551 batch->next += size;
552 }
553
554 uint64_t
555 anv_batch_emit_reloc(struct anv_batch *batch,
556 void *location, struct anv_bo *bo, uint32_t delta)
557 {
558 return anv_reloc_list_add(&batch->cmd_relocs,
559 location - batch->bo.map, bo, delta);
560 }
561
562 VkResult VKAPI vkQueueSubmit(
563 VkQueue _queue,
564 uint32_t cmdBufferCount,
565 const VkCmdBuffer* pCmdBuffers,
566 VkFence fence)
567 {
568 struct anv_queue *queue = (struct anv_queue *) _queue;
569 struct anv_device *device = queue->device;
570 int ret;
571
572 for (uint32_t i = 0; i < cmdBufferCount; i++) {
573 struct anv_cmd_buffer *cmd_buffer =
574 (struct anv_cmd_buffer *) pCmdBuffers[i];
575
576 if (device->dump_aub)
577 anv_cmd_buffer_dump(cmd_buffer);
578
579 if (!device->no_hw) {
580 ret = anv_gem_execbuffer(device, &cmd_buffer->execbuf);
581 if (ret != 0)
582 return vk_error(VK_ERROR_UNKNOWN);
583
584 for (uint32_t i = 0; i < cmd_buffer->bo_count; i++)
585 cmd_buffer->exec2_bos[i]->offset = cmd_buffer->exec2_objects[i].offset;
586 } else {
587 *(uint32_t *)queue->completed_serial.map = cmd_buffer->serial;
588 }
589 }
590
591 return VK_SUCCESS;
592 }
593
594 VkResult VKAPI vkQueueAddMemReferences(
595 VkQueue queue,
596 uint32_t count,
597 const VkDeviceMemory* pMems)
598 {
599 return VK_SUCCESS;
600 }
601
602 VkResult vkQueueRemoveMemReferences(
603 VkQueue queue,
604 uint32_t count,
605 const VkDeviceMemory* pMems)
606 {
607 return VK_SUCCESS;
608 }
609
610 VkResult VKAPI vkQueueWaitIdle(
611 VkQueue _queue)
612 {
613 struct anv_queue *queue = (struct anv_queue *) _queue;
614
615 return vkDeviceWaitIdle((VkDevice) queue->device);
616 }
617
618 VkResult VKAPI vkDeviceWaitIdle(
619 VkDevice _device)
620 {
621 struct anv_device *device = (struct anv_device *) _device;
622 struct anv_state state;
623 struct anv_batch batch;
624 struct drm_i915_gem_execbuffer2 execbuf;
625 struct drm_i915_gem_exec_object2 exec2_objects[1];
626 struct anv_bo *bo = NULL;
627 VkResult result;
628 int64_t timeout;
629 int ret;
630
631 state = anv_state_pool_alloc(&device->dynamic_state_pool, 32, 32);
632 bo = &device->dynamic_state_pool.block_pool->bo;
633 batch.next = state.map;
634 anv_batch_emit(&batch, GEN8_MI_BATCH_BUFFER_END);
635 anv_batch_emit(&batch, GEN8_MI_NOOP);
636
637 exec2_objects[0].handle = bo->gem_handle;
638 exec2_objects[0].relocation_count = 0;
639 exec2_objects[0].relocs_ptr = 0;
640 exec2_objects[0].alignment = 0;
641 exec2_objects[0].offset = bo->offset;
642 exec2_objects[0].flags = 0;
643 exec2_objects[0].rsvd1 = 0;
644 exec2_objects[0].rsvd2 = 0;
645
646 execbuf.buffers_ptr = (uintptr_t) exec2_objects;
647 execbuf.buffer_count = 1;
648 execbuf.batch_start_offset = state.offset;
649 execbuf.batch_len = batch.next - state.map;
650 execbuf.cliprects_ptr = 0;
651 execbuf.num_cliprects = 0;
652 execbuf.DR1 = 0;
653 execbuf.DR4 = 0;
654
655 execbuf.flags =
656 I915_EXEC_HANDLE_LUT | I915_EXEC_NO_RELOC | I915_EXEC_RENDER;
657 execbuf.rsvd1 = device->context_id;
658 execbuf.rsvd2 = 0;
659
660 if (!device->no_hw) {
661 ret = anv_gem_execbuffer(device, &execbuf);
662 if (ret != 0) {
663 result = vk_error(VK_ERROR_UNKNOWN);
664 goto fail;
665 }
666
667 timeout = INT64_MAX;
668 ret = anv_gem_wait(device, bo->gem_handle, &timeout);
669 if (ret != 0) {
670 result = vk_error(VK_ERROR_UNKNOWN);
671 goto fail;
672 }
673 }
674
675 anv_state_pool_free(&device->dynamic_state_pool, state);
676
677 return VK_SUCCESS;
678
679 fail:
680 anv_state_pool_free(&device->dynamic_state_pool, state);
681
682 return result;
683 }
684
685 void *
686 anv_device_alloc(struct anv_device * device,
687 size_t size,
688 size_t alignment,
689 VkSystemAllocType allocType)
690 {
691 return device->instance->pfnAlloc(device->instance->pAllocUserData,
692 size,
693 alignment,
694 allocType);
695 }
696
697 void
698 anv_device_free(struct anv_device * device,
699 void * mem)
700 {
701 return device->instance->pfnFree(device->instance->pAllocUserData,
702 mem);
703 }
704
705 VkResult
706 anv_bo_init_new(struct anv_bo *bo, struct anv_device *device, uint64_t size)
707 {
708 bo->gem_handle = anv_gem_create(device, size);
709 if (!bo->gem_handle)
710 return vk_error(VK_ERROR_OUT_OF_DEVICE_MEMORY);
711
712 bo->map = NULL;
713 bo->index = 0;
714 bo->offset = 0;
715 bo->size = size;
716
717 return VK_SUCCESS;
718 }
719
720 VkResult VKAPI vkAllocMemory(
721 VkDevice _device,
722 const VkMemoryAllocInfo* pAllocInfo,
723 VkDeviceMemory* pMem)
724 {
725 struct anv_device *device = (struct anv_device *) _device;
726 struct anv_device_memory *mem;
727 VkResult result;
728
729 assert(pAllocInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO);
730
731 mem = anv_device_alloc(device, sizeof(*mem), 8,
732 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
733 if (mem == NULL)
734 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
735
736 result = anv_bo_init_new(&mem->bo, device, pAllocInfo->allocationSize);
737 if (result != VK_SUCCESS)
738 goto fail;
739
740 *pMem = (VkDeviceMemory) mem;
741
742 return VK_SUCCESS;
743
744 fail:
745 anv_device_free(device, mem);
746
747 return result;
748 }
749
750 VkResult VKAPI vkFreeMemory(
751 VkDevice _device,
752 VkDeviceMemory _mem)
753 {
754 struct anv_device *device = (struct anv_device *) _device;
755 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
756
757 if (mem->bo.map)
758 anv_gem_munmap(mem->bo.map, mem->bo.size);
759
760 if (mem->bo.gem_handle != 0)
761 anv_gem_close(device, mem->bo.gem_handle);
762
763 anv_device_free(device, mem);
764
765 return VK_SUCCESS;
766 }
767
768 VkResult VKAPI vkSetMemoryPriority(
769 VkDevice device,
770 VkDeviceMemory mem,
771 VkMemoryPriority priority)
772 {
773 return VK_SUCCESS;
774 }
775
776 VkResult VKAPI vkMapMemory(
777 VkDevice _device,
778 VkDeviceMemory _mem,
779 VkDeviceSize offset,
780 VkDeviceSize size,
781 VkMemoryMapFlags flags,
782 void** ppData)
783 {
784 struct anv_device *device = (struct anv_device *) _device;
785 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
786
787 /* FIXME: Is this supposed to be thread safe? Since vkUnmapMemory() only
788 * takes a VkDeviceMemory pointer, it seems like only one map of the memory
789 * at a time is valid. We could just mmap up front and return an offset
790 * pointer here, but that may exhaust virtual memory on 32 bit
791 * userspace. */
792
793 mem->map = anv_gem_mmap(device, mem->bo.gem_handle, offset, size);
794 mem->map_size = size;
795
796 *ppData = mem->map;
797
798 return VK_SUCCESS;
799 }
800
801 VkResult VKAPI vkUnmapMemory(
802 VkDevice _device,
803 VkDeviceMemory _mem)
804 {
805 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
806
807 anv_gem_munmap(mem->map, mem->map_size);
808
809 return VK_SUCCESS;
810 }
811
812 VkResult VKAPI vkFlushMappedMemory(
813 VkDevice device,
814 VkDeviceMemory mem,
815 VkDeviceSize offset,
816 VkDeviceSize size)
817 {
818 /* clflush here for !llc platforms */
819
820 return VK_SUCCESS;
821 }
822
823 VkResult VKAPI vkPinSystemMemory(
824 VkDevice device,
825 const void* pSysMem,
826 size_t memSize,
827 VkDeviceMemory* pMem)
828 {
829 return VK_SUCCESS;
830 }
831
832 VkResult VKAPI vkGetMultiDeviceCompatibility(
833 VkPhysicalDevice physicalDevice0,
834 VkPhysicalDevice physicalDevice1,
835 VkPhysicalDeviceCompatibilityInfo* pInfo)
836 {
837 return VK_UNSUPPORTED;
838 }
839
840 VkResult VKAPI vkOpenSharedMemory(
841 VkDevice device,
842 const VkMemoryOpenInfo* pOpenInfo,
843 VkDeviceMemory* pMem)
844 {
845 return VK_UNSUPPORTED;
846 }
847
848 VkResult VKAPI vkOpenSharedSemaphore(
849 VkDevice device,
850 const VkSemaphoreOpenInfo* pOpenInfo,
851 VkSemaphore* pSemaphore)
852 {
853 return VK_UNSUPPORTED;
854 }
855
856 VkResult VKAPI vkOpenPeerMemory(
857 VkDevice device,
858 const VkPeerMemoryOpenInfo* pOpenInfo,
859 VkDeviceMemory* pMem)
860 {
861 return VK_UNSUPPORTED;
862 }
863
864 VkResult VKAPI vkOpenPeerImage(
865 VkDevice device,
866 const VkPeerImageOpenInfo* pOpenInfo,
867 VkImage* pImage,
868 VkDeviceMemory* pMem)
869 {
870 return VK_UNSUPPORTED;
871 }
872
873 static VkResult
874 anv_instance_destructor(struct anv_device * device,
875 VkObject object)
876 {
877 return vkDestroyInstance(object);
878 }
879
880 static VkResult
881 anv_noop_destructor(struct anv_device * device,
882 VkObject object)
883 {
884 return VK_SUCCESS;
885 }
886
887 static VkResult
888 anv_device_destructor(struct anv_device * device,
889 VkObject object)
890 {
891 return vkDestroyDevice(object);
892 }
893
894 static VkResult
895 anv_cmd_buffer_destructor(struct anv_device * device,
896 VkObject object)
897 {
898 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) object;
899
900 anv_state_stream_finish(&cmd_buffer->surface_state_stream);
901 anv_state_stream_finish(&cmd_buffer->dynamic_state_stream);
902 anv_batch_finish(&cmd_buffer->batch, device);
903 anv_device_free(device, cmd_buffer->exec2_objects);
904 anv_device_free(device, cmd_buffer->exec2_bos);
905 anv_device_free(device, cmd_buffer);
906
907 return VK_SUCCESS;
908 }
909
910 static VkResult
911 anv_pipeline_destructor(struct anv_device * device,
912 VkObject object)
913 {
914 struct anv_pipeline *pipeline = (struct anv_pipeline *) object;
915
916 return anv_pipeline_destroy(pipeline);
917 }
918
919 static VkResult
920 anv_free_destructor(struct anv_device * device,
921 VkObject object)
922 {
923 anv_device_free(device, (void *) object);
924
925 return VK_SUCCESS;
926 }
927
928 static VkResult (*anv_object_destructors[])(struct anv_device *device,
929 VkObject object) = {
930 [VK_OBJECT_TYPE_INSTANCE] = anv_instance_destructor,
931 [VK_OBJECT_TYPE_PHYSICAL_DEVICE] = anv_noop_destructor,
932 [VK_OBJECT_TYPE_DEVICE] = anv_device_destructor,
933 [VK_OBJECT_TYPE_QUEUE] = anv_noop_destructor,
934 [VK_OBJECT_TYPE_COMMAND_BUFFER] = anv_cmd_buffer_destructor,
935 [VK_OBJECT_TYPE_PIPELINE] = anv_pipeline_destructor,
936 [VK_OBJECT_TYPE_SHADER] = anv_free_destructor,
937 [VK_OBJECT_TYPE_BUFFER] = anv_free_destructor,
938 [VK_OBJECT_TYPE_IMAGE] = anv_free_destructor,
939 [VK_OBJECT_TYPE_RENDER_PASS] = anv_free_destructor
940 };
941
942 VkResult VKAPI vkDestroyObject(
943 VkDevice _device,
944 VkObjectType objType,
945 VkObject object)
946 {
947 struct anv_device *device = (struct anv_device *) _device;
948
949 assert(objType < ARRAY_SIZE(anv_object_destructors) &&
950 anv_object_destructors[objType] != NULL);
951
952 return anv_object_destructors[objType](device, object);
953 }
954
955 static void
956 fill_memory_requirements(
957 VkObjectType objType,
958 VkObject object,
959 VkMemoryRequirements * memory_requirements)
960 {
961 struct anv_buffer *buffer;
962 struct anv_image *image;
963
964 memory_requirements->memPropsAllowed =
965 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
966 VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT |
967 /* VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT | */
968 VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT |
969 VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL |
970 VK_MEMORY_PROPERTY_SHAREABLE_BIT;
971
972 memory_requirements->memPropsRequired = 0;
973
974 switch (objType) {
975 case VK_OBJECT_TYPE_BUFFER:
976 buffer = (struct anv_buffer *) object;
977 memory_requirements->size = buffer->size;
978 memory_requirements->alignment = 16;
979 break;
980 case VK_OBJECT_TYPE_IMAGE:
981 image = (struct anv_image *) object;
982 memory_requirements->size = image->size;
983 memory_requirements->alignment = image->alignment;
984 break;
985 default:
986 memory_requirements->size = 0;
987 break;
988 }
989 }
990
991 VkResult VKAPI vkGetObjectInfo(
992 VkDevice _device,
993 VkObjectType objType,
994 VkObject object,
995 VkObjectInfoType infoType,
996 size_t* pDataSize,
997 void* pData)
998 {
999 VkMemoryRequirements memory_requirements;
1000
1001 switch (infoType) {
1002 case VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS:
1003 fill_memory_requirements(objType, object, &memory_requirements);
1004 memcpy(pData, &memory_requirements,
1005 MIN2(*pDataSize, sizeof(memory_requirements)));
1006 *pDataSize = sizeof(memory_requirements);
1007 return VK_SUCCESS;
1008
1009 case VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
1010 default:
1011 return VK_UNSUPPORTED;
1012 }
1013
1014 }
1015
1016 VkResult VKAPI vkQueueBindObjectMemory(
1017 VkQueue queue,
1018 VkObjectType objType,
1019 VkObject object,
1020 uint32_t allocationIdx,
1021 VkDeviceMemory _mem,
1022 VkDeviceSize memOffset)
1023 {
1024 struct anv_buffer *buffer;
1025 struct anv_image *image;
1026 struct anv_device_memory *mem = (struct anv_device_memory *) _mem;
1027
1028 switch (objType) {
1029 case VK_OBJECT_TYPE_BUFFER:
1030 buffer = (struct anv_buffer *) object;
1031 buffer->bo = &mem->bo;
1032 buffer->offset = memOffset;
1033 break;
1034 case VK_OBJECT_TYPE_IMAGE:
1035 image = (struct anv_image *) object;
1036 image->bo = &mem->bo;
1037 image->offset = memOffset;
1038 break;
1039 default:
1040 break;
1041 }
1042
1043 return VK_SUCCESS;
1044 }
1045
1046 VkResult VKAPI vkQueueBindObjectMemoryRange(
1047 VkQueue queue,
1048 VkObjectType objType,
1049 VkObject object,
1050 uint32_t allocationIdx,
1051 VkDeviceSize rangeOffset,
1052 VkDeviceSize rangeSize,
1053 VkDeviceMemory mem,
1054 VkDeviceSize memOffset)
1055 {
1056 stub_return(VK_UNSUPPORTED);
1057 }
1058
1059 VkResult vkQueueBindImageMemoryRange(
1060 VkQueue queue,
1061 VkImage image,
1062 uint32_t allocationIdx,
1063 const VkImageMemoryBindInfo* pBindInfo,
1064 VkDeviceMemory mem,
1065 VkDeviceSize memOffset)
1066 {
1067 stub_return(VK_UNSUPPORTED);
1068 }
1069
1070 VkResult VKAPI vkCreateFence(
1071 VkDevice device,
1072 const VkFenceCreateInfo* pCreateInfo,
1073 VkFence* pFence)
1074 {
1075 stub_return(VK_UNSUPPORTED);
1076 }
1077
1078 VkResult VKAPI vkResetFences(
1079 VkDevice device,
1080 uint32_t fenceCount,
1081 VkFence* pFences)
1082 {
1083 stub_return(VK_UNSUPPORTED);
1084 }
1085
1086 VkResult VKAPI vkGetFenceStatus(
1087 VkDevice device,
1088 VkFence fence)
1089 {
1090 stub_return(VK_UNSUPPORTED);
1091 }
1092
1093 VkResult VKAPI vkWaitForFences(
1094 VkDevice device,
1095 uint32_t fenceCount,
1096 const VkFence* pFences,
1097 bool32_t waitAll,
1098 uint64_t timeout)
1099 {
1100 stub_return(VK_UNSUPPORTED);
1101 }
1102
1103 // Queue semaphore functions
1104
1105 VkResult VKAPI vkCreateSemaphore(
1106 VkDevice device,
1107 const VkSemaphoreCreateInfo* pCreateInfo,
1108 VkSemaphore* pSemaphore)
1109 {
1110 stub_return(VK_UNSUPPORTED);
1111 }
1112
1113 VkResult VKAPI vkQueueSignalSemaphore(
1114 VkQueue queue,
1115 VkSemaphore semaphore)
1116 {
1117 stub_return(VK_UNSUPPORTED);
1118 }
1119
1120 VkResult VKAPI vkQueueWaitSemaphore(
1121 VkQueue queue,
1122 VkSemaphore semaphore)
1123 {
1124 stub_return(VK_UNSUPPORTED);
1125 }
1126
1127 // Event functions
1128
1129 VkResult VKAPI vkCreateEvent(
1130 VkDevice device,
1131 const VkEventCreateInfo* pCreateInfo,
1132 VkEvent* pEvent)
1133 {
1134 stub_return(VK_UNSUPPORTED);
1135 }
1136
1137 VkResult VKAPI vkGetEventStatus(
1138 VkDevice device,
1139 VkEvent event)
1140 {
1141 stub_return(VK_UNSUPPORTED);
1142 }
1143
1144 VkResult VKAPI vkSetEvent(
1145 VkDevice device,
1146 VkEvent event)
1147 {
1148 stub_return(VK_UNSUPPORTED);
1149 }
1150
1151 VkResult VKAPI vkResetEvent(
1152 VkDevice device,
1153 VkEvent event)
1154 {
1155 stub_return(VK_UNSUPPORTED);
1156 }
1157
1158 // Query functions
1159
1160 struct anv_query_pool {
1161 VkQueryType type;
1162 uint32_t slots;
1163 struct anv_bo bo;
1164 };
1165
1166 VkResult VKAPI vkCreateQueryPool(
1167 VkDevice _device,
1168 const VkQueryPoolCreateInfo* pCreateInfo,
1169 VkQueryPool* pQueryPool)
1170 {
1171 struct anv_device *device = (struct anv_device *) _device;
1172 struct anv_query_pool *pool;
1173 VkResult result;
1174
1175 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO);
1176
1177 pool = anv_device_alloc(device, sizeof(*pool), 8,
1178 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1179 if (pool == NULL)
1180 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1181
1182 pool->type = pCreateInfo->queryType;
1183 result = anv_bo_init_new(&pool->bo, device, pCreateInfo->slots * 16);
1184 if (result != VK_SUCCESS)
1185 goto fail;
1186
1187 *pQueryPool = (VkQueryPool) pool;
1188
1189 return VK_SUCCESS;
1190
1191 fail:
1192 anv_device_free(device, pool);
1193
1194 return result;
1195 }
1196
1197 VkResult VKAPI vkGetQueryPoolResults(
1198 VkDevice device,
1199 VkQueryPool queryPool,
1200 uint32_t startQuery,
1201 uint32_t queryCount,
1202 size_t* pDataSize,
1203 void* pData,
1204 VkQueryResultFlags flags)
1205 {
1206 stub_return(VK_UNSUPPORTED);
1207 }
1208
1209 // Format capabilities
1210
1211 VkResult VKAPI vkGetFormatInfo(
1212 VkDevice device,
1213 VkFormat format,
1214 VkFormatInfoType infoType,
1215 size_t* pDataSize,
1216 void* pData)
1217 {
1218 stub_return(VK_UNSUPPORTED);
1219 }
1220
1221 // Buffer functions
1222
1223 VkResult VKAPI vkCreateBuffer(
1224 VkDevice _device,
1225 const VkBufferCreateInfo* pCreateInfo,
1226 VkBuffer* pBuffer)
1227 {
1228 struct anv_device *device = (struct anv_device *) _device;
1229 struct anv_buffer *buffer;
1230
1231 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
1232
1233 buffer = anv_device_alloc(device, sizeof(*buffer), 8,
1234 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1235 if (buffer == NULL)
1236 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1237
1238 buffer->size = pCreateInfo->size;
1239 buffer->bo = NULL;
1240 buffer->offset = 0;
1241
1242 *pBuffer = (VkBuffer) buffer;
1243
1244 return VK_SUCCESS;
1245 }
1246
1247 // Buffer view functions
1248
1249 VkResult VKAPI vkCreateBufferView(
1250 VkDevice _device,
1251 const VkBufferViewCreateInfo* pCreateInfo,
1252 VkBufferView* pView)
1253 {
1254 struct anv_device *device = (struct anv_device *) _device;
1255 struct anv_buffer *buffer = (struct anv_buffer *) pCreateInfo->buffer;
1256 struct anv_surface_view *view;
1257 const struct anv_format *format;
1258
1259 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);
1260
1261 view = anv_device_alloc(device, sizeof(*view), 8,
1262 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1263 if (view == NULL)
1264 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1265
1266 view->bo = buffer->bo;
1267 view->offset = buffer->offset + pCreateInfo->offset;
1268 view->surface_state =
1269 anv_state_pool_alloc(&device->surface_state_pool, 64, 64);
1270 view->format = pCreateInfo->format;
1271
1272 format = anv_format_for_vk_format(pCreateInfo->format);
1273 /* This assumes RGBA float format. */
1274 uint32_t stride = 4;
1275 uint32_t num_elements = pCreateInfo->range / stride;
1276 struct GEN8_RENDER_SURFACE_STATE surface_state = {
1277 .SurfaceType = SURFTYPE_BUFFER,
1278 .SurfaceArray = false,
1279 .SurfaceFormat = format->format,
1280 .SurfaceVerticalAlignment = VALIGN4,
1281 .SurfaceHorizontalAlignment = HALIGN4,
1282 .TileMode = LINEAR,
1283 .VerticalLineStride = 0,
1284 .VerticalLineStrideOffset = 0,
1285 .SamplerL2BypassModeDisable = true,
1286 .RenderCacheReadWriteMode = WriteOnlyCache,
1287 .MemoryObjectControlState = 0, /* FIXME: MOCS */
1288 .BaseMipLevel = 0,
1289 .SurfaceQPitch = 0,
1290 .Height = (num_elements >> 7) & 0x3fff,
1291 .Width = num_elements & 0x7f,
1292 .Depth = (num_elements >> 21) & 0x3f,
1293 .SurfacePitch = stride - 1,
1294 .MinimumArrayElement = 0,
1295 .NumberofMultisamples = MULTISAMPLECOUNT_1,
1296 .XOffset = 0,
1297 .YOffset = 0,
1298 .SurfaceMinLOD = 0,
1299 .MIPCountLOD = 0,
1300 .AuxiliarySurfaceMode = AUX_NONE,
1301 .RedClearColor = 0,
1302 .GreenClearColor = 0,
1303 .BlueClearColor = 0,
1304 .AlphaClearColor = 0,
1305 .ShaderChannelSelectRed = SCS_RED,
1306 .ShaderChannelSelectGreen = SCS_GREEN,
1307 .ShaderChannelSelectBlue = SCS_BLUE,
1308 .ShaderChannelSelectAlpha = SCS_ALPHA,
1309 .ResourceMinLOD = 0,
1310 /* FIXME: We assume that the image must be bound at this time. */
1311 .SurfaceBaseAddress = { NULL, view->offset },
1312 };
1313
1314 GEN8_RENDER_SURFACE_STATE_pack(NULL, view->surface_state.map, &surface_state);
1315
1316 *pView = (VkImageView) view;
1317
1318 return VK_SUCCESS;
1319 }
1320
1321 // Sampler functions
1322
1323 VkResult VKAPI vkCreateSampler(
1324 VkDevice _device,
1325 const VkSamplerCreateInfo* pCreateInfo,
1326 VkSampler* pSampler)
1327 {
1328 struct anv_device *device = (struct anv_device *) _device;
1329 struct anv_sampler *sampler;
1330
1331 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
1332
1333 sampler = anv_device_alloc(device, sizeof(*sampler), 8,
1334 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1335 if (!sampler)
1336 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1337
1338 static const uint32_t vk_to_gen_tex_filter[] = {
1339 [VK_TEX_FILTER_NEAREST] = MAPFILTER_NEAREST,
1340 [VK_TEX_FILTER_LINEAR] = MAPFILTER_LINEAR
1341 };
1342
1343 static const uint32_t vk_to_gen_mipmap_mode[] = {
1344 [VK_TEX_MIPMAP_MODE_BASE] = MIPFILTER_NONE,
1345 [VK_TEX_MIPMAP_MODE_NEAREST] = MIPFILTER_NEAREST,
1346 [VK_TEX_MIPMAP_MODE_LINEAR] = MIPFILTER_LINEAR
1347 };
1348
1349 static const uint32_t vk_to_gen_tex_address[] = {
1350 [VK_TEX_ADDRESS_WRAP] = TCM_WRAP,
1351 [VK_TEX_ADDRESS_MIRROR] = TCM_MIRROR,
1352 [VK_TEX_ADDRESS_CLAMP] = TCM_CLAMP,
1353 [VK_TEX_ADDRESS_MIRROR_ONCE] = TCM_MIRROR_ONCE,
1354 [VK_TEX_ADDRESS_CLAMP_BORDER] = TCM_CLAMP_BORDER,
1355 };
1356
1357 static const uint32_t vk_to_gen_compare_op[] = {
1358 [VK_COMPARE_OP_NEVER] = PREFILTEROPNEVER,
1359 [VK_COMPARE_OP_LESS] = PREFILTEROPLESS,
1360 [VK_COMPARE_OP_EQUAL] = PREFILTEROPEQUAL,
1361 [VK_COMPARE_OP_LESS_EQUAL] = PREFILTEROPLEQUAL,
1362 [VK_COMPARE_OP_GREATER] = PREFILTEROPGREATER,
1363 [VK_COMPARE_OP_NOT_EQUAL] = PREFILTEROPNOTEQUAL,
1364 [VK_COMPARE_OP_GREATER_EQUAL] = PREFILTEROPGEQUAL,
1365 [VK_COMPARE_OP_ALWAYS] = PREFILTEROPALWAYS,
1366 };
1367
1368 if (pCreateInfo->maxAnisotropy > 0)
1369 anv_finishme("missing support for anisotropic filtering");
1370
1371 struct GEN8_SAMPLER_STATE sampler_state = {
1372 .SamplerDisable = false,
1373 .TextureBorderColorMode = DX10OGL,
1374 .LODPreClampMode = 0,
1375 .BaseMipLevel = 0,
1376 .MipModeFilter = vk_to_gen_mipmap_mode[pCreateInfo->mipMode],
1377 .MagModeFilter = vk_to_gen_tex_filter[pCreateInfo->magFilter],
1378 .MinModeFilter = vk_to_gen_tex_filter[pCreateInfo->minFilter],
1379 .TextureLODBias = pCreateInfo->mipLodBias * 256,
1380 .AnisotropicAlgorithm = EWAApproximation,
1381 .MinLOD = pCreateInfo->minLod * 256,
1382 .MaxLOD = pCreateInfo->maxLod * 256,
1383 .ChromaKeyEnable = 0,
1384 .ChromaKeyIndex = 0,
1385 .ChromaKeyMode = 0,
1386 .ShadowFunction = vk_to_gen_compare_op[pCreateInfo->compareOp],
1387 .CubeSurfaceControlMode = 0,
1388 .IndirectStatePointer = 0,
1389 .LODClampMagnificationMode = MIPNONE,
1390 .MaximumAnisotropy = 0,
1391 .RAddressMinFilterRoundingEnable = 0,
1392 .RAddressMagFilterRoundingEnable = 0,
1393 .VAddressMinFilterRoundingEnable = 0,
1394 .VAddressMagFilterRoundingEnable = 0,
1395 .UAddressMinFilterRoundingEnable = 0,
1396 .UAddressMagFilterRoundingEnable = 0,
1397 .TrilinearFilterQuality = 0,
1398 .NonnormalizedCoordinateEnable = 0,
1399 .TCXAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressU],
1400 .TCYAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressV],
1401 .TCZAddressControlMode = vk_to_gen_tex_address[pCreateInfo->addressW],
1402 };
1403
1404 GEN8_SAMPLER_STATE_pack(NULL, sampler->state, &sampler_state);
1405
1406 *pSampler = (VkSampler) sampler;
1407
1408 return VK_SUCCESS;
1409 }
1410
1411 // Descriptor set functions
1412
1413 VkResult VKAPI vkCreateDescriptorSetLayout(
1414 VkDevice _device,
1415 const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
1416 VkDescriptorSetLayout* pSetLayout)
1417 {
1418 struct anv_device *device = (struct anv_device *) _device;
1419 struct anv_descriptor_set_layout *set_layout;
1420
1421 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
1422
1423 uint32_t sampler_count[VK_NUM_SHADER_STAGE] = { 0, };
1424 uint32_t surface_count[VK_NUM_SHADER_STAGE] = { 0, };
1425 uint32_t num_dynamic_buffers = 0;
1426 uint32_t count = 0;
1427 uint32_t s;
1428
1429 for (uint32_t i = 0; i < pCreateInfo->count; i++) {
1430 switch (pCreateInfo->pBinding[i].descriptorType) {
1431 case VK_DESCRIPTOR_TYPE_SAMPLER:
1432 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1433 sampler_count[s] += pCreateInfo->pBinding[i].count;
1434 break;
1435
1436 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1437 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1438 sampler_count[s] += pCreateInfo->pBinding[i].count;
1439
1440 /* fall through */
1441
1442 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1443 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1444 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1445 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1446 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1447 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1448 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1449 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1450 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1451 surface_count[s] += pCreateInfo->pBinding[i].count;
1452 break;
1453 default:
1454 break;
1455 }
1456
1457 count += pCreateInfo->pBinding[i].count;
1458 }
1459
1460 for (uint32_t i = 0; i < pCreateInfo->count; i++) {
1461 switch (pCreateInfo->pBinding[i].descriptorType) {
1462 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1463 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1464 num_dynamic_buffers++;
1465 break;
1466 default:
1467 break;
1468 }
1469 }
1470
1471 uint32_t sampler_total = 0;
1472 uint32_t surface_total = 0;
1473 for (uint32_t s = 0; s < VK_NUM_SHADER_STAGE; s++) {
1474 sampler_total += sampler_count[s];
1475 surface_total += surface_count[s];
1476 }
1477
1478 size_t size = sizeof(*set_layout) +
1479 (sampler_total + surface_total) * sizeof(uint32_t);
1480 set_layout = anv_device_alloc(device, size, 8,
1481 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1482 if (!set_layout)
1483 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1484
1485 set_layout->num_dynamic_buffers = num_dynamic_buffers;
1486 set_layout->count = count;
1487
1488 uint32_t *p = set_layout->entries;
1489 uint32_t *sampler[VK_NUM_SHADER_STAGE];
1490 uint32_t *surface[VK_NUM_SHADER_STAGE];
1491 for (uint32_t s = 0; s < VK_NUM_SHADER_STAGE; s++) {
1492 set_layout->stage[s].surface_count = surface_count[s];
1493 set_layout->stage[s].surface_start = surface[s] = p;
1494 p += surface_count[s];
1495 set_layout->stage[s].sampler_count = sampler_count[s];
1496 set_layout->stage[s].sampler_start = sampler[s] = p;
1497 p += sampler_count[s];
1498 }
1499
1500 uint32_t descriptor = 0;
1501 for (uint32_t i = 0; i < pCreateInfo->count; i++) {
1502 switch (pCreateInfo->pBinding[i].descriptorType) {
1503 case VK_DESCRIPTOR_TYPE_SAMPLER:
1504 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1505 for (uint32_t j = 0; j < pCreateInfo->pBinding[i].count; j++)
1506 *(sampler[s])++ = descriptor + j;
1507 break;
1508
1509 case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
1510 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1511 for (uint32_t j = 0; j < pCreateInfo->pBinding[i].count; j++)
1512 *(sampler[s])++ = descriptor + j;
1513
1514 /* fallthrough */
1515
1516 case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
1517 case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
1518 case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
1519 case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
1520 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
1521 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
1522 case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
1523 case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
1524 for_each_bit(s, pCreateInfo->pBinding[i].stageFlags)
1525 for (uint32_t j = 0; j < pCreateInfo->pBinding[i].count; j++) {
1526 *(surface[s])++ = descriptor + j;
1527 }
1528 break;
1529 default:
1530 unreachable("");
1531 }
1532 descriptor += pCreateInfo->pBinding[i].count;
1533 }
1534
1535 *pSetLayout = (VkDescriptorSetLayout) set_layout;
1536
1537 return VK_SUCCESS;
1538 }
1539
1540 VkResult VKAPI vkBeginDescriptorPoolUpdate(
1541 VkDevice device,
1542 VkDescriptorUpdateMode updateMode)
1543 {
1544 stub_return(VK_UNSUPPORTED);
1545 }
1546
1547 VkResult VKAPI vkEndDescriptorPoolUpdate(
1548 VkDevice device,
1549 VkCmdBuffer cmd)
1550 {
1551 stub_return(VK_UNSUPPORTED);
1552 }
1553
1554 VkResult VKAPI vkCreateDescriptorPool(
1555 VkDevice device,
1556 VkDescriptorPoolUsage poolUsage,
1557 uint32_t maxSets,
1558 const VkDescriptorPoolCreateInfo* pCreateInfo,
1559 VkDescriptorPool* pDescriptorPool)
1560 {
1561 stub_return(VK_UNSUPPORTED);
1562 }
1563
1564 VkResult VKAPI vkResetDescriptorPool(
1565 VkDevice device,
1566 VkDescriptorPool descriptorPool)
1567 {
1568 stub_return(VK_UNSUPPORTED);
1569 }
1570
1571 VkResult VKAPI vkAllocDescriptorSets(
1572 VkDevice _device,
1573 VkDescriptorPool descriptorPool,
1574 VkDescriptorSetUsage setUsage,
1575 uint32_t count,
1576 const VkDescriptorSetLayout* pSetLayouts,
1577 VkDescriptorSet* pDescriptorSets,
1578 uint32_t* pCount)
1579 {
1580 struct anv_device *device = (struct anv_device *) _device;
1581 const struct anv_descriptor_set_layout *layout;
1582 struct anv_descriptor_set *set;
1583 size_t size;
1584
1585 for (uint32_t i = 0; i < count; i++) {
1586 layout = (struct anv_descriptor_set_layout *) pSetLayouts[i];
1587 size = sizeof(*set) + layout->count * sizeof(set->descriptors[0]);
1588 set = anv_device_alloc(device, size, 8,
1589 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1590 if (!set) {
1591 *pCount = i;
1592 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1593 }
1594
1595 pDescriptorSets[i] = (VkDescriptorSet) set;
1596 }
1597
1598 *pCount = count;
1599
1600 return VK_UNSUPPORTED;
1601 }
1602
1603 void VKAPI vkClearDescriptorSets(
1604 VkDevice device,
1605 VkDescriptorPool descriptorPool,
1606 uint32_t count,
1607 const VkDescriptorSet* pDescriptorSets)
1608 {
1609 stub();
1610 }
1611
1612 void VKAPI vkUpdateDescriptors(
1613 VkDevice _device,
1614 VkDescriptorSet descriptorSet,
1615 uint32_t updateCount,
1616 const void** ppUpdateArray)
1617 {
1618 struct anv_descriptor_set *set = (struct anv_descriptor_set *) descriptorSet;
1619 VkUpdateSamplers *update_samplers;
1620 VkUpdateSamplerTextures *update_sampler_textures;
1621 VkUpdateImages *update_images;
1622 VkUpdateBuffers *update_buffers;
1623 VkUpdateAsCopy *update_as_copy;
1624
1625 for (uint32_t i = 0; i < updateCount; i++) {
1626 const struct anv_common *common = ppUpdateArray[i];
1627
1628 switch (common->sType) {
1629 case VK_STRUCTURE_TYPE_UPDATE_SAMPLERS:
1630 update_samplers = (VkUpdateSamplers *) common;
1631
1632 for (uint32_t j = 0; j < update_samplers->count; j++) {
1633 set->descriptors[update_samplers->binding + j].sampler =
1634 (struct anv_sampler *) update_samplers->pSamplers[j];
1635 }
1636 break;
1637
1638 case VK_STRUCTURE_TYPE_UPDATE_SAMPLER_TEXTURES:
1639 /* FIXME: Shouldn't this be *_UPDATE_SAMPLER_IMAGES? */
1640 update_sampler_textures = (VkUpdateSamplerTextures *) common;
1641
1642 for (uint32_t j = 0; j < update_sampler_textures->count; j++) {
1643 set->descriptors[update_sampler_textures->binding + j].view =
1644 (struct anv_surface_view *)
1645 update_sampler_textures->pSamplerImageViews[j].pImageView->view;
1646 set->descriptors[update_sampler_textures->binding + j].sampler =
1647 (struct anv_sampler *)
1648 update_sampler_textures->pSamplerImageViews[j].sampler;
1649 }
1650 break;
1651
1652 case VK_STRUCTURE_TYPE_UPDATE_IMAGES:
1653 update_images = (VkUpdateImages *) common;
1654
1655 for (uint32_t j = 0; j < update_images->count; j++) {
1656 set->descriptors[update_images->binding + j].view =
1657 (struct anv_surface_view *) update_images->pImageViews[j].view;
1658 }
1659 break;
1660
1661 case VK_STRUCTURE_TYPE_UPDATE_BUFFERS:
1662 update_buffers = (VkUpdateBuffers *) common;
1663
1664 for (uint32_t j = 0; j < update_buffers->count; j++) {
1665 set->descriptors[update_buffers->binding + j].view =
1666 (struct anv_surface_view *) update_buffers->pBufferViews[j].view;
1667 }
1668 /* FIXME: descriptor arrays? */
1669 break;
1670
1671 case VK_STRUCTURE_TYPE_UPDATE_AS_COPY:
1672 update_as_copy = (VkUpdateAsCopy *) common;
1673 (void) update_as_copy;
1674 break;
1675
1676 default:
1677 break;
1678 }
1679 }
1680 }
1681
1682 // State object functions
1683
1684 static inline int64_t
1685 clamp_int64(int64_t x, int64_t min, int64_t max)
1686 {
1687 if (x < min)
1688 return min;
1689 else if (x < max)
1690 return x;
1691 else
1692 return max;
1693 }
1694
1695 VkResult VKAPI vkCreateDynamicViewportState(
1696 VkDevice _device,
1697 const VkDynamicVpStateCreateInfo* pCreateInfo,
1698 VkDynamicVpState* pState)
1699 {
1700 struct anv_device *device = (struct anv_device *) _device;
1701 struct anv_dynamic_vp_state *state;
1702
1703 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO);
1704
1705 state = anv_device_alloc(device, sizeof(*state), 8,
1706 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1707 if (state == NULL)
1708 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1709
1710 unsigned count = pCreateInfo->viewportAndScissorCount;
1711 state->sf_clip_vp = anv_state_pool_alloc(&device->dynamic_state_pool,
1712 count * 64, 64);
1713 state->cc_vp = anv_state_pool_alloc(&device->dynamic_state_pool,
1714 count * 8, 32);
1715 state->scissor = anv_state_pool_alloc(&device->dynamic_state_pool,
1716 count * 32, 32);
1717
1718 for (uint32_t i = 0; i < pCreateInfo->viewportAndScissorCount; i++) {
1719 const VkViewport *vp = &pCreateInfo->pViewports[i];
1720 const VkRect *s = &pCreateInfo->pScissors[i];
1721
1722 struct GEN8_SF_CLIP_VIEWPORT sf_clip_viewport = {
1723 .ViewportMatrixElementm00 = vp->width / 2,
1724 .ViewportMatrixElementm11 = vp->height / 2,
1725 .ViewportMatrixElementm22 = (vp->maxDepth - vp->minDepth) / 2,
1726 .ViewportMatrixElementm30 = vp->originX + vp->width / 2,
1727 .ViewportMatrixElementm31 = vp->originY + vp->height / 2,
1728 .ViewportMatrixElementm32 = (vp->maxDepth + vp->minDepth) / 2,
1729 .XMinClipGuardband = -1.0f,
1730 .XMaxClipGuardband = 1.0f,
1731 .YMinClipGuardband = -1.0f,
1732 .YMaxClipGuardband = 1.0f,
1733 .XMinViewPort = vp->originX,
1734 .XMaxViewPort = vp->originX + vp->width - 1,
1735 .YMinViewPort = vp->originY,
1736 .YMaxViewPort = vp->originY + vp->height - 1,
1737 };
1738
1739 struct GEN8_CC_VIEWPORT cc_viewport = {
1740 .MinimumDepth = vp->minDepth,
1741 .MaximumDepth = vp->maxDepth
1742 };
1743
1744 /* Since xmax and ymax are inclusive, we have to have xmax < xmin or
1745 * ymax < ymin for empty clips. In case clip x, y, width height are all
1746 * 0, the clamps below produce 0 for xmin, ymin, xmax, ymax, which isn't
1747 * what we want. Just special case empty clips and produce a canonical
1748 * empty clip. */
1749 static const struct GEN8_SCISSOR_RECT empty_scissor = {
1750 .ScissorRectangleYMin = 1,
1751 .ScissorRectangleXMin = 1,
1752 .ScissorRectangleYMax = 0,
1753 .ScissorRectangleXMax = 0
1754 };
1755
1756 const int max = 0xffff;
1757 struct GEN8_SCISSOR_RECT scissor = {
1758 /* Do this math using int64_t so overflow gets clamped correctly. */
1759 .ScissorRectangleYMin = clamp_int64(s->offset.y, 0, max),
1760 .ScissorRectangleXMin = clamp_int64(s->offset.x, 0, max),
1761 .ScissorRectangleYMax = clamp_int64((uint64_t) s->offset.y + s->extent.height - 1, 0, max),
1762 .ScissorRectangleXMax = clamp_int64((uint64_t) s->offset.x + s->extent.width - 1, 0, max)
1763 };
1764
1765 GEN8_SF_CLIP_VIEWPORT_pack(NULL, state->sf_clip_vp.map + i * 64, &sf_clip_viewport);
1766 GEN8_CC_VIEWPORT_pack(NULL, state->cc_vp.map + i * 32, &cc_viewport);
1767
1768 if (s->extent.width <= 0 || s->extent.height <= 0) {
1769 GEN8_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &empty_scissor);
1770 } else {
1771 GEN8_SCISSOR_RECT_pack(NULL, state->scissor.map + i * 32, &scissor);
1772 }
1773 }
1774
1775 *pState = (VkDynamicVpState) state;
1776
1777 return VK_SUCCESS;
1778 }
1779
1780 VkResult VKAPI vkCreateDynamicRasterState(
1781 VkDevice _device,
1782 const VkDynamicRsStateCreateInfo* pCreateInfo,
1783 VkDynamicRsState* pState)
1784 {
1785 struct anv_device *device = (struct anv_device *) _device;
1786 struct anv_dynamic_rs_state *state;
1787
1788 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO);
1789
1790 state = anv_device_alloc(device, sizeof(*state), 8,
1791 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1792 if (state == NULL)
1793 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1794
1795 /* Missing these:
1796 * float depthBias;
1797 * float depthBiasClamp;
1798 * float slopeScaledDepthBias;
1799 * float pointFadeThreshold;
1800 * // optional (GL45) - Size of point fade threshold
1801 */
1802
1803 struct GEN8_3DSTATE_SF sf = {
1804 GEN8_3DSTATE_SF_header,
1805 .LineWidth = pCreateInfo->lineWidth,
1806 .PointWidth = pCreateInfo->pointSize,
1807 };
1808
1809 GEN8_3DSTATE_SF_pack(NULL, state->state_sf, &sf);
1810
1811 *pState = (VkDynamicRsState) state;
1812
1813 return VK_SUCCESS;
1814 }
1815
1816 VkResult VKAPI vkCreateDynamicColorBlendState(
1817 VkDevice _device,
1818 const VkDynamicCbStateCreateInfo* pCreateInfo,
1819 VkDynamicCbState* pState)
1820 {
1821 struct anv_device *device = (struct anv_device *) _device;
1822 struct anv_dynamic_cb_state *state;
1823
1824 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO);
1825
1826 state = anv_device_alloc(device, sizeof(*state), 8,
1827 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1828 if (state == NULL)
1829 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1830
1831 *pState = (VkDynamicCbState) state;
1832
1833 return VK_SUCCESS;
1834 }
1835
1836 VkResult VKAPI vkCreateDynamicDepthStencilState(
1837 VkDevice device,
1838 const VkDynamicDsStateCreateInfo* pCreateInfo,
1839 VkDynamicDsState* pState)
1840 {
1841 stub_return(VK_UNSUPPORTED);
1842 }
1843
1844 // Command buffer functions
1845
1846 VkResult VKAPI vkCreateCommandBuffer(
1847 VkDevice _device,
1848 const VkCmdBufferCreateInfo* pCreateInfo,
1849 VkCmdBuffer* pCmdBuffer)
1850 {
1851 struct anv_device *device = (struct anv_device *) _device;
1852 struct anv_cmd_buffer *cmd_buffer;
1853 VkResult result;
1854
1855 cmd_buffer = anv_device_alloc(device, sizeof(*cmd_buffer), 8,
1856 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1857 if (cmd_buffer == NULL)
1858 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1859
1860 cmd_buffer->device = device;
1861 cmd_buffer->rs_state = NULL;
1862 cmd_buffer->vp_state = NULL;
1863 memset(&cmd_buffer->default_bindings, 0, sizeof(cmd_buffer->default_bindings));
1864 cmd_buffer->bindings = &cmd_buffer->default_bindings;
1865
1866 result = anv_batch_init(&cmd_buffer->batch, device);
1867 if (result != VK_SUCCESS)
1868 goto fail;
1869
1870 cmd_buffer->exec2_objects =
1871 anv_device_alloc(device, 8192 * sizeof(cmd_buffer->exec2_objects[0]), 8,
1872 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1873 if (cmd_buffer->exec2_objects == NULL) {
1874 result = vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1875 goto fail_batch;
1876 }
1877
1878 cmd_buffer->exec2_bos =
1879 anv_device_alloc(device, 8192 * sizeof(cmd_buffer->exec2_bos[0]), 8,
1880 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
1881 if (cmd_buffer->exec2_bos == NULL) {
1882 result = vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
1883 goto fail_exec2_objects;
1884 }
1885
1886 anv_state_stream_init(&cmd_buffer->surface_state_stream,
1887 &device->surface_state_block_pool);
1888 anv_state_stream_init(&cmd_buffer->dynamic_state_stream,
1889 &device->dynamic_state_block_pool);
1890
1891 cmd_buffer->dirty = 0;
1892 cmd_buffer->vb_dirty = 0;
1893
1894 *pCmdBuffer = (VkCmdBuffer) cmd_buffer;
1895
1896 return VK_SUCCESS;
1897
1898 fail_exec2_objects:
1899 anv_device_free(device, cmd_buffer->exec2_objects);
1900 fail_batch:
1901 anv_batch_finish(&cmd_buffer->batch, device);
1902 fail:
1903 anv_device_free(device, cmd_buffer);
1904
1905 return result;
1906 }
1907
1908 VkResult VKAPI vkBeginCommandBuffer(
1909 VkCmdBuffer cmdBuffer,
1910 const VkCmdBufferBeginInfo* pBeginInfo)
1911 {
1912 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
1913 struct anv_device *device = cmd_buffer->device;
1914
1915 anv_batch_emit(&cmd_buffer->batch, GEN8_PIPELINE_SELECT,
1916 .PipelineSelection = _3D);
1917 anv_batch_emit(&cmd_buffer->batch, GEN8_STATE_SIP);
1918
1919 anv_batch_emit(&cmd_buffer->batch, GEN8_STATE_BASE_ADDRESS,
1920 .GeneralStateBaseAddress = { NULL, 0 },
1921 .GeneralStateBaseAddressModifyEnable = true,
1922 .GeneralStateBufferSize = 0xfffff,
1923 .GeneralStateBufferSizeModifyEnable = true,
1924
1925 .SurfaceStateBaseAddress = { &device->surface_state_block_pool.bo, 0 },
1926 .SurfaceStateMemoryObjectControlState = 0, /* FIXME: MOCS */
1927 .SurfaceStateBaseAddressModifyEnable = true,
1928
1929 .DynamicStateBaseAddress = { &device->dynamic_state_block_pool.bo, 0 },
1930 .DynamicStateBaseAddressModifyEnable = true,
1931 .DynamicStateBufferSize = 0xfffff,
1932 .DynamicStateBufferSizeModifyEnable = true,
1933
1934 .IndirectObjectBaseAddress = { NULL, 0 },
1935 .IndirectObjectBaseAddressModifyEnable = true,
1936 .IndirectObjectBufferSize = 0xfffff,
1937 .IndirectObjectBufferSizeModifyEnable = true,
1938
1939 .InstructionBaseAddress = { &device->instruction_block_pool.bo, 0 },
1940 .InstructionBaseAddressModifyEnable = true,
1941 .InstructionBufferSize = 0xfffff,
1942 .InstructionBuffersizeModifyEnable = true);
1943
1944 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VF_STATISTICS,
1945 .StatisticsEnable = true);
1946 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_HS, .Enable = false);
1947 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_TE, .TEEnable = false);
1948 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DS, .FunctionEnable = false);
1949 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_STREAMOUT, .SOFunctionEnable = false);
1950
1951 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS,
1952 .ConstantBufferOffset = 0,
1953 .ConstantBufferSize = 4);
1954 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS,
1955 .ConstantBufferOffset = 4,
1956 .ConstantBufferSize = 4);
1957 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS,
1958 .ConstantBufferOffset = 8,
1959 .ConstantBufferSize = 4);
1960
1961 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_WM_CHROMAKEY,
1962 .ChromaKeyKillEnable = false);
1963 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SBE_SWIZ);
1964 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_AA_LINE_PARAMETERS);
1965
1966 /* Hardcoded state: */
1967 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DEPTH_BUFFER,
1968 .SurfaceType = SURFTYPE_2D,
1969 .Width = 1,
1970 .Height = 1,
1971 .SurfaceFormat = D16_UNORM,
1972 .SurfaceBaseAddress = { NULL, 0 },
1973 .HierarchicalDepthBufferEnable = 0);
1974
1975 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_WM_DEPTH_STENCIL,
1976 .DepthTestEnable = false,
1977 .DepthBufferWriteEnable = false);
1978
1979 return VK_SUCCESS;
1980 }
1981
1982 static void
1983 anv_cmd_buffer_add_bo(struct anv_cmd_buffer *cmd_buffer,
1984 struct anv_bo *bo, struct anv_reloc_list *list)
1985 {
1986 struct drm_i915_gem_exec_object2 *obj;
1987
1988 bo->index = cmd_buffer->bo_count;
1989 obj = &cmd_buffer->exec2_objects[bo->index];
1990 cmd_buffer->exec2_bos[bo->index] = bo;
1991 cmd_buffer->bo_count++;
1992
1993 obj->handle = bo->gem_handle;
1994 obj->relocation_count = 0;
1995 obj->relocs_ptr = 0;
1996 obj->alignment = 0;
1997 obj->offset = bo->offset;
1998 obj->flags = 0;
1999 obj->rsvd1 = 0;
2000 obj->rsvd2 = 0;
2001
2002 if (list) {
2003 obj->relocation_count = list->num_relocs;
2004 obj->relocs_ptr = (uintptr_t) list->relocs;
2005 }
2006 }
2007
2008 static void
2009 anv_cmd_buffer_add_validate_bos(struct anv_cmd_buffer *cmd_buffer,
2010 struct anv_reloc_list *list)
2011 {
2012 struct anv_bo *bo, *batch_bo;
2013
2014 batch_bo = &cmd_buffer->batch.bo;
2015 for (size_t i = 0; i < list->num_relocs; i++) {
2016 bo = list->reloc_bos[i];
2017 /* Skip any relocations targeting the batch bo. We need to make sure
2018 * it's the last in the list so we'll add it manually later.
2019 */
2020 if (bo == batch_bo)
2021 continue;
2022 if (bo->index < cmd_buffer->bo_count && cmd_buffer->exec2_bos[bo->index] == bo)
2023 continue;
2024
2025 anv_cmd_buffer_add_bo(cmd_buffer, bo, NULL);
2026 }
2027 }
2028
2029 static void
2030 anv_cmd_buffer_process_relocs(struct anv_cmd_buffer *cmd_buffer,
2031 struct anv_reloc_list *list)
2032 {
2033 struct anv_bo *bo;
2034
2035 /* If the kernel supports I915_EXEC_NO_RELOC, it will compare offset in
2036 * struct drm_i915_gem_exec_object2 against the bos current offset and if
2037 * all bos haven't moved it will skip relocation processing alltogether.
2038 * If I915_EXEC_NO_RELOC is not supported, the kernel ignores the incoming
2039 * value of offset so we can set it either way. For that to work we need
2040 * to make sure all relocs use the same presumed offset.
2041 */
2042
2043 for (size_t i = 0; i < list->num_relocs; i++) {
2044 bo = list->reloc_bos[i];
2045 if (bo->offset != list->relocs[i].presumed_offset)
2046 cmd_buffer->need_reloc = true;
2047
2048 list->relocs[i].target_handle = bo->index;
2049 }
2050 }
2051
2052 VkResult VKAPI vkEndCommandBuffer(
2053 VkCmdBuffer cmdBuffer)
2054 {
2055 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2056 struct anv_device *device = cmd_buffer->device;
2057 struct anv_batch *batch = &cmd_buffer->batch;
2058
2059 anv_batch_emit(batch, GEN8_MI_BATCH_BUFFER_END);
2060
2061 /* Round batch up to an even number of dwords. */
2062 if ((batch->next - batch->bo.map) & 4)
2063 anv_batch_emit(batch, GEN8_MI_NOOP);
2064
2065 cmd_buffer->bo_count = 0;
2066 cmd_buffer->need_reloc = false;
2067
2068 /* Lock for access to bo->index. */
2069 pthread_mutex_lock(&device->mutex);
2070
2071 /* Add block pool bos first so we can add them with their relocs. */
2072 anv_cmd_buffer_add_bo(cmd_buffer, &device->surface_state_block_pool.bo,
2073 &batch->surf_relocs);
2074
2075 anv_cmd_buffer_add_validate_bos(cmd_buffer, &batch->surf_relocs);
2076 anv_cmd_buffer_add_validate_bos(cmd_buffer, &batch->cmd_relocs);
2077 anv_cmd_buffer_add_bo(cmd_buffer, &batch->bo, &batch->cmd_relocs);
2078 anv_cmd_buffer_process_relocs(cmd_buffer, &batch->surf_relocs);
2079 anv_cmd_buffer_process_relocs(cmd_buffer, &batch->cmd_relocs);
2080
2081 cmd_buffer->execbuf.buffers_ptr = (uintptr_t) cmd_buffer->exec2_objects;
2082 cmd_buffer->execbuf.buffer_count = cmd_buffer->bo_count;
2083 cmd_buffer->execbuf.batch_start_offset = 0;
2084 cmd_buffer->execbuf.batch_len = batch->next - batch->bo.map;
2085 cmd_buffer->execbuf.cliprects_ptr = 0;
2086 cmd_buffer->execbuf.num_cliprects = 0;
2087 cmd_buffer->execbuf.DR1 = 0;
2088 cmd_buffer->execbuf.DR4 = 0;
2089
2090 cmd_buffer->execbuf.flags = I915_EXEC_HANDLE_LUT;
2091 if (!cmd_buffer->need_reloc)
2092 cmd_buffer->execbuf.flags |= I915_EXEC_NO_RELOC;
2093 cmd_buffer->execbuf.flags |= I915_EXEC_RENDER;
2094 cmd_buffer->execbuf.rsvd1 = device->context_id;
2095 cmd_buffer->execbuf.rsvd2 = 0;
2096
2097 pthread_mutex_unlock(&device->mutex);
2098
2099 return VK_SUCCESS;
2100 }
2101
2102 VkResult VKAPI vkResetCommandBuffer(
2103 VkCmdBuffer cmdBuffer)
2104 {
2105 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2106
2107 anv_batch_reset(&cmd_buffer->batch);
2108
2109 return VK_SUCCESS;
2110 }
2111
2112 // Command buffer building functions
2113
2114 void VKAPI vkCmdBindPipeline(
2115 VkCmdBuffer cmdBuffer,
2116 VkPipelineBindPoint pipelineBindPoint,
2117 VkPipeline _pipeline)
2118 {
2119 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2120
2121 cmd_buffer->pipeline = (struct anv_pipeline *) _pipeline;
2122 cmd_buffer->dirty |= ANV_CMD_BUFFER_PIPELINE_DIRTY;
2123 }
2124
2125 void VKAPI vkCmdBindDynamicStateObject(
2126 VkCmdBuffer cmdBuffer,
2127 VkStateBindPoint stateBindPoint,
2128 VkDynamicStateObject dynamicState)
2129 {
2130 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2131 struct anv_dynamic_vp_state *vp_state;
2132
2133 switch (stateBindPoint) {
2134 case VK_STATE_BIND_POINT_VIEWPORT:
2135 vp_state = (struct anv_dynamic_vp_state *) dynamicState;
2136 /* We emit state immediately, but set cmd_buffer->vp_state to indicate
2137 * that vp state has been set in this command buffer. */
2138 cmd_buffer->vp_state = vp_state;
2139 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_SCISSOR_STATE_POINTERS,
2140 .ScissorRectPointer = vp_state->scissor.offset);
2141 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC,
2142 .CCViewportPointer = vp_state->cc_vp.offset);
2143 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP,
2144 .SFClipViewportPointer = vp_state->sf_clip_vp.offset);
2145 break;
2146 case VK_STATE_BIND_POINT_RASTER:
2147 cmd_buffer->rs_state = (struct anv_dynamic_rs_state *) dynamicState;
2148 cmd_buffer->dirty |= ANV_CMD_BUFFER_RS_DIRTY;
2149 break;
2150 case VK_STATE_BIND_POINT_COLOR_BLEND:
2151 case VK_STATE_BIND_POINT_DEPTH_STENCIL:
2152 break;
2153 default:
2154 break;
2155 };
2156 }
2157
2158 void VKAPI vkCmdBindDescriptorSets(
2159 VkCmdBuffer cmdBuffer,
2160 VkPipelineBindPoint pipelineBindPoint,
2161 uint32_t firstSet,
2162 uint32_t setCount,
2163 const VkDescriptorSet* pDescriptorSets,
2164 uint32_t dynamicOffsetCount,
2165 const uint32_t* pDynamicOffsets)
2166 {
2167 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2168 struct anv_pipeline_layout *layout = cmd_buffer->pipeline->layout;
2169 struct anv_bindings *bindings = cmd_buffer->bindings;
2170
2171 uint32_t offset = 0;
2172 for (uint32_t i = 0; i < setCount; i++) {
2173 struct anv_descriptor_set *set =
2174 (struct anv_descriptor_set *) pDescriptorSets[i];
2175 struct anv_descriptor_set_layout *set_layout = layout->set[firstSet + i].layout;
2176
2177 for (uint32_t s = 0; s < VK_NUM_SHADER_STAGE; s++) {
2178 uint32_t *surface_to_desc = set_layout->stage[s].surface_start;
2179 uint32_t *sampler_to_desc = set_layout->stage[s].sampler_start;
2180 uint32_t bias = s == VK_SHADER_STAGE_FRAGMENT ? MAX_RTS : 0;
2181 uint32_t start;
2182
2183 start = bias + layout->set[firstSet + i].surface_start[s];
2184 for (uint32_t b = 0; b < set_layout->stage[s].surface_count; b++) {
2185 struct anv_surface_view *view = set->descriptors[surface_to_desc[b]].view;
2186
2187 bindings->descriptors[s].surfaces[start + b] =
2188 view->surface_state.offset;
2189 bindings->descriptors[s].relocs[start + b].bo = view->bo;
2190 bindings->descriptors[s].relocs[start + b].offset = view->offset;
2191 }
2192
2193 start = layout->set[firstSet + i].sampler_start[s];
2194 for (uint32_t b = 0; b < set_layout->stage[s].sampler_count; b++) {
2195 struct anv_sampler *sampler = set->descriptors[sampler_to_desc[b]].sampler;
2196
2197 memcpy(&bindings->descriptors[s].samplers[start + b],
2198 sampler->state, sizeof(sampler->state));
2199 }
2200 }
2201
2202 offset += layout->set[firstSet + i].layout->num_dynamic_buffers;
2203 }
2204
2205 cmd_buffer->dirty |= ANV_CMD_BUFFER_DESCRIPTOR_SET_DIRTY;
2206 }
2207
2208 void VKAPI vkCmdBindIndexBuffer(
2209 VkCmdBuffer cmdBuffer,
2210 VkBuffer _buffer,
2211 VkDeviceSize offset,
2212 VkIndexType indexType)
2213 {
2214 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2215 struct anv_buffer *buffer = (struct anv_buffer *) _buffer;
2216
2217 static const uint32_t vk_to_gen_index_type[] = {
2218 [VK_INDEX_TYPE_UINT8] = INDEX_BYTE,
2219 [VK_INDEX_TYPE_UINT16] = INDEX_WORD,
2220 [VK_INDEX_TYPE_UINT32] = INDEX_DWORD,
2221 };
2222
2223 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_INDEX_BUFFER,
2224 .IndexFormat = vk_to_gen_index_type[indexType],
2225 .MemoryObjectControlState = 0,
2226 .BufferStartingAddress = { buffer->bo, buffer->offset + offset },
2227 .BufferSize = buffer->size - offset);
2228 }
2229
2230 void VKAPI vkCmdBindVertexBuffers(
2231 VkCmdBuffer cmdBuffer,
2232 uint32_t startBinding,
2233 uint32_t bindingCount,
2234 const VkBuffer* pBuffers,
2235 const VkDeviceSize* pOffsets)
2236 {
2237 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2238 struct anv_bindings *bindings = cmd_buffer->bindings;
2239
2240 /* We have to defer setting up vertex buffer since we need the buffer
2241 * stride from the pipeline. */
2242
2243 for (uint32_t i = 0; i < bindingCount; i++) {
2244 bindings->vb[startBinding + i].buffer = (struct anv_buffer *) pBuffers[i];
2245 bindings->vb[startBinding + i].offset = pOffsets[i];
2246 cmd_buffer->vb_dirty |= 1 << (startBinding + i);
2247 }
2248 }
2249
2250 static void
2251 flush_descriptor_sets(struct anv_cmd_buffer *cmd_buffer)
2252 {
2253 struct anv_pipeline_layout *layout = cmd_buffer->pipeline->layout;
2254 struct anv_bindings *bindings = cmd_buffer->bindings;
2255 uint32_t layers = cmd_buffer->framebuffer->layers;
2256
2257 for (uint32_t s = 0; s < VK_NUM_SHADER_STAGE; s++) {
2258 uint32_t bias;
2259
2260 if (s == VK_SHADER_STAGE_FRAGMENT) {
2261 bias = MAX_RTS;
2262 layers = cmd_buffer->framebuffer->layers;
2263 } else {
2264 bias = 0;
2265 layers = 0;
2266 }
2267
2268 /* This is a little awkward: layout can be NULL but we still have to
2269 * allocate and set a binding table for the PS stage for render
2270 * targets. */
2271 uint32_t surface_count = layout ? layout->stage[s].surface_count : 0;
2272
2273 if (layers + surface_count > 0) {
2274 struct anv_state state;
2275 uint32_t size;
2276
2277 size = (layers + surface_count) * sizeof(uint32_t);
2278 state = anv_state_stream_alloc(&cmd_buffer->surface_state_stream, size, 32);
2279 memcpy(state.map, bindings->descriptors[s].surfaces, size);
2280
2281 for (uint32_t i = 0; i < layers; i++)
2282 anv_reloc_list_add(&cmd_buffer->batch.surf_relocs,
2283 bindings->descriptors[s].surfaces[i] + 8 * sizeof(int32_t),
2284 bindings->descriptors[s].relocs[i].bo,
2285 bindings->descriptors[s].relocs[i].offset);
2286
2287 for (uint32_t i = 0; i < surface_count; i++)
2288 anv_reloc_list_add(&cmd_buffer->batch.surf_relocs,
2289 bindings->descriptors[s].surfaces[bias + i] + 8 * sizeof(int32_t),
2290 bindings->descriptors[s].relocs[bias + i].bo,
2291 bindings->descriptors[s].relocs[bias + i].offset);
2292
2293 static const uint32_t binding_table_opcodes[] = {
2294 [VK_SHADER_STAGE_VERTEX] = 38,
2295 [VK_SHADER_STAGE_TESS_CONTROL] = 39,
2296 [VK_SHADER_STAGE_TESS_EVALUATION] = 40,
2297 [VK_SHADER_STAGE_GEOMETRY] = 41,
2298 [VK_SHADER_STAGE_FRAGMENT] = 42,
2299 [VK_SHADER_STAGE_COMPUTE] = 0,
2300 };
2301
2302 anv_batch_emit(&cmd_buffer->batch,
2303 GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS,
2304 ._3DCommandSubOpcode = binding_table_opcodes[s],
2305 .PointertoVSBindingTable = state.offset);
2306 }
2307
2308 if (layout && layout->stage[s].sampler_count > 0) {
2309 struct anv_state state;
2310 size_t size;
2311
2312 size = layout->stage[s].sampler_count * 16;
2313 state = anv_state_stream_alloc(&cmd_buffer->dynamic_state_stream, size, 32);
2314 memcpy(state.map, bindings->descriptors[s].samplers, size);
2315
2316 static const uint32_t sampler_state_opcodes[] = {
2317 [VK_SHADER_STAGE_VERTEX] = 43,
2318 [VK_SHADER_STAGE_TESS_CONTROL] = 44, /* HS */
2319 [VK_SHADER_STAGE_TESS_EVALUATION] = 45, /* DS */
2320 [VK_SHADER_STAGE_GEOMETRY] = 46,
2321 [VK_SHADER_STAGE_FRAGMENT] = 47,
2322 [VK_SHADER_STAGE_COMPUTE] = 0,
2323 };
2324
2325 anv_batch_emit(&cmd_buffer->batch,
2326 GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS,
2327 ._3DCommandSubOpcode = sampler_state_opcodes[s],
2328 .PointertoVSSamplerState = state.offset);
2329 }
2330 }
2331 }
2332
2333 static void
2334 anv_cmd_buffer_flush_state(struct anv_cmd_buffer *cmd_buffer)
2335 {
2336 struct anv_pipeline *pipeline = cmd_buffer->pipeline;
2337 struct anv_bindings *bindings = cmd_buffer->bindings;
2338 const uint32_t num_buffers = __builtin_popcount(cmd_buffer->vb_dirty);
2339 const uint32_t num_dwords = 1 + num_buffers * 4;
2340 uint32_t *p;
2341
2342 if (cmd_buffer->vb_dirty) {
2343 p = anv_batch_emitn(&cmd_buffer->batch, num_dwords,
2344 GEN8_3DSTATE_VERTEX_BUFFERS);
2345 uint32_t vb, i = 0;
2346 for_each_bit(vb, cmd_buffer->vb_dirty) {
2347 struct anv_buffer *buffer = bindings->vb[vb].buffer;
2348 uint32_t offset = bindings->vb[vb].offset;
2349
2350 struct GEN8_VERTEX_BUFFER_STATE state = {
2351 .VertexBufferIndex = vb,
2352 .MemoryObjectControlState = 0,
2353 .AddressModifyEnable = true,
2354 .BufferPitch = pipeline->binding_stride[vb],
2355 .BufferStartingAddress = { buffer->bo, buffer->offset + offset },
2356 .BufferSize = buffer->size - offset
2357 };
2358
2359 GEN8_VERTEX_BUFFER_STATE_pack(&cmd_buffer->batch, &p[1 + i * 4], &state);
2360 i++;
2361 }
2362 }
2363
2364 if (cmd_buffer->dirty & ANV_CMD_BUFFER_PIPELINE_DIRTY)
2365 anv_batch_emit_batch(&cmd_buffer->batch, &pipeline->batch);
2366
2367 if (cmd_buffer->dirty & ANV_CMD_BUFFER_DESCRIPTOR_SET_DIRTY)
2368 flush_descriptor_sets(cmd_buffer);
2369
2370 if (cmd_buffer->dirty & (ANV_CMD_BUFFER_PIPELINE_DIRTY | ANV_CMD_BUFFER_RS_DIRTY))
2371 anv_batch_emit_merge(&cmd_buffer->batch,
2372 cmd_buffer->rs_state->state_sf, pipeline->state_sf);
2373
2374 cmd_buffer->vb_dirty = 0;
2375 cmd_buffer->dirty = 0;
2376 }
2377
2378 void VKAPI vkCmdDraw(
2379 VkCmdBuffer cmdBuffer,
2380 uint32_t firstVertex,
2381 uint32_t vertexCount,
2382 uint32_t firstInstance,
2383 uint32_t instanceCount)
2384 {
2385 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2386
2387 anv_cmd_buffer_flush_state(cmd_buffer);
2388
2389 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
2390 .VertexAccessType = SEQUENTIAL,
2391 .VertexCountPerInstance = vertexCount,
2392 .StartVertexLocation = firstVertex,
2393 .InstanceCount = instanceCount,
2394 .StartInstanceLocation = firstInstance,
2395 .BaseVertexLocation = 0);
2396 }
2397
2398 void VKAPI vkCmdDrawIndexed(
2399 VkCmdBuffer cmdBuffer,
2400 uint32_t firstIndex,
2401 uint32_t indexCount,
2402 int32_t vertexOffset,
2403 uint32_t firstInstance,
2404 uint32_t instanceCount)
2405 {
2406 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2407
2408 anv_cmd_buffer_flush_state(cmd_buffer);
2409
2410 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
2411 .VertexAccessType = RANDOM,
2412 .VertexCountPerInstance = indexCount,
2413 .StartVertexLocation = firstIndex,
2414 .InstanceCount = instanceCount,
2415 .StartInstanceLocation = firstInstance,
2416 .BaseVertexLocation = 0);
2417 }
2418
2419 static void
2420 anv_batch_lrm(struct anv_batch *batch,
2421 uint32_t reg, struct anv_bo *bo, uint32_t offset)
2422 {
2423 anv_batch_emit(batch, GEN8_MI_LOAD_REGISTER_MEM,
2424 .RegisterAddress = reg,
2425 .MemoryAddress = { bo, offset });
2426 }
2427
2428 static void
2429 anv_batch_lri(struct anv_batch *batch, uint32_t reg, uint32_t imm)
2430 {
2431 anv_batch_emit(batch, GEN8_MI_LOAD_REGISTER_IMM,
2432 .RegisterOffset = reg,
2433 .DataDWord = imm);
2434 }
2435
2436 /* Auto-Draw / Indirect Registers */
2437 #define GEN7_3DPRIM_END_OFFSET 0x2420
2438 #define GEN7_3DPRIM_START_VERTEX 0x2430
2439 #define GEN7_3DPRIM_VERTEX_COUNT 0x2434
2440 #define GEN7_3DPRIM_INSTANCE_COUNT 0x2438
2441 #define GEN7_3DPRIM_START_INSTANCE 0x243C
2442 #define GEN7_3DPRIM_BASE_VERTEX 0x2440
2443
2444 void VKAPI vkCmdDrawIndirect(
2445 VkCmdBuffer cmdBuffer,
2446 VkBuffer _buffer,
2447 VkDeviceSize offset,
2448 uint32_t count,
2449 uint32_t stride)
2450 {
2451 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2452 struct anv_buffer *buffer = (struct anv_buffer *) _buffer;
2453 struct anv_bo *bo = buffer->bo;
2454 uint32_t bo_offset = buffer->offset + offset;
2455
2456 anv_cmd_buffer_flush_state(cmd_buffer);
2457
2458 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset);
2459 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4);
2460 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8);
2461 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 12);
2462 anv_batch_lri(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, 0);
2463
2464 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
2465 .IndirectParameterEnable = true,
2466 .VertexAccessType = SEQUENTIAL);
2467 }
2468
2469 void VKAPI vkCmdDrawIndexedIndirect(
2470 VkCmdBuffer cmdBuffer,
2471 VkBuffer _buffer,
2472 VkDeviceSize offset,
2473 uint32_t count,
2474 uint32_t stride)
2475 {
2476 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2477 struct anv_buffer *buffer = (struct anv_buffer *) _buffer;
2478 struct anv_bo *bo = buffer->bo;
2479 uint32_t bo_offset = buffer->offset + offset;
2480
2481 anv_cmd_buffer_flush_state(cmd_buffer);
2482
2483 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_VERTEX_COUNT, bo, bo_offset);
2484 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_INSTANCE_COUNT, bo, bo_offset + 4);
2485 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_VERTEX, bo, bo_offset + 8);
2486 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_BASE_VERTEX, bo, bo_offset + 12);
2487 anv_batch_lrm(&cmd_buffer->batch, GEN7_3DPRIM_START_INSTANCE, bo, bo_offset + 16);
2488
2489 anv_batch_emit(&cmd_buffer->batch, GEN8_3DPRIMITIVE,
2490 .IndirectParameterEnable = true,
2491 .VertexAccessType = RANDOM);
2492 }
2493
2494 void VKAPI vkCmdDispatch(
2495 VkCmdBuffer cmdBuffer,
2496 uint32_t x,
2497 uint32_t y,
2498 uint32_t z)
2499 {
2500 stub();
2501 }
2502
2503 void VKAPI vkCmdDispatchIndirect(
2504 VkCmdBuffer cmdBuffer,
2505 VkBuffer buffer,
2506 VkDeviceSize offset)
2507 {
2508 stub();
2509 }
2510
2511 void VKAPI vkCmdSetEvent(
2512 VkCmdBuffer cmdBuffer,
2513 VkEvent event,
2514 VkPipeEvent pipeEvent)
2515 {
2516 stub();
2517 }
2518
2519 void VKAPI vkCmdResetEvent(
2520 VkCmdBuffer cmdBuffer,
2521 VkEvent event,
2522 VkPipeEvent pipeEvent)
2523 {
2524 stub();
2525 }
2526
2527 void VKAPI vkCmdWaitEvents(
2528 VkCmdBuffer cmdBuffer,
2529 VkWaitEvent waitEvent,
2530 uint32_t eventCount,
2531 const VkEvent* pEvents,
2532 uint32_t memBarrierCount,
2533 const void** ppMemBarriers)
2534 {
2535 stub();
2536 }
2537
2538 void VKAPI vkCmdPipelineBarrier(
2539 VkCmdBuffer cmdBuffer,
2540 VkWaitEvent waitEvent,
2541 uint32_t pipeEventCount,
2542 const VkPipeEvent* pPipeEvents,
2543 uint32_t memBarrierCount,
2544 const void** ppMemBarriers)
2545 {
2546 stub();
2547 }
2548
2549 static void
2550 anv_batch_emit_ps_depth_count(struct anv_batch *batch,
2551 struct anv_bo *bo, uint32_t offset)
2552 {
2553 anv_batch_emit(batch, GEN8_PIPE_CONTROL,
2554 .DestinationAddressType = DAT_PPGTT,
2555 .PostSyncOperation = WritePSDepthCount,
2556 .Address = { bo, offset }); /* FIXME: This is only lower 32 bits */
2557 }
2558
2559 void VKAPI vkCmdBeginQuery(
2560 VkCmdBuffer cmdBuffer,
2561 VkQueryPool queryPool,
2562 uint32_t slot,
2563 VkQueryControlFlags flags)
2564 {
2565 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2566 struct anv_query_pool *pool = (struct anv_query_pool *) queryPool;
2567
2568 switch (pool->type) {
2569 case VK_QUERY_TYPE_OCCLUSION:
2570 anv_batch_emit_ps_depth_count(&cmd_buffer->batch, &pool->bo, slot * 16);
2571 break;
2572
2573 case VK_QUERY_TYPE_PIPELINE_STATISTICS:
2574 break;
2575
2576 default:
2577 break;
2578 }
2579 }
2580
2581 void VKAPI vkCmdEndQuery(
2582 VkCmdBuffer cmdBuffer,
2583 VkQueryPool queryPool,
2584 uint32_t slot)
2585 {
2586 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2587 struct anv_query_pool *pool = (struct anv_query_pool *) queryPool;
2588
2589 switch (pool->type) {
2590 case VK_QUERY_TYPE_OCCLUSION:
2591 anv_batch_emit_ps_depth_count(&cmd_buffer->batch, &pool->bo, slot * 16 + 8);
2592 break;
2593
2594 case VK_QUERY_TYPE_PIPELINE_STATISTICS:
2595 break;
2596
2597 default:
2598 break;
2599 }
2600 }
2601
2602 void VKAPI vkCmdResetQueryPool(
2603 VkCmdBuffer cmdBuffer,
2604 VkQueryPool queryPool,
2605 uint32_t startQuery,
2606 uint32_t queryCount)
2607 {
2608 stub();
2609 }
2610
2611 #define TIMESTAMP 0x44070
2612
2613 void VKAPI vkCmdWriteTimestamp(
2614 VkCmdBuffer cmdBuffer,
2615 VkTimestampType timestampType,
2616 VkBuffer destBuffer,
2617 VkDeviceSize destOffset)
2618 {
2619 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2620 struct anv_buffer *buffer = (struct anv_buffer *) destBuffer;
2621 struct anv_bo *bo = buffer->bo;
2622
2623 switch (timestampType) {
2624 case VK_TIMESTAMP_TYPE_TOP:
2625 anv_batch_emit(&cmd_buffer->batch, GEN8_MI_STORE_REGISTER_MEM,
2626 .RegisterAddress = TIMESTAMP,
2627 .MemoryAddress = { bo, buffer->offset + destOffset });
2628 break;
2629
2630 case VK_TIMESTAMP_TYPE_BOTTOM:
2631 anv_batch_emit(&cmd_buffer->batch, GEN8_PIPE_CONTROL,
2632 .DestinationAddressType = DAT_PPGTT,
2633 .PostSyncOperation = WriteTimestamp,
2634 .Address = /* FIXME: This is only lower 32 bits */
2635 { bo, buffer->offset + destOffset });
2636 break;
2637
2638 default:
2639 break;
2640 }
2641 }
2642
2643 void VKAPI vkCmdCopyQueryPoolResults(
2644 VkCmdBuffer cmdBuffer,
2645 VkQueryPool queryPool,
2646 uint32_t startQuery,
2647 uint32_t queryCount,
2648 VkBuffer destBuffer,
2649 VkDeviceSize destOffset,
2650 VkDeviceSize destStride,
2651 VkQueryResultFlags flags)
2652 {
2653 stub();
2654 }
2655
2656 void VKAPI vkCmdInitAtomicCounters(
2657 VkCmdBuffer cmdBuffer,
2658 VkPipelineBindPoint pipelineBindPoint,
2659 uint32_t startCounter,
2660 uint32_t counterCount,
2661 const uint32_t* pData)
2662 {
2663 stub();
2664 }
2665
2666 void VKAPI vkCmdLoadAtomicCounters(
2667 VkCmdBuffer cmdBuffer,
2668 VkPipelineBindPoint pipelineBindPoint,
2669 uint32_t startCounter,
2670 uint32_t counterCount,
2671 VkBuffer srcBuffer,
2672 VkDeviceSize srcOffset)
2673 {
2674 stub();
2675 }
2676
2677 void VKAPI vkCmdSaveAtomicCounters(
2678 VkCmdBuffer cmdBuffer,
2679 VkPipelineBindPoint pipelineBindPoint,
2680 uint32_t startCounter,
2681 uint32_t counterCount,
2682 VkBuffer destBuffer,
2683 VkDeviceSize destOffset)
2684 {
2685 stub();
2686 }
2687
2688 VkResult VKAPI vkCreateFramebuffer(
2689 VkDevice _device,
2690 const VkFramebufferCreateInfo* pCreateInfo,
2691 VkFramebuffer* pFramebuffer)
2692 {
2693 struct anv_device *device = (struct anv_device *) _device;
2694 struct anv_framebuffer *framebuffer;
2695
2696 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
2697
2698 framebuffer = anv_device_alloc(device, sizeof(*framebuffer), 8,
2699 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
2700 if (framebuffer == NULL)
2701 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2702
2703 framebuffer->color_attachment_count = pCreateInfo->colorAttachmentCount;
2704 for (uint32_t i = 0; i < pCreateInfo->colorAttachmentCount; i++) {
2705 framebuffer->color_attachments[i] =
2706 (struct anv_surface_view *) pCreateInfo->pColorAttachments[i].view;
2707 }
2708
2709 if (pCreateInfo->pDepthStencilAttachment) {
2710 framebuffer->depth_stencil =
2711 (struct anv_depth_stencil_view *) pCreateInfo->pDepthStencilAttachment->view;
2712 }
2713
2714 framebuffer->sample_count = pCreateInfo->sampleCount;
2715 framebuffer->width = pCreateInfo->width;
2716 framebuffer->height = pCreateInfo->height;
2717 framebuffer->layers = pCreateInfo->layers;
2718
2719 vkCreateDynamicViewportState((VkDevice) device,
2720 &(VkDynamicVpStateCreateInfo) {
2721 .sType = VK_STRUCTURE_TYPE_DYNAMIC_VP_STATE_CREATE_INFO,
2722 .viewportAndScissorCount = 2,
2723 .pViewports = (VkViewport[]) {
2724 {
2725 .originX = 0,
2726 .originY = 0,
2727 .width = pCreateInfo->width,
2728 .height = pCreateInfo->height,
2729 .minDepth = 0,
2730 .maxDepth = 1
2731 },
2732 },
2733 .pScissors = (VkRect[]) {
2734 { { 0, 0 },
2735 { pCreateInfo->width, pCreateInfo->height } },
2736 }
2737 },
2738 &framebuffer->vp_state);
2739
2740 *pFramebuffer = (VkFramebuffer) framebuffer;
2741
2742 return VK_SUCCESS;
2743 }
2744
2745 VkResult VKAPI vkCreateRenderPass(
2746 VkDevice _device,
2747 const VkRenderPassCreateInfo* pCreateInfo,
2748 VkRenderPass* pRenderPass)
2749 {
2750 struct anv_device *device = (struct anv_device *) _device;
2751 struct anv_render_pass *pass;
2752 size_t size;
2753
2754 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
2755
2756 size = sizeof(*pass) +
2757 pCreateInfo->layers * sizeof(struct anv_render_pass_layer);
2758 pass = anv_device_alloc(device, size, 8,
2759 VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
2760 if (pass == NULL)
2761 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
2762
2763 pass->render_area = pCreateInfo->renderArea;
2764
2765 pass->num_layers = pCreateInfo->layers;
2766
2767 pass->num_clear_layers = 0;
2768 for (uint32_t i = 0; i < pCreateInfo->layers; i++) {
2769 pass->layers[i].color_load_op = pCreateInfo->pColorLoadOps[i];
2770 pass->layers[i].clear_color = pCreateInfo->pColorLoadClearValues[i];
2771 if (pass->layers[i].color_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR)
2772 pass->num_clear_layers++;
2773 }
2774
2775 *pRenderPass = (VkRenderPass) pass;
2776
2777 return VK_SUCCESS;
2778 }
2779
2780 void
2781 anv_cmd_buffer_fill_render_targets(struct anv_cmd_buffer *cmd_buffer)
2782 {
2783 struct anv_framebuffer *framebuffer = cmd_buffer->framebuffer;
2784 struct anv_bindings *bindings = cmd_buffer->bindings;
2785
2786 for (uint32_t i = 0; i < framebuffer->color_attachment_count; i++) {
2787 struct anv_surface_view *view = framebuffer->color_attachments[i];
2788
2789 bindings->descriptors[VK_SHADER_STAGE_FRAGMENT].surfaces[i] = view->surface_state.offset;
2790 bindings->descriptors[VK_SHADER_STAGE_FRAGMENT].relocs[i].bo = view->bo;
2791 bindings->descriptors[VK_SHADER_STAGE_FRAGMENT].relocs[i].offset = view->offset;
2792 }
2793 cmd_buffer->dirty |= ANV_CMD_BUFFER_DESCRIPTOR_SET_DIRTY;
2794 }
2795
2796 void VKAPI vkCmdBeginRenderPass(
2797 VkCmdBuffer cmdBuffer,
2798 const VkRenderPassBegin* pRenderPassBegin)
2799 {
2800 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *) cmdBuffer;
2801 struct anv_render_pass *pass = (struct anv_render_pass *) pRenderPassBegin->renderPass;
2802 struct anv_framebuffer *framebuffer =
2803 (struct anv_framebuffer *) pRenderPassBegin->framebuffer;
2804
2805 cmd_buffer->framebuffer = framebuffer;
2806
2807 anv_batch_emit(&cmd_buffer->batch, GEN8_3DSTATE_DRAWING_RECTANGLE,
2808 .ClippedDrawingRectangleYMin = pass->render_area.offset.y,
2809 .ClippedDrawingRectangleXMin = pass->render_area.offset.x,
2810 .ClippedDrawingRectangleYMax =
2811 pass->render_area.offset.y + pass->render_area.extent.height - 1,
2812 .ClippedDrawingRectangleXMax =
2813 pass->render_area.offset.x + pass->render_area.extent.width - 1,
2814 .DrawingRectangleOriginY = 0,
2815 .DrawingRectangleOriginX = 0);
2816
2817 anv_cmd_buffer_fill_render_targets(cmd_buffer);
2818
2819 anv_cmd_buffer_clear(cmd_buffer, pass);
2820 }
2821
2822 void VKAPI vkCmdEndRenderPass(
2823 VkCmdBuffer cmdBuffer,
2824 VkRenderPass renderPass)
2825 {
2826 /* Emit a flushing pipe control at the end of a pass. This is kind of a
2827 * hack but it ensures that render targets always actually get written.
2828 * Eventually, we should do flushing based on image format transitions
2829 * or something of that nature.
2830 */
2831 struct anv_cmd_buffer *cmd_buffer = (struct anv_cmd_buffer *)cmdBuffer;
2832 anv_batch_emit(&cmd_buffer->batch, GEN8_PIPE_CONTROL,
2833 .PostSyncOperation = NoWrite,
2834 .RenderTargetCacheFlushEnable = true,
2835 .InstructionCacheInvalidateEnable = true,
2836 .DepthCacheFlushEnable = true,
2837 .VFCacheInvalidationEnable = true,
2838 .TextureCacheInvalidationEnable = true,
2839 .CommandStreamerStallEnable = true);
2840
2841 stub();
2842 }