| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * NFC Ndef Mapping For Different Smart Cards. |
| * |
| */ |
| |
| #ifndef PHFRINFC_NDEFMAP_H |
| #define PHFRINFC_NDEFMAP_H |
| |
| |
| /*include files*/ |
| #include <phNfcTypes.h> |
| #include <phNfcStatus.h> |
| #include <phFriNfc.h> |
| #include <phNfcTypes_Mapping.h> |
| |
| /* NDEF Mapping Component |
| * |
| * This component implements the read/write/check NDEF functions for remote devices. |
| * NDEF data, as defined by the NFC Forum NDEF specification are written to or read from |
| * a remote device that can be a smart- or memory card. |
| * Please notice that the NDEF mapping command sequence must |
| * be contiguous (after correct initialization) |
| * |
| */ |
| |
| /* |
| * NDEF Mapping - specifies the different card types |
| * These are the only recognized card types in this version. |
| * |
| */ |
| |
| #define PH_FRINFC_NDEFMAP_MIFARE_STD_1K_CARD 7 /* Mifare Standard */ |
| #define PH_FRINFC_NDEFMAP_MIFARE_STD_4K_CARD 8 /* Mifare Standard */ |
| #define PH_FRINFC_NDEFMAP_MIFARE_STD_2K_CARD 11 /*internal Mifare Standard */ |
| #define PH_FRINFC_NDEFMAP_EMPTY_NDEF_MSG {0xD0, 0x00, 0x00} /* Empty ndef message */ |
| #define PH_FRINFC_NDEFMAP_MFUL_4BYTES_BUF 4 /* To store 4 bytes after write */ |
| |
| |
| /* Enum represents the different card state*/ |
| typedef enum |
| { |
| PH_NDEFMAP_CARD_STATE_INITIALIZED, |
| PH_NDEFMAP_CARD_STATE_READ_ONLY, |
| PH_NDEFMAP_CARD_STATE_READ_WRITE, |
| PH_NDEFMAP_CARD_STATE_INVALID |
| }phNDEF_CARD_STATE; |
| |
| |
| /* |
| * NDEF Mapping - specifies the Compliant Blocks in the Mifare 1k and 4k card types |
| * |
| */ |
| #define PH_FRINFC_NDEFMAP_MIFARESTD_1KNDEF_COMPBLOCK 45 /* Total Ndef Compliant blocks Mifare 1k */ |
| #define PH_FRINFC_NDEFMAP_MIFARESTD_2KNDEF_COMPBLOCK 90 /* Total Ndef Compliant blocks Mifare 2k */ |
| #define PH_FRINFC_NDEFMAP_MIFARESTD_4KNDEF_COMPBLOCK 210 /* Total Ndef Compliant blocks Mifare 4k */ |
| #define PH_FRINFC_NDEFMAP_MIFARESTD_RDWR_SIZE 16 /* Bytes read/write for one read/write operation*/ |
| #define PH_FRINFC_NDEFMAP_MIFARESTD_TOTALNO_BLK 40 /* Total number of sectors in Mifare 4k */ |
| #define PH_FRINFC_NDEFMAP_MIFARESTD_ST15_BYTES 15 /* To store 15 bytes after reading a block */ |
| |
| /* |
| * Completion Routine Indices |
| * |
| * These are the indices of the completion routine pointers within the component context. |
| * Completion routines belong to upper components. |
| * |
| */ |
| #define PH_FRINFC_NDEFMAP_CR_CHK_NDEF 0 /* */ |
| #define PH_FRINFC_NDEFMAP_CR_RD_NDEF 1 /* */ |
| #define PH_FRINFC_NDEFMAP_CR_WR_NDEF 2 /* */ |
| #define PH_FRINFC_NDEFMAP_CR_ERASE_NDEF 3 /* */ |
| #define PH_FRINFC_NDEFMAP_CR_INVALID_OPE 4 /* */ |
| #define PH_FRINFC_NDEFMAP_CR 5 /* */ |
| |
| /* |
| * File Offset Attributes |
| * |
| * Following values are used to determine the offset value for Read/Write. This specifies whether |
| * the Read/Write operation needs to be restarted/continued from the last offset set. |
| * |
| */ |
| /* Read/Write operation shall start from the last offset set */ |
| #define PH_FRINFC_NDEFMAP_SEEK_CUR 0 /* */ |
| /* Read/Write operation shall start from the beginning of the file/card */ |
| #define PH_FRINFC_NDEFMAP_SEEK_BEGIN 1 /* */ |
| |
| /* Read operation invalid */ |
| #define PH_FRINFC_NDEFMAP_SEEK_INVALID 0xFF /* */ |
| |
| /* |
| * Buffer Size Definitions |
| * |
| */ |
| /* Minimum size of the TRX buffer required */ |
| #define PH_FRINFC_NDEFMAP_MAX_SEND_RECV_BUF_SIZE 252 /* */ |
| /* The size of s MIFARE block */ |
| #define PH_FRINFC_NDEFMAP_MF_READ_BLOCK_SIZE 16 /* */ |
| |
| typedef struct phFriNfc_MifareStdCont |
| { |
| /* to store bytes that will be used in the next write/read operation, if any */ |
| uint8_t internalBuf[PH_FRINFC_NDEFMAP_MIFARESTD_ST15_BYTES]; |
| /* to Store the length of the internalBuf */ |
| uint16_t internalLength; |
| /* holds the block number which is presently been used */ |
| uint8_t currentBlock; |
| /* the number of Ndef compliant blocks written/read */ |
| uint8_t NdefBlocks; |
| /* Total Number of Ndef compliant Blocks */ |
| uint16_t NoOfNdefCompBlocks; |
| /* used in write ndef, to know that internal byte are accessed */ |
| uint8_t internalBufFlag; |
| /* used in write ndef, to know that last 16 bytes are used to write*/ |
| uint8_t RemainingBufFlag; |
| /* indicates that Read has reached the end of the card */ |
| uint8_t ReadWriteCompleteFlag; |
| /* indicates that Read has reached the end of the card */ |
| uint8_t ReadCompleteFlag; |
| /* indicates that Write is possible or not */ |
| uint8_t WriteFlag; |
| /* indicates that Write is possible or not */ |
| uint8_t ReadFlag; |
| /* indicates that Write is possible or not */ |
| uint8_t RdBeforeWrFlag; |
| /* Authentication Flag indicating that a particular sector is authenticated or not */ |
| uint8_t AuthDone; |
| /* to store the last Sector ID in Check Ndef */ |
| uint8_t SectorIndex; |
| /* to read the access bits of each sector */ |
| uint8_t ReadAcsBitFlag; |
| /* Flag to check if Acs bit was written in this call */ |
| uint8_t WriteAcsBitFlag; |
| /* Buffer to store 16 bytes */ |
| uint8_t Buffer[PH_FRINFC_NDEFMAP_MIFARESTD_RDWR_SIZE]; |
| /* to store the AIDs of Mifare 1k or 4k */ |
| uint8_t aid[PH_FRINFC_NDEFMAP_MIFARESTD_TOTALNO_BLK]; |
| /* flag to write with offset begin */ |
| uint8_t WrNdefFlag; |
| /* flag to read with offset begin */ |
| uint8_t ReadNdefFlag; |
| /* flag to check with offset begin */ |
| uint8_t ChkNdefFlag; |
| /* To store the remaining size of the Mifare 1k or 4k card */ |
| uint16_t remainingSize; |
| /* To update the remaining size when writing to the Mifare 1k or 4k card */ |
| uint8_t remSizeUpdFlag; |
| /* The flag is to know that there is a different AID apart from NFC forum sector AID */ |
| uint16_t aidCompleteFlag; |
| /* The flag is to know that there is a a NFC forum sector exists in the card */ |
| uint16_t NFCforumSectFlag; |
| /* The flag is to know that the particular sector is a proprietary NFC forum sector */ |
| uint16_t ProprforumSectFlag; |
| /* The flag is set after reading the MAD sectors */ |
| uint16_t ChkNdefCompleteFlag; |
| /* Flag to store the current block */ |
| uint8_t TempBlockNo; |
| /* Completion routine index */ |
| uint8_t CRIndex; |
| /* Bytes remaining to write for one write procedure */ |
| uint16_t WrLength; |
| /* Flag to read after write */ |
| uint8_t RdAfterWrFlag; |
| /* Flag to say that poll is required before write ndef (authentication) */ |
| uint8_t PollFlag; |
| /* Flag is to know that this is first time the read has been called. This |
| is required when read is called after write (especially for the card formatted |
| with the 2nd configuration) */ |
| uint8_t FirstReadFlag; |
| /* Flag is to know that this is first time the write has been called. This |
| is required when the card formatted with the 3rd configuration */ |
| uint8_t FirstWriteFlag; |
| /* Indicates the sector trailor id for which the convert |
| to read only is currently in progress*/ |
| uint8_t ReadOnlySectorIndex; |
| /* Indicates the total number of sectors on the card */ |
| uint8_t TotalNoSectors; |
| /* Indicates the block number of the sector trailor on the card */ |
| uint8_t SectorTrailerBlockNo; |
| /* Secret key B to given by the application */ |
| uint8_t UserScrtKeyB[6]; |
| }phFriNfc_MifareStdCont_t; |
| |
| /* |
| * NDEF TLV structure which details the different variables used for TLV. |
| * |
| */ |
| typedef struct phFriNfc_NDEFTLVCont |
| { |
| /* Flag is to know that the TLV Type Found */ |
| uint8_t NdefTLVFoundFlag; |
| /* Sector number of the next/present available TLV */ |
| uint8_t NdefTLVSector; |
| /* Following two variables are used to store the |
| T byte and the Block number in which the T is |
| found in Tag */ |
| /* Byte number of the next/present available TLV */ |
| uint16_t NdefTLVByte; |
| /* Block number of the next/present available TLV */ |
| uint8_t NdefTLVBlock; |
| /* Authentication flag for NDEF TLV Block */ |
| uint8_t NdefTLVAuthFlag; |
| /* if the 16th byte of the last read is type (T) of TLV |
| and next read contains length (L) bytes of TLV. This flag |
| is set when the type (T) of TLV is found in the last read */ |
| uint8_t TcheckedinTLVFlag; |
| /* if the 16th byte of the last read is Length (L) of TLV |
| and next read contains length (L) bytes of TLV. This flag |
| is set when the Length (L) of TLV is found in the last read */ |
| uint8_t LcheckedinTLVFlag; |
| /* This flag is set, if Terminator TLV is already written |
| and next read contains value (V) bytes of TLV. This flag |
| is set when the value (V) of TLV is found in the last read */ |
| uint8_t SetTermTLVFlag; |
| /* To know the number of Length (L) field is present in the |
| next block */ |
| uint8_t NoLbytesinTLV; |
| /* The value of 3 bytes length(L) field in TLV. In 3 bytes |
| length field, 2 bytes are in one block and other 1 byte |
| is in the next block. To store the former block length |
| field value, this variable is used */ |
| uint16_t prevLenByteValue; |
| /* The value of length(L) field in TLV. */ |
| uint16_t BytesRemainLinTLV; |
| /* Actual size to read and write. This will be always equal to the |
| length (L) of TLV as there is only one NDEF TLV . */ |
| uint16_t ActualSize; |
| /* Flag is to write the length (L) field of the TLV */ |
| uint8_t WrLenFlag; |
| /* Flag is to write the length (L) field of the TLV */ |
| uint16_t NULLTLVCount; |
| /* Buffer to store 4 bytes of data which is written to a block */ |
| uint8_t NdefTLVBuffer[PH_FRINFC_NDEFMAP_MFUL_4BYTES_BUF]; |
| /* Buffer to store 4 bytes of data which is written to a next block */ |
| uint8_t NdefTLVBuffer1[PH_FRINFC_NDEFMAP_MFUL_4BYTES_BUF]; |
| }phFriNfc_NDEFTLVCont_t; |
| |
| /* |
| * Lock Control TLV structure which stores the Position, Size and PageCntrl details. |
| */ |
| |
| typedef struct phFriNfc_LockCntrlTLVCont |
| { |
| /* Specifies the Byte Position of the lock cntrl tlv |
| in the card memory*/ |
| uint16_t ByteAddr; |
| |
| /* Specifies the Size of the lock area in terms of |
| bits/bytes*/ |
| uint16_t Size; |
| |
| /* Specifies the Bytes per Page*/ |
| uint8_t BytesPerPage; |
| |
| /* Specifies the BytesLockedPerLockBit */ |
| uint8_t BytesLockedPerLockBit; |
| |
| /* Specifies the index of Lock cntrl TLV*/ |
| uint8_t LockTlvBuffIdx; |
| |
| /* Store the content of Lock cntrl TLV*/ |
| uint8_t LockTlvBuff[8]; |
| |
| /* Specifies the Block number Lock cntrl TLV*/ |
| uint16_t BlkNum; |
| |
| /* Specifies the Byte Number position of Lock cntrl TLV*/ |
| uint16_t ByteNum; |
| |
| |
| }phFriNfc_LockCntrlTLVCont_t; |
| |
| |
| /* |
| * Memory Control TLV structure which stores the Position, Size and PageCntrl details of the reserved byte area. |
| */ |
| |
| typedef struct phFriNfc_ResMemCntrlTLVCont |
| { |
| /* Specifies the Byte Position of the lock cntrl tlv |
| in the card memory */ |
| uint16_t ByteAddr; |
| |
| /* Specifies the Size of the lock area in terms of |
| bits/bytes*/ |
| uint16_t Size; |
| |
| /* Store the content of Memory cntrl TLV*/ |
| uint8_t MemCntrlTlvBuff[8]; |
| |
| /* Specifies the Bytes per Page*/ |
| uint8_t BytesPerPage; |
| |
| /* Specifies the index of Mem cntrl TLV*/ |
| uint8_t MemTlvBuffIdx; |
| |
| /* Specifies the Block number Lock cntrl TLV*/ |
| uint16_t BlkNum; |
| |
| /* Specifies the Byte Number position of Lock cntrl TLV*/ |
| uint16_t ByteNum; |
| |
| |
| |
| }phFriNfc_ResMemCntrlTLVCont_t; |
| |
| /* |
| * NFC NDEF Mapping Component Context Structure |
| * |
| * This structure is used to store the current context information of the instance. |
| * |
| */ |
| typedef struct phFriNfc_NdefMap |
| { |
| /* The state of the operation. */ |
| uint8_t State; |
| |
| /* Completion Routine Context. */ |
| phFriNfc_CplRt_t CompletionRoutine[PH_FRINFC_NDEFMAP_CR]; |
| |
| phNfc_sTransceiveInfo_t *pTransceiveInfo; |
| |
| /*Holds the completion routine informations of the Map Layer*/ |
| phFriNfc_CplRt_t MapCompletionInfo; |
| |
| /* Pointer to the Remote Device Information */ |
| phLibNfc_sRemoteDevInformation_t *psRemoteDevInfo; |
| |
| /*Holds the Command Type(read/write)*/ |
| phNfc_uCmdList_t Cmd; |
| |
| /* Pointer to a temporary buffer. Could be |
| used for read/write purposes */ |
| uint8_t *ApduBuffer; |
| |
| /* Size allocated to the ApduBuffer. */ |
| uint32_t ApduBufferSize; |
| |
| /* Index to the APDU Buffer. Used for internal calculations */ |
| uint16_t ApduBuffIndex; |
| |
| /* Pointer to the user-provided Data Size to be written trough WrNdef function. */ |
| uint32_t *WrNdefPacketLength; |
| |
| |
| /* Holds the length of the received data. */ |
| uint16_t *SendRecvLength; |
| |
| /*Holds the ack of some initial commands*/ |
| uint8_t *SendRecvBuf; |
| |
| /* Holds the length of the data to be sent. */ |
| uint16_t SendLength; |
| |
| /* Data Byte Count, which gives the offset to the integration.*/ |
| uint16_t *DataCount; |
| |
| /* Holds the previous operation on the card*/ |
| uint8_t PrevOperation; |
| |
| /* Holds the previous read mode*/ |
| uint8_t bPrevReadMode; |
| |
| /* Holds the current read mode*/ |
| uint8_t bCurrReadMode; |
| |
| /* Holds the previous state on the card*/ |
| uint8_t PrevState; |
| |
| /* Stores the type of the smart card. */ |
| uint8_t CardType; |
| |
| /* Stores the card state. */ |
| uint8_t CardState; |
| |
| /* Stores the memory size of the card */ |
| uint16_t CardMemSize; |
| |
| /*to Store the page offset on the mifare ul card*/ |
| uint8_t Offset; |
| |
| /* specifies the desired operation to be performed*/ |
| uint8_t DespOpFlag; |
| |
| /* Used to remember how many bytes were written, to update |
| the dataCount and the BufferIndex */ |
| uint16_t NumOfBytesWritten; |
| |
| /*used to remember number of L byte Remaining to be written */ |
| uint16_t NumOfLReminWrite; |
| |
| /* Pointer Used to remember and return how many bytes were read, |
| to update the PacketDataLength in case of Read operation */ |
| /* Fix for 0000238: [gk] MAP: Number of bytes actually read out is |
| not returned. */ |
| uint32_t *NumOfBytesRead; |
| |
| /* Flag used to tell the process function that WRITE has |
| requested for an internal READ.*/ |
| uint8_t ReadingForWriteOperation; |
| |
| /* Buffer of 5 bytes used for the write operation for the |
| Mifare UL card.*/ |
| uint8_t BufferForWriteOp[5]; |
| |
| /* Temporary Receive Length to update the Receive Length |
| when every time the Overlapped HAL is called. */ |
| uint16_t TempReceiveLength; |
| |
| uint8_t NoOfDevices ; |
| |
| /* stores operating mode type of the felica smart tag */ |
| /* phHal_eOpModes_t OpModeType[2]; */ |
| |
| /* stores the type of the TLV found */ |
| uint8_t TLVFoundFlag; |
| |
| /* stores the TLV structure related informations */ |
| phFriNfc_NDEFTLVCont_t TLVStruct; |
| |
| /* stores the Lock Contrl Tlv related informations */ |
| phFriNfc_LockCntrlTLVCont_t LockTlv; |
| |
| /* stores the Mem Contrl Tlv related informations */ |
| phFriNfc_ResMemCntrlTLVCont_t MemTlv; |
| |
| /* Pointer to the Mifare Standard capability Container Structure. */ |
| phFriNfc_MifareStdCont_t StdMifareContainer; |
| |
| } phFriNfc_NdefMap_t; |
| |
| /* |
| * States of the FSM. |
| */ |
| #define PH_FRINFC_NDEFMAP_STATE_RESET_INIT 0 /* Initial state */ |
| #define PH_FRINFC_NDEFMAP_STATE_CR_REGISTERED 1 /* CR has been registered */ |
| #define PH_FRINFC_NDEFMAP_STATE_EOF_CARD 2 /* EOF card reached */ |
| |
| /* Following values specify the previous operation on the card. This value is assigned to |
| the context structure variable: PrevOperation. */ |
| |
| /* Previous operation is check */ |
| #define PH_FRINFC_NDEFMAP_CHECK_OPE 1 |
| /* Previous operation is read */ |
| #define PH_FRINFC_NDEFMAP_READ_OPE 2 |
| /* Previous operation is write */ |
| #define PH_FRINFC_NDEFMAP_WRITE_OPE 3 |
| /* Previous operation is Actual size */ |
| #define PH_FRINFC_NDEFMAP_GET_ACTSIZE_OPE 4 |
| |
| /* This flag is set when there is a need of write operation on the odd positions |
| ex: 35,5 etc. This is used with MfUlOp Flag */ |
| #define PH_FRINFC_MFUL_INTERNAL_READ 3 /* Read/Write control*/ |
| |
| |
| #endif /* PHFRINFC_NDEFMAP_H */ |
