X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fintel%2Fvulkan%2Fanv_android.c;h=8e6d0b65ea1ed84c71f27042b4b0b775be6febba;hb=512db7ec78a9d334e561ef0f6a3ae68aa10a6824;hp=1f6f1bc56e30b2bee66b9838a6e4b0bf901e4163;hpb=f1654fa7e313a97e8849973b6877700bbdb2ce06;p=mesa.git diff --git a/src/intel/vulkan/anv_android.c b/src/intel/vulkan/anv_android.c index 1f6f1bc56e3..8e6d0b65ea1 100644 --- a/src/intel/vulkan/anv_android.c +++ b/src/intel/vulkan/anv_android.c @@ -22,6 +22,11 @@ */ #include + +#if ANDROID_API_LEVEL >= 26 +#include +#endif + #include #include #include @@ -98,6 +103,7 @@ anv_hal_close(struct hw_device_t *dev) return -1; } +#if ANDROID_API_LEVEL >= 26 static VkResult get_ahw_buffer_format_properties( VkDevice device_h, @@ -120,12 +126,12 @@ get_ahw_buffer_format_properties( * one of the AHARDWAREBUFFER_USAGE_GPU_* usage flags." */ if (!(desc.usage & (gpu_usage))) - return VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR; + return VK_ERROR_INVALID_EXTERNAL_HANDLE; /* Fill properties fields based on description. */ VkAndroidHardwareBufferFormatPropertiesANDROID *p = pProperties; - p->format = vk_format_from_android(desc.format); + p->format = vk_format_from_android(desc.format, desc.usage); const struct anv_format *anv_format = anv_get_format(p->format); p->externalFormat = (uint64_t) (uintptr_t) anv_format; @@ -185,7 +191,6 @@ anv_GetAndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID *pProperties) { ANV_FROM_HANDLE(anv_device, dev, device_h); - struct anv_physical_device *pdevice = &dev->instance->physicalDevice; VkAndroidHardwareBufferFormatPropertiesANDROID *format_prop = vk_find_struct(pProperties->pNext, @@ -204,10 +209,10 @@ anv_GetAndroidHardwareBufferPropertiesANDROID( AHardwareBuffer_getNativeHandle(buffer); int dma_buf = (handle && handle->numFds) ? handle->data[0] : -1; if (dma_buf < 0) - return VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR; + return VK_ERROR_INVALID_EXTERNAL_HANDLE; /* All memory types. */ - uint32_t memory_types = (1ull << pdevice->memory.type_count) - 1; + uint32_t memory_types = (1ull << dev->physical->memory.type_count) - 1; pProperties->allocationSize = lseek(dma_buf, 0, SEEK_END); pProperties->memoryTypeBits = memory_types; @@ -215,6 +220,36 @@ anv_GetAndroidHardwareBufferPropertiesANDROID( return VK_SUCCESS; } +VkResult +anv_GetMemoryAndroidHardwareBufferANDROID( + VkDevice device_h, + const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, + struct AHardwareBuffer **pBuffer) +{ + ANV_FROM_HANDLE(anv_device_memory, mem, pInfo->memory); + + /* Some quotes from Vulkan spec: + * + * "If the device memory was created by importing an Android hardware + * buffer, vkGetMemoryAndroidHardwareBufferANDROID must return that same + * Android hardware buffer object." + * + * "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must + * have been included in VkExportMemoryAllocateInfo::handleTypes when + * memory was created." + */ + if (mem->ahw) { + *pBuffer = mem->ahw; + /* Increase refcount. */ + AHardwareBuffer_acquire(mem->ahw); + return VK_SUCCESS; + } + + return VK_ERROR_OUT_OF_HOST_MEMORY; +} + +#endif + /* Construct ahw usage mask from image usage bits, see * 'AHardwareBuffer Usage Equivalence' in Vulkan spec. */ @@ -223,7 +258,7 @@ anv_ahw_usage_from_vk_usage(const VkImageCreateFlags vk_create, const VkImageUsageFlags vk_usage) { uint64_t ahw_usage = 0; - +#if ANDROID_API_LEVEL >= 26 if (vk_usage & VK_IMAGE_USAGE_SAMPLED_BIT) ahw_usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE; @@ -242,38 +277,10 @@ anv_ahw_usage_from_vk_usage(const VkImageCreateFlags vk_create, /* No usage bits set - set at least one GPU usage. */ if (ahw_usage == 0) ahw_usage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE; - +#endif return ahw_usage; } -VkResult -anv_GetMemoryAndroidHardwareBufferANDROID( - VkDevice device_h, - const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo, - struct AHardwareBuffer **pBuffer) -{ - ANV_FROM_HANDLE(anv_device_memory, mem, pInfo->memory); - - /* Some quotes from Vulkan spec: - * - * "If the device memory was created by importing an Android hardware - * buffer, vkGetMemoryAndroidHardwareBufferANDROID must return that same - * Android hardware buffer object." - * - * "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must - * have been included in VkExportMemoryAllocateInfoKHR::handleTypes when - * memory was created." - */ - if (mem->ahw) { - *pBuffer = mem->ahw; - /* Increase refcount. */ - AHardwareBuffer_acquire(mem->ahw); - return VK_SUCCESS; - } - - return VK_ERROR_OUT_OF_HOST_MEMORY; -} - /* * Called from anv_AllocateMemory when import AHardwareBuffer. */ @@ -282,6 +289,7 @@ anv_import_ahw_memory(VkDevice device_h, struct anv_device_memory *mem, const VkImportAndroidHardwareBufferInfoANDROID *info) { +#if ANDROID_API_LEVEL >= 26 ANV_FROM_HANDLE(anv_device, device, device_h); /* Import from AHardwareBuffer to anv_device_memory. */ @@ -295,17 +303,12 @@ anv_import_ahw_memory(VkDevice device_h, */ int dma_buf = (handle && handle->numFds) ? handle->data[0] : -1; if (dma_buf < 0) - return VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR; + return VK_ERROR_INVALID_EXTERNAL_HANDLE; - uint64_t bo_flags = ANV_BO_EXTERNAL; - if (device->instance->physicalDevice.supports_48bit_addresses) - bo_flags |= EXEC_OBJECT_SUPPORTS_48B_ADDRESS; - if (device->instance->physicalDevice.use_softpin) - bo_flags |= EXEC_OBJECT_PINNED; - - VkResult result = anv_bo_cache_import(device, &device->bo_cache, - dma_buf, bo_flags, &mem->bo); - assert(VK_SUCCESS); + VkResult result = anv_device_import_bo(device, dma_buf, 0, + 0 /* client_address */, + &mem->bo); + assert(result == VK_SUCCESS); /* "If the vkAllocateMemory command succeeds, the implementation must * acquire a reference to the imported hardware buffer, which it must @@ -316,6 +319,9 @@ anv_import_ahw_memory(VkDevice device_h, mem->ahw = info->buffer; return VK_SUCCESS; +#else + return VK_ERROR_EXTENSION_NOT_PRESENT; +#endif } VkResult @@ -323,6 +329,7 @@ anv_create_ahw_memory(VkDevice device_h, struct anv_device_memory *mem, const VkMemoryAllocateInfo *pAllocateInfo) { +#if ANDROID_API_LEVEL >= 26 ANV_FROM_HANDLE(anv_device, dev, device_h); const VkMemoryDedicatedAllocateInfo *dedicated_info = @@ -369,21 +376,25 @@ anv_create_ahw_memory(VkDevice device_h, return VK_ERROR_OUT_OF_HOST_MEMORY; mem->ahw = ahw; - return VK_SUCCESS; +#else + return VK_ERROR_EXTENSION_NOT_PRESENT; +#endif + } VkResult anv_image_from_external( VkDevice device_h, const VkImageCreateInfo *base_info, - const struct VkExternalMemoryImageCreateInfo *create_info, + const VkExternalMemoryImageCreateInfo *create_info, const VkAllocationCallbacks *alloc, VkImage *out_image_h) { +#if ANDROID_API_LEVEL >= 26 ANV_FROM_HANDLE(anv_device, device, device_h); - const struct VkExternalFormatANDROID *ext_info = + const VkExternalFormatANDROID *ext_info = vk_find_struct_const(base_info->pNext, EXTERNAL_FORMAT_ANDROID); if (ext_info && ext_info->externalFormat != 0) { @@ -407,8 +418,12 @@ anv_image_from_external( *out_image_h = image_h; return VK_SUCCESS; +#else + return VK_ERROR_EXTENSION_NOT_PRESENT; +#endif } + VkResult anv_image_from_gralloc(VkDevice device_h, const VkImageCreateInfo *base_info, @@ -429,8 +444,7 @@ anv_image_from_gralloc(VkDevice device_h, }; if (gralloc_info->handle->numFds != 1) { - return vk_errorf(device->instance, device, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, + return vk_errorf(device, device, VK_ERROR_INVALID_EXTERNAL_HANDLE, "VkNativeBufferANDROID::handle::numFds is %d, " "expected 1", gralloc_info->handle->numFds); } @@ -441,15 +455,22 @@ anv_image_from_gralloc(VkDevice device_h, */ int dma_buf = gralloc_info->handle->data[0]; - uint64_t bo_flags = ANV_BO_EXTERNAL; - if (device->instance->physicalDevice.supports_48bit_addresses) - bo_flags |= EXEC_OBJECT_SUPPORTS_48B_ADDRESS; - if (device->instance->physicalDevice.use_softpin) - bo_flags |= EXEC_OBJECT_PINNED; - - result = anv_bo_cache_import(device, &device->bo_cache, dma_buf, bo_flags, &bo); + /* We need to set the WRITE flag on window system buffers so that GEM will + * know we're writing to them and synchronize uses on other rings (for + * example, if the display server uses the blitter ring). + * + * If this function fails and if the imported bo was resident in the cache, + * we should avoid updating the bo's flags. Therefore, we defer updating + * the flags until success is certain. + * + */ + result = anv_device_import_bo(device, dma_buf, + ANV_BO_ALLOC_IMPLICIT_SYNC | + ANV_BO_ALLOC_IMPLICIT_WRITE, + 0 /* client_address */, + &bo); if (result != VK_SUCCESS) { - return vk_errorf(device->instance, device, result, + return vk_errorf(device, device, result, "failed to import dma-buf from VkNativeBufferANDROID"); } @@ -465,14 +486,12 @@ anv_image_from_gralloc(VkDevice device_h, anv_info.isl_tiling_flags = ISL_TILING_Y0_BIT; break; case -1: - result = vk_errorf(device->instance, device, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, + result = vk_errorf(device, device, VK_ERROR_INVALID_EXTERNAL_HANDLE, "DRM_IOCTL_I915_GEM_GET_TILING failed for " "VkNativeBufferANDROID"); goto fail_tiling; default: - result = vk_errorf(device->instance, device, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, + result = vk_errorf(device, device, VK_ERROR_INVALID_EXTERNAL_HANDLE, "DRM_IOCTL_I915_GEM_GET_TILING returned unknown " "tiling %d for VkNativeBufferANDROID", i915_tiling); goto fail_tiling; @@ -493,8 +512,7 @@ anv_image_from_gralloc(VkDevice device_h, goto fail_create; if (bo->size < image->size) { - result = vk_errorf(device->instance, device, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, + result = vk_errorf(device, device, VK_ERROR_INVALID_EXTERNAL_HANDLE, "dma-buf from VkNativeBufferANDROID is too small for " "VkImage: %"PRIu64"B < %"PRIu64"B", bo->size, image->size); @@ -507,18 +525,6 @@ anv_image_from_gralloc(VkDevice device_h, image->planes[0].address.bo = bo; image->planes[0].bo_is_owned = true; - /* We need to set the WRITE flag on window system buffers so that GEM will - * know we're writing to them and synchronize uses on other rings (for - * example, if the display server uses the blitter ring). - * - * If this function fails and if the imported bo was resident in the cache, - * we should avoid updating the bo's flags. Therefore, we defer updating - * the flags until success is certain. - * - */ - bo->flags &= ~EXEC_OBJECT_ASYNC; - bo->flags |= EXEC_OBJECT_WRITE; - /* Don't clobber the out-parameter until success is certain. */ *out_image_h = image_h; @@ -528,65 +534,59 @@ anv_image_from_gralloc(VkDevice device_h, anv_DestroyImage(device_h, image_h, alloc); fail_create: fail_tiling: - anv_bo_cache_release(device, &device->bo_cache, bo); + anv_device_release_bo(device, bo); return result; } -VkResult anv_GetSwapchainGrallocUsageANDROID( - VkDevice device_h, - VkFormat format, - VkImageUsageFlags imageUsage, - int* grallocUsage) +static VkResult +format_supported_with_usage(VkDevice device_h, VkFormat format, + VkImageUsageFlags imageUsage) { ANV_FROM_HANDLE(anv_device, device, device_h); - struct anv_physical_device *phys_dev = &device->instance->physicalDevice; - VkPhysicalDevice phys_dev_h = anv_physical_device_to_handle(phys_dev); + VkPhysicalDevice phys_dev_h = anv_physical_device_to_handle(device->physical); VkResult result; - *grallocUsage = 0; - intel_logd("%s: format=%d, usage=0x%x", __func__, format, imageUsage); - - /* WARNING: Android Nougat's libvulkan.so hardcodes the VkImageUsageFlags - * returned to applications via VkSurfaceCapabilitiesKHR::supportedUsageFlags. - * The relevant code in libvulkan/swapchain.cpp contains this fun comment: - * - * TODO(jessehall): I think these are right, but haven't thought hard - * about it. Do we need to query the driver for support of any of - * these? - * - * Any disagreement between this function and the hardcoded - * VkSurfaceCapabilitiesKHR:supportedUsageFlags causes tests - * dEQP-VK.wsi.android.swapchain.*.image_usage to fail. - */ - - const VkPhysicalDeviceImageFormatInfo2KHR image_format_info = { - .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, + const VkPhysicalDeviceImageFormatInfo2 image_format_info = { + .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, .format = format, .type = VK_IMAGE_TYPE_2D, .tiling = VK_IMAGE_TILING_OPTIMAL, .usage = imageUsage, }; - VkImageFormatProperties2KHR image_format_props = { - .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, + VkImageFormatProperties2 image_format_props = { + .sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, }; /* Check that requested format and usage are supported. */ result = anv_GetPhysicalDeviceImageFormatProperties2(phys_dev_h, &image_format_info, &image_format_props); if (result != VK_SUCCESS) { - return vk_errorf(device->instance, device, result, + return vk_errorf(device, device, result, "anv_GetPhysicalDeviceImageFormatProperties2 failed " "inside %s", __func__); } + return VK_SUCCESS; +} - /* Reject STORAGE here to avoid complexity elsewhere. */ - if (imageUsage & VK_IMAGE_USAGE_STORAGE_BIT) { - return vk_errorf(device->instance, device, VK_ERROR_FORMAT_NOT_SUPPORTED, - "VK_IMAGE_USAGE_STORAGE_BIT unsupported for gralloc " - "swapchain"); - } + +static VkResult +setup_gralloc0_usage(VkFormat format, VkImageUsageFlags imageUsage, + int *grallocUsage) +{ + /* WARNING: Android's libvulkan.so hardcodes the VkImageUsageFlags + * returned to applications via VkSurfaceCapabilitiesKHR::supportedUsageFlags. + * The relevant code in libvulkan/swapchain.cpp contains this fun comment: + * + * TODO(jessehall): I think these are right, but haven't thought hard + * about it. Do we need to query the driver for support of any of + * these? + * + * Any disagreement between this function and the hardcoded + * VkSurfaceCapabilitiesKHR:supportedUsageFlags causes tests + * dEQP-VK.wsi.android.swapchain.*.image_usage to fail. + */ if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) @@ -594,6 +594,7 @@ VkResult anv_GetSwapchainGrallocUsageANDROID( if (unmask32(&imageUsage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT)) *grallocUsage |= GRALLOC_USAGE_HW_TEXTURE; @@ -601,7 +602,7 @@ VkResult anv_GetSwapchainGrallocUsageANDROID( * gralloc swapchains. */ if (imageUsage != 0) { - return vk_errorf(device->instance, device, VK_ERROR_FORMAT_NOT_SUPPORTED, + return vk_errorf(device, device, VK_ERROR_FORMAT_NOT_SUPPORTED, "unsupported VkImageUsageFlags(0x%x) for gralloc " "swapchain", imageUsage); } @@ -615,7 +616,7 @@ VkResult anv_GetSwapchainGrallocUsageANDROID( */ switch (format) { case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_B5G6R5_UNORM_PACK16: + case VK_FORMAT_R5G6B5_UNORM_PACK16: case VK_FORMAT_R8G8B8A8_UNORM: case VK_FORMAT_R8G8B8A8_SRGB: *grallocUsage |= GRALLOC_USAGE_HW_FB | @@ -632,6 +633,71 @@ VkResult anv_GetSwapchainGrallocUsageANDROID( return VK_SUCCESS; } +#if ANDROID_API_LEVEL >= 26 +VkResult anv_GetSwapchainGrallocUsage2ANDROID( + VkDevice device_h, + VkFormat format, + VkImageUsageFlags imageUsage, + VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, + uint64_t* grallocConsumerUsage, + uint64_t* grallocProducerUsage) +{ + ANV_FROM_HANDLE(anv_device, device, device_h); + VkResult result; + + *grallocConsumerUsage = 0; + *grallocProducerUsage = 0; + intel_logd("%s: format=%d, usage=0x%x", __func__, format, imageUsage); + + result = format_supported_with_usage(device_h, format, imageUsage); + if (result != VK_SUCCESS) + return result; + + int32_t grallocUsage = 0; + result = setup_gralloc0_usage(format, imageUsage, &grallocUsage); + if (result != VK_SUCCESS) + return result; + + /* Setup gralloc1 usage flags from gralloc0 flags. */ + + if (grallocUsage & GRALLOC_USAGE_HW_RENDER) { + *grallocProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET; + *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET; + } + + if (grallocUsage & GRALLOC_USAGE_HW_TEXTURE) { + *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE; + } + + if (grallocUsage & (GRALLOC_USAGE_HW_FB | + GRALLOC_USAGE_HW_COMPOSER | + GRALLOC_USAGE_EXTERNAL_DISP)) { + *grallocProducerUsage |= GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET; + *grallocConsumerUsage |= GRALLOC1_CONSUMER_USAGE_HWCOMPOSER; + } + + return VK_SUCCESS; +} +#endif + +VkResult anv_GetSwapchainGrallocUsageANDROID( + VkDevice device_h, + VkFormat format, + VkImageUsageFlags imageUsage, + int* grallocUsage) +{ + VkResult result; + + *grallocUsage = 0; + intel_logd("%s: format=%d, usage=0x%x", __func__, format, imageUsage); + + result = format_supported_with_usage(device_h, format, imageUsage); + if (result != VK_SUCCESS) + return result; + + return setup_gralloc0_usage(format, imageUsage, grallocUsage); +} + VkResult anv_AcquireImageANDROID( VkDevice device_h, @@ -652,7 +718,7 @@ anv_AcquireImageANDROID( * VkFence. */ if (sync_wait(nativeFenceFd, /*timeout*/ -1) < 0) { - result = vk_errorf(device->instance, device, VK_ERROR_DEVICE_LOST, + result = vk_errorf(device, device, VK_ERROR_DEVICE_LOST, "%s: failed to wait on nativeFenceFd=%d", __func__, nativeFenceFd); } @@ -698,7 +764,7 @@ anv_AcquireImageANDROID( result = anv_QueueSubmit(anv_queue_to_handle(&device->queue), 1, &submit, fence_h); if (result != VK_SUCCESS) { - return vk_errorf(device->instance, device, result, + return vk_errorf(device, device, result, "anv_QueueSubmit failed inside %s", __func__); } }