8 files changed, 107 insertions, 10 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0ee012aca8..2ab0ea589d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -89,6 +89,11 @@ endif()
 configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
                ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
                COPYONLY)
+if (EXISTS ${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json)
+    configure_file("${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json"
+                   "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json"
+                   COPYONLY)
+endif()
 if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
     message(STATUS "Downloading compatibility list for yuzu...")
     file(DOWNLOAD
diff --git a/src/core/hid/emulated_controller.cpp b/src/core/hid/emulated_controller.cpp
index 049602e7d6..f9f902c2dd 100644
--- a/src/core/hid/emulated_controller.cpp
+++ b/src/core/hid/emulated_controller.cpp
@@ -101,8 +101,10 @@ void EmulatedController::ReloadFromSettings() {
     // Other or debug controller should always be a pro controller
     if (npad_id_type != NpadIdType::Other) {
         SetNpadStyleIndex(MapSettingsTypeToNPad(player.controller_type));
+        original_npad_type = npad_type;
     } else {
         SetNpadStyleIndex(NpadStyleIndex::ProController);
+        original_npad_type = npad_type;
     }
 
     if (player.connected) {
@@ -354,6 +356,7 @@ void EmulatedController::DisableConfiguration() {
             Disconnect();
         }
         SetNpadStyleIndex(tmp_npad_type);
+        original_npad_type = tmp_npad_type;
     }
 
     // Apply temporary connected status to the real controller
@@ -1004,13 +1007,27 @@ void EmulatedController::SetSupportedNpadStyleTag(NpadStyleTag supported_styles)
     if (!is_connected) {
         return;
     }
+
+    // Attempt to reconnect with the original type
+    if (npad_type != original_npad_type) {
+        Disconnect();
+        const auto current_npad_type = npad_type;
+        SetNpadStyleIndex(original_npad_type);
+        if (IsControllerSupported()) {
+            Connect();
+            return;
+        }
+        SetNpadStyleIndex(current_npad_type);
+        Connect();
+    }
+
     if (IsControllerSupported()) {
         return;
     }
 
     Disconnect();
 
-    // Fallback fullkey controllers to Pro controllers
+    // Fallback Fullkey controllers to Pro controllers
     if (IsControllerFullkey() && supported_style_tag.fullkey) {
         LOG_WARNING(Service_HID, "Reconnecting controller type {} as Pro controller", npad_type);
         SetNpadStyleIndex(NpadStyleIndex::ProController);
@@ -1018,6 +1035,22 @@ void EmulatedController::SetSupportedNpadStyleTag(NpadStyleTag supported_styles)
         return;
     }
 
+    // Fallback Dual joycon controllers to Pro controllers
+    if (npad_type == NpadStyleIndex::JoyconDual && supported_style_tag.fullkey) {
+        LOG_WARNING(Service_HID, "Reconnecting controller type {} as Pro controller", npad_type);
+        SetNpadStyleIndex(NpadStyleIndex::ProController);
+        Connect();
+        return;
+    }
+
+    // Fallback Pro controllers to Dual joycon
+    if (npad_type == NpadStyleIndex::ProController && supported_style_tag.joycon_dual) {
+        LOG_WARNING(Service_HID, "Reconnecting controller type {} as Dual Joycons", npad_type);
+        SetNpadStyleIndex(NpadStyleIndex::JoyconDual);
+        Connect();
+        return;
+    }
+
     LOG_ERROR(Service_HID, "Controller type {} is not supported. Disconnecting controller",
               npad_type);
 }
diff --git a/src/core/hid/emulated_controller.h b/src/core/hid/emulated_controller.h
index cbd7c26d38..c3aa8f9d37 100644
--- a/src/core/hid/emulated_controller.h
+++ b/src/core/hid/emulated_controller.h
@@ -440,6 +440,7 @@ private:
 
     const NpadIdType npad_id_type;
     NpadStyleIndex npad_type{NpadStyleIndex::None};
+    NpadStyleIndex original_npad_type{NpadStyleIndex::None};
     NpadStyleTag supported_style_tag{NpadStyleSet::All};
     bool is_connected{false};
     bool is_configuring{false};
diff --git a/src/core/hle/service/audio/audren_u.cpp b/src/core/hle/service/audio/audren_u.cpp
index 381a66ba52..bc69117c62 100644
--- a/src/core/hle/service/audio/audren_u.cpp
+++ b/src/core/hle/service/audio/audren_u.cpp
@@ -50,7 +50,7 @@ public:
             {7, &IAudioRenderer::QuerySystemEvent, "QuerySystemEvent"},
             {8, &IAudioRenderer::SetRenderingTimeLimit, "SetRenderingTimeLimit"},
             {9, &IAudioRenderer::GetRenderingTimeLimit, "GetRenderingTimeLimit"},
-            {10, nullptr, "RequestUpdateAuto"},
+            {10, &IAudioRenderer::RequestUpdate, "RequestUpdateAuto"},
             {11, nullptr, "ExecuteAudioRendererRendering"},
         };
         // clang-format on
@@ -113,15 +113,30 @@ private:
 
         // These buffers are written manually to avoid an issue with WriteBuffer throwing errors for
         // checking size 0. Performance size is 0 for most games.
-        const auto buffers{ctx.BufferDescriptorB()};
-        std::vector<u8> output(buffers[0].Size(), 0);
-        std::vector<u8> performance(buffers[1].Size(), 0);
+
+        std::vector<u8> output{};
+        std::vector<u8> performance{};
+        auto is_buffer_b{ctx.BufferDescriptorB()[0].Size() != 0};
+        if (is_buffer_b) {
+            const auto buffersB{ctx.BufferDescriptorB()};
+            output.resize(buffersB[0].Size(), 0);
+            performance.resize(buffersB[1].Size(), 0);
+        } else {
+            const auto buffersC{ctx.BufferDescriptorC()};
+            output.resize(buffersC[0].Size(), 0);
+            performance.resize(buffersC[1].Size(), 0);
+        }
 
         auto result = impl->RequestUpdate(input, performance, output);
 
         if (result.IsSuccess()) {
-            ctx.WriteBufferB(output.data(), output.size(), 0);
-            ctx.WriteBufferB(performance.data(), performance.size(), 1);
+            if (is_buffer_b) {
+                ctx.WriteBufferB(output.data(), output.size(), 0);
+                ctx.WriteBufferB(performance.data(), performance.size(), 1);
+            } else {
+                ctx.WriteBufferC(output.data(), output.size(), 0);
+                ctx.WriteBufferC(performance.data(), performance.size(), 1);
+            }
         } else {
             LOG_ERROR(Service_Audio, "RequestUpdate failed error 0x{:02X}!", result.description);
         }
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index fae6e5affd..e23eae36a7 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -246,7 +246,8 @@ static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vec
     entries.reserve(entries.size() + new_data.size());
 
     for (const auto& new_entry : new_data) {
-        entries.emplace_back(new_entry->GetName(), type, new_entry->GetSize());
+        entries.emplace_back(new_entry->GetName(), type,
+                             type == FileSys::EntryType::Directory ? 0 : new_entry->GetSize());
     }
 }
 
