From 5676c2e17fe895e450e185029991fc20bdf56ec5 Mon Sep 17 00:00:00 2001
From: Narr the Reg <juangerman-13@hotmail.com>
Date: Tue, 20 Dec 2022 18:09:59 -0600
Subject: input_common: Use calibration from joycon
---
.../helpers/joycon_protocol/calibration.cpp | 169 +++++++++++++++++++++
1 file changed, 169 insertions(+)
create mode 100644 src/input_common/helpers/joycon_protocol/calibration.cpp
(limited to 'src/input_common/helpers/joycon_protocol/calibration.cpp')
diff --git a/src/input_common/helpers/joycon_protocol/calibration.cpp b/src/input_common/helpers/joycon_protocol/calibration.cpp
new file mode 100644
index 0000000000..5c29af545b
--- /dev/null
+++ b/src/input_common/helpers/joycon_protocol/calibration.cpp
@@ -0,0 +1,169 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cstring>
+
+#include "input_common/helpers/joycon_protocol/calibration.h"
+#include "input_common/helpers/joycon_protocol/joycon_types.h"
+
+namespace InputCommon::Joycon {
+
+CalibrationProtocol::CalibrationProtocol(std::shared_ptr<JoyconHandle> handle)
+ : JoyconCommonProtocol(handle) {}
+
+DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration& calibration) {
+ std::vector<u8> buffer;
+ DriverResult result{DriverResult::Success};
+ calibration = {};
+ SetBlocking();
+
+ result = ReadSPI(CalAddr::USER_LEFT_MAGIC, sizeof(u16), buffer);
+
+ if (result == DriverResult::Success) {
+ const bool has_user_calibration = buffer[0] == 0xB2 && buffer[1] == 0xA1;
+ if (has_user_calibration) {
+ result = ReadSPI(CalAddr::USER_LEFT_DATA, 9, buffer);
+ } else {
+ result = ReadSPI(CalAddr::FACT_LEFT_DATA, 9, buffer);
+ }
+ }
+
+ if (result == DriverResult::Success) {
+ calibration.x.max = static_cast<u16>(((buffer[1] & 0x0F) << 8) | buffer[0]);
+ calibration.y.max = static_cast<u16>((buffer[2] << 4) | (buffer[1] >> 4));
+ calibration.x.center = static_cast<u16>(((buffer[4] & 0x0F) << 8) | buffer[3]);
+ calibration.y.center = static_cast<u16>((buffer[5] << 4) | (buffer[4] >> 4));
+ calibration.x.min = static_cast<u16>(((buffer[7] & 0x0F) << 8) | buffer[6]);
+ calibration.y.min = static_cast<u16>((buffer[8] << 4) | (buffer[7] >> 4));
+ }
+
+ // Nintendo fix for drifting stick
+ // result = ReadSPI(0x60, 0x86 ,buffer, 16);
+ // calibration.deadzone = (u16)((buffer[4] << 8) & 0xF00 | buffer[3]);
+
+ // Set a valid default calibration if data is missing
+ ValidateCalibration(calibration);
+
+ SetNonBlocking();
+ return result;
+}
+
+DriverResult CalibrationProtocol::GetRightJoyStickCalibration(JoyStickCalibration& calibration) {
+ std::vector<u8> buffer;
+ DriverResult result{DriverResult::Success};
+ calibration = {};
+ SetBlocking();
+
+ result = ReadSPI(CalAddr::USER_RIGHT_MAGIC, sizeof(u16), buffer);
+
+ if (result == DriverResult::Success) {
+ const bool has_user_calibration = buffer[0] == 0xB2 && buffer[1] == 0xA1;
+ if (has_user_calibration) {
+ result = ReadSPI(CalAddr::USER_RIGHT_DATA, 9, buffer);
+ } else {
+ result = ReadSPI(CalAddr::FACT_RIGHT_DATA, 9, buffer);
+ }
+ }
+
+ if (result == DriverResult::Success) {
+ calibration.x.center = static_cast<u16>(((buffer[1] & 0x0F) << 8) | buffer[0]);
+ calibration.y.center = static_cast<u16>((buffer[2] << 4) | (buffer[1] >> 4));
+ calibration.x.min = static_cast<u16>(((buffer[4] & 0x0F) << 8) | buffer[3]);
+ calibration.y.min = static_cast<u16>((buffer[5] << 4) | (buffer[4] >> 4));
+ calibration.x.max = static_cast<u16>(((buffer[7] & 0x0F) << 8) | buffer[6]);
+ calibration.y.max = static_cast<u16>((buffer[8] << 4) | (buffer[7] >> 4));
+ }
+
+ // Nintendo fix for drifting stick
+ // buffer = ReadSPI(0x60, 0x98 , 16);
+ // joystick.deadzone = (u16)((buffer[4] << 8) & 0xF00 | buffer[3]);
+
+ // Set a valid default calibration if data is missing
+ ValidateCalibration(calibration);
+
+ SetNonBlocking();
+ return result;
+}
+
+DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibration) {
+ std::vector<u8> buffer;
+ DriverResult result{DriverResult::Success};
+ calibration = {};
+ SetBlocking();
+
+ result = ReadSPI(CalAddr::USER_IMU_MAGIC, sizeof(u16), buffer);
+
+ if (result == DriverResult::Success) {
+ const bool has_user_calibration = buffer[0] == 0xB2 && buffer[1] == 0xA1;
+ if (has_user_calibration) {
+ result = ReadSPI(CalAddr::USER_IMU_DATA, sizeof(IMUCalibration), buffer);
+ } else {
+ result = ReadSPI(CalAddr::FACT_IMU_DATA, sizeof(IMUCalibration), buffer);
+ }
+ }
+
+ if (result == DriverResult::Success) {
+ IMUCalibration device_calibration{};
+ memcpy(&device_calibration, buffer.data(), sizeof(IMUCalibration));
+ calibration.accelerometer[0].offset = device_calibration.accelerometer_offset[0];
+ calibration.accelerometer[1].offset = device_calibration.accelerometer_offset[1];
+ calibration.accelerometer[2].offset = device_calibration.accelerometer_offset[2];
+
+ calibration.accelerometer[0].scale = device_calibration.accelerometer_scale[0];
+ calibration.accelerometer[1].scale = device_calibration.accelerometer_scale[1];
+ calibration.accelerometer[2].scale = device_calibration.accelerometer_scale[2];
+
+ calibration.gyro[0].offset = device_calibration.gyroscope_offset[0];
+ calibration.gyro[1].offset = device_calibration.gyroscope_offset[1];
+ calibration.gyro[2].offset = device_calibration.gyroscope_offset[2];
+
+ calibration.gyro[0].scale = device_calibration.gyroscope_scale[0];
+ calibration.gyro[1].scale = device_calibration.gyroscope_scale[1];
+ calibration.gyro[2].scale = device_calibration.gyroscope_scale[2];
+ }
+
+ ValidateCalibration(calibration);
+
+ SetNonBlocking();
+ return result;
+}
+
+void CalibrationProtocol::ValidateCalibration(JoyStickCalibration& calibration) {
+ constexpr u16 DefaultStickCenter{2048};
+ constexpr u16 DefaultStickRange{1740};
+
+ if (calibration.x.center == 0xFFF || calibration.x.center == 0) {
+ calibration.x.center = DefaultStickCenter;
+ }
+ if (calibration.x.max == 0xFFF || calibration.x.max == 0) {
+ calibration.x.max = DefaultStickRange;
+ }
+ if (calibration.x.min == 0xFFF || calibration.x.min == 0) {
+ calibration.x.min = DefaultStickRange;
+ }
+
+ if (calibration.y.center == 0xFFF || calibration.y.center == 0) {
+ calibration.y.center = DefaultStickCenter;
+ }
+ if (calibration.y.max == 0xFFF || calibration.y.max == 0) {
+ calibration.y.max = DefaultStickRange;
+ }
+ if (calibration.y.min == 0xFFF || calibration.y.min == 0) {
+ calibration.y.min = DefaultStickRange;
+ }
+}
+
+void CalibrationProtocol::ValidateCalibration(MotionCalibration& calibration) {
+ for (auto& sensor : calibration.accelerometer) {
+ if (sensor.scale == 0) {
+ sensor.scale = 0x4000;
+ }
+ }
+ for (auto& sensor : calibration.gyro) {
+ if (sensor.scale == 0) {
+ sensor.scale = 0x3be7;
+ }
+ }
+}
+
+} // namespace InputCommon::Joycon
--
cgit v1.2.3-70-g09d2
From 751d36e7392b0b1637f17988cfc1ef0d7cd95753 Mon Sep 17 00:00:00 2001
From: Narr the Reg <juangerman-13@hotmail.com>
Date: Tue, 20 Dec 2022 19:10:42 -0600
Subject: input_common: Add support for joycon ring controller
---
src/input_common/CMakeLists.txt | 2 +
src/input_common/helpers/joycon_driver.cpp | 43 ++++++-
src/input_common/helpers/joycon_driver.h | 3 +
.../helpers/joycon_protocol/calibration.cpp | 22 ++++
.../helpers/joycon_protocol/calibration.h | 10 ++
.../helpers/joycon_protocol/poller.cpp | 22 +++-
src/input_common/helpers/joycon_protocol/poller.h | 4 +-
.../helpers/joycon_protocol/ringcon.cpp | 132 +++++++++++++++++++++
src/input_common/helpers/joycon_protocol/ringcon.h | 38 ++++++
9 files changed, 272 insertions(+), 4 deletions(-)
create mode 100644 src/input_common/helpers/joycon_protocol/ringcon.cpp
create mode 100644 src/input_common/helpers/joycon_protocol/ringcon.h
(limited to 'src/input_common/helpers/joycon_protocol/calibration.cpp')
diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index 4ab1ccbfbe..addecc9b3b 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -66,6 +66,8 @@ if (ENABLE_SDL2)
helpers/joycon_protocol/joycon_types.h
helpers/joycon_protocol/poller.cpp
helpers/joycon_protocol/poller.h
+ helpers/joycon_protocol/ringcon.cpp
+ helpers/joycon_protocol/ringcon.h
helpers/joycon_protocol/rumble.cpp
helpers/joycon_protocol/rumble.h
)
diff --git a/src/input_common/helpers/joycon_driver.cpp b/src/input_common/helpers/joycon_driver.cpp
index 5d0aeabf5f..c0a03fe2e1 100644
--- a/src/input_common/helpers/joycon_driver.cpp
+++ b/src/input_common/helpers/joycon_driver.cpp
@@ -52,12 +52,18 @@ DriverResult JoyconDriver::InitializeDevice() {
error_counter = 0;
hidapi_handle->packet_counter = 0;
+ // Reset external device status
+ starlink_connected = false;
+ ring_connected = false;
+ amiibo_detected = false;
+
// Set HW default configuration
vibration_enabled = true;
motion_enabled = true;
hidbus_enabled = false;
nfc_enabled = false;
passive_enabled = false;
+ irs_enabled = false;
gyro_sensitivity = Joycon::GyroSensitivity::DPS2000;
gyro_performance = Joycon::GyroPerformance::HZ833;
accelerometer_sensitivity = Joycon::AccelerometerSensitivity::G8;
@@ -66,6 +72,7 @@ DriverResult JoyconDriver::InitializeDevice() {
// Initialize HW Protocols
calibration_protocol = std::make_unique<CalibrationProtocol>(hidapi_handle);
generic_protocol = std::make_unique<GenericProtocol>(hidapi_handle);
+ ring_protocol = std::make_unique<RingConProtocol>(hidapi_handle);
rumble_protocol = std::make_unique<RumbleProtocol>(hidapi_handle);
// Get fixed joycon info
@@ -172,9 +179,23 @@ void JoyconDriver::OnNewData(std::span<u8> buffer) {
.accelerometer_sensitivity = accelerometer_sensitivity,
};
+ // TODO: Remove this when calibration is properly loaded and not calculated
+ if (ring_connected && report_mode == InputReport::STANDARD_FULL_60HZ) {
+ InputReportActive data{};
+ memcpy(&data, buffer.data(), sizeof(InputReportActive));
+ calibration_protocol->GetRingCalibration(ring_calibration, data.ring_input);
+ }
+
+ const RingStatus ring_status{
+ .is_enabled = ring_connected,
+ .default_value = ring_calibration.default_value,
+ .max_value = ring_calibration.max_value,
+ .min_value = ring_calibration.min_value,
+ };
+
switch (report_mode) {
case InputReport::STANDARD_FULL_60HZ:
- joycon_poller->ReadActiveMode(buffer, motion_status);
+ joycon_poller->ReadActiveMode(buffer, motion_status, ring_status);
break;
case InputReport::NFC_IR_MODE_60HZ:
joycon_poller->ReadNfcIRMode(buffer, motion_status);
@@ -204,6 +225,26 @@ void JoyconDriver::SetPollingMode() {
generic_protocol->EnableImu(false);
}
+ if (ring_protocol->IsEnabled()) {
+ ring_connected = false;
+ ring_protocol->DisableRingCon();
+ }
+
+ if (hidbus_enabled && supported_features.hidbus) {
+ auto result = ring_protocol->EnableRingCon();
+ if (result == DriverResult::Success) {
+ result = ring_protocol->StartRingconPolling();
+ }
+ if (result == DriverResult::Success) {
+ ring_connected = true;
+ disable_input_thread = false;
+ return;
+ }
+ ring_connected = false;
+ ring_protocol->DisableRingCon();
+ LOG_ERROR(Input, "Error enabling Ringcon");
+ }
+
if (passive_enabled && supported_features.passive) {
const auto result = generic_protocol->EnablePassiveMode();
if (result == DriverResult::Success) {
diff --git a/src/input_common/helpers/joycon_driver.h b/src/input_common/helpers/joycon_driver.h
index 48ba859f4e..dc5d60221a 100644
--- a/src/input_common/helpers/joycon_driver.h
+++ b/src/input_common/helpers/joycon_driver.h
@@ -12,6 +12,7 @@
#include "input_common/helpers/joycon_protocol/generic_functions.h"
#include "input_common/helpers/joycon_protocol/joycon_types.h"
#include "input_common/helpers/joycon_protocol/poller.h"
+#include "input_common/helpers/joycon_protocol/ringcon.h"
#include "input_common/helpers/joycon_protocol/rumble.h"
namespace InputCommon::Joycon {
@@ -86,6 +87,7 @@ private:
std::unique_ptr<CalibrationProtocol> calibration_protocol = nullptr;
std::unique_ptr<GenericProtocol> generic_protocol = nullptr;
std::unique_ptr<JoyconPoller> joycon_poller = nullptr;
+ std::unique_ptr<RingConProtocol> ring_protocol = nullptr;
std::unique_ptr<RumbleProtocol> rumble_protocol = nullptr;
// Connection status
@@ -118,6 +120,7 @@ private:
JoyStickCalibration left_stick_calibration{};
JoyStickCalibration right_stick_calibration{};
MotionCalibration motion_calibration{};
+ RingCalibration ring_calibration{};
// Fixed joycon info
FirmwareVersion version{};
diff --git a/src/input_common/helpers/joycon_protocol/calibration.cpp b/src/input_common/helpers/joycon_protocol/calibration.cpp
index 5c29af545b..ce1ff7061d 100644
--- a/src/input_common/helpers/joycon_protocol/calibration.cpp
+++ b/src/input_common/helpers/joycon_protocol/calibration.cpp
@@ -128,6 +128,28 @@ DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibrati
return result;
}
+DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibration,
+ s16 current_value) {
+ // TODO: Get default calibration form ring itself
+ if (ring_data_max == 0 && ring_data_min == 0) {
+ ring_data_max = current_value + 800;
+ ring_data_min = current_value - 800;
+ ring_data_default = current_value;
+ }
+ if (ring_data_max < current_value) {
+ ring_data_max = current_value;
+ }
+ if (ring_data_min > current_value) {
+ ring_data_min = current_value;
+ }
+ calibration = {
+ .default_value = ring_data_default,
+ .max_value = ring_data_max,
+ .min_value = ring_data_min,
+ };
+ return DriverResult::Success;
+}
+
void CalibrationProtocol::ValidateCalibration(JoyStickCalibration& calibration) {
constexpr u16 DefaultStickCenter{2048};
constexpr u16 DefaultStickRange{1740};
diff --git a/src/input_common/helpers/joycon_protocol/calibration.h b/src/input_common/helpers/joycon_protocol/calibration.h
index 38214eed41..32ddef4b85 100644
--- a/src/input_common/helpers/joycon_protocol/calibration.h
+++ b/src/input_common/helpers/joycon_protocol/calibration.h
@@ -46,9 +46,19 @@ public:
*/
DriverResult GetImuCalibration(MotionCalibration& calibration);
+ /**
+ * Calculates on run time the proper calibration of the ring controller
+ * @returns RingCalibration of the ring sensor
+ */
+ DriverResult GetRingCalibration(RingCalibration& calibration, s16 current_value);
+
private:
void ValidateCalibration(JoyStickCalibration& calibration);
void ValidateCalibration(MotionCalibration& calibration);
+
+ s16 ring_data_max = 0;
+ s16 ring_data_default = 0;
+ s16 ring_data_min = 0;
};
} // namespace InputCommon::Joycon
diff --git a/src/input_common/helpers/joycon_protocol/poller.cpp b/src/input_common/helpers/joycon_protocol/poller.cpp
index 341479c0ca..cb76e1e06f 100644
--- a/src/input_common/helpers/joycon_protocol/poller.cpp
+++ b/src/input_common/helpers/joycon_protocol/poller.cpp
@@ -16,7 +16,8 @@ void JoyconPoller::SetCallbacks(const Joycon::JoyconCallbacks& callbacks_) {
callbacks = std::move(callbacks_);
}
-void JoyconPoller::ReadActiveMode(std::span<u8> buffer, const MotionStatus& motion_status) {
+void JoyconPoller::ReadActiveMode(std::span<u8> buffer, const MotionStatus& motion_status,
+ const RingStatus& ring_status) {
InputReportActive data{};
memcpy(&data, buffer.data(), sizeof(InputReportActive));
@@ -36,6 +37,10 @@ void JoyconPoller::ReadActiveMode(std::span<u8> buffer, const MotionStatus& moti
break;
}
+ if (ring_status.is_enabled) {
+ UpdateRing(data.ring_input, ring_status);
+ }
+
callbacks.on_battery_data(data.battery_status);
}
@@ -62,13 +67,26 @@ void JoyconPoller::ReadPassiveMode(std::span<u8> buffer) {
void JoyconPoller::ReadNfcIRMode(std::span<u8> buffer, const MotionStatus& motion_status) {
// This mode is compatible with the active mode
- ReadActiveMode(buffer, motion_status);
+ ReadActiveMode(buffer, motion_status, {});
}
void JoyconPoller::UpdateColor(const Color& color) {
callbacks.on_color_data(color);
}
+void JoyconPoller::UpdateRing(s16 value, const RingStatus& ring_status) {
+ float normalized_value = static_cast<float>(value - ring_status.default_value);
+ if (normalized_value > 0) {
+ normalized_value = normalized_value /
+ static_cast<float>(ring_status.max_value - ring_status.default_value);
+ }
+ if (normalized_value < 0) {
+ normalized_value = normalized_value /
+ static_cast<float>(ring_status.default_value - ring_status.min_value);
+ }
+ callbacks.on_ring_data(normalized_value);
+}
+
void JoyconPoller::UpdateActiveLeftPadInput(const InputReportActive& input,
const MotionStatus& motion_status) {
static constexpr std::array<Joycon::PadButton, 11> left_buttons{
diff --git a/src/input_common/helpers/joycon_protocol/poller.h b/src/input_common/helpers/joycon_protocol/poller.h
index fff681d0a1..68b14b8ba0 100644
--- a/src/input_common/helpers/joycon_protocol/poller.h
+++ b/src/input_common/helpers/joycon_protocol/poller.h
@@ -28,12 +28,14 @@ public:
void ReadPassiveMode(std::span<u8> buffer);
/// Handles data from active packages
- void ReadActiveMode(std::span<u8> buffer, const MotionStatus& motion_status);
+ void ReadActiveMode(std::span<u8> buffer, const MotionStatus& motion_status,
+ const RingStatus& ring_status);
/// Handles data from nfc or ir packages
void ReadNfcIRMode(std::span<u8> buffer, const MotionStatus& motion_status);
void UpdateColor(const Color& color);
+ void UpdateRing(s16 value, const RingStatus& ring_status);
private:
void UpdateActiveLeftPadInput(const InputReportActive& input,
diff --git a/src/input_common/helpers/joycon_protocol/ringcon.cpp b/src/input_common/helpers/joycon_protocol/ringcon.cpp
new file mode 100644
index 0000000000..2d137b85d3
--- /dev/null
+++ b/src/input_common/helpers/joycon_protocol/ringcon.cpp
@@ -0,0 +1,132 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "input_common/helpers/joycon_protocol/ringcon.h"
+
+namespace InputCommon::Joycon {
+
+RingConProtocol::RingConProtocol(std::shared_ptr<JoyconHandle> handle)
+ : JoyconCommonProtocol(handle) {}
+
+DriverResult RingConProtocol::EnableRingCon() {
+ LOG_DEBUG(Input, "Enable Ringcon");
+ DriverResult result{DriverResult::Success};
+ SetBlocking();
+
+ if (result == DriverResult::Success) {
+ result = SetReportMode(ReportMode::STANDARD_FULL_60HZ);
+ }
+ if (result == DriverResult::Success) {
+ result = EnableMCU(true);
+ }
+ if (result == DriverResult::Success) {
+ const MCUConfig config{
+ .command = MCUCommand::ConfigureMCU,
+ .sub_command = MCUSubCommand::SetDeviceMode,
+ .mode = MCUMode::Standby,
+ .crc = {},
+ };
+ result = ConfigureMCU(config);
+ }
+
+ SetNonBlocking();
+ return result;
+}
+
+DriverResult RingConProtocol::DisableRingCon() {
+ LOG_DEBUG(Input, "Disable RingCon");
+ DriverResult result{DriverResult::Success};
+ SetBlocking();
+
+ if (result == DriverResult::Success) {
+ result = EnableMCU(false);
+ }
+
+ is_enabled = false;
+
+ SetNonBlocking();
+ return result;
+}
+
+DriverResult RingConProtocol::StartRingconPolling() {
+ LOG_DEBUG(Input, "Enable Ringcon");
+ bool is_connected = false;
+ DriverResult result{DriverResult::Success};
+ SetBlocking();
+
+ if (result == DriverResult::Success) {
+ result = WaitSetMCUMode(ReportMode::STANDARD_FULL_60HZ, MCUMode::Standby);
+ }
+ if (result == DriverResult::Success) {
+ result = IsRingConnected(is_connected);
+ }
+ if (result == DriverResult::Success && is_connected) {
+ LOG_INFO(Input, "Ringcon detected");
+ result = ConfigureRing();
+ }
+ if (result == DriverResult::Success) {
+ is_enabled = true;
+ }
+
+ SetNonBlocking();
+ return result;
+}
+
+DriverResult RingConProtocol::IsRingConnected(bool& is_connected) {
+ LOG_DEBUG(Input, "IsRingConnected");
+ constexpr std::size_t max_tries = 28;
+ std::vector<u8> output;
+ std::size_t tries = 0;
+ is_connected = false;
+
+ do {
+ std::vector<u8> empty_data(0);
+ const auto result = SendSubCommand(SubCommand::UNKNOWN_RINGCON, empty_data, output);
+
+ if (result != DriverResult::Success) {
+ return result;
+ }
+
+ if (tries++ >= max_tries) {
+ return DriverResult::NoDeviceDetected;
+ }
+ } while (output[14] != 0x59 || output[16] != 0x20);
+
+ is_connected = true;
+ return DriverResult::Success;
+}
+
+DriverResult RingConProtocol::ConfigureRing() {
+ LOG_DEBUG(Input, "ConfigureRing");
+ constexpr std::size_t max_tries = 28;
+ DriverResult result{DriverResult::Success};
+ std::vector<u8> output;
+ std::size_t tries = 0;
+
+ do {
+ std::vector<u8> ring_config{0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x16,
+ 0xED, 0x34, 0x36, 0x00, 0x00, 0x00, 0x0A, 0x64, 0x0B, 0xE6,
+ 0xA9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x90, 0xA8, 0xE1, 0x34, 0x36};
+ result = SendSubCommand(SubCommand::UNKNOWN_RINGCON3, ring_config, output);
+
+ if (result != DriverResult::Success) {
+ return result;
+ }
+ if (tries++ >= max_tries) {
+ return DriverResult::NoDeviceDetected;
+ }
+ } while (output[14] != 0x5C);
+
+ std::vector<u8> ringcon_data{0x04, 0x01, 0x01, 0x02};
+ result = SendSubCommand(SubCommand::UNKNOWN_RINGCON2, ringcon_data, output);
+
+ return result;
+}
+
+bool RingConProtocol::IsEnabled() {
+ return is_enabled;
+}
+
+} // namespace InputCommon::Joycon
diff --git a/src/input_common/helpers/joycon_protocol/ringcon.h b/src/input_common/helpers/joycon_protocol/ringcon.h
new file mode 100644
index 0000000000..0c25de23ee
--- /dev/null
+++ b/src/input_common/helpers/joycon_protocol/ringcon.h
@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Based on dkms-hid-nintendo implementation, CTCaer joycon toolkit and dekuNukem reverse
+// engineering https://github.com/nicman23/dkms-hid-nintendo/blob/master/src/hid-nintendo.c
+// https://github.com/CTCaer/jc_toolkit
+// https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering
+
+#pragma once
+
+#include <vector>
+
+#include "input_common/helpers/joycon_protocol/common_protocol.h"
+#include "input_common/helpers/joycon_protocol/joycon_types.h"
+
+namespace InputCommon::Joycon {
+
+class RingConProtocol final : private JoyconCommonProtocol {
+public:
+ RingConProtocol(std::shared_ptr<JoyconHandle> handle);
+
+ DriverResult EnableRingCon();
+
+ DriverResult DisableRingCon();
+
+ DriverResult StartRingconPolling();
+
+ bool IsEnabled();
+
+private:
+ DriverResult IsRingConnected(bool& is_connected);
+
+ DriverResult ConfigureRing();
+
+ bool is_enabled{};
+};
+
+} // namespace InputCommon::Joycon
--
cgit v1.2.3-70-g09d2
From e1a3bda4d9881cb99c36b64733b814a3bb437f13 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Fri, 23 Dec 2022 08:32:02 -0600
Subject: Address review comments
---
src/core/hid/input_converter.cpp | 6 ++----
src/input_common/drivers/joycon.cpp | 2 +-
src/input_common/helpers/joycon_driver.cpp | 2 +-
src/input_common/helpers/joycon_protocol/calibration.cpp | 10 +++-------
src/input_common/helpers/joycon_protocol/calibration.h | 2 +-
.../helpers/joycon_protocol/common_protocol.cpp | 6 +++---
.../helpers/joycon_protocol/generic_functions.cpp | 12 ++++++------
.../helpers/joycon_protocol/generic_functions.h | 2 +-
src/input_common/helpers/joycon_protocol/nfc.cpp | 9 +++++----
src/input_common/helpers/joycon_protocol/nfc.h | 4 ++--
src/input_common/helpers/joycon_protocol/ringcon.cpp | 16 ++++++++--------
src/input_common/helpers/joycon_protocol/ringcon.h | 4 ++--
src/input_common/helpers/joycon_protocol/rumble.cpp | 13 ++++++++-----
src/input_common/helpers/joycon_protocol/rumble.h | 2 +-
14 files changed, 44 insertions(+), 46 deletions(-)
(limited to 'src/input_common/helpers/joycon_protocol/calibration.cpp')
diff --git a/src/core/hid/input_converter.cpp b/src/core/hid/input_converter.cpp
index d7e253044a..3f7b8c0904 100644
--- a/src/core/hid/input_converter.cpp
+++ b/src/core/hid/input_converter.cpp
@@ -305,17 +305,15 @@ Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& cal
}
Common::Input::BodyColorStatus TransformToColor(const Common::Input::CallbackStatus& callback) {
- Common::Input::BodyColorStatus color{};
switch (callback.type) {
case Common::Input::InputType::Color:
- color = callback.color_status;
+ return callback.color_status;
break;
default:
LOG_ERROR(Input, "Conversion from type {} to color not implemented", callback.type);
+ return {};
break;
}
-
- return color;
}
void SanitizeAnalog(Common::Input::AnalogStatus& analog, bool clamp_value) {
diff --git a/src/input_common/drivers/joycon.cpp b/src/input_common/drivers/joycon.cpp
index 29f0dc0c89..696a6db393 100644
--- a/src/input_common/drivers/joycon.cpp
+++ b/src/input_common/drivers/joycon.cpp
@@ -316,7 +316,7 @@ void Joycons::OnBatteryUpdate(std::size_t port, Joycon::ControllerType type,
return;
}
- Common::Input::BatteryLevel battery{value.status.Value()};
+ Common::Input::BatteryLevel battery{};
switch (value.status) {
case 0:
battery = Common::Input::BatteryLevel::Empty;
diff --git a/src/input_common/helpers/joycon_driver.cpp b/src/input_common/helpers/joycon_driver.cpp
index db9ff4875e..8982a2397f 100644
--- a/src/input_common/helpers/joycon_driver.cpp
+++ b/src/input_common/helpers/joycon_driver.cpp
@@ -465,7 +465,7 @@ void JoyconDriver::SetCallbacks(const Joycon::JoyconCallbacks& callbacks) {
Joycon::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info,
ControllerType& controller_type) {
- std::array<std::pair<u32, Joycon::ControllerType>, 4> supported_devices{
+ static constexpr std::array<std::pair<u32, Joycon::ControllerType>, 4> supported_devices{
std::pair<u32, Joycon::ControllerType>{0x2006, Joycon::ControllerType::Left},
{0x2007, Joycon::ControllerType::Right},
{0x2009, Joycon::ControllerType::Pro},
diff --git a/src/input_common/helpers/joycon_protocol/calibration.cpp b/src/input_common/helpers/joycon_protocol/calibration.cpp
index ce1ff7061d..cd30ab8698 100644
--- a/src/input_common/helpers/joycon_protocol/calibration.cpp
+++ b/src/input_common/helpers/joycon_protocol/calibration.cpp
@@ -9,7 +9,7 @@
namespace InputCommon::Joycon {
CalibrationProtocol::CalibrationProtocol(std::shared_ptr<JoyconHandle> handle)
- : JoyconCommonProtocol(handle) {}
+ : JoyconCommonProtocol(std::move(handle)) {}
DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration& calibration) {
std::vector<u8> buffer;
@@ -136,12 +136,8 @@ DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibratio
ring_data_min = current_value - 800;
ring_data_default = current_value;
}
- if (ring_data_max < current_value) {
- ring_data_max = current_value;
- }
- if (ring_data_min > current_value) {
- ring_data_min = current_value;
- }
+ ring_data_max = std::max(ring_data_max, current_value);
+ ring_data_min = std::min(ring_data_min, current_value);
calibration = {
.default_value = ring_data_default,
.max_value = ring_data_max,
diff --git a/src/input_common/helpers/joycon_protocol/calibration.h b/src/input_common/helpers/joycon_protocol/calibration.h
index 32ddef4b85..afb52a36a4 100644
--- a/src/input_common/helpers/joycon_protocol/calibration.h
+++ b/src/input_common/helpers/joycon_protocol/calibration.h
@@ -24,7 +24,7 @@ namespace InputCommon::Joycon {
/// Driver functions related to retrieving calibration data from the device
class CalibrationProtocol final : private JoyconCommonProtocol {
public:
- CalibrationProtocol(std::shared_ptr<JoyconHandle> handle);
+ explicit CalibrationProtocol(std::shared_ptr<JoyconHandle> handle);
/**
* Sends a request to obtain the left stick calibration from memory
diff --git a/src/input_common/helpers/joycon_protocol/common_protocol.cpp b/src/input_common/helpers/joycon_protocol/common_protocol.cpp
index 43a036e027..a4d08fdafa 100644
--- a/src/input_common/helpers/joycon_protocol/common_protocol.cpp
+++ b/src/input_common/helpers/joycon_protocol/common_protocol.cpp
@@ -6,7 +6,7 @@
namespace InputCommon::Joycon {
JoyconCommonProtocol::JoyconCommonProtocol(std::shared_ptr<JoyconHandle> hidapi_handle_)
- : hidapi_handle{hidapi_handle_} {}
+ : hidapi_handle{std::move(hidapi_handle_)} {}
u8 JoyconCommonProtocol::GetCounter() {
hidapi_handle->packet_counter = (hidapi_handle->packet_counter + 1) & 0x0F;
@@ -256,7 +256,7 @@ DriverResult JoyconCommonProtocol::WaitSetMCUMode(ReportMode report_mode, MCUMod
}
// crc-8-ccitt / polynomial 0x07 look up table
-static constexpr uint8_t mcu_crc8_table[256] = {
+constexpr std::array<u8, 256> mcu_crc8_table = {
0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
@@ -278,7 +278,7 @@ u8 JoyconCommonProtocol::CalculateMCU_CRC8(u8* buffer, u8 size) const {
u8 crc8 = 0x0;
for (int i = 0; i < size; ++i) {
- crc8 = mcu_crc8_table[(u8)(crc8 ^ buffer[i])];
+ crc8 = mcu_crc8_table[static_cast<u8>(crc8 ^ buffer[i])];
}
return crc8;
}
diff --git a/src/input_common/helpers/joycon_protocol/generic_functions.cpp b/src/input_common/helpers/joycon_protocol/generic_functions.cpp
index 829f7625d6..cbd9ff4f8b 100644
--- a/src/input_common/helpers/joycon_protocol/generic_functions.cpp
+++ b/src/input_common/helpers/joycon_protocol/generic_functions.cpp
@@ -7,7 +7,7 @@
namespace InputCommon::Joycon {
GenericProtocol::GenericProtocol(std::shared_ptr<JoyconHandle> handle)
- : JoyconCommonProtocol(handle) {}
+ : JoyconCommonProtocol(std::move(handle)) {}
DriverResult GenericProtocol::EnablePassiveMode() {
SetBlocking();
@@ -43,7 +43,7 @@ DriverResult GenericProtocol::GetControllerType(ControllerType& controller_type)
}
DriverResult GenericProtocol::EnableImu(bool enable) {
- const std::vector<u8> buffer{static_cast<u8>(enable ? 1 : 0)};
+ const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)};
std::vector<u8> output;
SetBlocking();
const auto result = SendSubCommand(SubCommand::ENABLE_IMU, buffer, output);
@@ -54,8 +54,8 @@ DriverResult GenericProtocol::EnableImu(bool enable) {
DriverResult GenericProtocol::SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec,
AccelerometerSensitivity asen,
AccelerometerPerformance afrec) {
- const std::vector<u8> buffer{static_cast<u8>(gsen), static_cast<u8>(asen),
- static_cast<u8>(gfrec), static_cast<u8>(afrec)};
+ const std::array<u8, 4> buffer{static_cast<u8>(gsen), static_cast<u8>(asen),
+ static_cast<u8>(gfrec), static_cast<u8>(afrec)};
std::vector<u8> output;
SetBlocking();
const auto result = SendSubCommand(SubCommand::SET_IMU_SENSITIVITY, buffer, output);
@@ -115,7 +115,7 @@ DriverResult GenericProtocol::GetVersionNumber(FirmwareVersion& version) {
}
DriverResult GenericProtocol::SetHomeLight() {
- const std::vector<u8> buffer{0x0f, 0xf0, 0x00};
+ static constexpr std::array<u8, 3> buffer{0x0f, 0xf0, 0x00};
std::vector<u8> output;
SetBlocking();
@@ -130,7 +130,7 @@ DriverResult GenericProtocol::SetLedBusy() {
}
DriverResult GenericProtocol::SetLedPattern(u8 leds) {
- const std::vector<u8> buffer{leds};
+ const std::array<u8, 1> buffer{leds};
std::vector<u8> output;
SetBlocking();
diff --git a/src/input_common/helpers/joycon_protocol/generic_functions.h b/src/input_common/helpers/joycon_protocol/generic_functions.h
index c3e2ccadc0..239bb7dbf9 100644
--- a/src/input_common/helpers/joycon_protocol/generic_functions.h
+++ b/src/input_common/helpers/joycon_protocol/generic_functions.h
@@ -16,7 +16,7 @@ namespace InputCommon::Joycon {
/// Joycon driver functions that easily implemented
class GenericProtocol final : private JoyconCommonProtocol {
public:
- GenericProtocol(std::shared_ptr<JoyconHandle> handle);
+ explicit GenericProtocol(std::shared_ptr<JoyconHandle> handle);
/// Enables passive mode. This mode only sends button data on change. Sticks will return digital
/// data instead of analog. Motion will be disabled
diff --git a/src/input_common/helpers/joycon_protocol/nfc.cpp b/src/input_common/helpers/joycon_protocol/nfc.cpp
index 69b2bfe050..8755e310b8 100644
--- a/src/input_common/helpers/joycon_protocol/nfc.cpp
+++ b/src/input_common/helpers/joycon_protocol/nfc.cpp
@@ -7,7 +7,8 @@
namespace InputCommon::Joycon {
-NfcProtocol::NfcProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(handle) {}
+NfcProtocol::NfcProtocol(std::shared_ptr<JoyconHandle> handle)
+ : JoyconCommonProtocol(std::move(handle)) {}
DriverResult NfcProtocol::EnableNfc() {
LOG_INFO(Input, "Enable NFC");
@@ -160,9 +161,9 @@ DriverResult NfcProtocol::ReadTag(const TagFoundData& data) {
std::vector<u8> output;
std::size_t tries = 0;
- std::string uuid_string = "";
+ std::string uuid_string;
for (auto& content : data.uuid) {
- uuid_string += " " + fmt::format("{:02x}", content);
+ uuid_string += fmt::format(" {:02x}", content);
}
LOG_INFO(Input, "Tag detected, type={}, uuid={}", data.type, uuid_string);
@@ -407,7 +408,7 @@ NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(std::size_t pages) const {
return {};
}
-bool NfcProtocol::IsEnabled() {
+bool NfcProtocol::IsEnabled() const {
return is_enabled;
}
diff --git a/src/input_common/helpers/joycon_protocol/nfc.h b/src/input_common/helpers/joycon_protocol/nfc.h
index 0ede03d505..5cb0e5a652 100644
--- a/src/input_common/helpers/joycon_protocol/nfc.h
+++ b/src/input_common/helpers/joycon_protocol/nfc.h
@@ -17,7 +17,7 @@ namespace InputCommon::Joycon {
class NfcProtocol final : private JoyconCommonProtocol {
public:
- NfcProtocol(std::shared_ptr<JoyconHandle> handle);
+ explicit NfcProtocol(std::shared_ptr<JoyconHandle> handle);
DriverResult EnableNfc();
@@ -29,7 +29,7 @@ public:
bool HasAmiibo();
- bool IsEnabled();
+ bool IsEnabled() const;
private:
struct TagFoundData {
diff --git a/src/input_common/helpers/joycon_protocol/ringcon.cpp b/src/input_common/helpers/joycon_protocol/ringcon.cpp
index 47769f3441..8adad57dd6 100644
--- a/src/input_common/helpers/joycon_protocol/ringcon.cpp
+++ b/src/input_common/helpers/joycon_protocol/ringcon.cpp
@@ -7,7 +7,7 @@
namespace InputCommon::Joycon {
RingConProtocol::RingConProtocol(std::shared_ptr<JoyconHandle> handle)
- : JoyconCommonProtocol(handle) {}
+ : JoyconCommonProtocol(std::move(handle)) {}
DriverResult RingConProtocol::EnableRingCon() {
LOG_DEBUG(Input, "Enable Ringcon");
@@ -78,7 +78,7 @@ DriverResult RingConProtocol::IsRingConnected(bool& is_connected) {
is_connected = false;
do {
- std::vector<u8> empty_data(0);
+ std::array<u8, 1> empty_data{};
const auto result = SendSubCommand(SubCommand::UNKNOWN_RINGCON, empty_data, output);
if (result != DriverResult::Success) {
@@ -101,11 +101,11 @@ DriverResult RingConProtocol::ConfigureRing() {
std::vector<u8> output;
std::size_t tries = 0;
+ static constexpr std::array<u8, 37> ring_config{
+ 0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x16, 0xED, 0x34, 0x36,
+ 0x00, 0x00, 0x00, 0x0A, 0x64, 0x0B, 0xE6, 0xA9, 0x22, 0x00, 0x00, 0x04, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0xA8, 0xE1, 0x34, 0x36};
do {
- std::vector<u8> ring_config{0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x16,
- 0xED, 0x34, 0x36, 0x00, 0x00, 0x00, 0x0A, 0x64, 0x0B, 0xE6,
- 0xA9, 0x22, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x90, 0xA8, 0xE1, 0x34, 0x36};
result = SendSubCommand(SubCommand::UNKNOWN_RINGCON3, ring_config, output);
if (result != DriverResult::Success) {
@@ -116,13 +116,13 @@ DriverResult RingConProtocol::ConfigureRing() {
}
} while (output[14] != 0x5C);
- std::vector<u8> ringcon_data{0x04, 0x01, 0x01, 0x02};
+ static constexpr std::array<u8, 4> ringcon_data{0x04, 0x01, 0x01, 0x02};
result = SendSubCommand(SubCommand::UNKNOWN_RINGCON2, ringcon_data, output);
return result;
}
-bool RingConProtocol::IsEnabled() {
+bool RingConProtocol::IsEnabled() const {
return is_enabled;
}
diff --git a/src/input_common/helpers/joycon_protocol/ringcon.h b/src/input_common/helpers/joycon_protocol/ringcon.h
index 0c25de23ee..6e858f3fcb 100644
--- a/src/input_common/helpers/joycon_protocol/ringcon.h
+++ b/src/input_common/helpers/joycon_protocol/ringcon.h
@@ -17,7 +17,7 @@ namespace InputCommon::Joycon {
class RingConProtocol final : private JoyconCommonProtocol {
public:
- RingConProtocol(std::shared_ptr<JoyconHandle> handle);
+ explicit RingConProtocol(std::shared_ptr<JoyconHandle> handle);
DriverResult EnableRingCon();
@@ -25,7 +25,7 @@ public:
DriverResult StartRingconPolling();
- bool IsEnabled();
+ bool IsEnabled() const;
private:
DriverResult IsRingConnected(bool& is_connected);
diff --git a/src/input_common/helpers/joycon_protocol/rumble.cpp b/src/input_common/helpers/joycon_protocol/rumble.cpp
index 17ee388634..fad67a94ba 100644
--- a/src/input_common/helpers/joycon_protocol/rumble.cpp
+++ b/src/input_common/helpers/joycon_protocol/rumble.cpp
@@ -1,17 +1,20 @@
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
+#include <algorithm>
+#include <cmath>
+
#include "common/logging/log.h"
#include "input_common/helpers/joycon_protocol/rumble.h"
namespace InputCommon::Joycon {
RumbleProtocol::RumbleProtocol(std::shared_ptr<JoyconHandle> handle)
- : JoyconCommonProtocol(handle) {}
+ : JoyconCommonProtocol(std::move(handle)) {}
DriverResult RumbleProtocol::EnableRumble(bool is_enabled) {
LOG_DEBUG(Input, "Enable Rumble");
- const std::vector<u8> buffer{static_cast<u8>(is_enabled ? 1 : 0)};
+ const std::array<u8, 1> buffer{static_cast<u8>(is_enabled ? 1 : 0)};
std::vector<u8> output;
SetBlocking();
const auto result = SendSubCommand(SubCommand::ENABLE_VIBRATION, buffer, output);
@@ -20,7 +23,7 @@ DriverResult RumbleProtocol::EnableRumble(bool is_enabled) {
}
DriverResult RumbleProtocol::SendVibration(const VibrationValue& vibration) {
- std::vector<u8> buffer(sizeof(DefaultVibrationBuffer));
+ std::array<u8, sizeof(DefaultVibrationBuffer)> buffer{};
if (vibration.high_amplitude <= 0.0f && vibration.low_amplitude <= 0.0f) {
return SendVibrationReport(DefaultVibrationBuffer);
@@ -66,7 +69,7 @@ u8 RumbleProtocol::EncodeHighAmplitude(f32 amplitude) const {
/* More information about these values can be found here:
* https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
*/
- constexpr std::array<std::pair<f32, int>, 101> high_fequency_amplitude{
+ static constexpr std::array<std::pair<f32, int>, 101> high_fequency_amplitude{
std::pair<f32, int>{0.0f, 0x0},
{0.01f, 0x2},
{0.012f, 0x4},
@@ -183,7 +186,7 @@ u16 RumbleProtocol::EncodeLowAmplitude(f32 amplitude) const {
/* More information about these values can be found here:
* https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
*/
- constexpr std::array<std::pair<f32, int>, 101> high_fequency_amplitude{
+ static constexpr std::array<std::pair<f32, int>, 101> high_fequency_amplitude{
std::pair<f32, int>{0.0f, 0x0040},
{0.01f, 0x8040},
{0.012f, 0x0041},
diff --git a/src/input_common/helpers/joycon_protocol/rumble.h b/src/input_common/helpers/joycon_protocol/rumble.h
index 7d0329f039..6c12b79258 100644
--- a/src/input_common/helpers/joycon_protocol/rumble.h
+++ b/src/input_common/helpers/joycon_protocol/rumble.h
@@ -17,7 +17,7 @@ namespace InputCommon::Joycon {
class RumbleProtocol final : private JoyconCommonProtocol {
public:
- RumbleProtocol(std::shared_ptr<JoyconHandle> handle);
+ explicit RumbleProtocol(std::shared_ptr<JoyconHandle> handle);
DriverResult EnableRumble(bool is_enabled);
--
cgit v1.2.3-70-g09d2
From 340f15d1fa79594dbe12a6e19140ba012751b533 Mon Sep 17 00:00:00 2001
From: german77 <juangerman-13@hotmail.com>
Date: Fri, 13 Jan 2023 23:29:05 -0600
Subject: input_common: Address byte review
---
src/input_common/drivers/joycon.cpp | 50 +++---
src/input_common/drivers/joycon.h | 1 -
src/input_common/drivers/sdl_driver.cpp | 2 +-
src/input_common/helpers/joycon_driver.cpp | 8 +-
src/input_common/helpers/joycon_driver.h | 3 +-
.../helpers/joycon_protocol/calibration.cpp | 9 +-
.../helpers/joycon_protocol/common_protocol.cpp | 24 +--
.../helpers/joycon_protocol/common_protocol.h | 22 ++-
.../helpers/joycon_protocol/generic_functions.cpp | 54 ++----
src/input_common/helpers/joycon_protocol/irs.cpp | 18 +-
.../helpers/joycon_protocol/joycon_types.h | 12 ++
src/input_common/helpers/joycon_protocol/nfc.cpp | 183 ++++++++++-----------
src/input_common/helpers/joycon_protocol/nfc.h | 4 +-
.../helpers/joycon_protocol/poller.cpp | 18 +-
.../helpers/joycon_protocol/ringcon.cpp | 36 ++--
.../helpers/joycon_protocol/rumble.cpp | 19 +--
16 files changed, 220 insertions(+), 243 deletions(-)
(limited to 'src/input_common/helpers/joycon_protocol/calibration.cpp')
diff --git a/src/input_common/drivers/joycon.cpp b/src/input_common/drivers/joycon.cpp
index fff886ca8a..1582def13c 100644
--- a/src/input_common/drivers/joycon.cpp
+++ b/src/input_common/drivers/joycon.cpp
@@ -60,15 +60,12 @@ void Joycons::Setup() {
device = std::make_shared<Joycon::JoyconDriver>(port++);
}
- if (!scan_thread_running) {
- scan_thread = std::jthread([this](std::stop_token stop_token) { ScanThread(stop_token); });
- }
+ scan_thread = std::jthread([this](std::stop_token stop_token) { ScanThread(stop_token); });
}
void Joycons::ScanThread(std::stop_token stop_token) {
constexpr u16 nintendo_vendor_id = 0x057e;
- Common::SetCurrentThreadName("yuzu:input:JoyconScanThread");
- scan_thread_running = true;
+ Common::SetCurrentThreadName("JoyconScanThread");
while (!stop_token.stop_requested()) {
SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
SDL_hid_device_info* cur_dev = devs;
@@ -82,9 +79,9 @@ void Joycons::ScanThread(std::stop_token stop_token) {
cur_dev = cur_dev->next;
}
+ SDL_hid_free_enumeration(devs);
std::this_thread::sleep_for(std::chrono::seconds(5));
}
- scan_thread_running = false;
}
bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {
@@ -185,19 +182,19 @@ void Joycons::RegisterNewDevice(SDL_hid_device_info* device_info) {
std::shared_ptr<Joycon::JoyconDriver> Joycons::GetNextFreeHandle(
Joycon::ControllerType type) const {
-
if (type == Joycon::ControllerType::Left) {
- for (const auto& device : left_joycons) {
- if (!device->IsConnected()) {
- return device;
- }
+ const auto unconnected_device =
+ std::ranges::find_if(left_joycons, [](auto& device) { return !device->IsConnected(); });
+ if (unconnected_device != left_joycons.end()) {
+ return *unconnected_device;
}
}
if (type == Joycon::ControllerType::Right) {
- for (const auto& device : right_joycons) {
- if (!device->IsConnected()) {
- return device;
- }
+ const auto unconnected_device = std::ranges::find_if(
+ right_joycons, [](auto& device) { return !device->IsConnected(); });
+
+ if (unconnected_device != right_joycons.end()) {
+ return *unconnected_device;
}
}
return nullptr;
@@ -391,20 +388,25 @@ std::shared_ptr<Joycon::JoyconDriver> Joycons::GetHandle(PadIdentifier identifie
return false;
};
const auto type = static_cast<Joycon::ControllerType>(identifier.pad);
+
if (type == Joycon::ControllerType::Left) {
- for (const auto& device : left_joycons) {
- if (is_handle_active(device)) {
- return device;
- }
+ const auto matching_device = std::ranges::find_if(
+ left_joycons, [is_handle_active](auto& device) { return is_handle_active(device); });
+
+ if (matching_device != left_joycons.end()) {
+ return *matching_device;
}
}
+
if (type == Joycon::ControllerType::Right) {
- for (const auto& device : right_joycons) {
- if (is_handle_active(device)) {
- return device;
- }
+ const auto matching_device = std::ranges::find_if(
+ right_joycons, [is_handle_active](auto& device) { return is_handle_active(device); });
+
+ if (matching_device != right_joycons.end()) {
+ return *matching_device;
}
}
+
return nullptr;
}
@@ -676,7 +678,7 @@ std::string Joycons::JoyconName(Joycon::ControllerType type) const {
case Joycon::ControllerType::Dual:
return "Dual Joycon";
default:
- return "Unknow Joycon";
+ return "Unknown Joycon";
}
}
} // namespace InputCommon
diff --git a/src/input_common/drivers/joycon.h b/src/input_common/drivers/joycon.h
index f5cc787db0..6d2e2ec786 100644
--- a/src/input_common/drivers/joycon.h
+++ b/src/input_common/drivers/joycon.h
@@ -99,7 +99,6 @@ private:
std::string JoyconName(Joycon::ControllerType type) const;
std::jthread scan_thread;
- bool scan_thread_running{};
// Joycon types are split by type to ease supporting dualjoycon configurations
std::array<std::shared_ptr<Joycon::JoyconDriver>, MaxSupportedControllers> left_joycons{};
diff --git a/src/input_common/drivers/sdl_driver.cpp b/src/input_common/drivers/sdl_driver.cpp
index e915ec0908..a0103edde2 100644
--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -321,7 +321,7 @@ void SDLDriver::InitJoystick(int joystick_index) {
if (Settings::values.enable_joycon_driver) {
if (guid.uuid[5] == 0x05 && guid.uuid[4] == 0x7e &&
(guid.uuid[8] == 0x06 || guid.uuid[8] == 0x07)) {
- LOG_ERROR(Input, "Device black listed {}", joystick_index);
+ LOG_WARNING(Input, "Preferring joycon driver for device index {}", joystick_index);
SDL_JoystickClose(sdl_joystick);
return;
}
diff --git a/src/input_common/helpers/joycon_driver.cpp b/src/input_common/helpers/joycon_driver.cpp
index 5525723435..4159e5717a 100644
--- a/src/input_common/helpers/joycon_driver.cpp
+++ b/src/input_common/helpers/joycon_driver.cpp
@@ -123,7 +123,7 @@ DriverResult JoyconDriver::InitializeDevice() {
}
void JoyconDriver::InputThread(std::stop_token stop_token) {
- LOG_INFO(Input, "JC Adapter input thread started");
+ LOG_INFO(Input, "Joycon Adapter input thread started");
Common::SetCurrentThreadName("JoyconInput");
input_thread_running = true;
@@ -157,7 +157,7 @@ void JoyconDriver::InputThread(std::stop_token stop_token) {
is_connected = false;
input_thread_running = false;
- LOG_INFO(Input, "JC Adapter input thread stopped");
+ LOG_INFO(Input, "Joycon Adapter input thread stopped");
}
void JoyconDriver::OnNewData(std::span<u8> buffer) {
@@ -349,7 +349,7 @@ JoyconDriver::SupportedFeatures JoyconDriver::GetSupportedFeatures() {
}
bool JoyconDriver::IsInputThreadValid() const {
- if (!is_connected) {
+ if (!is_connected.load()) {
return false;
}
if (hidapi_handle->handle == nullptr) {
@@ -491,7 +491,7 @@ DriverResult JoyconDriver::SetRingConMode() {
bool JoyconDriver::IsConnected() const {
std::scoped_lock lock{mutex};
- return is_connected;
+ return is_connected.load();
}
bool JoyconDriver::IsVibrationEnabled() const {
diff --git a/src/input_common/helpers/joycon_driver.h b/src/input_common/helpers/joycon_driver.h
index e8e65e1331..c1e189fa52 100644
--- a/src/input_common/helpers/joycon_driver.h
+++ b/src/input_common/helpers/joycon_driver.h
@@ -3,6 +3,7 @@
#pragma once
+#include <atomic>
#include <functional>
#include <mutex>
#include <span>
@@ -97,7 +98,7 @@ private:
std::unique_ptr<RumbleProtocol> rumble_protocol;
// Connection status
- bool is_connected{};
+ std::atomic<bool> is_connected{};
u64 delta_time;
std::size_t error_counter{};
std::shared_ptr<JoyconHandle> hidapi_handle;
diff --git a/src/input_common/helpers/joycon_protocol/calibration.cpp b/src/input_common/helpers/joycon_protocol/calibration.cpp
index cd30ab8698..f6e7e97d59 100644
--- a/src/input_common/helpers/joycon_protocol/calibration.cpp
+++ b/src/input_common/helpers/joycon_protocol/calibration.cpp
@@ -12,10 +12,10 @@ CalibrationProtocol::CalibrationProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {}
DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration& calibration) {
+ ScopedSetBlocking sb(this);
std::vector<u8> buffer;
DriverResult result{DriverResult::Success};
calibration = {};
- SetBlocking();
result = ReadSPI(CalAddr::USER_LEFT_MAGIC, sizeof(u16), buffer);
@@ -44,15 +44,14 @@ DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration
// Set a valid default calibration if data is missing
ValidateCalibration(calibration);
- SetNonBlocking();
return result;
}
DriverResult CalibrationProtocol::GetRightJoyStickCalibration(JoyStickCalibration& calibration) {
+ ScopedSetBlocking sb(this);
std::vector<u8> buffer;
DriverResult result{DriverResult::Success};
calibration = {};
- SetBlocking();
result = ReadSPI(CalAddr::USER_RIGHT_MAGIC, sizeof(u16), buffer);
@@ -81,15 +80,14 @@ DriverResult CalibrationProtocol::GetRightJoyStickCalibration(JoyStickCalibratio
// Set a valid default calibration if data is missing
ValidateCalibration(calibration);
- SetNonBlocking();
return result;
}
DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibration) {
+ ScopedSetBlocking sb(this);
std::vector<u8> buffer;
DriverResult result{DriverResult::Success};
calibration = {};
- SetBlocking();
result = ReadSPI(CalAddr::USER_IMU_MAGIC, sizeof(u16), buffer);
@@ -124,7 +122,6 @@ DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibrati
ValidateCalibration(calibration);
- SetNonBlocking();
return result;
}
diff --git a/src/input_common/helpers/joycon_protocol/common_protocol.cpp b/src/input_common/helpers/joycon_protocol/common_protocol.cpp
index 153a3908c6..417d0dcc50 100644
--- a/src/input_common/helpers/joycon_protocol/common_protocol.cpp
+++ b/src/input_common/helpers/joycon_protocol/common_protocol.cpp
@@ -58,9 +58,8 @@ DriverResult JoyconCommonProtocol::CheckDeviceAccess(SDL_hid_device_info* device
}
DriverResult JoyconCommonProtocol::SetReportMode(ReportMode report_mode) {
- const std::vector<u8> buffer{static_cast<u8>(report_mode)};
- std::vector<u8> output;
- return SendSubCommand(SubCommand::SET_REPORT_MODE, buffer, output);
+ const std::array<u8, 1> buffer{static_cast<u8>(report_mode)};
+ return SendSubCommand(SubCommand::SET_REPORT_MODE, buffer);
}
DriverResult JoyconCommonProtocol::SendData(std::span<const u8> buffer) {
@@ -120,7 +119,12 @@ DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, std::span<const
return DriverResult::Success;
}
-DriverResult JoyconCommonProtocol::SendMcuCommand(SubCommand sc, std::span<const u8> buffer) {
+DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, std::span<const u8> buffer) {
+ std::vector<u8> output;
+ return SendSubCommand(sc, buffer, output);
+}
+
+DriverResult JoyconCommonProtocol::SendMCUCommand(SubCommand sc, std::span<const u8> buffer) {
std::vector<u8> local_buffer(MaxResponseSize);
local_buffer[0] = static_cast<u8>(OutputReport::MCU_DATA);
@@ -147,7 +151,7 @@ DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffe
DriverResult JoyconCommonProtocol::ReadSPI(CalAddr addr, u8 size, std::vector<u8>& output) {
constexpr std::size_t MaxTries = 10;
std::size_t tries = 0;
- std::vector<u8> buffer = {0x00, 0x00, 0x00, 0x00, size};
+ std::array<u8, 5> buffer = {0x00, 0x00, 0x00, 0x00, size};
std::vector<u8> local_buffer(size + 20);
buffer[0] = static_cast<u8>(static_cast<u16>(addr) & 0x00FF);
@@ -169,10 +173,8 @@ DriverResult JoyconCommonProtocol::ReadSPI(CalAddr addr, u8 size, std::vector<u8
}
DriverResult JoyconCommonProtocol::EnableMCU(bool enable) {
- std::vector<u8> output;
-
- const std::vector<u8> mcu_state{static_cast<u8>(enable ? 1 : 0)};
- const auto result = SendSubCommand(SubCommand::SET_MCU_STATE, mcu_state, output);
+ const std::array<u8, 1> mcu_state{static_cast<u8>(enable ? 1 : 0)};
+ const auto result = SendSubCommand(SubCommand::SET_MCU_STATE, mcu_state);
if (result != DriverResult::Success) {
LOG_ERROR(Input, "SendMCUData failed with error {}", result);
@@ -183,13 +185,11 @@ DriverResult JoyconCommonProtocol::EnableMCU(bool enable) {
DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig& config) {
LOG_DEBUG(Input, "ConfigureMCU");
- std::vector<u8> output;
-
std::array<u8, sizeof(MCUConfig)> config_buffer;
memcpy(config_buffer.data(), &config, sizeof(MCUConfig));
config_buffer[37] = CalculateMCU_CRC8(config_buffer.data() + 1, 36);
- const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, config_buffer, output);
+ const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, config_buffer);
if (result != DriverResult::Success) {
LOG_ERROR(Input, "Set MCU config failed with error {}", result);
diff --git a/src/input_common/helpers/joycon_protocol/common_protocol.h b/src/input_common/helpers/joycon_protocol/common_protocol.h
index 2a3feaf598..903bcf4025 100644
--- a/src/input_common/helpers/joycon_protocol/common_protocol.h
+++ b/src/input_common/helpers/joycon_protocol/common_protocol.h
@@ -74,12 +74,19 @@ public:
*/
DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer, std::vector<u8>& output);
+ /**
+ * Sends a sub command to the device and waits for it's reply and ignores the output
+ * @param sc sub command to be send
+ * @param buffer data to be send
+ */
+ DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer);
+
/**
* Sends a mcu command to the device
* @param sc sub command to be send
* @param buffer data to be send
*/
- DriverResult SendMcuCommand(SubCommand sc, std::span<const u8> buffer);
+ DriverResult SendMCUCommand(SubCommand sc, std::span<const u8> buffer);
/**
* Sends vibration data to the joycon
@@ -150,4 +157,17 @@ private:
std::shared_ptr<JoyconHandle> hidapi_handle;
};
+class ScopedSetBlocking {
+public:
+ explicit ScopedSetBlocking(JoyconCommonProtocol* self) : m_self{self} {
+ m_self->SetBlocking();
+ }
+
+ ~ScopedSetBlocking() {
+ m_self->SetNonBlocking();
+ }
+
+private:
+ JoyconCommonProtocol* m_self{};
+};
} // namespace InputCommon::Joycon
diff --git a/src/input_common/helpers/joycon_protocol/generic_functions.cpp b/src/input_common/helpers/joycon_protocol/generic_functions.cpp
index cbd9ff4f8b..52bb8b61aa 100644
--- a/src/input_common/helpers/joycon_protocol/generic_functions.cpp
+++ b/src/input_common/helpers/joycon_protocol/generic_functions.cpp
@@ -10,22 +10,18 @@ GenericProtocol::GenericProtocol(std::shared_ptr<JoyconHandle> handle)
: JoyconCommonProtocol(std::move(handle)) {}
DriverResult GenericProtocol::EnablePassiveMode() {
- SetBlocking();
- const auto result = SetReportMode(ReportMode::SIMPLE_HID_MODE);
- SetNonBlocking();
- return result;
+ ScopedSetBlocking sb(this);
+ return SetReportMode(ReportMode::SIMPLE_HID_MODE);
}
DriverResult GenericProtocol::EnableActiveMode() {
- SetBlocking();
- const auto result = SetReportMode(ReportMode::STANDARD_FULL_60HZ);
- SetNonBlocking();
- return result;
+ ScopedSetBlocking sb(this);
+ return SetReportMode(ReportMode::STANDARD_FULL_60HZ);
}
DriverResult GenericProtocol::GetDeviceInfo(DeviceInfo& device_info) {
+ ScopedSetBlocking sb(this);
std::vector<u8> output;
- SetBlocking();
const auto result = SendSubCommand(SubCommand::REQ_DEV_INFO, {}, output);
@@ -34,7 +30,6 @@ DriverResult GenericProtocol::GetDeviceInfo(DeviceInfo& device_info) {
memcpy(&device_info, output.data(), sizeof(DeviceInfo));
}
- SetNonBlocking();
return result;
}
@@ -43,36 +38,30 @@ DriverResult GenericProtocol::GetControllerType(ControllerType& controller_type)
}
DriverResult GenericProtocol::EnableImu(bool enable) {
+ ScopedSetBlocking sb(this);
const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)};
- std::vector<u8> output;
- SetBlocking();
- const auto result = SendSubCommand(SubCommand::ENABLE_IMU, buffer, output);
- SetNonBlocking();
- return result;
+ return SendSubCommand(SubCommand::ENABLE_IMU, buffer);
}
DriverResult GenericProtocol::SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec,
AccelerometerSensitivity asen,
AccelerometerPerformance afrec) {
+ ScopedSetBlocking sb(this);
const std::array<u8, 4> buffer{static_cast<u8>(gsen), static_cast<u8>(asen),
static_cast<u8>(gfrec), static_cast<u8>(afrec)};
- std::vector<u8> output;
- SetBlocking();
- const auto result = SendSubCommand(SubCommand::SET_IMU_SENSITIVITY, buffer, output);
- SetNonBlocking();
- return result;
+ return SendSubCommand(SubCommand::SET_IMU_SENSITIVITY, buffer);
}
DriverResult GenericProtocol::GetBattery(u32& battery_level) {
+ // This function is meant to request the high resolution battery status
battery_level = 0;
return DriverResult::NotSupported;
}
DriverResult GenericProtocol::GetColor(Color& color) {
+ ScopedSetBlocking sb(this);
std::vector<u8> buffer;
- SetBlocking();
const auto result = ReadSPI(CalAddr::COLOR_DATA, 12, buffer);
- SetNonBlocking();
color = {};
if (result == DriverResult::Success) {
@@ -86,10 +75,9 @@ DriverResult GenericProtocol::GetColor(Color& color) {
}
DriverResult GenericProtocol::GetSerialNumber(SerialNumber& serial_number) {
+ ScopedSetBlocking sb(this);
std::vector<u8> buffer;
- SetBlocking();
const auto result = ReadSPI(CalAddr::SERIAL_NUMBER, 16, buffer);
- SetNonBlocking();
serial_number = {};
if (result == DriverResult::Success) {
@@ -115,14 +103,9 @@ DriverResult GenericProtocol::GetVersionNumber(FirmwareVersion& version) {
}
DriverResult GenericProtocol::SetHomeLight() {
+ ScopedSetBlocking sb(this);
static constexpr std::array<u8, 3> buffer{0x0f, 0xf0, 0x00};
- std::vector<u8> output;
- SetBlocking();
-
- const auto result = SendSubCommand(SubCommand::SET_HOME_LIGHT, buffer, output);
-
- SetNonBlocking();
- return result;
+ return SendSubCommand(SubCommand::SET_HOME_LIGHT, buffer);
}
DriverResult GenericProtocol::SetLedBusy() {
@@ -130,14 +113,9 @@ DriverResult GenericProtocol::SetLedBusy() {
}
DriverResult GenericProtocol::SetLedPattern(u8 leds) {
+ ScopedSetBlocking sb(this);
const std::array<u8, 1> buffer{leds};
- std::vector<u8> output;
- SetBlocking();
-
- const auto result = SendSubCommand(SubCommand::SET_PLAYER_LIGHTS, buffer, output);
-
- SetNonBlocking();
- return result;
+ return SendSubCommand(SubCommand::SET_PLAYER_LIGHTS, buffer);
}
DriverResult GenericProtocol::SetLedBlinkPattern(u8 leds) {
diff --git a/src/input_common/helpers/joycon_protocol/irs.cpp b/src/input_common/helpers/joycon_protocol/irs.cpp
index 9dfa503c23..09e17bc5b6 100644
--- a/src/input_common/helpers/joycon_protocol/irs.cpp
+++ b/src/input_common/helpers/joycon_protocol/irs.cpp
@@ -12,8 +12,8 @@ IrsProtocol::IrsProtocol(std::shared_ptr<JoyconHandle> handle)
DriverResult IrsProtocol::EnableIrs() {
LOG_INFO(Input, "Enable IRS");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
- SetBlocking();
if (result == DriverResult::Success) {
result = SetReportMode(ReportMode::NFC_IR_MODE_60HZ);
@@ -49,14 +49,13 @@ DriverResult IrsProtocol::EnableIrs() {
is_enabled = true;
- SetNonBlocking();
return result;
}
DriverResult IrsProtocol::DisableIrs() {
LOG_DEBUG(Input, "Disable IRS");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
- SetBlocking();
if (result == DriverResult::Success) {
result = EnableMCU(false);
@@ -64,7 +63,6 @@ DriverResult IrsProtocol::DisableIrs() {
is_enabled = false;
- SetNonBlocking();
return result;
}
@@ -148,7 +146,7 @@ DriverResult IrsProtocol::ConfigureIrs() {
};
buf_image.resize((static_cast<u8>(fragments) + 1) * 300);
- std::vector<u8> request_data(sizeof(IrsConfigure));
+ std::array<u8, sizeof(IrsConfigure)> request_data{};
memcpy(request_data.data(), &irs_configuration, sizeof(IrsConfigure));
request_data[37] = CalculateMCU_CRC8(request_data.data() + 1, 36);
do {
@@ -191,7 +189,7 @@ DriverResult IrsProtocol::WriteRegistersStep1() {
.crc = {},
};
- std::vector<u8> request_data(sizeof(IrsWriteRegisters));
+ std::array<u8, sizeof(IrsWriteRegisters)> request_data{};
memcpy(request_data.data(), &irs_registers, sizeof(IrsWriteRegisters));
request_data[37] = CalculateMCU_CRC8(request_data.data() + 1, 36);
@@ -208,7 +206,7 @@ DriverResult IrsProtocol::WriteRegistersStep1() {
// First time we need to set the report mode
if (result == 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) {
GetSubCommandResponse(SubCommand::SET_MCU_CONFIG, output);
@@ -250,7 +248,7 @@ DriverResult IrsProtocol::WriteRegistersStep2() {
.crc = {},
};
- std::vector<u8> request_data(sizeof(IrsWriteRegisters));
+ std::array<u8, sizeof(IrsWriteRegisters)> request_data{};
memcpy(request_data.data(), &irs_registers, sizeof(IrsWriteRegisters));
request_data[37] = CalculateMCU_CRC8(request_data.data() + 1, 36);
do {
@@ -272,7 +270,7 @@ DriverResult IrsProtocol::RequestFrame(u8 frame) {
mcu_request[3] = frame;
mcu_request[36] = CalculateMCU_CRC8(mcu_request.data(), 36);
mcu_request[37] = 0xFF;
- return SendMcuCommand(SubCommand::SET_REPORT_MODE, mcu_request);
+ return SendMCUCommand(SubCommand::SET_REPORT_MODE, mcu_request);
}
DriverResult IrsProtocol::ResendFrame(u8 frame) {
@@ -282,7 +280,7 @@ DriverResult IrsProtocol::ResendFrame(u8 frame) {
mcu_request[3] = 0x0;
mcu_request[36] = CalculateMCU_CRC8(mcu_request.data(), 36);
mcu_request[37] = 0xFF;
- return SendMcuCommand(SubCommand::SET_REPORT_MODE, mcu_request);
+ return SendMCUCommand(SubCommand::SET_REPORT_MODE, mcu_request);
}
std::vector<u8> IrsProtocol::GetImage() const {
diff --git a/src/input_common/helpers/joycon_protocol/joycon_types.h b/src/input_common/helpers/joycon_protocol/joycon_types.h
index 273c8d07d3..e2d47349f0 100644
--- a/src/input_common/helpers/joycon_protocol/joycon_types.h
+++ b/src/input_common/helpers/joycon_protocol/joycon_types.h
@@ -273,6 +273,18 @@ enum class NFCTagType : u8 {
Ntag215 = 0x01,
};
+enum class NFCPages {
+ Block0 = 0,
+ Block45 = 45,
+ Block135 = 135,
+ Block231 = 231,
+};
+
+enum class NFCStatus : u8 {
+ LastPackage = 0x04,
+ TagLost = 0x07,
+};
+
enum class IrsMode : u8 {
None = 0x02,
Moment = 0x03,
diff --git a/src/input_common/helpers/joycon_protocol/nfc.cpp b/src/input_common/helpers/joycon_protocol/nfc.cpp
index 8755e310b8..5c0f717228 100644
--- a/src/input_common/helpers/joycon_protocol/nfc.cpp
+++ b/src/input_common/helpers/joycon_protocol/nfc.cpp
@@ -12,8 +12,8 @@ NfcProtocol::NfcProtocol(std::shared_ptr<JoyconHandle> handle)
DriverResult NfcProtocol::EnableNfc() {
LOG_INFO(Input, "Enable NFC");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
- SetBlocking();
if (result == DriverResult::Success) {
result = SetReportMode(ReportMode::NFC_IR_MODE_60HZ);
@@ -35,14 +35,13 @@ DriverResult NfcProtocol::EnableNfc() {
result = ConfigureMCU(config);
}
- SetNonBlocking();
return result;
}
DriverResult NfcProtocol::DisableNfc() {
LOG_DEBUG(Input, "Disable NFC");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
- SetBlocking();
if (result == DriverResult::Success) {
result = EnableMCU(false);
@@ -50,15 +49,14 @@ DriverResult NfcProtocol::DisableNfc() {
is_enabled = false;
- SetNonBlocking();
return result;
}
DriverResult NfcProtocol::StartNFCPollingMode() {
LOG_DEBUG(Input, "Start NFC pooling Mode");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
TagFoundData tag_data{};
- SetBlocking();
if (result == DriverResult::Success) {
result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::NFC);
@@ -70,15 +68,14 @@ DriverResult NfcProtocol::StartNFCPollingMode() {
is_enabled = true;
}
- SetNonBlocking();
return result;
}
DriverResult NfcProtocol::ScanAmiibo(std::vector<u8>& data) {
LOG_DEBUG(Input, "Start NFC pooling Mode");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
TagFoundData tag_data{};
- SetBlocking();
if (result == DriverResult::Success) {
result = StartPolling(tag_data);
@@ -96,20 +93,18 @@ DriverResult NfcProtocol::ScanAmiibo(std::vector<u8>& data) {
result = GetAmiiboData(data);
}
- SetNonBlocking();
return result;
}
bool NfcProtocol::HasAmiibo() {
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
TagFoundData tag_data{};
- SetBlocking();
if (result == DriverResult::Success) {
result = StartPolling(tag_data);
}
- SetNonBlocking();
return result == DriverResult::Success;
}
@@ -169,55 +164,53 @@ DriverResult NfcProtocol::ReadTag(const TagFoundData& data) {
LOG_INFO(Input, "Tag detected, type={}, uuid={}", data.type, uuid_string);
tries = 0;
- std::size_t ntag_pages = 0;
+ NFCPages ntag_pages = NFCPages::Block0;
// Read Tag data
-loop1:
while (true) {
auto result = SendReadAmiiboRequest(output, ntag_pages);
+ const auto mcu_report = static_cast<MCUReport>(output[49]);
+ const auto nfc_status = static_cast<NFCStatus>(output[56]);
- int attempt = 0;
- while (1) {
- if (attempt != 0) {
- result = GetMCUDataResponse(ReportMode::NFC_IR_MODE_60HZ, output);
+ if (result != DriverResult::Success) {
+ return result;
+ }
+
+ if ((mcu_report == MCUReport::NFCReadData || mcu_report == MCUReport::NFCState) &&
+ nfc_status == NFCStatus::TagLost) {
+ return DriverResult::ErrorReadingData;
+ }
+
+ if (mcu_report == MCUReport::NFCReadData && output[51] == 0x07 && output[52] == 0x01) {
+ if (data.type != 2) {
+ continue;
}
- if ((output[49] == 0x3a || output[49] == 0x2a) && output[56] == 0x07) {
+ switch (output[74]) {
+ case 0:
+ ntag_pages = NFCPages::Block135;
+ break;
+ case 3:
+ ntag_pages = NFCPages::Block45;
+ break;
+ case 4:
+ ntag_pages = NFCPages::Block231;
+ break;
+ default:
return DriverResult::ErrorReadingData;
}
- if (output[49] == 0x3a && output[51] == 0x07 && output[52] == 0x01) {
- if (data.type != 2) {
- goto loop1;
- }
- switch (output[74]) {
- case 0:
- ntag_pages = 135;
- break;
- case 3:
- ntag_pages = 45;
- break;
- case 4:
- ntag_pages = 231;
- break;
- default:
- return DriverResult::ErrorReadingData;
- }
- goto loop1;
- }
- if (output[49] == 0x2a && output[56] == 0x04) {
- // finished
- SendStopPollingRequest(output);
- return DriverResult::Success;
- }
- if (output[49] == 0x2a) {
- goto loop1;
- }
- if (attempt++ > 6) {
- goto loop1;
- }
+ continue;
}
- if (result != DriverResult::Success) {
- return result;
+ if (mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) {
+ // finished
+ SendStopPollingRequest(output);
+ return DriverResult::Success;
+ }
+
+ // Ignore other state reports
+ if (mcu_report == MCUReport::NFCState) {
+ continue;
}
+
if (tries++ > timeout_limit) {
return DriverResult::Timeout;
}
@@ -231,47 +224,44 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
std::vector<u8> output;
std::size_t tries = 0;
- std::size_t ntag_pages = 135;
+ NFCPages ntag_pages = NFCPages::Block135;
std::size_t ntag_buffer_pos = 0;
// Read Tag data
-loop1:
while (true) {
auto result = SendReadAmiiboRequest(output, ntag_pages);
+ const auto mcu_report = static_cast<MCUReport>(output[49]);
+ const auto nfc_status = static_cast<NFCStatus>(output[56]);
- int attempt = 0;
- while (1) {
- if (attempt != 0) {
- result = GetMCUDataResponse(ReportMode::NFC_IR_MODE_60HZ, output);
- }
- if ((output[49] == 0x3a || output[49] == 0x2a) && output[56] == 0x07) {
- return DriverResult::ErrorReadingData;
- }
- if (output[49] == 0x3a && output[51] == 0x07) {
- std::size_t payload_size = (output[54] << 8 | output[55]) & 0x7FF;
- if (output[52] == 0x01) {
- memcpy(ntag_data.data() + ntag_buffer_pos, output.data() + 116,
- payload_size - 60);
- ntag_buffer_pos += payload_size - 60;
- } else {
- memcpy(ntag_data.data() + ntag_buffer_pos, output.data() + 56, payload_size);
- }
- goto loop1;
- }
- if (output[49] == 0x2a && output[56] == 0x04) {
- LOG_INFO(Input, "Finished reading amiibo");
- return DriverResult::Success;
- }
- if (output[49] == 0x2a) {
- goto loop1;
- }
- if (attempt++ > 4) {
- goto loop1;
+ if (result != DriverResult::Success) {
+ return result;
+ }
+
+ if ((mcu_report == MCUReport::NFCReadData || mcu_report == MCUReport::NFCState) &&
+ nfc_status == NFCStatus::TagLost) {
+ return DriverResult::ErrorReadingData;
+ }
+
+ if (mcu_report == MCUReport::NFCReadData && output[51] == 0x07) {
+ std::size_t payload_size = (output[54] << 8 | output[55]) & 0x7FF;
+ if (output[52] == 0x01) {
+ memcpy(ntag_data.data() + ntag_buffer_pos, output.data() + 116, payload_size - 60);
+ ntag_buffer_pos += payload_size - 60;
+ } else {
+ memcpy(ntag_data.data() + ntag_buffer_pos, output.data() + 56, payload_size);
}
+ continue;
}
- if (result != DriverResult::Success) {
- return result;
+ if (mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) {
+ LOG_INFO(Input, "Finished reading amiibo");
+ return DriverResult::Success;
+ }
+
+ // Ignore other state reports
+ if (mcu_report == MCUReport::NFCState) {
+ continue;
}
+
if (tries++ > timeout_limit) {
return DriverResult::Timeout;
}
@@ -298,7 +288,7 @@ DriverResult NfcProtocol::SendStartPollingRequest(std::vector<u8>& output) {
.crc = {},
};
- std::vector<u8> request_data(sizeof(NFCRequestState));
+ std::array<u8, sizeof(NFCRequestState)> request_data{};
memcpy(request_data.data(), &request, sizeof(NFCRequestState));
request_data[37] = CalculateMCU_CRC8(request_data.data() + 1, 36);
return SendMCUData(ReportMode::NFC_IR_MODE_60HZ, SubCommand::STATE, request_data, output);
@@ -315,7 +305,7 @@ DriverResult NfcProtocol::SendStopPollingRequest(std::vector<u8>& output) {
.crc = {},
};
- std::vector<u8> request_data(sizeof(NFCRequestState));
+ std::array<u8, sizeof(NFCRequestState)> request_data{};
memcpy(request_data.data(), &request, sizeof(NFCRequestState));
request_data[37] = CalculateMCU_CRC8(request_data.data() + 1, 36);
return SendMCUData(ReportMode::NFC_IR_MODE_60HZ, SubCommand::STATE, request_data, output);
@@ -338,7 +328,7 @@ DriverResult NfcProtocol::SendStartWaitingRecieveRequest(std::vector<u8>& output
return SendMCUData(ReportMode::NFC_IR_MODE_60HZ, SubCommand::STATE, request_data, output);
}
-DriverResult NfcProtocol::SendReadAmiiboRequest(std::vector<u8>& output, std::size_t ntag_pages) {
+DriverResult NfcProtocol::SendReadAmiiboRequest(std::vector<u8>& output, NFCPages ntag_pages) {
NFCRequestState request{
.sub_command = MCUSubCommand::ReadDeviceMode,
.command_argument = NFCReadCommand::Ntag,
@@ -357,20 +347,19 @@ DriverResult NfcProtocol::SendReadAmiiboRequest(std::vector<u8>& output, std::si
.crc = {},
};
- std::vector<u8> request_data(sizeof(NFCRequestState));
+ std::array<u8, sizeof(NFCRequestState)> request_data{};
memcpy(request_data.data(), &request, sizeof(NFCRequestState));
request_data[37] = CalculateMCU_CRC8(request_data.data() + 1, 36);
return SendMCUData(ReportMode::NFC_IR_MODE_60HZ, SubCommand::STATE, request_data, output);
}
-NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(std::size_t pages) const {
- if (pages == 0) {
+NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(NFCPages pages) const {
+ switch (pages) {
+ case NFCPages::Block0:
return {
.block_count = 1,
};
- }
-
- if (pages == 45) {
+ case NFCPages::Block45:
return {
.block_count = 1,
.blocks =
@@ -378,9 +367,7 @@ NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(std::size_t pages) const {
NFCReadBlock{0x00, 0x2C},
},
};
- }
-
- if (pages == 135) {
+ case NFCPages::Block135:
return {
.block_count = 3,
.blocks =
@@ -390,9 +377,7 @@ NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(std::size_t pages) const {
{0x78, 0x86},
},
};
- }
-
- if (pages == 231) {
+ case NFCPages::Block231:
return {
.block_count = 4,
.blocks =
@@ -403,9 +388,9 @@ NFCReadBlockCommand NfcProtocol::GetReadBlockCommand(std::size_t pages) const {
{0xb4, 0xe6},
},
};
- }
-
- return {};
+ default:
+ return {};
+ };
}
bool NfcProtocol::IsEnabled() const {
diff --git a/src/input_common/helpers/joycon_protocol/nfc.h b/src/input_common/helpers/joycon_protocol/nfc.h
index 5cb0e5a652..e63665aa97 100644
--- a/src/input_common/helpers/joycon_protocol/nfc.h
+++ b/src/input_common/helpers/joycon_protocol/nfc.h
@@ -51,9 +51,9 @@ private:
DriverResult SendStartWaitingRecieveRequest(std::vector<u8>& output);
- DriverResult SendReadAmiiboRequest(std::vector<u8>& output, std::size_t ntag_pages);
+ DriverResult SendReadAmiiboRequest(std::vector<u8>& output, NFCPages ntag_pages);
- NFCReadBlockCommand GetReadBlockCommand(std::size_t pages) const;
+ NFCReadBlockCommand GetReadBlockCommand(NFCPages pages) const;
bool is_enabled{};
};
diff --git a/src/input_common/helpers/joycon_protocol/poller.cpp b/src/input_common/helpers/joycon_protocol/poller.cpp
index 940b20b7f0..7f8e093faf 100644
--- a/src/input_common/helpers/joycon_protocol/poller.cpp
+++ b/src/input_common/helpers/joycon_protocol/poller.cpp
@@ -224,9 +224,9 @@ void JoyconPoller::UpdatePasiveLeftPadInput(const InputReportPassive& input) {
Joycon::PasivePadButton::StickL,
};
- for (std::size_t i = 0; i < left_buttons.size(); ++i) {
- const bool button_status = (input.button_input & static_cast<u32>(left_buttons[i])) != 0;
- const int button = static_cast<int>(left_buttons[i]);
+ for (auto left_button : left_buttons) {
+ const bool button_status = (input.button_input & static_cast<u32>(left_button)) != 0;
+ const int button = static_cast<int>(left_button);
callbacks.on_button_data(button, button_status);
}
}
@@ -241,9 +241,9 @@ void JoyconPoller::UpdatePasiveRightPadInput(const InputReportPassive& input) {
Joycon::PasivePadButton::StickR,
};
- for (std::size_t i = 0; i < right_buttons.size(); ++i) {
- const bool button_status = (input.button_input & static_cast<u32>(right_buttons[i])) != 0;
- const int button = static_cast<int>(right_buttons[i]);
+ for (auto right_button : right_buttons) {
+ const bool button_status = (input.button_input & static_cast<u32>(right_button)) != 0;
+ const int button = static_cast<int>(right_button);
callbacks.on_button_data(button, button_status);
}
}
@@ -259,9 +259,9 @@ void JoyconPoller::UpdatePasiveProPadInput(const InputReportPassive& input) {
Joycon::PasivePadButton::StickL, Joycon::PasivePadButton::StickR,
};
- for (std::size_t i = 0; i < pro_buttons.size(); ++i) {
- const bool button_status = (input.button_input & static_cast<u32>(pro_buttons[i])) != 0;
- const int button = static_cast<int>(pro_buttons[i]);
+ for (auto pro_button : pro_buttons) {
+ const bool button_status = (input.button_input & static_cast<u32>(pro_button)) != 0;
+ const int button = static_cast<int>(pro_button);
callbacks.on_button_data(button, button_status);
}
}
diff --git a/src/input_common/helpers/joycon_protocol/ringcon.cpp b/src/input_common/helpers/joycon_protocol/ringcon.cpp
index 8adad57dd6..12f81309e1 100644
--- a/src/input_common/helpers/joycon_protocol/ringcon.cpp
+++ b/src/input_common/helpers/joycon_protocol/ringcon.cpp
@@ -11,8 +11,8 @@ RingConProtocol::RingConProtocol(std::shared_ptr<JoyconHandle> handle)
DriverResult RingConProtocol::EnableRingCon() {
LOG_DEBUG(Input, "Enable Ringcon");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
- SetBlocking();
if (result == DriverResult::Success) {
result = SetReportMode(ReportMode::STANDARD_FULL_60HZ);
@@ -30,14 +30,13 @@ DriverResult RingConProtocol::EnableRingCon() {
result = ConfigureMCU(config);
}
- SetNonBlocking();
return result;
}
DriverResult RingConProtocol::DisableRingCon() {
LOG_DEBUG(Input, "Disable RingCon");
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
- SetBlocking();
if (result == DriverResult::Success) {
result = EnableMCU(false);
@@ -45,15 +44,14 @@ DriverResult RingConProtocol::DisableRingCon() {
is_enabled = false;
- SetNonBlocking();
return result;
}
DriverResult RingConProtocol::StartRingconPolling() {
LOG_DEBUG(Input, "Enable Ringcon");
- bool is_connected = false;
+ ScopedSetBlocking sb(this);
DriverResult result{DriverResult::Success};
- SetBlocking();
+ bool is_connected = false;
if (result == DriverResult::Success) {
result = IsRingConnected(is_connected);
@@ -66,13 +64,13 @@ DriverResult RingConProtocol::StartRingconPolling() {
is_enabled = true;
}
- SetNonBlocking();
return result;
}
DriverResult RingConProtocol::IsRingConnected(bool& is_connected) {
LOG_DEBUG(Input, "IsRingConnected");
constexpr std::size_t max_tries = 28;
+ constexpr u8 ring_controller_id = 0x20;
std::vector<u8> output;
std::size_t tries = 0;
is_connected = false;
@@ -88,7 +86,7 @@ DriverResult RingConProtocol::IsRingConnected(bool& is_connected) {
if (tries++ >= max_tries) {
return DriverResult::NoDeviceDetected;
}
- } while (output[14] != 0x59 || output[16] != 0x20);
+ } while (output[16] != ring_controller_id);
is_connected = true;
return DriverResult::Success;
@@ -96,30 +94,20 @@ DriverResult RingConProtocol::IsRingConnected(bool& is_connected) {
DriverResult RingConProtocol::ConfigureRing() {
LOG_DEBUG(Input, "ConfigureRing");
- constexpr std::size_t max_tries = 28;
- DriverResult result{DriverResult::Success};
- std::vector<u8> output;
- std::size_t tries = 0;
static constexpr std::array<u8, 37> ring_config{
0x06, 0x03, 0x25, 0x06, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x16, 0xED, 0x34, 0x36,
0x00, 0x00, 0x00, 0x0A, 0x64, 0x0B, 0xE6, 0xA9, 0x22, 0x00, 0x00, 0x04, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0xA8, 0xE1, 0x34, 0x36};
- do {
- result = SendSubCommand(SubCommand::UNKNOWN_RINGCON3, ring_config, output);
- if (result != DriverResult::Success) {
- return result;
- }
- if (tries++ >= max_tries) {
- return DriverResult::NoDeviceDetected;
- }
- } while (output[14] != 0x5C);
+ const DriverResult result = SendSubCommand(SubCommand::UNKNOWN_RINGCON3, ring_config);
- static constexpr std::array<u8, 4> ringcon_data{0x04, 0x01, 0x01, 0x02};
- result = SendSubCommand(SubCommand::UNKNOWN_RINGCON2, ringcon_data, output);
+ if (result != DriverResult::Success) {
+ return result;
+ }
- return result;
+ static constexpr std::array<u8, 4> ringcon_data{0x04, 0x01, 0x01, 0x02};
+ return SendSubCommand(SubCommand::UNKNOWN_RINGCON2, ringcon_data);
}
bool RingConProtocol::IsEnabled() const {
diff --git a/src/input_common/helpers/joycon_protocol/rumble.cpp b/src/input_common/helpers/joycon_protocol/rumble.cpp
index fad67a94ba..63b60c9468 100644
--- a/src/input_common/helpers/joycon_protocol/rumble.cpp
+++ b/src/input_common/helpers/joycon_protocol/rumble.cpp
@@ -14,12 +14,9 @@ RumbleProtocol::RumbleProtocol(std::shared_ptr<JoyconHandle> handle)
DriverResult RumbleProtocol::EnableRumble(bool is_enabled) {
LOG_DEBUG(Input, "Enable Rumble");
+ ScopedSetBlocking sb(this);
const std::array<u8, 1> buffer{static_cast<u8>(is_enabled ? 1 : 0)};
- std::vector<u8> output;
- SetBlocking();
- const auto result = SendSubCommand(SubCommand::ENABLE_VIBRATION, buffer, output);
- SetNonBlocking();
- return result;
+ return SendSubCommand(SubCommand::ENABLE_VIBRATION, buffer);
}
DriverResult RumbleProtocol::SendVibration(const VibrationValue& vibration) {
@@ -66,9 +63,9 @@ u8 RumbleProtocol::EncodeLowFrequency(f32 frequency) const {
}
u8 RumbleProtocol::EncodeHighAmplitude(f32 amplitude) const {
- /* More information about these values can be found here:
- * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
- */
+ // More information about these values can be found here:
+ // https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
+
static constexpr std::array<std::pair<f32, int>, 101> high_fequency_amplitude{
std::pair<f32, int>{0.0f, 0x0},
{0.01f, 0x2},
@@ -183,9 +180,9 @@ u8 RumbleProtocol::EncodeHighAmplitude(f32 amplitude) const {
}
u16 RumbleProtocol::EncodeLowAmplitude(f32 amplitude) const {
- /* More information about these values can be found here:
- * https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
- */
+ // More information about these values can be found here:
+ // https://github.com/dekuNukem/Nintendo_Switch_Reverse_Engineering/blob/master/rumble_data_table.md
+
static constexpr std::array<std::pair<f32, int>, 101> high_fequency_amplitude{
std::pair<f32, int>{0.0f, 0x0040},
{0.01f, 0x8040},
--
cgit v1.2.3-70-g09d2