vulkan_device: Lift VK_EXT_extended_dynamic_state blacklist on RDNA

It seems to be safe to use this on new drivers.

src/core/hle/service/am/am.cpp

@@ -856,7 +856,7 @@ public:
             {25, nullptr, "Terminate"},
             {30, &ILibraryAppletAccessor::GetResult, "GetResult"},
             {50, nullptr, "SetOutOfFocusApplicationSuspendingEnabled"},
-            {60, nullptr, "PresetLibraryAppletGpuTimeSliceZero"},
+            {60, &ILibraryAppletAccessor::PresetLibraryAppletGpuTimeSliceZero, "PresetLibraryAppletGpuTimeSliceZero"},
             {100, &ILibraryAppletAccessor::PushInData, "PushInData"},
             {101, &ILibraryAppletAccessor::PopOutData, "PopOutData"},
             {102, nullptr, "PushExtraStorage"},
@@ -900,6 +900,13 @@ private:
         rb.Push(applet->GetStatus());
     }
 
+    void PresetLibraryAppletGpuTimeSliceZero(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_AM, "(STUBBED) called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
     void Start(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_AM, "called");
 

src/core/hle/service/lbl/lbl.cpp

@@ -20,30 +20,30 @@ public:
         static const FunctionInfo functions[] = {
             {0, nullptr, "SaveCurrentSetting"},
             {1, nullptr, "LoadCurrentSetting"},
-            {2, nullptr, "SetCurrentBrightnessSetting"},
-            {3, nullptr, "GetCurrentBrightnessSetting"},
+            {2, &LBL::SetCurrentBrightnessSetting, "SetCurrentBrightnessSetting"},
+            {3, &LBL::GetCurrentBrightnessSetting, "GetCurrentBrightnessSetting"},
             {4, nullptr, "ApplyCurrentBrightnessSettingToBacklight"},
             {5, nullptr, "GetBrightnessSettingAppliedToBacklight"},
-            {6, nullptr, "SwitchBacklightOn"},
-            {7, nullptr, "SwitchBacklightOff"},
-            {8, nullptr, "GetBacklightSwitchStatus"},
-            {9, nullptr, "EnableDimming"},
-            {10, nullptr, "DisableDimming"},
-            {11, nullptr, "IsDimmingEnabled"},
-            {12, nullptr, "EnableAutoBrightnessControl"},
-            {13, nullptr, "DisableAutoBrightnessControl"},
-            {14, nullptr, "IsAutoBrightnessControlEnabled"},
-            {15, nullptr, "SetAmbientLightSensorValue"},
-            {16, nullptr, "GetAmbientLightSensorValue"},
-            {17, nullptr, "SetBrightnessReflectionDelayLevel"},
-            {18, nullptr, "GetBrightnessReflectionDelayLevel"},
-            {19, nullptr, "SetCurrentBrightnessMapping"},
-            {20, nullptr, "GetCurrentBrightnessMapping"},
-            {21, nullptr, "SetCurrentAmbientLightSensorMapping"},
-            {22, nullptr, "GetCurrentAmbientLightSensorMapping"},
-            {23, nullptr, "IsAmbientLightSensorAvailable"},
-            {24, nullptr, "SetCurrentBrightnessSettingForVrMode"},
-            {25, nullptr, "GetCurrentBrightnessSettingForVrMode"},
+            {6, &LBL::SwitchBacklightOn, "SwitchBacklightOn"},
+            {7, &LBL::SwitchBacklightOff, "SwitchBacklightOff"},
+            {8, &LBL::GetBacklightSwitchStatus, "GetBacklightSwitchStatus"},
+            {9, &LBL::EnableDimming, "EnableDimming"},
+            {10, &LBL::DisableDimming, "DisableDimming"},
+            {11, &LBL::IsDimmingEnabled, "IsDimmingEnabled"},
+            {12, &LBL::EnableAutoBrightnessControl, "EnableAutoBrightnessControl"},
+            {13, &LBL::DisableAutoBrightnessControl, "DisableAutoBrightnessControl"},
+            {14, &LBL::IsAutoBrightnessControlEnabled, "IsAutoBrightnessControlEnabled"},
+            {15, &LBL::SetAmbientLightSensorValue, "SetAmbientLightSensorValue"},
+            {16, &LBL::GetAmbientLightSensorValue, "GetAmbientLightSensorValue"},
+            {17, &LBL::SetBrightnessReflectionDelayLevel, "SetBrightnessReflectionDelayLevel"},
+            {18, &LBL::GetBrightnessReflectionDelayLevel, "GetBrightnessReflectionDelayLevel"},
+            {19, &LBL::SetCurrentBrightnessMapping, "SetCurrentBrightnessMapping"},
+            {20, &LBL::GetCurrentBrightnessMapping, "GetCurrentBrightnessMapping"},
+            {21, &LBL::SetCurrentAmbientLightSensorMapping, "SetCurrentAmbientLightSensorMapping"},
+            {22, &LBL::GetCurrentAmbientLightSensorMapping, "GetCurrentAmbientLightSensorMapping"},
+            {23, &LBL::IsAmbientLightSensorAvailable, "IsAmbientLightSensorAvailable"},
+            {24, &LBL::SetCurrentBrightnessSettingForVrMode, "SetCurrentBrightnessSettingForVrMode"},
+            {25, &LBL::GetCurrentBrightnessSettingForVrMode, "GetCurrentBrightnessSettingForVrMode"},
             {26, &LBL::EnableVrMode, "EnableVrMode"},
             {27, &LBL::DisableVrMode, "DisableVrMode"},
             {28, &LBL::IsVrModeEnabled, "IsVrModeEnabled"},
@@ -55,6 +55,237 @@ public:
     }
 
 private:
+    enum class BacklightSwitchStatus : u32 {
+        Off = 0,
+        On = 1,
+    };
+
+    void SetCurrentBrightnessSetting(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        auto brightness = rp.Pop<float>();
+
+        if (!std::isfinite(brightness)) {
+            LOG_ERROR(Service_LBL, "Brightness is infinite!");
+            brightness = 0.0f;
+        }
+
+        LOG_DEBUG(Service_LBL, "called brightness={}", brightness);
+
+        current_brightness = brightness;
+        update_instantly = true;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetCurrentBrightnessSetting(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        auto brightness = current_brightness;
+        if (!std::isfinite(brightness)) {
+            LOG_ERROR(Service_LBL, "Brightness is infinite!");
+            brightness = 0.0f;
+        }
+
+        LOG_DEBUG(Service_LBL, "called brightness={}", brightness);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(brightness);
+    }
+
+    void SwitchBacklightOn(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto fade_time = rp.Pop<u64_le>();
+        LOG_WARNING(Service_LBL, "(STUBBED) called, fade_time={}", fade_time);
+
+        backlight_enabled = true;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void SwitchBacklightOff(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto fade_time = rp.Pop<u64_le>();
+        LOG_WARNING(Service_LBL, "(STUBBED) called, fade_time={}", fade_time);
+
+        backlight_enabled = false;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetBacklightSwitchStatus(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushEnum<BacklightSwitchStatus>(backlight_enabled ? BacklightSwitchStatus::On
+                                                             : BacklightSwitchStatus::Off);
+    }
+
+    void EnableDimming(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+
+        dimming = true;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void DisableDimming(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+
+        dimming = false;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void IsDimmingEnabled(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(dimming);
+    }
+
+    void EnableAutoBrightnessControl(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+        auto_brightness = true;
+        update_instantly = true;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void DisableAutoBrightnessControl(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+        auto_brightness = false;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void IsAutoBrightnessControlEnabled(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(auto_brightness);
+    }
+
+    void SetAmbientLightSensorValue(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto light_value = rp.Pop<float>();
+
+        LOG_DEBUG(Service_LBL, "called light_value={}", light_value);
+
+        ambient_light_value = light_value;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetAmbientLightSensorValue(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(ambient_light_value);
+    }
+
+    void SetBrightnessReflectionDelayLevel(Kernel::HLERequestContext& ctx) {
+        // This is Intentional, this function does absolutely nothing
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetBrightnessReflectionDelayLevel(Kernel::HLERequestContext& ctx) {
+        // This is intentional, the function is hard coded to return 0.0f on hardware
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(0.0f);
+    }
+
+    void SetCurrentBrightnessMapping(Kernel::HLERequestContext& ctx) {
+        // This is Intentional, this function does absolutely nothing
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetCurrentBrightnessMapping(Kernel::HLERequestContext& ctx) {
+        // This is Intentional, this function does absolutely nothing
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        // This function is suppose to return something but it seems like it doesn't
+    }
+
+    void SetCurrentAmbientLightSensorMapping(Kernel::HLERequestContext& ctx) {
+        // This is Intentional, this function does absolutely nothing
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetCurrentAmbientLightSensorMapping(Kernel::HLERequestContext& ctx) {
+        // This is Intentional, this function does absolutely nothing
+        LOG_DEBUG(Service_LBL, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+        // This function is suppose to return something but it seems like it doesn't
+    }
+
+    void IsAmbientLightSensorAvailable(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_LBL, "(STUBBED) called");
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        // TODO(ogniK): Only return true if there's no device error
+        rb.Push(true);
+    }
+
+    void SetCurrentBrightnessSettingForVrMode(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        auto brightness = rp.Pop<float>();
+
+        if (!std::isfinite(brightness)) {
+            LOG_ERROR(Service_LBL, "Brightness is infinite!");
+            brightness = 0.0f;
+        }
+
+        LOG_DEBUG(Service_LBL, "called brightness={}", brightness);
+
+        current_vr_brightness = brightness;
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetCurrentBrightnessSettingForVrMode(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        auto brightness = current_vr_brightness;
+        if (!std::isfinite(brightness)) {
+            LOG_ERROR(Service_LBL, "Brightness is infinite!");
+            brightness = 0.0f;
+        }
+
+        LOG_DEBUG(Service_LBL, "called brightness={}", brightness);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(brightness);
+    }
+
     void EnableVrMode(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_LBL, "called");
 
@@ -82,6 +313,14 @@ private:
     }
 
     bool vr_mode_enabled = false;
+    float current_brightness = 1.0f;
+    float backlight_brightness = 1.0f;
+    float ambient_light_value = 0.0f;
+    float current_vr_brightness = 1.0f;
+    bool dimming = true;
+    bool backlight_enabled = true;
+    bool update_instantly = false;
+    bool auto_brightness = false; // TODO(ogniK): Move to system settings
 };
 
 void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {

src/input_common/sdl/sdl_impl.cpp

@@ -81,10 +81,14 @@ public:
     }
 
     bool RumblePlay(u16 amp_low, u16 amp_high) {
+        constexpr u32 rumble_max_duration_ms = 1000;
+
         if (sdl_controller) {
-            return SDL_GameControllerRumble(sdl_controller.get(), amp_low, amp_high, 0) == 0;
+            return SDL_GameControllerRumble(sdl_controller.get(), amp_low, amp_high,
+                                            rumble_max_duration_ms) == 0;
         } else if (sdl_joystick) {
-            return SDL_JoystickRumble(sdl_joystick.get(), amp_low, amp_high, 0) == 0;
+            return SDL_JoystickRumble(sdl_joystick.get(), amp_low, amp_high,
+                                      rumble_max_duration_ms) == 0;
         }
 
         return false;

src/video_core/host_shaders/CMakeLists.txt

@@ -55,7 +55,7 @@ foreach(FILENAME IN ITEMS ${SHADER_FILES})
             OUTPUT
                 ${SPIRV_HEADER_FILE}
             COMMAND
-                ${GLSLANGVALIDATOR} -V ${GLSL_FLAGS} --variable-name ${SPIRV_VARIABLE_NAME} -o ${SPIRV_HEADER_FILE} ${SOURCE_FILE}
+                ${GLSLANGVALIDATOR} -V --quiet ${GLSL_FLAGS} --variable-name ${SPIRV_VARIABLE_NAME} -o ${SPIRV_HEADER_FILE} ${SOURCE_FILE}
             MAIN_DEPENDENCY
                 ${SOURCE_FILE}
         )

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -355,14 +355,12 @@ VKPipelineCache::DecompileShaders(const FixedPipelineState& fixed_state) {
     SPIRVProgram program;
     std::vector<VkDescriptorSetLayoutBinding> bindings;
 
-    for (std::size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
+    for (std::size_t index = 1; index < Maxwell::MaxShaderProgram; ++index) {
         const auto program_enum = static_cast<Maxwell::ShaderProgram>(index);
-
         // Skip stages that are not enabled
         if (!maxwell3d.regs.IsShaderConfigEnabled(index)) {
             continue;
         }
-
         const GPUVAddr gpu_addr = GetShaderAddress(maxwell3d, program_enum);
         const std::optional<VAddr> cpu_addr = gpu_memory.GpuToCpuAddress(gpu_addr);
         Shader* const shader = cpu_addr ? TryGet(*cpu_addr) : null_shader.get();
@@ -372,12 +370,8 @@ VKPipelineCache::DecompileShaders(const FixedPipelineState& fixed_state) {
         const auto& entries = shader->GetEntries();
         program[stage] = {
             Decompile(device, shader->GetIR(), program_type, shader->GetRegistry(), specialization),
-            entries};
-
-        if (program_enum == Maxwell::ShaderProgram::VertexA) {
-            // VertexB was combined with VertexA, so we skip the VertexB iteration
-            ++index;
-        }
+            entries,
+        };
 
         const u32 old_binding = specialization.base_binding;
         specialization.base_binding =

src/video_core/shader/shader_ir.cpp

@@ -392,7 +392,7 @@ void ShaderIR::SetInternalFlagsFromInteger(NodeBlock& bb, Node value, bool sets_
     case 0: // Operation Node
         SearchOperands(bb, value);
         break;
-    case 2: // Genral Purpose Node
+    case 2: // General Purpose Node
         if (const auto* gpr = std::get_if<GprNode>(value.get())) {
             LOG_DEBUG(HW_GPU, "GprNode: index={}", gpr->GetIndex());
             Node zerop = Operation(OperationCode::LogicalIEqual, std::move(value),

src/video_core/vulkan_common/vulkan_device.cpp

@@ -84,21 +84,6 @@ VkFormatFeatureFlags GetFormatFeatures(VkFormatProperties properties, FormatType
     }
 }
 
-[[nodiscard]] bool IsRDNA(std::string_view device_name, VkDriverIdKHR driver_id) {
-    static constexpr std::array RDNA_DEVICES{
-        "5700",
-        "5600",
-        "5500",
-        "5300",
-    };
-    if (driver_id != VK_DRIVER_ID_AMD_PROPRIETARY_KHR) {
-        return false;
-    }
-    return std::any_of(RDNA_DEVICES.begin(), RDNA_DEVICES.end(), [device_name](const char* name) {
-        return device_name.find(name) != std::string_view::npos;
-    });
-}
-
 std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::PhysicalDevice physical) {
     static constexpr std::array formats{
         VK_FORMAT_A8B8G8R8_UNORM_PACK32,
@@ -436,14 +421,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             "Blacklisting RADV for VK_EXT_extended_dynamic state, likely due to a bug in yuzu");
         ext_extended_dynamic_state = false;
     }
-    if (ext_extended_dynamic_state && IsRDNA(properties.deviceName, driver_id)) {
-        // AMD's proprietary driver supports VK_EXT_extended_dynamic_state but on RDNA devices it
-        // seems to cause stability issues
-        LOG_WARNING(
-            Render_Vulkan,
-            "Blacklisting AMD proprietary on RDNA devices from VK_EXT_extended_dynamic_state");
-        ext_extended_dynamic_state = false;
-    }
 
     graphics_queue = logical.GetQueue(graphics_family);
     present_queue = logical.GetQueue(present_family);