diff --git a/src/core/hle/service/hid/hid.cpp b/src/core/hle/service/hid/hid.cpp
index 5ecbddf94d..7909141c01 100644
--- a/src/core/hle/service/hid/hid.cpp
+++ b/src/core/hle/service/hid/hid.cpp
@@ -2146,12 +2146,18 @@ public:
             {324, nullptr, "GetUniquePadButtonSet"},
             {325, nullptr, "GetUniquePadColor"},
             {326, nullptr, "GetUniquePadAppletDetailedUiType"},
+            {327, nullptr, "GetAbstractedPadIdDataFromNpad"},
+            {328, nullptr, "AttachAbstractedPadToNpad"},
+            {329, nullptr, "DetachAbstractedPadAll"},
+            {330, nullptr, "CheckAbstractedPadConnection"},
             {500, nullptr, "SetAppletResourceUserId"},
             {501, nullptr, "RegisterAppletResourceUserId"},
             {502, nullptr, "UnregisterAppletResourceUserId"},
             {503, nullptr, "EnableAppletToGetInput"},
             {504, nullptr, "SetAruidValidForVibration"},
             {505, nullptr, "EnableAppletToGetSixAxisSensor"},
+            {506, nullptr, "EnableAppletToGetPadInput"},
+            {507, nullptr, "EnableAppletToGetTouchScreen"},
             {510, nullptr, "SetVibrationMasterVolume"},
             {511, nullptr, "GetVibrationMasterVolume"},
             {512, nullptr, "BeginPermitVibrationSession"},
