diff --git a/cafe/ntag.def b/cafe/ntag.def index 2f372782b..0f0762bd3 100644 --- a/cafe/ntag.def +++ b/cafe/ntag.def @@ -7,7 +7,6 @@ NTAGConvertMasterDataToWriteDataForT2T NTAGConvertT2T NTAGCreateAllWriteData NTAGCreateAllWriteDataForT2T -NTAGDetect NTAGFormat NTAGInit NTAGInitEx @@ -28,3 +27,6 @@ NTAGWriteT2TLockArea NTAGWriteT2TRawData NTAGWriteT2TRawDataEx NTAGWriteT2TWithConvert + +:TEXT_WRAP +NTAGDetect diff --git a/include/nfc/nfc.h b/include/nfc/nfc.h index 4f2b5fb10..e0923f17d 100644 --- a/include/nfc/nfc.h +++ b/include/nfc/nfc.h @@ -554,7 +554,7 @@ NFCAntennaCheck(VPADChan chan, void *userContext); /** - * Start tag discovery provide info about the first detected tag. + * Start tag discovery and provide info about the first detected tag. * * \param chan * The DRC channel to use. @@ -1144,7 +1144,7 @@ NFCSetReadOnly(VPADChan chan, * The end page address. * * \param authenticate - * \c TRUE if (custom?) authentification using PWD_AUTH should be done. + * \c TRUE if authentification using PWD_AUTH should be done. * * \param callback * A pointer to the callback function. @@ -1198,8 +1198,8 @@ NFCReadT2T(VPADChan chan, * \param write0Start,write1Start,write2Start,write3Start * The start page address. * - * \param write0End,write1End,write2End,write3End - * The end page address. + * \param write0Size,write1Size,write2Size,write3Size + * The size of the data to write in bytes. * * \param write0Data,write1Data,write2Data,write3Data * The data which should be written (max. \c 0xF0 bytes per write). @@ -1239,10 +1239,10 @@ NFCWriteT2T(VPADChan chan, NFCNTAGVersion *version, uint32_t commandTimeout, uint8_t numWrites, - uint8_t write0Start, uint8_t write0End, void *write0Data, - uint8_t write1Start, uint8_t write1End, void *write1Data, - uint8_t write2Start, uint8_t write2End, void *write2Data, - uint8_t write3Start, uint8_t write3End, void *write3Data, + uint8_t write0Start, uint8_t write0Size, void *write0Data, + uint8_t write1Start, uint8_t write1Size, void *write1Data, + uint8_t write2Start, uint8_t write2Size, void *write2Data, + uint8_t write3Start, uint8_t write3Size, void *write3Data, uint8_t activationStart, uint32_t *deactivationData, uint32_t *activationData, uint8_t authenticate, uint8_t activate, NFCCallbackFn callback, diff --git a/include/nn/nfp/nfp_cpp.h b/include/nn/nfp/nfp_cpp.h index ad456dc1a..c55820df9 100644 --- a/include/nn/nfp/nfp_cpp.h +++ b/include/nn/nfp/nfp_cpp.h @@ -182,8 +182,8 @@ struct WUT_PACKED RegisterInfo FFLStoreData mii; //! The name of this amiibo uint16_t name[11]; - //! Flags (see \link RegisterInfoSet \endlink) - uint8_t flags; + //! Font region + uint8_t fontRegion; //! Country code uint8_t country; //! The date when the amiibo was registered @@ -193,7 +193,7 @@ struct WUT_PACKED RegisterInfo }; WUT_CHECK_OFFSET(RegisterInfo, 0x0, mii); WUT_CHECK_OFFSET(RegisterInfo, 0x60, name); -WUT_CHECK_OFFSET(RegisterInfo, 0x76, flags); +WUT_CHECK_OFFSET(RegisterInfo, 0x76, fontRegion); WUT_CHECK_OFFSET(RegisterInfo, 0x77, country); WUT_CHECK_OFFSET(RegisterInfo, 0x78, registerDate); WUT_CHECK_OFFSET(RegisterInfo, 0x7C, reserved); @@ -230,14 +230,14 @@ struct WUT_PACKED RegisterInfoSet FFLStoreData mii; //! The name of this amiibo uint16_t name[11]; - //! Flags (can be retrieved from \link RegisterInfo \endlink) - uint8_t flags; + //! Font region + uint8_t fontRegion; //! reserved bytes, must be 0 uint8_t reserved[0x2d]; }; WUT_CHECK_OFFSET(RegisterInfoSet, 0x0, mii); WUT_CHECK_OFFSET(RegisterInfoSet, 0x60, name); -WUT_CHECK_OFFSET(RegisterInfoSet, 0x76, flags); +WUT_CHECK_OFFSET(RegisterInfoSet, 0x76, fontRegion); WUT_CHECK_OFFSET(RegisterInfoSet, 0x77, reserved); WUT_CHECK_SIZE(RegisterInfoSet, 0xA4); diff --git a/include/ntag/ntag.dox b/include/ntag/ntag.dox new file mode 100644 index 000000000..69333d7dd --- /dev/null +++ b/include/ntag/ntag.dox @@ -0,0 +1,5 @@ +/** + * \defgroup ntag ntag + * Nintendo? Tag (NTAG). + * NFC library for Amiibo and Pokemon Rumble U. + */ diff --git a/include/ntag/ntag.h b/include/ntag/ntag.h new file mode 100644 index 000000000..f62e25e40 --- /dev/null +++ b/include/ntag/ntag.h @@ -0,0 +1,980 @@ +#pragma once +#include +#include +#include + +/** + * \defgroup ntag_ntag + * \ingroup ntag + * Nintendo? Tag (NTAG). + * NFC library for Amiibo and Pokemon Rumble U. + * For a high-level Amiibo library see nn::nfp. + * @{ + */ + +#ifdef __cplusplus +extern "C" { +#endif + +typedef int32_t NTAGError; +typedef struct NTAGFormatSettings NTAGFormatSettings; +typedef struct NTAGNoftHeader NTAGNoftHeader; +typedef struct NTAGInfoHeader NTAGInfoHeader; +typedef struct NTAGAreaHeader NTAGAreaHeader; +typedef struct NTAGAreaInfo NTAGAreaInfo; +typedef struct NTAGData NTAGData; +typedef struct NTAGInfoT2T NTAGInfoT2T; +typedef struct NTAGApplicationDataT2T NTAGApplicationDataT2T; +typedef struct NTAGRawDataT2T NTAGRawDataT2T; +typedef struct NTAGRawDataContainerT2T NTAGRawDataContainerT2T; +typedef struct NTAGDataT2T NTAGDataT2T; + +struct NTAGFormatSettings +{ + uint8_t version; + WUT_PADDING_BYTES(0x3); + uint32_t makerCode; + uint32_t identifyCode; + WUT_PADDING_BYTES(0x1C); +}; +WUT_CHECK_OFFSET(NTAGFormatSettings, 0x0, version); +WUT_CHECK_OFFSET(NTAGFormatSettings, 0x4, makerCode); +WUT_CHECK_OFFSET(NTAGFormatSettings, 0x8, identifyCode); +WUT_CHECK_SIZE(NTAGFormatSettings, 0x28); + +struct WUT_PACKED NTAGNoftHeader +{ + uint32_t magic; + uint8_t version; + uint16_t writeCount; + uint8_t unknown; +}; +WUT_CHECK_OFFSET(NTAGNoftHeader, 0x0, magic); +WUT_CHECK_OFFSET(NTAGNoftHeader, 0x4, version); +WUT_CHECK_OFFSET(NTAGNoftHeader, 0x5, writeCount); +WUT_CHECK_OFFSET(NTAGNoftHeader, 0x7, unknown); +WUT_CHECK_SIZE(NTAGNoftHeader, 0x8); + +struct NTAGInfoHeader +{ + uint16_t rwHeaderOffset; + uint16_t rwSize; + uint16_t roHeaderOffset; + uint16_t roSize; + NFCUid uid; + uint8_t formatVersion; +}; +WUT_CHECK_OFFSET(NTAGInfoHeader, 0x0, rwHeaderOffset); +WUT_CHECK_OFFSET(NTAGInfoHeader, 0x2, rwSize); +WUT_CHECK_OFFSET(NTAGInfoHeader, 0x4, roHeaderOffset); +WUT_CHECK_OFFSET(NTAGInfoHeader, 0x6, roSize); +WUT_CHECK_OFFSET(NTAGInfoHeader, 0x8, uid); +WUT_CHECK_OFFSET(NTAGInfoHeader, 0xF, formatVersion); +WUT_CHECK_SIZE(NTAGInfoHeader, 0x10); + +struct NTAGAreaHeader +{ + uint16_t magic; + uint16_t offset; + uint16_t size; + WUT_PADDING_BYTES(0x2); + uint32_t makerCode; + uint32_t identifyCode; +}; +WUT_CHECK_OFFSET(NTAGAreaHeader, 0x0, magic); +WUT_CHECK_OFFSET(NTAGAreaHeader, 0x2, offset); +WUT_CHECK_OFFSET(NTAGAreaHeader, 0x4, size); +WUT_CHECK_OFFSET(NTAGAreaHeader, 0x8, makerCode); +WUT_CHECK_OFFSET(NTAGAreaHeader, 0xC, identifyCode); +WUT_CHECK_SIZE(NTAGAreaHeader, 0x10); + +struct NTAGAreaInfo +{ + void *data; + uint16_t size; + WUT_PADDING_BYTES(0x2); + uint32_t makerCode; + uint32_t identifyCode; + WUT_PADDING_BYTES(0x20); +}; +WUT_CHECK_OFFSET(NTAGAreaInfo, 0x0, data); +WUT_CHECK_OFFSET(NTAGAreaInfo, 0x4, size); +WUT_CHECK_OFFSET(NTAGAreaInfo, 0x8, makerCode); +WUT_CHECK_OFFSET(NTAGAreaInfo, 0xC, identifyCode); +WUT_CHECK_SIZE(NTAGAreaInfo, 0x30); + +struct NTAGData +{ + NFCUid uid; + uint8_t readOnly; + uint8_t formatVersion; + WUT_PADDING_BYTES(0x3); + NTAGAreaInfo rwInfo; + NTAGAreaInfo roInfo; + WUT_PADDING_BYTES(0x20); +}; +WUT_CHECK_OFFSET(NTAGData, 0x00, uid); +WUT_CHECK_OFFSET(NTAGData, 0x07, readOnly); +WUT_CHECK_OFFSET(NTAGData, 0x08, formatVersion); +WUT_CHECK_OFFSET(NTAGData, 0x0C, rwInfo); +WUT_CHECK_OFFSET(NTAGData, 0x3C, roInfo); +WUT_CHECK_SIZE(NTAGData, 0x8C); + +struct WUT_PACKED NTAGInfoT2T +{ + uint8_t magic; + uint16_t writes; + uint8_t figureVersion; + uint8_t flags; + uint8_t characterID[3]; + uint16_t numberingID; + uint8_t figureType; + uint8_t seriesID; + uint32_t unknown; + uint16_t applicationAreaWrites; + uint16_t crcCounter; + uint32_t crc; + uint8_t fontRegion; + uint16_t name[10]; + FFLStoreData mii; + uint8_t country; + uint16_t setupDate; + uint16_t lastWriteDate; + uint32_t accessID; + uint64_t titleID; + //! First 0x22 bytes contain NX specific extensions + uint8_t reserved[0x1FC]; +}; +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x00, magic); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x01, writes); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x03, figureVersion); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x04, flags); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x05, characterID); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x08, numberingID); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x0A, figureType); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x0B, seriesID); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x0C, unknown); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x10, applicationAreaWrites); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x12, crcCounter); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x14, crc); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x18, fontRegion); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x19, name); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x2D, mii); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x8D, country); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x8E, setupDate); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x90, lastWriteDate); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x92, accessID); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x96, titleID); +WUT_CHECK_OFFSET(NTAGInfoT2T, 0x9E, reserved); +WUT_CHECK_SIZE(NTAGInfoT2T, 0x29a); + +struct NTAGApplicationDataT2T +{ + uint16_t size; + uint8_t data[0xD8]; +}; +WUT_CHECK_OFFSET(NTAGApplicationDataT2T, 0x00, size); +WUT_CHECK_OFFSET(NTAGApplicationDataT2T, 0x02, data); +WUT_CHECK_SIZE(NTAGApplicationDataT2T, 0xDA); + +struct NTAGRawDataT2T +{ + uint8_t uid[9]; + uint8_t internal; + uint8_t lockBytes[2]; + uint8_t capabilityContainer[4]; + struct WUT_PACKED { + uint8_t magic; + uint16_t writes; + uint8_t figureVersion; + uint8_t flags; + uint8_t country; + uint16_t crcCounter; + uint16_t setupDate; + uint16_t lastWriteDate; + uint32_t crc; + uint16_t name[10]; + } section0; + struct WUT_PACKED { + uint8_t tagHmac[0x20]; + uint8_t characterID[3]; + uint8_t figureType; + uint16_t numberingID; + uint8_t seriesID; + uint8_t formatVersion; + uint32_t unknown; + uint8_t keygenSalt[0x20]; + uint8_t dataHmac[0x20]; + } section1; + struct WUT_PACKED { + FFLStoreData mii; + uint64_t titleID; + uint16_t applicationAreaWrites; + uint32_t accessID; + uint8_t reserved[0x22]; + } section2; + uint8_t applicationData[0xD8]; + uint8_t dynamicLock[3]; + uint8_t reserved0; + uint8_t cfg0[4]; + uint8_t cfg1[4]; + uint8_t pwd[4]; + uint8_t pack[2]; + uint8_t reserved1[2]; +}; +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x000, uid); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x009, internal); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x00A, lockBytes); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x00C, capabilityContainer); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x010, section0.magic); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x011, section0.writes); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x013, section0.figureVersion); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x014, section0.flags); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x015, section0.country); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x016, section0.crcCounter); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x018, section0.setupDate); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x01A, section0.lastWriteDate); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x01C, section0.crc); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x020, section0.name); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x034, section1.tagHmac); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x054, section1.characterID); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x057, section1.figureType); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x058, section1.numberingID); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x05A, section1.seriesID); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x05B, section1.formatVersion); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x05C, section1.unknown); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x060, section1.keygenSalt); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x080, section1.dataHmac); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x0A0, section2.mii); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x100, section2.titleID); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x108, section2.applicationAreaWrites); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x10A, section2.accessID); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x10E, section2.reserved); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x130, applicationData); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x208, dynamicLock); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x20B, reserved0); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x20C, cfg0); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x210, cfg1); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x214, pwd); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x218, pack); +WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x21A, reserved1); +WUT_CHECK_SIZE(NTAGRawDataT2T, 0x21C); + +struct NTAGRawDataContainerT2T +{ + uint16_t size; + NTAGRawDataT2T data; +}; +WUT_CHECK_OFFSET(NTAGRawDataContainerT2T, 0x00, size); +WUT_CHECK_OFFSET(NTAGRawDataContainerT2T, 0x02, data); +WUT_CHECK_SIZE(NTAGRawDataContainerT2T, 0x21E); + +struct NTAGDataT2T +{ + NFCTagInfo tagInfo; + uint8_t formatVersion; + NTAGInfoT2T info; + NTAGApplicationDataT2T appData; + NTAGRawDataContainerT2T raw; + WUT_PADDING_BYTES(0x20); +}; +WUT_CHECK_OFFSET(NTAGDataT2T, 0x000, tagInfo); +WUT_CHECK_OFFSET(NTAGDataT2T, 0x02D, formatVersion); +WUT_CHECK_OFFSET(NTAGDataT2T, 0x02E, info); +WUT_CHECK_OFFSET(NTAGDataT2T, 0x2C8, appData); +WUT_CHECK_OFFSET(NTAGDataT2T, 0x3A2, raw); +WUT_CHECK_SIZE(NTAGDataT2T, 0x5E0); + +/** + * Generic callback function. + * + * \param chan + * The channel this callback is coming from. + * + * \param error + * 0 on success. + * + * \param userContext + * User provided value. + */ +typedef void +(*NTAGCallbackFn)(VPADChan chan, + NTAGError error, + void *userContext); + +/** + * Callback function for \link NTAGRead \endlink. + * + * \param chan + * The channel this callback is coming from. + * + * \param error + * 0 on success. + * + * \param data + * The result of the data read. + * + * \param userContext + * User provided value. + */ +typedef void +(*NTAGReadCallbackFn)(VPADChan chan, + NTAGError error, + NTAGData *data, + void *userContext); + +/** + * Callback function for \link NTAGReadT2T \endlink. + * + * \param chan + * The channel this callback is coming from. + * + * \param error + * 0 on success. + * + * \param data + * The result of the data read. + * + * \param userContext + * User provided value. + */ +typedef void +(*NTAGReadT2TCallbackFn)(VPADChan chan, + NTAGError error, + NTAGDataT2T *data, + void *userContext); + +/** + * Callback function for \link NTAGReadT2TRawData \endlink. + * + * \param chan + * The channel this callback is coming from. + * + * \param error + * 0 on success. + * + * \param tagInfo + * The tag info of the read tag. + * + * \param data + * The result of the data read. + * + * \param userContext + * User provided value. + */ +typedef void +(*NTAGReadT2TRawDataCallbackFn)(VPADChan chan, + NTAGError error, + NFCTagInfo *tagInfo, + NTAGRawDataContainerT2T *rawData, + void *userContext); + +/** + * Initializes the NTAG library. + * + * \param chan + * The DRC channel to use. + * + * \return + * 0 on success. + */ +NTAGError +NTAGInit(VPADChan chan); + +/** + * Initializes the NTAG library. + * + * \param chan + * The DRC channel to use. + * + * \return + * 0 on success. + */ +NTAGError +NTAGInitEx(VPADChan chan); + +/** + * Check if NTAG is initialized. + * + * \param chan + * The DRC channel to use. + * + * \return + * \c TRUE if initialized, \c FALSE otherwise. + */ +BOOL +NTAGIsInit(VPADChan chan); + +/** + * Process NTAG. + * This needs to be called periodically and will call pending callbacks. + * + * \param chan + * The DRC channel to use. + */ +void +NTAGProc(VPADChan chan); + +/** + * Shutdown the NTAG library. + * + * \param chan + * The DRC channel to use. + * + * \return + * 0 on success. + */ +NTAGError +NTAGShutdown(VPADChan chan); + +/** + * Abort pending NTAG operations. + * + * \param chan + * The DRC channel to use. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGAbort(VPADChan chan, + NTAGCallbackFn callback, + void *userContext); + +/** + * Start tag discovery and provide info about the first detected tag. + * + * \note + * The original function contains an error and calls itself recursively. + * This inline version uses \link NFCDetect \endlink instead. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +static inline NFCError +NTAGDetect(VPADChan chan, + uint32_t timeout, + NFCDetectCallbackFn callback, + void *userContext) +{ + return NFCDetect(chan, timeout, callback, userContext); +} +// NTAGError +// NTAGDetect(VPADChan chan, +// uint32_t timeout, +// NTAGDetectCallbackFn callback, +// void *userContext); + +/** + * Format a Type 1 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param rwSize + * The size of the data which should be written to initialize the RW area. + * + * \param rwData + * A pointer to the data which should be written to initialize the RW area. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGFormat(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + uint32_t rwSize, + void *rwData, + NTAGCallbackFn callback, + void *userContext); + +/** + * Make a Type 1 Tag read only by setting the RWA byte. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag (can be \c NULL). + * + * \param uidMask + * The UID of the tag will be masked with this mask before compared to the expected UID (can be \c NULL). + * + * \param readOnly + * \c TRUE if read only, \c FALSE otherwise. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGSetReadOnly(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NFCUid *uidMask, + BOOL readOnly, + NTAGCallbackFn callback, + void *userContext); + +/** + * Set a callback which will be called once a tag is attached / removed. + * + * \param chan + * The DRC channel to use. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + */ +void +NTAGSetTagDetectCallback(VPADChan chan, + NFCTagDetectCallbackFn callback, + void *userContext); + +/** + * Set the format settings which should be checked against while reading from Type 1 tags. + * + * \param settings + * A pointer from which the settings should be copied from. + */ +void +NTAGSetFormatSettings(NTAGFormatSettings *settings); + +/** + * Read from a Type 1 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag (can be \c NULL). + * + * \param uidMask + * The UID of the tag will be masked with this mask before compared to the expected UID (can be \c NULL). + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGRead(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NFCUid *uidMask, + NTAGReadCallbackFn callback, + void *userContext); + +/** + * Read from a Type 2 Tag and decrypt & convert the data. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag (can be \c NULL). + * + * \param uidMask + * The UID of the tag will be masked with this mask before compared to the expected UID (can be \c NULL). + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGReadT2T(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NFCUid *uidMask, + NTAGReadT2TCallbackFn callback, + void *userContext); + +/** + * Read raw data from a Type 2 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag (can be \c NULL). + * + * \param uidMask + * The UID of the tag will be masked with this mask before compared to the expected UID (can be \c NULL). + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGReadT2TRawData(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NFCUid *uidMask, + NTAGReadT2TRawDataCallbackFn callback, + void *userContext); + +/** + * Write to the RW area of a Type 1 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param rwSize + * The size of the data which should be written to the RW area. + * + * \param rwData + * A pointer to the data which should be written to the RW area. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGWrite(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + uint32_t rwSize, + void *rwData, + NTAGCallbackFn callback, + void *userContext); + +/** + * Write to a Type 2 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param dataContainer + * A pointer to the container which contains the data which should be written to the tag. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGWriteT2T(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NTAGRawDataContainerT2T *dataContainer, + NTAGCallbackFn callback, + void *userContext); + +/** + * Write to the configuration fields of a Type 2 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param cfg0 + * A pointer to the data which should be written to the CFG0 field. + * + * \param cfg1 + * A pointer to the data which should be written to the CFG1 field. + * + * \param pwd + * A pointer to the data which should be written to the PWD field. + * + * \param pack + * A pointer to the data which should be written to the PACK field. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGWriteT2TConfigArea(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + uint32_t *cfg0, + uint32_t *cfg1, + uint32_t *pwd, + uint16_t *pack, + NTAGCallbackFn callback, + void *userContext); + +/** + * Write to the lock bytes of a Type 2 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param lockBytes + * A pointer to the data which should be written to the lock bytes. + * + * \param dynamicLock + * A pointer to the data which should be written to the dynamic lock bytes. + * + * \param cc + * A pointer to the data which should be written to the capability container. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGWriteT2TLockArea(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + uint32_t *lockBytes, + uint32_t *dynamicLock, + uint32_t *cc, + NTAGCallbackFn callback, + void *userContext); + +/** + * Write raw data to a Type 2 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param data + * A pointer to the data which should be written to the tag. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGWriteT2TRawData(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NTAGRawDataT2T *data, + NTAGCallbackFn callback, + void *userContext); + +/** + * Write raw data to a Type 2 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param data + * A pointer to the data which should be written to the tag. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \param authenticate + * \c TRUE if authentification using PWD_AUTH should be done. + * + * \return + * 0 on success. + */ +NTAGError +NTAGWriteT2TRawDataEx(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NTAGRawDataT2T *data, + NTAGCallbackFn callback, + void *userContext, + uint8_t authenticate); + +/** + * Convert & encrypt data and write it to a Type 2 Tag. + * + * \param chan + * The DRC channel to use. + * + * \param timeout + * Timeout in ms until tag discovery is cancelled. + * + * \param uid + * The UID of the expected tag. + * + * \param data + * A pointer to the data which should be written to the tag. + * + * \param callback + * A pointer to the callback function. + * + * \param userContext + * User provided value which will be passed to the callback. + * + * \return + * 0 on success. + */ +NTAGError +NTAGWriteT2TWithConvert(VPADChan chan, + uint32_t timeout, + NFCUid *uid, + NTAGDataT2T *data, + NTAGCallbackFn callback, + void *userContext); + +/** + * Convert and encrypt data. + * + * \param out + * A pointer to write the encrypted data to the raw field. This can be the same as \param in. + * + * \param in + * A pointer to read the data from. This can be the same as \param out. + * + * \return + * 0 on success. + */ +NTAGError +NTAGConvertT2T(NTAGDataT2T *out, + NTAGDataT2T *in); + +/** + * Parse the headers from Type 1 Tag data. + * + * \param data + * The data from which the headers should be parsed from. + * + * \param outNoftHeader + * A pointer to which the NOFT header should be copied to. + * + * \param outInfoHeader + * A pointer to which the info header should be copied to. + * + * \param outRwHeader + * A pointer to which the RW header should be copied to. + * + * \param outRoHeader + * A pointer to which the RO header should be copied to. + * + * \return + * 0 on success. + */ +NTAGError +NTAGParseHeader(void *data, + NTAGNoftHeader *outNoftHeader, + NTAGInfoHeader *outInfoHeader, + NTAGAreaHeader *outRwHeader, + NTAGAreaHeader *outRoHeader); + +#ifdef __cplusplus +} +#endif + +/** @} */ diff --git a/tests/test_compile_headers_common/test_compile_headers_list.h b/tests/test_compile_headers_common/test_compile_headers_list.h index 40822e818..8dc0c7a34 100644 --- a/tests/test_compile_headers_common/test_compile_headers_list.h +++ b/tests/test_compile_headers_common/test_compile_headers_list.h @@ -122,6 +122,7 @@ #include #include #include +#include #include #include #include