stuff/suyu
stuff/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu.git synced 2024-11-22 10:51:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

input_common: Remove duplicated DriverResult enum

Browse source
This commit is contained in:
german77 2023-06-28 00:20:38 -06:00 committed by Narr the Reg
parent 0fe44071f8
commit df9685a21c
21 changed files with 523 additions and 479 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/common/input.h
View file

@ -75,8 +75,10 @@ enum class DriverResult {
ErrorWritingData, ErrorWritingData,
NoDeviceDetected, NoDeviceDetected,
InvalidHandle, InvalidHandle,
InvalidParameters,
NotSupported, NotSupported,
Disabled, Disabled,
Delayed,
Unknown, Unknown,
}; };

35
src/input_common/drivers/joycon.cpp
View file

@ -102,12 +102,12 @@ bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {
Joycon::SerialNumber serial_number{}; Joycon::SerialNumber serial_number{};
const auto result = Joycon::JoyconDriver::GetDeviceType(device_info, type); const auto result = Joycon::JoyconDriver::GetDeviceType(device_info, type);
if (result != Joycon::DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return false; return false;
} }
const auto result2 = Joycon::JoyconDriver::GetSerialNumber(device_info, serial_number); const auto result2 = Joycon::JoyconDriver::GetSerialNumber(device_info, serial_number);
if (result2 != Joycon::DriverResult::Success) { if (result2 != Common::Input::DriverResult::Success) {
return false; return false;
} }
@ -171,10 +171,10 @@ void Joycons::RegisterNewDevice(SDL_hid_device_info* device_info) {
LOG_WARNING(Input, "No free handles available"); LOG_WARNING(Input, "No free handles available");
return; return;
} }
if (result == Joycon::DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = handle->RequestDeviceAccess(device_info); result = handle->RequestDeviceAccess(device_info);
} }
if (result == Joycon::DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
LOG_WARNING(Input, "Initialize device"); LOG_WARNING(Input, "Initialize device");
const std::size_t port = handle->GetDevicePort(); const std::size_t port = handle->GetDevicePort();
@ -273,8 +273,7 @@ Common::Input::DriverResult Joycons::SetLeds(const PadIdentifier& identifier,
led_config += led_status.led_3 ? 4 : 0; led_config += led_status.led_3 ? 4 : 0;
led_config += led_status.led_4 ? 8 : 0; led_config += led_status.led_4 ? 8 : 0;
return static_cast<Common::Input::DriverResult>( return handle->SetLedConfig(static_cast<u8>(led_config));
handle->SetLedConfig(static_cast<u8>(led_config)));
} }
Common::Input::DriverResult Joycons::SetCameraFormat(const PadIdentifier& identifier, Common::Input::DriverResult Joycons::SetCameraFormat(const PadIdentifier& identifier,
@ -283,8 +282,8 @@ Common::Input::DriverResult Joycons::SetCameraFormat(const PadIdentifier& identi
if (handle == nullptr) { if (handle == nullptr) {
return Common::Input::DriverResult::InvalidHandle; return Common::Input::DriverResult::InvalidHandle;
} }
return static_cast<Common::Input::DriverResult>(handle->SetIrsConfig( return handle->SetIrsConfig(Joycon::IrsMode::ImageTransfer,
Joycon::IrsMode::ImageTransfer, static_cast<Joycon::IrsResolution>(camera_format))); static_cast<Joycon::IrsResolution>(camera_format));
}; };
Common::Input::NfcState Joycons::SupportsNfc(const PadIdentifier& identifier_) const { Common::Input::NfcState Joycons::SupportsNfc(const PadIdentifier& identifier_) const {
@ -351,7 +350,7 @@ Common::Input::NfcState Joycons::ReadMifareData(const PadIdentifier& identifier,
std::vector<Joycon::MifareReadData> read_data(read_request.size()); std::vector<Joycon::MifareReadData> read_data(read_request.size());
const auto result = handle->ReadMifareData(read_request, read_data); const auto result = handle->ReadMifareData(read_request, read_data);
if (result == Joycon::DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
for (std::size_t i = 0; i < read_request.size(); i++) { for (std::size_t i = 0; i < read_request.size(); i++) {
data.data[i] = { data.data[i] = {
.command = static_cast<u8>(command), .command = static_cast<u8>(command),
@ -402,15 +401,15 @@ Common::Input::DriverResult Joycons::SetPollingMode(const PadIdentifier& identif
switch (polling_mode) { switch (polling_mode) {
case Common::Input::PollingMode::Active: case Common::Input::PollingMode::Active:
return static_cast<Common::Input::DriverResult>(handle->SetActiveMode()); return handle->SetActiveMode();
case Common::Input::PollingMode::Passive: case Common::Input::PollingMode::Passive:
return static_cast<Common::Input::DriverResult>(handle->SetPassiveMode()); return handle->SetPassiveMode();
case Common::Input::PollingMode::IR: case Common::Input::PollingMode::IR:
return static_cast<Common::Input::DriverResult>(handle->SetIrMode()); return handle->SetIrMode();
case Common::Input::PollingMode::NFC: case Common::Input::PollingMode::NFC:
return static_cast<Common::Input::DriverResult>(handle->SetNfcMode()); return handle->SetNfcMode();
case Common::Input::PollingMode::Ring: case Common::Input::PollingMode::Ring:
return static_cast<Common::Input::DriverResult>(handle->SetRingConMode()); return handle->SetRingConMode();
default: default:
return Common::Input::DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
@ -828,13 +827,13 @@ std::string Joycons::JoyconName(Joycon::ControllerType type) const {
} }
} }
Common::Input::NfcState Joycons::TranslateDriverResult(Joycon::DriverResult result) const { Common::Input::NfcState Joycons::TranslateDriverResult(Common::Input::DriverResult result) const {
switch (result) { switch (result) {
case Joycon::DriverResult::Success: case Common::Input::DriverResult::Success:
return Common::Input::NfcState::Success; return Common::Input::NfcState::Success;
case Joycon::DriverResult::Disabled: case Common::Input::DriverResult::Disabled:
return Common::Input::NfcState::WrongDeviceState; return Common::Input::NfcState::WrongDeviceState;
case Joycon::DriverResult::NotSupported: case Common::Input::DriverResult::NotSupported:
return Common::Input::NfcState::NotSupported; return Common::Input::NfcState::NotSupported;
default: default:
return Common::Input::NfcState::Unknown; return Common::Input::NfcState::Unknown;

3
src/input_common/drivers/joycon.h
View file

@ -17,7 +17,6 @@ struct Color;
struct MotionData; struct MotionData;
struct TagInfo; struct TagInfo;
enum class ControllerType : u8; enum class ControllerType : u8;
enum class DriverResult;
enum class IrsResolution; enum class IrsResolution;
class JoyconDriver; class JoyconDriver;
} // namespace InputCommon::Joycon } // namespace InputCommon::Joycon
@ -112,7 +111,7 @@ private:
/// Returns the name of the device in text format /// Returns the name of the device in text format
std::string JoyconName(Joycon::ControllerType type) const; std::string JoyconName(Joycon::ControllerType type) const;
Common::Input::NfcState TranslateDriverResult(Joycon::DriverResult result) const; Common::Input::NfcState TranslateDriverResult(Common::Input::DriverResult result) const;
std::jthread scan_thread; std::jthread scan_thread;

123
src/input_common/helpers/joycon_driver.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "common/input.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "common/scope_exit.h" #include "common/scope_exit.h"
#include "common/swap.h" #include "common/swap.h"
@ -28,13 +29,13 @@ void JoyconDriver::Stop() {
input_thread = {}; input_thread = {};
} }
DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_info* device_info) { Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_info* device_info) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
handle_device_type = ControllerType::None; handle_device_type = ControllerType::None;
GetDeviceType(device_info, handle_device_type); GetDeviceType(device_info, handle_device_type);
if (handle_device_type == ControllerType::None) { if (handle_device_type == ControllerType::None) {
return DriverResult::UnsupportedControllerType; return Common::Input::DriverResult::UnsupportedControllerType;
} }
hidapi_handle->handle = hidapi_handle->handle =
@ -43,15 +44,15 @@ DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_info* device_info)
if (!hidapi_handle->handle) { if (!hidapi_handle->handle) {
LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.", LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
device_info->vendor_id, device_info->product_id); device_info->vendor_id, device_info->product_id);
return DriverResult::HandleInUse; return Common::Input::DriverResult::HandleInUse;
} }
SDL_hid_set_nonblocking(hidapi_handle->handle, 1); SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult JoyconDriver::InitializeDevice() { Common::Input::DriverResult JoyconDriver::InitializeDevice() {
if (!hidapi_handle->handle) { if (!hidapi_handle->handle) {
return DriverResult::InvalidHandle; return Common::Input::DriverResult::InvalidHandle;
} }
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
disable_input_thread = true; disable_input_thread = true;
@ -87,7 +88,7 @@ DriverResult JoyconDriver::InitializeDevice() {
rumble_protocol = std::make_unique<RumbleProtocol>(hidapi_handle); rumble_protocol = std::make_unique<RumbleProtocol>(hidapi_handle);
// Get fixed joycon info // Get fixed joycon info
if (generic_protocol->GetVersionNumber(version) != DriverResult::Success) { if (generic_protocol->GetVersionNumber(version) != Common::Input::DriverResult::Success) {
// If this command fails the device doesn't accept configuration commands // If this command fails the device doesn't accept configuration commands
input_only_device = true; input_only_device = true;
} }
@ -129,7 +130,7 @@ DriverResult JoyconDriver::InitializeDevice() {
} }
disable_input_thread = false; disable_input_thread = false;
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
void JoyconDriver::InputThread(std::stop_token stop_token) { void JoyconDriver::InputThread(std::stop_token stop_token) {
@ -229,7 +230,7 @@ void JoyconDriver::OnNewData(std::span<u8> buffer) {
if (!amiibo_detected) { if (!amiibo_detected) {
Joycon::TagInfo tag_info; Joycon::TagInfo tag_info;
const auto result = nfc_protocol->GetTagInfo(tag_info); const auto result = nfc_protocol->GetTagInfo(tag_info);
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
joycon_poller->UpdateAmiibo(tag_info); joycon_poller->UpdateAmiibo(tag_info);
amiibo_detected = true; amiibo_detected = true;
} }
@ -255,7 +256,7 @@ void JoyconDriver::OnNewData(std::span<u8> buffer) {
} }
} }
DriverResult JoyconDriver::SetPollingMode() { Common::Input::DriverResult JoyconDriver::SetPollingMode() {
SCOPE_EXIT({ disable_input_thread = false; }); SCOPE_EXIT({ disable_input_thread = false; });
disable_input_thread = true; disable_input_thread = true;
@ -270,7 +271,7 @@ DriverResult JoyconDriver::SetPollingMode() {
} }
if (input_only_device) { if (input_only_device) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (irs_protocol->IsEnabled()) { if (irs_protocol->IsEnabled()) {
@ -289,7 +290,7 @@ DriverResult JoyconDriver::SetPollingMode() {
if (irs_enabled && supported_features.irs) { if (irs_enabled && supported_features.irs) {
auto result = irs_protocol->EnableIrs(); auto result = irs_protocol->EnableIrs();
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
return result; return result;
} }
irs_protocol->DisableIrs(); irs_protocol->DisableIrs();
@ -299,7 +300,7 @@ DriverResult JoyconDriver::SetPollingMode() {
if (nfc_enabled && supported_features.nfc) { if (nfc_enabled && supported_features.nfc) {
auto result = nfc_protocol->EnableNfc(); auto result = nfc_protocol->EnableNfc();
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
return result; return result;
} }
nfc_protocol->DisableNfc(); nfc_protocol->DisableNfc();
@ -309,10 +310,10 @@ DriverResult JoyconDriver::SetPollingMode() {
if (hidbus_enabled && supported_features.hidbus) { if (hidbus_enabled && supported_features.hidbus) {
auto result = ring_protocol->EnableRingCon(); auto result = ring_protocol->EnableRingCon();
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = ring_protocol->StartRingconPolling(); result = ring_protocol->StartRingconPolling();
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
ring_connected = true; ring_connected = true;
return result; return result;
} }
@ -324,7 +325,7 @@ DriverResult JoyconDriver::SetPollingMode() {
if (passive_enabled && supported_features.passive) { if (passive_enabled && supported_features.passive) {
const auto result = generic_protocol->EnablePassiveMode(); const auto result = generic_protocol->EnablePassiveMode();
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
return result; return result;
} }
LOG_ERROR(Input, "Error enabling passive mode"); LOG_ERROR(Input, "Error enabling passive mode");
@ -332,7 +333,7 @@ DriverResult JoyconDriver::SetPollingMode() {
// Default Mode // Default Mode
const auto result = generic_protocol->EnableActiveMode(); const auto result = generic_protocol->EnableActiveMode();
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
LOG_ERROR(Input, "Error enabling active mode"); LOG_ERROR(Input, "Error enabling active mode");
} }
// Switch calls this function after enabling active mode // Switch calls this function after enabling active mode
@ -396,26 +397,26 @@ bool JoyconDriver::IsPayloadCorrect(int status, std::span<const u8> buffer) {
return true; return true;
} }
DriverResult JoyconDriver::SetVibration(const VibrationValue& vibration) { Common::Input::DriverResult JoyconDriver::SetVibration(const VibrationValue& vibration) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (disable_input_thread) { if (disable_input_thread) {
return DriverResult::HandleInUse; return Common::Input::DriverResult::HandleInUse;
} }
return rumble_protocol->SendVibration(vibration); return rumble_protocol->SendVibration(vibration);
} }
DriverResult JoyconDriver::SetLedConfig(u8 led_pattern) { Common::Input::DriverResult JoyconDriver::SetLedConfig(u8 led_pattern) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (disable_input_thread) { if (disable_input_thread) {
return DriverResult::HandleInUse; return Common::Input::DriverResult::HandleInUse;
} }
return generic_protocol->SetLedPattern(led_pattern); return generic_protocol->SetLedPattern(led_pattern);
} }
DriverResult JoyconDriver::SetIrsConfig(IrsMode mode_, IrsResolution format_) { Common::Input::DriverResult JoyconDriver::SetIrsConfig(IrsMode mode_, IrsResolution format_) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (disable_input_thread) { if (disable_input_thread) {
return DriverResult::HandleInUse; return Common::Input::DriverResult::HandleInUse;
} }
disable_input_thread = true; disable_input_thread = true;
const auto result = irs_protocol->SetIrsConfig(mode_, format_); const auto result = irs_protocol->SetIrsConfig(mode_, format_);
@ -423,7 +424,7 @@ DriverResult JoyconDriver::SetIrsConfig(IrsMode mode_, IrsResolution format_) {
return result; return result;
} }
DriverResult JoyconDriver::SetPassiveMode() { Common::Input::DriverResult JoyconDriver::SetPassiveMode() {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
motion_enabled = false; motion_enabled = false;
hidbus_enabled = false; hidbus_enabled = false;
@ -433,7 +434,7 @@ DriverResult JoyconDriver::SetPassiveMode() {
return SetPollingMode(); return SetPollingMode();
} }
DriverResult JoyconDriver::SetActiveMode() { Common::Input::DriverResult JoyconDriver::SetActiveMode() {
if (is_ring_disabled_by_irs) { if (is_ring_disabled_by_irs) {
is_ring_disabled_by_irs = false; is_ring_disabled_by_irs = false;
SetActiveMode(); SetActiveMode();
@ -449,11 +450,11 @@ DriverResult JoyconDriver::SetActiveMode() {
return SetPollingMode(); return SetPollingMode();
} }
DriverResult JoyconDriver::SetIrMode() { Common::Input::DriverResult JoyconDriver::SetIrMode() {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.irs) { if (!supported_features.irs) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (ring_connected) { if (ring_connected) {
@ -468,11 +469,11 @@ DriverResult JoyconDriver::SetIrMode() {
return SetPollingMode(); return SetPollingMode();
} }
DriverResult JoyconDriver::SetNfcMode() { Common::Input::DriverResult JoyconDriver::SetNfcMode() {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.nfc) { if (!supported_features.nfc) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
motion_enabled = true; motion_enabled = true;
@ -483,11 +484,11 @@ DriverResult JoyconDriver::SetNfcMode() {
return SetPollingMode(); return SetPollingMode();
} }
DriverResult JoyconDriver::SetRingConMode() { Common::Input::DriverResult JoyconDriver::SetRingConMode() {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.hidbus) { if (!supported_features.hidbus) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
motion_enabled = true; motion_enabled = true;
@ -499,20 +500,20 @@ DriverResult JoyconDriver::SetRingConMode() {
const auto result = SetPollingMode(); const auto result = SetPollingMode();
if (!ring_connected) { if (!ring_connected) {
return DriverResult::NoDeviceDetected; return Common::Input::DriverResult::NoDeviceDetected;
} }
return result; return result;
} }
DriverResult JoyconDriver::StartNfcPolling() { Common::Input::DriverResult JoyconDriver::StartNfcPolling() {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.nfc) { if (!supported_features.nfc) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (!nfc_protocol->IsEnabled()) { if (!nfc_protocol->IsEnabled()) {
return DriverResult::Disabled; return Common::Input::DriverResult::Disabled;
} }
disable_input_thread = true; disable_input_thread = true;
@ -522,14 +523,14 @@ DriverResult JoyconDriver::StartNfcPolling() {
return result; return result;
} }
DriverResult JoyconDriver::StopNfcPolling() { Common::Input::DriverResult JoyconDriver::StopNfcPolling() {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.nfc) { if (!supported_features.nfc) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (!nfc_protocol->IsEnabled()) { if (!nfc_protocol->IsEnabled()) {
return DriverResult::Disabled; return Common::Input::DriverResult::Disabled;
} }
disable_input_thread = true; disable_input_thread = true;
@ -544,17 +545,17 @@ DriverResult JoyconDriver::StopNfcPolling() {
return result; return result;
} }
DriverResult JoyconDriver::ReadAmiiboData(std::vector<u8>& out_data) { Common::Input::DriverResult JoyconDriver::ReadAmiiboData(std::vector<u8>& out_data) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.nfc) { if (!supported_features.nfc) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (!nfc_protocol->IsEnabled()) { if (!nfc_protocol->IsEnabled()) {
return DriverResult::Disabled; return Common::Input::DriverResult::Disabled;
} }
if (!amiibo_detected) { if (!amiibo_detected) {
return DriverResult::ErrorWritingData; return Common::Input::DriverResult::ErrorWritingData;
} }
out_data.resize(0x21C); out_data.resize(0x21C);
@ -565,17 +566,17 @@ DriverResult JoyconDriver::ReadAmiiboData(std::vector<u8>& out_data) {
return result; return result;
} }
DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data) { Common::Input::DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.nfc) { if (!supported_features.nfc) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (!nfc_protocol->IsEnabled()) { if (!nfc_protocol->IsEnabled()) {
return DriverResult::Disabled; return Common::Input::DriverResult::Disabled;
} }
if (!amiibo_detected) { if (!amiibo_detected) {
return DriverResult::ErrorWritingData; return Common::Input::DriverResult::ErrorWritingData;
} }
disable_input_thread = true; disable_input_thread = true;
@ -585,18 +586,18 @@ DriverResult JoyconDriver::WriteNfcData(std::span<const u8> data) {
return result; return result;
} }
DriverResult JoyconDriver::ReadMifareData(std::span<const MifareReadChunk> data, Common::Input::DriverResult JoyconDriver::ReadMifareData(std::span<const MifareReadChunk> data,
std::span<MifareReadData> out_data) { std::span<MifareReadData> out_data) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.nfc) { if (!supported_features.nfc) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (!nfc_protocol->IsEnabled()) { if (!nfc_protocol->IsEnabled()) {
return DriverResult::Disabled; return Common::Input::DriverResult::Disabled;
} }
if (!amiibo_detected) { if (!amiibo_detected) {
return DriverResult::ErrorWritingData; return Common::Input::DriverResult::ErrorWritingData;
} }
disable_input_thread = true; disable_input_thread = true;
@ -606,17 +607,17 @@ DriverResult JoyconDriver::ReadMifareData(std::span<const MifareReadChunk> data,
return result; return result;
} }
DriverResult JoyconDriver::WriteMifareData(std::span<const MifareWriteChunk> data) { Common::Input::DriverResult JoyconDriver::WriteMifareData(std::span<const MifareWriteChunk> data) {
std::scoped_lock lock{mutex}; std::scoped_lock lock{mutex};
if (!supported_features.nfc) { if (!supported_features.nfc) {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
if (!nfc_protocol->IsEnabled()) { if (!nfc_protocol->IsEnabled()) {
return DriverResult::Disabled; return Common::Input::DriverResult::Disabled;
} }
if (!amiibo_detected) { if (!amiibo_detected) {
return DriverResult::ErrorWritingData; return Common::Input::DriverResult::ErrorWritingData;
} }
disable_input_thread = true; disable_input_thread = true;
@ -675,7 +676,7 @@ void JoyconDriver::SetCallbacks(const JoyconCallbacks& callbacks) {
joycon_poller->SetCallbacks(callbacks); joycon_poller->SetCallbacks(callbacks);
} }
DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info, Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info,
ControllerType& controller_type) { ControllerType& controller_type) {
static constexpr std::array<std::pair<u32, ControllerType>, 6> supported_devices{ static constexpr std::array<std::pair<u32, ControllerType>, 6> supported_devices{
std::pair<u32, ControllerType>{0x2006, ControllerType::Left}, std::pair<u32, ControllerType>{0x2006, ControllerType::Left},
@ -686,25 +687,25 @@ DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info,
controller_type = ControllerType::None; controller_type = ControllerType::None;
if (device_info->vendor_id != nintendo_vendor_id) { if (device_info->vendor_id != nintendo_vendor_id) {
return DriverResult::UnsupportedControllerType; return Common::Input::DriverResult::UnsupportedControllerType;
} }
for (const auto& [product_id, type] : supported_devices) { for (const auto& [product_id, type] : supported_devices) {
if (device_info->product_id == static_cast<u16>(product_id)) { if (device_info->product_id == static_cast<u16>(product_id)) {
controller_type = type; controller_type = type;
return Joycon::DriverResult::Success; return Common::Input::DriverResult::Success;
} }
} }
return Joycon::DriverResult::UnsupportedControllerType; return Common::Input::DriverResult::UnsupportedControllerType;
} }
DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info, Common::Input::DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info,
SerialNumber& serial_number) { SerialNumber& serial_number) {
if (device_info->serial_number == nullptr) { if (device_info->serial_number == nullptr) {
return DriverResult::Unknown; return Common::Input::DriverResult::Unknown;
} }
std::memcpy(&serial_number, device_info->serial_number, 15); std::memcpy(&serial_number, device_info->serial_number, 15);
return Joycon::DriverResult::Success; return Common::Input::DriverResult::Success;
} }
} // namespace InputCommon::Joycon } // namespace InputCommon::Joycon

42
src/input_common/helpers/joycon_driver.h
View file

@ -11,6 +11,10 @@
#include "input_common/helpers/joycon_protocol/joycon_types.h" #include "input_common/helpers/joycon_protocol/joycon_types.h"
namespace Common::Input {
enum class DriverResult;
}
namespace InputCommon::Joycon { namespace InputCommon::Joycon {
class CalibrationProtocol; class CalibrationProtocol;
class GenericProtocol; class GenericProtocol;
@ -26,8 +30,8 @@ public:
~JoyconDriver(); ~JoyconDriver();
DriverResult RequestDeviceAccess(SDL_hid_device_info* device_info); Common::Input::DriverResult RequestDeviceAccess(SDL_hid_device_info* device_info);
DriverResult InitializeDevice(); Common::Input::DriverResult InitializeDevice();
void Stop(); void Stop();
bool IsConnected() const; bool IsConnected() const;
@ -41,30 +45,30 @@ public:
SerialNumber GetSerialNumber() const; SerialNumber GetSerialNumber() const;
SerialNumber GetHandleSerialNumber() const; SerialNumber GetHandleSerialNumber() const;
DriverResult SetVibration(const VibrationValue& vibration); Common::Input::DriverResult SetVibration(const VibrationValue& vibration);
DriverResult SetLedConfig(u8 led_pattern); Common::Input::DriverResult SetLedConfig(u8 led_pattern);
DriverResult SetIrsConfig(IrsMode mode_, IrsResolution format_); Common::Input::DriverResult SetIrsConfig(IrsMode mode_, IrsResolution format_);
DriverResult SetPassiveMode(); Common::Input::DriverResult SetPassiveMode();
DriverResult SetActiveMode(); Common::Input::DriverResult SetActiveMode();
DriverResult SetIrMode(); Common::Input::DriverResult SetIrMode();
DriverResult SetNfcMode(); Common::Input::DriverResult SetNfcMode();
DriverResult SetRingConMode(); Common::Input::DriverResult SetRingConMode();
DriverResult StartNfcPolling(); Common::Input::DriverResult StartNfcPolling();
DriverResult StopNfcPolling(); Common::Input::DriverResult StopNfcPolling();
DriverResult ReadAmiiboData(std::vector<u8>& out_data); Common::Input::DriverResult ReadAmiiboData(std::vector<u8>& out_data);
DriverResult WriteNfcData(std::span<const u8> data); Common::Input::DriverResult WriteNfcData(std::span<const u8> data);
DriverResult ReadMifareData(std::span<const MifareReadChunk> request, Common::Input::DriverResult ReadMifareData(std::span<const MifareReadChunk> request,
std::span<MifareReadData> out_data); std::span<MifareReadData> out_data);
DriverResult WriteMifareData(std::span<const MifareWriteChunk> request); Common::Input::DriverResult WriteMifareData(std::span<const MifareWriteChunk> request);
void SetCallbacks(const JoyconCallbacks& callbacks); void SetCallbacks(const JoyconCallbacks& callbacks);
// Returns device type from hidapi handle // Returns device type from hidapi handle
static DriverResult GetDeviceType(SDL_hid_device_info* device_info, static Common::Input::DriverResult GetDeviceType(SDL_hid_device_info* device_info,
ControllerType& controller_type); ControllerType& controller_type);
// Returns serial number from hidapi handle // Returns serial number from hidapi handle
static DriverResult GetSerialNumber(SDL_hid_device_info* device_info, static Common::Input::DriverResult GetSerialNumber(SDL_hid_device_info* device_info,
SerialNumber& serial_number); SerialNumber& serial_number);
private: private:
@ -84,7 +88,7 @@ private:
void OnNewData(std::span<u8> buffer); void OnNewData(std::span<u8> buffer);
/// Updates device configuration to enable or disable features /// Updates device configuration to enable or disable features
DriverResult SetPollingMode(); Common::Input::DriverResult SetPollingMode();
/// Returns true if input thread is valid and doesn't need to be stopped /// Returns true if input thread is valid and doesn't need to be stopped
bool IsInputThreadValid() const; bool IsInputThreadValid() const;

49
src/input_common/helpers/joycon_protocol/calibration.cpp
View file

@ -3,6 +3,7 @@
#include <cstring> #include <cstring>
#include "common/input.h"
#include "input_common/helpers/joycon_protocol/calibration.h" #include "input_common/helpers/joycon_protocol/calibration.h"
#include "input_common/helpers/joycon_protocol/joycon_types.h" #include "input_common/helpers/joycon_protocol/joycon_types.h"
@ -11,28 +12,29 @@ namespace InputCommon::Joycon {
CalibrationProtocol::CalibrationProtocol(std::shared_ptr<JoyconHandle> handle) CalibrationProtocol::CalibrationProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {} : JoyconCommonProtocol(std::move(handle)) {}
DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration& calibration) { Common::Input::DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(
JoyStickCalibration& calibration) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
JoystickLeftSpiCalibration spi_calibration{}; JoystickLeftSpiCalibration spi_calibration{};
bool has_user_calibration = false; bool has_user_calibration = false;
calibration = {}; calibration = {};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = HasUserCalibration(SpiAddress::USER_LEFT_MAGIC, has_user_calibration); result = HasUserCalibration(SpiAddress::USER_LEFT_MAGIC, has_user_calibration);
} }
// Read User defined calibration // Read User defined calibration
if (result == DriverResult::Success && has_user_calibration) { if (result == Common::Input::DriverResult::Success && has_user_calibration) {
result = ReadSPI(SpiAddress::USER_LEFT_DATA, spi_calibration); result = ReadSPI(SpiAddress::USER_LEFT_DATA, spi_calibration);
} }
// Read Factory calibration // Read Factory calibration
if (result == DriverResult::Success && !has_user_calibration) { if (result == Common::Input::DriverResult::Success && !has_user_calibration) {
result = ReadSPI(SpiAddress::FACT_LEFT_DATA, spi_calibration); result = ReadSPI(SpiAddress::FACT_LEFT_DATA, spi_calibration);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
calibration.x.center = GetXAxisCalibrationValue(spi_calibration.center); calibration.x.center = GetXAxisCalibrationValue(spi_calibration.center);
calibration.y.center = GetYAxisCalibrationValue(spi_calibration.center); calibration.y.center = GetYAxisCalibrationValue(spi_calibration.center);
calibration.x.min = GetXAxisCalibrationValue(spi_calibration.min); calibration.x.min = GetXAxisCalibrationValue(spi_calibration.min);
@ -47,28 +49,29 @@ DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration
return result; return result;
} }
DriverResult CalibrationProtocol::GetRightJoyStickCalibration(JoyStickCalibration& calibration) { Common::Input::DriverResult CalibrationProtocol::GetRightJoyStickCalibration(
JoyStickCalibration& calibration) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
JoystickRightSpiCalibration spi_calibration{}; JoystickRightSpiCalibration spi_calibration{};
bool has_user_calibration = false; bool has_user_calibration = false;
calibration = {}; calibration = {};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = HasUserCalibration(SpiAddress::USER_RIGHT_MAGIC, has_user_calibration); result = HasUserCalibration(SpiAddress::USER_RIGHT_MAGIC, has_user_calibration);
} }
// Read User defined calibration // Read User defined calibration
if (result == DriverResult::Success && has_user_calibration) { if (result == Common::Input::DriverResult::Success && has_user_calibration) {
result = ReadSPI(SpiAddress::USER_RIGHT_DATA, spi_calibration); result = ReadSPI(SpiAddress::USER_RIGHT_DATA, spi_calibration);
} }
// Read Factory calibration // Read Factory calibration
if (result == DriverResult::Success && !has_user_calibration) { if (result == Common::Input::DriverResult::Success && !has_user_calibration) {
result = ReadSPI(SpiAddress::FACT_RIGHT_DATA, spi_calibration); result = ReadSPI(SpiAddress::FACT_RIGHT_DATA, spi_calibration);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
calibration.x.center = GetXAxisCalibrationValue(spi_calibration.center); calibration.x.center = GetXAxisCalibrationValue(spi_calibration.center);
calibration.y.center = GetYAxisCalibrationValue(spi_calibration.center); calibration.y.center = GetYAxisCalibrationValue(spi_calibration.center);
calibration.x.min = GetXAxisCalibrationValue(spi_calibration.min); calibration.x.min = GetXAxisCalibrationValue(spi_calibration.min);
@ -83,28 +86,28 @@ DriverResult CalibrationProtocol::GetRightJoyStickCalibration(JoyStickCalibratio
return result; return result;
} }
DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibration) { Common::Input::DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibration) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
ImuSpiCalibration spi_calibration{}; ImuSpiCalibration spi_calibration{};
bool has_user_calibration = false; bool has_user_calibration = false;
calibration = {}; calibration = {};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = HasUserCalibration(SpiAddress::USER_IMU_MAGIC, has_user_calibration); result = HasUserCalibration(SpiAddress::USER_IMU_MAGIC, has_user_calibration);
} }
// Read User defined calibration // Read User defined calibration
if (result == DriverResult::Success && has_user_calibration) { if (result == Common::Input::DriverResult::Success && has_user_calibration) {
result = ReadSPI(SpiAddress::USER_IMU_DATA, spi_calibration); result = ReadSPI(SpiAddress::USER_IMU_DATA, spi_calibration);
} }
// Read Factory calibration // Read Factory calibration
if (result == DriverResult::Success && !has_user_calibration) { if (result == Common::Input::DriverResult::Success && !has_user_calibration) {
result = ReadSPI(SpiAddress::FACT_IMU_DATA, spi_calibration); result = ReadSPI(SpiAddress::FACT_IMU_DATA, spi_calibration);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
calibration.accelerometer[0].offset = spi_calibration.accelerometer_offset[0]; calibration.accelerometer[0].offset = spi_calibration.accelerometer_offset[0];
calibration.accelerometer[1].offset = spi_calibration.accelerometer_offset[1]; calibration.accelerometer[1].offset = spi_calibration.accelerometer_offset[1];
calibration.accelerometer[2].offset = spi_calibration.accelerometer_offset[2]; calibration.accelerometer[2].offset = spi_calibration.accelerometer_offset[2];
@ -127,7 +130,7 @@ DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibrati
return result; return result;
} }
DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibration, Common::Input::DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibration,
s16 current_value) { s16 current_value) {
constexpr s16 DefaultRingRange{800}; constexpr s16 DefaultRingRange{800};
@ -144,15 +147,15 @@ DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibratio
.max_value = ring_data_max, .max_value = ring_data_max,
.min_value = ring_data_min, .min_value = ring_data_min,
}; };
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult CalibrationProtocol::HasUserCalibration(SpiAddress address, Common::Input::DriverResult CalibrationProtocol::HasUserCalibration(SpiAddress address,
bool& has_user_calibration) { bool& has_user_calibration) {
MagicSpiCalibration spi_magic{}; MagicSpiCalibration spi_magic{};
const DriverResult result{ReadSPI(address, spi_magic)}; const Common::Input::DriverResult result{ReadSPI(address, spi_magic)};
has_user_calibration = false; has_user_calibration = false;
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
has_user_calibration = spi_magic.first == CalibrationMagic::USR_MAGIC_0 && has_user_calibration = spi_magic.first == CalibrationMagic::USR_MAGIC_0 &&
spi_magic.second == CalibrationMagic::USR_MAGIC_1; spi_magic.second == CalibrationMagic::USR_MAGIC_1;
} }

15
src/input_common/helpers/joycon_protocol/calibration.h
View file

@ -12,8 +12,11 @@
#include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/common_protocol.h"
namespace InputCommon::Joycon { namespace Common::Input {
enum class DriverResult; enum class DriverResult;
}
namespace InputCommon::Joycon {
struct JoyStickCalibration; struct JoyStickCalibration;
struct IMUCalibration; struct IMUCalibration;
struct JoyconHandle; struct JoyconHandle;
@ -31,30 +34,30 @@ public:
* @param is_factory_calibration if true factory values will be returned * @param is_factory_calibration if true factory values will be returned
* @returns JoyStickCalibration of the left joystick * @returns JoyStickCalibration of the left joystick
*/ */
DriverResult GetLeftJoyStickCalibration(JoyStickCalibration& calibration); Common::Input::DriverResult GetLeftJoyStickCalibration(JoyStickCalibration& calibration);
/** /**
* Sends a request to obtain the right stick calibration from memory * Sends a request to obtain the right stick calibration from memory
* @param is_factory_calibration if true factory values will be returned * @param is_factory_calibration if true factory values will be returned
* @returns JoyStickCalibration of the right joystick * @returns JoyStickCalibration of the right joystick
*/ */
DriverResult GetRightJoyStickCalibration(JoyStickCalibration& calibration); Common::Input::DriverResult GetRightJoyStickCalibration(JoyStickCalibration& calibration);
/** /**
* Sends a request to obtain the motion calibration from memory * Sends a request to obtain the motion calibration from memory
* @returns ImuCalibration of the motion sensor * @returns ImuCalibration of the motion sensor
*/ */
DriverResult GetImuCalibration(MotionCalibration& calibration); Common::Input::DriverResult GetImuCalibration(MotionCalibration& calibration);
/** /**
* Calculates on run time the proper calibration of the ring controller * Calculates on run time the proper calibration of the ring controller
* @returns RingCalibration of the ring sensor * @returns RingCalibration of the ring sensor
*/ */
DriverResult GetRingCalibration(RingCalibration& calibration, s16 current_value); Common::Input::DriverResult GetRingCalibration(RingCalibration& calibration, s16 current_value);
private: private:
/// Returns true if the specified address corresponds to the magic value of user calibration /// Returns true if the specified address corresponds to the magic value of user calibration
DriverResult HasUserCalibration(SpiAddress address, bool& has_user_calibration); Common::Input::DriverResult HasUserCalibration(SpiAddress address, bool& has_user_calibration);
/// Converts a raw calibration block to an u16 value containing the x axis value /// Converts a raw calibration block to an u16 value containing the x axis value
u16 GetXAxisCalibrationValue(std::span<u8> block) const; u16 GetXAxisCalibrationValue(std::span<u8> block) const;

94
src/input_common/helpers/joycon_protocol/common_protocol.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "common/input.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/common_protocol.h"
@ -21,10 +22,10 @@ void JoyconCommonProtocol::SetNonBlocking() {
SDL_hid_set_nonblocking(hidapi_handle->handle, 1); SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
} }
DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type) { Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type) {
const auto result = ReadSPI(SpiAddress::DEVICE_TYPE, controller_type); const auto result = ReadSPI(SpiAddress::DEVICE_TYPE, controller_type);
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
// Fallback to 3rd party pro controllers // Fallback to 3rd party pro controllers
if (controller_type == ControllerType::None) { if (controller_type == ControllerType::None) {
controller_type = ControllerType::Pro; controller_type = ControllerType::Pro;
@ -34,12 +35,13 @@ DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type
return result; return result;
} }
DriverResult JoyconCommonProtocol::CheckDeviceAccess(SDL_hid_device_info* device_info) { Common::Input::DriverResult JoyconCommonProtocol::CheckDeviceAccess(
SDL_hid_device_info* device_info) {
ControllerType controller_type{ControllerType::None}; ControllerType controller_type{ControllerType::None};
const auto result = GetDeviceType(controller_type); const auto result = GetDeviceType(controller_type);
if (result != DriverResult::Success || controller_type == ControllerType::None) { if (result != Common::Input::DriverResult::Success || controller_type == ControllerType::None) {
return DriverResult::UnsupportedControllerType; return Common::Input::DriverResult::UnsupportedControllerType;
} }
hidapi_handle->handle = hidapi_handle->handle =
@ -48,30 +50,30 @@ DriverResult JoyconCommonProtocol::CheckDeviceAccess(SDL_hid_device_info* device
if (!hidapi_handle->handle) { if (!hidapi_handle->handle) {
LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.", LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
device_info->vendor_id, device_info->product_id); device_info->vendor_id, device_info->product_id);
return DriverResult::HandleInUse; return Common::Input::DriverResult::HandleInUse;
} }
SetNonBlocking(); SetNonBlocking();
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult JoyconCommonProtocol::SetReportMode(ReportMode report_mode) { Common::Input::DriverResult JoyconCommonProtocol::SetReportMode(ReportMode report_mode) {
const std::array<u8, 1> buffer{static_cast<u8>(report_mode)}; const std::array<u8, 1> buffer{static_cast<u8>(report_mode)};
return SendSubCommand(SubCommand::SET_REPORT_MODE, buffer); return SendSubCommand(SubCommand::SET_REPORT_MODE, buffer);
} }
DriverResult JoyconCommonProtocol::SendRawData(std::span<const u8> buffer) { Common::Input::DriverResult JoyconCommonProtocol::SendRawData(std::span<const u8> buffer) {
const auto result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size()); const auto result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size());
if (result == -1) { if (result == -1) {
return DriverResult::ErrorWritingData; return Common::Input::DriverResult::ErrorWritingData;
} }
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubCommand sc, Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(
SubCommandResponse& output) { SubCommand sc, SubCommandResponse& output) {
constexpr int timeout_mili = 66; constexpr int timeout_mili = 66;
constexpr int MaxTries = 3; constexpr int MaxTries = 3;
int tries = 0; int tries = 0;
@ -84,15 +86,16 @@ DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubCommand sc,
LOG_ERROR(Input, "No response from joycon"); LOG_ERROR(Input, "No response from joycon");
} }
if (tries++ > MaxTries) { if (tries++ > MaxTries) {
return DriverResult::Timeout; return Common::Input::DriverResult::Timeout;
} }
} while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY && } while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY &&
output.sub_command != sc); output.sub_command != sc);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, std::span<const u8> buffer, Common::Input::DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc,
std::span<const u8> buffer,
SubCommandResponse& output) { SubCommandResponse& output) {
SubCommandPacket packet{ SubCommandPacket packet{
.output_report = OutputReport::RUMBLE_AND_SUBCMD, .output_report = OutputReport::RUMBLE_AND_SUBCMD,
@ -102,26 +105,28 @@ DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, std::span<const
}; };
if (buffer.size() > packet.command_data.size()) { if (buffer.size() > packet.command_data.size()) {
return DriverResult::InvalidParameters; return Common::Input::DriverResult::InvalidParameters;
} }
memcpy(packet.command_data.data(), buffer.data(), buffer.size()); memcpy(packet.command_data.data(), buffer.data(), buffer.size());
auto result = SendData(packet); auto result = SendData(packet);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
return GetSubCommandResponse(sc, output); return GetSubCommandResponse(sc, output);
} }
DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, std::span<const u8> buffer) { Common::Input::DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc,
std::span<const u8> buffer) {
SubCommandResponse output{}; SubCommandResponse output{};
return SendSubCommand(sc, buffer, output); return SendSubCommand(sc, buffer, output);
} }
DriverResult JoyconCommonProtocol::SendMCUCommand(SubCommand sc, std::span<const u8> buffer) { Common::Input::DriverResult JoyconCommonProtocol::SendMCUCommand(SubCommand sc,
std::span<const u8> buffer) {
SubCommandPacket packet{ SubCommandPacket packet{
.output_report = OutputReport::MCU_DATA, .output_report = OutputReport::MCU_DATA,
.packet_counter = GetCounter(), .packet_counter = GetCounter(),
@ -130,7 +135,7 @@ DriverResult JoyconCommonProtocol::SendMCUCommand(SubCommand sc, std::span<const
}; };
if (buffer.size() > packet.command_data.size()) { if (buffer.size() > packet.command_data.size()) {
return DriverResult::InvalidParameters; return Common::Input::DriverResult::InvalidParameters;
} }
memcpy(packet.command_data.data(), buffer.data(), buffer.size()); memcpy(packet.command_data.data(), buffer.data(), buffer.size());
@ -138,7 +143,7 @@ DriverResult JoyconCommonProtocol::SendMCUCommand(SubCommand sc, std::span<const
return SendData(packet); return SendData(packet);
} }
DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffer) { Common::Input::DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffer) {
VibrationPacket packet{ VibrationPacket packet{
.output_report = OutputReport::RUMBLE_ONLY, .output_report = OutputReport::RUMBLE_ONLY,
.packet_counter = GetCounter(), .packet_counter = GetCounter(),
@ -146,7 +151,7 @@ DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffe
}; };
if (buffer.size() > packet.vibration_data.size()) { if (buffer.size() > packet.vibration_data.size()) {
return DriverResult::InvalidParameters; return Common::Input::DriverResult::InvalidParameters;
} }
memcpy(packet.vibration_data.data(), buffer.data(), buffer.size()); memcpy(packet.vibration_data.data(), buffer.data(), buffer.size());
@ -154,7 +159,8 @@ DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffe
return SendData(packet); return SendData(packet);
} }
DriverResult JoyconCommonProtocol::ReadRawSPI(SpiAddress addr, std::span<u8> output) { Common::Input::DriverResult JoyconCommonProtocol::ReadRawSPI(SpiAddress addr,
std::span<u8> output) {
constexpr std::size_t HeaderSize = 5; constexpr std::size_t HeaderSize = 5;
constexpr std::size_t MaxTries = 5; constexpr std::size_t MaxTries = 5;
std::size_t tries = 0; std::size_t tries = 0;
@ -168,36 +174,36 @@ DriverResult JoyconCommonProtocol::ReadRawSPI(SpiAddress addr, std::span<u8> out
memcpy(buffer.data(), &packet_data, sizeof(ReadSpiPacket)); memcpy(buffer.data(), &packet_data, sizeof(ReadSpiPacket));
do { do {
const auto result = SendSubCommand(SubCommand::SPI_FLASH_READ, buffer, response); const auto result = SendSubCommand(SubCommand::SPI_FLASH_READ, buffer, response);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ > MaxTries) { if (tries++ > MaxTries) {
return DriverResult::Timeout; return Common::Input::DriverResult::Timeout;
} }
} while (response.spi_address != addr); } while (response.spi_address != addr);
if (response.command_data.size() < packet_data.size + HeaderSize) { if (response.command_data.size() < packet_data.size + HeaderSize) {
return DriverResult::WrongReply; return Common::Input::DriverResult::WrongReply;
} }
// Remove header from output // Remove header from output
memcpy(output.data(), response.command_data.data() + HeaderSize, packet_data.size); memcpy(output.data(), response.command_data.data() + HeaderSize, packet_data.size);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult JoyconCommonProtocol::EnableMCU(bool enable) { Common::Input::DriverResult JoyconCommonProtocol::EnableMCU(bool enable) {
const std::array<u8, 1> mcu_state{static_cast<u8>(enable ? 1 : 0)}; const std::array<u8, 1> mcu_state{static_cast<u8>(enable ? 1 : 0)};
const auto result = SendSubCommand(SubCommand::SET_MCU_STATE, mcu_state); const auto result = SendSubCommand(SubCommand::SET_MCU_STATE, mcu_state);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
LOG_ERROR(Input, "Failed with error {}", result); LOG_ERROR(Input, "Failed with error {}", result);
} }
return result; return result;
} }
DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig& config) { Common::Input::DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig& config) {
LOG_DEBUG(Input, "ConfigureMCU"); LOG_DEBUG(Input, "ConfigureMCU");
std::array<u8, sizeof(MCUConfig)> config_buffer; std::array<u8, sizeof(MCUConfig)> config_buffer;
memcpy(config_buffer.data(), &config, sizeof(MCUConfig)); memcpy(config_buffer.data(), &config, sizeof(MCUConfig));
@ -205,14 +211,14 @@ DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig& config) {
const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, config_buffer); const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, config_buffer);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
LOG_ERROR(Input, "Failed with error {}", result); LOG_ERROR(Input, "Failed with error {}", result);
} }
return result; return result;
} }
DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode, Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode,
MCUCommandResponse& output) { MCUCommandResponse& output) {
constexpr int TimeoutMili = 200; constexpr int TimeoutMili = 200;
constexpr int MaxTries = 9; constexpr int MaxTries = 9;
@ -226,15 +232,16 @@ DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode,
LOG_ERROR(Input, "No response from joycon attempt {}", tries); LOG_ERROR(Input, "No response from joycon attempt {}", tries);
} }
if (tries++ > MaxTries) { if (tries++ > MaxTries) {
return DriverResult::Timeout; return Common::Input::DriverResult::Timeout;
} }
} while (output.input_report.report_mode != report_mode || } while (output.input_report.report_mode != report_mode ||
output.mcu_report == MCUReport::EmptyAwaitingCmd); output.mcu_report == MCUReport::EmptyAwaitingCmd);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode, MCUSubCommand sc, Common::Input::DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode,
MCUSubCommand sc,
std::span<const u8> buffer, std::span<const u8> buffer,
MCUCommandResponse& output) { MCUCommandResponse& output) {
SubCommandPacket packet{ SubCommandPacket packet{
@ -245,23 +252,24 @@ DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode, MCUSubCom
}; };
if (buffer.size() > packet.command_data.size()) { if (buffer.size() > packet.command_data.size()) {
return DriverResult::InvalidParameters; return Common::Input::DriverResult::InvalidParameters;
} }
memcpy(packet.command_data.data(), buffer.data(), buffer.size()); memcpy(packet.command_data.data(), buffer.data(), buffer.size());
auto result = SendData(packet); auto result = SendData(packet);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
result = GetMCUDataResponse(report_mode, output); result = GetMCUDataResponse(report_mode, output);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult JoyconCommonProtocol::WaitSetMCUMode(ReportMode report_mode, MCUMode mode) { Common::Input::DriverResult JoyconCommonProtocol::WaitSetMCUMode(ReportMode report_mode,
MCUMode mode) {
MCUCommandResponse output{}; MCUCommandResponse output{};
constexpr std::size_t MaxTries{16}; constexpr std::size_t MaxTries{16};
std::size_t tries{}; std::size_t tries{};
@ -269,17 +277,17 @@ DriverResult JoyconCommonProtocol::WaitSetMCUMode(ReportMode report_mode, MCUMod
do { do {
const auto result = SendMCUData(report_mode, MCUSubCommand::SetDeviceMode, {}, output); const auto result = SendMCUData(report_mode, MCUSubCommand::SetDeviceMode, {}, output);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ > MaxTries) { if (tries++ > MaxTries) {
return DriverResult::WrongReply; return Common::Input::DriverResult::WrongReply;
} }
} while (output.mcu_report != MCUReport::StateReport || } while (output.mcu_report != MCUReport::StateReport ||
output.mcu_data[6] != static_cast<u8>(mode)); output.mcu_data[6] != static_cast<u8>(mode));
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
// crc-8-ccitt / polynomial 0x07 look up table // crc-8-ccitt / polynomial 0x07 look up table

42
src/input_common/helpers/joycon_protocol/common_protocol.h
View file

@ -38,30 +38,30 @@ public:
* Sends a request to obtain the joycon type from device * Sends a request to obtain the joycon type from device
* @returns controller type of the joycon * @returns controller type of the joycon
*/ */
DriverResult GetDeviceType(ControllerType& controller_type); Common::Input::DriverResult GetDeviceType(ControllerType& controller_type);
/** /**
* Verifies and sets the joycon_handle if device is valid * Verifies and sets the joycon_handle if device is valid
* @param device info from the driver * @param device info from the driver
* @returns success if the device is valid * @returns success if the device is valid
*/ */
DriverResult CheckDeviceAccess(SDL_hid_device_info* device); Common::Input::DriverResult CheckDeviceAccess(SDL_hid_device_info* device);
/** /**
* Sends a request to set the polling mode of the joycon * Sends a request to set the polling mode of the joycon
* @param report_mode polling mode to be set * @param report_mode polling mode to be set
*/ */
DriverResult SetReportMode(Joycon::ReportMode report_mode); Common::Input::DriverResult SetReportMode(Joycon::ReportMode report_mode);
/** /**
* Sends data to the joycon device * Sends data to the joycon device
* @param buffer data to be send * @param buffer data to be send
*/ */
DriverResult SendRawData(std::span<const u8> buffer); Common::Input::DriverResult SendRawData(std::span<const u8> buffer);
template <typename Output> template <typename Output>
requires std::is_trivially_copyable_v<Output> requires std::is_trivially_copyable_v<Output>
DriverResult SendData(const Output& output) { Common::Input::DriverResult SendData(const Output& output) {
std::array<u8, sizeof(Output)> buffer; std::array<u8, sizeof(Output)> buffer;
std::memcpy(buffer.data(), &output, sizeof(Output)); std::memcpy(buffer.data(), &output, sizeof(Output));
return SendRawData(buffer); return SendRawData(buffer);
@ -72,7 +72,8 @@ public:
* @param sub_command type of data to be returned * @param sub_command type of data to be returned
* @returns a buffer containing the response * @returns a buffer containing the response
*/ */
DriverResult GetSubCommandResponse(SubCommand sub_command, SubCommandResponse& output); Common::Input::DriverResult GetSubCommandResponse(SubCommand sub_command,
SubCommandResponse& output);
/** /**
* Sends a sub command to the device and waits for it's reply * Sends a sub command to the device and waits for it's reply
@ -80,7 +81,7 @@ public:
* @param buffer data to be send * @param buffer data to be send
* @returns output buffer containing the response * @returns output buffer containing the response
*/ */
DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer, Common::Input::DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer,
SubCommandResponse& output); SubCommandResponse& output);
/** /**
@ -88,27 +89,27 @@ public:
* @param sc sub command to be send * @param sc sub command to be send
* @param buffer data to be send * @param buffer data to be send
*/ */
DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer); Common::Input::DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer);
/** /**
* Sends a mcu command to the device * Sends a mcu command to the device
* @param sc sub command to be send * @param sc sub command to be send
* @param buffer data to be send * @param buffer data to be send
*/ */
DriverResult SendMCUCommand(SubCommand sc, std::span<const u8> buffer); Common::Input::DriverResult SendMCUCommand(SubCommand sc, std::span<const u8> buffer);
/** /**
* Sends vibration data to the joycon * Sends vibration data to the joycon
* @param buffer data to be send * @param buffer data to be send
*/ */
DriverResult SendVibrationReport(std::span<const u8> buffer); Common::Input::DriverResult SendVibrationReport(std::span<const u8> buffer);
/** /**
* Reads the SPI memory stored on the joycon * Reads the SPI memory stored on the joycon
* @param Initial address location * @param Initial address location
* @returns output buffer containing the response * @returns output buffer containing the response
*/ */
DriverResult ReadRawSPI(SpiAddress addr, std::span<u8> output); Common::Input::DriverResult ReadRawSPI(SpiAddress addr, std::span<u8> output);
/** /**
* Reads the SPI memory stored on the joycon * Reads the SPI memory stored on the joycon
@ -117,37 +118,38 @@ public:
*/ */
template <typename Output> template <typename Output>
requires std::is_trivially_copyable_v<Output> requires std::is_trivially_copyable_v<Output>
DriverResult ReadSPI(SpiAddress addr, Output& output) { Common::Input::DriverResult ReadSPI(SpiAddress addr, Output& output) {
std::array<u8, sizeof(Output)> buffer; std::array<u8, sizeof(Output)> buffer;
output = {}; output = {};
const auto result = ReadRawSPI(addr, buffer); const auto result = ReadRawSPI(addr, buffer);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
std::memcpy(&output, buffer.data(), sizeof(Output)); std::memcpy(&output, buffer.data(), sizeof(Output));
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
/** /**
* Enables MCU chip on the joycon * Enables MCU chip on the joycon
* @param enable if true the chip will be enabled * @param enable if true the chip will be enabled
*/ */
DriverResult EnableMCU(bool enable); Common::Input::DriverResult EnableMCU(bool enable);
/** /**
* Configures the MCU to the corresponding mode * Configures the MCU to the corresponding mode
* @param MCUConfig configuration * @param MCUConfig configuration
*/ */
DriverResult ConfigureMCU(const MCUConfig& config); Common::Input::DriverResult ConfigureMCU(const MCUConfig& config);
/** /**
* Waits until there's MCU data available. On timeout returns error * Waits until there's MCU data available. On timeout returns error
* @param report mode of the expected reply * @param report mode of the expected reply
* @returns a buffer containing the response * @returns a buffer containing the response
*/ */
DriverResult GetMCUDataResponse(ReportMode report_mode_, MCUCommandResponse& output); Common::Input::DriverResult GetMCUDataResponse(ReportMode report_mode_,
MCUCommandResponse& output);
/** /**
* Sends data to the MCU chip and waits for it's reply * Sends data to the MCU chip and waits for it's reply
@ -156,15 +158,15 @@ public:
* @param buffer data to be send * @param buffer data to be send
* @returns output buffer containing the response * @returns output buffer containing the response
*/ */
DriverResult SendMCUData(ReportMode report_mode, MCUSubCommand sc, std::span<const u8> buffer, Common::Input::DriverResult SendMCUData(ReportMode report_mode, MCUSubCommand sc,
MCUCommandResponse& output); std::span<const u8> buffer, MCUCommandResponse& output);
/** /**
* Wait's until the MCU chip is on the specified mode * Wait's until the MCU chip is on the specified mode
* @param report mode of the expected reply * @param report mode of the expected reply
* @param MCUMode configuration * @param MCUMode configuration
*/ */
DriverResult WaitSetMCUMode(ReportMode report_mode, MCUMode mode); Common::Input::DriverResult WaitSetMCUMode(ReportMode report_mode, MCUMode mode);
/** /**
* Calculates the checksum from the MCU data * Calculates the checksum from the MCU data

48
src/input_common/helpers/joycon_protocol/generic_functions.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "common/input.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "input_common/helpers/joycon_protocol/generic_functions.h" #include "input_common/helpers/joycon_protocol/generic_functions.h"
@ -9,52 +10,53 @@ namespace InputCommon::Joycon {
GenericProtocol::GenericProtocol(std::shared_ptr<JoyconHandle> handle) GenericProtocol::GenericProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {} : JoyconCommonProtocol(std::move(handle)) {}
DriverResult GenericProtocol::EnablePassiveMode() { Common::Input::DriverResult GenericProtocol::EnablePassiveMode() {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
return SetReportMode(ReportMode::SIMPLE_HID_MODE); return SetReportMode(ReportMode::SIMPLE_HID_MODE);
} }
DriverResult GenericProtocol::EnableActiveMode() { Common::Input::DriverResult GenericProtocol::EnableActiveMode() {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
return SetReportMode(ReportMode::STANDARD_FULL_60HZ); return SetReportMode(ReportMode::STANDARD_FULL_60HZ);
} }
DriverResult GenericProtocol::SetLowPowerMode(bool enable) { Common::Input::DriverResult GenericProtocol::SetLowPowerMode(bool enable) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)}; const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)};
return SendSubCommand(SubCommand::LOW_POWER_MODE, buffer); return SendSubCommand(SubCommand::LOW_POWER_MODE, buffer);
} }
DriverResult GenericProtocol::TriggersElapsed() { Common::Input::DriverResult GenericProtocol::TriggersElapsed() {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
return SendSubCommand(SubCommand::TRIGGERS_ELAPSED, {}); return SendSubCommand(SubCommand::TRIGGERS_ELAPSED, {});
} }
DriverResult GenericProtocol::GetDeviceInfo(DeviceInfo& device_info) { Common::Input::DriverResult GenericProtocol::GetDeviceInfo(DeviceInfo& device_info) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
SubCommandResponse output{}; SubCommandResponse output{};
const auto result = SendSubCommand(SubCommand::REQ_DEV_INFO, {}, output); const auto result = SendSubCommand(SubCommand::REQ_DEV_INFO, {}, output);
device_info = {}; device_info = {};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
device_info = output.device_info; device_info = output.device_info;
} }
return result; return result;
} }
DriverResult GenericProtocol::GetControllerType(ControllerType& controller_type) { Common::Input::DriverResult GenericProtocol::GetControllerType(ControllerType& controller_type) {
return GetDeviceType(controller_type); return GetDeviceType(controller_type);
} }
DriverResult GenericProtocol::EnableImu(bool enable) { Common::Input::DriverResult GenericProtocol::EnableImu(bool enable) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)}; const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)};
return SendSubCommand(SubCommand::ENABLE_IMU, buffer); return SendSubCommand(SubCommand::ENABLE_IMU, buffer);
} }
DriverResult GenericProtocol::SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec, Common::Input::DriverResult GenericProtocol::SetImuConfig(GyroSensitivity gsen,
GyroPerformance gfrec,
AccelerometerSensitivity asen, AccelerometerSensitivity asen,
AccelerometerPerformance afrec) { AccelerometerPerformance afrec) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
@ -63,19 +65,19 @@ DriverResult GenericProtocol::SetImuConfig(GyroSensitivity gsen, GyroPerformance
return SendSubCommand(SubCommand::SET_IMU_SENSITIVITY, buffer); return SendSubCommand(SubCommand::SET_IMU_SENSITIVITY, buffer);
} }
DriverResult GenericProtocol::GetBattery(u32& battery_level) { Common::Input::DriverResult GenericProtocol::GetBattery(u32& battery_level) {
// This function is meant to request the high resolution battery status // This function is meant to request the high resolution battery status
battery_level = 0; battery_level = 0;
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
DriverResult GenericProtocol::GetColor(Color& color) { Common::Input::DriverResult GenericProtocol::GetColor(Color& color) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
std::array<u8, 12> buffer{}; std::array<u8, 12> buffer{};
const auto result = ReadRawSPI(SpiAddress::COLOR_DATA, buffer); const auto result = ReadRawSPI(SpiAddress::COLOR_DATA, buffer);
color = {}; color = {};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
color.body = static_cast<u32>((buffer[0] << 16) | (buffer[1] << 8) | buffer[2]); color.body = static_cast<u32>((buffer[0] << 16) | (buffer[1] << 8) | buffer[2]);
color.buttons = static_cast<u32>((buffer[3] << 16) | (buffer[4] << 8) | buffer[5]); color.buttons = static_cast<u32>((buffer[3] << 16) | (buffer[4] << 8) | buffer[5]);
color.left_grip = static_cast<u32>((buffer[6] << 16) | (buffer[7] << 8) | buffer[8]); color.left_grip = static_cast<u32>((buffer[6] << 16) | (buffer[7] << 8) | buffer[8]);
@ -85,26 +87,26 @@ DriverResult GenericProtocol::GetColor(Color& color) {
return result; return result;
} }
DriverResult GenericProtocol::GetSerialNumber(SerialNumber& serial_number) { Common::Input::DriverResult GenericProtocol::GetSerialNumber(SerialNumber& serial_number) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
std::array<u8, 16> buffer{}; std::array<u8, 16> buffer{};
const auto result = ReadRawSPI(SpiAddress::SERIAL_NUMBER, buffer); const auto result = ReadRawSPI(SpiAddress::SERIAL_NUMBER, buffer);
serial_number = {}; serial_number = {};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
memcpy(serial_number.data(), buffer.data() + 1, sizeof(SerialNumber)); memcpy(serial_number.data(), buffer.data() + 1, sizeof(SerialNumber));
} }
return result; return result;
} }
DriverResult GenericProtocol::GetTemperature(u32& temperature) { Common::Input::DriverResult GenericProtocol::GetTemperature(u32& temperature) {
// Not all devices have temperature sensor // Not all devices have temperature sensor
temperature = 25; temperature = 25;
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
DriverResult GenericProtocol::GetVersionNumber(FirmwareVersion& version) { Common::Input::DriverResult GenericProtocol::GetVersionNumber(FirmwareVersion& version) {
DeviceInfo device_info{}; DeviceInfo device_info{};
const auto result = GetDeviceInfo(device_info); const auto result = GetDeviceInfo(device_info);
@ -113,23 +115,23 @@ DriverResult GenericProtocol::GetVersionNumber(FirmwareVersion& version) {
return result; return result;
} }
DriverResult GenericProtocol::SetHomeLight() { Common::Input::DriverResult GenericProtocol::SetHomeLight() {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
static constexpr std::array<u8, 3> buffer{0x0f, 0xf0, 0x00}; static constexpr std::array<u8, 3> buffer{0x0f, 0xf0, 0x00};
return SendSubCommand(SubCommand::SET_HOME_LIGHT, buffer); return SendSubCommand(SubCommand::SET_HOME_LIGHT, buffer);
} }
DriverResult GenericProtocol::SetLedBusy() { Common::Input::DriverResult GenericProtocol::SetLedBusy() {
return DriverResult::NotSupported; return Common::Input::DriverResult::NotSupported;
} }
DriverResult GenericProtocol::SetLedPattern(u8 leds) { Common::Input::DriverResult GenericProtocol::SetLedPattern(u8 leds) {
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
const std::array<u8, 1> buffer{leds}; const std::array<u8, 1> buffer{leds};
return SendSubCommand(SubCommand::SET_PLAYER_LIGHTS, buffer); return SendSubCommand(SubCommand::SET_PLAYER_LIGHTS, buffer);
} }
DriverResult GenericProtocol::SetLedBlinkPattern(u8 leds) { Common::Input::DriverResult GenericProtocol::SetLedBlinkPattern(u8 leds) {
return SetLedPattern(static_cast<u8>(leds << 4)); return SetLedPattern(static_cast<u8>(leds << 4));
} }

41
src/input_common/helpers/joycon_protocol/generic_functions.h
View file

@ -11,6 +11,10 @@
#include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/common_protocol.h"
#include "input_common/helpers/joycon_protocol/joycon_types.h" #include "input_common/helpers/joycon_protocol/joycon_types.h"
namespace Common::Input {
enum class DriverResult;
}
namespace InputCommon::Joycon { namespace InputCommon::Joycon {
/// Joycon driver functions that easily implemented /// Joycon driver functions that easily implemented
@ -20,34 +24,34 @@ public:
/// Enables passive mode. This mode only sends button data on change. Sticks will return digital /// Enables passive mode. This mode only sends button data on change. Sticks will return digital
/// data instead of analog. Motion will be disabled /// data instead of analog. Motion will be disabled
DriverResult EnablePassiveMode(); Common::Input::DriverResult EnablePassiveMode();
/// Enables active mode. This mode will return the current status every 5-15ms /// Enables active mode. This mode will return the current status every 5-15ms
DriverResult EnableActiveMode(); Common::Input::DriverResult EnableActiveMode();
/// Enables or disables the low power mode /// Enables or disables the low power mode
DriverResult SetLowPowerMode(bool enable); Common::Input::DriverResult SetLowPowerMode(bool enable);
/// Unknown function used by the switch /// Unknown function used by the switch
DriverResult TriggersElapsed(); Common::Input::DriverResult TriggersElapsed();
/** /**
* Sends a request to obtain the joycon firmware and mac from handle * Sends a request to obtain the joycon firmware and mac from handle
* @returns controller device info * @returns controller device info
*/ */
DriverResult GetDeviceInfo(DeviceInfo& controller_type); Common::Input::DriverResult GetDeviceInfo(DeviceInfo& controller_type);
/** /**
* Sends a request to obtain the joycon type from handle * Sends a request to obtain the joycon type from handle
* @returns controller type of the joycon * @returns controller type of the joycon
*/ */
DriverResult GetControllerType(ControllerType& controller_type); Common::Input::DriverResult GetControllerType(ControllerType& controller_type);
/** /**
* Enables motion input * Enables motion input
* @param enable if true motion data will be enabled * @param enable if true motion data will be enabled
*/ */
DriverResult EnableImu(bool enable); Common::Input::DriverResult EnableImu(bool enable);
/** /**
* Configures the motion sensor with the specified parameters * Configures the motion sensor with the specified parameters
@ -56,59 +60,60 @@ public:
* @param asen accelerometer sensitivity in G force * @param asen accelerometer sensitivity in G force
* @param afrec accelerometer frequency in hertz * @param afrec accelerometer frequency in hertz
*/ */
DriverResult SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec, Common::Input::DriverResult SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec,
AccelerometerSensitivity asen, AccelerometerPerformance afrec); AccelerometerSensitivity asen,
AccelerometerPerformance afrec);
/** /**
* Request battery level from the device * Request battery level from the device
* @returns battery level * @returns battery level
*/ */
DriverResult GetBattery(u32& battery_level); Common::Input::DriverResult GetBattery(u32& battery_level);
/** /**
* Request joycon colors from the device * Request joycon colors from the device
* @returns colors of the body and buttons * @returns colors of the body and buttons
*/ */
DriverResult GetColor(Color& color); Common::Input::DriverResult GetColor(Color& color);
/** /**
* Request joycon serial number from the device * Request joycon serial number from the device
* @returns 16 byte serial number * @returns 16 byte serial number
*/ */
DriverResult GetSerialNumber(SerialNumber& serial_number); Common::Input::DriverResult GetSerialNumber(SerialNumber& serial_number);
/** /**
* Request joycon serial number from the device * Request joycon serial number from the device
* @returns 16 byte serial number * @returns 16 byte serial number
*/ */
DriverResult GetTemperature(u32& temperature); Common::Input::DriverResult GetTemperature(u32& temperature);
/** /**
* Request joycon serial number from the device * Request joycon serial number from the device
* @returns 16 byte serial number * @returns 16 byte serial number
*/ */
DriverResult GetVersionNumber(FirmwareVersion& version); Common::Input::DriverResult GetVersionNumber(FirmwareVersion& version);
/** /**
* Sets home led behaviour * Sets home led behaviour
*/ */
DriverResult SetHomeLight(); Common::Input::DriverResult SetHomeLight();
/** /**
* Sets home led into a slow breathing state * Sets home led into a slow breathing state
*/ */
DriverResult SetLedBusy(); Common::Input::DriverResult SetLedBusy();
/** /**
* Sets the 4 player leds on the joycon on a solid state * Sets the 4 player leds on the joycon on a solid state
* @params bit flag containing the led state * @params bit flag containing the led state
*/ */
DriverResult SetLedPattern(u8 leds); Common::Input::DriverResult SetLedPattern(u8 leds);
/** /**
* Sets the 4 player leds on the joycon on a blinking state * Sets the 4 player leds on the joycon on a blinking state
* @returns bit flag containing the led state * @returns bit flag containing the led state
*/ */
DriverResult SetLedBlinkPattern(u8 leds); Common::Input::DriverResult SetLedBlinkPattern(u8 leds);
}; };
} // namespace InputCommon::Joycon } // namespace InputCommon::Joycon

