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