Skip to content

Commit b59baef

Browse files
spencer-lunargspencer-lunarg
committed
layers: Fix DRM on Pixel CI device
1 parent d093178 commit b59baef

5 files changed

Lines changed: 209 additions & 115 deletions

File tree

‎tests/framework/layer_validation_tests.cpp‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,37 @@ VkResult GetImageFormatProps(VkPhysicalDevice gpu, const VkImageCreateInfo& ci,
9090
return vk::GetPhysicalDeviceImageFormatProperties(gpu, ci.format, ci.imageType, ci.tiling, ci.usage, ci.flags, &out_limits);
9191
}
9292

93+
bool IsDrmModifierSupported(VkPhysicalDevice gpu, uint64_t drm_format_modifier, const VkImageCreateInfo& ci,
94+
const void* image_format_info_pnext) {
95+
VkPhysicalDeviceImageDrmFormatModifierInfoEXT drm_format_modifier_info =
96+
vku::InitStructHelper(const_cast<void*>(image_format_info_pnext));
97+
drm_format_modifier_info.drmFormatModifier = drm_format_modifier;
98+
drm_format_modifier_info.sharingMode = ci.sharingMode;
99+
drm_format_modifier_info.queueFamilyIndexCount = ci.queueFamilyIndexCount;
100+
drm_format_modifier_info.pQueueFamilyIndices = ci.pQueueFamilyIndices;
101+
102+
VkPhysicalDeviceImageFormatInfo2 image_format_info = vku::InitStructHelper(&drm_format_modifier_info);
103+
image_format_info.format = ci.format;
104+
image_format_info.type = ci.imageType;
105+
image_format_info.tiling = ci.tiling;
106+
image_format_info.usage = ci.usage;
107+
image_format_info.flags = ci.flags;
108+
109+
VkImageFormatProperties2 image_format_properties = vku::InitStructHelper();
110+
return vk::GetPhysicalDeviceImageFormatProperties2(gpu, &image_format_info, &image_format_properties) == VK_SUCCESS;
111+
}
112+
113+
std::vector<uint64_t> GetSupportedDrmModifiers(VkPhysicalDevice gpu, const std::vector<uint64_t>& drm_format_modifiers,
114+
const VkImageCreateInfo& ci, const void* image_format_info_pnext) {
115+
std::vector<uint64_t> supported;
116+
for (uint64_t drm_format_modifier : drm_format_modifiers) {
117+
if (IsDrmModifierSupported(gpu, drm_format_modifier, ci, image_format_info_pnext)) {
118+
supported.push_back(drm_format_modifier);
119+
}
120+
}
121+
return supported;
122+
}
123+
93124
bool IsImageFormatSupported(const VkPhysicalDevice gpu, const VkImageCreateInfo& ci, const VkFormatFeatureFlags features) {
94125
// Verify physical device support of format features
95126
if (!FormatFeaturesAreSupported(gpu, ci.format, ci.tiling, features)) {

‎tests/framework/layer_validation_tests.h‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -110,6 +110,12 @@ bool FormatFeatures2AreSupported(VkPhysicalDevice gpu, VkFormat format, VkImageT
110110
// Small wrapprer around vkGetPhysicalDeviceImageFormatProperties
111111
VkResult GetImageFormatProps(VkPhysicalDevice gpu, const VkImageCreateInfo &ci, VkImageFormatProperties &out_limits);
112112

113+
// VK_EXT_image_drm_format_modifier
114+
bool IsDrmModifierSupported(VkPhysicalDevice gpu, uint64_t drm_format_modifier, const VkImageCreateInfo& ci,
115+
const void* image_format_info_pnext = nullptr);
116+
std::vector<uint64_t> GetSupportedDrmModifiers(VkPhysicalDevice gpu, const std::vector<uint64_t>& drm_format_modifiers,
117+
const VkImageCreateInfo& ci, const void* image_format_info_pnext = nullptr);
118+
113119
// Returns true if format and *all* requested features are available.
114120
bool IsImageFormatSupported(VkPhysicalDevice gpu, const VkImageCreateInfo &ci, const VkFormatFeatureFlags features);
115121

‎tests/unit/image_drm.cpp‎

Lines changed: 87 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,9 @@
1616

1717
class NegativeImageDrm : public ImageDrmTest {};
1818

19+
// DRM_FORMAT_MOD_INVALID
20+
static constexpr uint64_t kDrmFormatModInvalid = 0x00FFFFFFFFFFFFFFULL;
21+
1922
TEST_F(NegativeImageDrm, Basic) {
2023
RETURN_IF_SKIP(InitBasicImageDrm());
2124

@@ -107,6 +110,11 @@ TEST_F(NegativeImageDrm, Basic2) {
107110

108111
VkSubresourceLayout fake_plane_layout = {0, 0, 0, 0, 0};
109112

113+
mods = GetSupportedDrmModifiers(Gpu(), mods, image_info);
114+
if (mods.size() < 2) {
115+
GTEST_SKIP() << "Need 2 valid Format Modifiers";
116+
}
117+
110118
VkImageDrmFormatModifierListCreateInfoEXT drm_format_mod_list = vku::InitStructHelper();
111119
drm_format_mod_list.drmFormatModifierCount = mods.size();
112120
drm_format_mod_list.pDrmFormatModifiers = mods.data();
@@ -187,10 +195,7 @@ TEST_F(NegativeImageDrm, GetImageSubresourceLayoutPlane) {
187195
GTEST_SKIP() << "No valid Format Modifier found";
188196
}
189197

190-
VkImageDrmFormatModifierListCreateInfoEXT list_create_info = vku::InitStructHelper();
191-
list_create_info.drmFormatModifierCount = mods.size();
192-
list_create_info.pDrmFormatModifiers = mods.data();
193-
VkImageCreateInfo create_info = vku::InitStructHelper(&list_create_info);
198+
VkImageCreateInfo create_info = vku::InitStructHelper();
194199
create_info.imageType = VK_IMAGE_TYPE_2D;
195200
create_info.format = format;
196201
create_info.extent = {64, 64, 1};
@@ -200,23 +205,16 @@ TEST_F(NegativeImageDrm, GetImageSubresourceLayoutPlane) {
200205
create_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
201206
create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
202207

203-
for (uint64_t mod : mods) {
204-
VkPhysicalDeviceImageDrmFormatModifierInfoEXT drm_format_modifier = vku::InitStructHelper();
205-
drm_format_modifier.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
206-
drm_format_modifier.drmFormatModifier = mod;
207-
VkPhysicalDeviceImageFormatInfo2 image_info = vku::InitStructHelper(&drm_format_modifier);
208-
image_info.format = format;
209-
image_info.type = create_info.imageType;
210-
image_info.tiling = create_info.tiling;
211-
image_info.usage = create_info.usage;
212-
image_info.flags = create_info.flags;
213-
VkImageFormatProperties2 image_properties = vku::InitStructHelper();
214-
if (vk::GetPhysicalDeviceImageFormatProperties2(Gpu(), &image_info, &image_properties) != VK_SUCCESS) {
215-
// Works with Mesa, Pixel 7 doesn't support this combo
216-
GTEST_SKIP() << "Required formats/features not supported";
217-
}
208+
mods = GetSupportedDrmModifiers(Gpu(), mods, create_info);
209+
if (mods.empty()) {
210+
GTEST_SKIP() << "Required formats/features not supported";
218211
}
219212

213+
VkImageDrmFormatModifierListCreateInfoEXT list_create_info = vku::InitStructHelper();
214+
list_create_info.drmFormatModifierCount = mods.size();
215+
list_create_info.pDrmFormatModifiers = mods.data();
216+
create_info.pNext = &list_create_info;
217+
220218
vkt::Image image(*m_device, create_info, vkt::no_mem);
221219
if (image.initialized() == false) {
222220
GTEST_SKIP() << "Failed to create image.";
@@ -466,10 +464,7 @@ TEST_F(NegativeImageDrm, MultiPlanarGetImageMemoryRequirements) {
466464
GTEST_SKIP() << "No valid Format Modifier found";
467465
}
468466

469-
auto list_create_info = vku::InitStruct<VkImageDrmFormatModifierListCreateInfoEXT>();
470-
list_create_info.drmFormatModifierCount = mods.size();
471-
list_create_info.pDrmFormatModifiers = mods.data();
472-
auto create_info = vku::InitStruct<VkImageCreateInfo>(&list_create_info);
467+
auto create_info = vku::InitStruct<VkImageCreateInfo>();
473468
create_info.flags = VK_IMAGE_CREATE_DISJOINT_BIT;
474469
create_info.imageType = VK_IMAGE_TYPE_2D;
475470
create_info.format = format;
@@ -480,22 +475,16 @@ TEST_F(NegativeImageDrm, MultiPlanarGetImageMemoryRequirements) {
480475
create_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
481476
create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
482477

483-
for (uint64_t mod : mods) {
484-
auto drm_format_modifier = vku::InitStruct<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>();
485-
drm_format_modifier.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
486-
drm_format_modifier.drmFormatModifier = mod;
487-
auto image_info = vku::InitStruct<VkPhysicalDeviceImageFormatInfo2>(&drm_format_modifier);
488-
image_info.format = format;
489-
image_info.type = create_info.imageType;
490-
image_info.tiling = create_info.tiling;
491-
image_info.usage = create_info.usage;
492-
image_info.flags = create_info.flags;
493-
auto image_properties = vku::InitStruct<VkImageFormatProperties2>();
494-
if (vk::GetPhysicalDeviceImageFormatProperties2(Gpu(), &image_info, &image_properties) != VK_SUCCESS) {
495-
GTEST_SKIP() << "Required formats/features not supported";
496-
}
478+
mods = GetSupportedDrmModifiers(Gpu(), mods, create_info);
479+
if (mods.empty()) {
480+
GTEST_SKIP() << "Required formats/features not supported";
497481
}
498482

483+
auto list_create_info = vku::InitStruct<VkImageDrmFormatModifierListCreateInfoEXT>();
484+
list_create_info.drmFormatModifierCount = mods.size();
485+
list_create_info.pDrmFormatModifiers = mods.data();
486+
create_info.pNext = &list_create_info;
487+
499488
vkt::Image image(*m_device, create_info, vkt::no_mem);
500489
if (image.initialized() == false) {
501490
GTEST_SKIP() << "Failed to create image.";
@@ -523,10 +512,7 @@ TEST_F(NegativeImageDrm, MultiPlanarBindMemory) {
523512
GTEST_SKIP() << "No valid Format Modifier found";
524513
}
525514

526-
auto list_create_info = vku::InitStruct<VkImageDrmFormatModifierListCreateInfoEXT>();
527-
list_create_info.drmFormatModifierCount = mods.size();
528-
list_create_info.pDrmFormatModifiers = mods.data();
529-
auto create_info = vku::InitStruct<VkImageCreateInfo>(&list_create_info);
515+
auto create_info = vku::InitStruct<VkImageCreateInfo>();
530516
create_info.flags = VK_IMAGE_CREATE_DISJOINT_BIT;
531517
create_info.imageType = VK_IMAGE_TYPE_2D;
532518
create_info.format = format;
@@ -537,22 +523,16 @@ TEST_F(NegativeImageDrm, MultiPlanarBindMemory) {
537523
create_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
538524
create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
539525

540-
for (uint64_t mod : mods) {
541-
auto drm_format_modifier = vku::InitStruct<VkPhysicalDeviceImageDrmFormatModifierInfoEXT>();
542-
drm_format_modifier.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
543-
drm_format_modifier.drmFormatModifier = mod;
544-
auto image_info = vku::InitStruct<VkPhysicalDeviceImageFormatInfo2>(&drm_format_modifier);
545-
image_info.format = format;
546-
image_info.type = create_info.imageType;
547-
image_info.tiling = create_info.tiling;
548-
image_info.usage = create_info.usage;
549-
image_info.flags = create_info.flags;
550-
auto image_properties = vku::InitStruct<VkImageFormatProperties2>();
551-
if (vk::GetPhysicalDeviceImageFormatProperties2(Gpu(), &image_info, &image_properties) != VK_SUCCESS) {
552-
GTEST_SKIP() << "Required formats/features not supported";
553-
}
526+
mods = GetSupportedDrmModifiers(Gpu(), mods, create_info);
527+
if (mods.empty()) {
528+
GTEST_SKIP() << "Required formats/features not supported";
554529
}
555530

531+
auto list_create_info = vku::InitStruct<VkImageDrmFormatModifierListCreateInfoEXT>();
532+
list_create_info.drmFormatModifierCount = mods.size();
533+
list_create_info.pDrmFormatModifiers = mods.data();
534+
create_info.pNext = &list_create_info;
535+
556536
vkt::Image image(*m_device, create_info, vkt::no_mem);
557537
if (image.initialized() == false) {
558538
GTEST_SKIP() << "Failed to create image.";
@@ -690,14 +670,8 @@ TEST_F(NegativeImageDrm, ModifierListUnsupportedModifier) {
690670
if (mods.empty()) {
691671
GTEST_SKIP() << "No valid Format Modifier found";
692672
}
693-
// DRM_FORMAT_MOD_INVALID, will never be reported as supported
694-
mods.push_back(0x00FFFFFFFFFFFFFFULL);
695-
696-
VkImageDrmFormatModifierListCreateInfoEXT mod_list = vku::InitStructHelper();
697-
mod_list.drmFormatModifierCount = static_cast<uint32_t>(mods.size());
698-
mod_list.pDrmFormatModifiers = mods.data();
699673

700-
VkImageCreateInfo image_ci = vku::InitStructHelper(&mod_list);
674+
VkImageCreateInfo image_ci = vku::InitStructHelper();
701675
image_ci.imageType = VK_IMAGE_TYPE_2D;
702676
image_ci.format = VK_FORMAT_R8G8B8A8_UNORM;
703677
image_ci.extent = {64, 64, 1};
@@ -707,6 +681,21 @@ TEST_F(NegativeImageDrm, ModifierListUnsupportedModifier) {
707681
image_ci.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
708682
image_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
709683
image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
684+
685+
mods = GetSupportedDrmModifiers(Gpu(), mods, image_ci);
686+
if (mods.empty()) {
687+
GTEST_SKIP() << "No valid Format Modifier found";
688+
}
689+
if (IsDrmModifierSupported(Gpu(), kDrmFormatModInvalid, image_ci)) {
690+
GTEST_SKIP() << "Driver reports DRM_FORMAT_MOD_INVALID as supported";
691+
}
692+
mods.push_back(kDrmFormatModInvalid);
693+
694+
VkImageDrmFormatModifierListCreateInfoEXT mod_list = vku::InitStructHelper();
695+
mod_list.drmFormatModifierCount = static_cast<uint32_t>(mods.size());
696+
mod_list.pDrmFormatModifiers = mods.data();
697+
image_ci.pNext = &mod_list;
698+
710699
CreateImageTest(image_ci, "VUID-VkImageDrmFormatModifierListCreateInfoEXT-pDrmFormatModifiers-02263");
711700
}
712701

@@ -721,7 +710,7 @@ TEST_F(NegativeImageDrm, ExplicitUnsupportedModifier) {
721710
VkSubresourceLayout plane_layouts[2] = {{0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}};
722711

723712
VkImageDrmFormatModifierExplicitCreateInfoEXT mod_explicit = vku::InitStructHelper();
724-
mod_explicit.drmFormatModifier = 0x00FFFFFFFFFFFFFFULL; // DRM_FORMAT_MOD_INVALID
713+
mod_explicit.drmFormatModifier = kDrmFormatModInvalid;
725714
mod_explicit.drmFormatModifierPlaneCount = 1;
726715
mod_explicit.pPlaneLayouts = plane_layouts;
727716

@@ -736,9 +725,43 @@ TEST_F(NegativeImageDrm, ExplicitUnsupportedModifier) {
736725
image_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
737726
image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
738727

728+
if (IsDrmModifierSupported(Gpu(), kDrmFormatModInvalid, image_ci)) {
729+
GTEST_SKIP() << "Driver reports DRM_FORMAT_MOD_INVALID as supported";
730+
}
731+
739732
CreateImageTest(image_ci, "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264");
733+
}
740734

741-
mod_explicit.drmFormatModifier = mods[0];
735+
TEST_F(NegativeImageDrm, ExplicitPlaneCountMismatch) {
736+
RETURN_IF_SKIP(InitBasicImageDrm());
737+
738+
std::vector<uint64_t> mods = GetFormatModifier(VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT);
739+
if (mods.empty()) {
740+
GTEST_SKIP() << "No valid Format Modifier found";
741+
}
742+
743+
VkSubresourceLayout plane_layouts[2] = {{0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}};
744+
745+
VkImageDrmFormatModifierExplicitCreateInfoEXT mod_explicit = vku::InitStructHelper();
742746
mod_explicit.drmFormatModifierPlaneCount = 2;
747+
mod_explicit.pPlaneLayouts = plane_layouts;
748+
749+
VkImageCreateInfo image_ci = vku::InitStructHelper(&mod_explicit);
750+
image_ci.imageType = VK_IMAGE_TYPE_2D;
751+
image_ci.format = VK_FORMAT_R8G8B8A8_UNORM;
752+
image_ci.extent = {64, 64, 1};
753+
image_ci.mipLevels = 1;
754+
image_ci.arrayLayers = 1;
755+
image_ci.samples = VK_SAMPLE_COUNT_1_BIT;
756+
image_ci.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT;
757+
image_ci.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
758+
image_ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
759+
760+
mods = GetSupportedDrmModifiers(Gpu(), mods, image_ci);
761+
if (mods.empty()) {
762+
GTEST_SKIP() << "No valid Format Modifier found";
763+
}
764+
mod_explicit.drmFormatModifier = mods[0];
765+
743766
CreateImageTest(image_ci, "VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265");
744767
}

0 commit comments

Comments
 (0)