diff options
Diffstat (limited to '')
17 files changed, 834 insertions, 334 deletions
diff --git a/src/input_common/helpers/joycon_protocol/calibration.cpp b/src/input_common/helpers/joycon_protocol/calibration.cpp index d8f040f75..1300ecaf5 100644 --- a/src/input_common/helpers/joycon_protocol/calibration.cpp +++ b/src/input_common/helpers/joycon_protocol/calibration.cpp @@ -3,6 +3,7 @@ #include <cstring> +#include "common/input.h" #include "input_common/helpers/joycon_protocol/calibration.h" #include "input_common/helpers/joycon_protocol/joycon_types.h" @@ -11,28 +12,29 @@ namespace InputCommon::Joycon { CalibrationProtocol::CalibrationProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(std::move(handle)) {} -DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration& calibration) { +Common::Input::DriverResult CalibrationProtocol::GetLeftJoyStickCalibration( + JoyStickCalibration& calibration) { ScopedSetBlocking sb(this); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; JoystickLeftSpiCalibration spi_calibration{}; bool has_user_calibration = false; calibration = {}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = HasUserCalibration(SpiAddress::USER_LEFT_MAGIC, has_user_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); } // 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); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { calibration.x.center = GetXAxisCalibrationValue(spi_calibration.center); calibration.y.center = GetYAxisCalibrationValue(spi_calibration.center); calibration.x.min = GetXAxisCalibrationValue(spi_calibration.min); @@ -47,28 +49,29 @@ DriverResult CalibrationProtocol::GetLeftJoyStickCalibration(JoyStickCalibration return result; } -DriverResult CalibrationProtocol::GetRightJoyStickCalibration(JoyStickCalibration& calibration) { +Common::Input::DriverResult CalibrationProtocol::GetRightJoyStickCalibration( + JoyStickCalibration& calibration) { ScopedSetBlocking sb(this); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; JoystickRightSpiCalibration spi_calibration{}; bool has_user_calibration = false; calibration = {}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = HasUserCalibration(SpiAddress::USER_RIGHT_MAGIC, has_user_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); } // 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); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { calibration.x.center = GetXAxisCalibrationValue(spi_calibration.center); calibration.y.center = GetYAxisCalibrationValue(spi_calibration.center); calibration.x.min = GetXAxisCalibrationValue(spi_calibration.min); @@ -83,28 +86,28 @@ DriverResult CalibrationProtocol::GetRightJoyStickCalibration(JoyStickCalibratio return result; } -DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibration) { +Common::Input::DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibration) { ScopedSetBlocking sb(this); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; ImuSpiCalibration spi_calibration{}; bool has_user_calibration = false; calibration = {}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = HasUserCalibration(SpiAddress::USER_IMU_MAGIC, has_user_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); } // 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); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { calibration.accelerometer[0].offset = spi_calibration.accelerometer_offset[0]; calibration.accelerometer[1].offset = spi_calibration.accelerometer_offset[1]; calibration.accelerometer[2].offset = spi_calibration.accelerometer_offset[2]; @@ -127,8 +130,8 @@ DriverResult CalibrationProtocol::GetImuCalibration(MotionCalibration& calibrati return result; } -DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibration, - s16 current_value) { +Common::Input::DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibration, + s16 current_value) { constexpr s16 DefaultRingRange{800}; // TODO: Get default calibration form ring itself @@ -144,15 +147,15 @@ DriverResult CalibrationProtocol::GetRingCalibration(RingCalibration& calibratio .max_value = ring_data_max, .min_value = ring_data_min, }; - return DriverResult::Success; + return Common::Input::DriverResult::Success; } -DriverResult CalibrationProtocol::HasUserCalibration(SpiAddress address, - bool& has_user_calibration) { +Common::Input::DriverResult CalibrationProtocol::HasUserCalibration(SpiAddress address, + bool& has_user_calibration) { MagicSpiCalibration spi_magic{}; - const DriverResult result{ReadSPI(address, spi_magic)}; + const Common::Input::DriverResult result{ReadSPI(address, spi_magic)}; has_user_calibration = false; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { has_user_calibration = spi_magic.first == CalibrationMagic::USR_MAGIC_0 && spi_magic.second == CalibrationMagic::USR_MAGIC_1; } diff --git a/src/input_common/helpers/joycon_protocol/calibration.h b/src/input_common/helpers/joycon_protocol/calibration.h index c6fd0f729..82d94b366 100644 --- a/src/input_common/helpers/joycon_protocol/calibration.h +++ b/src/input_common/helpers/joycon_protocol/calibration.h @@ -12,8 +12,11 @@ #include "input_common/helpers/joycon_protocol/common_protocol.h" -namespace InputCommon::Joycon { +namespace Common::Input { enum class DriverResult; +} + +namespace InputCommon::Joycon { struct JoyStickCalibration; struct IMUCalibration; struct JoyconHandle; @@ -31,30 +34,30 @@ public: * @param is_factory_calibration if true factory values will be returned * @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 * @param is_factory_calibration if true factory values will be returned * @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 * @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 * @returns RingCalibration of the ring sensor */ - DriverResult GetRingCalibration(RingCalibration& calibration, s16 current_value); + Common::Input::DriverResult GetRingCalibration(RingCalibration& calibration, s16 current_value); private: /// 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 u16 GetXAxisCalibrationValue(std::span<u8> block) const; diff --git a/src/input_common/helpers/joycon_protocol/common_protocol.cpp b/src/input_common/helpers/joycon_protocol/common_protocol.cpp index 51669261a..a6eecf980 100644 --- a/src/input_common/helpers/joycon_protocol/common_protocol.cpp +++ b/src/input_common/helpers/joycon_protocol/common_protocol.cpp @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "common/input.h" #include "common/logging/log.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); } -DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type) { +Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& 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 if (controller_type == ControllerType::None) { controller_type = ControllerType::Pro; @@ -34,12 +35,13 @@ DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type 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}; const auto result = GetDeviceType(controller_type); - if (result != DriverResult::Success || controller_type == ControllerType::None) { - return DriverResult::UnsupportedControllerType; + if (result != Common::Input::DriverResult::Success || controller_type == ControllerType::None) { + return Common::Input::DriverResult::UnsupportedControllerType; } hidapi_handle->handle = @@ -48,32 +50,32 @@ DriverResult JoyconCommonProtocol::CheckDeviceAccess(SDL_hid_device_info* device if (!hidapi_handle->handle) { LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.", device_info->vendor_id, device_info->product_id); - return DriverResult::HandleInUse; + return Common::Input::DriverResult::HandleInUse; } 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)}; 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()); if (result == -1) { - return DriverResult::ErrorWritingData; + return Common::Input::DriverResult::ErrorWritingData; } - return DriverResult::Success; + return Common::Input::DriverResult::Success; } -DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubCommand sc, - SubCommandResponse& output) { +Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse( + SubCommand sc, SubCommandResponse& output) { constexpr int timeout_mili = 66; - constexpr int MaxTries = 15; + constexpr int MaxTries = 10; int tries = 0; do { @@ -84,16 +86,17 @@ DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubCommand sc, LOG_ERROR(Input, "No response from joycon"); } if (tries++ > MaxTries) { - return DriverResult::Timeout; + return Common::Input::DriverResult::Timeout; } } while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY && output.sub_command != sc); - return DriverResult::Success; + return Common::Input::DriverResult::Success; } -DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, std::span<const u8> buffer, - SubCommandResponse& output) { +Common::Input::DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, + std::span<const u8> buffer, + SubCommandResponse& output) { SubCommandPacket packet{ .output_report = OutputReport::RUMBLE_AND_SUBCMD, .packet_counter = GetCounter(), @@ -102,28 +105,28 @@ DriverResult JoyconCommonProtocol::SendSubCommand(SubCommand sc, std::span<const }; if (buffer.size() > packet.command_data.size()) { - return DriverResult::InvalidParameters; + return Common::Input::DriverResult::InvalidParameters; } memcpy(packet.command_data.data(), buffer.data(), buffer.size()); auto result = SendData(packet); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } - result = GetSubCommandResponse(sc, output); - - return DriverResult::Success; + 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{}; 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{ .output_report = OutputReport::MCU_DATA, .packet_counter = GetCounter(), @@ -132,7 +135,7 @@ DriverResult JoyconCommonProtocol::SendMCUCommand(SubCommand sc, std::span<const }; if (buffer.size() > packet.command_data.size()) { - return DriverResult::InvalidParameters; + return Common::Input::DriverResult::InvalidParameters; } memcpy(packet.command_data.data(), buffer.data(), buffer.size()); @@ -140,7 +143,7 @@ DriverResult JoyconCommonProtocol::SendMCUCommand(SubCommand sc, std::span<const return SendData(packet); } -DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffer) { +Common::Input::DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffer) { VibrationPacket packet{ .output_report = OutputReport::RUMBLE_ONLY, .packet_counter = GetCounter(), @@ -148,7 +151,7 @@ DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffe }; if (buffer.size() > packet.vibration_data.size()) { - return DriverResult::InvalidParameters; + return Common::Input::DriverResult::InvalidParameters; } memcpy(packet.vibration_data.data(), buffer.data(), buffer.size()); @@ -156,9 +159,10 @@ DriverResult JoyconCommonProtocol::SendVibrationReport(std::span<const u8> buffe 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 MaxTries = 10; + constexpr std::size_t MaxTries = 5; std::size_t tries = 0; SubCommandResponse response{}; std::array<u8, sizeof(ReadSpiPacket)> buffer{}; @@ -170,36 +174,36 @@ DriverResult JoyconCommonProtocol::ReadRawSPI(SpiAddress addr, std::span<u8> out memcpy(buffer.data(), &packet_data, sizeof(ReadSpiPacket)); do { const auto result = SendSubCommand(SubCommand::SPI_FLASH_READ, buffer, response); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if (tries++ > MaxTries) { - return DriverResult::Timeout; + return Common::Input::DriverResult::Timeout; } } while (response.spi_address != addr); if (response.command_data.size() < packet_data.size + HeaderSize) { - return DriverResult::WrongReply; + return Common::Input::DriverResult::WrongReply; } // Remove header from output 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 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); } return result; } -DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig& config) { +Common::Input::DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig& config) { LOG_DEBUG(Input, "ConfigureMCU"); std::array<u8, sizeof(MCUConfig)> config_buffer; memcpy(config_buffer.data(), &config, sizeof(MCUConfig)); @@ -207,15 +211,15 @@ DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig& config) { 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); } return result; } -DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode, - MCUCommandResponse& output) { +Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode, + MCUCommandResponse& output) { constexpr int TimeoutMili = 200; constexpr int MaxTries = 9; int tries = 0; @@ -228,17 +232,18 @@ DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode, LOG_ERROR(Input, "No response from joycon attempt {}", tries); } if (tries++ > MaxTries) { - return DriverResult::Timeout; + return Common::Input::DriverResult::Timeout; } } while (output.input_report.report_mode != report_mode || output.mcu_report == MCUReport::EmptyAwaitingCmd); - return DriverResult::Success; + return Common::Input::DriverResult::Success; } -DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode, MCUSubCommand sc, - std::span<const u8> buffer, - MCUCommandResponse& output) { +Common::Input::DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode, + MCUSubCommand sc, + std::span<const u8> buffer, + MCUCommandResponse& output) { SubCommandPacket packet{ .output_report = OutputReport::MCU_DATA, .packet_counter = GetCounter(), @@ -247,23 +252,24 @@ DriverResult JoyconCommonProtocol::SendMCUData(ReportMode report_mode, MCUSubCom }; if (buffer.size() > packet.command_data.size()) { - return DriverResult::InvalidParameters; + return Common::Input::DriverResult::InvalidParameters; } memcpy(packet.command_data.data(), buffer.data(), buffer.size()); auto result = SendData(packet); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } 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{}; constexpr std::size_t MaxTries{16}; std::size_t tries{}; @@ -271,17 +277,17 @@ DriverResult JoyconCommonProtocol::WaitSetMCUMode(ReportMode report_mode, MCUMod do { const auto result = SendMCUData(report_mode, MCUSubCommand::SetDeviceMode, {}, output); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if (tries++ > MaxTries) { - return DriverResult::WrongReply; + return Common::Input::DriverResult::WrongReply; } } while (output.mcu_report != MCUReport::StateReport || output.mcu_data[6] != static_cast<u8>(mode)); - return DriverResult::Success; + return Common::Input::DriverResult::Success; } // crc-8-ccitt / polynomial 0x07 look up table diff --git a/src/input_common/helpers/joycon_protocol/common_protocol.h b/src/input_common/helpers/joycon_protocol/common_protocol.h index 411ec018a..dd667ca2b 100644 --- a/src/input_common/helpers/joycon_protocol/common_protocol.h +++ b/src/input_common/helpers/joycon_protocol/common_protocol.h @@ -38,30 +38,30 @@ public: * Sends a request to obtain the joycon type from device * @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 * @param device info from the driver * @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 * @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 * @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> 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::memcpy(buffer.data(), &output, sizeof(Output)); return SendRawData(buffer); @@ -72,7 +72,8 @@ public: * @param sub_command type of data to be returned * @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 @@ -80,35 +81,35 @@ public: * @param buffer data to be send * @returns output buffer containing the response */ - DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer, - SubCommandResponse& output); + Common::Input::DriverResult SendSubCommand(SubCommand sc, std::span<const u8> buffer, + SubCommandResponse& 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); + Common::Input::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); + Common::Input::DriverResult SendMCUCommand(SubCommand sc, std::span<const u8> buffer); /** * Sends vibration data to the joycon * @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 * @param Initial address location * @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 @@ -117,37 +118,38 @@ public: */ template <typename 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; output = {}; const auto result = ReadRawSPI(addr, buffer); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } std::memcpy(&output, buffer.data(), sizeof(Output)); - return DriverResult::Success; + return Common::Input::DriverResult::Success; } /** * Enables MCU chip on the joycon * @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 * @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 * @param report mode of the expected reply * @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 @@ -156,15 +158,15 @@ public: * @param buffer data to be send * @returns output buffer containing the response */ - DriverResult SendMCUData(ReportMode report_mode, MCUSubCommand sc, std::span<const u8> buffer, - MCUCommandResponse& output); + Common::Input::DriverResult SendMCUData(ReportMode report_mode, MCUSubCommand sc, + std::span<const u8> buffer, MCUCommandResponse& output); /** * Wait's until the MCU chip is on the specified mode * @param report mode of the expected reply * @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 diff --git a/src/input_common/helpers/joycon_protocol/generic_functions.cpp b/src/input_common/helpers/joycon_protocol/generic_functions.cpp index 548a4b9e3..e9a056448 100644 --- a/src/input_common/helpers/joycon_protocol/generic_functions.cpp +++ b/src/input_common/helpers/joycon_protocol/generic_functions.cpp @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "common/input.h" #include "common/logging/log.h" #include "input_common/helpers/joycon_protocol/generic_functions.h" @@ -9,73 +10,74 @@ namespace InputCommon::Joycon { GenericProtocol::GenericProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(std::move(handle)) {} -DriverResult GenericProtocol::EnablePassiveMode() { +Common::Input::DriverResult GenericProtocol::EnablePassiveMode() { ScopedSetBlocking sb(this); return SetReportMode(ReportMode::SIMPLE_HID_MODE); } -DriverResult GenericProtocol::EnableActiveMode() { +Common::Input::DriverResult GenericProtocol::EnableActiveMode() { ScopedSetBlocking sb(this); return SetReportMode(ReportMode::STANDARD_FULL_60HZ); } -DriverResult GenericProtocol::SetLowPowerMode(bool enable) { +Common::Input::DriverResult GenericProtocol::SetLowPowerMode(bool enable) { ScopedSetBlocking sb(this); const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)}; return SendSubCommand(SubCommand::LOW_POWER_MODE, buffer); } -DriverResult GenericProtocol::TriggersElapsed() { +Common::Input::DriverResult GenericProtocol::TriggersElapsed() { ScopedSetBlocking sb(this); return SendSubCommand(SubCommand::TRIGGERS_ELAPSED, {}); } -DriverResult GenericProtocol::GetDeviceInfo(DeviceInfo& device_info) { +Common::Input::DriverResult GenericProtocol::GetDeviceInfo(DeviceInfo& device_info) { ScopedSetBlocking sb(this); SubCommandResponse output{}; const auto result = SendSubCommand(SubCommand::REQ_DEV_INFO, {}, output); device_info = {}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { device_info = output.device_info; } return result; } -DriverResult GenericProtocol::GetControllerType(ControllerType& controller_type) { +Common::Input::DriverResult GenericProtocol::GetControllerType(ControllerType& controller_type) { return GetDeviceType(controller_type); } -DriverResult GenericProtocol::EnableImu(bool enable) { +Common::Input::DriverResult GenericProtocol::EnableImu(bool enable) { ScopedSetBlocking sb(this); const std::array<u8, 1> buffer{static_cast<u8>(enable ? 1 : 0)}; return SendSubCommand(SubCommand::ENABLE_IMU, buffer); } -DriverResult GenericProtocol::SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec, - AccelerometerSensitivity asen, - AccelerometerPerformance afrec) { +Common::Input::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)}; 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 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); std::array<u8, 12> buffer{}; const auto result = ReadRawSPI(SpiAddress::COLOR_DATA, buffer); 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.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]); @@ -85,26 +87,26 @@ DriverResult GenericProtocol::GetColor(Color& color) { return result; } -DriverResult GenericProtocol::GetSerialNumber(SerialNumber& serial_number) { +Common::Input::DriverResult GenericProtocol::GetSerialNumber(SerialNumber& serial_number) { ScopedSetBlocking sb(this); std::array<u8, 16> buffer{}; const auto result = ReadRawSPI(SpiAddress::SERIAL_NUMBER, buffer); serial_number = {}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { memcpy(serial_number.data(), buffer.data() + 1, sizeof(SerialNumber)); } return result; } -DriverResult GenericProtocol::GetTemperature(u32& temperature) { +Common::Input::DriverResult GenericProtocol::GetTemperature(u32& temperature) { // Not all devices have temperature sensor 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{}; const auto result = GetDeviceInfo(device_info); @@ -113,23 +115,23 @@ DriverResult GenericProtocol::GetVersionNumber(FirmwareVersion& version) { return result; } -DriverResult GenericProtocol::SetHomeLight() { +Common::Input::DriverResult GenericProtocol::SetHomeLight() { ScopedSetBlocking sb(this); static constexpr std::array<u8, 3> buffer{0x0f, 0xf0, 0x00}; return SendSubCommand(SubCommand::SET_HOME_LIGHT, buffer); } -DriverResult GenericProtocol::SetLedBusy() { - return DriverResult::NotSupported; +Common::Input::DriverResult GenericProtocol::SetLedBusy() { + return Common::Input::DriverResult::NotSupported; } -DriverResult GenericProtocol::SetLedPattern(u8 leds) { +Common::Input::DriverResult GenericProtocol::SetLedPattern(u8 leds) { ScopedSetBlocking sb(this); const std::array<u8, 1> buffer{leds}; 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)); } diff --git a/src/input_common/helpers/joycon_protocol/generic_functions.h b/src/input_common/helpers/joycon_protocol/generic_functions.h index 424831e81..90fcd17f6 100644 --- a/src/input_common/helpers/joycon_protocol/generic_functions.h +++ b/src/input_common/helpers/joycon_protocol/generic_functions.h @@ -11,6 +11,10 @@ #include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/joycon_types.h" +namespace Common::Input { +enum class DriverResult; +} + namespace InputCommon::Joycon { /// 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 /// 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 - DriverResult EnableActiveMode(); + Common::Input::DriverResult EnableActiveMode(); /// Enables or disables the low power mode - DriverResult SetLowPowerMode(bool enable); + Common::Input::DriverResult SetLowPowerMode(bool enable); /// Unknown function used by the switch - DriverResult TriggersElapsed(); + Common::Input::DriverResult TriggersElapsed(); /** * Sends a request to obtain the joycon firmware and mac from handle * @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 * @returns controller type of the joycon */ - DriverResult GetControllerType(ControllerType& controller_type); + Common::Input::DriverResult GetControllerType(ControllerType& controller_type); /** * Enables motion input * @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 @@ -56,59 +60,60 @@ public: * @param asen accelerometer sensitivity in G force * @param afrec accelerometer frequency in hertz */ - DriverResult SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec, - AccelerometerSensitivity asen, AccelerometerPerformance afrec); + Common::Input::DriverResult SetImuConfig(GyroSensitivity gsen, GyroPerformance gfrec, + AccelerometerSensitivity asen, + AccelerometerPerformance afrec); /** * Request battery level from the device * @returns battery level */ - DriverResult GetBattery(u32& battery_level); + Common::Input::DriverResult GetBattery(u32& battery_level); /** * Request joycon colors from the device * @returns colors of the body and buttons */ - DriverResult GetColor(Color& color); + Common::Input::DriverResult GetColor(Color& color); /** * Request joycon serial number from the device * @returns 16 byte serial number */ - DriverResult GetSerialNumber(SerialNumber& serial_number); + Common::Input::DriverResult GetSerialNumber(SerialNumber& serial_number); /** * Request joycon serial number from the device * @returns 16 byte serial number */ - DriverResult GetTemperature(u32& temperature); + Common::Input::DriverResult GetTemperature(u32& temperature); /** * Request joycon serial number from the device * @returns 16 byte serial number */ - DriverResult GetVersionNumber(FirmwareVersion& version); + Common::Input::DriverResult GetVersionNumber(FirmwareVersion& version); /** * Sets home led behaviour */ - DriverResult SetHomeLight(); + Common::Input::DriverResult SetHomeLight(); /** * 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 * @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 * @returns bit flag containing the led state */ - DriverResult SetLedBlinkPattern(u8 leds); + Common::Input::DriverResult SetLedBlinkPattern(u8 leds); }; } // namespace InputCommon::Joycon diff --git a/src/input_common/helpers/joycon_protocol/irs.cpp b/src/input_common/helpers/joycon_protocol/irs.cpp index 731fd5981..68b0589e3 100644 --- a/src/input_common/helpers/joycon_protocol/irs.cpp +++ b/src/input_common/helpers/joycon_protocol/irs.cpp @@ -1,7 +1,7 @@ // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <thread> +#include "common/input.h" #include "common/logging/log.h" #include "input_common/helpers/joycon_protocol/irs.h" @@ -10,21 +10,21 @@ namespace InputCommon::Joycon { IrsProtocol::IrsProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(std::move(handle)) {} -DriverResult IrsProtocol::EnableIrs() { +Common::Input::DriverResult IrsProtocol::EnableIrs() { LOG_INFO(Input, "Enable IRS"); 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); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = EnableMCU(true); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::Standby); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { const MCUConfig config{ .command = MCUCommand::ConfigureMCU, .sub_command = MCUSubCommand::SetMCUMode, @@ -34,16 +34,16 @@ DriverResult IrsProtocol::EnableIrs() { result = ConfigureMCU(config); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::IR); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = ConfigureIrs(); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WriteRegistersStep1(); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WriteRegistersStep2(); } @@ -52,12 +52,12 @@ DriverResult IrsProtocol::EnableIrs() { return result; } -DriverResult IrsProtocol::DisableIrs() { +Common::Input::DriverResult IrsProtocol::DisableIrs() { LOG_DEBUG(Input, "Disable IRS"); 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); } @@ -66,7 +66,7 @@ DriverResult IrsProtocol::DisableIrs() { return result; } -DriverResult IrsProtocol::SetIrsConfig(IrsMode mode, IrsResolution format) { +Common::Input::DriverResult IrsProtocol::SetIrsConfig(IrsMode mode, IrsResolution format) { irs_mode = mode; switch (format) { case IrsResolution::Size320x240: @@ -103,10 +103,10 @@ DriverResult IrsProtocol::SetIrsConfig(IrsMode mode, IrsResolution format) { 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 = 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); } -DriverResult IrsProtocol::ConfigureIrs() { +Common::Input::DriverResult IrsProtocol::ConfigureIrs() { LOG_DEBUG(Input, "Configure IRS"); constexpr std::size_t max_tries = 28; SubCommandResponse output{}; @@ -152,20 +152,20 @@ DriverResult IrsProtocol::ConfigureIrs() { do { const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if (tries++ >= max_tries) { - return DriverResult::WrongReply; + return Common::Input::DriverResult::WrongReply; } } 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"); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; constexpr std::size_t max_tries = 28; SubCommandResponse output{}; std::size_t tries = 0; @@ -197,7 +197,7 @@ DriverResult IrsProtocol::WriteRegistersStep1() { mcu_request[36] = CalculateMCU_CRC8(mcu_request.data(), 36); mcu_request[37] = 0xFF; - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } @@ -205,26 +205,26 @@ DriverResult IrsProtocol::WriteRegistersStep1() { result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output); // 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); } - if (result == DriverResult::Success && tries == 0) { + if (result == Common::Input::DriverResult::Success && tries == 0) { GetSubCommandResponse(SubCommand::SET_MCU_CONFIG, output); } - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if (tries++ >= max_tries) { - return DriverResult::WrongReply; + return Common::Input::DriverResult::WrongReply; } } while (!(output.command_data[0] == 0x13 && output.command_data[2] == 0x07) && 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"); constexpr std::size_t max_tries = 28; SubCommandResponse output{}; @@ -255,18 +255,18 @@ DriverResult IrsProtocol::WriteRegistersStep2() { do { const auto result = SendSubCommand(SubCommand::SET_MCU_CONFIG, request_data, output); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if (tries++ >= max_tries) { - return DriverResult::WrongReply; + return Common::Input::DriverResult::WrongReply; } } 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{}; mcu_request[3] = frame; 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); } -DriverResult IrsProtocol::ResendFrame(u8 frame) { +Common::Input::DriverResult IrsProtocol::ResendFrame(u8 frame) { std::array<u8, 38> mcu_request{}; mcu_request[1] = 0x1; mcu_request[2] = frame; diff --git a/src/input_common/helpers/joycon_protocol/irs.h b/src/input_common/helpers/joycon_protocol/irs.h index 76dfa02ea..714cbb6b2 100644 --- a/src/input_common/helpers/joycon_protocol/irs.h +++ b/src/input_common/helpers/joycon_protocol/irs.h @@ -13,19 +13,23 @@ #include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/joycon_types.h" +namespace Common::Input { +enum class DriverResult; +} + namespace InputCommon::Joycon { class IrsProtocol final : private JoyconCommonProtocol { public: 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; @@ -34,13 +38,13 @@ public: bool IsEnabled() const; private: - DriverResult ConfigureIrs(); + Common::Input::DriverResult ConfigureIrs(); - DriverResult WriteRegistersStep1(); - DriverResult WriteRegistersStep2(); + Common::Input::DriverResult WriteRegistersStep1(); + Common::Input::DriverResult WriteRegistersStep2(); - DriverResult RequestFrame(u8 frame); - DriverResult ResendFrame(u8 frame); + Common::Input::DriverResult RequestFrame(u8 frame); + Common::Input::DriverResult ResendFrame(u8 frame); IrsMode irs_mode{IrsMode::ImageTransfer}; IrsResolution resolution{IrsResolution::Size40x30}; diff --git a/src/input_common/helpers/joycon_protocol/joycon_types.h b/src/input_common/helpers/joycon_protocol/joycon_types.h index 5007b0e18..77a43c67a 100644 --- a/src/input_common/helpers/joycon_protocol/joycon_types.h +++ b/src/input_common/helpers/joycon_protocol/joycon_types.h @@ -24,6 +24,7 @@ constexpr std::array<u8, 8> DefaultVibrationBuffer{0x0, 0x1, 0x40, 0x40, 0x0, 0x using MacAddress = std::array<u8, 6>; using SerialNumber = std::array<u8, 15>; using TagUUID = std::array<u8, 7>; +using MifareUUID = std::array<u8, 4>; enum class ControllerType : u8 { None = 0x00, @@ -307,6 +308,19 @@ enum class NFCStatus : u8 { WriteDone = 0x05, TagLost = 0x07, WriteReady = 0x09, + MifareDone = 0x10, +}; + +enum class MifareCmd : u8 { + None = 0x00, + Read = 0x30, + AuthA = 0x60, + AuthB = 0x61, + Write = 0xA0, + Transfer = 0xB0, + Decrement = 0xC0, + Increment = 0xC1, + Store = 0xC2 }; enum class IrsMode : u8 { @@ -388,23 +402,6 @@ enum class ExternalDeviceId : u16 { Starlink = 0x2800, }; -enum class DriverResult { - Success, - WrongReply, - Timeout, - InvalidParameters, - UnsupportedControllerType, - HandleInUse, - ErrorReadingData, - ErrorWritingData, - NoDeviceDetected, - InvalidHandle, - NotSupported, - Disabled, - Delayed, - Unknown, -}; - struct MotionSensorCalibration { s16 offset; s16 scale; @@ -592,6 +589,14 @@ struct NFCWriteCommandData { static_assert(sizeof(NFCWriteCommandData) == 0x15, "NFCWriteCommandData is an invalid size"); #pragma pack(pop) +struct MifareCommandData { + u8 unknown1; + u8 unknown2; + u8 number_of_short_bytes; + MifareUUID uid; +}; +static_assert(sizeof(MifareCommandData) == 0x7, "MifareCommandData is an invalid size"); + struct NFCPollingCommandData { u8 enable_mifare; u8 unknown_1; @@ -629,6 +634,41 @@ struct NFCWritePackage { std::array<NFCDataChunk, 4> data_chunks; }; +struct MifareReadChunk { + MifareCmd command; + std::array<u8, 0x6> sector_key; + u8 sector; +}; + +struct MifareWriteChunk { + MifareCmd command; + std::array<u8, 0x6> sector_key; + u8 sector; + std::array<u8, 0x10> data; +}; + +struct MifareReadData { + u8 sector; + std::array<u8, 0x10> data; +}; + +struct MifareReadPackage { + MifareCommandData command_data; + std::array<MifareReadChunk, 0x10> data_chunks; +}; + +struct MifareWritePackage { + MifareCommandData command_data; + std::array<MifareWriteChunk, 0x10> data_chunks; +}; + +struct TagInfo { + u8 uuid_length; + u8 protocol; + u8 tag_type; + std::array<u8, 10> uuid; +}; + struct IrsConfigure { MCUCommand command; MCUSubCommand sub_command; @@ -744,7 +784,7 @@ struct JoyconCallbacks { std::function<void(int, f32)> on_stick_data; std::function<void(int, const MotionData&)> on_motion_data; std::function<void(f32)> on_ring_data; - std::function<void(const std::vector<u8>&)> on_amiibo_data; + std::function<void(const Joycon::TagInfo&)> on_amiibo_data; std::function<void(const std::vector<u8>&, IrsResolution)> on_camera_data; }; diff --git a/src/input_common/helpers/joycon_protocol/nfc.cpp b/src/input_common/helpers/joycon_protocol/nfc.cpp index f7058c4a7..09953394b 100644 --- a/src/input_common/helpers/joycon_protocol/nfc.cpp +++ b/src/input_common/helpers/joycon_protocol/nfc.cpp @@ -1,7 +1,7 @@ // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#include <thread> +#include "common/input.h" #include "common/logging/log.h" #include "input_common/helpers/joycon_protocol/nfc.h" @@ -10,21 +10,21 @@ namespace InputCommon::Joycon { NfcProtocol::NfcProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(std::move(handle)) {} -DriverResult NfcProtocol::EnableNfc() { +Common::Input::DriverResult NfcProtocol::EnableNfc() { LOG_INFO(Input, "Enable NFC"); 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); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = EnableMCU(true); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::Standby); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { const MCUConfig config{ .command = MCUCommand::ConfigureMCU, .sub_command = MCUSubCommand::SetMCUMode, @@ -34,123 +34,240 @@ DriverResult NfcProtocol::EnableNfc() { result = ConfigureMCU(config); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::NFC); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitUntilNfcIs(NFCStatus::Ready); } + if (result == Common::Input::DriverResult::Success) { + MCUCommandResponse output{}; + result = SendStopPollingRequest(output); + } + if (result == Common::Input::DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::Ready); + } + if (result == Common::Input::DriverResult::Success) { + is_enabled = true; + } return result; } -DriverResult NfcProtocol::DisableNfc() { +Common::Input::DriverResult NfcProtocol::DisableNfc() { LOG_DEBUG(Input, "Disable NFC"); 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); } is_enabled = false; + is_polling = false; return result; } -DriverResult NfcProtocol::StartNFCPollingMode() { - LOG_DEBUG(Input, "Start NFC pooling Mode"); +Common::Input::DriverResult NfcProtocol::StartNFCPollingMode() { + LOG_DEBUG(Input, "Start NFC polling Mode"); 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{}; - result = SendStopPollingRequest(output); + result = SendStartPollingRequest(output); } - if (result == DriverResult::Success) { - result = WaitUntilNfcIs(NFCStatus::Ready); + if (result == Common::Input::DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::Polling); + } + if (result == Common::Input::DriverResult::Success) { + is_polling = true; } - if (result == DriverResult::Success) { + + return result; +} + +Common::Input::DriverResult NfcProtocol::StopNFCPollingMode() { + LOG_DEBUG(Input, "Stop NFC polling Mode"); + ScopedSetBlocking sb(this); + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; + + if (result == Common::Input::DriverResult::Success) { MCUCommandResponse output{}; - result = SendStartPollingRequest(output); + result = SendStopPollingRequest(output); } - if (result == DriverResult::Success) { - result = WaitUntilNfcIs(NFCStatus::Polling); + if (result == Common::Input::DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::WriteReady); } - if (result == DriverResult::Success) { - is_enabled = true; + if (result == Common::Input::DriverResult::Success) { + is_polling = false; } return result; } -DriverResult NfcProtocol::ScanAmiibo(std::vector<u8>& data) { +Common::Input::DriverResult NfcProtocol::GetTagInfo(Joycon::TagInfo& tag_info) { if (update_counter++ < AMIIBO_UPDATE_DELAY) { - return DriverResult::Delayed; + return Common::Input::DriverResult::Delayed; } update_counter = 0; LOG_DEBUG(Input, "Scan for amiibos"); ScopedSetBlocking sb(this); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; TagFoundData tag_data{}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = IsTagInRange(tag_data); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { + tag_info = { + .uuid_length = tag_data.uuid_size, + .protocol = 1, + .tag_type = tag_data.type, + .uuid = {}, + }; + + memcpy(tag_info.uuid.data(), tag_data.uuid.data(), tag_data.uuid_size); + + // Investigate why mifare type is not correct + if (tag_info.tag_type == 144) { + tag_info.tag_type = 1U << 6; + } + std::string uuid_string; for (auto& content : tag_data.uuid) { uuid_string += fmt::format(" {:02x}", content); } LOG_INFO(Input, "Tag detected, type={}, uuid={}", tag_data.type, uuid_string); + } + + return result; +} + +Common::Input::DriverResult NfcProtocol::ReadAmiibo(std::vector<u8>& data) { + LOG_DEBUG(Input, "Scan for amiibos"); + ScopedSetBlocking sb(this); + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; + TagFoundData tag_data{}; + + if (result == Common::Input::DriverResult::Success) { + result = IsTagInRange(tag_data, 7); + } + + if (result == Common::Input::DriverResult::Success) { result = GetAmiiboData(data); } 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"); ScopedSetBlocking sb(this); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; TagUUID tag_uuid = GetTagUUID(data); TagFoundData tag_data{}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = IsTagInRange(tag_data, 7); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { 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{}; result = SendStopPollingRequest(output); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitUntilNfcIs(NFCStatus::Ready); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { MCUCommandResponse output{}; result = SendStartPollingRequest(output, true); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitUntilNfcIs(NFCStatus::WriteReady); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WriteAmiiboData(tag_uuid, data); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = WaitUntilNfcIs(NFCStatus::WriteDone); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { + MCUCommandResponse output{}; + result = SendStopPollingRequest(output); + } + + return result; +} + +Common::Input::DriverResult NfcProtocol::ReadMifare(std::span<const MifareReadChunk> read_request, + std::span<MifareReadData> out_data) { + LOG_DEBUG(Input, "Read mifare"); + ScopedSetBlocking sb(this); + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; + TagFoundData tag_data{}; + MifareUUID tag_uuid{}; + + if (result == Common::Input::DriverResult::Success) { + result = IsTagInRange(tag_data, 7); + } + if (result == Common::Input::DriverResult::Success) { + memcpy(tag_uuid.data(), tag_data.uuid.data(), sizeof(MifareUUID)); + result = GetMifareData(tag_uuid, read_request, out_data); + } + if (result == Common::Input::DriverResult::Success) { MCUCommandResponse output{}; result = SendStopPollingRequest(output); } + if (result == Common::Input::DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::Ready); + } + if (result == Common::Input::DriverResult::Success) { + MCUCommandResponse output{}; + result = SendStartPollingRequest(output, true); + } + if (result == Common::Input::DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::WriteReady); + } + return result; +} + +Common::Input::DriverResult NfcProtocol::WriteMifare( + std::span<const MifareWriteChunk> write_request) { + LOG_DEBUG(Input, "Write mifare"); + ScopedSetBlocking sb(this); + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; + TagFoundData tag_data{}; + MifareUUID tag_uuid{}; + if (result == Common::Input::DriverResult::Success) { + result = IsTagInRange(tag_data, 7); + } + if (result == Common::Input::DriverResult::Success) { + memcpy(tag_uuid.data(), tag_data.uuid.data(), sizeof(MifareUUID)); + result = WriteMifareData(tag_uuid, write_request); + } + if (result == Common::Input::DriverResult::Success) { + MCUCommandResponse output{}; + result = SendStopPollingRequest(output); + } + if (result == Common::Input::DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::Ready); + } + if (result == Common::Input::DriverResult::Success) { + MCUCommandResponse output{}; + result = SendStartPollingRequest(output, true); + } + if (result == Common::Input::DriverResult::Success) { + result = WaitUntilNfcIs(NFCStatus::WriteReady); + } return result; } @@ -161,17 +278,17 @@ bool NfcProtocol::HasAmiibo() { update_counter = 0; ScopedSetBlocking sb(this); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; TagFoundData tag_data{}; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { 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; MCUCommandResponse output{}; std::size_t tries = 0; @@ -179,30 +296,31 @@ DriverResult NfcProtocol::WaitUntilNfcIs(NFCStatus status) { do { auto result = SendNextPackageRequest(output, {}); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if (tries++ > timeout_limit) { - return DriverResult::Timeout; + return Common::Input::DriverResult::Timeout; } } while (output.mcu_report != MCUReport::NFCState || (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 || 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{}; std::size_t tries = 0; do { const auto result = SendNextPackageRequest(output, {}); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if (tries++ > timeout_limit) { - return DriverResult::Timeout; + return Common::Input::DriverResult::Timeout; } } while (output.mcu_report != MCUReport::NFCState || (output.mcu_data[1] << 8) + output.mcu_data[0] != 0x0500 || @@ -212,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))); 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; MCUCommandResponse output{}; std::size_t tries = 0; @@ -224,7 +342,7 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) { std::size_t ntag_buffer_pos = 0; auto result = SendReadAmiiboRequest(output, NFCPages::Block135); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } @@ -233,14 +351,14 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) { result = SendNextPackageRequest(output, package_index); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if ((output.mcu_report == MCUReport::NFCReadData || output.mcu_report == MCUReport::NFCState) && nfc_status == NFCStatus::TagLost) { - return DriverResult::ErrorReadingData; + return Common::Input::DriverResult::ErrorReadingData; } if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) { @@ -259,14 +377,15 @@ DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) { if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::LastPackage) { 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; const auto nfc_data = MakeAmiiboWritePackage(tag_uuid, data); const std::vector<u8> nfc_buffer_data = SerializeWritePackage(nfc_data); @@ -281,7 +400,7 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con auto result = SendWriteAmiiboRequest(output, tag_uuid); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } @@ -290,14 +409,14 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con result = SendNextPackageRequest(output, package_index); const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success) { return result; } if ((output.mcu_report == MCUReport::NFCReadData || output.mcu_report == MCUReport::NFCState) && nfc_status == NFCStatus::TagLost) { - return DriverResult::ErrorReadingData; + return Common::Input::DriverResult::ErrorReadingData; } if (output.mcu_report == MCUReport::NFCReadData && output.mcu_data[1] == 0x07) { @@ -326,7 +445,131 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con if ((output.mcu_report == MCUReport::NFCReadData || 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 + if (output.mcu_report == MCUReport::NFCState && + (output.mcu_data[1] << 8) + output.mcu_data[0] == 0x0500 && + output.mcu_data[3] == block_id) { + block_id++; + current_position = next_position; + } + } + + return result; +} + +Common::Input::DriverResult NfcProtocol::GetMifareData( + const MifareUUID& tag_uuid, std::span<const MifareReadChunk> read_request, + std::span<MifareReadData> out_data) { + constexpr std::size_t timeout_limit = 60; + const auto nfc_data = MakeMifareReadPackage(tag_uuid, read_request); + const std::vector<u8> nfc_buffer_data = SerializeMifareReadPackage(nfc_data); + std::span<const u8> buffer(nfc_buffer_data); + Common::Input::DriverResult result = Common::Input::DriverResult::Success; + MCUCommandResponse output{}; + u8 block_id = 1; + u8 package_index = 0; + std::size_t tries = 0; + std::size_t current_position = 0; + + LOG_INFO(Input, "Reading Mifare data"); + + // Send data request. Nfc buffer size is 31, Send the data in smaller packages + while (current_position < buffer.size() && tries++ < timeout_limit) { + const std::size_t next_position = + std::min(current_position + sizeof(NFCRequestState::raw_data), buffer.size()); + const std::size_t block_size = next_position - current_position; + const bool is_last_packet = block_size < sizeof(NFCRequestState::raw_data); + + SendReadDataMifareRequest(output, block_id, is_last_packet, + buffer.subspan(current_position, block_size)); + + const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); + + if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { + return Common::Input::DriverResult::ErrorReadingData; + } + + // Increase position when data is confirmed by the joycon + if (output.mcu_report == MCUReport::NFCState && + (output.mcu_data[1] << 8) + output.mcu_data[0] == 0x0500 && + output.mcu_data[3] == block_id) { + block_id++; + current_position = next_position; + } + } + + if (result != Common::Input::DriverResult::Success) { + return result; + } + + // Wait for reply and save the output data + while (tries++ < timeout_limit) { + result = SendNextPackageRequest(output, package_index); + const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); + + if (result != Common::Input::DriverResult::Success) { + return result; + } + + if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { + return Common::Input::DriverResult::ErrorReadingData; + } + + if (output.mcu_report == MCUReport::NFCState && output.mcu_data[1] == 0x10) { + constexpr std::size_t DATA_LENGHT = 0x10 + 1; + constexpr std::size_t DATA_START = 11; + const u8 number_of_elements = output.mcu_data[10]; + for (std::size_t i = 0; i < number_of_elements; i++) { + out_data[i].sector = output.mcu_data[DATA_START + (i * DATA_LENGHT)]; + memcpy(out_data[i].data.data(), + output.mcu_data.data() + DATA_START + 1 + (i * DATA_LENGHT), + sizeof(MifareReadData::data)); + } + package_index++; + continue; + } + + if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::MifareDone) { + LOG_INFO(Input, "Finished reading mifare"); + break; + } + } + + return result; +} + +Common::Input::DriverResult NfcProtocol::WriteMifareData( + const MifareUUID& tag_uuid, std::span<const MifareWriteChunk> write_request) { + constexpr std::size_t timeout_limit = 60; + const auto nfc_data = MakeMifareWritePackage(tag_uuid, write_request); + const std::vector<u8> nfc_buffer_data = SerializeMifareWritePackage(nfc_data); + std::span<const u8> buffer(nfc_buffer_data); + Common::Input::DriverResult result = Common::Input::DriverResult::Success; + MCUCommandResponse output{}; + u8 block_id = 1; + u8 package_index = 0; + std::size_t tries = 0; + std::size_t current_position = 0; + + LOG_INFO(Input, "Writing Mifare data"); + + // Send data request. Nfc buffer size is 31, Send the data in smaller packages + while (current_position < buffer.size() && tries++ < timeout_limit) { + const std::size_t next_position = + std::min(current_position + sizeof(NFCRequestState::raw_data), buffer.size()); + const std::size_t block_size = next_position - current_position; + const bool is_last_packet = block_size < sizeof(NFCRequestState::raw_data); + + SendReadDataMifareRequest(output, block_id, is_last_packet, + buffer.subspan(current_position, block_size)); + + const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); + + if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { + return Common::Input::DriverResult::ErrorReadingData; } // Increase position when data is confirmed by the joycon @@ -338,11 +581,39 @@ DriverResult NfcProtocol::WriteAmiiboData(const TagUUID& tag_uuid, std::span<con } } + if (result != Common::Input::DriverResult::Success) { + return result; + } + + // Wait for reply and ignore the output data + while (tries++ < timeout_limit) { + result = SendNextPackageRequest(output, package_index); + const auto nfc_status = static_cast<NFCStatus>(output.mcu_data[6]); + + if (result != Common::Input::DriverResult::Success) { + return result; + } + + if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::TagLost) { + return Common::Input::DriverResult::ErrorReadingData; + } + + if (output.mcu_report == MCUReport::NFCState && output.mcu_data[1] == 0x10) { + package_index++; + continue; + } + + if (output.mcu_report == MCUReport::NFCState && nfc_status == NFCStatus::MifareDone) { + LOG_INFO(Input, "Finished writing mifare"); + break; + } + } + return result; } -DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output, - bool is_second_attempt) { +Common::Input::DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output, + bool is_second_attempt) { NFCRequestState request{ .command_argument = NFCCommand::StartPolling, .block_id = {}, @@ -367,7 +638,7 @@ DriverResult NfcProtocol::SendStartPollingRequest(MCUCommandResponse& output, output); } -DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) { +Common::Input::DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) { NFCRequestState request{ .command_argument = NFCCommand::StopPolling, .block_id = {}, @@ -385,7 +656,8 @@ DriverResult NfcProtocol::SendStopPollingRequest(MCUCommandResponse& output) { output); } -DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id) { +Common::Input::DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output, + u8 packet_id) { NFCRequestState request{ .command_argument = NFCCommand::StartWaitingRecieve, .block_id = {}, @@ -403,7 +675,8 @@ DriverResult NfcProtocol::SendNextPackageRequest(MCUCommandResponse& output, u8 output); } -DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output, NFCPages ntag_pages) { +Common::Input::DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output, + NFCPages ntag_pages) { NFCRequestState request{ .command_argument = NFCCommand::ReadNtag, .block_id = {}, @@ -428,8 +701,8 @@ DriverResult NfcProtocol::SendReadAmiiboRequest(MCUCommandResponse& output, NFCP output); } -DriverResult NfcProtocol::SendWriteAmiiboRequest(MCUCommandResponse& output, - const TagUUID& tag_uuid) { +Common::Input::DriverResult NfcProtocol::SendWriteAmiiboRequest(MCUCommandResponse& output, + const TagUUID& tag_uuid) { NFCRequestState request{ .command_argument = NFCCommand::ReadNtag, .block_id = {}, @@ -454,9 +727,10 @@ DriverResult NfcProtocol::SendWriteAmiiboRequest(MCUCommandResponse& output, output); } -DriverResult NfcProtocol::SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id, - bool is_last_packet, - std::span<const u8> data) { +Common::Input::DriverResult NfcProtocol::SendWriteDataAmiiboRequest(MCUCommandResponse& output, + u8 block_id, + bool is_last_packet, + std::span<const u8> data) { const auto data_size = std::min(data.size(), sizeof(NFCRequestState::raw_data)); NFCRequestState request{ .command_argument = NFCCommand::WriteNtag, @@ -477,6 +751,29 @@ DriverResult NfcProtocol::SendWriteDataAmiiboRequest(MCUCommandResponse& output, output); } +Common::Input::DriverResult NfcProtocol::SendReadDataMifareRequest(MCUCommandResponse& output, + u8 block_id, bool is_last_packet, + std::span<const u8> data) { + const auto data_size = std::min(data.size(), sizeof(NFCRequestState::raw_data)); + NFCRequestState request{ + .command_argument = NFCCommand::Mifare, + .block_id = block_id, + .packet_id = {}, + .packet_flag = + is_last_packet ? MCUPacketFlag::LastCommandPacket : MCUPacketFlag::MorePacketsRemaining, + .data_length = static_cast<u8>(data_size), + .raw_data = {}, + .crc = {}, + }; + memcpy(request.raw_data.data(), data.data(), data_size); + + std::array<u8, sizeof(NFCRequestState)> request_data{}; + memcpy(request_data.data(), &request, sizeof(NFCRequestState)); + request_data[36] = CalculateMCU_CRC8(request_data.data(), 36); + return SendMCUData(ReportMode::NFC_IR_MODE_60HZ, MCUSubCommand::ReadDeviceMode, request_data, + output); +} + std::vector<u8> NfcProtocol::SerializeWritePackage(const NFCWritePackage& package) const { const std::size_t header_size = sizeof(NFCWriteCommandData) + sizeof(NFCWritePackage::number_of_chunks); @@ -498,6 +795,48 @@ std::vector<u8> NfcProtocol::SerializeWritePackage(const NFCWritePackage& packag return serialized_data; } +std::vector<u8> NfcProtocol::SerializeMifareReadPackage(const MifareReadPackage& package) const { + const std::size_t header_size = sizeof(MifareCommandData); + std::vector<u8> serialized_data(header_size); + std::size_t start_index = 0; + + memcpy(serialized_data.data(), &package, header_size); + start_index += header_size; + + for (const auto& data_chunk : package.data_chunks) { + const std::size_t chunk_size = sizeof(MifareReadChunk); + if (data_chunk.command == MifareCmd::None) { + continue; + } + serialized_data.resize(start_index + chunk_size); + memcpy(serialized_data.data() + start_index, &data_chunk, chunk_size); + start_index += chunk_size; + } + + return serialized_data; +} + +std::vector<u8> NfcProtocol::SerializeMifareWritePackage(const MifareWritePackage& package) const { + const std::size_t header_size = sizeof(MifareCommandData); + std::vector<u8> serialized_data(header_size); + std::size_t start_index = 0; + + memcpy(serialized_data.data(), &package, header_size); + start_index += header_size; + + for (const auto& data_chunk : package.data_chunks) { + const std::size_t chunk_size = sizeof(MifareWriteChunk); + if (data_chunk.command == MifareCmd::None) { + continue; + } + serialized_data.resize(start_index + chunk_size); + memcpy(serialized_data.data() + start_index, &data_chunk, chunk_size); + start_index += chunk_size; + } + + return serialized_data; +} + NFCWritePackage NfcProtocol::MakeAmiiboWritePackage(const TagUUID& tag_uuid, std::span<const u8> data) const { return { @@ -527,6 +866,46 @@ NFCWritePackage NfcProtocol::MakeAmiiboWritePackage(const TagUUID& tag_uuid, }; } +MifareReadPackage NfcProtocol::MakeMifareReadPackage( + const MifareUUID& tag_uuid, std::span<const MifareReadChunk> read_request) const { + MifareReadPackage package{ + .command_data{ + .unknown1 = 0xd0, + .unknown2 = 0x07, + .number_of_short_bytes = static_cast<u8>( + ((read_request.size() * sizeof(MifareReadChunk)) + sizeof(MifareUUID)) / 2), + .uid = tag_uuid, + }, + .data_chunks = {}, + }; + + for (std::size_t i = 0; i < read_request.size() && i < package.data_chunks.size(); ++i) { + package.data_chunks[i] = read_request[i]; + } + + return package; +} + +MifareWritePackage NfcProtocol::MakeMifareWritePackage( + const MifareUUID& tag_uuid, std::span<const MifareWriteChunk> read_request) const { + MifareWritePackage package{ + .command_data{ + .unknown1 = 0xd0, + .unknown2 = 0x07, + .number_of_short_bytes = static_cast<u8>( + ((read_request.size() * sizeof(MifareReadChunk)) + sizeof(MifareUUID) + 2) / 2), + .uid = tag_uuid, + }, + .data_chunks = {}, + }; + + for (std::size_t i = 0; i < read_request.size() && i < package.data_chunks.size(); ++i) { + package.data_chunks[i] = read_request[i]; + } + + return package; +} + NFCDataChunk NfcProtocol::MakeAmiiboChunk(u8 page, u8 size, std::span<const u8> data) const { constexpr u8 NFC_PAGE_SIZE = 4; @@ -606,4 +985,8 @@ bool NfcProtocol::IsEnabled() const { return is_enabled; } +bool NfcProtocol::IsPolling() const { + return is_polling; +} + } // namespace InputCommon::Joycon diff --git a/src/input_common/helpers/joycon_protocol/nfc.h b/src/input_common/helpers/joycon_protocol/nfc.h index eb58c427d..22db95170 100644 --- a/src/input_common/helpers/joycon_protocol/nfc.h +++ b/src/input_common/helpers/joycon_protocol/nfc.h @@ -13,26 +13,41 @@ #include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/joycon_types.h" +namespace Common::Input { +enum class DriverResult; +} + namespace InputCommon::Joycon { class NfcProtocol final : private JoyconCommonProtocol { public: explicit NfcProtocol(std::shared_ptr<JoyconHandle> handle); - DriverResult EnableNfc(); + Common::Input::DriverResult EnableNfc(); + + Common::Input::DriverResult DisableNfc(); + + Common::Input::DriverResult StartNFCPollingMode(); + + Common::Input::DriverResult StopNFCPollingMode(); - DriverResult DisableNfc(); + Common::Input::DriverResult GetTagInfo(Joycon::TagInfo& tag_info); - DriverResult StartNFCPollingMode(); + Common::Input::DriverResult ReadAmiibo(std::vector<u8>& data); - DriverResult ScanAmiibo(std::vector<u8>& data); + Common::Input::DriverResult WriteAmiibo(std::span<const u8> data); - DriverResult WriteAmiibo(std::span<const u8> data); + Common::Input::DriverResult ReadMifare(std::span<const MifareReadChunk> read_request, + std::span<MifareReadData> out_data); + + Common::Input::DriverResult WriteMifare(std::span<const MifareWriteChunk> write_request); bool HasAmiibo(); bool IsEnabled() const; + bool IsPolling() const; + private: // Number of times the function will be delayed until it outputs valid data static constexpr std::size_t AMIIBO_UPDATE_DELAY = 15; @@ -43,39 +58,64 @@ private: TagUUID uuid; }; - DriverResult WaitUntilNfcIs(NFCStatus status); + Common::Input::DriverResult WaitUntilNfcIs(NFCStatus status); + + Common::Input::DriverResult IsTagInRange(TagFoundData& data, std::size_t timeout_limit = 1); - DriverResult IsTagInRange(TagFoundData& data, std::size_t timeout_limit = 1); + Common::Input::DriverResult GetAmiiboData(std::vector<u8>& data); - DriverResult GetAmiiboData(std::vector<u8>& data); + Common::Input::DriverResult WriteAmiiboData(const TagUUID& tag_uuid, std::span<const u8> data); - DriverResult WriteAmiiboData(const TagUUID& tag_uuid, std::span<const u8> data); + Common::Input::DriverResult GetMifareData(const MifareUUID& tag_uuid, + std::span<const MifareReadChunk> read_request, + std::span<MifareReadData> out_data); - DriverResult SendStartPollingRequest(MCUCommandResponse& output, - bool is_second_attempt = false); + Common::Input::DriverResult WriteMifareData(const MifareUUID& tag_uuid, + std::span<const MifareWriteChunk> write_request); - DriverResult SendStopPollingRequest(MCUCommandResponse& output); + Common::Input::DriverResult SendStartPollingRequest(MCUCommandResponse& output, + bool is_second_attempt = false); - DriverResult SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id); + Common::Input::DriverResult SendStopPollingRequest(MCUCommandResponse& output); - DriverResult SendReadAmiiboRequest(MCUCommandResponse& output, NFCPages ntag_pages); + Common::Input::DriverResult SendNextPackageRequest(MCUCommandResponse& output, u8 packet_id); - DriverResult SendWriteAmiiboRequest(MCUCommandResponse& output, const TagUUID& tag_uuid); + Common::Input::DriverResult SendReadAmiiboRequest(MCUCommandResponse& output, + NFCPages ntag_pages); - DriverResult SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id, - bool is_last_packet, std::span<const u8> data); + Common::Input::DriverResult SendWriteAmiiboRequest(MCUCommandResponse& output, + const TagUUID& tag_uuid); + + Common::Input::DriverResult SendWriteDataAmiiboRequest(MCUCommandResponse& output, u8 block_id, + bool is_last_packet, + std::span<const u8> data); + + Common::Input::DriverResult SendReadDataMifareRequest(MCUCommandResponse& output, u8 block_id, + bool is_last_packet, + std::span<const u8> data); std::vector<u8> SerializeWritePackage(const NFCWritePackage& package) const; + std::vector<u8> SerializeMifareReadPackage(const MifareReadPackage& package) const; + + std::vector<u8> SerializeMifareWritePackage(const MifareWritePackage& package) const; + NFCWritePackage MakeAmiiboWritePackage(const TagUUID& tag_uuid, std::span<const u8> data) const; NFCDataChunk MakeAmiiboChunk(u8 page, u8 size, std::span<const u8> data) const; + MifareReadPackage MakeMifareReadPackage(const MifareUUID& tag_uuid, + std::span<const MifareReadChunk> read_request) const; + + MifareWritePackage MakeMifareWritePackage(const MifareUUID& tag_uuid, + std::span<const MifareWriteChunk> read_request) const; + NFCReadBlockCommand GetReadBlockCommand(NFCPages pages) const; TagUUID GetTagUUID(std::span<const u8> data) const; bool is_enabled{}; + bool is_polling{}; std::size_t update_counter{}; }; diff --git a/src/input_common/helpers/joycon_protocol/poller.cpp b/src/input_common/helpers/joycon_protocol/poller.cpp index dca797f7a..1aab9e12a 100644 --- a/src/input_common/helpers/joycon_protocol/poller.cpp +++ b/src/input_common/helpers/joycon_protocol/poller.cpp @@ -70,8 +70,8 @@ void JoyconPoller::UpdateColor(const Color& color) { callbacks.on_color_data(color); } -void JoyconPoller::UpdateAmiibo(const std::vector<u8>& amiibo_data) { - callbacks.on_amiibo_data(amiibo_data); +void JoyconPoller::UpdateAmiibo(const Joycon::TagInfo& tag_info) { + callbacks.on_amiibo_data(tag_info); } void JoyconPoller::UpdateCamera(const std::vector<u8>& camera_data, IrsResolution format) { diff --git a/src/input_common/helpers/joycon_protocol/poller.h b/src/input_common/helpers/joycon_protocol/poller.h index 0fa72c6db..3746abe5d 100644 --- a/src/input_common/helpers/joycon_protocol/poller.h +++ b/src/input_common/helpers/joycon_protocol/poller.h @@ -36,8 +36,8 @@ public: void UpdateColor(const Color& color); void UpdateRing(s16 value, const RingStatus& ring_status); - void UpdateAmiibo(const std::vector<u8>& amiibo_data); - void UpdateCamera(const std::vector<u8>& amiibo_data, IrsResolution format); + void UpdateAmiibo(const Joycon::TagInfo& tag_info); + void UpdateCamera(const std::vector<u8>& camera_data, IrsResolution format); 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 index 190cef812..96414fb67 100644 --- a/src/input_common/helpers/joycon_protocol/ringcon.cpp +++ b/src/input_common/helpers/joycon_protocol/ringcon.cpp @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include "common/input.h" #include "common/logging/log.h" #include "input_common/helpers/joycon_protocol/ringcon.h" @@ -9,18 +10,18 @@ namespace InputCommon::Joycon { RingConProtocol::RingConProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(std::move(handle)) {} -DriverResult RingConProtocol::EnableRingCon() { +Common::Input::DriverResult RingConProtocol::EnableRingCon() { LOG_DEBUG(Input, "Enable Ringcon"); 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); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = EnableMCU(true); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { const MCUConfig config{ .command = MCUCommand::ConfigureMCU, .sub_command = MCUSubCommand::SetDeviceMode, @@ -33,12 +34,12 @@ DriverResult RingConProtocol::EnableRingCon() { return result; } -DriverResult RingConProtocol::DisableRingCon() { +Common::Input::DriverResult RingConProtocol::DisableRingCon() { LOG_DEBUG(Input, "Disable RingCon"); 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); } @@ -47,29 +48,29 @@ DriverResult RingConProtocol::DisableRingCon() { return result; } -DriverResult RingConProtocol::StartRingconPolling() { +Common::Input::DriverResult RingConProtocol::StartRingconPolling() { LOG_DEBUG(Input, "Enable Ringcon"); ScopedSetBlocking sb(this); - DriverResult result{DriverResult::Success}; + Common::Input::DriverResult result{Common::Input::DriverResult::Success}; bool is_connected = false; - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { result = IsRingConnected(is_connected); } - if (result == DriverResult::Success && is_connected) { + if (result == Common::Input::DriverResult::Success && is_connected) { LOG_INFO(Input, "Ringcon detected"); result = ConfigureRing(); } - if (result == DriverResult::Success) { + if (result == Common::Input::DriverResult::Success) { is_enabled = true; } return result; } -DriverResult RingConProtocol::IsRingConnected(bool& is_connected) { +Common::Input::DriverResult RingConProtocol::IsRingConnected(bool& is_connected) { LOG_DEBUG(Input, "IsRingConnected"); - constexpr std::size_t max_tries = 28; + constexpr std::size_t max_tries = 42; SubCommandResponse output{}; std::size_t tries = 0; is_connected = false; @@ -77,20 +78,21 @@ DriverResult RingConProtocol::IsRingConnected(bool& is_connected) { do { const auto result = SendSubCommand(SubCommand::GET_EXTERNAL_DEVICE_INFO, {}, output); - if (result != DriverResult::Success) { + if (result != Common::Input::DriverResult::Success && + result != Common::Input::DriverResult::Timeout) { return result; } if (tries++ >= max_tries) { - return DriverResult::NoDeviceDetected; + return Common::Input::DriverResult::NoDeviceDetected; } } while (output.external_device_id != ExternalDeviceId::RingController); is_connected = true; - return DriverResult::Success; + return Common::Input::DriverResult::Success; } -DriverResult RingConProtocol::ConfigureRing() { +Common::Input::DriverResult RingConProtocol::ConfigureRing() { LOG_DEBUG(Input, "ConfigureRing"); static constexpr std::array<u8, 37> ring_config{ @@ -98,9 +100,10 @@ DriverResult RingConProtocol::ConfigureRing() { 0x00, 0x00, 0x00, 0x0A, 0x64, 0x0B, 0xE6, 0xA9, 0x22, 0x00, 0x00, 0x04, 0x00, 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; } diff --git a/src/input_common/helpers/joycon_protocol/ringcon.h b/src/input_common/helpers/joycon_protocol/ringcon.h index 6e858f3fc..9f0888de3 100644 --- a/src/input_common/helpers/joycon_protocol/ringcon.h +++ b/src/input_common/helpers/joycon_protocol/ringcon.h @@ -13,24 +13,28 @@ #include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/joycon_types.h" +namespace Common::Input { +enum class DriverResult; +} + namespace InputCommon::Joycon { class RingConProtocol final : private JoyconCommonProtocol { public: 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; private: - DriverResult IsRingConnected(bool& is_connected); + Common::Input::DriverResult IsRingConnected(bool& is_connected); - DriverResult ConfigureRing(); + Common::Input::DriverResult ConfigureRing(); bool is_enabled{}; }; diff --git a/src/input_common/helpers/joycon_protocol/rumble.cpp b/src/input_common/helpers/joycon_protocol/rumble.cpp index 63b60c946..7647f505e 100644 --- a/src/input_common/helpers/joycon_protocol/rumble.cpp +++ b/src/input_common/helpers/joycon_protocol/rumble.cpp @@ -4,6 +4,7 @@ #include <algorithm> #include <cmath> +#include "common/input.h" #include "common/logging/log.h" #include "input_common/helpers/joycon_protocol/rumble.h" @@ -12,14 +13,14 @@ namespace InputCommon::Joycon { RumbleProtocol::RumbleProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(std::move(handle)) {} -DriverResult RumbleProtocol::EnableRumble(bool is_enabled) { +Common::Input::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)}; 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{}; if (vibration.high_amplitude <= 0.0f && vibration.low_amplitude <= 0.0f) { diff --git a/src/input_common/helpers/joycon_protocol/rumble.h b/src/input_common/helpers/joycon_protocol/rumble.h index 6c12b7925..5e50e531a 100644 --- a/src/input_common/helpers/joycon_protocol/rumble.h +++ b/src/input_common/helpers/joycon_protocol/rumble.h @@ -13,15 +13,19 @@ #include "input_common/helpers/joycon_protocol/common_protocol.h" #include "input_common/helpers/joycon_protocol/joycon_types.h" +namespace Common::Input { +enum class DriverResult; +} + namespace InputCommon::Joycon { class RumbleProtocol final : private JoyconCommonProtocol { public: 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: u16 EncodeHighFrequency(f32 frequency) const; |