input_common: Implement joycon nfc

src/core/hid/emulated_controller.cpp

@@ -144,7 +144,8 @@ void EmulatedController::LoadDevices() {
     battery_params[RightIndex].Set("battery", true);
 
     camera_params = Common::ParamPackage{"engine:camera,camera:1"};
-    nfc_params = Common::ParamPackage{"engine:virtual_amiibo,nfc:1"};
+    nfc_params = right_joycon;
+    nfc_params.Set("nfc", true);
     ring_params = Common::ParamPackage{"engine:joycon,axis_x:100,axis_y:101"};
 
     output_params[LeftIndex] = left_joycon;

src/input_common/CMakeLists.txt

@@ -64,6 +64,8 @@ if (ENABLE_SDL2)
         helpers/joycon_protocol/generic_functions.cpp
         helpers/joycon_protocol/generic_functions.h
         helpers/joycon_protocol/joycon_types.h
+        helpers/joycon_protocol/nfc.cpp
+        helpers/joycon_protocol/nfc.h
         helpers/joycon_protocol/poller.cpp
         helpers/joycon_protocol/poller.h
         helpers/joycon_protocol/ringcon.cpp

src/input_common/drivers/joycon.cpp

@@ -388,7 +388,9 @@ void Joycons::OnRingConUpdate(f32 ring_data) {
 
 void Joycons::OnAmiiboUpdate(std::size_t port, const std::vector<u8>& amiibo_data) {
     const auto identifier = GetIdentifier(port, Joycon::ControllerType::Right);
-    SetNfc(identifier, {Common::Input::NfcState::NewAmiibo, amiibo_data});
+    const auto nfc_state = amiibo_data.empty() ? Common::Input::NfcState::AmiiboRemoved
+                                               : Common::Input::NfcState::NewAmiibo;
+    SetNfc(identifier, {nfc_state, amiibo_data});
 }
 
 std::shared_ptr<Joycon::JoyconDriver> Joycons::GetHandle(PadIdentifier identifier) const {

src/input_common/helpers/joycon_driver.cpp

@@ -5,6 +5,12 @@
 #include "common/swap.h"
 #include "common/thread.h"
 #include "input_common/helpers/joycon_driver.h"
+#include "input_common/helpers/joycon_protocol/calibration.h"
+#include "input_common/helpers/joycon_protocol/generic_functions.h"
+#include "input_common/helpers/joycon_protocol/nfc.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 {
 JoyconDriver::JoyconDriver(std::size_t port_) : port{port_} {
@@ -72,6 +78,7 @@ DriverResult JoyconDriver::InitializeDevice() {
     // Initialize HW Protocols
     calibration_protocol = std::make_unique<CalibrationProtocol>(hidapi_handle);
     generic_protocol = std::make_unique<GenericProtocol>(hidapi_handle);
+    nfc_protocol = std::make_unique<NfcProtocol>(hidapi_handle);
     ring_protocol = std::make_unique<RingConProtocol>(hidapi_handle);
     rumble_protocol = std::make_unique<RumbleProtocol>(hidapi_handle);
 
@@ -193,6 +200,25 @@ void JoyconDriver::OnNewData(std::span<u8> buffer) {
         .min_value = ring_calibration.min_value,
     };
 
+    if (nfc_protocol->IsEnabled()) {
+        if (amiibo_detected) {
+            if (!nfc_protocol->HasAmiibo()) {
+                joycon_poller->updateAmiibo({});
+                amiibo_detected = false;
+                return;
+            }
+        }
+
+        if (!amiibo_detected) {
+            std::vector<u8> data(0x21C);
+            const auto result = nfc_protocol->ScanAmiibo(data);
+            if (result == DriverResult::Success) {
+                joycon_poller->updateAmiibo(data);
+                amiibo_detected = true;
+            }
+        }
+    }
+
     switch (report_mode) {
     case InputReport::STANDARD_FULL_60HZ:
         joycon_poller->ReadActiveMode(buffer, motion_status, ring_status);
@@ -225,6 +251,24 @@ void JoyconDriver::SetPollingMode() {
         generic_protocol->EnableImu(false);
     }
 
+    if (nfc_protocol->IsEnabled()) {
+        amiibo_detected = false;
+        nfc_protocol->DisableNfc();
+    }
+
+    if (nfc_enabled && supported_features.nfc) {
+        auto result = nfc_protocol->EnableNfc();
+        if (result == DriverResult::Success) {
+            result = nfc_protocol->StartNFCPollingMode();
+        }
+        if (result == DriverResult::Success) {
+            disable_input_thread = false;
+            return;
+        }
+        nfc_protocol->DisableNfc();
+        LOG_ERROR(Input, "Error enabling NFC");
+    }
+
     if (ring_protocol->IsEnabled()) {
         ring_connected = false;
         ring_protocol->DisableRingCon();

src/input_common/helpers/joycon_driver.h

@@ -8,14 +8,15 @@
 #include <span>
 #include <thread>
 
-#include "input_common/helpers/joycon_protocol/calibration.h"
-#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 {
+class CalibrationProtocol;
+class GenericProtocol;
+class NfcProtocol;
+class JoyconPoller;
+class RingConProtocol;
+class RumbleProtocol;
 
 class JoyconDriver final {
 public:
@@ -84,17 +85,18 @@ private:
     SupportedFeatures GetSupportedFeatures();
 
     // Protocol Features
-    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;
+    std::unique_ptr<CalibrationProtocol> calibration_protocol;
+    std::unique_ptr<GenericProtocol> generic_protocol;
+    std::unique_ptr<NfcProtocol> nfc_protocol;
+    std::unique_ptr<JoyconPoller> joycon_poller;
+    std::unique_ptr<RingConProtocol> ring_protocol;
+    std::unique_ptr<RumbleProtocol> rumble_protocol;
 
     // Connection status
     bool is_connected{};
     u64 delta_time;
     std::size_t error_counter{};
-    std::shared_ptr<JoyconHandle> hidapi_handle = nullptr;
+    std::shared_ptr<JoyconHandle> hidapi_handle;
     std::chrono::time_point<std::chrono::steady_clock> last_update;
 
     // External device status

src/input_common/helpers/joycon_protocol/nfc.cpp

@@ -0,0 +1,414 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <thread>
+#include "common/logging/log.h"
+#include "input_common/helpers/joycon_protocol/nfc.h"
+
+namespace InputCommon::Joycon {
+
+NfcProtocol::NfcProtocol(std::shared_ptr<JoyconHandle> handle) : JoyconCommonProtocol(handle) {}
+
+DriverResult NfcProtocol::EnableNfc() {
+    LOG_INFO(Input, "Enable NFC");
+    DriverResult result{DriverResult::Success};
+    SetBlocking();
+
+    if (result == DriverResult::Success) {
+        result = SetReportMode(ReportMode::NFC_IR_MODE_60HZ);
+    }
+    if (result == DriverResult::Success) {
+        result = EnableMCU(true);
+    }
+    if (result == DriverResult::Success) {
+        result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::Standby);
+    }
+    if (result == DriverResult::Success) {
+        const MCUConfig config{
+            .command = MCUCommand::ConfigureMCU,
+            .sub_command = MCUSubCommand::SetMCUMode,
+            .mode = MCUMode::NFC,
+            .crc = {},
+        };
+
+        result = ConfigureMCU(config);
+    }
+
+    SetNonBlocking();
+    return result;
+}
+
+DriverResult NfcProtocol::DisableNfc() {
+    LOG_DEBUG(Input, "Disable NFC");
+    DriverResult result{DriverResult::Success};
+    SetBlocking();
+
+    if (result == DriverResult::Success) {
+        result = EnableMCU(false);
+    }
+
+    is_enabled = false;
+
+    SetNonBlocking();
+    return result;
+}
+
+DriverResult NfcProtocol::StartNFCPollingMode() {
+    LOG_DEBUG(Input, "Start NFC pooling Mode");
+    DriverResult result{DriverResult::Success};
+    TagFoundData tag_data{};
+    SetBlocking();
+
+    if (result == DriverResult::Success) {
+        result = WaitSetMCUMode(ReportMode::NFC_IR_MODE_60HZ, MCUMode::NFC);
+    }
+    if (result == DriverResult::Success) {
+        result = WaitUntilNfcIsReady();
+    }
+    if (result == DriverResult::Success) {
+        is_enabled = true;
+    }
+
+    SetNonBlocking();
+    return result;
+}
+
+DriverResult NfcProtocol::ScanAmiibo(std::vector<u8>& data) {
+    LOG_DEBUG(Input, "Start NFC pooling Mode");
+    DriverResult result{DriverResult::Success};
+    TagFoundData tag_data{};
+    SetBlocking();
+
+    if (result == DriverResult::Success) {
+        result = StartPolling(tag_data);
+    }
+    if (result == DriverResult::Success) {
+        result = ReadTag(tag_data);
+    }
+    if (result == DriverResult::Success) {
+        result = WaitUntilNfcIsReady();
+    }
+    if (result == DriverResult::Success) {
+        result = StartPolling(tag_data);
+    }
+    if (result == DriverResult::Success) {
+        result = GetAmiiboData(data);
+    }
+
+    SetNonBlocking();
+    return result;
+}
+
+bool NfcProtocol::HasAmiibo() {
+    DriverResult result{DriverResult::Success};
+    TagFoundData tag_data{};
+    SetBlocking();
+
+    if (result == DriverResult::Success) {
+        result = StartPolling(tag_data);
+    }
+
+    SetNonBlocking();
+    return result == DriverResult::Success;
+}
+
+DriverResult NfcProtocol::WaitUntilNfcIsReady() {
+    constexpr std::size_t timeout_limit = 10;
+    std::vector<u8> output;
+    std::size_t tries = 0;
+
+    do {
+        auto result = SendStartWaitingRecieveRequest(output);
+
+        if (result != DriverResult::Success) {
+            return result;
+        }
+        if (tries++ > timeout_limit) {
+            return DriverResult::Timeout;
+        }
+    } while (output[49] != 0x2a || (output[51] << 8) + output[50] != 0x0500 || output[55] != 0x31 ||
+             output[56] != 0x00);
+
+    return DriverResult::Success;
+}
+
+DriverResult NfcProtocol::StartPolling(TagFoundData& data) {
+    LOG_DEBUG(Input, "Start Polling for tag");
+    constexpr std::size_t timeout_limit = 7;
+    std::vector<u8> output;
+    std::size_t tries = 0;
+
+    do {
+        const auto result = SendStartPollingRequest(output);
+        if (result != DriverResult::Success) {
+            return result;
+        }
+        if (tries++ > timeout_limit) {
+            return DriverResult::Timeout;
+        }
+    } while (output[49] != 0x2a || (output[51] << 8) + output[50] != 0x0500 || output[56] != 0x09);
+
+    data.type = output[62];
+    data.uuid.resize(output[64]);
+    memcpy(data.uuid.data(), output.data() + 65, data.uuid.size());
+
+    return DriverResult::Success;
+}
+
+DriverResult NfcProtocol::ReadTag(const TagFoundData& data) {
+    constexpr std::size_t timeout_limit = 10;
+    std::vector<u8> output;
+    std::size_t tries = 0;
+
+    std::string uuid_string = "";
+    for (auto& content : data.uuid) {
+        uuid_string += " " + fmt::format("{:02x}", content);
+    }
+
+    LOG_INFO(Input, "Tag detected, type={}, uuid={}", data.type, uuid_string);
+
+    tries = 0;
+    std::size_t ntag_pages = 0;
+    // Read Tag data
+loop1:
+    while (true) {
+        auto result = SendReadAmiiboRequest(output, ntag_pages);
+
+        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 && 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;
+            }
+        }
+
+        if (result != DriverResult::Success) {
+            return result;
+        }
+        if (tries++ > timeout_limit) {
+            return DriverResult::Timeout;
+        }
+    }
+
+    return DriverResult::Success;
+}
+
+DriverResult NfcProtocol::GetAmiiboData(std::vector<u8>& ntag_data) {
+    constexpr std::size_t timeout_limit = 10;
+    std::vector<u8> output;
+    std::size_t tries = 0;
+
+    std::size_t ntag_pages = 135;
+    std::size_t ntag_buffer_pos = 0;
+    // Read Tag data
+loop1:
+    while (true) {
+        auto result = SendReadAmiiboRequest(output, ntag_pages);
+
+        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 (tries++ > timeout_limit) {
+            return DriverResult::Timeout;
+        }
+    }
+
+    return DriverResult::Success;
+}
+
+DriverResult NfcProtocol::SendStartPollingRequest(std::vector<u8>& output) {
+    NFCRequestState request{
+        .sub_command = MCUSubCommand::ReadDeviceMode,
+        .command_argument = NFCReadCommand::StartPolling,
+        .packet_id = 0x0,
+        .packet_flag = MCUPacketFlag::LastCommandPacket,
+        .data_length = sizeof(NFCPollingCommandData),
+        .nfc_polling =
+            {
+                .enable_mifare = 0x01,
+                .unknown_1 = 0x00,
+                .unknown_2 = 0x00,
+                .unknown_3 = 0x2c,
+                .unknown_4 = 0x01,
+            },
+        .crc = {},
+    };
+
+    std::vector<u8> request_data(sizeof(NFCRequestState));
+    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);
+}
+
+DriverResult NfcProtocol::SendStopPollingRequest(std::vector<u8>& output) {
+    NFCRequestState request{
+        .sub_command = MCUSubCommand::ReadDeviceMode,
+        .command_argument = NFCReadCommand::StopPolling,
+        .packet_id = 0x0,
+        .packet_flag = MCUPacketFlag::LastCommandPacket,
+        .data_length = 0,
+        .raw_data = {},
+        .crc = {},
+    };
+
+    std::vector<u8> request_data(sizeof(NFCRequestState));
+    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);
+}
+
+DriverResult NfcProtocol::SendStartWaitingRecieveRequest(std::vector<u8>& output) {
+    NFCRequestState request{
+        .sub_command = MCUSubCommand::ReadDeviceMode,
+        .command_argument = NFCReadCommand::StartWaitingRecieve,
+        .packet_id = 0x0,
+        .packet_flag = MCUPacketFlag::LastCommandPacket,
+        .data_length = 0,
+        .raw_data = {},
+        .crc = {},
+    };
+
+    std::vector<u8> request_data(sizeof(NFCRequestState));
+    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);
+}
+
+DriverResult NfcProtocol::SendReadAmiiboRequest(std::vector<u8>& output, std::size_t ntag_pages) {
+    NFCRequestState request{
+        .sub_command = MCUSubCommand::ReadDeviceMode,
+        .command_argument = NFCReadCommand::Ntag,
+        .packet_id = 0x0,
+        .packet_flag = MCUPacketFlag::LastCommandPacket,
+        .data_length = sizeof(NFCReadCommandData),
+        .nfc_read =
+            {
+                .unknown = 0xd0,
+                .uuid_length = 0x07,
+                .unknown_2 = 0x00,
+                .uid = {},
+                .tag_type = NFCTagType::AllTags,
+                .read_block = GetReadBlockCommand(ntag_pages),
+            },
+        .crc = {},
+    };
+
+    std::vector<u8> request_data(sizeof(NFCRequestState));
+    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) {
+        return {
+            .block_count = 1,
+        };
+    }
+
+    if (pages == 45) {
+        return {
+            .block_count = 1,
+            .blocks =
+                {
+                    NFCReadBlock{0x00, 0x2C},
+                },
+        };
+    }
+
+    if (pages == 135) {
+        return {
+            .block_count = 3,
+            .blocks =
+                {
+                    NFCReadBlock{0x00, 0x3b},
+                    {0x3c, 0x77},
+                    {0x78, 0x86},
+                },
+        };
+    }
+
+    if (pages == 231) {
+        return {
+            .block_count = 4,
+            .blocks =
+                {
+                    NFCReadBlock{0x00, 0x3b},
+                    {0x3c, 0x77},
+                    {0x78, 0x83},
+                    {0xb4, 0xe6},
+                },
+        };
+    }
+
+    return {};
+}
+
+bool NfcProtocol::IsEnabled() {
+    return is_enabled;
+}
+
+} // namespace InputCommon::Joycon

src/input_common/helpers/joycon_protocol/nfc.h

@@ -0,0 +1,61 @@
+// 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 NfcProtocol final : private JoyconCommonProtocol {
+public:
+    NfcProtocol(std::shared_ptr<JoyconHandle> handle);
+
+    DriverResult EnableNfc();
+
+    DriverResult DisableNfc();
+
+    DriverResult StartNFCPollingMode();
+
+    DriverResult ScanAmiibo(std::vector<u8>& data);
+
+    bool HasAmiibo();
+
+    bool IsEnabled();
+
+private:
+    struct TagFoundData {
+        u8 type;
+        std::vector<u8> uuid;
+    };
+
+    DriverResult WaitUntilNfcIsReady();
+
+    DriverResult StartPolling(TagFoundData& data);
+
+    DriverResult ReadTag(const TagFoundData& data);
+
+    DriverResult GetAmiiboData(std::vector<u8>& data);
+
+    DriverResult SendStartPollingRequest(std::vector<u8>& output);
+
+    DriverResult SendStopPollingRequest(std::vector<u8>& output);
+
+    DriverResult SendStartWaitingRecieveRequest(std::vector<u8>& output);
+
+    DriverResult SendReadAmiiboRequest(std::vector<u8>& output, std::size_t ntag_pages);
+
+    NFCReadBlockCommand GetReadBlockCommand(std::size_t pages) const;
+
+    bool is_enabled{};
+};
+
+} // namespace InputCommon::Joycon

src/input_common/helpers/joycon_protocol/poller.cpp

@@ -74,6 +74,10 @@ 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::UpdateRing(s16 value, const RingStatus& ring_status) {
     float normalized_value = static_cast<float>(value - ring_status.default_value);
     if (normalized_value > 0) {

src/input_common/helpers/joycon_protocol/poller.h

@@ -36,6 +36,7 @@ public:
 
     void UpdateColor(const Color& color);
     void UpdateRing(s16 value, const RingStatus& ring_status);
+    void updateAmiibo(const std::vector<u8>& amiibo_data);
 
 private:
     void UpdateActiveLeftPadInput(const InputReportActive& input,