VERY experimental Nintendo Switch 2 emulator
C++
service: nfc: Merge device interfaces and create the device manager
Narr the Reg2a36d667c937
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txtindex 8817a99c9a..45328158f6 100644--- a/src/core/CMakeLists.txt+++ b/src/core/CMakeLists.txt@@ -555,21 +555,22 @@ add_library(core STATIChle/service/mnpp/mnpp_app.hhle/service/ncm/ncm.cpphle/service/ncm/ncm.h- hle/service/nfc/mifare_user.cpp- hle/service/nfc/mifare_user.h+ hle/service/nfc/common/amiibo_crypto.cpp+ hle/service/nfc/common/amiibo_crypto.h+ hle/service/nfc/common/device.cpp+ hle/service/nfc/common/device.h+ hle/service/nfc/common/device_manager.cpp+ hle/service/nfc/common/device_manager.h+ hle/service/nfc/mifare_result.h+ hle/service/nfc/mifare_types.hhle/service/nfc/nfc.cpphle/service/nfc/nfc.h- hle/service/nfc/nfc_device.cpp- hle/service/nfc/nfc_device.h+ hle/service/nfc/nfc_interface.cpp+ hle/service/nfc/nfc_interface.hhle/service/nfc/nfc_result.h- hle/service/nfc/nfc_user.cpp- hle/service/nfc/nfc_user.h- hle/service/nfp/amiibo_crypto.cpp- hle/service/nfp/amiibo_crypto.h+ hle/service/nfc/nfc_types.hhle/service/nfp/nfp.cpphle/service/nfp/nfp.h- hle/service/nfp/nfp_device.cpp- hle/service/nfp/nfp_device.hhle/service/nfp/nfp_interface.cpphle/service/nfp/nfp_interface.hhle/service/nfp/nfp_result.hdiff --git a/src/core/frontend/applets/cabinet.cpp b/src/core/frontend/applets/cabinet.cppindex 2d501eeae9..c33ce248b5 100644--- a/src/core/frontend/applets/cabinet.cpp+++ b/src/core/frontend/applets/cabinet.cpp@@ -14,7 +14,7 @@ void DefaultCabinetApplet::Close() const {}void DefaultCabinetApplet::ShowCabinetApplet(const CabinetCallback& callback, const CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const {+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device) const {LOG_WARNING(Service_AM, "(STUBBED) called");callback(false, {});}diff --git a/src/core/frontend/applets/cabinet.h b/src/core/frontend/applets/cabinet.hindex 74dc5a4f6f..af3fc6c3d5 100644--- a/src/core/frontend/applets/cabinet.h+++ b/src/core/frontend/applets/cabinet.h@@ -7,9 +7,9 @@#include "core/frontend/applets/applet.h"#include "core/hle/service/nfp/nfp_types.h"-namespace Service::NFP {-class NfpDevice;-} // namespace Service::NFP+namespace Service::NFC {+class NfcDevice;+} // namespace Service::NFCnamespace Core::Frontend {@@ -26,14 +26,14 @@ public:virtual ~CabinetApplet();virtual void ShowCabinetApplet(const CabinetCallback& callback,const CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const = 0;+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device) const = 0;};class DefaultCabinetApplet final : public CabinetApplet {public:void Close() const override;void ShowCabinetApplet(const CabinetCallback& callback, const CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const override;+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device) const override;};} // namespace Core::Frontenddiff --git a/src/core/hle/service/am/applets/applet_cabinet.cpp b/src/core/hle/service/am/applets/applet_cabinet.cppindex 93c9f2a558..8b754e9d49 100644--- a/src/core/hle/service/am/applets/applet_cabinet.cpp+++ b/src/core/hle/service/am/applets/applet_cabinet.cpp@@ -11,7 +11,7 @@#include "core/hle/service/am/am.h"#include "core/hle/service/am/applets/applet_cabinet.h"#include "core/hle/service/mii/mii_manager.h"-#include "core/hle/service/nfp/nfp_device.h"+#include "core/hle/service/nfc/common/device.h"namespace Service::AM::Applets {@@ -72,10 +72,10 @@ void Cabinet::Execute() {// TODO: listen on all controllersif (nfp_device == nullptr) {- nfp_device = std::make_shared<Service::NFP::NfpDevice>(+ nfp_device = std::make_shared<Service::NFC::NfcDevice>(system.HIDCore().GetFirstNpadId(), system, service_context, availability_change_event);nfp_device->Initialize();- nfp_device->StartDetection(Service::NFP::TagProtocol::All);+ nfp_device->StartDetection(Service::NFC::NfcProtocol::All);}const Core::Frontend::CabinetParameters parameters{@@ -106,20 +106,22 @@ void Cabinet::DisplayCompleted(bool apply_changes, std::string_view amiibo_name)Cancel();}- if (nfp_device->GetCurrentState() != Service::NFP::DeviceState::TagFound &&- nfp_device->GetCurrentState() != Service::NFP::DeviceState::TagMounted) {+ if (nfp_device->GetCurrentState() != Service::NFC::DeviceState::TagFound &&+ nfp_device->GetCurrentState() != Service::NFC::DeviceState::TagMounted) {Cancel();}- if (nfp_device->GetCurrentState() == Service::NFP::DeviceState::TagFound) {- nfp_device->Mount(Service::NFP::MountTarget::All);+ if (nfp_device->GetCurrentState() == Service::NFC::DeviceState::TagFound) {+ nfp_device->Mount(Service::NFP::ModelType::Amiibo, Service::NFP::MountTarget::All);}switch (applet_input_common.applet_mode) {case Service::NFP::CabinetMode::StartNicknameAndOwnerSettings: {- Service::NFP::AmiiboName name{};- std::memcpy(name.data(), amiibo_name.data(), std::min(amiibo_name.size(), name.size() - 1));- nfp_device->SetRegisterInfoPrivate(name);+ Service::NFP::RegisterInfoPrivate register_info{};+ std::memcpy(register_info.amiibo_name.data(), amiibo_name.data(),+ std::min(amiibo_name.size(), register_info.amiibo_name.size() - 1));++ nfp_device->SetRegisterInfoPrivate(register_info);break;}case Service::NFP::CabinetMode::StartGameDataEraser:@@ -139,7 +141,7 @@ void Cabinet::DisplayCompleted(bool apply_changes, std::string_view amiibo_name)applet_output.device_handle = applet_input_common.device_handle;applet_output.result = CabinetResult::Cancel;const auto reg_result = nfp_device->GetRegisterInfo(applet_output.register_info);- const auto tag_result = nfp_device->GetTagInfo(applet_output.tag_info);+ const auto tag_result = nfp_device->GetTagInfo(applet_output.tag_info, false);nfp_device->Finalize();if (reg_result.IsSuccess()) {diff --git a/src/core/hle/service/am/applets/applet_cabinet.h b/src/core/hle/service/am/applets/applet_cabinet.hindex edd295a273..b56427021e 100644--- a/src/core/hle/service/am/applets/applet_cabinet.h+++ b/src/core/hle/service/am/applets/applet_cabinet.h@@ -19,8 +19,8 @@ namespace Core {class System;} // namespace Core-namespace Service::NFP {-class NfpDevice;+namespace Service::NFC {+class NfcDevice;}namespace Service::AM::Applets {@@ -96,7 +96,7 @@ private:Core::System& system;bool is_complete{false};- std::shared_ptr<Service::NFP::NfpDevice> nfp_device;+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device;Kernel::KEvent* availability_change_event;KernelHelpers::ServiceContext service_context;StartParamForAmiiboSettings applet_input_common{};diff --git a/src/core/hle/service/nfp/amiibo_crypto.cpp b/src/core/hle/service/nfc/common/amiibo_crypto.cppsimilarity index 99%rename from src/core/hle/service/nfp/amiibo_crypto.cpprename to src/core/hle/service/nfc/common/amiibo_crypto.cppindex a3622e792d..f3901ee8db 100644--- a/src/core/hle/service/nfp/amiibo_crypto.cpp+++ b/src/core/hle/service/nfc/common/amiibo_crypto.cpp@@ -12,7 +12,7 @@#include "common/fs/fs.h"#include "common/fs/path_util.h"#include "common/logging/log.h"-#include "core/hle/service/nfp/amiibo_crypto.h"+#include "core/hle/service/nfc/common/amiibo_crypto.h"namespace Service::NFP::AmiiboCrypto {@@ -55,7 +55,7 @@ bool IsAmiiboValid(const EncryptedNTAG215File& ntag_file) {if (amiibo_data.constant_value != 0xA5) {return false;}- if (amiibo_data.model_info.tag_type != PackedTagType::Type2) {+ if (amiibo_data.model_info.tag_type != NFC::PackedTagType::Type2) {return false;}if ((ntag_file.dynamic_lock & 0xFFFFFF) != 0x0F0001U) {diff --git a/src/core/hle/service/nfp/amiibo_crypto.h b/src/core/hle/service/nfc/common/amiibo_crypto.hsimilarity index 98%rename from src/core/hle/service/nfp/amiibo_crypto.hrename to src/core/hle/service/nfc/common/amiibo_crypto.hindex f6208ee6b8..bf3044ed96 100644--- a/src/core/hle/service/nfp/amiibo_crypto.h+++ b/src/core/hle/service/nfc/common/amiibo_crypto.h@@ -24,9 +24,9 @@ using DrgbOutput = std::array<u8, 0x20>;struct HashSeed {u16_be magic;std::array<u8, 0xE> padding;- UniqueSerialNumber uid_1;+ NFC::UniqueSerialNumber uid_1;u8 nintendo_id_1;- UniqueSerialNumber uid_2;+ NFC::UniqueSerialNumber uid_2;u8 nintendo_id_2;std::array<u8, 0x20> keygen_salt;};diff --git a/src/core/hle/service/nfp/nfp_device.cpp b/src/core/hle/service/nfc/common/device.cppsimilarity index 61%rename from src/core/hle/service/nfp/nfp_device.cpprename to src/core/hle/service/nfc/common/device.cppindex 3f9af53c8f..e5de65ce01 100644--- a/src/core/hle/service/nfp/nfp_device.cpp+++ b/src/core/hle/service/nfc/common/device.cpp@@ -1,8 +1,6 @@-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later-#include <array>-#ifdef _MSC_VER#pragma warning(push)#pragma warning(disable : 4701) // Potentially uninitialized local variable 'result' used@@ -26,21 +24,22 @@#include "core/hle/service/ipc_helpers.h"#include "core/hle/service/mii/mii_manager.h"#include "core/hle/service/mii/types.h"-#include "core/hle/service/nfp/amiibo_crypto.h"-#include "core/hle/service/nfp/nfp_device.h"-#include "core/hle/service/nfp/nfp_result.h"+#include "core/hle/service/nfc/common/amiibo_crypto.h"+#include "core/hle/service/nfc/common/device.h"+#include "core/hle/service/nfc/mifare_result.h"+#include "core/hle/service/nfc/nfc_result.h"#include "core/hle/service/time/time_manager.h"#include "core/hle/service/time/time_zone_content_manager.h"#include "core/hle/service/time/time_zone_types.h"-namespace Service::NFP {-NfpDevice::NfpDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,+namespace Service::NFC {+NfcDevice::NfcDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,KernelHelpers::ServiceContext& service_context_,Kernel::KEvent* availability_change_event_): npad_id{npad_id_}, system{system_}, service_context{service_context_},availability_change_event{availability_change_event_} {- activate_event = service_context.CreateEvent("IUser:NFPActivateEvent");- deactivate_event = service_context.CreateEvent("IUser:NFPDeactivateEvent");+ activate_event = service_context.CreateEvent("NFC:ActivateEvent");+ deactivate_event = service_context.CreateEvent("NFC:DeactivateEvent");npad_device = system.HIDCore().GetEmulatedController(npad_id);Core::HID::ControllerUpdateCallback engine_callback{@@ -54,9 +53,9 @@ NfpDevice::NfpDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,current_posix_time = standard_steady_clock.GetCurrentTimePoint(system).time_point;}-NfpDevice::~NfpDevice() {- activate_event->Close();- deactivate_event->Close();+NfcDevice::~NfcDevice() {+ service_context.CloseEvent(activate_event);+ service_context.CloseEvent(deactivate_event);if (!is_controller_set) {return;}@@ -64,7 +63,7 @@ NfpDevice::~NfpDevice() {is_controller_set = false;};-void NfpDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {+void NfcDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {if (!is_initalized) {return;}@@ -92,14 +91,14 @@ void NfpDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {const auto nfc_status = npad_device->GetNfc();switch (nfc_status.state) {case Common::Input::NfcState::NewAmiibo:- LoadAmiibo(nfc_status.data);+ LoadNfcTag(nfc_status.data);break;case Common::Input::NfcState::AmiiboRemoved:if (device_state == DeviceState::Initialized || device_state == DeviceState::TagRemoved) {break;}if (device_state != DeviceState::SearchingForTag) {- CloseAmiibo();+ CloseNfcTag();}break;default:@@ -107,28 +106,29 @@ void NfpDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {}}-bool NfpDevice::LoadAmiibo(std::span<const u8> data) {+bool NfcDevice::LoadNfcTag(std::span<const u8> data) {if (device_state != DeviceState::SearchingForTag) {- LOG_ERROR(Service_NFP, "Game is not looking for amiibos, current state {}", device_state);+ LOG_ERROR(Service_NFC, "Game is not looking for nfc tag, current state {}", device_state);return false;}- if (data.size() != sizeof(EncryptedNTAG215File)) {- LOG_ERROR(Service_NFP, "Not an amiibo, size={}", data.size());+ if (data.size() < sizeof(NFP::EncryptedNTAG215File)) {+ LOG_ERROR(Service_NFC, "Not an amiibo, size={}", data.size());return false;}- // TODO: Filter by allowed_protocols here+ mifare_data.resize(data.size());+ memcpy(mifare_data.data(), data.data(), data.size());- memcpy(&tag_data, data.data(), sizeof(EncryptedNTAG215File));- is_plain_amiibo = AmiiboCrypto::IsAmiiboValid(tag_data);+ memcpy(&tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File));+ is_plain_amiibo = NFP::AmiiboCrypto::IsAmiiboValid(tag_data);if (is_plain_amiibo) {- encrypted_tag_data = AmiiboCrypto::EncodedDataToNfcData(tag_data);+ encrypted_tag_data = NFP::AmiiboCrypto::EncodedDataToNfcData(tag_data);LOG_INFO(Service_NFP, "Using plain amiibo");} else {tag_data = {};- memcpy(&encrypted_tag_data, data.data(), sizeof(EncryptedNTAG215File));+ memcpy(&encrypted_tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File));}device_state = DeviceState::TagFound;@@ -137,8 +137,8 @@ bool NfpDevice::LoadAmiibo(std::span<const u8> data) {return true;}-void NfpDevice::CloseAmiibo() {- LOG_INFO(Service_NFP, "Remove amiibo");+void NfcDevice::CloseNfcTag() {+ LOG_INFO(Service_NFC, "Remove nfc tag");if (device_state == DeviceState::TagMounted) {Unmount();@@ -147,26 +147,28 @@ void NfpDevice::CloseAmiibo() {device_state = DeviceState::TagRemoved;encrypted_tag_data = {};tag_data = {};+ mifare_data = {};activate_event->GetReadableEvent().Clear();deactivate_event->Signal();}-Kernel::KReadableEvent& NfpDevice::GetActivateEvent() const {+Kernel::KReadableEvent& NfcDevice::GetActivateEvent() const {return activate_event->GetReadableEvent();}-Kernel::KReadableEvent& NfpDevice::GetDeactivateEvent() const {+Kernel::KReadableEvent& NfcDevice::GetDeactivateEvent() const {return deactivate_event->GetReadableEvent();}-void NfpDevice::Initialize() {+void NfcDevice::Initialize() {device_state = npad_device->HasNfc() ? DeviceState::Initialized : DeviceState::Unavailable;encrypted_tag_data = {};tag_data = {};+ mifare_data = {};is_initalized = true;}-void NfpDevice::Finalize() {+void NfcDevice::Finalize() {if (device_state == DeviceState::TagMounted) {Unmount();}@@ -177,17 +179,17 @@ void NfpDevice::Finalize() {is_initalized = false;}-Result NfpDevice::StartDetection(TagProtocol allowed_protocol) {+Result NfcDevice::StartDetection(NfcProtocol allowed_protocol) {if (device_state != DeviceState::Initialized && device_state != DeviceState::TagRemoved) {- LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);- return WrongDeviceState;+ LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);+ return ResultWrongDeviceState;}if (npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,Common::Input::PollingMode::NFC) !=Common::Input::DriverResult::Success) {- LOG_ERROR(Service_NFP, "Nfc not supported");- return NfcDisabled;+ LOG_ERROR(Service_NFC, "Nfc not supported");+ return ResultNfcDisabled;}device_state = DeviceState::SearchingForTag;@@ -195,7 +197,7 @@ Result NfpDevice::StartDetection(TagProtocol allowed_protocol) {return ResultSuccess;}-Result NfpDevice::StopDetection() {+Result NfcDevice::StopDetection() {npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,Common::Input::PollingMode::Active);@@ -204,7 +206,7 @@ Result NfpDevice::StopDetection() {}if (device_state == DeviceState::TagFound || device_state == DeviceState::TagMounted) {- CloseAmiibo();+ CloseNfcTag();}if (device_state == DeviceState::SearchingForTag || device_state == DeviceState::TagRemoved) {@@ -212,94 +214,129 @@ Result NfpDevice::StopDetection() {return ResultSuccess;}- LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);- return WrongDeviceState;+ LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);+ return ResultWrongDeviceState;}-Result NfpDevice::Flush() {- if (device_state != DeviceState::TagMounted) {- LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);+Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info, bool is_mifare) const {+ if (device_state != DeviceState::TagFound && device_state != DeviceState::TagMounted) {+ LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {- LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ if (is_mifare) {+ tag_info = {+ .uuid = encrypted_tag_data.uuid.uid,+ .uuid_extension = {},+ .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),+ .protocol = NfcProtocol::TypeA,+ .tag_type = TagType::Type4,+ };+ return ResultSuccess;}- auto& settings = tag_data.settings;-- const auto& current_date = GetAmiiboDate(current_posix_time);- if (settings.write_date.raw_date != current_date.raw_date) {- settings.write_date = current_date;- UpdateSettingsCrc();- }+ // Protocol and tag type may change here+ tag_info = {+ .uuid = encrypted_tag_data.uuid.uid,+ .uuid_extension = {},+ .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),+ .protocol = NfcProtocol::TypeA,+ .tag_type = TagType::Type2,+ };- tag_data.write_counter++;+ return ResultSuccess;+}- FlushWithBreak(BreakType::Normal);+Result NfcDevice::ReadMifare(std::span<const MifareReadBlockParameter> parameters,+ std::span<MifareReadBlockData> read_block_data) const {+ Result result = ResultSuccess;- is_data_moddified = false;+ for (std::size_t i = 0; i < parameters.size(); i++) {+ result = ReadMifare(parameters[i], read_block_data[i]);+ if (result.IsError()) {+ break;+ }+ }- return ResultSuccess;+ return result;}-Result NfpDevice::FlushDebug() {- if (device_state != DeviceState::TagMounted) {+Result NfcDevice::ReadMifare(const MifareReadBlockParameter& parameter,+ MifareReadBlockData& read_block_data) const {+ const std::size_t sector_index = parameter.sector_number * sizeof(DataBlock);+ read_block_data.sector_number = parameter.sector_number;++ if (device_state != DeviceState::TagFound && device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {- LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ if (mifare_data.size() < sector_index + sizeof(DataBlock)) {+ return Mifare::ResultReadError;}- tag_data.write_counter++;-- FlushWithBreak(BreakType::Normal);-- is_data_moddified = false;+ // TODO: Use parameter.sector_key to read encrypted data+ memcpy(read_block_data.data.data(), mifare_data.data() + sector_index, sizeof(DataBlock));return ResultSuccess;}-Result NfpDevice::FlushWithBreak(BreakType break_type) {- if (break_type != BreakType::Normal) {- LOG_ERROR(Service_NFC, "Break type not implemented {}", break_type);- return WrongDeviceState;- }+Result NfcDevice::WriteMifare(std::span<const MifareWriteBlockParameter> parameters) {+ Result result = ResultSuccess;- std::vector<u8> data(sizeof(EncryptedNTAG215File));- if (is_plain_amiibo) {- memcpy(data.data(), &tag_data, sizeof(tag_data));- } else {- if (!AmiiboCrypto::EncodeAmiibo(tag_data, encrypted_tag_data)) {- LOG_ERROR(Service_NFP, "Failed to encode data");- return WriteAmiiboFailed;+ for (std::size_t i = 0; i < parameters.size(); i++) {+ result = WriteMifare(parameters[i]);+ if (result.IsError()) {+ break;}-- memcpy(data.data(), &encrypted_tag_data, sizeof(encrypted_tag_data));}- if (!npad_device->WriteNfc(data)) {+ if (!npad_device->WriteNfc(mifare_data)) {LOG_ERROR(Service_NFP, "Error writing to file");- return WriteAmiiboFailed;+ return Mifare::ResultReadError;+ }++ return result;+}++Result NfcDevice::WriteMifare(const MifareWriteBlockParameter& parameter) {+ const std::size_t sector_index = parameter.sector_number * sizeof(DataBlock);++ if (device_state != DeviceState::TagFound && device_state != DeviceState::TagMounted) {+ LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);+ if (device_state == DeviceState::TagRemoved) {+ return ResultTagRemoved;+ }+ return ResultWrongDeviceState;+ }++ if (mifare_data.size() < sector_index + sizeof(DataBlock)) {+ return Mifare::ResultReadError;}+ // TODO: Use parameter.sector_key to encrypt the data+ memcpy(mifare_data.data() + sector_index, parameter.data.data(), sizeof(DataBlock));+return ResultSuccess;}-Result NfpDevice::Mount(MountTarget mount_target_) {+Result NfcDevice::SendCommandByPassThrough(const Time::Clock::TimeSpanType& timeout,+ std::span<const u8> command_data,+ std::span<u8> out_data) {+ // Not implemented+ return ResultSuccess;+}++Result NfcDevice::Mount(NFP::ModelType model_type, NFP::MountTarget mount_target_) {if (device_state != DeviceState::TagFound) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}// The loaded amiibo is not encrypted@@ -309,22 +346,22 @@ Result NfpDevice::Mount(MountTarget mount_target_) {return ResultSuccess;}- if (!AmiiboCrypto::IsAmiiboValid(encrypted_tag_data)) {+ if (!NFP::AmiiboCrypto::IsAmiiboValid(encrypted_tag_data)) {LOG_ERROR(Service_NFP, "Not an amiibo");- return NotAnAmiibo;+ return ResultNotAnAmiibo;}// Mark amiibos as read only when keys are missing- if (!AmiiboCrypto::IsKeyAvailable()) {+ if (!NFP::AmiiboCrypto::IsKeyAvailable()) {LOG_ERROR(Service_NFP, "No keys detected");device_state = DeviceState::TagMounted;- mount_target = MountTarget::Rom;+ mount_target = NFP::MountTarget::Rom;return ResultSuccess;}- if (!AmiiboCrypto::DecodeAmiibo(encrypted_tag_data, tag_data)) {+ if (!NFP::AmiiboCrypto::DecodeAmiibo(encrypted_tag_data, tag_data)) {LOG_ERROR(Service_NFP, "Can't decode amiibo {}", device_state);- return CorruptedData;+ return ResultCorruptedData;}device_state = DeviceState::TagMounted;@@ -332,13 +369,13 @@ Result NfpDevice::Mount(MountTarget mount_target_) {return ResultSuccess;}-Result NfpDevice::Unmount() {+Result NfcDevice::Unmount() {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}// Save data before unloading the amiibo@@ -347,43 +384,123 @@ Result NfpDevice::Unmount() {}device_state = DeviceState::TagFound;- mount_target = MountTarget::None;+ mount_target = NFP::MountTarget::None;is_app_area_open = false;return ResultSuccess;}-Result NfpDevice::GetTagInfo(TagInfo& tag_info) const {- if (device_state != DeviceState::TagFound && device_state != DeviceState::TagMounted) {+Result NfcDevice::Flush() {+ if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- tag_info = {- .uuid = encrypted_tag_data.uuid.uid,- .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),- .protocol = TagProtocol::TypeA,- .tag_type = TagType::Type2,- };+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {+ LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);+ return ResultWrongDeviceState;+ }++ auto& settings = tag_data.settings;++ const auto& current_date = GetAmiiboDate(current_posix_time);+ if (settings.write_date.raw_date != current_date.raw_date) {+ settings.write_date = current_date;+ UpdateSettingsCrc();+ }++ tag_data.write_counter++;++ FlushWithBreak(NFP::BreakType::Normal);++ is_data_moddified = false;return ResultSuccess;}-Result NfpDevice::GetCommonInfo(CommonInfo& common_info) const {+Result NfcDevice::FlushDebug() {+ if (device_state != DeviceState::TagMounted) {+ LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);+ if (device_state == DeviceState::TagRemoved) {+ return ResultTagRemoved;+ }+ return ResultWrongDeviceState;+ }++ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {+ LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);+ return ResultWrongDeviceState;+ }++ tag_data.write_counter++;++ FlushWithBreak(NFP::BreakType::Normal);++ is_data_moddified = false;++ return ResultSuccess;+}++Result NfcDevice::FlushWithBreak(NFP::BreakType break_type) {+ if (break_type != NFP::BreakType::Normal) {+ LOG_ERROR(Service_NFC, "Break type not implemented {}", break_type);+ return ResultWrongDeviceState;+ }++ std::vector<u8> data(sizeof(NFP::EncryptedNTAG215File));+ if (is_plain_amiibo) {+ memcpy(data.data(), &tag_data, sizeof(tag_data));+ } else {+ if (!NFP::AmiiboCrypto::EncodeAmiibo(tag_data, encrypted_tag_data)) {+ LOG_ERROR(Service_NFP, "Failed to encode data");+ return ResultWriteAmiiboFailed;+ }++ memcpy(data.data(), &encrypted_tag_data, sizeof(encrypted_tag_data));+ }++ if (!npad_device->WriteNfc(data)) {+ LOG_ERROR(Service_NFP, "Error writing to file");+ return ResultWriteAmiiboFailed;+ }++ return ResultSuccess;+}++Result NfcDevice::Restore() {+ if (device_state != DeviceState::TagMounted) {+ LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);+ if (device_state == DeviceState::TagRemoved) {+ return ResultTagRemoved;+ }+ return ResultWrongDeviceState;+ }++ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {+ LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);+ return ResultWrongDeviceState;+ }++ // TODO: Load amiibo from backup on system+ LOG_ERROR(Service_NFP, "Not Implemented");+ return ResultSuccess;+}++Result NfcDevice::GetCommonInfo(NFP::CommonInfo& common_info) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}const auto& settings = tag_data.settings;@@ -393,18 +510,18 @@ Result NfpDevice::GetCommonInfo(CommonInfo& common_info) const {.last_write_date = settings.write_date.GetWriteDate(),.write_counter = tag_data.write_counter,.version = tag_data.amiibo_version,- .application_area_size = sizeof(ApplicationArea),+ .application_area_size = sizeof(NFP::ApplicationArea),};return ResultSuccess;}-Result NfpDevice::GetModelInfo(ModelInfo& model_info) const {+Result NfcDevice::GetModelInfo(NFP::ModelInfo& model_info) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}const auto& model_info_data = encrypted_tag_data.user_memory.model_info;@@ -418,22 +535,22 @@ Result NfpDevice::GetModelInfo(ModelInfo& model_info) const {return ResultSuccess;}-Result NfpDevice::GetRegisterInfo(RegisterInfo& register_info) const {+Result NfcDevice::GetRegisterInfo(NFP::RegisterInfo& register_info) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.amiibo_initialized == 0) {- return RegistrationIsNotInitialized;+ return ResultRegistrationIsNotInitialized;}Service::Mii::MiiManager manager;@@ -450,22 +567,22 @@ Result NfpDevice::GetRegisterInfo(RegisterInfo& register_info) const {return ResultSuccess;}-Result NfpDevice::GetRegisterInfoPrivate(RegisterInfoPrivate& register_info) const {+Result NfcDevice::GetRegisterInfoPrivate(NFP::RegisterInfoPrivate& register_info) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.amiibo_initialized == 0) {- return RegistrationIsNotInitialized;+ return ResultRegistrationIsNotInitialized;}Service::Mii::MiiManager manager;@@ -482,18 +599,18 @@ Result NfpDevice::GetRegisterInfoPrivate(RegisterInfoPrivate& register_info) conreturn ResultSuccess;}-Result NfpDevice::GetAdminInfo(AdminInfo& admin_info) const {+Result NfcDevice::GetAdminInfo(NFP::AdminInfo& admin_info) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}u8 flags = static_cast<u8>(tag_data.settings.settings.raw >> 0x4);@@ -503,17 +620,18 @@ Result NfpDevice::GetAdminInfo(AdminInfo& admin_info) const {u64 application_id = 0;u32 application_area_id = 0;- AppAreaVersion app_area_version = AppAreaVersion::NotSet;+ NFP::AppAreaVersion app_area_version = NFP::AppAreaVersion::NotSet;if (tag_data.settings.settings.appdata_initialized != 0) {application_id = tag_data.application_id;- app_area_version =- static_cast<AppAreaVersion>(application_id >> application_id_version_offset & 0xf);+ app_area_version = static_cast<NFP::AppAreaVersion>(+ application_id >> NFP::application_id_version_offset & 0xf);// Restore application id to original valueif (application_id >> 0x38 != 0) {const u8 application_byte = tag_data.application_id_byte & 0xf;- application_id = RemoveVersionByte(application_id) |- (static_cast<u64>(application_byte) << application_id_version_offset);+ application_id =+ RemoveVersionByte(application_id) |+ (static_cast<u64>(application_byte) << NFP::application_id_version_offset);}application_area_id = tag_data.application_area_id;@@ -532,22 +650,22 @@ Result NfpDevice::GetAdminInfo(AdminInfo& admin_info) const {return ResultSuccess;}-Result NfpDevice::DeleteRegisterInfo() {+Result NfcDevice::DeleteRegisterInfo() {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.amiibo_initialized == 0) {- return RegistrationIsNotInitialized;+ return ResultRegistrationIsNotInitialized;}Common::TinyMT rng{};@@ -564,18 +682,18 @@ Result NfpDevice::DeleteRegisterInfo() {return Flush();}-Result NfpDevice::SetRegisterInfoPrivate(const AmiiboName& amiibo_name) {+Result NfcDevice::SetRegisterInfoPrivate(const NFP::RegisterInfoPrivate& register_info) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}Service::Mii::MiiManager manager;@@ -587,7 +705,7 @@ Result NfpDevice::SetRegisterInfoPrivate(const AmiiboName& amiibo_name) {settings.write_date.raw_date = 0;}- SetAmiiboName(settings, amiibo_name);+ SetAmiiboName(settings, register_info.amiibo_name);tag_data.owner_mii = manager.BuildFromStoreData(mii);tag_data.mii_extension = manager.SetFromStoreData(mii);tag_data.unknown = 0;@@ -601,18 +719,18 @@ Result NfpDevice::SetRegisterInfoPrivate(const AmiiboName& amiibo_name) {return Flush();}-Result NfpDevice::RestoreAmiibo() {+Result NfcDevice::RestoreAmiibo() {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}// TODO: Load amiibo from backup on system@@ -620,7 +738,7 @@ Result NfpDevice::RestoreAmiibo() {return ResultSuccess;}-Result NfpDevice::Format() {+Result NfcDevice::Format() {auto result1 = DeleteApplicationArea();auto result2 = DeleteRegisterInfo();@@ -635,28 +753,28 @@ Result NfpDevice::Format() {return Flush();}-Result NfpDevice::OpenApplicationArea(u32 access_id) {+Result NfcDevice::OpenApplicationArea(u32 access_id) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.appdata_initialized.Value() == 0) {LOG_WARNING(Service_NFP, "Application area is not initialized");- return ApplicationAreaIsNotInitialized;+ return ResultApplicationAreaIsNotInitialized;}if (tag_data.application_area_id != access_id) {LOG_WARNING(Service_NFP, "Wrong application area id");- return WrongApplicationAreaId;+ return ResultWrongApplicationAreaId;}is_app_area_open = true;@@ -664,25 +782,25 @@ Result NfpDevice::OpenApplicationArea(u32 access_id) {return ResultSuccess;}-Result NfpDevice::GetApplicationAreaId(u32& application_area_id) const {+Result NfcDevice::GetApplicationAreaId(u32& application_area_id) const {application_area_id = {};if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.appdata_initialized.Value() == 0) {LOG_WARNING(Service_NFP, "Application area is not initialized");- return ApplicationAreaIsNotInitialized;+ return ResultApplicationAreaIsNotInitialized;}application_area_id = tag_data.application_area_id;@@ -690,64 +808,61 @@ Result NfpDevice::GetApplicationAreaId(u32& application_area_id) const {return ResultSuccess;}-Result NfpDevice::GetApplicationArea(std::vector<u8>& data) const {+Result NfcDevice::GetApplicationArea(std::span<u8> data) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (!is_app_area_open) {LOG_ERROR(Service_NFP, "Application area is not open");- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.appdata_initialized.Value() == 0) {LOG_ERROR(Service_NFP, "Application area is not initialized");- return ApplicationAreaIsNotInitialized;- }-- if (data.size() > sizeof(ApplicationArea)) {- data.resize(sizeof(ApplicationArea));+ return ResultApplicationAreaIsNotInitialized;}- memcpy(data.data(), tag_data.application_area.data(), data.size());+ memcpy(data.data(), tag_data.application_area.data(),+ std::min(data.size(), sizeof(NFP::ApplicationArea)));return ResultSuccess;}-Result NfpDevice::SetApplicationArea(std::span<const u8> data) {+Result NfcDevice::SetApplicationArea(std::span<const u8> data) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (!is_app_area_open) {LOG_ERROR(Service_NFP, "Application area is not open");- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.appdata_initialized.Value() == 0) {LOG_ERROR(Service_NFP, "Application area is not initialized");- return ApplicationAreaIsNotInitialized;+ return ResultApplicationAreaIsNotInitialized;}- if (data.size() > sizeof(ApplicationArea)) {+ if (data.size() > sizeof(NFP::ApplicationArea)) {LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());return ResultUnknown;}@@ -756,9 +871,9 @@ Result NfpDevice::SetApplicationArea(std::span<const u8> data) {std::memcpy(tag_data.application_area.data(), data.data(), data.size());// Fill remaining data with random numbersrng.GenerateRandomBytes(tag_data.application_area.data() + data.size(),- sizeof(ApplicationArea) - data.size());+ sizeof(NFP::ApplicationArea) - data.size());- if (tag_data.application_write_counter != counter_limit) {+ if (tag_data.application_write_counter != NFP::counter_limit) {tag_data.application_write_counter++;}@@ -767,64 +882,64 @@ Result NfpDevice::SetApplicationArea(std::span<const u8> data) {return ResultSuccess;}-Result NfpDevice::CreateApplicationArea(u32 access_id, std::span<const u8> data) {+Result NfcDevice::CreateApplicationArea(u32 access_id, std::span<const u8> data) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.appdata_initialized.Value() != 0) {LOG_ERROR(Service_NFP, "Application area already exist");- return ApplicationAreaExist;+ return ResultApplicationAreaExist;}return RecreateApplicationArea(access_id, data);}-Result NfpDevice::RecreateApplicationArea(u32 access_id, std::span<const u8> data) {+Result NfcDevice::RecreateApplicationArea(u32 access_id, std::span<const u8> data) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}if (is_app_area_open) {LOG_ERROR(Service_NFP, "Application area is open");- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (data.size() > sizeof(ApplicationArea)) {+ if (data.size() > sizeof(NFP::ApplicationArea)) {LOG_ERROR(Service_NFP, "Wrong data size {}", data.size());- return WrongApplicationAreaSize;+ return ResultWrongApplicationAreaSize;}Common::TinyMT rng{};std::memcpy(tag_data.application_area.data(), data.data(), data.size());// Fill remaining data with random numbersrng.GenerateRandomBytes(tag_data.application_area.data() + data.size(),- sizeof(ApplicationArea) - data.size());+ sizeof(NFP::ApplicationArea) - data.size());- if (tag_data.application_write_counter != counter_limit) {+ if (tag_data.application_write_counter != NFP::counter_limit) {tag_data.application_write_counter++;}const u64 application_id = system.GetApplicationProcessProgramID();tag_data.application_id_byte =- static_cast<u8>(application_id >> application_id_version_offset & 0xf);+ static_cast<u8>(application_id >> NFP::application_id_version_offset & 0xf);tag_data.application_id =- RemoveVersionByte(application_id) |- (static_cast<u64>(AppAreaVersion::NintendoSwitch) << application_id_version_offset);+ RemoveVersionByte(application_id) | (static_cast<u64>(NFP::AppAreaVersion::NintendoSwitch)+ << NFP::application_id_version_offset);tag_data.settings.settings.appdata_initialized.Assign(1);tag_data.application_area_id = access_id;tag_data.unknown = {};@@ -835,30 +950,30 @@ Result NfpDevice::RecreateApplicationArea(u32 access_id, std::span<const u8> datreturn Flush();}-Result NfpDevice::DeleteApplicationArea() {+Result NfcDevice::DeleteApplicationArea() {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFP, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}if (tag_data.settings.settings.appdata_initialized == 0) {- return ApplicationAreaIsNotInitialized;+ return ResultApplicationAreaIsNotInitialized;}- if (tag_data.application_write_counter != counter_limit) {+ if (tag_data.application_write_counter != NFP::counter_limit) {tag_data.application_write_counter++;}Common::TinyMT rng{};- rng.GenerateRandomBytes(tag_data.application_area.data(), sizeof(ApplicationArea));+ rng.GenerateRandomBytes(tag_data.application_area.data(), sizeof(NFP::ApplicationArea));rng.GenerateRandomBytes(&tag_data.application_id, sizeof(u64));rng.GenerateRandomBytes(&tag_data.application_area_id, sizeof(u32));rng.GenerateRandomBytes(&tag_data.application_id_byte, sizeof(u8));@@ -872,18 +987,18 @@ Result NfpDevice::DeleteApplicationArea() {return Flush();}-Result NfpDevice::ExistApplicationArea(bool& has_application_area) {+Result NfcDevice::ExistsApplicationArea(bool& has_application_area) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}has_application_area = tag_data.settings.settings.appdata_initialized.Value() != 0;@@ -891,21 +1006,21 @@ Result NfpDevice::ExistApplicationArea(bool& has_application_area) {return ResultSuccess;}-Result NfpDevice::GetAll(NfpData& data) const {+Result NfcDevice::GetAll(NFP::NfpData& data) const {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}- CommonInfo common_info{};+ NFP::CommonInfo common_info{};Service::Mii::MiiManager manager;const u64 application_id = tag_data.application_id;@@ -930,8 +1045,8 @@ Result NfpDevice::GetAll(NfpData& data) const {.settings_crc_counter = tag_data.settings.crc_counter,.font_region = tag_data.settings.settings.font_region,.tag_type = PackedTagType::Type2,- .console_type =- static_cast<AppAreaVersion>(application_id >> application_id_version_offset & 0xf),+ .console_type = static_cast<NFP::AppAreaVersion>(+ application_id >> NFP::application_id_version_offset & 0xf),.application_id_byte = tag_data.application_id_byte,.application_area = tag_data.application_area,};@@ -939,18 +1054,18 @@ Result NfpDevice::GetAll(NfpData& data) const {return ResultSuccess;}-Result NfpDevice::SetAll(const NfpData& data) {+Result NfcDevice::SetAll(const NFP::NfpData& data) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}tag_data.constant_value = data.magic;@@ -977,18 +1092,18 @@ Result NfpDevice::SetAll(const NfpData& data) {return ResultSuccess;}-Result NfpDevice::BreakTag(BreakType break_type) {+Result NfcDevice::BreakTag(NFP::BreakType break_type) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}// TODO: Complete this implementation@@ -996,28 +1111,28 @@ Result NfpDevice::BreakTag(BreakType break_type) {return FlushWithBreak(break_type);}-Result NfpDevice::ReadBackupData() {+Result NfcDevice::ReadBackupData(std::span<u8> data) const {// Not implementedreturn ResultSuccess;}-Result NfpDevice::WriteBackupData() {+Result NfcDevice::WriteBackupData(std::span<const u8> data) {// Not implementedreturn ResultSuccess;}-Result NfpDevice::WriteNtf() {+Result NfcDevice::WriteNtf(std::span<const u8> data) {if (device_state != DeviceState::TagMounted) {LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);if (device_state == DeviceState::TagRemoved) {- return TagRemoved;+ return ResultTagRemoved;}- return WrongDeviceState;+ return ResultWrongDeviceState;}- if (mount_target == MountTarget::None || mount_target == MountTarget::Rom) {+ if (mount_target == NFP::MountTarget::None || mount_target == NFP::MountTarget::Rom) {LOG_ERROR(Service_NFC, "Amiibo is read only", device_state);- return WrongDeviceState;+ return ResultWrongDeviceState;}// Not implemented@@ -1025,29 +1140,12 @@ Result NfpDevice::WriteNtf() {return ResultSuccess;}-u64 NfpDevice::GetHandle() const {- // Generate a handle based of the npad id- return static_cast<u64>(npad_id);-}--u32 NfpDevice::GetApplicationAreaSize() const {- return sizeof(ApplicationArea);-}--DeviceState NfpDevice::GetCurrentState() const {- return device_state;-}--Core::HID::NpadIdType NfpDevice::GetNpadId() const {- return npad_id;-}--AmiiboName NfpDevice::GetAmiiboName(const AmiiboSettings& settings) const {- std::array<char16_t, amiibo_name_length> settings_amiibo_name{};- AmiiboName amiibo_name{};+NFP::AmiiboName NfcDevice::GetAmiiboName(const NFP::AmiiboSettings& settings) const {+ std::array<char16_t, NFP::amiibo_name_length> settings_amiibo_name{};+ NFP::AmiiboName amiibo_name{};// Convert from big endian to little endian- for (std::size_t i = 0; i < amiibo_name_length; i++) {+ for (std::size_t i = 0; i < NFP::amiibo_name_length; i++) {settings_amiibo_name[i] = static_cast<u16>(settings.amiibo_name[i]);}@@ -1058,8 +1156,8 @@ AmiiboName NfpDevice::GetAmiiboName(const AmiiboSettings& settings) const {return amiibo_name;}-void NfpDevice::SetAmiiboName(AmiiboSettings& settings, const AmiiboName& amiibo_name) {- std::array<char16_t, amiibo_name_length> settings_amiibo_name{};+void NfcDevice::SetAmiiboName(NFP::AmiiboSettings& settings, const NFP::AmiiboName& amiibo_name) {+ std::array<char16_t, NFP::amiibo_name_length> settings_amiibo_name{};// Convert from utf8 to utf16const auto amiibo_name_utf16 = Common::UTF8ToUTF16(amiibo_name.data());@@ -1067,16 +1165,16 @@ void NfpDevice::SetAmiiboName(AmiiboSettings& settings, const AmiiboName& amiiboamiibo_name_utf16.size() * sizeof(char16_t));// Convert from little endian to big endian- for (std::size_t i = 0; i < amiibo_name_length; i++) {+ for (std::size_t i = 0; i < NFP::amiibo_name_length; i++) {settings.amiibo_name[i] = static_cast<u16_be>(settings_amiibo_name[i]);}}-AmiiboDate NfpDevice::GetAmiiboDate(s64 posix_time) const {+NFP::AmiiboDate NfcDevice::GetAmiiboDate(s64 posix_time) const {const auto& time_zone_manager =system.GetTimeManager().GetTimeZoneContentManager().GetTimeZoneManager();Time::TimeZone::CalendarInfo calendar_info{};- AmiiboDate amiibo_date{};+ NFP::AmiiboDate amiibo_date{};amiibo_date.SetYear(2000);amiibo_date.SetMonth(1);@@ -1091,14 +1189,14 @@ AmiiboDate NfpDevice::GetAmiiboDate(s64 posix_time) const {return amiibo_date;}-u64 NfpDevice::RemoveVersionByte(u64 application_id) const {- return application_id & ~(0xfULL << application_id_version_offset);+u64 NfcDevice::RemoveVersionByte(u64 application_id) const {+ return application_id & ~(0xfULL << NFP::application_id_version_offset);}-void NfpDevice::UpdateSettingsCrc() {+void NfcDevice::UpdateSettingsCrc() {auto& settings = tag_data.settings;- if (settings.crc_counter != counter_limit) {+ if (settings.crc_counter != NFP::counter_limit) {settings.crc_counter++;}@@ -1109,7 +1207,7 @@ void NfpDevice::UpdateSettingsCrc() {settings.crc = crc.checksum();}-void NfpDevice::UpdateRegisterInfoCrc() {+void NfcDevice::UpdateRegisterInfoCrc() {#pragma pack(push, 1)struct CrcData {Mii::Ver3StoreData mii;@@ -1134,4 +1232,18 @@ void NfpDevice::UpdateRegisterInfoCrc() {tag_data.register_info_crc = crc.checksum();}-} // namespace Service::NFP+u64 NfcDevice::GetHandle() const {+ // Generate a handle based of the npad id+ return static_cast<u64>(npad_id);+}++DeviceState NfcDevice::GetCurrentState() const {+ return device_state;+}++Result NfcDevice::GetNpadId(Core::HID::NpadIdType& out_npad_id) const {+ out_npad_id = npad_id;+ return ResultSuccess;+}++} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/common/device.h b/src/core/hle/service/nfc/common/device.hnew file mode 100644index 0000000000..654eda98e3--- /dev/null+++ b/src/core/hle/service/nfc/common/device.h@@ -0,0 +1,138 @@+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#pragma once++#include <span>++#include "common/common_types.h"+#include "core/hle/service/kernel_helpers.h"+#include "core/hle/service/nfc/mifare_types.h"+#include "core/hle/service/nfc/nfc_types.h"+#include "core/hle/service/nfp/nfp_types.h"+#include "core/hle/service/service.h"+#include "core/hle/service/time/clock_types.h"++namespace Kernel {+class KEvent;+class KReadableEvent;+} // namespace Kernel++namespace Core {+class System;+} // namespace Core++namespace Core::HID {+class EmulatedController;+enum class ControllerTriggerType;+enum class NpadIdType : u32;+} // namespace Core::HID++namespace Service::NFC {+class NfcDevice {+public:+ NfcDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,+ KernelHelpers::ServiceContext& service_context_,+ Kernel::KEvent* availability_change_event_);+ ~NfcDevice();++ void Initialize();+ void Finalize();++ Result StartDetection(NfcProtocol allowed_protocol);+ Result StopDetection();++ Result GetTagInfo(TagInfo& tag_info, bool is_mifare) const;++ Result ReadMifare(std::span<const MifareReadBlockParameter> parameters,+ std::span<MifareReadBlockData> read_block_data) const;+ Result ReadMifare(const MifareReadBlockParameter& parameter,+ MifareReadBlockData& read_block_data) const;++ Result WriteMifare(std::span<const MifareWriteBlockParameter> parameters);+ Result WriteMifare(const MifareWriteBlockParameter& parameter);++ Result SendCommandByPassThrough(const Time::Clock::TimeSpanType& timeout,+ std::span<const u8> command_data, std::span<u8> out_data);++ Result Mount(NFP::ModelType model_type, NFP::MountTarget mount_target);+ Result Unmount();++ Result Flush();+ Result FlushDebug();+ Result FlushWithBreak(NFP::BreakType break_type);+ Result Restore();++ Result GetCommonInfo(NFP::CommonInfo& common_info) const;+ Result GetModelInfo(NFP::ModelInfo& model_info) const;+ Result GetRegisterInfo(NFP::RegisterInfo& register_info) const;+ Result GetRegisterInfoPrivate(NFP::RegisterInfoPrivate& register_info) const;+ Result GetAdminInfo(NFP::AdminInfo& admin_info) const;++ Result DeleteRegisterInfo();+ Result SetRegisterInfoPrivate(const NFP::RegisterInfoPrivate& register_info);+ Result RestoreAmiibo();+ Result Format();++ Result OpenApplicationArea(u32 access_id);+ Result GetApplicationAreaId(u32& application_area_id) const;+ Result GetApplicationArea(std::span<u8> data) const;+ Result SetApplicationArea(std::span<const u8> data);+ Result CreateApplicationArea(u32 access_id, std::span<const u8> data);+ Result RecreateApplicationArea(u32 access_id, std::span<const u8> data);+ Result DeleteApplicationArea();+ Result ExistsApplicationArea(bool& has_application_area) const;++ Result GetAll(NFP::NfpData& data) const;+ Result SetAll(const NFP::NfpData& data);+ Result BreakTag(NFP::BreakType break_type);+ Result ReadBackupData(std::span<u8> data) const;+ Result WriteBackupData(std::span<const u8> data);+ Result WriteNtf(std::span<const u8> data);++ u64 GetHandle() const;+ DeviceState GetCurrentState() const;+ Result GetNpadId(Core::HID::NpadIdType& out_npad_id) const;++ Kernel::KReadableEvent& GetActivateEvent() const;+ Kernel::KReadableEvent& GetDeactivateEvent() const;++private:+ void NpadUpdate(Core::HID::ControllerTriggerType type);+ bool LoadNfcTag(std::span<const u8> data);+ void CloseNfcTag();++ NFP::AmiiboName GetAmiiboName(const NFP::AmiiboSettings& settings) const;+ void SetAmiiboName(NFP::AmiiboSettings& settings, const NFP::AmiiboName& amiibo_name);+ NFP::AmiiboDate GetAmiiboDate(s64 posix_time) const;+ u64 RemoveVersionByte(u64 application_id) const;+ void UpdateSettingsCrc();+ void UpdateRegisterInfoCrc();++ bool is_controller_set{};+ int callback_key;+ const Core::HID::NpadIdType npad_id;+ Core::System& system;+ Core::HID::EmulatedController* npad_device = nullptr;+ KernelHelpers::ServiceContext& service_context;+ Kernel::KEvent* activate_event = nullptr;+ Kernel::KEvent* deactivate_event = nullptr;+ Kernel::KEvent* availability_change_event = nullptr;++ bool is_initalized{};+ NfcProtocol allowed_protocols{};+ DeviceState device_state{DeviceState::Unavailable};++ // NFP data+ bool is_data_moddified{};+ bool is_app_area_open{};+ bool is_plain_amiibo{};+ s64 current_posix_time{};+ NFP::MountTarget mount_target{NFP::MountTarget::None};++ NFP::NTAG215File tag_data{};+ std::vector<u8> mifare_data{};+ NFP::EncryptedNTAG215File encrypted_tag_data{};+};++} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/common/device_manager.cpp b/src/core/hle/service/nfc/common/device_manager.cppnew file mode 100644index 0000000000..d5deaaf273--- /dev/null+++ b/src/core/hle/service/nfc/common/device_manager.cpp@@ -0,0 +1,695 @@+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#include "common/logging/log.h"+#include "core/core.h"+#include "core/hid/hid_types.h"+#include "core/hle/kernel/k_event.h"+#include "core/hle/service/ipc_helpers.h"+#include "core/hle/service/nfc/common/device.h"+#include "core/hle/service/nfc/common/device_manager.h"+#include "core/hle/service/nfc/nfc_result.h"+#include "core/hle/service/time/clock_types.h"++namespace Service::NFC {++DeviceManager::DeviceManager(Core::System& system_, KernelHelpers::ServiceContext& service_context_)+ : system{system_}, service_context{service_context_} {++ availability_change_event =+ service_context.CreateEvent("Nfc:DeviceManager:AvailabilityChangeEvent");++ for (u32 device_index = 0; device_index < devices.size(); device_index++) {+ devices[device_index] =+ std::make_shared<NfcDevice>(Core::HID::IndexToNpadIdType(device_index), system,+ service_context, availability_change_event);+ }++ is_initialized = false;+}++DeviceManager ::~DeviceManager() {+ service_context.CloseEvent(availability_change_event);+}++Result DeviceManager::Initialize() {+ for (auto& device : devices) {+ device->Initialize();+ }+ is_initialized = true;+ return ResultSuccess;+}++Result DeviceManager::Finalize() {+ for (auto& device : devices) {+ device->Finalize();+ }+ is_initialized = false;+ return ResultSuccess;+}++Result DeviceManager::ListDevices(std::vector<u64>& nfp_devices,+ std::size_t max_allowed_devices) const {+ for (auto& device : devices) {+ if (nfp_devices.size() >= max_allowed_devices) {+ continue;+ }+ if (device->GetCurrentState() != DeviceState::Unavailable) {+ nfp_devices.push_back(device->GetHandle());+ }+ }++ if (nfp_devices.empty()) {+ return ResultDeviceNotFound;+ }++ return ResultSuccess;+}++DeviceState DeviceManager::GetDeviceState(u64 device_handle) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ const auto result = GetDeviceFromHandle(device_handle, device, false);++ if (result.IsSuccess()) {+ return device->GetCurrentState();+ }++ return DeviceState::Unavailable;+}++Result DeviceManager::GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetNpadId(npad_id);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Kernel::KReadableEvent& DeviceManager::AttachAvailabilityChangeEvent() const {+ return availability_change_event->GetReadableEvent();+}++Result DeviceManager::StartDetection(u64 device_handle, NfcProtocol tag_protocol) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->StartDetection(tag_protocol);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::StopDetection(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->StopDetection();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetTagInfo(u64 device_handle, TagInfo& tag_info, bool is_mifare) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetTagInfo(tag_info, is_mifare);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Kernel::KReadableEvent& DeviceManager::AttachActivateEvent(u64 device_handle) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ GetDeviceFromHandle(device_handle, device, false);++ // TODO: Return proper error code on failure+ return device->GetActivateEvent();+}++Kernel::KReadableEvent& DeviceManager::AttachDeactivateEvent(u64 device_handle) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ GetDeviceFromHandle(device_handle, device, false);++ // TODO: Return proper error code on failure+ return device->GetDeactivateEvent();+}++Result DeviceManager::ReadMifare(u64 device_handle,+ std::span<const MifareReadBlockParameter> read_parameters,+ std::span<MifareReadBlockData> read_data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->ReadMifare(read_parameters, read_data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::WriteMifare(u64 device_handle,+ std::span<const MifareWriteBlockParameter> write_parameters) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->WriteMifare(write_parameters);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::SendCommandByPassThrough(u64 device_handle,+ const Time::Clock::TimeSpanType& timeout,+ std::span<const u8> command_data,+ std::span<u8> out_data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->SendCommandByPassThrough(timeout, command_data, out_data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::Mount(u64 device_handle, NFP::ModelType model_type,+ NFP::MountTarget mount_target) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->Mount(model_type, mount_target);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::Unmount(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->Unmount();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::OpenApplicationArea(u64 device_handle, u32 access_id) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->OpenApplicationArea(access_id);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetApplicationArea(u64 device_handle, std::span<u8> data) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetApplicationArea(data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::SetApplicationArea(u64 device_handle, std::span<const u8> data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->SetApplicationArea(data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::Flush(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->Flush();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::Restore(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->Restore();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::CreateApplicationArea(u64 device_handle, u32 access_id,+ std::span<const u8> data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->CreateApplicationArea(access_id, data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetRegisterInfo(register_info);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetCommonInfo(common_info);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetModelInfo(model_info);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++u32 DeviceManager::GetApplicationAreaSize() const {+ return sizeof(NFP::ApplicationArea);+}++Result DeviceManager::RecreateApplicationArea(u64 device_handle, u32 access_id,+ std::span<const u8> data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->RecreateApplicationArea(access_id, data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::Format(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->Format();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetAdminInfo(admin_info);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetRegisterInfoPrivate(u64 device_handle,+ NFP::RegisterInfoPrivate& register_info) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetRegisterInfoPrivate(register_info);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::SetRegisterInfoPrivate(u64 device_handle,+ const NFP::RegisterInfoPrivate& register_info) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->SetRegisterInfoPrivate(register_info);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::DeleteRegisterInfo(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->DeleteRegisterInfo();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::DeleteApplicationArea(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->DeleteApplicationArea();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::ExistsApplicationArea(u64 device_handle, bool& has_application_area) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->ExistsApplicationArea(has_application_area);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetAll(u64 device_handle, NFP::NfpData& nfp_data) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->GetAll(nfp_data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::SetAll(u64 device_handle, const NFP::NfpData& nfp_data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->SetAll(nfp_data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::FlushDebug(u64 device_handle) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->FlushDebug();+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::BreakTag(u64 device_handle, NFP::BreakType break_type) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->BreakTag(break_type);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::ReadBackupData(u64 device_handle, std::span<u8> data) const {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->ReadBackupData(data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::WriteBackupData(u64 device_handle, std::span<const u8> data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->WriteBackupData(data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::WriteNtf(u64 device_handle, NFP::WriteType, std::span<const u8> data) {+ std::scoped_lock lock{mutex};++ std::shared_ptr<NfcDevice> device = nullptr;+ auto result = GetDeviceHandle(device_handle, device);++ if (result.IsSuccess()) {+ result = device->WriteNtf(data);+ result = VerifyDeviceResult(device, result);+ }++ return result;+}++Result DeviceManager::GetDeviceFromHandle(u64 handle, std::shared_ptr<NfcDevice>& nfc_device,+ bool check_state) const {+ if (check_state) {+ const Result is_parameter_set = IsNfcParameterSet();+ if (is_parameter_set.IsError()) {+ return is_parameter_set;+ }+ const Result is_enabled = IsNfcEnabled();+ if (is_enabled.IsError()) {+ return is_enabled;+ }+ const Result is_nfc_initialized = IsNfcInitialized();+ if (is_nfc_initialized.IsError()) {+ return is_nfc_initialized;+ }+ }++ for (auto& device : devices) {+ if (device->GetHandle() == handle) {+ nfc_device = device;+ return ResultSuccess;+ }+ }++ return ResultDeviceNotFound;+}++std::optional<std::shared_ptr<NfcDevice>> DeviceManager::GetNfcDevice(u64 handle) {+ for (auto& device : devices) {+ if (device->GetHandle() == handle) {+ return device;+ }+ }+ return std::nullopt;+}++const std::optional<std::shared_ptr<NfcDevice>> DeviceManager::GetNfcDevice(u64 handle) const {+ for (auto& device : devices) {+ if (device->GetHandle() == handle) {+ return device;+ }+ }+ return std::nullopt;+}++Result DeviceManager::GetDeviceHandle(u64 handle, std::shared_ptr<NfcDevice>& device) const {+ const auto result = GetDeviceFromHandle(handle, device, true);+ if (result.IsError()) {+ return result;+ }+ return CheckDeviceState(device);+}++Result DeviceManager::VerifyDeviceResult(std::shared_ptr<NfcDevice> device,+ Result operation_result) const {+ if (operation_result.IsSuccess()) {+ return operation_result;+ }++ const Result is_parameter_set = IsNfcParameterSet();+ if (is_parameter_set.IsError()) {+ return is_parameter_set;+ }+ const Result is_enabled = IsNfcEnabled();+ if (is_enabled.IsError()) {+ return is_enabled;+ }+ const Result is_nfc_initialized = IsNfcInitialized();+ if (is_nfc_initialized.IsError()) {+ return is_nfc_initialized;+ }+ const Result device_state = CheckDeviceState(device);+ if (device_state.IsError()) {+ return device_state;+ }++ return operation_result;+}++Result DeviceManager::CheckDeviceState(std::shared_ptr<NfcDevice> device) const {+ if (device == nullptr) {+ return ResultInvalidArgument;+ }++ return ResultSuccess;+}++Result DeviceManager::IsNfcEnabled() const {+ // TODO: This calls nn::settings::detail::GetNfcEnableFlag+ const bool is_enabled = true;+ if (!is_enabled) {+ return ResultNfcDisabled;+ }+ return ResultSuccess;+}++Result DeviceManager::IsNfcParameterSet() const {+ // TODO: This calls checks against a bool on offset 0x450+ const bool is_set = true;+ if (!is_set) {+ return ResultUnknown76;+ }+ return ResultSuccess;+}++Result DeviceManager::IsNfcInitialized() const {+ if (!is_initialized) {+ return ResultNfcNotInitialized;+ }+ return ResultSuccess;+}++} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/common/device_manager.h b/src/core/hle/service/nfc/common/device_manager.hnew file mode 100644index 0000000000..2971e280f3--- /dev/null+++ b/src/core/hle/service/nfc/common/device_manager.h@@ -0,0 +1,100 @@+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#pragma once++#include <array>+#include <memory>+#include <optional>+#include <span>++#include "core/hid/hid_types.h"+#include "core/hle/service/kernel_helpers.h"+#include "core/hle/service/nfc/mifare_types.h"+#include "core/hle/service/nfc/nfc_types.h"+#include "core/hle/service/nfp/nfp_types.h"+#include "core/hle/service/service.h"+#include "core/hle/service/time/clock_types.h"++namespace Service::NFC {+class NfcDevice;++class DeviceManager {+public:+ explicit DeviceManager(Core::System& system_, KernelHelpers::ServiceContext& service_context_);+ ~DeviceManager();++ // Nfc device manager+ Result Initialize();+ Result Finalize();+ Result ListDevices(std::vector<u64>& nfp_devices, std::size_t max_allowed_devices) const;+ DeviceState GetDeviceState(u64 device_handle) const;+ Result GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) const;+ Kernel::KReadableEvent& AttachAvailabilityChangeEvent() const;+ Result StartDetection(u64 device_handle, NfcProtocol tag_protocol);+ Result StopDetection(u64 device_handle);+ Result GetTagInfo(u64 device_handle, NFP::TagInfo& tag_info, bool is_mifare) const;+ Kernel::KReadableEvent& AttachActivateEvent(u64 device_handle) const;+ Kernel::KReadableEvent& AttachDeactivateEvent(u64 device_handle) const;+ Result ReadMifare(u64 device_handle,+ const std::span<const MifareReadBlockParameter> read_parameters,+ std::span<MifareReadBlockData> read_data);+ Result WriteMifare(u64 device_handle,+ std::span<const MifareWriteBlockParameter> write_parameters);+ Result SendCommandByPassThrough(u64 device_handle, const Time::Clock::TimeSpanType& timeout,+ std::span<const u8> command_data, std::span<u8> out_data);++ // Nfp device manager+ Result Mount(u64 device_handle, NFP::ModelType model_type, NFP::MountTarget mount_target);+ Result Unmount(u64 device_handle);+ Result OpenApplicationArea(u64 device_handle, u32 access_id);+ Result GetApplicationArea(u64 device_handle, std::span<u8> data) const;+ Result SetApplicationArea(u64 device_handle, std::span<const u8> data);+ Result Flush(u64 device_handle);+ Result Restore(u64 device_handle);+ Result CreateApplicationArea(u64 device_handle, u32 access_id, std::span<const u8> data);+ Result GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) const;+ Result GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) const;+ Result GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) const;+ u32 GetApplicationAreaSize() const;+ Result RecreateApplicationArea(u64 device_handle, u32 access_id, std::span<const u8> data);+ Result Format(u64 device_handle);+ Result GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) const;+ Result GetRegisterInfoPrivate(u64 device_handle, NFP::RegisterInfoPrivate& register_info) const;+ Result SetRegisterInfoPrivate(u64 device_handle, const NFP::RegisterInfoPrivate& register_info);+ Result DeleteRegisterInfo(u64 device_handle);+ Result DeleteApplicationArea(u64 device_handle);+ Result ExistsApplicationArea(u64 device_handle, bool& has_application_area) const;+ Result GetAll(u64 device_handle, NFP::NfpData& nfp_data) const;+ Result SetAll(u64 device_handle, const NFP::NfpData& nfp_data);+ Result FlushDebug(u64 device_handle);+ Result BreakTag(u64 device_handle, NFP::BreakType break_type);+ Result ReadBackupData(u64 device_handle, std::span<u8> data) const;+ Result WriteBackupData(u64 device_handle, std::span<const u8> data);+ Result WriteNtf(u64 device_handle, NFP::WriteType, std::span<const u8> data);++private:+ Result IsNfcEnabled() const;+ Result IsNfcParameterSet() const;+ Result IsNfcInitialized() const;++ Result GetDeviceFromHandle(u64 handle, std::shared_ptr<NfcDevice>& device,+ bool check_state) const;++ Result GetDeviceHandle(u64 handle, std::shared_ptr<NfcDevice>& device) const;+ Result VerifyDeviceResult(std::shared_ptr<NfcDevice> device, Result operation_result) const;+ Result CheckDeviceState(std::shared_ptr<NfcDevice> device) const;++ std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle);+ const std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle) const;++ bool is_initialized = false;+ mutable std::mutex mutex;+ std::array<std::shared_ptr<NfcDevice>, 10> devices{};++ Core::System& system;+ KernelHelpers::ServiceContext service_context;+ Kernel::KEvent* availability_change_event;+};++} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/mifare_interface.cpp b/src/core/hle/service/nfc/mifare_interface.cppdeleted file mode 100644index 7e6635ba2d..0000000000--- a/src/core/hle/service/nfc/mifare_interface.cpp+++ /dev/null@@ -1,382 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include "common/logging/log.h"-#include "core/core.h"-#include "core/hid/hid_types.h"-#include "core/hle/kernel/k_event.h"-#include "core/hle/service/ipc_helpers.h"-#include "core/hle/service/nfc/mifare_interface.h"-#include "core/hle/service/nfc/nfc_device.h"-#include "core/hle/service/nfc/nfc_result.h"--namespace Service::NFC {--MFInterface::MFInterface(Core::System& system_, const char* name)- : ServiceFramework{system_, name}, service_context{system_, service_name} {- availability_change_event = service_context.CreateEvent("MFInterface:AvailabilityChangeEvent");-- for (u32 device_index = 0; device_index < 10; device_index++) {- devices[device_index] =- std::make_shared<NfcDevice>(Core::HID::IndexToNpadIdType(device_index), system,- service_context, availability_change_event);- }-}--MFInterface ::~MFInterface() {- availability_change_event->Close();-}--void MFInterface::Initialize(HLERequestContext& ctx) {- LOG_INFO(Service_NFC, "called");-- state = State::Initialized;-- for (auto& device : devices) {- device->Initialize();- }-- IPC::ResponseBuilder rb{ctx, 2, 0};- rb.Push(ResultSuccess);-}--void MFInterface::Finalize(HLERequestContext& ctx) {- LOG_INFO(Service_NFC, "called");-- state = State::NonInitialized;-- for (auto& device : devices) {- device->Finalize();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);-}--void MFInterface::ListDevices(HLERequestContext& ctx) {- LOG_DEBUG(Service_NFC, "called");-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- if (!ctx.CanWriteBuffer()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareInvalidArgument);- return;- }-- if (ctx.GetWriteBufferSize() == 0) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareInvalidArgument);- return;- }-- std::vector<u64> nfp_devices;- const std::size_t max_allowed_devices = ctx.GetWriteBufferNumElements<u64>();-- for (const auto& device : devices) {- if (nfp_devices.size() >= max_allowed_devices) {- continue;- }- if (device->GetCurrentState() != NFP::DeviceState::Unavailable) {- nfp_devices.push_back(device->GetHandle());- }- }-- if (nfp_devices.empty()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- ctx.WriteBuffer(nfp_devices);-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.Push(static_cast<s32>(nfp_devices.size()));-}--void MFInterface::StartDetection(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- const auto result = device.value()->StartDetection(NFP::TagProtocol::All);- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);-}--void MFInterface::StopDetection(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- const auto result = device.value()->StopDetection();- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);-}--void MFInterface::Read(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- const auto buffer{ctx.ReadBuffer()};- const auto number_of_commands{ctx.GetReadBufferNumElements<NFP::MifareReadBlockParameter>()};- std::vector<NFP::MifareReadBlockParameter> read_commands(number_of_commands);-- memcpy(read_commands.data(), buffer.data(),- number_of_commands * sizeof(NFP::MifareReadBlockParameter));-- LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, read_commands_size={}",- device_handle, number_of_commands);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- Result result = ResultSuccess;- std::vector<NFP::MifareReadBlockData> out_data(number_of_commands);- for (std::size_t i = 0; i < number_of_commands; i++) {- result = device.value()->MifareRead(read_commands[i], out_data[i]);- if (result.IsError()) {- break;- }- }-- ctx.WriteBuffer(out_data);- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);-}--void MFInterface::Write(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- const auto buffer{ctx.ReadBuffer()};- const auto number_of_commands{ctx.GetReadBufferNumElements<NFP::MifareWriteBlockParameter>()};- std::vector<NFP::MifareWriteBlockParameter> write_commands(number_of_commands);-- memcpy(write_commands.data(), buffer.data(),- number_of_commands * sizeof(NFP::MifareWriteBlockParameter));-- LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, write_commands_size={}",- device_handle, number_of_commands);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- Result result = ResultSuccess;- std::vector<NFP::MifareReadBlockData> out_data(number_of_commands);- for (std::size_t i = 0; i < number_of_commands; i++) {- result = device.value()->MifareWrite(write_commands[i]);- if (result.IsError()) {- break;- }- }-- if (result.IsSuccess()) {- result = device.value()->Flush();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);-}--void MFInterface::GetTagInfo(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- NFP::TagInfo tag_info{};- const auto result = device.value()->GetTagInfo(tag_info, true);- ctx.WriteBuffer(tag_info);- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);-}--void MFInterface::GetActivateEventHandle(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 2, 1};- rb.Push(ResultSuccess);- rb.PushCopyObjects(device.value()->GetActivateEvent());-}--void MFInterface::GetDeactivateEventHandle(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 2, 1};- rb.Push(ResultSuccess);- rb.PushCopyObjects(device.value()->GetDeactivateEvent());-}--void MFInterface::GetState(HLERequestContext& ctx) {- LOG_DEBUG(Service_NFC, "called");-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.PushEnum(state);-}--void MFInterface::GetDeviceState(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.PushEnum(device.value()->GetCurrentState());-}--void MFInterface::GetNpadId(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareDeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.PushEnum(device.value()->GetNpadId());-}--void MFInterface::GetAvailabilityChangeEventHandle(HLERequestContext& ctx) {- LOG_INFO(Service_NFC, "called");-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(MifareNfcDisabled);- return;- }-- IPC::ResponseBuilder rb{ctx, 2, 1};- rb.Push(ResultSuccess);- rb.PushCopyObjects(availability_change_event->GetReadableEvent());-}--std::optional<std::shared_ptr<NfcDevice>> MFInterface::GetNfcDevice(u64 handle) {- for (auto& device : devices) {- if (device->GetHandle() == handle) {- return device;- }- }- return std::nullopt;-}--} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/mifare_interface.h b/src/core/hle/service/nfc/mifare_interface.hdeleted file mode 100644index 698c8a6b63..0000000000--- a/src/core/hle/service/nfc/mifare_interface.h+++ /dev/null@@ -1,52 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include <array>-#include <memory>-#include <optional>--#include "core/hle/service/kernel_helpers.h"-#include "core/hle/service/service.h"--namespace Service::NFC {-class NfcDevice;--class MFInterface : public ServiceFramework<MFInterface> {-public:- explicit MFInterface(Core::System& system_, const char* name);- ~MFInterface();-- void Initialize(HLERequestContext& ctx);- void Finalize(HLERequestContext& ctx);- void ListDevices(HLERequestContext& ctx);- void StartDetection(HLERequestContext& ctx);- void StopDetection(HLERequestContext& ctx);- void Read(HLERequestContext& ctx);- void Write(HLERequestContext& ctx);- void GetTagInfo(HLERequestContext& ctx);- void GetActivateEventHandle(HLERequestContext& ctx);- void GetDeactivateEventHandle(HLERequestContext& ctx);- void GetState(HLERequestContext& ctx);- void GetDeviceState(HLERequestContext& ctx);- void GetNpadId(HLERequestContext& ctx);- void GetAvailabilityChangeEventHandle(HLERequestContext& ctx);--private:- enum class State : u32 {- NonInitialized,- Initialized,- };-- std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle);-- KernelHelpers::ServiceContext service_context;-- std::array<std::shared_ptr<NfcDevice>, 10> devices{};-- State state{State::NonInitialized};- Kernel::KEvent* availability_change_event;-};--} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/mifare_result.h b/src/core/hle/service/nfc/mifare_result.hnew file mode 100644index 0000000000..4b60048a56--- /dev/null+++ b/src/core/hle/service/nfc/mifare_result.h@@ -0,0 +1,17 @@+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#pragma once++#include "core/hle/result.h"++namespace Service::NFC::Mifare {++constexpr Result ResultDeviceNotFound(ErrorModule::NFCMifare, 64);+constexpr Result ResultInvalidArgument(ErrorModule::NFCMifare, 65);+constexpr Result ResultWrongDeviceState(ErrorModule::NFCMifare, 73);+constexpr Result ResultNfcDisabled(ErrorModule::NFCMifare, 80);+constexpr Result ResultTagRemoved(ErrorModule::NFCMifare, 97);+constexpr Result ResultReadError(ErrorModule::NFCMifare, 288);++} // namespace Service::NFC::Mifarediff --git a/src/core/hle/service/nfc/mifare_types.h b/src/core/hle/service/nfc/mifare_types.hnew file mode 100644index 0000000000..75b59f0211--- /dev/null+++ b/src/core/hle/service/nfc/mifare_types.h@@ -0,0 +1,63 @@+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#pragma once++#include <array>++#include "common/common_funcs.h"+#include "common/common_types.h"++namespace Service::NFC {++enum class MifareCmd : u8 {+ AuthA = 0x60,+ AuthB = 0x61,+ Read = 0x30,+ Write = 0xA0,+ Transfer = 0xB0,+ Decrement = 0xC0,+ Increment = 0xC1,+ Store = 0xC2+};++using DataBlock = std::array<u8, 0x10>;+using KeyData = std::array<u8, 0x6>;++struct SectorKey {+ MifareCmd command;+ u8 unknown; // Usually 1+ INSERT_PADDING_BYTES(0x6);+ KeyData sector_key;+ INSERT_PADDING_BYTES(0x2);+};+static_assert(sizeof(SectorKey) == 0x10, "SectorKey is an invalid size");++// This is nn::nfc::MifareReadBlockParameter+struct MifareReadBlockParameter {+ u8 sector_number;+ INSERT_PADDING_BYTES(0x7);+ SectorKey sector_key;+};+static_assert(sizeof(MifareReadBlockParameter) == 0x18,+ "MifareReadBlockParameter is an invalid size");++// This is nn::nfc::MifareReadBlockData+struct MifareReadBlockData {+ DataBlock data;+ u8 sector_number;+ INSERT_PADDING_BYTES(0x7);+};+static_assert(sizeof(MifareReadBlockData) == 0x18, "MifareReadBlockData is an invalid size");++// This is nn::nfc::MifareWriteBlockParameter+struct MifareWriteBlockParameter {+ DataBlock data;+ u8 sector_number;+ INSERT_PADDING_BYTES(0x7);+ SectorKey sector_key;+};+static_assert(sizeof(MifareWriteBlockParameter) == 0x28,+ "MifareWriteBlockParameter is an invalid size");++} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/nfc.cpp b/src/core/hle/service/nfc/nfc.cppindex 444d65f074..30ae989b9b 100644--- a/src/core/hle/service/nfc/nfc.cpp+++ b/src/core/hle/service/nfc/nfc.cpp@@ -6,7 +6,6 @@#include "common/logging/log.h"#include "common/settings.h"#include "core/hle/service/ipc_helpers.h"-#include "core/hle/service/nfc/mifare_interface.h"#include "core/hle/service/nfc/nfc.h"#include "core/hle/service/nfc/nfc_interface.h"#include "core/hle/service/server_manager.h"@@ -14,31 +13,31 @@namespace Service::NFC {-class IUser final : public Interface {+class IUser final : public NfcInterface {public:- explicit IUser(Core::System& system_) : Interface(system_, "NFC::IUser") {+ explicit IUser(Core::System& system_) : NfcInterface(system_, "NFC::IUser", BackendType::Nfc) {// clang-format offstatic const FunctionInfo functions[] = {- {0, &Interface::Initialize, "InitializeOld"},- {1, &Interface::Finalize, "FinalizeOld"},- {2, &Interface::GetState, "GetStateOld"},- {3, &Interface::IsNfcEnabled, "IsNfcEnabledOld"},- {400, &Interface::Initialize, "Initialize"},- {401, &Interface::Finalize, "Finalize"},- {402, &Interface::GetState, "GetState"},- {403, &Interface::IsNfcEnabled, "IsNfcEnabled"},- {404, &Interface::ListDevices, "ListDevices"},- {405, &Interface::GetDeviceState, "GetDeviceState"},- {406, &Interface::GetNpadId, "GetNpadId"},- {407, &Interface::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},- {408, &Interface::StartDetection, "StartDetection"},- {409, &Interface::StopDetection, "StopDetection"},- {410, &Interface::GetTagInfo, "GetTagInfo"},- {411, &Interface::AttachActivateEvent, "AttachActivateEvent"},- {412, &Interface::AttachDeactivateEvent, "AttachDeactivateEvent"},- {1000, nullptr, "ReadMifare"},- {1001, nullptr, "WriteMifare"},- {1300, &Interface::SendCommandByPassThrough, "SendCommandByPassThrough"},+ {0, &NfcInterface::Initialize, "InitializeOld"},+ {1, &NfcInterface::Finalize, "FinalizeOld"},+ {2, &NfcInterface::GetState, "GetStateOld"},+ {3, &NfcInterface::IsNfcEnabled, "IsNfcEnabledOld"},+ {400, &NfcInterface::Initialize, "Initialize"},+ {401, &NfcInterface::Finalize, "Finalize"},+ {402, &NfcInterface::GetState, "GetState"},+ {403, &NfcInterface::IsNfcEnabled, "IsNfcEnabled"},+ {404, &NfcInterface::ListDevices, "ListDevices"},+ {405, &NfcInterface::GetDeviceState, "GetDeviceState"},+ {406, &NfcInterface::GetNpadId, "GetNpadId"},+ {407, &NfcInterface::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},+ {408, &NfcInterface::StartDetection, "StartDetection"},+ {409, &NfcInterface::StopDetection, "StopDetection"},+ {410, &NfcInterface::GetTagInfo, "GetTagInfo"},+ {411, &NfcInterface::AttachActivateEvent, "AttachActivateEvent"},+ {412, &NfcInterface::AttachDeactivateEvent, "AttachDeactivateEvent"},+ {1000, &NfcInterface::ReadMifare, "ReadMifare"},+ {1001, &NfcInterface::WriteMifare ,"WriteMifare"},+ {1300, &NfcInterface::SendCommandByPassThrough, "SendCommandByPassThrough"},{1301, nullptr, "KeepPassThroughSession"},{1302, nullptr, "ReleasePassThroughSession"},};@@ -48,34 +47,35 @@ public:}};-class ISystem final : public Interface {+class ISystem final : public NfcInterface {public:- explicit ISystem(Core::System& system_) : Interface{system_, "NFC::ISystem"} {+ explicit ISystem(Core::System& system_)+ : NfcInterface{system_, "NFC::ISystem", BackendType::Nfc} {// clang-format offstatic const FunctionInfo functions[] = {- {0, &Interface::Initialize, "InitializeOld"},- {1, &Interface::Finalize, "FinalizeOld"},- {2, &Interface::GetState, "GetStateOld"},- {3, &Interface::IsNfcEnabled, "IsNfcEnabledOld"},+ {0, &NfcInterface::Initialize, "InitializeOld"},+ {1, &NfcInterface::Finalize, "FinalizeOld"},+ {2, &NfcInterface::GetState, "GetStateOld"},+ {3, &NfcInterface::IsNfcEnabled, "IsNfcEnabledOld"},{100, nullptr, "SetNfcEnabledOld"},- {400, &Interface::Initialize, "Initialize"},- {401, &Interface::Finalize, "Finalize"},- {402, &Interface::GetState, "GetState"},- {403, &Interface::IsNfcEnabled, "IsNfcEnabled"},- {404, &Interface::ListDevices, "ListDevices"},- {405, &Interface::GetDeviceState, "GetDeviceState"},- {406, &Interface::GetNpadId, "GetNpadId"},- {407, &Interface::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},- {408, &Interface::StartDetection, "StartDetection"},- {409, &Interface::StopDetection, "StopDetection"},- {410, &Interface::GetTagInfo, "GetTagInfo"},- {411, &Interface::AttachActivateEvent, "AttachActivateEvent"},- {412, &Interface::AttachDeactivateEvent, "AttachDeactivateEvent"},+ {400, &NfcInterface::Initialize, "Initialize"},+ {401, &NfcInterface::Finalize, "Finalize"},+ {402, &NfcInterface::GetState, "GetState"},+ {403, &NfcInterface::IsNfcEnabled, "IsNfcEnabled"},+ {404, &NfcInterface::ListDevices, "ListDevices"},+ {405, &NfcInterface::GetDeviceState, "GetDeviceState"},+ {406, &NfcInterface::GetNpadId, "GetNpadId"},+ {407, &NfcInterface::AttachAvailabilityChangeEvent, "AttachAvailabilityChangeEvent"},+ {408, &NfcInterface::StartDetection, "StartDetection"},+ {409, &NfcInterface::StopDetection, "StopDetection"},+ {410, &NfcInterface::GetTagInfo, "GetTagInfo"},+ {411, &NfcInterface::AttachActivateEvent, "AttachActivateEvent"},+ {412, &NfcInterface::AttachDeactivateEvent, "AttachDeactivateEvent"},{500, nullptr, "SetNfcEnabled"},{510, nullptr, "OutputTestWave"},- {1000, nullptr, "ReadMifare"},- {1001, nullptr, "WriteMifare"},- {1300, &Interface::SendCommandByPassThrough, "SendCommandByPassThrough"},+ {1000, &NfcInterface::ReadMifare, "ReadMifare"},+ {1001, &NfcInterface::WriteMifare, "WriteMifare"},+ {1300, &NfcInterface::SendCommandByPassThrough, "SendCommandByPassThrough"},{1301, nullptr, "KeepPassThroughSession"},{1302, nullptr, "ReleasePassThroughSession"},};@@ -85,25 +85,29 @@ public:}};+// MFInterface has an unique interface but it's identical to NfcInterface so we can keep the code+// simpler+using MFInterface = NfcInterface;class MFIUser final : public MFInterface {public:- explicit MFIUser(Core::System& system_) : MFInterface{system_, "NFC::MFInterface"} {+ explicit MFIUser(Core::System& system_)+ : MFInterface{system_, "NFC::MFInterface", BackendType::Mifare} {// clang-format off- static const FunctionInfo functions[] = {+ static const FunctionInfoTyped<MFIUser> functions[] = {{0, &MFIUser::Initialize, "Initialize"},{1, &MFIUser::Finalize, "Finalize"},{2, &MFIUser::ListDevices, "ListDevices"},{3, &MFIUser::StartDetection, "StartDetection"},{4, &MFIUser::StopDetection, "StopDetection"},- {5, &MFIUser::Read, "Read"},- {6, &MFIUser::Write, "Write"},+ {5, &MFIUser::ReadMifare, "Read"},+ {6, &MFIUser::WriteMifare, "Write"},{7, &MFIUser::GetTagInfo, "GetTagInfo"},- {8, &MFIUser::GetActivateEventHandle, "GetActivateEventHandle"},- {9, &MFIUser::GetDeactivateEventHandle, "GetDeactivateEventHandle"},+ {8, &MFIUser::AttachActivateEvent, "GetActivateEventHandle"},+ {9, &MFIUser::AttachDeactivateEvent, "GetDeactivateEventHandle"},{10, &MFIUser::GetState, "GetState"},{11, &MFIUser::GetDeviceState, "GetDeviceState"},{12, &MFIUser::GetNpadId, "GetNpadId"},- {13, &MFIUser::GetAvailabilityChangeEventHandle, "GetAvailabilityChangeEventHandle"},+ {13, &MFIUser::AttachAvailabilityChangeEvent, "GetAvailabilityChangeEventHandle"},};// clang-format on@@ -131,7 +135,7 @@ public:explicit NFC_AM(Core::System& system_) : ServiceFramework{system_, "nfc:am"} {// clang-format offstatic const FunctionInfo functions[] = {- {0, &NFC_AM::CreateAmInterface, "CreateAmInterface"},+ {0, &NFC_AM::CreateAmNfcInterface, "CreateAmNfcInterface"},};// clang-format on@@ -139,7 +143,7 @@ public:}private:- void CreateAmInterface(HLERequestContext& ctx) {+ void CreateAmNfcInterface(HLERequestContext& ctx) {LOG_DEBUG(Service_NFC, "called");IPC::ResponseBuilder rb{ctx, 2, 0, 1};@@ -153,7 +157,7 @@ public:explicit NFC_MF_U(Core::System& system_) : ServiceFramework{system_, "nfc:mf:u"} {// clang-format offstatic const FunctionInfo functions[] = {- {0, &NFC_MF_U::CreateUserInterface, "CreateUserInterface"},+ {0, &NFC_MF_U::CreateUserNfcInterface, "CreateUserNfcInterface"},};// clang-format on@@ -161,7 +165,7 @@ public:}private:- void CreateUserInterface(HLERequestContext& ctx) {+ void CreateUserNfcInterface(HLERequestContext& ctx) {LOG_DEBUG(Service_NFC, "called");IPC::ResponseBuilder rb{ctx, 2, 0, 1};@@ -175,7 +179,7 @@ public:explicit NFC_U(Core::System& system_) : ServiceFramework{system_, "nfc:user"} {// clang-format offstatic const FunctionInfo functions[] = {- {0, &NFC_U::CreateUserInterface, "CreateUserInterface"},+ {0, &NFC_U::CreateUserNfcInterface, "CreateUserNfcInterface"},};// clang-format on@@ -183,7 +187,7 @@ public:}private:- void CreateUserInterface(HLERequestContext& ctx) {+ void CreateUserNfcInterface(HLERequestContext& ctx) {LOG_DEBUG(Service_NFC, "called");IPC::ResponseBuilder rb{ctx, 2, 0, 1};@@ -197,7 +201,7 @@ public:explicit NFC_SYS(Core::System& system_) : ServiceFramework{system_, "nfc:sys"} {// clang-format offstatic const FunctionInfo functions[] = {- {0, &NFC_SYS::CreateSystemInterface, "CreateSystemInterface"},+ {0, &NFC_SYS::CreateSystemNfcInterface, "CreateSystemNfcInterface"},};// clang-format on@@ -205,7 +209,7 @@ public:}private:- void CreateSystemInterface(HLERequestContext& ctx) {+ void CreateSystemNfcInterface(HLERequestContext& ctx) {LOG_DEBUG(Service_NFC, "called");IPC::ResponseBuilder rb{ctx, 2, 0, 1};@@ -221,6 +225,7 @@ void LoopProcess(Core::System& system) {server_manager->RegisterNamedService("nfc:mf:u", std::make_shared<NFC_MF_U>(system));server_manager->RegisterNamedService("nfc:user", std::make_shared<NFC_U>(system));server_manager->RegisterNamedService("nfc:sys", std::make_shared<NFC_SYS>(system));+ServerManager::RunServer(std::move(server_manager));}diff --git a/src/core/hle/service/nfc/nfc_device.cpp b/src/core/hle/service/nfc/nfc_device.cppdeleted file mode 100644index 47bc1a05dc..0000000000--- a/src/core/hle/service/nfc/nfc_device.cpp+++ /dev/null@@ -1,287 +0,0 @@-// 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 "core/core.h"-#include "core/hid/emulated_controller.h"-#include "core/hid/hid_core.h"-#include "core/hid/hid_types.h"-#include "core/hle/kernel/k_event.h"-#include "core/hle/service/ipc_helpers.h"-#include "core/hle/service/nfc/nfc_device.h"-#include "core/hle/service/nfc/nfc_result.h"--namespace Service::NFC {-NfcDevice::NfcDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,- KernelHelpers::ServiceContext& service_context_,- Kernel::KEvent* availability_change_event_)- : npad_id{npad_id_}, system{system_}, service_context{service_context_},- availability_change_event{availability_change_event_} {- activate_event = service_context.CreateEvent("IUser:NFCActivateEvent");- deactivate_event = service_context.CreateEvent("IUser:NFCDeactivateEvent");- npad_device = system.HIDCore().GetEmulatedController(npad_id);-- Core::HID::ControllerUpdateCallback engine_callback{- .on_change = [this](Core::HID::ControllerTriggerType type) { NpadUpdate(type); },- .is_npad_service = false,- };- is_controller_set = true;- callback_key = npad_device->SetCallback(engine_callback);-}--NfcDevice::~NfcDevice() {- activate_event->Close();- deactivate_event->Close();- if (!is_controller_set) {- return;- }- npad_device->DeleteCallback(callback_key);- is_controller_set = false;-};--void NfcDevice::NpadUpdate(Core::HID::ControllerTriggerType type) {- if (!is_initalized) {- return;- }-- if (type == Core::HID::ControllerTriggerType::Connected) {- Initialize();- availability_change_event->Signal();- return;- }-- if (type == Core::HID::ControllerTriggerType::Disconnected) {- device_state = NFP::DeviceState::Unavailable;- availability_change_event->Signal();- return;- }-- if (type != Core::HID::ControllerTriggerType::Nfc) {- return;- }-- if (!npad_device->IsConnected()) {- return;- }-- const auto nfc_status = npad_device->GetNfc();- switch (nfc_status.state) {- case Common::Input::NfcState::NewAmiibo:- LoadNfcTag(nfc_status.data);- break;- case Common::Input::NfcState::AmiiboRemoved:- if (device_state != NFP::DeviceState::SearchingForTag) {- CloseNfcTag();- }- break;- default:- break;- }-}--bool NfcDevice::LoadNfcTag(std::span<const u8> data) {- if (device_state != NFP::DeviceState::SearchingForTag) {- LOG_ERROR(Service_NFC, "Game is not looking for nfc tag, current state {}", device_state);- return false;- }-- if (data.size() < sizeof(NFP::EncryptedNTAG215File)) {- LOG_ERROR(Service_NFC, "Not an amiibo, size={}", data.size());- return false;- }-- tag_data.resize(data.size());- memcpy(tag_data.data(), data.data(), data.size());- memcpy(&encrypted_tag_data, data.data(), sizeof(NFP::EncryptedNTAG215File));-- device_state = NFP::DeviceState::TagFound;- deactivate_event->GetReadableEvent().Clear();- activate_event->Signal();- return true;-}--void NfcDevice::CloseNfcTag() {- LOG_INFO(Service_NFC, "Remove nfc tag");-- device_state = NFP::DeviceState::TagRemoved;- encrypted_tag_data = {};- activate_event->GetReadableEvent().Clear();- deactivate_event->Signal();-}--Kernel::KReadableEvent& NfcDevice::GetActivateEvent() const {- return activate_event->GetReadableEvent();-}--Kernel::KReadableEvent& NfcDevice::GetDeactivateEvent() const {- return deactivate_event->GetReadableEvent();-}--void NfcDevice::Initialize() {- device_state =- npad_device->HasNfc() ? NFP::DeviceState::Initialized : NFP::DeviceState::Unavailable;- encrypted_tag_data = {};- is_initalized = true;-}--void NfcDevice::Finalize() {- if (device_state == NFP::DeviceState::SearchingForTag ||- device_state == NFP::DeviceState::TagRemoved) {- StopDetection();- }- device_state = NFP::DeviceState::Unavailable;- is_initalized = false;-}--Result NfcDevice::StartDetection(NFP::TagProtocol allowed_protocol) {- if (device_state != NFP::DeviceState::Initialized &&- device_state != NFP::DeviceState::TagRemoved) {- LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);- return WrongDeviceState;- }-- if (npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,- Common::Input::PollingMode::NFC) !=- Common::Input::DriverResult::Success) {- LOG_ERROR(Service_NFC, "Nfc not supported");- return NfcDisabled;- }-- device_state = NFP::DeviceState::SearchingForTag;- allowed_protocols = allowed_protocol;- return ResultSuccess;-}--Result NfcDevice::StopDetection() {- npad_device->SetPollingMode(Core::HID::EmulatedDeviceIndex::RightIndex,- Common::Input::PollingMode::Active);-- if (device_state == NFP::DeviceState::Initialized) {- return ResultSuccess;- }-- if (device_state == NFP::DeviceState::TagFound ||- device_state == NFP::DeviceState::TagMounted) {- CloseNfcTag();- return ResultSuccess;- }- if (device_state == NFP::DeviceState::SearchingForTag ||- device_state == NFP::DeviceState::TagRemoved) {- device_state = NFP::DeviceState::Initialized;- return ResultSuccess;- }-- LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);- return WrongDeviceState;-}--Result NfcDevice::Flush() {- if (device_state != NFP::DeviceState::TagFound &&- device_state != NFP::DeviceState::TagMounted) {- LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);- if (device_state == NFP::DeviceState::TagRemoved) {- return TagRemoved;- }- return WrongDeviceState;- }-- if (!npad_device->WriteNfc(tag_data)) {- LOG_ERROR(Service_NFP, "Error writing to file");- return MifareReadError;- }-- return ResultSuccess;-}--Result NfcDevice::GetTagInfo(NFP::TagInfo& tag_info, bool is_mifare) const {- if (device_state != NFP::DeviceState::TagFound &&- device_state != NFP::DeviceState::TagMounted) {- LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);- if (device_state == NFP::DeviceState::TagRemoved) {- return TagRemoved;- }- return WrongDeviceState;- }-- if (is_mifare) {- tag_info = {- .uuid = encrypted_tag_data.uuid.uid,- .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),- .protocol = NFP::TagProtocol::TypeA,- .tag_type = NFP::TagType::Type4,- };- return ResultSuccess;- }-- // Protocol and tag type may change here- tag_info = {- .uuid = encrypted_tag_data.uuid.uid,- .uuid_length = static_cast<u8>(encrypted_tag_data.uuid.uid.size()),- .protocol = NFP::TagProtocol::TypeA,- .tag_type = NFP::TagType::Type2,- };-- return ResultSuccess;-}--Result NfcDevice::MifareRead(const NFP::MifareReadBlockParameter& parameter,- NFP::MifareReadBlockData& read_block_data) {- const std::size_t sector_index = parameter.sector_number * sizeof(NFP::DataBlock);- read_block_data.sector_number = parameter.sector_number;-- if (device_state != NFP::DeviceState::TagFound &&- device_state != NFP::DeviceState::TagMounted) {- LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);- if (device_state == NFP::DeviceState::TagRemoved) {- return TagRemoved;- }- return WrongDeviceState;- }-- if (tag_data.size() < sector_index + sizeof(NFP::DataBlock)) {- return MifareReadError;- }-- // TODO: Use parameter.sector_key to read encrypted data- memcpy(read_block_data.data.data(), tag_data.data() + sector_index, sizeof(NFP::DataBlock));-- return ResultSuccess;-}--Result NfcDevice::MifareWrite(const NFP::MifareWriteBlockParameter& parameter) {- const std::size_t sector_index = parameter.sector_number * sizeof(NFP::DataBlock);-- if (device_state != NFP::DeviceState::TagFound &&- device_state != NFP::DeviceState::TagMounted) {- LOG_ERROR(Service_NFC, "Wrong device state {}", device_state);- if (device_state == NFP::DeviceState::TagRemoved) {- return TagRemoved;- }- return WrongDeviceState;- }-- if (tag_data.size() < sector_index + sizeof(NFP::DataBlock)) {- return MifareReadError;- }-- // TODO: Use parameter.sector_key to encrypt the data- memcpy(tag_data.data() + sector_index, parameter.data.data(), sizeof(NFP::DataBlock));-- return ResultSuccess;-}--u64 NfcDevice::GetHandle() const {- // Generate a handle based of the npad id- return static_cast<u64>(npad_id);-}--NFP::DeviceState NfcDevice::GetCurrentState() const {- return device_state;-}--Core::HID::NpadIdType NfcDevice::GetNpadId() const {- return npad_id;-}--} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/nfc_device.h b/src/core/hle/service/nfc/nfc_device.hdeleted file mode 100644index ea63f05379..0000000000--- a/src/core/hle/service/nfc/nfc_device.h+++ /dev/null@@ -1,78 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include "common/common_types.h"-#include "core/hle/service/kernel_helpers.h"-#include "core/hle/service/nfp/nfp_types.h"-#include "core/hle/service/service.h"--namespace Kernel {-class KEvent;-class KReadableEvent;-} // namespace Kernel--namespace Core {-class System;-} // namespace Core--namespace Core::HID {-class EmulatedController;-enum class ControllerTriggerType;-enum class NpadIdType : u32;-} // namespace Core::HID--namespace Service::NFC {-class NfcDevice {-public:- NfcDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,- KernelHelpers::ServiceContext& service_context_,- Kernel::KEvent* availability_change_event_);- ~NfcDevice();-- void Initialize();- void Finalize();-- Result StartDetection(NFP::TagProtocol allowed_protocol);- Result StopDetection();- Result Flush();-- Result GetTagInfo(NFP::TagInfo& tag_info, bool is_mifare) const;-- Result MifareRead(const NFP::MifareReadBlockParameter& parameter,- NFP::MifareReadBlockData& read_block_data);-- Result MifareWrite(const NFP::MifareWriteBlockParameter& parameter);-- u64 GetHandle() const;- NFP::DeviceState GetCurrentState() const;- Core::HID::NpadIdType GetNpadId() const;-- Kernel::KReadableEvent& GetActivateEvent() const;- Kernel::KReadableEvent& GetDeactivateEvent() const;--private:- void NpadUpdate(Core::HID::ControllerTriggerType type);- bool LoadNfcTag(std::span<const u8> data);- void CloseNfcTag();-- bool is_controller_set{};- int callback_key;- const Core::HID::NpadIdType npad_id;- Core::System& system;- Core::HID::EmulatedController* npad_device = nullptr;- KernelHelpers::ServiceContext& service_context;- Kernel::KEvent* activate_event = nullptr;- Kernel::KEvent* deactivate_event = nullptr;- Kernel::KEvent* availability_change_event = nullptr;-- bool is_initalized{};- NFP::TagProtocol allowed_protocols{};- NFP::DeviceState device_state{NFP::DeviceState::Unavailable};-- NFP::EncryptedNTAG215File encrypted_tag_data{};- std::vector<u8> tag_data{};-};--} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/nfc_interface.cpp b/src/core/hle/service/nfc/nfc_interface.cppindex be96d0cbc6..0fa29d398b 100644--- a/src/core/hle/service/nfc/nfc_interface.cpp+++ b/src/core/hle/service/nfc/nfc_interface.cpp@@ -6,55 +6,56 @@#include "core/hid/hid_types.h"#include "core/hle/kernel/k_event.h"#include "core/hle/service/ipc_helpers.h"-#include "core/hle/service/nfc/nfc_device.h"+#include "core/hle/service/nfc/common/device.h"+#include "core/hle/service/nfc/common/device_manager.h"+#include "core/hle/service/nfc/mifare_result.h"+#include "core/hle/service/nfc/mifare_types.h"#include "core/hle/service/nfc/nfc_interface.h"#include "core/hle/service/nfc/nfc_result.h"+#include "core/hle/service/nfc/nfc_types.h"+#include "core/hle/service/nfp/nfp_result.h"#include "core/hle/service/time/clock_types.h"namespace Service::NFC {-Interface::Interface(Core::System& system_, const char* name)- : ServiceFramework{system_, name}, service_context{system_, service_name} {- availability_change_event = service_context.CreateEvent("Interface:AvailabilityChangeEvent");+NfcInterface::NfcInterface(Core::System& system_, const char* name, BackendType service_backend)+ : ServiceFramework{system_, name}, service_context{system_, service_name},+ backend_type{service_backend} {}- for (u32 device_index = 0; device_index < 10; device_index++) {- devices[device_index] =- std::make_shared<NfcDevice>(Core::HID::IndexToNpadIdType(device_index), system,- service_context, availability_change_event);- }-}+NfcInterface ::~NfcInterface() = default;-Interface ::~Interface() {- availability_change_event->Close();-}--void Interface::Initialize(HLERequestContext& ctx) {+void NfcInterface::Initialize(HLERequestContext& ctx) {LOG_INFO(Service_NFC, "called");- state = State::Initialized;+ auto manager = GetManager();+ auto result = manager->Initialize();- for (auto& device : devices) {- device->Initialize();+ if (result.IsSuccess()) {+ state = State::Initialized;+ } else {+ manager->Finalize();}IPC::ResponseBuilder rb{ctx, 2, 0};- rb.Push(ResultSuccess);+ rb.Push(result);}-void Interface::Finalize(HLERequestContext& ctx) {+void NfcInterface::Finalize(HLERequestContext& ctx) {LOG_INFO(Service_NFC, "called");- state = State::NonInitialized;-- for (auto& device : devices) {- device->Finalize();+ if (state != State::NonInitialized) {+ if (GetBackendType() != BackendType::None) {+ GetManager()->Finalize();+ }+ device_manager = nullptr;+ state = State::NonInitialized;}IPC::ResponseBuilder rb{ctx, 2};rb.Push(ResultSuccess);}-void Interface::GetState(HLERequestContext& ctx) {+void NfcInterface::GetState(HLERequestContext& ctx) {LOG_DEBUG(Service_NFC, "called");IPC::ResponseBuilder rb{ctx, 3};@@ -62,50 +63,28 @@ void Interface::GetState(HLERequestContext& ctx) {rb.PushEnum(state);}-void Interface::IsNfcEnabled(HLERequestContext& ctx) {+void NfcInterface::IsNfcEnabled(HLERequestContext& ctx) {LOG_DEBUG(Service_NFC, "called");+ // TODO: This calls nn::settings::detail::GetNfcEnableFlag+ const bool is_enabled = true;+IPC::ResponseBuilder rb{ctx, 3};rb.Push(ResultSuccess);- rb.Push(state != State::NonInitialized);+ rb.Push(is_enabled);}-void Interface::ListDevices(HLERequestContext& ctx) {- LOG_DEBUG(Service_NFC, "called");-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- if (!ctx.CanWriteBuffer()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(InvalidArgument);- return;- }-- if (ctx.GetWriteBufferSize() == 0) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(InvalidArgument);- return;- }-+void NfcInterface::ListDevices(HLERequestContext& ctx) {std::vector<u64> nfp_devices;const std::size_t max_allowed_devices = ctx.GetWriteBufferNumElements<u64>();+ LOG_DEBUG(Service_NFC, "called");- for (auto& device : devices) {- if (nfp_devices.size() >= max_allowed_devices) {- continue;- }- if (device->GetCurrentState() != NFP::DeviceState::Unavailable) {- nfp_devices.push_back(device->GetHandle());- }- }+ auto result = GetManager()->ListDevices(nfp_devices, max_allowed_devices);+ result = TranslateResultToServiceError(result);- if (nfp_devices.empty()) {+ if (result.IsError()) {IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);+ rb.Push(result);return;}@@ -116,210 +95,177 @@ void Interface::ListDevices(HLERequestContext& ctx) {rb.Push(static_cast<s32>(nfp_devices.size()));}-void Interface::GetDeviceState(HLERequestContext& ctx) {+void NfcInterface::GetDeviceState(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);- auto device = GetNfcDevice(device_handle);+ const auto device_state = GetManager()->GetDeviceState(device_handle);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (device_state > DeviceState::Finalized) {+ ASSERT_MSG(false, "Invalid device state");}IPC::ResponseBuilder rb{ctx, 3};rb.Push(ResultSuccess);- rb.PushEnum(device.value()->GetCurrentState());+ rb.PushEnum(device_state);}-void Interface::GetNpadId(HLERequestContext& ctx) {+void NfcInterface::GetNpadId(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);+ Core::HID::NpadIdType npad_id{};+ auto result = GetManager()->GetNpadId(device_handle, npad_id);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {+ if (result.IsError()) {IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);+ rb.Push(result);return;}IPC::ResponseBuilder rb{ctx, 3};rb.Push(ResultSuccess);- rb.PushEnum(device.value()->GetNpadId());+ rb.PushEnum(npad_id);}-void Interface::AttachAvailabilityChangeEvent(HLERequestContext& ctx) {+void NfcInterface::AttachAvailabilityChangeEvent(HLERequestContext& ctx) {LOG_INFO(Service_NFC, "called");- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-IPC::ResponseBuilder rb{ctx, 2, 1};rb.Push(ResultSuccess);- rb.PushCopyObjects(availability_change_event->GetReadableEvent());+ rb.PushCopyObjects(GetManager()->AttachAvailabilityChangeEvent());}-void Interface::StartDetection(HLERequestContext& ctx) {+void NfcInterface::StartDetection(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- const auto nfp_protocol{rp.PopEnum<NFP::TagProtocol>()};- LOG_INFO(Service_NFC, "called, device_handle={}, nfp_protocol={}", device_handle, nfp_protocol);+ const auto tag_protocol{rp.PopEnum<NfcProtocol>()};+ LOG_INFO(Service_NFC, "called, device_handle={}, nfp_protocol={}", device_handle, tag_protocol);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);+ auto result = GetManager()->StartDetection(device_handle, tag_protocol);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->StartDetection(nfp_protocol);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}-void Interface::StopDetection(HLERequestContext& ctx) {+void NfcInterface::StopDetection(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ auto result = GetManager()->StopDetection(device_handle);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->StopDetection();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}-void Interface::GetTagInfo(HLERequestContext& ctx) {+void NfcInterface::GetTagInfo(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFC, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ TagInfo tag_info{};+ auto result =+ GetManager()->GetTagInfo(device_handle, tag_info, backend_type == BackendType::Mifare);+ result = TranslateResultToServiceError(result);- auto device = GetNfcDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(tag_info);}- NFP::TagInfo tag_info{};- const auto result = device.value()->GetTagInfo(tag_info, false);- ctx.WriteBuffer(tag_info);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}-void Interface::AttachActivateEvent(HLERequestContext& ctx) {+void NfcInterface::AttachActivateEvent(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);+ IPC::ResponseBuilder rb{ctx, 2, 1};+ rb.Push(ResultSuccess);+ rb.PushCopyObjects(GetManager()->AttachActivateEvent(device_handle));+}- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {+ IPC::RequestParser rp{ctx};+ const auto device_handle{rp.Pop<u64>()};+ LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);IPC::ResponseBuilder rb{ctx, 2, 1};rb.Push(ResultSuccess);- rb.PushCopyObjects(device.value()->GetActivateEvent());+ rb.PushCopyObjects(GetManager()->AttachDeactivateEvent(device_handle));}-void Interface::AttachDeactivateEvent(HLERequestContext& ctx) {+void NfcInterface::ReadMifare(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);+ const auto buffer{ctx.ReadBuffer()};+ const auto number_of_commands{ctx.GetReadBufferNumElements<MifareReadBlockParameter>()};+ std::vector<MifareReadBlockParameter> read_commands(number_of_commands);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ memcpy(read_commands.data(), buffer.data(),+ number_of_commands * sizeof(MifareReadBlockParameter));- auto device = GetNfcDevice(device_handle);+ LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, read_commands_size={}",+ device_handle, number_of_commands);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ std::vector<MifareReadBlockData> out_data(number_of_commands);+ auto result = GetManager()->ReadMifare(device_handle, read_commands, out_data);+ result = TranslateResultToServiceError(result);++ if (result.IsSuccess()) {+ ctx.WriteBuffer(out_data);}- IPC::ResponseBuilder rb{ctx, 2, 1};- rb.Push(ResultSuccess);- rb.PushCopyObjects(device.value()->GetDeactivateEvent());+ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(result);+}++void NfcInterface::WriteMifare(HLERequestContext& ctx) {+ IPC::RequestParser rp{ctx};+ const auto device_handle{rp.Pop<u64>()};+ const auto buffer{ctx.ReadBuffer()};+ const auto number_of_commands{ctx.GetReadBufferNumElements<MifareWriteBlockParameter>()};+ std::vector<MifareWriteBlockParameter> write_commands(number_of_commands);++ memcpy(write_commands.data(), buffer.data(),+ number_of_commands * sizeof(MifareWriteBlockParameter));++ LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, write_commands_size={}",+ device_handle, number_of_commands);++ auto result = GetManager()->WriteMifare(device_handle, write_commands);+ result = TranslateResultToServiceError(result);++ IPC::ResponseBuilder rb{ctx, 2};+ rb.Push(result);}-void Interface::SendCommandByPassThrough(HLERequestContext& ctx) {+void NfcInterface::SendCommandByPassThrough(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};const auto timeout{rp.PopRaw<Time::Clock::TimeSpanType>()};const auto command_data{ctx.ReadBuffer()};-LOG_INFO(Service_NFC, "(STUBBED) called, device_handle={}, timeout={}, data_size={}",device_handle, timeout.ToSeconds(), command_data.size());- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfcDevice(device_handle);+ std::vector<u8> out_data(1);+ auto result =+ GetManager()->SendCommandByPassThrough(device_handle, timeout, command_data, out_data);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {+ if (result.IsError()) {IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);+ rb.Push(result);return;}- std::vector<u8> out_data(1);- // TODO: Request data from nfc devicectx.WriteBuffer(out_data);IPC::ResponseBuilder rb{ctx, 3};@@ -327,13 +273,110 @@ void Interface::SendCommandByPassThrough(HLERequestContext& ctx) {rb.Push(static_cast<u32>(out_data.size()));}-std::optional<std::shared_ptr<NfcDevice>> Interface::GetNfcDevice(u64 handle) {- for (auto& device : devices) {- if (device->GetHandle() == handle) {- return device;+std::shared_ptr<DeviceManager> NfcInterface::GetManager() {+ if (device_manager == nullptr) {+ device_manager = std::make_shared<DeviceManager>(system, service_context);+ }+ return device_manager;+}++BackendType NfcInterface::GetBackendType() const {+ return backend_type;+}++Result NfcInterface::TranslateResultToServiceError(Result result) const {+ const auto backend = GetBackendType();++ if (result.IsSuccess()) {+ return result;+ }++ if (result.module != ErrorModule::NFC) {+ return result;+ }++ switch (backend) {+ case BackendType::Mifare:+ return TranslateResultToNfp(result);+ case BackendType::Nfp: {+ return TranslateResultToNfp(result);+ }+ default:+ if (result != ResultUnknown216) {+ return result;}+ return ResultUnknown74;+ }+}++Result NfcInterface::TranslateResultToNfp(Result result) const {+ if (result == ResultDeviceNotFound) {+ return NFP::ResultDeviceNotFound;+ }+ if (result == ResultInvalidArgument) {+ return NFP::ResultInvalidArgument;+ }+ if (result == ResultWrongApplicationAreaSize) {+ return NFP::ResultWrongApplicationAreaSize;+ }+ if (result == ResultWrongDeviceState) {+ return NFP::ResultWrongDeviceState;+ }+ if (result == ResultUnknown74) {+ return NFP::ResultUnknown74;+ }+ if (result == ResultNfcDisabled) {+ return NFP::ResultNfcDisabled;+ }+ if (result == ResultNfcNotInitialized) {+ return NFP::ResultNfcDisabled;+ }+ if (result == ResultWriteAmiiboFailed) {+ return NFP::ResultWriteAmiiboFailed;+ }+ if (result == ResultTagRemoved) {+ return NFP::ResultTagRemoved;+ }+ if (result == ResultRegistrationIsNotInitialized) {+ return NFP::ResultRegistrationIsNotInitialized;+ }+ if (result == ResultApplicationAreaIsNotInitialized) {+ return NFP::ResultApplicationAreaIsNotInitialized;+ }+ if (result == ResultCorruptedData) {+ return NFP::ResultCorruptedData;+ }+ if (result == ResultWrongApplicationAreaId) {+ return NFP::ResultWrongApplicationAreaId;+ }+ if (result == ResultApplicationAreaExist) {+ return NFP::ResultApplicationAreaExist;+ }+ if (result == ResultNotAnAmiibo) {+ return NFP::ResultNotAnAmiibo;+ }+ LOG_WARNING(Service_NFC, "Result conversion not handled");+ return result;+}++Result NfcInterface::TranslateResultToMifare(Result result) const {+ if (result == ResultDeviceNotFound) {+ return Mifare::ResultDeviceNotFound;+ }+ if (result == ResultInvalidArgument) {+ return Mifare::ResultInvalidArgument;+ }+ if (result == ResultWrongDeviceState) {+ return Mifare::ResultWrongDeviceState;+ }+ if (result == ResultNfcDisabled) {+ return Mifare::ResultNfcDisabled;+ }+ if (result == ResultTagRemoved) {+ return Mifare::ResultTagRemoved;}- return std::nullopt;+ LOG_WARNING(Service_NFC, "Result conversion not handled");+ return result;}} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/nfc_interface.h b/src/core/hle/service/nfc/nfc_interface.hindex 8c1bf5a599..08be174d83 100644--- a/src/core/hle/service/nfc/nfc_interface.h+++ b/src/core/hle/service/nfc/nfc_interface.h@@ -3,20 +3,17 @@#pragma once-#include <array>-#include <memory>-#include <optional>-#include "core/hle/service/kernel_helpers.h"+#include "core/hle/service/nfc/nfc_types.h"#include "core/hle/service/service.h"namespace Service::NFC {-class NfcDevice;+class DeviceManager;-class Interface : public ServiceFramework<Interface> {+class NfcInterface : public ServiceFramework<NfcInterface> {public:- explicit Interface(Core::System& system_, const char* name);- ~Interface();+ explicit NfcInterface(Core::System& system_, const char* name, BackendType service_backend);+ ~NfcInterface();void Initialize(HLERequestContext& ctx);void Finalize(HLERequestContext& ctx);@@ -31,22 +28,22 @@ public:void GetTagInfo(HLERequestContext& ctx);void AttachActivateEvent(HLERequestContext& ctx);void AttachDeactivateEvent(HLERequestContext& ctx);+ void ReadMifare(HLERequestContext& ctx);+ void WriteMifare(HLERequestContext& ctx);void SendCommandByPassThrough(HLERequestContext& ctx);-private:- enum class State : u32 {- NonInitialized,- Initialized,- };-- std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle);+protected:+ std::shared_ptr<DeviceManager> GetManager();+ BackendType GetBackendType() const;+ Result TranslateResultToServiceError(Result result) const;+ Result TranslateResultToNfp(Result result) const;+ Result TranslateResultToMifare(Result result) const;KernelHelpers::ServiceContext service_context;- std::array<std::shared_ptr<NfcDevice>, 10> devices{};-+ BackendType backend_type;State state{State::NonInitialized};- Kernel::KEvent* availability_change_event;+ std::shared_ptr<DeviceManager> device_manager = nullptr;};} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/nfc_result.h b/src/core/hle/service/nfc/nfc_result.hindex 146b8ba61e..917d79ef8c 100644--- a/src/core/hle/service/nfc/nfc_result.h+++ b/src/core/hle/service/nfc/nfc_result.h@@ -1,5 +1,5 @@-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later#pragma once@@ -7,17 +7,22 @@namespace Service::NFC {-constexpr Result DeviceNotFound(ErrorModule::NFC, 64);-constexpr Result InvalidArgument(ErrorModule::NFC, 65);-constexpr Result WrongDeviceState(ErrorModule::NFC, 73);-constexpr Result NfcDisabled(ErrorModule::NFC, 80);-constexpr Result TagRemoved(ErrorModule::NFC, 97);--constexpr Result MifareDeviceNotFound(ErrorModule::NFCMifare, 64);-constexpr Result MifareInvalidArgument(ErrorModule::NFCMifare, 65);-constexpr Result MifareWrongDeviceState(ErrorModule::NFCMifare, 73);-constexpr Result MifareNfcDisabled(ErrorModule::NFCMifare, 80);-constexpr Result MifareTagRemoved(ErrorModule::NFCMifare, 97);-constexpr Result MifareReadError(ErrorModule::NFCMifare, 288);+constexpr Result ResultDeviceNotFound(ErrorModule::NFC, 64);+constexpr Result ResultInvalidArgument(ErrorModule::NFC, 65);+constexpr Result ResultWrongApplicationAreaSize(ErrorModule::NFP, 68);+constexpr Result ResultWrongDeviceState(ErrorModule::NFC, 73);+constexpr Result ResultUnknown74(ErrorModule::NFC, 74);+constexpr Result ResultUnknown76(ErrorModule::NFC, 76);+constexpr Result ResultNfcNotInitialized(ErrorModule::NFC, 77);+constexpr Result ResultNfcDisabled(ErrorModule::NFC, 80);+constexpr Result ResultWriteAmiiboFailed(ErrorModule::NFP, 88);+constexpr Result ResultTagRemoved(ErrorModule::NFC, 97);+constexpr Result ResultRegistrationIsNotInitialized(ErrorModule::NFP, 120);+constexpr Result ResultApplicationAreaIsNotInitialized(ErrorModule::NFP, 128);+constexpr Result ResultCorruptedData(ErrorModule::NFP, 144);+constexpr Result ResultWrongApplicationAreaId(ErrorModule::NFP, 152);+constexpr Result ResultApplicationAreaExist(ErrorModule::NFP, 168);+constexpr Result ResultNotAnAmiibo(ErrorModule::NFP, 178);+constexpr Result ResultUnknown216(ErrorModule::NFC, 216);} // namespace Service::NFCdiff --git a/src/core/hle/service/nfc/nfc_types.h b/src/core/hle/service/nfc/nfc_types.hnew file mode 100644index 0000000000..c7ebd1fdbb--- /dev/null+++ b/src/core/hle/service/nfc/nfc_types.h@@ -0,0 +1,90 @@+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-3.0-or-later++#pragma once++#include <array>++#include "common/common_funcs.h"+#include "common/common_types.h"++namespace Service::NFC {+enum class BackendType : u32 {+ None,+ Nfc,+ Nfp,+ Mifare,+};++// This is nn::nfc::DeviceState+enum class DeviceState : u32 {+ Initialized,+ SearchingForTag,+ TagFound,+ TagRemoved,+ TagMounted,+ Unavailable,+ Finalized,+};++// This is nn::nfc::State+enum class State : u32 {+ NonInitialized,+ Initialized,+};++// This is nn::nfc::TagType+enum class TagType : u32 {+ None,+ Type1, // ISO14443A RW 96-2k bytes 106kbit/s+ Type2, // ISO14443A RW/RO 540 bytes 106kbit/s+ Type3, // Sony FeliCa RW/RO 2k bytes 212kbit/s+ Type4, // ISO14443A RW/RO 4k-32k bytes 424kbit/s+ Type5, // ISO15693 RW/RO 540 bytes 106kbit/s+};++enum class PackedTagType : u8 {+ None,+ Type1, // ISO14443A RW 96-2k bytes 106kbit/s+ Type2, // ISO14443A RW/RO 540 bytes 106kbit/s+ Type3, // Sony FeliCa RW/RO 2k bytes 212kbit/s+ Type4, // ISO14443A RW/RO 4k-32k bytes 424kbit/s+ Type5, // ISO15693 RW/RO 540 bytes 106kbit/s+};++// This is nn::nfc::NfcProtocol+// Verify this enum. It might be completely wrong default protocol is 0x48+enum class NfcProtocol : u32 {+ None,+ TypeA = 1U << 0, // ISO14443A+ TypeB = 1U << 1, // ISO14443B+ TypeF = 1U << 2, // Sony FeliCa+ Unknown1 = 1U << 3,+ Unknown2 = 1U << 5,+ All = 0xFFFFFFFFU,+};++// this is nn::nfc::TestWaveType+enum class TestWaveType : u32 {+ Unknown,+};++using UniqueSerialNumber = std::array<u8, 7>;+using UniqueSerialNumberExtension = std::array<u8, 3>;++// This is nn::nfc::DeviceHandle+using DeviceHandle = u64;++// This is nn::nfc::TagInfo+struct TagInfo {+ UniqueSerialNumber uuid;+ UniqueSerialNumberExtension uuid_extension;+ u8 uuid_length;+ INSERT_PADDING_BYTES(0x15);+ NfcProtocol protocol;+ TagType tag_type;+ INSERT_PADDING_BYTES(0x30);+};+static_assert(sizeof(TagInfo) == 0x58, "TagInfo is an invalid size");++} // namespace Service::NFCdiff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cppindex 2559fe5982..2eeabc1387 100644--- a/src/core/hle/service/nfp/nfp.cpp+++ b/src/core/hle/service/nfp/nfp.cpp@@ -13,7 +13,7 @@ class IUser final : public Interface {public:explicit IUser(Core::System& system_) : Interface(system_, "NFP:IUser") {// clang-format off- static const FunctionInfo functions[] = {+ static const FunctionInfoTyped<IUser> functions[] = {{0, &IUser::Initialize, "Initialize"},{1, &IUser::Finalize, "Finalize"},{2, &IUser::ListDevices, "ListDevices"},@@ -50,7 +50,7 @@ class ISystem final : public Interface {public:explicit ISystem(Core::System& system_) : Interface(system_, "NFP:ISystem") {// clang-format off- static const FunctionInfo functions[] = {+ static const FunctionInfoTyped<ISystem> functions[] = {{0, &ISystem::InitializeSystem, "InitializeSystem"},{1, &ISystem::FinalizeSystem, "FinalizeSystem"},{2, &ISystem::ListDevices, "ListDevices"},@@ -89,7 +89,7 @@ class IDebug final : public Interface {public:explicit IDebug(Core::System& system_) : Interface(system_, "NFP:IDebug") {// clang-format off- static const FunctionInfo functions[] = {+ static const FunctionInfoTyped<IDebug> functions[] = {{0, &IDebug::InitializeDebug, "InitializeDebug"},{1, &IDebug::FinalizeDebug, "FinalizeDebug"},{2, &IDebug::ListDevices, "ListDevices"},@@ -126,9 +126,9 @@ public:{201, &IDebug::SetAll, "SetAll"},{202, &IDebug::FlushDebug, "FlushDebug"},{203, &IDebug::BreakTag, "BreakTag"},- {204, nullptr, "ReadBackupData"},- {205, nullptr, "WriteBackupData"},- {206, nullptr, "WriteNtf"},+ {204, &IDebug::ReadBackupData, "ReadBackupData"},+ {205, &IDebug::WriteBackupData, "WriteBackupData"},+ {206, &IDebug::WriteNtf, "WriteNtf"},};// clang-format ondiff --git a/src/core/hle/service/nfp/nfp_device.h b/src/core/hle/service/nfp/nfp_device.hdeleted file mode 100644index bab05538ad..0000000000--- a/src/core/hle/service/nfp/nfp_device.h+++ /dev/null@@ -1,120 +0,0 @@-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include <span>-#include <vector>--#include "common/common_types.h"-#include "core/hle/service/kernel_helpers.h"-#include "core/hle/service/nfp/nfp_types.h"-#include "core/hle/service/service.h"--namespace Kernel {-class KEvent;-class KReadableEvent;-} // namespace Kernel--namespace Core {-class System;-} // namespace Core--namespace Core::HID {-class EmulatedController;-enum class ControllerTriggerType;-enum class NpadIdType : u32;-} // namespace Core::HID--namespace Service::NFP {-class NfpDevice {-public:- NfpDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,- KernelHelpers::ServiceContext& service_context_,- Kernel::KEvent* availability_change_event_);- ~NfpDevice();-- void Initialize();- void Finalize();-- Result StartDetection(TagProtocol allowed_protocol);- Result StopDetection();- Result Mount(MountTarget mount_target);- Result Unmount();-- Result Flush();- Result FlushDebug();- Result FlushWithBreak(BreakType break_type);-- Result GetTagInfo(TagInfo& tag_info) const;- Result GetCommonInfo(CommonInfo& common_info) const;- Result GetModelInfo(ModelInfo& model_info) const;- Result GetRegisterInfo(RegisterInfo& register_info) const;- Result GetRegisterInfoPrivate(RegisterInfoPrivate& register_info) const;- Result GetAdminInfo(AdminInfo& admin_info) const;-- Result DeleteRegisterInfo();- Result SetRegisterInfoPrivate(const AmiiboName& amiibo_name);- Result RestoreAmiibo();- Result Format();-- Result OpenApplicationArea(u32 access_id);- Result GetApplicationAreaId(u32& application_area_id) const;- Result GetApplicationArea(std::vector<u8>& data) const;- Result SetApplicationArea(std::span<const u8> data);- Result CreateApplicationArea(u32 access_id, std::span<const u8> data);- Result RecreateApplicationArea(u32 access_id, std::span<const u8> data);- Result DeleteApplicationArea();- Result ExistApplicationArea(bool& has_application_area);-- Result GetAll(NfpData& data) const;- Result SetAll(const NfpData& data);- Result BreakTag(BreakType break_type);- Result ReadBackupData();- Result WriteBackupData();- Result WriteNtf();-- u64 GetHandle() const;- u32 GetApplicationAreaSize() const;- DeviceState GetCurrentState() const;- Core::HID::NpadIdType GetNpadId() const;-- Kernel::KReadableEvent& GetActivateEvent() const;- Kernel::KReadableEvent& GetDeactivateEvent() const;--private:- void NpadUpdate(Core::HID::ControllerTriggerType type);- bool LoadAmiibo(std::span<const u8> data);- void CloseAmiibo();-- AmiiboName GetAmiiboName(const AmiiboSettings& settings) const;- void SetAmiiboName(AmiiboSettings& settings, const AmiiboName& amiibo_name);- AmiiboDate GetAmiiboDate(s64 posix_time) const;- u64 RemoveVersionByte(u64 application_id) const;- void UpdateSettingsCrc();- void UpdateRegisterInfoCrc();-- bool is_controller_set{};- int callback_key;- const Core::HID::NpadIdType npad_id;- Core::System& system;- Core::HID::EmulatedController* npad_device = nullptr;- KernelHelpers::ServiceContext& service_context;- Kernel::KEvent* activate_event = nullptr;- Kernel::KEvent* deactivate_event = nullptr;- Kernel::KEvent* availability_change_event = nullptr;-- bool is_initalized{};- bool is_data_moddified{};- bool is_app_area_open{};- bool is_plain_amiibo{};- TagProtocol allowed_protocols{};- s64 current_posix_time{};- MountTarget mount_target{MountTarget::None};- DeviceState device_state{DeviceState::Unavailable};-- NTAG215File tag_data{};- EncryptedNTAG215File encrypted_tag_data{};-};--} // namespace Service::NFPdiff --git a/src/core/hle/service/nfp/nfp_interface.cpp b/src/core/hle/service/nfp/nfp_interface.cppindex 2ed8bb1baa..21d1591549 100644--- a/src/core/hle/service/nfp/nfp_interface.cpp+++ b/src/core/hle/service/nfp/nfp_interface.cpp@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#include "common/logging/log.h"@@ -6,198 +6,34 @@#include "core/hid/hid_types.h"#include "core/hle/kernel/k_event.h"#include "core/hle/service/ipc_helpers.h"-#include "core/hle/service/nfp/nfp_device.h"+#include "core/hle/service/nfc/common/device.h"+#include "core/hle/service/nfc/common/device_manager.h"+#include "core/hle/service/nfc/nfc_types.h"#include "core/hle/service/nfp/nfp_interface.h"#include "core/hle/service/nfp/nfp_result.h"+#include "core/hle/service/nfp/nfp_types.h"namespace Service::NFP {Interface::Interface(Core::System& system_, const char* name)- : ServiceFramework{system_, name}, service_context{system_, service_name} {- availability_change_event = service_context.CreateEvent("IUser:AvailabilityChangeEvent");+ : NfcInterface{system_, name, NFC::BackendType::Nfp} {}- for (u32 device_index = 0; device_index < 10; device_index++) {- devices[device_index] =- std::make_shared<NfpDevice>(Core::HID::IndexToNpadIdType(device_index), system,- service_context, availability_change_event);- }-}--Interface::~Interface() {- availability_change_event->Close();-}--void Interface::Initialize(HLERequestContext& ctx) {- LOG_INFO(Service_NFP, "called");-- state = State::Initialized;-- for (auto& device : devices) {- device->Initialize();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);-}+Interface::~Interface() = default;void Interface::InitializeSystem(HLERequestContext& ctx) {- LOG_INFO(Service_NFP, "called");-- state = State::Initialized;-- for (auto& device : devices) {- device->Initialize();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ Initialize(ctx);}void Interface::InitializeDebug(HLERequestContext& ctx) {- LOG_INFO(Service_NFP, "called");-- state = State::Initialized;-- for (auto& device : devices) {- device->Initialize();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);-}--void Interface::Finalize(HLERequestContext& ctx) {- LOG_INFO(Service_NFP, "called");-- state = State::NonInitialized;-- for (auto& device : devices) {- device->Finalize();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ Initialize(ctx);}void Interface::FinalizeSystem(HLERequestContext& ctx) {- LOG_INFO(Service_NFP, "called");-- state = State::NonInitialized;-- for (auto& device : devices) {- device->Finalize();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);+ Finalize(ctx);}void Interface::FinalizeDebug(HLERequestContext& ctx) {- LOG_INFO(Service_NFP, "called");-- state = State::NonInitialized;-- for (auto& device : devices) {- device->Finalize();- }-- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(ResultSuccess);-}--void Interface::ListDevices(HLERequestContext& ctx) {- LOG_DEBUG(Service_NFP, "called");-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- if (!ctx.CanWriteBuffer()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(InvalidArgument);- return;- }-- if (ctx.GetWriteBufferSize() == 0) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(InvalidArgument);- return;- }-- std::vector<u64> nfp_devices;- const std::size_t max_allowed_devices = ctx.GetWriteBufferNumElements<u64>();-- for (const auto& device : devices) {- if (nfp_devices.size() >= max_allowed_devices) {- continue;- }- if (device->GetCurrentState() != DeviceState::Unavailable) {- nfp_devices.push_back(device->GetHandle());- }- }-- if (nfp_devices.empty()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- ctx.WriteBuffer(nfp_devices);-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.Push(static_cast<s32>(nfp_devices.size()));-}--void Interface::StartDetection(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- const auto nfp_protocol{rp.PopEnum<TagProtocol>()};- LOG_INFO(Service_NFP, "called, device_handle={}, nfp_protocol={}", device_handle, nfp_protocol);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->StartDetection(nfp_protocol);- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);-}--void Interface::StopDetection(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->StopDetection();- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);+ Finalize(ctx);}void Interface::Mount(HLERequestContext& ctx) {@@ -208,21 +44,9 @@ void Interface::Mount(HLERequestContext& ctx) {LOG_INFO(Service_NFP, "called, device_handle={}, model_type={}, mount_target={}", device_handle,model_type, mount_target);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ auto result = GetManager()->Mount(device_handle, model_type, mount_target);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->Mount(mount_target);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -232,21 +56,9 @@ void Interface::Unmount(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ auto result = GetManager()->Unmount(device_handle);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->Unmount();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -257,21 +69,9 @@ void Interface::OpenApplicationArea(HLERequestContext& ctx) {const auto access_id{rp.Pop<u32>()};LOG_INFO(Service_NFP, "called, device_handle={}, access_id={}", device_handle, access_id);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ auto result = GetManager()->OpenApplicationArea(device_handle, access_id);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->OpenApplicationArea(access_id);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -282,28 +82,16 @@ void Interface::GetApplicationArea(HLERequestContext& ctx) {const auto data_size = ctx.GetWriteBufferSize();LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- if (!ctx.CanWriteBuffer()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(InvalidArgument);- return;- }-- auto device = GetNfpDevice(device_handle);+ std::vector<u8> data(data_size);+ auto result = GetManager()->GetApplicationArea(device_handle, data);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {+ if (result.IsError()) {IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);+ rb.Push(result);return;}- std::vector<u8> data(data_size);- const auto result = device.value()->GetApplicationArea(data);ctx.WriteBuffer(data);IPC::ResponseBuilder rb{ctx, 3};rb.Push(result);@@ -316,27 +104,9 @@ void Interface::SetApplicationArea(HLERequestContext& ctx) {const auto data{ctx.ReadBuffer()};LOG_INFO(Service_NFP, "called, device_handle={}, data_size={}", device_handle, data.size());- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- if (!ctx.CanReadBuffer()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(InvalidArgument);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ auto result = GetManager()->SetApplicationArea(device_handle, data);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->SetApplicationArea(data);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -346,21 +116,9 @@ void Interface::Flush(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);+ auto result = GetManager()->Flush(device_handle);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->Flush();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -370,21 +128,9 @@ void Interface::Restore(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ auto result = GetManager()->Restore(device_handle);+ result = TranslateResultToServiceError(result);- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->RestoreAmiibo();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -397,53 +143,9 @@ void Interface::CreateApplicationArea(HLERequestContext& ctx) {LOG_INFO(Service_NFP, "called, device_handle={}, data_size={}, access_id={}", device_handle,access_id, data.size());- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- if (!ctx.CanReadBuffer()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(InvalidArgument);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->CreateApplicationArea(access_id, data);- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(result);-}--void Interface::GetTagInfo(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ auto result = GetManager()->CreateApplicationArea(device_handle, access_id, data);+ result = TranslateResultToServiceError(result);- TagInfo tag_info{};- const auto result = device.value()->GetTagInfo(tag_info);- ctx.WriteBuffer(tag_info);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -453,23 +155,14 @@ void Interface::GetRegisterInfo(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);+ RegisterInfo register_info{};+ auto result = GetManager()->GetRegisterInfo(device_handle, register_info);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(register_info);}- RegisterInfo register_info{};- const auto result = device.value()->GetRegisterInfo(register_info);- ctx.WriteBuffer(register_info);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -479,23 +172,14 @@ void Interface::GetCommonInfo(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);+ CommonInfo common_info{};+ auto result = GetManager()->GetCommonInfo(device_handle, common_info);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(common_info);}- CommonInfo common_info{};- const auto result = device.value()->GetCommonInfo(common_info);- ctx.WriteBuffer(common_info);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -505,155 +189,26 @@ void Interface::GetModelInfo(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);+ ModelInfo model_info{};+ auto result = GetManager()->GetModelInfo(device_handle, model_info);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(model_info);}- ModelInfo model_info{};- const auto result = device.value()->GetModelInfo(model_info);- ctx.WriteBuffer(model_info);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}-void Interface::AttachActivateEvent(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 2, 1};- rb.Push(ResultSuccess);- rb.PushCopyObjects(device.value()->GetActivateEvent());-}--void Interface::AttachDeactivateEvent(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 2, 1};- rb.Push(ResultSuccess);- rb.PushCopyObjects(device.value()->GetDeactivateEvent());-}--void Interface::GetState(HLERequestContext& ctx) {- LOG_DEBUG(Service_NFP, "called");-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.PushEnum(state);-}--void Interface::GetDeviceState(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.PushEnum(device.value()->GetCurrentState());-}--void Interface::GetNpadId(HLERequestContext& ctx) {- IPC::RequestParser rp{ctx};- const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- IPC::ResponseBuilder rb{ctx, 3};- rb.Push(ResultSuccess);- rb.PushEnum(device.value()->GetNpadId());-}-void Interface::GetApplicationAreaSize(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-IPC::ResponseBuilder rb{ctx, 3};rb.Push(ResultSuccess);- rb.Push(device.value()->GetApplicationAreaSize());-}--void Interface::AttachAvailabilityChangeEvent(HLERequestContext& ctx) {- LOG_INFO(Service_NFP, "called");-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- IPC::ResponseBuilder rb{ctx, 2, 1};- rb.Push(ResultSuccess);- rb.PushCopyObjects(availability_change_event->GetReadableEvent());+ rb.Push(GetManager()->GetApplicationAreaSize());}void Interface::RecreateApplicationArea(HLERequestContext& ctx) {@@ -664,21 +219,9 @@ void Interface::RecreateApplicationArea(HLERequestContext& ctx) {LOG_INFO(Service_NFP, "called, device_handle={}, data_size={}, access_id={}", device_handle,access_id, data.size());- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ auto result = GetManager()->RecreateApplicationArea(device_handle, access_id, data);+ result = TranslateResultToServiceError(result);- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->RecreateApplicationArea(access_id, data);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -686,23 +229,11 @@ void Interface::RecreateApplicationArea(HLERequestContext& ctx) {void Interface::Format(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ auto result = GetManager()->Format(device_handle);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->Format();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -712,23 +243,14 @@ void Interface::GetAdminInfo(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);+ AdminInfo admin_info{};+ auto result = GetManager()->GetAdminInfo(device_handle, admin_info);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(admin_info);}- AdminInfo admin_info{};- const auto result = device.value()->GetAdminInfo(admin_info);- ctx.WriteBuffer(admin_info);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -738,23 +260,14 @@ void Interface::GetRegisterInfoPrivate(HLERequestContext& ctx) {const auto device_handle{rp.Pop<u64>()};LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);+ RegisterInfoPrivate register_info{};+ auto result = GetManager()->GetRegisterInfoPrivate(device_handle, register_info);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(register_info);}- RegisterInfoPrivate register_info{};- const auto result = device.value()->GetRegisterInfoPrivate(register_info);- ctx.WriteBuffer(register_info);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -762,25 +275,15 @@ void Interface::GetRegisterInfoPrivate(HLERequestContext& ctx) {void Interface::SetRegisterInfoPrivate(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- const auto buffer{ctx.ReadBuffer()};- LOG_DEBUG(Service_NFP, "called, device_handle={}, buffer_size={}", device_handle,- buffer.size());+ const auto register_info_buffer{ctx.ReadBuffer()};+ LOG_INFO(Service_NFP, "called, device_handle={}, buffer_size={}", device_handle,+ register_info_buffer.size());- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ RegisterInfoPrivate register_info{};+ memcpy(®ister_info, register_info_buffer.data(), sizeof(RegisterInfoPrivate));+ auto result = GetManager()->SetRegisterInfoPrivate(device_handle, register_info);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->SetRegisterInfoPrivate({});IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -788,23 +291,11 @@ void Interface::SetRegisterInfoPrivate(HLERequestContext& ctx) {void Interface::DeleteRegisterInfo(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ auto result = GetManager()->DeleteRegisterInfo(device_handle);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->DeleteRegisterInfo();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -812,23 +303,11 @@ void Interface::DeleteRegisterInfo(HLERequestContext& ctx) {void Interface::DeleteApplicationArea(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ auto result = GetManager()->DeleteApplicationArea(device_handle);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->DeleteApplicationArea();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -836,24 +315,18 @@ void Interface::DeleteApplicationArea(HLERequestContext& ctx) {void Interface::ExistsApplicationArea(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ bool has_application_area = false;+ auto result = GetManager()->ExistsApplicationArea(device_handle, has_application_area);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {+ if (result.IsError()) {IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);+ rb.Push(result);return;}- bool has_application_area = false;- const auto result = device.value()->ExistApplicationArea(has_application_area);IPC::ResponseBuilder rb{ctx, 3};rb.Push(result);rb.Push(has_application_area);@@ -862,27 +335,16 @@ void Interface::ExistsApplicationArea(HLERequestContext& ctx) {void Interface::GetAll(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ NfpData nfp_data{};+ auto result = GetManager()->GetAll(device_handle, nfp_data);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(nfp_data);}- NfpData data{};- const auto result = device.value()->GetAll(data);-- ctx.WriteBuffer(data);-IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -890,28 +352,15 @@ void Interface::GetAll(HLERequestContext& ctx) {void Interface::SetAll(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- const auto nfp_data{ctx.ReadBuffer()};-- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ const auto nfp_data_buffer{ctx.ReadBuffer()};- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- NfpData data{};- memcpy(&data, nfp_data.data(), sizeof(NfpData));+ NfpData nfp_data{};+ memcpy(&nfp_data, nfp_data_buffer.data(), sizeof(NfpData));+ auto result = GetManager()->SetAll(device_handle, nfp_data);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->SetAll(data);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -919,23 +368,11 @@ void Interface::SetAll(HLERequestContext& ctx) {void Interface::FlushDebug(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ LOG_INFO(Service_NFP, "called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ auto result = GetManager()->FlushDebug(device_handle);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->FlushDebug();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -944,23 +381,12 @@ void Interface::BreakTag(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};const auto break_type{rp.PopEnum<BreakType>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}, break_type={}", device_handle, break_type);+ LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}, break_type={}", device_handle,+ break_type);- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ auto result = GetManager()->BreakTag(device_handle, break_type);+ result = TranslateResultToServiceError(result);- auto device = GetNfpDevice(device_handle);-- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->BreakTag(break_type);IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -968,23 +394,16 @@ void Interface::BreakTag(HLERequestContext& ctx) {void Interface::ReadBackupData(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ std::vector<u8> backup_data{};+ auto result = GetManager()->ReadBackupData(device_handle, backup_data);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;+ if (result.IsSuccess()) {+ ctx.WriteBuffer(backup_data);}- const auto result = device.value()->ReadBackupData();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -992,23 +411,12 @@ void Interface::ReadBackupData(HLERequestContext& ctx) {void Interface::WriteBackupData(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }-- auto device = GetNfpDevice(device_handle);+ const auto backup_data_buffer{ctx.ReadBuffer()};+ LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}", device_handle);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }+ auto result = GetManager()->WriteBackupData(device_handle, backup_data_buffer);+ result = TranslateResultToServiceError(result);- const auto result = device.value()->WriteBackupData();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}@@ -1016,34 +424,15 @@ void Interface::WriteBackupData(HLERequestContext& ctx) {void Interface::WriteNtf(HLERequestContext& ctx) {IPC::RequestParser rp{ctx};const auto device_handle{rp.Pop<u64>()};- LOG_DEBUG(Service_NFP, "called, device_handle={}", device_handle);-- if (state == State::NonInitialized) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(NfcDisabled);- return;- }+ const auto write_type{rp.PopEnum<WriteType>()};+ const auto ntf_data_buffer{ctx.ReadBuffer()};+ LOG_WARNING(Service_NFP, "(STUBBED) called, device_handle={}", device_handle);- auto device = GetNfpDevice(device_handle);+ auto result = GetManager()->WriteNtf(device_handle, write_type, ntf_data_buffer);+ result = TranslateResultToServiceError(result);- if (!device.has_value()) {- IPC::ResponseBuilder rb{ctx, 2};- rb.Push(DeviceNotFound);- return;- }-- const auto result = device.value()->WriteNtf();IPC::ResponseBuilder rb{ctx, 2};rb.Push(result);}-std::optional<std::shared_ptr<NfpDevice>> Interface::GetNfpDevice(u64 handle) {- for (auto& device : devices) {- if (device->GetHandle() == handle) {- return device;- }- }- return std::nullopt;-}-} // namespace Service::NFPdiff --git a/src/core/hle/service/nfp/nfp_interface.h b/src/core/hle/service/nfp/nfp_interface.hindex 616c94b061..fa985b068e 100644--- a/src/core/hle/service/nfp/nfp_interface.h+++ b/src/core/hle/service/nfp/nfp_interface.h@@ -1,32 +1,23 @@-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma once-#include <array>-#include <memory>-#include <optional>-#include "core/hle/service/kernel_helpers.h"+#include "core/hle/service/nfc/nfc_interface.h"#include "core/hle/service/service.h"namespace Service::NFP {-class NfpDevice;-class Interface : public ServiceFramework<Interface> {+class Interface : public NFC::NfcInterface {public:explicit Interface(Core::System& system_, const char* name);~Interface() override;- void Initialize(HLERequestContext& ctx);void InitializeSystem(HLERequestContext& ctx);void InitializeDebug(HLERequestContext& ctx);- void Finalize(HLERequestContext& ctx);void FinalizeSystem(HLERequestContext& ctx);void FinalizeDebug(HLERequestContext& ctx);- void ListDevices(HLERequestContext& ctx);- void StartDetection(HLERequestContext& ctx);- void StopDetection(HLERequestContext& ctx);void Mount(HLERequestContext& ctx);void Unmount(HLERequestContext& ctx);void OpenApplicationArea(HLERequestContext& ctx);@@ -35,17 +26,10 @@ public:void Flush(HLERequestContext& ctx);void Restore(HLERequestContext& ctx);void CreateApplicationArea(HLERequestContext& ctx);- void GetTagInfo(HLERequestContext& ctx);void GetRegisterInfo(HLERequestContext& ctx);void GetCommonInfo(HLERequestContext& ctx);void GetModelInfo(HLERequestContext& ctx);- void AttachActivateEvent(HLERequestContext& ctx);- void AttachDeactivateEvent(HLERequestContext& ctx);- void GetState(HLERequestContext& ctx);- void GetDeviceState(HLERequestContext& ctx);- void GetNpadId(HLERequestContext& ctx);void GetApplicationAreaSize(HLERequestContext& ctx);- void AttachAvailabilityChangeEvent(HLERequestContext& ctx);void RecreateApplicationArea(HLERequestContext& ctx);void Format(HLERequestContext& ctx);void GetAdminInfo(HLERequestContext& ctx);@@ -61,21 +45,6 @@ public:void ReadBackupData(HLERequestContext& ctx);void WriteBackupData(HLERequestContext& ctx);void WriteNtf(HLERequestContext& ctx);--private:- enum class State : u32 {- NonInitialized,- Initialized,- };-- std::optional<std::shared_ptr<NfpDevice>> GetNfpDevice(u64 handle);-- KernelHelpers::ServiceContext service_context;-- std::array<std::shared_ptr<NfpDevice>, 10> devices{};-- State state{State::NonInitialized};- Kernel::KEvent* availability_change_event;};} // namespace Service::NFPdiff --git a/src/core/hle/service/nfp/nfp_result.h b/src/core/hle/service/nfp/nfp_result.hindex d8e4cf0945..4c126cd815 100644--- a/src/core/hle/service/nfp/nfp_result.h+++ b/src/core/hle/service/nfp/nfp_result.h@@ -1,5 +1,5 @@// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project-// SPDX-License-Identifier: GPL-3.0-or-later+// SPDX-License-Identifier: GPL-2.0-or-later#pragma once@@ -7,18 +7,19 @@namespace Service::NFP {-constexpr Result DeviceNotFound(ErrorModule::NFP, 64);-constexpr Result InvalidArgument(ErrorModule::NFP, 65);-constexpr Result WrongApplicationAreaSize(ErrorModule::NFP, 68);-constexpr Result WrongDeviceState(ErrorModule::NFP, 73);-constexpr Result NfcDisabled(ErrorModule::NFP, 80);-constexpr Result WriteAmiiboFailed(ErrorModule::NFP, 88);-constexpr Result TagRemoved(ErrorModule::NFP, 97);-constexpr Result RegistrationIsNotInitialized(ErrorModule::NFP, 120);-constexpr Result ApplicationAreaIsNotInitialized(ErrorModule::NFP, 128);-constexpr Result CorruptedData(ErrorModule::NFP, 144);-constexpr Result WrongApplicationAreaId(ErrorModule::NFP, 152);-constexpr Result ApplicationAreaExist(ErrorModule::NFP, 168);-constexpr Result NotAnAmiibo(ErrorModule::NFP, 178);+constexpr Result ResultDeviceNotFound(ErrorModule::NFP, 64);+constexpr Result ResultInvalidArgument(ErrorModule::NFP, 65);+constexpr Result ResultWrongApplicationAreaSize(ErrorModule::NFP, 68);+constexpr Result ResultWrongDeviceState(ErrorModule::NFP, 73);+constexpr Result ResultUnknown74(ErrorModule::NFC, 74);+constexpr Result ResultNfcDisabled(ErrorModule::NFP, 80);+constexpr Result ResultWriteAmiiboFailed(ErrorModule::NFP, 88);+constexpr Result ResultTagRemoved(ErrorModule::NFP, 97);+constexpr Result ResultRegistrationIsNotInitialized(ErrorModule::NFP, 120);+constexpr Result ResultApplicationAreaIsNotInitialized(ErrorModule::NFP, 128);+constexpr Result ResultCorruptedData(ErrorModule::NFP, 144);+constexpr Result ResultWrongApplicationAreaId(ErrorModule::NFP, 152);+constexpr Result ResultApplicationAreaExist(ErrorModule::NFP, 168);+constexpr Result ResultNotAnAmiibo(ErrorModule::NFP, 178);} // namespace Service::NFPdiff --git a/src/core/hle/service/nfp/nfp_types.h b/src/core/hle/service/nfp/nfp_types.hindex 1ef047cee6..7d36d5ee69 100644--- a/src/core/hle/service/nfp/nfp_types.h+++ b/src/core/hle/service/nfp/nfp_types.h@@ -7,32 +7,19 @@#include "common/swap.h"#include "core/hle/service/mii/types.h"+#include "core/hle/service/nfc/nfc_types.h"namespace Service::NFP {static constexpr std::size_t amiibo_name_length = 0xA;static constexpr std::size_t application_id_version_offset = 0x1c;static constexpr std::size_t counter_limit = 0xffff;-enum class ServiceType : u32 {- User,- Debug,- System,-};--enum class DeviceState : u32 {- Initialized,- SearchingForTag,- TagFound,- TagRemoved,- TagMounted,- Unavailable,- Finalized,-};-+// This is nn::nfp::ModelTypeenum class ModelType : u32 {Amiibo,};+// This is nn::nfp::MountTargetenum class MountTarget : u32 {None,Rom,@@ -72,35 +59,6 @@ enum class AmiiboSeries : u8 {Diablo,};-enum class TagType : u32 {- None,- Type1, // ISO14443A RW 96-2k bytes 106kbit/s- Type2, // ISO14443A RW/RO 540 bytes 106kbit/s- Type3, // Sony Felica RW/RO 2k bytes 212kbit/s- Type4, // ISO14443A RW/RO 4k-32k bytes 424kbit/s- Type5, // ISO15693 RW/RO 540 bytes 106kbit/s-};--enum class PackedTagType : u8 {- None,- Type1, // ISO14443A RW 96-2k bytes 106kbit/s- Type2, // ISO14443A RW/RO 540 bytes 106kbit/s- Type3, // Sony Felica RW/RO 2k bytes 212kbit/s- Type4, // ISO14443A RW/RO 4k-32k bytes 424kbit/s- Type5, // ISO15693 RW/RO 540 bytes 106kbit/s-};--// Verify this enum. It might be completely wrong default protocol is 0x48-enum class TagProtocol : u32 {- None,- TypeA = 1U << 0, // ISO14443A- TypeB = 1U << 1, // ISO14443B- TypeF = 1U << 2, // Sony Felica- Unknown1 = 1U << 3,- Unknown2 = 1U << 5,- All = 0xFFFFFFFFU,-};-enum class AppAreaVersion : u8 {Nintendo3DS = 0,NintendoWiiU = 1,@@ -115,6 +73,11 @@ enum class BreakType : u32 {Unknown2,};+enum class WriteType : u32 {+ Unknown0,+ Unknown1,+};+enum class CabinetMode : u8 {StartNicknameAndOwnerSettings,StartGameDataEraser,@@ -122,27 +85,16 @@ enum class CabinetMode : u8 {StartFormatter,};-enum class MifareCmd : u8 {- AuthA = 0x60,- AuthB = 0x61,- Read = 0x30,- Write = 0xA0,- Transfer = 0xB0,- Decrement = 0xC0,- Increment = 0xC1,- Store = 0xC2-};--using UniqueSerialNumber = std::array<u8, 7>;using LockBytes = std::array<u8, 2>;using HashData = std::array<u8, 0x20>;using ApplicationArea = std::array<u8, 0xD8>;using AmiiboName = std::array<char, (amiibo_name_length * 4) + 1>;-using DataBlock = std::array<u8, 0x10>;-using KeyData = std::array<u8, 0x6>;++// This is nn::nfp::TagInfo+using TagInfo = NFC::TagInfo;struct TagUuid {- UniqueSerialNumber uid;+ NFC::UniqueSerialNumber uid;u8 nintendo_id;LockBytes lock_bytes;};@@ -243,7 +195,7 @@ struct AmiiboModelInfo {AmiiboType amiibo_type;u16_be model_number;AmiiboSeries series;- PackedTagType tag_type;+ NFC::PackedTagType tag_type;INSERT_PADDING_BYTES(0x4); // Unknown};static_assert(sizeof(AmiiboModelInfo) == 0xC, "AmiiboModelInfo is an invalid size");@@ -298,7 +250,7 @@ struct NTAG215File {u32_be register_info_crc;ApplicationArea application_area; // Encrypted Game dataHashData hmac_tag; // Hash- UniqueSerialNumber uid; // Unique serial number+ NFC::UniqueSerialNumber uid; // Unique serial numberu8 nintendo_id; // Tag UUIDAmiiboModelInfo model_info;HashData keygen_salt; // Salt@@ -326,17 +278,7 @@ static_assert(sizeof(EncryptedNTAG215File) == sizeof(NTAG215File),static_assert(std::is_trivially_copyable_v<EncryptedNTAG215File>,"EncryptedNTAG215File must be trivially copyable.");-struct TagInfo {- UniqueSerialNumber uuid;- INSERT_PADDING_BYTES(0x3);- u8 uuid_length;- INSERT_PADDING_BYTES(0x15);- TagProtocol protocol;- TagType tag_type;- INSERT_PADDING_BYTES(0x30);-};-static_assert(sizeof(TagInfo) == 0x58, "TagInfo is an invalid size");-+// This is nn::nfp::CommonInfostruct CommonInfo {WriteDate last_write_date;u16 write_counter;@@ -347,6 +289,7 @@ struct CommonInfo {};static_assert(sizeof(CommonInfo) == 0x40, "CommonInfo is an invalid size");+// This is nn::nfp::ModelInfostruct ModelInfo {u16 character_id;u8 character_variant;@@ -357,6 +300,7 @@ struct ModelInfo {};static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");+// This is nn::nfp::RegisterInfostruct RegisterInfo {Service::Mii::CharInfo mii_char_info;WriteDate creation_date;@@ -366,6 +310,7 @@ struct RegisterInfo {};static_assert(sizeof(RegisterInfo) == 0x100, "RegisterInfo is an invalid size");+// This is nn::nfp::RegisterInfoPrivatestruct RegisterInfoPrivate {Service::Mii::MiiStoreData mii_store_data;WriteDate creation_date;@@ -375,12 +320,13 @@ struct RegisterInfoPrivate {};static_assert(sizeof(RegisterInfoPrivate) == 0x100, "RegisterInfoPrivate is an invalid size");+// This is nn::nfp::AdminInfostruct AdminInfo {u64 application_id;u32 application_area_id;u16 crc_change_counter;u8 flags;- PackedTagType tag_type;+ NFC::PackedTagType tag_type;AppAreaVersion app_area_version;INSERT_PADDING_BYTES(0x7);INSERT_PADDING_BYTES(0x28);@@ -411,7 +357,7 @@ struct NfpData {u32 access_id;u16 settings_crc_counter;u8 font_region;- PackedTagType tag_type;+ NFC::PackedTagType tag_type;AppAreaVersion console_type;u8 application_id_byte;INSERT_PADDING_BYTES(0x2E);@@ -420,37 +366,4 @@ struct NfpData {static_assert(sizeof(NfpData) == 0x298, "NfpData is an invalid size");#pragma pack()-struct SectorKey {- MifareCmd command;- u8 unknown; // Usually 1- INSERT_PADDING_BYTES(0x6);- KeyData sector_key;- INSERT_PADDING_BYTES(0x2);-};-static_assert(sizeof(SectorKey) == 0x10, "SectorKey is an invalid size");--struct MifareReadBlockParameter {- u8 sector_number;- INSERT_PADDING_BYTES(0x7);- SectorKey sector_key;-};-static_assert(sizeof(MifareReadBlockParameter) == 0x18,- "MifareReadBlockParameter is an invalid size");--struct MifareReadBlockData {- DataBlock data;- u8 sector_number;- INSERT_PADDING_BYTES(0x7);-};-static_assert(sizeof(MifareReadBlockData) == 0x18, "MifareReadBlockData is an invalid size");--struct MifareWriteBlockParameter {- DataBlock data;- u8 sector_number;- INSERT_PADDING_BYTES(0x7);- SectorKey sector_key;-};-static_assert(sizeof(MifareWriteBlockParameter) == 0x28,- "MifareWriteBlockParameter is an invalid size");-} // namespace Service::NFPdiff --git a/src/yuzu/applets/qt_amiibo_settings.cpp b/src/yuzu/applets/qt_amiibo_settings.cppindex 4559df5b16..4988fcc834 100644--- a/src/yuzu/applets/qt_amiibo_settings.cpp+++ b/src/yuzu/applets/qt_amiibo_settings.cpp@@ -8,7 +8,7 @@#include "common/assert.h"#include "common/string_util.h"-#include "core/hle/service/nfp/nfp_device.h"+#include "core/hle/service/nfc/common/device.h"#include "core/hle/service/nfp/nfp_result.h"#include "input_common/drivers/virtual_amiibo.h"#include "input_common/main.h"@@ -22,7 +22,7 @@QtAmiiboSettingsDialog::QtAmiiboSettingsDialog(QWidget* parent,Core::Frontend::CabinetParameters parameters_,InputCommon::InputSubsystem* input_subsystem_,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device_)+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device_): QDialog(parent), ui(std::make_unique<Ui::QtAmiiboSettingsDialog>()),input_subsystem{input_subsystem_}, nfp_device{std::move(nfp_device_)},parameters(std::move(parameters_)) {@@ -52,11 +52,11 @@ void QtAmiiboSettingsDialog::LoadInfo() {return;}- if (nfp_device->GetCurrentState() != Service::NFP::DeviceState::TagFound &&- nfp_device->GetCurrentState() != Service::NFP::DeviceState::TagMounted) {+ if (nfp_device->GetCurrentState() != Service::NFC::DeviceState::TagFound &&+ nfp_device->GetCurrentState() != Service::NFC::DeviceState::TagMounted) {return;}- nfp_device->Mount(Service::NFP::MountTarget::All);+ nfp_device->Mount(Service::NFP::ModelType::Amiibo, Service::NFP::MountTarget::All);LoadAmiiboInfo();LoadAmiiboData();@@ -261,7 +261,7 @@ void QtAmiiboSettings::Close() const {void QtAmiiboSettings::ShowCabinetApplet(const Core::Frontend::CabinetCallback& callback_,const Core::Frontend::CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const {+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device) const {callback = std::move(callback_);emit MainWindowShowAmiiboSettings(parameters, nfp_device);}diff --git a/src/yuzu/applets/qt_amiibo_settings.h b/src/yuzu/applets/qt_amiibo_settings.hindex bc389a33fa..ee66a02550 100644--- a/src/yuzu/applets/qt_amiibo_settings.h+++ b/src/yuzu/applets/qt_amiibo_settings.h@@ -23,9 +23,9 @@ namespace Ui {class QtAmiiboSettingsDialog;}-namespace Service::NFP {-class NfpDevice;-} // namespace Service::NFP+namespace Service::NFC {+class NfcDevice;+} // namespace Service::NFCclass QtAmiiboSettingsDialog final : public QDialog {Q_OBJECT@@ -33,7 +33,7 @@ class QtAmiiboSettingsDialog final : public QDialog {public:explicit QtAmiiboSettingsDialog(QWidget* parent, Core::Frontend::CabinetParameters parameters_,InputCommon::InputSubsystem* input_subsystem_,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device_);+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device_);~QtAmiiboSettingsDialog() override;int exec() override;@@ -52,7 +52,7 @@ private:std::unique_ptr<Ui::QtAmiiboSettingsDialog> ui;InputCommon::InputSubsystem* input_subsystem;- std::shared_ptr<Service::NFP::NfpDevice> nfp_device;+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device;// Parameters sent in from the backend HLE applet.Core::Frontend::CabinetParameters parameters;@@ -71,11 +71,11 @@ public:void Close() const override;void ShowCabinetApplet(const Core::Frontend::CabinetCallback& callback_,const Core::Frontend::CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const override;+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device) const override;signals:void MainWindowShowAmiiboSettings(const Core::Frontend::CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device) const;+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device) const;void MainWindowRequestExit() const;private:diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cppindex b79409a68a..e051e35df9 100644--- a/src/yuzu/main.cpp+++ b/src/yuzu/main.cpp@@ -570,8 +570,8 @@ void GMainWindow::RegisterMetaTypes() {// Cabinet AppletqRegisterMetaType<Core::Frontend::CabinetParameters>("Core::Frontend::CabinetParameters");- qRegisterMetaType<std::shared_ptr<Service::NFP::NfpDevice>>(- "std::shared_ptr<Service::NFP::NfpDevice>");+ qRegisterMetaType<std::shared_ptr<Service::NFC::NfcDevice>>(+ "std::shared_ptr<Service::NFC::NfcDevice>");// Controller AppletqRegisterMetaType<Core::Frontend::ControllerParameters>("Core::Frontend::ControllerParameters");@@ -599,7 +599,7 @@ void GMainWindow::RegisterMetaTypes() {}void GMainWindow::AmiiboSettingsShowDialog(const Core::Frontend::CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device) {+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device) {cabinet_applet =new QtAmiiboSettingsDialog(this, parameters, input_subsystem.get(), nfp_device);SCOPE_EXIT({diff --git a/src/yuzu/main.h b/src/yuzu/main.hindex 8b5c1d7471..ac90bd5ae6 100644--- a/src/yuzu/main.h+++ b/src/yuzu/main.h@@ -93,9 +93,9 @@ enum class SwkbdReplyType : u32;enum class WebExitReason : u32;} // namespace Service::AM::Applets-namespace Service::NFP {-class NfpDevice;-} // namespace Service::NFP+namespace Service::NFC {+class NfcDevice;+} // namespace Service::NFCnamespace Ui {class MainWindow;@@ -188,7 +188,7 @@ public slots:void OnExit();void OnSaveConfig();void AmiiboSettingsShowDialog(const Core::Frontend::CabinetParameters& parameters,- std::shared_ptr<Service::NFP::NfpDevice> nfp_device);+ std::shared_ptr<Service::NFC::NfcDevice> nfp_device);void AmiiboSettingsRequestExit();void ControllerSelectorReconfigureControllers(const Core::Frontend::ControllerParameters& parameters);