[hle] constexpr handler dispatch maps, introduce version gating (#4480)

This PR primarily focuses on upbringing constexpr maps for handlers.

Each time an HLE object of a service is construed, it registers it's own handlers, over and over.
Regardless of whetever it needs them at the moment or not.
Additionally we don't require to keep track of different function pointers amongst each object.
This can be done by overriding the given function instead, as opposed to having a separate
hash map for every given object.

In other words: Remove handlers (and handlers_tipc) map for every instance
then read from a static defined per-class.

- [x] Migrate all HLE functions to new `frozen::map` constexpr time finder
- [ ] Measure if this approach actually makes better codegen

Optional:
- [x] Properly gate all functions (that have versions commented next to them)
- [x] Maybe store `HandlerFnP<>` and `const char*` separately, version gating can go in a different map as well

Information such as name can be used on debug builds, but doesn't particularly help on release as one can consult an external reference (or have an annotated IPC map)

Signed-off-by: lizzie <lizzie@eden-emu.dev>

- [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions).
- [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md)
- [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability.

-------------------

Co-authored-by: Maufeat <sahyno1996@gmail.com>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4480
Reviewed-by: Maufeat <sahyno1996@gmail.com>
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
This commit is contained in:
lizzie
2026-10-13 04:38:36 +02:00
committed by PavelBARABANOV
parent 989768aa46
commit 1059202c75
392 changed files with 12453 additions and 14117 deletions
+399 -96
View File
@@ -6,111 +6,414 @@
#include <memory>
#include "common/logging.h"
#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/set/system_settings_server.h"
#include "core/hle/service/sm/sm.h"
#include "core/hle/service/btm/btm.h"
#include "core/hle/service/btm/btm_debug.h"
#include "core/hle/service/btm/btm_system.h"
#include "core/hle/service/btm/btm_user.h"
#include "core/hle/service/server_manager.h"
#include "core/hle/service/service.h"
namespace Kernel {
class KEvent;
class KReadableEvent;
} // namespace Kernel
namespace Core {
class System;
}
namespace Service::Set {
class ISystemSettingsServer;
}
namespace Service::BTM {
class IBtmSystemCore final : public ServiceFramework<IBtmSystemCore> {
public:
explicit IBtmSystemCore(Core::System& system_)
: ServiceFramework{system_, "IBtmSystemCore"}, service_context{system_, "IBtmSystemCore"} {
radio_event = service_context.CreateEvent("IBtmSystemCore:RadioEvent");
audio_device_connection_event = service_context.CreateEvent("IBtmSystemCore:AudioDeviceConnectionEvent");
m_set_sys = system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
}
~IBtmSystemCore() override {
service_context.CloseEvent(radio_event);
service_context.CloseEvent(audio_device_connection_event);
}
Result StartGamepadPairing() {
LOG_WARNING(Service_BTM, "(STUBBED) called");
R_SUCCEED();
}
Result CancelGamepadPairing() {
LOG_WARNING(Service_BTM, "(STUBBED) called");
R_SUCCEED();
}
Result EnableRadio() {
LOG_DEBUG(Service_BTM, "called");
R_RETURN(m_set_sys->SetBluetoothEnableFlag(true));
}
Result DisableRadio() {
LOG_DEBUG(Service_BTM, "called");
R_RETURN(m_set_sys->SetBluetoothEnableFlag(false));
}
Result IsRadioEnabled(Out<bool> out_is_enabled) {
LOG_DEBUG(Service_BTM, "called");
R_RETURN(m_set_sys->GetBluetoothEnableFlag(out_is_enabled));
}
Result AcquireRadioEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &radio_event->GetReadableEvent();
R_SUCCEED();
}
Result GetDiscoveredAudioDevice(OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices, s32 count, Out<s32> out_total) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
R_SUCCEED();
}
Result AcquireAudioDeviceConnectionEvent(
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_event = &audio_device_connection_event->GetReadableEvent();
R_SUCCEED();
}
Result GetConnectedAudioDevices(
Out<s32> out_count, OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_count = 0;
R_SUCCEED();
}
Result GetPairedAudioDevices(
Out<s32> out_count, OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_count = 0;
R_SUCCEED();
}
Result RequestAudioDeviceConnectionRejection(ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_BTM, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
R_SUCCEED();
}
Result CancelAudioDeviceConnectionRejection(ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_BTM, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
R_SUCCEED();
}
std::optional<FunctionInfoBase> FindRequest(u32 key) override {
return HandlerTableGenerateWithFind(key, functions);
}
static constexpr auto functions = CreateStaticMap(
FunctionInfo{0, C<&IBtmSystemCore::StartGamepadPairing>, "StartGamepadPairing"},
FunctionInfo{1, C<&IBtmSystemCore::CancelGamepadPairing>, "CancelGamepadPairing"},
FunctionInfo{2, nullptr, "ClearGamepadPairingDatabase"},
FunctionInfo{3, nullptr, "GetPairedGamepadCount"},
FunctionInfo{4, C<&IBtmSystemCore::EnableRadio>, "EnableRadio"},
FunctionInfo{5, C<&IBtmSystemCore::DisableRadio>, "DisableRadio"},
FunctionInfo{6, C<&IBtmSystemCore::IsRadioEnabled>, "IsRadioEnabled"},
FunctionInfo{7, C<&IBtmSystemCore::AcquireRadioEvent>, "AcquireRadioEvent"},
FunctionInfo{8, nullptr, "AcquireGamepadPairingEvent"},
FunctionInfo{9, nullptr, "IsGamepadPairingStarted"},
FunctionInfo{10, nullptr, "StartAudioDeviceDiscovery"},
FunctionInfo{11, nullptr, "StopAudioDeviceDiscovery"},
FunctionInfo{12, nullptr, "IsDiscoveryingAudioDevice"},
FunctionInfo{13, C<&IBtmSystemCore::GetDiscoveredAudioDevice>, "GetDiscoveredAudioDevice"},
FunctionInfo{14, C<&IBtmSystemCore::AcquireAudioDeviceConnectionEvent>, "AcquireAudioDeviceConnectionEvent"},
FunctionInfo{15, nullptr, "ConnectAudioDevice"},
FunctionInfo{16, nullptr, "IsConnectingAudioDevice"},
FunctionInfo{17, C<&IBtmSystemCore::GetConnectedAudioDevices>, "GetConnectedAudioDevices"},
FunctionInfo{18, nullptr, "DisconnectAudioDevice"},
FunctionInfo{19, nullptr, "AcquirePairedAudioDeviceInfoChangedEvent"},
FunctionInfo{20, C<&IBtmSystemCore::GetPairedAudioDevices>, "GetPairedAudioDevices"},
FunctionInfo{21, nullptr, "RemoveAudioDevicePairing"},
FunctionInfo{22, C<&IBtmSystemCore::RequestAudioDeviceConnectionRejection>, "RequestAudioDeviceConnectionRejection"},
FunctionInfo{23, C<&IBtmSystemCore::CancelAudioDeviceConnectionRejection>, "CancelAudioDeviceConnectionRejection"}
);
KernelHelpers::ServiceContext service_context;
Kernel::KEvent* radio_event;
Kernel::KEvent* audio_device_connection_event;
std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
};
class IBtmSystem final : public ServiceFramework<IBtmSystem> {
public:
explicit IBtmSystem(Core::System& system_) : ServiceFramework{system_, "btm:sys"} {}
~IBtmSystem() override = default;
Result GetCore(OutInterface<IBtmSystemCore> out_interface) {
LOG_WARNING(Service_BTM, "called");
*out_interface = std::make_shared<IBtmSystemCore>(system);
R_SUCCEED();
}
std::optional<FunctionInfoBase> FindRequest(u32 key) override {
return HandlerTableGenerateWithFind(key, functions);
}
static constexpr auto functions = CreateStaticMap(
FunctionInfo{0, C<&IBtmSystem::GetCore>, "GetCore"}
);
};
class IBtmUserCore final : public ServiceFramework<IBtmUserCore> {
public:
explicit IBtmUserCore(Core::System& system_)
: ServiceFramework{system_, "IBtmUserCore"}, service_context{system_, "IBtmUserCore"} {
scan_event = service_context.CreateEvent("IBtmUserCore:ScanEvent");
connection_event = service_context.CreateEvent("IBtmUserCore:ConnectionEvent");
service_discovery_event = service_context.CreateEvent("IBtmUserCore:DiscoveryEvent");
config_event = service_context.CreateEvent("IBtmUserCore:ConfigEvent");
}
~IBtmUserCore() override {
service_context.CloseEvent(scan_event);
service_context.CloseEvent(connection_event);
service_context.CloseEvent(service_discovery_event);
service_context.CloseEvent(config_event);
}
Result AcquireBleScanEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &scan_event->GetReadableEvent();
R_SUCCEED();
}
Result AcquireBleConnectionEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &connection_event->GetReadableEvent();
R_SUCCEED();
}
Result AcquireBleServiceDiscoveryEvent(
Out<bool> out_is_valid, OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &service_discovery_event->GetReadableEvent();
R_SUCCEED();
}
Result AcquireBleMtuConfigEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &config_event->GetReadableEvent();
R_SUCCEED();
}
std::optional<FunctionInfoBase> FindRequest(u32 key) override {
return HandlerTableGenerateWithFind(key, functions);
}
static constexpr auto functions = CreateStaticMap(
FunctionInfo{0, C<&IBtmUserCore::AcquireBleScanEvent>, "AcquireBleScanEvent"},
FunctionInfo{1, nullptr, "GetBleScanFilterParameter"},
FunctionInfo{2, nullptr, "GetBleScanFilterParameter2"},
FunctionInfo{3, nullptr, "StartBleScanForGeneral"},
FunctionInfo{4, nullptr, "StopBleScanForGeneral"},
FunctionInfo{5, nullptr, "GetBleScanResultsForGeneral"},
FunctionInfo{6, nullptr, "StartBleScanForPaired"},
FunctionInfo{7, nullptr, "StopBleScanForPaired"},
FunctionInfo{8, nullptr, "StartBleScanForSmartDevice"},
FunctionInfo{9, nullptr, "StopBleScanForSmartDevice"},
FunctionInfo{10, nullptr, "GetBleScanResultsForSmartDevice"},
FunctionInfo{17, C<&IBtmUserCore::AcquireBleConnectionEvent>, "AcquireBleConnectionEvent"},
FunctionInfo{18, nullptr, "BleConnect"},
FunctionInfo{19, nullptr, "BleDisconnect"},
FunctionInfo{20, nullptr, "BleGetConnectionState"},
FunctionInfo{21, nullptr, "AcquireBlePairingEvent"},
FunctionInfo{22, nullptr, "BlePairDevice"},
FunctionInfo{23, nullptr, "BleUnPairDevice"},
FunctionInfo{24, nullptr, "BleUnPairDevice2"},
FunctionInfo{25, nullptr, "BleGetPairedDevices"},
FunctionInfo{26, C<&IBtmUserCore::AcquireBleServiceDiscoveryEvent>, "AcquireBleServiceDiscoveryEvent"},
FunctionInfo{27, nullptr, "GetGattServices"},
FunctionInfo{28, nullptr, "GetGattService"},
FunctionInfo{29, nullptr, "GetGattIncludedServices"},
FunctionInfo{30, nullptr, "GetBelongingGattService"},
FunctionInfo{31, nullptr, "GetGattCharacteristics"},
FunctionInfo{32, nullptr, "GetGattDescriptors"},
FunctionInfo{33, C<&IBtmUserCore::AcquireBleMtuConfigEvent>, "AcquireBleMtuConfigEvent"},
FunctionInfo{34, nullptr, "ConfigureBleMtu"},
FunctionInfo{35, nullptr, "GetBleMtu"},
FunctionInfo{36, nullptr, "RegisterBleGattDataPath"},
FunctionInfo{37, nullptr, "UnregisterBleGattDataPath"}
);
KernelHelpers::ServiceContext service_context;
Kernel::KEvent* scan_event;
Kernel::KEvent* connection_event;
Kernel::KEvent* service_discovery_event;
Kernel::KEvent* config_event;
};
class IBtmUser final : public ServiceFramework<IBtmUser> {
public:
explicit IBtmUser(Core::System& system_) : ServiceFramework{system_, "btm:u"} {}
~IBtmUser() override = default;
Result GetCore(OutInterface<IBtmUserCore> out_interface) {
LOG_WARNING(Service_BTM, "called");
*out_interface = std::make_shared<IBtmUserCore>(system);
R_SUCCEED();
}
std::optional<FunctionInfoBase> FindRequest(u32 key) override {
return HandlerTableGenerateWithFind(key, functions);
}
static constexpr auto functions = CreateStaticMap(
FunctionInfo{0, C<&IBtmUser::GetCore>, "GetCore"}
);
};
class IBtmDebug final : public ServiceFramework<IBtmDebug> {
public:
explicit IBtmDebug(Core::System& system_) : ServiceFramework{system_, "btm:dbg"} {}
~IBtmDebug() override = default;
std::optional<FunctionInfoBase> FindRequest(u32 key) override {
return HandlerTableGenerateWithFind(key, functions);
}
static constexpr auto functions = CreateStaticMap(
FunctionInfo{0, nullptr, "AcquireDiscoveryEvent"},
FunctionInfo{1, nullptr, "StartDiscovery"},
FunctionInfo{2, nullptr, "CancelDiscovery"},
FunctionInfo{3, nullptr, "GetDeviceProperty"},
FunctionInfo{4, nullptr, "CreateBond"},
FunctionInfo{5, nullptr, "CancelBond"},
FunctionInfo{6, nullptr, "SetTsiMode"},
FunctionInfo{7, nullptr, "GeneralTest"},
FunctionInfo{8, nullptr, "HidConnect"},
FunctionInfo{9, nullptr, "GeneralGet", MakeVersionGate({5,0,0})},
FunctionInfo{10, nullptr, "GetGattClientDisconnectionReason", MakeVersionGate({5,0,0})},
FunctionInfo{11, nullptr, "GetBleConnectionParameter", MakeVersionGate({5,1,0})},
FunctionInfo{12, nullptr, "GetBleConnectionParameterRequest", MakeVersionGate({5,1,0})},
FunctionInfo{13, nullptr, "GetDiscoveredDevice", MakeVersionGate({12,0,0})},
FunctionInfo{14, nullptr, "SleepAwakeLoopTest", MakeVersionGate({15,0,0})},
FunctionInfo{15, nullptr, "SleepTest", MakeVersionGate({15,0,0})},
FunctionInfo{16, nullptr, "MinimumAwakeTest", MakeVersionGate({15,0,0})},
FunctionInfo{17, nullptr, "ForceEnableBtm", MakeVersionGate({15,0,0})}
);
};
class IBtm final : public ServiceFramework<IBtm> {
public:
explicit IBtm(Core::System& system_) : ServiceFramework{system_, "btm"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, nullptr, "GetState"},
{1, nullptr, "GetHostDeviceProperty"},
{2, nullptr, "AcquireDeviceConditionEvent"},
{3, nullptr, "GetDeviceCondition"},
{4, nullptr, "SetBurstMode"},
{5, nullptr, "SetSlotMode"},
{6, nullptr, "SetBluetoothMode"},
{7, nullptr, "SetWlanMode"},
{8, nullptr, "AcquireDeviceInfoEvent"},
{9, nullptr, "GetDeviceInfo"},
{10, nullptr, "AddDeviceInfo"},
{11, nullptr, "RemoveDeviceInfo"},
{12, nullptr, "IncreaseDeviceInfoOrder"},
{13, nullptr, "LlrNotify"},
{14, nullptr, "EnableRadio"},
{15, nullptr, "DisableRadio"},
{16, nullptr, "HidDisconnect"},
{17, nullptr, "HidSetRetransmissionMode"},
{18, nullptr, "AcquireAwakeReqEvent"},
{19, nullptr, "AcquireLlrStateEvent"},
{20, nullptr, "IsLlrStarted"},
{21, nullptr, "EnableSlotSaving"},
{22, nullptr, "ProtectDeviceInfo"},
{23, nullptr, "AcquireBleScanEvent"},
{24, nullptr, "GetBleScanParameterGeneral"},
{25, nullptr, "GetBleScanParameterSmartDevice"},
{26, nullptr, "StartBleScanForGeneral"},
{27, nullptr, "StopBleScanForGeneral"},
{28, nullptr, "GetBleScanResultsForGeneral"},
{29, nullptr, "StartBleScanForPairedDevice"},
{30, nullptr, "StopBleScanForPairedDevice"},
{31, nullptr, "StartBleScanForSmartDevice"},
{32, nullptr, "StopBleScanForSmartDevice"},
{33, nullptr, "GetBleScanResultsForSmartDevice"},
{34, nullptr, "AcquireBleConnectionEvent"},
{35, nullptr, "BleConnect"},
{36, nullptr, "BleOverrideConnection"},
{37, nullptr, "BleDisconnect"},
{38, nullptr, "BleGetConnectionState"},
{39, nullptr, "BleGetGattClientConditionList"},
{40, nullptr, "AcquireBlePairingEvent"},
{41, nullptr, "BlePairDevice"},
{42, nullptr, "BleUnpairDeviceOnBoth"},
{43, nullptr, "BleUnpairDevice"},
{44, nullptr, "BleGetPairedAddresses"},
{45, nullptr, "AcquireBleServiceDiscoveryEvent"},
{46, nullptr, "GetGattServices"},
{47, nullptr, "GetGattService"},
{48, nullptr, "GetGattIncludedServices"},
{49, nullptr, "GetBelongingService"},
{50, nullptr, "GetGattCharacteristics"},
{51, nullptr, "GetGattDescriptors"},
{52, nullptr, "AcquireBleMtuConfigEvent"},
{53, nullptr, "ConfigureBleMtu"},
{54, nullptr, "GetBleMtu"},
{55, nullptr, "RegisterBleGattDataPath"},
{56, nullptr, "UnregisterBleGattDataPath"},
{57, nullptr, "RegisterAppletResourceUserId"},
{58, nullptr, "UnregisterAppletResourceUserId"},
{59, nullptr, "SetAppletResourceUserId"},
{60, nullptr, "AcquireBleConnectionParameterUpdateEvent"}, //8.0.0+
{61, nullptr, "SetCeLength"}, //8.0.0+
{62, nullptr, "EnsureSlotExpansion"}, //9.0.0+
{63, nullptr, "IsSlotExpansionEnsured"}, //9.0.0+
{64, nullptr, "CancelConnectionTrigger"}, //10.0.0+
{65, nullptr, "GetConnectionCapacity"}, //13.0.0+
{66, nullptr, "GetWlanMode"}, //13.0.0+
{67, nullptr, "IsSlotSavingEnabled"}, //13.0.0+
{68, nullptr, "IsSlotSavingForPairingEnabled"}, //13.0.0+
{69, nullptr, "AcquireAudioDeviceConnectionEvent"}, //13.0.0+
{70, nullptr, "GetConnectedAudioDevices"}, //13.0.0+
{71, nullptr, "SetAudioSourceVolume"}, //13.0.0+
{72, nullptr, "GetAudioSourceVolume"}, //13.0.0+
{73, nullptr, "RequestAudioDeviceConnectionRejection"}, //13.0.0+
{74, nullptr, "CancelAudioDeviceConnectionRejection"}, //13.0.0+
{75, nullptr, "GetPairedAudioDevices"}, //13.0.0+
{76, nullptr, "SetWlanModeWithOption"}, //13.1.0+
{100, nullptr, "AcquireConnectionDisallowedEvent"}, //13.0.0+
{101, nullptr, "GetUsecaseViolationFactor"}, //13.0.0+
{110, nullptr, "GetShortenedDeviceInfo"}, //13.0.0+
{111, nullptr, "AcquirePairingCountUpdateEvent"},//13.0.0+
{112, nullptr, "Unknown112"}, //14.0.0-14.1.2
{113, nullptr, "Unknown113"}, //14.0.0-14.1.2
{114, nullptr, "IsFirstAudioControlConnection"}, //14.0.0+
{115, nullptr, "GetShortenedDeviceCondition"}, //14.0.0+
{116, nullptr, "SetAudioSinkVolume"}, //15.0.0+
{117, nullptr, "GetAudioSinkVolume"}, //15.0.0+
};
// clang-format on
explicit IBtm(Core::System& system_) : ServiceFramework{system_, "btm"} {}
RegisterHandlers(functions);
static constexpr auto functions = CreateStaticMap(
FunctionInfo{0, nullptr, "GetState"},
FunctionInfo{1, nullptr, "GetHostDeviceProperty"},
FunctionInfo{2, nullptr, "AcquireDeviceConditionEvent"},
FunctionInfo{3, nullptr, "GetDeviceCondition"},
FunctionInfo{4, nullptr, "SetBurstMode"},
FunctionInfo{5, nullptr, "SetSlotMode"},
FunctionInfo{6, nullptr, "SetBluetoothMode"},
FunctionInfo{7, nullptr, "SetWlanMode"},
FunctionInfo{8, nullptr, "AcquireDeviceInfoEvent"},
FunctionInfo{9, nullptr, "GetDeviceInfo"},
FunctionInfo{10, nullptr, "AddDeviceInfo"},
FunctionInfo{11, nullptr, "RemoveDeviceInfo"},
FunctionInfo{12, nullptr, "IncreaseDeviceInfoOrder"},
FunctionInfo{13, nullptr, "LlrNotify"},
FunctionInfo{14, nullptr, "EnableRadio"},
FunctionInfo{15, nullptr, "DisableRadio"},
FunctionInfo{16, nullptr, "HidDisconnect"},
FunctionInfo{17, nullptr, "HidSetRetransmissionMode"},
FunctionInfo{18, nullptr, "AcquireAwakeReqEvent"},
FunctionInfo{19, nullptr, "AcquireLlrStateEvent"},
FunctionInfo{20, nullptr, "IsLlrStarted"},
FunctionInfo{21, nullptr, "EnableSlotSaving"},
FunctionInfo{22, nullptr, "ProtectDeviceInfo"},
FunctionInfo{23, nullptr, "AcquireBleScanEvent"},
FunctionInfo{24, nullptr, "GetBleScanParameterGeneral"},
FunctionInfo{25, nullptr, "GetBleScanParameterSmartDevice"},
FunctionInfo{26, nullptr, "StartBleScanForGeneral"},
FunctionInfo{27, nullptr, "StopBleScanForGeneral"},
FunctionInfo{28, nullptr, "GetBleScanResultsForGeneral"},
FunctionInfo{29, nullptr, "StartBleScanForPairedDevice"},
FunctionInfo{30, nullptr, "StopBleScanForPairedDevice"},
FunctionInfo{31, nullptr, "StartBleScanForSmartDevice"},
FunctionInfo{32, nullptr, "StopBleScanForSmartDevice"},
FunctionInfo{33, nullptr, "GetBleScanResultsForSmartDevice"},
FunctionInfo{34, nullptr, "AcquireBleConnectionEvent"},
FunctionInfo{35, nullptr, "BleConnect"},
FunctionInfo{36, nullptr, "BleOverrideConnection"},
FunctionInfo{37, nullptr, "BleDisconnect"},
FunctionInfo{38, nullptr, "BleGetConnectionState"},
FunctionInfo{39, nullptr, "BleGetGattClientConditionList"},
FunctionInfo{40, nullptr, "AcquireBlePairingEvent"},
FunctionInfo{41, nullptr, "BlePairDevice"},
FunctionInfo{42, nullptr, "BleUnpairDeviceOnBoth"},
FunctionInfo{43, nullptr, "BleUnpairDevice"},
FunctionInfo{44, nullptr, "BleGetPairedAddresses"},
FunctionInfo{45, nullptr, "AcquireBleServiceDiscoveryEvent"},
FunctionInfo{46, nullptr, "GetGattServices"},
FunctionInfo{47, nullptr, "GetGattService"},
FunctionInfo{48, nullptr, "GetGattIncludedServices"},
FunctionInfo{49, nullptr, "GetBelongingService"},
FunctionInfo{50, nullptr, "GetGattCharacteristics"},
FunctionInfo{51, nullptr, "GetGattDescriptors"},
FunctionInfo{52, nullptr, "AcquireBleMtuConfigEvent"},
FunctionInfo{53, nullptr, "ConfigureBleMtu"},
FunctionInfo{54, nullptr, "GetBleMtu"},
FunctionInfo{55, nullptr, "RegisterBleGattDataPath"},
FunctionInfo{56, nullptr, "UnregisterBleGattDataPath"},
FunctionInfo{57, nullptr, "RegisterAppletResourceUserId"},
FunctionInfo{58, nullptr, "UnregisterAppletResourceUserId"},
FunctionInfo{59, nullptr, "SetAppletResourceUserId"},
FunctionInfo{60, nullptr, "AcquireBleConnectionParameterUpdateEvent", MakeVersionGate({8,0,0})},
FunctionInfo{61, nullptr, "SetCeLength", MakeVersionGate({8,0,0})},
FunctionInfo{62, nullptr, "EnsureSlotExpansion", MakeVersionGate({9,0,0})},
FunctionInfo{63, nullptr, "IsSlotExpansionEnsured", MakeVersionGate({9,0,0})},
FunctionInfo{64, nullptr, "CancelConnectionTrigger", MakeVersionGate({10,0,0})},
FunctionInfo{65, nullptr, "GetConnectionCapacity", MakeVersionGate({13,0,0})},
FunctionInfo{66, nullptr, "GetWlanMode", MakeVersionGate({13,0,0})},
FunctionInfo{67, nullptr, "IsSlotSavingEnabled", MakeVersionGate({13,0,0})},
FunctionInfo{68, nullptr, "IsSlotSavingForPairingEnabled", MakeVersionGate({13,0,0})},
FunctionInfo{69, nullptr, "AcquireAudioDeviceConnectionEvent", MakeVersionGate({13,0,0})},
FunctionInfo{70, nullptr, "GetConnectedAudioDevices", MakeVersionGate({13,0,0})},
FunctionInfo{71, nullptr, "SetAudioSourceVolume", MakeVersionGate({13,0,0})},
FunctionInfo{72, nullptr, "GetAudioSourceVolume", MakeVersionGate({13,0,0})},
FunctionInfo{73, nullptr, "RequestAudioDeviceConnectionRejection", MakeVersionGate({13,0,0})},
FunctionInfo{74, nullptr, "CancelAudioDeviceConnectionRejection", MakeVersionGate({13,0,0})},
FunctionInfo{75, nullptr, "GetPairedAudioDevices", MakeVersionGate({13,0,0})},
FunctionInfo{76, nullptr, "SetWlanModeWithOption", MakeVersionGate({13,1,0})},
FunctionInfo{100, nullptr, "AcquireConnectionDisallowedEvent", MakeVersionGate({13,0,0})},
FunctionInfo{101, nullptr, "GetUsecaseViolationFactor", MakeVersionGate({13,0,0})},
FunctionInfo{110, nullptr, "GetShortenedDeviceInfo", MakeVersionGate({13,0,0})},
FunctionInfo{111, nullptr, "AcquirePairingCountUpdateEvent"},//13.0.0+
FunctionInfo{112, nullptr, "Unknown112", MakeVersionGate({14,0,0}, {14,1,2})},
FunctionInfo{113, nullptr, "Unknown113", MakeVersionGate({14,0,0}, {14,1,2})},
FunctionInfo{114, nullptr, "IsFirstAudioControlConnection", MakeVersionGate({14,0,0})},
FunctionInfo{115, nullptr, "GetShortenedDeviceCondition", MakeVersionGate({14,0,0})},
FunctionInfo{116, nullptr, "SetAudioSinkVolume", MakeVersionGate({15,0,0})},
FunctionInfo{117, nullptr, "GetAudioSinkVolume", MakeVersionGate({15,0,0})}
);
std::optional<FunctionInfoBase> FindRequest(u32 key) override {
return HandlerTableGenerateWithFind(key, functions);
}
};
-40
View File
@@ -1,40 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include "core/hle/service/btm/btm_debug.h"
namespace Service::BTM {
IBtmDebug::IBtmDebug(Core::System& system_) : ServiceFramework{system_, "btm:dbg"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, nullptr, "AcquireDiscoveryEvent"},
{1, nullptr, "StartDiscovery"},
{2, nullptr, "CancelDiscovery"},
{3, nullptr, "GetDeviceProperty"},
{4, nullptr, "CreateBond"},
{5, nullptr, "CancelBond"},
{6, nullptr, "SetTsiMode"},
{7, nullptr, "GeneralTest"},
{8, nullptr, "HidConnect"},
{9, nullptr, "GeneralGet"}, //5.0.0+
{10, nullptr, "GetGattClientDisconnectionReason"}, //5.0.0+
{11, nullptr, "GetBleConnectionParameter"}, //5.1.0+
{12, nullptr, "GetBleConnectionParameterRequest"}, //5.1.0+
{13, nullptr, "GetDiscoveredDevice"}, //12.0.0+
{14, nullptr, "SleepAwakeLoopTest"}, //15.0.0+
{15, nullptr, "SleepTest"}, //15.0.0+
{16, nullptr, "MinimumAwakeTest"}, //15.0.0+
{17, nullptr, "ForceEnableBtm"}, //15.0.0+
};
// clang-format on
RegisterHandlers(functions);
}
IBtmDebug::~IBtmDebug() = default;
} // namespace Service::BTM
-24
View File
@@ -1,24 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "core/hle/service/cmif_types.h"
#include "core/hle/service/service.h"
namespace Core {
class System;
}
namespace Service::BTM {
class IBtmDebug final : public ServiceFramework<IBtmDebug> {
public:
explicit IBtmDebug(Core::System& system_);
~IBtmDebug() override;
};
} // namespace Service::BTM
-34
View File
@@ -1,34 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include "common/logging.h"
#include "core/hle/service/btm/btm_system.h"
#include "core/hle/service/btm/btm_system_core.h"
#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/service.h"
namespace Service::BTM {
IBtmSystem::IBtmSystem(Core::System& system_) : ServiceFramework{system_, "btm:sys"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, C<&IBtmSystem::GetCore>, "GetCore"},
};
// clang-format on
RegisterHandlers(functions);
}
IBtmSystem::~IBtmSystem() = default;
Result IBtmSystem::GetCore(OutInterface<IBtmSystemCore> out_interface) {
LOG_WARNING(Service_BTM, "called");
*out_interface = std::make_shared<IBtmSystemCore>(system);
R_SUCCEED();
}
} // namespace Service::BTM
-28
View File
@@ -1,28 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "core/hle/service/cmif_types.h"
#include "core/hle/service/service.h"
namespace Core {
class System;
}
namespace Service::BTM {
class IBtmSystemCore;
class IBtmSystem final : public ServiceFramework<IBtmSystem> {
public:
explicit IBtmSystem(Core::System& system_);
~IBtmSystem() override;
private:
Result GetCore(OutInterface<IBtmSystemCore> out_interface);
};
} // namespace Service::BTM
@@ -1,135 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include "common/logging.h"
#include "core/hle/service/btm/btm_system_core.h"
#include "core/hle/service/cmif_serialization.h"
#include "core/hle/service/set/system_settings_server.h"
#include "core/hle/service/sm/sm.h"
namespace Service::BTM {
IBtmSystemCore::IBtmSystemCore(Core::System& system_)
: ServiceFramework{system_, "IBtmSystemCore"}, service_context{system_, "IBtmSystemCore"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, C<&IBtmSystemCore::StartGamepadPairing>, "StartGamepadPairing"},
{1, C<&IBtmSystemCore::CancelGamepadPairing>, "CancelGamepadPairing"},
{2, nullptr, "ClearGamepadPairingDatabase"},
{3, nullptr, "GetPairedGamepadCount"},
{4, C<&IBtmSystemCore::EnableRadio>, "EnableRadio"},
{5, C<&IBtmSystemCore::DisableRadio>, "DisableRadio"},
{6, C<&IBtmSystemCore::IsRadioEnabled>, "IsRadioEnabled"},
{7, C<&IBtmSystemCore::AcquireRadioEvent>, "AcquireRadioEvent"},
{8, nullptr, "AcquireGamepadPairingEvent"},
{9, nullptr, "IsGamepadPairingStarted"},
{10, nullptr, "StartAudioDeviceDiscovery"},
{11, nullptr, "StopAudioDeviceDiscovery"},
{12, nullptr, "IsDiscoveryingAudioDevice"},
{13, C<&IBtmSystemCore::GetDiscoveredAudioDevice>, "GetDiscoveredAudioDevice"},
{14, C<&IBtmSystemCore::AcquireAudioDeviceConnectionEvent>, "AcquireAudioDeviceConnectionEvent"},
{15, nullptr, "ConnectAudioDevice"},
{16, nullptr, "IsConnectingAudioDevice"},
{17, C<&IBtmSystemCore::GetConnectedAudioDevices>, "GetConnectedAudioDevices"},
{18, nullptr, "DisconnectAudioDevice"},
{19, nullptr, "AcquirePairedAudioDeviceInfoChangedEvent"},
{20, C<&IBtmSystemCore::GetPairedAudioDevices>, "GetPairedAudioDevices"},
{21, nullptr, "RemoveAudioDevicePairing"},
{22, C<&IBtmSystemCore::RequestAudioDeviceConnectionRejection>, "RequestAudioDeviceConnectionRejection"},
{23, C<&IBtmSystemCore::CancelAudioDeviceConnectionRejection>, "CancelAudioDeviceConnectionRejection"}
};
// clang-format on
RegisterHandlers(functions);
radio_event = service_context.CreateEvent("IBtmSystemCore::RadioEvent");
audio_device_connection_event =
service_context.CreateEvent("IBtmSystemCore::AudioDeviceConnectionEvent");
m_set_sys =
system.ServiceManager().GetService<Service::Set::ISystemSettingsServer>("set:sys", true);
}
IBtmSystemCore::~IBtmSystemCore() {
service_context.CloseEvent(radio_event);
service_context.CloseEvent(audio_device_connection_event);
}
Result IBtmSystemCore::StartGamepadPairing() {
LOG_WARNING(Service_BTM, "(STUBBED) called");
R_SUCCEED();
}
Result IBtmSystemCore::CancelGamepadPairing() {
LOG_WARNING(Service_BTM, "(STUBBED) called");
R_SUCCEED();
}
Result IBtmSystemCore::EnableRadio() {
LOG_DEBUG(Service_BTM, "called");
R_RETURN(m_set_sys->SetBluetoothEnableFlag(true));
}
Result IBtmSystemCore::DisableRadio() {
LOG_DEBUG(Service_BTM, "called");
R_RETURN(m_set_sys->SetBluetoothEnableFlag(false));
}
Result IBtmSystemCore::IsRadioEnabled(Out<bool> out_is_enabled) {
LOG_DEBUG(Service_BTM, "called");
R_RETURN(m_set_sys->GetBluetoothEnableFlag(out_is_enabled));
}
Result IBtmSystemCore::AcquireRadioEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &radio_event->GetReadableEvent();
R_SUCCEED();
}
Result IBtmSystemCore::GetDiscoveredAudioDevice(OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices, s32 count, Out<s32> out_total) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
R_SUCCEED();
}
Result IBtmSystemCore::AcquireAudioDeviceConnectionEvent(
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_event = &audio_device_connection_event->GetReadableEvent();
R_SUCCEED();
}
Result IBtmSystemCore::GetConnectedAudioDevices(
Out<s32> out_count, OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_count = 0;
R_SUCCEED();
}
Result IBtmSystemCore::GetPairedAudioDevices(
Out<s32> out_count, OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_count = 0;
R_SUCCEED();
}
Result IBtmSystemCore::RequestAudioDeviceConnectionRejection(ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_BTM, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
R_SUCCEED();
}
Result IBtmSystemCore::CancelAudioDeviceConnectionRejection(ClientAppletResourceUserId aruid) {
LOG_WARNING(Service_BTM, "(STUBBED) called, applet_resource_user_id={}", aruid.pid);
R_SUCCEED();
}
} // namespace Service::BTM
@@ -1,62 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "core/hle/service/cmif_types.h"
#include "core/hle/service/kernel_helpers.h"
#include "core/hle/service/service.h"
namespace Kernel {
class KEvent;
class KReadableEvent;
} // namespace Kernel
namespace Core {
class System;
}
namespace Service::Set {
class ISystemSettingsServer;
}
namespace Service::BTM {
class IBtmSystemCore final : public ServiceFramework<IBtmSystemCore> {
public:
explicit IBtmSystemCore(Core::System& system_);
~IBtmSystemCore() override;
private:
Result StartGamepadPairing();
Result CancelGamepadPairing();
Result EnableRadio();
Result DisableRadio();
Result IsRadioEnabled(Out<bool> out_is_enabled);
Result AcquireRadioEvent(Out<bool> out_is_valid, OutCopyHandle<Kernel::KReadableEvent> out_event);
Result GetDiscoveredAudioDevice(OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices, s32 count, Out<s32> out_total);
Result AcquireAudioDeviceConnectionEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
Result GetConnectedAudioDevices(
Out<s32> out_count,
OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices);
Result GetPairedAudioDevices(
Out<s32> out_count,
OutArray<std::array<u8, 0xFF>, BufferAttr_HipcPointer> out_audio_devices);
Result RequestAudioDeviceConnectionRejection(ClientAppletResourceUserId aruid);
Result CancelAudioDeviceConnectionRejection(ClientAppletResourceUserId aruid);
KernelHelpers::ServiceContext service_context;
Kernel::KEvent* radio_event;
Kernel::KEvent* audio_device_connection_event;
std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
};
} // namespace Service::BTM
-33
View File
@@ -1,33 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include "common/logging.h"
#include "core/hle/service/btm/btm_user.h"
#include "core/hle/service/btm/btm_user_core.h"
#include "core/hle/service/cmif_serialization.h"
namespace Service::BTM {
IBtmUser::IBtmUser(Core::System& system_) : ServiceFramework{system_, "btm:u"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, C<&IBtmUser::GetCore>, "GetCore"},
};
// clang-format on
RegisterHandlers(functions);
}
IBtmUser::~IBtmUser() = default;
Result IBtmUser::GetCore(OutInterface<IBtmUserCore> out_interface) {
LOG_WARNING(Service_BTM, "called");
*out_interface = std::make_shared<IBtmUserCore>(system);
R_SUCCEED();
}
} // namespace Service::BTM
-28
View File
@@ -1,28 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "core/hle/service/cmif_types.h"
#include "core/hle/service/service.h"
namespace Core {
class System;
}
namespace Service::BTM {
class IBtmUserCore;
class IBtmUser final : public ServiceFramework<IBtmUser> {
public:
explicit IBtmUser(Core::System& system_);
~IBtmUser() override;
private:
Result GetCore(OutInterface<IBtmUserCore> out_interface);
};
} // namespace Service::BTM
-106
View File
@@ -1,106 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#include <memory>
#include "common/logging.h"
#include "core/core.h"
#include "core/hle/kernel/k_event.h"
#include "core/hle/service/btm/btm_user_core.h"
#include "core/hle/service/cmif_serialization.h"
namespace Service::BTM {
IBtmUserCore::IBtmUserCore(Core::System& system_)
: ServiceFramework{system_, "IBtmUserCore"}, service_context{system_, "IBtmUserCore"} {
// clang-format off
static const FunctionInfo functions[] = {
{0, C<&IBtmUserCore::AcquireBleScanEvent>, "AcquireBleScanEvent"},
{1, nullptr, "GetBleScanFilterParameter"},
{2, nullptr, "GetBleScanFilterParameter2"},
{3, nullptr, "StartBleScanForGeneral"},
{4, nullptr, "StopBleScanForGeneral"},
{5, nullptr, "GetBleScanResultsForGeneral"},
{6, nullptr, "StartBleScanForPaired"},
{7, nullptr, "StopBleScanForPaired"},
{8, nullptr, "StartBleScanForSmartDevice"},
{9, nullptr, "StopBleScanForSmartDevice"},
{10, nullptr, "GetBleScanResultsForSmartDevice"},
{17, C<&IBtmUserCore::AcquireBleConnectionEvent>, "AcquireBleConnectionEvent"},
{18, nullptr, "BleConnect"},
{19, nullptr, "BleDisconnect"},
{20, nullptr, "BleGetConnectionState"},
{21, nullptr, "AcquireBlePairingEvent"},
{22, nullptr, "BlePairDevice"},
{23, nullptr, "BleUnPairDevice"},
{24, nullptr, "BleUnPairDevice2"},
{25, nullptr, "BleGetPairedDevices"},
{26, C<&IBtmUserCore::AcquireBleServiceDiscoveryEvent>, "AcquireBleServiceDiscoveryEvent"},
{27, nullptr, "GetGattServices"},
{28, nullptr, "GetGattService"},
{29, nullptr, "GetGattIncludedServices"},
{30, nullptr, "GetBelongingGattService"},
{31, nullptr, "GetGattCharacteristics"},
{32, nullptr, "GetGattDescriptors"},
{33, C<&IBtmUserCore::AcquireBleMtuConfigEvent>, "AcquireBleMtuConfigEvent"},
{34, nullptr, "ConfigureBleMtu"},
{35, nullptr, "GetBleMtu"},
{36, nullptr, "RegisterBleGattDataPath"},
{37, nullptr, "UnregisterBleGattDataPath"},
};
// clang-format on
RegisterHandlers(functions);
scan_event = service_context.CreateEvent("IBtmUserCore:ScanEvent");
connection_event = service_context.CreateEvent("IBtmUserCore:ConnectionEvent");
service_discovery_event = service_context.CreateEvent("IBtmUserCore:DiscoveryEvent");
config_event = service_context.CreateEvent("IBtmUserCore:ConfigEvent");
}
IBtmUserCore::~IBtmUserCore() {
service_context.CloseEvent(scan_event);
service_context.CloseEvent(connection_event);
service_context.CloseEvent(service_discovery_event);
service_context.CloseEvent(config_event);
}
Result IBtmUserCore::AcquireBleScanEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &scan_event->GetReadableEvent();
R_SUCCEED();
}
Result IBtmUserCore::AcquireBleConnectionEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &connection_event->GetReadableEvent();
R_SUCCEED();
}
Result IBtmUserCore::AcquireBleServiceDiscoveryEvent(
Out<bool> out_is_valid, OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &service_discovery_event->GetReadableEvent();
R_SUCCEED();
}
Result IBtmUserCore::AcquireBleMtuConfigEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event) {
LOG_WARNING(Service_BTM, "(STUBBED) called");
*out_is_valid = true;
*out_event = &config_event->GetReadableEvent();
R_SUCCEED();
}
} // namespace Service::BTM
-50
View File
@@ -1,50 +0,0 @@
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
#pragma once
#include "core/hle/service/cmif_types.h"
#include "core/hle/service/kernel_helpers.h"
#include "core/hle/service/service.h"
namespace Kernel {
class KEvent;
class KReadableEvent;
} // namespace Kernel
namespace Core {
class System;
}
namespace Service::BTM {
class IBtmUserCore final : public ServiceFramework<IBtmUserCore> {
public:
explicit IBtmUserCore(Core::System& system_);
~IBtmUserCore() override;
private:
Result AcquireBleScanEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event);
Result AcquireBleConnectionEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event);
Result AcquireBleServiceDiscoveryEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event);
Result AcquireBleMtuConfigEvent(Out<bool> out_is_valid,
OutCopyHandle<Kernel::KReadableEvent> out_event);
KernelHelpers::ServiceContext service_context;
Kernel::KEvent* scan_event;
Kernel::KEvent* connection_event;
Kernel::KEvent* service_discovery_event;
Kernel::KEvent* config_event;
};
} // namespace Service::BTM