diff --git a/src/yuzu/bootmanager.cpp b/src/yuzu/bootmanager.cpp
index c262d0a2bb..d3fbdb09d1 100644
--- a/src/yuzu/bootmanager.cpp
+++ b/src/yuzu/bootmanager.cpp
@@ -815,6 +815,12 @@ void GRenderWindow::InitializeCamera() {
         if (Settings::values.ir_sensor_device.GetValue() == cameraInfo.deviceName().toStdString() ||
             Settings::values.ir_sensor_device.GetValue() == "Auto") {
             camera = std::make_unique<QCamera>(cameraInfo);
+            if (!camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder) &&
+                !camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+                LOG_ERROR(Frontend,
+                          "Camera doesn't support CaptureViewfinder or CaptureStillImage");
+                continue;
+            }
             camera_found = true;
             break;
         }
@@ -825,10 +831,22 @@ void GRenderWindow::InitializeCamera() {
     }
 
     camera_capture = std::make_unique<QCameraImageCapture>(camera.get());
+
+    if (!camera_capture->isCaptureDestinationSupported(
+            QCameraImageCapture::CaptureDestination::CaptureToBuffer)) {
+        LOG_ERROR(Frontend, "Camera doesn't support saving to buffer");
+        return;
+    }
+
+    camera_capture->setCaptureDestination(QCameraImageCapture::CaptureDestination::CaptureToBuffer);
     connect(camera_capture.get(), &QCameraImageCapture::imageCaptured, this,
             &GRenderWindow::OnCameraCapture);
     camera->unload();
-    camera->setCaptureMode(QCamera::CaptureViewfinder);
+    if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder)) {
+        camera->setCaptureMode(QCamera::CaptureViewfinder);
+    } else if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+        camera->setCaptureMode(QCamera::CaptureStillImage);
+    }
     camera->load();
     camera->start();
 
diff --git a/src/yuzu/configuration/configure_camera.cpp b/src/yuzu/configuration/configure_camera.cpp
index 73cdcf3f21..2a61de2a1e 100644
--- a/src/yuzu/configuration/configure_camera.cpp
+++ b/src/yuzu/configuration/configure_camera.cpp
@@ -42,6 +42,12 @@ void ConfigureCamera::PreviewCamera() {
             LOG_INFO(Frontend, "Selected Camera {} {}", cameraInfo.description().toStdString(),
                      cameraInfo.deviceName().toStdString());
             camera = std::make_unique<QCamera>(cameraInfo);
+            if (!camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder) &&
+                !camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+                LOG_ERROR(Frontend,
+                          "Camera doesn't support CaptureViewfinder or CaptureStillImage");
+                continue;
+            }
             camera_found = true;
             break;
         }
@@ -57,10 +63,22 @@ void ConfigureCamera::PreviewCamera() {
     }
 
     camera_capture = std::make_unique<QCameraImageCapture>(camera.get());
+
+    if (!camera_capture->isCaptureDestinationSupported(
+            QCameraImageCapture::CaptureDestination::CaptureToBuffer)) {
+        LOG_ERROR(Frontend, "Camera doesn't support saving to buffer");
+        return;
+    }
+
+    camera_capture->setCaptureDestination(QCameraImageCapture::CaptureDestination::CaptureToBuffer);
     connect(camera_capture.get(), &QCameraImageCapture::imageCaptured, this,
             &ConfigureCamera::DisplayCapturedFrame);
     camera->unload();
-    camera->setCaptureMode(QCamera::CaptureViewfinder);
+    if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureViewfinder)) {
+        camera->setCaptureMode(QCamera::CaptureViewfinder);
+    } else if (camera->isCaptureModeSupported(QCamera::CaptureMode::CaptureStillImage)) {
+        camera->setCaptureMode(QCamera::CaptureStillImage);
+    }
     camera->load();
     camera->start();