nfp_cpp.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <nn/result.h>
#include <nn/ffl/miidata.h>
#include <coreinit/event.h>
#include <nfc/nfc.h>
 
#ifdef __cplusplus
 
namespace nn {
 
namespace nfp {
 
enum ResultDescription 
{
 // Usage results
 RESULT_OUT_OF_RANGE = 0x03700,
 RESULT_INVALID_PARAM = 0x03780,
 RESULT_INVALID_ALIGNMENT = 0x03800,
 
 // Status results
 RESULT_INVALID_STATE = 0x06400,
 RESULT_INVALID_TAG = 0x0c800,
 RESULT_INVALID_TAG_INFO = 0x0ca80,
 RESULT_NO_BACKUPENTRY = 0x0e580,
 RESULT_NO_REGISTER_INFO = 0x10900,
 RESULT_APP_AREA_MISSING = 0x10400,
 RESULT_APP_AREA_TAGID_MISMATCH = 0x11d00,
 RESULT_APP_AREA_ALREADY_EXISTS = 0x10e00,
 RESULT_APP_AREA_ACCESS_ID_MISMATCH = 0x11300,
 RESULT_NO_BACKUP_SAVEDATA = 0x38880,
 RESULT_SYSTEM_ERROR = 0x3e880,
 
 // Fatal results
 RESULT_FATAL = 0x5db00,
};
 
enum class NfpState : uint32_t
{
 Uninitialized = 0,
 Initialized = 1,
 Searching = 2,
 Found = 3,
 Removed = 4,
 Mounted = 5,
 Unknown6 = 6,
 MountedROM = 7,
};
WUT_CHECK_SIZE(NfpState, 0x4);
 
enum class AdminFlags : uint8_t
{
 IsRegistered = 1 << 0,
 HasApplicationData = 1 << 1,
};
WUT_CHECK_SIZE(AdminFlags, 0x1);
 
enum class TagType : uint8_t
{
 Unknown = 0,
 Type1Tag = 1 << 0,
 Type2Tag = 1 << 1,
 Type3Tag = 1 << 2,
 Iso15693 = 1 << 5,
};
WUT_CHECK_SIZE(TagType, 0x1);
 
struct Date
{
 uint16_t year;
 uint8_t month;
 uint8_t day;
};
WUT_CHECK_OFFSET(Date, 0x0, year);
WUT_CHECK_OFFSET(Date, 0x2, month);
WUT_CHECK_OFFSET(Date, 0x3, day);
WUT_CHECK_SIZE(Date, 0x4);
 
struct ApplicationAreaCreateInfo
{
 uint32_t accessID;
 void* data;
 uint32_t size;
 uint8_t reserved[0x30];
};
WUT_CHECK_OFFSET(ApplicationAreaCreateInfo, 0x0, accessID);
WUT_CHECK_OFFSET(ApplicationAreaCreateInfo, 0x4, data);
WUT_CHECK_OFFSET(ApplicationAreaCreateInfo, 0x8, size);
WUT_CHECK_OFFSET(ApplicationAreaCreateInfo, 0xC, reserved);
WUT_CHECK_SIZE(ApplicationAreaCreateInfo, 0x3C);
 
struct TagId
{
 uint8_t size;
 uint8_t uid[10];
};
WUT_CHECK_OFFSET(TagId, 0x0, size);
WUT_CHECK_OFFSET(TagId, 0x1, uid);
WUT_CHECK_SIZE(TagId, 0xB);
 
struct TagInfo
{
 TagId id;
 uint8_t reserved0[0x15];
 NFCTechnology technology;
 TagType tag_type;
 uint8_t reserved1[0x32];
};
WUT_CHECK_OFFSET(TagInfo, 0x0, id);
WUT_CHECK_OFFSET(TagInfo, 0xB, reserved0);
WUT_CHECK_OFFSET(TagInfo, 0x20, technology);
WUT_CHECK_OFFSET(TagInfo, 0x21, tag_type);
WUT_CHECK_OFFSET(TagInfo, 0x22, reserved1);
WUT_CHECK_SIZE(TagInfo, 0x54);
 
struct CommonInfo
{
 Date lastWriteDate;
 uint16_t writes;
 uint8_t characterID[3];
 uint8_t seriesID;
 uint16_t numberingID;
 uint8_t figureType;
 uint8_t figureVersion;
 uint16_t applicationAreaSize;
 uint8_t reserved[0x30];
};
WUT_CHECK_OFFSET(CommonInfo, 0x0, lastWriteDate);
WUT_CHECK_OFFSET(CommonInfo, 0x4, writes);
WUT_CHECK_OFFSET(CommonInfo, 0x6, characterID);
WUT_CHECK_OFFSET(CommonInfo, 0x9, seriesID);
WUT_CHECK_OFFSET(CommonInfo, 0xA, numberingID);
WUT_CHECK_OFFSET(CommonInfo, 0xC, figureType);
WUT_CHECK_OFFSET(CommonInfo, 0xD, figureVersion);
WUT_CHECK_OFFSET(CommonInfo, 0xE, applicationAreaSize);
WUT_CHECK_OFFSET(CommonInfo, 0x10, reserved);
WUT_CHECK_SIZE(CommonInfo, 0x40);
 
struct WUT_PACKED RegisterInfo
{
 FFLStoreData mii;
 uint16_t name[11];
 uint8_t fontRegion;
 uint8_t country;
 Date registerDate;
 uint8_t reserved[0x2c];
};
WUT_CHECK_OFFSET(RegisterInfo, 0x0, mii);
WUT_CHECK_OFFSET(RegisterInfo, 0x60, name);
WUT_CHECK_OFFSET(RegisterInfo, 0x76, fontRegion);
WUT_CHECK_OFFSET(RegisterInfo, 0x77, country);
WUT_CHECK_OFFSET(RegisterInfo, 0x78, registerDate);
WUT_CHECK_OFFSET(RegisterInfo, 0x7C, reserved);
WUT_CHECK_SIZE(RegisterInfo, 0xA8);
 
struct WUT_PACKED ReadOnlyInfo
{
 uint8_t characterID[3];
 uint8_t seriesID;
 uint16_t numberingID;
 uint8_t figureType;
 uint8_t reserved[0x2f];
};
WUT_CHECK_OFFSET(ReadOnlyInfo, 0x0, characterID);
WUT_CHECK_OFFSET(ReadOnlyInfo, 0x3, seriesID);
WUT_CHECK_OFFSET(ReadOnlyInfo, 0x4, numberingID);
WUT_CHECK_OFFSET(ReadOnlyInfo, 0x6, figureType);
WUT_CHECK_OFFSET(ReadOnlyInfo, 0x7, reserved);
WUT_CHECK_SIZE(ReadOnlyInfo, 0x36);
 
// seems to be the same as ReadOnlyInfo
// maybe left over from an older library version?
using RomInfo = ReadOnlyInfo;
WUT_CHECK_SIZE(RomInfo, 0x36);
 
struct WUT_PACKED RegisterInfoSet
{
 FFLStoreData mii;
 uint16_t name[11];
 uint8_t fontRegion;
 uint8_t reserved[0x2d];
};
WUT_CHECK_OFFSET(RegisterInfoSet, 0x0, mii);
WUT_CHECK_OFFSET(RegisterInfoSet, 0x60, name);
WUT_CHECK_OFFSET(RegisterInfoSet, 0x76, fontRegion);
WUT_CHECK_OFFSET(RegisterInfoSet, 0x77, reserved);
WUT_CHECK_SIZE(RegisterInfoSet, 0xA4);
 
struct WUT_PACKED AdminInfo
{
 uint64_t titleID;
 uint32_t accessID;
 uint16_t applicationAreaWrites;
 AdminFlags flags;
 uint8_t formatVersion;
 uint8_t platform;
 uint8_t reserved[0x2f];
};
WUT_CHECK_OFFSET(AdminInfo, 0x0, titleID);
WUT_CHECK_OFFSET(AdminInfo, 0x8, accessID);
WUT_CHECK_OFFSET(AdminInfo, 0xC, applicationAreaWrites);
WUT_CHECK_OFFSET(AdminInfo, 0xE, flags);
WUT_CHECK_OFFSET(AdminInfo, 0xF, formatVersion);
WUT_CHECK_OFFSET(AdminInfo, 0x10, platform);
WUT_CHECK_OFFSET(AdminInfo, 0x11, reserved);
WUT_CHECK_SIZE(AdminInfo, 0x40);
 
NfpState
GetNfpState()
 asm("GetNfpState__Q2_2nn3nfpFv");
 
nn::Result
Initialize()
 asm("Initialize__Q2_2nn3nfpFv");
 
nn::Result
Finalize()
 asm("Finalize__Q2_2nn3nfpFv");
 
nn::Result
AntennaCheck()
 asm("AntennaCheck__Q2_2nn3nfpFv");
 
nn::Result
SetActivateEvent(OSEvent *event)
 asm("SetActivateEvent__Q2_2nn3nfpFP7OSEvent");
 
nn::Result
SetDeactivateEvent(OSEvent *event)
 asm("SetDeactivateEvent__Q2_2nn3nfpFP7OSEvent");
 
nn::Result
StartDetection()
 asm("StartDetection__Q2_2nn3nfpFv");
 
nn::Result
StopDetection()
 asm("StopDetection__Q2_2nn3nfpFv");
 
nn::Result
Mount()
 asm("Mount__Q2_2nn3nfpFv");
 
nn::Result
MountReadOnly()
 asm("MountReadOnly__Q2_2nn3nfpFv");
 
nn::Result
MountRom()
 asm("MountRom__Q2_2nn3nfpFv");
 
nn::Result
Flush()
 asm("Flush__Q2_2nn3nfpFv");
 
nn::Result
Unmount()
 asm("Unmount__Q2_2nn3nfpFv");
 
bool
IsExistApplicationArea()
 asm("IsExistApplicationArea__Q2_2nn3nfpFv");
 
nn::Result
InitializeCreateInfo(ApplicationAreaCreateInfo *info)
 asm("InitializeCreateInfo__Q2_2nn3nfpFPQ3_2nn3nfp25ApplicationAreaCreateInfo");
 
nn::Result
CreateApplicationArea(const ApplicationAreaCreateInfo &createInfo)
 asm("CreateApplicationArea__Q2_2nn3nfpFRCQ3_2nn3nfp25ApplicationAreaCreateInfo");
 
nn::Result
OpenApplicationArea(uint32_t accessID)
 asm("OpenApplicationArea__Q2_2nn3nfpFUi");
 
nn::Result
DeleteApplicationArea()
 asm("DeleteApplicationArea__Q2_2nn3nfpFv");
 
nn::Result
WriteApplicationArea(const void *data, uint32_t size, const TagId &id)
 asm("WriteApplicationArea__Q2_2nn3nfpFPCvUiRCQ3_2nn3nfp5TagId");
 
nn::Result
ReadApplicationArea(void *outData, uint32_t size)
 asm("ReadApplicationArea__Q2_2nn3nfpFPvUi");
 
nn::Result
InitializeRegisterInfoSet(RegisterInfoSet *infoSet)
 asm("InitializeRegisterInfoSet__Q2_2nn3nfpFPQ3_2nn3nfp15RegisterInfoSet");
 
nn::Result
SetNfpRegisterInfo(const RegisterInfoSet &info)
 asm("SetNfpRegisterInfo__Q2_2nn3nfpFRCQ3_2nn3nfp15RegisterInfoSet");
 
nn::Result
GetNfpRegisterInfo(RegisterInfo *outInfo)
 asm("GetNfpRegisterInfo__Q2_2nn3nfpFPQ3_2nn3nfp12RegisterInfo");
 
nn::Result
DeleteNfpRegisterInfo()
 asm("DeleteNfpRegisterInfo__Q2_2nn3nfpFv");
 
nn::Result
GetNfpCommonInfo(CommonInfo *outInfo)
 asm("GetNfpCommonInfo__Q2_2nn3nfpFPQ3_2nn3nfp10CommonInfo");
 
nn::Result
GetNfpReadOnlyInfo(ReadOnlyInfo *outInfo)
 asm("GetNfpReadOnlyInfo__Q2_2nn3nfpFPQ3_2nn3nfp12ReadOnlyInfo");
 
nn::Result
GetNfpAdminInfo(AdminInfo *outInfo)
 asm("GetNfpAdminInfo__Q2_2nn3nfpFPQ3_2nn3nfp9AdminInfo");
 
nn::Result
GetNfpRomInfo(RomInfo *outInfo)
 asm("GetNfpRomInfo__Q2_2nn3nfpFPQ3_2nn3nfp7RomInfo");
 
nn::Result
GetTagInfo(TagInfo *outInfo)
 asm("GetTagInfo__Q2_2nn3nfpFPQ3_2nn3nfp7TagInfo");
 
nn::Result
Format(const uint8_t *data, int32_t size)
 asm("Format__Q2_2nn3nfpFPCUci");
 
nn::Result
Restore()
 asm("Restore__Q2_2nn3nfpFv");
 
uint32_t
GetErrorCode(const nn::Result &res)
 asm("GetErrorCode__Q2_2nn3nfpFRCQ2_2nn6Result");
 
} //namespace nfp
 
} //namespace nn
 
#endif