nfp_cpp.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <coreinit/event.h>
#include <nfc/nfc.h>
#include <nn/ffl/miidata.h>
#include <nn/result.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