| /* |
| * Copyright (C) 2010 NXP Semiconductors |
| * |
| * 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. |
| */ |
| |
| /*! |
| * \file phFriNfc_FelicaMap.c |
| * \brief This component encapsulates read/write/check ndef/process functionalities, |
| * for the Felica Smart Card. |
| * |
| * Project: NFC-FRI |
| * |
| * $Date: Thu May 6 14:01:35 2010 $ |
| * $Author: ing07385 $ |
| * $Revision: 1.10 $ |
| * $Aliases: NFC_FRI1.1_WK1017_R34_4,NFC_FRI1.1_WK1023_R35_1 $ |
| * |
| */ |
| |
| #ifndef PH_FRINFC_MAP_FELICA_DISABLED |
| |
| #include <phNfcTypes.h> |
| #include <phFriNfc_OvrHal.h> |
| #include <phFriNfc_FelicaMap.h> |
| #include <phFriNfc_MapTools.h> |
| |
| |
| /*! \ingroup grp_file_attributes |
| * \name NDEF Mapping |
| * |
| * File: \ref phFriNfc_FelicaMap.c |
| * |
| */ |
| /*@{*/ |
| |
| #define PHFRINFCNDEFMAP_FILEREVISION "$Revision: 1.10 $" |
| #define PHFRINFCNDEFMAP_FILEALIASES "$Aliases: NFC_FRI1.1_WK1017_R34_4,NFC_FRI1.1_WK1023_R35_1 $" |
| |
| /*@}*/ |
| |
| /* Helpers for Read and updating the attribute informations*/ |
| static NFCSTATUS phFriNfc_Felica_HRdAttrInfo(phFriNfc_NdefMap_t *NdefMap); |
| static NFCSTATUS phFriNfc_Felica_HUpdateAttrInfo(phFriNfc_NdefMap_t *NdefMap); |
| static NFCSTATUS phFriNfc_Felica_HCalCheckSum(const uint8_t *TempBuffer, |
| uint8_t StartIndex, |
| uint8_t EndIndex, |
| uint16_t RecvChkSum); |
| |
| /* Helpers for Poll Related Operations*/ |
| static NFCSTATUS phFriNfc_Felica_HPollCard( phFriNfc_NdefMap_t *NdefMap, |
| const uint8_t sysCode[], |
| uint8_t state); |
| |
| static NFCSTATUS phFriNfc_Felica_HUpdateManufIdDetails(const phFriNfc_NdefMap_t *NdefMap); |
| |
| /*Helpers for Reading Operations*/ |
| static NFCSTATUS phFriNfc_Felica_HReadData(phFriNfc_NdefMap_t *NdefMap,uint8_t offset); |
| static uint16_t phFriNfc_Felica_HGetMaximumBlksToRead(const phFriNfc_NdefMap_t *NdefMap,uint8_t NbcOrNmaxb ); |
| static void phFriNfc_Felica_HAfterRead_CopyDataToBuff(phFriNfc_NdefMap_t *NdefMap); |
| static NFCSTATUS phFriNfc_Felica_HSetTransceiveForRead(phFriNfc_NdefMap_t *NdefMap,uint16_t TrxLen,uint8_t Offset); |
| static uint16_t phFriNfc_Felica_HSetTrxLen(phFriNfc_NdefMap_t *NdefMap,uint16_t Nbc); |
| static NFCSTATUS phFriNfc_Felica_HChkApduBuff_Size( phFriNfc_NdefMap_t *NdefMap); |
| |
| /* Helpers for Writing Operations*/ |
| static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap); |
| static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForRdOp(phFriNfc_NdefMap_t *NdefMap, |
| uint32_t NdefLen); |
| static NFCSTATUS phFriNfc_Felica_HUpdateAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap,uint8_t isStarted); |
| static NFCSTATUS phFriNfc_Felica_HUpdateData(phFriNfc_NdefMap_t *NdefMap); |
| static NFCSTATUS phFriNfc_Felica_HWriteDataBlk(phFriNfc_NdefMap_t *NdefMap); |
| |
| /* Write Empty NDEF Message*/ |
| static NFCSTATUS phFriNfc_Felica_HWrEmptyMsg(phFriNfc_NdefMap_t *NdefMap); |
| |
| /*Helpers for common checks*/ |
| static NFCSTATUS phFriNfc_Felica_HCheckManufId(const phFriNfc_NdefMap_t *NdefMap); |
| static void phFriNfc_Felica_HCrHandler(phFriNfc_NdefMap_t *NdefMap, |
| uint8_t CrIndex, |
| NFCSTATUS Status); |
| |
| static void phFriNfc_Felica_HInitInternalBuf(uint8_t *Buffer); |
| |
| static int phFriNfc_Felica_MemCompare ( void *s1, void *s2, unsigned int n ); |
| |
| /*! |
| * \brief returns maximum number of blocks can be read from the Felica Smart Card. |
| * |
| * The function is useful in reading of NDEF information from a felica tag. |
| */ |
| |
| static uint16_t phFriNfc_Felica_HGetMaximumBlksToRead(const phFriNfc_NdefMap_t *NdefMap, uint8_t NbcOrNmaxb ) |
| { |
| uint16_t BlksToRead=0; |
| uint32_t DataLen = 0; |
| /* This part of the code is useful if we take account of Nbc blks reading*/ |
| if ( NbcOrNmaxb == PH_NFCFRI_NDEFMAP_FELI_NBC ) |
| { |
| PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0], |
| NdefMap->FelicaAttrInfo.LenBytes[1], |
| NdefMap->FelicaAttrInfo.LenBytes[2], |
| DataLen); |
| /* Calculate Nbc*/ |
| BlksToRead = (uint16_t) ( ((DataLen % 16) == 0) ? (DataLen >> 4) : ((DataLen >> 4) +1) ); |
| |
| |
| } |
| else if ( NbcOrNmaxb == PH_NFCFRI_NDEFMAP_FELI_NMAXB) |
| { |
| BlksToRead = NdefMap->FelicaAttrInfo.Nmaxb; |
| } |
| else |
| { |
| /* WARNING !!! code should not reach this point*/ |
| ; |
| } |
| return (BlksToRead); |
| } |
| |
| /*! |
| * \brief Initiates Reading of NDEF information from the Felica Card. |
| * |
| * The function initiates the reading of NDEF information from a Remote Device. |
| * It performs a reset of the state and starts the action (state machine). |
| * A periodic call of the \ref phFriNfcNdefMap_Process has to be |
| * done once the action has been triggered. |
| */ |
| |
| NFCSTATUS phFriNfc_Felica_RdNdef( phFriNfc_NdefMap_t *NdefMap, |
| uint8_t *PacketData, |
| uint32_t *PacketDataLength, |
| uint8_t Offset) |
| { |
| |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| uint32_t Nbc = 0; |
| |
| NdefMap->ApduBufferSize = *PacketDataLength; |
| /*Store the packet data buffer*/ |
| NdefMap->ApduBuffer = PacketData; |
| |
| NdefMap->NumOfBytesRead = PacketDataLength ; |
| *NdefMap->NumOfBytesRead = 0; |
| NdefMap->ApduBuffIndex = 0; |
| |
| NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_READ_OPE; |
| NdefMap->Felica.Offset = Offset; |
| |
| if( ( Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN )||( NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_WRITE_OPE)) |
| { |
| NdefMap->Felica.CurBlockNo = 0; |
| NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_RD_ATTR_RD_OP; |
| NdefMap->Felica.IntermediateCpyFlag = FALSE; |
| NdefMap->Felica.IntermediateCpyLen = 0; |
| NdefMap->Felica.Rd_NoBytesToCopy = 0; |
| NdefMap->Felica.EofCardReachedFlag= FALSE ; |
| NdefMap->Felica.LastBlkReachedFlag = FALSE; |
| NdefMap->Felica.CurrBytesRead = 0; |
| |
| phFriNfc_Felica_HInitInternalBuf(NdefMap->Felica.Rd_BytesToCopyBuff); |
| |
| /* send request to read attribute information*/ |
| status = phFriNfc_Felica_HRdAttrInfo(NdefMap); |
| /* handle the error in Transc function*/ |
| if ( (status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,status); |
| } |
| } |
| else |
| { |
| Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC); |
| |
| /* Offset = Current, but the read has reached the End of NBC Blocks */ |
| if(( ( Offset == PH_FRINFC_NDEFMAP_SEEK_CUR) && (NdefMap->Felica.CurBlockNo == Nbc)) && |
| (NdefMap->Felica.EofCardReachedFlag == FELICA_RD_WR_EOF_CARD_REACHED )) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); |
| } |
| else |
| { |
| |
| NdefMap->Felica.CurrBytesRead = ((NdefMap->Felica.CurBlockNo * 16)- NdefMap->Felica.Rd_NoBytesToCopy); |
| status = phFriNfc_Felica_HReadData(NdefMap,NdefMap->Felica.Offset); |
| |
| } |
| } |
| return (status); |
| } |
| |
| /*Read Operation Related Helper Routines*/ |
| |
| /*! |
| * \brief Used in Read Opearation.Sets the Trx Buffer Len calls Transc Cmd. |
| * After a successful read operation, function does checks the user buffer size |
| * sets the status flags. |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HReadData(phFriNfc_NdefMap_t *NdefMap,uint8_t offset) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| uint16_t Nbc=0,TranscLen=0; |
| |
| Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC); |
| if( ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) > 0) && (NdefMap->Felica.CurBlockNo < Nbc )) |
| { |
| /* if data is present in the internal buffer*/ |
| if (NdefMap->Felica.Rd_NoBytesToCopy > 0 ) |
| { |
| /* copy data to external buffer*/ |
| phFriNfc_Felica_HAfterRead_CopyDataToBuff(NdefMap); |
| /*Check the size of user buffer*/ |
| status = phFriNfc_Felica_HChkApduBuff_Size(NdefMap); |
| if ( (status != NFCSTATUS_SUCCESS) && (NdefMap->Felica.IntermediateRdFlag == TRUE )) |
| { |
| /* set the transc len and call transc cmd*/ |
| TranscLen = phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc); |
| status= phFriNfc_Felica_HSetTransceiveForRead(NdefMap,TranscLen,offset); |
| } |
| else |
| { |
| /* Nothing to be done , if IntermediateRdFlag is set to zero*/ |
| ; |
| } |
| } |
| else |
| { |
| /* set the transc len and call transc cmd*/ |
| TranscLen = phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc); |
| status= phFriNfc_Felica_HSetTransceiveForRead(NdefMap,TranscLen,offset); |
| } |
| } |
| else |
| { |
| /* Chk the Buffer size*/ |
| status = phFriNfc_Felica_HChkApduBuff_Size(NdefMap); |
| if ( (status != NFCSTATUS_SUCCESS) && (NdefMap->Felica.IntermediateRdFlag == TRUE )) |
| { |
| TranscLen = phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc); |
| status= phFriNfc_Felica_HSetTransceiveForRead(NdefMap,TranscLen,offset); |
| } |
| } |
| return (status); |
| } |
| |
| /*! |
| * \brief Used in Read Opearation.Sets the Trx Buffer Len. |
| */ |
| |
| static uint16_t phFriNfc_Felica_HSetTrxLen(phFriNfc_NdefMap_t *NdefMap,uint16_t Nbc) |
| { |
| uint16_t TranscLen = 0,BlocksToRead=0; |
| |
| if( ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)% 16) == 0) |
| { |
| BlocksToRead = (uint16_t)( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)/16 ); |
| } |
| else |
| { |
| BlocksToRead = (uint16_t)(((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)/16) +1); |
| } |
| if ( (BlocksToRead > Nbc) ||( (BlocksToRead) > ( Nbc - NdefMap->Felica.CurBlockNo)) ) |
| { |
| BlocksToRead = Nbc - NdefMap->Felica.CurBlockNo; |
| } |
| |
| |
| if ( BlocksToRead >= NdefMap->FelicaAttrInfo.Nbr) |
| { |
| if( NdefMap->FelicaAttrInfo.Nbr < Nbc ) |
| { |
| TranscLen = NdefMap->FelicaAttrInfo.Nbr*16; |
| } |
| else |
| { |
| TranscLen = Nbc*16; |
| NdefMap->Felica.LastBlkReachedFlag =1; |
| } |
| } |
| else |
| { |
| if (BlocksToRead <= Nbc ) |
| { |
| if ( ( BlocksToRead * 16) == ((Nbc *16) - (NdefMap->Felica.CurBlockNo * 16))) |
| { |
| NdefMap->Felica.LastBlkReachedFlag =1; |
| |
| } |
| TranscLen = BlocksToRead*16; |
| |
| } |
| else |
| { |
| TranscLen = Nbc*16; |
| } |
| } |
| /* As Cur Blk changes, to remember the exact len what we had set |
| in the begining of each read operation*/ |
| NdefMap->Felica.TrxLen = TranscLen; |
| return (TranscLen); |
| } |
| |
| /*! |
| * \brief Used in Read Opearation.After a successful read operation, |
| * Copies the data to user buffer. |
| */ |
| |
| static void phFriNfc_Felica_HAfterRead_CopyDataToBuff(phFriNfc_NdefMap_t *NdefMap) |
| { |
| uint8_t ResetFlag = FALSE, ExtrBytesToCpy = FALSE; |
| uint16_t Nbc=0; |
| uint32_t DataLen=0; |
| |
| Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC ); |
| |
| PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0], |
| NdefMap->FelicaAttrInfo.LenBytes[1], |
| NdefMap->FelicaAttrInfo.LenBytes[2], |
| DataLen); |
| /* Internal Buffer has some old read bytes to cpy to user buffer*/ |
| if( NdefMap->Felica.Rd_NoBytesToCopy > 0 ) |
| { |
| if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) < NdefMap->Felica.Rd_NoBytesToCopy ) |
| { |
| NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| |
| if (NdefMap->Felica.IntermediateCpyFlag == TRUE ) |
| { |
| /*Copy data from the internal buffer to user buffer*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->Felica.Rd_BytesToCopyBuff[NdefMap->Felica.IntermediateCpyLen])), |
| (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)); |
| |
| |
| |
| /* Store number of bytes copied frm internal buffer to User Buffer */ |
| NdefMap->Felica.IntermediateCpyLen += (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| NdefMap->Felica.IntermediateCpyFlag = 1; |
| |
| /* check do we reach len bytes any chance*/ |
| PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0], |
| NdefMap->FelicaAttrInfo.LenBytes[1], |
| NdefMap->FelicaAttrInfo.LenBytes[2], |
| DataLen); |
| /* Internal buffer has zero bytes for copy operation*/ |
| if ( NdefMap->Felica.Rd_NoBytesToCopy == 0) |
| { |
| NdefMap->Felica.EofCardReachedFlag =FELICA_RD_WR_EOF_CARD_REACHED; |
| } |
| } |
| else |
| { |
| /*Copy data from the internal buffer to apdu buffer*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| NdefMap->Felica.Rd_BytesToCopyBuff, |
| (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)); |
| } |
| NdefMap->ApduBuffIndex += (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| |
| } |
| else if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) == NdefMap->Felica.Rd_NoBytesToCopy ) |
| { |
| if ( NdefMap->Felica.IntermediateCpyFlag == TRUE ) |
| { |
| /*Copy data internal buff to apdubuffer*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->Felica.Rd_BytesToCopyBuff[NdefMap->Felica.IntermediateCpyLen])), |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| } |
| else |
| { |
| /*Copy data internal buff to apdubuffer*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| NdefMap->Felica.Rd_BytesToCopyBuff, |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| } |
| |
| /*increment the index,internal buffer len*/ |
| NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy; |
| NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBuffIndex); |
| |
| /* To reset the parameters*/ |
| ResetFlag = TRUE; |
| } |
| else |
| { |
| /* Extra Bytes to Copy from internal buffer to external buffer*/ |
| if ( NdefMap->Felica.IntermediateCpyFlag == TRUE ) |
| { |
| /*Copy data internal buff to apdubuffer*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->Felica.Rd_BytesToCopyBuff[NdefMap->Felica.IntermediateCpyLen])), |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| } |
| else |
| { |
| /*Copy data internal buff to apdubuffer*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| NdefMap->Felica.Rd_BytesToCopyBuff, |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| } |
| /*increment the index*/ |
| NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy; |
| |
| /* To reset the parameters*/ |
| ResetFlag = TRUE; |
| } |
| }/*End of Internal Buffer has some old read bytes to cpy to user buffer*/ |
| else |
| { |
| /* check if last block is reached*/ |
| if ( ((NdefMap->Felica.LastBlkReachedFlag == 1) && (( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= 16)) ) |
| { |
| /* greater than 16 but less than the data len size*/ |
| if (( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= DataLen) |
| { |
| NdefMap->Felica.CurrBytesRead = (uint16_t)((DataLen) - (NdefMap->Felica.CurrBytesRead + |
| NdefMap->ApduBuffIndex)); |
| |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->SendRecvBuf[13])), |
| NdefMap->Felica.CurrBytesRead); |
| |
| NdefMap->ApduBuffIndex += NdefMap->Felica.CurrBytesRead; |
| if ( NdefMap->ApduBuffIndex == DataLen) |
| { |
| ResetFlag = TRUE; |
| } |
| } |
| else |
| { |
| /* need to check exact no. of bytes to copy to buffer*/ |
| if( ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <= NdefMap->Felica.TrxLen )|| |
| ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) <= DataLen )) |
| { |
| |
| ExtrBytesToCpy = TRUE; |
| } |
| else |
| { |
| NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)(16-(( Nbc * 16) - (DataLen))); |
| |
| if ( NdefMap->Felica.Rd_NoBytesToCopy > (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)) |
| { |
| /*Reduce already copied bytes from the internal buffer*/ |
| NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| ExtrBytesToCpy = TRUE; |
| } |
| else |
| { |
| ExtrBytesToCpy = FALSE; |
| } |
| } |
| if ( ExtrBytesToCpy == TRUE ) |
| { |
| NdefMap->Felica.CurrBytesRead = (uint16_t)((DataLen)- (NdefMap->Felica.CurrBytesRead + |
| NdefMap->ApduBuffIndex)); |
| |
| if(NdefMap->Felica.CurrBytesRead < |
| (uint16_t)(NdefMap->ApduBufferSize - |
| NdefMap->ApduBuffIndex)) |
| { |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->SendRecvBuf[13])), |
| NdefMap->Felica.CurrBytesRead); |
| } |
| else |
| { |
| (void)memcpy( (&( NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&( NdefMap->SendRecvBuf[13])), |
| (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)); |
| } |
| |
| if ( NdefMap->Felica.LastBlkReachedFlag == 1 ) |
| { |
| NdefMap->Felica.Rd_NoBytesToCopy = |
| (uint8_t)((NdefMap->Felica.CurrBytesRead > |
| (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex))? |
| (NdefMap->Felica.CurrBytesRead - |
| (uint16_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)): |
| 0); |
| |
| ResetFlag = ((NdefMap->Felica.Rd_NoBytesToCopy == 0)?TRUE:FALSE); |
| |
| } |
| else |
| { |
| NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)( NdefMap->Felica.TrxLen - (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)); |
| } |
| |
| /* Copy remained bytes back into internal buffer*/ |
| (void)memcpy( NdefMap->Felica.Rd_BytesToCopyBuff, |
| (&(NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_RESP_HEADER_LEN+(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)])), |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| |
| /* set the intermediate flag : This flag remembers that there are still X no. bytes remained in |
| Internal Buffer Ex: User has given only one byte buffer,needs to cpy one byte at a time*/ |
| NdefMap->Felica.IntermediateCpyFlag = TRUE; |
| |
| NdefMap->ApduBuffIndex += ((NdefMap->Felica.CurrBytesRead < |
| (uint16_t)(NdefMap->ApduBufferSize - |
| NdefMap->ApduBuffIndex))? |
| NdefMap->Felica.CurrBytesRead: |
| (uint16_t)(NdefMap->ApduBufferSize - |
| NdefMap->ApduBuffIndex)); |
| } |
| else |
| { |
| /*Copy data from the internal buffer to user buffer*/ |
| (void)memcpy( (&( NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&( NdefMap->SendRecvBuf[13])), |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| |
| NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy; |
| ResetFlag = TRUE; |
| |
| } |
| } |
| |
| } |
| else |
| { |
| if ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) < NdefMap->Felica.TrxLen ) |
| { |
| /* Calculate exactly remained bytes to copy to internal buffer and set it*/ |
| if ( NdefMap->Felica.LastBlkReachedFlag == 1) |
| { |
| NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)(16-(( Nbc * 16) - DataLen)); |
| |
| if ( NdefMap->Felica.Rd_NoBytesToCopy > (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)) |
| { |
| /*Reduce already copied bytes from the internal buffer*/ |
| NdefMap->Felica.Rd_NoBytesToCopy -= (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| ExtrBytesToCpy = TRUE; |
| } |
| } |
| else |
| { |
| NdefMap->Felica.Rd_NoBytesToCopy = (uint8_t)(NdefMap->Felica.TrxLen - (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)); |
| ExtrBytesToCpy = TRUE; |
| } |
| if ( ExtrBytesToCpy == TRUE ) |
| { |
| /*Copy the read data from trx buffer to apdu of size apdu*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->SendRecvBuf[13])), |
| NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| |
| /*copy bytesToCopy to internal buffer*/ |
| (void)memcpy( NdefMap->Felica.Rd_BytesToCopyBuff, |
| (&(NdefMap->SendRecvBuf[13+(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)])), |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| |
| NdefMap->Felica.IntermediateCpyFlag = TRUE; |
| NdefMap->ApduBuffIndex += (uint16_t)NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex; |
| } |
| else |
| { |
| /*Copy data from the internal buffer to user buffer*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->SendRecvBuf[13])), |
| NdefMap->Felica.Rd_NoBytesToCopy); |
| |
| NdefMap->ApduBuffIndex += NdefMap->Felica.Rd_NoBytesToCopy; |
| ResetFlag = TRUE; |
| |
| } |
| if ( DataLen <= (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) ) |
| { |
| NdefMap->Felica.EofCardReachedFlag =FELICA_RD_WR_EOF_CARD_REACHED; |
| } |
| else |
| { |
| ; |
| } |
| } |
| else if ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) == NdefMap->Felica.TrxLen ) |
| { |
| /*Copy exactly remained last bytes to user buffer and increment the index*/ |
| /*13 : 1+12 : 1st byte entire pkt length + 12 bytes to skip manuf details*/ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->SendRecvBuf[13])), |
| (NdefMap->Felica.TrxLen )); |
| |
| NdefMap->ApduBuffIndex += NdefMap->Felica.TrxLen; |
| } |
| else |
| { |
| if ((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) > NdefMap->Felica.TrxLen ) |
| { |
| /*Copy the data to apdu buffer and increment the index */ |
| (void)memcpy( (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (&(NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_RESP_HEADER_LEN])), |
| NdefMap->Felica.TrxLen); |
| |
| NdefMap->ApduBuffIndex += (uint16_t)NdefMap->Felica.TrxLen; |
| } |
| } |
| } |
| } |
| if ( ResetFlag == TRUE ) |
| { |
| /* reset the internal buffer variables*/ |
| NdefMap->Felica.Rd_NoBytesToCopy =0; |
| NdefMap->Felica.IntermediateCpyLen =0; |
| NdefMap->Felica.IntermediateCpyFlag =FALSE; |
| } |
| return; |
| } |
| |
| |
| /*! |
| * \brief Used in Read Opearation.After a successful read operation, |
| Checks the relavent buffer sizes and set the status.Following function is used |
| when we read the Nmaxb blocks. Retained for future purpose. |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HChkApduBuff_Size( phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| uint8_t ResetFlag = FALSE; |
| uint32_t Nbc = 0; |
| |
| Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC); |
| |
| /* set status to Success : User Buffer is full and Curblk < nmaxb*/ |
| if ( (( NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0) && |
| (NdefMap->Felica.CurBlockNo < Nbc )) |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| /*Reset the index, internal buffer counters back to zero*/ |
| *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; |
| NdefMap->ApduBuffIndex = 0; |
| |
| }/*if( (NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0 && NdefMap->Felica.CurBlockNo < NdefMap->FelicaAttrInfo.Nmaxb )*/ |
| else |
| { |
| if (( ( NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0) && |
| (NdefMap->Felica.CurBlockNo == Nbc )) |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| |
| ResetFlag = ((NdefMap->Felica.Rd_NoBytesToCopy > 0 )? |
| FALSE: |
| TRUE); |
| if( ResetFlag== FALSE) |
| { |
| *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; |
| /*Reset the index, internal buffer counters back to zero*/ |
| NdefMap->ApduBuffIndex = 0; |
| } |
| }/*if ((NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )== 0 && NdefMap->Felica.CurBlockNo == NdefMap->FelicaAttrInfo.Nmaxb )*/ |
| else |
| { |
| /* reached reading all the blks available in the card: set EOF flag*/ |
| if ( NdefMap->ApduBuffIndex == (Nbc*16)) |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| ResetFlag = TRUE; |
| } |
| else |
| { |
| if ((NdefMap->ApduBufferSize-NdefMap->ApduBuffIndex )> 0 ) |
| { |
| if ( NdefMap->Felica.CurBlockNo == Nbc ) |
| { |
| /* bytes pending in internal buffer , No Space in User Buffer*/ |
| if ( NdefMap->Felica.Rd_NoBytesToCopy > 0) |
| { |
| if ( NdefMap->Felica.EofCardReachedFlag == TRUE ) |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; |
| NdefMap->ApduBuffIndex=0; |
| } |
| else |
| { |
| phFriNfc_Felica_HAfterRead_CopyDataToBuff(NdefMap); |
| if( NdefMap->Felica.Rd_NoBytesToCopy > 0 ) |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; |
| NdefMap->ApduBuffIndex=0; |
| } |
| else |
| { |
| /* EOF Card Reached set the internal EOF Flag*/ |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| |
| ResetFlag = TRUE; |
| } |
| } |
| } |
| /* All bytes from internal buffer are copied and set eof flag*/ |
| else |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| ResetFlag = TRUE; |
| } |
| } |
| else |
| { |
| /* This flag is set to ensure that, need of Read Opearation |
| we completed coying the data from internal buffer to external buffer |
| left some more bytes,in User bufer so initiate the read operation */ |
| NdefMap->Felica.IntermediateRdFlag = TRUE; |
| } |
| } |
| else |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, |
| NFCSTATUS_SUCCESS); |
| } |
| } |
| } |
| if ( ResetFlag == TRUE) |
| { |
| *NdefMap->NumOfBytesRead = NdefMap->ApduBuffIndex; |
| /*Reset the index, internal buffer counters back to zero*/ |
| NdefMap->ApduBuffIndex = 0; |
| NdefMap->Felica.Rd_NoBytesToCopy=0; |
| NdefMap->Felica.EofCardReachedFlag=FELICA_RD_WR_EOF_CARD_REACHED; |
| |
| } |
| |
| } |
| return( status); |
| } |
| |
| /*! |
| * \brief Used in Read Opearation.Sets the transceive Command for read. |
| */ |
| static NFCSTATUS phFriNfc_Felica_HSetTransceiveForRead(phFriNfc_NdefMap_t *NdefMap,uint16_t TrxLen,uint8_t Offset) |
| { |
| NFCSTATUS TrxStatus = NFCSTATUS_PENDING; |
| uint16_t BufIndex=0,i=0; |
| |
| /* set the felica cmd */ |
| #ifdef PH_HAL4_ENABLE |
| NdefMap->Cmd.FelCmd = phHal_eFelica_Raw; |
| #else |
| NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd; |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| /*Change the state to Read */ |
| NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_RD_BLOCK; |
| |
| /* set the complition routines for the mifare operations */ |
| NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Felica_Process; |
| NdefMap->MapCompletionInfo.Context = NdefMap; |
| |
| /*set the additional informations for the data exchange*/ |
| NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; |
| NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; |
| |
| /* pkt len : updated at the end*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex ++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x06; |
| BufIndex++; |
| |
| /* IDm - Manufacturer Id : 8bytes*/ |
| #ifdef PH_HAL4_ENABLE |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (void * )(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)), |
| 8); |
| #else |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (void * )(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)), |
| 8); |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| BufIndex+=8; |
| |
| /*Number of Services (n=1 ==> 0x80)*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; |
| BufIndex++; |
| |
| /*Service Code List*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x0B; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| /*Number of Blocks to read*/ |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(TrxLen/16); |
| BufIndex++; |
| /* Set the Blk numbers as per the offset set by the user : Block List*/ |
| if ( Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN ) |
| { |
| for ( i=0;i<(TrxLen/16);i++) |
| { |
| /*1st Service Code list : byte 1*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; |
| BufIndex++; |
| |
| /* No. Of Blocks*/ |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(i + 1); |
| BufIndex++; |
| } |
| } |
| else |
| { |
| for ( i= 1;i<=(TrxLen/16);i++) |
| { |
| /*1st Service Code list : byte 1*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; |
| BufIndex++; |
| |
| /* No. Of Blocks*/ |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(NdefMap->Felica.CurBlockNo + i); |
| BufIndex++; |
| } |
| } |
| |
| /* len of entire pkt*/ |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = (uint8_t) BufIndex; |
| |
| /* Set the Pkt Len*/ |
| NdefMap->SendLength = BufIndex; |
| |
| *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; |
| |
| TrxStatus = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice, |
| &NdefMap->MapCompletionInfo, |
| NdefMap->psRemoteDevInfo, |
| NdefMap->Cmd, |
| &NdefMap->psDepAdditionalInfo, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendLength, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendRecvLength); |
| return (TrxStatus); |
| } |
| |
| /*! |
| * \brief Initiates Writing of NDEF information to the Remote Device. |
| * |
| * The function initiates the writing of NDEF information to a Remote Device. |
| * It performs a reset of the state and starts the action (state machine). |
| * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action |
| * has been triggered. |
| */ |
| |
| NFCSTATUS phFriNfc_Felica_WrNdef( phFriNfc_NdefMap_t *NdefMap, |
| uint8_t *PacketData, |
| uint32_t *PacketDataLength, |
| uint8_t Offset) |
| { |
| |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| NdefMap->ApduBufferSize = *PacketDataLength; |
| /*Store the packet data buffer*/ |
| NdefMap->ApduBuffer = PacketData; |
| |
| /* To Update the Acutal written bytes to context*/ |
| NdefMap->WrNdefPacketLength = PacketDataLength; |
| *NdefMap->WrNdefPacketLength = 0; |
| |
| |
| NdefMap->PrevOperation = PH_FRINFC_NDEFMAP_WRITE_OPE; |
| NdefMap->Felica.Offset = Offset; |
| |
| NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_WR_ATTR_RD_OP; |
| status = phFriNfc_Felica_HRdAttrInfo(NdefMap); |
| /* handle the error in Transc function*/ |
| if ( (status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,status); |
| } |
| return (status); |
| } |
| |
| /*! |
| * \brief Initiates Writing of Empty NDEF information to the Remote Device. |
| * |
| * The function initiates the writing empty of NDEF information to a Remote Device. |
| * It performs a reset of the state and starts the action (state machine). |
| * A periodic call of the \ref phFriNfcNdefMap_Process has to be done once the action |
| * has been triggered. |
| */ |
| |
| NFCSTATUS phFriNfc_Felica_EraseNdef( phFriNfc_NdefMap_t *NdefMap) |
| { |
| |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| static uint32_t PktDtLength =0; |
| |
| if ( NdefMap->CardState == PH_NDEFMAP_CARD_STATE_INVALID ) |
| { |
| /* Card is in invalid state, cannot have any read/write |
| operations*/ |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_INVALID_FORMAT); |
| } |
| else if ( NdefMap->CardState == PH_NDEFMAP_CARD_STATE_READ_ONLY ) |
| { |
| /*Can't write to the card :No Grants */ |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_WRITE_FAILED); |
| /* set the no. bytes written is zero*/ |
| NdefMap->WrNdefPacketLength = &PktDtLength; |
| *NdefMap->WrNdefPacketLength = 0; |
| } |
| else |
| { |
| |
| /* set the Operation*/ |
| NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_WR_EMPTY_MSG_OP; |
| |
| status = phFriNfc_Felica_HRdAttrInfo(NdefMap); |
| } |
| return (status); |
| } |
| |
| |
| /*! |
| * \brief Used in Write Opearation. |
| * check the value set for the Write Flag, in first write operation(begin), sets the |
| * WR flag in attribute blck. |
| * After a successful write operation, This function sets the WR flag off and updates |
| * the LEN bytes in attribute Block. |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HUpdateAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap,uint8_t isStarted) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| uint16_t ChkSum=0,index=0; |
| uint8_t BufIndex=0, ErrFlag = FALSE; |
| uint32_t TotNoWrittenBytes=0; |
| |
| /* Write Operation : Begin/End Check*/ |
| |
| NdefMap->State = |
| (( isStarted == FELICA_WRITE_STARTED )? |
| PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN: |
| PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END); |
| |
| if( ( NdefMap->State == PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN)|| |
| ( NdefMap->State == PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END) ) |
| { |
| |
| /* Set the Felica Cmd*/ |
| #ifdef PH_HAL4_ENABLE |
| NdefMap->Cmd.FelCmd = phHal_eFelica_Raw; |
| #else |
| NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd; |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| /* 1st byte represents the length of the cmd packet*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| /* Write/Update command code*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x08; |
| BufIndex++; |
| |
| /* IDm - Manufacturer Id : 8bytes*/ |
| #ifdef PH_HAL4_ENABLE |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)), |
| 8); |
| #else |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)), |
| 8); |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| BufIndex+=8; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x09; /* Service Code List*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Blocks to Write*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; /* 1st Block Element : byte 1*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* 1st Block Element : byte 2, block 1*/ |
| BufIndex++; |
| |
| /* Fill Attribute Blk Information*/ |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Version; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbr; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbw; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) >> 8); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) & (0x00ff)); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| if (isStarted == FELICA_WRITE_STARTED ) |
| { |
| NdefMap->SendRecvBuf[BufIndex] = 0x0F; /* Write Flag Made On*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.RdWrFlag; /* Read write flag*/ |
| BufIndex++; |
| |
| /* Len Bytes*/ |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.LenBytes[0]; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.LenBytes[1]; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.LenBytes[2]; |
| BufIndex++; |
| } |
| else |
| { |
| /* Case: Previous Write Operation failed and integration context continues with write |
| operation with offset set to Current. In this case, if we find Internal Bytes remained in the |
| felica context is true(>0) and current block number is Zero. Then we shouldn't allow the module |
| to write the data to card, as this is a invalid case*/ |
| if ( (NdefMap->Felica.Wr_BytesRemained > 0) && (NdefMap->Felica.CurBlockNo == 0)) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_INVALID_PARAMETER); |
| ErrFlag = TRUE; |
| } |
| else |
| { |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Write Flag Made Off*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.RdWrFlag; /* Read write flag*/ |
| BufIndex++; |
| |
| if ( NdefMap->Felica.Wr_BytesRemained > 0 ) |
| { |
| TotNoWrittenBytes = ( (NdefMap->Felica.CurBlockNo *16)- (16 - (NdefMap->Felica.Wr_BytesRemained))); |
| } |
| else |
| { |
| TotNoWrittenBytes = ( NdefMap->Felica.CurBlockNo *16); |
| |
| } |
| |
| /* Update Len Bytes*/ |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(( TotNoWrittenBytes & 0x00ff0000) >> 16); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((TotNoWrittenBytes & 0x0000ff00) >> 8); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(TotNoWrittenBytes & 0x000000ff); |
| BufIndex++; |
| } |
| } |
| |
| if ( ErrFlag != TRUE ) |
| { |
| /* check sum update*/ |
| for ( index = 16 ; index < 30 ; index ++) |
| { |
| ChkSum += NdefMap->SendRecvBuf[index]; |
| } |
| |
| /* fill check sum in command pkt*/ |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(ChkSum >> 8); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t )(ChkSum & 0x00ff); |
| BufIndex++; |
| |
| /* update length of the cmd pkt*/ |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex; |
| |
| *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; |
| |
| /* Update the Send Len*/ |
| NdefMap->SendLength = BufIndex; |
| |
| /*set the completion routines for the desfire card operations*/ |
| NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_NdefMap_Process; |
| NdefMap->MapCompletionInfo.Context = NdefMap; |
| |
| /*set the additional informations for the data exchange*/ |
| NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; |
| NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; |
| |
| /*Call the Overlapped HAL Transceive function */ |
| status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, |
| &NdefMap->MapCompletionInfo, |
| NdefMap->psRemoteDevInfo, |
| NdefMap->Cmd, |
| &NdefMap->psDepAdditionalInfo, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendLength, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendRecvLength); |
| } |
| } |
| else |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_INVALID_PARAMETER); |
| |
| } |
| return (status); |
| } |
| |
| static NFCSTATUS phFriNfc_Felica_HWrEmptyMsg(phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| uint16_t ChkSum=0,index=0; |
| uint8_t BufIndex=0; |
| |
| /* Write Operation : To Erase the present NDEF Data*/ |
| |
| NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_WR_EMPTY_MSG; |
| |
| /* Set the Felica Cmd*/ |
| #ifdef PH_HAL4_ENABLE |
| NdefMap->Cmd.FelCmd = phHal_eFelica_Raw; |
| #else |
| NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd; |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| /* 1st byte represents the length of the cmd packet*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| /* Write/Update command code*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x08; |
| BufIndex++; |
| |
| /* IDm - Manufacturer Id : 8bytes*/ |
| #ifdef PH_HAL4_ENABLE |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)), |
| 8); |
| #else |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (void*)(&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)), |
| 8); |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| |
| BufIndex+=8; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x09; /* Service Code List*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Blocks to Write*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; /* 1st Block Element : byte 1*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* 1st Block Element : byte 2, block 1*/ |
| BufIndex++; |
| |
| /* Fill Attribute Blk Information*/ |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Version; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbr; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbw; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) >> 8); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb) & (0x00ff)); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /*RFU*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.WriteFlag; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.RdWrFlag; /* Read write flag*/ |
| BufIndex++; |
| |
| /* Len Bytes are set to 0 : Empty Msg*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| /* check sum update*/ |
| for ( index = 16 ; index < 30 ; index ++) |
| { |
| ChkSum += NdefMap->SendRecvBuf[index]; |
| } |
| |
| /* fill check sum in command pkt*/ |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)(ChkSum >> 8); |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t )(ChkSum & 0x00ff); |
| BufIndex++; |
| |
| /* update length of the cmd pkt*/ |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex; |
| |
| *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; |
| |
| /* Update the Send Len*/ |
| NdefMap->SendLength = BufIndex; |
| |
| /*set the completion routines for the desfire card operations*/ |
| NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_NdefMap_Process; |
| NdefMap->MapCompletionInfo.Context = NdefMap; |
| |
| /*set the additional informations for the data exchange*/ |
| NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; |
| NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; |
| |
| /*Call the Overlapped HAL Transceive function */ |
| status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, |
| &NdefMap->MapCompletionInfo, |
| NdefMap->psRemoteDevInfo, |
| NdefMap->Cmd, |
| &NdefMap->psDepAdditionalInfo, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendLength, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendRecvLength); |
| |
| return (status); |
| } |
| |
| |
| |
| |
| /*! |
| * \brief Used in Write Opearation. |
| * This Function is called after a successful validation and storing of attribution block |
| * content in to context. |
| * If the write operation is initiated with begin,function initiates the write operation with |
| * RdWr flag. |
| * If the Offset is set to Current, Checks for the EOF card reached status and writes data to |
| * The Card |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForWrOp(phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| uint32_t DataLen=0; |
| |
| /*check RW Flag Access Rights*/ |
| /* set to read only cannot write*/ |
| if ( NdefMap->FelicaAttrInfo.RdWrFlag == 0x00) |
| |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_INVALID_DEVICE_REQUEST); |
| } |
| else |
| { |
| if ( ( NdefMap->Felica.Offset == PH_FRINFC_NDEFMAP_SEEK_BEGIN) || |
| ( ( NdefMap->PrevOperation == PH_FRINFC_NDEFMAP_READ_OPE) && |
| (NdefMap->Felica.Offset != PH_FRINFC_NDEFMAP_SEEK_BEGIN ) )) |
| { |
| /* check allready written number of bytes and apdu buffer size*/ |
| if (NdefMap->ApduBufferSize > (uint32_t)(NdefMap->FelicaAttrInfo.Nmaxb *16)) |
| { |
| NdefMap->Felica.EofCardReachedFlag = FELICA_EOF_REACHED_WR_WITH_BEGIN_OFFSET; |
| } |
| else |
| { |
| NdefMap->Felica.EofCardReachedFlag = FALSE; |
| } |
| |
| |
| /* reset the internal variables initiate toupdate the attribute blk*/ |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| NdefMap->Felica.CurBlockNo = 0; |
| NdefMap->Felica.NoBlocksWritten = 0; |
| phFriNfc_Felica_HInitInternalBuf(NdefMap->Felica.Wr_RemainedBytesBuff); |
| status= phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_STARTED); |
| |
| } |
| else |
| { |
| if (NdefMap->Felica.Offset == PH_FRINFC_NDEFMAP_SEEK_CUR ) |
| { |
| /* Calculate the Allready Written No. Of Blocks*/ |
| PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0], |
| NdefMap->FelicaAttrInfo.LenBytes[1], |
| NdefMap->FelicaAttrInfo.LenBytes[2], |
| DataLen); |
| |
| if (( NdefMap->ApduBufferSize + (DataLen )) > |
| (uint32_t)( NdefMap->FelicaAttrInfo.Nmaxb *16)) |
| { |
| if(( DataLen ) == (uint32_t)(NdefMap->FelicaAttrInfo.Nmaxb *16) ) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_EOF_NDEF_CONTAINER_REACHED); |
| } |
| else |
| { |
| |
| NdefMap->Felica.EofCardReachedFlag =FELICA_EOF_REACHED_WR_WITH_CURR_OFFSET; |
| NdefMap->ApduBuffIndex =0; |
| NdefMap->Felica.NoBlocksWritten = 0; |
| status= phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_STARTED); |
| } |
| } |
| else |
| { |
| NdefMap->ApduBuffIndex =0; |
| NdefMap->Felica.NoBlocksWritten = 0; |
| status= phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_STARTED); |
| } |
| }/*if (NdefMap->Felica.Offset == PH_FRINFC_NDEFMAP_SEEK_CUR )*/ |
| } |
| } |
| return (status); |
| } |
| |
| /*! |
| * \brief Used in Read Opearation. |
| * This Function is called after a successful validation and storing of attribution block |
| * content in to context. |
| * While Offset is set to Current, Checks for the EOF card reached status and reads data from |
| * The Card |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HChkAttrBlkForRdOp(phFriNfc_NdefMap_t *NdefMap, |
| uint32_t NdefLen) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| /*check WR Flag Access Rights*/ |
| /* set to still writing data state only cannot Read*/ |
| if ( NdefMap->FelicaAttrInfo.WriteFlag == 0x0F ) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_READ_FAILED); |
| /* As we are not able to continue with reading data |
| bytes read set to zero*/ |
| *NdefMap->NumOfBytesRead = 0; |
| } |
| else |
| { |
| status = phFriNfc_MapTool_SetCardState( NdefMap,NdefLen); |
| if ( status == NFCSTATUS_SUCCESS) |
| { |
| /* Read data From the card*/ |
| status = phFriNfc_Felica_HReadData(NdefMap,NdefMap->Felica.Offset); |
| } |
| } |
| |
| return (status); |
| } |
| |
| /*! |
| * \brief Used in Write Opearation. |
| * This function writes the data in terms of blocks. |
| * Each write operation supports,minimum Nbw blocks of bytes. |
| * Also checks for the EOF,>=NBW,<NBW etc |
| */ |
| static NFCSTATUS phFriNfc_Felica_HUpdateData(phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| uint8_t BufIndex=0, |
| i=0, |
| BlkNo=0, |
| PadBytes=0, |
| CurBlk=1, |
| NoOfBlks=0, |
| NbwCheck=0, |
| TotNoBlks=0; |
| |
| uint32_t BytesRemainedInCard=0, |
| BytesRemained=0, |
| TotNoWrittenBytes=0; |
| |
| if( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) > 0 ) |
| { |
| /* Prepare the write cmd pkt for felica*/ |
| /* 1st byte represents the length of the cmd packet*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| /* Write/Update command code*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x08; |
| BufIndex++; |
| |
| /* IDm - Manufacturer Id : 8bytes*/ |
| #ifdef PH_HAL4_ENABLE |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm)), |
| 8); |
| #else |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t)), |
| 8); |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| BufIndex+=8; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x09; /* Service Code List*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/ |
| BufIndex++; |
| |
| if ( NdefMap->Felica.EofCardReachedFlag == FELICA_EOF_REACHED_WR_WITH_BEGIN_OFFSET) |
| { |
| /* check for the eof card reached flag.Need to write only mamximum bytes(memory)to card. |
| Used when, offset set to begin case*/ |
| BytesRemainedInCard= ( (NdefMap->FelicaAttrInfo.Nmaxb*16) - (NdefMap->Felica.CurBlockNo * 16)); |
| } |
| else |
| { |
| /* Offset : Cuurent*/ |
| if ( NdefMap->Felica.EofCardReachedFlag == FELICA_EOF_REACHED_WR_WITH_CURR_OFFSET ) |
| { |
| /* caculate previously written Ndef blks*/ |
| (void)phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC); |
| |
| if ( NdefMap->Felica.Wr_BytesRemained ) |
| { |
| TotNoWrittenBytes = ( (NdefMap->Felica.CurBlockNo *16)- (16 - (NdefMap->Felica.Wr_BytesRemained))); |
| } |
| else |
| { |
| TotNoWrittenBytes = ( NdefMap->Felica.CurBlockNo *16); |
| } |
| /* Determine exactly, how many bytes we can write*/ |
| BytesRemainedInCard = (NdefMap->FelicaAttrInfo.Nmaxb*16 - (TotNoWrittenBytes)); |
| } |
| |
| } |
| /* Write Data Pending in the Internal Buffer*/ |
| if(NdefMap->Felica.Wr_BytesRemained > 0) |
| { |
| /* update the number of blocks to write with the block list elements*/ |
| /* Total Number of blocks to write*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0; |
| BufIndex++; |
| |
| /* Update this Total no. Bloks later*/ |
| NoOfBlks = BufIndex; |
| |
| /* As we are writing atleast one block*/ |
| TotNoBlks = 1; |
| |
| /* check do we have some extra bytes to write? in User Buffer*/ |
| if ( NdefMap->ApduBufferSize >(uint32_t) (16 - NdefMap->Felica.Wr_BytesRemained)) |
| { |
| /* Have we reached EOF?*/ |
| if ( NdefMap->Felica.EofCardReachedFlag ) |
| { |
| BytesRemained = BytesRemainedInCard; |
| } |
| else |
| { |
| /* This value tells how many extra bytes we can write other than internal buffer bytes*/ |
| BytesRemained = (uint8_t)NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained); |
| } |
| |
| if ( BytesRemained ) |
| { |
| /* Not reached EOF*/ |
| if (!NdefMap->Felica.EofCardReachedFlag) |
| { |
| /* Calculate How many blks we need to write*/ |
| BlkNo =((uint8_t)( BytesRemained )/16); |
| |
| /* check blocks to write exceeds nbw*/ |
| if ( BlkNo >= NdefMap->FelicaAttrInfo.Nbw ) |
| { |
| BlkNo = NdefMap->FelicaAttrInfo.Nbw; |
| /* No. Blks to write are more than Nbw*/ |
| NbwCheck = 1; |
| } |
| else |
| { |
| if ((( BytesRemained %16) == 0)&& (BlkNo == 0 )) |
| { |
| BlkNo=1; |
| } |
| } |
| /* check do we need pad bytes?*/ |
| if( (!NbwCheck && (uint8_t)( BytesRemained)%16) != 0) |
| { |
| BlkNo++; |
| PadBytes = (BlkNo * 16) - (uint8_t)( BytesRemained); |
| NdefMap->Felica.PadByteFlag = TRUE; |
| NdefMap->Felica.NoBlocksWritten = BlkNo; |
| TotNoBlks += BlkNo; |
| |
| } |
| else |
| { |
| if ( NbwCheck ) |
| { |
| /* as we have to write only 8 blocks and already we have pad bytes so we have |
| to strat from previous block*/ |
| TotNoBlks += BlkNo - 1; |
| NdefMap->Felica.NoBlocksWritten = TotNoBlks-1; |
| } |
| else |
| { |
| if ( !(BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained)== 0 )) |
| { |
| TotNoBlks += BlkNo; |
| } |
| else |
| { |
| |
| } |
| if ( NdefMap->Felica.PadByteFlag ) |
| { |
| NdefMap->Felica.NoBlocksWritten = TotNoBlks-1; |
| |
| } |
| } |
| } |
| } |
| else |
| { |
| /* we have reached the eof card & hv bytes to write*/ |
| BlkNo =(uint8_t)(( BytesRemained - ((16 -NdefMap->Felica.Wr_BytesRemained)) )/16); |
| |
| /* check are we exceeding the NBW limit, while a write?*/ |
| if ( BlkNo >= NdefMap->FelicaAttrInfo.Nbw ) |
| { |
| BlkNo = NdefMap->FelicaAttrInfo.Nbw; |
| |
| /* No. Blks to write are more than Nbw*/ |
| NbwCheck = 1; |
| |
| } |
| else |
| { |
| if ((( BytesRemained %16) == 0)&& (BlkNo == 0 )) |
| { |
| BlkNo=1; |
| } |
| } |
| |
| /*check Total how many blocks to write*/ |
| if(((!NbwCheck) &&( BytesRemained- (16 - NdefMap->Felica.Wr_BytesRemained))%16) != 0) |
| { |
| BlkNo++; |
| PadBytes = (BlkNo * 16) - (uint8_t)( BytesRemained); |
| NdefMap->Felica.PadByteFlag = TRUE; |
| NdefMap->Felica.NoBlocksWritten = BlkNo; |
| TotNoBlks += BlkNo; |
| |
| } |
| else |
| { |
| if ( NbwCheck ) |
| { |
| /* as we have to write only 8 blocks and already we have pad bytes so we have |
| to strat from previous last block*/ |
| TotNoBlks += BlkNo - 1; |
| NdefMap->Felica.NoBlocksWritten = TotNoBlks-1; |
| } |
| else |
| { |
| /* we need to write only one block ( bytesremanind + internal buffer size = 16)*/ |
| if ( !(BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained)== 0 )) |
| { |
| TotNoBlks += BlkNo; |
| } |
| else |
| { |
| ;/* we are not incrementing the Total no. of blocks to write*/ |
| } |
| |
| if ( NdefMap->Felica.PadByteFlag ) |
| { |
| NdefMap->Felica.NoBlocksWritten = TotNoBlks -1; |
| |
| } |
| } |
| } |
| } |
| }/*if ( BytesRemained )*/ |
| else |
| { |
| ; /*Nothing to process here*/ |
| } |
| }/*if ( NdefMap->ApduBufferSize >(uint32_t) (16 - NdefMap->Felica.Wr_BytesRemained))*/ |
| else |
| { |
| /* No new blks to write*/ |
| NdefMap->Felica.NoBlocksWritten = 0; |
| } |
| /* Prepare the Blk List for Write Operation*/ |
| /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/ |
| for ( i=0; i< TotNoBlks; i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; |
| BufIndex++; |
| /* remember the previous Blk no and continue from there*/ |
| if ( NdefMap->Felica.PadByteFlag == TRUE ) |
| { |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->Felica.CurBlockNo + i; |
| BufIndex++; |
| } |
| else |
| { |
| CurBlk = NdefMap->Felica.CurBlockNo +1; |
| NdefMap->SendRecvBuf[BufIndex] = CurBlk + i; |
| BufIndex++; |
| } |
| } |
| /* Copy relevant data to Transc buffer*/ |
| if((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16 - NdefMap->Felica.Wr_BytesRemained)) |
| { |
| |
| /*Copy the Remained bytes from the internal buffer to trxbuffer */ |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| NdefMap->Felica.Wr_RemainedBytesBuff, |
| NdefMap->Felica.Wr_BytesRemained); |
| |
| /*Increment the buff index*/ |
| BufIndex += NdefMap->Felica.Wr_BytesRemained; |
| |
| |
| /*append copy 16-bytesToPad to trxBuffer*/ |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (16 - NdefMap->Felica.Wr_BytesRemained)); |
| |
| /* Update Number Of Bytes Writtened*/ |
| NdefMap->NumOfBytesWritten = 16 - NdefMap->Felica.Wr_BytesRemained; |
| |
| /* increment the index*/ |
| BufIndex += 16 - NdefMap->Felica.Wr_BytesRemained; |
| |
| if ( BytesRemained ) |
| { |
| if (!NdefMap->Felica.EofCardReachedFlag) |
| { |
| /* check nbw limit*/ |
| if ( NbwCheck != 1 ) |
| { |
| /* Copy Extra Bytes other than the internal buffer bytes*/ |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])), |
| (NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained))); |
| |
| |
| /* Update Number Of Bytes Writtened*/ |
| NdefMap->NumOfBytesWritten += (uint16_t)(NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained)); |
| |
| BufIndex += (uint8_t)(NdefMap->ApduBufferSize - (16 - NdefMap->Felica.Wr_BytesRemained)); |
| |
| if ( PadBytes ) |
| { |
| for(i= 0; i< PadBytes; i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] =0x00; |
| BufIndex++; |
| } |
| /* no of bytes remained copy*/ |
| NdefMap->Felica.Wr_BytesRemained = (uint8_t)(16 - PadBytes); |
| |
| /*copy the data to internal buffer : Bytes remained*/ |
| (void)memcpy( NdefMap->Felica.Wr_RemainedBytesBuff, |
| (&( NdefMap->ApduBuffer[(NdefMap->ApduBufferSize - NdefMap->Felica.Wr_BytesRemained)])), |
| ( NdefMap->Felica.Wr_BytesRemained)); |
| } |
| else |
| { |
| /* No Bytes in Internal buffer*/ |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| } |
| |
| } |
| else |
| { |
| |
| /*Copy Nbw*16 bytes of data to the trx buffer*/ |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])), |
| (NdefMap->FelicaAttrInfo.Nbw - 1) * 16); |
| |
| /* increment the Buffindex*/ |
| BufIndex += ((NdefMap->FelicaAttrInfo.Nbw - 1 )*16); |
| |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| NdefMap->NumOfBytesWritten+= ((NdefMap->FelicaAttrInfo.Nbw -1)*16); |
| NdefMap->Felica.PadByteFlag =FALSE; |
| } |
| }/*if (!NdefMap->Felica.EofCardReachedFlag)*/ |
| else |
| { |
| /* check nbw limit*/ |
| if ( NbwCheck != 1 ) |
| { |
| /* handle EOF card reached case*/ |
| (void)memcpy( (&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])), |
| ( BytesRemained - ((16 -NdefMap->Felica.Wr_BytesRemained) ))); |
| |
| /* Update Number Of Bytes Writtened*/ |
| NdefMap->NumOfBytesWritten += (uint16_t)( BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained)); |
| |
| BufIndex += (uint8_t)( BytesRemained - (16 -NdefMap->Felica.Wr_BytesRemained)); |
| |
| if ( PadBytes ) |
| { |
| for(i= 0; i< PadBytes; i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] =0x00; |
| BufIndex++; |
| } |
| |
| /*no of bytes remained copy*/ |
| NdefMap->Felica.Wr_BytesRemained = (uint8_t)(16 - PadBytes); |
| |
| /*copy the data to internal buffer : Bytes remained*/ |
| (void)memcpy(NdefMap->Felica.Wr_RemainedBytesBuff, |
| (&(NdefMap->ApduBuffer[(NdefMap->ApduBufferSize - NdefMap->Felica.Wr_BytesRemained)])), |
| (NdefMap->Felica.Wr_BytesRemained)); |
| |
| } |
| else |
| { |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| } |
| } |
| else |
| { |
| |
| /*Copy Nbw*16 bytes of data to the trx buffer*/ |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[(16 - NdefMap->Felica.Wr_BytesRemained)])), |
| (NdefMap->FelicaAttrInfo.Nbw - 1) * 16); |
| |
| /* increment the Buffindex*/ |
| BufIndex += ((NdefMap->FelicaAttrInfo.Nbw - 1 )*16); |
| |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| NdefMap->NumOfBytesWritten+= ((NdefMap->FelicaAttrInfo.Nbw -1)*16); |
| |
| NdefMap->Felica.PadByteFlag =FALSE; |
| } |
| } |
| }/*if ( BytesRemained )*/ |
| else |
| { |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| } |
| /* Update Total No. of blocks writtened*/ |
| NdefMap->SendRecvBuf[NoOfBlks -1 ]=TotNoBlks; |
| }/*if((NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16 - NdefMap->Felica.Wr_BytesRemained))*/ |
| else |
| { |
| /*copy the internal buffer data to trx buffer*/ |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| NdefMap->Felica.Wr_RemainedBytesBuff, |
| (NdefMap->Felica.Wr_BytesRemained)); |
| |
| /* increment the index*/ |
| BufIndex+=NdefMap->Felica.Wr_BytesRemained; |
| |
| /*append the apdusize data to the trx buffer*/ |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| NdefMap->ApduBufferSize); |
| |
| /* Index increment*/ |
| BufIndex+= (uint8_t)NdefMap->ApduBufferSize; |
| |
| /* Tells how many bytes present in the internal buffer*/ |
| BytesRemained = NdefMap->Felica.Wr_BytesRemained + NdefMap->ApduBufferSize; |
| |
| PadBytes = (uint8_t)(16-BytesRemained); |
| |
| /* Pad empty bytes with Zeroes to complete 16 bytes*/ |
| for(i= 0; i< PadBytes; i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] =0x00; |
| BufIndex++; |
| } |
| |
| /* Update Number Of Bytes Writtened*/ |
| NdefMap->NumOfBytesWritten = (uint16_t)NdefMap->ApduBufferSize; |
| |
| /* Flag set to understand that , we have received less no. of bytes than |
| present in the internal buffer*/ |
| NdefMap->Felica.IntermediateWrFlag = TRUE; |
| |
| if ( NdefMap->Felica.PadByteFlag ) |
| { |
| NdefMap->Felica.NoBlocksWritten = 0; |
| } |
| } |
| |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex; |
| NdefMap->SendLength = BufIndex; |
| /* Update Total No. of blocks writtened*/ |
| NdefMap->SendRecvBuf[NoOfBlks -1 ]=TotNoBlks; |
| } |
| else |
| { |
| /*Fresh write, starting from a new block*/ |
| if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16* NdefMap->FelicaAttrInfo.Nbw )) |
| { |
| /* check for the card size and write Nbw Blks*/ |
| if ( NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo >= NdefMap->FelicaAttrInfo.Nbw) |
| { |
| /* update the number of blocks to write with the block list elements*/ |
| /* Total Number of blocks to write*/ |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->FelicaAttrInfo.Nbw; |
| BufIndex++; |
| |
| /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/ |
| for ( i=1; i<= NdefMap->FelicaAttrInfo.Nbw; i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->Felica.CurBlockNo + i; |
| BufIndex++; |
| } |
| /*Copy Nbw*16 bytes of data to the trx buffer*/ |
| |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| NdefMap->FelicaAttrInfo.Nbw * 16); |
| |
| /* increment the Buffindex*/ |
| BufIndex += (NdefMap->FelicaAttrInfo.Nbw*16); |
| |
| /* update the length*/ |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex; |
| |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| NdefMap->NumOfBytesWritten = (NdefMap->FelicaAttrInfo.Nbw*16); |
| NdefMap->Felica.NoBlocksWritten = NdefMap->FelicaAttrInfo.Nbw; |
| |
| /* update the Send length*/ |
| NdefMap->SendLength = BufIndex; |
| |
| NdefMap->Felica.PadByteFlag = FALSE; |
| }/*if ( NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo >= NdefMap->FelicaAttrInfo.Nbw)*/ |
| else |
| { |
| /* we need to write less than nbw blks*/ |
| /* update the number of blocks to write with the block list elements*/ |
| /* Total Number of blocks to write*/ |
| NdefMap->SendRecvBuf[BufIndex] = (uint8_t)( NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo); |
| BufIndex++; |
| |
| /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/ |
| for ( i=1; i<= (NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo); i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; |
| BufIndex++; |
| NdefMap->SendRecvBuf[BufIndex] = NdefMap->Felica.CurBlockNo + i; |
| BufIndex++; |
| } |
| |
| /*Copy Nbw*16 bytes of data to the trx buffer*/ |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo)*16); |
| |
| /* increment the Buffindex*/ |
| BufIndex += (uint8_t)((NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo )*16); |
| |
| /* update the length*/ |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex; |
| |
| NdefMap->NumOfBytesWritten = ((NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo)*16); |
| NdefMap->Felica.NoBlocksWritten = (uint8_t)(NdefMap->FelicaAttrInfo.Nmaxb - NdefMap->Felica.CurBlockNo); |
| |
| /* update the Send length*/ |
| NdefMap->SendLength = BufIndex; |
| |
| NdefMap->Felica.PadByteFlag =FALSE; |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| } |
| }/* if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16* NdefMap->FelicaAttrInfo.Nbw )) */ |
| else |
| { |
| /*chk eof reached*/ |
| if ( NdefMap->Felica.EofCardReachedFlag) |
| { |
| BlkNo =((uint8_t)(BytesRemainedInCard )/16); |
| if(((uint8_t)( BytesRemainedInCard )%16) != 0) |
| { |
| BlkNo++; |
| PadBytes = ((BlkNo * 16) - (uint8_t)(BytesRemainedInCard )); |
| NdefMap->Felica.PadByteFlag = TRUE; |
| } |
| } |
| else |
| { |
| |
| BlkNo =((uint8_t)( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)/16); |
| if(((uint8_t)( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)%16) != 0) |
| { |
| BlkNo++; |
| PadBytes = (BlkNo * 16) - (uint8_t)( NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| NdefMap->Felica.PadByteFlag = TRUE; |
| |
| } |
| |
| |
| } |
| |
| /* update the number of blocks to write with the block list elements*/ |
| /* Total Number of blocks to write*/ |
| NdefMap->SendRecvBuf[BufIndex] = BlkNo; |
| BufIndex++; |
| |
| NdefMap->Felica.NoBlocksWritten = BlkNo; |
| |
| /* Block List for NBw : 1st byte : two byte len list: 2nd byte is the block number*/ |
| for ( i=0; i< BlkNo; i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; |
| BufIndex++; |
| { |
| CurBlk = NdefMap->Felica.CurBlockNo +1; |
| NdefMap->SendRecvBuf[BufIndex] = CurBlk + i; |
| BufIndex++; |
| } |
| } |
| if ( NdefMap->Felica.EofCardReachedFlag ) |
| { |
| /*Copy last data to the trx buffer*/ |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| BytesRemainedInCard ); |
| |
| /* increment the bufindex and bytes written*/ |
| BufIndex += (uint8_t )BytesRemainedInCard ; |
| NdefMap->NumOfBytesWritten = (uint16_t)BytesRemainedInCard ; |
| } |
| else |
| { |
| /*Copy data to the trx buffer*/ |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (&(NdefMap->ApduBuffer[NdefMap->ApduBuffIndex])), |
| (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex)); |
| |
| /* increment the bufindex and bytes written*/ |
| BufIndex += (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| NdefMap->NumOfBytesWritten = (uint8_t)(NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex); |
| } |
| if ( PadBytes ) |
| { |
| for(i= 0; i< PadBytes; i++) |
| { |
| NdefMap->SendRecvBuf[BufIndex] =0x00; |
| BufIndex++; |
| } |
| /*no of bytes remained copy*/ |
| NdefMap->Felica.Wr_BytesRemained = (uint8_t)(16 - PadBytes); |
| |
| if ( NdefMap->Felica.EofCardReachedFlag ) |
| { |
| /*copy the data to internal buffer : Bytes remained*/ |
| (void)memcpy(NdefMap->Felica.Wr_RemainedBytesBuff, |
| (&(NdefMap->ApduBuffer[((BytesRemainedInCard - (BytesRemainedInCard % 16)))])), |
| ( NdefMap->Felica.Wr_BytesRemained)); |
| |
| } |
| else |
| { |
| /*copy the data to internal buffer : Bytes remained*/ |
| (void)memcpy( NdefMap->Felica.Wr_RemainedBytesBuff, |
| (&(NdefMap->ApduBuffer[((NdefMap->ApduBufferSize - NdefMap->Felica.Wr_BytesRemained))])), |
| ( NdefMap->Felica.Wr_BytesRemained)); |
| |
| } |
| }/*if ( PadBytes )*/ |
| else |
| { |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| NdefMap->Felica.PadByteFlag = FALSE; |
| } |
| /* update the pkt len*/ |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex; |
| NdefMap->SendLength = BufIndex; |
| } |
| }/* else of if ( (NdefMap->ApduBufferSize - NdefMap->ApduBuffIndex) >= (uint32_t)(16* NdefMap->FelicaAttrInfo.Nbw )) */ |
| status = phFriNfc_Felica_HWriteDataBlk(NdefMap); |
| } |
| else |
| { |
| /*0 represents the write operation ended*/ |
| status = phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_ENDED); |
| } |
| return (status); |
| } |
| |
| |
| /*! |
| * \brief Used in Write Opearation. |
| * This function prepares and sends transcc Cmd Pkt. |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HWriteDataBlk(phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| /*set the additional informations for the data exchange*/ |
| NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; |
| NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; |
| |
| /*Set the ISO14434 command*/ |
| #ifdef PH_HAL4_ENABLE |
| NdefMap->Cmd.FelCmd = phHal_eFelica_Raw; |
| #else |
| NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd; |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| /* set the state*/ |
| NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_WR_BLOCK; |
| |
| /* set send receive length*/ |
| *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; |
| |
| /*Call the Overlapped HAL Transceive function */ |
| status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, |
| &NdefMap->MapCompletionInfo, |
| NdefMap->psRemoteDevInfo, |
| NdefMap->Cmd, |
| &NdefMap->psDepAdditionalInfo, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendLength, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendRecvLength); |
| return (status); |
| } |
| |
| /*! |
| * \brief Check whether a particular Remote Device is NDEF compliant. |
| * The function checks whether the peer device is NDEF compliant. |
| */ |
| |
| NFCSTATUS phFriNfc_Felica_ChkNdef( phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| uint8_t sysCode[2]; |
| |
| /* set the system code for selecting the wild card*/ |
| sysCode[0] = 0x12; |
| sysCode[1] = 0xFC; |
| |
| status = phFriNfc_Felica_HPollCard( NdefMap,sysCode,PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_NDEF_APP); |
| |
| return (status); |
| |
| } |
| /*! |
| * \brief Check whether a particular Remote Device is NDEF compliant. |
| * selects the sysCode and then NFC Forum Reference Applications |
| */ |
| #ifdef PH_HAL4_ENABLE |
| static NFCSTATUS phFriNfc_Felica_HPollCard( phFriNfc_NdefMap_t *NdefMap, |
| const uint8_t sysCode[], |
| uint8_t state) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| /*Format the Poll Packet for selecting the system code passed as parameter */ |
| NdefMap->SendRecvBuf[0] = 0x06; |
| NdefMap->SendRecvBuf[1] = 0x00; |
| NdefMap->SendRecvBuf[2] = sysCode[0]; |
| NdefMap->SendRecvBuf[3] = sysCode[1]; |
| NdefMap->SendRecvBuf[4] = 0x01; |
| NdefMap->SendRecvBuf[5] = 0x03; |
| |
| NdefMap->SendLength = 6; |
| |
| /*set the completion routines for the felica card operations*/ |
| NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Felica_Process; |
| NdefMap->MapCompletionInfo.Context = NdefMap; |
| |
| /*Set Ndef State*/ |
| NdefMap->State = state; |
| |
| /* set the felica cmd */ |
| NdefMap->Cmd.FelCmd = phHal_eFelica_Raw; |
| |
| /*set the additional informations for the data exchange*/ |
| NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; |
| NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; |
| |
| status = phFriNfc_OvrHal_Transceive(NdefMap->LowerDevice, |
| &NdefMap->MapCompletionInfo, |
| NdefMap->psRemoteDevInfo, |
| NdefMap->Cmd, |
| &NdefMap->psDepAdditionalInfo, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendLength, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendRecvLength); |
| return (status); |
| } |
| #endif |
| |
| |
| #ifndef PH_HAL4_ENABLE |
| static NFCSTATUS phFriNfc_Felica_HPollCard( phFriNfc_NdefMap_t *NdefMap, |
| const uint8_t sysCode[], |
| uint8_t state) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| /*Format the Poll Packet for selecting the wild card "0xff 0xff as system code*/ |
| NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[0] = 0x00; |
| NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[1] = sysCode[0]; |
| NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[2] = sysCode[1]; |
| NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[3] = 0x01; |
| NdefMap->FelicaPollDetails.DevInputParam->FelicaPollPayload[4] = 0x03; |
| |
| /* set the length to zero*/ |
| NdefMap->FelicaPollDetails.DevInputParam->GeneralByteLength =0x00; |
| |
| NdefMap->NoOfDevices = PH_FRINFC_NDEFMAP_FELI_NUM_DEVICE_TO_DETECT; |
| |
| /*set the completion routines for the felica card operations*/ |
| NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_Felica_Process; |
| NdefMap->MapCompletionInfo.Context = NdefMap; |
| |
| /*Set Ndef State*/ |
| NdefMap->State = state; |
| |
| /* Harsha: This is a special case for felica. |
| Make a copy of the remote device information and send it for |
| polling. Return the original remote device information to the |
| caller. The user does not need the updated results of the poll |
| that we are going to call now. This is only used for checking |
| whether the felica card is NDEF compliant or not. */ |
| (void) memcpy( &NdefMap->FelicaPollDetails.psTempRemoteDevInfo, |
| NdefMap->psRemoteDevInfo, |
| sizeof(phHal_sRemoteDevInformation_t)); |
| |
| /* Reset the session opened flag */ |
| NdefMap->FelicaPollDetails.psTempRemoteDevInfo.SessionOpened = 0x00; |
| |
| /*Call the Overlapped HAL POLL function */ |
| status = phFriNfc_OvrHal_Poll( NdefMap->LowerDevice, |
| &NdefMap->MapCompletionInfo, |
| NdefMap->OpModeType, |
| &NdefMap->FelicaPollDetails.psTempRemoteDevInfo, |
| &NdefMap->NoOfDevices, |
| NdefMap->FelicaPollDetails.DevInputParam); |
| |
| return (status); |
| } |
| #endif /* #ifndef PH_HAL4_ENABLE */ |
| /*! |
| * \brief Checks validity of system code sent from the lower device, during poll operation. |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HUpdateManufIdDetails(const phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| /* Get the details from Poll Response packet */ |
| if (NdefMap->SendRecvLength >= 20) |
| { |
| (void)memcpy( (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm, |
| (uint8_t *)&NdefMap->SendRecvBuf[2], 8); |
| (void)memcpy( (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.PMm, |
| (uint8_t *)&NdefMap->SendRecvBuf[10], 8); |
| NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[1] = NdefMap->SendRecvBuf[18]; |
| NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[0] = NdefMap->SendRecvBuf[19]; |
| NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDmLength = 8; |
| |
| /* copy the IDm and PMm in Manufacture Details Structure*/ |
| (void)memcpy( (uint8_t *)(NdefMap->FelicaManufDetails.ManufID), |
| (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm, |
| 8); |
| (void)memcpy( (uint8_t *)(NdefMap->FelicaManufDetails.ManufParameter), |
| (uint8_t *)NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.PMm, |
| 8); |
| if((NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[1] == 0x12) |
| && (NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.SystemCode[0] == 0xFC)) |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE, NFCSTATUS_SUCCESS); |
| } |
| else |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_NO_NDEF_SUPPORT); |
| } |
| } |
| else |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_NO_NDEF_SUPPORT); |
| } |
| |
| return (status); |
| } |
| |
| |
| /*! |
| * \brief Completion Routine, Processing function, needed to avoid long blocking. |
| * \note The lower (Overlapped HAL) layer must register a pointer to this function as a Completion |
| * Routine in order to be able to notify the component that an I/O has finished and data are |
| * ready to be processed. |
| */ |
| |
| void phFriNfc_Felica_Process(void *Context, |
| NFCSTATUS Status) |
| { |
| uint8_t CRFlag = FALSE; |
| uint16_t RecvTxLen = 0, |
| BytesToRecv = 0, |
| Nbc = 0; |
| uint32_t TotNoWrittenBytes = 0, |
| NDEFLen=0; |
| |
| /*Set the context to Map Module*/ |
| phFriNfc_NdefMap_t *NdefMap = (phFriNfc_NdefMap_t *)Context; |
| |
| if ( Status == NFCSTATUS_SUCCESS ) |
| { |
| switch (NdefMap->State) |
| { |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_NDEF_APP: |
| |
| /* check the ndef compliency with the system code reecived in the RemoteDevInfo*/ |
| Status = phFriNfc_Felica_HUpdateManufIdDetails(NdefMap); |
| |
| if (Status == NFCSTATUS_SUCCESS) |
| { |
| /* Mantis ID : 645*/ |
| /* set the operation type to Check ndef type*/ |
| NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_CHK_NDEF_OP; |
| Status = phFriNfc_Felica_HRdAttrInfo(NdefMap); |
| /* handle the error in Transc function*/ |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| CRFlag = TRUE; |
| } |
| } |
| else |
| { |
| CRFlag = TRUE; |
| } |
| if ( CRFlag == TRUE ) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,Status); |
| |
| } |
| break; |
| |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR: |
| /* check for the status flag1 and status flag2for the successful read operation*/ |
| if ( NdefMap->SendRecvBuf[10] == 0x00) |
| { |
| /* check the Manuf Id in the receive buffer*/ |
| Status = phFriNfc_Felica_HCheckManufId(NdefMap); |
| if ( Status == NFCSTATUS_SUCCESS) |
| { |
| /* Update the Attribute Information in to the context structure*/ |
| Status = phFriNfc_Felica_HUpdateAttrInfo(NdefMap); |
| if ( Status == NFCSTATUS_SUCCESS ) |
| { |
| PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0], |
| NdefMap->FelicaAttrInfo.LenBytes[1], |
| NdefMap->FelicaAttrInfo.LenBytes[2], |
| NDEFLen); |
| |
| if ( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_WR_ATTR_RD_OP ) |
| { |
| /* Proceed With Write Functinality*/ |
| Status = phFriNfc_Felica_HChkAttrBlkForWrOp(NdefMap); |
| /* handle the error in Transc function*/ |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| } |
| } |
| else if( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_RD_ATTR_RD_OP ) |
| { |
| /* Proceed With Read Functinality*/ |
| Status = phFriNfc_Felica_HChkAttrBlkForRdOp(NdefMap,NDEFLen); |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_RD_NDEF,Status); |
| } |
| } |
| else if( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_CHK_NDEF_OP ) |
| { |
| |
| Status = phFriNfc_MapTool_SetCardState( NdefMap, |
| NDEFLen); |
| /* check status value*/ |
| NdefMap->CardType = PH_FRINFC_NDEFMAP_FELICA_SMART_CARD; |
| /*reset the buffer index*/ |
| NdefMap->ApduBuffIndex = 0; |
| /* set the Next operation Flag to indicate need of reading attribute information*/ |
| NdefMap->Felica.OpFlag = PH_FRINFC_NDEFMAP_FELI_OP_NONE; |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_CHK_NDEF,Status); |
| } |
| else if ( NdefMap->Felica.OpFlag == PH_FRINFC_NDEFMAP_FELI_WR_EMPTY_MSG_OP ) |
| { |
| /* Proceed With Write Functinality*/ |
| Status = phFriNfc_Felica_HWrEmptyMsg(NdefMap); |
| /* handle the error in Transc function*/ |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_ERASE_NDEF,Status); |
| } |
| } |
| else |
| { |
| |
| /* invalid operation occured*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_INVALID_DEVICE_REQUEST); |
| CRFlag =TRUE ; |
| } |
| } |
| else |
| { |
| CRFlag =TRUE ; |
| } |
| } |
| else |
| { |
| CRFlag =TRUE ; |
| } |
| } |
| else |
| { |
| CRFlag =TRUE; |
| /*handle the Error case*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_READ_FAILED); |
| } |
| if ( CRFlag == TRUE ) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_RD_NDEF,Status); |
| } |
| break; |
| |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN: |
| /* chk the status flags 1 and 2*/ |
| if ( NdefMap->SendRecvBuf[10] == 0x00 ) |
| { |
| /* Update Data Call*/ |
| Status =phFriNfc_Felica_HUpdateData(NdefMap); |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| } |
| } |
| else |
| { |
| /*handle the Error case*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_WRITE_FAILED); |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| |
| } |
| break; |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END: |
| |
| /* chk the status flags 1 and 2*/ |
| if ( NdefMap->SendRecvBuf[10] == 0x00) |
| { |
| /* Entire Write Operation is complete*/ |
| Status = PHNFCSTVAL(CID_NFC_NONE,\ |
| NFCSTATUS_SUCCESS); |
| } |
| else |
| { |
| /*handle the Error case*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_WRITE_FAILED); |
| } |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| break; |
| |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_WR_EMPTY_MSG : |
| |
| /* chk the status flags 1 and 2*/ |
| if ( NdefMap->SendRecvBuf[10] == 0x00) |
| { |
| /* Entire Write Operation is complete*/ |
| Status = PHNFCSTVAL(CID_NFC_NONE,\ |
| NFCSTATUS_SUCCESS); |
| } |
| else |
| { |
| /*handle the Error case*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_WRITE_FAILED); |
| } |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| break; |
| |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_WR_BLOCK : |
| if(NdefMap->SendRecvBuf[1] == PH_NFCFRI_NDEFMAP_FELI_WR_RESP_BYTE ) |
| { |
| /* chk the status flags 1 and 2*/ |
| if ( NdefMap->SendRecvBuf[10] == 0x00 ) |
| { |
| /* This is used when we have bytes less than 16 bytes*/ |
| if ( NdefMap->Felica.IntermediateWrFlag == TRUE ) |
| { |
| /* after Successful write copy the last writtened bytes back to the |
| internal buffer*/ |
| (void)memcpy( (&(NdefMap->Felica.Wr_RemainedBytesBuff[NdefMap->Felica.Wr_BytesRemained])), |
| NdefMap->ApduBuffer, |
| NdefMap->NumOfBytesWritten); |
| |
| NdefMap->Felica.Wr_BytesRemained += |
| (uint8_t)( NdefMap->NumOfBytesWritten); |
| |
| /* Increment the Send Buffer index */ |
| NdefMap->ApduBuffIndex += |
| NdefMap->NumOfBytesWritten; |
| |
| *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; |
| NdefMap->Felica.IntermediateWrFlag = FALSE; |
| /* Call Update Data()*/ |
| Status = phFriNfc_Felica_HUpdateData(NdefMap); |
| } |
| else |
| { |
| /* update the index and bytes writtened*/ |
| NdefMap->ApduBuffIndex += NdefMap->NumOfBytesWritten; |
| *NdefMap->WrNdefPacketLength = NdefMap->ApduBuffIndex; |
| if ( NdefMap->Felica.EofCardReachedFlag ) |
| { |
| if ( NdefMap->Felica.CurBlockNo < NdefMap->FelicaAttrInfo.Nmaxb) |
| { |
| NdefMap->Felica.CurBlockNo += NdefMap->Felica.NoBlocksWritten; |
| } |
| if (( NdefMap->Felica.CurBlockNo == NdefMap->FelicaAttrInfo.Nmaxb) && |
| ( NdefMap->ApduBuffIndex == (NdefMap->FelicaAttrInfo.Nmaxb*16))) |
| { |
| NdefMap->Felica.EofCardReachedFlag = FELICA_RD_WR_EOF_CARD_REACHED ; |
| /*0 represents the write ended*/ |
| Status = phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_ENDED); |
| if( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| } |
| } |
| else |
| { |
| PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES(NdefMap->FelicaAttrInfo.LenBytes[0], |
| NdefMap->FelicaAttrInfo.LenBytes[1], |
| NdefMap->FelicaAttrInfo.LenBytes[2], |
| TotNoWrittenBytes); |
| if ( ( NdefMap->Felica.CurBlockNo == NdefMap->FelicaAttrInfo.Nmaxb) && |
| ((TotNoWrittenBytes + NdefMap->ApduBuffIndex) == (uint32_t)(NdefMap->FelicaAttrInfo.Nmaxb*16))) |
| { |
| NdefMap->Felica.EofCardReachedFlag =FELICA_RD_WR_EOF_CARD_REACHED; |
| /*0 represents the write ended*/ |
| Status = phFriNfc_Felica_HUpdateAttrBlkForWrOp(NdefMap,FELICA_WRITE_ENDED); |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| } |
| } |
| else |
| { |
| /* Call Update Data()*/ |
| Status = phFriNfc_Felica_HUpdateData(NdefMap); |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| } |
| } |
| } |
| }/*if ( NdefMap->Felica.EofCardReachedFlag )*/ |
| else |
| { |
| NdefMap->Felica.CurBlockNo += NdefMap->Felica.NoBlocksWritten; |
| /* Call Update Data()*/ |
| Status = phFriNfc_Felica_HUpdateData(NdefMap); |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| } |
| } |
| } |
| }/*if ( NdefMap->SendRecvBuf[10] == 0x00 )*/ |
| else |
| { |
| /*handle the Error case*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_WRITE_FAILED); |
| CRFlag = TRUE; |
| |
| } |
| }/*if(NdefMap->SendRecvBuf[1] == PH_NFCFRI_NDEFMAP_FELI_WR_RESP_BYTE )*/ |
| else |
| { |
| /*return Error "Invalid Write Response Code"*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_WRITE_FAILED); |
| CRFlag = TRUE; |
| |
| } |
| if ( CRFlag == TRUE ) |
| { |
| /* Reset following parameters*/ |
| NdefMap->ApduBuffIndex=0; |
| NdefMap->Felica.Wr_BytesRemained = 0; |
| NdefMap->ApduBufferSize = 0; |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_WR_NDEF,Status); |
| } |
| |
| break; |
| |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_BLOCK : |
| |
| /* check the Manuf Id in the receive buffer*/ |
| Status = phFriNfc_Felica_HCheckManufId(NdefMap); |
| if ( Status == NFCSTATUS_SUCCESS ) |
| { |
| if(NdefMap->SendRecvBuf[1] == PH_NFCFRI_NDEFMAP_FELI_RD_RESP_BYTE ) |
| { |
| /* calculate the Nmaxb*/ |
| Nbc = phFriNfc_Felica_HGetMaximumBlksToRead(NdefMap,PH_NFCFRI_NDEFMAP_FELI_NBC); |
| /*get Receive length from the card for corss verifications*/ |
| RecvTxLen= phFriNfc_Felica_HSetTrxLen(NdefMap,Nbc); |
| BytesToRecv = NdefMap->SendRecvBuf[12]*16; |
| |
| /* chk the status flags 1 */ |
| if ( NdefMap->SendRecvBuf[10] == 0x00) |
| { |
| if ( RecvTxLen == BytesToRecv) |
| { |
| NdefMap->Felica.CurBlockNo += (uint8_t)(RecvTxLen/16); |
| phFriNfc_Felica_HAfterRead_CopyDataToBuff(NdefMap); |
| Status = phFriNfc_Felica_HReadData(NdefMap,PH_FRINFC_NDEFMAP_SEEK_CUR); |
| /* handle the error in Transc function*/ |
| if ( (Status & PHNFCSTBLOWER) != (NFCSTATUS_PENDING & PHNFCSTBLOWER)) |
| { |
| CRFlag =TRUE; |
| } |
| } |
| else |
| { |
| CRFlag =TRUE; |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_INVALID_RECEIVE_LENGTH); |
| /*set the buffer index back to zero*/ |
| NdefMap->ApduBuffIndex = 0; |
| NdefMap->Felica.Rd_NoBytesToCopy = 0; |
| } |
| } |
| else |
| { |
| NdefMap->ApduBuffIndex=0; |
| /*handle the Error case*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,\ |
| NFCSTATUS_READ_FAILED); |
| CRFlag =TRUE; |
| } |
| } |
| else |
| { |
| CRFlag =TRUE; |
| NdefMap->ApduBuffIndex=0; |
| /*return Error "Invalid Read Response Code"*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_READ_FAILED); |
| } |
| } |
| else |
| { |
| CRFlag =TRUE; |
| } |
| if ( CRFlag ==TRUE ) |
| { |
| /* call respective CR */ |
| phFriNfc_Felica_HCrHandler(NdefMap,PH_FRINFC_NDEFMAP_CR_RD_NDEF,Status); |
| } |
| break; |
| |
| default: |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_INVALID_DEVICE_REQUEST); |
| phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_INVALID_OPE, Status); |
| break; |
| |
| |
| } |
| } |
| else |
| { |
| /* Call CR for unknown Error's*/ |
| switch ( NdefMap->State) |
| { |
| case PH_FRINFC_NDEFMAP_FELI_STATE_CHK_NDEF : |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_WILD_CARD : |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_SELECT_NDEF_APP : |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR : |
| phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_CHK_NDEF, |
| Status); |
| break; |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_WR_BLOCK : |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_BEGIN : |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_ATTR_BLK_WR_END : |
| phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_WR_NDEF, |
| Status); |
| break; |
| case PH_NFCFRI_NDEFMAP_FELI_STATE_RD_BLOCK : |
| phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_RD_NDEF, |
| Status); |
| break; |
| default : |
| /*set the invalid state*/ |
| Status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_DEVICE_REQUEST); |
| phFriNfc_Felica_HCrHandler(NdefMap, PH_FRINFC_NDEFMAP_CR_INVALID_OPE, Status); |
| break; |
| } |
| } |
| |
| } |
| |
| /*! |
| * \brief Prepares Cmd Pkt for reading attribute Blk information. |
| */ |
| static NFCSTATUS phFriNfc_Felica_HRdAttrInfo(phFriNfc_NdefMap_t *NdefMap) |
| { |
| |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| uint8_t BufIndex = 0; |
| |
| /* Set the Felica Cmd*/ |
| #ifdef PH_HAL4_ENABLE |
| NdefMap->Cmd.FelCmd = phHal_eFelica_Raw; |
| #else |
| NdefMap->Cmd.FelCmd = phHal_eFelicaCmdListFelicaCmd; |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| /*set the additional informations for the data exchange*/ |
| NdefMap->psDepAdditionalInfo.DepFlags.MetaChaining = 0; |
| NdefMap->psDepAdditionalInfo.DepFlags.NADPresent = 0; |
| |
| /* 1st byte represents the length of the cmd packet*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; |
| BufIndex++; |
| |
| /* Read/check command code*/ |
| NdefMap->SendRecvBuf[BufIndex] = 0x06; |
| BufIndex++; |
| |
| /* IDm - Manufacturer Id : 8bytes*/ |
| #ifdef PH_HAL4_ENABLE |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (void * )&NdefMap->psRemoteDevInfo->RemoteDevInfo.Felica_Info.IDm, |
| 8); |
| #else |
| (void)memcpy((&(NdefMap->SendRecvBuf[BufIndex])), |
| (void * )&NdefMap->psRemoteDevInfo->RemoteDevInfo.CardInfo212_424.Startup212_424.NFCID2t, |
| 8); |
| |
| #endif /* #ifdef PH_HAL4_ENABLE */ |
| |
| BufIndex+=8; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Services (n=1 ==> 0x80)*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x0B; /* Service Code List*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* Service Code List*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x01; /* Number of Blocks to read)*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x80; /* 1st Block Element : byte 1*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[BufIndex] = 0x00; /* 1st Block Element : byte 2, block 1*/ |
| BufIndex++; |
| |
| NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_PKT_LEN_INDEX] = BufIndex; |
| |
| *NdefMap->SendRecvLength = NdefMap->TempReceiveLength; |
| |
| /* Update the Send Len*/ |
| NdefMap->SendLength = BufIndex; |
| |
| /* Change the state to PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR */ |
| NdefMap->State = PH_NFCFRI_NDEFMAP_FELI_STATE_RD_ATTR; |
| |
| /*set the completion routines for the desfire card operations*/ |
| NdefMap->MapCompletionInfo.CompletionRoutine = phFriNfc_NdefMap_Process; |
| NdefMap->MapCompletionInfo.Context = NdefMap; |
| |
| /*Call the Overlapped HAL Transceive function */ |
| status = phFriNfc_OvrHal_Transceive( NdefMap->LowerDevice, |
| &NdefMap->MapCompletionInfo, |
| NdefMap->psRemoteDevInfo, |
| NdefMap->Cmd, |
| &NdefMap->psDepAdditionalInfo, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendLength, |
| NdefMap->SendRecvBuf, |
| NdefMap->SendRecvLength); |
| return (status); |
| |
| } |
| |
| /*! |
| * \brief Validated manufacturer Details, during the read/write operations. |
| */ |
| |
| static NFCSTATUS phFriNfc_Felica_HCheckManufId(const phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| |
| uint8_t result = 0; |
| |
| /* check the stored manufacture id with the received manufacture id*/ |
| result = (uint8_t)(phFriNfc_Felica_MemCompare( (void *)(&(NdefMap->SendRecvBuf[2])), |
| (void *)NdefMap->FelicaManufDetails.ManufID, |
| 8)); |
| |
| if ( result != 0) |
| { |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, NFCSTATUS_INVALID_REMOTE_DEVICE); |
| |
| } |
| else |
| { |
| status = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS); |
| |
| } |
| return (status); |
| } |
| |
| static NFCSTATUS phFriNfc_Felica_HCalCheckSum(const uint8_t *TempBuffer, |
| uint8_t StartIndex, |
| uint8_t EndIndex, |
| uint16_t RecvChkSum) |
| { |
| NFCSTATUS Result = NFCSTATUS_SUCCESS; |
| uint16_t CheckSum=0, |
| BufIndex=0; |
| |
| for(BufIndex = StartIndex;BufIndex <=EndIndex;BufIndex++) |
| { |
| CheckSum += TempBuffer[BufIndex]; |
| } |
| if( RecvChkSum != CheckSum ) |
| { |
| Result = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP, |
| NFCSTATUS_INVALID_FORMAT); |
| } |
| return (Result); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| /*! |
| * \brief On successful read attribute blk information, this function validates and stores the |
| * Attribute informations in to the context. |
| */ |
| static NFCSTATUS phFriNfc_Felica_HUpdateAttrInfo(phFriNfc_NdefMap_t *NdefMap) |
| { |
| NFCSTATUS status = NFCSTATUS_PENDING; |
| uint8_t CRFlag = FALSE, |
| Nmaxb1, Nmaxb2 = 0, |
| ChkSum1 = 0, ChkSum2=0; |
| |
| uint16_t Nmaxblk = 0, |
| RecvChkSum=0, |
| NdefBlk = 0; |
| uint32_t DataLen =0; |
| |
| |
| /* Validate T3VNo and NFCDevVNo */ |
| status = phFriNfc_MapTool_ChkSpcVer(NdefMap, |
| PH_NFCFRI_NDEFMAP_FELI_VERSION_INDEX); |
| if ( status != NFCSTATUS_SUCCESS ) |
| { |
| CRFlag = TRUE; |
| } |
| else |
| { |
| /* get the Nmaxb from the receive buffer*/ |
| Nmaxb1 = NdefMap->SendRecvBuf[16]; |
| Nmaxb2 = NdefMap->SendRecvBuf[17]; |
| |
| Nmaxblk = (((uint16_t)Nmaxb1 << 8) | (Nmaxb2 & 0x00ff)); |
| |
| if ( Nmaxblk != 0 ) |
| { |
| /* check the Nbr against the Nmaxb*/ |
| if ( NdefMap->SendRecvBuf[14] > Nmaxblk ) |
| { |
| CRFlag = TRUE; |
| } |
| else |
| { |
| /*check Nbw > Nmaxb*/ |
| /*check the write flag validity*/ |
| /*check for the RFU bytes validity*/ |
| if ( (NdefMap->SendRecvBuf[15] > Nmaxblk) || |
| ((NdefMap->SendRecvBuf[22] != 0x00) && (NdefMap->SendRecvBuf[22] !=0x0f ))|| |
| ( (NdefMap->SendRecvBuf[23] != 0x00) && (NdefMap->SendRecvBuf[23] !=0x01 ))|| |
| ( NdefMap->SendRecvBuf[18] != 0x00) || |
| ( NdefMap->SendRecvBuf[19] != 0x00) || |
| ( NdefMap->SendRecvBuf[20] != 0x00) || |
| ( NdefMap->SendRecvBuf[21] != 0x00)) |
| |
| { |
| CRFlag = TRUE; |
| } |
| else |
| { |
| /* check the validity of the actual ndef data len*/ |
| PH_NFCFRI_NDEFMAP_FELI_CAL_LEN_BYTES( NdefMap->SendRecvBuf[24], |
| NdefMap->SendRecvBuf[25], |
| NdefMap->SendRecvBuf[26], |
| DataLen); |
| |
| |
| /* Calculate Nbc*/ |
| NdefBlk = (uint16_t )((( DataLen % 16) == 0 ) ? (DataLen >> 4) : ((DataLen >> 4) +1)); |
| |
| /* check Nbc against Nmaxb*/ |
| if ((NdefBlk > Nmaxblk)) |
| { |
| CRFlag = TRUE; |
| } |
| else |
| { |
| /*Store the attribute information in phFriNfc_Felica_AttrInfo*/ |
| NdefMap->FelicaAttrInfo.Version = NdefMap->SendRecvBuf[PH_NFCFRI_NDEFMAP_FELI_VERSION_INDEX]; |
| NdefMap->FelicaAttrInfo.Nbr = NdefMap->SendRecvBuf[14]; |
| NdefMap->FelicaAttrInfo.Nbw = NdefMap->SendRecvBuf[15]; |
| |
| NdefMap->FelicaAttrInfo.Nmaxb = Nmaxblk; |
| |
| NdefMap->FelicaAttrInfo.WriteFlag = NdefMap->SendRecvBuf[22]; |
| NdefMap->FelicaAttrInfo.RdWrFlag = NdefMap->SendRecvBuf[23]; |
| |
| /* Get CheckSum*/ |
| ChkSum1 = NdefMap->SendRecvBuf[27]; |
| ChkSum2 = NdefMap->SendRecvBuf[28]; |
| |
| RecvChkSum = (((uint16_t)ChkSum1 << 8) | (ChkSum2 & 0x00ff)); |
| |
| /* Check the check sum validity?*/ |
| status = phFriNfc_Felica_HCalCheckSum(NdefMap->SendRecvBuf, |
| PH_NFCFRI_NDEFMAP_FELI_VERSION_INDEX, |
| 26, |
| RecvChkSum); |
| if ( status != NFCSTATUS_SUCCESS ) |
| { |
| CRFlag = TRUE; |
| } |
| else |
| { |
| /*check RW Flag Access Rights*/ |
| /* set to read only cannot write*/ |
| if ( NdefMap->FelicaAttrInfo.RdWrFlag == 0x00 ) |
| { |
| NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_ONLY; |
| } |
| else if ( NdefMap->FelicaAttrInfo.RdWrFlag == 0x01 ) // additional check for R/W access |
| { |
| NdefMap->CardState = PH_NDEFMAP_CARD_STATE_READ_WRITE; |
| } |
| else // otherwise invalid |
| { |
| NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; |
| } |
| |
| NdefMap->FelicaAttrInfo.LenBytes[0] = NdefMap->SendRecvBuf[24]; |
| NdefMap->FelicaAttrInfo.LenBytes[1] = NdefMap->SendRecvBuf[25]; |
| NdefMap->FelicaAttrInfo.LenBytes[2] = NdefMap->SendRecvBuf[26]; |
| status = PHNFCSTVAL(CID_NFC_NONE,NFCSTATUS_SUCCESS); |
| } |
| } |
| } |
| } |
| } |
| else |
| { |
| CRFlag = TRUE; |
| } |
| } |
| if ( (status == NFCSTATUS_INVALID_FORMAT ) && (CRFlag == TRUE )) |
| { |
| NdefMap->CardState = PH_NDEFMAP_CARD_STATE_INVALID; |
| } |
| if ( CRFlag == TRUE ) |
| { |
| /*Return Status Error “ Invalid Format”*/ |
| status = PHNFCSTVAL(CID_FRI_NFC_NDEF_MAP,NFCSTATUS_INVALID_FORMAT); |
| } |
| |
| return (status); |
| } |
| |
| /*! |
| * \brief this shall notify the integration software with respective |
| * success/error status along with the completion routines. |
| */ |
| static void phFriNfc_Felica_HCrHandler(phFriNfc_NdefMap_t *NdefMap, |
| uint8_t CrIndex, |
| NFCSTATUS Status) |
| { |
| /* set the state back to the Reset_Init state*/ |
| NdefMap->State = PH_FRINFC_NDEFMAP_STATE_RESET_INIT; |
| |
| /* set the completion routine*/ |
| NdefMap->CompletionRoutine[CrIndex]. |
| CompletionRoutine(NdefMap->CompletionRoutine->Context, Status); |
| } |
| |
| /*! |
| * \brief this shall initialise the internal buffer data to zero. |
| */ |
| static void phFriNfc_Felica_HInitInternalBuf(uint8_t *Buffer) |
| { |
| uint8_t index=0; |
| |
| for( index = 0; index< 16 ; index++) |
| { |
| Buffer[index] = 0; |
| } |
| } |
| |
| static int phFriNfc_Felica_MemCompare ( void *s1, void *s2, unsigned int n ) |
| { |
| int8_t diff = 0; |
| int8_t *char_1 =(int8_t *)s1; |
| int8_t *char_2 =(int8_t *)s2; |
| if(NULL == s1 || NULL == s2) |
| { |
| PHDBG_CRITICAL_ERROR("NULL pointer passed to memcompare"); |
| } |
| else |
| { |
| for(;((n>0)&&(diff==0));n--,char_1++,char_2++) |
| { |
| diff = *char_1 - *char_2; |
| } |
| } |
| return (int)diff; |
| } |
| |
| |
| #ifdef UNIT_TEST |
| #include <phUnitTestNfc_Felica_static.c> |
| #endif |
| |
| #endif /* PH_FRINFC_MAP_FELICA_DISABLED */ |
