"Merge Tagged PR 9042"

src/core/hle/service/ldn/lan_discovery.cpp

@@ -487,7 +487,7 @@ void LANDiscovery::ReceivePacket(const Network::LDNPacket& packet) {
     std::scoped_lock lock{packet_mutex};
     switch (packet.type) {
     case Network::LDNPacketType::Scan: {
-        LOG_INFO(Frontend, "Scan packet received!");
+        LOG_DEBUG(Frontend, "Scan packet received!");
         if (state == State::AccessPointCreated) {
             // Reply to the sender
             SendPacket(Network::LDNPacketType::ScanResp, network_info, packet.local_ip);
@@ -495,7 +495,7 @@ void LANDiscovery::ReceivePacket(const Network::LDNPacket& packet) {
         break;
     }
     case Network::LDNPacketType::ScanResp: {
-        LOG_INFO(Frontend, "ScanResp packet received!");
+        LOG_DEBUG(Frontend, "ScanResp packet received!");
 
         NetworkInfo info{};
         std::memcpy(&info, packet.data.data(), sizeof(NetworkInfo));
@@ -611,13 +611,6 @@ MacAddress LANDiscovery::GetFakeMac() const {
 
 Result LANDiscovery::GetNodeInfo(NodeInfo& node, const UserConfig& userConfig,
                                  u16 localCommunicationVersion) {
-    const auto network_interface = Network::GetSelectedNetworkInterface();
-
-    if (!network_interface) {
-        LOG_ERROR(Service_LDN, "No network interface available");
-        return ResultNoIpAddress;
-    }
-
     node.mac_address = GetFakeMac();
     node.is_connected = 1;
     std::memcpy(node.user_name.data(), userConfig.user_name.data(), UserNameBytesMax + 1);

src/core/hle/service/ldn/ldn.cpp

@@ -150,7 +150,7 @@ public:
     }
 
     ~IUserLocalCommunicationService() {
-        if (is_initialized) {
+        if (is_network_available) {
             if (auto room_member = room_network.GetRoomMember().lock()) {
                 room_member->Unbind(ldn_packet_received);
             }
@@ -193,7 +193,7 @@ public:
         NetworkInfo network_info{};
         const auto rc = lan_discovery.GetNetworkInfo(network_info);
         if (rc.IsError()) {
-            LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
+            LOG_DEBUG(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(rc);
             return;
@@ -205,6 +205,14 @@ public:
     }
 
     void GetIpv4Address(Kernel::HLERequestContext& ctx) {
+        if (!is_network_available) {
+            IPC::ResponseBuilder rb{ctx, 4};
+            rb.Push(ResultSuccess);
+            rb.PushRaw(Ipv4Address{127, 0, 0, 1});
+            rb.PushRaw(Ipv4Address{255, 255, 255, 0});
+            return;
+        }
+
         const auto network_interface = Network::GetSelectedNetworkInterface();
 
         if (!network_interface) {
@@ -342,6 +350,13 @@ public:
             return;
         }
 
+        if (!is_network_available) {
+            IPC::ResponseBuilder rb{ctx, 3};
+            rb.Push(ResultSuccess);
+            rb.Push(0);
+            return;
+        }
+
         u16 count = 0;
         std::vector<NetworkInfo> network_infos(network_info_size);
         Result rc = lan_discovery.Scan(network_infos, count, scan_filter);
@@ -488,18 +503,18 @@ public:
     }
 
     void Initialize(Kernel::HLERequestContext& ctx) {
-        const auto rc = InitializeImpl(ctx);
-        if (rc.IsError()) {
-            LOG_ERROR(Service_LDN, "Network isn't initialized, rc={}", rc.raw);
-        }
+        InitializeImpl(ctx);
 
+        // Initialize always returns success
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(rc);
+        rb.Push(ResultSuccess);
     }
 
     void Finalize(Kernel::HLERequestContext& ctx) {
-        if (auto room_member = room_network.GetRoomMember().lock()) {
-            room_member->Unbind(ldn_packet_received);
+        if (is_network_available) {
+            if (auto room_member = room_network.GetRoomMember().lock()) {
+                room_member->Unbind(ldn_packet_received);
+            }
         }
 
         is_initialized = false;
@@ -519,22 +534,25 @@ public:
     }
 
     Result InitializeImpl(Kernel::HLERequestContext& ctx) {
+        lan_discovery.Initialize([&]() { OnEventFired(); });
+        is_initialized = true;
+        is_network_available = false;
+
         const auto network_interface = Network::GetSelectedNetworkInterface();
         if (!network_interface) {
             LOG_ERROR(Service_LDN, "No network interface is set");
-            return ResultAirplaneModeEnabled;
+            return ResultSuccess;
         }
 
         if (auto room_member = room_network.GetRoomMember().lock()) {
             ldn_packet_received = room_member->BindOnLdnPacketReceived(
                 [this](const Network::LDNPacket& packet) { OnLDNPacketReceived(packet); });
+            is_network_available = true;
         } else {
             LOG_ERROR(Service_LDN, "Couldn't bind callback!");
-            return ResultAirplaneModeEnabled;
+            return ResultSuccess;
         }
 
-        lan_discovery.Initialize([&]() { OnEventFired(); });
-        is_initialized = true;
         return ResultSuccess;
     }
 
@@ -547,6 +565,7 @@ public:
     Network::RoomMember::CallbackHandle<Network::LDNPacket> ldn_packet_received;
 
     bool is_initialized{};
+    bool is_network_available{};
 };
 
 class LDNS final : public ServiceFramework<LDNS> {

src/core/internal_network/network_interface.cpp

@@ -200,7 +200,7 @@ std::optional<NetworkInterface> GetSelectedNetworkInterface() {
         });
 
     if (res == network_interfaces.end()) {
-        LOG_ERROR(Network, "Couldn't find selected interface \"{}\"", selected_network_interface);
+        LOG_DEBUG(Network, "Couldn't find selected interface \"{}\"", selected_network_interface);
         return std::nullopt;
     }
 

src/shader_recompiler/frontend/maxwell/translate_program.cpp

@@ -292,7 +292,7 @@ IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Blo
 
     Optimization::PositionPass(env, program);
 
-    Optimization::GlobalMemoryToStorageBufferPass(program, host_info);
+    Optimization::GlobalMemoryToStorageBufferPass(program);
     Optimization::TexturePass(env, program, host_info);
 
     if (Settings::values.resolution_info.active) {

src/shader_recompiler/host_translate_info.h

@@ -15,7 +15,6 @@ struct HostTranslateInfo {
     bool needs_demote_reorder{}; ///< True when the device needs DemoteToHelperInvocation reordered
     bool support_snorm_render_buffer{};  ///< True when the device supports SNORM render buffers
     bool support_viewport_index_layer{}; ///< True when the device supports gl_Layer in VS
-    u32 min_ssbo_alignment{};            ///< Minimum alignment supported by the device for SSBOs
     bool support_geometry_shader_passthrough{}; ///< True when the device supports geometry
                                                 ///< passthrough shaders
 };

src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp

@@ -11,7 +11,6 @@
 #include "shader_recompiler/frontend/ir/breadth_first_search.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 #include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/host_translate_info.h"
 #include "shader_recompiler/ir_opt/passes.h"
 
 namespace Shader::Optimization {
@@ -403,7 +402,7 @@ void CollectStorageBuffers(IR::Block& block, IR::Inst& inst, StorageInfo& info)
 }
 
 /// Returns the offset in indices (not bytes) for an equivalent storage instruction
-IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer, u32 alignment) {
+IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer) {
     IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
     IR::U32 offset;
     if (const std::optional<LowAddrInfo> low_addr{TrackLowAddress(&inst)}) {
@@ -416,10 +415,7 @@ IR::U32 StorageOffset(IR::Block& block, IR::Inst& inst, StorageBufferAddr buffer
     }
     // Subtract the least significant 32 bits from the guest offset. The result is the storage
     // buffer offset in bytes.
-    IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
-
-    // Align the offset base to match the host alignment requirements
-    low_cbuf = ir.BitwiseAnd(low_cbuf, ir.Imm32(~(alignment - 1U)));
+    const IR::U32 low_cbuf{ir.GetCbuf(ir.Imm32(buffer.index), ir.Imm32(buffer.offset))};
     return ir.ISub(offset, low_cbuf);
 }
 
@@ -514,7 +510,7 @@ void Replace(IR::Block& block, IR::Inst& inst, const IR::U32& storage_index,
 }
 } // Anonymous namespace
 
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info) {
+void GlobalMemoryToStorageBufferPass(IR::Program& program) {
     StorageInfo info;
     for (IR::Block* const block : program.post_order_blocks) {
         for (IR::Inst& inst : block->Instructions()) {
@@ -538,8 +534,7 @@ void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateIn
         const IR::U32 index{IR::Value{static_cast<u32>(info.set.index_of(it))}};
         IR::Block* const block{storage_inst.block};
         IR::Inst* const inst{storage_inst.inst};
-        const IR::U32 offset{
-            StorageOffset(*block, *inst, storage_buffer, host_info.min_ssbo_alignment)};
+        const IR::U32 offset{StorageOffset(*block, *inst, storage_buffer)};
         Replace(*block, *inst, index, offset);
     }
 }

src/shader_recompiler/ir_opt/passes.h

@@ -15,7 +15,7 @@ namespace Shader::Optimization {
 void CollectShaderInfoPass(Environment& env, IR::Program& program);
 void ConstantPropagationPass(Environment& env, IR::Program& program);
 void DeadCodeEliminationPass(IR::Program& program);
-void GlobalMemoryToStorageBufferPass(IR::Program& program, const HostTranslateInfo& host_info);
+void GlobalMemoryToStorageBufferPass(IR::Program& program);
 void IdentityRemovalPass(IR::Program& program);
 void LowerFp16ToFp32(IR::Program& program);
 void LowerInt64ToInt32(IR::Program& program);

src/video_core/buffer_cache/buffer_cache.h

@@ -1938,21 +1938,14 @@ typename BufferCache<P>::Binding BufferCache<P>::StorageBufferBinding(GPUVAddr s
                                                                       bool is_written) const {
     const GPUVAddr gpu_addr = gpu_memory->Read<u64>(ssbo_addr);
     const u32 size = gpu_memory->Read<u32>(ssbo_addr + 8);
-    const u32 alignment = runtime.GetStorageBufferAlignment();
-
-    const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
-    const u32 aligned_size =
-        Common::AlignUp(static_cast<u32>(gpu_addr - aligned_gpu_addr) + size, alignment);
-
-    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(aligned_gpu_addr);
+    const std::optional<VAddr> cpu_addr = gpu_memory->GpuToCpuAddress(gpu_addr);
     if (!cpu_addr || size == 0) {
         return NULL_BINDING;
     }
-
-    const VAddr cpu_end = Common::AlignUp(*cpu_addr + aligned_size, Core::Memory::YUZU_PAGESIZE);
+    const VAddr cpu_end = Common::AlignUp(*cpu_addr + size, Core::Memory::YUZU_PAGESIZE);
     const Binding binding{
         .cpu_addr = *cpu_addr,
-        .size = is_written ? aligned_size : static_cast<u32>(cpu_end - *cpu_addr),
+        .size = is_written ? size : static_cast<u32>(cpu_end - *cpu_addr),
         .buffer_id = BufferId{},
     };
     return binding;

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -160,10 +160,6 @@ public:
         return device.CanReportMemoryUsage();
     }
 
-    u32 GetStorageBufferAlignment() const {
-        return static_cast<u32>(device.GetShaderStorageBufferAlignment());
-    }
-
 private:
     static constexpr std::array PABO_LUT{
         GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV,          GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV,

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -236,7 +236,6 @@ ShaderCache::ShaderCache(RasterizerOpenGL& rasterizer_, Core::Frontend::EmuWindo
           .needs_demote_reorder = device.IsAmd(),
           .support_snorm_render_buffer = false,
           .support_viewport_index_layer = device.HasVertexViewportLayer(),
-          .min_ssbo_alignment = static_cast<u32>(device.GetShaderStorageBufferAlignment()),
           .support_geometry_shader_passthrough = device.HasGeometryShaderPassthrough(),
       } {
     if (use_asynchronous_shaders) {

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -330,10 +330,6 @@ bool BufferCacheRuntime::CanReportMemoryUsage() const {
     return device.CanReportMemoryUsage();
 }
 
-u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
-    return static_cast<u32>(device.GetStorageBufferAlignment());
-}
-
 void BufferCacheRuntime::Finish() {
     scheduler.Finish();
 }

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -73,8 +73,6 @@ public:
 
     bool CanReportMemoryUsage() const;
 
-    u32 GetStorageBufferAlignment() const;
-
     [[nodiscard]] StagingBufferRef UploadStagingBuffer(size_t size);
 
     [[nodiscard]] StagingBufferRef DownloadStagingBuffer(size_t size);

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -344,7 +344,6 @@ PipelineCache::PipelineCache(RasterizerVulkan& rasterizer_, const Device& device
             driver_id == VK_DRIVER_ID_AMD_PROPRIETARY || driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE,
         .support_snorm_render_buffer = true,
         .support_viewport_index_layer = device.IsExtShaderViewportIndexLayerSupported(),
-        .min_ssbo_alignment = static_cast<u32>(device.GetStorageBufferAlignment()),
         .support_geometry_shader_passthrough = device.IsNvGeometryShaderPassthroughSupported(),
     };
 

src/yuzu/main.cpp

@@ -948,7 +948,6 @@ void GMainWindow::InitializeWidgets() {
         statusBar()->addPermanentWidget(label);
     }
 
-    // TODO (flTobi): Add the widget when multiplayer is fully implemented
     statusBar()->addPermanentWidget(multiplayer_state->GetStatusText(), 0);
     statusBar()->addPermanentWidget(multiplayer_state->GetStatusIcon(), 0);