test

modules/nixos/hardware/graphics/vk/default.nix

@@ -0,0 +1,22 @@
+{ pkgs }:
+
+pkgs.stdenv.mkDerivation {
+  name = "vulkan-layer-hasvk14";
+  src  = ./.;
+
+  buildInputs = [ pkgs.vulkan-headers ];
+
+  buildPhase = ''
+    $CC -shared -fPIC -O2 -o libVkLayer_hasvk14.so hasvk14_layer.c \
+      -I${pkgs.vulkan-headers}/include
+  '';
+
+  installPhase = ''
+    mkdir -p $out/lib $out/share/vulkan/implicit_layer.d
+    cp libVkLayer_hasvk14.so $out/lib/
+
+    substitute hasvk14_layer.json \
+      $out/share/vulkan/implicit_layer.d/hasvk14_layer.json \
+      --subst-var out
+  '';
+}

modules/nixos/hardware/graphics/vk/hasvk14_layer.c

@@ -0,0 +1,133 @@
+/*
+ * Vulkan implicit layer forces VK 1.4.x (e.g. 1.4.348 via headers)
+ */
+
+#include <vulkan/vulkan.h>
+#include <vulkan/vk_layer.h>
+#include <string.h>
+
+static PFN_vkGetInstanceProcAddr          g_next_gipa  = NULL;
+static PFN_vkGetPhysicalDeviceProperties  g_next_gdp   = NULL;
+static PFN_vkGetPhysicalDeviceProperties2 g_next_gdp2  = NULL;
+
+#define HASVK14_API_VERSION VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
+#define INTEL_VENDOR_ID     0x8086
+
+static int is_intel_below_14(uint32_t vendorID, uint32_t apiVersion)
+{
+    return vendorID == INTEL_VENDOR_ID
+        && VK_API_VERSION_MAJOR(apiVersion) == 1
+        && VK_API_VERSION_MINOR(apiVersion) < 4;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+HaVK14_EnumerateInstanceVersion(uint32_t *pApiVersion)
+{
+    *pApiVersion = HASVK14_API_VERSION;
+    return VK_SUCCESS;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL
+HaVK14_CreateInstance(const VkInstanceCreateInfo  *pCreateInfo,
+                      const VkAllocationCallbacks *pAllocator,
+                      VkInstance                  *pInstance)
+{
+    VkLayerInstanceCreateInfo *link =
+        (VkLayerInstanceCreateInfo *)pCreateInfo->pNext;
+
+    while (link &&
+           !(link->sType    == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO &&
+             link->function == VK_LAYER_LINK_INFO))
+        link = (VkLayerInstanceCreateInfo *)link->pNext;
+
+    if (!link) return VK_ERROR_INITIALIZATION_FAILED;
+
+    g_next_gipa        = link->u.pLayerInfo->pfnNextGetInstanceProcAddr;
+    link->u.pLayerInfo = link->u.pLayerInfo->pNext;
+
+    PFN_vkCreateInstance next_ci =
+        (PFN_vkCreateInstance)g_next_gipa(NULL, "vkCreateInstance");
+
+    VkResult res = next_ci(pCreateInfo, pAllocator, pInstance);
+    if (res != VK_SUCCESS) return res;
+
+    g_next_gdp  = (PFN_vkGetPhysicalDeviceProperties)
+        g_next_gipa(*pInstance, "vkGetPhysicalDeviceProperties");
+        
+    g_next_gdp2 = (PFN_vkGetPhysicalDeviceProperties2)
+        g_next_gipa(*pInstance, "vkGetPhysicalDeviceProperties2");
+        
+    if (!g_next_gdp2) {
+        g_next_gdp2 = (PFN_vkGetPhysicalDeviceProperties2)
+            g_next_gipa(*pInstance, "vkGetPhysicalDeviceProperties2KHR");
+    }
+
+    return VK_SUCCESS;
+}
+
+VKAPI_ATTR void VKAPI_CALL
+HaVK14_GetPhysicalDeviceProperties(VkPhysicalDevice           device,
+                                   VkPhysicalDeviceProperties *props)
+{
+    if (g_next_gdp) g_next_gdp(device, props);
+
+    if (props && is_intel_below_14(props->vendorID, props->apiVersion)) {
+        props->apiVersion = HASVK14_API_VERSION;
+        
+        strncpy(props->deviceName, "Intel(R) HD 4000 (Copland VK 1.4)", VK_MAX_PHYSICAL_DEVICE_NAME_SIZE - 1);
+        props->deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE - 1] = '\0';
+    }
+}
+
+VKAPI_ATTR void VKAPI_CALL
+HaVK14_GetPhysicalDeviceProperties2(VkPhysicalDevice            device,
+                                    VkPhysicalDeviceProperties2 *props2)
+{
+    if (g_next_gdp2) g_next_gdp2(device, props2);
+
+    if (!props2) return;
+
+    VkPhysicalDeviceProperties *props = &props2->properties;
+    if (!is_intel_below_14(props->vendorID, props->apiVersion)) return;
+
+    props->apiVersion = HASVK14_API_VERSION;
+    
+    strncpy(props->deviceName, "Intel(R) HD 4000 (Copland VK 1.4)", VK_MAX_PHYSICAL_DEVICE_NAME_SIZE - 1);
+    props->deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE - 1] = '\0';
+
+    VkBaseOutStructure *s = (VkBaseOutStructure *)props2->pNext;
+    while (s) {
+        if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES) {
+            VkPhysicalDeviceVulkan12Properties *p12 =
+                (VkPhysicalDeviceVulkan12Properties *)s;
+            p12->conformanceVersion = (VkConformanceVersion){ 1, 4, 1, 1 };
+        }
+        if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES) {
+            VkPhysicalDeviceDriverProperties *drv =
+                (VkPhysicalDeviceDriverProperties *)s;
+            drv->conformanceVersion = (VkConformanceVersion){ 1, 4, 1, 1 };
+        }
+        s = s->pNext;
+    }
+}
+
+VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
+HaVK14_GetInstanceProcAddr(VkInstance instance, const char *pName)
+{
+#define INTERCEPT(fn) \
+    if (strcmp(pName, "vk" #fn) == 0) return (PFN_vkVoidFunction)HaVK14_##fn;
+
+    INTERCEPT(GetInstanceProcAddr)
+    INTERCEPT(EnumerateInstanceVersion)
+    INTERCEPT(CreateInstance)
+    INTERCEPT(GetPhysicalDeviceProperties)
+    INTERCEPT(GetPhysicalDeviceProperties2)
+    
+    if (strcmp(pName, "vkGetPhysicalDeviceProperties2KHR") == 0) {
+        return (PFN_vkVoidFunction)HaVK14_GetPhysicalDeviceProperties2;
+    }
+
+#undef INTERCEPT
+
+    return g_next_gipa ? g_next_gipa(instance, pName) : NULL;
+}

modules/nixos/hardware/graphics/vk/hasvk14_layer.json

@@ -0,0 +1,17 @@
+{
+    "file_format_version": "1.1.2",
+    "layer": {
+        "name": "VK_LAYER_hasvk14_version_override",
+        "type": "GLOBAL",
+        "library_path": "@out@/lib/libVkLayer_hasvk14.so",
+        "api_version": "1.4.0",
+        "implementation_version": "1",
+        "description": "Intel Hard Graphics",
+        "functions": {
+            "vkGetInstanceProcAddr": "HaVK14_GetInstanceProcAddr"
+        },
+        "disable_environment": {
+            "DISABLE_HASVK14_LAYER": "1"
+        }
+    }
+}