70
src/input_common/helpers/joycon_protocol/irs.cpp
View file

@ -1,7 +1,7 @@
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include <thread> #include "common/input.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "input_common/helpers/joycon_protocol/irs.h" #include "input_common/helpers/joycon_protocol/irs.h"
@ -10,21 +10,21 @@ namespace InputCommon::Joycon {
IrsProtocol::IrsProtocol(std::shared_ptr<JoyconHandle> handle) IrsProtocol::IrsProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {} : JoyconCommonProtocol(std::move(handle)) {}
DriverResult IrsProtocol::EnableIrs() { Common::Input::DriverResult IrsProtocol::EnableIrs() {
LOG_INFO(Input, "Enable IRS"); LOG_INFO(Input, "Enable IRS");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = SetReportMode(ReportMode::NFC_IR_MODE_60HZ); result = SetReportMode(ReportMode::NFC_IR_MODE_60HZ);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = EnableMCU(true); result = EnableMCU(true);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::Standby); result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::Standby);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
const MCUConfig config{ const MCUConfig config{
.command = MCUCommand::ConfigureMCU, .command = MCUCommand::ConfigureMCU,
.sub_command = MCUSubCommand::SetMCUMode, .sub_command = MCUSubCommand::SetMCUMode,
@ -34,16 +34,16 @@ DriverResult IrsProtocol::EnableIrs() {
result = ConfigureMCU(config); result = ConfigureMCU(config);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::IR); result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::IR);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = ConfigureIrs(); result = ConfigureIrs();
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WriteRegistersStep1(); result = WriteRegistersStep1();
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WriteRegistersStep2(); result = WriteRegistersStep2();
} }
@ -52,12 +52,12 @@ DriverResult IrsProtocol::EnableIrs() {
return result; return result;
} }
DriverResult IrsProtocol::DisableIrs() { Common::Input::DriverResult IrsProtocol::DisableIrs() {
LOG_DEBUG(Input, "Disable IRS"); LOG_DEBUG(Input, "Disable IRS");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = EnableMCU(false); result = EnableMCU(false);
} }
@ -66,7 +66,7 @@ DriverResult IrsProtocol::DisableIrs() {
return result; return result;
} }
DriverResult IrsProtocol::SetIrsConfig(IrsMode mode, IrsResolution format) { Common::Input::DriverResult IrsProtocol::SetIrsConfig(IrsMode mode, IrsResolution format) {
irs_mode = mode; irs_mode = mode;
switch (format) { switch (format) {
case IrsResolution::Size320x240: case IrsResolution::Size320x240:
@ -103,10 +103,10 @@ DriverResult IrsProtocol::SetIrsConfig(IrsMode mode, IrsResolution format) {
return EnableIrs(); return EnableIrs();
} }
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult IrsProtocol::RequestImage(std::span<u8> buffer) { Common::Input::DriverResult IrsProtocol::RequestImage(std::span<u8> buffer) {
const u8 next_packet_fragment = const u8 next_packet_fragment =
static_cast<u8>((packet_fragment + 1) % (static_cast<u8>(fragments) + 1)); static_cast<u8>((packet_fragment + 1) % (static_cast<u8>(fragments) + 1));
@ -129,7 +129,7 @@ DriverResult IrsProtocol::RequestImage(std::span<u8> buffer) {
return RequestFrame(packet_fragment); return RequestFrame(packet_fragment);
} }
DriverResult IrsProtocol::ConfigureIrs() { Common::Input::DriverResult IrsProtocol::ConfigureIrs() {
LOG_DEBUG(Input, "Configure IRS"); LOG_DEBUG(Input, "Configure IRS");
constexpr std::size_t max_tries = 28; constexpr std::size_t max_tries = 28;
SubCommandResponse output{}; SubCommandResponse output{};
@ -152,20 +152,20 @@ DriverResult IrsProtocol::ConfigureIrs() {
do { do {
const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output); const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ >= max_tries) { if (tries++ >= max_tries) {
return DriverResult::WrongReply; return Common::Input::DriverResult::WrongReply;
} }
} while (output.command_data[0] != 0x0b); } while (output.command_data[0] != 0x0b);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult IrsProtocol::WriteRegistersStep1() { Common::Input::DriverResult IrsProtocol::WriteRegistersStep1() {
LOG_DEBUG(Input, "WriteRegistersStep1"); LOG_DEBUG(Input, "WriteRegistersStep1");
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
constexpr std::size_t max_tries = 28; constexpr std::size_t max_tries = 28;
SubCommandResponse output{}; SubCommandResponse output{};
std::size_t tries = 0; std::size_t tries = 0;
@ -197,7 +197,7 @@ DriverResult IrsProtocol::WriteRegistersStep1() {
mcu_request[36] = CalculateMCU_CRC8(mcu_request.data(), 36); mcu_request[36] = CalculateMCU_CRC8(mcu_request.data(), 36);
mcu_request[37] = 0xFF; mcu_request[37] = 0xFF;
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
@ -205,26 +205,26 @@ DriverResult IrsProtocol::WriteRegistersStep1() {
result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output); result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output);
// First time we need to set the report mode // First time we need to set the report mode
if (result == DriverResult::Success && tries == 0) { if (result == Common::Input::DriverResult::Success && tries == 0) {
result = SendMCUCommand(SubCommand::SET_REPORT_MODE, mcu_request); result = SendMCUCommand(SubCommand::SET_REPORT_MODE, mcu_request);
} }
if (result == DriverResult::Success && tries == 0) { if (result == Common::Input::DriverResult::Success && tries == 0) {
GetSubCommandResponse(SubCommand::SET_MCU_CONFIG, output); GetSubCommandResponse(SubCommand::SET_MCU_CONFIG, output);
} }
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ >= max_tries) { if (tries++ >= max_tries) {
return DriverResult::WrongReply; return Common::Input::DriverResult::WrongReply;
} }
} while (!(output.command_data[0] == 0x13 && output.command_data[2] == 0x07) && } while (!(output.command_data[0] == 0x13 && output.command_data[2] == 0x07) &&
output.command_data[0] != 0x23); output.command_data[0] != 0x23);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult IrsProtocol::WriteRegistersStep2() { Common::Input::DriverResult IrsProtocol::WriteRegistersStep2() {
LOG_DEBUG(Input, "WriteRegistersStep2"); LOG_DEBUG(Input, "WriteRegistersStep2");
constexpr std::size_t max_tries = 28; constexpr std::size_t max_tries = 28;
SubCommandResponse output{}; SubCommandResponse output{};
@ -255,18 +255,18 @@ DriverResult IrsProtocol::WriteRegistersStep2() {
do { do {
const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output); const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ >= max_tries) { if (tries++ >= max_tries) {
return DriverResult::WrongReply; return Common::Input::DriverResult::WrongReply;
} }
} while (output.command_data[0] != 0x13 && output.command_data[0] != 0x23); } while (output.command_data[0] != 0x13 && output.command_data[0] != 0x23);
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult IrsProtocol::RequestFrame(u8 frame) { Common::Input::DriverResult IrsProtocol::RequestFrame(u8 frame) {
std::array<u8, 38> mcu_request{}; std::array<u8, 38> mcu_request{};
mcu_request[3] = frame; mcu_request[3] = frame;
mcu_request[36] = CalculateMCU_CRC8(mcu_request.data(), 36); mcu_request[36] = CalculateMCU_CRC8(mcu_request.data(), 36);
@ -274,7 +274,7 @@ DriverResult IrsProtocol::RequestFrame(u8 frame) {
return SendMCUCommand(SubCommand::SET_REPORT_MODE, mcu_request); return SendMCUCommand(SubCommand::SET_REPORT_MODE, mcu_request);
} }
DriverResult IrsProtocol::ResendFrame(u8 frame) { Common::Input::DriverResult IrsProtocol::ResendFrame(u8 frame) {
std::array<u8, 38> mcu_request{}; std::array<u8, 38> mcu_request{};
mcu_request[1] = 0x1; mcu_request[1] = 0x1;
mcu_request[2] = frame; mcu_request[2] = frame;

22
src/input_common/helpers/joycon_protocol/irs.h
View file

@ -13,19 +13,23 @@
#include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/common_protocol.h"
#include "input_common/helpers/joycon_protocol/joycon_types.h" #include "input_common/helpers/joycon_protocol/joycon_types.h"
namespace Common::Input {
enum class DriverResult;
}
namespace InputCommon::Joycon { namespace InputCommon::Joycon {
class IrsProtocol final : private JoyconCommonProtocol { class IrsProtocol final : private JoyconCommonProtocol {
public: public:
explicit IrsProtocol(std::shared_ptr<JoyconHandle> handle); explicit IrsProtocol(std::shared_ptr<JoyconHandle> handle);
DriverResult EnableIrs(); Common::Input::DriverResult EnableIrs();
DriverResult DisableIrs(); Common::Input::DriverResult DisableIrs();
DriverResult SetIrsConfig(IrsMode mode, IrsResolution format); Common::Input::DriverResult SetIrsConfig(IrsMode mode, IrsResolution format);
DriverResult RequestImage(std::span<u8> buffer); Common::Input::DriverResult RequestImage(std::span<u8> buffer);
std::vector<u8> GetImage() const; std::vector<u8> GetImage() const;
@ -34,13 +38,13 @@ public:
bool IsEnabled() const; bool IsEnabled() const;
private: private:
DriverResult ConfigureIrs(); Common::Input::DriverResult ConfigureIrs();
DriverResult WriteRegistersStep1(); Common::Input::DriverResult WriteRegistersStep1();
DriverResult WriteRegistersStep2(); Common::Input::DriverResult WriteRegistersStep2();
DriverResult RequestFrame(u8 frame); Common::Input::DriverResult RequestFrame(u8 frame);
DriverResult ResendFrame(u8 frame); Common::Input::DriverResult ResendFrame(u8 frame);
IrsMode irs_mode{IrsMode::ImageTransfer}; IrsMode irs_mode{IrsMode::ImageTransfer};
IrsResolution resolution{IrsResolution::Size40x30}; IrsResolution resolution{IrsResolution::Size40x30};

17
src/input_common/helpers/joycon_protocol/joycon_types.h
View file

@ -402,23 +402,6 @@ enum class ExternalDeviceId : u16 {
Starlink = 0x2800, Starlink = 0x2800,
}; };
enum class DriverResult {
Success,
WrongReply,
Timeout,
InvalidParameters,
UnsupportedControllerType,
HandleInUse,
ErrorReadingData,
ErrorWritingData,
NoDeviceDetected,
InvalidHandle,
NotSupported,
Disabled,
Delayed,
Unknown,
};
struct MotionSensorCalibration { struct MotionSensorCalibration {
s16 offset; s16 offset;
s16 scale; s16 scale;

219
src/input_common/helpers/joycon_protocol/nfc.cpp
View file

@ -1,7 +1,7 @@
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include <thread> #include "common/input.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "input_common/helpers/joycon_protocol/nfc.h" #include "input_common/helpers/joycon_protocol/nfc.h"
@ -10,21 +10,21 @@ namespace InputCommon::Joycon {
NfcProtocol::NfcProtocol(std::shared_ptr<JoyconHandle> handle) NfcProtocol::NfcProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {} : JoyconCommonProtocol(std::move(handle)) {}
DriverResult NfcProtocol::EnableNfc() { Common::Input::DriverResult NfcProtocol::EnableNfc() {
LOG_INFO(Input, "Enable NFC"); LOG_INFO(Input, "Enable NFC");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = SetReportMode(ReportMode::NFC_IR_MODE_60HZ); result = SetReportMode(ReportMode::NFC_IR_MODE_60HZ);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = EnableMCU(true); result = EnableMCU(true);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::Standby); result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::Standby);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
const MCUConfig config{ const MCUConfig config{
.command = MCUCommand::ConfigureMCU, .command = MCUCommand::ConfigureMCU,
.sub_command = MCUSubCommand::SetMCUMode, .sub_command = MCUSubCommand::SetMCUMode,
@ -34,32 +34,32 @@ DriverResult NfcProtocol::EnableNfc() {
result = ConfigureMCU(config); result = ConfigureMCU(config);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::NFC); result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::NFC);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::Ready); result = WaitUntilNfcIs(NFCStatus::Ready);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStopPollingRequest(output); result = SendStopPollingRequest(output);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::Ready); result = WaitUntilNfcIs(NFCStatus::Ready);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
is_enabled = true; is_enabled = true;
} }
return result; return result;
} }
DriverResult NfcProtocol::DisableNfc() { Common::Input::DriverResult NfcProtocol::DisableNfc() {
LOG_DEBUG(Input, "Disable NFC"); LOG_DEBUG(Input, "Disable NFC");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = EnableMCU(false); result = EnableMCU(false);
} }
@ -69,60 +69,60 @@ DriverResult NfcProtocol::DisableNfc() {
return result; return result;
} }
DriverResult NfcProtocol::StartNFCPollingMode() { Common::Input::DriverResult NfcProtocol::StartNFCPollingMode() {
LOG_DEBUG(Input, "Start NFC polling Mode"); LOG_DEBUG(Input, "Start NFC polling Mode");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStartPollingRequest(output); result = SendStartPollingRequest(output);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::Polling); result = WaitUntilNfcIs(NFCStatus::Polling);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
is_polling = true; is_polling = true;
} }
return result; return result;
} }
DriverResult NfcProtocol::StopNFCPollingMode() { Common::Input::DriverResult NfcProtocol::StopNFCPollingMode() {
LOG_DEBUG(Input, "Stop NFC polling Mode"); LOG_DEBUG(Input, "Stop NFC polling Mode");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStopPollingRequest(output); result = SendStopPollingRequest(output);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::WriteReady); result = WaitUntilNfcIs(NFCStatus::WriteReady);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
is_polling = false; is_polling = false;
} }
return result; return result;
} }
DriverResult NfcProtocol::GetTagInfo(Joycon::TagInfo& tag_info) { Common::Input::DriverResult NfcProtocol::GetTagInfo(Joycon::TagInfo& tag_info) {
if (update_counter++ < AMIIBO_UPDATE_DELAY) { if (update_counter++ < AMIIBO_UPDATE_DELAY) {
return DriverResult::Delayed; return Common::Input::DriverResult::Delayed;
} }
update_counter = 0; update_counter = 0;
LOG_DEBUG(Input, "Scan for amiibos"); LOG_DEBUG(Input, "Scan for amiibos");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
TagFoundData tag_data{}; TagFoundData tag_data{};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = IsTagInRange(tag_data); result = IsTagInRange(tag_data);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
tag_info = { tag_info = {
.uuid_length = tag_data.uuid_size, .uuid_length = tag_data.uuid_size,
.protocol = 1, .protocol = 1,
@ -147,59 +147,59 @@ DriverResult NfcProtocol::GetTagInfo(Joycon::TagInfo& tag_info) {
return result; return result;
} }
DriverResult NfcProtocol::ReadAmiibo(std::vector<u8>& data) { Common::Input::DriverResult NfcProtocol::ReadAmiibo(std::vector<u8>& data) {
LOG_DEBUG(Input, "Scan for amiibos"); LOG_DEBUG(Input, "Scan for amiibos");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
TagFoundData tag_data{}; TagFoundData tag_data{};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = IsTagInRange(tag_data, 7); result = IsTagInRange(tag_data, 7);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = GetAmiiboData(data); result = GetAmiiboData(data);
} }
return result; return result;
} }
DriverResult NfcProtocol::WriteAmiibo(std::span<const u8> data) { Common::Input::DriverResult NfcProtocol::WriteAmiibo(std::span<const u8> data) {
LOG_DEBUG(Input, "Write amiibo"); LOG_DEBUG(Input, "Write amiibo");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
TagUUID tag_uuid = GetTagUUID(data); TagUUID tag_uuid = GetTagUUID(data);
TagFoundData tag_data{}; TagFoundData tag_data{};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = IsTagInRange(tag_data, 7); result = IsTagInRange(tag_data, 7);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
if (tag_data.uuid != tag_uuid) { if (tag_data.uuid != tag_uuid) {
result = DriverResult::InvalidParameters; result = Common::Input::DriverResult::InvalidParameters;
} }
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStopPollingRequest(output); result = SendStopPollingRequest(output);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::Ready); result = WaitUntilNfcIs(NFCStatus::Ready);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStartPollingRequest(output, true); result = SendStartPollingRequest(output, true);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::WriteReady); result = WaitUntilNfcIs(NFCStatus::WriteReady);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WriteAmiiboData(tag_uuid, data); result = WriteAmiiboData(tag_uuid, data);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::WriteDone); result = WaitUntilNfcIs(NFCStatus::WriteDone);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStopPollingRequest(output); result = SendStopPollingRequest(output);
} }
@ -207,64 +207,65 @@ DriverResult NfcProtocol::WriteAmiibo(std::span<const u8> data) {
return result; return result;
} }
DriverResult NfcProtocol::ReadMifare(std::span<const MifareReadChunk> read_request, Common::Input::DriverResult NfcProtocol::ReadMifare(std::span<const MifareReadChunk> read_request,
std::span<MifareReadData> out_data) { std::span<MifareReadData> out_data) {
LOG_DEBUG(Input, "Read mifare"); LOG_DEBUG(Input, "Read mifare");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
TagFoundData tag_data{}; TagFoundData tag_data{};
MifareUUID tag_uuid{}; MifareUUID tag_uuid{};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = IsTagInRange(tag_data, 7); result = IsTagInRange(tag_data, 7);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
memcpy(tag_uuid.data(), tag_data.uuid.data(), sizeof(MifareUUID)); memcpy(tag_uuid.data(), tag_data.uuid.data(), sizeof(MifareUUID));
result = GetMifareData(tag_uuid, read_request, out_data); result = GetMifareData(tag_uuid, read_request, out_data);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStopPollingRequest(output); result = SendStopPollingRequest(output);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::Ready); result = WaitUntilNfcIs(NFCStatus::Ready);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStartPollingRequest(output, true); result = SendStartPollingRequest(output, true);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::WriteReady); result = WaitUntilNfcIs(NFCStatus::WriteReady);
} }
return result; return result;
} }
DriverResult NfcProtocol::WriteMifare(std::span<const MifareWriteChunk> write_request) { Common::Input::DriverResult NfcProtocol::WriteMifare(
std::span<const MifareWriteChunk> write_request) {
LOG_DEBUG(Input, "Write mifare"); LOG_DEBUG(Input, "Write mifare");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
TagFoundData tag_data{}; TagFoundData tag_data{};
MifareUUID tag_uuid{}; MifareUUID tag_uuid{};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = IsTagInRange(tag_data, 7); result = IsTagInRange(tag_data, 7);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
memcpy(tag_uuid.data(), tag_data.uuid.data(), sizeof(MifareUUID)); memcpy(tag_uuid.data(), tag_data.uuid.data(), sizeof(MifareUUID));
result = WriteMifareData(tag_uuid, write_request); result = WriteMifareData(tag_uuid, write_request);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStopPollingRequest(output); result = SendStopPollingRequest(output);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::Ready); result = WaitUntilNfcIs(NFCStatus::Ready);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
MCUCommandResponse output{}; MCUCommandResponse output{};
result = SendStartPollingRequest(output, true); result = SendStartPollingRequest(output, true);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = WaitUntilNfcIs(NFCStatus::WriteReady); result = WaitUntilNfcIs(NFCStatus::WriteReady);
} }
return result; return result;
@ -277,17 +278,17 @@ bool NfcProtocol::HasAmiibo() {
update_counter = 0; update_counter = 0;
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
TagFoundData tag_data{}; TagFoundData tag_data{};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = IsTagInRange(tag_data, 7); result = IsTagInRange(tag_data, 7);
} }
return result == DriverResult::Success; return result == Common::Input::DriverResult::Success;
} }
DriverResult NfcProtocol::WaitUntilNfcIs(NFCStatus status) { Common::Input::DriverResult NfcProtocol::WaitUntilNfcIs(NFCStatus status) {
constexpr std::size_t timeout_limit = 10; constexpr std::size_t timeout_limit = 10;
MCUCommandResponse output{}; MCUCommandResponse output{};
std::size_t tries = 0; std::size_t tries = 0;
@ -295,30 +296,31 @@ DriverResult NfcProtocol::WaitUntilNfcIs(NFCStatus status) {
do { do {
auto result = SendNextPackageRequest(output, {}); auto result = SendNextPackageRequest(output, {});
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ > timeout_limit) { if (tries++ > timeout_limit) {
return DriverResult::Timeout; return Common::Input::DriverResult::Timeout;
} }
} while (output.mcu_report != MCUReport::NFCState || } while (output.mcu_report != MCUReport::NFCState ||
(output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 || (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 ||
output.mcu_data[5] != 0x31 || output.mcu_data[6] != static_cast<u8>(status)); output.mcu_data[5] != 0x31 || output.mcu_data[6] != static_cast<u8>(status));
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult NfcProtocol::IsTagInRange(TagFoundData& data, std::size_t timeout_limit) { Common::Input::DriverResult NfcProtocol::IsTagInRange(TagFoundData& data,
std::size_t timeout_limit) {
MCUCommandResponse output{}; MCUCommandResponse output{};
std::size_t tries = 0; std::size_t tries = 0;
do { do {
const auto result = SendNextPackageRequest(output, {}); const auto result = SendNextPackageRequest(output, {});
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ > timeout_limit) { if (tries++ > timeout_limit) {
return DriverResult::Timeout; return Common::Input::DriverResult::Timeout;
} }
} while (output.mcu_report != MCUReport::NFCState || } while (output.mcu_report != MCUReport::NFCState ||
(output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 || (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 ||
@ -328,10 +330,10 @@ DriverResult NfcProtocol::IsTagInRange(TagFoundData& data, std::size_t timeout_l
data.uuid_size = std::min(output.mcu_data[14], static_cast<u8>(sizeof(TagUUID))); data.uuid_size = std::min(output.mcu_data[14], static_cast<u8>(sizeof(TagUUID)));
memcpy(data.uuid.data(), output.mcu_data.data() + 15, data.uuid.size()); memcpy(data.uuid.data(), output.mcu_data.data() + 15, data.uuid.size());
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) { Common::Input::DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
constexpr std::size_t timeout_limit = 60; constexpr std::size_t timeout_limit = 60;
MCUCommandResponse output{}; MCUCommandResponse output{};
std::size_t tries = 0; std::size_t tries = 0;
@ -340,7 +342,7 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
std::size_t ntag_buffer_pos = 0; std::size_t ntag_buffer_pos = 0;
auto result = SendReadAmiiboRequest(output, NFCPages::Block135); auto result = SendReadAmiiboRequest(output, NFCPages::Block135);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
@ -349,14 +351,14 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
result = SendNextPackageRequest(output, package_index); result = SendNextPackageRequest(output, package_index);
const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if ((output.mcu_report == MCUReport::NFCReadData || if ((output.mcu_report == MCUReport::NFCReadData ||
output.mcu_report == MCUReport::NFCState) && output.mcu_report == MCUReport::NFCState) &&
nfc_status == NFCStatus::TagLost) { nfc_status == NFCStatus::TagLost) {
return DriverResult::ErrorReadingData; return Common::Input::DriverResult::ErrorReadingData;
} }
if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) { if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) {
@ -375,14 +377,15 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) { if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) {
LOG_INFO(Input, "Finished reading amiibo"); LOG_INFO(Input, "Finished reading amiibo");
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
} }
return DriverResult::Timeout; return Common::Input::DriverResult::Timeout;
} }
DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<const u8> data) { Common::Input::DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid,
std::span<const u8> data) {
constexpr std::size_t timeout_limit = 60; constexpr std::size_t timeout_limit = 60;
const auto nfc_data = MakeAmiiboWritePackage(tag_uuid, data); const auto nfc_data = MakeAmiiboWritePackage(tag_uuid, data);
const std::vector<u8> nfc_buffer_data = SerializeWritePackage(nfc_data); const std::vector<u8> nfc_buffer_data = SerializeWritePackage(nfc_data);
@ -397,7 +400,7 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con
auto result = SendWriteAmiiboRequest(output, tag_uuid); auto result = SendWriteAmiiboRequest(output, tag_uuid);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
@ -406,14 +409,14 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con
result = SendNextPackageRequest(output, package_index); result = SendNextPackageRequest(output, package_index);
const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if ((output.mcu_report == MCUReport::NFCReadData || if ((output.mcu_report == MCUReport::NFCReadData ||
output.mcu_report == MCUReport::NFCState) && output.mcu_report == MCUReport::NFCState) &&
nfc_status == NFCStatus::TagLost) { nfc_status == NFCStatus::TagLost) {
return DriverResult::ErrorReadingData; return Common::Input::DriverResult::ErrorReadingData;
} }
if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) { if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) {
@ -442,7 +445,7 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con
if ((output.mcu_report == MCUReport::NFCReadData || if ((output.mcu_report == MCUReport::NFCReadData ||
output.mcu_report == MCUReport::NFCState) && output.mcu_report == MCUReport::NFCState) &&
nfc_status == NFCStatus::TagLost) { nfc_status == NFCStatus::TagLost) {
return DriverResult::ErrorReadingData; return Common::Input::DriverResult::ErrorReadingData;
} }
// Increase position when data is confirmed by the joycon // Increase position when data is confirmed by the joycon
@ -457,14 +460,14 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con
return result; return result;
} }
DriverResult NfcProtocol::GetMifareData(const MifareUUID& tag_uuid, Common::Input::DriverResult NfcProtocol::GetMifareData(
std::span<const MifareReadChunk> read_request, const MifareUUID& tag_uuid, std::span<const MifareReadChunk> read_request,
std::span<MifareReadData> out_data) { std::span<MifareReadData> out_data) {
constexpr std::size_t timeout_limit = 60; constexpr std::size_t timeout_limit = 60;
const auto nfc_data = MakeMifareReadPackage(tag_uuid, read_request); const auto nfc_data = MakeMifareReadPackage(tag_uuid, read_request);
const std::vector<u8> nfc_buffer_data = SerializeMifareReadPackage(nfc_data); const std::vector<u8> nfc_buffer_data = SerializeMifareReadPackage(nfc_data);
std::span<const u8> buffer(nfc_buffer_data); std::span<const u8> buffer(nfc_buffer_data);
DriverResult result = DriverResult::Success; Common::Input::DriverResult result = Common::Input::DriverResult::Success;
MCUCommandResponse output{}; MCUCommandResponse output{};
u8 block_id = 1; u8 block_id = 1;
u8 package_index = 0; u8 package_index = 0;
@ -486,7 +489,7 @@ DriverResult NfcProtocol::GetMifareData(const MifareUUID& tag_uuid,
const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) {
return DriverResult::ErrorReadingData; return Common::Input::DriverResult::ErrorReadingData;
} }
// Increase position when data is confirmed by the joycon // Increase position when data is confirmed by the joycon
@ -498,7 +501,7 @@ DriverResult NfcProtocol::GetMifareData(const MifareUUID& tag_uuid,
} }
} }
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
@ -507,12 +510,12 @@ DriverResult NfcProtocol::GetMifareData(const MifareUUID& tag_uuid,
result = SendNextPackageRequest(output, package_index); result = SendNextPackageRequest(output, package_index);
const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) {
return DriverResult::ErrorReadingData; return Common::Input::DriverResult::ErrorReadingData;
} }
if (output.mcu_report == MCUReport::NFCState && output.mcu_data[1] == 0x10) { if (output.mcu_report == MCUReport::NFCState && output.mcu_data[1] == 0x10) {
@ -538,13 +541,13 @@ DriverResult NfcProtocol::GetMifareData(const MifareUUID& tag_uuid,
return result; return result;
} }
DriverResult NfcProtocol::WriteMifareData(const MifareUUID& tag_uuid, Common::Input::DriverResult NfcProtocol::WriteMifareData(
std::span<const MifareWriteChunk> write_request) { const MifareUUID& tag_uuid, std::span<const MifareWriteChunk> write_request) {
constexpr std::size_t timeout_limit = 60; constexpr std::size_t timeout_limit = 60;
const auto nfc_data = MakeMifareWritePackage(tag_uuid, write_request); const auto nfc_data = MakeMifareWritePackage(tag_uuid, write_request);
const std::vector<u8> nfc_buffer_data = SerializeMifareWritePackage(nfc_data); const std::vector<u8> nfc_buffer_data = SerializeMifareWritePackage(nfc_data);
std::span<const u8> buffer(nfc_buffer_data); std::span<const u8> buffer(nfc_buffer_data);
DriverResult result = DriverResult::Success; Common::Input::DriverResult result = Common::Input::DriverResult::Success;
MCUCommandResponse output{}; MCUCommandResponse output{};
u8 block_id = 1; u8 block_id = 1;
u8 package_index = 0; u8 package_index = 0;
@ -566,7 +569,7 @@ DriverResult NfcProtocol::WriteMifareData(const MifareUUID& tag_uuid,
const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) {
return DriverResult::ErrorReadingData; return Common::Input::DriverResult::ErrorReadingData;
} }
// Increase position when data is confirmed by the joycon // Increase position when data is confirmed by the joycon
@ -578,7 +581,7 @@ DriverResult NfcProtocol::WriteMifareData(const MifareUUID& tag_uuid,
} }
} }
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
@ -587,12 +590,12 @@ DriverResult NfcProtocol::WriteMifareData(const MifareUUID& tag_uuid,
result = SendNextPackageRequest(output, package_index); result = SendNextPackageRequest(output, package_index);
const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) {
return DriverResult::ErrorReadingData; return Common::Input::DriverResult::ErrorReadingData;
} }
if (output.mcu_report == MCUReport::NFCState && output.mcu_data[1] == 0x10) { if (output.mcu_report == MCUReport::NFCState && output.mcu_data[1] == 0x10) {
@ -609,7 +612,7 @@ DriverResult NfcProtocol::WriteMifareData(const MifareUUID& tag_uuid,
return result; return result;
} }
DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output, Common::Input::DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output,
bool is_second_attempt) { bool is_second_attempt) {
NFCRequestState request{ NFCRequestState request{
.command_argument = NFCCommand::StartPolling, .command_argument = NFCCommand::StartPolling,
@ -635,7 +638,7 @@ DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output,
output); output);
} }
DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) { Common::Input::DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) {
NFCRequestState request{ NFCRequestState request{
.command_argument = NFCCommand::StopPolling, .command_argument = NFCCommand::StopPolling,
.block_id = {}, .block_id = {},
@ -653,7 +656,8 @@ DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) {
output); output);
} }
DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id) { Common::Input::DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output,
u8 packet_id) {
NFCRequestState request{ NFCRequestState request{
.command_argument = NFCCommand::StartWaitingRecieve, .command_argument = NFCCommand::StartWaitingRecieve,
.block_id = {}, .block_id = {},
@ -671,7 +675,8 @@ DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output, u8
output); output);
} }
DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output, NFCPages ntag_pages) { Common::Input::DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output,
NFCPages ntag_pages) {
NFCRequestState request{ NFCRequestState request{
.command_argument = NFCCommand::ReadNtag, .command_argument = NFCCommand::ReadNtag,
.block_id = {}, .block_id = {},
@ -696,7 +701,7 @@ DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output, NFCP
output); output);
} }
DriverResult NfcProtocol::SendWriteAmiiboRequest(MCUCommandResponse& output, Common::Input::DriverResult NfcProtocol::SendWriteAmiiboRequest(MCUCommandResponse& output,
const TagUUID& tag_uuid) { const TagUUID& tag_uuid) {
NFCRequestState request{ NFCRequestState request{
.command_argument = NFCCommand::ReadNtag, .command_argument = NFCCommand::ReadNtag,
@ -722,7 +727,8 @@ DriverResult NfcProtocol::SendWriteAmiiboRequest(MCUCommandResponse& output,
output); output);
} }
DriverResult NfcProtocol::SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id, Common::Input::DriverResult NfcProtocol::SendWriteDataAmiiboRequest(MCUCommandResponse& output,
u8 block_id,
bool is_last_packet, bool is_last_packet,
std::span<const u8> data) { std::span<const u8> data) {
const auto data_size = std::min(data.size(), sizeof(NFCRequestState::raw_data)); const auto data_size = std::min(data.size(), sizeof(NFCRequestState::raw_data));
@ -745,8 +751,9 @@ DriverResult NfcProtocol::SendWriteDataAmiiboRequest(MCUCommandResponse& output,
output); output);
} }
DriverResult NfcProtocol::SendReadDataMifareRequest(MCUCommandResponse& output, u8 block_id, Common::Input::DriverResult NfcProtocol::SendReadDataMifareRequest(MCUCommandResponse& output,
bool is_last_packet, std::span<const u8> data) { u8 block_id, bool is_last_packet,
std::span<const u8> data) {
const auto data_size = std::min(data.size(), sizeof(NFCRequestState::raw_data)); const auto data_size = std::min(data.size(), sizeof(NFCRequestState::raw_data));
NFCRequestState request{ NFCRequestState request{
.command_argument = NFCCommand::Mifare, .command_argument = NFCCommand::Mifare,

56
src/input_common/helpers/joycon_protocol/nfc.h
View file

@ -13,30 +13,34 @@
#include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/common_protocol.h"
#include "input_common/helpers/joycon_protocol/joycon_types.h" #include "input_common/helpers/joycon_protocol/joycon_types.h"
namespace Common::Input {
enum class DriverResult;
}
namespace InputCommon::Joycon { namespace InputCommon::Joycon {
class NfcProtocol final : private JoyconCommonProtocol { class NfcProtocol final : private JoyconCommonProtocol {
public: public:
explicit NfcProtocol(std::shared_ptr<JoyconHandle> handle); explicit NfcProtocol(std::shared_ptr<JoyconHandle> handle);
DriverResult EnableNfc(); Common::Input::DriverResult EnableNfc();
DriverResult DisableNfc(); Common::Input::DriverResult DisableNfc();
DriverResult StartNFCPollingMode(); Common::Input::DriverResult StartNFCPollingMode();
DriverResult StopNFCPollingMode(); Common::Input::DriverResult StopNFCPollingMode();
DriverResult GetTagInfo(Joycon::TagInfo& tag_info); Common::Input::DriverResult GetTagInfo(Joycon::TagInfo& tag_info);
DriverResult ReadAmiibo(std::vector<u8>& data); Common::Input::DriverResult ReadAmiibo(std::vector<u8>& data);
DriverResult WriteAmiibo(std::span<const u8> data); Common::Input::DriverResult WriteAmiibo(std::span<const u8> data);
DriverResult ReadMifare(std::span<const MifareReadChunk> read_request, Common::Input::DriverResult ReadMifare(std::span<const MifareReadChunk> read_request,
std::span<MifareReadData> out_data); std::span<MifareReadData> out_data);
DriverResult WriteMifare(std::span<const MifareWriteChunk> write_request); Common::Input::DriverResult WriteMifare(std::span<const MifareWriteChunk> write_request);
bool HasAmiibo(); bool HasAmiibo();
@ -54,37 +58,41 @@ private:
TagUUID uuid; TagUUID uuid;
}; };
DriverResult WaitUntilNfcIs(NFCStatus status); Common::Input::DriverResult WaitUntilNfcIs(NFCStatus status);
DriverResult IsTagInRange(TagFoundData& data, std::size_t timeout_limit = 1); Common::Input::DriverResult IsTagInRange(TagFoundData& data, std::size_t timeout_limit = 1);
DriverResult GetAmiiboData(std::vector<u8>& data); Common::Input::DriverResult GetAmiiboData(std::vector<u8>& data);
DriverResult WriteAmiiboData(const TagUUID& tag_uuid, std::span<const u8> data); Common::Input::DriverResult WriteAmiiboData(const TagUUID& tag_uuid, std::span<const u8> data);
DriverResult GetMifareData(const MifareUUID& tag_uuid, Common::Input::DriverResult GetMifareData(const MifareUUID& tag_uuid,
std::span<const MifareReadChunk> read_request, std::span<const MifareReadChunk> read_request,
std::span<MifareReadData> out_data); std::span<MifareReadData> out_data);
DriverResult WriteMifareData(const MifareUUID& tag_uuid, Common::Input::DriverResult WriteMifareData(const MifareUUID& tag_uuid,
std::span<const MifareWriteChunk> write_request); std::span<const MifareWriteChunk> write_request);
DriverResult SendStartPollingRequest(MCUCommandResponse& output, Common::Input::DriverResult SendStartPollingRequest(MCUCommandResponse& output,
bool is_second_attempt = false); bool is_second_attempt = false);
DriverResult SendStopPollingRequest(MCUCommandResponse& output); Common::Input::DriverResult SendStopPollingRequest(MCUCommandResponse& output);
DriverResult SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id); Common::Input::DriverResult SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id);
DriverResult SendReadAmiiboRequest(MCUCommandResponse& output, NFCPages ntag_pages); Common::Input::DriverResult SendReadAmiiboRequest(MCUCommandResponse& output,
NFCPages ntag_pages);
DriverResult SendWriteAmiiboRequest(MCUCommandResponse& output, const TagUUID& tag_uuid); Common::Input::DriverResult SendWriteAmiiboRequest(MCUCommandResponse& output,
const TagUUID& tag_uuid);
DriverResult SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id, Common::Input::DriverResult SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id,
bool is_last_packet, std::span<const u8> data); bool is_last_packet,
std::span<const u8> data);
DriverResult SendReadDataMifareRequest(MCUCommandResponse& output, u8 block_id, Common::Input::DriverResult SendReadDataMifareRequest(MCUCommandResponse& output, u8 block_id,
bool is_last_packet, std::span<const u8> data); bool is_last_packet,
std::span<const u8> data);
std::vector<u8> SerializeWritePackage(const NFCWritePackage& package) const; std::vector<u8> SerializeWritePackage(const NFCWritePackage& package) const;

42
src/input_common/helpers/joycon_protocol/ringcon.cpp
View file

@ -1,6 +1,7 @@
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later // SPDX-License-Identifier: GPL-2.0-or-later
#include "common/input.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "input_common/helpers/joycon_protocol/ringcon.h" #include "input_common/helpers/joycon_protocol/ringcon.h"
@ -9,18 +10,18 @@ namespace InputCommon::Joycon {
RingConProtocol::RingConProtocol(std::shared_ptr<JoyconHandle> handle) RingConProtocol::RingConProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {} : JoyconCommonProtocol(std::move(handle)) {}
DriverResult RingConProtocol::EnableRingCon() { Common::Input::DriverResult RingConProtocol::EnableRingCon() {
LOG_DEBUG(Input, "Enable Ringcon"); LOG_DEBUG(Input, "Enable Ringcon");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = SetReportMode(ReportMode::STANDARD_FULL_60HZ); result = SetReportMode(ReportMode::STANDARD_FULL_60HZ);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = EnableMCU(true); result = EnableMCU(true);
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
const MCUConfig config{ const MCUConfig config{
.command = MCUCommand::ConfigureMCU, .command = MCUCommand::ConfigureMCU,
.sub_command = MCUSubCommand::SetDeviceMode, .sub_command = MCUSubCommand::SetDeviceMode,
@ -33,12 +34,12 @@ DriverResult RingConProtocol::EnableRingCon() {
return result; return result;
} }
DriverResult RingConProtocol::DisableRingCon() { Common::Input::DriverResult RingConProtocol::DisableRingCon() {
LOG_DEBUG(Input, "Disable RingCon"); LOG_DEBUG(Input, "Disable RingCon");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = EnableMCU(false); result = EnableMCU(false);
} }
@ -47,27 +48,27 @@ DriverResult RingConProtocol::DisableRingCon() {
return result; return result;
} }
DriverResult RingConProtocol::StartRingconPolling() { Common::Input::DriverResult RingConProtocol::StartRingconPolling() {
LOG_DEBUG(Input, "Enable Ringcon"); LOG_DEBUG(Input, "Enable Ringcon");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success}; Common::Input::DriverResult result{Common::Input::DriverResult::Success};
bool is_connected = false; bool is_connected = false;
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
result = IsRingConnected(is_connected); result = IsRingConnected(is_connected);
} }
if (result == DriverResult::Success && is_connected) { if (result == Common::Input::DriverResult::Success && is_connected) {
LOG_INFO(Input, "Ringcon detected"); LOG_INFO(Input, "Ringcon detected");
result = ConfigureRing(); result = ConfigureRing();
} }
if (result == DriverResult::Success) { if (result == Common::Input::DriverResult::Success) {
is_enabled = true; is_enabled = true;
} }
return result; return result;
} }
DriverResult RingConProtocol::IsRingConnected(bool& is_connected) { Common::Input::DriverResult RingConProtocol::IsRingConnected(bool& is_connected) {
LOG_DEBUG(Input, "IsRingConnected"); LOG_DEBUG(Input, "IsRingConnected");
constexpr std::size_t max_tries = 28; constexpr std::size_t max_tries = 28;
SubCommandResponse output{}; SubCommandResponse output{};
@ -77,20 +78,20 @@ DriverResult RingConProtocol::IsRingConnected(bool& is_connected) {
do { do {
const auto result = SendSubCommand(SubCommand::GET_EXTERNAL_DEVICE_INFO, {}, output); const auto result = SendSubCommand(SubCommand::GET_EXTERNAL_DEVICE_INFO, {}, output);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }
if (tries++ >= max_tries) { if (tries++ >= max_tries) {
return DriverResult::NoDeviceDetected; return Common::Input::DriverResult::NoDeviceDetected;
} }
} while (output.external_device_id != ExternalDeviceId::RingController); } while (output.external_device_id != ExternalDeviceId::RingController);
is_connected = true; is_connected = true;
return DriverResult::Success; return Common::Input::DriverResult::Success;
} }
DriverResult RingConProtocol::ConfigureRing() { Common::Input::DriverResult RingConProtocol::ConfigureRing() {
LOG_DEBUG(Input, "ConfigureRing"); LOG_DEBUG(Input, "ConfigureRing");
static constexpr std::array<u8, 37> ring_config{ static constexpr std::array<u8, 37> ring_config{
@ -98,9 +99,10 @@ DriverResult RingConProtocol::ConfigureRing() {
0x00, 0x00, 0x00, 0x0A, 0x64, 0x0B, 0xE6, 0xA9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x64, 0x0B, 0xE6, 0xA9, 0x22, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0xA8, 0xE1, 0x34, 0x36}; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0xA8, 0xE1, 0x34, 0x36};
const DriverResult result = SendSubCommand(SubCommand::SET_EXTERNAL_FORMAT_CONFIG, ring_config); const Common::Input::DriverResult result =
SendSubCommand(SubCommand::SET_EXTERNAL_FORMAT_CONFIG, ring_config);
if (result != DriverResult::Success) { if (result != Common::Input::DriverResult::Success) {
return result; return result;
} }

14
src/input_common/helpers/joycon_protocol/ringcon.h
View file

@ -13,24 +13,28 @@
#include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/common_protocol.h"
#include "input_common/helpers/joycon_protocol/joycon_types.h" #include "input_common/helpers/joycon_protocol/joycon_types.h"
namespace Common::Input {
enum class DriverResult;
}
namespace InputCommon::Joycon { namespace InputCommon::Joycon {
class RingConProtocol final : private JoyconCommonProtocol { class RingConProtocol final : private JoyconCommonProtocol {
public: public:
explicit RingConProtocol(std::shared_ptr<JoyconHandle> handle); explicit RingConProtocol(std::shared_ptr<JoyconHandle> handle);
DriverResult EnableRingCon(); Common::Input::DriverResult EnableRingCon();
DriverResult DisableRingCon(); Common::Input::DriverResult DisableRingCon();
DriverResult StartRingconPolling(); Common::Input::DriverResult StartRingconPolling();
bool IsEnabled() const; bool IsEnabled() const;
private: private:
DriverResult IsRingConnected(bool& is_connected); Common::Input::DriverResult IsRingConnected(bool& is_connected);
DriverResult ConfigureRing(); Common::Input::DriverResult ConfigureRing();
bool is_enabled{}; bool is_enabled{};
}; };

5
src/input_common/helpers/joycon_protocol/rumble.cpp
View file

@ -4,6 +4,7 @@
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
#include "common/input.h"
#include "common/logging/log.h" #include "common/logging/log.h"
#include "input_common/helpers/joycon_protocol/rumble.h" #include "input_common/helpers/joycon_protocol/rumble.h"
@ -12,14 +13,14 @@ namespace InputCommon::Joycon {
RumbleProtocol::RumbleProtocol(std::shared_ptr<JoyconHandle> handle) RumbleProtocol::RumbleProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {} : JoyconCommonProtocol(std::move(handle)) {}
DriverResult RumbleProtocol::EnableRumble(bool is_enabled) { Common::Input::DriverResult RumbleProtocol::EnableRumble(bool is_enabled) {
LOG_DEBUG(Input, "Enable Rumble"); LOG_DEBUG(Input, "Enable Rumble");
ScopedSetBlocking sb(this); ScopedSetBlocking sb(this);
const std::array<u8, 1> buffer{static_cast<u8>(is_enabled ? 1 : 0)}; const std::array<u8, 1> buffer{static_cast<u8>(is_enabled ? 1 : 0)};
return SendSubCommand(SubCommand::ENABLE_VIBRATION, buffer); return SendSubCommand(SubCommand::ENABLE_VIBRATION, buffer);
} }
DriverResult RumbleProtocol::SendVibration(const VibrationValue& vibration) { Common::Input::DriverResult RumbleProtocol::SendVibration(const VibrationValue& vibration) {
std::array<u8, sizeof(DefaultVibrationBuffer)> buffer{}; std::array<u8, sizeof(DefaultVibrationBuffer)> buffer{};
if (vibration.high_amplitude <= 0.0f && vibration.low_amplitude <= 0.0f) { if (vibration.high_amplitude <= 0.0f && vibration.low_amplitude <= 0.0f) {

8
src/input_common/helpers/joycon_protocol/rumble.h
View file

@ -13,15 +13,19 @@
#include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/common_protocol.h"
#include "input_common/helpers/joycon_protocol/joycon_types.h" #include "input_common/helpers/joycon_protocol/joycon_types.h"
namespace Common::Input {
enum class DriverResult;
}
namespace InputCommon::Joycon { namespace InputCommon::Joycon {
class RumbleProtocol final : private JoyconCommonProtocol { class RumbleProtocol final : private JoyconCommonProtocol {
public: public:
explicit RumbleProtocol(std::shared_ptr<JoyconHandle> handle); explicit RumbleProtocol(std::shared_ptr<JoyconHandle> handle);
DriverResult EnableRumble(bool is_enabled); Common::Input::DriverResult EnableRumble(bool is_enabled);
DriverResult SendVibration(const VibrationValue& vibration); Common::Input::DriverResult SendVibration(const VibrationValue& vibration);
private: private:
u16 EncodeHighFrequency(f32 frequency) const; u16 EncodeHighFrequency(f32 frequency) const;

3
src/yuzu/configuration/configure_ringcon.cpp
View file

@ -305,6 +305,9 @@ void ConfigureRingController::EnableRingController() {
QMessageBox::warning(this, dialog_title, QMessageBox::warning(this, dialog_title,
tr("The current mapped device doesn't have a ring attached")); tr("The current mapped device doesn't have a ring attached"));
break; break;
case Common::Input::DriverResult::InvalidHandle:
QMessageBox::warning(this, dialog_title, tr("The current mapped device is not connected"));
break;
default: default:
QMessageBox::warning(this, dialog_title, QMessageBox::warning(this, dialog_title,
tr("Unexpected driver result %1").arg(static_cast<int>(result))); tr("Unexpected driver result %1").arg(static_cast<int>(result)));